Valgrind warnings removed: all changes were false-positive issues.
[platform/core/security/key-manager.git] / src / manager / sqlcipher / sqlcipher.c
1 /******************************************************************************
2 ** This file is an amalgamation of many separate C source files from SQLite
3 ** version 3.7.9.  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 "sqlcipher3.h" header file that defines
12 ** the programming interface to the SQLite library.  (If you do not have 
13 ** the "sqlcipher3.h" header file at hand, you will find a copy embedded within
14 ** the text of this file.  Search for "Begin file sqlcipher3.h" to find the start
15 ** of the embedded sqlcipher3.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 "sqlcipher3" command-line shell is also in a
18 ** separate file. This file contains only code for the core SQLite library.
19 */
20 #pragma GCC diagnostic push
21 #pragma GCC diagnostic warning "-Wunused-but-set-variable"
22 #pragma GCC diagnostic warning "-Wunused-parameter"
23 #pragma GCC diagnostic warning "-Wsign-compare"
24
25 #define SQLCIPHER_CORE 1
26 #define SQLCIPHER_AMALGAMATION 1
27 #ifndef SQLCIPHER_PRIVATE
28 # define SQLCIPHER_PRIVATE static
29 #endif
30 #ifndef SQLCIPHER_API
31 # define SQLCIPHER_API
32 #endif
33 /************** Begin file sqlcipherInt.h ***************************************/
34 /*
35 ** 2001 September 15
36 **
37 ** The author disclaims copyright to this source code.  In place of
38 ** a legal notice, here is a blessing:
39 **
40 **    May you do good and not evil.
41 **    May you find forgiveness for yourself and forgive others.
42 **    May you share freely, never taking more than you give.
43 **
44 *************************************************************************
45 ** Internal interface definitions for SQLite.
46 **
47 */
48 #ifndef _SQLCIPHERINT_H_
49 #define _SQLCIPHERINT_H_
50
51 /*
52 ** These #defines should enable >2GB file support on POSIX if the
53 ** underlying operating system supports it.  If the OS lacks
54 ** large file support, or if the OS is windows, these should be no-ops.
55 **
56 ** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any
57 ** system #includes.  Hence, this block of code must be the very first
58 ** code in all source files.
59 **
60 ** Large file support can be disabled using the -DSQLCIPHER_DISABLE_LFS switch
61 ** on the compiler command line.  This is necessary if you are compiling
62 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
63 ** on an older machine (ex: Red Hat 6.0).  If you compile on Red Hat 7.2
64 ** without this option, LFS is enable.  But LFS does not exist in the kernel
65 ** in Red Hat 6.0, so the code won't work.  Hence, for maximum binary
66 ** portability you should omit LFS.
67 **
68 ** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.
69 */
70 #ifndef SQLCIPHER_DISABLE_LFS
71 # define _LARGE_FILE       1
72 # ifndef _FILE_OFFSET_BITS
73 #   define _FILE_OFFSET_BITS 64
74 # endif
75 # define _LARGEFILE_SOURCE 1
76 #endif
77
78 /*
79 ** Include the configuration header output by 'configure' if we're using the
80 ** autoconf-based build
81 */
82 #ifdef _HAVE_SQLCIPHER_CONFIG_H
83 #include "config.h"
84 #endif
85
86 /************** Include sqlcipherLimit.h in the middle of sqlcipherInt.h ***********/
87 /************** Begin file sqlcipherLimit.h *************************************/
88 /*
89 ** 2007 May 7
90 **
91 ** The author disclaims copyright to this source code.  In place of
92 ** a legal notice, here is a blessing:
93 **
94 **    May you do good and not evil.
95 **    May you find forgiveness for yourself and forgive others.
96 **    May you share freely, never taking more than you give.
97 **
98 *************************************************************************
99 ** 
100 ** This file defines various limits of what SQLite can process.
101 */
102
103 /*
104 ** The maximum length of a TEXT or BLOB in bytes.   This also
105 ** limits the size of a row in a table or index.
106 **
107 ** The hard limit is the ability of a 32-bit signed integer
108 ** to count the size: 2^31-1 or 2147483647.
109 */
110 #ifndef SQLCIPHER_MAX_LENGTH
111 # define SQLCIPHER_MAX_LENGTH 1000000000
112 #endif
113
114 /*
115 ** This is the maximum number of
116 **
117 **    * Columns in a table
118 **    * Columns in an index
119 **    * Columns in a view
120 **    * Terms in the SET clause of an UPDATE statement
121 **    * Terms in the result set of a SELECT statement
122 **    * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
123 **    * Terms in the VALUES clause of an INSERT statement
124 **
125 ** The hard upper limit here is 32676.  Most database people will
126 ** tell you that in a well-normalized database, you usually should
127 ** not have more than a dozen or so columns in any table.  And if
128 ** that is the case, there is no point in having more than a few
129 ** dozen values in any of the other situations described above.
130 */
131 #ifndef SQLCIPHER_MAX_COLUMN
132 # define SQLCIPHER_MAX_COLUMN 2000
133 #endif
134
135 /*
136 ** The maximum length of a single SQL statement in bytes.
137 **
138 ** It used to be the case that setting this value to zero would
139 ** turn the limit off.  That is no longer true.  It is not possible
140 ** to turn this limit off.
141 */
142 #ifndef SQLCIPHER_MAX_SQL_LENGTH
143 # define SQLCIPHER_MAX_SQL_LENGTH 1000000000
144 #endif
145
146 /*
147 ** The maximum depth of an expression tree. This is limited to 
148 ** some extent by SQLCIPHER_MAX_SQL_LENGTH. But sometime you might 
149 ** want to place more severe limits on the complexity of an 
150 ** expression.
151 **
152 ** A value of 0 used to mean that the limit was not enforced.
153 ** But that is no longer true.  The limit is now strictly enforced
154 ** at all times.
155 */
156 #ifndef SQLCIPHER_MAX_EXPR_DEPTH
157 # define SQLCIPHER_MAX_EXPR_DEPTH 1000
158 #endif
159
160 /*
161 ** The maximum number of terms in a compound SELECT statement.
162 ** The code generator for compound SELECT statements does one
163 ** level of recursion for each term.  A stack overflow can result
164 ** if the number of terms is too large.  In practice, most SQL
165 ** never has more than 3 or 4 terms.  Use a value of 0 to disable
166 ** any limit on the number of terms in a compount SELECT.
167 */
168 #ifndef SQLCIPHER_MAX_COMPOUND_SELECT
169 # define SQLCIPHER_MAX_COMPOUND_SELECT 500
170 #endif
171
172 /*
173 ** The maximum number of opcodes in a VDBE program.
174 ** Not currently enforced.
175 */
176 #ifndef SQLCIPHER_MAX_VDBE_OP
177 # define SQLCIPHER_MAX_VDBE_OP 25000
178 #endif
179
180 /*
181 ** The maximum number of arguments to an SQL function.
182 */
183 #ifndef SQLCIPHER_MAX_FUNCTION_ARG
184 # define SQLCIPHER_MAX_FUNCTION_ARG 127
185 #endif
186
187 /*
188 ** The maximum number of in-memory pages to use for the main database
189 ** table and for temporary tables.  The SQLCIPHER_DEFAULT_CACHE_SIZE
190 */
191 #ifndef SQLCIPHER_DEFAULT_CACHE_SIZE
192 # define SQLCIPHER_DEFAULT_CACHE_SIZE  2000
193 #endif
194 #ifndef SQLCIPHER_DEFAULT_TEMP_CACHE_SIZE
195 # define SQLCIPHER_DEFAULT_TEMP_CACHE_SIZE  500
196 #endif
197
198 /*
199 ** The default number of frames to accumulate in the log file before
200 ** checkpointing the database in WAL mode.
201 */
202 #ifndef SQLCIPHER_DEFAULT_WAL_AUTOCHECKPOINT
203 # define SQLCIPHER_DEFAULT_WAL_AUTOCHECKPOINT  1000
204 #endif
205
206 /*
207 ** The maximum number of attached databases.  This must be between 0
208 ** and 62.  The upper bound on 62 is because a 64-bit integer bitmap
209 ** is used internally to track attached databases.
210 */
211 #ifndef SQLCIPHER_MAX_ATTACHED
212 # define SQLCIPHER_MAX_ATTACHED 10
213 #endif
214
215
216 /*
217 ** The maximum value of a ?nnn wildcard that the parser will accept.
218 */
219 #ifndef SQLCIPHER_MAX_VARIABLE_NUMBER
220 # define SQLCIPHER_MAX_VARIABLE_NUMBER 999
221 #endif
222
223 /* Maximum page size.  The upper bound on this value is 65536.  This a limit
224 ** imposed by the use of 16-bit offsets within each page.
225 **
226 ** Earlier versions of SQLite allowed the user to change this value at
227 ** compile time. This is no longer permitted, on the grounds that it creates
228 ** a library that is technically incompatible with an SQLite library 
229 ** compiled with a different limit. If a process operating on a database 
230 ** with a page-size of 65536 bytes crashes, then an instance of SQLite 
231 ** compiled with the default page-size limit will not be able to rollback 
232 ** the aborted transaction. This could lead to database corruption.
233 */
234 #ifdef SQLCIPHER_MAX_PAGE_SIZE
235 # undef SQLCIPHER_MAX_PAGE_SIZE
236 #endif
237 #define SQLCIPHER_MAX_PAGE_SIZE 65536
238
239
240 /*
241 ** The default size of a database page.
242 */
243 #ifndef SQLCIPHER_DEFAULT_PAGE_SIZE
244 # define SQLCIPHER_DEFAULT_PAGE_SIZE 1024
245 #endif
246 #if SQLCIPHER_DEFAULT_PAGE_SIZE>SQLCIPHER_MAX_PAGE_SIZE
247 # undef SQLCIPHER_DEFAULT_PAGE_SIZE
248 # define SQLCIPHER_DEFAULT_PAGE_SIZE SQLCIPHER_MAX_PAGE_SIZE
249 #endif
250
251 /*
252 ** Ordinarily, if no value is explicitly provided, SQLite creates databases
253 ** with page size SQLCIPHER_DEFAULT_PAGE_SIZE. However, based on certain
254 ** device characteristics (sector-size and atomic write() support),
255 ** SQLite may choose a larger value. This constant is the maximum value
256 ** SQLite will choose on its own.
257 */
258 #ifndef SQLCIPHER_MAX_DEFAULT_PAGE_SIZE
259 # define SQLCIPHER_MAX_DEFAULT_PAGE_SIZE 8192
260 #endif
261 #if SQLCIPHER_MAX_DEFAULT_PAGE_SIZE>SQLCIPHER_MAX_PAGE_SIZE
262 # undef SQLCIPHER_MAX_DEFAULT_PAGE_SIZE
263 # define SQLCIPHER_MAX_DEFAULT_PAGE_SIZE SQLCIPHER_MAX_PAGE_SIZE
264 #endif
265
266
267 /*
268 ** Maximum number of pages in one database file.
269 **
270 ** This is really just the default value for the max_page_count pragma.
271 ** This value can be lowered (or raised) at run-time using that the
272 ** max_page_count macro.
273 */
274 #ifndef SQLCIPHER_MAX_PAGE_COUNT
275 # define SQLCIPHER_MAX_PAGE_COUNT 1073741823
276 #endif
277
278 /*
279 ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
280 ** operator.
281 */
282 #ifndef SQLCIPHER_MAX_LIKE_PATTERN_LENGTH
283 # define SQLCIPHER_MAX_LIKE_PATTERN_LENGTH 50000
284 #endif
285
286 /*
287 ** Maximum depth of recursion for triggers.
288 **
289 ** A value of 1 means that a trigger program will not be able to itself
290 ** fire any triggers. A value of 0 means that no trigger programs at all 
291 ** may be executed.
292 */
293 #ifndef SQLCIPHER_MAX_TRIGGER_DEPTH
294 # define SQLCIPHER_MAX_TRIGGER_DEPTH 1000
295 #endif
296
297 /************** End of sqlcipherLimit.h *****************************************/
298 /************** Continuing where we left off in sqlcipherInt.h ******************/
299
300 /* Disable nuisance warnings on Borland compilers */
301 #if defined(__BORLANDC__)
302 #pragma warn -rch /* unreachable code */
303 #pragma warn -ccc /* Condition is always true or false */
304 #pragma warn -aus /* Assigned value is never used */
305 #pragma warn -csu /* Comparing signed and unsigned */
306 #pragma warn -spa /* Suspicious pointer arithmetic */
307 #endif
308
309 /* Needed for various definitions... */
310 #ifndef _GNU_SOURCE
311 # define _GNU_SOURCE
312 #endif
313
314 /*
315 ** Include standard header files as necessary
316 */
317 #ifdef HAVE_STDINT_H
318 #include <stdint.h>
319 #endif
320 #ifdef HAVE_INTTYPES_H
321 #include <inttypes.h>
322 #endif
323
324 /*
325 ** The following macros are used to cast pointers to integers and
326 ** integers to pointers.  The way you do this varies from one compiler
327 ** to the next, so we have developed the following set of #if statements
328 ** to generate appropriate macros for a wide range of compilers.
329 **
330 ** The correct "ANSI" way to do this is to use the intptr_t type. 
331 ** Unfortunately, that typedef is not available on all compilers, or
332 ** if it is available, it requires an #include of specific headers
333 ** that vary from one machine to the next.
334 **
335 ** Ticket #3860:  The llvm-gcc-4.2 compiler from Apple chokes on
336 ** the ((void*)&((char*)0)[X]) construct.  But MSVC chokes on ((void*)(X)).
337 ** So we have to define the macros in different ways depending on the
338 ** compiler.
339 */
340 #if defined(__PTRDIFF_TYPE__)  /* This case should work for GCC */
341 # define SQLCIPHER_INT_TO_PTR(X)  ((void*)(__PTRDIFF_TYPE__)(X))
342 # define SQLCIPHER_PTR_TO_INT(X)  ((int)(__PTRDIFF_TYPE__)(X))
343 #elif !defined(__GNUC__)       /* Works for compilers other than LLVM */
344 # define SQLCIPHER_INT_TO_PTR(X)  ((void*)&((char*)0)[X])
345 # define SQLCIPHER_PTR_TO_INT(X)  ((int)(((char*)X)-(char*)0))
346 #elif defined(HAVE_STDINT_H)   /* Use this case if we have ANSI headers */
347 # define SQLCIPHER_INT_TO_PTR(X)  ((void*)(intptr_t)(X))
348 # define SQLCIPHER_PTR_TO_INT(X)  ((int)(intptr_t)(X))
349 #else                          /* Generates a warning - but it always works */
350 # define SQLCIPHER_INT_TO_PTR(X)  ((void*)(X))
351 # define SQLCIPHER_PTR_TO_INT(X)  ((int)(X))
352 #endif
353
354 /*
355 ** The SQLCIPHER_THREADSAFE macro must be defined as 0, 1, or 2.
356 ** 0 means mutexes are permanently disable and the library is never
357 ** threadsafe.  1 means the library is serialized which is the highest
358 ** level of threadsafety.  2 means the libary is multithreaded - multiple
359 ** threads can use SQLite as long as no two threads try to use the same
360 ** database connection at the same time.
361 **
362 ** Older versions of SQLite used an optional THREADSAFE macro.
363 ** We support that for legacy.
364 */
365 #if !defined(SQLCIPHER_THREADSAFE)
366 #if defined(THREADSAFE)
367 # define SQLCIPHER_THREADSAFE THREADSAFE
368 #else
369 # define SQLCIPHER_THREADSAFE 1 /* IMP: R-07272-22309 */
370 #endif
371 #endif
372
373 /*
374 ** The SQLCIPHER_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.
375 ** It determines whether or not the features related to 
376 ** SQLCIPHER_CONFIG_MEMSTATUS are available by default or not. This value can
377 ** be overridden at runtime using the sqlcipher3_config() API.
378 */
379 #if !defined(SQLCIPHER_DEFAULT_MEMSTATUS)
380 # define SQLCIPHER_DEFAULT_MEMSTATUS 1
381 #endif
382
383 /*
384 ** Exactly one of the following macros must be defined in order to
385 ** specify which memory allocation subsystem to use.
386 **
387 **     SQLCIPHER_SYSTEM_MALLOC          // Use normal system malloc()
388 **     SQLCIPHER_WIN32_MALLOC           // Use Win32 native heap API
389 **     SQLCIPHER_MEMDEBUG               // Debugging version of system malloc()
390 **
391 ** On Windows, if the SQLCIPHER_WIN32_MALLOC_VALIDATE macro is defined and the
392 ** assert() macro is enabled, each call into the Win32 native heap subsystem
393 ** will cause HeapValidate to be called.  If heap validation should fail, an
394 ** assertion will be triggered.
395 **
396 ** (Historical note:  There used to be several other options, but we've
397 ** pared it down to just these three.)
398 **
399 ** If none of the above are defined, then set SQLCIPHER_SYSTEM_MALLOC as
400 ** the default.
401 */
402 #if defined(SQLCIPHER_SYSTEM_MALLOC)+defined(SQLCIPHER_WIN32_MALLOC)+defined(SQLCIPHER_MEMDEBUG)>1
403 # error "At most one of the following compile-time configuration options\
404  is allows: SQLCIPHER_SYSTEM_MALLOC, SQLCIPHER_WIN32_MALLOC, SQLCIPHER_MEMDEBUG"
405 #endif
406 #if defined(SQLCIPHER_SYSTEM_MALLOC)+defined(SQLCIPHER_WIN32_MALLOC)+defined(SQLCIPHER_MEMDEBUG)==0
407 # define SQLCIPHER_SYSTEM_MALLOC 1
408 #endif
409
410 /*
411 ** If SQLCIPHER_MALLOC_SOFT_LIMIT is not zero, then try to keep the
412 ** sizes of memory allocations below this value where possible.
413 */
414 #if !defined(SQLCIPHER_MALLOC_SOFT_LIMIT)
415 # define SQLCIPHER_MALLOC_SOFT_LIMIT 1024
416 #endif
417
418 /*
419 ** We need to define _XOPEN_SOURCE as follows in order to enable
420 ** recursive mutexes on most Unix systems.  But Mac OS X is different.
421 ** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,
422 ** so it is omitted there.  See ticket #2673.
423 **
424 ** Later we learn that _XOPEN_SOURCE is poorly or incorrectly
425 ** implemented on some systems.  So we avoid defining it at all
426 ** if it is already defined or if it is unneeded because we are
427 ** not doing a threadsafe build.  Ticket #2681.
428 **
429 ** See also ticket #2741.
430 */
431 #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLCIPHER_THREADSAFE
432 #  define _XOPEN_SOURCE 500  /* Needed to enable pthread recursive mutexes */
433 #endif
434
435 /*
436 ** The TCL headers are only needed when compiling the TCL bindings.
437 */
438 #if defined(SQLCIPHER_TCL) || defined(TCLSH)
439 # include <tcl.h>
440 #endif
441
442 /*
443 ** Many people are failing to set -DNDEBUG=1 when compiling SQLite.
444 ** Setting NDEBUG makes the code smaller and run faster.  So the following
445 ** lines are added to automatically set NDEBUG unless the -DSQLCIPHER_DEBUG=1
446 ** option is set.  Thus NDEBUG becomes an opt-in rather than an opt-out
447 ** feature.
448 */
449 #if !defined(NDEBUG) && !defined(SQLCIPHER_DEBUG) 
450 # define NDEBUG 1
451 #endif
452
453 /*
454 ** The testcase() macro is used to aid in coverage testing.  When 
455 ** doing coverage testing, the condition inside the argument to
456 ** testcase() must be evaluated both true and false in order to
457 ** get full branch coverage.  The testcase() macro is inserted
458 ** to help ensure adequate test coverage in places where simple
459 ** condition/decision coverage is inadequate.  For example, testcase()
460 ** can be used to make sure boundary values are tested.  For
461 ** bitmask tests, testcase() can be used to make sure each bit
462 ** is significant and used at least once.  On switch statements
463 ** where multiple cases go to the same block of code, testcase()
464 ** can insure that all cases are evaluated.
465 **
466 */
467 #ifdef SQLCIPHER_COVERAGE_TEST
468 SQLCIPHER_PRIVATE   void sqlcipher3Coverage(int);
469 # define testcase(X)  if( X ){ sqlcipher3Coverage(__LINE__); }
470 #else
471 # define testcase(X)
472 #endif
473
474 /*
475 ** The TESTONLY macro is used to enclose variable declarations or
476 ** other bits of code that are needed to support the arguments
477 ** within testcase() and assert() macros.
478 */
479 #if !defined(NDEBUG) || defined(SQLCIPHER_COVERAGE_TEST)
480 # define TESTONLY(X)  X
481 #else
482 # define TESTONLY(X)
483 #endif
484
485 /*
486 ** Sometimes we need a small amount of code such as a variable initialization
487 ** to setup for a later assert() statement.  We do not want this code to
488 ** appear when assert() is disabled.  The following macro is therefore
489 ** used to contain that setup code.  The "VVA" acronym stands for
490 ** "Verification, Validation, and Accreditation".  In other words, the
491 ** code within VVA_ONLY() will only run during verification processes.
492 */
493 #ifndef NDEBUG
494 # define VVA_ONLY(X)  X
495 #else
496 # define VVA_ONLY(X)
497 #endif
498
499 /*
500 ** The ALWAYS and NEVER macros surround boolean expressions which 
501 ** are intended to always be true or false, respectively.  Such
502 ** expressions could be omitted from the code completely.  But they
503 ** are included in a few cases in order to enhance the resilience
504 ** of SQLite to unexpected behavior - to make the code "self-healing"
505 ** or "ductile" rather than being "brittle" and crashing at the first
506 ** hint of unplanned behavior.
507 **
508 ** In other words, ALWAYS and NEVER are added for defensive code.
509 **
510 ** When doing coverage testing ALWAYS and NEVER are hard-coded to
511 ** be true and false so that the unreachable code then specify will
512 ** not be counted as untested code.
513 */
514 #if defined(SQLCIPHER_COVERAGE_TEST)
515 # define ALWAYS(X)      (1)
516 # define NEVER(X)       (0)
517 #elif !defined(NDEBUG)
518 # define ALWAYS(X)      ((X)?1:(assert(0),0))
519 # define NEVER(X)       ((X)?(assert(0),1):0)
520 #else
521 # define ALWAYS(X)      (X)
522 # define NEVER(X)       (X)
523 #endif
524
525 /*
526 ** Return true (non-zero) if the input is a integer that is too large
527 ** to fit in 32-bits.  This macro is used inside of various testcase()
528 ** macros to verify that we have tested SQLite for large-file support.
529 */
530 #define IS_BIG_INT(X)  (((X)&~(i64)0xffffffff)!=0)
531
532 /*
533 ** The macro unlikely() is a hint that surrounds a boolean
534 ** expression that is usually false.  Macro likely() surrounds
535 ** a boolean expression that is usually true.  GCC is able to
536 ** use these hints to generate better code, sometimes.
537 */
538 #if defined(__GNUC__) && 0
539 # define likely(X)    __builtin_expect((X),1)
540 # define unlikely(X)  __builtin_expect((X),0)
541 #else
542 # define likely(X)    !!(X)
543 # define unlikely(X)  !!(X)
544 #endif
545
546 /************** Include sqlcipher3.h in the middle of sqlcipherInt.h ***************/
547 /************** Begin file sqlcipher3.h *****************************************/
548 /*
549 ** 2001 September 15
550 **
551 ** The author disclaims copyright to this source code.  In place of
552 ** a legal notice, here is a blessing:
553 **
554 **    May you do good and not evil.
555 **    May you find forgiveness for yourself and forgive others.
556 **    May you share freely, never taking more than you give.
557 **
558 *************************************************************************
559 ** This header file defines the interface that the SQLite library
560 ** presents to client programs.  If a C-function, structure, datatype,
561 ** or constant definition does not appear in this file, then it is
562 ** not a published API of SQLite, is subject to change without
563 ** notice, and should not be referenced by programs that use SQLite.
564 **
565 ** Some of the definitions that are in this file are marked as
566 ** "experimental".  Experimental interfaces are normally new
567 ** features recently added to SQLite.  We do not anticipate changes
568 ** to experimental interfaces but reserve the right to make minor changes
569 ** if experience from use "in the wild" suggest such changes are prudent.
570 **
571 ** The official C-language API documentation for SQLite is derived
572 ** from comments in this file.  This file is the authoritative source
573 ** on how SQLite interfaces are suppose to operate.
574 **
575 ** The name of this file under configuration management is "sqlcipher.h.in".
576 ** The makefile makes some minor changes to this file (such as inserting
577 ** the version number) and changes its name to "sqlcipher3.h" as
578 ** part of the build process.
579 */
580 #ifndef _SQLCIPHER3_H_
581 #define _SQLCIPHER3_H_
582 #include <stdarg.h>     /* Needed for the definition of va_list */
583
584 /*
585 ** Make sure we can call this stuff from C++.
586 */
587 #if 0
588 extern "C" {
589 #endif
590
591
592 /*
593 ** Add the ability to override 'extern'
594 */
595 #ifndef SQLCIPHER_EXTERN
596 # define SQLCIPHER_EXTERN extern
597 #endif
598
599 #ifndef SQLCIPHER_API
600 # define SQLCIPHER_API
601 #endif
602
603
604 /*
605 ** These no-op macros are used in front of interfaces to mark those
606 ** interfaces as either deprecated or experimental.  New applications
607 ** should not use deprecated interfaces - they are support for backwards
608 ** compatibility only.  Application writers should be aware that
609 ** experimental interfaces are subject to change in point releases.
610 **
611 ** These macros used to resolve to various kinds of compiler magic that
612 ** would generate warning messages when they were used.  But that
613 ** compiler magic ended up generating such a flurry of bug reports
614 ** that we have taken it all out and gone back to using simple
615 ** noop macros.
616 */
617 #define SQLCIPHER_DEPRECATED
618 #define SQLCIPHER_EXPERIMENTAL
619
620 /*
621 ** Ensure these symbols were not defined by some previous header file.
622 */
623 #ifdef SQLCIPHER_VERSION
624 # undef SQLCIPHER_VERSION
625 #endif
626 #ifdef SQLCIPHER_VERSION_NUMBER
627 # undef SQLCIPHER_VERSION_NUMBER
628 #endif
629
630 /*
631 ** CAPI3REF: Compile-Time Library Version Numbers
632 **
633 ** ^(The [SQLCIPHER_VERSION] C preprocessor macro in the sqlcipher3.h header
634 ** evaluates to a string literal that is the SQLite version in the
635 ** format "X.Y.Z" where X is the major version number (always 3 for
636 ** SQLite3) and Y is the minor version number and Z is the release number.)^
637 ** ^(The [SQLCIPHER_VERSION_NUMBER] C preprocessor macro resolves to an integer
638 ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
639 ** numbers used in [SQLCIPHER_VERSION].)^
640 ** The SQLCIPHER_VERSION_NUMBER for any given release of SQLite will also
641 ** be larger than the release from which it is derived.  Either Y will
642 ** be held constant and Z will be incremented or else Y will be incremented
643 ** and Z will be reset to zero.
644 **
645 ** Since version 3.6.18, SQLite source code has been stored in the
646 ** <a href="http://www.fossil-scm.org/">Fossil configuration management
647 ** system</a>.  ^The SQLCIPHER_SOURCE_ID macro evaluates to
648 ** a string which identifies a particular check-in of SQLite
649 ** within its configuration management system.  ^The SQLCIPHER_SOURCE_ID
650 ** string contains the date and time of the check-in (UTC) and an SHA1
651 ** hash of the entire source tree.
652 **
653 ** See also: [sqlcipher3_libversion()],
654 ** [sqlcipher3_libversion_number()], [sqlcipher3_sourceid()],
655 ** [sqlcipher_version()] and [sqlcipher_source_id()].
656 */
657 #define SQLCIPHER_VERSION        "3.7.9"
658 #define SQLCIPHER_VERSION_NUMBER 3007009
659 #define SQLCIPHER_SOURCE_ID      "2011-11-01 00:52:41 c7c6050ef060877ebe77b41d959e9df13f8c9b5e"
660
661 /*
662 ** CAPI3REF: Run-Time Library Version Numbers
663 ** KEYWORDS: sqlcipher3_version, sqlcipher3_sourceid
664 **
665 ** These interfaces provide the same information as the [SQLCIPHER_VERSION],
666 ** [SQLCIPHER_VERSION_NUMBER], and [SQLCIPHER_SOURCE_ID] C preprocessor macros
667 ** but are associated with the library instead of the header file.  ^(Cautious
668 ** programmers might include assert() statements in their application to
669 ** verify that values returned by these interfaces match the macros in
670 ** the header, and thus insure that the application is
671 ** compiled with matching library and header files.
672 **
673 ** <blockquote><pre>
674 ** assert( sqlcipher3_libversion_number()==SQLCIPHER_VERSION_NUMBER );
675 ** assert( strcmp(sqlcipher3_sourceid(),SQLCIPHER_SOURCE_ID)==0 );
676 ** assert( strcmp(sqlcipher3_libversion(),SQLCIPHER_VERSION)==0 );
677 ** </pre></blockquote>)^
678 **
679 ** ^The sqlcipher3_version[] string constant contains the text of [SQLCIPHER_VERSION]
680 ** macro.  ^The sqlcipher3_libversion() function returns a pointer to the
681 ** to the sqlcipher3_version[] string constant.  The sqlcipher3_libversion()
682 ** function is provided for use in DLLs since DLL users usually do not have
683 ** direct access to string constants within the DLL.  ^The
684 ** sqlcipher3_libversion_number() function returns an integer equal to
685 ** [SQLCIPHER_VERSION_NUMBER].  ^The sqlcipher3_sourceid() function returns 
686 ** a pointer to a string constant whose value is the same as the 
687 ** [SQLCIPHER_SOURCE_ID] C preprocessor macro.
688 **
689 ** See also: [sqlcipher_version()] and [sqlcipher_source_id()].
690 */
691 SQLCIPHER_API const char sqlcipher3_version[] = SQLCIPHER_VERSION;
692 SQLCIPHER_API const char *sqlcipher3_libversion(void);
693 SQLCIPHER_API const char *sqlcipher3_sourceid(void);
694 SQLCIPHER_API int sqlcipher3_libversion_number(void);
695
696 /*
697 ** CAPI3REF: Run-Time Library Compilation Options Diagnostics
698 **
699 ** ^The sqlcipher3_compileoption_used() function returns 0 or 1 
700 ** indicating whether the specified option was defined at 
701 ** compile time.  ^The SQLCIPHER_ prefix may be omitted from the 
702 ** option name passed to sqlcipher3_compileoption_used().  
703 **
704 ** ^The sqlcipher3_compileoption_get() function allows iterating
705 ** over the list of options that were defined at compile time by
706 ** returning the N-th compile time option string.  ^If N is out of range,
707 ** sqlcipher3_compileoption_get() returns a NULL pointer.  ^The SQLCIPHER_ 
708 ** prefix is omitted from any strings returned by 
709 ** sqlcipher3_compileoption_get().
710 **
711 ** ^Support for the diagnostic functions sqlcipher3_compileoption_used()
712 ** and sqlcipher3_compileoption_get() may be omitted by specifying the 
713 ** [SQLCIPHER_OMIT_COMPILEOPTION_DIAGS] option at compile time.
714 **
715 ** See also: SQL functions [sqlcipher_compileoption_used()] and
716 ** [sqlcipher_compileoption_get()] and the [compile_options pragma].
717 */
718 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
719 SQLCIPHER_API int sqlcipher3_compileoption_used(const char *zOptName);
720 SQLCIPHER_API const char *sqlcipher3_compileoption_get(int N);
721 #endif
722
723 /*
724 ** CAPI3REF: Test To See If The Library Is Threadsafe
725 **
726 ** ^The sqlcipher3_threadsafe() function returns zero if and only if
727 ** SQLite was compiled mutexing code omitted due to the
728 ** [SQLCIPHER_THREADSAFE] compile-time option being set to 0.
729 **
730 ** SQLite can be compiled with or without mutexes.  When
731 ** the [SQLCIPHER_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
732 ** are enabled and SQLite is threadsafe.  When the
733 ** [SQLCIPHER_THREADSAFE] macro is 0, 
734 ** the mutexes are omitted.  Without the mutexes, it is not safe
735 ** to use SQLite concurrently from more than one thread.
736 **
737 ** Enabling mutexes incurs a measurable performance penalty.
738 ** So if speed is of utmost importance, it makes sense to disable
739 ** the mutexes.  But for maximum safety, mutexes should be enabled.
740 ** ^The default behavior is for mutexes to be enabled.
741 **
742 ** This interface can be used by an application to make sure that the
743 ** version of SQLite that it is linking against was compiled with
744 ** the desired setting of the [SQLCIPHER_THREADSAFE] macro.
745 **
746 ** This interface only reports on the compile-time mutex setting
747 ** of the [SQLCIPHER_THREADSAFE] flag.  If SQLite is compiled with
748 ** SQLCIPHER_THREADSAFE=1 or =2 then mutexes are enabled by default but
749 ** can be fully or partially disabled using a call to [sqlcipher3_config()]
750 ** with the verbs [SQLCIPHER_CONFIG_SINGLETHREAD], [SQLCIPHER_CONFIG_MULTITHREAD],
751 ** or [SQLCIPHER_CONFIG_MUTEX].  ^(The return value of the
752 ** sqlcipher3_threadsafe() function shows only the compile-time setting of
753 ** thread safety, not any run-time changes to that setting made by
754 ** sqlcipher3_config(). In other words, the return value from sqlcipher3_threadsafe()
755 ** is unchanged by calls to sqlcipher3_config().)^
756 **
757 ** See the [threading mode] documentation for additional information.
758 */
759 SQLCIPHER_API int sqlcipher3_threadsafe(void);
760
761 /*
762 ** CAPI3REF: Database Connection Handle
763 ** KEYWORDS: {database connection} {database connections}
764 **
765 ** Each open SQLite database is represented by a pointer to an instance of
766 ** the opaque structure named "sqlcipher3".  It is useful to think of an sqlcipher3
767 ** pointer as an object.  The [sqlcipher3_open()], [sqlcipher3_open16()], and
768 ** [sqlcipher3_open_v2()] interfaces are its constructors, and [sqlcipher3_close()]
769 ** is its destructor.  There are many other interfaces (such as
770 ** [sqlcipher3_prepare_v2()], [sqlcipher3_create_function()], and
771 ** [sqlcipher3_busy_timeout()] to name but three) that are methods on an
772 ** sqlcipher3 object.
773 */
774 typedef struct sqlcipher3 sqlcipher3;
775
776 /*
777 ** CAPI3REF: 64-Bit Integer Types
778 ** KEYWORDS: sqlcipher_int64 sqlcipher_uint64
779 **
780 ** Because there is no cross-platform way to specify 64-bit integer types
781 ** SQLite includes typedefs for 64-bit signed and unsigned integers.
782 **
783 ** The sqlcipher3_int64 and sqlcipher3_uint64 are the preferred type definitions.
784 ** The sqlcipher_int64 and sqlcipher_uint64 types are supported for backwards
785 ** compatibility only.
786 **
787 ** ^The sqlcipher3_int64 and sqlcipher_int64 types can store integer values
788 ** between -9223372036854775808 and +9223372036854775807 inclusive.  ^The
789 ** sqlcipher3_uint64 and sqlcipher_uint64 types can store integer values 
790 ** between 0 and +18446744073709551615 inclusive.
791 */
792 #ifdef SQLCIPHER_INT64_TYPE
793   typedef SQLCIPHER_INT64_TYPE sqlcipher_int64;
794   typedef unsigned SQLCIPHER_INT64_TYPE sqlcipher_uint64;
795 #elif defined(_MSC_VER) || defined(__BORLANDC__)
796   typedef __int64 sqlcipher_int64;
797   typedef unsigned __int64 sqlcipher_uint64;
798 #else
799   typedef long long int sqlcipher_int64;
800   typedef unsigned long long int sqlcipher_uint64;
801 #endif
802 typedef sqlcipher_int64 sqlcipher3_int64;
803 typedef sqlcipher_uint64 sqlcipher3_uint64;
804
805 /*
806 ** If compiling for a processor that lacks floating point support,
807 ** substitute integer for floating-point.
808 */
809 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
810 # define double sqlcipher3_int64
811 #endif
812
813 /*
814 ** CAPI3REF: Closing A Database Connection
815 **
816 ** ^The sqlcipher3_close() routine is the destructor for the [sqlcipher3] object.
817 ** ^Calls to sqlcipher3_close() return SQLCIPHER_OK if the [sqlcipher3] object is
818 ** successfully destroyed and all associated resources are deallocated.
819 **
820 ** Applications must [sqlcipher3_finalize | finalize] all [prepared statements]
821 ** and [sqlcipher3_blob_close | close] all [BLOB handles] associated with
822 ** the [sqlcipher3] object prior to attempting to close the object.  ^If
823 ** sqlcipher3_close() is called on a [database connection] that still has
824 ** outstanding [prepared statements] or [BLOB handles], then it returns
825 ** SQLCIPHER_BUSY.
826 **
827 ** ^If [sqlcipher3_close()] is invoked while a transaction is open,
828 ** the transaction is automatically rolled back.
829 **
830 ** The C parameter to [sqlcipher3_close(C)] must be either a NULL
831 ** pointer or an [sqlcipher3] object pointer obtained
832 ** from [sqlcipher3_open()], [sqlcipher3_open16()], or
833 ** [sqlcipher3_open_v2()], and not previously closed.
834 ** ^Calling sqlcipher3_close() with a NULL pointer argument is a 
835 ** harmless no-op.
836 */
837 SQLCIPHER_API int sqlcipher3_close(sqlcipher3 *);
838
839 /*
840 ** The type for a callback function.
841 ** This is legacy and deprecated.  It is included for historical
842 ** compatibility and is not documented.
843 */
844 typedef int (*sqlcipher3_callback)(void*,int,char**, char**);
845
846 /*
847 ** CAPI3REF: One-Step Query Execution Interface
848 **
849 ** The sqlcipher3_exec() interface is a convenience wrapper around
850 ** [sqlcipher3_prepare_v2()], [sqlcipher3_step()], and [sqlcipher3_finalize()],
851 ** that allows an application to run multiple statements of SQL
852 ** without having to use a lot of C code. 
853 **
854 ** ^The sqlcipher3_exec() interface runs zero or more UTF-8 encoded,
855 ** semicolon-separate SQL statements passed into its 2nd argument,
856 ** in the context of the [database connection] passed in as its 1st
857 ** argument.  ^If the callback function of the 3rd argument to
858 ** sqlcipher3_exec() is not NULL, then it is invoked for each result row
859 ** coming out of the evaluated SQL statements.  ^The 4th argument to
860 ** sqlcipher3_exec() is relayed through to the 1st argument of each
861 ** callback invocation.  ^If the callback pointer to sqlcipher3_exec()
862 ** is NULL, then no callback is ever invoked and result rows are
863 ** ignored.
864 **
865 ** ^If an error occurs while evaluating the SQL statements passed into
866 ** sqlcipher3_exec(), then execution of the current statement stops and
867 ** subsequent statements are skipped.  ^If the 5th parameter to sqlcipher3_exec()
868 ** is not NULL then any error message is written into memory obtained
869 ** from [sqlcipher3_malloc()] and passed back through the 5th parameter.
870 ** To avoid memory leaks, the application should invoke [sqlcipher3_free()]
871 ** on error message strings returned through the 5th parameter of
872 ** of sqlcipher3_exec() after the error message string is no longer needed.
873 ** ^If the 5th parameter to sqlcipher3_exec() is not NULL and no errors
874 ** occur, then sqlcipher3_exec() sets the pointer in its 5th parameter to
875 ** NULL before returning.
876 **
877 ** ^If an sqlcipher3_exec() callback returns non-zero, the sqlcipher3_exec()
878 ** routine returns SQLCIPHER_ABORT without invoking the callback again and
879 ** without running any subsequent SQL statements.
880 **
881 ** ^The 2nd argument to the sqlcipher3_exec() callback function is the
882 ** number of columns in the result.  ^The 3rd argument to the sqlcipher3_exec()
883 ** callback is an array of pointers to strings obtained as if from
884 ** [sqlcipher3_column_text()], one for each column.  ^If an element of a
885 ** result row is NULL then the corresponding string pointer for the
886 ** sqlcipher3_exec() callback is a NULL pointer.  ^The 4th argument to the
887 ** sqlcipher3_exec() callback is an array of pointers to strings where each
888 ** entry represents the name of corresponding result column as obtained
889 ** from [sqlcipher3_column_name()].
890 **
891 ** ^If the 2nd parameter to sqlcipher3_exec() is a NULL pointer, a pointer
892 ** to an empty string, or a pointer that contains only whitespace and/or 
893 ** SQL comments, then no SQL statements are evaluated and the database
894 ** is not changed.
895 **
896 ** Restrictions:
897 **
898 ** <ul>
899 ** <li> The application must insure that the 1st parameter to sqlcipher3_exec()
900 **      is a valid and open [database connection].
901 ** <li> The application must not close [database connection] specified by
902 **      the 1st parameter to sqlcipher3_exec() while sqlcipher3_exec() is running.
903 ** <li> The application must not modify the SQL statement text passed into
904 **      the 2nd parameter of sqlcipher3_exec() while sqlcipher3_exec() is running.
905 ** </ul>
906 */
907 SQLCIPHER_API int sqlcipher3_exec(
908   sqlcipher3*,                                  /* An open database */
909   const char *sql,                           /* SQL to be evaluated */
910   int (*callback)(void*,int,char**,char**),  /* Callback function */
911   void *,                                    /* 1st argument to callback */
912   char **errmsg                              /* Error msg written here */
913 );
914
915 /*
916 ** CAPI3REF: Result Codes
917 ** KEYWORDS: SQLCIPHER_OK {error code} {error codes}
918 ** KEYWORDS: {result code} {result codes}
919 **
920 ** Many SQLite functions return an integer result code from the set shown
921 ** here in order to indicates success or failure.
922 **
923 ** New error codes may be added in future versions of SQLite.
924 **
925 ** See also: [SQLCIPHER_IOERR_READ | extended result codes],
926 ** [sqlcipher3_vtab_on_conflict()] [SQLCIPHER_ROLLBACK | result codes].
927 */
928 #define SQLCIPHER_OK           0   /* Successful result */
929 /* beginning-of-error-codes */
930 #define SQLCIPHER_ERROR        1   /* SQL error or missing database */
931 #define SQLCIPHER_INTERNAL     2   /* Internal logic error in SQLite */
932 #define SQLCIPHER_PERM         3   /* Access permission denied */
933 #define SQLCIPHER_ABORT        4   /* Callback routine requested an abort */
934 #define SQLCIPHER_BUSY         5   /* The database file is locked */
935 #define SQLCIPHER_LOCKED       6   /* A table in the database is locked */
936 #define SQLCIPHER_NOMEM        7   /* A malloc() failed */
937 #define SQLCIPHER_READONLY     8   /* Attempt to write a readonly database */
938 #define SQLCIPHER_INTERRUPT    9   /* Operation terminated by sqlcipher3_interrupt()*/
939 #define SQLCIPHER_IOERR       10   /* Some kind of disk I/O error occurred */
940 #define SQLCIPHER_CORRUPT     11   /* The database disk image is malformed */
941 #define SQLCIPHER_NOTFOUND    12   /* Unknown opcode in sqlcipher3_file_control() */
942 #define SQLCIPHER_FULL        13   /* Insertion failed because database is full */
943 #define SQLCIPHER_CANTOPEN    14   /* Unable to open the database file */
944 #define SQLCIPHER_PROTOCOL    15   /* Database lock protocol error */
945 #define SQLCIPHER_EMPTY       16   /* Database is empty */
946 #define SQLCIPHER_SCHEMA      17   /* The database schema changed */
947 #define SQLCIPHER_TOOBIG      18   /* String or BLOB exceeds size limit */
948 #define SQLCIPHER_CONSTRAINT  19   /* Abort due to constraint violation */
949 #define SQLCIPHER_MISMATCH    20   /* Data type mismatch */
950 #define SQLCIPHER_MISUSE      21   /* Library used incorrectly */
951 #define SQLCIPHER_NOLFS       22   /* Uses OS features not supported on host */
952 #define SQLCIPHER_AUTH        23   /* Authorization denied */
953 #define SQLCIPHER_FORMAT      24   /* Auxiliary database format error */
954 #define SQLCIPHER_RANGE       25   /* 2nd parameter to sqlcipher3_bind out of range */
955 #define SQLCIPHER_NOTADB      26   /* File opened that is not a database file */
956 #define SQLCIPHER_ROW         100  /* sqlcipher3_step() has another row ready */
957 #define SQLCIPHER_DONE        101  /* sqlcipher3_step() has finished executing */
958 /* end-of-error-codes */
959
960 /*
961 ** CAPI3REF: Extended Result Codes
962 ** KEYWORDS: {extended error code} {extended error codes}
963 ** KEYWORDS: {extended result code} {extended result codes}
964 **
965 ** In its default configuration, SQLite API routines return one of 26 integer
966 ** [SQLCIPHER_OK | result codes].  However, experience has shown that many of
967 ** these result codes are too coarse-grained.  They do not provide as
968 ** much information about problems as programmers might like.  In an effort to
969 ** address this, newer versions of SQLite (version 3.3.8 and later) include
970 ** support for additional result codes that provide more detailed information
971 ** about errors. The extended result codes are enabled or disabled
972 ** on a per database connection basis using the
973 ** [sqlcipher3_extended_result_codes()] API.
974 **
975 ** Some of the available extended result codes are listed here.
976 ** One may expect the number of extended result codes will be expand
977 ** over time.  Software that uses extended result codes should expect
978 ** to see new result codes in future releases of SQLite.
979 **
980 ** The SQLCIPHER_OK result code will never be extended.  It will always
981 ** be exactly zero.
982 */
983 #define SQLCIPHER_IOERR_READ              (SQLCIPHER_IOERR | (1<<8))
984 #define SQLCIPHER_IOERR_SHORT_READ        (SQLCIPHER_IOERR | (2<<8))
985 #define SQLCIPHER_IOERR_WRITE             (SQLCIPHER_IOERR | (3<<8))
986 #define SQLCIPHER_IOERR_FSYNC             (SQLCIPHER_IOERR | (4<<8))
987 #define SQLCIPHER_IOERR_DIR_FSYNC         (SQLCIPHER_IOERR | (5<<8))
988 #define SQLCIPHER_IOERR_TRUNCATE          (SQLCIPHER_IOERR | (6<<8))
989 #define SQLCIPHER_IOERR_FSTAT             (SQLCIPHER_IOERR | (7<<8))
990 #define SQLCIPHER_IOERR_UNLOCK            (SQLCIPHER_IOERR | (8<<8))
991 #define SQLCIPHER_IOERR_RDLOCK            (SQLCIPHER_IOERR | (9<<8))
992 #define SQLCIPHER_IOERR_DELETE            (SQLCIPHER_IOERR | (10<<8))
993 #define SQLCIPHER_IOERR_BLOCKED           (SQLCIPHER_IOERR | (11<<8))
994 #define SQLCIPHER_IOERR_NOMEM             (SQLCIPHER_IOERR | (12<<8))
995 #define SQLCIPHER_IOERR_ACCESS            (SQLCIPHER_IOERR | (13<<8))
996 #define SQLCIPHER_IOERR_CHECKRESERVEDLOCK (SQLCIPHER_IOERR | (14<<8))
997 #define SQLCIPHER_IOERR_LOCK              (SQLCIPHER_IOERR | (15<<8))
998 #define SQLCIPHER_IOERR_CLOSE             (SQLCIPHER_IOERR | (16<<8))
999 #define SQLCIPHER_IOERR_DIR_CLOSE         (SQLCIPHER_IOERR | (17<<8))
1000 #define SQLCIPHER_IOERR_SHMOPEN           (SQLCIPHER_IOERR | (18<<8))
1001 #define SQLCIPHER_IOERR_SHMSIZE           (SQLCIPHER_IOERR | (19<<8))
1002 #define SQLCIPHER_IOERR_SHMLOCK           (SQLCIPHER_IOERR | (20<<8))
1003 #define SQLCIPHER_IOERR_SHMMAP            (SQLCIPHER_IOERR | (21<<8))
1004 #define SQLCIPHER_IOERR_SEEK              (SQLCIPHER_IOERR | (22<<8))
1005 #define SQLCIPHER_LOCKED_SHAREDCACHE      (SQLCIPHER_LOCKED |  (1<<8))
1006 #define SQLCIPHER_BUSY_RECOVERY           (SQLCIPHER_BUSY   |  (1<<8))
1007 #define SQLCIPHER_CANTOPEN_NOTEMPDIR      (SQLCIPHER_CANTOPEN | (1<<8))
1008 #define SQLCIPHER_CORRUPT_VTAB            (SQLCIPHER_CORRUPT | (1<<8))
1009 #define SQLCIPHER_READONLY_RECOVERY       (SQLCIPHER_READONLY | (1<<8))
1010 #define SQLCIPHER_READONLY_CANTLOCK       (SQLCIPHER_READONLY | (2<<8))
1011
1012 /*
1013 ** CAPI3REF: Flags For File Open Operations
1014 **
1015 ** These bit values are intended for use in the
1016 ** 3rd parameter to the [sqlcipher3_open_v2()] interface and
1017 ** in the 4th parameter to the [sqlcipher3_vfs.xOpen] method.
1018 */
1019 #define SQLCIPHER_OPEN_READONLY         0x00000001  /* Ok for sqlcipher3_open_v2() */
1020 #define SQLCIPHER_OPEN_READWRITE        0x00000002  /* Ok for sqlcipher3_open_v2() */
1021 #define SQLCIPHER_OPEN_CREATE           0x00000004  /* Ok for sqlcipher3_open_v2() */
1022 #define SQLCIPHER_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */
1023 #define SQLCIPHER_OPEN_EXCLUSIVE        0x00000010  /* VFS only */
1024 #define SQLCIPHER_OPEN_AUTOPROXY        0x00000020  /* VFS only */
1025 #define SQLCIPHER_OPEN_URI              0x00000040  /* Ok for sqlcipher3_open_v2() */
1026 #define SQLCIPHER_OPEN_MAIN_DB          0x00000100  /* VFS only */
1027 #define SQLCIPHER_OPEN_TEMP_DB          0x00000200  /* VFS only */
1028 #define SQLCIPHER_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */
1029 #define SQLCIPHER_OPEN_MAIN_JOURNAL     0x00000800  /* VFS only */
1030 #define SQLCIPHER_OPEN_TEMP_JOURNAL     0x00001000  /* VFS only */
1031 #define SQLCIPHER_OPEN_SUBJOURNAL       0x00002000  /* VFS only */
1032 #define SQLCIPHER_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */
1033 #define SQLCIPHER_OPEN_NOMUTEX          0x00008000  /* Ok for sqlcipher3_open_v2() */
1034 #define SQLCIPHER_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlcipher3_open_v2() */
1035 #define SQLCIPHER_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlcipher3_open_v2() */
1036 #define SQLCIPHER_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlcipher3_open_v2() */
1037 #define SQLCIPHER_OPEN_WAL              0x00080000  /* VFS only */
1038
1039 /* Reserved:                         0x00F00000 */
1040
1041 /*
1042 ** CAPI3REF: Device Characteristics
1043 **
1044 ** The xDeviceCharacteristics method of the [sqlcipher3_io_methods]
1045 ** object returns an integer which is a vector of the these
1046 ** bit values expressing I/O characteristics of the mass storage
1047 ** device that holds the file that the [sqlcipher3_io_methods]
1048 ** refers to.
1049 **
1050 ** The SQLCIPHER_IOCAP_ATOMIC property means that all writes of
1051 ** any size are atomic.  The SQLCIPHER_IOCAP_ATOMICnnn values
1052 ** mean that writes of blocks that are nnn bytes in size and
1053 ** are aligned to an address which is an integer multiple of
1054 ** nnn are atomic.  The SQLCIPHER_IOCAP_SAFE_APPEND value means
1055 ** that when data is appended to a file, the data is appended
1056 ** first then the size of the file is extended, never the other
1057 ** way around.  The SQLCIPHER_IOCAP_SEQUENTIAL property means that
1058 ** information is written to disk in the same order as calls
1059 ** to xWrite().
1060 */
1061 #define SQLCIPHER_IOCAP_ATOMIC                 0x00000001
1062 #define SQLCIPHER_IOCAP_ATOMIC512              0x00000002
1063 #define SQLCIPHER_IOCAP_ATOMIC1K               0x00000004
1064 #define SQLCIPHER_IOCAP_ATOMIC2K               0x00000008
1065 #define SQLCIPHER_IOCAP_ATOMIC4K               0x00000010
1066 #define SQLCIPHER_IOCAP_ATOMIC8K               0x00000020
1067 #define SQLCIPHER_IOCAP_ATOMIC16K              0x00000040
1068 #define SQLCIPHER_IOCAP_ATOMIC32K              0x00000080
1069 #define SQLCIPHER_IOCAP_ATOMIC64K              0x00000100
1070 #define SQLCIPHER_IOCAP_SAFE_APPEND            0x00000200
1071 #define SQLCIPHER_IOCAP_SEQUENTIAL             0x00000400
1072 #define SQLCIPHER_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
1073
1074 /*
1075 ** CAPI3REF: File Locking Levels
1076 **
1077 ** SQLite uses one of these integer values as the second
1078 ** argument to calls it makes to the xLock() and xUnlock() methods
1079 ** of an [sqlcipher3_io_methods] object.
1080 */
1081 #define SQLCIPHER_LOCK_NONE          0
1082 #define SQLCIPHER_LOCK_SHARED        1
1083 #define SQLCIPHER_LOCK_RESERVED      2
1084 #define SQLCIPHER_LOCK_PENDING       3
1085 #define SQLCIPHER_LOCK_EXCLUSIVE     4
1086
1087 /*
1088 ** CAPI3REF: Synchronization Type Flags
1089 **
1090 ** When SQLite invokes the xSync() method of an
1091 ** [sqlcipher3_io_methods] object it uses a combination of
1092 ** these integer values as the second argument.
1093 **
1094 ** When the SQLCIPHER_SYNC_DATAONLY flag is used, it means that the
1095 ** sync operation only needs to flush data to mass storage.  Inode
1096 ** information need not be flushed. If the lower four bits of the flag
1097 ** equal SQLCIPHER_SYNC_NORMAL, that means to use normal fsync() semantics.
1098 ** If the lower four bits equal SQLCIPHER_SYNC_FULL, that means
1099 ** to use Mac OS X style fullsync instead of fsync().
1100 **
1101 ** Do not confuse the SQLCIPHER_SYNC_NORMAL and SQLCIPHER_SYNC_FULL flags
1102 ** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL
1103 ** settings.  The [synchronous pragma] determines when calls to the
1104 ** xSync VFS method occur and applies uniformly across all platforms.
1105 ** The SQLCIPHER_SYNC_NORMAL and SQLCIPHER_SYNC_FULL flags determine how
1106 ** energetic or rigorous or forceful the sync operations are and
1107 ** only make a difference on Mac OSX for the default SQLite code.
1108 ** (Third-party VFS implementations might also make the distinction
1109 ** between SQLCIPHER_SYNC_NORMAL and SQLCIPHER_SYNC_FULL, but among the
1110 ** operating systems natively supported by SQLite, only Mac OSX
1111 ** cares about the difference.)
1112 */
1113 #define SQLCIPHER_SYNC_NORMAL        0x00002
1114 #define SQLCIPHER_SYNC_FULL          0x00003
1115 #define SQLCIPHER_SYNC_DATAONLY      0x00010
1116
1117 /*
1118 ** CAPI3REF: OS Interface Open File Handle
1119 **
1120 ** An [sqlcipher3_file] object represents an open file in the 
1121 ** [sqlcipher3_vfs | OS interface layer].  Individual OS interface
1122 ** implementations will
1123 ** want to subclass this object by appending additional fields
1124 ** for their own use.  The pMethods entry is a pointer to an
1125 ** [sqlcipher3_io_methods] object that defines methods for performing
1126 ** I/O operations on the open file.
1127 */
1128 typedef struct sqlcipher3_file sqlcipher3_file;
1129 struct sqlcipher3_file {
1130   const struct sqlcipher3_io_methods *pMethods;  /* Methods for an open file */
1131 };
1132
1133 /*
1134 ** CAPI3REF: OS Interface File Virtual Methods Object
1135 **
1136 ** Every file opened by the [sqlcipher3_vfs.xOpen] method populates an
1137 ** [sqlcipher3_file] object (or, more commonly, a subclass of the
1138 ** [sqlcipher3_file] object) with a pointer to an instance of this object.
1139 ** This object defines the methods used to perform various operations
1140 ** against the open file represented by the [sqlcipher3_file] object.
1141 **
1142 ** If the [sqlcipher3_vfs.xOpen] method sets the sqlcipher3_file.pMethods element 
1143 ** to a non-NULL pointer, then the sqlcipher3_io_methods.xClose method
1144 ** may be invoked even if the [sqlcipher3_vfs.xOpen] reported that it failed.  The
1145 ** only way to prevent a call to xClose following a failed [sqlcipher3_vfs.xOpen]
1146 ** is for the [sqlcipher3_vfs.xOpen] to set the sqlcipher3_file.pMethods element
1147 ** to NULL.
1148 **
1149 ** The flags argument to xSync may be one of [SQLCIPHER_SYNC_NORMAL] or
1150 ** [SQLCIPHER_SYNC_FULL].  The first choice is the normal fsync().
1151 ** The second choice is a Mac OS X style fullsync.  The [SQLCIPHER_SYNC_DATAONLY]
1152 ** flag may be ORed in to indicate that only the data of the file
1153 ** and not its inode needs to be synced.
1154 **
1155 ** The integer values to xLock() and xUnlock() are one of
1156 ** <ul>
1157 ** <li> [SQLCIPHER_LOCK_NONE],
1158 ** <li> [SQLCIPHER_LOCK_SHARED],
1159 ** <li> [SQLCIPHER_LOCK_RESERVED],
1160 ** <li> [SQLCIPHER_LOCK_PENDING], or
1161 ** <li> [SQLCIPHER_LOCK_EXCLUSIVE].
1162 ** </ul>
1163 ** xLock() increases the lock. xUnlock() decreases the lock.
1164 ** The xCheckReservedLock() method checks whether any database connection,
1165 ** either in this process or in some other process, is holding a RESERVED,
1166 ** PENDING, or EXCLUSIVE lock on the file.  It returns true
1167 ** if such a lock exists and false otherwise.
1168 **
1169 ** The xFileControl() method is a generic interface that allows custom
1170 ** VFS implementations to directly control an open file using the
1171 ** [sqlcipher3_file_control()] interface.  The second "op" argument is an
1172 ** integer opcode.  The third argument is a generic pointer intended to
1173 ** point to a structure that may contain arguments or space in which to
1174 ** write return values.  Potential uses for xFileControl() might be
1175 ** functions to enable blocking locks with timeouts, to change the
1176 ** locking strategy (for example to use dot-file locks), to inquire
1177 ** about the status of a lock, or to break stale locks.  The SQLite
1178 ** core reserves all opcodes less than 100 for its own use.
1179 ** A [SQLCIPHER_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
1180 ** Applications that define a custom xFileControl method should use opcodes
1181 ** greater than 100 to avoid conflicts.  VFS implementations should
1182 ** return [SQLCIPHER_NOTFOUND] for file control opcodes that they do not
1183 ** recognize.
1184 **
1185 ** The xSectorSize() method returns the sector size of the
1186 ** device that underlies the file.  The sector size is the
1187 ** minimum write that can be performed without disturbing
1188 ** other bytes in the file.  The xDeviceCharacteristics()
1189 ** method returns a bit vector describing behaviors of the
1190 ** underlying device:
1191 **
1192 ** <ul>
1193 ** <li> [SQLCIPHER_IOCAP_ATOMIC]
1194 ** <li> [SQLCIPHER_IOCAP_ATOMIC512]
1195 ** <li> [SQLCIPHER_IOCAP_ATOMIC1K]
1196 ** <li> [SQLCIPHER_IOCAP_ATOMIC2K]
1197 ** <li> [SQLCIPHER_IOCAP_ATOMIC4K]
1198 ** <li> [SQLCIPHER_IOCAP_ATOMIC8K]
1199 ** <li> [SQLCIPHER_IOCAP_ATOMIC16K]
1200 ** <li> [SQLCIPHER_IOCAP_ATOMIC32K]
1201 ** <li> [SQLCIPHER_IOCAP_ATOMIC64K]
1202 ** <li> [SQLCIPHER_IOCAP_SAFE_APPEND]
1203 ** <li> [SQLCIPHER_IOCAP_SEQUENTIAL]
1204 ** </ul>
1205 **
1206 ** The SQLCIPHER_IOCAP_ATOMIC property means that all writes of
1207 ** any size are atomic.  The SQLCIPHER_IOCAP_ATOMICnnn values
1208 ** mean that writes of blocks that are nnn bytes in size and
1209 ** are aligned to an address which is an integer multiple of
1210 ** nnn are atomic.  The SQLCIPHER_IOCAP_SAFE_APPEND value means
1211 ** that when data is appended to a file, the data is appended
1212 ** first then the size of the file is extended, never the other
1213 ** way around.  The SQLCIPHER_IOCAP_SEQUENTIAL property means that
1214 ** information is written to disk in the same order as calls
1215 ** to xWrite().
1216 **
1217 ** If xRead() returns SQLCIPHER_IOERR_SHORT_READ it must also fill
1218 ** in the unread portions of the buffer with zeros.  A VFS that
1219 ** fails to zero-fill short reads might seem to work.  However,
1220 ** failure to zero-fill short reads will eventually lead to
1221 ** database corruption.
1222 */
1223 typedef struct sqlcipher3_io_methods sqlcipher3_io_methods;
1224 struct sqlcipher3_io_methods {
1225   int iVersion;
1226   int (*xClose)(sqlcipher3_file*);
1227   int (*xRead)(sqlcipher3_file*, void*, int iAmt, sqlcipher3_int64 iOfst);
1228   int (*xWrite)(sqlcipher3_file*, const void*, int iAmt, sqlcipher3_int64 iOfst);
1229   int (*xTruncate)(sqlcipher3_file*, sqlcipher3_int64 size);
1230   int (*xSync)(sqlcipher3_file*, int flags);
1231   int (*xFileSize)(sqlcipher3_file*, sqlcipher3_int64 *pSize);
1232   int (*xLock)(sqlcipher3_file*, int);
1233   int (*xUnlock)(sqlcipher3_file*, int);
1234   int (*xCheckReservedLock)(sqlcipher3_file*, int *pResOut);
1235   int (*xFileControl)(sqlcipher3_file*, int op, void *pArg);
1236   int (*xSectorSize)(sqlcipher3_file*);
1237   int (*xDeviceCharacteristics)(sqlcipher3_file*);
1238   /* Methods above are valid for version 1 */
1239   int (*xShmMap)(sqlcipher3_file*, int iPg, int pgsz, int, void volatile**);
1240   int (*xShmLock)(sqlcipher3_file*, int offset, int n, int flags);
1241   void (*xShmBarrier)(sqlcipher3_file*);
1242   int (*xShmUnmap)(sqlcipher3_file*, int deleteFlag);
1243   /* Methods above are valid for version 2 */
1244   /* Additional methods may be added in future releases */
1245 };
1246
1247 /*
1248 ** CAPI3REF: Standard File Control Opcodes
1249 **
1250 ** These integer constants are opcodes for the xFileControl method
1251 ** of the [sqlcipher3_io_methods] object and for the [sqlcipher3_file_control()]
1252 ** interface.
1253 **
1254 ** The [SQLCIPHER_FCNTL_LOCKSTATE] opcode is used for debugging.  This
1255 ** opcode causes the xFileControl method to write the current state of
1256 ** the lock (one of [SQLCIPHER_LOCK_NONE], [SQLCIPHER_LOCK_SHARED],
1257 ** [SQLCIPHER_LOCK_RESERVED], [SQLCIPHER_LOCK_PENDING], or [SQLCIPHER_LOCK_EXCLUSIVE])
1258 ** into an integer that the pArg argument points to. This capability
1259 ** is used during testing and only needs to be supported when SQLCIPHER_TEST
1260 ** is defined.
1261 **
1262 ** The [SQLCIPHER_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
1263 ** layer a hint of how large the database file will grow to be during the
1264 ** current transaction.  This hint is not guaranteed to be accurate but it
1265 ** is often close.  The underlying VFS might choose to preallocate database
1266 ** file space based on this hint in order to help writes to the database
1267 ** file run faster.
1268 **
1269 ** The [SQLCIPHER_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
1270 ** extends and truncates the database file in chunks of a size specified
1271 ** by the user. The fourth argument to [sqlcipher3_file_control()] should 
1272 ** point to an integer (type int) containing the new chunk-size to use
1273 ** for the nominated database. Allocating database file space in large
1274 ** chunks (say 1MB at a time), may reduce file-system fragmentation and
1275 ** improve performance on some systems.
1276 **
1277 ** The [SQLCIPHER_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
1278 ** to the [sqlcipher3_file] object associated with a particular database
1279 ** connection.  See the [sqlcipher3_file_control()] documentation for
1280 ** additional information.
1281 **
1282 ** ^(The [SQLCIPHER_FCNTL_SYNC_OMITTED] opcode is generated internally by
1283 ** SQLite and sent to all VFSes in place of a call to the xSync method
1284 ** when the database connection has [PRAGMA synchronous] set to OFF.)^
1285 ** Some specialized VFSes need this signal in order to operate correctly
1286 ** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most 
1287 ** VFSes do not need this signal and should silently ignore this opcode.
1288 ** Applications should not call [sqlcipher3_file_control()] with this
1289 ** opcode as doing so may disrupt the operation of the specialized VFSes
1290 ** that do require it.  
1291 **
1292 ** ^The [SQLCIPHER_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic
1293 ** retry counts and intervals for certain disk I/O operations for the
1294 ** windows [VFS] in order to work to provide robustness against
1295 ** anti-virus programs.  By default, the windows VFS will retry file read,
1296 ** file write, and file delete operations up to 10 times, with a delay
1297 ** of 25 milliseconds before the first retry and with the delay increasing
1298 ** by an additional 25 milliseconds with each subsequent retry.  This
1299 ** opcode allows those to values (10 retries and 25 milliseconds of delay)
1300 ** to be adjusted.  The values are changed for all database connections
1301 ** within the same process.  The argument is a pointer to an array of two
1302 ** integers where the first integer i the new retry count and the second
1303 ** integer is the delay.  If either integer is negative, then the setting
1304 ** is not changed but instead the prior value of that setting is written
1305 ** into the array entry, allowing the current retry settings to be
1306 ** interrogated.  The zDbName parameter is ignored.
1307 **
1308 ** ^The [SQLCIPHER_FCNTL_PERSIST_WAL] opcode is used to set or query the
1309 ** persistent [WAL | Write AHead Log] setting.  By default, the auxiliary
1310 ** write ahead log and shared memory files used for transaction control
1311 ** are automatically deleted when the latest connection to the database
1312 ** closes.  Setting persistent WAL mode causes those files to persist after
1313 ** close.  Persisting the files is useful when other processes that do not
1314 ** have write permission on the directory containing the database file want
1315 ** to read the database file, as the WAL and shared memory files must exist
1316 ** in order for the database to be readable.  The fourth parameter to
1317 ** [sqlcipher3_file_control()] for this opcode should be a pointer to an integer.
1318 ** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
1319 ** WAL mode.  If the integer is -1, then it is overwritten with the current
1320 ** WAL persistence setting.
1321 **
1322 ** ^The [SQLCIPHER_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening
1323 ** a write transaction to indicate that, unless it is rolled back for some
1324 ** reason, the entire database file will be overwritten by the current 
1325 ** transaction. This is used by VACUUM operations.
1326 */
1327 #define SQLCIPHER_FCNTL_LOCKSTATE        1
1328 #define SQLCIPHER_GET_LOCKPROXYFILE      2
1329 #define SQLCIPHER_SET_LOCKPROXYFILE      3
1330 #define SQLCIPHER_LAST_ERRNO             4
1331 #define SQLCIPHER_FCNTL_SIZE_HINT        5
1332 #define SQLCIPHER_FCNTL_CHUNK_SIZE       6
1333 #define SQLCIPHER_FCNTL_FILE_POINTER     7
1334 #define SQLCIPHER_FCNTL_SYNC_OMITTED     8
1335 #define SQLCIPHER_FCNTL_WIN32_AV_RETRY   9
1336 #define SQLCIPHER_FCNTL_PERSIST_WAL     10
1337 #define SQLCIPHER_FCNTL_OVERWRITE       11
1338
1339 /*
1340 ** CAPI3REF: Mutex Handle
1341 **
1342 ** The mutex module within SQLite defines [sqlcipher3_mutex] to be an
1343 ** abstract type for a mutex object.  The SQLite core never looks
1344 ** at the internal representation of an [sqlcipher3_mutex].  It only
1345 ** deals with pointers to the [sqlcipher3_mutex] object.
1346 **
1347 ** Mutexes are created using [sqlcipher3_mutex_alloc()].
1348 */
1349 typedef struct sqlcipher3_mutex sqlcipher3_mutex;
1350
1351 /*
1352 ** CAPI3REF: OS Interface Object
1353 **
1354 ** An instance of the sqlcipher3_vfs object defines the interface between
1355 ** the SQLite core and the underlying operating system.  The "vfs"
1356 ** in the name of the object stands for "virtual file system".  See
1357 ** the [VFS | VFS documentation] for further information.
1358 **
1359 ** The value of the iVersion field is initially 1 but may be larger in
1360 ** future versions of SQLite.  Additional fields may be appended to this
1361 ** object when the iVersion value is increased.  Note that the structure
1362 ** of the sqlcipher3_vfs object changes in the transaction between
1363 ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
1364 ** modified.
1365 **
1366 ** The szOsFile field is the size of the subclassed [sqlcipher3_file]
1367 ** structure used by this VFS.  mxPathname is the maximum length of
1368 ** a pathname in this VFS.
1369 **
1370 ** Registered sqlcipher3_vfs objects are kept on a linked list formed by
1371 ** the pNext pointer.  The [sqlcipher3_vfs_register()]
1372 ** and [sqlcipher3_vfs_unregister()] interfaces manage this list
1373 ** in a thread-safe way.  The [sqlcipher3_vfs_find()] interface
1374 ** searches the list.  Neither the application code nor the VFS
1375 ** implementation should use the pNext pointer.
1376 **
1377 ** The pNext field is the only field in the sqlcipher3_vfs
1378 ** structure that SQLite will ever modify.  SQLite will only access
1379 ** or modify this field while holding a particular static mutex.
1380 ** The application should never modify anything within the sqlcipher3_vfs
1381 ** object once the object has been registered.
1382 **
1383 ** The zName field holds the name of the VFS module.  The name must
1384 ** be unique across all VFS modules.
1385 **
1386 ** [[sqlcipher3_vfs.xOpen]]
1387 ** ^SQLite guarantees that the zFilename parameter to xOpen
1388 ** is either a NULL pointer or string obtained
1389 ** from xFullPathname() with an optional suffix added.
1390 ** ^If a suffix is added to the zFilename parameter, it will
1391 ** consist of a single "-" character followed by no more than
1392 ** 10 alphanumeric and/or "-" characters.
1393 ** ^SQLite further guarantees that
1394 ** the string will be valid and unchanged until xClose() is
1395 ** called. Because of the previous sentence,
1396 ** the [sqlcipher3_file] can safely store a pointer to the
1397 ** filename if it needs to remember the filename for some reason.
1398 ** If the zFilename parameter to xOpen is a NULL pointer then xOpen
1399 ** must invent its own temporary name for the file.  ^Whenever the 
1400 ** xFilename parameter is NULL it will also be the case that the
1401 ** flags parameter will include [SQLCIPHER_OPEN_DELETEONCLOSE].
1402 **
1403 ** The flags argument to xOpen() includes all bits set in
1404 ** the flags argument to [sqlcipher3_open_v2()].  Or if [sqlcipher3_open()]
1405 ** or [sqlcipher3_open16()] is used, then flags includes at least
1406 ** [SQLCIPHER_OPEN_READWRITE] | [SQLCIPHER_OPEN_CREATE]. 
1407 ** If xOpen() opens a file read-only then it sets *pOutFlags to
1408 ** include [SQLCIPHER_OPEN_READONLY].  Other bits in *pOutFlags may be set.
1409 **
1410 ** ^(SQLite will also add one of the following flags to the xOpen()
1411 ** call, depending on the object being opened:
1412 **
1413 ** <ul>
1414 ** <li>  [SQLCIPHER_OPEN_MAIN_DB]
1415 ** <li>  [SQLCIPHER_OPEN_MAIN_JOURNAL]
1416 ** <li>  [SQLCIPHER_OPEN_TEMP_DB]
1417 ** <li>  [SQLCIPHER_OPEN_TEMP_JOURNAL]
1418 ** <li>  [SQLCIPHER_OPEN_TRANSIENT_DB]
1419 ** <li>  [SQLCIPHER_OPEN_SUBJOURNAL]
1420 ** <li>  [SQLCIPHER_OPEN_MASTER_JOURNAL]
1421 ** <li>  [SQLCIPHER_OPEN_WAL]
1422 ** </ul>)^
1423 **
1424 ** The file I/O implementation can use the object type flags to
1425 ** change the way it deals with files.  For example, an application
1426 ** that does not care about crash recovery or rollback might make
1427 ** the open of a journal file a no-op.  Writes to this journal would
1428 ** also be no-ops, and any attempt to read the journal would return
1429 ** SQLCIPHER_IOERR.  Or the implementation might recognize that a database
1430 ** file will be doing page-aligned sector reads and writes in a random
1431 ** order and set up its I/O subsystem accordingly.
1432 **
1433 ** SQLite might also add one of the following flags to the xOpen method:
1434 **
1435 ** <ul>
1436 ** <li> [SQLCIPHER_OPEN_DELETEONCLOSE]
1437 ** <li> [SQLCIPHER_OPEN_EXCLUSIVE]
1438 ** </ul>
1439 **
1440 ** The [SQLCIPHER_OPEN_DELETEONCLOSE] flag means the file should be
1441 ** deleted when it is closed.  ^The [SQLCIPHER_OPEN_DELETEONCLOSE]
1442 ** will be set for TEMP databases and their journals, transient
1443 ** databases, and subjournals.
1444 **
1445 ** ^The [SQLCIPHER_OPEN_EXCLUSIVE] flag is always used in conjunction
1446 ** with the [SQLCIPHER_OPEN_CREATE] flag, which are both directly
1447 ** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
1448 ** API.  The SQLCIPHER_OPEN_EXCLUSIVE flag, when paired with the 
1449 ** SQLCIPHER_OPEN_CREATE, is used to indicate that file should always
1450 ** be created, and that it is an error if it already exists.
1451 ** It is <i>not</i> used to indicate the file should be opened 
1452 ** for exclusive access.
1453 **
1454 ** ^At least szOsFile bytes of memory are allocated by SQLite
1455 ** to hold the  [sqlcipher3_file] structure passed as the third
1456 ** argument to xOpen.  The xOpen method does not have to
1457 ** allocate the structure; it should just fill it in.  Note that
1458 ** the xOpen method must set the sqlcipher3_file.pMethods to either
1459 ** a valid [sqlcipher3_io_methods] object or to NULL.  xOpen must do
1460 ** this even if the open fails.  SQLite expects that the sqlcipher3_file.pMethods
1461 ** element will be valid after xOpen returns regardless of the success
1462 ** or failure of the xOpen call.
1463 **
1464 ** [[sqlcipher3_vfs.xAccess]]
1465 ** ^The flags argument to xAccess() may be [SQLCIPHER_ACCESS_EXISTS]
1466 ** to test for the existence of a file, or [SQLCIPHER_ACCESS_READWRITE] to
1467 ** test whether a file is readable and writable, or [SQLCIPHER_ACCESS_READ]
1468 ** to test whether a file is at least readable.   The file can be a
1469 ** directory.
1470 **
1471 ** ^SQLite will always allocate at least mxPathname+1 bytes for the
1472 ** output buffer xFullPathname.  The exact size of the output buffer
1473 ** is also passed as a parameter to both  methods. If the output buffer
1474 ** is not large enough, [SQLCIPHER_CANTOPEN] should be returned. Since this is
1475 ** handled as a fatal error by SQLite, vfs implementations should endeavor
1476 ** to prevent this by setting mxPathname to a sufficiently large value.
1477 **
1478 ** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()
1479 ** interfaces are not strictly a part of the filesystem, but they are
1480 ** included in the VFS structure for completeness.
1481 ** The xRandomness() function attempts to return nBytes bytes
1482 ** of good-quality randomness into zOut.  The return value is
1483 ** the actual number of bytes of randomness obtained.
1484 ** The xSleep() method causes the calling thread to sleep for at
1485 ** least the number of microseconds given.  ^The xCurrentTime()
1486 ** method returns a Julian Day Number for the current date and time as
1487 ** a floating point value.
1488 ** ^The xCurrentTimeInt64() method returns, as an integer, the Julian
1489 ** Day Number multiplied by 86400000 (the number of milliseconds in 
1490 ** a 24-hour day).  
1491 ** ^SQLite will use the xCurrentTimeInt64() method to get the current
1492 ** date and time if that method is available (if iVersion is 2 or 
1493 ** greater and the function pointer is not NULL) and will fall back
1494 ** to xCurrentTime() if xCurrentTimeInt64() is unavailable.
1495 **
1496 ** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces
1497 ** are not used by the SQLite core.  These optional interfaces are provided
1498 ** by some VFSes to facilitate testing of the VFS code. By overriding 
1499 ** system calls with functions under its control, a test program can
1500 ** simulate faults and error conditions that would otherwise be difficult
1501 ** or impossible to induce.  The set of system calls that can be overridden
1502 ** varies from one VFS to another, and from one version of the same VFS to the
1503 ** next.  Applications that use these interfaces must be prepared for any
1504 ** or all of these interfaces to be NULL or for their behavior to change
1505 ** from one release to the next.  Applications must not attempt to access
1506 ** any of these methods if the iVersion of the VFS is less than 3.
1507 */
1508 typedef struct sqlcipher3_vfs sqlcipher3_vfs;
1509 typedef void (*sqlcipher3_syscall_ptr)(void);
1510 struct sqlcipher3_vfs {
1511   int iVersion;            /* Structure version number (currently 3) */
1512   int szOsFile;            /* Size of subclassed sqlcipher3_file */
1513   int mxPathname;          /* Maximum file pathname length */
1514   sqlcipher3_vfs *pNext;      /* Next registered VFS */
1515   const char *zName;       /* Name of this virtual file system */
1516   void *pAppData;          /* Pointer to application-specific data */
1517   int (*xOpen)(sqlcipher3_vfs*, const char *zName, sqlcipher3_file*,
1518                int flags, int *pOutFlags);
1519   int (*xDelete)(sqlcipher3_vfs*, const char *zName, int syncDir);
1520   int (*xAccess)(sqlcipher3_vfs*, const char *zName, int flags, int *pResOut);
1521   int (*xFullPathname)(sqlcipher3_vfs*, const char *zName, int nOut, char *zOut);
1522   void *(*xDlOpen)(sqlcipher3_vfs*, const char *zFilename);
1523   void (*xDlError)(sqlcipher3_vfs*, int nByte, char *zErrMsg);
1524   void (*(*xDlSym)(sqlcipher3_vfs*,void*, const char *zSymbol))(void);
1525   void (*xDlClose)(sqlcipher3_vfs*, void*);
1526   int (*xRandomness)(sqlcipher3_vfs*, int nByte, char *zOut);
1527   int (*xSleep)(sqlcipher3_vfs*, int microseconds);
1528   int (*xCurrentTime)(sqlcipher3_vfs*, double*);
1529   int (*xGetLastError)(sqlcipher3_vfs*, int, char *);
1530   /*
1531   ** The methods above are in version 1 of the sqlcipher_vfs object
1532   ** definition.  Those that follow are added in version 2 or later
1533   */
1534   int (*xCurrentTimeInt64)(sqlcipher3_vfs*, sqlcipher3_int64*);
1535   /*
1536   ** The methods above are in versions 1 and 2 of the sqlcipher_vfs object.
1537   ** Those below are for version 3 and greater.
1538   */
1539   int (*xSetSystemCall)(sqlcipher3_vfs*, const char *zName, sqlcipher3_syscall_ptr);
1540   sqlcipher3_syscall_ptr (*xGetSystemCall)(sqlcipher3_vfs*, const char *zName);
1541   const char *(*xNextSystemCall)(sqlcipher3_vfs*, const char *zName);
1542   /*
1543   ** The methods above are in versions 1 through 3 of the sqlcipher_vfs object.
1544   ** New fields may be appended in figure versions.  The iVersion
1545   ** value will increment whenever this happens. 
1546   */
1547 };
1548
1549 /*
1550 ** CAPI3REF: Flags for the xAccess VFS method
1551 **
1552 ** These integer constants can be used as the third parameter to
1553 ** the xAccess method of an [sqlcipher3_vfs] object.  They determine
1554 ** what kind of permissions the xAccess method is looking for.
1555 ** With SQLCIPHER_ACCESS_EXISTS, the xAccess method
1556 ** simply checks whether the file exists.
1557 ** With SQLCIPHER_ACCESS_READWRITE, the xAccess method
1558 ** checks whether the named directory is both readable and writable
1559 ** (in other words, if files can be added, removed, and renamed within
1560 ** the directory).
1561 ** The SQLCIPHER_ACCESS_READWRITE constant is currently used only by the
1562 ** [temp_store_directory pragma], though this could change in a future
1563 ** release of SQLite.
1564 ** With SQLCIPHER_ACCESS_READ, the xAccess method
1565 ** checks whether the file is readable.  The SQLCIPHER_ACCESS_READ constant is
1566 ** currently unused, though it might be used in a future release of
1567 ** SQLite.
1568 */
1569 #define SQLCIPHER_ACCESS_EXISTS    0
1570 #define SQLCIPHER_ACCESS_READWRITE 1   /* Used by PRAGMA temp_store_directory */
1571 #define SQLCIPHER_ACCESS_READ      2   /* Unused */
1572
1573 /*
1574 ** CAPI3REF: Flags for the xShmLock VFS method
1575 **
1576 ** These integer constants define the various locking operations
1577 ** allowed by the xShmLock method of [sqlcipher3_io_methods].  The
1578 ** following are the only legal combinations of flags to the
1579 ** xShmLock method:
1580 **
1581 ** <ul>
1582 ** <li>  SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_SHARED
1583 ** <li>  SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_EXCLUSIVE
1584 ** <li>  SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_SHARED
1585 ** <li>  SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_EXCLUSIVE
1586 ** </ul>
1587 **
1588 ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
1589 ** was given no the corresponding lock.  
1590 **
1591 ** The xShmLock method can transition between unlocked and SHARED or
1592 ** between unlocked and EXCLUSIVE.  It cannot transition between SHARED
1593 ** and EXCLUSIVE.
1594 */
1595 #define SQLCIPHER_SHM_UNLOCK       1
1596 #define SQLCIPHER_SHM_LOCK         2
1597 #define SQLCIPHER_SHM_SHARED       4
1598 #define SQLCIPHER_SHM_EXCLUSIVE    8
1599
1600 /*
1601 ** CAPI3REF: Maximum xShmLock index
1602 **
1603 ** The xShmLock method on [sqlcipher3_io_methods] may use values
1604 ** between 0 and this upper bound as its "offset" argument.
1605 ** The SQLite core will never attempt to acquire or release a
1606 ** lock outside of this range
1607 */
1608 #define SQLCIPHER_SHM_NLOCK        8
1609
1610
1611 /*
1612 ** CAPI3REF: Initialize The SQLite Library
1613 **
1614 ** ^The sqlcipher3_initialize() routine initializes the
1615 ** SQLite library.  ^The sqlcipher3_shutdown() routine
1616 ** deallocates any resources that were allocated by sqlcipher3_initialize().
1617 ** These routines are designed to aid in process initialization and
1618 ** shutdown on embedded systems.  Workstation applications using
1619 ** SQLite normally do not need to invoke either of these routines.
1620 **
1621 ** A call to sqlcipher3_initialize() is an "effective" call if it is
1622 ** the first time sqlcipher3_initialize() is invoked during the lifetime of
1623 ** the process, or if it is the first time sqlcipher3_initialize() is invoked
1624 ** following a call to sqlcipher3_shutdown().  ^(Only an effective call
1625 ** of sqlcipher3_initialize() does any initialization.  All other calls
1626 ** are harmless no-ops.)^
1627 **
1628 ** A call to sqlcipher3_shutdown() is an "effective" call if it is the first
1629 ** call to sqlcipher3_shutdown() since the last sqlcipher3_initialize().  ^(Only
1630 ** an effective call to sqlcipher3_shutdown() does any deinitialization.
1631 ** All other valid calls to sqlcipher3_shutdown() are harmless no-ops.)^
1632 **
1633 ** The sqlcipher3_initialize() interface is threadsafe, but sqlcipher3_shutdown()
1634 ** is not.  The sqlcipher3_shutdown() interface must only be called from a
1635 ** single thread.  All open [database connections] must be closed and all
1636 ** other SQLite resources must be deallocated prior to invoking
1637 ** sqlcipher3_shutdown().
1638 **
1639 ** Among other things, ^sqlcipher3_initialize() will invoke
1640 ** sqlcipher3_os_init().  Similarly, ^sqlcipher3_shutdown()
1641 ** will invoke sqlcipher3_os_end().
1642 **
1643 ** ^The sqlcipher3_initialize() routine returns [SQLCIPHER_OK] on success.
1644 ** ^If for some reason, sqlcipher3_initialize() is unable to initialize
1645 ** the library (perhaps it is unable to allocate a needed resource such
1646 ** as a mutex) it returns an [error code] other than [SQLCIPHER_OK].
1647 **
1648 ** ^The sqlcipher3_initialize() routine is called internally by many other
1649 ** SQLite interfaces so that an application usually does not need to
1650 ** invoke sqlcipher3_initialize() directly.  For example, [sqlcipher3_open()]
1651 ** calls sqlcipher3_initialize() so the SQLite library will be automatically
1652 ** initialized when [sqlcipher3_open()] is called if it has not be initialized
1653 ** already.  ^However, if SQLite is compiled with the [SQLCIPHER_OMIT_AUTOINIT]
1654 ** compile-time option, then the automatic calls to sqlcipher3_initialize()
1655 ** are omitted and the application must call sqlcipher3_initialize() directly
1656 ** prior to using any other SQLite interface.  For maximum portability,
1657 ** it is recommended that applications always invoke sqlcipher3_initialize()
1658 ** directly prior to using any other SQLite interface.  Future releases
1659 ** of SQLite may require this.  In other words, the behavior exhibited
1660 ** when SQLite is compiled with [SQLCIPHER_OMIT_AUTOINIT] might become the
1661 ** default behavior in some future release of SQLite.
1662 **
1663 ** The sqlcipher3_os_init() routine does operating-system specific
1664 ** initialization of the SQLite library.  The sqlcipher3_os_end()
1665 ** routine undoes the effect of sqlcipher3_os_init().  Typical tasks
1666 ** performed by these routines include allocation or deallocation
1667 ** of static resources, initialization of global variables,
1668 ** setting up a default [sqlcipher3_vfs] module, or setting up
1669 ** a default configuration using [sqlcipher3_config()].
1670 **
1671 ** The application should never invoke either sqlcipher3_os_init()
1672 ** or sqlcipher3_os_end() directly.  The application should only invoke
1673 ** sqlcipher3_initialize() and sqlcipher3_shutdown().  The sqlcipher3_os_init()
1674 ** interface is called automatically by sqlcipher3_initialize() and
1675 ** sqlcipher3_os_end() is called by sqlcipher3_shutdown().  Appropriate
1676 ** implementations for sqlcipher3_os_init() and sqlcipher3_os_end()
1677 ** are built into SQLite when it is compiled for Unix, Windows, or OS/2.
1678 ** When [custom builds | built for other platforms]
1679 ** (using the [SQLCIPHER_OS_OTHER=1] compile-time
1680 ** option) the application must supply a suitable implementation for
1681 ** sqlcipher3_os_init() and sqlcipher3_os_end().  An application-supplied
1682 ** implementation of sqlcipher3_os_init() or sqlcipher3_os_end()
1683 ** must return [SQLCIPHER_OK] on success and some other [error code] upon
1684 ** failure.
1685 */
1686 SQLCIPHER_API int sqlcipher3_initialize(void);
1687 SQLCIPHER_API int sqlcipher3_shutdown(void);
1688 SQLCIPHER_API int sqlcipher3_os_init(void);
1689 SQLCIPHER_API int sqlcipher3_os_end(void);
1690
1691 /*
1692 ** CAPI3REF: Configuring The SQLite Library
1693 **
1694 ** The sqlcipher3_config() interface is used to make global configuration
1695 ** changes to SQLite in order to tune SQLite to the specific needs of
1696 ** the application.  The default configuration is recommended for most
1697 ** applications and so this routine is usually not necessary.  It is
1698 ** provided to support rare applications with unusual needs.
1699 **
1700 ** The sqlcipher3_config() interface is not threadsafe.  The application
1701 ** must insure that no other SQLite interfaces are invoked by other
1702 ** threads while sqlcipher3_config() is running.  Furthermore, sqlcipher3_config()
1703 ** may only be invoked prior to library initialization using
1704 ** [sqlcipher3_initialize()] or after shutdown by [sqlcipher3_shutdown()].
1705 ** ^If sqlcipher3_config() is called after [sqlcipher3_initialize()] and before
1706 ** [sqlcipher3_shutdown()] then it will return SQLCIPHER_MISUSE.
1707 ** Note, however, that ^sqlcipher3_config() can be called as part of the
1708 ** implementation of an application-defined [sqlcipher3_os_init()].
1709 **
1710 ** The first argument to sqlcipher3_config() is an integer
1711 ** [configuration option] that determines
1712 ** what property of SQLite is to be configured.  Subsequent arguments
1713 ** vary depending on the [configuration option]
1714 ** in the first argument.
1715 **
1716 ** ^When a configuration option is set, sqlcipher3_config() returns [SQLCIPHER_OK].
1717 ** ^If the option is unknown or SQLite is unable to set the option
1718 ** then this routine returns a non-zero [error code].
1719 */
1720 SQLCIPHER_API int sqlcipher3_config(int, ...);
1721
1722 /*
1723 ** CAPI3REF: Configure database connections
1724 **
1725 ** The sqlcipher3_db_config() interface is used to make configuration
1726 ** changes to a [database connection].  The interface is similar to
1727 ** [sqlcipher3_config()] except that the changes apply to a single
1728 ** [database connection] (specified in the first argument).
1729 **
1730 ** The second argument to sqlcipher3_db_config(D,V,...)  is the
1731 ** [SQLCIPHER_DBCONFIG_LOOKASIDE | configuration verb] - an integer code 
1732 ** that indicates what aspect of the [database connection] is being configured.
1733 ** Subsequent arguments vary depending on the configuration verb.
1734 **
1735 ** ^Calls to sqlcipher3_db_config() return SQLCIPHER_OK if and only if
1736 ** the call is considered successful.
1737 */
1738 SQLCIPHER_API int sqlcipher3_db_config(sqlcipher3*, int op, ...);
1739
1740 /*
1741 ** CAPI3REF: Memory Allocation Routines
1742 **
1743 ** An instance of this object defines the interface between SQLite
1744 ** and low-level memory allocation routines.
1745 **
1746 ** This object is used in only one place in the SQLite interface.
1747 ** A pointer to an instance of this object is the argument to
1748 ** [sqlcipher3_config()] when the configuration option is
1749 ** [SQLCIPHER_CONFIG_MALLOC] or [SQLCIPHER_CONFIG_GETMALLOC].  
1750 ** By creating an instance of this object
1751 ** and passing it to [sqlcipher3_config]([SQLCIPHER_CONFIG_MALLOC])
1752 ** during configuration, an application can specify an alternative
1753 ** memory allocation subsystem for SQLite to use for all of its
1754 ** dynamic memory needs.
1755 **
1756 ** Note that SQLite comes with several [built-in memory allocators]
1757 ** that are perfectly adequate for the overwhelming majority of applications
1758 ** and that this object is only useful to a tiny minority of applications
1759 ** with specialized memory allocation requirements.  This object is
1760 ** also used during testing of SQLite in order to specify an alternative
1761 ** memory allocator that simulates memory out-of-memory conditions in
1762 ** order to verify that SQLite recovers gracefully from such
1763 ** conditions.
1764 **
1765 ** The xMalloc, xRealloc, and xFree methods must work like the
1766 ** malloc(), realloc() and free() functions from the standard C library.
1767 ** ^SQLite guarantees that the second argument to
1768 ** xRealloc is always a value returned by a prior call to xRoundup.
1769 **
1770 ** xSize should return the allocated size of a memory allocation
1771 ** previously obtained from xMalloc or xRealloc.  The allocated size
1772 ** is always at least as big as the requested size but may be larger.
1773 **
1774 ** The xRoundup method returns what would be the allocated size of
1775 ** a memory allocation given a particular requested size.  Most memory
1776 ** allocators round up memory allocations at least to the next multiple
1777 ** of 8.  Some allocators round up to a larger multiple or to a power of 2.
1778 ** Every memory allocation request coming in through [sqlcipher3_malloc()]
1779 ** or [sqlcipher3_realloc()] first calls xRoundup.  If xRoundup returns 0, 
1780 ** that causes the corresponding memory allocation to fail.
1781 **
1782 ** The xInit method initializes the memory allocator.  (For example,
1783 ** it might allocate any require mutexes or initialize internal data
1784 ** structures.  The xShutdown method is invoked (indirectly) by
1785 ** [sqlcipher3_shutdown()] and should deallocate any resources acquired
1786 ** by xInit.  The pAppData pointer is used as the only parameter to
1787 ** xInit and xShutdown.
1788 **
1789 ** SQLite holds the [SQLCIPHER_MUTEX_STATIC_MASTER] mutex when it invokes
1790 ** the xInit method, so the xInit method need not be threadsafe.  The
1791 ** xShutdown method is only called from [sqlcipher3_shutdown()] so it does
1792 ** not need to be threadsafe either.  For all other methods, SQLite
1793 ** holds the [SQLCIPHER_MUTEX_STATIC_MEM] mutex as long as the
1794 ** [SQLCIPHER_CONFIG_MEMSTATUS] configuration option is turned on (which
1795 ** it is by default) and so the methods are automatically serialized.
1796 ** However, if [SQLCIPHER_CONFIG_MEMSTATUS] is disabled, then the other
1797 ** methods must be threadsafe or else make their own arrangements for
1798 ** serialization.
1799 **
1800 ** SQLite will never invoke xInit() more than once without an intervening
1801 ** call to xShutdown().
1802 */
1803 typedef struct sqlcipher3_mem_methods sqlcipher3_mem_methods;
1804 struct sqlcipher3_mem_methods {
1805   void *(*xMalloc)(int);         /* Memory allocation function */
1806   void (*xFree)(void*);          /* Free a prior allocation */
1807   void *(*xRealloc)(void*,int);  /* Resize an allocation */
1808   int (*xSize)(void*);           /* Return the size of an allocation */
1809   int (*xRoundup)(int);          /* Round up request size to allocation size */
1810   int (*xInit)(void*);           /* Initialize the memory allocator */
1811   void (*xShutdown)(void*);      /* Deinitialize the memory allocator */
1812   void *pAppData;                /* Argument to xInit() and xShutdown() */
1813 };
1814
1815 /*
1816 ** CAPI3REF: Configuration Options
1817 ** KEYWORDS: {configuration option}
1818 **
1819 ** These constants are the available integer configuration options that
1820 ** can be passed as the first argument to the [sqlcipher3_config()] interface.
1821 **
1822 ** New configuration options may be added in future releases of SQLite.
1823 ** Existing configuration options might be discontinued.  Applications
1824 ** should check the return code from [sqlcipher3_config()] to make sure that
1825 ** the call worked.  The [sqlcipher3_config()] interface will return a
1826 ** non-zero [error code] if a discontinued or unsupported configuration option
1827 ** is invoked.
1828 **
1829 ** <dl>
1830 ** [[SQLCIPHER_CONFIG_SINGLETHREAD]] <dt>SQLCIPHER_CONFIG_SINGLETHREAD</dt>
1831 ** <dd>There are no arguments to this option.  ^This option sets the
1832 ** [threading mode] to Single-thread.  In other words, it disables
1833 ** all mutexing and puts SQLite into a mode where it can only be used
1834 ** by a single thread.   ^If SQLite is compiled with
1835 ** the [SQLCIPHER_THREADSAFE | SQLCIPHER_THREADSAFE=0] compile-time option then
1836 ** it is not possible to change the [threading mode] from its default
1837 ** value of Single-thread and so [sqlcipher3_config()] will return 
1838 ** [SQLCIPHER_ERROR] if called with the SQLCIPHER_CONFIG_SINGLETHREAD
1839 ** configuration option.</dd>
1840 **
1841 ** [[SQLCIPHER_CONFIG_MULTITHREAD]] <dt>SQLCIPHER_CONFIG_MULTITHREAD</dt>
1842 ** <dd>There are no arguments to this option.  ^This option sets the
1843 ** [threading mode] to Multi-thread.  In other words, it disables
1844 ** mutexing on [database connection] and [prepared statement] objects.
1845 ** The application is responsible for serializing access to
1846 ** [database connections] and [prepared statements].  But other mutexes
1847 ** are enabled so that SQLite will be safe to use in a multi-threaded
1848 ** environment as long as no two threads attempt to use the same
1849 ** [database connection] at the same time.  ^If SQLite is compiled with
1850 ** the [SQLCIPHER_THREADSAFE | SQLCIPHER_THREADSAFE=0] compile-time option then
1851 ** it is not possible to set the Multi-thread [threading mode] and
1852 ** [sqlcipher3_config()] will return [SQLCIPHER_ERROR] if called with the
1853 ** SQLCIPHER_CONFIG_MULTITHREAD configuration option.</dd>
1854 **
1855 ** [[SQLCIPHER_CONFIG_SERIALIZED]] <dt>SQLCIPHER_CONFIG_SERIALIZED</dt>
1856 ** <dd>There are no arguments to this option.  ^This option sets the
1857 ** [threading mode] to Serialized. In other words, this option enables
1858 ** all mutexes including the recursive
1859 ** mutexes on [database connection] and [prepared statement] objects.
1860 ** In this mode (which is the default when SQLite is compiled with
1861 ** [SQLCIPHER_THREADSAFE=1]) the SQLite library will itself serialize access
1862 ** to [database connections] and [prepared statements] so that the
1863 ** application is free to use the same [database connection] or the
1864 ** same [prepared statement] in different threads at the same time.
1865 ** ^If SQLite is compiled with
1866 ** the [SQLCIPHER_THREADSAFE | SQLCIPHER_THREADSAFE=0] compile-time option then
1867 ** it is not possible to set the Serialized [threading mode] and
1868 ** [sqlcipher3_config()] will return [SQLCIPHER_ERROR] if called with the
1869 ** SQLCIPHER_CONFIG_SERIALIZED configuration option.</dd>
1870 **
1871 ** [[SQLCIPHER_CONFIG_MALLOC]] <dt>SQLCIPHER_CONFIG_MALLOC</dt>
1872 ** <dd> ^(This option takes a single argument which is a pointer to an
1873 ** instance of the [sqlcipher3_mem_methods] structure.  The argument specifies
1874 ** alternative low-level memory allocation routines to be used in place of
1875 ** the memory allocation routines built into SQLite.)^ ^SQLite makes
1876 ** its own private copy of the content of the [sqlcipher3_mem_methods] structure
1877 ** before the [sqlcipher3_config()] call returns.</dd>
1878 **
1879 ** [[SQLCIPHER_CONFIG_GETMALLOC]] <dt>SQLCIPHER_CONFIG_GETMALLOC</dt>
1880 ** <dd> ^(This option takes a single argument which is a pointer to an
1881 ** instance of the [sqlcipher3_mem_methods] structure.  The [sqlcipher3_mem_methods]
1882 ** structure is filled with the currently defined memory allocation routines.)^
1883 ** This option can be used to overload the default memory allocation
1884 ** routines with a wrapper that simulations memory allocation failure or
1885 ** tracks memory usage, for example. </dd>
1886 **
1887 ** [[SQLCIPHER_CONFIG_MEMSTATUS]] <dt>SQLCIPHER_CONFIG_MEMSTATUS</dt>
1888 ** <dd> ^This option takes single argument of type int, interpreted as a 
1889 ** boolean, which enables or disables the collection of memory allocation 
1890 ** statistics. ^(When memory allocation statistics are disabled, the 
1891 ** following SQLite interfaces become non-operational:
1892 **   <ul>
1893 **   <li> [sqlcipher3_memory_used()]
1894 **   <li> [sqlcipher3_memory_highwater()]
1895 **   <li> [sqlcipher3_soft_heap_limit64()]
1896 **   <li> [sqlcipher3_status()]
1897 **   </ul>)^
1898 ** ^Memory allocation statistics are enabled by default unless SQLite is
1899 ** compiled with [SQLCIPHER_DEFAULT_MEMSTATUS]=0 in which case memory
1900 ** allocation statistics are disabled by default.
1901 ** </dd>
1902 **
1903 ** [[SQLCIPHER_CONFIG_SCRATCH]] <dt>SQLCIPHER_CONFIG_SCRATCH</dt>
1904 ** <dd> ^This option specifies a static memory buffer that SQLite can use for
1905 ** scratch memory.  There are three arguments:  A pointer an 8-byte
1906 ** aligned memory buffer from which the scratch allocations will be
1907 ** drawn, the size of each scratch allocation (sz),
1908 ** and the maximum number of scratch allocations (N).  The sz
1909 ** argument must be a multiple of 16.
1910 ** The first argument must be a pointer to an 8-byte aligned buffer
1911 ** of at least sz*N bytes of memory.
1912 ** ^SQLite will use no more than two scratch buffers per thread.  So
1913 ** N should be set to twice the expected maximum number of threads.
1914 ** ^SQLite will never require a scratch buffer that is more than 6
1915 ** times the database page size. ^If SQLite needs needs additional
1916 ** scratch memory beyond what is provided by this configuration option, then 
1917 ** [sqlcipher3_malloc()] will be used to obtain the memory needed.</dd>
1918 **
1919 ** [[SQLCIPHER_CONFIG_PAGECACHE]] <dt>SQLCIPHER_CONFIG_PAGECACHE</dt>
1920 ** <dd> ^This option specifies a static memory buffer that SQLite can use for
1921 ** the database page cache with the default page cache implementation.  
1922 ** This configuration should not be used if an application-define page
1923 ** cache implementation is loaded using the SQLCIPHER_CONFIG_PCACHE option.
1924 ** There are three arguments to this option: A pointer to 8-byte aligned
1925 ** memory, the size of each page buffer (sz), and the number of pages (N).
1926 ** The sz argument should be the size of the largest database page
1927 ** (a power of two between 512 and 32768) plus a little extra for each
1928 ** page header.  ^The page header size is 20 to 40 bytes depending on
1929 ** the host architecture.  ^It is harmless, apart from the wasted memory,
1930 ** to make sz a little too large.  The first
1931 ** argument should point to an allocation of at least sz*N bytes of memory.
1932 ** ^SQLite will use the memory provided by the first argument to satisfy its
1933 ** memory needs for the first N pages that it adds to cache.  ^If additional
1934 ** page cache memory is needed beyond what is provided by this option, then
1935 ** SQLite goes to [sqlcipher3_malloc()] for the additional storage space.
1936 ** The pointer in the first argument must
1937 ** be aligned to an 8-byte boundary or subsequent behavior of SQLite
1938 ** will be undefined.</dd>
1939 **
1940 ** [[SQLCIPHER_CONFIG_HEAP]] <dt>SQLCIPHER_CONFIG_HEAP</dt>
1941 ** <dd> ^This option specifies a static memory buffer that SQLite will use
1942 ** for all of its dynamic memory allocation needs beyond those provided
1943 ** for by [SQLCIPHER_CONFIG_SCRATCH] and [SQLCIPHER_CONFIG_PAGECACHE].
1944 ** There are three arguments: An 8-byte aligned pointer to the memory,
1945 ** the number of bytes in the memory buffer, and the minimum allocation size.
1946 ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
1947 ** to using its default memory allocator (the system malloc() implementation),
1948 ** undoing any prior invocation of [SQLCIPHER_CONFIG_MALLOC].  ^If the
1949 ** memory pointer is not NULL and either [SQLCIPHER_ENABLE_MEMSYS3] or
1950 ** [SQLCIPHER_ENABLE_MEMSYS5] are defined, then the alternative memory
1951 ** allocator is engaged to handle all of SQLites memory allocation needs.
1952 ** The first pointer (the memory pointer) must be aligned to an 8-byte
1953 ** boundary or subsequent behavior of SQLite will be undefined.
1954 ** The minimum allocation size is capped at 2**12. Reasonable values
1955 ** for the minimum allocation size are 2**5 through 2**8.</dd>
1956 **
1957 ** [[SQLCIPHER_CONFIG_MUTEX]] <dt>SQLCIPHER_CONFIG_MUTEX</dt>
1958 ** <dd> ^(This option takes a single argument which is a pointer to an
1959 ** instance of the [sqlcipher3_mutex_methods] structure.  The argument specifies
1960 ** alternative low-level mutex routines to be used in place
1961 ** the mutex routines built into SQLite.)^  ^SQLite makes a copy of the
1962 ** content of the [sqlcipher3_mutex_methods] structure before the call to
1963 ** [sqlcipher3_config()] returns. ^If SQLite is compiled with
1964 ** the [SQLCIPHER_THREADSAFE | SQLCIPHER_THREADSAFE=0] compile-time option then
1965 ** the entire mutexing subsystem is omitted from the build and hence calls to
1966 ** [sqlcipher3_config()] with the SQLCIPHER_CONFIG_MUTEX configuration option will
1967 ** return [SQLCIPHER_ERROR].</dd>
1968 **
1969 ** [[SQLCIPHER_CONFIG_GETMUTEX]] <dt>SQLCIPHER_CONFIG_GETMUTEX</dt>
1970 ** <dd> ^(This option takes a single argument which is a pointer to an
1971 ** instance of the [sqlcipher3_mutex_methods] structure.  The
1972 ** [sqlcipher3_mutex_methods]
1973 ** structure is filled with the currently defined mutex routines.)^
1974 ** This option can be used to overload the default mutex allocation
1975 ** routines with a wrapper used to track mutex usage for performance
1976 ** profiling or testing, for example.   ^If SQLite is compiled with
1977 ** the [SQLCIPHER_THREADSAFE | SQLCIPHER_THREADSAFE=0] compile-time option then
1978 ** the entire mutexing subsystem is omitted from the build and hence calls to
1979 ** [sqlcipher3_config()] with the SQLCIPHER_CONFIG_GETMUTEX configuration option will
1980 ** return [SQLCIPHER_ERROR].</dd>
1981 **
1982 ** [[SQLCIPHER_CONFIG_LOOKASIDE]] <dt>SQLCIPHER_CONFIG_LOOKASIDE</dt>
1983 ** <dd> ^(This option takes two arguments that determine the default
1984 ** memory allocation for the lookaside memory allocator on each
1985 ** [database connection].  The first argument is the
1986 ** size of each lookaside buffer slot and the second is the number of
1987 ** slots allocated to each database connection.)^  ^(This option sets the
1988 ** <i>default</i> lookaside size. The [SQLCIPHER_DBCONFIG_LOOKASIDE]
1989 ** verb to [sqlcipher3_db_config()] can be used to change the lookaside
1990 ** configuration on individual connections.)^ </dd>
1991 **
1992 ** [[SQLCIPHER_CONFIG_PCACHE]] <dt>SQLCIPHER_CONFIG_PCACHE</dt>
1993 ** <dd> ^(This option takes a single argument which is a pointer to
1994 ** an [sqlcipher3_pcache_methods] object.  This object specifies the interface
1995 ** to a custom page cache implementation.)^  ^SQLite makes a copy of the
1996 ** object and uses it for page cache memory allocations.</dd>
1997 **
1998 ** [[SQLCIPHER_CONFIG_GETPCACHE]] <dt>SQLCIPHER_CONFIG_GETPCACHE</dt>
1999 ** <dd> ^(This option takes a single argument which is a pointer to an
2000 ** [sqlcipher3_pcache_methods] object.  SQLite copies of the current
2001 ** page cache implementation into that object.)^ </dd>
2002 **
2003 ** [[SQLCIPHER_CONFIG_LOG]] <dt>SQLCIPHER_CONFIG_LOG</dt>
2004 ** <dd> ^The SQLCIPHER_CONFIG_LOG option takes two arguments: a pointer to a
2005 ** function with a call signature of void(*)(void*,int,const char*), 
2006 ** and a pointer to void. ^If the function pointer is not NULL, it is
2007 ** invoked by [sqlcipher3_log()] to process each logging event.  ^If the
2008 ** function pointer is NULL, the [sqlcipher3_log()] interface becomes a no-op.
2009 ** ^The void pointer that is the second argument to SQLCIPHER_CONFIG_LOG is
2010 ** passed through as the first parameter to the application-defined logger
2011 ** function whenever that function is invoked.  ^The second parameter to
2012 ** the logger function is a copy of the first parameter to the corresponding
2013 ** [sqlcipher3_log()] call and is intended to be a [result code] or an
2014 ** [extended result code].  ^The third parameter passed to the logger is
2015 ** log message after formatting via [sqlcipher3_snprintf()].
2016 ** The SQLite logging interface is not reentrant; the logger function
2017 ** supplied by the application must not invoke any SQLite interface.
2018 ** In a multi-threaded application, the application-defined logger
2019 ** function must be threadsafe. </dd>
2020 **
2021 ** [[SQLCIPHER_CONFIG_URI]] <dt>SQLCIPHER_CONFIG_URI
2022 ** <dd> This option takes a single argument of type int. If non-zero, then
2023 ** URI handling is globally enabled. If the parameter is zero, then URI handling
2024 ** is globally disabled. If URI handling is globally enabled, all filenames
2025 ** passed to [sqlcipher3_open()], [sqlcipher3_open_v2()], [sqlcipher3_open16()] or
2026 ** specified as part of [ATTACH] commands are interpreted as URIs, regardless
2027 ** of whether or not the [SQLCIPHER_OPEN_URI] flag is set when the database
2028 ** connection is opened. If it is globally disabled, filenames are
2029 ** only interpreted as URIs if the SQLCIPHER_OPEN_URI flag is set when the
2030 ** database connection is opened. By default, URI handling is globally
2031 ** disabled. The default value may be changed by compiling with the
2032 ** [SQLCIPHER_USE_URI] symbol defined.
2033 ** </dl>
2034 */
2035 #define SQLCIPHER_CONFIG_SINGLETHREAD  1  /* nil */
2036 #define SQLCIPHER_CONFIG_MULTITHREAD   2  /* nil */
2037 #define SQLCIPHER_CONFIG_SERIALIZED    3  /* nil */
2038 #define SQLCIPHER_CONFIG_MALLOC        4  /* sqlcipher3_mem_methods* */
2039 #define SQLCIPHER_CONFIG_GETMALLOC     5  /* sqlcipher3_mem_methods* */
2040 #define SQLCIPHER_CONFIG_SCRATCH       6  /* void*, int sz, int N */
2041 #define SQLCIPHER_CONFIG_PAGECACHE     7  /* void*, int sz, int N */
2042 #define SQLCIPHER_CONFIG_HEAP          8  /* void*, int nByte, int min */
2043 #define SQLCIPHER_CONFIG_MEMSTATUS     9  /* boolean */
2044 #define SQLCIPHER_CONFIG_MUTEX        10  /* sqlcipher3_mutex_methods* */
2045 #define SQLCIPHER_CONFIG_GETMUTEX     11  /* sqlcipher3_mutex_methods* */
2046 /* previously SQLCIPHER_CONFIG_CHUNKALLOC 12 which is now unused. */ 
2047 #define SQLCIPHER_CONFIG_LOOKASIDE    13  /* int int */
2048 #define SQLCIPHER_CONFIG_PCACHE       14  /* sqlcipher3_pcache_methods* */
2049 #define SQLCIPHER_CONFIG_GETPCACHE    15  /* sqlcipher3_pcache_methods* */
2050 #define SQLCIPHER_CONFIG_LOG          16  /* xFunc, void* */
2051 #define SQLCIPHER_CONFIG_URI          17  /* int */
2052
2053 /*
2054 ** CAPI3REF: Database Connection Configuration Options
2055 **
2056 ** These constants are the available integer configuration options that
2057 ** can be passed as the second argument to the [sqlcipher3_db_config()] interface.
2058 **
2059 ** New configuration options may be added in future releases of SQLite.
2060 ** Existing configuration options might be discontinued.  Applications
2061 ** should check the return code from [sqlcipher3_db_config()] to make sure that
2062 ** the call worked.  ^The [sqlcipher3_db_config()] interface will return a
2063 ** non-zero [error code] if a discontinued or unsupported configuration option
2064 ** is invoked.
2065 **
2066 ** <dl>
2067 ** <dt>SQLCIPHER_DBCONFIG_LOOKASIDE</dt>
2068 ** <dd> ^This option takes three additional arguments that determine the 
2069 ** [lookaside memory allocator] configuration for the [database connection].
2070 ** ^The first argument (the third parameter to [sqlcipher3_db_config()] is a
2071 ** pointer to a memory buffer to use for lookaside memory.
2072 ** ^The first argument after the SQLCIPHER_DBCONFIG_LOOKASIDE verb
2073 ** may be NULL in which case SQLite will allocate the
2074 ** lookaside buffer itself using [sqlcipher3_malloc()]. ^The second argument is the
2075 ** size of each lookaside buffer slot.  ^The third argument is the number of
2076 ** slots.  The size of the buffer in the first argument must be greater than
2077 ** or equal to the product of the second and third arguments.  The buffer
2078 ** must be aligned to an 8-byte boundary.  ^If the second argument to
2079 ** SQLCIPHER_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
2080 ** rounded down to the next smaller multiple of 8.  ^(The lookaside memory
2081 ** configuration for a database connection can only be changed when that
2082 ** connection is not currently using lookaside memory, or in other words
2083 ** when the "current value" returned by
2084 ** [sqlcipher3_db_status](D,[SQLCIPHER_CONFIG_LOOKASIDE],...) is zero.
2085 ** Any attempt to change the lookaside memory configuration when lookaside
2086 ** memory is in use leaves the configuration unchanged and returns 
2087 ** [SQLCIPHER_BUSY].)^</dd>
2088 **
2089 ** <dt>SQLCIPHER_DBCONFIG_ENABLE_FKEY</dt>
2090 ** <dd> ^This option is used to enable or disable the enforcement of
2091 ** [foreign key constraints].  There should be two additional arguments.
2092 ** The first argument is an integer which is 0 to disable FK enforcement,
2093 ** positive to enable FK enforcement or negative to leave FK enforcement
2094 ** unchanged.  The second parameter is a pointer to an integer into which
2095 ** is written 0 or 1 to indicate whether FK enforcement is off or on
2096 ** following this call.  The second parameter may be a NULL pointer, in
2097 ** which case the FK enforcement setting is not reported back. </dd>
2098 **
2099 ** <dt>SQLCIPHER_DBCONFIG_ENABLE_TRIGGER</dt>
2100 ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
2101 ** There should be two additional arguments.
2102 ** The first argument is an integer which is 0 to disable triggers,
2103 ** positive to enable triggers or negative to leave the setting unchanged.
2104 ** The second parameter is a pointer to an integer into which
2105 ** is written 0 or 1 to indicate whether triggers are disabled or enabled
2106 ** following this call.  The second parameter may be a NULL pointer, in
2107 ** which case the trigger setting is not reported back. </dd>
2108 **
2109 ** </dl>
2110 */
2111 #define SQLCIPHER_DBCONFIG_LOOKASIDE       1001  /* void* int int */
2112 #define SQLCIPHER_DBCONFIG_ENABLE_FKEY     1002  /* int int* */
2113 #define SQLCIPHER_DBCONFIG_ENABLE_TRIGGER  1003  /* int int* */
2114
2115
2116 /*
2117 ** CAPI3REF: Enable Or Disable Extended Result Codes
2118 **
2119 ** ^The sqlcipher3_extended_result_codes() routine enables or disables the
2120 ** [extended result codes] feature of SQLite. ^The extended result
2121 ** codes are disabled by default for historical compatibility.
2122 */
2123 SQLCIPHER_API int sqlcipher3_extended_result_codes(sqlcipher3*, int onoff);
2124
2125 /*
2126 ** CAPI3REF: Last Insert Rowid
2127 **
2128 ** ^Each entry in an SQLite table has a unique 64-bit signed
2129 ** integer key called the [ROWID | "rowid"]. ^The rowid is always available
2130 ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2131 ** names are not also used by explicitly declared columns. ^If
2132 ** the table has a column of type [INTEGER PRIMARY KEY] then that column
2133 ** is another alias for the rowid.
2134 **
2135 ** ^This routine returns the [rowid] of the most recent
2136 ** successful [INSERT] into the database from the [database connection]
2137 ** in the first argument.  ^As of SQLite version 3.7.7, this routines
2138 ** records the last insert rowid of both ordinary tables and [virtual tables].
2139 ** ^If no successful [INSERT]s
2140 ** have ever occurred on that database connection, zero is returned.
2141 **
2142 ** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
2143 ** method, then this routine will return the [rowid] of the inserted
2144 ** row as long as the trigger or virtual table method is running.
2145 ** But once the trigger or virtual table method ends, the value returned 
2146 ** by this routine reverts to what it was before the trigger or virtual
2147 ** table method began.)^
2148 **
2149 ** ^An [INSERT] that fails due to a constraint violation is not a
2150 ** successful [INSERT] and does not change the value returned by this
2151 ** routine.  ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2152 ** and INSERT OR ABORT make no changes to the return value of this
2153 ** routine when their insertion fails.  ^(When INSERT OR REPLACE
2154 ** encounters a constraint violation, it does not fail.  The
2155 ** INSERT continues to completion after deleting rows that caused
2156 ** the constraint problem so INSERT OR REPLACE will always change
2157 ** the return value of this interface.)^
2158 **
2159 ** ^For the purposes of this routine, an [INSERT] is considered to
2160 ** be successful even if it is subsequently rolled back.
2161 **
2162 ** This function is accessible to SQL statements via the
2163 ** [last_insert_rowid() SQL function].
2164 **
2165 ** If a separate thread performs a new [INSERT] on the same
2166 ** database connection while the [sqlcipher3_last_insert_rowid()]
2167 ** function is running and thus changes the last insert [rowid],
2168 ** then the value returned by [sqlcipher3_last_insert_rowid()] is
2169 ** unpredictable and might not equal either the old or the new
2170 ** last insert [rowid].
2171 */
2172 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_last_insert_rowid(sqlcipher3*);
2173
2174 /*
2175 ** CAPI3REF: Count The Number Of Rows Modified
2176 **
2177 ** ^This function returns the number of database rows that were changed
2178 ** or inserted or deleted by the most recently completed SQL statement
2179 ** on the [database connection] specified by the first parameter.
2180 ** ^(Only changes that are directly specified by the [INSERT], [UPDATE],
2181 ** or [DELETE] statement are counted.  Auxiliary changes caused by
2182 ** triggers or [foreign key actions] are not counted.)^ Use the
2183 ** [sqlcipher3_total_changes()] function to find the total number of changes
2184 ** including changes caused by triggers and foreign key actions.
2185 **
2186 ** ^Changes to a view that are simulated by an [INSTEAD OF trigger]
2187 ** are not counted.  Only real table changes are counted.
2188 **
2189 ** ^(A "row change" is a change to a single row of a single table
2190 ** caused by an INSERT, DELETE, or UPDATE statement.  Rows that
2191 ** are changed as side effects of [REPLACE] constraint resolution,
2192 ** rollback, ABORT processing, [DROP TABLE], or by any other
2193 ** mechanisms do not count as direct row changes.)^
2194 **
2195 ** A "trigger context" is a scope of execution that begins and
2196 ** ends with the script of a [CREATE TRIGGER | trigger]. 
2197 ** Most SQL statements are
2198 ** evaluated outside of any trigger.  This is the "top level"
2199 ** trigger context.  If a trigger fires from the top level, a
2200 ** new trigger context is entered for the duration of that one
2201 ** trigger.  Subtriggers create subcontexts for their duration.
2202 **
2203 ** ^Calling [sqlcipher3_exec()] or [sqlcipher3_step()] recursively does
2204 ** not create a new trigger context.
2205 **
2206 ** ^This function returns the number of direct row changes in the
2207 ** most recent INSERT, UPDATE, or DELETE statement within the same
2208 ** trigger context.
2209 **
2210 ** ^Thus, when called from the top level, this function returns the
2211 ** number of changes in the most recent INSERT, UPDATE, or DELETE
2212 ** that also occurred at the top level.  ^(Within the body of a trigger,
2213 ** the sqlcipher3_changes() interface can be called to find the number of
2214 ** changes in the most recently completed INSERT, UPDATE, or DELETE
2215 ** statement within the body of the same trigger.
2216 ** However, the number returned does not include changes
2217 ** caused by subtriggers since those have their own context.)^
2218 **
2219 ** See also the [sqlcipher3_total_changes()] interface, the
2220 ** [count_changes pragma], and the [changes() SQL function].
2221 **
2222 ** If a separate thread makes changes on the same database connection
2223 ** while [sqlcipher3_changes()] is running then the value returned
2224 ** is unpredictable and not meaningful.
2225 */
2226 SQLCIPHER_API int sqlcipher3_changes(sqlcipher3*);
2227
2228 /*
2229 ** CAPI3REF: Total Number Of Rows Modified
2230 **
2231 ** ^This function returns the number of row changes caused by [INSERT],
2232 ** [UPDATE] or [DELETE] statements since the [database connection] was opened.
2233 ** ^(The count returned by sqlcipher3_total_changes() includes all changes
2234 ** from all [CREATE TRIGGER | trigger] contexts and changes made by
2235 ** [foreign key actions]. However,
2236 ** the count does not include changes used to implement [REPLACE] constraints,
2237 ** do rollbacks or ABORT processing, or [DROP TABLE] processing.  The
2238 ** count does not include rows of views that fire an [INSTEAD OF trigger],
2239 ** though if the INSTEAD OF trigger makes changes of its own, those changes 
2240 ** are counted.)^
2241 ** ^The sqlcipher3_total_changes() function counts the changes as soon as
2242 ** the statement that makes them is completed (when the statement handle
2243 ** is passed to [sqlcipher3_reset()] or [sqlcipher3_finalize()]).
2244 **
2245 ** See also the [sqlcipher3_changes()] interface, the
2246 ** [count_changes pragma], and the [total_changes() SQL function].
2247 **
2248 ** If a separate thread makes changes on the same database connection
2249 ** while [sqlcipher3_total_changes()] is running then the value
2250 ** returned is unpredictable and not meaningful.
2251 */
2252 SQLCIPHER_API int sqlcipher3_total_changes(sqlcipher3*);
2253
2254 /*
2255 ** CAPI3REF: Interrupt A Long-Running Query
2256 **
2257 ** ^This function causes any pending database operation to abort and
2258 ** return at its earliest opportunity. This routine is typically
2259 ** called in response to a user action such as pressing "Cancel"
2260 ** or Ctrl-C where the user wants a long query operation to halt
2261 ** immediately.
2262 **
2263 ** ^It is safe to call this routine from a thread different from the
2264 ** thread that is currently running the database operation.  But it
2265 ** is not safe to call this routine with a [database connection] that
2266 ** is closed or might close before sqlcipher3_interrupt() returns.
2267 **
2268 ** ^If an SQL operation is very nearly finished at the time when
2269 ** sqlcipher3_interrupt() is called, then it might not have an opportunity
2270 ** to be interrupted and might continue to completion.
2271 **
2272 ** ^An SQL operation that is interrupted will return [SQLCIPHER_INTERRUPT].
2273 ** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
2274 ** that is inside an explicit transaction, then the entire transaction
2275 ** will be rolled back automatically.
2276 **
2277 ** ^The sqlcipher3_interrupt(D) call is in effect until all currently running
2278 ** SQL statements on [database connection] D complete.  ^Any new SQL statements
2279 ** that are started after the sqlcipher3_interrupt() call and before the 
2280 ** running statements reaches zero are interrupted as if they had been
2281 ** running prior to the sqlcipher3_interrupt() call.  ^New SQL statements
2282 ** that are started after the running statement count reaches zero are
2283 ** not effected by the sqlcipher3_interrupt().
2284 ** ^A call to sqlcipher3_interrupt(D) that occurs when there are no running
2285 ** SQL statements is a no-op and has no effect on SQL statements
2286 ** that are started after the sqlcipher3_interrupt() call returns.
2287 **
2288 ** If the database connection closes while [sqlcipher3_interrupt()]
2289 ** is running then bad things will likely happen.
2290 */
2291 SQLCIPHER_API void sqlcipher3_interrupt(sqlcipher3*);
2292
2293 /*
2294 ** CAPI3REF: Determine If An SQL Statement Is Complete
2295 **
2296 ** These routines are useful during command-line input to determine if the
2297 ** currently entered text seems to form a complete SQL statement or
2298 ** if additional input is needed before sending the text into
2299 ** SQLite for parsing.  ^These routines return 1 if the input string
2300 ** appears to be a complete SQL statement.  ^A statement is judged to be
2301 ** complete if it ends with a semicolon token and is not a prefix of a
2302 ** well-formed CREATE TRIGGER statement.  ^Semicolons that are embedded within
2303 ** string literals or quoted identifier names or comments are not
2304 ** independent tokens (they are part of the token in which they are
2305 ** embedded) and thus do not count as a statement terminator.  ^Whitespace
2306 ** and comments that follow the final semicolon are ignored.
2307 **
2308 ** ^These routines return 0 if the statement is incomplete.  ^If a
2309 ** memory allocation fails, then SQLCIPHER_NOMEM is returned.
2310 **
2311 ** ^These routines do not parse the SQL statements thus
2312 ** will not detect syntactically incorrect SQL.
2313 **
2314 ** ^(If SQLite has not been initialized using [sqlcipher3_initialize()] prior 
2315 ** to invoking sqlcipher3_complete16() then sqlcipher3_initialize() is invoked
2316 ** automatically by sqlcipher3_complete16().  If that initialization fails,
2317 ** then the return value from sqlcipher3_complete16() will be non-zero
2318 ** regardless of whether or not the input SQL is complete.)^
2319 **
2320 ** The input to [sqlcipher3_complete()] must be a zero-terminated
2321 ** UTF-8 string.
2322 **
2323 ** The input to [sqlcipher3_complete16()] must be a zero-terminated
2324 ** UTF-16 string in native byte order.
2325 */
2326 SQLCIPHER_API int sqlcipher3_complete(const char *sql);
2327 SQLCIPHER_API int sqlcipher3_complete16(const void *sql);
2328
2329 /*
2330 ** CAPI3REF: Register A Callback To Handle SQLCIPHER_BUSY Errors
2331 **
2332 ** ^This routine sets a callback function that might be invoked whenever
2333 ** an attempt is made to open a database table that another thread
2334 ** or process has locked.
2335 **
2336 ** ^If the busy callback is NULL, then [SQLCIPHER_BUSY] or [SQLCIPHER_IOERR_BLOCKED]
2337 ** is returned immediately upon encountering the lock.  ^If the busy callback
2338 ** is not NULL, then the callback might be invoked with two arguments.
2339 **
2340 ** ^The first argument to the busy handler is a copy of the void* pointer which
2341 ** is the third argument to sqlcipher3_busy_handler().  ^The second argument to
2342 ** the busy handler callback is the number of times that the busy handler has
2343 ** been invoked for this locking event.  ^If the
2344 ** busy callback returns 0, then no additional attempts are made to
2345 ** access the database and [SQLCIPHER_BUSY] or [SQLCIPHER_IOERR_BLOCKED] is returned.
2346 ** ^If the callback returns non-zero, then another attempt
2347 ** is made to open the database for reading and the cycle repeats.
2348 **
2349 ** The presence of a busy handler does not guarantee that it will be invoked
2350 ** when there is lock contention. ^If SQLite determines that invoking the busy
2351 ** handler could result in a deadlock, it will go ahead and return [SQLCIPHER_BUSY]
2352 ** or [SQLCIPHER_IOERR_BLOCKED] instead of invoking the busy handler.
2353 ** Consider a scenario where one process is holding a read lock that
2354 ** it is trying to promote to a reserved lock and
2355 ** a second process is holding a reserved lock that it is trying
2356 ** to promote to an exclusive lock.  The first process cannot proceed
2357 ** because it is blocked by the second and the second process cannot
2358 ** proceed because it is blocked by the first.  If both processes
2359 ** invoke the busy handlers, neither will make any progress.  Therefore,
2360 ** SQLite returns [SQLCIPHER_BUSY] for the first process, hoping that this
2361 ** will induce the first process to release its read lock and allow
2362 ** the second process to proceed.
2363 **
2364 ** ^The default busy callback is NULL.
2365 **
2366 ** ^The [SQLCIPHER_BUSY] error is converted to [SQLCIPHER_IOERR_BLOCKED]
2367 ** when SQLite is in the middle of a large transaction where all the
2368 ** changes will not fit into the in-memory cache.  SQLite will
2369 ** already hold a RESERVED lock on the database file, but it needs
2370 ** to promote this lock to EXCLUSIVE so that it can spill cache
2371 ** pages into the database file without harm to concurrent
2372 ** readers.  ^If it is unable to promote the lock, then the in-memory
2373 ** cache will be left in an inconsistent state and so the error
2374 ** code is promoted from the relatively benign [SQLCIPHER_BUSY] to
2375 ** the more severe [SQLCIPHER_IOERR_BLOCKED].  ^This error code promotion
2376 ** forces an automatic rollback of the changes.  See the
2377 ** <a href="/cvstrac/wiki?p=CorruptionFollowingBusyError">
2378 ** CorruptionFollowingBusyError</a> wiki page for a discussion of why
2379 ** this is important.
2380 **
2381 ** ^(There can only be a single busy handler defined for each
2382 ** [database connection].  Setting a new busy handler clears any
2383 ** previously set handler.)^  ^Note that calling [sqlcipher3_busy_timeout()]
2384 ** will also set or clear the busy handler.
2385 **
2386 ** The busy callback should not take any actions which modify the
2387 ** database connection that invoked the busy handler.  Any such actions
2388 ** result in undefined behavior.
2389 ** 
2390 ** A busy handler must not close the database connection
2391 ** or [prepared statement] that invoked the busy handler.
2392 */
2393 SQLCIPHER_API int sqlcipher3_busy_handler(sqlcipher3*, int(*)(void*,int), void*);
2394
2395 /*
2396 ** CAPI3REF: Set A Busy Timeout
2397 **
2398 ** ^This routine sets a [sqlcipher3_busy_handler | busy handler] that sleeps
2399 ** for a specified amount of time when a table is locked.  ^The handler
2400 ** will sleep multiple times until at least "ms" milliseconds of sleeping
2401 ** have accumulated.  ^After at least "ms" milliseconds of sleeping,
2402 ** the handler returns 0 which causes [sqlcipher3_step()] to return
2403 ** [SQLCIPHER_BUSY] or [SQLCIPHER_IOERR_BLOCKED].
2404 **
2405 ** ^Calling this routine with an argument less than or equal to zero
2406 ** turns off all busy handlers.
2407 **
2408 ** ^(There can only be a single busy handler for a particular
2409 ** [database connection] any any given moment.  If another busy handler
2410 ** was defined  (using [sqlcipher3_busy_handler()]) prior to calling
2411 ** this routine, that other busy handler is cleared.)^
2412 */
2413 SQLCIPHER_API int sqlcipher3_busy_timeout(sqlcipher3*, int ms);
2414
2415 /*
2416 ** CAPI3REF: Convenience Routines For Running Queries
2417 **
2418 ** This is a legacy interface that is preserved for backwards compatibility.
2419 ** Use of this interface is not recommended.
2420 **
2421 ** Definition: A <b>result table</b> is memory data structure created by the
2422 ** [sqlcipher3_get_table()] interface.  A result table records the
2423 ** complete query results from one or more queries.
2424 **
2425 ** The table conceptually has a number of rows and columns.  But
2426 ** these numbers are not part of the result table itself.  These
2427 ** numbers are obtained separately.  Let N be the number of rows
2428 ** and M be the number of columns.
2429 **
2430 ** A result table is an array of pointers to zero-terminated UTF-8 strings.
2431 ** There are (N+1)*M elements in the array.  The first M pointers point
2432 ** to zero-terminated strings that  contain the names of the columns.
2433 ** The remaining entries all point to query results.  NULL values result
2434 ** in NULL pointers.  All other values are in their UTF-8 zero-terminated
2435 ** string representation as returned by [sqlcipher3_column_text()].
2436 **
2437 ** A result table might consist of one or more memory allocations.
2438 ** It is not safe to pass a result table directly to [sqlcipher3_free()].
2439 ** A result table should be deallocated using [sqlcipher3_free_table()].
2440 **
2441 ** ^(As an example of the result table format, suppose a query result
2442 ** is as follows:
2443 **
2444 ** <blockquote><pre>
2445 **        Name        | Age
2446 **        -----------------------
2447 **        Alice       | 43
2448 **        Bob         | 28
2449 **        Cindy       | 21
2450 ** </pre></blockquote>
2451 **
2452 ** There are two column (M==2) and three rows (N==3).  Thus the
2453 ** result table has 8 entries.  Suppose the result table is stored
2454 ** in an array names azResult.  Then azResult holds this content:
2455 **
2456 ** <blockquote><pre>
2457 **        azResult&#91;0] = "Name";
2458 **        azResult&#91;1] = "Age";
2459 **        azResult&#91;2] = "Alice";
2460 **        azResult&#91;3] = "43";
2461 **        azResult&#91;4] = "Bob";
2462 **        azResult&#91;5] = "28";
2463 **        azResult&#91;6] = "Cindy";
2464 **        azResult&#91;7] = "21";
2465 ** </pre></blockquote>)^
2466 **
2467 ** ^The sqlcipher3_get_table() function evaluates one or more
2468 ** semicolon-separated SQL statements in the zero-terminated UTF-8
2469 ** string of its 2nd parameter and returns a result table to the
2470 ** pointer given in its 3rd parameter.
2471 **
2472 ** After the application has finished with the result from sqlcipher3_get_table(),
2473 ** it must pass the result table pointer to sqlcipher3_free_table() in order to
2474 ** release the memory that was malloced.  Because of the way the
2475 ** [sqlcipher3_malloc()] happens within sqlcipher3_get_table(), the calling
2476 ** function must not try to call [sqlcipher3_free()] directly.  Only
2477 ** [sqlcipher3_free_table()] is able to release the memory properly and safely.
2478 **
2479 ** The sqlcipher3_get_table() interface is implemented as a wrapper around
2480 ** [sqlcipher3_exec()].  The sqlcipher3_get_table() routine does not have access
2481 ** to any internal data structures of SQLite.  It uses only the public
2482 ** interface defined here.  As a consequence, errors that occur in the
2483 ** wrapper layer outside of the internal [sqlcipher3_exec()] call are not
2484 ** reflected in subsequent calls to [sqlcipher3_errcode()] or
2485 ** [sqlcipher3_errmsg()].
2486 */
2487 SQLCIPHER_API int sqlcipher3_get_table(
2488   sqlcipher3 *db,          /* An open database */
2489   const char *zSql,     /* SQL to be evaluated */
2490   char ***pazResult,    /* Results of the query */
2491   int *pnRow,           /* Number of result rows written here */
2492   int *pnColumn,        /* Number of result columns written here */
2493   char **pzErrmsg       /* Error msg written here */
2494 );
2495 SQLCIPHER_API void sqlcipher3_free_table(char **result);
2496
2497 /*
2498 ** CAPI3REF: Formatted String Printing Functions
2499 **
2500 ** These routines are work-alikes of the "printf()" family of functions
2501 ** from the standard C library.
2502 **
2503 ** ^The sqlcipher3_mprintf() and sqlcipher3_vmprintf() routines write their
2504 ** results into memory obtained from [sqlcipher3_malloc()].
2505 ** The strings returned by these two routines should be
2506 ** released by [sqlcipher3_free()].  ^Both routines return a
2507 ** NULL pointer if [sqlcipher3_malloc()] is unable to allocate enough
2508 ** memory to hold the resulting string.
2509 **
2510 ** ^(The sqlcipher3_snprintf() routine is similar to "snprintf()" from
2511 ** the standard C library.  The result is written into the
2512 ** buffer supplied as the second parameter whose size is given by
2513 ** the first parameter. Note that the order of the
2514 ** first two parameters is reversed from snprintf().)^  This is an
2515 ** historical accident that cannot be fixed without breaking
2516 ** backwards compatibility.  ^(Note also that sqlcipher3_snprintf()
2517 ** returns a pointer to its buffer instead of the number of
2518 ** characters actually written into the buffer.)^  We admit that
2519 ** the number of characters written would be a more useful return
2520 ** value but we cannot change the implementation of sqlcipher3_snprintf()
2521 ** now without breaking compatibility.
2522 **
2523 ** ^As long as the buffer size is greater than zero, sqlcipher3_snprintf()
2524 ** guarantees that the buffer is always zero-terminated.  ^The first
2525 ** parameter "n" is the total size of the buffer, including space for
2526 ** the zero terminator.  So the longest string that can be completely
2527 ** written will be n-1 characters.
2528 **
2529 ** ^The sqlcipher3_vsnprintf() routine is a varargs version of sqlcipher3_snprintf().
2530 **
2531 ** These routines all implement some additional formatting
2532 ** options that are useful for constructing SQL statements.
2533 ** All of the usual printf() formatting options apply.  In addition, there
2534 ** is are "%q", "%Q", and "%z" options.
2535 **
2536 ** ^(The %q option works like %s in that it substitutes a null-terminated
2537 ** string from the argument list.  But %q also doubles every '\'' character.
2538 ** %q is designed for use inside a string literal.)^  By doubling each '\''
2539 ** character it escapes that character and allows it to be inserted into
2540 ** the string.
2541 **
2542 ** For example, assume the string variable zText contains text as follows:
2543 **
2544 ** <blockquote><pre>
2545 **  char *zText = "It's a happy day!";
2546 ** </pre></blockquote>
2547 **
2548 ** One can use this text in an SQL statement as follows:
2549 **
2550 ** <blockquote><pre>
2551 **  char *zSQL = sqlcipher3_mprintf("INSERT INTO table VALUES('%q')", zText);
2552 **  sqlcipher3_exec(db, zSQL, 0, 0, 0);
2553 **  sqlcipher3_free(zSQL);
2554 ** </pre></blockquote>
2555 **
2556 ** Because the %q format string is used, the '\'' character in zText
2557 ** is escaped and the SQL generated is as follows:
2558 **
2559 ** <blockquote><pre>
2560 **  INSERT INTO table1 VALUES('It''s a happy day!')
2561 ** </pre></blockquote>
2562 **
2563 ** This is correct.  Had we used %s instead of %q, the generated SQL
2564 ** would have looked like this:
2565 **
2566 ** <blockquote><pre>
2567 **  INSERT INTO table1 VALUES('It's a happy day!');
2568 ** </pre></blockquote>
2569 **
2570 ** This second example is an SQL syntax error.  As a general rule you should
2571 ** always use %q instead of %s when inserting text into a string literal.
2572 **
2573 ** ^(The %Q option works like %q except it also adds single quotes around
2574 ** the outside of the total string.  Additionally, if the parameter in the
2575 ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without
2576 ** single quotes).)^  So, for example, one could say:
2577 **
2578 ** <blockquote><pre>
2579 **  char *zSQL = sqlcipher3_mprintf("INSERT INTO table VALUES(%Q)", zText);
2580 **  sqlcipher3_exec(db, zSQL, 0, 0, 0);
2581 **  sqlcipher3_free(zSQL);
2582 ** </pre></blockquote>
2583 **
2584 ** The code above will render a correct SQL statement in the zSQL
2585 ** variable even if the zText variable is a NULL pointer.
2586 **
2587 ** ^(The "%z" formatting option works like "%s" but with the
2588 ** addition that after the string has been read and copied into
2589 ** the result, [sqlcipher3_free()] is called on the input string.)^
2590 */
2591 SQLCIPHER_API char *sqlcipher3_mprintf(const char*,...);
2592 SQLCIPHER_API char *sqlcipher3_vmprintf(const char*, va_list);
2593 SQLCIPHER_API char *sqlcipher3_snprintf(int,char*,const char*, ...);
2594 SQLCIPHER_API char *sqlcipher3_vsnprintf(int,char*,const char*, va_list);
2595
2596 /*
2597 ** CAPI3REF: Memory Allocation Subsystem
2598 **
2599 ** The SQLite core uses these three routines for all of its own
2600 ** internal memory allocation needs. "Core" in the previous sentence
2601 ** does not include operating-system specific VFS implementation.  The
2602 ** Windows VFS uses native malloc() and free() for some operations.
2603 **
2604 ** ^The sqlcipher3_malloc() routine returns a pointer to a block
2605 ** of memory at least N bytes in length, where N is the parameter.
2606 ** ^If sqlcipher3_malloc() is unable to obtain sufficient free
2607 ** memory, it returns a NULL pointer.  ^If the parameter N to
2608 ** sqlcipher3_malloc() is zero or negative then sqlcipher3_malloc() returns
2609 ** a NULL pointer.
2610 **
2611 ** ^Calling sqlcipher3_free() with a pointer previously returned
2612 ** by sqlcipher3_malloc() or sqlcipher3_realloc() releases that memory so
2613 ** that it might be reused.  ^The sqlcipher3_free() routine is
2614 ** a no-op if is called with a NULL pointer.  Passing a NULL pointer
2615 ** to sqlcipher3_free() is harmless.  After being freed, memory
2616 ** should neither be read nor written.  Even reading previously freed
2617 ** memory might result in a segmentation fault or other severe error.
2618 ** Memory corruption, a segmentation fault, or other severe error
2619 ** might result if sqlcipher3_free() is called with a non-NULL pointer that
2620 ** was not obtained from sqlcipher3_malloc() or sqlcipher3_realloc().
2621 **
2622 ** ^(The sqlcipher3_realloc() interface attempts to resize a
2623 ** prior memory allocation to be at least N bytes, where N is the
2624 ** second parameter.  The memory allocation to be resized is the first
2625 ** parameter.)^ ^ If the first parameter to sqlcipher3_realloc()
2626 ** is a NULL pointer then its behavior is identical to calling
2627 ** sqlcipher3_malloc(N) where N is the second parameter to sqlcipher3_realloc().
2628 ** ^If the second parameter to sqlcipher3_realloc() is zero or
2629 ** negative then the behavior is exactly the same as calling
2630 ** sqlcipher3_free(P) where P is the first parameter to sqlcipher3_realloc().
2631 ** ^sqlcipher3_realloc() returns a pointer to a memory allocation
2632 ** of at least N bytes in size or NULL if sufficient memory is unavailable.
2633 ** ^If M is the size of the prior allocation, then min(N,M) bytes
2634 ** of the prior allocation are copied into the beginning of buffer returned
2635 ** by sqlcipher3_realloc() and the prior allocation is freed.
2636 ** ^If sqlcipher3_realloc() returns NULL, then the prior allocation
2637 ** is not freed.
2638 **
2639 ** ^The memory returned by sqlcipher3_malloc() and sqlcipher3_realloc()
2640 ** is always aligned to at least an 8 byte boundary, or to a
2641 ** 4 byte boundary if the [SQLCIPHER_4_BYTE_ALIGNED_MALLOC] compile-time
2642 ** option is used.
2643 **
2644 ** In SQLite version 3.5.0 and 3.5.1, it was possible to define
2645 ** the SQLCIPHER_OMIT_MEMORY_ALLOCATION which would cause the built-in
2646 ** implementation of these routines to be omitted.  That capability
2647 ** is no longer provided.  Only built-in memory allocators can be used.
2648 **
2649 ** The Windows OS interface layer calls
2650 ** the system malloc() and free() directly when converting
2651 ** filenames between the UTF-8 encoding used by SQLite
2652 ** and whatever filename encoding is used by the particular Windows
2653 ** installation.  Memory allocation errors are detected, but
2654 ** they are reported back as [SQLCIPHER_CANTOPEN] or
2655 ** [SQLCIPHER_IOERR] rather than [SQLCIPHER_NOMEM].
2656 **
2657 ** The pointer arguments to [sqlcipher3_free()] and [sqlcipher3_realloc()]
2658 ** must be either NULL or else pointers obtained from a prior
2659 ** invocation of [sqlcipher3_malloc()] or [sqlcipher3_realloc()] that have
2660 ** not yet been released.
2661 **
2662 ** The application must not read or write any part of
2663 ** a block of memory after it has been released using
2664 ** [sqlcipher3_free()] or [sqlcipher3_realloc()].
2665 */
2666 SQLCIPHER_API void *sqlcipher3_malloc(int);
2667 SQLCIPHER_API void *sqlcipher3_realloc(void*, int);
2668 SQLCIPHER_API void sqlcipher3_free(void*);
2669
2670 /*
2671 ** CAPI3REF: Memory Allocator Statistics
2672 **
2673 ** SQLite provides these two interfaces for reporting on the status
2674 ** of the [sqlcipher3_malloc()], [sqlcipher3_free()], and [sqlcipher3_realloc()]
2675 ** routines, which form the built-in memory allocation subsystem.
2676 **
2677 ** ^The [sqlcipher3_memory_used()] routine returns the number of bytes
2678 ** of memory currently outstanding (malloced but not freed).
2679 ** ^The [sqlcipher3_memory_highwater()] routine returns the maximum
2680 ** value of [sqlcipher3_memory_used()] since the high-water mark
2681 ** was last reset.  ^The values returned by [sqlcipher3_memory_used()] and
2682 ** [sqlcipher3_memory_highwater()] include any overhead
2683 ** added by SQLite in its implementation of [sqlcipher3_malloc()],
2684 ** but not overhead added by the any underlying system library
2685 ** routines that [sqlcipher3_malloc()] may call.
2686 **
2687 ** ^The memory high-water mark is reset to the current value of
2688 ** [sqlcipher3_memory_used()] if and only if the parameter to
2689 ** [sqlcipher3_memory_highwater()] is true.  ^The value returned
2690 ** by [sqlcipher3_memory_highwater(1)] is the high-water mark
2691 ** prior to the reset.
2692 */
2693 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_memory_used(void);
2694 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_memory_highwater(int resetFlag);
2695
2696 /*
2697 ** CAPI3REF: Pseudo-Random Number Generator
2698 **
2699 ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
2700 ** select random [ROWID | ROWIDs] when inserting new records into a table that
2701 ** already uses the largest possible [ROWID].  The PRNG is also used for
2702 ** the build-in random() and randomblob() SQL functions.  This interface allows
2703 ** applications to access the same PRNG for other purposes.
2704 **
2705 ** ^A call to this routine stores N bytes of randomness into buffer P.
2706 **
2707 ** ^The first time this routine is invoked (either internally or by
2708 ** the application) the PRNG is seeded using randomness obtained
2709 ** from the xRandomness method of the default [sqlcipher3_vfs] object.
2710 ** ^On all subsequent invocations, the pseudo-randomness is generated
2711 ** internally and without recourse to the [sqlcipher3_vfs] xRandomness
2712 ** method.
2713 */
2714 SQLCIPHER_API void sqlcipher3_randomness(int N, void *P);
2715
2716 /*
2717 ** CAPI3REF: Compile-Time Authorization Callbacks
2718 **
2719 ** ^This routine registers an authorizer callback with a particular
2720 ** [database connection], supplied in the first argument.
2721 ** ^The authorizer callback is invoked as SQL statements are being compiled
2722 ** by [sqlcipher3_prepare()] or its variants [sqlcipher3_prepare_v2()],
2723 ** [sqlcipher3_prepare16()] and [sqlcipher3_prepare16_v2()].  ^At various
2724 ** points during the compilation process, as logic is being created
2725 ** to perform various actions, the authorizer callback is invoked to
2726 ** see if those actions are allowed.  ^The authorizer callback should
2727 ** return [SQLCIPHER_OK] to allow the action, [SQLCIPHER_IGNORE] to disallow the
2728 ** specific action but allow the SQL statement to continue to be
2729 ** compiled, or [SQLCIPHER_DENY] to cause the entire SQL statement to be
2730 ** rejected with an error.  ^If the authorizer callback returns
2731 ** any value other than [SQLCIPHER_IGNORE], [SQLCIPHER_OK], or [SQLCIPHER_DENY]
2732 ** then the [sqlcipher3_prepare_v2()] or equivalent call that triggered
2733 ** the authorizer will fail with an error message.
2734 **
2735 ** When the callback returns [SQLCIPHER_OK], that means the operation
2736 ** requested is ok.  ^When the callback returns [SQLCIPHER_DENY], the
2737 ** [sqlcipher3_prepare_v2()] or equivalent call that triggered the
2738 ** authorizer will fail with an error message explaining that
2739 ** access is denied. 
2740 **
2741 ** ^The first parameter to the authorizer callback is a copy of the third
2742 ** parameter to the sqlcipher3_set_authorizer() interface. ^The second parameter
2743 ** to the callback is an integer [SQLCIPHER_COPY | action code] that specifies
2744 ** the particular action to be authorized. ^The third through sixth parameters
2745 ** to the callback are zero-terminated strings that contain additional
2746 ** details about the action to be authorized.
2747 **
2748 ** ^If the action code is [SQLCIPHER_READ]
2749 ** and the callback returns [SQLCIPHER_IGNORE] then the
2750 ** [prepared statement] statement is constructed to substitute
2751 ** a NULL value in place of the table column that would have
2752 ** been read if [SQLCIPHER_OK] had been returned.  The [SQLCIPHER_IGNORE]
2753 ** return can be used to deny an untrusted user access to individual
2754 ** columns of a table.
2755 ** ^If the action code is [SQLCIPHER_DELETE] and the callback returns
2756 ** [SQLCIPHER_IGNORE] then the [DELETE] operation proceeds but the
2757 ** [truncate optimization] is disabled and all rows are deleted individually.
2758 **
2759 ** An authorizer is used when [sqlcipher3_prepare | preparing]
2760 ** SQL statements from an untrusted source, to ensure that the SQL statements
2761 ** do not try to access data they are not allowed to see, or that they do not
2762 ** try to execute malicious statements that damage the database.  For
2763 ** example, an application may allow a user to enter arbitrary
2764 ** SQL queries for evaluation by a database.  But the application does
2765 ** not want the user to be able to make arbitrary changes to the
2766 ** database.  An authorizer could then be put in place while the
2767 ** user-entered SQL is being [sqlcipher3_prepare | prepared] that
2768 ** disallows everything except [SELECT] statements.
2769 **
2770 ** Applications that need to process SQL from untrusted sources
2771 ** might also consider lowering resource limits using [sqlcipher3_limit()]
2772 ** and limiting database size using the [max_page_count] [PRAGMA]
2773 ** in addition to using an authorizer.
2774 **
2775 ** ^(Only a single authorizer can be in place on a database connection
2776 ** at a time.  Each call to sqlcipher3_set_authorizer overrides the
2777 ** previous call.)^  ^Disable the authorizer by installing a NULL callback.
2778 ** The authorizer is disabled by default.
2779 **
2780 ** The authorizer callback must not do anything that will modify
2781 ** the database connection that invoked the authorizer callback.
2782 ** Note that [sqlcipher3_prepare_v2()] and [sqlcipher3_step()] both modify their
2783 ** database connections for the meaning of "modify" in this paragraph.
2784 **
2785 ** ^When [sqlcipher3_prepare_v2()] is used to prepare a statement, the
2786 ** statement might be re-prepared during [sqlcipher3_step()] due to a 
2787 ** schema change.  Hence, the application should ensure that the
2788 ** correct authorizer callback remains in place during the [sqlcipher3_step()].
2789 **
2790 ** ^Note that the authorizer callback is invoked only during
2791 ** [sqlcipher3_prepare()] or its variants.  Authorization is not
2792 ** performed during statement evaluation in [sqlcipher3_step()], unless
2793 ** as stated in the previous paragraph, sqlcipher3_step() invokes
2794 ** sqlcipher3_prepare_v2() to reprepare a statement after a schema change.
2795 */
2796 SQLCIPHER_API int sqlcipher3_set_authorizer(
2797   sqlcipher3*,
2798   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
2799   void *pUserData
2800 );
2801
2802 /*
2803 ** CAPI3REF: Authorizer Return Codes
2804 **
2805 ** The [sqlcipher3_set_authorizer | authorizer callback function] must
2806 ** return either [SQLCIPHER_OK] or one of these two constants in order
2807 ** to signal SQLite whether or not the action is permitted.  See the
2808 ** [sqlcipher3_set_authorizer | authorizer documentation] for additional
2809 ** information.
2810 **
2811 ** Note that SQLCIPHER_IGNORE is also used as a [SQLCIPHER_ROLLBACK | return code]
2812 ** from the [sqlcipher3_vtab_on_conflict()] interface.
2813 */
2814 #define SQLCIPHER_DENY   1   /* Abort the SQL statement with an error */
2815 #define SQLCIPHER_IGNORE 2   /* Don't allow access, but don't generate an error */
2816
2817 /*
2818 ** CAPI3REF: Authorizer Action Codes
2819 **
2820 ** The [sqlcipher3_set_authorizer()] interface registers a callback function
2821 ** that is invoked to authorize certain SQL statement actions.  The
2822 ** second parameter to the callback is an integer code that specifies
2823 ** what action is being authorized.  These are the integer action codes that
2824 ** the authorizer callback may be passed.
2825 **
2826 ** These action code values signify what kind of operation is to be
2827 ** authorized.  The 3rd and 4th parameters to the authorization
2828 ** callback function will be parameters or NULL depending on which of these
2829 ** codes is used as the second parameter.  ^(The 5th parameter to the
2830 ** authorizer callback is the name of the database ("main", "temp",
2831 ** etc.) if applicable.)^  ^The 6th parameter to the authorizer callback
2832 ** is the name of the inner-most trigger or view that is responsible for
2833 ** the access attempt or NULL if this access attempt is directly from
2834 ** top-level SQL code.
2835 */
2836 /******************************************* 3rd ************ 4th ***********/
2837 #define SQLCIPHER_CREATE_INDEX          1   /* Index Name      Table Name      */
2838 #define SQLCIPHER_CREATE_TABLE          2   /* Table Name      NULL            */
2839 #define SQLCIPHER_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
2840 #define SQLCIPHER_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
2841 #define SQLCIPHER_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
2842 #define SQLCIPHER_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
2843 #define SQLCIPHER_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
2844 #define SQLCIPHER_CREATE_VIEW           8   /* View Name       NULL            */
2845 #define SQLCIPHER_DELETE                9   /* Table Name      NULL            */
2846 #define SQLCIPHER_DROP_INDEX           10   /* Index Name      Table Name      */
2847 #define SQLCIPHER_DROP_TABLE           11   /* Table Name      NULL            */
2848 #define SQLCIPHER_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
2849 #define SQLCIPHER_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
2850 #define SQLCIPHER_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
2851 #define SQLCIPHER_DROP_TEMP_VIEW       15   /* View Name       NULL            */
2852 #define SQLCIPHER_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
2853 #define SQLCIPHER_DROP_VIEW            17   /* View Name       NULL            */
2854 #define SQLCIPHER_INSERT               18   /* Table Name      NULL            */
2855 #define SQLCIPHER_PRAGMA               19   /* Pragma Name     1st arg or NULL */
2856 #define SQLCIPHER_READ                 20   /* Table Name      Column Name     */
2857 #define SQLCIPHER_SELECT               21   /* NULL            NULL            */
2858 #define SQLCIPHER_TRANSACTION          22   /* Operation       NULL            */
2859 #define SQLCIPHER_UPDATE               23   /* Table Name      Column Name     */
2860 #define SQLCIPHER_ATTACH               24   /* Filename        NULL            */
2861 #define SQLCIPHER_DETACH               25   /* Database Name   NULL            */
2862 #define SQLCIPHER_ALTER_TABLE          26   /* Database Name   Table Name      */
2863 #define SQLCIPHER_REINDEX              27   /* Index Name      NULL            */
2864 #define SQLCIPHER_ANALYZE              28   /* Table Name      NULL            */
2865 #define SQLCIPHER_CREATE_VTABLE        29   /* Table Name      Module Name     */
2866 #define SQLCIPHER_DROP_VTABLE          30   /* Table Name      Module Name     */
2867 #define SQLCIPHER_FUNCTION             31   /* NULL            Function Name   */
2868 #define SQLCIPHER_SAVEPOINT            32   /* Operation       Savepoint Name  */
2869 #define SQLCIPHER_COPY                  0   /* No longer used */
2870
2871 /*
2872 ** CAPI3REF: Tracing And Profiling Functions
2873 **
2874 ** These routines register callback functions that can be used for
2875 ** tracing and profiling the execution of SQL statements.
2876 **
2877 ** ^The callback function registered by sqlcipher3_trace() is invoked at
2878 ** various times when an SQL statement is being run by [sqlcipher3_step()].
2879 ** ^The sqlcipher3_trace() callback is invoked with a UTF-8 rendering of the
2880 ** SQL statement text as the statement first begins executing.
2881 ** ^(Additional sqlcipher3_trace() callbacks might occur
2882 ** as each triggered subprogram is entered.  The callbacks for triggers
2883 ** contain a UTF-8 SQL comment that identifies the trigger.)^
2884 **
2885 ** ^The callback function registered by sqlcipher3_profile() is invoked
2886 ** as each SQL statement finishes.  ^The profile callback contains
2887 ** the original statement text and an estimate of wall-clock time
2888 ** of how long that statement took to run.  ^The profile callback
2889 ** time is in units of nanoseconds, however the current implementation
2890 ** is only capable of millisecond resolution so the six least significant
2891 ** digits in the time are meaningless.  Future versions of SQLite
2892 ** might provide greater resolution on the profiler callback.  The
2893 ** sqlcipher3_profile() function is considered experimental and is
2894 ** subject to change in future versions of SQLite.
2895 */
2896 SQLCIPHER_API void *sqlcipher3_trace(sqlcipher3*, void(*xTrace)(void*,const char*), void*);
2897 SQLCIPHER_API SQLCIPHER_EXPERIMENTAL void *sqlcipher3_profile(sqlcipher3*,
2898    void(*xProfile)(void*,const char*,sqlcipher3_uint64), void*);
2899
2900 /*
2901 ** CAPI3REF: Query Progress Callbacks
2902 **
2903 ** ^The sqlcipher3_progress_handler(D,N,X,P) interface causes the callback
2904 ** function X to be invoked periodically during long running calls to
2905 ** [sqlcipher3_exec()], [sqlcipher3_step()] and [sqlcipher3_get_table()] for
2906 ** database connection D.  An example use for this
2907 ** interface is to keep a GUI updated during a large query.
2908 **
2909 ** ^The parameter P is passed through as the only parameter to the 
2910 ** callback function X.  ^The parameter N is the number of 
2911 ** [virtual machine instructions] that are evaluated between successive
2912 ** invocations of the callback X.
2913 **
2914 ** ^Only a single progress handler may be defined at one time per
2915 ** [database connection]; setting a new progress handler cancels the
2916 ** old one.  ^Setting parameter X to NULL disables the progress handler.
2917 ** ^The progress handler is also disabled by setting N to a value less
2918 ** than 1.
2919 **
2920 ** ^If the progress callback returns non-zero, the operation is
2921 ** interrupted.  This feature can be used to implement a
2922 ** "Cancel" button on a GUI progress dialog box.
2923 **
2924 ** The progress handler callback must not do anything that will modify
2925 ** the database connection that invoked the progress handler.
2926 ** Note that [sqlcipher3_prepare_v2()] and [sqlcipher3_step()] both modify their
2927 ** database connections for the meaning of "modify" in this paragraph.
2928 **
2929 */
2930 SQLCIPHER_API void sqlcipher3_progress_handler(sqlcipher3*, int, int(*)(void*), void*);
2931
2932 /*
2933 ** CAPI3REF: Opening A New Database Connection
2934 **
2935 ** ^These routines open an SQLite database file as specified by the 
2936 ** filename argument. ^The filename argument is interpreted as UTF-8 for
2937 ** sqlcipher3_open() and sqlcipher3_open_v2() and as UTF-16 in the native byte
2938 ** order for sqlcipher3_open16(). ^(A [database connection] handle is usually
2939 ** returned in *ppDb, even if an error occurs.  The only exception is that
2940 ** if SQLite is unable to allocate memory to hold the [sqlcipher3] object,
2941 ** a NULL will be written into *ppDb instead of a pointer to the [sqlcipher3]
2942 ** object.)^ ^(If the database is opened (and/or created) successfully, then
2943 ** [SQLCIPHER_OK] is returned.  Otherwise an [error code] is returned.)^ ^The
2944 ** [sqlcipher3_errmsg()] or [sqlcipher3_errmsg16()] routines can be used to obtain
2945 ** an English language description of the error following a failure of any
2946 ** of the sqlcipher3_open() routines.
2947 **
2948 ** ^The default encoding for the database will be UTF-8 if
2949 ** sqlcipher3_open() or sqlcipher3_open_v2() is called and
2950 ** UTF-16 in the native byte order if sqlcipher3_open16() is used.
2951 **
2952 ** Whether or not an error occurs when it is opened, resources
2953 ** associated with the [database connection] handle should be released by
2954 ** passing it to [sqlcipher3_close()] when it is no longer required.
2955 **
2956 ** The sqlcipher3_open_v2() interface works like sqlcipher3_open()
2957 ** except that it accepts two additional parameters for additional control
2958 ** over the new database connection.  ^(The flags parameter to
2959 ** sqlcipher3_open_v2() can take one of
2960 ** the following three values, optionally combined with the 
2961 ** [SQLCIPHER_OPEN_NOMUTEX], [SQLCIPHER_OPEN_FULLMUTEX], [SQLCIPHER_OPEN_SHAREDCACHE],
2962 ** [SQLCIPHER_OPEN_PRIVATECACHE], and/or [SQLCIPHER_OPEN_URI] flags:)^
2963 **
2964 ** <dl>
2965 ** ^(<dt>[SQLCIPHER_OPEN_READONLY]</dt>
2966 ** <dd>The database is opened in read-only mode.  If the database does not
2967 ** already exist, an error is returned.</dd>)^
2968 **
2969 ** ^(<dt>[SQLCIPHER_OPEN_READWRITE]</dt>
2970 ** <dd>The database is opened for reading and writing if possible, or reading
2971 ** only if the file is write protected by the operating system.  In either
2972 ** case the database must already exist, otherwise an error is returned.</dd>)^
2973 **
2974 ** ^(<dt>[SQLCIPHER_OPEN_READWRITE] | [SQLCIPHER_OPEN_CREATE]</dt>
2975 ** <dd>The database is opened for reading and writing, and is created if
2976 ** it does not already exist. This is the behavior that is always used for
2977 ** sqlcipher3_open() and sqlcipher3_open16().</dd>)^
2978 ** </dl>
2979 **
2980 ** If the 3rd parameter to sqlcipher3_open_v2() is not one of the
2981 ** combinations shown above optionally combined with other
2982 ** [SQLCIPHER_OPEN_READONLY | SQLCIPHER_OPEN_* bits]
2983 ** then the behavior is undefined.
2984 **
2985 ** ^If the [SQLCIPHER_OPEN_NOMUTEX] flag is set, then the database connection
2986 ** opens in the multi-thread [threading mode] as long as the single-thread
2987 ** mode has not been set at compile-time or start-time.  ^If the
2988 ** [SQLCIPHER_OPEN_FULLMUTEX] flag is set then the database connection opens
2989 ** in the serialized [threading mode] unless single-thread was
2990 ** previously selected at compile-time or start-time.
2991 ** ^The [SQLCIPHER_OPEN_SHAREDCACHE] flag causes the database connection to be
2992 ** eligible to use [shared cache mode], regardless of whether or not shared
2993 ** cache is enabled using [sqlcipher3_enable_shared_cache()].  ^The
2994 ** [SQLCIPHER_OPEN_PRIVATECACHE] flag causes the database connection to not
2995 ** participate in [shared cache mode] even if it is enabled.
2996 **
2997 ** ^The fourth parameter to sqlcipher3_open_v2() is the name of the
2998 ** [sqlcipher3_vfs] object that defines the operating system interface that
2999 ** the new database connection should use.  ^If the fourth parameter is
3000 ** a NULL pointer then the default [sqlcipher3_vfs] object is used.
3001 **
3002 ** ^If the filename is ":memory:", then a private, temporary in-memory database
3003 ** is created for the connection.  ^This in-memory database will vanish when
3004 ** the database connection is closed.  Future versions of SQLite might
3005 ** make use of additional special filenames that begin with the ":" character.
3006 ** It is recommended that when a database filename actually does begin with
3007 ** a ":" character you should prefix the filename with a pathname such as
3008 ** "./" to avoid ambiguity.
3009 **
3010 ** ^If the filename is an empty string, then a private, temporary
3011 ** on-disk database will be created.  ^This private database will be
3012 ** automatically deleted as soon as the database connection is closed.
3013 **
3014 ** [[URI filenames in sqlcipher3_open()]] <h3>URI Filenames</h3>
3015 **
3016 ** ^If [URI filename] interpretation is enabled, and the filename argument
3017 ** begins with "file:", then the filename is interpreted as a URI. ^URI
3018 ** filename interpretation is enabled if the [SQLCIPHER_OPEN_URI] flag is
3019 ** set in the fourth argument to sqlcipher3_open_v2(), or if it has
3020 ** been enabled globally using the [SQLCIPHER_CONFIG_URI] option with the
3021 ** [sqlcipher3_config()] method or by the [SQLCIPHER_USE_URI] compile-time option.
3022 ** As of SQLite version 3.7.7, URI filename interpretation is turned off
3023 ** by default, but future releases of SQLite might enable URI filename
3024 ** interpretation by default.  See "[URI filenames]" for additional
3025 ** information.
3026 **
3027 ** URI filenames are parsed according to RFC 3986. ^If the URI contains an
3028 ** authority, then it must be either an empty string or the string 
3029 ** "localhost". ^If the authority is not an empty string or "localhost", an 
3030 ** error is returned to the caller. ^The fragment component of a URI, if 
3031 ** present, is ignored.
3032 **
3033 ** ^SQLite uses the path component of the URI as the name of the disk file
3034 ** which contains the database. ^If the path begins with a '/' character, 
3035 ** then it is interpreted as an absolute path. ^If the path does not begin 
3036 ** with a '/' (meaning that the authority section is omitted from the URI)
3037 ** then the path is interpreted as a relative path. 
3038 ** ^On windows, the first component of an absolute path 
3039 ** is a drive specification (e.g. "C:").
3040 **
3041 ** [[core URI query parameters]]
3042 ** The query component of a URI may contain parameters that are interpreted
3043 ** either by SQLite itself, or by a [VFS | custom VFS implementation].
3044 ** SQLite interprets the following three query parameters:
3045 **
3046 ** <ul>
3047 **   <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
3048 **     a VFS object that provides the operating system interface that should
3049 **     be used to access the database file on disk. ^If this option is set to
3050 **     an empty string the default VFS object is used. ^Specifying an unknown
3051 **     VFS is an error. ^If sqlcipher3_open_v2() is used and the vfs option is
3052 **     present, then the VFS specified by the option takes precedence over
3053 **     the value passed as the fourth parameter to sqlcipher3_open_v2().
3054 **
3055 **   <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw" or
3056 **     "rwc". Attempting to set it to any other value is an error)^. 
3057 **     ^If "ro" is specified, then the database is opened for read-only 
3058 **     access, just as if the [SQLCIPHER_OPEN_READONLY] flag had been set in the 
3059 **     third argument to sqlcipher3_prepare_v2(). ^If the mode option is set to 
3060 **     "rw", then the database is opened for read-write (but not create) 
3061 **     access, as if SQLCIPHER_OPEN_READWRITE (but not SQLCIPHER_OPEN_CREATE) had 
3062 **     been set. ^Value "rwc" is equivalent to setting both 
3063 **     SQLCIPHER_OPEN_READWRITE and SQLCIPHER_OPEN_CREATE. ^If sqlcipher3_open_v2() is 
3064 **     used, it is an error to specify a value for the mode parameter that is 
3065 **     less restrictive than that specified by the flags passed as the third 
3066 **     parameter.
3067 **
3068 **   <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
3069 **     "private". ^Setting it to "shared" is equivalent to setting the
3070 **     SQLCIPHER_OPEN_SHAREDCACHE bit in the flags argument passed to
3071 **     sqlcipher3_open_v2(). ^Setting the cache parameter to "private" is 
3072 **     equivalent to setting the SQLCIPHER_OPEN_PRIVATECACHE bit.
3073 **     ^If sqlcipher3_open_v2() is used and the "cache" parameter is present in
3074 **     a URI filename, its value overrides any behaviour requested by setting
3075 **     SQLCIPHER_OPEN_PRIVATECACHE or SQLCIPHER_OPEN_SHAREDCACHE flag.
3076 ** </ul>
3077 **
3078 ** ^Specifying an unknown parameter in the query component of a URI is not an
3079 ** error.  Future versions of SQLite might understand additional query
3080 ** parameters.  See "[query parameters with special meaning to SQLite]" for
3081 ** additional information.
3082 **
3083 ** [[URI filename examples]] <h3>URI filename examples</h3>
3084 **
3085 ** <table border="1" align=center cellpadding=5>
3086 ** <tr><th> URI filenames <th> Results
3087 ** <tr><td> file:data.db <td> 
3088 **          Open the file "data.db" in the current directory.
3089 ** <tr><td> file:/home/fred/data.db<br>
3090 **          file:///home/fred/data.db <br> 
3091 **          file://localhost/home/fred/data.db <br> <td> 
3092 **          Open the database file "/home/fred/data.db".
3093 ** <tr><td> file://darkstar/home/fred/data.db <td> 
3094 **          An error. "darkstar" is not a recognized authority.
3095 ** <tr><td style="white-space:nowrap"> 
3096 **          file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
3097 **     <td> Windows only: Open the file "data.db" on fred's desktop on drive
3098 **          C:. Note that the %20 escaping in this example is not strictly 
3099 **          necessary - space characters can be used literally
3100 **          in URI filenames.
3101 ** <tr><td> file:data.db?mode=ro&cache=private <td> 
3102 **          Open file "data.db" in the current directory for read-only access.
3103 **          Regardless of whether or not shared-cache mode is enabled by
3104 **          default, use a private cache.
3105 ** <tr><td> file:/home/fred/data.db?vfs=unix-nolock <td>
3106 **          Open file "/home/fred/data.db". Use the special VFS "unix-nolock".
3107 ** <tr><td> file:data.db?mode=readonly <td> 
3108 **          An error. "readonly" is not a valid option for the "mode" parameter.
3109 ** </table>
3110 **
3111 ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
3112 ** query components of a URI. A hexadecimal escape sequence consists of a
3113 ** percent sign - "%" - followed by exactly two hexadecimal digits 
3114 ** specifying an octet value. ^Before the path or query components of a
3115 ** URI filename are interpreted, they are encoded using UTF-8 and all 
3116 ** hexadecimal escape sequences replaced by a single byte containing the
3117 ** corresponding octet. If this process generates an invalid UTF-8 encoding,
3118 ** the results are undefined.
3119 **
3120 ** <b>Note to Windows users:</b>  The encoding used for the filename argument
3121 ** of sqlcipher3_open() and sqlcipher3_open_v2() must be UTF-8, not whatever
3122 ** codepage is currently defined.  Filenames containing international
3123 ** characters must be converted to UTF-8 prior to passing them into
3124 ** sqlcipher3_open() or sqlcipher3_open_v2().
3125 */
3126 SQLCIPHER_API int sqlcipher3_open(
3127   const char *filename,   /* Database filename (UTF-8) */
3128   sqlcipher3 **ppDb          /* OUT: SQLite db handle */
3129 );
3130 SQLCIPHER_API int sqlcipher3_open16(
3131   const void *filename,   /* Database filename (UTF-16) */
3132   sqlcipher3 **ppDb          /* OUT: SQLite db handle */
3133 );
3134 SQLCIPHER_API int sqlcipher3_open_v2(
3135   const char *filename,   /* Database filename (UTF-8) */
3136   sqlcipher3 **ppDb,         /* OUT: SQLite db handle */
3137   int flags,              /* Flags */
3138   const char *zVfs        /* Name of VFS module to use */
3139 );
3140
3141 /*
3142 ** CAPI3REF: Obtain Values For URI Parameters
3143 **
3144 ** This is a utility routine, useful to VFS implementations, that checks
3145 ** to see if a database file was a URI that contained a specific query 
3146 ** parameter, and if so obtains the value of the query parameter.
3147 **
3148 ** The zFilename argument is the filename pointer passed into the xOpen()
3149 ** method of a VFS implementation.  The zParam argument is the name of the
3150 ** query parameter we seek.  This routine returns the value of the zParam
3151 ** parameter if it exists.  If the parameter does not exist, this routine
3152 ** returns a NULL pointer.
3153 **
3154 ** If the zFilename argument to this function is not a pointer that SQLite
3155 ** passed into the xOpen VFS method, then the behavior of this routine
3156 ** is undefined and probably undesirable.
3157 */
3158 SQLCIPHER_API const char *sqlcipher3_uri_parameter(const char *zFilename, const char *zParam);
3159
3160
3161 /*
3162 ** CAPI3REF: Error Codes And Messages
3163 **
3164 ** ^The sqlcipher3_errcode() interface returns the numeric [result code] or
3165 ** [extended result code] for the most recent failed sqlcipher3_* API call
3166 ** associated with a [database connection]. If a prior API call failed
3167 ** but the most recent API call succeeded, the return value from
3168 ** sqlcipher3_errcode() is undefined.  ^The sqlcipher3_extended_errcode()
3169 ** interface is the same except that it always returns the 
3170 ** [extended result code] even when extended result codes are
3171 ** disabled.
3172 **
3173 ** ^The sqlcipher3_errmsg() and sqlcipher3_errmsg16() return English-language
3174 ** text that describes the error, as either UTF-8 or UTF-16 respectively.
3175 ** ^(Memory to hold the error message string is managed internally.
3176 ** The application does not need to worry about freeing the result.
3177 ** However, the error string might be overwritten or deallocated by
3178 ** subsequent calls to other SQLite interface functions.)^
3179 **
3180 ** When the serialized [threading mode] is in use, it might be the
3181 ** case that a second error occurs on a separate thread in between
3182 ** the time of the first error and the call to these interfaces.
3183 ** When that happens, the second error will be reported since these
3184 ** interfaces always report the most recent result.  To avoid
3185 ** this, each thread can obtain exclusive use of the [database connection] D
3186 ** by invoking [sqlcipher3_mutex_enter]([sqlcipher3_db_mutex](D)) before beginning
3187 ** to use D and invoking [sqlcipher3_mutex_leave]([sqlcipher3_db_mutex](D)) after
3188 ** all calls to the interfaces listed here are completed.
3189 **
3190 ** If an interface fails with SQLCIPHER_MISUSE, that means the interface
3191 ** was invoked incorrectly by the application.  In that case, the
3192 ** error code and message may or may not be set.
3193 */
3194 SQLCIPHER_API int sqlcipher3_errcode(sqlcipher3 *db);
3195 SQLCIPHER_API int sqlcipher3_extended_errcode(sqlcipher3 *db);
3196 SQLCIPHER_API const char *sqlcipher3_errmsg(sqlcipher3*);
3197 SQLCIPHER_API const void *sqlcipher3_errmsg16(sqlcipher3*);
3198
3199 /*
3200 ** CAPI3REF: SQL Statement Object
3201 ** KEYWORDS: {prepared statement} {prepared statements}
3202 **
3203 ** An instance of this object represents a single SQL statement.
3204 ** This object is variously known as a "prepared statement" or a
3205 ** "compiled SQL statement" or simply as a "statement".
3206 **
3207 ** The life of a statement object goes something like this:
3208 **
3209 ** <ol>
3210 ** <li> Create the object using [sqlcipher3_prepare_v2()] or a related
3211 **      function.
3212 ** <li> Bind values to [host parameters] using the sqlcipher3_bind_*()
3213 **      interfaces.
3214 ** <li> Run the SQL by calling [sqlcipher3_step()] one or more times.
3215 ** <li> Reset the statement using [sqlcipher3_reset()] then go back
3216 **      to step 2.  Do this zero or more times.
3217 ** <li> Destroy the object using [sqlcipher3_finalize()].
3218 ** </ol>
3219 **
3220 ** Refer to documentation on individual methods above for additional
3221 ** information.
3222 */
3223 typedef struct sqlcipher3_stmt sqlcipher3_stmt;
3224
3225 /*
3226 ** CAPI3REF: Run-time Limits
3227 **
3228 ** ^(This interface allows the size of various constructs to be limited
3229 ** on a connection by connection basis.  The first parameter is the
3230 ** [database connection] whose limit is to be set or queried.  The
3231 ** second parameter is one of the [limit categories] that define a
3232 ** class of constructs to be size limited.  The third parameter is the
3233 ** new limit for that construct.)^
3234 **
3235 ** ^If the new limit is a negative number, the limit is unchanged.
3236 ** ^(For each limit category SQLCIPHER_LIMIT_<i>NAME</i> there is a 
3237 ** [limits | hard upper bound]
3238 ** set at compile-time by a C preprocessor macro called
3239 ** [limits | SQLCIPHER_MAX_<i>NAME</i>].
3240 ** (The "_LIMIT_" in the name is changed to "_MAX_".))^
3241 ** ^Attempts to increase a limit above its hard upper bound are
3242 ** silently truncated to the hard upper bound.
3243 **
3244 ** ^Regardless of whether or not the limit was changed, the 
3245 ** [sqlcipher3_limit()] interface returns the prior value of the limit.
3246 ** ^Hence, to find the current value of a limit without changing it,
3247 ** simply invoke this interface with the third parameter set to -1.
3248 **
3249 ** Run-time limits are intended for use in applications that manage
3250 ** both their own internal database and also databases that are controlled
3251 ** by untrusted external sources.  An example application might be a
3252 ** web browser that has its own databases for storing history and
3253 ** separate databases controlled by JavaScript applications downloaded
3254 ** off the Internet.  The internal databases can be given the
3255 ** large, default limits.  Databases managed by external sources can
3256 ** be given much smaller limits designed to prevent a denial of service
3257 ** attack.  Developers might also want to use the [sqlcipher3_set_authorizer()]
3258 ** interface to further control untrusted SQL.  The size of the database
3259 ** created by an untrusted script can be contained using the
3260 ** [max_page_count] [PRAGMA].
3261 **
3262 ** New run-time limit categories may be added in future releases.
3263 */
3264 SQLCIPHER_API int sqlcipher3_limit(sqlcipher3*, int id, int newVal);
3265
3266 /*
3267 ** CAPI3REF: Run-Time Limit Categories
3268 ** KEYWORDS: {limit category} {*limit categories}
3269 **
3270 ** These constants define various performance limits
3271 ** that can be lowered at run-time using [sqlcipher3_limit()].
3272 ** The synopsis of the meanings of the various limits is shown below.
3273 ** Additional information is available at [limits | Limits in SQLite].
3274 **
3275 ** <dl>
3276 ** [[SQLCIPHER_LIMIT_LENGTH]] ^(<dt>SQLCIPHER_LIMIT_LENGTH</dt>
3277 ** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
3278 **
3279 ** [[SQLCIPHER_LIMIT_SQL_LENGTH]] ^(<dt>SQLCIPHER_LIMIT_SQL_LENGTH</dt>
3280 ** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
3281 **
3282 ** [[SQLCIPHER_LIMIT_COLUMN]] ^(<dt>SQLCIPHER_LIMIT_COLUMN</dt>
3283 ** <dd>The maximum number of columns in a table definition or in the
3284 ** result set of a [SELECT] or the maximum number of columns in an index
3285 ** or in an ORDER BY or GROUP BY clause.</dd>)^
3286 **
3287 ** [[SQLCIPHER_LIMIT_EXPR_DEPTH]] ^(<dt>SQLCIPHER_LIMIT_EXPR_DEPTH</dt>
3288 ** <dd>The maximum depth of the parse tree on any expression.</dd>)^
3289 **
3290 ** [[SQLCIPHER_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLCIPHER_LIMIT_COMPOUND_SELECT</dt>
3291 ** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
3292 **
3293 ** [[SQLCIPHER_LIMIT_VDBE_OP]] ^(<dt>SQLCIPHER_LIMIT_VDBE_OP</dt>
3294 ** <dd>The maximum number of instructions in a virtual machine program
3295 ** used to implement an SQL statement.  This limit is not currently
3296 ** enforced, though that might be added in some future release of
3297 ** SQLite.</dd>)^
3298 **
3299 ** [[SQLCIPHER_LIMIT_FUNCTION_ARG]] ^(<dt>SQLCIPHER_LIMIT_FUNCTION_ARG</dt>
3300 ** <dd>The maximum number of arguments on a function.</dd>)^
3301 **
3302 ** [[SQLCIPHER_LIMIT_ATTACHED]] ^(<dt>SQLCIPHER_LIMIT_ATTACHED</dt>
3303 ** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
3304 **
3305 ** [[SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH]]
3306 ** ^(<dt>SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH</dt>
3307 ** <dd>The maximum length of the pattern argument to the [LIKE] or
3308 ** [GLOB] operators.</dd>)^
3309 **
3310 ** [[SQLCIPHER_LIMIT_VARIABLE_NUMBER]]
3311 ** ^(<dt>SQLCIPHER_LIMIT_VARIABLE_NUMBER</dt>
3312 ** <dd>The maximum index number of any [parameter] in an SQL statement.)^
3313 **
3314 ** [[SQLCIPHER_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLCIPHER_LIMIT_TRIGGER_DEPTH</dt>
3315 ** <dd>The maximum depth of recursion for triggers.</dd>)^
3316 ** </dl>
3317 */
3318 #define SQLCIPHER_LIMIT_LENGTH                    0
3319 #define SQLCIPHER_LIMIT_SQL_LENGTH                1
3320 #define SQLCIPHER_LIMIT_COLUMN                    2
3321 #define SQLCIPHER_LIMIT_EXPR_DEPTH                3
3322 #define SQLCIPHER_LIMIT_COMPOUND_SELECT           4
3323 #define SQLCIPHER_LIMIT_VDBE_OP                   5
3324 #define SQLCIPHER_LIMIT_FUNCTION_ARG              6
3325 #define SQLCIPHER_LIMIT_ATTACHED                  7
3326 #define SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH       8
3327 #define SQLCIPHER_LIMIT_VARIABLE_NUMBER           9
3328 #define SQLCIPHER_LIMIT_TRIGGER_DEPTH            10
3329
3330 /*
3331 ** CAPI3REF: Compiling An SQL Statement
3332 ** KEYWORDS: {SQL statement compiler}
3333 **
3334 ** To execute an SQL query, it must first be compiled into a byte-code
3335 ** program using one of these routines.
3336 **
3337 ** The first argument, "db", is a [database connection] obtained from a
3338 ** prior successful call to [sqlcipher3_open()], [sqlcipher3_open_v2()] or
3339 ** [sqlcipher3_open16()].  The database connection must not have been closed.
3340 **
3341 ** The second argument, "zSql", is the statement to be compiled, encoded
3342 ** as either UTF-8 or UTF-16.  The sqlcipher3_prepare() and sqlcipher3_prepare_v2()
3343 ** interfaces use UTF-8, and sqlcipher3_prepare16() and sqlcipher3_prepare16_v2()
3344 ** use UTF-16.
3345 **
3346 ** ^If the nByte argument is less than zero, then zSql is read up to the
3347 ** first zero terminator. ^If nByte is non-negative, then it is the maximum
3348 ** number of  bytes read from zSql.  ^When nByte is non-negative, the
3349 ** zSql string ends at either the first '\000' or '\u0000' character or
3350 ** the nByte-th byte, whichever comes first. If the caller knows
3351 ** that the supplied string is nul-terminated, then there is a small
3352 ** performance advantage to be gained by passing an nByte parameter that
3353 ** is equal to the number of bytes in the input string <i>including</i>
3354 ** the nul-terminator bytes as this saves SQLite from having to
3355 ** make a copy of the input string.
3356 **
3357 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3358 ** past the end of the first SQL statement in zSql.  These routines only
3359 ** compile the first statement in zSql, so *pzTail is left pointing to
3360 ** what remains uncompiled.
3361 **
3362 ** ^*ppStmt is left pointing to a compiled [prepared statement] that can be
3363 ** executed using [sqlcipher3_step()].  ^If there is an error, *ppStmt is set
3364 ** to NULL.  ^If the input text contains no SQL (if the input is an empty
3365 ** string or a comment) then *ppStmt is set to NULL.
3366 ** The calling procedure is responsible for deleting the compiled
3367 ** SQL statement using [sqlcipher3_finalize()] after it has finished with it.
3368 ** ppStmt may not be NULL.
3369 **
3370 ** ^On success, the sqlcipher3_prepare() family of routines return [SQLCIPHER_OK];
3371 ** otherwise an [error code] is returned.
3372 **
3373 ** The sqlcipher3_prepare_v2() and sqlcipher3_prepare16_v2() interfaces are
3374 ** recommended for all new programs. The two older interfaces are retained
3375 ** for backwards compatibility, but their use is discouraged.
3376 ** ^In the "v2" interfaces, the prepared statement
3377 ** that is returned (the [sqlcipher3_stmt] object) contains a copy of the
3378 ** original SQL text. This causes the [sqlcipher3_step()] interface to
3379 ** behave differently in three ways:
3380 **
3381 ** <ol>
3382 ** <li>
3383 ** ^If the database schema changes, instead of returning [SQLCIPHER_SCHEMA] as it
3384 ** always used to do, [sqlcipher3_step()] will automatically recompile the SQL
3385 ** statement and try to run it again.
3386 ** </li>
3387 **
3388 ** <li>
3389 ** ^When an error occurs, [sqlcipher3_step()] will return one of the detailed
3390 ** [error codes] or [extended error codes].  ^The legacy behavior was that
3391 ** [sqlcipher3_step()] would only return a generic [SQLCIPHER_ERROR] result code
3392 ** and the application would have to make a second call to [sqlcipher3_reset()]
3393 ** in order to find the underlying cause of the problem. With the "v2" prepare
3394 ** interfaces, the underlying reason for the error is returned immediately.
3395 ** </li>
3396 **
3397 ** <li>
3398 ** ^If the specific value bound to [parameter | host parameter] in the 
3399 ** WHERE clause might influence the choice of query plan for a statement,
3400 ** then the statement will be automatically recompiled, as if there had been 
3401 ** a schema change, on the first  [sqlcipher3_step()] call following any change
3402 ** to the [sqlcipher3_bind_text | bindings] of that [parameter]. 
3403 ** ^The specific value of WHERE-clause [parameter] might influence the 
3404 ** choice of query plan if the parameter is the left-hand side of a [LIKE]
3405 ** or [GLOB] operator or if the parameter is compared to an indexed column
3406 ** and the [SQLCIPHER_ENABLE_STAT3] compile-time option is enabled.
3407 ** the 
3408 ** </li>
3409 ** </ol>
3410 */
3411 SQLCIPHER_API int sqlcipher3_prepare(
3412   sqlcipher3 *db,            /* Database handle */
3413   const char *zSql,       /* SQL statement, UTF-8 encoded */
3414   int nByte,              /* Maximum length of zSql in bytes. */
3415   sqlcipher3_stmt **ppStmt,  /* OUT: Statement handle */
3416   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
3417 );
3418 SQLCIPHER_API int sqlcipher3_prepare_v2(
3419   sqlcipher3 *db,            /* Database handle */
3420   const char *zSql,       /* SQL statement, UTF-8 encoded */
3421   int nByte,              /* Maximum length of zSql in bytes. */
3422   sqlcipher3_stmt **ppStmt,  /* OUT: Statement handle */
3423   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
3424 );
3425 SQLCIPHER_API int sqlcipher3_prepare16(
3426   sqlcipher3 *db,            /* Database handle */
3427   const void *zSql,       /* SQL statement, UTF-16 encoded */
3428   int nByte,              /* Maximum length of zSql in bytes. */
3429   sqlcipher3_stmt **ppStmt,  /* OUT: Statement handle */
3430   const void **pzTail     /* OUT: Pointer to unused portion of zSql */
3431 );
3432 SQLCIPHER_API int sqlcipher3_prepare16_v2(
3433   sqlcipher3 *db,            /* Database handle */
3434   const void *zSql,       /* SQL statement, UTF-16 encoded */
3435   int nByte,              /* Maximum length of zSql in bytes. */
3436   sqlcipher3_stmt **ppStmt,  /* OUT: Statement handle */
3437   const void **pzTail     /* OUT: Pointer to unused portion of zSql */
3438 );
3439
3440 /*
3441 ** CAPI3REF: Retrieving Statement SQL
3442 **
3443 ** ^This interface can be used to retrieve a saved copy of the original
3444 ** SQL text used to create a [prepared statement] if that statement was
3445 ** compiled using either [sqlcipher3_prepare_v2()] or [sqlcipher3_prepare16_v2()].
3446 */
3447 SQLCIPHER_API const char *sqlcipher3_sql(sqlcipher3_stmt *pStmt);
3448
3449 /*
3450 ** CAPI3REF: Determine If An SQL Statement Writes The Database
3451 **
3452 ** ^The sqlcipher3_stmt_readonly(X) interface returns true (non-zero) if
3453 ** and only if the [prepared statement] X makes no direct changes to
3454 ** the content of the database file.
3455 **
3456 ** Note that [application-defined SQL functions] or
3457 ** [virtual tables] might change the database indirectly as a side effect.  
3458 ** ^(For example, if an application defines a function "eval()" that 
3459 ** calls [sqlcipher3_exec()], then the following SQL statement would
3460 ** change the database file through side-effects:
3461 **
3462 ** <blockquote><pre>
3463 **    SELECT eval('DELETE FROM t1') FROM t2;
3464 ** </pre></blockquote>
3465 **
3466 ** But because the [SELECT] statement does not change the database file
3467 ** directly, sqlcipher3_stmt_readonly() would still return true.)^
3468 **
3469 ** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],
3470 ** [SAVEPOINT], and [RELEASE] cause sqlcipher3_stmt_readonly() to return true,
3471 ** since the statements themselves do not actually modify the database but
3472 ** rather they control the timing of when other statements modify the 
3473 ** database.  ^The [ATTACH] and [DETACH] statements also cause
3474 ** sqlcipher3_stmt_readonly() to return true since, while those statements
3475 ** change the configuration of a database connection, they do not make 
3476 ** changes to the content of the database files on disk.
3477 */
3478 SQLCIPHER_API int sqlcipher3_stmt_readonly(sqlcipher3_stmt *pStmt);
3479
3480 /*
3481 ** CAPI3REF: Dynamically Typed Value Object
3482 ** KEYWORDS: {protected sqlcipher3_value} {unprotected sqlcipher3_value}
3483 **
3484 ** SQLite uses the sqlcipher3_value object to represent all values
3485 ** that can be stored in a database table. SQLite uses dynamic typing
3486 ** for the values it stores.  ^Values stored in sqlcipher3_value objects
3487 ** can be integers, floating point values, strings, BLOBs, or NULL.
3488 **
3489 ** An sqlcipher3_value object may be either "protected" or "unprotected".
3490 ** Some interfaces require a protected sqlcipher3_value.  Other interfaces
3491 ** will accept either a protected or an unprotected sqlcipher3_value.
3492 ** Every interface that accepts sqlcipher3_value arguments specifies
3493 ** whether or not it requires a protected sqlcipher3_value.
3494 **
3495 ** The terms "protected" and "unprotected" refer to whether or not
3496 ** a mutex is held.  An internal mutex is held for a protected
3497 ** sqlcipher3_value object but no mutex is held for an unprotected
3498 ** sqlcipher3_value object.  If SQLite is compiled to be single-threaded
3499 ** (with [SQLCIPHER_THREADSAFE=0] and with [sqlcipher3_threadsafe()] returning 0)
3500 ** or if SQLite is run in one of reduced mutex modes 
3501 ** [SQLCIPHER_CONFIG_SINGLETHREAD] or [SQLCIPHER_CONFIG_MULTITHREAD]
3502 ** then there is no distinction between protected and unprotected
3503 ** sqlcipher3_value objects and they can be used interchangeably.  However,
3504 ** for maximum code portability it is recommended that applications
3505 ** still make the distinction between protected and unprotected
3506 ** sqlcipher3_value objects even when not strictly required.
3507 **
3508 ** ^The sqlcipher3_value objects that are passed as parameters into the
3509 ** implementation of [application-defined SQL functions] are protected.
3510 ** ^The sqlcipher3_value object returned by
3511 ** [sqlcipher3_column_value()] is unprotected.
3512 ** Unprotected sqlcipher3_value objects may only be used with
3513 ** [sqlcipher3_result_value()] and [sqlcipher3_bind_value()].
3514 ** The [sqlcipher3_value_blob | sqlcipher3_value_type()] family of
3515 ** interfaces require protected sqlcipher3_value objects.
3516 */
3517 typedef struct Mem sqlcipher3_value;
3518
3519 /*
3520 ** CAPI3REF: SQL Function Context Object
3521 **
3522 ** The context in which an SQL function executes is stored in an
3523 ** sqlcipher3_context object.  ^A pointer to an sqlcipher3_context object
3524 ** is always first parameter to [application-defined SQL functions].
3525 ** The application-defined SQL function implementation will pass this
3526 ** pointer through into calls to [sqlcipher3_result_int | sqlcipher3_result()],
3527 ** [sqlcipher3_aggregate_context()], [sqlcipher3_user_data()],
3528 ** [sqlcipher3_context_db_handle()], [sqlcipher3_get_auxdata()],
3529 ** and/or [sqlcipher3_set_auxdata()].
3530 */
3531 typedef struct sqlcipher3_context sqlcipher3_context;
3532
3533 /*
3534 ** CAPI3REF: Binding Values To Prepared Statements
3535 ** KEYWORDS: {host parameter} {host parameters} {host parameter name}
3536 ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
3537 **
3538 ** ^(In the SQL statement text input to [sqlcipher3_prepare_v2()] and its variants,
3539 ** literals may be replaced by a [parameter] that matches one of following
3540 ** templates:
3541 **
3542 ** <ul>
3543 ** <li>  ?
3544 ** <li>  ?NNN
3545 ** <li>  :VVV
3546 ** <li>  @VVV
3547 ** <li>  $VVV
3548 ** </ul>
3549 **
3550 ** In the templates above, NNN represents an integer literal,
3551 ** and VVV represents an alphanumeric identifier.)^  ^The values of these
3552 ** parameters (also called "host parameter names" or "SQL parameters")
3553 ** can be set using the sqlcipher3_bind_*() routines defined here.
3554 **
3555 ** ^The first argument to the sqlcipher3_bind_*() routines is always
3556 ** a pointer to the [sqlcipher3_stmt] object returned from
3557 ** [sqlcipher3_prepare_v2()] or its variants.
3558 **
3559 ** ^The second argument is the index of the SQL parameter to be set.
3560 ** ^The leftmost SQL parameter has an index of 1.  ^When the same named
3561 ** SQL parameter is used more than once, second and subsequent
3562 ** occurrences have the same index as the first occurrence.
3563 ** ^The index for named parameters can be looked up using the
3564 ** [sqlcipher3_bind_parameter_index()] API if desired.  ^The index
3565 ** for "?NNN" parameters is the value of NNN.
3566 ** ^The NNN value must be between 1 and the [sqlcipher3_limit()]
3567 ** parameter [SQLCIPHER_LIMIT_VARIABLE_NUMBER] (default value: 999).
3568 **
3569 ** ^The third argument is the value to bind to the parameter.
3570 **
3571 ** ^(In those routines that have a fourth argument, its value is the
3572 ** number of bytes in the parameter.  To be clear: the value is the
3573 ** number of <u>bytes</u> in the value, not the number of characters.)^
3574 ** ^If the fourth parameter is negative, the length of the string is
3575 ** the number of bytes up to the first zero terminator.
3576 ** If a non-negative fourth parameter is provided to sqlcipher3_bind_text()
3577 ** or sqlcipher3_bind_text16() then that parameter must be the byte offset
3578 ** where the NUL terminator would occur assuming the string were NUL
3579 ** terminated.  If any NUL characters occur at byte offsets less than 
3580 ** the value of the fourth parameter then the resulting string value will
3581 ** contain embedded NULs.  The result of expressions involving strings
3582 ** with embedded NULs is undefined.
3583 **
3584 ** ^The fifth argument to sqlcipher3_bind_blob(), sqlcipher3_bind_text(), and
3585 ** sqlcipher3_bind_text16() is a destructor used to dispose of the BLOB or
3586 ** string after SQLite has finished with it.  ^The destructor is called
3587 ** to dispose of the BLOB or string even if the call to sqlcipher3_bind_blob(),
3588 ** sqlcipher3_bind_text(), or sqlcipher3_bind_text16() fails.  
3589 ** ^If the fifth argument is
3590 ** the special value [SQLCIPHER_STATIC], then SQLite assumes that the
3591 ** information is in static, unmanaged space and does not need to be freed.
3592 ** ^If the fifth argument has the value [SQLCIPHER_TRANSIENT], then
3593 ** SQLite makes its own private copy of the data immediately, before
3594 ** the sqlcipher3_bind_*() routine returns.
3595 **
3596 ** ^The sqlcipher3_bind_zeroblob() routine binds a BLOB of length N that
3597 ** is filled with zeroes.  ^A zeroblob uses a fixed amount of memory
3598 ** (just an integer to hold its size) while it is being processed.
3599 ** Zeroblobs are intended to serve as placeholders for BLOBs whose
3600 ** content is later written using
3601 ** [sqlcipher3_blob_open | incremental BLOB I/O] routines.
3602 ** ^A negative value for the zeroblob results in a zero-length BLOB.
3603 **
3604 ** ^If any of the sqlcipher3_bind_*() routines are called with a NULL pointer
3605 ** for the [prepared statement] or with a prepared statement for which
3606 ** [sqlcipher3_step()] has been called more recently than [sqlcipher3_reset()],
3607 ** then the call will return [SQLCIPHER_MISUSE].  If any sqlcipher3_bind_()
3608 ** routine is passed a [prepared statement] that has been finalized, the
3609 ** result is undefined and probably harmful.
3610 **
3611 ** ^Bindings are not cleared by the [sqlcipher3_reset()] routine.
3612 ** ^Unbound parameters are interpreted as NULL.
3613 **
3614 ** ^The sqlcipher3_bind_* routines return [SQLCIPHER_OK] on success or an
3615 ** [error code] if anything goes wrong.
3616 ** ^[SQLCIPHER_RANGE] is returned if the parameter
3617 ** index is out of range.  ^[SQLCIPHER_NOMEM] is returned if malloc() fails.
3618 **
3619 ** See also: [sqlcipher3_bind_parameter_count()],
3620 ** [sqlcipher3_bind_parameter_name()], and [sqlcipher3_bind_parameter_index()].
3621 */
3622 SQLCIPHER_API int sqlcipher3_bind_blob(sqlcipher3_stmt*, int, const void*, int n, void(*)(void*));
3623 SQLCIPHER_API int sqlcipher3_bind_double(sqlcipher3_stmt*, int, double);
3624 SQLCIPHER_API int sqlcipher3_bind_int(sqlcipher3_stmt*, int, int);
3625 SQLCIPHER_API int sqlcipher3_bind_int64(sqlcipher3_stmt*, int, sqlcipher3_int64);
3626 SQLCIPHER_API int sqlcipher3_bind_null(sqlcipher3_stmt*, int);
3627 SQLCIPHER_API int sqlcipher3_bind_text(sqlcipher3_stmt*, int, const char*, int n, void(*)(void*));
3628 SQLCIPHER_API int sqlcipher3_bind_text16(sqlcipher3_stmt*, int, const void*, int, void(*)(void*));
3629 SQLCIPHER_API int sqlcipher3_bind_value(sqlcipher3_stmt*, int, const sqlcipher3_value*);
3630 SQLCIPHER_API int sqlcipher3_bind_zeroblob(sqlcipher3_stmt*, int, int n);
3631
3632 /*
3633 ** CAPI3REF: Number Of SQL Parameters
3634 **
3635 ** ^This routine can be used to find the number of [SQL parameters]
3636 ** in a [prepared statement].  SQL parameters are tokens of the
3637 ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
3638 ** placeholders for values that are [sqlcipher3_bind_blob | bound]
3639 ** to the parameters at a later time.
3640 **
3641 ** ^(This routine actually returns the index of the largest (rightmost)
3642 ** parameter. For all forms except ?NNN, this will correspond to the
3643 ** number of unique parameters.  If parameters of the ?NNN form are used,
3644 ** there may be gaps in the list.)^
3645 **
3646 ** See also: [sqlcipher3_bind_blob|sqlcipher3_bind()],
3647 ** [sqlcipher3_bind_parameter_name()], and
3648 ** [sqlcipher3_bind_parameter_index()].
3649 */
3650 SQLCIPHER_API int sqlcipher3_bind_parameter_count(sqlcipher3_stmt*);
3651
3652 /*
3653 ** CAPI3REF: Name Of A Host Parameter
3654 **
3655 ** ^The sqlcipher3_bind_parameter_name(P,N) interface returns
3656 ** the name of the N-th [SQL parameter] in the [prepared statement] P.
3657 ** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
3658 ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
3659 ** respectively.
3660 ** In other words, the initial ":" or "$" or "@" or "?"
3661 ** is included as part of the name.)^
3662 ** ^Parameters of the form "?" without a following integer have no name
3663 ** and are referred to as "nameless" or "anonymous parameters".
3664 **
3665 ** ^The first host parameter has an index of 1, not 0.
3666 **
3667 ** ^If the value N is out of range or if the N-th parameter is
3668 ** nameless, then NULL is returned.  ^The returned string is
3669 ** always in UTF-8 encoding even if the named parameter was
3670 ** originally specified as UTF-16 in [sqlcipher3_prepare16()] or
3671 ** [sqlcipher3_prepare16_v2()].
3672 **
3673 ** See also: [sqlcipher3_bind_blob|sqlcipher3_bind()],
3674 ** [sqlcipher3_bind_parameter_count()], and
3675 ** [sqlcipher3_bind_parameter_index()].
3676 */
3677 SQLCIPHER_API const char *sqlcipher3_bind_parameter_name(sqlcipher3_stmt*, int);
3678
3679 /*
3680 ** CAPI3REF: Index Of A Parameter With A Given Name
3681 **
3682 ** ^Return the index of an SQL parameter given its name.  ^The
3683 ** index value returned is suitable for use as the second
3684 ** parameter to [sqlcipher3_bind_blob|sqlcipher3_bind()].  ^A zero
3685 ** is returned if no matching parameter is found.  ^The parameter
3686 ** name must be given in UTF-8 even if the original statement
3687 ** was prepared from UTF-16 text using [sqlcipher3_prepare16_v2()].
3688 **
3689 ** See also: [sqlcipher3_bind_blob|sqlcipher3_bind()],
3690 ** [sqlcipher3_bind_parameter_count()], and
3691 ** [sqlcipher3_bind_parameter_index()].
3692 */
3693 SQLCIPHER_API int sqlcipher3_bind_parameter_index(sqlcipher3_stmt*, const char *zName);
3694
3695 /*
3696 ** CAPI3REF: Reset All Bindings On A Prepared Statement
3697 **
3698 ** ^Contrary to the intuition of many, [sqlcipher3_reset()] does not reset
3699 ** the [sqlcipher3_bind_blob | bindings] on a [prepared statement].
3700 ** ^Use this routine to reset all host parameters to NULL.
3701 */
3702 SQLCIPHER_API int sqlcipher3_clear_bindings(sqlcipher3_stmt*);
3703
3704 /*
3705 ** CAPI3REF: Number Of Columns In A Result Set
3706 **
3707 ** ^Return the number of columns in the result set returned by the
3708 ** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
3709 ** statement that does not return data (for example an [UPDATE]).
3710 **
3711 ** See also: [sqlcipher3_data_count()]
3712 */
3713 SQLCIPHER_API int sqlcipher3_column_count(sqlcipher3_stmt *pStmt);
3714
3715 /*
3716 ** CAPI3REF: Column Names In A Result Set
3717 **
3718 ** ^These routines return the name assigned to a particular column
3719 ** in the result set of a [SELECT] statement.  ^The sqlcipher3_column_name()
3720 ** interface returns a pointer to a zero-terminated UTF-8 string
3721 ** and sqlcipher3_column_name16() returns a pointer to a zero-terminated
3722 ** UTF-16 string.  ^The first parameter is the [prepared statement]
3723 ** that implements the [SELECT] statement. ^The second parameter is the
3724 ** column number.  ^The leftmost column is number 0.
3725 **
3726 ** ^The returned string pointer is valid until either the [prepared statement]
3727 ** is destroyed by [sqlcipher3_finalize()] or until the statement is automatically
3728 ** reprepared by the first call to [sqlcipher3_step()] for a particular run
3729 ** or until the next call to
3730 ** sqlcipher3_column_name() or sqlcipher3_column_name16() on the same column.
3731 **
3732 ** ^If sqlcipher3_malloc() fails during the processing of either routine
3733 ** (for example during a conversion from UTF-8 to UTF-16) then a
3734 ** NULL pointer is returned.
3735 **
3736 ** ^The name of a result column is the value of the "AS" clause for
3737 ** that column, if there is an AS clause.  If there is no AS clause
3738 ** then the name of the column is unspecified and may change from
3739 ** one release of SQLite to the next.
3740 */
3741 SQLCIPHER_API const char *sqlcipher3_column_name(sqlcipher3_stmt*, int N);
3742 SQLCIPHER_API const void *sqlcipher3_column_name16(sqlcipher3_stmt*, int N);
3743
3744 /*
3745 ** CAPI3REF: Source Of Data In A Query Result
3746 **
3747 ** ^These routines provide a means to determine the database, table, and
3748 ** table column that is the origin of a particular result column in
3749 ** [SELECT] statement.
3750 ** ^The name of the database or table or column can be returned as
3751 ** either a UTF-8 or UTF-16 string.  ^The _database_ routines return
3752 ** the database name, the _table_ routines return the table name, and
3753 ** the origin_ routines return the column name.
3754 ** ^The returned string is valid until the [prepared statement] is destroyed
3755 ** using [sqlcipher3_finalize()] or until the statement is automatically
3756 ** reprepared by the first call to [sqlcipher3_step()] for a particular run
3757 ** or until the same information is requested
3758 ** again in a different encoding.
3759 **
3760 ** ^The names returned are the original un-aliased names of the
3761 ** database, table, and column.
3762 **
3763 ** ^The first argument to these interfaces is a [prepared statement].
3764 ** ^These functions return information about the Nth result column returned by
3765 ** the statement, where N is the second function argument.
3766 ** ^The left-most column is column 0 for these routines.
3767 **
3768 ** ^If the Nth column returned by the statement is an expression or
3769 ** subquery and is not a column value, then all of these functions return
3770 ** NULL.  ^These routine might also return NULL if a memory allocation error
3771 ** occurs.  ^Otherwise, they return the name of the attached database, table,
3772 ** or column that query result column was extracted from.
3773 **
3774 ** ^As with all other SQLite APIs, those whose names end with "16" return
3775 ** UTF-16 encoded strings and the other functions return UTF-8.
3776 **
3777 ** ^These APIs are only available if the library was compiled with the
3778 ** [SQLCIPHER_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
3779 **
3780 ** If two or more threads call one or more of these routines against the same
3781 ** prepared statement and column at the same time then the results are
3782 ** undefined.
3783 **
3784 ** If two or more threads call one or more
3785 ** [sqlcipher3_column_database_name | column metadata interfaces]
3786 ** for the same [prepared statement] and result column
3787 ** at the same time then the results are undefined.
3788 */
3789 SQLCIPHER_API const char *sqlcipher3_column_database_name(sqlcipher3_stmt*,int);
3790 SQLCIPHER_API const void *sqlcipher3_column_database_name16(sqlcipher3_stmt*,int);
3791 SQLCIPHER_API const char *sqlcipher3_column_table_name(sqlcipher3_stmt*,int);
3792 SQLCIPHER_API const void *sqlcipher3_column_table_name16(sqlcipher3_stmt*,int);
3793 SQLCIPHER_API const char *sqlcipher3_column_origin_name(sqlcipher3_stmt*,int);
3794 SQLCIPHER_API const void *sqlcipher3_column_origin_name16(sqlcipher3_stmt*,int);
3795
3796 /*
3797 ** CAPI3REF: Declared Datatype Of A Query Result
3798 **
3799 ** ^(The first parameter is a [prepared statement].
3800 ** If this statement is a [SELECT] statement and the Nth column of the
3801 ** returned result set of that [SELECT] is a table column (not an
3802 ** expression or subquery) then the declared type of the table
3803 ** column is returned.)^  ^If the Nth column of the result set is an
3804 ** expression or subquery, then a NULL pointer is returned.
3805 ** ^The returned string is always UTF-8 encoded.
3806 **
3807 ** ^(For example, given the database schema:
3808 **
3809 ** CREATE TABLE t1(c1 VARIANT);
3810 **
3811 ** and the following statement to be compiled:
3812 **
3813 ** SELECT c1 + 1, c1 FROM t1;
3814 **
3815 ** this routine would return the string "VARIANT" for the second result
3816 ** column (i==1), and a NULL pointer for the first result column (i==0).)^
3817 **
3818 ** ^SQLite uses dynamic run-time typing.  ^So just because a column
3819 ** is declared to contain a particular type does not mean that the
3820 ** data stored in that column is of the declared type.  SQLite is
3821 ** strongly typed, but the typing is dynamic not static.  ^Type
3822 ** is associated with individual values, not with the containers
3823 ** used to hold those values.
3824 */
3825 SQLCIPHER_API const char *sqlcipher3_column_decltype(sqlcipher3_stmt*,int);
3826 SQLCIPHER_API const void *sqlcipher3_column_decltype16(sqlcipher3_stmt*,int);
3827
3828 /*
3829 ** CAPI3REF: Evaluate An SQL Statement
3830 **
3831 ** After a [prepared statement] has been prepared using either
3832 ** [sqlcipher3_prepare_v2()] or [sqlcipher3_prepare16_v2()] or one of the legacy
3833 ** interfaces [sqlcipher3_prepare()] or [sqlcipher3_prepare16()], this function
3834 ** must be called one or more times to evaluate the statement.
3835 **
3836 ** The details of the behavior of the sqlcipher3_step() interface depend
3837 ** on whether the statement was prepared using the newer "v2" interface
3838 ** [sqlcipher3_prepare_v2()] and [sqlcipher3_prepare16_v2()] or the older legacy
3839 ** interface [sqlcipher3_prepare()] and [sqlcipher3_prepare16()].  The use of the
3840 ** new "v2" interface is recommended for new applications but the legacy
3841 ** interface will continue to be supported.
3842 **
3843 ** ^In the legacy interface, the return value will be either [SQLCIPHER_BUSY],
3844 ** [SQLCIPHER_DONE], [SQLCIPHER_ROW], [SQLCIPHER_ERROR], or [SQLCIPHER_MISUSE].
3845 ** ^With the "v2" interface, any of the other [result codes] or
3846 ** [extended result codes] might be returned as well.
3847 **
3848 ** ^[SQLCIPHER_BUSY] means that the database engine was unable to acquire the
3849 ** database locks it needs to do its job.  ^If the statement is a [COMMIT]
3850 ** or occurs outside of an explicit transaction, then you can retry the
3851 ** statement.  If the statement is not a [COMMIT] and occurs within an
3852 ** explicit transaction then you should rollback the transaction before
3853 ** continuing.
3854 **
3855 ** ^[SQLCIPHER_DONE] means that the statement has finished executing
3856 ** successfully.  sqlcipher3_step() should not be called again on this virtual
3857 ** machine without first calling [sqlcipher3_reset()] to reset the virtual
3858 ** machine back to its initial state.
3859 **
3860 ** ^If the SQL statement being executed returns any data, then [SQLCIPHER_ROW]
3861 ** is returned each time a new row of data is ready for processing by the
3862 ** caller. The values may be accessed using the [column access functions].
3863 ** sqlcipher3_step() is called again to retrieve the next row of data.
3864 **
3865 ** ^[SQLCIPHER_ERROR] means that a run-time error (such as a constraint
3866 ** violation) has occurred.  sqlcipher3_step() should not be called again on
3867 ** the VM. More information may be found by calling [sqlcipher3_errmsg()].
3868 ** ^With the legacy interface, a more specific error code (for example,
3869 ** [SQLCIPHER_INTERRUPT], [SQLCIPHER_SCHEMA], [SQLCIPHER_CORRUPT], and so forth)
3870 ** can be obtained by calling [sqlcipher3_reset()] on the
3871 ** [prepared statement].  ^In the "v2" interface,
3872 ** the more specific error code is returned directly by sqlcipher3_step().
3873 **
3874 ** [SQLCIPHER_MISUSE] means that the this routine was called inappropriately.
3875 ** Perhaps it was called on a [prepared statement] that has
3876 ** already been [sqlcipher3_finalize | finalized] or on one that had
3877 ** previously returned [SQLCIPHER_ERROR] or [SQLCIPHER_DONE].  Or it could
3878 ** be the case that the same database connection is being used by two or
3879 ** more threads at the same moment in time.
3880 **
3881 ** For all versions of SQLite up to and including 3.6.23.1, a call to
3882 ** [sqlcipher3_reset()] was required after sqlcipher3_step() returned anything
3883 ** other than [SQLCIPHER_ROW] before any subsequent invocation of
3884 ** sqlcipher3_step().  Failure to reset the prepared statement using 
3885 ** [sqlcipher3_reset()] would result in an [SQLCIPHER_MISUSE] return from
3886 ** sqlcipher3_step().  But after version 3.6.23.1, sqlcipher3_step() began
3887 ** calling [sqlcipher3_reset()] automatically in this circumstance rather
3888 ** than returning [SQLCIPHER_MISUSE].  This is not considered a compatibility
3889 ** break because any application that ever receives an SQLCIPHER_MISUSE error
3890 ** is broken by definition.  The [SQLCIPHER_OMIT_AUTORESET] compile-time option
3891 ** can be used to restore the legacy behavior.
3892 **
3893 ** <b>Goofy Interface Alert:</b> In the legacy interface, the sqlcipher3_step()
3894 ** API always returns a generic error code, [SQLCIPHER_ERROR], following any
3895 ** error other than [SQLCIPHER_BUSY] and [SQLCIPHER_MISUSE].  You must call
3896 ** [sqlcipher3_reset()] or [sqlcipher3_finalize()] in order to find one of the
3897 ** specific [error codes] that better describes the error.
3898 ** We admit that this is a goofy design.  The problem has been fixed
3899 ** with the "v2" interface.  If you prepare all of your SQL statements
3900 ** using either [sqlcipher3_prepare_v2()] or [sqlcipher3_prepare16_v2()] instead
3901 ** of the legacy [sqlcipher3_prepare()] and [sqlcipher3_prepare16()] interfaces,
3902 ** then the more specific [error codes] are returned directly
3903 ** by sqlcipher3_step().  The use of the "v2" interface is recommended.
3904 */
3905 SQLCIPHER_API int sqlcipher3_step(sqlcipher3_stmt*);
3906
3907 /*
3908 ** CAPI3REF: Number of columns in a result set
3909 **
3910 ** ^The sqlcipher3_data_count(P) interface returns the number of columns in the
3911 ** current row of the result set of [prepared statement] P.
3912 ** ^If prepared statement P does not have results ready to return
3913 ** (via calls to the [sqlcipher3_column_int | sqlcipher3_column_*()] of
3914 ** interfaces) then sqlcipher3_data_count(P) returns 0.
3915 ** ^The sqlcipher3_data_count(P) routine also returns 0 if P is a NULL pointer.
3916 ** ^The sqlcipher3_data_count(P) routine returns 0 if the previous call to
3917 ** [sqlcipher3_step](P) returned [SQLCIPHER_DONE].  ^The sqlcipher3_data_count(P)
3918 ** will return non-zero if previous call to [sqlcipher3_step](P) returned
3919 ** [SQLCIPHER_ROW], except in the case of the [PRAGMA incremental_vacuum]
3920 ** where it always returns zero since each step of that multi-step
3921 ** pragma returns 0 columns of data.
3922 **
3923 ** See also: [sqlcipher3_column_count()]
3924 */
3925 SQLCIPHER_API int sqlcipher3_data_count(sqlcipher3_stmt *pStmt);
3926
3927 /*
3928 ** CAPI3REF: Fundamental Datatypes
3929 ** KEYWORDS: SQLCIPHER_TEXT
3930 **
3931 ** ^(Every value in SQLite has one of five fundamental datatypes:
3932 **
3933 ** <ul>
3934 ** <li> 64-bit signed integer
3935 ** <li> 64-bit IEEE floating point number
3936 ** <li> string
3937 ** <li> BLOB
3938 ** <li> NULL
3939 ** </ul>)^
3940 **
3941 ** These constants are codes for each of those types.
3942 **
3943 ** Note that the SQLCIPHER_TEXT constant was also used in SQLite version 2
3944 ** for a completely different meaning.  Software that links against both
3945 ** SQLite version 2 and SQLite version 3 should use SQLCIPHER3_TEXT, not
3946 ** SQLCIPHER_TEXT.
3947 */
3948 #define SQLCIPHER_INTEGER  1
3949 #define SQLCIPHER_FLOAT    2
3950 #define SQLCIPHER_BLOB     4
3951 #define SQLCIPHER_NULL     5
3952 #ifdef SQLCIPHER_TEXT
3953 # undef SQLCIPHER_TEXT
3954 #else
3955 # define SQLCIPHER_TEXT     3
3956 #endif
3957 #define SQLCIPHER3_TEXT     3
3958
3959 /*
3960 ** CAPI3REF: Result Values From A Query
3961 ** KEYWORDS: {column access functions}
3962 **
3963 ** These routines form the "result set" interface.
3964 **
3965 ** ^These routines return information about a single column of the current
3966 ** result row of a query.  ^In every case the first argument is a pointer
3967 ** to the [prepared statement] that is being evaluated (the [sqlcipher3_stmt*]
3968 ** that was returned from [sqlcipher3_prepare_v2()] or one of its variants)
3969 ** and the second argument is the index of the column for which information
3970 ** should be returned. ^The leftmost column of the result set has the index 0.
3971 ** ^The number of columns in the result can be determined using
3972 ** [sqlcipher3_column_count()].
3973 **
3974 ** If the SQL statement does not currently point to a valid row, or if the
3975 ** column index is out of range, the result is undefined.
3976 ** These routines may only be called when the most recent call to
3977 ** [sqlcipher3_step()] has returned [SQLCIPHER_ROW] and neither
3978 ** [sqlcipher3_reset()] nor [sqlcipher3_finalize()] have been called subsequently.
3979 ** If any of these routines are called after [sqlcipher3_reset()] or
3980 ** [sqlcipher3_finalize()] or after [sqlcipher3_step()] has returned
3981 ** something other than [SQLCIPHER_ROW], the results are undefined.
3982 ** If [sqlcipher3_step()] or [sqlcipher3_reset()] or [sqlcipher3_finalize()]
3983 ** are called from a different thread while any of these routines
3984 ** are pending, then the results are undefined.
3985 **
3986 ** ^The sqlcipher3_column_type() routine returns the
3987 ** [SQLCIPHER_INTEGER | datatype code] for the initial data type
3988 ** of the result column.  ^The returned value is one of [SQLCIPHER_INTEGER],
3989 ** [SQLCIPHER_FLOAT], [SQLCIPHER_TEXT], [SQLCIPHER_BLOB], or [SQLCIPHER_NULL].  The value
3990 ** returned by sqlcipher3_column_type() is only meaningful if no type
3991 ** conversions have occurred as described below.  After a type conversion,
3992 ** the value returned by sqlcipher3_column_type() is undefined.  Future
3993 ** versions of SQLite may change the behavior of sqlcipher3_column_type()
3994 ** following a type conversion.
3995 **
3996 ** ^If the result is a BLOB or UTF-8 string then the sqlcipher3_column_bytes()
3997 ** routine returns the number of bytes in that BLOB or string.
3998 ** ^If the result is a UTF-16 string, then sqlcipher3_column_bytes() converts
3999 ** the string to UTF-8 and then returns the number of bytes.
4000 ** ^If the result is a numeric value then sqlcipher3_column_bytes() uses
4001 ** [sqlcipher3_snprintf()] to convert that value to a UTF-8 string and returns
4002 ** the number of bytes in that string.
4003 ** ^If the result is NULL, then sqlcipher3_column_bytes() returns zero.
4004 **
4005 ** ^If the result is a BLOB or UTF-16 string then the sqlcipher3_column_bytes16()
4006 ** routine returns the number of bytes in that BLOB or string.
4007 ** ^If the result is a UTF-8 string, then sqlcipher3_column_bytes16() converts
4008 ** the string to UTF-16 and then returns the number of bytes.
4009 ** ^If the result is a numeric value then sqlcipher3_column_bytes16() uses
4010 ** [sqlcipher3_snprintf()] to convert that value to a UTF-16 string and returns
4011 ** the number of bytes in that string.
4012 ** ^If the result is NULL, then sqlcipher3_column_bytes16() returns zero.
4013 **
4014 ** ^The values returned by [sqlcipher3_column_bytes()] and 
4015 ** [sqlcipher3_column_bytes16()] do not include the zero terminators at the end
4016 ** of the string.  ^For clarity: the values returned by
4017 ** [sqlcipher3_column_bytes()] and [sqlcipher3_column_bytes16()] are the number of
4018 ** bytes in the string, not the number of characters.
4019 **
4020 ** ^Strings returned by sqlcipher3_column_text() and sqlcipher3_column_text16(),
4021 ** even empty strings, are always zero terminated.  ^The return
4022 ** value from sqlcipher3_column_blob() for a zero-length BLOB is a NULL pointer.
4023 **
4024 ** ^The object returned by [sqlcipher3_column_value()] is an
4025 ** [unprotected sqlcipher3_value] object.  An unprotected sqlcipher3_value object
4026 ** may only be used with [sqlcipher3_bind_value()] and [sqlcipher3_result_value()].
4027 ** If the [unprotected sqlcipher3_value] object returned by
4028 ** [sqlcipher3_column_value()] is used in any other way, including calls
4029 ** to routines like [sqlcipher3_value_int()], [sqlcipher3_value_text()],
4030 ** or [sqlcipher3_value_bytes()], then the behavior is undefined.
4031 **
4032 ** These routines attempt to convert the value where appropriate.  ^For
4033 ** example, if the internal representation is FLOAT and a text result
4034 ** is requested, [sqlcipher3_snprintf()] is used internally to perform the
4035 ** conversion automatically.  ^(The following table details the conversions
4036 ** that are applied:
4037 **
4038 ** <blockquote>
4039 ** <table border="1">
4040 ** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
4041 **
4042 ** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
4043 ** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
4044 ** <tr><td>  NULL    <td>   TEXT    <td> Result is NULL pointer
4045 ** <tr><td>  NULL    <td>   BLOB    <td> Result is NULL pointer
4046 ** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
4047 ** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
4048 ** <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
4049 ** <tr><td>  FLOAT   <td> INTEGER   <td> Convert from float to integer
4050 ** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
4051 ** <tr><td>  FLOAT   <td>   BLOB    <td> Same as FLOAT->TEXT
4052 ** <tr><td>  TEXT    <td> INTEGER   <td> Use atoi()
4053 ** <tr><td>  TEXT    <td>  FLOAT    <td> Use atof()
4054 ** <tr><td>  TEXT    <td>   BLOB    <td> No change
4055 ** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
4056 ** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
4057 ** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
4058 ** </table>
4059 ** </blockquote>)^
4060 **
4061 ** The table above makes reference to standard C library functions atoi()
4062 ** and atof().  SQLite does not really use these functions.  It has its
4063 ** own equivalent internal routines.  The atoi() and atof() names are
4064 ** used in the table for brevity and because they are familiar to most
4065 ** C programmers.
4066 **
4067 ** Note that when type conversions occur, pointers returned by prior
4068 ** calls to sqlcipher3_column_blob(), sqlcipher3_column_text(), and/or
4069 ** sqlcipher3_column_text16() may be invalidated.
4070 ** Type conversions and pointer invalidations might occur
4071 ** in the following cases:
4072 **
4073 ** <ul>
4074 ** <li> The initial content is a BLOB and sqlcipher3_column_text() or
4075 **      sqlcipher3_column_text16() is called.  A zero-terminator might
4076 **      need to be added to the string.</li>
4077 ** <li> The initial content is UTF-8 text and sqlcipher3_column_bytes16() or
4078 **      sqlcipher3_column_text16() is called.  The content must be converted
4079 **      to UTF-16.</li>
4080 ** <li> The initial content is UTF-16 text and sqlcipher3_column_bytes() or
4081 **      sqlcipher3_column_text() is called.  The content must be converted
4082 **      to UTF-8.</li>
4083 ** </ul>
4084 **
4085 ** ^Conversions between UTF-16be and UTF-16le are always done in place and do
4086 ** not invalidate a prior pointer, though of course the content of the buffer
4087 ** that the prior pointer references will have been modified.  Other kinds
4088 ** of conversion are done in place when it is possible, but sometimes they
4089 ** are not possible and in those cases prior pointers are invalidated.
4090 **
4091 ** The safest and easiest to remember policy is to invoke these routines
4092 ** in one of the following ways:
4093 **
4094 ** <ul>
4095 **  <li>sqlcipher3_column_text() followed by sqlcipher3_column_bytes()</li>
4096 **  <li>sqlcipher3_column_blob() followed by sqlcipher3_column_bytes()</li>
4097 **  <li>sqlcipher3_column_text16() followed by sqlcipher3_column_bytes16()</li>
4098 ** </ul>
4099 **
4100 ** In other words, you should call sqlcipher3_column_text(),
4101 ** sqlcipher3_column_blob(), or sqlcipher3_column_text16() first to force the result
4102 ** into the desired format, then invoke sqlcipher3_column_bytes() or
4103 ** sqlcipher3_column_bytes16() to find the size of the result.  Do not mix calls
4104 ** to sqlcipher3_column_text() or sqlcipher3_column_blob() with calls to
4105 ** sqlcipher3_column_bytes16(), and do not mix calls to sqlcipher3_column_text16()
4106 ** with calls to sqlcipher3_column_bytes().
4107 **
4108 ** ^The pointers returned are valid until a type conversion occurs as
4109 ** described above, or until [sqlcipher3_step()] or [sqlcipher3_reset()] or
4110 ** [sqlcipher3_finalize()] is called.  ^The memory space used to hold strings
4111 ** and BLOBs is freed automatically.  Do <b>not</b> pass the pointers returned
4112 ** [sqlcipher3_column_blob()], [sqlcipher3_column_text()], etc. into
4113 ** [sqlcipher3_free()].
4114 **
4115 ** ^(If a memory allocation error occurs during the evaluation of any
4116 ** of these routines, a default value is returned.  The default value
4117 ** is either the integer 0, the floating point number 0.0, or a NULL
4118 ** pointer.  Subsequent calls to [sqlcipher3_errcode()] will return
4119 ** [SQLCIPHER_NOMEM].)^
4120 */
4121 SQLCIPHER_API const void *sqlcipher3_column_blob(sqlcipher3_stmt*, int iCol);
4122 SQLCIPHER_API int sqlcipher3_column_bytes(sqlcipher3_stmt*, int iCol);
4123 SQLCIPHER_API int sqlcipher3_column_bytes16(sqlcipher3_stmt*, int iCol);
4124 SQLCIPHER_API double sqlcipher3_column_double(sqlcipher3_stmt*, int iCol);
4125 SQLCIPHER_API int sqlcipher3_column_int(sqlcipher3_stmt*, int iCol);
4126 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_column_int64(sqlcipher3_stmt*, int iCol);
4127 SQLCIPHER_API const unsigned char *sqlcipher3_column_text(sqlcipher3_stmt*, int iCol);
4128 SQLCIPHER_API const void *sqlcipher3_column_text16(sqlcipher3_stmt*, int iCol);
4129 SQLCIPHER_API int sqlcipher3_column_type(sqlcipher3_stmt*, int iCol);
4130 SQLCIPHER_API sqlcipher3_value *sqlcipher3_column_value(sqlcipher3_stmt*, int iCol);
4131
4132 /*
4133 ** CAPI3REF: Destroy A Prepared Statement Object
4134 **
4135 ** ^The sqlcipher3_finalize() function is called to delete a [prepared statement].
4136 ** ^If the most recent evaluation of the statement encountered no errors
4137 ** or if the statement is never been evaluated, then sqlcipher3_finalize() returns
4138 ** SQLCIPHER_OK.  ^If the most recent evaluation of statement S failed, then
4139 ** sqlcipher3_finalize(S) returns the appropriate [error code] or
4140 ** [extended error code].
4141 **
4142 ** ^The sqlcipher3_finalize(S) routine can be called at any point during
4143 ** the life cycle of [prepared statement] S:
4144 ** before statement S is ever evaluated, after
4145 ** one or more calls to [sqlcipher3_reset()], or after any call
4146 ** to [sqlcipher3_step()] regardless of whether or not the statement has
4147 ** completed execution.
4148 **
4149 ** ^Invoking sqlcipher3_finalize() on a NULL pointer is a harmless no-op.
4150 **
4151 ** The application must finalize every [prepared statement] in order to avoid
4152 ** resource leaks.  It is a grievous error for the application to try to use
4153 ** a prepared statement after it has been finalized.  Any use of a prepared
4154 ** statement after it has been finalized can result in undefined and
4155 ** undesirable behavior such as segfaults and heap corruption.
4156 */
4157 SQLCIPHER_API int sqlcipher3_finalize(sqlcipher3_stmt *pStmt);
4158
4159 /*
4160 ** CAPI3REF: Reset A Prepared Statement Object
4161 **
4162 ** The sqlcipher3_reset() function is called to reset a [prepared statement]
4163 ** object back to its initial state, ready to be re-executed.
4164 ** ^Any SQL statement variables that had values bound to them using
4165 ** the [sqlcipher3_bind_blob | sqlcipher3_bind_*() API] retain their values.
4166 ** Use [sqlcipher3_clear_bindings()] to reset the bindings.
4167 **
4168 ** ^The [sqlcipher3_reset(S)] interface resets the [prepared statement] S
4169 ** back to the beginning of its program.
4170 **
4171 ** ^If the most recent call to [sqlcipher3_step(S)] for the
4172 ** [prepared statement] S returned [SQLCIPHER_ROW] or [SQLCIPHER_DONE],
4173 ** or if [sqlcipher3_step(S)] has never before been called on S,
4174 ** then [sqlcipher3_reset(S)] returns [SQLCIPHER_OK].
4175 **
4176 ** ^If the most recent call to [sqlcipher3_step(S)] for the
4177 ** [prepared statement] S indicated an error, then
4178 ** [sqlcipher3_reset(S)] returns an appropriate [error code].
4179 **
4180 ** ^The [sqlcipher3_reset(S)] interface does not change the values
4181 ** of any [sqlcipher3_bind_blob|bindings] on the [prepared statement] S.
4182 */
4183 SQLCIPHER_API int sqlcipher3_reset(sqlcipher3_stmt *pStmt);
4184
4185 /*
4186 ** CAPI3REF: Create Or Redefine SQL Functions
4187 ** KEYWORDS: {function creation routines}
4188 ** KEYWORDS: {application-defined SQL function}
4189 ** KEYWORDS: {application-defined SQL functions}
4190 **
4191 ** ^These functions (collectively known as "function creation routines")
4192 ** are used to add SQL functions or aggregates or to redefine the behavior
4193 ** of existing SQL functions or aggregates.  The only differences between
4194 ** these routines are the text encoding expected for
4195 ** the second parameter (the name of the function being created)
4196 ** and the presence or absence of a destructor callback for
4197 ** the application data pointer.
4198 **
4199 ** ^The first parameter is the [database connection] to which the SQL
4200 ** function is to be added.  ^If an application uses more than one database
4201 ** connection then application-defined SQL functions must be added
4202 ** to each database connection separately.
4203 **
4204 ** ^The second parameter is the name of the SQL function to be created or
4205 ** redefined.  ^The length of the name is limited to 255 bytes in a UTF-8
4206 ** representation, exclusive of the zero-terminator.  ^Note that the name
4207 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.  
4208 ** ^Any attempt to create a function with a longer name
4209 ** will result in [SQLCIPHER_MISUSE] being returned.
4210 **
4211 ** ^The third parameter (nArg)
4212 ** is the number of arguments that the SQL function or
4213 ** aggregate takes. ^If this parameter is -1, then the SQL function or
4214 ** aggregate may take any number of arguments between 0 and the limit
4215 ** set by [sqlcipher3_limit]([SQLCIPHER_LIMIT_FUNCTION_ARG]).  If the third
4216 ** parameter is less than -1 or greater than 127 then the behavior is
4217 ** undefined.
4218 **
4219 ** ^The fourth parameter, eTextRep, specifies what
4220 ** [SQLCIPHER_UTF8 | text encoding] this SQL function prefers for
4221 ** its parameters.  Every SQL function implementation must be able to work
4222 ** with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
4223 ** more efficient with one encoding than another.  ^An application may
4224 ** invoke sqlcipher3_create_function() or sqlcipher3_create_function16() multiple
4225 ** times with the same function but with different values of eTextRep.
4226 ** ^When multiple implementations of the same function are available, SQLite
4227 ** will pick the one that involves the least amount of data conversion.
4228 ** If there is only a single implementation which does not care what text
4229 ** encoding is used, then the fourth argument should be [SQLCIPHER_ANY].
4230 **
4231 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
4232 ** function can gain access to this pointer using [sqlcipher3_user_data()].)^
4233 **
4234 ** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are
4235 ** pointers to C-language functions that implement the SQL function or
4236 ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
4237 ** callback only; NULL pointers must be passed as the xStep and xFinal
4238 ** parameters. ^An aggregate SQL function requires an implementation of xStep
4239 ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
4240 ** SQL function or aggregate, pass NULL pointers for all three function
4241 ** callbacks.
4242 **
4243 ** ^(If the ninth parameter to sqlcipher3_create_function_v2() is not NULL,
4244 ** then it is destructor for the application data pointer. 
4245 ** The destructor is invoked when the function is deleted, either by being
4246 ** overloaded or when the database connection closes.)^
4247 ** ^The destructor is also invoked if the call to
4248 ** sqlcipher3_create_function_v2() fails.
4249 ** ^When the destructor callback of the tenth parameter is invoked, it
4250 ** is passed a single argument which is a copy of the application data 
4251 ** pointer which was the fifth parameter to sqlcipher3_create_function_v2().
4252 **
4253 ** ^It is permitted to register multiple implementations of the same
4254 ** functions with the same name but with either differing numbers of
4255 ** arguments or differing preferred text encodings.  ^SQLite will use
4256 ** the implementation that most closely matches the way in which the
4257 ** SQL function is used.  ^A function implementation with a non-negative
4258 ** nArg parameter is a better match than a function implementation with
4259 ** a negative nArg.  ^A function where the preferred text encoding
4260 ** matches the database encoding is a better
4261 ** match than a function where the encoding is different.  
4262 ** ^A function where the encoding difference is between UTF16le and UTF16be
4263 ** is a closer match than a function where the encoding difference is
4264 ** between UTF8 and UTF16.
4265 **
4266 ** ^Built-in functions may be overloaded by new application-defined functions.
4267 **
4268 ** ^An application-defined function is permitted to call other
4269 ** SQLite interfaces.  However, such calls must not
4270 ** close the database connection nor finalize or reset the prepared
4271 ** statement in which the function is running.
4272 */
4273 SQLCIPHER_API int sqlcipher3_create_function(
4274   sqlcipher3 *db,
4275   const char *zFunctionName,
4276   int nArg,
4277   int eTextRep,
4278   void *pApp,
4279   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
4280   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
4281   void (*xFinal)(sqlcipher3_context*)
4282 );
4283 SQLCIPHER_API int sqlcipher3_create_function16(
4284   sqlcipher3 *db,
4285   const void *zFunctionName,
4286   int nArg,
4287   int eTextRep,
4288   void *pApp,
4289   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
4290   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
4291   void (*xFinal)(sqlcipher3_context*)
4292 );
4293 SQLCIPHER_API int sqlcipher3_create_function_v2(
4294   sqlcipher3 *db,
4295   const char *zFunctionName,
4296   int nArg,
4297   int eTextRep,
4298   void *pApp,
4299   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
4300   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
4301   void (*xFinal)(sqlcipher3_context*),
4302   void(*xDestroy)(void*)
4303 );
4304
4305 /*
4306 ** CAPI3REF: Text Encodings
4307 **
4308 ** These constant define integer codes that represent the various
4309 ** text encodings supported by SQLite.
4310 */
4311 #define SQLCIPHER_UTF8           1
4312 #define SQLCIPHER_UTF16LE        2
4313 #define SQLCIPHER_UTF16BE        3
4314 #define SQLCIPHER_UTF16          4    /* Use native byte order */
4315 #define SQLCIPHER_ANY            5    /* sqlcipher3_create_function only */
4316 #define SQLCIPHER_UTF16_ALIGNED  8    /* sqlcipher3_create_collation only */
4317
4318 /*
4319 ** CAPI3REF: Deprecated Functions
4320 ** DEPRECATED
4321 **
4322 ** These functions are [deprecated].  In order to maintain
4323 ** backwards compatibility with older code, these functions continue 
4324 ** to be supported.  However, new applications should avoid
4325 ** the use of these functions.  To help encourage people to avoid
4326 ** using these functions, we are not going to tell you what they do.
4327 */
4328 #ifndef SQLCIPHER_OMIT_DEPRECATED
4329 SQLCIPHER_API SQLCIPHER_DEPRECATED int sqlcipher3_aggregate_count(sqlcipher3_context*);
4330 SQLCIPHER_API SQLCIPHER_DEPRECATED int sqlcipher3_expired(sqlcipher3_stmt*);
4331 SQLCIPHER_API SQLCIPHER_DEPRECATED int sqlcipher3_transfer_bindings(sqlcipher3_stmt*, sqlcipher3_stmt*);
4332 SQLCIPHER_API SQLCIPHER_DEPRECATED int sqlcipher3_global_recover(void);
4333 SQLCIPHER_API SQLCIPHER_DEPRECATED void sqlcipher3_thread_cleanup(void);
4334 SQLCIPHER_API SQLCIPHER_DEPRECATED int sqlcipher3_memory_alarm(void(*)(void*,sqlcipher3_int64,int),void*,sqlcipher3_int64);
4335 #endif
4336
4337 /*
4338 ** CAPI3REF: Obtaining SQL Function Parameter Values
4339 **
4340 ** The C-language implementation of SQL functions and aggregates uses
4341 ** this set of interface routines to access the parameter values on
4342 ** the function or aggregate.
4343 **
4344 ** The xFunc (for scalar functions) or xStep (for aggregates) parameters
4345 ** to [sqlcipher3_create_function()] and [sqlcipher3_create_function16()]
4346 ** define callbacks that implement the SQL functions and aggregates.
4347 ** The 3rd parameter to these callbacks is an array of pointers to
4348 ** [protected sqlcipher3_value] objects.  There is one [sqlcipher3_value] object for
4349 ** each parameter to the SQL function.  These routines are used to
4350 ** extract values from the [sqlcipher3_value] objects.
4351 **
4352 ** These routines work only with [protected sqlcipher3_value] objects.
4353 ** Any attempt to use these routines on an [unprotected sqlcipher3_value]
4354 ** object results in undefined behavior.
4355 **
4356 ** ^These routines work just like the corresponding [column access functions]
4357 ** except that  these routines take a single [protected sqlcipher3_value] object
4358 ** pointer instead of a [sqlcipher3_stmt*] pointer and an integer column number.
4359 **
4360 ** ^The sqlcipher3_value_text16() interface extracts a UTF-16 string
4361 ** in the native byte-order of the host machine.  ^The
4362 ** sqlcipher3_value_text16be() and sqlcipher3_value_text16le() interfaces
4363 ** extract UTF-16 strings as big-endian and little-endian respectively.
4364 **
4365 ** ^(The sqlcipher3_value_numeric_type() interface attempts to apply
4366 ** numeric affinity to the value.  This means that an attempt is
4367 ** made to convert the value to an integer or floating point.  If
4368 ** such a conversion is possible without loss of information (in other
4369 ** words, if the value is a string that looks like a number)
4370 ** then the conversion is performed.  Otherwise no conversion occurs.
4371 ** The [SQLCIPHER_INTEGER | datatype] after conversion is returned.)^
4372 **
4373 ** Please pay particular attention to the fact that the pointer returned
4374 ** from [sqlcipher3_value_blob()], [sqlcipher3_value_text()], or
4375 ** [sqlcipher3_value_text16()] can be invalidated by a subsequent call to
4376 ** [sqlcipher3_value_bytes()], [sqlcipher3_value_bytes16()], [sqlcipher3_value_text()],
4377 ** or [sqlcipher3_value_text16()].
4378 **
4379 ** These routines must be called from the same thread as
4380 ** the SQL function that supplied the [sqlcipher3_value*] parameters.
4381 */
4382 SQLCIPHER_API const void *sqlcipher3_value_blob(sqlcipher3_value*);
4383 SQLCIPHER_API int sqlcipher3_value_bytes(sqlcipher3_value*);
4384 SQLCIPHER_API int sqlcipher3_value_bytes16(sqlcipher3_value*);
4385 SQLCIPHER_API double sqlcipher3_value_double(sqlcipher3_value*);
4386 SQLCIPHER_API int sqlcipher3_value_int(sqlcipher3_value*);
4387 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_value_int64(sqlcipher3_value*);
4388 SQLCIPHER_API const unsigned char *sqlcipher3_value_text(sqlcipher3_value*);
4389 SQLCIPHER_API const void *sqlcipher3_value_text16(sqlcipher3_value*);
4390 SQLCIPHER_API const void *sqlcipher3_value_text16le(sqlcipher3_value*);
4391 SQLCIPHER_API const void *sqlcipher3_value_text16be(sqlcipher3_value*);
4392 SQLCIPHER_API int sqlcipher3_value_type(sqlcipher3_value*);
4393 SQLCIPHER_API int sqlcipher3_value_numeric_type(sqlcipher3_value*);
4394
4395 /*
4396 ** CAPI3REF: Obtain Aggregate Function Context
4397 **
4398 ** Implementations of aggregate SQL functions use this
4399 ** routine to allocate memory for storing their state.
4400 **
4401 ** ^The first time the sqlcipher3_aggregate_context(C,N) routine is called 
4402 ** for a particular aggregate function, SQLite
4403 ** allocates N of memory, zeroes out that memory, and returns a pointer
4404 ** to the new memory. ^On second and subsequent calls to
4405 ** sqlcipher3_aggregate_context() for the same aggregate function instance,
4406 ** the same buffer is returned.  Sqlite3_aggregate_context() is normally
4407 ** called once for each invocation of the xStep callback and then one
4408 ** last time when the xFinal callback is invoked.  ^(When no rows match
4409 ** an aggregate query, the xStep() callback of the aggregate function
4410 ** implementation is never called and xFinal() is called exactly once.
4411 ** In those cases, sqlcipher3_aggregate_context() might be called for the
4412 ** first time from within xFinal().)^
4413 **
4414 ** ^The sqlcipher3_aggregate_context(C,N) routine returns a NULL pointer if N is
4415 ** less than or equal to zero or if a memory allocate error occurs.
4416 **
4417 ** ^(The amount of space allocated by sqlcipher3_aggregate_context(C,N) is
4418 ** determined by the N parameter on first successful call.  Changing the
4419 ** value of N in subsequent call to sqlcipher3_aggregate_context() within
4420 ** the same aggregate function instance will not resize the memory
4421 ** allocation.)^
4422 **
4423 ** ^SQLite automatically frees the memory allocated by 
4424 ** sqlcipher3_aggregate_context() when the aggregate query concludes.
4425 **
4426 ** The first parameter must be a copy of the
4427 ** [sqlcipher3_context | SQL function context] that is the first parameter
4428 ** to the xStep or xFinal callback routine that implements the aggregate
4429 ** function.
4430 **
4431 ** This routine must be called from the same thread in which
4432 ** the aggregate SQL function is running.
4433 */
4434 SQLCIPHER_API void *sqlcipher3_aggregate_context(sqlcipher3_context*, int nBytes);
4435
4436 /*
4437 ** CAPI3REF: User Data For Functions
4438 **
4439 ** ^The sqlcipher3_user_data() interface returns a copy of
4440 ** the pointer that was the pUserData parameter (the 5th parameter)
4441 ** of the [sqlcipher3_create_function()]
4442 ** and [sqlcipher3_create_function16()] routines that originally
4443 ** registered the application defined function.
4444 **
4445 ** This routine must be called from the same thread in which
4446 ** the application-defined function is running.
4447 */
4448 SQLCIPHER_API void *sqlcipher3_user_data(sqlcipher3_context*);
4449
4450 /*
4451 ** CAPI3REF: Database Connection For Functions
4452 **
4453 ** ^The sqlcipher3_context_db_handle() interface returns a copy of
4454 ** the pointer to the [database connection] (the 1st parameter)
4455 ** of the [sqlcipher3_create_function()]
4456 ** and [sqlcipher3_create_function16()] routines that originally
4457 ** registered the application defined function.
4458 */
4459 SQLCIPHER_API sqlcipher3 *sqlcipher3_context_db_handle(sqlcipher3_context*);
4460
4461 /*
4462 ** CAPI3REF: Function Auxiliary Data
4463 **
4464 ** The following two functions may be used by scalar SQL functions to
4465 ** associate metadata with argument values. If the same value is passed to
4466 ** multiple invocations of the same SQL function during query execution, under
4467 ** some circumstances the associated metadata may be preserved. This may
4468 ** be used, for example, to add a regular-expression matching scalar
4469 ** function. The compiled version of the regular expression is stored as
4470 ** metadata associated with the SQL value passed as the regular expression
4471 ** pattern.  The compiled regular expression can be reused on multiple
4472 ** invocations of the same function so that the original pattern string
4473 ** does not need to be recompiled on each invocation.
4474 **
4475 ** ^The sqlcipher3_get_auxdata() interface returns a pointer to the metadata
4476 ** associated by the sqlcipher3_set_auxdata() function with the Nth argument
4477 ** value to the application-defined function. ^If no metadata has been ever
4478 ** been set for the Nth argument of the function, or if the corresponding
4479 ** function parameter has changed since the meta-data was set,
4480 ** then sqlcipher3_get_auxdata() returns a NULL pointer.
4481 **
4482 ** ^The sqlcipher3_set_auxdata() interface saves the metadata
4483 ** pointed to by its 3rd parameter as the metadata for the N-th
4484 ** argument of the application-defined function.  Subsequent
4485 ** calls to sqlcipher3_get_auxdata() might return this data, if it has
4486 ** not been destroyed.
4487 ** ^If it is not NULL, SQLite will invoke the destructor
4488 ** function given by the 4th parameter to sqlcipher3_set_auxdata() on
4489 ** the metadata when the corresponding function parameter changes
4490 ** or when the SQL statement completes, whichever comes first.
4491 **
4492 ** SQLite is free to call the destructor and drop metadata on any
4493 ** parameter of any function at any time.  ^The only guarantee is that
4494 ** the destructor will be called before the metadata is dropped.
4495 **
4496 ** ^(In practice, metadata is preserved between function calls for
4497 ** expressions that are constant at compile time. This includes literal
4498 ** values and [parameters].)^
4499 **
4500 ** These routines must be called from the same thread in which
4501 ** the SQL function is running.
4502 */
4503 SQLCIPHER_API void *sqlcipher3_get_auxdata(sqlcipher3_context*, int N);
4504 SQLCIPHER_API void sqlcipher3_set_auxdata(sqlcipher3_context*, int N, void*, void (*)(void*));
4505
4506
4507 /*
4508 ** CAPI3REF: Constants Defining Special Destructor Behavior
4509 **
4510 ** These are special values for the destructor that is passed in as the
4511 ** final argument to routines like [sqlcipher3_result_blob()].  ^If the destructor
4512 ** argument is SQLCIPHER_STATIC, it means that the content pointer is constant
4513 ** and will never change.  It does not need to be destroyed.  ^The
4514 ** SQLCIPHER_TRANSIENT value means that the content will likely change in
4515 ** the near future and that SQLite should make its own private copy of
4516 ** the content before returning.
4517 **
4518 ** The typedef is necessary to work around problems in certain
4519 ** C++ compilers.  See ticket #2191.
4520 */
4521 typedef void (*sqlcipher3_destructor_type)(void*);
4522 #define SQLCIPHER_STATIC      ((sqlcipher3_destructor_type)0)
4523 #define SQLCIPHER_TRANSIENT   ((sqlcipher3_destructor_type)-1)
4524
4525 /*
4526 ** CAPI3REF: Setting The Result Of An SQL Function
4527 **
4528 ** These routines are used by the xFunc or xFinal callbacks that
4529 ** implement SQL functions and aggregates.  See
4530 ** [sqlcipher3_create_function()] and [sqlcipher3_create_function16()]
4531 ** for additional information.
4532 **
4533 ** These functions work very much like the [parameter binding] family of
4534 ** functions used to bind values to host parameters in prepared statements.
4535 ** Refer to the [SQL parameter] documentation for additional information.
4536 **
4537 ** ^The sqlcipher3_result_blob() interface sets the result from
4538 ** an application-defined function to be the BLOB whose content is pointed
4539 ** to by the second parameter and which is N bytes long where N is the
4540 ** third parameter.
4541 **
4542 ** ^The sqlcipher3_result_zeroblob() interfaces set the result of
4543 ** the application-defined function to be a BLOB containing all zero
4544 ** bytes and N bytes in size, where N is the value of the 2nd parameter.
4545 **
4546 ** ^The sqlcipher3_result_double() interface sets the result from
4547 ** an application-defined function to be a floating point value specified
4548 ** by its 2nd argument.
4549 **
4550 ** ^The sqlcipher3_result_error() and sqlcipher3_result_error16() functions
4551 ** cause the implemented SQL function to throw an exception.
4552 ** ^SQLite uses the string pointed to by the
4553 ** 2nd parameter of sqlcipher3_result_error() or sqlcipher3_result_error16()
4554 ** as the text of an error message.  ^SQLite interprets the error
4555 ** message string from sqlcipher3_result_error() as UTF-8. ^SQLite
4556 ** interprets the string from sqlcipher3_result_error16() as UTF-16 in native
4557 ** byte order.  ^If the third parameter to sqlcipher3_result_error()
4558 ** or sqlcipher3_result_error16() is negative then SQLite takes as the error
4559 ** message all text up through the first zero character.
4560 ** ^If the third parameter to sqlcipher3_result_error() or
4561 ** sqlcipher3_result_error16() is non-negative then SQLite takes that many
4562 ** bytes (not characters) from the 2nd parameter as the error message.
4563 ** ^The sqlcipher3_result_error() and sqlcipher3_result_error16()
4564 ** routines make a private copy of the error message text before
4565 ** they return.  Hence, the calling function can deallocate or
4566 ** modify the text after they return without harm.
4567 ** ^The sqlcipher3_result_error_code() function changes the error code
4568 ** returned by SQLite as a result of an error in a function.  ^By default,
4569 ** the error code is SQLCIPHER_ERROR.  ^A subsequent call to sqlcipher3_result_error()
4570 ** or sqlcipher3_result_error16() resets the error code to SQLCIPHER_ERROR.
4571 **
4572 ** ^The sqlcipher3_result_toobig() interface causes SQLite to throw an error
4573 ** indicating that a string or BLOB is too long to represent.
4574 **
4575 ** ^The sqlcipher3_result_nomem() interface causes SQLite to throw an error
4576 ** indicating that a memory allocation failed.
4577 **
4578 ** ^The sqlcipher3_result_int() interface sets the return value
4579 ** of the application-defined function to be the 32-bit signed integer
4580 ** value given in the 2nd argument.
4581 ** ^The sqlcipher3_result_int64() interface sets the return value
4582 ** of the application-defined function to be the 64-bit signed integer
4583 ** value given in the 2nd argument.
4584 **
4585 ** ^The sqlcipher3_result_null() interface sets the return value
4586 ** of the application-defined function to be NULL.
4587 **
4588 ** ^The sqlcipher3_result_text(), sqlcipher3_result_text16(),
4589 ** sqlcipher3_result_text16le(), and sqlcipher3_result_text16be() interfaces
4590 ** set the return value of the application-defined function to be
4591 ** a text string which is represented as UTF-8, UTF-16 native byte order,
4592 ** UTF-16 little endian, or UTF-16 big endian, respectively.
4593 ** ^SQLite takes the text result from the application from
4594 ** the 2nd parameter of the sqlcipher3_result_text* interfaces.
4595 ** ^If the 3rd parameter to the sqlcipher3_result_text* interfaces
4596 ** is negative, then SQLite takes result text from the 2nd parameter
4597 ** through the first zero character.
4598 ** ^If the 3rd parameter to the sqlcipher3_result_text* interfaces
4599 ** is non-negative, then as many bytes (not characters) of the text
4600 ** pointed to by the 2nd parameter are taken as the application-defined
4601 ** function result.  If the 3rd parameter is non-negative, then it
4602 ** must be the byte offset into the string where the NUL terminator would
4603 ** appear if the string where NUL terminated.  If any NUL characters occur
4604 ** in the string at a byte offset that is less than the value of the 3rd
4605 ** parameter, then the resulting string will contain embedded NULs and the
4606 ** result of expressions operating on strings with embedded NULs is undefined.
4607 ** ^If the 4th parameter to the sqlcipher3_result_text* interfaces
4608 ** or sqlcipher3_result_blob is a non-NULL pointer, then SQLite calls that
4609 ** function as the destructor on the text or BLOB result when it has
4610 ** finished using that result.
4611 ** ^If the 4th parameter to the sqlcipher3_result_text* interfaces or to
4612 ** sqlcipher3_result_blob is the special constant SQLCIPHER_STATIC, then SQLite
4613 ** assumes that the text or BLOB result is in constant space and does not
4614 ** copy the content of the parameter nor call a destructor on the content
4615 ** when it has finished using that result.
4616 ** ^If the 4th parameter to the sqlcipher3_result_text* interfaces
4617 ** or sqlcipher3_result_blob is the special constant SQLCIPHER_TRANSIENT
4618 ** then SQLite makes a copy of the result into space obtained from
4619 ** from [sqlcipher3_malloc()] before it returns.
4620 **
4621 ** ^The sqlcipher3_result_value() interface sets the result of
4622 ** the application-defined function to be a copy the
4623 ** [unprotected sqlcipher3_value] object specified by the 2nd parameter.  ^The
4624 ** sqlcipher3_result_value() interface makes a copy of the [sqlcipher3_value]
4625 ** so that the [sqlcipher3_value] specified in the parameter may change or
4626 ** be deallocated after sqlcipher3_result_value() returns without harm.
4627 ** ^A [protected sqlcipher3_value] object may always be used where an
4628 ** [unprotected sqlcipher3_value] object is required, so either
4629 ** kind of [sqlcipher3_value] object can be used with this interface.
4630 **
4631 ** If these routines are called from within the different thread
4632 ** than the one containing the application-defined function that received
4633 ** the [sqlcipher3_context] pointer, the results are undefined.
4634 */
4635 SQLCIPHER_API void sqlcipher3_result_blob(sqlcipher3_context*, const void*, int, void(*)(void*));
4636 SQLCIPHER_API void sqlcipher3_result_double(sqlcipher3_context*, double);
4637 SQLCIPHER_API void sqlcipher3_result_error(sqlcipher3_context*, const char*, int);
4638 SQLCIPHER_API void sqlcipher3_result_error16(sqlcipher3_context*, const void*, int);
4639 SQLCIPHER_API void sqlcipher3_result_error_toobig(sqlcipher3_context*);
4640 SQLCIPHER_API void sqlcipher3_result_error_nomem(sqlcipher3_context*);
4641 SQLCIPHER_API void sqlcipher3_result_error_code(sqlcipher3_context*, int);
4642 SQLCIPHER_API void sqlcipher3_result_int(sqlcipher3_context*, int);
4643 SQLCIPHER_API void sqlcipher3_result_int64(sqlcipher3_context*, sqlcipher3_int64);
4644 SQLCIPHER_API void sqlcipher3_result_null(sqlcipher3_context*);
4645 SQLCIPHER_API void sqlcipher3_result_text(sqlcipher3_context*, const char*, int, void(*)(void*));
4646 SQLCIPHER_API void sqlcipher3_result_text16(sqlcipher3_context*, const void*, int, void(*)(void*));
4647 SQLCIPHER_API void sqlcipher3_result_text16le(sqlcipher3_context*, const void*, int,void(*)(void*));
4648 SQLCIPHER_API void sqlcipher3_result_text16be(sqlcipher3_context*, const void*, int,void(*)(void*));
4649 SQLCIPHER_API void sqlcipher3_result_value(sqlcipher3_context*, sqlcipher3_value*);
4650 SQLCIPHER_API void sqlcipher3_result_zeroblob(sqlcipher3_context*, int n);
4651
4652 /*
4653 ** CAPI3REF: Define New Collating Sequences
4654 **
4655 ** ^These functions add, remove, or modify a [collation] associated
4656 ** with the [database connection] specified as the first argument.
4657 **
4658 ** ^The name of the collation is a UTF-8 string
4659 ** for sqlcipher3_create_collation() and sqlcipher3_create_collation_v2()
4660 ** and a UTF-16 string in native byte order for sqlcipher3_create_collation16().
4661 ** ^Collation names that compare equal according to [sqlcipher3_strnicmp()] are
4662 ** considered to be the same name.
4663 **
4664 ** ^(The third argument (eTextRep) must be one of the constants:
4665 ** <ul>
4666 ** <li> [SQLCIPHER_UTF8],
4667 ** <li> [SQLCIPHER_UTF16LE],
4668 ** <li> [SQLCIPHER_UTF16BE],
4669 ** <li> [SQLCIPHER_UTF16], or
4670 ** <li> [SQLCIPHER_UTF16_ALIGNED].
4671 ** </ul>)^
4672 ** ^The eTextRep argument determines the encoding of strings passed
4673 ** to the collating function callback, xCallback.
4674 ** ^The [SQLCIPHER_UTF16] and [SQLCIPHER_UTF16_ALIGNED] values for eTextRep
4675 ** force strings to be UTF16 with native byte order.
4676 ** ^The [SQLCIPHER_UTF16_ALIGNED] value for eTextRep forces strings to begin
4677 ** on an even byte address.
4678 **
4679 ** ^The fourth argument, pArg, is an application data pointer that is passed
4680 ** through as the first argument to the collating function callback.
4681 **
4682 ** ^The fifth argument, xCallback, is a pointer to the collating function.
4683 ** ^Multiple collating functions can be registered using the same name but
4684 ** with different eTextRep parameters and SQLite will use whichever
4685 ** function requires the least amount of data transformation.
4686 ** ^If the xCallback argument is NULL then the collating function is
4687 ** deleted.  ^When all collating functions having the same name are deleted,
4688 ** that collation is no longer usable.
4689 **
4690 ** ^The collating function callback is invoked with a copy of the pArg 
4691 ** application data pointer and with two strings in the encoding specified
4692 ** by the eTextRep argument.  The collating function must return an
4693 ** integer that is negative, zero, or positive
4694 ** if the first string is less than, equal to, or greater than the second,
4695 ** respectively.  A collating function must always return the same answer
4696 ** given the same inputs.  If two or more collating functions are registered
4697 ** to the same collation name (using different eTextRep values) then all
4698 ** must give an equivalent answer when invoked with equivalent strings.
4699 ** The collating function must obey the following properties for all
4700 ** strings A, B, and C:
4701 **
4702 ** <ol>
4703 ** <li> If A==B then B==A.
4704 ** <li> If A==B and B==C then A==C.
4705 ** <li> If A&lt;B THEN B&gt;A.
4706 ** <li> If A&lt;B and B&lt;C then A&lt;C.
4707 ** </ol>
4708 **
4709 ** If a collating function fails any of the above constraints and that
4710 ** collating function is  registered and used, then the behavior of SQLite
4711 ** is undefined.
4712 **
4713 ** ^The sqlcipher3_create_collation_v2() works like sqlcipher3_create_collation()
4714 ** with the addition that the xDestroy callback is invoked on pArg when
4715 ** the collating function is deleted.
4716 ** ^Collating functions are deleted when they are overridden by later
4717 ** calls to the collation creation functions or when the
4718 ** [database connection] is closed using [sqlcipher3_close()].
4719 **
4720 ** ^The xDestroy callback is <u>not</u> called if the 
4721 ** sqlcipher3_create_collation_v2() function fails.  Applications that invoke
4722 ** sqlcipher3_create_collation_v2() with a non-NULL xDestroy argument should 
4723 ** check the return code and dispose of the application data pointer
4724 ** themselves rather than expecting SQLite to deal with it for them.
4725 ** This is different from every other SQLite interface.  The inconsistency 
4726 ** is unfortunate but cannot be changed without breaking backwards 
4727 ** compatibility.
4728 **
4729 ** See also:  [sqlcipher3_collation_needed()] and [sqlcipher3_collation_needed16()].
4730 */
4731 SQLCIPHER_API int sqlcipher3_create_collation(
4732   sqlcipher3*, 
4733   const char *zName, 
4734   int eTextRep, 
4735   void *pArg,
4736   int(*xCompare)(void*,int,const void*,int,const void*)
4737 );
4738 SQLCIPHER_API int sqlcipher3_create_collation_v2(
4739   sqlcipher3*, 
4740   const char *zName, 
4741   int eTextRep, 
4742   void *pArg,
4743   int(*xCompare)(void*,int,const void*,int,const void*),
4744   void(*xDestroy)(void*)
4745 );
4746 SQLCIPHER_API int sqlcipher3_create_collation16(
4747   sqlcipher3*, 
4748   const void *zName,
4749   int eTextRep, 
4750   void *pArg,
4751   int(*xCompare)(void*,int,const void*,int,const void*)
4752 );
4753
4754 /*
4755 ** CAPI3REF: Collation Needed Callbacks
4756 **
4757 ** ^To avoid having to register all collation sequences before a database
4758 ** can be used, a single callback function may be registered with the
4759 ** [database connection] to be invoked whenever an undefined collation
4760 ** sequence is required.
4761 **
4762 ** ^If the function is registered using the sqlcipher3_collation_needed() API,
4763 ** then it is passed the names of undefined collation sequences as strings
4764 ** encoded in UTF-8. ^If sqlcipher3_collation_needed16() is used,
4765 ** the names are passed as UTF-16 in machine native byte order.
4766 ** ^A call to either function replaces the existing collation-needed callback.
4767 **
4768 ** ^(When the callback is invoked, the first argument passed is a copy
4769 ** of the second argument to sqlcipher3_collation_needed() or
4770 ** sqlcipher3_collation_needed16().  The second argument is the database
4771 ** connection.  The third argument is one of [SQLCIPHER_UTF8], [SQLCIPHER_UTF16BE],
4772 ** or [SQLCIPHER_UTF16LE], indicating the most desirable form of the collation
4773 ** sequence function required.  The fourth parameter is the name of the
4774 ** required collation sequence.)^
4775 **
4776 ** The callback function should register the desired collation using
4777 ** [sqlcipher3_create_collation()], [sqlcipher3_create_collation16()], or
4778 ** [sqlcipher3_create_collation_v2()].
4779 */
4780 SQLCIPHER_API int sqlcipher3_collation_needed(
4781   sqlcipher3*, 
4782   void*, 
4783   void(*)(void*,sqlcipher3*,int eTextRep,const char*)
4784 );
4785 SQLCIPHER_API int sqlcipher3_collation_needed16(
4786   sqlcipher3*, 
4787   void*,
4788   void(*)(void*,sqlcipher3*,int eTextRep,const void*)
4789 );
4790
4791 #ifdef SQLCIPHER_HAS_CODEC
4792 /*
4793 ** Specify the key for an encrypted database.  This routine should be
4794 ** called right after sqlcipher3_open().
4795 **
4796 ** The code to implement this API is not available in the public release
4797 ** of SQLite.
4798 */
4799 SQLCIPHER_API int sqlcipher3_key(
4800   sqlcipher3 *db,                   /* Database to be rekeyed */
4801   const void *pKey, int nKey     /* The key */
4802 );
4803
4804 /*
4805 ** Change the key on an open database.  If the current database is not
4806 ** encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
4807 ** database is decrypted.
4808 **
4809 ** The code to implement this API is not available in the public release
4810 ** of SQLite.
4811 */
4812 SQLCIPHER_API int sqlcipher3_rekey(
4813   sqlcipher3 *db,                   /* Database to be rekeyed */
4814   const void *pKey, int nKey     /* The new key */
4815 );
4816
4817 /*
4818 ** Specify the activation key for a SEE database.  Unless 
4819 ** activated, none of the SEE routines will work.
4820 */
4821 SQLCIPHER_API void sqlcipher3_activate_see(
4822   const char *zPassPhrase        /* Activation phrase */
4823 );
4824 #endif
4825
4826 #ifdef SQLCIPHER_ENABLE_CEROD
4827 /*
4828 ** Specify the activation key for a CEROD database.  Unless 
4829 ** activated, none of the CEROD routines will work.
4830 */
4831 SQLCIPHER_API void sqlcipher3_activate_cerod(
4832   const char *zPassPhrase        /* Activation phrase */
4833 );
4834 #endif
4835
4836 /*
4837 ** CAPI3REF: Suspend Execution For A Short Time
4838 **
4839 ** The sqlcipher3_sleep() function causes the current thread to suspend execution
4840 ** for at least a number of milliseconds specified in its parameter.
4841 **
4842 ** If the operating system does not support sleep requests with
4843 ** millisecond time resolution, then the time will be rounded up to
4844 ** the nearest second. The number of milliseconds of sleep actually
4845 ** requested from the operating system is returned.
4846 **
4847 ** ^SQLite implements this interface by calling the xSleep()
4848 ** method of the default [sqlcipher3_vfs] object.  If the xSleep() method
4849 ** of the default VFS is not implemented correctly, or not implemented at
4850 ** all, then the behavior of sqlcipher3_sleep() may deviate from the description
4851 ** in the previous paragraphs.
4852 */
4853 SQLCIPHER_API int sqlcipher3_sleep(int);
4854
4855 /*
4856 ** CAPI3REF: Name Of The Folder Holding Temporary Files
4857 **
4858 ** ^(If this global variable is made to point to a string which is
4859 ** the name of a folder (a.k.a. directory), then all temporary files
4860 ** created by SQLite when using a built-in [sqlcipher3_vfs | VFS]
4861 ** will be placed in that directory.)^  ^If this variable
4862 ** is a NULL pointer, then SQLite performs a search for an appropriate
4863 ** temporary file directory.
4864 **
4865 ** It is not safe to read or modify this variable in more than one
4866 ** thread at a time.  It is not safe to read or modify this variable
4867 ** if a [database connection] is being used at the same time in a separate
4868 ** thread.
4869 ** It is intended that this variable be set once
4870 ** as part of process initialization and before any SQLite interface
4871 ** routines have been called and that this variable remain unchanged
4872 ** thereafter.
4873 **
4874 ** ^The [temp_store_directory pragma] may modify this variable and cause
4875 ** it to point to memory obtained from [sqlcipher3_malloc].  ^Furthermore,
4876 ** the [temp_store_directory pragma] always assumes that any string
4877 ** that this variable points to is held in memory obtained from 
4878 ** [sqlcipher3_malloc] and the pragma may attempt to free that memory
4879 ** using [sqlcipher3_free].
4880 ** Hence, if this variable is modified directly, either it should be
4881 ** made NULL or made to point to memory obtained from [sqlcipher3_malloc]
4882 ** or else the use of the [temp_store_directory pragma] should be avoided.
4883 */
4884 SQLCIPHER_API char *sqlcipher3_temp_directory;
4885
4886 /*
4887 ** CAPI3REF: Test For Auto-Commit Mode
4888 ** KEYWORDS: {autocommit mode}
4889 **
4890 ** ^The sqlcipher3_get_autocommit() interface returns non-zero or
4891 ** zero if the given database connection is or is not in autocommit mode,
4892 ** respectively.  ^Autocommit mode is on by default.
4893 ** ^Autocommit mode is disabled by a [BEGIN] statement.
4894 ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
4895 **
4896 ** If certain kinds of errors occur on a statement within a multi-statement
4897 ** transaction (errors including [SQLCIPHER_FULL], [SQLCIPHER_IOERR],
4898 ** [SQLCIPHER_NOMEM], [SQLCIPHER_BUSY], and [SQLCIPHER_INTERRUPT]) then the
4899 ** transaction might be rolled back automatically.  The only way to
4900 ** find out whether SQLite automatically rolled back the transaction after
4901 ** an error is to use this function.
4902 **
4903 ** If another thread changes the autocommit status of the database
4904 ** connection while this routine is running, then the return value
4905 ** is undefined.
4906 */
4907 SQLCIPHER_API int sqlcipher3_get_autocommit(sqlcipher3*);
4908
4909 /*
4910 ** CAPI3REF: Find The Database Handle Of A Prepared Statement
4911 **
4912 ** ^The sqlcipher3_db_handle interface returns the [database connection] handle
4913 ** to which a [prepared statement] belongs.  ^The [database connection]
4914 ** returned by sqlcipher3_db_handle is the same [database connection]
4915 ** that was the first argument
4916 ** to the [sqlcipher3_prepare_v2()] call (or its variants) that was used to
4917 ** create the statement in the first place.
4918 */
4919 SQLCIPHER_API sqlcipher3 *sqlcipher3_db_handle(sqlcipher3_stmt*);
4920
4921 /*
4922 ** CAPI3REF: Find the next prepared statement
4923 **
4924 ** ^This interface returns a pointer to the next [prepared statement] after
4925 ** pStmt associated with the [database connection] pDb.  ^If pStmt is NULL
4926 ** then this interface returns a pointer to the first prepared statement
4927 ** associated with the database connection pDb.  ^If no prepared statement
4928 ** satisfies the conditions of this routine, it returns NULL.
4929 **
4930 ** The [database connection] pointer D in a call to
4931 ** [sqlcipher3_next_stmt(D,S)] must refer to an open database
4932 ** connection and in particular must not be a NULL pointer.
4933 */
4934 SQLCIPHER_API sqlcipher3_stmt *sqlcipher3_next_stmt(sqlcipher3 *pDb, sqlcipher3_stmt *pStmt);
4935
4936 /*
4937 ** CAPI3REF: Commit And Rollback Notification Callbacks
4938 **
4939 ** ^The sqlcipher3_commit_hook() interface registers a callback
4940 ** function to be invoked whenever a transaction is [COMMIT | committed].
4941 ** ^Any callback set by a previous call to sqlcipher3_commit_hook()
4942 ** for the same database connection is overridden.
4943 ** ^The sqlcipher3_rollback_hook() interface registers a callback
4944 ** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
4945 ** ^Any callback set by a previous call to sqlcipher3_rollback_hook()
4946 ** for the same database connection is overridden.
4947 ** ^The pArg argument is passed through to the callback.
4948 ** ^If the callback on a commit hook function returns non-zero,
4949 ** then the commit is converted into a rollback.
4950 **
4951 ** ^The sqlcipher3_commit_hook(D,C,P) and sqlcipher3_rollback_hook(D,C,P) functions
4952 ** return the P argument from the previous call of the same function
4953 ** on the same [database connection] D, or NULL for
4954 ** the first call for each function on D.
4955 **
4956 ** The callback implementation must not do anything that will modify
4957 ** the database connection that invoked the callback.  Any actions
4958 ** to modify the database connection must be deferred until after the
4959 ** completion of the [sqlcipher3_step()] call that triggered the commit
4960 ** or rollback hook in the first place.
4961 ** Note that [sqlcipher3_prepare_v2()] and [sqlcipher3_step()] both modify their
4962 ** database connections for the meaning of "modify" in this paragraph.
4963 **
4964 ** ^Registering a NULL function disables the callback.
4965 **
4966 ** ^When the commit hook callback routine returns zero, the [COMMIT]
4967 ** operation is allowed to continue normally.  ^If the commit hook
4968 ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
4969 ** ^The rollback hook is invoked on a rollback that results from a commit
4970 ** hook returning non-zero, just as it would be with any other rollback.
4971 **
4972 ** ^For the purposes of this API, a transaction is said to have been
4973 ** rolled back if an explicit "ROLLBACK" statement is executed, or
4974 ** an error or constraint causes an implicit rollback to occur.
4975 ** ^The rollback callback is not invoked if a transaction is
4976 ** automatically rolled back because the database connection is closed.
4977 **
4978 ** See also the [sqlcipher3_update_hook()] interface.
4979 */
4980 SQLCIPHER_API void *sqlcipher3_commit_hook(sqlcipher3*, int(*)(void*), void*);
4981 SQLCIPHER_API void *sqlcipher3_rollback_hook(sqlcipher3*, void(*)(void *), void*);
4982
4983 /*
4984 ** CAPI3REF: Data Change Notification Callbacks
4985 **
4986 ** ^The sqlcipher3_update_hook() interface registers a callback function
4987 ** with the [database connection] identified by the first argument
4988 ** to be invoked whenever a row is updated, inserted or deleted.
4989 ** ^Any callback set by a previous call to this function
4990 ** for the same database connection is overridden.
4991 **
4992 ** ^The second argument is a pointer to the function to invoke when a
4993 ** row is updated, inserted or deleted.
4994 ** ^The first argument to the callback is a copy of the third argument
4995 ** to sqlcipher3_update_hook().
4996 ** ^The second callback argument is one of [SQLCIPHER_INSERT], [SQLCIPHER_DELETE],
4997 ** or [SQLCIPHER_UPDATE], depending on the operation that caused the callback
4998 ** to be invoked.
4999 ** ^The third and fourth arguments to the callback contain pointers to the
5000 ** database and table name containing the affected row.
5001 ** ^The final callback parameter is the [rowid] of the row.
5002 ** ^In the case of an update, this is the [rowid] after the update takes place.
5003 **
5004 ** ^(The update hook is not invoked when internal system tables are
5005 ** modified (i.e. sqlcipher_master and sqlcipher_sequence).)^
5006 **
5007 ** ^In the current implementation, the update hook
5008 ** is not invoked when duplication rows are deleted because of an
5009 ** [ON CONFLICT | ON CONFLICT REPLACE] clause.  ^Nor is the update hook
5010 ** invoked when rows are deleted using the [truncate optimization].
5011 ** The exceptions defined in this paragraph might change in a future
5012 ** release of SQLite.
5013 **
5014 ** The update hook implementation must not do anything that will modify
5015 ** the database connection that invoked the update hook.  Any actions
5016 ** to modify the database connection must be deferred until after the
5017 ** completion of the [sqlcipher3_step()] call that triggered the update hook.
5018 ** Note that [sqlcipher3_prepare_v2()] and [sqlcipher3_step()] both modify their
5019 ** database connections for the meaning of "modify" in this paragraph.
5020 **
5021 ** ^The sqlcipher3_update_hook(D,C,P) function
5022 ** returns the P argument from the previous call
5023 ** on the same [database connection] D, or NULL for
5024 ** the first call on D.
5025 **
5026 ** See also the [sqlcipher3_commit_hook()] and [sqlcipher3_rollback_hook()]
5027 ** interfaces.
5028 */
5029 SQLCIPHER_API void *sqlcipher3_update_hook(
5030   sqlcipher3*, 
5031   void(*)(void *,int ,char const *,char const *,sqlcipher3_int64),
5032   void*
5033 );
5034
5035 /*
5036 ** CAPI3REF: Enable Or Disable Shared Pager Cache
5037 ** KEYWORDS: {shared cache}
5038 **
5039 ** ^(This routine enables or disables the sharing of the database cache
5040 ** and schema data structures between [database connection | connections]
5041 ** to the same database. Sharing is enabled if the argument is true
5042 ** and disabled if the argument is false.)^
5043 **
5044 ** ^Cache sharing is enabled and disabled for an entire process.
5045 ** This is a change as of SQLite version 3.5.0. In prior versions of SQLite,
5046 ** sharing was enabled or disabled for each thread separately.
5047 **
5048 ** ^(The cache sharing mode set by this interface effects all subsequent
5049 ** calls to [sqlcipher3_open()], [sqlcipher3_open_v2()], and [sqlcipher3_open16()].
5050 ** Existing database connections continue use the sharing mode
5051 ** that was in effect at the time they were opened.)^
5052 **
5053 ** ^(This routine returns [SQLCIPHER_OK] if shared cache was enabled or disabled
5054 ** successfully.  An [error code] is returned otherwise.)^
5055 **
5056 ** ^Shared cache is disabled by default. But this might change in
5057 ** future releases of SQLite.  Applications that care about shared
5058 ** cache setting should set it explicitly.
5059 **
5060 ** See Also:  [SQLite Shared-Cache Mode]
5061 */
5062 SQLCIPHER_API int sqlcipher3_enable_shared_cache(int);
5063
5064 /*
5065 ** CAPI3REF: Attempt To Free Heap Memory
5066 **
5067 ** ^The sqlcipher3_release_memory() interface attempts to free N bytes
5068 ** of heap memory by deallocating non-essential memory allocations
5069 ** held by the database library.   Memory used to cache database
5070 ** pages to improve performance is an example of non-essential memory.
5071 ** ^sqlcipher3_release_memory() returns the number of bytes actually freed,
5072 ** which might be more or less than the amount requested.
5073 ** ^The sqlcipher3_release_memory() routine is a no-op returning zero
5074 ** if SQLite is not compiled with [SQLCIPHER_ENABLE_MEMORY_MANAGEMENT].
5075 */
5076 SQLCIPHER_API int sqlcipher3_release_memory(int);
5077
5078 /*
5079 ** CAPI3REF: Impose A Limit On Heap Size
5080 **
5081 ** ^The sqlcipher3_soft_heap_limit64() interface sets and/or queries the
5082 ** soft limit on the amount of heap memory that may be allocated by SQLite.
5083 ** ^SQLite strives to keep heap memory utilization below the soft heap
5084 ** limit by reducing the number of pages held in the page cache
5085 ** as heap memory usages approaches the limit.
5086 ** ^The soft heap limit is "soft" because even though SQLite strives to stay
5087 ** below the limit, it will exceed the limit rather than generate
5088 ** an [SQLCIPHER_NOMEM] error.  In other words, the soft heap limit 
5089 ** is advisory only.
5090 **
5091 ** ^The return value from sqlcipher3_soft_heap_limit64() is the size of
5092 ** the soft heap limit prior to the call.  ^If the argument N is negative
5093 ** then no change is made to the soft heap limit.  Hence, the current
5094 ** size of the soft heap limit can be determined by invoking
5095 ** sqlcipher3_soft_heap_limit64() with a negative argument.
5096 **
5097 ** ^If the argument N is zero then the soft heap limit is disabled.
5098 **
5099 ** ^(The soft heap limit is not enforced in the current implementation
5100 ** if one or more of following conditions are true:
5101 **
5102 ** <ul>
5103 ** <li> The soft heap limit is set to zero.
5104 ** <li> Memory accounting is disabled using a combination of the
5105 **      [sqlcipher3_config]([SQLCIPHER_CONFIG_MEMSTATUS],...) start-time option and
5106 **      the [SQLCIPHER_DEFAULT_MEMSTATUS] compile-time option.
5107 ** <li> An alternative page cache implementation is specified using
5108 **      [sqlcipher3_config]([SQLCIPHER_CONFIG_PCACHE],...).
5109 ** <li> The page cache allocates from its own memory pool supplied
5110 **      by [sqlcipher3_config]([SQLCIPHER_CONFIG_PAGECACHE],...) rather than
5111 **      from the heap.
5112 ** </ul>)^
5113 **
5114 ** Beginning with SQLite version 3.7.3, the soft heap limit is enforced
5115 ** regardless of whether or not the [SQLCIPHER_ENABLE_MEMORY_MANAGEMENT]
5116 ** compile-time option is invoked.  With [SQLCIPHER_ENABLE_MEMORY_MANAGEMENT],
5117 ** the soft heap limit is enforced on every memory allocation.  Without
5118 ** [SQLCIPHER_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced
5119 ** when memory is allocated by the page cache.  Testing suggests that because
5120 ** the page cache is the predominate memory user in SQLite, most
5121 ** applications will achieve adequate soft heap limit enforcement without
5122 ** the use of [SQLCIPHER_ENABLE_MEMORY_MANAGEMENT].
5123 **
5124 ** The circumstances under which SQLite will enforce the soft heap limit may
5125 ** changes in future releases of SQLite.
5126 */
5127 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_soft_heap_limit64(sqlcipher3_int64 N);
5128
5129 /*
5130 ** CAPI3REF: Deprecated Soft Heap Limit Interface
5131 ** DEPRECATED
5132 **
5133 ** This is a deprecated version of the [sqlcipher3_soft_heap_limit64()]
5134 ** interface.  This routine is provided for historical compatibility
5135 ** only.  All new applications should use the
5136 ** [sqlcipher3_soft_heap_limit64()] interface rather than this one.
5137 */
5138 SQLCIPHER_API SQLCIPHER_DEPRECATED void sqlcipher3_soft_heap_limit(int N);
5139
5140
5141 /*
5142 ** CAPI3REF: Extract Metadata About A Column Of A Table
5143 **
5144 ** ^This routine returns metadata about a specific column of a specific
5145 ** database table accessible using the [database connection] handle
5146 ** passed as the first function argument.
5147 **
5148 ** ^The column is identified by the second, third and fourth parameters to
5149 ** this function. ^The second parameter is either the name of the database
5150 ** (i.e. "main", "temp", or an attached database) containing the specified
5151 ** table or NULL. ^If it is NULL, then all attached databases are searched
5152 ** for the table using the same algorithm used by the database engine to
5153 ** resolve unqualified table references.
5154 **
5155 ** ^The third and fourth parameters to this function are the table and column
5156 ** name of the desired column, respectively. Neither of these parameters
5157 ** may be NULL.
5158 **
5159 ** ^Metadata is returned by writing to the memory locations passed as the 5th
5160 ** and subsequent parameters to this function. ^Any of these arguments may be
5161 ** NULL, in which case the corresponding element of metadata is omitted.
5162 **
5163 ** ^(<blockquote>
5164 ** <table border="1">
5165 ** <tr><th> Parameter <th> Output<br>Type <th>  Description
5166 **
5167 ** <tr><td> 5th <td> const char* <td> Data type
5168 ** <tr><td> 6th <td> const char* <td> Name of default collation sequence
5169 ** <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
5170 ** <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
5171 ** <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
5172 ** </table>
5173 ** </blockquote>)^
5174 **
5175 ** ^The memory pointed to by the character pointers returned for the
5176 ** declaration type and collation sequence is valid only until the next
5177 ** call to any SQLite API function.
5178 **
5179 ** ^If the specified table is actually a view, an [error code] is returned.
5180 **
5181 ** ^If the specified column is "rowid", "oid" or "_rowid_" and an
5182 ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
5183 ** parameters are set for the explicitly declared column. ^(If there is no
5184 ** explicitly declared [INTEGER PRIMARY KEY] column, then the output
5185 ** parameters are set as follows:
5186 **
5187 ** <pre>
5188 **     data type: "INTEGER"
5189 **     collation sequence: "BINARY"
5190 **     not null: 0
5191 **     primary key: 1
5192 **     auto increment: 0
5193 ** </pre>)^
5194 **
5195 ** ^(This function may load one or more schemas from database files. If an
5196 ** error occurs during this process, or if the requested table or column
5197 ** cannot be found, an [error code] is returned and an error message left
5198 ** in the [database connection] (to be retrieved using sqlcipher3_errmsg()).)^
5199 **
5200 ** ^This API is only available if the library was compiled with the
5201 ** [SQLCIPHER_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
5202 */
5203 SQLCIPHER_API int sqlcipher3_table_column_metadata(
5204   sqlcipher3 *db,                /* Connection handle */
5205   const char *zDbName,        /* Database name or NULL */
5206   const char *zTableName,     /* Table name */
5207   const char *zColumnName,    /* Column name */
5208   char const **pzDataType,    /* OUTPUT: Declared data type */
5209   char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
5210   int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
5211   int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
5212   int *pAutoinc               /* OUTPUT: True if column is auto-increment */
5213 );
5214
5215 /*
5216 ** CAPI3REF: Load An Extension
5217 **
5218 ** ^This interface loads an SQLite extension library from the named file.
5219 **
5220 ** ^The sqlcipher3_load_extension() interface attempts to load an
5221 ** SQLite extension library contained in the file zFile.
5222 **
5223 ** ^The entry point is zProc.
5224 ** ^zProc may be 0, in which case the name of the entry point
5225 ** defaults to "sqlcipher3_extension_init".
5226 ** ^The sqlcipher3_load_extension() interface returns
5227 ** [SQLCIPHER_OK] on success and [SQLCIPHER_ERROR] if something goes wrong.
5228 ** ^If an error occurs and pzErrMsg is not 0, then the
5229 ** [sqlcipher3_load_extension()] interface shall attempt to
5230 ** fill *pzErrMsg with error message text stored in memory
5231 ** obtained from [sqlcipher3_malloc()]. The calling function
5232 ** should free this memory by calling [sqlcipher3_free()].
5233 **
5234 ** ^Extension loading must be enabled using
5235 ** [sqlcipher3_enable_load_extension()] prior to calling this API,
5236 ** otherwise an error will be returned.
5237 **
5238 ** See also the [load_extension() SQL function].
5239 */
5240 SQLCIPHER_API int sqlcipher3_load_extension(
5241   sqlcipher3 *db,          /* Load the extension into this database connection */
5242   const char *zFile,    /* Name of the shared library containing extension */
5243   const char *zProc,    /* Entry point.  Derived from zFile if 0 */
5244   char **pzErrMsg       /* Put error message here if not 0 */
5245 );
5246
5247 /*
5248 ** CAPI3REF: Enable Or Disable Extension Loading
5249 **
5250 ** ^So as not to open security holes in older applications that are
5251 ** unprepared to deal with extension loading, and as a means of disabling
5252 ** extension loading while evaluating user-entered SQL, the following API
5253 ** is provided to turn the [sqlcipher3_load_extension()] mechanism on and off.
5254 **
5255 ** ^Extension loading is off by default. See ticket #1863.
5256 ** ^Call the sqlcipher3_enable_load_extension() routine with onoff==1
5257 ** to turn extension loading on and call it with onoff==0 to turn
5258 ** it back off again.
5259 */
5260 SQLCIPHER_API int sqlcipher3_enable_load_extension(sqlcipher3 *db, int onoff);
5261
5262 /*
5263 ** CAPI3REF: Automatically Load Statically Linked Extensions
5264 **
5265 ** ^This interface causes the xEntryPoint() function to be invoked for
5266 ** each new [database connection] that is created.  The idea here is that
5267 ** xEntryPoint() is the entry point for a statically linked SQLite extension
5268 ** that is to be automatically loaded into all new database connections.
5269 **
5270 ** ^(Even though the function prototype shows that xEntryPoint() takes
5271 ** no arguments and returns void, SQLite invokes xEntryPoint() with three
5272 ** arguments and expects and integer result as if the signature of the
5273 ** entry point where as follows:
5274 **
5275 ** <blockquote><pre>
5276 ** &nbsp;  int xEntryPoint(
5277 ** &nbsp;    sqlcipher3 *db,
5278 ** &nbsp;    const char **pzErrMsg,
5279 ** &nbsp;    const struct sqlcipher3_api_routines *pThunk
5280 ** &nbsp;  );
5281 ** </pre></blockquote>)^
5282 **
5283 ** If the xEntryPoint routine encounters an error, it should make *pzErrMsg
5284 ** point to an appropriate error message (obtained from [sqlcipher3_mprintf()])
5285 ** and return an appropriate [error code].  ^SQLite ensures that *pzErrMsg
5286 ** is NULL before calling the xEntryPoint().  ^SQLite will invoke
5287 ** [sqlcipher3_free()] on *pzErrMsg after xEntryPoint() returns.  ^If any
5288 ** xEntryPoint() returns an error, the [sqlcipher3_open()], [sqlcipher3_open16()],
5289 ** or [sqlcipher3_open_v2()] call that provoked the xEntryPoint() will fail.
5290 **
5291 ** ^Calling sqlcipher3_auto_extension(X) with an entry point X that is already
5292 ** on the list of automatic extensions is a harmless no-op. ^No entry point
5293 ** will be called more than once for each database connection that is opened.
5294 **
5295 ** See also: [sqlcipher3_reset_auto_extension()].
5296 */
5297 SQLCIPHER_API int sqlcipher3_auto_extension(void (*xEntryPoint)(void));
5298
5299 /*
5300 ** CAPI3REF: Reset Automatic Extension Loading
5301 **
5302 ** ^This interface disables all automatic extensions previously
5303 ** registered using [sqlcipher3_auto_extension()].
5304 */
5305 SQLCIPHER_API void sqlcipher3_reset_auto_extension(void);
5306
5307 /*
5308 ** The interface to the virtual-table mechanism is currently considered
5309 ** to be experimental.  The interface might change in incompatible ways.
5310 ** If this is a problem for you, do not use the interface at this time.
5311 **
5312 ** When the virtual-table mechanism stabilizes, we will declare the
5313 ** interface fixed, support it indefinitely, and remove this comment.
5314 */
5315
5316 /*
5317 ** Structures used by the virtual table interface
5318 */
5319 typedef struct sqlcipher3_vtab sqlcipher3_vtab;
5320 typedef struct sqlcipher3_index_info sqlcipher3_index_info;
5321 typedef struct sqlcipher3_vtab_cursor sqlcipher3_vtab_cursor;
5322 typedef struct sqlcipher3_module sqlcipher3_module;
5323
5324 /*
5325 ** CAPI3REF: Virtual Table Object
5326 ** KEYWORDS: sqlcipher3_module {virtual table module}
5327 **
5328 ** This structure, sometimes called a "virtual table module", 
5329 ** defines the implementation of a [virtual tables].  
5330 ** This structure consists mostly of methods for the module.
5331 **
5332 ** ^A virtual table module is created by filling in a persistent
5333 ** instance of this structure and passing a pointer to that instance
5334 ** to [sqlcipher3_create_module()] or [sqlcipher3_create_module_v2()].
5335 ** ^The registration remains valid until it is replaced by a different
5336 ** module or until the [database connection] closes.  The content
5337 ** of this structure must not change while it is registered with
5338 ** any database connection.
5339 */
5340 struct sqlcipher3_module {
5341   int iVersion;
5342   int (*xCreate)(sqlcipher3*, void *pAux,
5343                int argc, const char *const*argv,
5344                sqlcipher3_vtab **ppVTab, char**);
5345   int (*xConnect)(sqlcipher3*, void *pAux,
5346                int argc, const char *const*argv,
5347                sqlcipher3_vtab **ppVTab, char**);
5348   int (*xBestIndex)(sqlcipher3_vtab *pVTab, sqlcipher3_index_info*);
5349   int (*xDisconnect)(sqlcipher3_vtab *pVTab);
5350   int (*xDestroy)(sqlcipher3_vtab *pVTab);
5351   int (*xOpen)(sqlcipher3_vtab *pVTab, sqlcipher3_vtab_cursor **ppCursor);
5352   int (*xClose)(sqlcipher3_vtab_cursor*);
5353   int (*xFilter)(sqlcipher3_vtab_cursor*, int idxNum, const char *idxStr,
5354                 int argc, sqlcipher3_value **argv);
5355   int (*xNext)(sqlcipher3_vtab_cursor*);
5356   int (*xEof)(sqlcipher3_vtab_cursor*);
5357   int (*xColumn)(sqlcipher3_vtab_cursor*, sqlcipher3_context*, int);
5358   int (*xRowid)(sqlcipher3_vtab_cursor*, sqlcipher3_int64 *pRowid);
5359   int (*xUpdate)(sqlcipher3_vtab *, int, sqlcipher3_value **, sqlcipher3_int64 *);
5360   int (*xBegin)(sqlcipher3_vtab *pVTab);
5361   int (*xSync)(sqlcipher3_vtab *pVTab);
5362   int (*xCommit)(sqlcipher3_vtab *pVTab);
5363   int (*xRollback)(sqlcipher3_vtab *pVTab);
5364   int (*xFindFunction)(sqlcipher3_vtab *pVtab, int nArg, const char *zName,
5365                        void (**pxFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
5366                        void **ppArg);
5367   int (*xRename)(sqlcipher3_vtab *pVtab, const char *zNew);
5368   /* The methods above are in version 1 of the sqlcipher_module object. Those 
5369   ** below are for version 2 and greater. */
5370   int (*xSavepoint)(sqlcipher3_vtab *pVTab, int);
5371   int (*xRelease)(sqlcipher3_vtab *pVTab, int);
5372   int (*xRollbackTo)(sqlcipher3_vtab *pVTab, int);
5373 };
5374
5375 /*
5376 ** CAPI3REF: Virtual Table Indexing Information
5377 ** KEYWORDS: sqlcipher3_index_info
5378 **
5379 ** The sqlcipher3_index_info structure and its substructures is used as part
5380 ** of the [virtual table] interface to
5381 ** pass information into and receive the reply from the [xBestIndex]
5382 ** method of a [virtual table module].  The fields under **Inputs** are the
5383 ** inputs to xBestIndex and are read-only.  xBestIndex inserts its
5384 ** results into the **Outputs** fields.
5385 **
5386 ** ^(The aConstraint[] array records WHERE clause constraints of the form:
5387 **
5388 ** <blockquote>column OP expr</blockquote>
5389 **
5390 ** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.)^  ^(The particular operator is
5391 ** stored in aConstraint[].op using one of the
5392 ** [SQLCIPHER_INDEX_CONSTRAINT_EQ | SQLCIPHER_INDEX_CONSTRAINT_ values].)^
5393 ** ^(The index of the column is stored in
5394 ** aConstraint[].iColumn.)^  ^(aConstraint[].usable is TRUE if the
5395 ** expr on the right-hand side can be evaluated (and thus the constraint
5396 ** is usable) and false if it cannot.)^
5397 **
5398 ** ^The optimizer automatically inverts terms of the form "expr OP column"
5399 ** and makes other simplifications to the WHERE clause in an attempt to
5400 ** get as many WHERE clause terms into the form shown above as possible.
5401 ** ^The aConstraint[] array only reports WHERE clause terms that are
5402 ** relevant to the particular virtual table being queried.
5403 **
5404 ** ^Information about the ORDER BY clause is stored in aOrderBy[].
5405 ** ^Each term of aOrderBy records a column of the ORDER BY clause.
5406 **
5407 ** The [xBestIndex] method must fill aConstraintUsage[] with information
5408 ** about what parameters to pass to xFilter.  ^If argvIndex>0 then
5409 ** the right-hand side of the corresponding aConstraint[] is evaluated
5410 ** and becomes the argvIndex-th entry in argv.  ^(If aConstraintUsage[].omit
5411 ** is true, then the constraint is assumed to be fully handled by the
5412 ** virtual table and is not checked again by SQLite.)^
5413 **
5414 ** ^The idxNum and idxPtr values are recorded and passed into the
5415 ** [xFilter] method.
5416 ** ^[sqlcipher3_free()] is used to free idxPtr if and only if
5417 ** needToFreeIdxPtr is true.
5418 **
5419 ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in
5420 ** the correct order to satisfy the ORDER BY clause so that no separate
5421 ** sorting step is required.
5422 **
5423 ** ^The estimatedCost value is an estimate of the cost of doing the
5424 ** particular lookup.  A full scan of a table with N entries should have
5425 ** a cost of N.  A binary search of a table of N entries should have a
5426 ** cost of approximately log(N).
5427 */
5428 struct sqlcipher3_index_info {
5429   /* Inputs */
5430   int nConstraint;           /* Number of entries in aConstraint */
5431   struct sqlcipher3_index_constraint {
5432      int iColumn;              /* Column on left-hand side of constraint */
5433      unsigned char op;         /* Constraint operator */
5434      unsigned char usable;     /* True if this constraint is usable */
5435      int iTermOffset;          /* Used internally - xBestIndex should ignore */
5436   } *aConstraint;            /* Table of WHERE clause constraints */
5437   int nOrderBy;              /* Number of terms in the ORDER BY clause */
5438   struct sqlcipher3_index_orderby {
5439      int iColumn;              /* Column number */
5440      unsigned char desc;       /* True for DESC.  False for ASC. */
5441   } *aOrderBy;               /* The ORDER BY clause */
5442   /* Outputs */
5443   struct sqlcipher3_index_constraint_usage {
5444     int argvIndex;           /* if >0, constraint is part of argv to xFilter */
5445     unsigned char omit;      /* Do not code a test for this constraint */
5446   } *aConstraintUsage;
5447   int idxNum;                /* Number used to identify the index */
5448   char *idxStr;              /* String, possibly obtained from sqlcipher3_malloc */
5449   int needToFreeIdxStr;      /* Free idxStr using sqlcipher3_free() if true */
5450   int orderByConsumed;       /* True if output is already ordered */
5451   double estimatedCost;      /* Estimated cost of using this index */
5452 };
5453
5454 /*
5455 ** CAPI3REF: Virtual Table Constraint Operator Codes
5456 **
5457 ** These macros defined the allowed values for the
5458 ** [sqlcipher3_index_info].aConstraint[].op field.  Each value represents
5459 ** an operator that is part of a constraint term in the wHERE clause of
5460 ** a query that uses a [virtual table].
5461 */
5462 #define SQLCIPHER_INDEX_CONSTRAINT_EQ    2
5463 #define SQLCIPHER_INDEX_CONSTRAINT_GT    4
5464 #define SQLCIPHER_INDEX_CONSTRAINT_LE    8
5465 #define SQLCIPHER_INDEX_CONSTRAINT_LT    16
5466 #define SQLCIPHER_INDEX_CONSTRAINT_GE    32
5467 #define SQLCIPHER_INDEX_CONSTRAINT_MATCH 64
5468
5469 /*
5470 ** CAPI3REF: Register A Virtual Table Implementation
5471 **
5472 ** ^These routines are used to register a new [virtual table module] name.
5473 ** ^Module names must be registered before
5474 ** creating a new [virtual table] using the module and before using a
5475 ** preexisting [virtual table] for the module.
5476 **
5477 ** ^The module name is registered on the [database connection] specified
5478 ** by the first parameter.  ^The name of the module is given by the 
5479 ** second parameter.  ^The third parameter is a pointer to
5480 ** the implementation of the [virtual table module].   ^The fourth
5481 ** parameter is an arbitrary client data pointer that is passed through
5482 ** into the [xCreate] and [xConnect] methods of the virtual table module
5483 ** when a new virtual table is be being created or reinitialized.
5484 **
5485 ** ^The sqlcipher3_create_module_v2() interface has a fifth parameter which
5486 ** is a pointer to a destructor for the pClientData.  ^SQLite will
5487 ** invoke the destructor function (if it is not NULL) when SQLite
5488 ** no longer needs the pClientData pointer.  ^The destructor will also
5489 ** be invoked if the call to sqlcipher3_create_module_v2() fails.
5490 ** ^The sqlcipher3_create_module()
5491 ** interface is equivalent to sqlcipher3_create_module_v2() with a NULL
5492 ** destructor.
5493 */
5494 SQLCIPHER_API int sqlcipher3_create_module(
5495   sqlcipher3 *db,               /* SQLite connection to register module with */
5496   const char *zName,         /* Name of the module */
5497   const sqlcipher3_module *p,   /* Methods for the module */
5498   void *pClientData          /* Client data for xCreate/xConnect */
5499 );
5500 SQLCIPHER_API int sqlcipher3_create_module_v2(
5501   sqlcipher3 *db,               /* SQLite connection to register module with */
5502   const char *zName,         /* Name of the module */
5503   const sqlcipher3_module *p,   /* Methods for the module */
5504   void *pClientData,         /* Client data for xCreate/xConnect */
5505   void(*xDestroy)(void*)     /* Module destructor function */
5506 );
5507
5508 /*
5509 ** CAPI3REF: Virtual Table Instance Object
5510 ** KEYWORDS: sqlcipher3_vtab
5511 **
5512 ** Every [virtual table module] implementation uses a subclass
5513 ** of this object to describe a particular instance
5514 ** of the [virtual table].  Each subclass will
5515 ** be tailored to the specific needs of the module implementation.
5516 ** The purpose of this superclass is to define certain fields that are
5517 ** common to all module implementations.
5518 **
5519 ** ^Virtual tables methods can set an error message by assigning a
5520 ** string obtained from [sqlcipher3_mprintf()] to zErrMsg.  The method should
5521 ** take care that any prior string is freed by a call to [sqlcipher3_free()]
5522 ** prior to assigning a new string to zErrMsg.  ^After the error message
5523 ** is delivered up to the client application, the string will be automatically
5524 ** freed by sqlcipher3_free() and the zErrMsg field will be zeroed.
5525 */
5526 struct sqlcipher3_vtab {
5527   const sqlcipher3_module *pModule;  /* The module for this virtual table */
5528   int nRef;                       /* NO LONGER USED */
5529   char *zErrMsg;                  /* Error message from sqlcipher3_mprintf() */
5530   /* Virtual table implementations will typically add additional fields */
5531 };
5532
5533 /*
5534 ** CAPI3REF: Virtual Table Cursor Object
5535 ** KEYWORDS: sqlcipher3_vtab_cursor {virtual table cursor}
5536 **
5537 ** Every [virtual table module] implementation uses a subclass of the
5538 ** following structure to describe cursors that point into the
5539 ** [virtual table] and are used
5540 ** to loop through the virtual table.  Cursors are created using the
5541 ** [sqlcipher3_module.xOpen | xOpen] method of the module and are destroyed
5542 ** by the [sqlcipher3_module.xClose | xClose] method.  Cursors are used
5543 ** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods
5544 ** of the module.  Each module implementation will define
5545 ** the content of a cursor structure to suit its own needs.
5546 **
5547 ** This superclass exists in order to define fields of the cursor that
5548 ** are common to all implementations.
5549 */
5550 struct sqlcipher3_vtab_cursor {
5551   sqlcipher3_vtab *pVtab;      /* Virtual table of this cursor */
5552   /* Virtual table implementations will typically add additional fields */
5553 };
5554
5555 /*
5556 ** CAPI3REF: Declare The Schema Of A Virtual Table
5557 **
5558 ** ^The [xCreate] and [xConnect] methods of a
5559 ** [virtual table module] call this interface
5560 ** to declare the format (the names and datatypes of the columns) of
5561 ** the virtual tables they implement.
5562 */
5563 SQLCIPHER_API int sqlcipher3_declare_vtab(sqlcipher3*, const char *zSQL);
5564
5565 /*
5566 ** CAPI3REF: Overload A Function For A Virtual Table
5567 **
5568 ** ^(Virtual tables can provide alternative implementations of functions
5569 ** using the [xFindFunction] method of the [virtual table module].  
5570 ** But global versions of those functions
5571 ** must exist in order to be overloaded.)^
5572 **
5573 ** ^(This API makes sure a global version of a function with a particular
5574 ** name and number of parameters exists.  If no such function exists
5575 ** before this API is called, a new function is created.)^  ^The implementation
5576 ** of the new function always causes an exception to be thrown.  So
5577 ** the new function is not good for anything by itself.  Its only
5578 ** purpose is to be a placeholder function that can be overloaded
5579 ** by a [virtual table].
5580 */
5581 SQLCIPHER_API int sqlcipher3_overload_function(sqlcipher3*, const char *zFuncName, int nArg);
5582
5583 /*
5584 ** The interface to the virtual-table mechanism defined above (back up
5585 ** to a comment remarkably similar to this one) is currently considered
5586 ** to be experimental.  The interface might change in incompatible ways.
5587 ** If this is a problem for you, do not use the interface at this time.
5588 **
5589 ** When the virtual-table mechanism stabilizes, we will declare the
5590 ** interface fixed, support it indefinitely, and remove this comment.
5591 */
5592
5593 /*
5594 ** CAPI3REF: A Handle To An Open BLOB
5595 ** KEYWORDS: {BLOB handle} {BLOB handles}
5596 **
5597 ** An instance of this object represents an open BLOB on which
5598 ** [sqlcipher3_blob_open | incremental BLOB I/O] can be performed.
5599 ** ^Objects of this type are created by [sqlcipher3_blob_open()]
5600 ** and destroyed by [sqlcipher3_blob_close()].
5601 ** ^The [sqlcipher3_blob_read()] and [sqlcipher3_blob_write()] interfaces
5602 ** can be used to read or write small subsections of the BLOB.
5603 ** ^The [sqlcipher3_blob_bytes()] interface returns the size of the BLOB in bytes.
5604 */
5605 typedef struct sqlcipher3_blob sqlcipher3_blob;
5606
5607 /*
5608 ** CAPI3REF: Open A BLOB For Incremental I/O
5609 **
5610 ** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
5611 ** in row iRow, column zColumn, table zTable in database zDb;
5612 ** in other words, the same BLOB that would be selected by:
5613 **
5614 ** <pre>
5615 **     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
5616 ** </pre>)^
5617 **
5618 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
5619 ** and write access. ^If it is zero, the BLOB is opened for read access.
5620 ** ^It is not possible to open a column that is part of an index or primary 
5621 ** key for writing. ^If [foreign key constraints] are enabled, it is 
5622 ** not possible to open a column that is part of a [child key] for writing.
5623 **
5624 ** ^Note that the database name is not the filename that contains
5625 ** the database but rather the symbolic name of the database that
5626 ** appears after the AS keyword when the database is connected using [ATTACH].
5627 ** ^For the main database file, the database name is "main".
5628 ** ^For TEMP tables, the database name is "temp".
5629 **
5630 ** ^(On success, [SQLCIPHER_OK] is returned and the new [BLOB handle] is written
5631 ** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set
5632 ** to be a null pointer.)^
5633 ** ^This function sets the [database connection] error code and message
5634 ** accessible via [sqlcipher3_errcode()] and [sqlcipher3_errmsg()] and related
5635 ** functions. ^Note that the *ppBlob variable is always initialized in a
5636 ** way that makes it safe to invoke [sqlcipher3_blob_close()] on *ppBlob
5637 ** regardless of the success or failure of this routine.
5638 **
5639 ** ^(If the row that a BLOB handle points to is modified by an
5640 ** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
5641 ** then the BLOB handle is marked as "expired".
5642 ** This is true if any column of the row is changed, even a column
5643 ** other than the one the BLOB handle is open on.)^
5644 ** ^Calls to [sqlcipher3_blob_read()] and [sqlcipher3_blob_write()] for
5645 ** an expired BLOB handle fail with a return code of [SQLCIPHER_ABORT].
5646 ** ^(Changes written into a BLOB prior to the BLOB expiring are not
5647 ** rolled back by the expiration of the BLOB.  Such changes will eventually
5648 ** commit if the transaction continues to completion.)^
5649 **
5650 ** ^Use the [sqlcipher3_blob_bytes()] interface to determine the size of
5651 ** the opened blob.  ^The size of a blob may not be changed by this
5652 ** interface.  Use the [UPDATE] SQL command to change the size of a
5653 ** blob.
5654 **
5655 ** ^The [sqlcipher3_bind_zeroblob()] and [sqlcipher3_result_zeroblob()] interfaces
5656 ** and the built-in [zeroblob] SQL function can be used, if desired,
5657 ** to create an empty, zero-filled blob in which to read or write using
5658 ** this interface.
5659 **
5660 ** To avoid a resource leak, every open [BLOB handle] should eventually
5661 ** be released by a call to [sqlcipher3_blob_close()].
5662 */
5663 SQLCIPHER_API int sqlcipher3_blob_open(
5664   sqlcipher3*,
5665   const char *zDb,
5666   const char *zTable,
5667   const char *zColumn,
5668   sqlcipher3_int64 iRow,
5669   int flags,
5670   sqlcipher3_blob **ppBlob
5671 );
5672
5673 /*
5674 ** CAPI3REF: Move a BLOB Handle to a New Row
5675 **
5676 ** ^This function is used to move an existing blob handle so that it points
5677 ** to a different row of the same database table. ^The new row is identified
5678 ** by the rowid value passed as the second argument. Only the row can be
5679 ** changed. ^The database, table and column on which the blob handle is open
5680 ** remain the same. Moving an existing blob handle to a new row can be
5681 ** faster than closing the existing handle and opening a new one.
5682 **
5683 ** ^(The new row must meet the same criteria as for [sqlcipher3_blob_open()] -
5684 ** it must exist and there must be either a blob or text value stored in
5685 ** the nominated column.)^ ^If the new row is not present in the table, or if
5686 ** it does not contain a blob or text value, or if another error occurs, an
5687 ** SQLite error code is returned and the blob handle is considered aborted.
5688 ** ^All subsequent calls to [sqlcipher3_blob_read()], [sqlcipher3_blob_write()] or
5689 ** [sqlcipher3_blob_reopen()] on an aborted blob handle immediately return
5690 ** SQLCIPHER_ABORT. ^Calling [sqlcipher3_blob_bytes()] on an aborted blob handle
5691 ** always returns zero.
5692 **
5693 ** ^This function sets the database handle error code and message.
5694 */
5695 SQLCIPHER_API SQLCIPHER_EXPERIMENTAL int sqlcipher3_blob_reopen(sqlcipher3_blob *, sqlcipher3_int64);
5696
5697 /*
5698 ** CAPI3REF: Close A BLOB Handle
5699 **
5700 ** ^Closes an open [BLOB handle].
5701 **
5702 ** ^Closing a BLOB shall cause the current transaction to commit
5703 ** if there are no other BLOBs, no pending prepared statements, and the
5704 ** database connection is in [autocommit mode].
5705 ** ^If any writes were made to the BLOB, they might be held in cache
5706 ** until the close operation if they will fit.
5707 **
5708 ** ^(Closing the BLOB often forces the changes
5709 ** out to disk and so if any I/O errors occur, they will likely occur
5710 ** at the time when the BLOB is closed.  Any errors that occur during
5711 ** closing are reported as a non-zero return value.)^
5712 **
5713 ** ^(The BLOB is closed unconditionally.  Even if this routine returns
5714 ** an error code, the BLOB is still closed.)^
5715 **
5716 ** ^Calling this routine with a null pointer (such as would be returned
5717 ** by a failed call to [sqlcipher3_blob_open()]) is a harmless no-op.
5718 */
5719 SQLCIPHER_API int sqlcipher3_blob_close(sqlcipher3_blob *);
5720
5721 /*
5722 ** CAPI3REF: Return The Size Of An Open BLOB
5723 **
5724 ** ^Returns the size in bytes of the BLOB accessible via the 
5725 ** successfully opened [BLOB handle] in its only argument.  ^The
5726 ** incremental blob I/O routines can only read or overwriting existing
5727 ** blob content; they cannot change the size of a blob.
5728 **
5729 ** This routine only works on a [BLOB handle] which has been created
5730 ** by a prior successful call to [sqlcipher3_blob_open()] and which has not
5731 ** been closed by [sqlcipher3_blob_close()].  Passing any other pointer in
5732 ** to this routine results in undefined and probably undesirable behavior.
5733 */
5734 SQLCIPHER_API int sqlcipher3_blob_bytes(sqlcipher3_blob *);
5735
5736 /*
5737 ** CAPI3REF: Read Data From A BLOB Incrementally
5738 **
5739 ** ^(This function is used to read data from an open [BLOB handle] into a
5740 ** caller-supplied buffer. N bytes of data are copied into buffer Z
5741 ** from the open BLOB, starting at offset iOffset.)^
5742 **
5743 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5744 ** [SQLCIPHER_ERROR] is returned and no data is read.  ^If N or iOffset is
5745 ** less than zero, [SQLCIPHER_ERROR] is returned and no data is read.
5746 ** ^The size of the blob (and hence the maximum value of N+iOffset)
5747 ** can be determined using the [sqlcipher3_blob_bytes()] interface.
5748 **
5749 ** ^An attempt to read from an expired [BLOB handle] fails with an
5750 ** error code of [SQLCIPHER_ABORT].
5751 **
5752 ** ^(On success, sqlcipher3_blob_read() returns SQLCIPHER_OK.
5753 ** Otherwise, an [error code] or an [extended error code] is returned.)^
5754 **
5755 ** This routine only works on a [BLOB handle] which has been created
5756 ** by a prior successful call to [sqlcipher3_blob_open()] and which has not
5757 ** been closed by [sqlcipher3_blob_close()].  Passing any other pointer in
5758 ** to this routine results in undefined and probably undesirable behavior.
5759 **
5760 ** See also: [sqlcipher3_blob_write()].
5761 */
5762 SQLCIPHER_API int sqlcipher3_blob_read(sqlcipher3_blob *, void *Z, int N, int iOffset);
5763
5764 /*
5765 ** CAPI3REF: Write Data Into A BLOB Incrementally
5766 **
5767 ** ^This function is used to write data into an open [BLOB handle] from a
5768 ** caller-supplied buffer. ^N bytes of data are copied from the buffer Z
5769 ** into the open BLOB, starting at offset iOffset.
5770 **
5771 ** ^If the [BLOB handle] passed as the first argument was not opened for
5772 ** writing (the flags parameter to [sqlcipher3_blob_open()] was zero),
5773 ** this function returns [SQLCIPHER_READONLY].
5774 **
5775 ** ^This function may only modify the contents of the BLOB; it is
5776 ** not possible to increase the size of a BLOB using this API.
5777 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5778 ** [SQLCIPHER_ERROR] is returned and no data is written.  ^If N is
5779 ** less than zero [SQLCIPHER_ERROR] is returned and no data is written.
5780 ** The size of the BLOB (and hence the maximum value of N+iOffset)
5781 ** can be determined using the [sqlcipher3_blob_bytes()] interface.
5782 **
5783 ** ^An attempt to write to an expired [BLOB handle] fails with an
5784 ** error code of [SQLCIPHER_ABORT].  ^Writes to the BLOB that occurred
5785 ** before the [BLOB handle] expired are not rolled back by the
5786 ** expiration of the handle, though of course those changes might
5787 ** have been overwritten by the statement that expired the BLOB handle
5788 ** or by other independent statements.
5789 **
5790 ** ^(On success, sqlcipher3_blob_write() returns SQLCIPHER_OK.
5791 ** Otherwise, an  [error code] or an [extended error code] is returned.)^
5792 **
5793 ** This routine only works on a [BLOB handle] which has been created
5794 ** by a prior successful call to [sqlcipher3_blob_open()] and which has not
5795 ** been closed by [sqlcipher3_blob_close()].  Passing any other pointer in
5796 ** to this routine results in undefined and probably undesirable behavior.
5797 **
5798 ** See also: [sqlcipher3_blob_read()].
5799 */
5800 SQLCIPHER_API int sqlcipher3_blob_write(sqlcipher3_blob *, const void *z, int n, int iOffset);
5801
5802 /*
5803 ** CAPI3REF: Virtual File System Objects
5804 **
5805 ** A virtual filesystem (VFS) is an [sqlcipher3_vfs] object
5806 ** that SQLite uses to interact
5807 ** with the underlying operating system.  Most SQLite builds come with a
5808 ** single default VFS that is appropriate for the host computer.
5809 ** New VFSes can be registered and existing VFSes can be unregistered.
5810 ** The following interfaces are provided.
5811 **
5812 ** ^The sqlcipher3_vfs_find() interface returns a pointer to a VFS given its name.
5813 ** ^Names are case sensitive.
5814 ** ^Names are zero-terminated UTF-8 strings.
5815 ** ^If there is no match, a NULL pointer is returned.
5816 ** ^If zVfsName is NULL then the default VFS is returned.
5817 **
5818 ** ^New VFSes are registered with sqlcipher3_vfs_register().
5819 ** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
5820 ** ^The same VFS can be registered multiple times without injury.
5821 ** ^To make an existing VFS into the default VFS, register it again
5822 ** with the makeDflt flag set.  If two different VFSes with the
5823 ** same name are registered, the behavior is undefined.  If a
5824 ** VFS is registered with a name that is NULL or an empty string,
5825 ** then the behavior is undefined.
5826 **
5827 ** ^Unregister a VFS with the sqlcipher3_vfs_unregister() interface.
5828 ** ^(If the default VFS is unregistered, another VFS is chosen as
5829 ** the default.  The choice for the new VFS is arbitrary.)^
5830 */
5831 SQLCIPHER_API sqlcipher3_vfs *sqlcipher3_vfs_find(const char *zVfsName);
5832 SQLCIPHER_API int sqlcipher3_vfs_register(sqlcipher3_vfs*, int makeDflt);
5833 SQLCIPHER_API int sqlcipher3_vfs_unregister(sqlcipher3_vfs*);
5834
5835 /*
5836 ** CAPI3REF: Mutexes
5837 **
5838 ** The SQLite core uses these routines for thread
5839 ** synchronization. Though they are intended for internal
5840 ** use by SQLite, code that links against SQLite is
5841 ** permitted to use any of these routines.
5842 **
5843 ** The SQLite source code contains multiple implementations
5844 ** of these mutex routines.  An appropriate implementation
5845 ** is selected automatically at compile-time.  ^(The following
5846 ** implementations are available in the SQLite core:
5847 **
5848 ** <ul>
5849 ** <li>   SQLCIPHER_MUTEX_OS2
5850 ** <li>   SQLCIPHER_MUTEX_PTHREAD
5851 ** <li>   SQLCIPHER_MUTEX_W32
5852 ** <li>   SQLCIPHER_MUTEX_NOOP
5853 ** </ul>)^
5854 **
5855 ** ^The SQLCIPHER_MUTEX_NOOP implementation is a set of routines
5856 ** that does no real locking and is appropriate for use in
5857 ** a single-threaded application.  ^The SQLCIPHER_MUTEX_OS2,
5858 ** SQLCIPHER_MUTEX_PTHREAD, and SQLCIPHER_MUTEX_W32 implementations
5859 ** are appropriate for use on OS/2, Unix, and Windows.
5860 **
5861 ** ^(If SQLite is compiled with the SQLCIPHER_MUTEX_APPDEF preprocessor
5862 ** macro defined (with "-DSQLCIPHER_MUTEX_APPDEF=1"), then no mutex
5863 ** implementation is included with the library. In this case the
5864 ** application must supply a custom mutex implementation using the
5865 ** [SQLCIPHER_CONFIG_MUTEX] option of the sqlcipher3_config() function
5866 ** before calling sqlcipher3_initialize() or any other public sqlcipher3_
5867 ** function that calls sqlcipher3_initialize().)^
5868 **
5869 ** ^The sqlcipher3_mutex_alloc() routine allocates a new
5870 ** mutex and returns a pointer to it. ^If it returns NULL
5871 ** that means that a mutex could not be allocated.  ^SQLite
5872 ** will unwind its stack and return an error.  ^(The argument
5873 ** to sqlcipher3_mutex_alloc() is one of these integer constants:
5874 **
5875 ** <ul>
5876 ** <li>  SQLCIPHER_MUTEX_FAST
5877 ** <li>  SQLCIPHER_MUTEX_RECURSIVE
5878 ** <li>  SQLCIPHER_MUTEX_STATIC_MASTER
5879 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM
5880 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM2
5881 ** <li>  SQLCIPHER_MUTEX_STATIC_PRNG
5882 ** <li>  SQLCIPHER_MUTEX_STATIC_LRU
5883 ** <li>  SQLCIPHER_MUTEX_STATIC_LRU2
5884 ** </ul>)^
5885 **
5886 ** ^The first two constants (SQLCIPHER_MUTEX_FAST and SQLCIPHER_MUTEX_RECURSIVE)
5887 ** cause sqlcipher3_mutex_alloc() to create
5888 ** a new mutex.  ^The new mutex is recursive when SQLCIPHER_MUTEX_RECURSIVE
5889 ** is used but not necessarily so when SQLCIPHER_MUTEX_FAST is used.
5890 ** The mutex implementation does not need to make a distinction
5891 ** between SQLCIPHER_MUTEX_RECURSIVE and SQLCIPHER_MUTEX_FAST if it does
5892 ** not want to.  ^SQLite will only request a recursive mutex in
5893 ** cases where it really needs one.  ^If a faster non-recursive mutex
5894 ** implementation is available on the host platform, the mutex subsystem
5895 ** might return such a mutex in response to SQLCIPHER_MUTEX_FAST.
5896 **
5897 ** ^The other allowed parameters to sqlcipher3_mutex_alloc() (anything other
5898 ** than SQLCIPHER_MUTEX_FAST and SQLCIPHER_MUTEX_RECURSIVE) each return
5899 ** a pointer to a static preexisting mutex.  ^Six static mutexes are
5900 ** used by the current version of SQLite.  Future versions of SQLite
5901 ** may add additional static mutexes.  Static mutexes are for internal
5902 ** use by SQLite only.  Applications that use SQLite mutexes should
5903 ** use only the dynamic mutexes returned by SQLCIPHER_MUTEX_FAST or
5904 ** SQLCIPHER_MUTEX_RECURSIVE.
5905 **
5906 ** ^Note that if one of the dynamic mutex parameters (SQLCIPHER_MUTEX_FAST
5907 ** or SQLCIPHER_MUTEX_RECURSIVE) is used then sqlcipher3_mutex_alloc()
5908 ** returns a different mutex on every call.  ^But for the static
5909 ** mutex types, the same mutex is returned on every call that has
5910 ** the same type number.
5911 **
5912 ** ^The sqlcipher3_mutex_free() routine deallocates a previously
5913 ** allocated dynamic mutex.  ^SQLite is careful to deallocate every
5914 ** dynamic mutex that it allocates.  The dynamic mutexes must not be in
5915 ** use when they are deallocated.  Attempting to deallocate a static
5916 ** mutex results in undefined behavior.  ^SQLite never deallocates
5917 ** a static mutex.
5918 **
5919 ** ^The sqlcipher3_mutex_enter() and sqlcipher3_mutex_try() routines attempt
5920 ** to enter a mutex.  ^If another thread is already within the mutex,
5921 ** sqlcipher3_mutex_enter() will block and sqlcipher3_mutex_try() will return
5922 ** SQLCIPHER_BUSY.  ^The sqlcipher3_mutex_try() interface returns [SQLCIPHER_OK]
5923 ** upon successful entry.  ^(Mutexes created using
5924 ** SQLCIPHER_MUTEX_RECURSIVE can be entered multiple times by the same thread.
5925 ** In such cases the,
5926 ** mutex must be exited an equal number of times before another thread
5927 ** can enter.)^  ^(If the same thread tries to enter any other
5928 ** kind of mutex more than once, the behavior is undefined.
5929 ** SQLite will never exhibit
5930 ** such behavior in its own use of mutexes.)^
5931 **
5932 ** ^(Some systems (for example, Windows 95) do not support the operation
5933 ** implemented by sqlcipher3_mutex_try().  On those systems, sqlcipher3_mutex_try()
5934 ** will always return SQLCIPHER_BUSY.  The SQLite core only ever uses
5935 ** sqlcipher3_mutex_try() as an optimization so this is acceptable behavior.)^
5936 **
5937 ** ^The sqlcipher3_mutex_leave() routine exits a mutex that was
5938 ** previously entered by the same thread.   ^(The behavior
5939 ** is undefined if the mutex is not currently entered by the
5940 ** calling thread or is not currently allocated.  SQLite will
5941 ** never do either.)^
5942 **
5943 ** ^If the argument to sqlcipher3_mutex_enter(), sqlcipher3_mutex_try(), or
5944 ** sqlcipher3_mutex_leave() is a NULL pointer, then all three routines
5945 ** behave as no-ops.
5946 **
5947 ** See also: [sqlcipher3_mutex_held()] and [sqlcipher3_mutex_notheld()].
5948 */
5949 SQLCIPHER_API sqlcipher3_mutex *sqlcipher3_mutex_alloc(int);
5950 SQLCIPHER_API void sqlcipher3_mutex_free(sqlcipher3_mutex*);
5951 SQLCIPHER_API void sqlcipher3_mutex_enter(sqlcipher3_mutex*);
5952 SQLCIPHER_API int sqlcipher3_mutex_try(sqlcipher3_mutex*);
5953 SQLCIPHER_API void sqlcipher3_mutex_leave(sqlcipher3_mutex*);
5954
5955 /*
5956 ** CAPI3REF: Mutex Methods Object
5957 **
5958 ** An instance of this structure defines the low-level routines
5959 ** used to allocate and use mutexes.
5960 **
5961 ** Usually, the default mutex implementations provided by SQLite are
5962 ** sufficient, however the user has the option of substituting a custom
5963 ** implementation for specialized deployments or systems for which SQLite
5964 ** does not provide a suitable implementation. In this case, the user
5965 ** creates and populates an instance of this structure to pass
5966 ** to sqlcipher3_config() along with the [SQLCIPHER_CONFIG_MUTEX] option.
5967 ** Additionally, an instance of this structure can be used as an
5968 ** output variable when querying the system for the current mutex
5969 ** implementation, using the [SQLCIPHER_CONFIG_GETMUTEX] option.
5970 **
5971 ** ^The xMutexInit method defined by this structure is invoked as
5972 ** part of system initialization by the sqlcipher3_initialize() function.
5973 ** ^The xMutexInit routine is called by SQLite exactly once for each
5974 ** effective call to [sqlcipher3_initialize()].
5975 **
5976 ** ^The xMutexEnd method defined by this structure is invoked as
5977 ** part of system shutdown by the sqlcipher3_shutdown() function. The
5978 ** implementation of this method is expected to release all outstanding
5979 ** resources obtained by the mutex methods implementation, especially
5980 ** those obtained by the xMutexInit method.  ^The xMutexEnd()
5981 ** interface is invoked exactly once for each call to [sqlcipher3_shutdown()].
5982 **
5983 ** ^(The remaining seven methods defined by this structure (xMutexAlloc,
5984 ** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
5985 ** xMutexNotheld) implement the following interfaces (respectively):
5986 **
5987 ** <ul>
5988 **   <li>  [sqlcipher3_mutex_alloc()] </li>
5989 **   <li>  [sqlcipher3_mutex_free()] </li>
5990 **   <li>  [sqlcipher3_mutex_enter()] </li>
5991 **   <li>  [sqlcipher3_mutex_try()] </li>
5992 **   <li>  [sqlcipher3_mutex_leave()] </li>
5993 **   <li>  [sqlcipher3_mutex_held()] </li>
5994 **   <li>  [sqlcipher3_mutex_notheld()] </li>
5995 ** </ul>)^
5996 **
5997 ** The only difference is that the public sqlcipher3_XXX functions enumerated
5998 ** above silently ignore any invocations that pass a NULL pointer instead
5999 ** of a valid mutex handle. The implementations of the methods defined
6000 ** by this structure are not required to handle this case, the results
6001 ** of passing a NULL pointer instead of a valid mutex handle are undefined
6002 ** (i.e. it is acceptable to provide an implementation that segfaults if
6003 ** it is passed a NULL pointer).
6004 **
6005 ** The xMutexInit() method must be threadsafe.  ^It must be harmless to
6006 ** invoke xMutexInit() multiple times within the same process and without
6007 ** intervening calls to xMutexEnd().  Second and subsequent calls to
6008 ** xMutexInit() must be no-ops.
6009 **
6010 ** ^xMutexInit() must not use SQLite memory allocation ([sqlcipher3_malloc()]
6011 ** and its associates).  ^Similarly, xMutexAlloc() must not use SQLite memory
6012 ** allocation for a static mutex.  ^However xMutexAlloc() may use SQLite
6013 ** memory allocation for a fast or recursive mutex.
6014 **
6015 ** ^SQLite will invoke the xMutexEnd() method when [sqlcipher3_shutdown()] is
6016 ** called, but only if the prior call to xMutexInit returned SQLCIPHER_OK.
6017 ** If xMutexInit fails in any way, it is expected to clean up after itself
6018 ** prior to returning.
6019 */
6020 typedef struct sqlcipher3_mutex_methods sqlcipher3_mutex_methods;
6021 struct sqlcipher3_mutex_methods {
6022   int (*xMutexInit)(void);
6023   int (*xMutexEnd)(void);
6024   sqlcipher3_mutex *(*xMutexAlloc)(int);
6025   void (*xMutexFree)(sqlcipher3_mutex *);
6026   void (*xMutexEnter)(sqlcipher3_mutex *);
6027   int (*xMutexTry)(sqlcipher3_mutex *);
6028   void (*xMutexLeave)(sqlcipher3_mutex *);
6029   int (*xMutexHeld)(sqlcipher3_mutex *);
6030   int (*xMutexNotheld)(sqlcipher3_mutex *);
6031 };
6032
6033 /*
6034 ** CAPI3REF: Mutex Verification Routines
6035 **
6036 ** The sqlcipher3_mutex_held() and sqlcipher3_mutex_notheld() routines
6037 ** are intended for use inside assert() statements.  ^The SQLite core
6038 ** never uses these routines except inside an assert() and applications
6039 ** are advised to follow the lead of the core.  ^The SQLite core only
6040 ** provides implementations for these routines when it is compiled
6041 ** with the SQLCIPHER_DEBUG flag.  ^External mutex implementations
6042 ** are only required to provide these routines if SQLCIPHER_DEBUG is
6043 ** defined and if NDEBUG is not defined.
6044 **
6045 ** ^These routines should return true if the mutex in their argument
6046 ** is held or not held, respectively, by the calling thread.
6047 **
6048 ** ^The implementation is not required to provided versions of these
6049 ** routines that actually work. If the implementation does not provide working
6050 ** versions of these routines, it should at least provide stubs that always
6051 ** return true so that one does not get spurious assertion failures.
6052 **
6053 ** ^If the argument to sqlcipher3_mutex_held() is a NULL pointer then
6054 ** the routine should return 1.   This seems counter-intuitive since
6055 ** clearly the mutex cannot be held if it does not exist.  But
6056 ** the reason the mutex does not exist is because the build is not
6057 ** using mutexes.  And we do not want the assert() containing the
6058 ** call to sqlcipher3_mutex_held() to fail, so a non-zero return is
6059 ** the appropriate thing to do.  ^The sqlcipher3_mutex_notheld()
6060 ** interface should also return 1 when given a NULL pointer.
6061 */
6062 #ifndef NDEBUG
6063 SQLCIPHER_API int sqlcipher3_mutex_held(sqlcipher3_mutex*);
6064 SQLCIPHER_API int sqlcipher3_mutex_notheld(sqlcipher3_mutex*);
6065 #endif
6066
6067 /*
6068 ** CAPI3REF: Mutex Types
6069 **
6070 ** The [sqlcipher3_mutex_alloc()] interface takes a single argument
6071 ** which is one of these integer constants.
6072 **
6073 ** The set of static mutexes may change from one SQLite release to the
6074 ** next.  Applications that override the built-in mutex logic must be
6075 ** prepared to accommodate additional static mutexes.
6076 */
6077 #define SQLCIPHER_MUTEX_FAST             0
6078 #define SQLCIPHER_MUTEX_RECURSIVE        1
6079 #define SQLCIPHER_MUTEX_STATIC_MASTER    2
6080 #define SQLCIPHER_MUTEX_STATIC_MEM       3  /* sqlcipher3_malloc() */
6081 #define SQLCIPHER_MUTEX_STATIC_MEM2      4  /* NOT USED */
6082 #define SQLCIPHER_MUTEX_STATIC_OPEN      4  /* sqlcipher3BtreeOpen() */
6083 #define SQLCIPHER_MUTEX_STATIC_PRNG      5  /* sqlcipher3_random() */
6084 #define SQLCIPHER_MUTEX_STATIC_LRU       6  /* lru page list */
6085 #define SQLCIPHER_MUTEX_STATIC_LRU2      7  /* NOT USED */
6086 #define SQLCIPHER_MUTEX_STATIC_PMEM      7  /* sqlcipher3PageMalloc() */
6087
6088 /*
6089 ** CAPI3REF: Retrieve the mutex for a database connection
6090 **
6091 ** ^This interface returns a pointer the [sqlcipher3_mutex] object that 
6092 ** serializes access to the [database connection] given in the argument
6093 ** when the [threading mode] is Serialized.
6094 ** ^If the [threading mode] is Single-thread or Multi-thread then this
6095 ** routine returns a NULL pointer.
6096 */
6097 SQLCIPHER_API sqlcipher3_mutex *sqlcipher3_db_mutex(sqlcipher3*);
6098
6099 /*
6100 ** CAPI3REF: Low-Level Control Of Database Files
6101 **
6102 ** ^The [sqlcipher3_file_control()] interface makes a direct call to the
6103 ** xFileControl method for the [sqlcipher3_io_methods] object associated
6104 ** with a particular database identified by the second argument. ^The
6105 ** name of the database is "main" for the main database or "temp" for the
6106 ** TEMP database, or the name that appears after the AS keyword for
6107 ** databases that are added using the [ATTACH] SQL command.
6108 ** ^A NULL pointer can be used in place of "main" to refer to the
6109 ** main database file.
6110 ** ^The third and fourth parameters to this routine
6111 ** are passed directly through to the second and third parameters of
6112 ** the xFileControl method.  ^The return value of the xFileControl
6113 ** method becomes the return value of this routine.
6114 **
6115 ** ^The SQLCIPHER_FCNTL_FILE_POINTER value for the op parameter causes
6116 ** a pointer to the underlying [sqlcipher3_file] object to be written into
6117 ** the space pointed to by the 4th parameter.  ^The SQLCIPHER_FCNTL_FILE_POINTER
6118 ** case is a short-circuit path which does not actually invoke the
6119 ** underlying sqlcipher3_io_methods.xFileControl method.
6120 **
6121 ** ^If the second parameter (zDbName) does not match the name of any
6122 ** open database file, then SQLCIPHER_ERROR is returned.  ^This error
6123 ** code is not remembered and will not be recalled by [sqlcipher3_errcode()]
6124 ** or [sqlcipher3_errmsg()].  The underlying xFileControl method might
6125 ** also return SQLCIPHER_ERROR.  There is no way to distinguish between
6126 ** an incorrect zDbName and an SQLCIPHER_ERROR return from the underlying
6127 ** xFileControl method.
6128 **
6129 ** See also: [SQLCIPHER_FCNTL_LOCKSTATE]
6130 */
6131 SQLCIPHER_API int sqlcipher3_file_control(sqlcipher3*, const char *zDbName, int op, void*);
6132
6133 /*
6134 ** CAPI3REF: Testing Interface
6135 **
6136 ** ^The sqlcipher3_test_control() interface is used to read out internal
6137 ** state of SQLite and to inject faults into SQLite for testing
6138 ** purposes.  ^The first parameter is an operation code that determines
6139 ** the number, meaning, and operation of all subsequent parameters.
6140 **
6141 ** This interface is not for use by applications.  It exists solely
6142 ** for verifying the correct operation of the SQLite library.  Depending
6143 ** on how the SQLite library is compiled, this interface might not exist.
6144 **
6145 ** The details of the operation codes, their meanings, the parameters
6146 ** they take, and what they do are all subject to change without notice.
6147 ** Unlike most of the SQLite API, this function is not guaranteed to
6148 ** operate consistently from one release to the next.
6149 */
6150 SQLCIPHER_API int sqlcipher3_test_control(int op, ...);
6151
6152 /*
6153 ** CAPI3REF: Testing Interface Operation Codes
6154 **
6155 ** These constants are the valid operation code parameters used
6156 ** as the first argument to [sqlcipher3_test_control()].
6157 **
6158 ** These parameters and their meanings are subject to change
6159 ** without notice.  These values are for testing purposes only.
6160 ** Applications should not use any of these parameters or the
6161 ** [sqlcipher3_test_control()] interface.
6162 */
6163 #define SQLCIPHER_TESTCTRL_FIRST                    5
6164 #define SQLCIPHER_TESTCTRL_PRNG_SAVE                5
6165 #define SQLCIPHER_TESTCTRL_PRNG_RESTORE             6
6166 #define SQLCIPHER_TESTCTRL_PRNG_RESET               7
6167 #define SQLCIPHER_TESTCTRL_BITVEC_TEST              8
6168 #define SQLCIPHER_TESTCTRL_FAULT_INSTALL            9
6169 #define SQLCIPHER_TESTCTRL_BENIGN_MALLOC_HOOKS     10
6170 #define SQLCIPHER_TESTCTRL_PENDING_BYTE            11
6171 #define SQLCIPHER_TESTCTRL_ASSERT                  12
6172 #define SQLCIPHER_TESTCTRL_ALWAYS                  13
6173 #define SQLCIPHER_TESTCTRL_RESERVE                 14
6174 #define SQLCIPHER_TESTCTRL_OPTIMIZATIONS           15
6175 #define SQLCIPHER_TESTCTRL_ISKEYWORD               16
6176 #define SQLCIPHER_TESTCTRL_PGHDRSZ                 17
6177 #define SQLCIPHER_TESTCTRL_SCRATCHMALLOC           18
6178 #define SQLCIPHER_TESTCTRL_LOCALTIME_FAULT         19
6179 #define SQLCIPHER_TESTCTRL_LAST                    19
6180
6181 /*
6182 ** CAPI3REF: SQLite Runtime Status
6183 **
6184 ** ^This interface is used to retrieve runtime status information
6185 ** about the performance of SQLite, and optionally to reset various
6186 ** highwater marks.  ^The first argument is an integer code for
6187 ** the specific parameter to measure.  ^(Recognized integer codes
6188 ** are of the form [status parameters | SQLCIPHER_STATUS_...].)^
6189 ** ^The current value of the parameter is returned into *pCurrent.
6190 ** ^The highest recorded value is returned in *pHighwater.  ^If the
6191 ** resetFlag is true, then the highest record value is reset after
6192 ** *pHighwater is written.  ^(Some parameters do not record the highest
6193 ** value.  For those parameters
6194 ** nothing is written into *pHighwater and the resetFlag is ignored.)^
6195 ** ^(Other parameters record only the highwater mark and not the current
6196 ** value.  For these latter parameters nothing is written into *pCurrent.)^
6197 **
6198 ** ^The sqlcipher3_status() routine returns SQLCIPHER_OK on success and a
6199 ** non-zero [error code] on failure.
6200 **
6201 ** This routine is threadsafe but is not atomic.  This routine can be
6202 ** called while other threads are running the same or different SQLite
6203 ** interfaces.  However the values returned in *pCurrent and
6204 ** *pHighwater reflect the status of SQLite at different points in time
6205 ** and it is possible that another thread might change the parameter
6206 ** in between the times when *pCurrent and *pHighwater are written.
6207 **
6208 ** See also: [sqlcipher3_db_status()]
6209 */
6210 SQLCIPHER_API int sqlcipher3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
6211
6212
6213 /*
6214 ** CAPI3REF: Status Parameters
6215 ** KEYWORDS: {status parameters}
6216 **
6217 ** These integer constants designate various run-time status parameters
6218 ** that can be returned by [sqlcipher3_status()].
6219 **
6220 ** <dl>
6221 ** [[SQLCIPHER_STATUS_MEMORY_USED]] ^(<dt>SQLCIPHER_STATUS_MEMORY_USED</dt>
6222 ** <dd>This parameter is the current amount of memory checked out
6223 ** using [sqlcipher3_malloc()], either directly or indirectly.  The
6224 ** figure includes calls made to [sqlcipher3_malloc()] by the application
6225 ** and internal memory usage by the SQLite library.  Scratch memory
6226 ** controlled by [SQLCIPHER_CONFIG_SCRATCH] and auxiliary page-cache
6227 ** memory controlled by [SQLCIPHER_CONFIG_PAGECACHE] is not included in
6228 ** this parameter.  The amount returned is the sum of the allocation
6229 ** sizes as reported by the xSize method in [sqlcipher3_mem_methods].</dd>)^
6230 **
6231 ** [[SQLCIPHER_STATUS_MALLOC_SIZE]] ^(<dt>SQLCIPHER_STATUS_MALLOC_SIZE</dt>
6232 ** <dd>This parameter records the largest memory allocation request
6233 ** handed to [sqlcipher3_malloc()] or [sqlcipher3_realloc()] (or their
6234 ** internal equivalents).  Only the value returned in the
6235 ** *pHighwater parameter to [sqlcipher3_status()] is of interest.  
6236 ** The value written into the *pCurrent parameter is undefined.</dd>)^
6237 **
6238 ** [[SQLCIPHER_STATUS_MALLOC_COUNT]] ^(<dt>SQLCIPHER_STATUS_MALLOC_COUNT</dt>
6239 ** <dd>This parameter records the number of separate memory allocations
6240 ** currently checked out.</dd>)^
6241 **
6242 ** [[SQLCIPHER_STATUS_PAGECACHE_USED]] ^(<dt>SQLCIPHER_STATUS_PAGECACHE_USED</dt>
6243 ** <dd>This parameter returns the number of pages used out of the
6244 ** [pagecache memory allocator] that was configured using 
6245 ** [SQLCIPHER_CONFIG_PAGECACHE].  The
6246 ** value returned is in pages, not in bytes.</dd>)^
6247 **
6248 ** [[SQLCIPHER_STATUS_PAGECACHE_OVERFLOW]] 
6249 ** ^(<dt>SQLCIPHER_STATUS_PAGECACHE_OVERFLOW</dt>
6250 ** <dd>This parameter returns the number of bytes of page cache
6251 ** allocation which could not be satisfied by the [SQLCIPHER_CONFIG_PAGECACHE]
6252 ** buffer and where forced to overflow to [sqlcipher3_malloc()].  The
6253 ** returned value includes allocations that overflowed because they
6254 ** where too large (they were larger than the "sz" parameter to
6255 ** [SQLCIPHER_CONFIG_PAGECACHE]) and allocations that overflowed because
6256 ** no space was left in the page cache.</dd>)^
6257 **
6258 ** [[SQLCIPHER_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLCIPHER_STATUS_PAGECACHE_SIZE</dt>
6259 ** <dd>This parameter records the largest memory allocation request
6260 ** handed to [pagecache memory allocator].  Only the value returned in the
6261 ** *pHighwater parameter to [sqlcipher3_status()] is of interest.  
6262 ** The value written into the *pCurrent parameter is undefined.</dd>)^
6263 **
6264 ** [[SQLCIPHER_STATUS_SCRATCH_USED]] ^(<dt>SQLCIPHER_STATUS_SCRATCH_USED</dt>
6265 ** <dd>This parameter returns the number of allocations used out of the
6266 ** [scratch memory allocator] configured using
6267 ** [SQLCIPHER_CONFIG_SCRATCH].  The value returned is in allocations, not
6268 ** in bytes.  Since a single thread may only have one scratch allocation
6269 ** outstanding at time, this parameter also reports the number of threads
6270 ** using scratch memory at the same time.</dd>)^
6271 **
6272 ** [[SQLCIPHER_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLCIPHER_STATUS_SCRATCH_OVERFLOW</dt>
6273 ** <dd>This parameter returns the number of bytes of scratch memory
6274 ** allocation which could not be satisfied by the [SQLCIPHER_CONFIG_SCRATCH]
6275 ** buffer and where forced to overflow to [sqlcipher3_malloc()].  The values
6276 ** returned include overflows because the requested allocation was too
6277 ** larger (that is, because the requested allocation was larger than the
6278 ** "sz" parameter to [SQLCIPHER_CONFIG_SCRATCH]) and because no scratch buffer
6279 ** slots were available.
6280 ** </dd>)^
6281 **
6282 ** [[SQLCIPHER_STATUS_SCRATCH_SIZE]] ^(<dt>SQLCIPHER_STATUS_SCRATCH_SIZE</dt>
6283 ** <dd>This parameter records the largest memory allocation request
6284 ** handed to [scratch memory allocator].  Only the value returned in the
6285 ** *pHighwater parameter to [sqlcipher3_status()] is of interest.  
6286 ** The value written into the *pCurrent parameter is undefined.</dd>)^
6287 **
6288 ** [[SQLCIPHER_STATUS_PARSER_STACK]] ^(<dt>SQLCIPHER_STATUS_PARSER_STACK</dt>
6289 ** <dd>This parameter records the deepest parser stack.  It is only
6290 ** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^
6291 ** </dl>
6292 **
6293 ** New status parameters may be added from time to time.
6294 */
6295 #define SQLCIPHER_STATUS_MEMORY_USED          0
6296 #define SQLCIPHER_STATUS_PAGECACHE_USED       1
6297 #define SQLCIPHER_STATUS_PAGECACHE_OVERFLOW   2
6298 #define SQLCIPHER_STATUS_SCRATCH_USED         3
6299 #define SQLCIPHER_STATUS_SCRATCH_OVERFLOW     4
6300 #define SQLCIPHER_STATUS_MALLOC_SIZE          5
6301 #define SQLCIPHER_STATUS_PARSER_STACK         6
6302 #define SQLCIPHER_STATUS_PAGECACHE_SIZE       7
6303 #define SQLCIPHER_STATUS_SCRATCH_SIZE         8
6304 #define SQLCIPHER_STATUS_MALLOC_COUNT         9
6305
6306 /*
6307 ** CAPI3REF: Database Connection Status
6308 **
6309 ** ^This interface is used to retrieve runtime status information 
6310 ** about a single [database connection].  ^The first argument is the
6311 ** database connection object to be interrogated.  ^The second argument
6312 ** is an integer constant, taken from the set of
6313 ** [SQLCIPHER_DBSTATUS options], that
6314 ** determines the parameter to interrogate.  The set of 
6315 ** [SQLCIPHER_DBSTATUS options] is likely
6316 ** to grow in future releases of SQLite.
6317 **
6318 ** ^The current value of the requested parameter is written into *pCur
6319 ** and the highest instantaneous value is written into *pHiwtr.  ^If
6320 ** the resetFlg is true, then the highest instantaneous value is
6321 ** reset back down to the current value.
6322 **
6323 ** ^The sqlcipher3_db_status() routine returns SQLCIPHER_OK on success and a
6324 ** non-zero [error code] on failure.
6325 **
6326 ** See also: [sqlcipher3_status()] and [sqlcipher3_stmt_status()].
6327 */
6328 SQLCIPHER_API int sqlcipher3_db_status(sqlcipher3*, int op, int *pCur, int *pHiwtr, int resetFlg);
6329
6330 /*
6331 ** CAPI3REF: Status Parameters for database connections
6332 ** KEYWORDS: {SQLCIPHER_DBSTATUS options}
6333 **
6334 ** These constants are the available integer "verbs" that can be passed as
6335 ** the second argument to the [sqlcipher3_db_status()] interface.
6336 **
6337 ** New verbs may be added in future releases of SQLite. Existing verbs
6338 ** might be discontinued. Applications should check the return code from
6339 ** [sqlcipher3_db_status()] to make sure that the call worked.
6340 ** The [sqlcipher3_db_status()] interface will return a non-zero error code
6341 ** if a discontinued or unsupported verb is invoked.
6342 **
6343 ** <dl>
6344 ** [[SQLCIPHER_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLCIPHER_DBSTATUS_LOOKASIDE_USED</dt>
6345 ** <dd>This parameter returns the number of lookaside memory slots currently
6346 ** checked out.</dd>)^
6347 **
6348 ** [[SQLCIPHER_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLCIPHER_DBSTATUS_LOOKASIDE_HIT</dt>
6349 ** <dd>This parameter returns the number malloc attempts that were 
6350 ** satisfied using lookaside memory. Only the high-water value is meaningful;
6351 ** the current value is always zero.)^
6352 **
6353 ** [[SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_SIZE]]
6354 ** ^(<dt>SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
6355 ** <dd>This parameter returns the number malloc attempts that might have
6356 ** been satisfied using lookaside memory but failed due to the amount of
6357 ** memory requested being larger than the lookaside slot size.
6358 ** Only the high-water value is meaningful;
6359 ** the current value is always zero.)^
6360 **
6361 ** [[SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_FULL]]
6362 ** ^(<dt>SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
6363 ** <dd>This parameter returns the number malloc attempts that might have
6364 ** been satisfied using lookaside memory but failed due to all lookaside
6365 ** memory already being in use.
6366 ** Only the high-water value is meaningful;
6367 ** the current value is always zero.)^
6368 **
6369 ** [[SQLCIPHER_DBSTATUS_CACHE_USED]] ^(<dt>SQLCIPHER_DBSTATUS_CACHE_USED</dt>
6370 ** <dd>This parameter returns the approximate number of of bytes of heap
6371 ** memory used by all pager caches associated with the database connection.)^
6372 ** ^The highwater mark associated with SQLCIPHER_DBSTATUS_CACHE_USED is always 0.
6373 **
6374 ** [[SQLCIPHER_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLCIPHER_DBSTATUS_SCHEMA_USED</dt>
6375 ** <dd>This parameter returns the approximate number of of bytes of heap
6376 ** memory used to store the schema for all databases associated
6377 ** with the connection - main, temp, and any [ATTACH]-ed databases.)^ 
6378 ** ^The full amount of memory used by the schemas is reported, even if the
6379 ** schema memory is shared with other database connections due to
6380 ** [shared cache mode] being enabled.
6381 ** ^The highwater mark associated with SQLCIPHER_DBSTATUS_SCHEMA_USED is always 0.
6382 **
6383 ** [[SQLCIPHER_DBSTATUS_STMT_USED]] ^(<dt>SQLCIPHER_DBSTATUS_STMT_USED</dt>
6384 ** <dd>This parameter returns the approximate number of of bytes of heap
6385 ** and lookaside memory used by all prepared statements associated with
6386 ** the database connection.)^
6387 ** ^The highwater mark associated with SQLCIPHER_DBSTATUS_STMT_USED is always 0.
6388 ** </dd>
6389 **
6390 ** [[SQLCIPHER_DBSTATUS_CACHE_HIT]] ^(<dt>SQLCIPHER_DBSTATUS_CACHE_HIT</dt>
6391 ** <dd>This parameter returns the number of pager cache hits that have
6392 ** occurred.)^ ^The highwater mark associated with SQLCIPHER_DBSTATUS_CACHE_HIT 
6393 ** is always 0.
6394 ** </dd>
6395 **
6396 ** [[SQLCIPHER_DBSTATUS_CACHE_MISS]] ^(<dt>SQLCIPHER_DBSTATUS_CACHE_MISS</dt>
6397 ** <dd>This parameter returns the number of pager cache misses that have
6398 ** occurred.)^ ^The highwater mark associated with SQLCIPHER_DBSTATUS_CACHE_MISS 
6399 ** is always 0.
6400 ** </dd>
6401 ** </dl>
6402 */
6403 #define SQLCIPHER_DBSTATUS_LOOKASIDE_USED       0
6404 #define SQLCIPHER_DBSTATUS_CACHE_USED           1
6405 #define SQLCIPHER_DBSTATUS_SCHEMA_USED          2
6406 #define SQLCIPHER_DBSTATUS_STMT_USED            3
6407 #define SQLCIPHER_DBSTATUS_LOOKASIDE_HIT        4
6408 #define SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_SIZE  5
6409 #define SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_FULL  6
6410 #define SQLCIPHER_DBSTATUS_CACHE_HIT            7
6411 #define SQLCIPHER_DBSTATUS_CACHE_MISS           8
6412 #define SQLCIPHER_DBSTATUS_MAX                  8   /* Largest defined DBSTATUS */
6413
6414
6415 /*
6416 ** CAPI3REF: Prepared Statement Status
6417 **
6418 ** ^(Each prepared statement maintains various
6419 ** [SQLCIPHER_STMTSTATUS counters] that measure the number
6420 ** of times it has performed specific operations.)^  These counters can
6421 ** be used to monitor the performance characteristics of the prepared
6422 ** statements.  For example, if the number of table steps greatly exceeds
6423 ** the number of table searches or result rows, that would tend to indicate
6424 ** that the prepared statement is using a full table scan rather than
6425 ** an index.  
6426 **
6427 ** ^(This interface is used to retrieve and reset counter values from
6428 ** a [prepared statement].  The first argument is the prepared statement
6429 ** object to be interrogated.  The second argument
6430 ** is an integer code for a specific [SQLCIPHER_STMTSTATUS counter]
6431 ** to be interrogated.)^
6432 ** ^The current value of the requested counter is returned.
6433 ** ^If the resetFlg is true, then the counter is reset to zero after this
6434 ** interface call returns.
6435 **
6436 ** See also: [sqlcipher3_status()] and [sqlcipher3_db_status()].
6437 */
6438 SQLCIPHER_API int sqlcipher3_stmt_status(sqlcipher3_stmt*, int op,int resetFlg);
6439
6440 /*
6441 ** CAPI3REF: Status Parameters for prepared statements
6442 ** KEYWORDS: {SQLCIPHER_STMTSTATUS counter} {SQLCIPHER_STMTSTATUS counters}
6443 **
6444 ** These preprocessor macros define integer codes that name counter
6445 ** values associated with the [sqlcipher3_stmt_status()] interface.
6446 ** The meanings of the various counters are as follows:
6447 **
6448 ** <dl>
6449 ** [[SQLCIPHER_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLCIPHER_STMTSTATUS_FULLSCAN_STEP</dt>
6450 ** <dd>^This is the number of times that SQLite has stepped forward in
6451 ** a table as part of a full table scan.  Large numbers for this counter
6452 ** may indicate opportunities for performance improvement through 
6453 ** careful use of indices.</dd>
6454 **
6455 ** [[SQLCIPHER_STMTSTATUS_SORT]] <dt>SQLCIPHER_STMTSTATUS_SORT</dt>
6456 ** <dd>^This is the number of sort operations that have occurred.
6457 ** A non-zero value in this counter may indicate an opportunity to
6458 ** improvement performance through careful use of indices.</dd>
6459 **
6460 ** [[SQLCIPHER_STMTSTATUS_AUTOINDEX]] <dt>SQLCIPHER_STMTSTATUS_AUTOINDEX</dt>
6461 ** <dd>^This is the number of rows inserted into transient indices that
6462 ** were created automatically in order to help joins run faster.
6463 ** A non-zero value in this counter may indicate an opportunity to
6464 ** improvement performance by adding permanent indices that do not
6465 ** need to be reinitialized each time the statement is run.</dd>
6466 ** </dl>
6467 */
6468 #define SQLCIPHER_STMTSTATUS_FULLSCAN_STEP     1
6469 #define SQLCIPHER_STMTSTATUS_SORT              2
6470 #define SQLCIPHER_STMTSTATUS_AUTOINDEX         3
6471
6472 /*
6473 ** CAPI3REF: Custom Page Cache Object
6474 **
6475 ** The sqlcipher3_pcache type is opaque.  It is implemented by
6476 ** the pluggable module.  The SQLite core has no knowledge of
6477 ** its size or internal structure and never deals with the
6478 ** sqlcipher3_pcache object except by holding and passing pointers
6479 ** to the object.
6480 **
6481 ** See [sqlcipher3_pcache_methods] for additional information.
6482 */
6483 typedef struct sqlcipher3_pcache sqlcipher3_pcache;
6484
6485 /*
6486 ** CAPI3REF: Application Defined Page Cache.
6487 ** KEYWORDS: {page cache}
6488 **
6489 ** ^(The [sqlcipher3_config]([SQLCIPHER_CONFIG_PCACHE], ...) interface can
6490 ** register an alternative page cache implementation by passing in an 
6491 ** instance of the sqlcipher3_pcache_methods structure.)^
6492 ** In many applications, most of the heap memory allocated by 
6493 ** SQLite is used for the page cache.
6494 ** By implementing a 
6495 ** custom page cache using this API, an application can better control
6496 ** the amount of memory consumed by SQLite, the way in which 
6497 ** that memory is allocated and released, and the policies used to 
6498 ** determine exactly which parts of a database file are cached and for 
6499 ** how long.
6500 **
6501 ** The alternative page cache mechanism is an
6502 ** extreme measure that is only needed by the most demanding applications.
6503 ** The built-in page cache is recommended for most uses.
6504 **
6505 ** ^(The contents of the sqlcipher3_pcache_methods structure are copied to an
6506 ** internal buffer by SQLite within the call to [sqlcipher3_config].  Hence
6507 ** the application may discard the parameter after the call to
6508 ** [sqlcipher3_config()] returns.)^
6509 **
6510 ** [[the xInit() page cache method]]
6511 ** ^(The xInit() method is called once for each effective 
6512 ** call to [sqlcipher3_initialize()])^
6513 ** (usually only once during the lifetime of the process). ^(The xInit()
6514 ** method is passed a copy of the sqlcipher3_pcache_methods.pArg value.)^
6515 ** The intent of the xInit() method is to set up global data structures 
6516 ** required by the custom page cache implementation. 
6517 ** ^(If the xInit() method is NULL, then the 
6518 ** built-in default page cache is used instead of the application defined
6519 ** page cache.)^
6520 **
6521 ** [[the xShutdown() page cache method]]
6522 ** ^The xShutdown() method is called by [sqlcipher3_shutdown()].
6523 ** It can be used to clean up 
6524 ** any outstanding resources before process shutdown, if required.
6525 ** ^The xShutdown() method may be NULL.
6526 **
6527 ** ^SQLite automatically serializes calls to the xInit method,
6528 ** so the xInit method need not be threadsafe.  ^The
6529 ** xShutdown method is only called from [sqlcipher3_shutdown()] so it does
6530 ** not need to be threadsafe either.  All other methods must be threadsafe
6531 ** in multithreaded applications.
6532 **
6533 ** ^SQLite will never invoke xInit() more than once without an intervening
6534 ** call to xShutdown().
6535 **
6536 ** [[the xCreate() page cache methods]]
6537 ** ^SQLite invokes the xCreate() method to construct a new cache instance.
6538 ** SQLite will typically create one cache instance for each open database file,
6539 ** though this is not guaranteed. ^The
6540 ** first parameter, szPage, is the size in bytes of the pages that must
6541 ** be allocated by the cache.  ^szPage will not be a power of two.  ^szPage
6542 ** will the page size of the database file that is to be cached plus an
6543 ** increment (here called "R") of less than 250.  SQLite will use the
6544 ** extra R bytes on each page to store metadata about the underlying
6545 ** database page on disk.  The value of R depends
6546 ** on the SQLite version, the target platform, and how SQLite was compiled.
6547 ** ^(R is constant for a particular build of SQLite. Except, there are two
6548 ** distinct values of R when SQLite is compiled with the proprietary
6549 ** ZIPVFS extension.)^  ^The second argument to
6550 ** xCreate(), bPurgeable, is true if the cache being created will
6551 ** be used to cache database pages of a file stored on disk, or
6552 ** false if it is used for an in-memory database. The cache implementation
6553 ** does not have to do anything special based with the value of bPurgeable;
6554 ** it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will
6555 ** never invoke xUnpin() except to deliberately delete a page.
6556 ** ^In other words, calls to xUnpin() on a cache with bPurgeable set to
6557 ** false will always have the "discard" flag set to true.  
6558 ** ^Hence, a cache created with bPurgeable false will
6559 ** never contain any unpinned pages.
6560 **
6561 ** [[the xCachesize() page cache method]]
6562 ** ^(The xCachesize() method may be called at any time by SQLite to set the
6563 ** suggested maximum cache-size (number of pages stored by) the cache
6564 ** instance passed as the first argument. This is the value configured using
6565 ** the SQLite "[PRAGMA cache_size]" command.)^  As with the bPurgeable
6566 ** parameter, the implementation is not required to do anything with this
6567 ** value; it is advisory only.
6568 **
6569 ** [[the xPagecount() page cache methods]]
6570 ** The xPagecount() method must return the number of pages currently
6571 ** stored in the cache, both pinned and unpinned.
6572 ** 
6573 ** [[the xFetch() page cache methods]]
6574 ** The xFetch() method locates a page in the cache and returns a pointer to 
6575 ** the page, or a NULL pointer.
6576 ** A "page", in this context, means a buffer of szPage bytes aligned at an
6577 ** 8-byte boundary. The page to be fetched is determined by the key. ^The
6578 ** minimum key value is 1.  After it has been retrieved using xFetch, the page 
6579 ** is considered to be "pinned".
6580 **
6581 ** If the requested page is already in the page cache, then the page cache
6582 ** implementation must return a pointer to the page buffer with its content
6583 ** intact.  If the requested page is not already in the cache, then the
6584 ** cache implementation should use the value of the createFlag
6585 ** parameter to help it determined what action to take:
6586 **
6587 ** <table border=1 width=85% align=center>
6588 ** <tr><th> createFlag <th> Behaviour when page is not already in cache
6589 ** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
6590 ** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
6591 **                 Otherwise return NULL.
6592 ** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
6593 **                 NULL if allocating a new page is effectively impossible.
6594 ** </table>
6595 **
6596 ** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1.  SQLite
6597 ** will only use a createFlag of 2 after a prior call with a createFlag of 1
6598 ** failed.)^  In between the to xFetch() calls, SQLite may
6599 ** attempt to unpin one or more cache pages by spilling the content of
6600 ** pinned pages to disk and synching the operating system disk cache.
6601 **
6602 ** [[the xUnpin() page cache method]]
6603 ** ^xUnpin() is called by SQLite with a pointer to a currently pinned page
6604 ** as its second argument.  If the third parameter, discard, is non-zero,
6605 ** then the page must be evicted from the cache.
6606 ** ^If the discard parameter is
6607 ** zero, then the page may be discarded or retained at the discretion of
6608 ** page cache implementation. ^The page cache implementation
6609 ** may choose to evict unpinned pages at any time.
6610 **
6611 ** The cache must not perform any reference counting. A single 
6612 ** call to xUnpin() unpins the page regardless of the number of prior calls 
6613 ** to xFetch().
6614 **
6615 ** [[the xRekey() page cache methods]]
6616 ** The xRekey() method is used to change the key value associated with the
6617 ** page passed as the second argument. If the cache
6618 ** previously contains an entry associated with newKey, it must be
6619 ** discarded. ^Any prior cache entry associated with newKey is guaranteed not
6620 ** to be pinned.
6621 **
6622 ** When SQLite calls the xTruncate() method, the cache must discard all
6623 ** existing cache entries with page numbers (keys) greater than or equal
6624 ** to the value of the iLimit parameter passed to xTruncate(). If any
6625 ** of these pages are pinned, they are implicitly unpinned, meaning that
6626 ** they can be safely discarded.
6627 **
6628 ** [[the xDestroy() page cache method]]
6629 ** ^The xDestroy() method is used to delete a cache allocated by xCreate().
6630 ** All resources associated with the specified cache should be freed. ^After
6631 ** calling the xDestroy() method, SQLite considers the [sqlcipher3_pcache*]
6632 ** handle invalid, and will not use it with any other sqlcipher3_pcache_methods
6633 ** functions.
6634 */
6635 typedef struct sqlcipher3_pcache_methods sqlcipher3_pcache_methods;
6636 struct sqlcipher3_pcache_methods {
6637   void *pArg;
6638   int (*xInit)(void*);
6639   void (*xShutdown)(void*);
6640   sqlcipher3_pcache *(*xCreate)(int szPage, int bPurgeable);
6641   void (*xCachesize)(sqlcipher3_pcache*, int nCachesize);
6642   int (*xPagecount)(sqlcipher3_pcache*);
6643   void *(*xFetch)(sqlcipher3_pcache*, unsigned key, int createFlag);
6644   void (*xUnpin)(sqlcipher3_pcache*, void*, int discard);
6645   void (*xRekey)(sqlcipher3_pcache*, void*, unsigned oldKey, unsigned newKey);
6646   void (*xTruncate)(sqlcipher3_pcache*, unsigned iLimit);
6647   void (*xDestroy)(sqlcipher3_pcache*);
6648 };
6649
6650 /*
6651 ** CAPI3REF: Online Backup Object
6652 **
6653 ** The sqlcipher3_backup object records state information about an ongoing
6654 ** online backup operation.  ^The sqlcipher3_backup object is created by
6655 ** a call to [sqlcipher3_backup_init()] and is destroyed by a call to
6656 ** [sqlcipher3_backup_finish()].
6657 **
6658 ** See Also: [Using the SQLite Online Backup API]
6659 */
6660 typedef struct sqlcipher3_backup sqlcipher3_backup;
6661
6662 /*
6663 ** CAPI3REF: Online Backup API.
6664 **
6665 ** The backup API copies the content of one database into another.
6666 ** It is useful either for creating backups of databases or
6667 ** for copying in-memory databases to or from persistent files. 
6668 **
6669 ** See Also: [Using the SQLite Online Backup API]
6670 **
6671 ** ^SQLite holds a write transaction open on the destination database file
6672 ** for the duration of the backup operation.
6673 ** ^The source database is read-locked only while it is being read;
6674 ** it is not locked continuously for the entire backup operation.
6675 ** ^Thus, the backup may be performed on a live source database without
6676 ** preventing other database connections from
6677 ** reading or writing to the source database while the backup is underway.
6678 ** 
6679 ** ^(To perform a backup operation: 
6680 **   <ol>
6681 **     <li><b>sqlcipher3_backup_init()</b> is called once to initialize the
6682 **         backup, 
6683 **     <li><b>sqlcipher3_backup_step()</b> is called one or more times to transfer 
6684 **         the data between the two databases, and finally
6685 **     <li><b>sqlcipher3_backup_finish()</b> is called to release all resources 
6686 **         associated with the backup operation. 
6687 **   </ol>)^
6688 ** There should be exactly one call to sqlcipher3_backup_finish() for each
6689 ** successful call to sqlcipher3_backup_init().
6690 **
6691 ** [[sqlcipher3_backup_init()]] <b>sqlcipher3_backup_init()</b>
6692 **
6693 ** ^The D and N arguments to sqlcipher3_backup_init(D,N,S,M) are the 
6694 ** [database connection] associated with the destination database 
6695 ** and the database name, respectively.
6696 ** ^The database name is "main" for the main database, "temp" for the
6697 ** temporary database, or the name specified after the AS keyword in
6698 ** an [ATTACH] statement for an attached database.
6699 ** ^The S and M arguments passed to 
6700 ** sqlcipher3_backup_init(D,N,S,M) identify the [database connection]
6701 ** and database name of the source database, respectively.
6702 ** ^The source and destination [database connections] (parameters S and D)
6703 ** must be different or else sqlcipher3_backup_init(D,N,S,M) will fail with
6704 ** an error.
6705 **
6706 ** ^If an error occurs within sqlcipher3_backup_init(D,N,S,M), then NULL is
6707 ** returned and an error code and error message are stored in the
6708 ** destination [database connection] D.
6709 ** ^The error code and message for the failed call to sqlcipher3_backup_init()
6710 ** can be retrieved using the [sqlcipher3_errcode()], [sqlcipher3_errmsg()], and/or
6711 ** [sqlcipher3_errmsg16()] functions.
6712 ** ^A successful call to sqlcipher3_backup_init() returns a pointer to an
6713 ** [sqlcipher3_backup] object.
6714 ** ^The [sqlcipher3_backup] object may be used with the sqlcipher3_backup_step() and
6715 ** sqlcipher3_backup_finish() functions to perform the specified backup 
6716 ** operation.
6717 **
6718 ** [[sqlcipher3_backup_step()]] <b>sqlcipher3_backup_step()</b>
6719 **
6720 ** ^Function sqlcipher3_backup_step(B,N) will copy up to N pages between 
6721 ** the source and destination databases specified by [sqlcipher3_backup] object B.
6722 ** ^If N is negative, all remaining source pages are copied. 
6723 ** ^If sqlcipher3_backup_step(B,N) successfully copies N pages and there
6724 ** are still more pages to be copied, then the function returns [SQLCIPHER_OK].
6725 ** ^If sqlcipher3_backup_step(B,N) successfully finishes copying all pages
6726 ** from source to destination, then it returns [SQLCIPHER_DONE].
6727 ** ^If an error occurs while running sqlcipher3_backup_step(B,N),
6728 ** then an [error code] is returned. ^As well as [SQLCIPHER_OK] and
6729 ** [SQLCIPHER_DONE], a call to sqlcipher3_backup_step() may return [SQLCIPHER_READONLY],
6730 ** [SQLCIPHER_NOMEM], [SQLCIPHER_BUSY], [SQLCIPHER_LOCKED], or an
6731 ** [SQLCIPHER_IOERR_ACCESS | SQLCIPHER_IOERR_XXX] extended error code.
6732 **
6733 ** ^(The sqlcipher3_backup_step() might return [SQLCIPHER_READONLY] if
6734 ** <ol>
6735 ** <li> the destination database was opened read-only, or
6736 ** <li> the destination database is using write-ahead-log journaling
6737 ** and the destination and source page sizes differ, or
6738 ** <li> the destination database is an in-memory database and the
6739 ** destination and source page sizes differ.
6740 ** </ol>)^
6741 **
6742 ** ^If sqlcipher3_backup_step() cannot obtain a required file-system lock, then
6743 ** the [sqlcipher3_busy_handler | busy-handler function]
6744 ** is invoked (if one is specified). ^If the 
6745 ** busy-handler returns non-zero before the lock is available, then 
6746 ** [SQLCIPHER_BUSY] is returned to the caller. ^In this case the call to
6747 ** sqlcipher3_backup_step() can be retried later. ^If the source
6748 ** [database connection]
6749 ** is being used to write to the source database when sqlcipher3_backup_step()
6750 ** is called, then [SQLCIPHER_LOCKED] is returned immediately. ^Again, in this
6751 ** case the call to sqlcipher3_backup_step() can be retried later on. ^(If
6752 ** [SQLCIPHER_IOERR_ACCESS | SQLCIPHER_IOERR_XXX], [SQLCIPHER_NOMEM], or
6753 ** [SQLCIPHER_READONLY] is returned, then 
6754 ** there is no point in retrying the call to sqlcipher3_backup_step(). These 
6755 ** errors are considered fatal.)^  The application must accept 
6756 ** that the backup operation has failed and pass the backup operation handle 
6757 ** to the sqlcipher3_backup_finish() to release associated resources.
6758 **
6759 ** ^The first call to sqlcipher3_backup_step() obtains an exclusive lock
6760 ** on the destination file. ^The exclusive lock is not released until either 
6761 ** sqlcipher3_backup_finish() is called or the backup operation is complete 
6762 ** and sqlcipher3_backup_step() returns [SQLCIPHER_DONE].  ^Every call to
6763 ** sqlcipher3_backup_step() obtains a [shared lock] on the source database that
6764 ** lasts for the duration of the sqlcipher3_backup_step() call.
6765 ** ^Because the source database is not locked between calls to
6766 ** sqlcipher3_backup_step(), the source database may be modified mid-way
6767 ** through the backup process.  ^If the source database is modified by an
6768 ** external process or via a database connection other than the one being
6769 ** used by the backup operation, then the backup will be automatically
6770 ** restarted by the next call to sqlcipher3_backup_step(). ^If the source 
6771 ** database is modified by the using the same database connection as is used
6772 ** by the backup operation, then the backup database is automatically
6773 ** updated at the same time.
6774 **
6775 ** [[sqlcipher3_backup_finish()]] <b>sqlcipher3_backup_finish()</b>
6776 **
6777 ** When sqlcipher3_backup_step() has returned [SQLCIPHER_DONE], or when the 
6778 ** application wishes to abandon the backup operation, the application
6779 ** should destroy the [sqlcipher3_backup] by passing it to sqlcipher3_backup_finish().
6780 ** ^The sqlcipher3_backup_finish() interfaces releases all
6781 ** resources associated with the [sqlcipher3_backup] object. 
6782 ** ^If sqlcipher3_backup_step() has not yet returned [SQLCIPHER_DONE], then any
6783 ** active write-transaction on the destination database is rolled back.
6784 ** The [sqlcipher3_backup] object is invalid
6785 ** and may not be used following a call to sqlcipher3_backup_finish().
6786 **
6787 ** ^The value returned by sqlcipher3_backup_finish is [SQLCIPHER_OK] if no
6788 ** sqlcipher3_backup_step() errors occurred, regardless or whether or not
6789 ** sqlcipher3_backup_step() completed.
6790 ** ^If an out-of-memory condition or IO error occurred during any prior
6791 ** sqlcipher3_backup_step() call on the same [sqlcipher3_backup] object, then
6792 ** sqlcipher3_backup_finish() returns the corresponding [error code].
6793 **
6794 ** ^A return of [SQLCIPHER_BUSY] or [SQLCIPHER_LOCKED] from sqlcipher3_backup_step()
6795 ** is not a permanent error and does not affect the return value of
6796 ** sqlcipher3_backup_finish().
6797 **
6798 ** [[sqlcipher3_backup__remaining()]] [[sqlcipher3_backup_pagecount()]]
6799 ** <b>sqlcipher3_backup_remaining() and sqlcipher3_backup_pagecount()</b>
6800 **
6801 ** ^Each call to sqlcipher3_backup_step() sets two values inside
6802 ** the [sqlcipher3_backup] object: the number of pages still to be backed
6803 ** up and the total number of pages in the source database file.
6804 ** The sqlcipher3_backup_remaining() and sqlcipher3_backup_pagecount() interfaces
6805 ** retrieve these two values, respectively.
6806 **
6807 ** ^The values returned by these functions are only updated by
6808 ** sqlcipher3_backup_step(). ^If the source database is modified during a backup
6809 ** operation, then the values are not updated to account for any extra
6810 ** pages that need to be updated or the size of the source database file
6811 ** changing.
6812 **
6813 ** <b>Concurrent Usage of Database Handles</b>
6814 **
6815 ** ^The source [database connection] may be used by the application for other
6816 ** purposes while a backup operation is underway or being initialized.
6817 ** ^If SQLite is compiled and configured to support threadsafe database
6818 ** connections, then the source database connection may be used concurrently
6819 ** from within other threads.
6820 **
6821 ** However, the application must guarantee that the destination 
6822 ** [database connection] is not passed to any other API (by any thread) after 
6823 ** sqlcipher3_backup_init() is called and before the corresponding call to
6824 ** sqlcipher3_backup_finish().  SQLite does not currently check to see
6825 ** if the application incorrectly accesses the destination [database connection]
6826 ** and so no error code is reported, but the operations may malfunction
6827 ** nevertheless.  Use of the destination database connection while a
6828 ** backup is in progress might also also cause a mutex deadlock.
6829 **
6830 ** If running in [shared cache mode], the application must
6831 ** guarantee that the shared cache used by the destination database
6832 ** is not accessed while the backup is running. In practice this means
6833 ** that the application must guarantee that the disk file being 
6834 ** backed up to is not accessed by any connection within the process,
6835 ** not just the specific connection that was passed to sqlcipher3_backup_init().
6836 **
6837 ** The [sqlcipher3_backup] object itself is partially threadsafe. Multiple 
6838 ** threads may safely make multiple concurrent calls to sqlcipher3_backup_step().
6839 ** However, the sqlcipher3_backup_remaining() and sqlcipher3_backup_pagecount()
6840 ** APIs are not strictly speaking threadsafe. If they are invoked at the
6841 ** same time as another thread is invoking sqlcipher3_backup_step() it is
6842 ** possible that they return invalid values.
6843 */
6844 SQLCIPHER_API sqlcipher3_backup *sqlcipher3_backup_init(
6845   sqlcipher3 *pDest,                        /* Destination database handle */
6846   const char *zDestName,                 /* Destination database name */
6847   sqlcipher3 *pSource,                      /* Source database handle */
6848   const char *zSourceName                /* Source database name */
6849 );
6850 SQLCIPHER_API int sqlcipher3_backup_step(sqlcipher3_backup *p, int nPage);
6851 SQLCIPHER_API int sqlcipher3_backup_finish(sqlcipher3_backup *p);
6852 SQLCIPHER_API int sqlcipher3_backup_remaining(sqlcipher3_backup *p);
6853 SQLCIPHER_API int sqlcipher3_backup_pagecount(sqlcipher3_backup *p);
6854
6855 /*
6856 ** CAPI3REF: Unlock Notification
6857 **
6858 ** ^When running in shared-cache mode, a database operation may fail with
6859 ** an [SQLCIPHER_LOCKED] error if the required locks on the shared-cache or
6860 ** individual tables within the shared-cache cannot be obtained. See
6861 ** [SQLite Shared-Cache Mode] for a description of shared-cache locking. 
6862 ** ^This API may be used to register a callback that SQLite will invoke 
6863 ** when the connection currently holding the required lock relinquishes it.
6864 ** ^This API is only available if the library was compiled with the
6865 ** [SQLCIPHER_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
6866 **
6867 ** See Also: [Using the SQLite Unlock Notification Feature].
6868 **
6869 ** ^Shared-cache locks are released when a database connection concludes
6870 ** its current transaction, either by committing it or rolling it back. 
6871 **
6872 ** ^When a connection (known as the blocked connection) fails to obtain a
6873 ** shared-cache lock and SQLCIPHER_LOCKED is returned to the caller, the
6874 ** identity of the database connection (the blocking connection) that
6875 ** has locked the required resource is stored internally. ^After an 
6876 ** application receives an SQLCIPHER_LOCKED error, it may call the
6877 ** sqlcipher3_unlock_notify() method with the blocked connection handle as 
6878 ** the first argument to register for a callback that will be invoked
6879 ** when the blocking connections current transaction is concluded. ^The
6880 ** callback is invoked from within the [sqlcipher3_step] or [sqlcipher3_close]
6881 ** call that concludes the blocking connections transaction.
6882 **
6883 ** ^(If sqlcipher3_unlock_notify() is called in a multi-threaded application,
6884 ** there is a chance that the blocking connection will have already
6885 ** concluded its transaction by the time sqlcipher3_unlock_notify() is invoked.
6886 ** If this happens, then the specified callback is invoked immediately,
6887 ** from within the call to sqlcipher3_unlock_notify().)^
6888 **
6889 ** ^If the blocked connection is attempting to obtain a write-lock on a
6890 ** shared-cache table, and more than one other connection currently holds
6891 ** a read-lock on the same table, then SQLite arbitrarily selects one of 
6892 ** the other connections to use as the blocking connection.
6893 **
6894 ** ^(There may be at most one unlock-notify callback registered by a 
6895 ** blocked connection. If sqlcipher3_unlock_notify() is called when the
6896 ** blocked connection already has a registered unlock-notify callback,
6897 ** then the new callback replaces the old.)^ ^If sqlcipher3_unlock_notify() is
6898 ** called with a NULL pointer as its second argument, then any existing
6899 ** unlock-notify callback is canceled. ^The blocked connections 
6900 ** unlock-notify callback may also be canceled by closing the blocked
6901 ** connection using [sqlcipher3_close()].
6902 **
6903 ** The unlock-notify callback is not reentrant. If an application invokes
6904 ** any sqlcipher3_xxx API functions from within an unlock-notify callback, a
6905 ** crash or deadlock may be the result.
6906 **
6907 ** ^Unless deadlock is detected (see below), sqlcipher3_unlock_notify() always
6908 ** returns SQLCIPHER_OK.
6909 **
6910 ** <b>Callback Invocation Details</b>
6911 **
6912 ** When an unlock-notify callback is registered, the application provides a 
6913 ** single void* pointer that is passed to the callback when it is invoked.
6914 ** However, the signature of the callback function allows SQLite to pass
6915 ** it an array of void* context pointers. The first argument passed to
6916 ** an unlock-notify callback is a pointer to an array of void* pointers,
6917 ** and the second is the number of entries in the array.
6918 **
6919 ** When a blocking connections transaction is concluded, there may be
6920 ** more than one blocked connection that has registered for an unlock-notify
6921 ** callback. ^If two or more such blocked connections have specified the
6922 ** same callback function, then instead of invoking the callback function
6923 ** multiple times, it is invoked once with the set of void* context pointers
6924 ** specified by the blocked connections bundled together into an array.
6925 ** This gives the application an opportunity to prioritize any actions 
6926 ** related to the set of unblocked database connections.
6927 **
6928 ** <b>Deadlock Detection</b>
6929 **
6930 ** Assuming that after registering for an unlock-notify callback a 
6931 ** database waits for the callback to be issued before taking any further
6932 ** action (a reasonable assumption), then using this API may cause the
6933 ** application to deadlock. For example, if connection X is waiting for
6934 ** connection Y's transaction to be concluded, and similarly connection
6935 ** Y is waiting on connection X's transaction, then neither connection
6936 ** will proceed and the system may remain deadlocked indefinitely.
6937 **
6938 ** To avoid this scenario, the sqlcipher3_unlock_notify() performs deadlock
6939 ** detection. ^If a given call to sqlcipher3_unlock_notify() would put the
6940 ** system in a deadlocked state, then SQLCIPHER_LOCKED is returned and no
6941 ** unlock-notify callback is registered. The system is said to be in
6942 ** a deadlocked state if connection A has registered for an unlock-notify
6943 ** callback on the conclusion of connection B's transaction, and connection
6944 ** B has itself registered for an unlock-notify callback when connection
6945 ** A's transaction is concluded. ^Indirect deadlock is also detected, so
6946 ** the system is also considered to be deadlocked if connection B has
6947 ** registered for an unlock-notify callback on the conclusion of connection
6948 ** C's transaction, where connection C is waiting on connection A. ^Any
6949 ** number of levels of indirection are allowed.
6950 **
6951 ** <b>The "DROP TABLE" Exception</b>
6952 **
6953 ** When a call to [sqlcipher3_step()] returns SQLCIPHER_LOCKED, it is almost 
6954 ** always appropriate to call sqlcipher3_unlock_notify(). There is however,
6955 ** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement,
6956 ** SQLite checks if there are any currently executing SELECT statements
6957 ** that belong to the same connection. If there are, SQLCIPHER_LOCKED is
6958 ** returned. In this case there is no "blocking connection", so invoking
6959 ** sqlcipher3_unlock_notify() results in the unlock-notify callback being
6960 ** invoked immediately. If the application then re-attempts the "DROP TABLE"
6961 ** or "DROP INDEX" query, an infinite loop might be the result.
6962 **
6963 ** One way around this problem is to check the extended error code returned
6964 ** by an sqlcipher3_step() call. ^(If there is a blocking connection, then the
6965 ** extended error code is set to SQLCIPHER_LOCKED_SHAREDCACHE. Otherwise, in
6966 ** the special "DROP TABLE/INDEX" case, the extended error code is just 
6967 ** SQLCIPHER_LOCKED.)^
6968 */
6969 SQLCIPHER_API int sqlcipher3_unlock_notify(
6970   sqlcipher3 *pBlocked,                          /* Waiting connection */
6971   void (*xNotify)(void **apArg, int nArg),    /* Callback function to invoke */
6972   void *pNotifyArg                            /* Argument to pass to xNotify */
6973 );
6974
6975
6976 /*
6977 ** CAPI3REF: String Comparison
6978 **
6979 ** ^The [sqlcipher3_strnicmp()] API allows applications and extensions to
6980 ** compare the contents of two buffers containing UTF-8 strings in a
6981 ** case-independent fashion, using the same definition of case independence 
6982 ** that SQLite uses internally when comparing identifiers.
6983 */
6984 SQLCIPHER_API int sqlcipher3_strnicmp(const char *, const char *, int);
6985
6986 /*
6987 ** CAPI3REF: Error Logging Interface
6988 **
6989 ** ^The [sqlcipher3_log()] interface writes a message into the error log
6990 ** established by the [SQLCIPHER_CONFIG_LOG] option to [sqlcipher3_config()].
6991 ** ^If logging is enabled, the zFormat string and subsequent arguments are
6992 ** used with [sqlcipher3_snprintf()] to generate the final output string.
6993 **
6994 ** The sqlcipher3_log() interface is intended for use by extensions such as
6995 ** virtual tables, collating functions, and SQL functions.  While there is
6996 ** nothing to prevent an application from calling sqlcipher3_log(), doing so
6997 ** is considered bad form.
6998 **
6999 ** The zFormat string must not be NULL.
7000 **
7001 ** To avoid deadlocks and other threading problems, the sqlcipher3_log() routine
7002 ** will not use dynamically allocated memory.  The log message is stored in
7003 ** a fixed-length buffer on the stack.  If the log message is longer than
7004 ** a few hundred characters, it will be truncated to the length of the
7005 ** buffer.
7006 */
7007 SQLCIPHER_API void sqlcipher3_log(int iErrCode, const char *zFormat, ...);
7008
7009 /*
7010 ** CAPI3REF: Write-Ahead Log Commit Hook
7011 **
7012 ** ^The [sqlcipher3_wal_hook()] function is used to register a callback that
7013 ** will be invoked each time a database connection commits data to a
7014 ** [write-ahead log] (i.e. whenever a transaction is committed in
7015 ** [journal_mode | journal_mode=WAL mode]). 
7016 **
7017 ** ^The callback is invoked by SQLite after the commit has taken place and 
7018 ** the associated write-lock on the database released, so the implementation 
7019 ** may read, write or [checkpoint] the database as required.
7020 **
7021 ** ^The first parameter passed to the callback function when it is invoked
7022 ** is a copy of the third parameter passed to sqlcipher3_wal_hook() when
7023 ** registering the callback. ^The second is a copy of the database handle.
7024 ** ^The third parameter is the name of the database that was written to -
7025 ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
7026 ** is the number of pages currently in the write-ahead log file,
7027 ** including those that were just committed.
7028 **
7029 ** The callback function should normally return [SQLCIPHER_OK].  ^If an error
7030 ** code is returned, that error will propagate back up through the
7031 ** SQLite code base to cause the statement that provoked the callback
7032 ** to report an error, though the commit will have still occurred. If the
7033 ** callback returns [SQLCIPHER_ROW] or [SQLCIPHER_DONE], or if it returns a value
7034 ** that does not correspond to any valid SQLite error code, the results
7035 ** are undefined.
7036 **
7037 ** A single database handle may have at most a single write-ahead log callback 
7038 ** registered at one time. ^Calling [sqlcipher3_wal_hook()] replaces any
7039 ** previously registered write-ahead log callback. ^Note that the
7040 ** [sqlcipher3_wal_autocheckpoint()] interface and the
7041 ** [wal_autocheckpoint pragma] both invoke [sqlcipher3_wal_hook()] and will
7042 ** those overwrite any prior [sqlcipher3_wal_hook()] settings.
7043 */
7044 SQLCIPHER_API void *sqlcipher3_wal_hook(
7045   sqlcipher3*, 
7046   int(*)(void *,sqlcipher3*,const char*,int),
7047   void*
7048 );
7049
7050 /*
7051 ** CAPI3REF: Configure an auto-checkpoint
7052 **
7053 ** ^The [sqlcipher3_wal_autocheckpoint(D,N)] is a wrapper around
7054 ** [sqlcipher3_wal_hook()] that causes any database on [database connection] D
7055 ** to automatically [checkpoint]
7056 ** after committing a transaction if there are N or
7057 ** more frames in the [write-ahead log] file.  ^Passing zero or 
7058 ** a negative value as the nFrame parameter disables automatic
7059 ** checkpoints entirely.
7060 **
7061 ** ^The callback registered by this function replaces any existing callback
7062 ** registered using [sqlcipher3_wal_hook()].  ^Likewise, registering a callback
7063 ** using [sqlcipher3_wal_hook()] disables the automatic checkpoint mechanism
7064 ** configured by this function.
7065 **
7066 ** ^The [wal_autocheckpoint pragma] can be used to invoke this interface
7067 ** from SQL.
7068 **
7069 ** ^Every new [database connection] defaults to having the auto-checkpoint
7070 ** enabled with a threshold of 1000 or [SQLCIPHER_DEFAULT_WAL_AUTOCHECKPOINT]
7071 ** pages.  The use of this interface
7072 ** is only necessary if the default setting is found to be suboptimal
7073 ** for a particular application.
7074 */
7075 SQLCIPHER_API int sqlcipher3_wal_autocheckpoint(sqlcipher3 *db, int N);
7076
7077 /*
7078 ** CAPI3REF: Checkpoint a database
7079 **
7080 ** ^The [sqlcipher3_wal_checkpoint(D,X)] interface causes database named X
7081 ** on [database connection] D to be [checkpointed].  ^If X is NULL or an
7082 ** empty string, then a checkpoint is run on all databases of
7083 ** connection D.  ^If the database connection D is not in
7084 ** [WAL | write-ahead log mode] then this interface is a harmless no-op.
7085 **
7086 ** ^The [wal_checkpoint pragma] can be used to invoke this interface
7087 ** from SQL.  ^The [sqlcipher3_wal_autocheckpoint()] interface and the
7088 ** [wal_autocheckpoint pragma] can be used to cause this interface to be
7089 ** run whenever the WAL reaches a certain size threshold.
7090 **
7091 ** See also: [sqlcipher3_wal_checkpoint_v2()]
7092 */
7093 SQLCIPHER_API int sqlcipher3_wal_checkpoint(sqlcipher3 *db, const char *zDb);
7094
7095 /*
7096 ** CAPI3REF: Checkpoint a database
7097 **
7098 ** Run a checkpoint operation on WAL database zDb attached to database 
7099 ** handle db. The specific operation is determined by the value of the 
7100 ** eMode parameter:
7101 **
7102 ** <dl>
7103 ** <dt>SQLCIPHER_CHECKPOINT_PASSIVE<dd>
7104 **   Checkpoint as many frames as possible without waiting for any database 
7105 **   readers or writers to finish. Sync the db file if all frames in the log
7106 **   are checkpointed. This mode is the same as calling 
7107 **   sqlcipher3_wal_checkpoint(). The busy-handler callback is never invoked.
7108 **
7109 ** <dt>SQLCIPHER_CHECKPOINT_FULL<dd>
7110 **   This mode blocks (calls the busy-handler callback) until there is no
7111 **   database writer and all readers are reading from the most recent database
7112 **   snapshot. It then checkpoints all frames in the log file and syncs the
7113 **   database file. This call blocks database writers while it is running,
7114 **   but not database readers.
7115 **
7116 ** <dt>SQLCIPHER_CHECKPOINT_RESTART<dd>
7117 **   This mode works the same way as SQLCIPHER_CHECKPOINT_FULL, except after 
7118 **   checkpointing the log file it blocks (calls the busy-handler callback)
7119 **   until all readers are reading from the database file only. This ensures 
7120 **   that the next client to write to the database file restarts the log file 
7121 **   from the beginning. This call blocks database writers while it is running,
7122 **   but not database readers.
7123 ** </dl>
7124 **
7125 ** If pnLog is not NULL, then *pnLog is set to the total number of frames in
7126 ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
7127 ** the total number of checkpointed frames (including any that were already
7128 ** checkpointed when this function is called). *pnLog and *pnCkpt may be
7129 ** populated even if sqlcipher3_wal_checkpoint_v2() returns other than SQLCIPHER_OK.
7130 ** If no values are available because of an error, they are both set to -1
7131 ** before returning to communicate this to the caller.
7132 **
7133 ** All calls obtain an exclusive "checkpoint" lock on the database file. If
7134 ** any other process is running a checkpoint operation at the same time, the 
7135 ** lock cannot be obtained and SQLCIPHER_BUSY is returned. Even if there is a 
7136 ** busy-handler configured, it will not be invoked in this case.
7137 **
7138 ** The SQLCIPHER_CHECKPOINT_FULL and RESTART modes also obtain the exclusive 
7139 ** "writer" lock on the database file. If the writer lock cannot be obtained
7140 ** immediately, and a busy-handler is configured, it is invoked and the writer
7141 ** lock retried until either the busy-handler returns 0 or the lock is
7142 ** successfully obtained. The busy-handler is also invoked while waiting for
7143 ** database readers as described above. If the busy-handler returns 0 before
7144 ** the writer lock is obtained or while waiting for database readers, the
7145 ** checkpoint operation proceeds from that point in the same way as 
7146 ** SQLCIPHER_CHECKPOINT_PASSIVE - checkpointing as many frames as possible 
7147 ** without blocking any further. SQLCIPHER_BUSY is returned in this case.
7148 **
7149 ** If parameter zDb is NULL or points to a zero length string, then the
7150 ** specified operation is attempted on all WAL databases. In this case the
7151 ** values written to output parameters *pnLog and *pnCkpt are undefined. If 
7152 ** an SQLCIPHER_BUSY error is encountered when processing one or more of the 
7153 ** attached WAL databases, the operation is still attempted on any remaining 
7154 ** attached databases and SQLCIPHER_BUSY is returned to the caller. If any other 
7155 ** error occurs while processing an attached database, processing is abandoned 
7156 ** and the error code returned to the caller immediately. If no error 
7157 ** (SQLCIPHER_BUSY or otherwise) is encountered while processing the attached 
7158 ** databases, SQLCIPHER_OK is returned.
7159 **
7160 ** If database zDb is the name of an attached database that is not in WAL
7161 ** mode, SQLCIPHER_OK is returned and both *pnLog and *pnCkpt set to -1. If
7162 ** zDb is not NULL (or a zero length string) and is not the name of any
7163 ** attached database, SQLCIPHER_ERROR is returned to the caller.
7164 */
7165 SQLCIPHER_API int sqlcipher3_wal_checkpoint_v2(
7166   sqlcipher3 *db,                    /* Database handle */
7167   const char *zDb,                /* Name of attached database (or NULL) */
7168   int eMode,                      /* SQLCIPHER_CHECKPOINT_* value */
7169   int *pnLog,                     /* OUT: Size of WAL log in frames */
7170   int *pnCkpt                     /* OUT: Total number of frames checkpointed */
7171 );
7172
7173 /*
7174 ** CAPI3REF: Checkpoint operation parameters
7175 **
7176 ** These constants can be used as the 3rd parameter to
7177 ** [sqlcipher3_wal_checkpoint_v2()].  See the [sqlcipher3_wal_checkpoint_v2()]
7178 ** documentation for additional information about the meaning and use of
7179 ** each of these values.
7180 */
7181 #define SQLCIPHER_CHECKPOINT_PASSIVE 0
7182 #define SQLCIPHER_CHECKPOINT_FULL    1
7183 #define SQLCIPHER_CHECKPOINT_RESTART 2
7184
7185 /*
7186 ** CAPI3REF: Virtual Table Interface Configuration
7187 **
7188 ** This function may be called by either the [xConnect] or [xCreate] method
7189 ** of a [virtual table] implementation to configure
7190 ** various facets of the virtual table interface.
7191 **
7192 ** If this interface is invoked outside the context of an xConnect or
7193 ** xCreate virtual table method then the behavior is undefined.
7194 **
7195 ** At present, there is only one option that may be configured using
7196 ** this function. (See [SQLCIPHER_VTAB_CONSTRAINT_SUPPORT].)  Further options
7197 ** may be added in the future.
7198 */
7199 SQLCIPHER_API int sqlcipher3_vtab_config(sqlcipher3*, int op, ...);
7200
7201 /*
7202 ** CAPI3REF: Virtual Table Configuration Options
7203 **
7204 ** These macros define the various options to the
7205 ** [sqlcipher3_vtab_config()] interface that [virtual table] implementations
7206 ** can use to customize and optimize their behavior.
7207 **
7208 ** <dl>
7209 ** <dt>SQLCIPHER_VTAB_CONSTRAINT_SUPPORT
7210 ** <dd>Calls of the form
7211 ** [sqlcipher3_vtab_config](db,SQLCIPHER_VTAB_CONSTRAINT_SUPPORT,X) are supported,
7212 ** where X is an integer.  If X is zero, then the [virtual table] whose
7213 ** [xCreate] or [xConnect] method invoked [sqlcipher3_vtab_config()] does not
7214 ** support constraints.  In this configuration (which is the default) if
7215 ** a call to the [xUpdate] method returns [SQLCIPHER_CONSTRAINT], then the entire
7216 ** statement is rolled back as if [ON CONFLICT | OR ABORT] had been
7217 ** specified as part of the users SQL statement, regardless of the actual
7218 ** ON CONFLICT mode specified.
7219 **
7220 ** If X is non-zero, then the virtual table implementation guarantees
7221 ** that if [xUpdate] returns [SQLCIPHER_CONSTRAINT], it will do so before
7222 ** any modifications to internal or persistent data structures have been made.
7223 ** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite 
7224 ** is able to roll back a statement or database transaction, and abandon
7225 ** or continue processing the current SQL statement as appropriate. 
7226 ** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
7227 ** [SQLCIPHER_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
7228 ** had been ABORT.
7229 **
7230 ** Virtual table implementations that are required to handle OR REPLACE
7231 ** must do so within the [xUpdate] method. If a call to the 
7232 ** [sqlcipher3_vtab_on_conflict()] function indicates that the current ON 
7233 ** CONFLICT policy is REPLACE, the virtual table implementation should 
7234 ** silently replace the appropriate rows within the xUpdate callback and
7235 ** return SQLCIPHER_OK. Or, if this is not possible, it may return
7236 ** SQLCIPHER_CONSTRAINT, in which case SQLite falls back to OR ABORT 
7237 ** constraint handling.
7238 ** </dl>
7239 */
7240 #define SQLCIPHER_VTAB_CONSTRAINT_SUPPORT 1
7241
7242 /*
7243 ** CAPI3REF: Determine The Virtual Table Conflict Policy
7244 **
7245 ** This function may only be called from within a call to the [xUpdate] method
7246 ** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The
7247 ** value returned is one of [SQLCIPHER_ROLLBACK], [SQLCIPHER_IGNORE], [SQLCIPHER_FAIL],
7248 ** [SQLCIPHER_ABORT], or [SQLCIPHER_REPLACE], according to the [ON CONFLICT] mode
7249 ** of the SQL statement that triggered the call to the [xUpdate] method of the
7250 ** [virtual table].
7251 */
7252 SQLCIPHER_API int sqlcipher3_vtab_on_conflict(sqlcipher3 *);
7253
7254 /*
7255 ** CAPI3REF: Conflict resolution modes
7256 **
7257 ** These constants are returned by [sqlcipher3_vtab_on_conflict()] to
7258 ** inform a [virtual table] implementation what the [ON CONFLICT] mode
7259 ** is for the SQL statement being evaluated.
7260 **
7261 ** Note that the [SQLCIPHER_IGNORE] constant is also used as a potential
7262 ** return value from the [sqlcipher3_set_authorizer()] callback and that
7263 ** [SQLCIPHER_ABORT] is also a [result code].
7264 */
7265 #define SQLCIPHER_ROLLBACK 1
7266 /* #define SQLCIPHER_IGNORE 2 // Also used by sqlcipher3_authorizer() callback */
7267 #define SQLCIPHER_FAIL     3
7268 /* #define SQLCIPHER_ABORT 4  // Also an error code */
7269 #define SQLCIPHER_REPLACE  5
7270
7271
7272
7273 /*
7274 ** Undo the hack that converts floating point types to integer for
7275 ** builds on processors without floating point support.
7276 */
7277 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
7278 # undef double
7279 #endif
7280
7281 #if 0
7282 }  /* End of the 'extern "C"' block */
7283 #endif
7284 #endif
7285
7286 /*
7287 ** 2010 August 30
7288 **
7289 ** The author disclaims copyright to this source code.  In place of
7290 ** a legal notice, here is a blessing:
7291 **
7292 **    May you do good and not evil.
7293 **    May you find forgiveness for yourself and forgive others.
7294 **    May you share freely, never taking more than you give.
7295 **
7296 *************************************************************************
7297 */
7298
7299 #ifndef _SQLCIPHER3RTREE_H_
7300 #define _SQLCIPHER3RTREE_H_
7301
7302
7303 #if 0
7304 extern "C" {
7305 #endif
7306
7307 typedef struct sqlcipher3_rtree_geometry sqlcipher3_rtree_geometry;
7308
7309 /*
7310 ** Register a geometry callback named zGeom that can be used as part of an
7311 ** R-Tree geometry query as follows:
7312 **
7313 **   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
7314 */
7315 SQLCIPHER_API int sqlcipher3_rtree_geometry_callback(
7316   sqlcipher3 *db,
7317   const char *zGeom,
7318   int (*xGeom)(sqlcipher3_rtree_geometry *, int nCoord, double *aCoord, int *pRes),
7319   void *pContext
7320 );
7321
7322
7323 /*
7324 ** A pointer to a structure of the following type is passed as the first
7325 ** argument to callbacks registered using rtree_geometry_callback().
7326 */
7327 struct sqlcipher3_rtree_geometry {
7328   void *pContext;                 /* Copy of pContext passed to s_r_g_c() */
7329   int nParam;                     /* Size of array aParam[] */
7330   double *aParam;                 /* Parameters passed to SQL geom function */
7331   void *pUser;                    /* Callback implementation user data */
7332   void (*xDelUser)(void *);       /* Called by SQLite to clean up pUser */
7333 };
7334
7335
7336 #if 0
7337 }  /* end of the 'extern "C"' block */
7338 #endif
7339
7340 #endif  /* ifndef _SQLCIPHER3RTREE_H_ */
7341
7342
7343 /************** End of sqlcipher3.h *********************************************/
7344 /************** Continuing where we left off in sqlcipherInt.h ******************/
7345 /************** Include hash.h in the middle of sqlcipherInt.h ******************/
7346 /************** Begin file hash.h ********************************************/
7347 /*
7348 ** 2001 September 22
7349 **
7350 ** The author disclaims copyright to this source code.  In place of
7351 ** a legal notice, here is a blessing:
7352 **
7353 **    May you do good and not evil.
7354 **    May you find forgiveness for yourself and forgive others.
7355 **    May you share freely, never taking more than you give.
7356 **
7357 *************************************************************************
7358 ** This is the header file for the generic hash-table implemenation
7359 ** used in SQLite.
7360 */
7361 #ifndef _SQLCIPHER_HASH_H_
7362 #define _SQLCIPHER_HASH_H_
7363
7364 /* Forward declarations of structures. */
7365 typedef struct Hash Hash;
7366 typedef struct HashElem HashElem;
7367
7368 /* A complete hash table is an instance of the following structure.
7369 ** The internals of this structure are intended to be opaque -- client
7370 ** code should not attempt to access or modify the fields of this structure
7371 ** directly.  Change this structure only by using the routines below.
7372 ** However, some of the "procedures" and "functions" for modifying and
7373 ** accessing this structure are really macros, so we can't really make
7374 ** this structure opaque.
7375 **
7376 ** All elements of the hash table are on a single doubly-linked list.
7377 ** Hash.first points to the head of this list.
7378 **
7379 ** There are Hash.htsize buckets.  Each bucket points to a spot in
7380 ** the global doubly-linked list.  The contents of the bucket are the
7381 ** element pointed to plus the next _ht.count-1 elements in the list.
7382 **
7383 ** Hash.htsize and Hash.ht may be zero.  In that case lookup is done
7384 ** by a linear search of the global list.  For small tables, the 
7385 ** Hash.ht table is never allocated because if there are few elements
7386 ** in the table, it is faster to do a linear search than to manage
7387 ** the hash table.
7388 */
7389 struct Hash {
7390   unsigned int htsize;      /* Number of buckets in the hash table */
7391   unsigned int count;       /* Number of entries in this table */
7392   HashElem *first;          /* The first element of the array */
7393   struct _ht {              /* the hash table */
7394     int count;                 /* Number of entries with this hash */
7395     HashElem *chain;           /* Pointer to first entry with this hash */
7396   } *ht;
7397 };
7398
7399 /* Each element in the hash table is an instance of the following 
7400 ** structure.  All elements are stored on a single doubly-linked list.
7401 **
7402 ** Again, this structure is intended to be opaque, but it can't really
7403 ** be opaque because it is used by macros.
7404 */
7405 struct HashElem {
7406   HashElem *next, *prev;       /* Next and previous elements in the table */
7407   void *data;                  /* Data associated with this element */
7408   const char *pKey; int nKey;  /* Key associated with this element */
7409 };
7410
7411 /*
7412 ** Access routines.  To delete, insert a NULL pointer.
7413 */
7414 SQLCIPHER_PRIVATE void sqlcipher3HashInit(Hash*);
7415 SQLCIPHER_PRIVATE void *sqlcipher3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7416 SQLCIPHER_PRIVATE void *sqlcipher3HashFind(const Hash*, const char *pKey, int nKey);
7417 SQLCIPHER_PRIVATE void sqlcipher3HashClear(Hash*);
7418
7419 /*
7420 ** Macros for looping over all elements of a hash table.  The idiom is
7421 ** like this:
7422 **
7423 **   Hash h;
7424 **   HashElem *p;
7425 **   ...
7426 **   for(p=sqlcipherHashFirst(&h); p; p=sqlcipherHashNext(p)){
7427 **     SomeStructure *pData = sqlcipherHashData(p);
7428 **     // do something with pData
7429 **   }
7430 */
7431 #define sqlcipherHashFirst(H)  ((H)->first)
7432 #define sqlcipherHashNext(E)   ((E)->next)
7433 #define sqlcipherHashData(E)   ((E)->data)
7434 /* #define sqlcipherHashKey(E)    ((E)->pKey) // NOT USED */
7435 /* #define sqlcipherHashKeysize(E) ((E)->nKey)  // NOT USED */
7436
7437 /*
7438 ** Number of entries in a hash table
7439 */
7440 /* #define sqlcipherHashCount(H)  ((H)->count) // NOT USED */
7441
7442 #endif /* _SQLCIPHER_HASH_H_ */
7443
7444 /************** End of hash.h ************************************************/
7445 /************** Continuing where we left off in sqlcipherInt.h ******************/
7446 /************** Include parse.h in the middle of sqlcipherInt.h *****************/
7447 /************** Begin file parse.h *******************************************/
7448 #define TK_SEMI                            1
7449 #define TK_EXPLAIN                         2
7450 #define TK_QUERY                           3
7451 #define TK_PLAN                            4
7452 #define TK_BEGIN                           5
7453 #define TK_TRANSACTION                     6
7454 #define TK_DEFERRED                        7
7455 #define TK_IMMEDIATE                       8
7456 #define TK_EXCLUSIVE                       9
7457 #define TK_COMMIT                         10
7458 #define TK_END                            11
7459 #define TK_ROLLBACK                       12
7460 #define TK_SAVEPOINT                      13
7461 #define TK_RELEASE                        14
7462 #define TK_TO                             15
7463 #define TK_TABLE                          16
7464 #define TK_CREATE                         17
7465 #define TK_IF                             18
7466 #define TK_NOT                            19
7467 #define TK_EXISTS                         20
7468 #define TK_TEMP                           21
7469 #define TK_LP                             22
7470 #define TK_RP                             23
7471 #define TK_AS                             24
7472 #define TK_COMMA                          25
7473 #define TK_ID                             26
7474 #define TK_INDEXED                        27
7475 #define TK_ABORT                          28
7476 #define TK_ACTION                         29
7477 #define TK_AFTER                          30
7478 #define TK_ANALYZE                        31
7479 #define TK_ASC                            32
7480 #define TK_ATTACH                         33
7481 #define TK_BEFORE                         34
7482 #define TK_BY                             35
7483 #define TK_CASCADE                        36
7484 #define TK_CAST                           37
7485 #define TK_COLUMNKW                       38
7486 #define TK_CONFLICT                       39
7487 #define TK_DATABASE                       40
7488 #define TK_DESC                           41
7489 #define TK_DETACH                         42
7490 #define TK_EACH                           43
7491 #define TK_FAIL                           44
7492 #define TK_FOR                            45
7493 #define TK_IGNORE                         46
7494 #define TK_INITIALLY                      47
7495 #define TK_INSTEAD                        48
7496 #define TK_LIKE_KW                        49
7497 #define TK_MATCH                          50
7498 #define TK_NO                             51
7499 #define TK_KEY                            52
7500 #define TK_OF                             53
7501 #define TK_OFFSET                         54
7502 #define TK_PRAGMA                         55
7503 #define TK_RAISE                          56
7504 #define TK_REPLACE                        57
7505 #define TK_RESTRICT                       58
7506 #define TK_ROW                            59
7507 #define TK_TRIGGER                        60
7508 #define TK_VACUUM                         61
7509 #define TK_VIEW                           62
7510 #define TK_VIRTUAL                        63
7511 #define TK_REINDEX                        64
7512 #define TK_RENAME                         65
7513 #define TK_CTIME_KW                       66
7514 #define TK_ANY                            67
7515 #define TK_OR                             68
7516 #define TK_AND                            69
7517 #define TK_IS                             70
7518 #define TK_BETWEEN                        71
7519 #define TK_IN                             72
7520 #define TK_ISNULL                         73
7521 #define TK_NOTNULL                        74
7522 #define TK_NE                             75
7523 #define TK_EQ                             76
7524 #define TK_GT                             77
7525 #define TK_LE                             78
7526 #define TK_LT                             79
7527 #define TK_GE                             80
7528 #define TK_ESCAPE                         81
7529 #define TK_BITAND                         82
7530 #define TK_BITOR                          83
7531 #define TK_LSHIFT                         84
7532 #define TK_RSHIFT                         85
7533 #define TK_PLUS                           86
7534 #define TK_MINUS                          87
7535 #define TK_STAR                           88
7536 #define TK_SLASH                          89
7537 #define TK_REM                            90
7538 #define TK_CONCAT                         91
7539 #define TK_COLLATE                        92
7540 #define TK_BITNOT                         93
7541 #define TK_STRING                         94
7542 #define TK_JOIN_KW                        95
7543 #define TK_CONSTRAINT                     96
7544 #define TK_DEFAULT                        97
7545 #define TK_NULL                           98
7546 #define TK_PRIMARY                        99
7547 #define TK_UNIQUE                         100
7548 #define TK_CHECK                          101
7549 #define TK_REFERENCES                     102
7550 #define TK_AUTOINCR                       103
7551 #define TK_ON                             104
7552 #define TK_INSERT                         105
7553 #define TK_DELETE                         106
7554 #define TK_UPDATE                         107
7555 #define TK_SET                            108
7556 #define TK_DEFERRABLE                     109
7557 #define TK_FOREIGN                        110
7558 #define TK_DROP                           111
7559 #define TK_UNION                          112
7560 #define TK_ALL                            113
7561 #define TK_EXCEPT                         114
7562 #define TK_INTERSECT                      115
7563 #define TK_SELECT                         116
7564 #define TK_DISTINCT                       117
7565 #define TK_DOT                            118
7566 #define TK_FROM                           119
7567 #define TK_JOIN                           120
7568 #define TK_USING                          121
7569 #define TK_ORDER                          122
7570 #define TK_GROUP                          123
7571 #define TK_HAVING                         124
7572 #define TK_LIMIT                          125
7573 #define TK_WHERE                          126
7574 #define TK_INTO                           127
7575 #define TK_VALUES                         128
7576 #define TK_INTEGER                        129
7577 #define TK_FLOAT                          130
7578 #define TK_BLOB                           131
7579 #define TK_REGISTER                       132
7580 #define TK_VARIABLE                       133
7581 #define TK_CASE                           134
7582 #define TK_WHEN                           135
7583 #define TK_THEN                           136
7584 #define TK_ELSE                           137
7585 #define TK_INDEX                          138
7586 #define TK_ALTER                          139
7587 #define TK_ADD                            140
7588 #define TK_TO_TEXT                        141
7589 #define TK_TO_BLOB                        142
7590 #define TK_TO_NUMERIC                     143
7591 #define TK_TO_INT                         144
7592 #define TK_TO_REAL                        145
7593 #define TK_ISNOT                          146
7594 #define TK_END_OF_FILE                    147
7595 #define TK_ILLEGAL                        148
7596 #define TK_SPACE                          149
7597 #define TK_UNCLOSED_STRING                150
7598 #define TK_FUNCTION                       151
7599 #define TK_COLUMN                         152
7600 #define TK_AGG_FUNCTION                   153
7601 #define TK_AGG_COLUMN                     154
7602 #define TK_CONST_FUNC                     155
7603 #define TK_UMINUS                         156
7604 #define TK_UPLUS                          157
7605
7606 /************** End of parse.h ***********************************************/
7607 /************** Continuing where we left off in sqlcipherInt.h ******************/
7608 #include <stdio.h>
7609 #include <stdlib.h>
7610 #include <string.h>
7611 #include <assert.h>
7612 #include <stddef.h>
7613
7614 /*
7615 ** If compiling for a processor that lacks floating point support,
7616 ** substitute integer for floating-point
7617 */
7618 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
7619 # define double sqlcipher_int64
7620 # define float sqlcipher_int64
7621 # define LONGDOUBLE_TYPE sqlcipher_int64
7622 # ifndef SQLCIPHER_BIG_DBL
7623 #   define SQLCIPHER_BIG_DBL (((sqlcipher3_int64)1)<<50)
7624 # endif
7625 # define SQLCIPHER_OMIT_DATETIME_FUNCS 1
7626 # define SQLCIPHER_OMIT_TRACE 1
7627 # undef SQLCIPHER_MIXED_ENDIAN_64BIT_FLOAT
7628 # undef SQLCIPHER_HAVE_ISNAN
7629 #endif
7630 #ifndef SQLCIPHER_BIG_DBL
7631 # define SQLCIPHER_BIG_DBL (1e99)
7632 #endif
7633
7634 /*
7635 ** OMIT_TEMPDB is set to 1 if SQLCIPHER_OMIT_TEMPDB is defined, or 0
7636 ** afterward. Having this macro allows us to cause the C compiler 
7637 ** to omit code used by TEMP tables without messy #ifndef statements.
7638 */
7639 #ifdef SQLCIPHER_OMIT_TEMPDB
7640 #define OMIT_TEMPDB 1
7641 #else
7642 #define OMIT_TEMPDB 0
7643 #endif
7644
7645 /*
7646 ** The "file format" number is an integer that is incremented whenever
7647 ** the VDBE-level file format changes.  The following macros define the
7648 ** the default file format for new databases and the maximum file format
7649 ** that the library can read.
7650 */
7651 #define SQLCIPHER_MAX_FILE_FORMAT 4
7652 #ifndef SQLCIPHER_DEFAULT_FILE_FORMAT
7653 # define SQLCIPHER_DEFAULT_FILE_FORMAT 1
7654 #endif
7655
7656 /*
7657 ** Determine whether triggers are recursive by default.  This can be
7658 ** changed at run-time using a pragma.
7659 */
7660 #ifndef SQLCIPHER_DEFAULT_RECURSIVE_TRIGGERS
7661 # define SQLCIPHER_DEFAULT_RECURSIVE_TRIGGERS 0
7662 #endif
7663
7664 /*
7665 ** Provide a default value for SQLCIPHER_TEMP_STORE in case it is not specified
7666 ** on the command-line
7667 */
7668 #ifndef SQLCIPHER_TEMP_STORE
7669 # define SQLCIPHER_TEMP_STORE 1
7670 #endif
7671
7672 /*
7673 ** GCC does not define the offsetof() macro so we'll have to do it
7674 ** ourselves.
7675 */
7676 #ifndef offsetof
7677 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
7678 #endif
7679
7680 /*
7681 ** Check to see if this machine uses EBCDIC.  (Yes, believe it or
7682 ** not, there are still machines out there that use EBCDIC.)
7683 */
7684 #if 'A' == '\301'
7685 # define SQLCIPHER_EBCDIC 1
7686 #else
7687 # define SQLCIPHER_ASCII 1
7688 #endif
7689
7690 /*
7691 ** Integers of known sizes.  These typedefs might change for architectures
7692 ** where the sizes very.  Preprocessor macros are available so that the
7693 ** types can be conveniently redefined at compile-type.  Like this:
7694 **
7695 **         cc '-DUINTPTR_TYPE=long long int' ...
7696 */
7697 #ifndef UINT32_TYPE
7698 # ifdef HAVE_UINT32_T
7699 #  define UINT32_TYPE uint32_t
7700 # else
7701 #  define UINT32_TYPE unsigned int
7702 # endif
7703 #endif
7704 #ifndef UINT16_TYPE
7705 # ifdef HAVE_UINT16_T
7706 #  define UINT16_TYPE uint16_t
7707 # else
7708 #  define UINT16_TYPE unsigned short int
7709 # endif
7710 #endif
7711 #ifndef INT16_TYPE
7712 # ifdef HAVE_INT16_T
7713 #  define INT16_TYPE int16_t
7714 # else
7715 #  define INT16_TYPE short int
7716 # endif
7717 #endif
7718 #ifndef UINT8_TYPE
7719 # ifdef HAVE_UINT8_T
7720 #  define UINT8_TYPE uint8_t
7721 # else
7722 #  define UINT8_TYPE unsigned char
7723 # endif
7724 #endif
7725 #ifndef INT8_TYPE
7726 # ifdef HAVE_INT8_T
7727 #  define INT8_TYPE int8_t
7728 # else
7729 #  define INT8_TYPE signed char
7730 # endif
7731 #endif
7732 #ifndef LONGDOUBLE_TYPE
7733 # define LONGDOUBLE_TYPE long double
7734 #endif
7735 typedef sqlcipher_int64 i64;          /* 8-byte signed integer */
7736 typedef sqlcipher_uint64 u64;         /* 8-byte unsigned integer */
7737 typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */
7738 typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */
7739 typedef INT16_TYPE i16;            /* 2-byte signed integer */
7740 typedef UINT8_TYPE u8;             /* 1-byte unsigned integer */
7741 typedef INT8_TYPE i8;              /* 1-byte signed integer */
7742
7743 /*
7744 ** SQLCIPHER_MAX_U32 is a u64 constant that is the maximum u64 value
7745 ** that can be stored in a u32 without loss of data.  The value
7746 ** is 0x00000000ffffffff.  But because of quirks of some compilers, we
7747 ** have to specify the value in the less intuitive manner shown:
7748 */
7749 #define SQLCIPHER_MAX_U32  ((((u64)1)<<32)-1)
7750
7751 /*
7752 ** The datatype used to store estimates of the number of rows in a
7753 ** table or index.  This is an unsigned integer type.  For 99.9% of
7754 ** the world, a 32-bit integer is sufficient.  But a 64-bit integer
7755 ** can be used at compile-time if desired.
7756 */
7757 #ifdef SQLCIPHER_64BIT_STATS
7758  typedef u64 tRowcnt;    /* 64-bit only if requested at compile-time */
7759 #else
7760  typedef u32 tRowcnt;    /* 32-bit is the default */
7761 #endif
7762
7763 /*
7764 ** Macros to determine whether the machine is big or little endian,
7765 ** evaluated at runtime.
7766 */
7767 #ifdef SQLCIPHER_AMALGAMATION
7768 SQLCIPHER_PRIVATE const int sqlcipher3one = 1;
7769 #else
7770 SQLCIPHER_PRIVATE const int sqlcipher3one;
7771 #endif
7772 #if defined(i386) || defined(__i386__) || defined(_M_IX86)\
7773                              || defined(__x86_64) || defined(__x86_64__)
7774 # define SQLCIPHER_BIGENDIAN    0
7775 # define SQLCIPHER_LITTLEENDIAN 1
7776 # define SQLCIPHER_UTF16NATIVE  SQLCIPHER_UTF16LE
7777 #else
7778 # define SQLCIPHER_BIGENDIAN    (*(char *)(&sqlcipher3one)==0)
7779 # define SQLCIPHER_LITTLEENDIAN (*(char *)(&sqlcipher3one)==1)
7780 # define SQLCIPHER_UTF16NATIVE (SQLCIPHER_BIGENDIAN?SQLCIPHER_UTF16BE:SQLCIPHER_UTF16LE)
7781 #endif
7782
7783 /*
7784 ** Constants for the largest and smallest possible 64-bit signed integers.
7785 ** These macros are designed to work correctly on both 32-bit and 64-bit
7786 ** compilers.
7787 */
7788 #define LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))
7789 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
7790
7791 /* 
7792 ** Round up a number to the next larger multiple of 8.  This is used
7793 ** to force 8-byte alignment on 64-bit architectures.
7794 */
7795 #define ROUND8(x)     (((x)+7)&~7)
7796
7797 /*
7798 ** Round down to the nearest multiple of 8
7799 */
7800 #define ROUNDDOWN8(x) ((x)&~7)
7801
7802 /*
7803 ** Assert that the pointer X is aligned to an 8-byte boundary.  This
7804 ** macro is used only within assert() to verify that the code gets
7805 ** all alignment restrictions correct.
7806 **
7807 ** Except, if SQLCIPHER_4_BYTE_ALIGNED_MALLOC is defined, then the
7808 ** underlying malloc() implemention might return us 4-byte aligned
7809 ** pointers.  In that case, only verify 4-byte alignment.
7810 */
7811 #ifdef SQLCIPHER_4_BYTE_ALIGNED_MALLOC
7812 # define EIGHT_BYTE_ALIGNMENT(X)   ((((char*)(X) - (char*)0)&3)==0)
7813 #else
7814 # define EIGHT_BYTE_ALIGNMENT(X)   ((((char*)(X) - (char*)0)&7)==0)
7815 #endif
7816
7817
7818 /*
7819 ** An instance of the following structure is used to store the busy-handler
7820 ** callback for a given sqlcipher handle. 
7821 **
7822 ** The sqlcipher.busyHandler member of the sqlcipher struct contains the busy
7823 ** callback for the database handle. Each pager opened via the sqlcipher
7824 ** handle is passed a pointer to sqlcipher.busyHandler. The busy-handler
7825 ** callback is currently invoked only from within pager.c.
7826 */
7827 typedef struct BusyHandler BusyHandler;
7828 struct BusyHandler {
7829   int (*xFunc)(void *,int);  /* The busy callback */
7830   void *pArg;                /* First arg to busy callback */
7831   int nBusy;                 /* Incremented with each busy call */
7832 };
7833
7834 /*
7835 ** Name of the master database table.  The master database table
7836 ** is a special table that holds the names and attributes of all
7837 ** user tables and indices.
7838 */
7839 #define MASTER_NAME       "sqlcipher_master"
7840 #define TEMP_MASTER_NAME  "sqlcipher_temp_master"
7841
7842 /*
7843 ** The root-page of the master database table.
7844 */
7845 #define MASTER_ROOT       1
7846
7847 /*
7848 ** The name of the schema table.
7849 */
7850 #define SCHEMA_TABLE(x)  ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
7851
7852 /*
7853 ** A convenience macro that returns the number of elements in
7854 ** an array.
7855 */
7856 #define ArraySize(X)    ((int)(sizeof(X)/sizeof(X[0])))
7857
7858 /*
7859 ** The following value as a destructor means to use sqlcipher3DbFree().
7860 ** This is an internal extension to SQLCIPHER_STATIC and SQLCIPHER_TRANSIENT.
7861 */
7862 #define SQLCIPHER_DYNAMIC   ((sqlcipher3_destructor_type)sqlcipher3DbFree)
7863
7864 /*
7865 ** When SQLCIPHER_OMIT_WSD is defined, it means that the target platform does
7866 ** not support Writable Static Data (WSD) such as global and static variables.
7867 ** All variables must either be on the stack or dynamically allocated from
7868 ** the heap.  When WSD is unsupported, the variable declarations scattered
7869 ** throughout the SQLite code must become constants instead.  The SQLCIPHER_WSD
7870 ** macro is used for this purpose.  And instead of referencing the variable
7871 ** directly, we use its constant as a key to lookup the run-time allocated
7872 ** buffer that holds real variable.  The constant is also the initializer
7873 ** for the run-time allocated buffer.
7874 **
7875 ** In the usual case where WSD is supported, the SQLCIPHER_WSD and GLOBAL
7876 ** macros become no-ops and have zero performance impact.
7877 */
7878 #ifdef SQLCIPHER_OMIT_WSD
7879   #define SQLCIPHER_WSD const
7880   #define GLOBAL(t,v) (*(t*)sqlcipher3_wsd_find((void*)&(v), sizeof(v)))
7881   #define sqlcipher3GlobalConfig GLOBAL(struct Sqlite3Config, sqlcipher3Config)
7882 SQLCIPHER_API   int sqlcipher3_wsd_init(int N, int J);
7883 SQLCIPHER_API   void *sqlcipher3_wsd_find(void *K, int L);
7884 #else
7885   #define SQLCIPHER_WSD 
7886   #define GLOBAL(t,v) v
7887   #define sqlcipher3GlobalConfig sqlcipher3Config
7888 #endif
7889
7890 /*
7891 ** The following macros are used to suppress compiler warnings and to
7892 ** make it clear to human readers when a function parameter is deliberately 
7893 ** left unused within the body of a function. This usually happens when
7894 ** a function is called via a function pointer. For example the 
7895 ** implementation of an SQL aggregate step callback may not use the
7896 ** parameter indicating the number of arguments passed to the aggregate,
7897 ** if it knows that this is enforced elsewhere.
7898 **
7899 ** When a function parameter is not used at all within the body of a function,
7900 ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
7901 ** However, these macros may also be used to suppress warnings related to
7902 ** parameters that may or may not be used depending on compilation options.
7903 ** For example those parameters only used in assert() statements. In these
7904 ** cases the parameters are named as per the usual conventions.
7905 */
7906 #define UNUSED_PARAMETER(x) (void)(x)
7907 #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
7908
7909 /*
7910 ** Forward references to structures
7911 */
7912 typedef struct AggInfo AggInfo;
7913 typedef struct AuthContext AuthContext;
7914 typedef struct AutoincInfo AutoincInfo;
7915 typedef struct Bitvec Bitvec;
7916 typedef struct CollSeq CollSeq;
7917 typedef struct Column Column;
7918 typedef struct Db Db;
7919 typedef struct Schema Schema;
7920 typedef struct Expr Expr;
7921 typedef struct ExprList ExprList;
7922 typedef struct ExprSpan ExprSpan;
7923 typedef struct FKey FKey;
7924 typedef struct FuncDestructor FuncDestructor;
7925 typedef struct FuncDef FuncDef;
7926 typedef struct FuncDefHash FuncDefHash;
7927 typedef struct IdList IdList;
7928 typedef struct Index Index;
7929 typedef struct IndexSample IndexSample;
7930 typedef struct KeyClass KeyClass;
7931 typedef struct KeyInfo KeyInfo;
7932 typedef struct Lookaside Lookaside;
7933 typedef struct LookasideSlot LookasideSlot;
7934 typedef struct Module Module;
7935 typedef struct NameContext NameContext;
7936 typedef struct Parse Parse;
7937 typedef struct RowSet RowSet;
7938 typedef struct Savepoint Savepoint;
7939 typedef struct Select Select;
7940 typedef struct SrcList SrcList;
7941 typedef struct StrAccum StrAccum;
7942 typedef struct Table Table;
7943 typedef struct TableLock TableLock;
7944 typedef struct Token Token;
7945 typedef struct Trigger Trigger;
7946 typedef struct TriggerPrg TriggerPrg;
7947 typedef struct TriggerStep TriggerStep;
7948 typedef struct UnpackedRecord UnpackedRecord;
7949 typedef struct VTable VTable;
7950 typedef struct VtabCtx VtabCtx;
7951 typedef struct Walker Walker;
7952 typedef struct WherePlan WherePlan;
7953 typedef struct WhereInfo WhereInfo;
7954 typedef struct WhereLevel WhereLevel;
7955
7956 /*
7957 ** Defer sourcing vdbe.h and btree.h until after the "u8" and 
7958 ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
7959 ** pointer types (i.e. FuncDef) defined above.
7960 */
7961 /************** Include btree.h in the middle of sqlcipherInt.h *****************/
7962 /************** Begin file btree.h *******************************************/
7963 /*
7964 ** 2001 September 15
7965 **
7966 ** The author disclaims copyright to this source code.  In place of
7967 ** a legal notice, here is a blessing:
7968 **
7969 **    May you do good and not evil.
7970 **    May you find forgiveness for yourself and forgive others.
7971 **    May you share freely, never taking more than you give.
7972 **
7973 *************************************************************************
7974 ** This header file defines the interface that the sqlcipher B-Tree file
7975 ** subsystem.  See comments in the source code for a detailed description
7976 ** of what each interface routine does.
7977 */
7978 #ifndef _BTREE_H_
7979 #define _BTREE_H_
7980
7981 /* TODO: This definition is just included so other modules compile. It
7982 ** needs to be revisited.
7983 */
7984 #define SQLCIPHER_N_BTREE_META 10
7985
7986 /*
7987 ** If defined as non-zero, auto-vacuum is enabled by default. Otherwise
7988 ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
7989 */
7990 #ifndef SQLCIPHER_DEFAULT_AUTOVACUUM
7991   #define SQLCIPHER_DEFAULT_AUTOVACUUM 0
7992 #endif
7993
7994 #define BTREE_AUTOVACUUM_NONE 0        /* Do not do auto-vacuum */
7995 #define BTREE_AUTOVACUUM_FULL 1        /* Do full auto-vacuum */
7996 #define BTREE_AUTOVACUUM_INCR 2        /* Incremental vacuum */
7997
7998 /*
7999 ** Forward declarations of structure
8000 */
8001 typedef struct Btree Btree;
8002 typedef struct BtCursor BtCursor;
8003 typedef struct BtShared BtShared;
8004
8005
8006 SQLCIPHER_PRIVATE int sqlcipher3BtreeOpen(
8007   sqlcipher3_vfs *pVfs,       /* VFS to use with this b-tree */
8008   const char *zFilename,   /* Name of database file to open */
8009   sqlcipher3 *db,             /* Associated database connection */
8010   Btree **ppBtree,         /* Return open Btree* here */
8011   int flags,               /* Flags */
8012   int vfsFlags             /* Flags passed through to VFS open */
8013 );
8014
8015 /* The flags parameter to sqlcipher3BtreeOpen can be the bitwise or of the
8016 ** following values.
8017 **
8018 ** NOTE:  These values must match the corresponding PAGER_ values in
8019 ** pager.h.
8020 */
8021 #define BTREE_OMIT_JOURNAL  1  /* Do not create or use a rollback journal */
8022 #define BTREE_NO_READLOCK   2  /* Omit readlocks on readonly files */
8023 #define BTREE_MEMORY        4  /* This is an in-memory DB */
8024 #define BTREE_SINGLE        8  /* The file contains at most 1 b-tree */
8025 #define BTREE_UNORDERED    16  /* Use of a hash implementation is OK */
8026
8027 SQLCIPHER_PRIVATE int sqlcipher3BtreeClose(Btree*);
8028 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetCacheSize(Btree*,int);
8029 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetSafetyLevel(Btree*,int,int,int);
8030 SQLCIPHER_PRIVATE int sqlcipher3BtreeSyncDisabled(Btree*);
8031 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix);
8032 SQLCIPHER_PRIVATE int sqlcipher3BtreeGetPageSize(Btree*);
8033 SQLCIPHER_PRIVATE int sqlcipher3BtreeMaxPageCount(Btree*,int);
8034 SQLCIPHER_PRIVATE u32 sqlcipher3BtreeLastPage(Btree*);
8035 SQLCIPHER_PRIVATE int sqlcipher3BtreeSecureDelete(Btree*,int);
8036 SQLCIPHER_PRIVATE int sqlcipher3BtreeGetReserve(Btree*);
8037 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetAutoVacuum(Btree *, int);
8038 SQLCIPHER_PRIVATE int sqlcipher3BtreeGetAutoVacuum(Btree *);
8039 SQLCIPHER_PRIVATE int sqlcipher3BtreeBeginTrans(Btree*,int);
8040 SQLCIPHER_PRIVATE int sqlcipher3BtreeCommitPhaseOne(Btree*, const char *zMaster);
8041 SQLCIPHER_PRIVATE int sqlcipher3BtreeCommitPhaseTwo(Btree*, int);
8042 SQLCIPHER_PRIVATE int sqlcipher3BtreeCommit(Btree*);
8043 SQLCIPHER_PRIVATE int sqlcipher3BtreeRollback(Btree*);
8044 SQLCIPHER_PRIVATE int sqlcipher3BtreeBeginStmt(Btree*,int);
8045 SQLCIPHER_PRIVATE int sqlcipher3BtreeCreateTable(Btree*, int*, int flags);
8046 SQLCIPHER_PRIVATE int sqlcipher3BtreeIsInTrans(Btree*);
8047 SQLCIPHER_PRIVATE int sqlcipher3BtreeIsInReadTrans(Btree*);
8048 SQLCIPHER_PRIVATE int sqlcipher3BtreeIsInBackup(Btree*);
8049 SQLCIPHER_PRIVATE void *sqlcipher3BtreeSchema(Btree *, int, void(*)(void *));
8050 SQLCIPHER_PRIVATE int sqlcipher3BtreeSchemaLocked(Btree *pBtree);
8051 SQLCIPHER_PRIVATE int sqlcipher3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock);
8052 SQLCIPHER_PRIVATE int sqlcipher3BtreeSavepoint(Btree *, int, int);
8053
8054 SQLCIPHER_PRIVATE const char *sqlcipher3BtreeGetFilename(Btree *);
8055 SQLCIPHER_PRIVATE const char *sqlcipher3BtreeGetJournalname(Btree *);
8056 SQLCIPHER_PRIVATE int sqlcipher3BtreeCopyFile(Btree *, Btree *);
8057
8058 SQLCIPHER_PRIVATE int sqlcipher3BtreeIncrVacuum(Btree *);
8059
8060 /* The flags parameter to sqlcipher3BtreeCreateTable can be the bitwise OR
8061 ** of the flags shown below.
8062 **
8063 ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
8064 ** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data
8065 ** is stored in the leaves.  (BTREE_INTKEY is used for SQL tables.)  With
8066 ** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored
8067 ** anywhere - the key is the content.  (BTREE_BLOBKEY is used for SQL
8068 ** indices.)
8069 */
8070 #define BTREE_INTKEY     1    /* Table has only 64-bit signed integer keys */
8071 #define BTREE_BLOBKEY    2    /* Table has keys only - no data */
8072
8073 SQLCIPHER_PRIVATE int sqlcipher3BtreeDropTable(Btree*, int, int*);
8074 SQLCIPHER_PRIVATE int sqlcipher3BtreeClearTable(Btree*, int, int*);
8075 SQLCIPHER_PRIVATE void sqlcipher3BtreeTripAllCursors(Btree*, int);
8076
8077 SQLCIPHER_PRIVATE void sqlcipher3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
8078 SQLCIPHER_PRIVATE int sqlcipher3BtreeUpdateMeta(Btree*, int idx, u32 value);
8079
8080 /*
8081 ** The second parameter to sqlcipher3BtreeGetMeta or sqlcipher3BtreeUpdateMeta
8082 ** should be one of the following values. The integer values are assigned 
8083 ** to constants so that the offset of the corresponding field in an
8084 ** SQLite database header may be found using the following formula:
8085 **
8086 **   offset = 36 + (idx * 4)
8087 **
8088 ** For example, the free-page-count field is located at byte offset 36 of
8089 ** the database file header. The incr-vacuum-flag field is located at
8090 ** byte offset 64 (== 36+4*7).
8091 */
8092 #define BTREE_FREE_PAGE_COUNT     0
8093 #define BTREE_SCHEMA_VERSION      1
8094 #define BTREE_FILE_FORMAT         2
8095 #define BTREE_DEFAULT_CACHE_SIZE  3
8096 #define BTREE_LARGEST_ROOT_PAGE   4
8097 #define BTREE_TEXT_ENCODING       5
8098 #define BTREE_USER_VERSION        6
8099 #define BTREE_INCR_VACUUM         7
8100
8101 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursor(
8102   Btree*,                              /* BTree containing table to open */
8103   int iTable,                          /* Index of root page */
8104   int wrFlag,                          /* 1 for writing.  0 for read-only */
8105   struct KeyInfo*,                     /* First argument to compare function */
8106   BtCursor *pCursor                    /* Space to write cursor structure */
8107 );
8108 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorSize(void);
8109 SQLCIPHER_PRIVATE void sqlcipher3BtreeCursorZero(BtCursor*);
8110
8111 SQLCIPHER_PRIVATE int sqlcipher3BtreeCloseCursor(BtCursor*);
8112 SQLCIPHER_PRIVATE int sqlcipher3BtreeMovetoUnpacked(
8113   BtCursor*,
8114   UnpackedRecord *pUnKey,
8115   i64 intKey,
8116   int bias,
8117   int *pRes
8118 );
8119 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorHasMoved(BtCursor*, int*);
8120 SQLCIPHER_PRIVATE int sqlcipher3BtreeDelete(BtCursor*);
8121 SQLCIPHER_PRIVATE int sqlcipher3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
8122                                   const void *pData, int nData,
8123                                   int nZero, int bias, int seekResult);
8124 SQLCIPHER_PRIVATE int sqlcipher3BtreeFirst(BtCursor*, int *pRes);
8125 SQLCIPHER_PRIVATE int sqlcipher3BtreeLast(BtCursor*, int *pRes);
8126 SQLCIPHER_PRIVATE int sqlcipher3BtreeNext(BtCursor*, int *pRes);
8127 SQLCIPHER_PRIVATE int sqlcipher3BtreeEof(BtCursor*);
8128 SQLCIPHER_PRIVATE int sqlcipher3BtreePrevious(BtCursor*, int *pRes);
8129 SQLCIPHER_PRIVATE int sqlcipher3BtreeKeySize(BtCursor*, i64 *pSize);
8130 SQLCIPHER_PRIVATE int sqlcipher3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
8131 SQLCIPHER_PRIVATE const void *sqlcipher3BtreeKeyFetch(BtCursor*, int *pAmt);
8132 SQLCIPHER_PRIVATE const void *sqlcipher3BtreeDataFetch(BtCursor*, int *pAmt);
8133 SQLCIPHER_PRIVATE int sqlcipher3BtreeDataSize(BtCursor*, u32 *pSize);
8134 SQLCIPHER_PRIVATE int sqlcipher3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
8135 SQLCIPHER_PRIVATE void sqlcipher3BtreeSetCachedRowid(BtCursor*, sqlcipher3_int64);
8136 SQLCIPHER_PRIVATE sqlcipher3_int64 sqlcipher3BtreeGetCachedRowid(BtCursor*);
8137
8138 SQLCIPHER_PRIVATE char *sqlcipher3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*);
8139 SQLCIPHER_PRIVATE struct Pager *sqlcipher3BtreePager(Btree*);
8140
8141 SQLCIPHER_PRIVATE int sqlcipher3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
8142 SQLCIPHER_PRIVATE void sqlcipher3BtreeCacheOverflow(BtCursor *);
8143 SQLCIPHER_PRIVATE void sqlcipher3BtreeClearCursor(BtCursor *);
8144
8145 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetVersion(Btree *pBt, int iVersion);
8146
8147 #ifndef NDEBUG
8148 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorIsValid(BtCursor*);
8149 #endif
8150
8151 #ifndef SQLCIPHER_OMIT_BTREECOUNT
8152 SQLCIPHER_PRIVATE int sqlcipher3BtreeCount(BtCursor *, i64 *);
8153 #endif
8154
8155 #ifdef SQLCIPHER_TEST
8156 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorInfo(BtCursor*, int*, int);
8157 SQLCIPHER_PRIVATE void sqlcipher3BtreeCursorList(Btree*);
8158 #endif
8159
8160 #ifndef SQLCIPHER_OMIT_WAL
8161 SQLCIPHER_PRIVATE   int sqlcipher3BtreeCheckpoint(Btree*, int, int *, int *);
8162 #endif
8163
8164 /*
8165 ** If we are not using shared cache, then there is no need to
8166 ** use mutexes to access the BtShared structures.  So make the
8167 ** Enter and Leave procedures no-ops.
8168 */
8169 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
8170 SQLCIPHER_PRIVATE   void sqlcipher3BtreeEnter(Btree*);
8171 SQLCIPHER_PRIVATE   void sqlcipher3BtreeEnterAll(sqlcipher3*);
8172 #else
8173 # define sqlcipher3BtreeEnter(X) 
8174 # define sqlcipher3BtreeEnterAll(X)
8175 #endif
8176
8177 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && SQLCIPHER_THREADSAFE
8178 SQLCIPHER_PRIVATE   int sqlcipher3BtreeSharable(Btree*);
8179 SQLCIPHER_PRIVATE   void sqlcipher3BtreeLeave(Btree*);
8180 SQLCIPHER_PRIVATE   void sqlcipher3BtreeEnterCursor(BtCursor*);
8181 SQLCIPHER_PRIVATE   void sqlcipher3BtreeLeaveCursor(BtCursor*);
8182 SQLCIPHER_PRIVATE   void sqlcipher3BtreeLeaveAll(sqlcipher3*);
8183 #ifndef NDEBUG
8184   /* These routines are used inside assert() statements only. */
8185 SQLCIPHER_PRIVATE   int sqlcipher3BtreeHoldsMutex(Btree*);
8186 SQLCIPHER_PRIVATE   int sqlcipher3BtreeHoldsAllMutexes(sqlcipher3*);
8187 SQLCIPHER_PRIVATE   int sqlcipher3SchemaMutexHeld(sqlcipher3*,int,Schema*);
8188 #endif
8189 #else
8190
8191 # define sqlcipher3BtreeSharable(X) 0
8192 # define sqlcipher3BtreeLeave(X)
8193 # define sqlcipher3BtreeEnterCursor(X)
8194 # define sqlcipher3BtreeLeaveCursor(X)
8195 # define sqlcipher3BtreeLeaveAll(X)
8196
8197 # define sqlcipher3BtreeHoldsMutex(X) 1
8198 # define sqlcipher3BtreeHoldsAllMutexes(X) 1
8199 # define sqlcipher3SchemaMutexHeld(X,Y,Z) 1
8200 #endif
8201
8202
8203 #endif /* _BTREE_H_ */
8204
8205 /************** End of btree.h ***********************************************/
8206 /************** Continuing where we left off in sqlcipherInt.h ******************/
8207 /************** Include vdbe.h in the middle of sqlcipherInt.h ******************/
8208 /************** Begin file vdbe.h ********************************************/
8209 /*
8210 ** 2001 September 15
8211 **
8212 ** The author disclaims copyright to this source code.  In place of
8213 ** a legal notice, here is a blessing:
8214 **
8215 **    May you do good and not evil.
8216 **    May you find forgiveness for yourself and forgive others.
8217 **    May you share freely, never taking more than you give.
8218 **
8219 *************************************************************************
8220 ** Header file for the Virtual DataBase Engine (VDBE)
8221 **
8222 ** This header defines the interface to the virtual database engine
8223 ** or VDBE.  The VDBE implements an abstract machine that runs a
8224 ** simple program to access and modify the underlying database.
8225 */
8226 #ifndef _SQLCIPHER_VDBE_H_
8227 #define _SQLCIPHER_VDBE_H_
8228 /* #include <stdio.h> */
8229
8230 /*
8231 ** A single VDBE is an opaque structure named "Vdbe".  Only routines
8232 ** in the source file sqlcipherVdbe.c are allowed to see the insides
8233 ** of this structure.
8234 */
8235 typedef struct Vdbe Vdbe;
8236
8237 /*
8238 ** The names of the following types declared in vdbeInt.h are required
8239 ** for the VdbeOp definition.
8240 */
8241 typedef struct VdbeFunc VdbeFunc;
8242 typedef struct Mem Mem;
8243 typedef struct SubProgram SubProgram;
8244
8245 /*
8246 ** A single instruction of the virtual machine has an opcode
8247 ** and as many as three operands.  The instruction is recorded
8248 ** as an instance of the following structure:
8249 */
8250 struct VdbeOp {
8251   u8 opcode;          /* What operation to perform */
8252   signed char p4type; /* One of the P4_xxx constants for p4 */
8253   u8 opflags;         /* Mask of the OPFLG_* flags in opcodes.h */
8254   u8 p5;              /* Fifth parameter is an unsigned character */
8255   int p1;             /* First operand */
8256   int p2;             /* Second parameter (often the jump destination) */
8257   int p3;             /* The third parameter */
8258   union {             /* fourth parameter */
8259     int i;                 /* Integer value if p4type==P4_INT32 */
8260     void *p;               /* Generic pointer */
8261     char *z;               /* Pointer to data for string (char array) types */
8262     i64 *pI64;             /* Used when p4type is P4_INT64 */
8263     double *pReal;         /* Used when p4type is P4_REAL */
8264     FuncDef *pFunc;        /* Used when p4type is P4_FUNCDEF */
8265     VdbeFunc *pVdbeFunc;   /* Used when p4type is P4_VDBEFUNC */
8266     CollSeq *pColl;        /* Used when p4type is P4_COLLSEQ */
8267     Mem *pMem;             /* Used when p4type is P4_MEM */
8268     VTable *pVtab;         /* Used when p4type is P4_VTAB */
8269     KeyInfo *pKeyInfo;     /* Used when p4type is P4_KEYINFO */
8270     int *ai;               /* Used when p4type is P4_INTARRAY */
8271     SubProgram *pProgram;  /* Used when p4type is P4_SUBPROGRAM */
8272     int (*xAdvance)(BtCursor *, int *);
8273   } p4;
8274 #ifdef SQLCIPHER_DEBUG
8275   char *zComment;          /* Comment to improve readability */
8276 #endif
8277 #ifdef VDBE_PROFILE
8278   int cnt;                 /* Number of times this instruction was executed */
8279   u64 cycles;              /* Total time spent executing this instruction */
8280 #endif
8281 };
8282 typedef struct VdbeOp VdbeOp;
8283
8284
8285 /*
8286 ** A sub-routine used to implement a trigger program.
8287 */
8288 struct SubProgram {
8289   VdbeOp *aOp;                  /* Array of opcodes for sub-program */
8290   int nOp;                      /* Elements in aOp[] */
8291   int nMem;                     /* Number of memory cells required */
8292   int nCsr;                     /* Number of cursors required */
8293   void *token;                  /* id that may be used to recursive triggers */
8294   SubProgram *pNext;            /* Next sub-program already visited */
8295 };
8296
8297 /*
8298 ** A smaller version of VdbeOp used for the VdbeAddOpList() function because
8299 ** it takes up less space.
8300 */
8301 struct VdbeOpList {
8302   u8 opcode;          /* What operation to perform */
8303   signed char p1;     /* First operand */
8304   signed char p2;     /* Second parameter (often the jump destination) */
8305   signed char p3;     /* Third parameter */
8306 };
8307 typedef struct VdbeOpList VdbeOpList;
8308
8309 /*
8310 ** Allowed values of VdbeOp.p4type
8311 */
8312 #define P4_NOTUSED    0   /* The P4 parameter is not used */
8313 #define P4_DYNAMIC  (-1)  /* Pointer to a string obtained from sqlcipherMalloc() */
8314 #define P4_STATIC   (-2)  /* Pointer to a static string */
8315 #define P4_COLLSEQ  (-4)  /* P4 is a pointer to a CollSeq structure */
8316 #define P4_FUNCDEF  (-5)  /* P4 is a pointer to a FuncDef structure */
8317 #define P4_KEYINFO  (-6)  /* P4 is a pointer to a KeyInfo structure */
8318 #define P4_VDBEFUNC (-7)  /* P4 is a pointer to a VdbeFunc structure */
8319 #define P4_MEM      (-8)  /* P4 is a pointer to a Mem*    structure */
8320 #define P4_TRANSIENT  0   /* P4 is a pointer to a transient string */
8321 #define P4_VTAB     (-10) /* P4 is a pointer to an sqlcipher3_vtab structure */
8322 #define P4_MPRINTF  (-11) /* P4 is a string obtained from sqlcipher3_mprintf() */
8323 #define P4_REAL     (-12) /* P4 is a 64-bit floating point value */
8324 #define P4_INT64    (-13) /* P4 is a 64-bit signed integer */
8325 #define P4_INT32    (-14) /* P4 is a 32-bit signed integer */
8326 #define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */
8327 #define P4_SUBPROGRAM  (-18) /* P4 is a pointer to a SubProgram structure */
8328 #define P4_ADVANCE  (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */
8329
8330 /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
8331 ** is made.  That copy is freed when the Vdbe is finalized.  But if the
8332 ** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used.  It still
8333 ** gets freed when the Vdbe is finalized so it still should be obtained
8334 ** from a single sqlcipherMalloc().  But no copy is made and the calling
8335 ** function should *not* try to free the KeyInfo.
8336 */
8337 #define P4_KEYINFO_HANDOFF (-16)
8338 #define P4_KEYINFO_STATIC  (-17)
8339
8340 /*
8341 ** The Vdbe.aColName array contains 5n Mem structures, where n is the 
8342 ** number of columns of data returned by the statement.
8343 */
8344 #define COLNAME_NAME     0
8345 #define COLNAME_DECLTYPE 1
8346 #define COLNAME_DATABASE 2
8347 #define COLNAME_TABLE    3
8348 #define COLNAME_COLUMN   4
8349 #ifdef SQLCIPHER_ENABLE_COLUMN_METADATA
8350 # define COLNAME_N        5      /* Number of COLNAME_xxx symbols */
8351 #else
8352 # ifdef SQLCIPHER_OMIT_DECLTYPE
8353 #   define COLNAME_N      1      /* Store only the name */
8354 # else
8355 #   define COLNAME_N      2      /* Store the name and decltype */
8356 # endif
8357 #endif
8358
8359 /*
8360 ** The following macro converts a relative address in the p2 field
8361 ** of a VdbeOp structure into a negative number so that 
8362 ** sqlcipher3VdbeAddOpList() knows that the address is relative.  Calling
8363 ** the macro again restores the address.
8364 */
8365 #define ADDR(X)  (-1-(X))
8366
8367 /*
8368 ** The makefile scans the vdbe.c source file and creates the "opcodes.h"
8369 ** header file that defines a number for each opcode used by the VDBE.
8370 */
8371 /************** Include opcodes.h in the middle of vdbe.h ********************/
8372 /************** Begin file opcodes.h *****************************************/
8373 /* Automatically generated.  Do not edit */
8374 /* See the mkopcodeh.awk script for details */
8375 #define OP_Goto                                 1
8376 #define OP_Gosub                                2
8377 #define OP_Return                               3
8378 #define OP_Yield                                4
8379 #define OP_HaltIfNull                           5
8380 #define OP_Halt                                 6
8381 #define OP_Integer                              7
8382 #define OP_Int64                                8
8383 #define OP_Real                               130   /* same as TK_FLOAT    */
8384 #define OP_String8                             94   /* same as TK_STRING   */
8385 #define OP_String                               9
8386 #define OP_Null                                10
8387 #define OP_Blob                                11
8388 #define OP_Variable                            12
8389 #define OP_Move                                13
8390 #define OP_Copy                                14
8391 #define OP_SCopy                               15
8392 #define OP_ResultRow                           16
8393 #define OP_Concat                              91   /* same as TK_CONCAT   */
8394 #define OP_Add                                 86   /* same as TK_PLUS     */
8395 #define OP_Subtract                            87   /* same as TK_MINUS    */
8396 #define OP_Multiply                            88   /* same as TK_STAR     */
8397 #define OP_Divide                              89   /* same as TK_SLASH    */
8398 #define OP_Remainder                           90   /* same as TK_REM      */
8399 #define OP_CollSeq                             17
8400 #define OP_Function                            18
8401 #define OP_BitAnd                              82   /* same as TK_BITAND   */
8402 #define OP_BitOr                               83   /* same as TK_BITOR    */
8403 #define OP_ShiftLeft                           84   /* same as TK_LSHIFT   */
8404 #define OP_ShiftRight                          85   /* same as TK_RSHIFT   */
8405 #define OP_AddImm                              20
8406 #define OP_MustBeInt                           21
8407 #define OP_RealAffinity                        22
8408 #define OP_ToText                             141   /* same as TK_TO_TEXT  */
8409 #define OP_ToBlob                             142   /* same as TK_TO_BLOB  */
8410 #define OP_ToNumeric                          143   /* same as TK_TO_NUMERIC*/
8411 #define OP_ToInt                              144   /* same as TK_TO_INT   */
8412 #define OP_ToReal                             145   /* same as TK_TO_REAL  */
8413 #define OP_Eq                                  76   /* same as TK_EQ       */
8414 #define OP_Ne                                  75   /* same as TK_NE       */
8415 #define OP_Lt                                  79   /* same as TK_LT       */
8416 #define OP_Le                                  78   /* same as TK_LE       */
8417 #define OP_Gt                                  77   /* same as TK_GT       */
8418 #define OP_Ge                                  80   /* same as TK_GE       */
8419 #define OP_Permutation                         23
8420 #define OP_Compare                             24
8421 #define OP_Jump                                25
8422 #define OP_And                                 69   /* same as TK_AND      */
8423 #define OP_Or                                  68   /* same as TK_OR       */
8424 #define OP_Not                                 19   /* same as TK_NOT      */
8425 #define OP_BitNot                              93   /* same as TK_BITNOT   */
8426 #define OP_Once                                26
8427 #define OP_If                                  27
8428 #define OP_IfNot                               28
8429 #define OP_IsNull                              73   /* same as TK_ISNULL   */
8430 #define OP_NotNull                             74   /* same as TK_NOTNULL  */
8431 #define OP_Column                              29
8432 #define OP_Affinity                            30
8433 #define OP_MakeRecord                          31
8434 #define OP_Count                               32
8435 #define OP_Savepoint                           33
8436 #define OP_AutoCommit                          34
8437 #define OP_Transaction                         35
8438 #define OP_ReadCookie                          36
8439 #define OP_SetCookie                           37
8440 #define OP_VerifyCookie                        38
8441 #define OP_OpenRead                            39
8442 #define OP_OpenWrite                           40
8443 #define OP_OpenAutoindex                       41
8444 #define OP_OpenEphemeral                       42
8445 #define OP_SorterOpen                          43
8446 #define OP_OpenPseudo                          44
8447 #define OP_Close                               45
8448 #define OP_SeekLt                              46
8449 #define OP_SeekLe                              47
8450 #define OP_SeekGe                              48
8451 #define OP_SeekGt                              49
8452 #define OP_Seek                                50
8453 #define OP_NotFound                            51
8454 #define OP_Found                               52
8455 #define OP_IsUnique                            53
8456 #define OP_NotExists                           54
8457 #define OP_Sequence                            55
8458 #define OP_NewRowid                            56
8459 #define OP_Insert                              57
8460 #define OP_InsertInt                           58
8461 #define OP_Delete                              59
8462 #define OP_ResetCount                          60
8463 #define OP_SorterCompare                       61
8464 #define OP_SorterData                          62
8465 #define OP_RowKey                              63
8466 #define OP_RowData                             64
8467 #define OP_Rowid                               65
8468 #define OP_NullRow                             66
8469 #define OP_Last                                67
8470 #define OP_SorterSort                          70
8471 #define OP_Sort                                71
8472 #define OP_Rewind                              72
8473 #define OP_SorterNext                          81
8474 #define OP_Prev                                92
8475 #define OP_Next                                95
8476 #define OP_SorterInsert                        96
8477 #define OP_IdxInsert                           97
8478 #define OP_IdxDelete                           98
8479 #define OP_IdxRowid                            99
8480 #define OP_IdxLT                              100
8481 #define OP_IdxGE                              101
8482 #define OP_Destroy                            102
8483 #define OP_Clear                              103
8484 #define OP_CreateIndex                        104
8485 #define OP_CreateTable                        105
8486 #define OP_ParseSchema                        106
8487 #define OP_LoadAnalysis                       107
8488 #define OP_DropTable                          108
8489 #define OP_DropIndex                          109
8490 #define OP_DropTrigger                        110
8491 #define OP_IntegrityCk                        111
8492 #define OP_RowSetAdd                          112
8493 #define OP_RowSetRead                         113
8494 #define OP_RowSetTest                         114
8495 #define OP_Program                            115
8496 #define OP_Param                              116
8497 #define OP_FkCounter                          117
8498 #define OP_FkIfZero                           118
8499 #define OP_MemMax                             119
8500 #define OP_IfPos                              120
8501 #define OP_IfNeg                              121
8502 #define OP_IfZero                             122
8503 #define OP_AggStep                            123
8504 #define OP_AggFinal                           124
8505 #define OP_Checkpoint                         125
8506 #define OP_JournalMode                        126
8507 #define OP_Vacuum                             127
8508 #define OP_IncrVacuum                         128
8509 #define OP_Expire                             129
8510 #define OP_TableLock                          131
8511 #define OP_VBegin                             132
8512 #define OP_VCreate                            133
8513 #define OP_VDestroy                           134
8514 #define OP_VOpen                              135
8515 #define OP_VFilter                            136
8516 #define OP_VColumn                            137
8517 #define OP_VNext                              138
8518 #define OP_VRename                            139
8519 #define OP_VUpdate                            140
8520 #define OP_Pagecount                          146
8521 #define OP_MaxPgcnt                           147
8522 #define OP_Trace                              148
8523 #define OP_Noop                               149
8524 #define OP_Explain                            150
8525
8526
8527 /* Properties such as "out2" or "jump" that are specified in
8528 ** comments following the "case" for each opcode in the vdbe.c
8529 ** are encoded into bitvectors as follows:
8530 */
8531 #define OPFLG_JUMP            0x0001  /* jump:  P2 holds jmp target */
8532 #define OPFLG_OUT2_PRERELEASE 0x0002  /* out2-prerelease: */
8533 #define OPFLG_IN1             0x0004  /* in1:   P1 is an input */
8534 #define OPFLG_IN2             0x0008  /* in2:   P2 is an input */
8535 #define OPFLG_IN3             0x0010  /* in3:   P3 is an input */
8536 #define OPFLG_OUT2            0x0020  /* out2:  P2 is an output */
8537 #define OPFLG_OUT3            0x0040  /* out3:  P3 is an output */
8538 #define OPFLG_INITIALIZER {\
8539 /*   0 */ 0x00, 0x01, 0x05, 0x04, 0x04, 0x10, 0x00, 0x02,\
8540 /*   8 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x24, 0x24,\
8541 /*  16 */ 0x00, 0x00, 0x00, 0x24, 0x04, 0x05, 0x04, 0x00,\
8542 /*  24 */ 0x00, 0x01, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00,\
8543 /*  32 */ 0x02, 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00,\
8544 /*  40 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,\
8545 /*  48 */ 0x11, 0x11, 0x08, 0x11, 0x11, 0x11, 0x11, 0x02,\
8546 /*  56 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
8547 /*  64 */ 0x00, 0x02, 0x00, 0x01, 0x4c, 0x4c, 0x01, 0x01,\
8548 /*  72 */ 0x01, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\
8549 /*  80 */ 0x15, 0x01, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\
8550 /*  88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x01, 0x24, 0x02, 0x01,\
8551 /*  96 */ 0x08, 0x08, 0x00, 0x02, 0x01, 0x01, 0x02, 0x00,\
8552 /* 104 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
8553 /* 112 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x00, 0x01, 0x08,\
8554 /* 120 */ 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00,\
8555 /* 128 */ 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,\
8556 /* 136 */ 0x01, 0x00, 0x01, 0x00, 0x00, 0x04, 0x04, 0x04,\
8557 /* 144 */ 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00,}
8558
8559 /************** End of opcodes.h *********************************************/
8560 /************** Continuing where we left off in vdbe.h ***********************/
8561
8562 /*
8563 ** Prototypes for the VDBE interface.  See comments on the implementation
8564 ** for a description of what each of these routines does.
8565 */
8566 SQLCIPHER_PRIVATE Vdbe *sqlcipher3VdbeCreate(sqlcipher3*);
8567 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp0(Vdbe*,int);
8568 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp1(Vdbe*,int,int);
8569 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp2(Vdbe*,int,int,int);
8570 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp3(Vdbe*,int,int,int,int);
8571 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
8572 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
8573 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
8574 SQLCIPHER_PRIVATE void sqlcipher3VdbeAddParseSchemaOp(Vdbe*,int,char*);
8575 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP1(Vdbe*, u32 addr, int P1);
8576 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP2(Vdbe*, u32 addr, int P2);
8577 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP3(Vdbe*, u32 addr, int P3);
8578 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP5(Vdbe*, u8 P5);
8579 SQLCIPHER_PRIVATE void sqlcipher3VdbeJumpHere(Vdbe*, int addr);
8580 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeToNoop(Vdbe*, int addr);
8581 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
8582 SQLCIPHER_PRIVATE void sqlcipher3VdbeUsesBtree(Vdbe*, int);
8583 SQLCIPHER_PRIVATE VdbeOp *sqlcipher3VdbeGetOp(Vdbe*, int);
8584 SQLCIPHER_PRIVATE int sqlcipher3VdbeMakeLabel(Vdbe*);
8585 SQLCIPHER_PRIVATE void sqlcipher3VdbeRunOnlyOnce(Vdbe*);
8586 SQLCIPHER_PRIVATE void sqlcipher3VdbeDelete(Vdbe*);
8587 SQLCIPHER_PRIVATE void sqlcipher3VdbeDeleteObject(sqlcipher3*,Vdbe*);
8588 SQLCIPHER_PRIVATE void sqlcipher3VdbeMakeReady(Vdbe*,Parse*);
8589 SQLCIPHER_PRIVATE int sqlcipher3VdbeFinalize(Vdbe*);
8590 SQLCIPHER_PRIVATE void sqlcipher3VdbeResolveLabel(Vdbe*, int);
8591 SQLCIPHER_PRIVATE int sqlcipher3VdbeCurrentAddr(Vdbe*);
8592 #ifdef SQLCIPHER_DEBUG
8593 SQLCIPHER_PRIVATE   int sqlcipher3VdbeAssertMayAbort(Vdbe *, int);
8594 SQLCIPHER_PRIVATE   void sqlcipher3VdbeTrace(Vdbe*,FILE*);
8595 #endif
8596 SQLCIPHER_PRIVATE void sqlcipher3VdbeResetStepResult(Vdbe*);
8597 SQLCIPHER_PRIVATE void sqlcipher3VdbeRewind(Vdbe*);
8598 SQLCIPHER_PRIVATE int sqlcipher3VdbeReset(Vdbe*);
8599 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetNumCols(Vdbe*,int);
8600 SQLCIPHER_PRIVATE int sqlcipher3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
8601 SQLCIPHER_PRIVATE void sqlcipher3VdbeCountChanges(Vdbe*);
8602 SQLCIPHER_PRIVATE sqlcipher3 *sqlcipher3VdbeDb(Vdbe*);
8603 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetSql(Vdbe*, const char *z, int n, int);
8604 SQLCIPHER_PRIVATE void sqlcipher3VdbeSwap(Vdbe*,Vdbe*);
8605 SQLCIPHER_PRIVATE VdbeOp *sqlcipher3VdbeTakeOpArray(Vdbe*, int*, int*);
8606 SQLCIPHER_PRIVATE sqlcipher3_value *sqlcipher3VdbeGetValue(Vdbe*, int, u8);
8607 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetVarmask(Vdbe*, int);
8608 #ifndef SQLCIPHER_OMIT_TRACE
8609 SQLCIPHER_PRIVATE   char *sqlcipher3VdbeExpandSql(Vdbe*, const char*);
8610 #endif
8611
8612 SQLCIPHER_PRIVATE void sqlcipher3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*);
8613 SQLCIPHER_PRIVATE int sqlcipher3VdbeRecordCompare(int,const void*,UnpackedRecord*);
8614 SQLCIPHER_PRIVATE UnpackedRecord *sqlcipher3VdbeAllocUnpackedRecord(KeyInfo *, char *, int, char **);
8615
8616 #ifndef SQLCIPHER_OMIT_TRIGGER
8617 SQLCIPHER_PRIVATE void sqlcipher3VdbeLinkSubProgram(Vdbe *, SubProgram *);
8618 #endif
8619
8620
8621 #ifndef NDEBUG
8622 SQLCIPHER_PRIVATE   void sqlcipher3VdbeComment(Vdbe*, const char*, ...);
8623 # define VdbeComment(X)  sqlcipher3VdbeComment X
8624 SQLCIPHER_PRIVATE   void sqlcipher3VdbeNoopComment(Vdbe*, const char*, ...);
8625 # define VdbeNoopComment(X)  sqlcipher3VdbeNoopComment X
8626 #else
8627 # define VdbeComment(X)
8628 # define VdbeNoopComment(X)
8629 #endif
8630
8631 #endif
8632
8633 /************** End of vdbe.h ************************************************/
8634 /************** Continuing where we left off in sqlcipherInt.h ******************/
8635 /************** Include pager.h in the middle of sqlcipherInt.h *****************/
8636 /************** Begin file pager.h *******************************************/
8637 /*
8638 ** 2001 September 15
8639 **
8640 ** The author disclaims copyright to this source code.  In place of
8641 ** a legal notice, here is a blessing:
8642 **
8643 **    May you do good and not evil.
8644 **    May you find forgiveness for yourself and forgive others.
8645 **    May you share freely, never taking more than you give.
8646 **
8647 *************************************************************************
8648 ** This header file defines the interface that the sqlcipher page cache
8649 ** subsystem.  The page cache subsystem reads and writes a file a page
8650 ** at a time and provides a journal for rollback.
8651 */
8652
8653 #ifndef _PAGER_H_
8654 #define _PAGER_H_
8655
8656 /*
8657 ** Default maximum size for persistent journal files. A negative 
8658 ** value means no limit. This value may be overridden using the 
8659 ** sqlcipher3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit".
8660 */
8661 #ifndef SQLCIPHER_DEFAULT_JOURNAL_SIZE_LIMIT
8662   #define SQLCIPHER_DEFAULT_JOURNAL_SIZE_LIMIT -1
8663 #endif
8664
8665 /*
8666 ** The type used to represent a page number.  The first page in a file
8667 ** is called page 1.  0 is used to represent "not a page".
8668 */
8669 typedef u32 Pgno;
8670
8671 /*
8672 ** Each open file is managed by a separate instance of the "Pager" structure.
8673 */
8674 typedef struct Pager Pager;
8675
8676 /*
8677 ** Handle type for pages.
8678 */
8679 typedef struct PgHdr DbPage;
8680
8681 /*
8682 ** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
8683 ** reserved for working around a windows/posix incompatibility). It is
8684 ** used in the journal to signify that the remainder of the journal file 
8685 ** is devoted to storing a master journal name - there are no more pages to
8686 ** roll back. See comments for function writeMasterJournal() in pager.c 
8687 ** for details.
8688 */
8689 #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
8690
8691 /*
8692 ** Allowed values for the flags parameter to sqlcipher3PagerOpen().
8693 **
8694 ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
8695 */
8696 #define PAGER_OMIT_JOURNAL  0x0001    /* Do not use a rollback journal */
8697 #define PAGER_NO_READLOCK   0x0002    /* Omit readlocks on readonly files */
8698 #define PAGER_MEMORY        0x0004    /* In-memory database */
8699
8700 /*
8701 ** Valid values for the second argument to sqlcipher3PagerLockingMode().
8702 */
8703 #define PAGER_LOCKINGMODE_QUERY      -1
8704 #define PAGER_LOCKINGMODE_NORMAL      0
8705 #define PAGER_LOCKINGMODE_EXCLUSIVE   1
8706
8707 /*
8708 ** Numeric constants that encode the journalmode.  
8709 */
8710 #define PAGER_JOURNALMODE_QUERY     (-1)  /* Query the value of journalmode */
8711 #define PAGER_JOURNALMODE_DELETE      0   /* Commit by deleting journal file */
8712 #define PAGER_JOURNALMODE_PERSIST     1   /* Commit by zeroing journal header */
8713 #define PAGER_JOURNALMODE_OFF         2   /* Journal omitted.  */
8714 #define PAGER_JOURNALMODE_TRUNCATE    3   /* Commit by truncating journal */
8715 #define PAGER_JOURNALMODE_MEMORY      4   /* In-memory journal file */
8716 #define PAGER_JOURNALMODE_WAL         5   /* Use write-ahead logging */
8717
8718 /*
8719 ** The remainder of this file contains the declarations of the functions
8720 ** that make up the Pager sub-system API. See source code comments for 
8721 ** a detailed description of each routine.
8722 */
8723
8724 /* Open and close a Pager connection. */ 
8725 SQLCIPHER_PRIVATE int sqlcipher3PagerOpen(
8726   sqlcipher3_vfs*,
8727   Pager **ppPager,
8728   const char*,
8729   int,
8730   int,
8731   int,
8732   void(*)(DbPage*)
8733 );
8734 SQLCIPHER_PRIVATE int sqlcipher3PagerClose(Pager *pPager);
8735 SQLCIPHER_PRIVATE int sqlcipher3PagerReadFileheader(Pager*, int, unsigned char*);
8736
8737 /* Functions used to configure a Pager object. */
8738 SQLCIPHER_PRIVATE void sqlcipher3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
8739 SQLCIPHER_PRIVATE int sqlcipher3PagerSetPagesize(Pager*, u32*, int);
8740 SQLCIPHER_PRIVATE int sqlcipher3PagerMaxPageCount(Pager*, int);
8741 SQLCIPHER_PRIVATE void sqlcipher3PagerSetCachesize(Pager*, int);
8742 SQLCIPHER_PRIVATE void sqlcipher3PagerSetSafetyLevel(Pager*,int,int,int);
8743 SQLCIPHER_PRIVATE int sqlcipher3PagerLockingMode(Pager *, int);
8744 SQLCIPHER_PRIVATE int sqlcipher3PagerSetJournalMode(Pager *, int);
8745 SQLCIPHER_PRIVATE int sqlcipher3PagerGetJournalMode(Pager*);
8746 SQLCIPHER_PRIVATE int sqlcipher3PagerOkToChangeJournalMode(Pager*);
8747 SQLCIPHER_PRIVATE i64 sqlcipher3PagerJournalSizeLimit(Pager *, i64);
8748 SQLCIPHER_PRIVATE sqlcipher3_backup **sqlcipher3PagerBackupPtr(Pager*);
8749
8750 /* Functions used to obtain and release page references. */ 
8751 SQLCIPHER_PRIVATE int sqlcipher3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
8752 #define sqlcipher3PagerGet(A,B,C) sqlcipher3PagerAcquire(A,B,C,0)
8753 SQLCIPHER_PRIVATE DbPage *sqlcipher3PagerLookup(Pager *pPager, Pgno pgno);
8754 SQLCIPHER_PRIVATE void sqlcipher3PagerRef(DbPage*);
8755 SQLCIPHER_PRIVATE void sqlcipher3PagerUnref(DbPage*);
8756
8757 /* Operations on page references. */
8758 SQLCIPHER_PRIVATE int sqlcipher3PagerWrite(DbPage*);
8759 SQLCIPHER_PRIVATE void sqlcipher3PagerDontWrite(DbPage*);
8760 SQLCIPHER_PRIVATE int sqlcipher3PagerMovepage(Pager*,DbPage*,Pgno,int);
8761 SQLCIPHER_PRIVATE int sqlcipher3PagerPageRefcount(DbPage*);
8762 SQLCIPHER_PRIVATE void *sqlcipher3PagerGetData(DbPage *); 
8763 SQLCIPHER_PRIVATE void *sqlcipher3PagerGetExtra(DbPage *); 
8764
8765 /* Functions used to manage pager transactions and savepoints. */
8766 SQLCIPHER_PRIVATE void sqlcipher3PagerPagecount(Pager*, int*);
8767 SQLCIPHER_PRIVATE int sqlcipher3PagerBegin(Pager*, int exFlag, int);
8768 SQLCIPHER_PRIVATE int sqlcipher3PagerCommitPhaseOne(Pager*,const char *zMaster, int);
8769 SQLCIPHER_PRIVATE int sqlcipher3PagerExclusiveLock(Pager*);
8770 SQLCIPHER_PRIVATE int sqlcipher3PagerSync(Pager *pPager);
8771 SQLCIPHER_PRIVATE int sqlcipher3PagerCommitPhaseTwo(Pager*);
8772 SQLCIPHER_PRIVATE int sqlcipher3PagerRollback(Pager*);
8773 SQLCIPHER_PRIVATE int sqlcipher3PagerOpenSavepoint(Pager *pPager, int n);
8774 SQLCIPHER_PRIVATE int sqlcipher3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
8775 SQLCIPHER_PRIVATE int sqlcipher3PagerSharedLock(Pager *pPager);
8776
8777 SQLCIPHER_PRIVATE int sqlcipher3PagerCheckpoint(Pager *pPager, int, int*, int*);
8778 SQLCIPHER_PRIVATE int sqlcipher3PagerWalSupported(Pager *pPager);
8779 SQLCIPHER_PRIVATE int sqlcipher3PagerWalCallback(Pager *pPager);
8780 SQLCIPHER_PRIVATE int sqlcipher3PagerOpenWal(Pager *pPager, int *pisOpen);
8781 SQLCIPHER_PRIVATE int sqlcipher3PagerCloseWal(Pager *pPager);
8782
8783 /* Functions used to query pager state and configuration. */
8784 SQLCIPHER_PRIVATE u8 sqlcipher3PagerIsreadonly(Pager*);
8785 SQLCIPHER_PRIVATE int sqlcipher3PagerRefcount(Pager*);
8786 SQLCIPHER_PRIVATE int sqlcipher3PagerMemUsed(Pager*);
8787 SQLCIPHER_PRIVATE const char *sqlcipher3PagerFilename(Pager*);
8788 SQLCIPHER_PRIVATE const sqlcipher3_vfs *sqlcipher3PagerVfs(Pager*);
8789 SQLCIPHER_PRIVATE sqlcipher3_file *sqlcipher3PagerFile(Pager*);
8790 SQLCIPHER_PRIVATE const char *sqlcipher3PagerJournalname(Pager*);
8791 SQLCIPHER_PRIVATE int sqlcipher3PagerNosync(Pager*);
8792 SQLCIPHER_PRIVATE void *sqlcipher3PagerTempSpace(Pager*);
8793 SQLCIPHER_PRIVATE int sqlcipher3PagerIsMemdb(Pager*);
8794 SQLCIPHER_PRIVATE void sqlcipher3PagerCacheStat(Pager *, int, int, int *);
8795 SQLCIPHER_PRIVATE void sqlcipher3PagerClearCache(Pager *);
8796
8797 /* Functions used to truncate the database file. */
8798 SQLCIPHER_PRIVATE void sqlcipher3PagerTruncateImage(Pager*,Pgno);
8799
8800 #if defined(SQLCIPHER_HAS_CODEC) && !defined(SQLCIPHER_OMIT_WAL)
8801 SQLCIPHER_PRIVATE void *sqlcipher3PagerCodec(DbPage *);
8802 #endif
8803
8804 /* Functions to support testing and debugging. */
8805 #if !defined(NDEBUG) || defined(SQLCIPHER_TEST)
8806 SQLCIPHER_PRIVATE   Pgno sqlcipher3PagerPagenumber(DbPage*);
8807 SQLCIPHER_PRIVATE   int sqlcipher3PagerIswriteable(DbPage*);
8808 #endif
8809 #ifdef SQLCIPHER_TEST
8810 SQLCIPHER_PRIVATE   int *sqlcipher3PagerStats(Pager*);
8811 SQLCIPHER_PRIVATE   void sqlcipher3PagerRefdump(Pager*);
8812   void disable_simulated_io_errors(void);
8813   void enable_simulated_io_errors(void);
8814 #else
8815 # define disable_simulated_io_errors()
8816 # define enable_simulated_io_errors()
8817 #endif
8818
8819 #endif /* _PAGER_H_ */
8820
8821 /************** End of pager.h ***********************************************/
8822 /************** Continuing where we left off in sqlcipherInt.h ******************/
8823 /************** Include pcache.h in the middle of sqlcipherInt.h ****************/
8824 /************** Begin file pcache.h ******************************************/
8825 /*
8826 ** 2008 August 05
8827 **
8828 ** The author disclaims copyright to this source code.  In place of
8829 ** a legal notice, here is a blessing:
8830 **
8831 **    May you do good and not evil.
8832 **    May you find forgiveness for yourself and forgive others.
8833 **    May you share freely, never taking more than you give.
8834 **
8835 *************************************************************************
8836 ** This header file defines the interface that the sqlcipher page cache
8837 ** subsystem. 
8838 */
8839
8840 #ifndef _PCACHE_H_
8841
8842 typedef struct PgHdr PgHdr;
8843 typedef struct PCache PCache;
8844
8845 /*
8846 ** Every page in the cache is controlled by an instance of the following
8847 ** structure.
8848 */
8849 struct PgHdr {
8850   void *pData;                   /* Content of this page */
8851   void *pExtra;                  /* Extra content */
8852   PgHdr *pDirty;                 /* Transient list of dirty pages */
8853   Pgno pgno;                     /* Page number for this page */
8854   Pager *pPager;                 /* The pager this page is part of */
8855 #ifdef SQLCIPHER_CHECK_PAGES
8856   u32 pageHash;                  /* Hash of page content */
8857 #endif
8858   u16 flags;                     /* PGHDR flags defined below */
8859
8860   /**********************************************************************
8861   ** Elements above are public.  All that follows is private to pcache.c
8862   ** and should not be accessed by other modules.
8863   */
8864   i16 nRef;                      /* Number of users of this page */
8865   PCache *pCache;                /* Cache that owns this page */
8866
8867   PgHdr *pDirtyNext;             /* Next element in list of dirty pages */
8868   PgHdr *pDirtyPrev;             /* Previous element in list of dirty pages */
8869 };
8870
8871 /* Bit values for PgHdr.flags */
8872 #define PGHDR_DIRTY             0x002  /* Page has changed */
8873 #define PGHDR_NEED_SYNC         0x004  /* Fsync the rollback journal before
8874                                        ** writing this page to the database */
8875 #define PGHDR_NEED_READ         0x008  /* Content is unread */
8876 #define PGHDR_REUSE_UNLIKELY    0x010  /* A hint that reuse is unlikely */
8877 #define PGHDR_DONT_WRITE        0x020  /* Do not write content to disk */
8878
8879 /* Initialize and shutdown the page cache subsystem */
8880 SQLCIPHER_PRIVATE int sqlcipher3PcacheInitialize(void);
8881 SQLCIPHER_PRIVATE void sqlcipher3PcacheShutdown(void);
8882
8883 /* Page cache buffer management:
8884 ** These routines implement SQLCIPHER_CONFIG_PAGECACHE.
8885 */
8886 SQLCIPHER_PRIVATE void sqlcipher3PCacheBufferSetup(void *, int sz, int n);
8887
8888 /* Create a new pager cache.
8889 ** Under memory stress, invoke xStress to try to make pages clean.
8890 ** Only clean and unpinned pages can be reclaimed.
8891 */
8892 SQLCIPHER_PRIVATE void sqlcipher3PcacheOpen(
8893   int szPage,                    /* Size of every page */
8894   int szExtra,                   /* Extra space associated with each page */
8895   int bPurgeable,                /* True if pages are on backing store */
8896   int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
8897   void *pStress,                 /* Argument to xStress */
8898   PCache *pToInit                /* Preallocated space for the PCache */
8899 );
8900
8901 /* Modify the page-size after the cache has been created. */
8902 SQLCIPHER_PRIVATE void sqlcipher3PcacheSetPageSize(PCache *, int);
8903
8904 /* Return the size in bytes of a PCache object.  Used to preallocate
8905 ** storage space.
8906 */
8907 SQLCIPHER_PRIVATE int sqlcipher3PcacheSize(void);
8908
8909 /* One release per successful fetch.  Page is pinned until released.
8910 ** Reference counted. 
8911 */
8912 SQLCIPHER_PRIVATE int sqlcipher3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
8913 SQLCIPHER_PRIVATE void sqlcipher3PcacheRelease(PgHdr*);
8914
8915 SQLCIPHER_PRIVATE void sqlcipher3PcacheDrop(PgHdr*);         /* Remove page from cache */
8916 SQLCIPHER_PRIVATE void sqlcipher3PcacheMakeDirty(PgHdr*);    /* Make sure page is marked dirty */
8917 SQLCIPHER_PRIVATE void sqlcipher3PcacheMakeClean(PgHdr*);    /* Mark a single page as clean */
8918 SQLCIPHER_PRIVATE void sqlcipher3PcacheCleanAll(PCache*);    /* Mark all dirty list pages as clean */
8919
8920 /* Change a page number.  Used by incr-vacuum. */
8921 SQLCIPHER_PRIVATE void sqlcipher3PcacheMove(PgHdr*, Pgno);
8922
8923 /* Remove all pages with pgno>x.  Reset the cache if x==0 */
8924 SQLCIPHER_PRIVATE void sqlcipher3PcacheTruncate(PCache*, Pgno x);
8925
8926 /* Get a list of all dirty pages in the cache, sorted by page number */
8927 SQLCIPHER_PRIVATE PgHdr *sqlcipher3PcacheDirtyList(PCache*);
8928
8929 /* Reset and close the cache object */
8930 SQLCIPHER_PRIVATE void sqlcipher3PcacheClose(PCache*);
8931
8932 /* Clear flags from pages of the page cache */
8933 SQLCIPHER_PRIVATE void sqlcipher3PcacheClearSyncFlags(PCache *);
8934
8935 /* Discard the contents of the cache */
8936 SQLCIPHER_PRIVATE void sqlcipher3PcacheClear(PCache*);
8937
8938 /* Return the total number of outstanding page references */
8939 SQLCIPHER_PRIVATE int sqlcipher3PcacheRefCount(PCache*);
8940
8941 /* Increment the reference count of an existing page */
8942 SQLCIPHER_PRIVATE void sqlcipher3PcacheRef(PgHdr*);
8943
8944 SQLCIPHER_PRIVATE int sqlcipher3PcachePageRefcount(PgHdr*);
8945
8946 /* Return the total number of pages stored in the cache */
8947 SQLCIPHER_PRIVATE int sqlcipher3PcachePagecount(PCache*);
8948
8949 #if defined(SQLCIPHER_CHECK_PAGES) || defined(SQLCIPHER_DEBUG)
8950 /* Iterate through all dirty pages currently stored in the cache. This
8951 ** interface is only available if SQLCIPHER_CHECK_PAGES is defined when the 
8952 ** library is built.
8953 */
8954 SQLCIPHER_PRIVATE void sqlcipher3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
8955 #endif
8956
8957 /* Set and get the suggested cache-size for the specified pager-cache.
8958 **
8959 ** If no global maximum is configured, then the system attempts to limit
8960 ** the total number of pages cached by purgeable pager-caches to the sum
8961 ** of the suggested cache-sizes.
8962 */
8963 SQLCIPHER_PRIVATE void sqlcipher3PcacheSetCachesize(PCache *, int);
8964 #ifdef SQLCIPHER_TEST
8965 SQLCIPHER_PRIVATE int sqlcipher3PcacheGetCachesize(PCache *);
8966 #endif
8967
8968 #ifdef SQLCIPHER_ENABLE_MEMORY_MANAGEMENT
8969 /* Try to return memory used by the pcache module to the main memory heap */
8970 SQLCIPHER_PRIVATE int sqlcipher3PcacheReleaseMemory(int);
8971 #endif
8972
8973 #ifdef SQLCIPHER_TEST
8974 SQLCIPHER_PRIVATE void sqlcipher3PcacheStats(int*,int*,int*,int*);
8975 #endif
8976
8977 SQLCIPHER_PRIVATE void sqlcipher3PCacheSetDefault(void);
8978
8979 #endif /* _PCACHE_H_ */
8980
8981 /************** End of pcache.h **********************************************/
8982 /************** Continuing where we left off in sqlcipherInt.h ******************/
8983
8984 /************** Include os.h in the middle of sqlcipherInt.h ********************/
8985 /************** Begin file os.h **********************************************/
8986 /*
8987 ** 2001 September 16
8988 **
8989 ** The author disclaims copyright to this source code.  In place of
8990 ** a legal notice, here is a blessing:
8991 **
8992 **    May you do good and not evil.
8993 **    May you find forgiveness for yourself and forgive others.
8994 **    May you share freely, never taking more than you give.
8995 **
8996 ******************************************************************************
8997 **
8998 ** This header file (together with is companion C source-code file
8999 ** "os.c") attempt to abstract the underlying operating system so that
9000 ** the SQLite library will work on both POSIX and windows systems.
9001 **
9002 ** This header file is #include-ed by sqlcipherInt.h and thus ends up
9003 ** being included by every source file.
9004 */
9005 #ifndef _SQLCIPHER_OS_H_
9006 #define _SQLCIPHER_OS_H_
9007
9008 /*
9009 ** Figure out if we are dealing with Unix, Windows, or some other
9010 ** operating system.  After the following block of preprocess macros,
9011 ** all of SQLCIPHER_OS_UNIX, SQLCIPHER_OS_WIN, SQLCIPHER_OS_OS2, and SQLCIPHER_OS_OTHER 
9012 ** will defined to either 1 or 0.  One of the four will be 1.  The other 
9013 ** three will be 0.
9014 */
9015 #if defined(SQLCIPHER_OS_OTHER)
9016 # if SQLCIPHER_OS_OTHER==1
9017 #   undef SQLCIPHER_OS_UNIX
9018 #   define SQLCIPHER_OS_UNIX 0
9019 #   undef SQLCIPHER_OS_WIN
9020 #   define SQLCIPHER_OS_WIN 0
9021 #   undef SQLCIPHER_OS_OS2
9022 #   define SQLCIPHER_OS_OS2 0
9023 # else
9024 #   undef SQLCIPHER_OS_OTHER
9025 # endif
9026 #endif
9027 #if !defined(SQLCIPHER_OS_UNIX) && !defined(SQLCIPHER_OS_OTHER)
9028 # define SQLCIPHER_OS_OTHER 0
9029 # ifndef SQLCIPHER_OS_WIN
9030 #   if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
9031 #     define SQLCIPHER_OS_WIN 1
9032 #     define SQLCIPHER_OS_UNIX 0
9033 #     define SQLCIPHER_OS_OS2 0
9034 #   elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__)
9035 #     define SQLCIPHER_OS_WIN 0
9036 #     define SQLCIPHER_OS_UNIX 0
9037 #     define SQLCIPHER_OS_OS2 1
9038 #   else
9039 #     define SQLCIPHER_OS_WIN 0
9040 #     define SQLCIPHER_OS_UNIX 1
9041 #     define SQLCIPHER_OS_OS2 0
9042 #  endif
9043 # else
9044 #  define SQLCIPHER_OS_UNIX 0
9045 #  define SQLCIPHER_OS_OS2 0
9046 # endif
9047 #else
9048 # ifndef SQLCIPHER_OS_WIN
9049 #  define SQLCIPHER_OS_WIN 0
9050 # endif
9051 #endif
9052
9053 /*
9054 ** Determine if we are dealing with WindowsCE - which has a much
9055 ** reduced API.
9056 */
9057 #if defined(_WIN32_WCE)
9058 # define SQLCIPHER_OS_WINCE 1
9059 #else
9060 # define SQLCIPHER_OS_WINCE 0
9061 #endif
9062
9063
9064 /*
9065 ** Define the maximum size of a temporary filename
9066 */
9067 #if SQLCIPHER_OS_WIN
9068 # include <windows.h>
9069 # define SQLCIPHER_TEMPNAME_SIZE (MAX_PATH+50)
9070 #elif SQLCIPHER_OS_OS2
9071 # if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY)
9072 #  include <os2safe.h> /* has to be included before os2.h for linking to work */
9073 # endif
9074 # define INCL_DOSDATETIME
9075 # define INCL_DOSFILEMGR
9076 # define INCL_DOSERRORS
9077 # define INCL_DOSMISC
9078 # define INCL_DOSPROCESS
9079 # define INCL_DOSMODULEMGR
9080 # define INCL_DOSSEMAPHORES
9081 # include <os2.h>
9082 # include <uconv.h>
9083 # define SQLCIPHER_TEMPNAME_SIZE (CCHMAXPATHCOMP)
9084 #else
9085 # define SQLCIPHER_TEMPNAME_SIZE 200
9086 #endif
9087
9088 /* If the SET_FULLSYNC macro is not defined above, then make it
9089 ** a no-op
9090 */
9091 #ifndef SET_FULLSYNC
9092 # define SET_FULLSYNC(x,y)
9093 #endif
9094
9095 /*
9096 ** The default size of a disk sector
9097 */
9098 #ifndef SQLCIPHER_DEFAULT_SECTOR_SIZE
9099 # define SQLCIPHER_DEFAULT_SECTOR_SIZE 512
9100 #endif
9101
9102 /*
9103 ** Temporary files are named starting with this prefix followed by 16 random
9104 ** alphanumeric characters, and no file extension. They are stored in the
9105 ** OS's standard temporary file directory, and are deleted prior to exit.
9106 ** If sqlcipher is being embedded in another program, you may wish to change the
9107 ** prefix to reflect your program's name, so that if your program exits
9108 ** prematurely, old temporary files can be easily identified. This can be done
9109 ** using -DSQLCIPHER_TEMP_FILE_PREFIX=myprefix_ on the compiler command line.
9110 **
9111 ** 2006-10-31:  The default prefix used to be "sqlcipher_".  But then
9112 ** Mcafee started using SQLite in their anti-virus product and it
9113 ** started putting files with the "sqlcipher" name in the c:/temp folder.
9114 ** This annoyed many windows users.  Those users would then do a 
9115 ** Google search for "sqlcipher", find the telephone numbers of the
9116 ** developers and call to wake them up at night and complain.
9117 ** For this reason, the default name prefix is changed to be "sqlcipher" 
9118 ** spelled backwards.  So the temp files are still identified, but
9119 ** anybody smart enough to figure out the code is also likely smart
9120 ** enough to know that calling the developer will not help get rid
9121 ** of the file.
9122 */
9123 #ifndef SQLCIPHER_TEMP_FILE_PREFIX
9124 # define SQLCIPHER_TEMP_FILE_PREFIX "etilqs_"
9125 #endif
9126
9127 /*
9128 ** The following values may be passed as the second argument to
9129 ** sqlcipher3OsLock(). The various locks exhibit the following semantics:
9130 **
9131 ** SHARED:    Any number of processes may hold a SHARED lock simultaneously.
9132 ** RESERVED:  A single process may hold a RESERVED lock on a file at
9133 **            any time. Other processes may hold and obtain new SHARED locks.
9134 ** PENDING:   A single process may hold a PENDING lock on a file at
9135 **            any one time. Existing SHARED locks may persist, but no new
9136 **            SHARED locks may be obtained by other processes.
9137 ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
9138 **
9139 ** PENDING_LOCK may not be passed directly to sqlcipher3OsLock(). Instead, a
9140 ** process that requests an EXCLUSIVE lock may actually obtain a PENDING
9141 ** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to
9142 ** sqlcipher3OsLock().
9143 */
9144 #define NO_LOCK         0
9145 #define SHARED_LOCK     1
9146 #define RESERVED_LOCK   2
9147 #define PENDING_LOCK    3
9148 #define EXCLUSIVE_LOCK  4
9149
9150 /*
9151 ** File Locking Notes:  (Mostly about windows but also some info for Unix)
9152 **
9153 ** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
9154 ** those functions are not available.  So we use only LockFile() and
9155 ** UnlockFile().
9156 **
9157 ** LockFile() prevents not just writing but also reading by other processes.
9158 ** A SHARED_LOCK is obtained by locking a single randomly-chosen 
9159 ** byte out of a specific range of bytes. The lock byte is obtained at 
9160 ** random so two separate readers can probably access the file at the 
9161 ** same time, unless they are unlucky and choose the same lock byte.
9162 ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
9163 ** There can only be one writer.  A RESERVED_LOCK is obtained by locking
9164 ** a single byte of the file that is designated as the reserved lock byte.
9165 ** A PENDING_LOCK is obtained by locking a designated byte different from
9166 ** the RESERVED_LOCK byte.
9167 **
9168 ** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available,
9169 ** which means we can use reader/writer locks.  When reader/writer locks
9170 ** are used, the lock is placed on the same range of bytes that is used
9171 ** for probabilistic locking in Win95/98/ME.  Hence, the locking scheme
9172 ** will support two or more Win95 readers or two or more WinNT readers.
9173 ** But a single Win95 reader will lock out all WinNT readers and a single
9174 ** WinNT reader will lock out all other Win95 readers.
9175 **
9176 ** The following #defines specify the range of bytes used for locking.
9177 ** SHARED_SIZE is the number of bytes available in the pool from which
9178 ** a random byte is selected for a shared lock.  The pool of bytes for
9179 ** shared locks begins at SHARED_FIRST. 
9180 **
9181 ** The same locking strategy and
9182 ** byte ranges are used for Unix.  This leaves open the possiblity of having
9183 ** clients on win95, winNT, and unix all talking to the same shared file
9184 ** and all locking correctly.  To do so would require that samba (or whatever
9185 ** tool is being used for file sharing) implements locks correctly between
9186 ** windows and unix.  I'm guessing that isn't likely to happen, but by
9187 ** using the same locking range we are at least open to the possibility.
9188 **
9189 ** Locking in windows is manditory.  For this reason, we cannot store
9190 ** actual data in the bytes used for locking.  The pager never allocates
9191 ** the pages involved in locking therefore.  SHARED_SIZE is selected so
9192 ** that all locks will fit on a single page even at the minimum page size.
9193 ** PENDING_BYTE defines the beginning of the locks.  By default PENDING_BYTE
9194 ** is set high so that we don't have to allocate an unused page except
9195 ** for very large databases.  But one should test the page skipping logic 
9196 ** by setting PENDING_BYTE low and running the entire regression suite.
9197 **
9198 ** Changing the value of PENDING_BYTE results in a subtly incompatible
9199 ** file format.  Depending on how it is changed, you might not notice
9200 ** the incompatibility right away, even running a full regression test.
9201 ** The default location of PENDING_BYTE is the first byte past the
9202 ** 1GB boundary.
9203 **
9204 */
9205 #ifdef SQLCIPHER_OMIT_WSD
9206 # define PENDING_BYTE     (0x40000000)
9207 #else
9208 # define PENDING_BYTE      sqlcipher3PendingByte
9209 #endif
9210 #define RESERVED_BYTE     (PENDING_BYTE+1)
9211 #define SHARED_FIRST      (PENDING_BYTE+2)
9212 #define SHARED_SIZE       510
9213
9214 /*
9215 ** Wrapper around OS specific sqlcipher3_os_init() function.
9216 */
9217 SQLCIPHER_PRIVATE int sqlcipher3OsInit(void);
9218
9219 /* 
9220 ** Functions for accessing sqlcipher3_file methods 
9221 */
9222 SQLCIPHER_PRIVATE int sqlcipher3OsClose(sqlcipher3_file*);
9223 SQLCIPHER_PRIVATE int sqlcipher3OsRead(sqlcipher3_file*, void*, int amt, i64 offset);
9224 SQLCIPHER_PRIVATE int sqlcipher3OsWrite(sqlcipher3_file*, const void*, int amt, i64 offset);
9225 SQLCIPHER_PRIVATE int sqlcipher3OsTruncate(sqlcipher3_file*, i64 size);
9226 SQLCIPHER_PRIVATE int sqlcipher3OsSync(sqlcipher3_file*, int);
9227 SQLCIPHER_PRIVATE int sqlcipher3OsFileSize(sqlcipher3_file*, i64 *pSize);
9228 SQLCIPHER_PRIVATE int sqlcipher3OsLock(sqlcipher3_file*, int);
9229 SQLCIPHER_PRIVATE int sqlcipher3OsUnlock(sqlcipher3_file*, int);
9230 SQLCIPHER_PRIVATE int sqlcipher3OsCheckReservedLock(sqlcipher3_file *id, int *pResOut);
9231 SQLCIPHER_PRIVATE int sqlcipher3OsFileControl(sqlcipher3_file*,int,void*);
9232 #define SQLCIPHER_FCNTL_DB_UNCHANGED 0xca093fa0
9233 SQLCIPHER_PRIVATE int sqlcipher3OsSectorSize(sqlcipher3_file *id);
9234 SQLCIPHER_PRIVATE int sqlcipher3OsDeviceCharacteristics(sqlcipher3_file *id);
9235 SQLCIPHER_PRIVATE int sqlcipher3OsShmMap(sqlcipher3_file *,int,int,int,void volatile **);
9236 SQLCIPHER_PRIVATE int sqlcipher3OsShmLock(sqlcipher3_file *id, int, int, int);
9237 SQLCIPHER_PRIVATE void sqlcipher3OsShmBarrier(sqlcipher3_file *id);
9238 SQLCIPHER_PRIVATE int sqlcipher3OsShmUnmap(sqlcipher3_file *id, int);
9239
9240 /* 
9241 ** Functions for accessing sqlcipher3_vfs methods 
9242 */
9243 SQLCIPHER_PRIVATE int sqlcipher3OsOpen(sqlcipher3_vfs *, const char *, sqlcipher3_file*, int, int *);
9244 SQLCIPHER_PRIVATE int sqlcipher3OsDelete(sqlcipher3_vfs *, const char *, int);
9245 SQLCIPHER_PRIVATE int sqlcipher3OsAccess(sqlcipher3_vfs *, const char *, int, int *pResOut);
9246 SQLCIPHER_PRIVATE int sqlcipher3OsFullPathname(sqlcipher3_vfs *, const char *, int, char *);
9247 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
9248 SQLCIPHER_PRIVATE void *sqlcipher3OsDlOpen(sqlcipher3_vfs *, const char *);
9249 SQLCIPHER_PRIVATE void sqlcipher3OsDlError(sqlcipher3_vfs *, int, char *);
9250 SQLCIPHER_PRIVATE void (*sqlcipher3OsDlSym(sqlcipher3_vfs *, void *, const char *))(void);
9251 SQLCIPHER_PRIVATE void sqlcipher3OsDlClose(sqlcipher3_vfs *, void *);
9252 #endif /* SQLCIPHER_OMIT_LOAD_EXTENSION */
9253 SQLCIPHER_PRIVATE int sqlcipher3OsRandomness(sqlcipher3_vfs *, int, char *);
9254 SQLCIPHER_PRIVATE int sqlcipher3OsSleep(sqlcipher3_vfs *, int);
9255 SQLCIPHER_PRIVATE int sqlcipher3OsCurrentTimeInt64(sqlcipher3_vfs *, sqlcipher3_int64*);
9256
9257 /*
9258 ** Convenience functions for opening and closing files using 
9259 ** sqlcipher3_malloc() to obtain space for the file-handle structure.
9260 */
9261 SQLCIPHER_PRIVATE int sqlcipher3OsOpenMalloc(sqlcipher3_vfs *, const char *, sqlcipher3_file **, int,int*);
9262 SQLCIPHER_PRIVATE int sqlcipher3OsCloseFree(sqlcipher3_file *);
9263
9264 #endif /* _SQLCIPHER_OS_H_ */
9265
9266 /************** End of os.h **************************************************/
9267 /************** Continuing where we left off in sqlcipherInt.h ******************/
9268 /************** Include mutex.h in the middle of sqlcipherInt.h *****************/
9269 /************** Begin file mutex.h *******************************************/
9270 /*
9271 ** 2007 August 28
9272 **
9273 ** The author disclaims copyright to this source code.  In place of
9274 ** a legal notice, here is a blessing:
9275 **
9276 **    May you do good and not evil.
9277 **    May you find forgiveness for yourself and forgive others.
9278 **    May you share freely, never taking more than you give.
9279 **
9280 *************************************************************************
9281 **
9282 ** This file contains the common header for all mutex implementations.
9283 ** The sqlcipherInt.h header #includes this file so that it is available
9284 ** to all source files.  We break it out in an effort to keep the code
9285 ** better organized.
9286 **
9287 ** NOTE:  source files should *not* #include this header file directly.
9288 ** Source files should #include the sqlcipherInt.h file and let that file
9289 ** include this one indirectly.
9290 */
9291
9292
9293 /*
9294 ** Figure out what version of the code to use.  The choices are
9295 **
9296 **   SQLCIPHER_MUTEX_OMIT         No mutex logic.  Not even stubs.  The
9297 **                             mutexes implemention cannot be overridden
9298 **                             at start-time.
9299 **
9300 **   SQLCIPHER_MUTEX_NOOP         For single-threaded applications.  No
9301 **                             mutual exclusion is provided.  But this
9302 **                             implementation can be overridden at
9303 **                             start-time.
9304 **
9305 **   SQLCIPHER_MUTEX_PTHREADS     For multi-threaded applications on Unix.
9306 **
9307 **   SQLCIPHER_MUTEX_W32          For multi-threaded applications on Win32.
9308 **
9309 **   SQLCIPHER_MUTEX_OS2          For multi-threaded applications on OS/2.
9310 */
9311 #if !SQLCIPHER_THREADSAFE
9312 # define SQLCIPHER_MUTEX_OMIT
9313 #endif
9314 #if SQLCIPHER_THREADSAFE && !defined(SQLCIPHER_MUTEX_NOOP)
9315 #  if SQLCIPHER_OS_UNIX
9316 #    define SQLCIPHER_MUTEX_PTHREADS
9317 #  elif SQLCIPHER_OS_WIN
9318 #    define SQLCIPHER_MUTEX_W32
9319 #  elif SQLCIPHER_OS_OS2
9320 #    define SQLCIPHER_MUTEX_OS2
9321 #  else
9322 #    define SQLCIPHER_MUTEX_NOOP
9323 #  endif
9324 #endif
9325
9326 #ifdef SQLCIPHER_MUTEX_OMIT
9327 /*
9328 ** If this is a no-op implementation, implement everything as macros.
9329 */
9330 #define sqlcipher3_mutex_alloc(X)    ((sqlcipher3_mutex*)8)
9331 #define sqlcipher3_mutex_free(X)
9332 #define sqlcipher3_mutex_enter(X)    
9333 #define sqlcipher3_mutex_try(X)      SQLCIPHER_OK
9334 #define sqlcipher3_mutex_leave(X)    
9335 #define sqlcipher3_mutex_held(X)     ((void)(X),1)
9336 #define sqlcipher3_mutex_notheld(X)  ((void)(X),1)
9337 #define sqlcipher3MutexAlloc(X)      ((sqlcipher3_mutex*)8)
9338 #define sqlcipher3MutexInit()        SQLCIPHER_OK
9339 #define sqlcipher3MutexEnd()
9340 #define MUTEX_LOGIC(X)
9341 #else
9342 #define MUTEX_LOGIC(X)            X
9343 #endif /* defined(SQLCIPHER_MUTEX_OMIT) */
9344
9345 /************** End of mutex.h ***********************************************/
9346 /************** Continuing where we left off in sqlcipherInt.h ******************/
9347
9348
9349 /*
9350 ** Each database file to be accessed by the system is an instance
9351 ** of the following structure.  There are normally two of these structures
9352 ** in the sqlcipher.aDb[] array.  aDb[0] is the main database file and
9353 ** aDb[1] is the database file used to hold temporary tables.  Additional
9354 ** databases may be attached.
9355 */
9356 struct Db {
9357   char *zName;         /* Name of this database */
9358   Btree *pBt;          /* The B*Tree structure for this database file */
9359   u8 inTrans;          /* 0: not writable.  1: Transaction.  2: Checkpoint */
9360   u8 safety_level;     /* How aggressive at syncing data to disk */
9361   Schema *pSchema;     /* Pointer to database schema (possibly shared) */
9362 };
9363
9364 /*
9365 ** An instance of the following structure stores a database schema.
9366 **
9367 ** Most Schema objects are associated with a Btree.  The exception is
9368 ** the Schema for the TEMP databaes (sqlcipher3.aDb[1]) which is free-standing.
9369 ** In shared cache mode, a single Schema object can be shared by multiple
9370 ** Btrees that refer to the same underlying BtShared object.
9371 ** 
9372 ** Schema objects are automatically deallocated when the last Btree that
9373 ** references them is destroyed.   The TEMP Schema is manually freed by
9374 ** sqlcipher3_close().
9375 *
9376 ** A thread must be holding a mutex on the corresponding Btree in order
9377 ** to access Schema content.  This implies that the thread must also be
9378 ** holding a mutex on the sqlcipher3 connection pointer that owns the Btree.
9379 ** For a TEMP Schema, only the connection mutex is required.
9380 */
9381 struct Schema {
9382   int schema_cookie;   /* Database schema version number for this file */
9383   int iGeneration;     /* Generation counter.  Incremented with each change */
9384   Hash tblHash;        /* All tables indexed by name */
9385   Hash idxHash;        /* All (named) indices indexed by name */
9386   Hash trigHash;       /* All triggers indexed by name */
9387   Hash fkeyHash;       /* All foreign keys by referenced table name */
9388   Table *pSeqTab;      /* The sqlcipher_sequence table used by AUTOINCREMENT */
9389   u8 file_format;      /* Schema format version for this file */
9390   u8 enc;              /* Text encoding used by this database */
9391   u16 flags;           /* Flags associated with this schema */
9392   int cache_size;      /* Number of pages to use in the cache */
9393 };
9394
9395 /*
9396 ** These macros can be used to test, set, or clear bits in the 
9397 ** Db.pSchema->flags field.
9398 */
9399 #define DbHasProperty(D,I,P)     (((D)->aDb[I].pSchema->flags&(P))==(P))
9400 #define DbHasAnyProperty(D,I,P)  (((D)->aDb[I].pSchema->flags&(P))!=0)
9401 #define DbSetProperty(D,I,P)     (D)->aDb[I].pSchema->flags|=(P)
9402 #define DbClearProperty(D,I,P)   (D)->aDb[I].pSchema->flags&=~(P)
9403
9404 /*
9405 ** Allowed values for the DB.pSchema->flags field.
9406 **
9407 ** The DB_SchemaLoaded flag is set after the database schema has been
9408 ** read into internal hash tables.
9409 **
9410 ** DB_UnresetViews means that one or more views have column names that
9411 ** have been filled out.  If the schema changes, these column names might
9412 ** changes and so the view will need to be reset.
9413 */
9414 #define DB_SchemaLoaded    0x0001  /* The schema has been loaded */
9415 #define DB_UnresetViews    0x0002  /* Some views have defined column names */
9416 #define DB_Empty           0x0004  /* The file is empty (length 0 bytes) */
9417
9418 /*
9419 ** The number of different kinds of things that can be limited
9420 ** using the sqlcipher3_limit() interface.
9421 */
9422 #define SQLCIPHER_N_LIMIT (SQLCIPHER_LIMIT_TRIGGER_DEPTH+1)
9423
9424 /*
9425 ** Lookaside malloc is a set of fixed-size buffers that can be used
9426 ** to satisfy small transient memory allocation requests for objects
9427 ** associated with a particular database connection.  The use of
9428 ** lookaside malloc provides a significant performance enhancement
9429 ** (approx 10%) by avoiding numerous malloc/free requests while parsing
9430 ** SQL statements.
9431 **
9432 ** The Lookaside structure holds configuration information about the
9433 ** lookaside malloc subsystem.  Each available memory allocation in
9434 ** the lookaside subsystem is stored on a linked list of LookasideSlot
9435 ** objects.
9436 **
9437 ** Lookaside allocations are only allowed for objects that are associated
9438 ** with a particular database connection.  Hence, schema information cannot
9439 ** be stored in lookaside because in shared cache mode the schema information
9440 ** is shared by multiple database connections.  Therefore, while parsing
9441 ** schema information, the Lookaside.bEnabled flag is cleared so that
9442 ** lookaside allocations are not used to construct the schema objects.
9443 */
9444 struct Lookaside {
9445   u16 sz;                 /* Size of each buffer in bytes */
9446   u8 bEnabled;            /* False to disable new lookaside allocations */
9447   u8 bMalloced;           /* True if pStart obtained from sqlcipher3_malloc() */
9448   int nOut;               /* Number of buffers currently checked out */
9449   int mxOut;              /* Highwater mark for nOut */
9450   int anStat[3];          /* 0: hits.  1: size misses.  2: full misses */
9451   LookasideSlot *pFree;   /* List of available buffers */
9452   void *pStart;           /* First byte of available memory space */
9453   void *pEnd;             /* First byte past end of available space */
9454 };
9455 struct LookasideSlot {
9456   LookasideSlot *pNext;    /* Next buffer in the list of free buffers */
9457 };
9458
9459 /*
9460 ** A hash table for function definitions.
9461 **
9462 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
9463 ** Collisions are on the FuncDef.pHash chain.
9464 */
9465 struct FuncDefHash {
9466   FuncDef *a[23];       /* Hash table for functions */
9467 };
9468
9469 /*
9470 ** Each database connection is an instance of the following structure.
9471 **
9472 ** The sqlcipher.lastRowid records the last insert rowid generated by an
9473 ** insert statement.  Inserts on views do not affect its value.  Each
9474 ** trigger has its own context, so that lastRowid can be updated inside
9475 ** triggers as usual.  The previous value will be restored once the trigger
9476 ** exits.  Upon entering a before or instead of trigger, lastRowid is no
9477 ** longer (since after version 2.8.12) reset to -1.
9478 **
9479 ** The sqlcipher.nChange does not count changes within triggers and keeps no
9480 ** context.  It is reset at start of sqlcipher3_exec.
9481 ** The sqlcipher.lsChange represents the number of changes made by the last
9482 ** insert, update, or delete statement.  It remains constant throughout the
9483 ** length of a statement and is then updated by OP_SetCounts.  It keeps a
9484 ** context stack just like lastRowid so that the count of changes
9485 ** within a trigger is not seen outside the trigger.  Changes to views do not
9486 ** affect the value of lsChange.
9487 ** The sqlcipher.csChange keeps track of the number of current changes (since
9488 ** the last statement) and is used to update sqlcipher_lsChange.
9489 **
9490 ** The member variables sqlcipher.errCode, sqlcipher.zErrMsg and sqlcipher.zErrMsg16
9491 ** store the most recent error code and, if applicable, string. The
9492 ** internal function sqlcipher3Error() is used to set these variables
9493 ** consistently.
9494 */
9495 struct sqlcipher3 {
9496   sqlcipher3_vfs *pVfs;            /* OS Interface */
9497   int nDb;                      /* Number of backends currently in use */
9498   Db *aDb;                      /* All backends */
9499   int flags;                    /* Miscellaneous flags. See below */
9500   unsigned int openFlags;       /* Flags passed to sqlcipher3_vfs.xOpen() */
9501   int errCode;                  /* Most recent error code (SQLCIPHER_*) */
9502   int errMask;                  /* & result codes with this before returning */
9503   u8 autoCommit;                /* The auto-commit flag. */
9504   u8 temp_store;                /* 1: file 2: memory 0: default */
9505   u8 mallocFailed;              /* True if we have seen a malloc failure */
9506   u8 dfltLockMode;              /* Default locking-mode for attached dbs */
9507   signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
9508   u8 suppressErr;               /* Do not issue error messages if true */
9509   u8 vtabOnConflict;            /* Value to return for s3_vtab_on_conflict() */
9510   int nextPagesize;             /* Pagesize after VACUUM if >0 */
9511   int nTable;                   /* Number of tables in the database */
9512   CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */
9513   i64 lastRowid;                /* ROWID of most recent insert (see above) */
9514   u32 magic;                    /* Magic number for detect library misuse */
9515   int nChange;                  /* Value returned by sqlcipher3_changes() */
9516   int nTotalChange;             /* Value returned by sqlcipher3_total_changes() */
9517   sqlcipher3_mutex *mutex;         /* Connection mutex */
9518   int aLimit[SQLCIPHER_N_LIMIT];   /* Limits */
9519   struct sqlcipher3InitInfo {      /* Information used during initialization */
9520     int iDb;                    /* When back is being initialized */
9521     int newTnum;                /* Rootpage of table being initialized */
9522     u8 busy;                    /* TRUE if currently initializing */
9523     u8 orphanTrigger;           /* Last statement is orphaned TEMP trigger */
9524   } init;
9525   int nExtension;               /* Number of loaded extensions */
9526   void **aExtension;            /* Array of shared library handles */
9527   struct Vdbe *pVdbe;           /* List of active virtual machines */
9528   int activeVdbeCnt;            /* Number of VDBEs currently executing */
9529   int writeVdbeCnt;             /* Number of active VDBEs that are writing */
9530   int vdbeExecCnt;              /* Number of nested calls to VdbeExec() */
9531   void (*xTrace)(void*,const char*);        /* Trace function */
9532   void *pTraceArg;                          /* Argument to the trace function */
9533   void (*xProfile)(void*,const char*,u64);  /* Profiling function */
9534   void *pProfileArg;                        /* Argument to profile function */
9535   void *pCommitArg;                 /* Argument to xCommitCallback() */   
9536   int (*xCommitCallback)(void*);    /* Invoked at every commit. */
9537   void *pRollbackArg;               /* Argument to xRollbackCallback() */   
9538   void (*xRollbackCallback)(void*); /* Invoked at every commit. */
9539   void *pUpdateArg;
9540   void (*xUpdateCallback)(void*,int, const char*,const char*,sqlcipher_int64);
9541 #ifndef SQLCIPHER_OMIT_WAL
9542   int (*xWalCallback)(void *, sqlcipher3 *, const char *, int);
9543   void *pWalArg;
9544 #endif
9545   void(*xCollNeeded)(void*,sqlcipher3*,int eTextRep,const char*);
9546   void(*xCollNeeded16)(void*,sqlcipher3*,int eTextRep,const void*);
9547   void *pCollNeededArg;
9548   sqlcipher3_value *pErr;          /* Most recent error message */
9549   char *zErrMsg;                /* Most recent error message (UTF-8 encoded) */
9550   char *zErrMsg16;              /* Most recent error message (UTF-16 encoded) */
9551   union {
9552     volatile int isInterrupted; /* True if sqlcipher3_interrupt has been called */
9553     double notUsed1;            /* Spacer */
9554   } u1;
9555   Lookaside lookaside;          /* Lookaside malloc configuration */
9556 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
9557   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
9558                                 /* Access authorization function */
9559   void *pAuthArg;               /* 1st argument to the access auth function */
9560 #endif
9561 #ifndef SQLCIPHER_OMIT_PROGRESS_CALLBACK
9562   int (*xProgress)(void *);     /* The progress callback */
9563   void *pProgressArg;           /* Argument to the progress callback */
9564   int nProgressOps;             /* Number of opcodes for progress callback */
9565 #endif
9566 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
9567   Hash aModule;                 /* populated by sqlcipher3_create_module() */
9568   VtabCtx *pVtabCtx;            /* Context for active vtab connect/create */
9569   VTable **aVTrans;             /* Virtual tables with open transactions */
9570   int nVTrans;                  /* Allocated size of aVTrans */
9571   VTable *pDisconnect;    /* Disconnect these in next sqlcipher3_prepare() */
9572 #endif
9573   FuncDefHash aFunc;            /* Hash table of connection functions */
9574   Hash aCollSeq;                /* All collating sequences */
9575   BusyHandler busyHandler;      /* Busy callback */
9576   int busyTimeout;              /* Busy handler timeout, in msec */
9577   Db aDbStatic[2];              /* Static space for the 2 default backends */
9578   Savepoint *pSavepoint;        /* List of active savepoints */
9579   int nSavepoint;               /* Number of non-transaction savepoints */
9580   int nStatement;               /* Number of nested statement-transactions  */
9581   u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */
9582   i64 nDeferredCons;            /* Net deferred constraints this transaction. */
9583   int *pnBytesFreed;            /* If not NULL, increment this in DbFree() */
9584
9585 #ifdef SQLCIPHER_ENABLE_UNLOCK_NOTIFY
9586   /* The following variables are all protected by the STATIC_MASTER 
9587   ** mutex, not by sqlcipher3.mutex. They are used by code in notify.c. 
9588   **
9589   ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
9590   ** unlock so that it can proceed.
9591   **
9592   ** When X.pBlockingConnection==Y, that means that something that X tried
9593   ** tried to do recently failed with an SQLCIPHER_LOCKED error due to locks
9594   ** held by Y.
9595   */
9596   sqlcipher3 *pBlockingConnection; /* Connection that caused SQLCIPHER_LOCKED */
9597   sqlcipher3 *pUnlockConnection;           /* Connection to watch for unlock */
9598   void *pUnlockArg;                     /* Argument to xUnlockNotify */
9599   void (*xUnlockNotify)(void **, int);  /* Unlock notify callback */
9600   sqlcipher3 *pNextBlocked;        /* Next in list of all blocked connections */
9601 #endif
9602 };
9603
9604 /*
9605 ** A macro to discover the encoding of a database.
9606 */
9607 #define ENC(db) ((db)->aDb[0].pSchema->enc)
9608
9609 /*
9610 ** Possible values for the sqlcipher3.flags.
9611 */
9612 #define SQLCIPHER_VdbeTrace      0x00000100  /* True to trace VDBE execution */
9613 #define SQLCIPHER_InternChanges  0x00000200  /* Uncommitted Hash table changes */
9614 #define SQLCIPHER_FullColNames   0x00000400  /* Show full column names on SELECT */
9615 #define SQLCIPHER_ShortColNames  0x00000800  /* Show short columns names */
9616 #define SQLCIPHER_CountRows      0x00001000  /* Count rows changed by INSERT, */
9617                                           /*   DELETE, or UPDATE and return */
9618                                           /*   the count using a callback. */
9619 #define SQLCIPHER_NullCallback   0x00002000  /* Invoke the callback once if the */
9620                                           /*   result set is empty */
9621 #define SQLCIPHER_SqlTrace       0x00004000  /* Debug print SQL as it executes */
9622 #define SQLCIPHER_VdbeListing    0x00008000  /* Debug listings of VDBE programs */
9623 #define SQLCIPHER_WriteSchema    0x00010000  /* OK to update SQLCIPHER_MASTER */
9624 #define SQLCIPHER_NoReadlock     0x00020000  /* Readlocks are omitted when 
9625                                           ** accessing read-only databases */
9626 #define SQLCIPHER_IgnoreChecks   0x00040000  /* Do not enforce check constraints */
9627 #define SQLCIPHER_ReadUncommitted 0x0080000  /* For shared-cache mode */
9628 #define SQLCIPHER_LegacyFileFmt  0x00100000  /* Create new databases in format 1 */
9629 #define SQLCIPHER_FullFSync      0x00200000  /* Use full fsync on the backend */
9630 #define SQLCIPHER_CkptFullFSync  0x00400000  /* Use full fsync for checkpoint */
9631 #define SQLCIPHER_RecoveryMode   0x00800000  /* Ignore schema errors */
9632 #define SQLCIPHER_ReverseOrder   0x01000000  /* Reverse unordered SELECTs */
9633 #define SQLCIPHER_RecTriggers    0x02000000  /* Enable recursive triggers */
9634 #define SQLCIPHER_ForeignKeys    0x04000000  /* Enforce foreign key constraints  */
9635 #define SQLCIPHER_AutoIndex      0x08000000  /* Enable automatic indexes */
9636 #define SQLCIPHER_PreferBuiltin  0x10000000  /* Preference to built-in funcs */
9637 #define SQLCIPHER_LoadExtension  0x20000000  /* Enable load_extension */
9638 #define SQLCIPHER_EnableTrigger  0x40000000  /* True to enable triggers */
9639
9640 /*
9641 ** Bits of the sqlcipher3.flags field that are used by the
9642 ** sqlcipher3_test_control(SQLCIPHER_TESTCTRL_OPTIMIZATIONS,...) interface.
9643 ** These must be the low-order bits of the flags field.
9644 */
9645 #define SQLCIPHER_QueryFlattener 0x01        /* Disable query flattening */
9646 #define SQLCIPHER_ColumnCache    0x02        /* Disable the column cache */
9647 #define SQLCIPHER_IndexSort      0x04        /* Disable indexes for sorting */
9648 #define SQLCIPHER_IndexSearch    0x08        /* Disable indexes for searching */
9649 #define SQLCIPHER_IndexCover     0x10        /* Disable index covering table */
9650 #define SQLCIPHER_GroupByOrder   0x20        /* Disable GROUPBY cover of ORDERBY */
9651 #define SQLCIPHER_FactorOutConst 0x40        /* Disable factoring out constants */
9652 #define SQLCIPHER_IdxRealAsInt   0x80        /* Store REAL as INT in indices */
9653 #define SQLCIPHER_DistinctOpt    0x80        /* DISTINCT using indexes */
9654 #define SQLCIPHER_OptMask        0xff        /* Mask of all disablable opts */
9655
9656 /*
9657 ** Possible values for the sqlcipher.magic field.
9658 ** The numbers are obtained at random and have no special meaning, other
9659 ** than being distinct from one another.
9660 */
9661 #define SQLCIPHER_MAGIC_OPEN     0xa029a697  /* Database is open */
9662 #define SQLCIPHER_MAGIC_CLOSED   0x9f3c2d33  /* Database is closed */
9663 #define SQLCIPHER_MAGIC_SICK     0x4b771290  /* Error and awaiting close */
9664 #define SQLCIPHER_MAGIC_BUSY     0xf03b7906  /* Database currently in use */
9665 #define SQLCIPHER_MAGIC_ERROR    0xb5357930  /* An SQLCIPHER_MISUSE error occurred */
9666
9667 /*
9668 ** Each SQL function is defined by an instance of the following
9669 ** structure.  A pointer to this structure is stored in the sqlcipher.aFunc
9670 ** hash table.  When multiple functions have the same name, the hash table
9671 ** points to a linked list of these structures.
9672 */
9673 struct FuncDef {
9674   i16 nArg;            /* Number of arguments.  -1 means unlimited */
9675   u8 iPrefEnc;         /* Preferred text encoding (SQLCIPHER_UTF8, 16LE, 16BE) */
9676   u8 flags;            /* Some combination of SQLCIPHER_FUNC_* */
9677   void *pUserData;     /* User data parameter */
9678   FuncDef *pNext;      /* Next function with same name */
9679   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**); /* Regular function */
9680   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**); /* Aggregate step */
9681   void (*xFinalize)(sqlcipher3_context*);                /* Aggregate finalizer */
9682   char *zName;         /* SQL name of the function. */
9683   FuncDef *pHash;      /* Next with a different name but the same hash */
9684   FuncDestructor *pDestructor;   /* Reference counted destructor function */
9685 };
9686
9687 /*
9688 ** This structure encapsulates a user-function destructor callback (as
9689 ** configured using create_function_v2()) and a reference counter. When
9690 ** create_function_v2() is called to create a function with a destructor,
9691 ** a single object of this type is allocated. FuncDestructor.nRef is set to 
9692 ** the number of FuncDef objects created (either 1 or 3, depending on whether
9693 ** or not the specified encoding is SQLCIPHER_ANY). The FuncDef.pDestructor
9694 ** member of each of the new FuncDef objects is set to point to the allocated
9695 ** FuncDestructor.
9696 **
9697 ** Thereafter, when one of the FuncDef objects is deleted, the reference
9698 ** count on this object is decremented. When it reaches 0, the destructor
9699 ** is invoked and the FuncDestructor structure freed.
9700 */
9701 struct FuncDestructor {
9702   int nRef;
9703   void (*xDestroy)(void *);
9704   void *pUserData;
9705 };
9706
9707 /*
9708 ** Possible values for FuncDef.flags
9709 */
9710 #define SQLCIPHER_FUNC_LIKE     0x01 /* Candidate for the LIKE optimization */
9711 #define SQLCIPHER_FUNC_CASE     0x02 /* Case-sensitive LIKE-type function */
9712 #define SQLCIPHER_FUNC_EPHEM    0x04 /* Ephemeral.  Delete with VDBE */
9713 #define SQLCIPHER_FUNC_NEEDCOLL 0x08 /* sqlcipher3GetFuncCollSeq() might be called */
9714 #define SQLCIPHER_FUNC_PRIVATE  0x10 /* Allowed for internal use only */
9715 #define SQLCIPHER_FUNC_COUNT    0x20 /* Built-in count(*) aggregate */
9716 #define SQLCIPHER_FUNC_COALESCE 0x40 /* Built-in coalesce() or ifnull() function */
9717
9718 /*
9719 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
9720 ** used to create the initializers for the FuncDef structures.
9721 **
9722 **   FUNCTION(zName, nArg, iArg, bNC, xFunc)
9723 **     Used to create a scalar function definition of a function zName 
9724 **     implemented by C function xFunc that accepts nArg arguments. The
9725 **     value passed as iArg is cast to a (void*) and made available
9726 **     as the user-data (sqlcipher3_user_data()) for the function. If 
9727 **     argument bNC is true, then the SQLCIPHER_FUNC_NEEDCOLL flag is set.
9728 **
9729 **   AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
9730 **     Used to create an aggregate function definition implemented by
9731 **     the C functions xStep and xFinal. The first four parameters
9732 **     are interpreted in the same way as the first 4 parameters to
9733 **     FUNCTION().
9734 **
9735 **   LIKEFUNC(zName, nArg, pArg, flags)
9736 **     Used to create a scalar function definition of a function zName 
9737 **     that accepts nArg arguments and is implemented by a call to C 
9738 **     function likeFunc. Argument pArg is cast to a (void *) and made
9739 **     available as the function user-data (sqlcipher3_user_data()). The
9740 **     FuncDef.flags variable is set to the value passed as the flags
9741 **     parameter.
9742 */
9743 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
9744   {nArg, SQLCIPHER_UTF8, bNC*SQLCIPHER_FUNC_NEEDCOLL, \
9745    SQLCIPHER_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
9746 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
9747   {nArg, SQLCIPHER_UTF8, bNC*SQLCIPHER_FUNC_NEEDCOLL, \
9748    pArg, 0, xFunc, 0, 0, #zName, 0, 0}
9749 #define LIKEFUNC(zName, nArg, arg, flags) \
9750   {nArg, SQLCIPHER_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
9751 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
9752   {nArg, SQLCIPHER_UTF8, nc*SQLCIPHER_FUNC_NEEDCOLL, \
9753    SQLCIPHER_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
9754
9755 /*
9756 ** All current savepoints are stored in a linked list starting at
9757 ** sqlcipher3.pSavepoint. The first element in the list is the most recently
9758 ** opened savepoint. Savepoints are added to the list by the vdbe
9759 ** OP_Savepoint instruction.
9760 */
9761 struct Savepoint {
9762   char *zName;                        /* Savepoint name (nul-terminated) */
9763   i64 nDeferredCons;                  /* Number of deferred fk violations */
9764   Savepoint *pNext;                   /* Parent savepoint (if any) */
9765 };
9766
9767 /*
9768 ** The following are used as the second parameter to sqlcipher3Savepoint(),
9769 ** and as the P1 argument to the OP_Savepoint instruction.
9770 */
9771 #define SAVEPOINT_BEGIN      0
9772 #define SAVEPOINT_RELEASE    1
9773 #define SAVEPOINT_ROLLBACK   2
9774
9775
9776 /*
9777 ** Each SQLite module (virtual table definition) is defined by an
9778 ** instance of the following structure, stored in the sqlcipher3.aModule
9779 ** hash table.
9780 */
9781 struct Module {
9782   const sqlcipher3_module *pModule;       /* Callback pointers */
9783   const char *zName;                   /* Name passed to create_module() */
9784   void *pAux;                          /* pAux passed to create_module() */
9785   void (*xDestroy)(void *);            /* Module destructor function */
9786 };
9787
9788 /*
9789 ** information about each column of an SQL table is held in an instance
9790 ** of this structure.
9791 */
9792 struct Column {
9793   char *zName;     /* Name of this column */
9794   Expr *pDflt;     /* Default value of this column */
9795   char *zDflt;     /* Original text of the default value */
9796   char *zType;     /* Data type for this column */
9797   char *zColl;     /* Collating sequence.  If NULL, use the default */
9798   u8 notNull;      /* True if there is a NOT NULL constraint */
9799   u8 isPrimKey;    /* True if this column is part of the PRIMARY KEY */
9800   char affinity;   /* One of the SQLCIPHER_AFF_... values */
9801 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
9802   u8 isHidden;     /* True if this column is 'hidden' */
9803 #endif
9804 };
9805
9806 /*
9807 ** A "Collating Sequence" is defined by an instance of the following
9808 ** structure. Conceptually, a collating sequence consists of a name and
9809 ** a comparison routine that defines the order of that sequence.
9810 **
9811 ** There may two separate implementations of the collation function, one
9812 ** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that
9813 ** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine
9814 ** native byte order. When a collation sequence is invoked, SQLite selects
9815 ** the version that will require the least expensive encoding
9816 ** translations, if any.
9817 **
9818 ** The CollSeq.pUser member variable is an extra parameter that passed in
9819 ** as the first argument to the UTF-8 comparison function, xCmp.
9820 ** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function,
9821 ** xCmp16.
9822 **
9823 ** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the
9824 ** collating sequence is undefined.  Indices built on an undefined
9825 ** collating sequence may not be read or written.
9826 */
9827 struct CollSeq {
9828   char *zName;          /* Name of the collating sequence, UTF-8 encoded */
9829   u8 enc;               /* Text encoding handled by xCmp() */
9830   u8 type;              /* One of the SQLCIPHER_COLL_... values below */
9831   void *pUser;          /* First argument to xCmp() */
9832   int (*xCmp)(void*,int, const void*, int, const void*);
9833   void (*xDel)(void*);  /* Destructor for pUser */
9834 };
9835
9836 /*
9837 ** Allowed values of CollSeq.type:
9838 */
9839 #define SQLCIPHER_COLL_BINARY  1  /* The default memcmp() collating sequence */
9840 #define SQLCIPHER_COLL_NOCASE  2  /* The built-in NOCASE collating sequence */
9841 #define SQLCIPHER_COLL_REVERSE 3  /* The built-in REVERSE collating sequence */
9842 #define SQLCIPHER_COLL_USER    0  /* Any other user-defined collating sequence */
9843
9844 /*
9845 ** A sort order can be either ASC or DESC.
9846 */
9847 #define SQLCIPHER_SO_ASC       0  /* Sort in ascending order */
9848 #define SQLCIPHER_SO_DESC      1  /* Sort in ascending order */
9849
9850 /*
9851 ** Column affinity types.
9852 **
9853 ** These used to have mnemonic name like 'i' for SQLCIPHER_AFF_INTEGER and
9854 ** 't' for SQLCIPHER_AFF_TEXT.  But we can save a little space and improve
9855 ** the speed a little by numbering the values consecutively.  
9856 **
9857 ** But rather than start with 0 or 1, we begin with 'a'.  That way,
9858 ** when multiple affinity types are concatenated into a string and
9859 ** used as the P4 operand, they will be more readable.
9860 **
9861 ** Note also that the numeric types are grouped together so that testing
9862 ** for a numeric type is a single comparison.
9863 */
9864 #define SQLCIPHER_AFF_TEXT     'a'
9865 #define SQLCIPHER_AFF_NONE     'b'
9866 #define SQLCIPHER_AFF_NUMERIC  'c'
9867 #define SQLCIPHER_AFF_INTEGER  'd'
9868 #define SQLCIPHER_AFF_REAL     'e'
9869
9870 #define sqlcipher3IsNumericAffinity(X)  ((X)>=SQLCIPHER_AFF_NUMERIC)
9871
9872 /*
9873 ** The SQLCIPHER_AFF_MASK values masks off the significant bits of an
9874 ** affinity value. 
9875 */
9876 #define SQLCIPHER_AFF_MASK     0x67
9877
9878 /*
9879 ** Additional bit values that can be ORed with an affinity without
9880 ** changing the affinity.
9881 */
9882 #define SQLCIPHER_JUMPIFNULL   0x08  /* jumps if either operand is NULL */
9883 #define SQLCIPHER_STOREP2      0x10  /* Store result in reg[P2] rather than jump */
9884 #define SQLCIPHER_NULLEQ       0x80  /* NULL=NULL */
9885
9886 /*
9887 ** An object of this type is created for each virtual table present in
9888 ** the database schema. 
9889 **
9890 ** If the database schema is shared, then there is one instance of this
9891 ** structure for each database connection (sqlcipher3*) that uses the shared
9892 ** schema. This is because each database connection requires its own unique
9893 ** instance of the sqlcipher3_vtab* handle used to access the virtual table 
9894 ** implementation. sqlcipher3_vtab* handles can not be shared between 
9895 ** database connections, even when the rest of the in-memory database 
9896 ** schema is shared, as the implementation often stores the database
9897 ** connection handle passed to it via the xConnect() or xCreate() method
9898 ** during initialization internally. This database connection handle may
9899 ** then be used by the virtual table implementation to access real tables 
9900 ** within the database. So that they appear as part of the callers 
9901 ** transaction, these accesses need to be made via the same database 
9902 ** connection as that used to execute SQL operations on the virtual table.
9903 **
9904 ** All VTable objects that correspond to a single table in a shared
9905 ** database schema are initially stored in a linked-list pointed to by
9906 ** the Table.pVTable member variable of the corresponding Table object.
9907 ** When an sqlcipher3_prepare() operation is required to access the virtual
9908 ** table, it searches the list for the VTable that corresponds to the
9909 ** database connection doing the preparing so as to use the correct
9910 ** sqlcipher3_vtab* handle in the compiled query.
9911 **
9912 ** When an in-memory Table object is deleted (for example when the
9913 ** schema is being reloaded for some reason), the VTable objects are not 
9914 ** deleted and the sqlcipher3_vtab* handles are not xDisconnect()ed 
9915 ** immediately. Instead, they are moved from the Table.pVTable list to
9916 ** another linked list headed by the sqlcipher3.pDisconnect member of the
9917 ** corresponding sqlcipher3 structure. They are then deleted/xDisconnected 
9918 ** next time a statement is prepared using said sqlcipher3*. This is done
9919 ** to avoid deadlock issues involving multiple sqlcipher3.mutex mutexes.
9920 ** Refer to comments above function sqlcipher3VtabUnlockList() for an
9921 ** explanation as to why it is safe to add an entry to an sqlcipher3.pDisconnect
9922 ** list without holding the corresponding sqlcipher3.mutex mutex.
9923 **
9924 ** The memory for objects of this type is always allocated by 
9925 ** sqlcipher3DbMalloc(), using the connection handle stored in VTable.db as 
9926 ** the first argument.
9927 */
9928 struct VTable {
9929   sqlcipher3 *db;              /* Database connection associated with this table */
9930   Module *pMod;             /* Pointer to module implementation */
9931   sqlcipher3_vtab *pVtab;      /* Pointer to vtab instance */
9932   int nRef;                 /* Number of pointers to this structure */
9933   u8 bConstraint;           /* True if constraints are supported */
9934   int iSavepoint;           /* Depth of the SAVEPOINT stack */
9935   VTable *pNext;            /* Next in linked list (see above) */
9936 };
9937
9938 /*
9939 ** Each SQL table is represented in memory by an instance of the
9940 ** following structure.
9941 **
9942 ** Table.zName is the name of the table.  The case of the original
9943 ** CREATE TABLE statement is stored, but case is not significant for
9944 ** comparisons.
9945 **
9946 ** Table.nCol is the number of columns in this table.  Table.aCol is a
9947 ** pointer to an array of Column structures, one for each column.
9948 **
9949 ** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
9950 ** the column that is that key.   Otherwise Table.iPKey is negative.  Note
9951 ** that the datatype of the PRIMARY KEY must be INTEGER for this field to
9952 ** be set.  An INTEGER PRIMARY KEY is used as the rowid for each row of
9953 ** the table.  If a table has no INTEGER PRIMARY KEY, then a random rowid
9954 ** is generated for each row of the table.  TF_HasPrimaryKey is set if
9955 ** the table has any PRIMARY KEY, INTEGER or otherwise.
9956 **
9957 ** Table.tnum is the page number for the root BTree page of the table in the
9958 ** database file.  If Table.iDb is the index of the database table backend
9959 ** in sqlcipher.aDb[].  0 is for the main database and 1 is for the file that
9960 ** holds temporary tables and indices.  If TF_Ephemeral is set
9961 ** then the table is stored in a file that is automatically deleted
9962 ** when the VDBE cursor to the table is closed.  In this case Table.tnum 
9963 ** refers VDBE cursor number that holds the table open, not to the root
9964 ** page number.  Transient tables are used to hold the results of a
9965 ** sub-query that appears instead of a real table name in the FROM clause 
9966 ** of a SELECT statement.
9967 */
9968 struct Table {
9969   char *zName;         /* Name of the table or view */
9970   int iPKey;           /* If not negative, use aCol[iPKey] as the primary key */
9971   int nCol;            /* Number of columns in this table */
9972   Column *aCol;        /* Information about each column */
9973   Index *pIndex;       /* List of SQL indexes on this table. */
9974   int tnum;            /* Root BTree node for this table (see note above) */
9975   tRowcnt nRowEst;     /* Estimated rows in table - from sqlcipher_stat1 table */
9976   Select *pSelect;     /* NULL for tables.  Points to definition if a view. */
9977   u16 nRef;            /* Number of pointers to this Table */
9978   u8 tabFlags;         /* Mask of TF_* values */
9979   u8 keyConf;          /* What to do in case of uniqueness conflict on iPKey */
9980   FKey *pFKey;         /* Linked list of all foreign keys in this table */
9981   char *zColAff;       /* String defining the affinity of each column */
9982 #ifndef SQLCIPHER_OMIT_CHECK
9983   Expr *pCheck;        /* The AND of all CHECK constraints */
9984 #endif
9985 #ifndef SQLCIPHER_OMIT_ALTERTABLE
9986   int addColOffset;    /* Offset in CREATE TABLE stmt to add a new column */
9987 #endif
9988 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
9989   VTable *pVTable;     /* List of VTable objects. */
9990   int nModuleArg;      /* Number of arguments to the module */
9991   char **azModuleArg;  /* Text of all module args. [0] is module name */
9992 #endif
9993   Trigger *pTrigger;   /* List of triggers stored in pSchema */
9994   Schema *pSchema;     /* Schema that contains this table */
9995   Table *pNextZombie;  /* Next on the Parse.pZombieTab list */
9996 };
9997
9998 /*
9999 ** Allowed values for Tabe.tabFlags.
10000 */
10001 #define TF_Readonly        0x01    /* Read-only system table */
10002 #define TF_Ephemeral       0x02    /* An ephemeral table */
10003 #define TF_HasPrimaryKey   0x04    /* Table has a primary key */
10004 #define TF_Autoincrement   0x08    /* Integer primary key is autoincrement */
10005 #define TF_Virtual         0x10    /* Is a virtual table */
10006 #define TF_NeedMetadata    0x20    /* aCol[].zType and aCol[].pColl missing */
10007
10008
10009
10010 /*
10011 ** Test to see whether or not a table is a virtual table.  This is
10012 ** done as a macro so that it will be optimized out when virtual
10013 ** table support is omitted from the build.
10014 */
10015 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
10016 #  define IsVirtual(X)      (((X)->tabFlags & TF_Virtual)!=0)
10017 #  define IsHiddenColumn(X) ((X)->isHidden)
10018 #else
10019 #  define IsVirtual(X)      0
10020 #  define IsHiddenColumn(X) 0
10021 #endif
10022
10023 /*
10024 ** Each foreign key constraint is an instance of the following structure.
10025 **
10026 ** A foreign key is associated with two tables.  The "from" table is
10027 ** the table that contains the REFERENCES clause that creates the foreign
10028 ** key.  The "to" table is the table that is named in the REFERENCES clause.
10029 ** Consider this example:
10030 **
10031 **     CREATE TABLE ex1(
10032 **       a INTEGER PRIMARY KEY,
10033 **       b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
10034 **     );
10035 **
10036 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
10037 **
10038 ** Each REFERENCES clause generates an instance of the following structure
10039 ** which is attached to the from-table.  The to-table need not exist when
10040 ** the from-table is created.  The existence of the to-table is not checked.
10041 */
10042 struct FKey {
10043   Table *pFrom;     /* Table containing the REFERENCES clause (aka: Child) */
10044   FKey *pNextFrom;  /* Next foreign key in pFrom */
10045   char *zTo;        /* Name of table that the key points to (aka: Parent) */
10046   FKey *pNextTo;    /* Next foreign key on table named zTo */
10047   FKey *pPrevTo;    /* Previous foreign key on table named zTo */
10048   int nCol;         /* Number of columns in this key */
10049   /* EV: R-30323-21917 */
10050   u8 isDeferred;    /* True if constraint checking is deferred till COMMIT */
10051   u8 aAction[2];          /* ON DELETE and ON UPDATE actions, respectively */
10052   Trigger *apTrigger[2];  /* Triggers for aAction[] actions */
10053   struct sColMap {  /* Mapping of columns in pFrom to columns in zTo */
10054     int iFrom;         /* Index of column in pFrom */
10055     char *zCol;        /* Name of column in zTo.  If 0 use PRIMARY KEY */
10056   } aCol[1];        /* One entry for each of nCol column s */
10057 };
10058
10059 /*
10060 ** SQLite supports many different ways to resolve a constraint
10061 ** error.  ROLLBACK processing means that a constraint violation
10062 ** causes the operation in process to fail and for the current transaction
10063 ** to be rolled back.  ABORT processing means the operation in process
10064 ** fails and any prior changes from that one operation are backed out,
10065 ** but the transaction is not rolled back.  FAIL processing means that
10066 ** the operation in progress stops and returns an error code.  But prior
10067 ** changes due to the same operation are not backed out and no rollback
10068 ** occurs.  IGNORE means that the particular row that caused the constraint
10069 ** error is not inserted or updated.  Processing continues and no error
10070 ** is returned.  REPLACE means that preexisting database rows that caused
10071 ** a UNIQUE constraint violation are removed so that the new insert or
10072 ** update can proceed.  Processing continues and no error is reported.
10073 **
10074 ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
10075 ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
10076 ** same as ROLLBACK for DEFERRED keys.  SETNULL means that the foreign
10077 ** key is set to NULL.  CASCADE means that a DELETE or UPDATE of the
10078 ** referenced table row is propagated into the row that holds the
10079 ** foreign key.
10080 ** 
10081 ** The following symbolic values are used to record which type
10082 ** of action to take.
10083 */
10084 #define OE_None     0   /* There is no constraint to check */
10085 #define OE_Rollback 1   /* Fail the operation and rollback the transaction */
10086 #define OE_Abort    2   /* Back out changes but do no rollback transaction */
10087 #define OE_Fail     3   /* Stop the operation but leave all prior changes */
10088 #define OE_Ignore   4   /* Ignore the error. Do not do the INSERT or UPDATE */
10089 #define OE_Replace  5   /* Delete existing record, then do INSERT or UPDATE */
10090
10091 #define OE_Restrict 6   /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
10092 #define OE_SetNull  7   /* Set the foreign key value to NULL */
10093 #define OE_SetDflt  8   /* Set the foreign key value to its default */
10094 #define OE_Cascade  9   /* Cascade the changes */
10095
10096 #define OE_Default  99  /* Do whatever the default action is */
10097
10098
10099 /*
10100 ** An instance of the following structure is passed as the first
10101 ** argument to sqlcipher3VdbeKeyCompare and is used to control the 
10102 ** comparison of the two index keys.
10103 */
10104 struct KeyInfo {
10105   sqlcipher3 *db;        /* The database connection */
10106   u8 enc;             /* Text encoding - one of the SQLCIPHER_UTF* values */
10107   u16 nField;         /* Number of entries in aColl[] */
10108   u8 *aSortOrder;     /* Sort order for each column.  May be NULL */
10109   CollSeq *aColl[1];  /* Collating sequence for each term of the key */
10110 };
10111
10112 /*
10113 ** An instance of the following structure holds information about a
10114 ** single index record that has already been parsed out into individual
10115 ** values.
10116 **
10117 ** A record is an object that contains one or more fields of data.
10118 ** Records are used to store the content of a table row and to store
10119 ** the key of an index.  A blob encoding of a record is created by
10120 ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
10121 ** OP_Column opcode.
10122 **
10123 ** This structure holds a record that has already been disassembled
10124 ** into its constituent fields.
10125 */
10126 struct UnpackedRecord {
10127   KeyInfo *pKeyInfo;  /* Collation and sort-order information */
10128   u16 nField;         /* Number of entries in apMem[] */
10129   u16 flags;          /* Boolean settings.  UNPACKED_... below */
10130   i64 rowid;          /* Used by UNPACKED_PREFIX_SEARCH */
10131   Mem *aMem;          /* Values */
10132 };
10133
10134 /*
10135 ** Allowed values of UnpackedRecord.flags
10136 */
10137 #define UNPACKED_NEED_FREE     0x0001  /* Memory is from sqlcipher3Malloc() */
10138 #define UNPACKED_NEED_DESTROY  0x0002  /* apMem[]s should all be destroyed */
10139 #define UNPACKED_IGNORE_ROWID  0x0004  /* Ignore trailing rowid on key1 */
10140 #define UNPACKED_INCRKEY       0x0008  /* Make this key an epsilon larger */
10141 #define UNPACKED_PREFIX_MATCH  0x0010  /* A prefix match is considered OK */
10142 #define UNPACKED_PREFIX_SEARCH 0x0020  /* A prefix match is considered OK */
10143
10144 /*
10145 ** Each SQL index is represented in memory by an
10146 ** instance of the following structure.
10147 **
10148 ** The columns of the table that are to be indexed are described
10149 ** by the aiColumn[] field of this structure.  For example, suppose
10150 ** we have the following table and index:
10151 **
10152 **     CREATE TABLE Ex1(c1 int, c2 int, c3 text);
10153 **     CREATE INDEX Ex2 ON Ex1(c3,c1);
10154 **
10155 ** In the Table structure describing Ex1, nCol==3 because there are
10156 ** three columns in the table.  In the Index structure describing
10157 ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
10158 ** The value of aiColumn is {2, 0}.  aiColumn[0]==2 because the 
10159 ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
10160 ** The second column to be indexed (c1) has an index of 0 in
10161 ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
10162 **
10163 ** The Index.onError field determines whether or not the indexed columns
10164 ** must be unique and what to do if they are not.  When Index.onError=OE_None,
10165 ** it means this is not a unique index.  Otherwise it is a unique index
10166 ** and the value of Index.onError indicate the which conflict resolution 
10167 ** algorithm to employ whenever an attempt is made to insert a non-unique
10168 ** element.
10169 */
10170 struct Index {
10171   char *zName;     /* Name of this index */
10172   int nColumn;     /* Number of columns in the table used by this index */
10173   int *aiColumn;   /* Which columns are used by this index.  1st is 0 */
10174   tRowcnt *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */
10175   Table *pTable;   /* The SQL table being indexed */
10176   int tnum;        /* Page containing root of this index in database file */
10177   u8 onError;      /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
10178   u8 autoIndex;    /* True if is automatically created (ex: by UNIQUE) */
10179   u8 bUnordered;   /* Use this index for == or IN queries only */
10180   char *zColAff;   /* String defining the affinity of each column */
10181   Index *pNext;    /* The next index associated with the same table */
10182   Schema *pSchema; /* Schema containing this index */
10183   u8 *aSortOrder;  /* Array of size Index.nColumn. True==DESC, False==ASC */
10184   char **azColl;   /* Array of collation sequence names for index */
10185 #ifdef SQLCIPHER_ENABLE_STAT3
10186   int nSample;             /* Number of elements in aSample[] */
10187   tRowcnt avgEq;           /* Average nEq value for key values not in aSample */
10188   IndexSample *aSample;    /* Samples of the left-most key */
10189 #endif
10190 };
10191
10192 /*
10193 ** Each sample stored in the sqlcipher_stat3 table is represented in memory 
10194 ** using a structure of this type.  See documentation at the top of the
10195 ** analyze.c source file for additional information.
10196 */
10197 struct IndexSample {
10198   union {
10199     char *z;        /* Value if eType is SQLCIPHER_TEXT or SQLCIPHER_BLOB */
10200     double r;       /* Value if eType is SQLCIPHER_FLOAT */
10201     i64 i;          /* Value if eType is SQLCIPHER_INTEGER */
10202   } u;
10203   u8 eType;         /* SQLCIPHER_NULL, SQLCIPHER_INTEGER ... etc. */
10204   int nByte;        /* Size in byte of text or blob. */
10205   tRowcnt nEq;      /* Est. number of rows where the key equals this sample */
10206   tRowcnt nLt;      /* Est. number of rows where key is less than this sample */
10207   tRowcnt nDLt;     /* Est. number of distinct keys less than this sample */
10208 };
10209
10210 /*
10211 ** Each token coming out of the lexer is an instance of
10212 ** this structure.  Tokens are also used as part of an expression.
10213 **
10214 ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
10215 ** may contain random values.  Do not make any assumptions about Token.dyn
10216 ** and Token.n when Token.z==0.
10217 */
10218 struct Token {
10219   const char *z;     /* Text of the token.  Not NULL-terminated! */
10220   unsigned int n;    /* Number of characters in this token */
10221 };
10222
10223 /*
10224 ** An instance of this structure contains information needed to generate
10225 ** code for a SELECT that contains aggregate functions.
10226 **
10227 ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
10228 ** pointer to this structure.  The Expr.iColumn field is the index in
10229 ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
10230 ** code for that node.
10231 **
10232 ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
10233 ** original Select structure that describes the SELECT statement.  These
10234 ** fields do not need to be freed when deallocating the AggInfo structure.
10235 */
10236 struct AggInfo {
10237   u8 directMode;          /* Direct rendering mode means take data directly
10238                           ** from source tables rather than from accumulators */
10239   u8 useSortingIdx;       /* In direct mode, reference the sorting index rather
10240                           ** than the source table */
10241   int sortingIdx;         /* Cursor number of the sorting index */
10242   int sortingIdxPTab;     /* Cursor number of pseudo-table */
10243   ExprList *pGroupBy;     /* The group by clause */
10244   int nSortingColumn;     /* Number of columns in the sorting index */
10245   struct AggInfo_col {    /* For each column used in source tables */
10246     Table *pTab;             /* Source table */
10247     int iTable;              /* Cursor number of the source table */
10248     int iColumn;             /* Column number within the source table */
10249     int iSorterColumn;       /* Column number in the sorting index */
10250     int iMem;                /* Memory location that acts as accumulator */
10251     Expr *pExpr;             /* The original expression */
10252   } *aCol;
10253   int nColumn;            /* Number of used entries in aCol[] */
10254   int nColumnAlloc;       /* Number of slots allocated for aCol[] */
10255   int nAccumulator;       /* Number of columns that show through to the output.
10256                           ** Additional columns are used only as parameters to
10257                           ** aggregate functions */
10258   struct AggInfo_func {   /* For each aggregate function */
10259     Expr *pExpr;             /* Expression encoding the function */
10260     FuncDef *pFunc;          /* The aggregate function implementation */
10261     int iMem;                /* Memory location that acts as accumulator */
10262     int iDistinct;           /* Ephemeral table used to enforce DISTINCT */
10263   } *aFunc;
10264   int nFunc;              /* Number of entries in aFunc[] */
10265   int nFuncAlloc;         /* Number of slots allocated for aFunc[] */
10266 };
10267
10268 /*
10269 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
10270 ** Usually it is 16-bits.  But if SQLCIPHER_MAX_VARIABLE_NUMBER is greater
10271 ** than 32767 we have to make it 32-bit.  16-bit is preferred because
10272 ** it uses less memory in the Expr object, which is a big memory user
10273 ** in systems with lots of prepared statements.  And few applications
10274 ** need more than about 10 or 20 variables.  But some extreme users want
10275 ** to have prepared statements with over 32767 variables, and for them
10276 ** the option is available (at compile-time).
10277 */
10278 #if SQLCIPHER_MAX_VARIABLE_NUMBER<=32767
10279 typedef i16 ynVar;
10280 #else
10281 typedef int ynVar;
10282 #endif
10283
10284 /*
10285 ** Each node of an expression in the parse tree is an instance
10286 ** of this structure.
10287 **
10288 ** Expr.op is the opcode. The integer parser token codes are reused
10289 ** as opcodes here. For example, the parser defines TK_GE to be an integer
10290 ** code representing the ">=" operator. This same integer code is reused
10291 ** to represent the greater-than-or-equal-to operator in the expression
10292 ** tree.
10293 **
10294 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, 
10295 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
10296 ** the expression is a variable (TK_VARIABLE), then Expr.token contains the 
10297 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
10298 ** then Expr.token contains the name of the function.
10299 **
10300 ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
10301 ** binary operator. Either or both may be NULL.
10302 **
10303 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
10304 ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
10305 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
10306 ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
10307 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is 
10308 ** valid.
10309 **
10310 ** An expression of the form ID or ID.ID refers to a column in a table.
10311 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
10312 ** the integer cursor number of a VDBE cursor pointing to that table and
10313 ** Expr.iColumn is the column number for the specific column.  If the
10314 ** expression is used as a result in an aggregate SELECT, then the
10315 ** value is also stored in the Expr.iAgg column in the aggregate so that
10316 ** it can be accessed after all aggregates are computed.
10317 **
10318 ** If the expression is an unbound variable marker (a question mark 
10319 ** character '?' in the original SQL) then the Expr.iTable holds the index 
10320 ** number for that variable.
10321 **
10322 ** If the expression is a subquery then Expr.iColumn holds an integer
10323 ** register number containing the result of the subquery.  If the
10324 ** subquery gives a constant result, then iTable is -1.  If the subquery
10325 ** gives a different answer at different times during statement processing
10326 ** then iTable is the address of a subroutine that computes the subquery.
10327 **
10328 ** If the Expr is of type OP_Column, and the table it is selecting from
10329 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
10330 ** corresponding table definition.
10331 **
10332 ** ALLOCATION NOTES:
10333 **
10334 ** Expr objects can use a lot of memory space in database schema.  To
10335 ** help reduce memory requirements, sometimes an Expr object will be
10336 ** truncated.  And to reduce the number of memory allocations, sometimes
10337 ** two or more Expr objects will be stored in a single memory allocation,
10338 ** together with Expr.zToken strings.
10339 **
10340 ** If the EP_Reduced and EP_TokenOnly flags are set when
10341 ** an Expr object is truncated.  When EP_Reduced is set, then all
10342 ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
10343 ** are contained within the same memory allocation.  Note, however, that
10344 ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
10345 ** allocated, regardless of whether or not EP_Reduced is set.
10346 */
10347 struct Expr {
10348   u8 op;                 /* Operation performed by this node */
10349   char affinity;         /* The affinity of the column or 0 if not a column */
10350   u16 flags;             /* Various flags.  EP_* See below */
10351   union {
10352     char *zToken;          /* Token value. Zero terminated and dequoted */
10353     int iValue;            /* Non-negative integer value if EP_IntValue */
10354   } u;
10355
10356   /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
10357   ** space is allocated for the fields below this point. An attempt to
10358   ** access them will result in a segfault or malfunction. 
10359   *********************************************************************/
10360
10361   Expr *pLeft;           /* Left subnode */
10362   Expr *pRight;          /* Right subnode */
10363   union {
10364     ExprList *pList;     /* Function arguments or in "<expr> IN (<expr-list)" */
10365     Select *pSelect;     /* Used for sub-selects and "<expr> IN (<select>)" */
10366   } x;
10367   CollSeq *pColl;        /* The collation type of the column or 0 */
10368
10369   /* If the EP_Reduced flag is set in the Expr.flags mask, then no
10370   ** space is allocated for the fields below this point. An attempt to
10371   ** access them will result in a segfault or malfunction.
10372   *********************************************************************/
10373
10374   int iTable;            /* TK_COLUMN: cursor number of table holding column
10375                          ** TK_REGISTER: register number
10376                          ** TK_TRIGGER: 1 -> new, 0 -> old */
10377   ynVar iColumn;         /* TK_COLUMN: column index.  -1 for rowid.
10378                          ** TK_VARIABLE: variable number (always >= 1). */
10379   i16 iAgg;              /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
10380   i16 iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
10381   u8 flags2;             /* Second set of flags.  EP2_... */
10382   u8 op2;                /* If a TK_REGISTER, the original value of Expr.op */
10383   AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
10384   Table *pTab;           /* Table for TK_COLUMN expressions. */
10385 #if SQLCIPHER_MAX_EXPR_DEPTH>0
10386   int nHeight;           /* Height of the tree headed by this node */
10387 #endif
10388 };
10389
10390 /*
10391 ** The following are the meanings of bits in the Expr.flags field.
10392 */
10393 #define EP_FromJoin   0x0001  /* Originated in ON or USING clause of a join */
10394 #define EP_Agg        0x0002  /* Contains one or more aggregate functions */
10395 #define EP_Resolved   0x0004  /* IDs have been resolved to COLUMNs */
10396 #define EP_Error      0x0008  /* Expression contains one or more errors */
10397 #define EP_Distinct   0x0010  /* Aggregate function with DISTINCT keyword */
10398 #define EP_VarSelect  0x0020  /* pSelect is correlated, not constant */
10399 #define EP_DblQuoted  0x0040  /* token.z was originally in "..." */
10400 #define EP_InfixFunc  0x0080  /* True for an infix function: LIKE, GLOB, etc */
10401 #define EP_ExpCollate 0x0100  /* Collating sequence specified explicitly */
10402 #define EP_FixedDest  0x0200  /* Result needed in a specific register */
10403 #define EP_IntValue   0x0400  /* Integer value contained in u.iValue */
10404 #define EP_xIsSelect  0x0800  /* x.pSelect is valid (otherwise x.pList is) */
10405
10406 #define EP_Reduced    0x1000  /* Expr struct is EXPR_REDUCEDSIZE bytes only */
10407 #define EP_TokenOnly  0x2000  /* Expr struct is EXPR_TOKENONLYSIZE bytes only */
10408 #define EP_Static     0x4000  /* Held in memory not obtained from malloc() */
10409
10410 /*
10411 ** The following are the meanings of bits in the Expr.flags2 field.
10412 */
10413 #define EP2_MallocedToken  0x0001  /* Need to sqlcipher3DbFree() Expr.zToken */
10414 #define EP2_Irreducible    0x0002  /* Cannot EXPRDUP_REDUCE this Expr */
10415
10416 /*
10417 ** The pseudo-routine sqlcipher3ExprSetIrreducible sets the EP2_Irreducible
10418 ** flag on an expression structure.  This flag is used for VV&A only.  The
10419 ** routine is implemented as a macro that only works when in debugging mode,
10420 ** so as not to burden production code.
10421 */
10422 #ifdef SQLCIPHER_DEBUG
10423 # define ExprSetIrreducible(X)  (X)->flags2 |= EP2_Irreducible
10424 #else
10425 # define ExprSetIrreducible(X)
10426 #endif
10427
10428 /*
10429 ** These macros can be used to test, set, or clear bits in the 
10430 ** Expr.flags field.
10431 */
10432 #define ExprHasProperty(E,P)     (((E)->flags&(P))==(P))
10433 #define ExprHasAnyProperty(E,P)  (((E)->flags&(P))!=0)
10434 #define ExprSetProperty(E,P)     (E)->flags|=(P)
10435 #define ExprClearProperty(E,P)   (E)->flags&=~(P)
10436
10437 /*
10438 ** Macros to determine the number of bytes required by a normal Expr 
10439 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags 
10440 ** and an Expr struct with the EP_TokenOnly flag set.
10441 */
10442 #define EXPR_FULLSIZE           sizeof(Expr)           /* Full size */
10443 #define EXPR_REDUCEDSIZE        offsetof(Expr,iTable)  /* Common features */
10444 #define EXPR_TOKENONLYSIZE      offsetof(Expr,pLeft)   /* Fewer features */
10445
10446 /*
10447 ** Flags passed to the sqlcipher3ExprDup() function. See the header comment 
10448 ** above sqlcipher3ExprDup() for details.
10449 */
10450 #define EXPRDUP_REDUCE         0x0001  /* Used reduced-size Expr nodes */
10451
10452 /*
10453 ** A list of expressions.  Each expression may optionally have a
10454 ** name.  An expr/name combination can be used in several ways, such
10455 ** as the list of "expr AS ID" fields following a "SELECT" or in the
10456 ** list of "ID = expr" items in an UPDATE.  A list of expressions can
10457 ** also be used as the argument to a function, in which case the a.zName
10458 ** field is not used.
10459 */
10460 struct ExprList {
10461   int nExpr;             /* Number of expressions on the list */
10462   int nAlloc;            /* Number of entries allocated below */
10463   int iECursor;          /* VDBE Cursor associated with this ExprList */
10464   struct ExprList_item {
10465     Expr *pExpr;           /* The list of expressions */
10466     char *zName;           /* Token associated with this expression */
10467     char *zSpan;           /* Original text of the expression */
10468     u8 sortOrder;          /* 1 for DESC or 0 for ASC */
10469     u8 done;               /* A flag to indicate when processing is finished */
10470     u16 iCol;              /* For ORDER BY, column number in result set */
10471     u16 iAlias;            /* Index into Parse.aAlias[] for zName */
10472   } *a;                  /* One entry for each expression */
10473 };
10474
10475 /*
10476 ** An instance of this structure is used by the parser to record both
10477 ** the parse tree for an expression and the span of input text for an
10478 ** expression.
10479 */
10480 struct ExprSpan {
10481   Expr *pExpr;          /* The expression parse tree */
10482   const char *zStart;   /* First character of input text */
10483   const char *zEnd;     /* One character past the end of input text */
10484 };
10485
10486 /*
10487 ** An instance of this structure can hold a simple list of identifiers,
10488 ** such as the list "a,b,c" in the following statements:
10489 **
10490 **      INSERT INTO t(a,b,c) VALUES ...;
10491 **      CREATE INDEX idx ON t(a,b,c);
10492 **      CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
10493 **
10494 ** The IdList.a.idx field is used when the IdList represents the list of
10495 ** column names after a table name in an INSERT statement.  In the statement
10496 **
10497 **     INSERT INTO t(a,b,c) ...
10498 **
10499 ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
10500 */
10501 struct IdList {
10502   struct IdList_item {
10503     char *zName;      /* Name of the identifier */
10504     int idx;          /* Index in some Table.aCol[] of a column named zName */
10505   } *a;
10506   int nId;         /* Number of identifiers on the list */
10507   int nAlloc;      /* Number of entries allocated for a[] below */
10508 };
10509
10510 /*
10511 ** The bitmask datatype defined below is used for various optimizations.
10512 **
10513 ** Changing this from a 64-bit to a 32-bit type limits the number of
10514 ** tables in a join to 32 instead of 64.  But it also reduces the size
10515 ** of the library by 738 bytes on ix86.
10516 */
10517 typedef u64 Bitmask;
10518
10519 /*
10520 ** The number of bits in a Bitmask.  "BMS" means "BitMask Size".
10521 */
10522 #define BMS  ((int)(sizeof(Bitmask)*8))
10523
10524 /*
10525 ** The following structure describes the FROM clause of a SELECT statement.
10526 ** Each table or subquery in the FROM clause is a separate element of
10527 ** the SrcList.a[] array.
10528 **
10529 ** With the addition of multiple database support, the following structure
10530 ** can also be used to describe a particular table such as the table that
10531 ** is modified by an INSERT, DELETE, or UPDATE statement.  In standard SQL,
10532 ** such a table must be a simple name: ID.  But in SQLite, the table can
10533 ** now be identified by a database name, a dot, then the table name: ID.ID.
10534 **
10535 ** The jointype starts out showing the join type between the current table
10536 ** and the next table on the list.  The parser builds the list this way.
10537 ** But sqlcipher3SrcListShiftJoinType() later shifts the jointypes so that each
10538 ** jointype expresses the join between the table and the previous table.
10539 **
10540 ** In the colUsed field, the high-order bit (bit 63) is set if the table
10541 ** contains more than 63 columns and the 64-th or later column is used.
10542 */
10543 struct SrcList {
10544   i16 nSrc;        /* Number of tables or subqueries in the FROM clause */
10545   i16 nAlloc;      /* Number of entries allocated in a[] below */
10546   struct SrcList_item {
10547     char *zDatabase;  /* Name of database holding this table */
10548     char *zName;      /* Name of the table */
10549     char *zAlias;     /* The "B" part of a "A AS B" phrase.  zName is the "A" */
10550     Table *pTab;      /* An SQL table corresponding to zName */
10551     Select *pSelect;  /* A SELECT statement used in place of a table name */
10552     int addrFillSub;  /* Address of subroutine to manifest a subquery */
10553     int regReturn;    /* Register holding return address of addrFillSub */
10554     u8 jointype;      /* Type of join between this able and the previous */
10555     u8 notIndexed;    /* True if there is a NOT INDEXED clause */
10556     u8 isCorrelated;  /* True if sub-query is correlated */
10557 #ifndef SQLCIPHER_OMIT_EXPLAIN
10558     u8 iSelectId;     /* If pSelect!=0, the id of the sub-select in EQP */
10559 #endif
10560     int iCursor;      /* The VDBE cursor number used to access this table */
10561     Expr *pOn;        /* The ON clause of a join */
10562     IdList *pUsing;   /* The USING clause of a join */
10563     Bitmask colUsed;  /* Bit N (1<<N) set if column N of pTab is used */
10564     char *zIndex;     /* Identifier from "INDEXED BY <zIndex>" clause */
10565     Index *pIndex;    /* Index structure corresponding to zIndex, if any */
10566   } a[1];             /* One entry for each identifier on the list */
10567 };
10568
10569 /*
10570 ** Permitted values of the SrcList.a.jointype field
10571 */
10572 #define JT_INNER     0x0001    /* Any kind of inner or cross join */
10573 #define JT_CROSS     0x0002    /* Explicit use of the CROSS keyword */
10574 #define JT_NATURAL   0x0004    /* True for a "natural" join */
10575 #define JT_LEFT      0x0008    /* Left outer join */
10576 #define JT_RIGHT     0x0010    /* Right outer join */
10577 #define JT_OUTER     0x0020    /* The "OUTER" keyword is present */
10578 #define JT_ERROR     0x0040    /* unknown or unsupported join type */
10579
10580
10581 /*
10582 ** A WherePlan object holds information that describes a lookup
10583 ** strategy.
10584 **
10585 ** This object is intended to be opaque outside of the where.c module.
10586 ** It is included here only so that that compiler will know how big it
10587 ** is.  None of the fields in this object should be used outside of
10588 ** the where.c module.
10589 **
10590 ** Within the union, pIdx is only used when wsFlags&WHERE_INDEXED is true.
10591 ** pTerm is only used when wsFlags&WHERE_MULTI_OR is true.  And pVtabIdx
10592 ** is only used when wsFlags&WHERE_VIRTUALTABLE is true.  It is never the
10593 ** case that more than one of these conditions is true.
10594 */
10595 struct WherePlan {
10596   u32 wsFlags;                   /* WHERE_* flags that describe the strategy */
10597   u32 nEq;                       /* Number of == constraints */
10598   double nRow;                   /* Estimated number of rows (for EQP) */
10599   union {
10600     Index *pIdx;                   /* Index when WHERE_INDEXED is true */
10601     struct WhereTerm *pTerm;       /* WHERE clause term for OR-search */
10602     sqlcipher3_index_info *pVtabIdx;  /* Virtual table index to use */
10603   } u;
10604 };
10605
10606 /*
10607 ** For each nested loop in a WHERE clause implementation, the WhereInfo
10608 ** structure contains a single instance of this structure.  This structure
10609 ** is intended to be private the the where.c module and should not be
10610 ** access or modified by other modules.
10611 **
10612 ** The pIdxInfo field is used to help pick the best index on a
10613 ** virtual table.  The pIdxInfo pointer contains indexing
10614 ** information for the i-th table in the FROM clause before reordering.
10615 ** All the pIdxInfo pointers are freed by whereInfoFree() in where.c.
10616 ** All other information in the i-th WhereLevel object for the i-th table
10617 ** after FROM clause ordering.
10618 */
10619 struct WhereLevel {
10620   WherePlan plan;       /* query plan for this element of the FROM clause */
10621   int iLeftJoin;        /* Memory cell used to implement LEFT OUTER JOIN */
10622   int iTabCur;          /* The VDBE cursor used to access the table */
10623   int iIdxCur;          /* The VDBE cursor used to access pIdx */
10624   int addrBrk;          /* Jump here to break out of the loop */
10625   int addrNxt;          /* Jump here to start the next IN combination */
10626   int addrCont;         /* Jump here to continue with the next loop cycle */
10627   int addrFirst;        /* First instruction of interior of the loop */
10628   u8 iFrom;             /* Which entry in the FROM clause */
10629   u8 op, p5;            /* Opcode and P5 of the opcode that ends the loop */
10630   int p1, p2;           /* Operands of the opcode used to ends the loop */
10631   union {               /* Information that depends on plan.wsFlags */
10632     struct {
10633       int nIn;              /* Number of entries in aInLoop[] */
10634       struct InLoop {
10635         int iCur;              /* The VDBE cursor used by this IN operator */
10636         int addrInTop;         /* Top of the IN loop */
10637       } *aInLoop;           /* Information about each nested IN operator */
10638     } in;                 /* Used when plan.wsFlags&WHERE_IN_ABLE */
10639   } u;
10640
10641   /* The following field is really not part of the current level.  But
10642   ** we need a place to cache virtual table index information for each
10643   ** virtual table in the FROM clause and the WhereLevel structure is
10644   ** a convenient place since there is one WhereLevel for each FROM clause
10645   ** element.
10646   */
10647   sqlcipher3_index_info *pIdxInfo;  /* Index info for n-th source table */
10648 };
10649
10650 /*
10651 ** Flags appropriate for the wctrlFlags parameter of sqlcipher3WhereBegin()
10652 ** and the WhereInfo.wctrlFlags member.
10653 */
10654 #define WHERE_ORDERBY_NORMAL   0x0000 /* No-op */
10655 #define WHERE_ORDERBY_MIN      0x0001 /* ORDER BY processing for min() func */
10656 #define WHERE_ORDERBY_MAX      0x0002 /* ORDER BY processing for max() func */
10657 #define WHERE_ONEPASS_DESIRED  0x0004 /* Want to do one-pass UPDATE/DELETE */
10658 #define WHERE_DUPLICATES_OK    0x0008 /* Ok to return a row more than once */
10659 #define WHERE_OMIT_OPEN_CLOSE  0x0010 /* Table cursors are already open */
10660 #define WHERE_FORCE_TABLE      0x0020 /* Do not use an index-only search */
10661 #define WHERE_ONETABLE_ONLY    0x0040 /* Only code the 1st table in pTabList */
10662 #define WHERE_AND_ONLY         0x0080 /* Don't use indices for OR terms */
10663
10664 /*
10665 ** The WHERE clause processing routine has two halves.  The
10666 ** first part does the start of the WHERE loop and the second
10667 ** half does the tail of the WHERE loop.  An instance of
10668 ** this structure is returned by the first half and passed
10669 ** into the second half to give some continuity.
10670 */
10671 struct WhereInfo {
10672   Parse *pParse;       /* Parsing and code generating context */
10673   u16 wctrlFlags;      /* Flags originally passed to sqlcipher3WhereBegin() */
10674   u8 okOnePass;        /* Ok to use one-pass algorithm for UPDATE or DELETE */
10675   u8 untestedTerms;    /* Not all WHERE terms resolved by outer loop */
10676   u8 eDistinct;
10677   SrcList *pTabList;             /* List of tables in the join */
10678   int iTop;                      /* The very beginning of the WHERE loop */
10679   int iContinue;                 /* Jump here to continue with next record */
10680   int iBreak;                    /* Jump here to break out of the loop */
10681   int nLevel;                    /* Number of nested loop */
10682   struct WhereClause *pWC;       /* Decomposition of the WHERE clause */
10683   double savedNQueryLoop;        /* pParse->nQueryLoop outside the WHERE loop */
10684   double nRowOut;                /* Estimated number of output rows */
10685   WhereLevel a[1];               /* Information about each nest loop in WHERE */
10686 };
10687
10688 #define WHERE_DISTINCT_UNIQUE 1
10689 #define WHERE_DISTINCT_ORDERED 2
10690
10691 /*
10692 ** A NameContext defines a context in which to resolve table and column
10693 ** names.  The context consists of a list of tables (the pSrcList) field and
10694 ** a list of named expression (pEList).  The named expression list may
10695 ** be NULL.  The pSrc corresponds to the FROM clause of a SELECT or
10696 ** to the table being operated on by INSERT, UPDATE, or DELETE.  The
10697 ** pEList corresponds to the result set of a SELECT and is NULL for
10698 ** other statements.
10699 **
10700 ** NameContexts can be nested.  When resolving names, the inner-most 
10701 ** context is searched first.  If no match is found, the next outer
10702 ** context is checked.  If there is still no match, the next context
10703 ** is checked.  This process continues until either a match is found
10704 ** or all contexts are check.  When a match is found, the nRef member of
10705 ** the context containing the match is incremented. 
10706 **
10707 ** Each subquery gets a new NameContext.  The pNext field points to the
10708 ** NameContext in the parent query.  Thus the process of scanning the
10709 ** NameContext list corresponds to searching through successively outer
10710 ** subqueries looking for a match.
10711 */
10712 struct NameContext {
10713   Parse *pParse;       /* The parser */
10714   SrcList *pSrcList;   /* One or more tables used to resolve names */
10715   ExprList *pEList;    /* Optional list of named expressions */
10716   int nRef;            /* Number of names resolved by this context */
10717   int nErr;            /* Number of errors encountered while resolving names */
10718   u8 allowAgg;         /* Aggregate functions allowed here */
10719   u8 hasAgg;           /* True if aggregates are seen */
10720   u8 isCheck;          /* True if resolving names in a CHECK constraint */
10721   int nDepth;          /* Depth of subquery recursion. 1 for no recursion */
10722   AggInfo *pAggInfo;   /* Information about aggregates at this level */
10723   NameContext *pNext;  /* Next outer name context.  NULL for outermost */
10724 };
10725
10726 /*
10727 ** An instance of the following structure contains all information
10728 ** needed to generate code for a single SELECT statement.
10729 **
10730 ** nLimit is set to -1 if there is no LIMIT clause.  nOffset is set to 0.
10731 ** If there is a LIMIT clause, the parser sets nLimit to the value of the
10732 ** limit and nOffset to the value of the offset (or 0 if there is not
10733 ** offset).  But later on, nLimit and nOffset become the memory locations
10734 ** in the VDBE that record the limit and offset counters.
10735 **
10736 ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
10737 ** These addresses must be stored so that we can go back and fill in
10738 ** the P4_KEYINFO and P2 parameters later.  Neither the KeyInfo nor
10739 ** the number of columns in P2 can be computed at the same time
10740 ** as the OP_OpenEphm instruction is coded because not
10741 ** enough information about the compound query is known at that point.
10742 ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
10743 ** for the result set.  The KeyInfo for addrOpenTran[2] contains collating
10744 ** sequences for the ORDER BY clause.
10745 */
10746 struct Select {
10747   ExprList *pEList;      /* The fields of the result */
10748   u8 op;                 /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
10749   char affinity;         /* MakeRecord with this affinity for SRT_Set */
10750   u16 selFlags;          /* Various SF_* values */
10751   SrcList *pSrc;         /* The FROM clause */
10752   Expr *pWhere;          /* The WHERE clause */
10753   ExprList *pGroupBy;    /* The GROUP BY clause */
10754   Expr *pHaving;         /* The HAVING clause */
10755   ExprList *pOrderBy;    /* The ORDER BY clause */
10756   Select *pPrior;        /* Prior select in a compound select statement */
10757   Select *pNext;         /* Next select to the left in a compound */
10758   Select *pRightmost;    /* Right-most select in a compound select statement */
10759   Expr *pLimit;          /* LIMIT expression. NULL means not used. */
10760   Expr *pOffset;         /* OFFSET expression. NULL means not used. */
10761   int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
10762   int addrOpenEphm[3];   /* OP_OpenEphem opcodes related to this select */
10763   double nSelectRow;     /* Estimated number of result rows */
10764 };
10765
10766 /*
10767 ** Allowed values for Select.selFlags.  The "SF" prefix stands for
10768 ** "Select Flag".
10769 */
10770 #define SF_Distinct        0x0001  /* Output should be DISTINCT */
10771 #define SF_Resolved        0x0002  /* Identifiers have been resolved */
10772 #define SF_Aggregate       0x0004  /* Contains aggregate functions */
10773 #define SF_UsesEphemeral   0x0008  /* Uses the OpenEphemeral opcode */
10774 #define SF_Expanded        0x0010  /* sqlcipher3SelectExpand() called on this */
10775 #define SF_HasTypeInfo     0x0020  /* FROM subqueries have Table metadata */
10776 #define SF_UseSorter       0x0040  /* Sort using a sorter */
10777
10778
10779 /*
10780 ** The results of a select can be distributed in several ways.  The
10781 ** "SRT" prefix means "SELECT Result Type".
10782 */
10783 #define SRT_Union        1  /* Store result as keys in an index */
10784 #define SRT_Except       2  /* Remove result from a UNION index */
10785 #define SRT_Exists       3  /* Store 1 if the result is not empty */
10786 #define SRT_Discard      4  /* Do not save the results anywhere */
10787
10788 /* The ORDER BY clause is ignored for all of the above */
10789 #define IgnorableOrderby(X) ((X->eDest)<=SRT_Discard)
10790
10791 #define SRT_Output       5  /* Output each row of result */
10792 #define SRT_Mem          6  /* Store result in a memory cell */
10793 #define SRT_Set          7  /* Store results as keys in an index */
10794 #define SRT_Table        8  /* Store result as data with an automatic rowid */
10795 #define SRT_EphemTab     9  /* Create transient tab and store like SRT_Table */
10796 #define SRT_Coroutine   10  /* Generate a single row of result */
10797
10798 /*
10799 ** A structure used to customize the behavior of sqlcipher3Select(). See
10800 ** comments above sqlcipher3Select() for details.
10801 */
10802 typedef struct SelectDest SelectDest;
10803 struct SelectDest {
10804   u8 eDest;         /* How to dispose of the results */
10805   u8 affinity;      /* Affinity used when eDest==SRT_Set */
10806   int iParm;        /* A parameter used by the eDest disposal method */
10807   int iMem;         /* Base register where results are written */
10808   int nMem;         /* Number of registers allocated */
10809 };
10810
10811 /*
10812 ** During code generation of statements that do inserts into AUTOINCREMENT 
10813 ** tables, the following information is attached to the Table.u.autoInc.p
10814 ** pointer of each autoincrement table to record some side information that
10815 ** the code generator needs.  We have to keep per-table autoincrement
10816 ** information in case inserts are down within triggers.  Triggers do not
10817 ** normally coordinate their activities, but we do need to coordinate the
10818 ** loading and saving of autoincrement information.
10819 */
10820 struct AutoincInfo {
10821   AutoincInfo *pNext;   /* Next info block in a list of them all */
10822   Table *pTab;          /* Table this info block refers to */
10823   int iDb;              /* Index in sqlcipher3.aDb[] of database holding pTab */
10824   int regCtr;           /* Memory register holding the rowid counter */
10825 };
10826
10827 /*
10828 ** Size of the column cache
10829 */
10830 #ifndef SQLCIPHER_N_COLCACHE
10831 # define SQLCIPHER_N_COLCACHE 10
10832 #endif
10833
10834 /*
10835 ** At least one instance of the following structure is created for each 
10836 ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
10837 ** statement. All such objects are stored in the linked list headed at
10838 ** Parse.pTriggerPrg and deleted once statement compilation has been
10839 ** completed.
10840 **
10841 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
10842 ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
10843 ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
10844 ** The Parse.pTriggerPrg list never contains two entries with the same
10845 ** values for both pTrigger and orconf.
10846 **
10847 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
10848 ** accessed (or set to 0 for triggers fired as a result of INSERT 
10849 ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
10850 ** a mask of new.* columns used by the program.
10851 */
10852 struct TriggerPrg {
10853   Trigger *pTrigger;      /* Trigger this program was coded from */
10854   int orconf;             /* Default ON CONFLICT policy */
10855   SubProgram *pProgram;   /* Program implementing pTrigger/orconf */
10856   u32 aColmask[2];        /* Masks of old.*, new.* columns accessed */
10857   TriggerPrg *pNext;      /* Next entry in Parse.pTriggerPrg list */
10858 };
10859
10860 /*
10861 ** The yDbMask datatype for the bitmask of all attached databases.
10862 */
10863 #if SQLCIPHER_MAX_ATTACHED>30
10864   typedef sqlcipher3_uint64 yDbMask;
10865 #else
10866   typedef unsigned int yDbMask;
10867 #endif
10868
10869 /*
10870 ** An SQL parser context.  A copy of this structure is passed through
10871 ** the parser and down into all the parser action routine in order to
10872 ** carry around information that is global to the entire parse.
10873 **
10874 ** The structure is divided into two parts.  When the parser and code
10875 ** generate call themselves recursively, the first part of the structure
10876 ** is constant but the second part is reset at the beginning and end of
10877 ** each recursion.
10878 **
10879 ** The nTableLock and aTableLock variables are only used if the shared-cache 
10880 ** feature is enabled (if sqlcipher3Tsd()->useSharedData is true). They are
10881 ** used to store the set of table-locks required by the statement being
10882 ** compiled. Function sqlcipher3TableLock() is used to add entries to the
10883 ** list.
10884 */
10885 struct Parse {
10886   sqlcipher3 *db;         /* The main database structure */
10887   int rc;              /* Return code from execution */
10888   char *zErrMsg;       /* An error message */
10889   Vdbe *pVdbe;         /* An engine for executing database bytecode */
10890   u8 colNamesSet;      /* TRUE after OP_ColumnName has been issued to pVdbe */
10891   u8 nameClash;        /* A permanent table name clashes with temp table name */
10892   u8 checkSchema;      /* Causes schema cookie check after an error */
10893   u8 nested;           /* Number of nested calls to the parser/code generator */
10894   u8 parseError;       /* True after a parsing error.  Ticket #1794 */
10895   u8 nTempReg;         /* Number of temporary registers in aTempReg[] */
10896   u8 nTempInUse;       /* Number of aTempReg[] currently checked out */
10897   int aTempReg[8];     /* Holding area for temporary registers */
10898   int nRangeReg;       /* Size of the temporary register block */
10899   int iRangeReg;       /* First register in temporary register block */
10900   int nErr;            /* Number of errors seen */
10901   int nTab;            /* Number of previously allocated VDBE cursors */
10902   int nMem;            /* Number of memory cells used so far */
10903   int nSet;            /* Number of sets used so far */
10904   int ckBase;          /* Base register of data during check constraints */
10905   int iCacheLevel;     /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
10906   int iCacheCnt;       /* Counter used to generate aColCache[].lru values */
10907   u8 nColCache;        /* Number of entries in the column cache */
10908   u8 iColCache;        /* Next entry of the cache to replace */
10909   struct yColCache {
10910     int iTable;           /* Table cursor number */
10911     int iColumn;          /* Table column number */
10912     u8 tempReg;           /* iReg is a temp register that needs to be freed */
10913     int iLevel;           /* Nesting level */
10914     int iReg;             /* Reg with value of this column. 0 means none. */
10915     int lru;              /* Least recently used entry has the smallest value */
10916   } aColCache[SQLCIPHER_N_COLCACHE];  /* One for each column cache entry */
10917   yDbMask writeMask;   /* Start a write transaction on these databases */
10918   yDbMask cookieMask;  /* Bitmask of schema verified databases */
10919   u8 isMultiWrite;     /* True if statement may affect/insert multiple rows */
10920   u8 mayAbort;         /* True if statement may throw an ABORT exception */
10921   int cookieGoto;      /* Address of OP_Goto to cookie verifier subroutine */
10922   int cookieValue[SQLCIPHER_MAX_ATTACHED+2];  /* Values of cookies to verify */
10923 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
10924   int nTableLock;        /* Number of locks in aTableLock */
10925   TableLock *aTableLock; /* Required table locks for shared-cache mode */
10926 #endif
10927   int regRowid;        /* Register holding rowid of CREATE TABLE entry */
10928   int regRoot;         /* Register holding root page number for new objects */
10929   AutoincInfo *pAinc;  /* Information about AUTOINCREMENT counters */
10930   int nMaxArg;         /* Max args passed to user function by sub-program */
10931
10932   /* Information used while coding trigger programs. */
10933   Parse *pToplevel;    /* Parse structure for main program (or NULL) */
10934   Table *pTriggerTab;  /* Table triggers are being coded for */
10935   u32 oldmask;         /* Mask of old.* columns referenced */
10936   u32 newmask;         /* Mask of new.* columns referenced */
10937   u8 eTriggerOp;       /* TK_UPDATE, TK_INSERT or TK_DELETE */
10938   u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */
10939   u8 disableTriggers;  /* True to disable triggers */
10940   double nQueryLoop;   /* Estimated number of iterations of a query */
10941
10942   /* Above is constant between recursions.  Below is reset before and after
10943   ** each recursion */
10944
10945   int nVar;            /* Number of '?' variables seen in the SQL so far */
10946   int nzVar;           /* Number of available slots in azVar[] */
10947   char **azVar;        /* Pointers to names of parameters */
10948   Vdbe *pReprepare;    /* VM being reprepared (sqlcipher3Reprepare()) */
10949   int nAlias;          /* Number of aliased result set columns */
10950   int nAliasAlloc;     /* Number of allocated slots for aAlias[] */
10951   int *aAlias;         /* Register used to hold aliased result */
10952   u8 explain;          /* True if the EXPLAIN flag is found on the query */
10953   Token sNameToken;    /* Token with unqualified schema object name */
10954   Token sLastToken;    /* The last token parsed */
10955   const char *zTail;   /* All SQL text past the last semicolon parsed */
10956   Table *pNewTable;    /* A table being constructed by CREATE TABLE */
10957   Trigger *pNewTrigger;     /* Trigger under construct by a CREATE TRIGGER */
10958   const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
10959 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
10960   Token sArg;                /* Complete text of a module argument */
10961   u8 declareVtab;            /* True if inside sqlcipher3_declare_vtab() */
10962   int nVtabLock;             /* Number of virtual tables to lock */
10963   Table **apVtabLock;        /* Pointer to virtual tables needing locking */
10964 #endif
10965   int nHeight;            /* Expression tree height of current sub-select */
10966   Table *pZombieTab;      /* List of Table objects to delete after code gen */
10967   TriggerPrg *pTriggerPrg;    /* Linked list of coded triggers */
10968
10969 #ifndef SQLCIPHER_OMIT_EXPLAIN
10970   int iSelectId;
10971   int iNextSelectId;
10972 #endif
10973 };
10974
10975 #ifdef SQLCIPHER_OMIT_VIRTUALTABLE
10976   #define IN_DECLARE_VTAB 0
10977 #else
10978   #define IN_DECLARE_VTAB (pParse->declareVtab)
10979 #endif
10980
10981 /*
10982 ** An instance of the following structure can be declared on a stack and used
10983 ** to save the Parse.zAuthContext value so that it can be restored later.
10984 */
10985 struct AuthContext {
10986   const char *zAuthContext;   /* Put saved Parse.zAuthContext here */
10987   Parse *pParse;              /* The Parse structure */
10988 };
10989
10990 /*
10991 ** Bitfield flags for P5 value in OP_Insert and OP_Delete
10992 */
10993 #define OPFLAG_NCHANGE       0x01    /* Set to update db->nChange */
10994 #define OPFLAG_LASTROWID     0x02    /* Set to update db->lastRowid */
10995 #define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */
10996 #define OPFLAG_APPEND        0x08    /* This is likely to be an append */
10997 #define OPFLAG_USESEEKRESULT 0x10    /* Try to avoid a seek in BtreeInsert() */
10998 #define OPFLAG_CLEARCACHE    0x20    /* Clear pseudo-table cache in OP_Column */
10999
11000 /*
11001  * Each trigger present in the database schema is stored as an instance of
11002  * struct Trigger. 
11003  *
11004  * Pointers to instances of struct Trigger are stored in two ways.
11005  * 1. In the "trigHash" hash table (part of the sqlcipher3* that represents the 
11006  *    database). This allows Trigger structures to be retrieved by name.
11007  * 2. All triggers associated with a single table form a linked list, using the
11008  *    pNext member of struct Trigger. A pointer to the first element of the
11009  *    linked list is stored as the "pTrigger" member of the associated
11010  *    struct Table.
11011  *
11012  * The "step_list" member points to the first element of a linked list
11013  * containing the SQL statements specified as the trigger program.
11014  */
11015 struct Trigger {
11016   char *zName;            /* The name of the trigger                        */
11017   char *table;            /* The table or view to which the trigger applies */
11018   u8 op;                  /* One of TK_DELETE, TK_UPDATE, TK_INSERT         */
11019   u8 tr_tm;               /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
11020   Expr *pWhen;            /* The WHEN clause of the expression (may be NULL) */
11021   IdList *pColumns;       /* If this is an UPDATE OF <column-list> trigger,
11022                              the <column-list> is stored here */
11023   Schema *pSchema;        /* Schema containing the trigger */
11024   Schema *pTabSchema;     /* Schema containing the table */
11025   TriggerStep *step_list; /* Link list of trigger program steps             */
11026   Trigger *pNext;         /* Next trigger associated with the table */
11027 };
11028
11029 /*
11030 ** A trigger is either a BEFORE or an AFTER trigger.  The following constants
11031 ** determine which. 
11032 **
11033 ** If there are multiple triggers, you might of some BEFORE and some AFTER.
11034 ** In that cases, the constants below can be ORed together.
11035 */
11036 #define TRIGGER_BEFORE  1
11037 #define TRIGGER_AFTER   2
11038
11039 /*
11040  * An instance of struct TriggerStep is used to store a single SQL statement
11041  * that is a part of a trigger-program. 
11042  *
11043  * Instances of struct TriggerStep are stored in a singly linked list (linked
11044  * using the "pNext" member) referenced by the "step_list" member of the 
11045  * associated struct Trigger instance. The first element of the linked list is
11046  * the first step of the trigger-program.
11047  * 
11048  * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
11049  * "SELECT" statement. The meanings of the other members is determined by the 
11050  * value of "op" as follows:
11051  *
11052  * (op == TK_INSERT)
11053  * orconf    -> stores the ON CONFLICT algorithm
11054  * pSelect   -> If this is an INSERT INTO ... SELECT ... statement, then
11055  *              this stores a pointer to the SELECT statement. Otherwise NULL.
11056  * target    -> A token holding the quoted name of the table to insert into.
11057  * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
11058  *              this stores values to be inserted. Otherwise NULL.
11059  * pIdList   -> If this is an INSERT INTO ... (<column-names>) VALUES ... 
11060  *              statement, then this stores the column-names to be
11061  *              inserted into.
11062  *
11063  * (op == TK_DELETE)
11064  * target    -> A token holding the quoted name of the table to delete from.
11065  * pWhere    -> The WHERE clause of the DELETE statement if one is specified.
11066  *              Otherwise NULL.
11067  * 
11068  * (op == TK_UPDATE)
11069  * target    -> A token holding the quoted name of the table to update rows of.
11070  * pWhere    -> The WHERE clause of the UPDATE statement if one is specified.
11071  *              Otherwise NULL.
11072  * pExprList -> A list of the columns to update and the expressions to update
11073  *              them to. See sqlcipher3Update() documentation of "pChanges"
11074  *              argument.
11075  * 
11076  */
11077 struct TriggerStep {
11078   u8 op;               /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
11079   u8 orconf;           /* OE_Rollback etc. */
11080   Trigger *pTrig;      /* The trigger that this step is a part of */
11081   Select *pSelect;     /* SELECT statment or RHS of INSERT INTO .. SELECT ... */
11082   Token target;        /* Target table for DELETE, UPDATE, INSERT */
11083   Expr *pWhere;        /* The WHERE clause for DELETE or UPDATE steps */
11084   ExprList *pExprList; /* SET clause for UPDATE.  VALUES clause for INSERT */
11085   IdList *pIdList;     /* Column names for INSERT */
11086   TriggerStep *pNext;  /* Next in the link-list */
11087   TriggerStep *pLast;  /* Last element in link-list. Valid for 1st elem only */
11088 };
11089
11090 /*
11091 ** The following structure contains information used by the sqlcipherFix...
11092 ** routines as they walk the parse tree to make database references
11093 ** explicit.  
11094 */
11095 typedef struct DbFixer DbFixer;
11096 struct DbFixer {
11097   Parse *pParse;      /* The parsing context.  Error messages written here */
11098   const char *zDb;    /* Make sure all objects are contained in this database */
11099   const char *zType;  /* Type of the container - used for error messages */
11100   const Token *pName; /* Name of the container - used for error messages */
11101 };
11102
11103 /*
11104 ** An objected used to accumulate the text of a string where we
11105 ** do not necessarily know how big the string will be in the end.
11106 */
11107 struct StrAccum {
11108   sqlcipher3 *db;         /* Optional database for lookaside.  Can be NULL */
11109   char *zBase;         /* A base allocation.  Not from malloc. */
11110   char *zText;         /* The string collected so far */
11111   int  nChar;          /* Length of the string so far */
11112   int  nAlloc;         /* Amount of space allocated in zText */
11113   int  mxAlloc;        /* Maximum allowed string length */
11114   u8   mallocFailed;   /* Becomes true if any memory allocation fails */
11115   u8   useMalloc;      /* 0: none,  1: sqlcipher3DbMalloc,  2: sqlcipher3_malloc */
11116   u8   tooBig;         /* Becomes true if string size exceeds limits */
11117 };
11118
11119 /*
11120 ** A pointer to this structure is used to communicate information
11121 ** from sqlcipher3Init and OP_ParseSchema into the sqlcipher3InitCallback.
11122 */
11123 typedef struct {
11124   sqlcipher3 *db;        /* The database being initialized */
11125   int iDb;            /* 0 for main database.  1 for TEMP, 2.. for ATTACHed */
11126   char **pzErrMsg;    /* Error message stored here */
11127   int rc;             /* Result code stored here */
11128 } InitData;
11129
11130 /*
11131 ** Structure containing global configuration data for the SQLite library.
11132 **
11133 ** This structure also contains some state information.
11134 */
11135 struct Sqlite3Config {
11136   int bMemstat;                     /* True to enable memory status */
11137   int bCoreMutex;                   /* True to enable core mutexing */
11138   int bFullMutex;                   /* True to enable full mutexing */
11139   int bOpenUri;                     /* True to interpret filenames as URIs */
11140   int mxStrlen;                     /* Maximum string length */
11141   int szLookaside;                  /* Default lookaside buffer size */
11142   int nLookaside;                   /* Default lookaside buffer count */
11143   sqlcipher3_mem_methods m;            /* Low-level memory allocation interface */
11144   sqlcipher3_mutex_methods mutex;      /* Low-level mutex interface */
11145   sqlcipher3_pcache_methods pcache;    /* Low-level page-cache interface */
11146   void *pHeap;                      /* Heap storage space */
11147   int nHeap;                        /* Size of pHeap[] */
11148   int mnReq, mxReq;                 /* Min and max heap requests sizes */
11149   void *pScratch;                   /* Scratch memory */
11150   int szScratch;                    /* Size of each scratch buffer */
11151   int nScratch;                     /* Number of scratch buffers */
11152   void *pPage;                      /* Page cache memory */
11153   int szPage;                       /* Size of each page in pPage[] */
11154   int nPage;                        /* Number of pages in pPage[] */
11155   int mxParserStack;                /* maximum depth of the parser stack */
11156   int sharedCacheEnabled;           /* true if shared-cache mode enabled */
11157   /* The above might be initialized to non-zero.  The following need to always
11158   ** initially be zero, however. */
11159   int isInit;                       /* True after initialization has finished */
11160   int inProgress;                   /* True while initialization in progress */
11161   int isMutexInit;                  /* True after mutexes are initialized */
11162   int isMallocInit;                 /* True after malloc is initialized */
11163   int isPCacheInit;                 /* True after malloc is initialized */
11164   sqlcipher3_mutex *pInitMutex;        /* Mutex used by sqlcipher3_initialize() */
11165   int nRefInitMutex;                /* Number of users of pInitMutex */
11166   void (*xLog)(void*,int,const char*); /* Function for logging */
11167   void *pLogArg;                       /* First argument to xLog() */
11168   int bLocaltimeFault;              /* True to fail localtime() calls */
11169 };
11170
11171 /*
11172 ** Context pointer passed down through the tree-walk.
11173 */
11174 struct Walker {
11175   int (*xExprCallback)(Walker*, Expr*);     /* Callback for expressions */
11176   int (*xSelectCallback)(Walker*,Select*);  /* Callback for SELECTs */
11177   Parse *pParse;                            /* Parser context.  */
11178   union {                                   /* Extra data for callback */
11179     NameContext *pNC;                          /* Naming context */
11180     int i;                                     /* Integer value */
11181   } u;
11182 };
11183
11184 /* Forward declarations */
11185 SQLCIPHER_PRIVATE int sqlcipher3WalkExpr(Walker*, Expr*);
11186 SQLCIPHER_PRIVATE int sqlcipher3WalkExprList(Walker*, ExprList*);
11187 SQLCIPHER_PRIVATE int sqlcipher3WalkSelect(Walker*, Select*);
11188 SQLCIPHER_PRIVATE int sqlcipher3WalkSelectExpr(Walker*, Select*);
11189 SQLCIPHER_PRIVATE int sqlcipher3WalkSelectFrom(Walker*, Select*);
11190
11191 /*
11192 ** Return code from the parse-tree walking primitives and their
11193 ** callbacks.
11194 */
11195 #define WRC_Continue    0   /* Continue down into children */
11196 #define WRC_Prune       1   /* Omit children but continue walking siblings */
11197 #define WRC_Abort       2   /* Abandon the tree walk */
11198
11199 /*
11200 ** Assuming zIn points to the first byte of a UTF-8 character,
11201 ** advance zIn to point to the first byte of the next UTF-8 character.
11202 */
11203 #define SQLCIPHER_SKIP_UTF8(zIn) {                        \
11204   if( (*(zIn++))>=0xc0 ){                              \
11205     while( (*zIn & 0xc0)==0x80 ){ zIn++; }             \
11206   }                                                    \
11207 }
11208
11209 /*
11210 ** The SQLCIPHER_*_BKPT macros are substitutes for the error codes with
11211 ** the same name but without the _BKPT suffix.  These macros invoke
11212 ** routines that report the line-number on which the error originated
11213 ** using sqlcipher3_log().  The routines also provide a convenient place
11214 ** to set a debugger breakpoint.
11215 */
11216 SQLCIPHER_PRIVATE int sqlcipher3CorruptError(int);
11217 SQLCIPHER_PRIVATE int sqlcipher3MisuseError(int);
11218 SQLCIPHER_PRIVATE int sqlcipher3CantopenError(int);
11219 #define SQLCIPHER_CORRUPT_BKPT sqlcipher3CorruptError(__LINE__)
11220 #define SQLCIPHER_MISUSE_BKPT sqlcipher3MisuseError(__LINE__)
11221 #define SQLCIPHER_CANTOPEN_BKPT sqlcipher3CantopenError(__LINE__)
11222
11223
11224 /*
11225 ** FTS4 is really an extension for FTS3.  It is enabled using the
11226 ** SQLCIPHER_ENABLE_FTS3 macro.  But to avoid confusion we also all
11227 ** the SQLCIPHER_ENABLE_FTS4 macro to serve as an alisse for SQLCIPHER_ENABLE_FTS3.
11228 */
11229 #if defined(SQLCIPHER_ENABLE_FTS4) && !defined(SQLCIPHER_ENABLE_FTS3)
11230 # define SQLCIPHER_ENABLE_FTS3
11231 #endif
11232
11233 /*
11234 ** The ctype.h header is needed for non-ASCII systems.  It is also
11235 ** needed by FTS3 when FTS3 is included in the amalgamation.
11236 */
11237 #if !defined(SQLCIPHER_ASCII) || \
11238     (defined(SQLCIPHER_ENABLE_FTS3) && defined(SQLCIPHER_AMALGAMATION))
11239 # include <ctype.h>
11240 #endif
11241
11242 /*
11243 ** The following macros mimic the standard library functions toupper(),
11244 ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
11245 ** sqlcipher versions only work for ASCII characters, regardless of locale.
11246 */
11247 #ifdef SQLCIPHER_ASCII
11248 # define sqlcipher3Toupper(x)  ((x)&~(sqlcipher3CtypeMap[(unsigned char)(x)]&0x20))
11249 # define sqlcipher3Isspace(x)   (sqlcipher3CtypeMap[(unsigned char)(x)]&0x01)
11250 # define sqlcipher3Isalnum(x)   (sqlcipher3CtypeMap[(unsigned char)(x)]&0x06)
11251 # define sqlcipher3Isalpha(x)   (sqlcipher3CtypeMap[(unsigned char)(x)]&0x02)
11252 # define sqlcipher3Isdigit(x)   (sqlcipher3CtypeMap[(unsigned char)(x)]&0x04)
11253 # define sqlcipher3Isxdigit(x)  (sqlcipher3CtypeMap[(unsigned char)(x)]&0x08)
11254 # define sqlcipher3Tolower(x)   (sqlcipher3UpperToLower[(unsigned char)(x)])
11255 #else
11256 # define sqlcipher3Toupper(x)   toupper((unsigned char)(x))
11257 # define sqlcipher3Isspace(x)   isspace((unsigned char)(x))
11258 # define sqlcipher3Isalnum(x)   isalnum((unsigned char)(x))
11259 # define sqlcipher3Isalpha(x)   isalpha((unsigned char)(x))
11260 # define sqlcipher3Isdigit(x)   isdigit((unsigned char)(x))
11261 # define sqlcipher3Isxdigit(x)  isxdigit((unsigned char)(x))
11262 # define sqlcipher3Tolower(x)   tolower((unsigned char)(x))
11263 #endif
11264
11265 /*
11266 ** Internal function prototypes
11267 */
11268 SQLCIPHER_PRIVATE int sqlcipher3StrICmp(const char *, const char *);
11269 SQLCIPHER_PRIVATE int sqlcipher3Strlen30(const char*);
11270 #define sqlcipher3StrNICmp sqlcipher3_strnicmp
11271
11272 SQLCIPHER_PRIVATE int sqlcipher3MallocInit(void);
11273 SQLCIPHER_PRIVATE void sqlcipher3MallocEnd(void);
11274 SQLCIPHER_PRIVATE void *sqlcipher3Malloc(int);
11275 SQLCIPHER_PRIVATE void *sqlcipher3MallocZero(int);
11276 SQLCIPHER_PRIVATE void *sqlcipher3DbMallocZero(sqlcipher3*, int);
11277 SQLCIPHER_PRIVATE void *sqlcipher3DbMallocRaw(sqlcipher3*, int);
11278 SQLCIPHER_PRIVATE char *sqlcipher3DbStrDup(sqlcipher3*,const char*);
11279 SQLCIPHER_PRIVATE char *sqlcipher3DbStrNDup(sqlcipher3*,const char*, int);
11280 SQLCIPHER_PRIVATE void *sqlcipher3Realloc(void*, int);
11281 SQLCIPHER_PRIVATE void *sqlcipher3DbReallocOrFree(sqlcipher3 *, void *, int);
11282 SQLCIPHER_PRIVATE void *sqlcipher3DbRealloc(sqlcipher3 *, void *, int);
11283 SQLCIPHER_PRIVATE void sqlcipher3DbFree(sqlcipher3*, void*);
11284 SQLCIPHER_PRIVATE int sqlcipher3MallocSize(void*);
11285 SQLCIPHER_PRIVATE int sqlcipher3DbMallocSize(sqlcipher3*, void*);
11286 SQLCIPHER_PRIVATE void *sqlcipher3ScratchMalloc(int);
11287 SQLCIPHER_PRIVATE void sqlcipher3ScratchFree(void*);
11288 SQLCIPHER_PRIVATE void *sqlcipher3PageMalloc(int);
11289 SQLCIPHER_PRIVATE void sqlcipher3PageFree(void*);
11290 SQLCIPHER_PRIVATE void sqlcipher3MemSetDefault(void);
11291 SQLCIPHER_PRIVATE void sqlcipher3BenignMallocHooks(void (*)(void), void (*)(void));
11292 SQLCIPHER_PRIVATE int sqlcipher3HeapNearlyFull(void);
11293
11294 /*
11295 ** On systems with ample stack space and that support alloca(), make
11296 ** use of alloca() to obtain space for large automatic objects.  By default,
11297 ** obtain space from malloc().
11298 **
11299 ** The alloca() routine never returns NULL.  This will cause code paths
11300 ** that deal with sqlcipher3StackAlloc() failures to be unreachable.
11301 */
11302 #ifdef SQLCIPHER_USE_ALLOCA
11303 # define sqlcipher3StackAllocRaw(D,N)   alloca(N)
11304 # define sqlcipher3StackAllocZero(D,N)  memset(alloca(N), 0, N)
11305 # define sqlcipher3StackFree(D,P)       
11306 #else
11307 # define sqlcipher3StackAllocRaw(D,N)   sqlcipher3DbMallocRaw(D,N)
11308 # define sqlcipher3StackAllocZero(D,N)  sqlcipher3DbMallocZero(D,N)
11309 # define sqlcipher3StackFree(D,P)       sqlcipher3DbFree(D,P)
11310 #endif
11311
11312 #ifdef SQLCIPHER_ENABLE_MEMSYS3
11313 SQLCIPHER_PRIVATE const sqlcipher3_mem_methods *sqlcipher3MemGetMemsys3(void);
11314 #endif
11315 #ifdef SQLCIPHER_ENABLE_MEMSYS5
11316 SQLCIPHER_PRIVATE const sqlcipher3_mem_methods *sqlcipher3MemGetMemsys5(void);
11317 #endif
11318
11319
11320 #ifndef SQLCIPHER_MUTEX_OMIT
11321 SQLCIPHER_PRIVATE   sqlcipher3_mutex_methods const *sqlcipher3DefaultMutex(void);
11322 SQLCIPHER_PRIVATE   sqlcipher3_mutex_methods const *sqlcipher3NoopMutex(void);
11323 SQLCIPHER_PRIVATE   sqlcipher3_mutex *sqlcipher3MutexAlloc(int);
11324 SQLCIPHER_PRIVATE   int sqlcipher3MutexInit(void);
11325 SQLCIPHER_PRIVATE   int sqlcipher3MutexEnd(void);
11326 #endif
11327
11328 SQLCIPHER_PRIVATE int sqlcipher3StatusValue(int);
11329 SQLCIPHER_PRIVATE void sqlcipher3StatusAdd(int, int);
11330 SQLCIPHER_PRIVATE void sqlcipher3StatusSet(int, int);
11331
11332 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
11333 SQLCIPHER_PRIVATE   int sqlcipher3IsNaN(double);
11334 #else
11335 # define sqlcipher3IsNaN(X)  0
11336 #endif
11337
11338 SQLCIPHER_PRIVATE void sqlcipher3VXPrintf(StrAccum*, int, const char*, va_list);
11339 #ifndef SQLCIPHER_OMIT_TRACE
11340 SQLCIPHER_PRIVATE void sqlcipher3XPrintf(StrAccum*, const char*, ...);
11341 #endif
11342 SQLCIPHER_PRIVATE char *sqlcipher3MPrintf(sqlcipher3*,const char*, ...);
11343 SQLCIPHER_PRIVATE char *sqlcipher3VMPrintf(sqlcipher3*,const char*, va_list);
11344 SQLCIPHER_PRIVATE char *sqlcipher3MAppendf(sqlcipher3*,char*,const char*,...);
11345 #if defined(SQLCIPHER_TEST) || defined(SQLCIPHER_DEBUG)
11346 SQLCIPHER_PRIVATE   void sqlcipher3DebugPrintf(const char*, ...);
11347 #endif
11348 #if defined(SQLCIPHER_TEST)
11349 SQLCIPHER_PRIVATE   void *sqlcipher3TestTextToPtr(const char*);
11350 #endif
11351 SQLCIPHER_PRIVATE void sqlcipher3SetString(char **, sqlcipher3*, const char*, ...);
11352 SQLCIPHER_PRIVATE void sqlcipher3ErrorMsg(Parse*, const char*, ...);
11353 SQLCIPHER_PRIVATE int sqlcipher3Dequote(char*);
11354 SQLCIPHER_PRIVATE int sqlcipher3KeywordCode(const unsigned char*, int);
11355 SQLCIPHER_PRIVATE int sqlcipher3RunParser(Parse*, const char*, char **);
11356 SQLCIPHER_PRIVATE void sqlcipher3FinishCoding(Parse*);
11357 SQLCIPHER_PRIVATE int sqlcipher3GetTempReg(Parse*);
11358 SQLCIPHER_PRIVATE void sqlcipher3ReleaseTempReg(Parse*,int);
11359 SQLCIPHER_PRIVATE int sqlcipher3GetTempRange(Parse*,int);
11360 SQLCIPHER_PRIVATE void sqlcipher3ReleaseTempRange(Parse*,int,int);
11361 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprAlloc(sqlcipher3*,int,const Token*,int);
11362 SQLCIPHER_PRIVATE Expr *sqlcipher3Expr(sqlcipher3*,int,const char*);
11363 SQLCIPHER_PRIVATE void sqlcipher3ExprAttachSubtrees(sqlcipher3*,Expr*,Expr*,Expr*);
11364 SQLCIPHER_PRIVATE Expr *sqlcipher3PExpr(Parse*, int, Expr*, Expr*, const Token*);
11365 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprAnd(sqlcipher3*,Expr*, Expr*);
11366 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprFunction(Parse*,ExprList*, Token*);
11367 SQLCIPHER_PRIVATE void sqlcipher3ExprAssignVarNumber(Parse*, Expr*);
11368 SQLCIPHER_PRIVATE void sqlcipher3ExprDelete(sqlcipher3*, Expr*);
11369 SQLCIPHER_PRIVATE ExprList *sqlcipher3ExprListAppend(Parse*,ExprList*,Expr*);
11370 SQLCIPHER_PRIVATE void sqlcipher3ExprListSetName(Parse*,ExprList*,Token*,int);
11371 SQLCIPHER_PRIVATE void sqlcipher3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
11372 SQLCIPHER_PRIVATE void sqlcipher3ExprListDelete(sqlcipher3*, ExprList*);
11373 SQLCIPHER_PRIVATE int sqlcipher3Init(sqlcipher3*, char**);
11374 SQLCIPHER_PRIVATE int sqlcipher3InitCallback(void*, int, char**, char**);
11375 SQLCIPHER_PRIVATE void sqlcipher3Pragma(Parse*,Token*,Token*,Token*,int);
11376 SQLCIPHER_PRIVATE void sqlcipher3ResetInternalSchema(sqlcipher3*, int);
11377 SQLCIPHER_PRIVATE void sqlcipher3BeginParse(Parse*,int);
11378 SQLCIPHER_PRIVATE void sqlcipher3CommitInternalChanges(sqlcipher3*);
11379 SQLCIPHER_PRIVATE Table *sqlcipher3ResultSetOfSelect(Parse*,Select*);
11380 SQLCIPHER_PRIVATE void sqlcipher3OpenMasterTable(Parse *, int);
11381 SQLCIPHER_PRIVATE void sqlcipher3StartTable(Parse*,Token*,Token*,int,int,int,int);
11382 SQLCIPHER_PRIVATE void sqlcipher3AddColumn(Parse*,Token*);
11383 SQLCIPHER_PRIVATE void sqlcipher3AddNotNull(Parse*, int);
11384 SQLCIPHER_PRIVATE void sqlcipher3AddPrimaryKey(Parse*, ExprList*, int, int, int);
11385 SQLCIPHER_PRIVATE void sqlcipher3AddCheckConstraint(Parse*, Expr*);
11386 SQLCIPHER_PRIVATE void sqlcipher3AddColumnType(Parse*,Token*);
11387 SQLCIPHER_PRIVATE void sqlcipher3AddDefaultValue(Parse*,ExprSpan*);
11388 SQLCIPHER_PRIVATE void sqlcipher3AddCollateType(Parse*, Token*);
11389 SQLCIPHER_PRIVATE void sqlcipher3EndTable(Parse*,Token*,Token*,Select*);
11390 SQLCIPHER_PRIVATE int sqlcipher3ParseUri(const char*,const char*,unsigned int*,
11391                     sqlcipher3_vfs**,char**,char **);
11392
11393 SQLCIPHER_PRIVATE Bitvec *sqlcipher3BitvecCreate(u32);
11394 SQLCIPHER_PRIVATE int sqlcipher3BitvecTest(Bitvec*, u32);
11395 SQLCIPHER_PRIVATE int sqlcipher3BitvecSet(Bitvec*, u32);
11396 SQLCIPHER_PRIVATE void sqlcipher3BitvecClear(Bitvec*, u32, void*);
11397 SQLCIPHER_PRIVATE void sqlcipher3BitvecDestroy(Bitvec*);
11398 SQLCIPHER_PRIVATE u32 sqlcipher3BitvecSize(Bitvec*);
11399 SQLCIPHER_PRIVATE int sqlcipher3BitvecBuiltinTest(int,int*);
11400
11401 SQLCIPHER_PRIVATE RowSet *sqlcipher3RowSetInit(sqlcipher3*, void*, unsigned int);
11402 SQLCIPHER_PRIVATE void sqlcipher3RowSetClear(RowSet*);
11403 SQLCIPHER_PRIVATE void sqlcipher3RowSetInsert(RowSet*, i64);
11404 SQLCIPHER_PRIVATE int sqlcipher3RowSetTest(RowSet*, u8 iBatch, i64);
11405 SQLCIPHER_PRIVATE int sqlcipher3RowSetNext(RowSet*, i64*);
11406
11407 SQLCIPHER_PRIVATE void sqlcipher3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
11408
11409 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_VIRTUALTABLE)
11410 SQLCIPHER_PRIVATE   int sqlcipher3ViewGetColumnNames(Parse*,Table*);
11411 #else
11412 # define sqlcipher3ViewGetColumnNames(A,B) 0
11413 #endif
11414
11415 SQLCIPHER_PRIVATE void sqlcipher3DropTable(Parse*, SrcList*, int, int);
11416 SQLCIPHER_PRIVATE void sqlcipher3CodeDropTable(Parse*, Table*, int, int);
11417 SQLCIPHER_PRIVATE void sqlcipher3DeleteTable(sqlcipher3*, Table*);
11418 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
11419 SQLCIPHER_PRIVATE   void sqlcipher3AutoincrementBegin(Parse *pParse);
11420 SQLCIPHER_PRIVATE   void sqlcipher3AutoincrementEnd(Parse *pParse);
11421 #else
11422 # define sqlcipher3AutoincrementBegin(X)
11423 # define sqlcipher3AutoincrementEnd(X)
11424 #endif
11425 SQLCIPHER_PRIVATE void sqlcipher3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
11426 SQLCIPHER_PRIVATE void *sqlcipher3ArrayAllocate(sqlcipher3*,void*,int,int,int*,int*,int*);
11427 SQLCIPHER_PRIVATE IdList *sqlcipher3IdListAppend(sqlcipher3*, IdList*, Token*);
11428 SQLCIPHER_PRIVATE int sqlcipher3IdListIndex(IdList*,const char*);
11429 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListEnlarge(sqlcipher3*, SrcList*, int, int);
11430 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListAppend(sqlcipher3*, SrcList*, Token*, Token*);
11431 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
11432                                       Token*, Select*, Expr*, IdList*);
11433 SQLCIPHER_PRIVATE void sqlcipher3SrcListIndexedBy(Parse *, SrcList *, Token *);
11434 SQLCIPHER_PRIVATE int sqlcipher3IndexedByLookup(Parse *, struct SrcList_item *);
11435 SQLCIPHER_PRIVATE void sqlcipher3SrcListShiftJoinType(SrcList*);
11436 SQLCIPHER_PRIVATE void sqlcipher3SrcListAssignCursors(Parse*, SrcList*);
11437 SQLCIPHER_PRIVATE void sqlcipher3IdListDelete(sqlcipher3*, IdList*);
11438 SQLCIPHER_PRIVATE void sqlcipher3SrcListDelete(sqlcipher3*, SrcList*);
11439 SQLCIPHER_PRIVATE Index *sqlcipher3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
11440                         Token*, int, int);
11441 SQLCIPHER_PRIVATE void sqlcipher3DropIndex(Parse*, SrcList*, int);
11442 SQLCIPHER_PRIVATE int sqlcipher3Select(Parse*, Select*, SelectDest*);
11443 SQLCIPHER_PRIVATE Select *sqlcipher3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
11444                          Expr*,ExprList*,int,Expr*,Expr*);
11445 SQLCIPHER_PRIVATE void sqlcipher3SelectDelete(sqlcipher3*, Select*);
11446 SQLCIPHER_PRIVATE Table *sqlcipher3SrcListLookup(Parse*, SrcList*);
11447 SQLCIPHER_PRIVATE int sqlcipher3IsReadOnly(Parse*, Table*, int);
11448 SQLCIPHER_PRIVATE void sqlcipher3OpenTable(Parse*, int iCur, int iDb, Table*, int);
11449 #if defined(SQLCIPHER_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLCIPHER_OMIT_SUBQUERY)
11450 SQLCIPHER_PRIVATE Expr *sqlcipher3LimitWhere(Parse *, SrcList *, Expr *, ExprList *, Expr *, Expr *, char *);
11451 #endif
11452 SQLCIPHER_PRIVATE void sqlcipher3DeleteFrom(Parse*, SrcList*, Expr*);
11453 SQLCIPHER_PRIVATE void sqlcipher3Update(Parse*, SrcList*, ExprList*, Expr*, int);
11454 SQLCIPHER_PRIVATE WhereInfo *sqlcipher3WhereBegin(Parse*, SrcList*, Expr*, ExprList**,ExprList*,u16);
11455 SQLCIPHER_PRIVATE void sqlcipher3WhereEnd(WhereInfo*);
11456 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeGetColumn(Parse*, Table*, int, int, int);
11457 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
11458 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeMove(Parse*, int, int, int);
11459 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeCopy(Parse*, int, int, int);
11460 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheStore(Parse*, int, int, int);
11461 SQLCIPHER_PRIVATE void sqlcipher3ExprCachePush(Parse*);
11462 SQLCIPHER_PRIVATE void sqlcipher3ExprCachePop(Parse*, int);
11463 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheRemove(Parse*, int, int);
11464 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheClear(Parse*);
11465 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheAffinityChange(Parse*, int, int);
11466 SQLCIPHER_PRIVATE int sqlcipher3ExprCode(Parse*, Expr*, int);
11467 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeTemp(Parse*, Expr*, int*);
11468 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeTarget(Parse*, Expr*, int);
11469 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeAndCache(Parse*, Expr*, int);
11470 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeConstants(Parse*, Expr*);
11471 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeExprList(Parse*, ExprList*, int, int);
11472 SQLCIPHER_PRIVATE void sqlcipher3ExprIfTrue(Parse*, Expr*, int, int);
11473 SQLCIPHER_PRIVATE void sqlcipher3ExprIfFalse(Parse*, Expr*, int, int);
11474 SQLCIPHER_PRIVATE Table *sqlcipher3FindTable(sqlcipher3*,const char*, const char*);
11475 SQLCIPHER_PRIVATE Table *sqlcipher3LocateTable(Parse*,int isView,const char*, const char*);
11476 SQLCIPHER_PRIVATE Index *sqlcipher3FindIndex(sqlcipher3*,const char*, const char*);
11477 SQLCIPHER_PRIVATE void sqlcipher3UnlinkAndDeleteTable(sqlcipher3*,int,const char*);
11478 SQLCIPHER_PRIVATE void sqlcipher3UnlinkAndDeleteIndex(sqlcipher3*,int,const char*);
11479 SQLCIPHER_PRIVATE void sqlcipher3Vacuum(Parse*);
11480 SQLCIPHER_PRIVATE int sqlcipher3RunVacuum(char**, sqlcipher3*);
11481 SQLCIPHER_PRIVATE char *sqlcipher3NameFromToken(sqlcipher3*, Token*);
11482 SQLCIPHER_PRIVATE int sqlcipher3ExprCompare(Expr*, Expr*);
11483 SQLCIPHER_PRIVATE int sqlcipher3ExprListCompare(ExprList*, ExprList*);
11484 SQLCIPHER_PRIVATE void sqlcipher3ExprAnalyzeAggregates(NameContext*, Expr*);
11485 SQLCIPHER_PRIVATE void sqlcipher3ExprAnalyzeAggList(NameContext*,ExprList*);
11486 SQLCIPHER_PRIVATE Vdbe *sqlcipher3GetVdbe(Parse*);
11487 SQLCIPHER_PRIVATE void sqlcipher3PrngSaveState(void);
11488 SQLCIPHER_PRIVATE void sqlcipher3PrngRestoreState(void);
11489 SQLCIPHER_PRIVATE void sqlcipher3PrngResetState(void);
11490 SQLCIPHER_PRIVATE void sqlcipher3RollbackAll(sqlcipher3*);
11491 SQLCIPHER_PRIVATE void sqlcipher3CodeVerifySchema(Parse*, int);
11492 SQLCIPHER_PRIVATE void sqlcipher3CodeVerifyNamedSchema(Parse*, const char *zDb);
11493 SQLCIPHER_PRIVATE void sqlcipher3BeginTransaction(Parse*, int);
11494 SQLCIPHER_PRIVATE void sqlcipher3CommitTransaction(Parse*);
11495 SQLCIPHER_PRIVATE void sqlcipher3RollbackTransaction(Parse*);
11496 SQLCIPHER_PRIVATE void sqlcipher3Savepoint(Parse*, int, Token*);
11497 SQLCIPHER_PRIVATE void sqlcipher3CloseSavepoints(sqlcipher3 *);
11498 SQLCIPHER_PRIVATE int sqlcipher3ExprIsConstant(Expr*);
11499 SQLCIPHER_PRIVATE int sqlcipher3ExprIsConstantNotJoin(Expr*);
11500 SQLCIPHER_PRIVATE int sqlcipher3ExprIsConstantOrFunction(Expr*);
11501 SQLCIPHER_PRIVATE int sqlcipher3ExprIsInteger(Expr*, int*);
11502 SQLCIPHER_PRIVATE int sqlcipher3ExprCanBeNull(const Expr*);
11503 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
11504 SQLCIPHER_PRIVATE int sqlcipher3ExprNeedsNoAffinityChange(const Expr*, char);
11505 SQLCIPHER_PRIVATE int sqlcipher3IsRowid(const char*);
11506 SQLCIPHER_PRIVATE void sqlcipher3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int);
11507 SQLCIPHER_PRIVATE void sqlcipher3GenerateRowIndexDelete(Parse*, Table*, int, int*);
11508 SQLCIPHER_PRIVATE int sqlcipher3GenerateIndexKey(Parse*, Index*, int, int, int);
11509 SQLCIPHER_PRIVATE void sqlcipher3GenerateConstraintChecks(Parse*,Table*,int,int,
11510                                      int*,int,int,int,int,int*);
11511 SQLCIPHER_PRIVATE void sqlcipher3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int);
11512 SQLCIPHER_PRIVATE int sqlcipher3OpenTableAndIndices(Parse*, Table*, int, int);
11513 SQLCIPHER_PRIVATE void sqlcipher3BeginWriteOperation(Parse*, int, int);
11514 SQLCIPHER_PRIVATE void sqlcipher3MultiWrite(Parse*);
11515 SQLCIPHER_PRIVATE void sqlcipher3MayAbort(Parse*);
11516 SQLCIPHER_PRIVATE void sqlcipher3HaltConstraint(Parse*, int, char*, int);
11517 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprDup(sqlcipher3*,Expr*,int);
11518 SQLCIPHER_PRIVATE ExprList *sqlcipher3ExprListDup(sqlcipher3*,ExprList*,int);
11519 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListDup(sqlcipher3*,SrcList*,int);
11520 SQLCIPHER_PRIVATE IdList *sqlcipher3IdListDup(sqlcipher3*,IdList*);
11521 SQLCIPHER_PRIVATE Select *sqlcipher3SelectDup(sqlcipher3*,Select*,int);
11522 SQLCIPHER_PRIVATE void sqlcipher3FuncDefInsert(FuncDefHash*, FuncDef*);
11523 SQLCIPHER_PRIVATE FuncDef *sqlcipher3FindFunction(sqlcipher3*,const char*,int,int,u8,int);
11524 SQLCIPHER_PRIVATE void sqlcipher3RegisterBuiltinFunctions(sqlcipher3*);
11525 SQLCIPHER_PRIVATE void sqlcipher3RegisterDateTimeFunctions(void);
11526 SQLCIPHER_PRIVATE void sqlcipher3RegisterGlobalFunctions(void);
11527 SQLCIPHER_PRIVATE int sqlcipher3SafetyCheckOk(sqlcipher3*);
11528 SQLCIPHER_PRIVATE int sqlcipher3SafetyCheckSickOrOk(sqlcipher3*);
11529 SQLCIPHER_PRIVATE void sqlcipher3ChangeCookie(Parse*, int);
11530
11531 #if !defined(SQLCIPHER_OMIT_VIEW) && !defined(SQLCIPHER_OMIT_TRIGGER)
11532 SQLCIPHER_PRIVATE void sqlcipher3MaterializeView(Parse*, Table*, Expr*, int);
11533 #endif
11534
11535 #ifndef SQLCIPHER_OMIT_TRIGGER
11536 SQLCIPHER_PRIVATE   void sqlcipher3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
11537                            Expr*,int, int);
11538 SQLCIPHER_PRIVATE   void sqlcipher3FinishTrigger(Parse*, TriggerStep*, Token*);
11539 SQLCIPHER_PRIVATE   void sqlcipher3DropTrigger(Parse*, SrcList*, int);
11540 SQLCIPHER_PRIVATE   void sqlcipher3DropTriggerPtr(Parse*, Trigger*);
11541 SQLCIPHER_PRIVATE   Trigger *sqlcipher3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask);
11542 SQLCIPHER_PRIVATE   Trigger *sqlcipher3TriggerList(Parse *, Table *);
11543 SQLCIPHER_PRIVATE   void sqlcipher3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
11544                             int, int, int);
11545 SQLCIPHER_PRIVATE   void sqlcipher3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
11546   void sqlcipherViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
11547 SQLCIPHER_PRIVATE   void sqlcipher3DeleteTriggerStep(sqlcipher3*, TriggerStep*);
11548 SQLCIPHER_PRIVATE   TriggerStep *sqlcipher3TriggerSelectStep(sqlcipher3*,Select*);
11549 SQLCIPHER_PRIVATE   TriggerStep *sqlcipher3TriggerInsertStep(sqlcipher3*,Token*, IdList*,
11550                                         ExprList*,Select*,u8);
11551 SQLCIPHER_PRIVATE   TriggerStep *sqlcipher3TriggerUpdateStep(sqlcipher3*,Token*,ExprList*, Expr*, u8);
11552 SQLCIPHER_PRIVATE   TriggerStep *sqlcipher3TriggerDeleteStep(sqlcipher3*,Token*, Expr*);
11553 SQLCIPHER_PRIVATE   void sqlcipher3DeleteTrigger(sqlcipher3*, Trigger*);
11554 SQLCIPHER_PRIVATE   void sqlcipher3UnlinkAndDeleteTrigger(sqlcipher3*,int,const char*);
11555 SQLCIPHER_PRIVATE   u32 sqlcipher3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
11556 # define sqlcipher3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
11557 #else
11558 # define sqlcipher3TriggersExist(B,C,D,E,F) 0
11559 # define sqlcipher3DeleteTrigger(A,B)
11560 # define sqlcipher3DropTriggerPtr(A,B)
11561 # define sqlcipher3UnlinkAndDeleteTrigger(A,B,C)
11562 # define sqlcipher3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
11563 # define sqlcipher3CodeRowTriggerDirect(A,B,C,D,E,F)
11564 # define sqlcipher3TriggerList(X, Y) 0
11565 # define sqlcipher3ParseToplevel(p) p
11566 # define sqlcipher3TriggerColmask(A,B,C,D,E,F,G) 0
11567 #endif
11568
11569 SQLCIPHER_PRIVATE int sqlcipher3JoinType(Parse*, Token*, Token*, Token*);
11570 SQLCIPHER_PRIVATE void sqlcipher3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
11571 SQLCIPHER_PRIVATE void sqlcipher3DeferForeignKey(Parse*, int);
11572 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
11573 SQLCIPHER_PRIVATE   void sqlcipher3AuthRead(Parse*,Expr*,Schema*,SrcList*);
11574 SQLCIPHER_PRIVATE   int sqlcipher3AuthCheck(Parse*,int, const char*, const char*, const char*);
11575 SQLCIPHER_PRIVATE   void sqlcipher3AuthContextPush(Parse*, AuthContext*, const char*);
11576 SQLCIPHER_PRIVATE   void sqlcipher3AuthContextPop(AuthContext*);
11577 SQLCIPHER_PRIVATE   int sqlcipher3AuthReadCol(Parse*, const char *, const char *, int);
11578 #else
11579 # define sqlcipher3AuthRead(a,b,c,d)
11580 # define sqlcipher3AuthCheck(a,b,c,d,e)    SQLCIPHER_OK
11581 # define sqlcipher3AuthContextPush(a,b,c)
11582 # define sqlcipher3AuthContextPop(a)  ((void)(a))
11583 #endif
11584 SQLCIPHER_PRIVATE void sqlcipher3Attach(Parse*, Expr*, Expr*, Expr*);
11585 SQLCIPHER_PRIVATE void sqlcipher3Detach(Parse*, Expr*);
11586 SQLCIPHER_PRIVATE int sqlcipher3FixInit(DbFixer*, Parse*, int, const char*, const Token*);
11587 SQLCIPHER_PRIVATE int sqlcipher3FixSrcList(DbFixer*, SrcList*);
11588 SQLCIPHER_PRIVATE int sqlcipher3FixSelect(DbFixer*, Select*);
11589 SQLCIPHER_PRIVATE int sqlcipher3FixExpr(DbFixer*, Expr*);
11590 SQLCIPHER_PRIVATE int sqlcipher3FixExprList(DbFixer*, ExprList*);
11591 SQLCIPHER_PRIVATE int sqlcipher3FixTriggerStep(DbFixer*, TriggerStep*);
11592 SQLCIPHER_PRIVATE int sqlcipher3AtoF(const char *z, double*, int, u8);
11593 SQLCIPHER_PRIVATE int sqlcipher3GetInt32(const char *, int*);
11594 SQLCIPHER_PRIVATE int sqlcipher3Atoi(const char*);
11595 SQLCIPHER_PRIVATE int sqlcipher3Utf16ByteLen(const void *pData, int nChar);
11596 SQLCIPHER_PRIVATE int sqlcipher3Utf8CharLen(const char *pData, int nByte);
11597 SQLCIPHER_PRIVATE u32 sqlcipher3Utf8Read(const u8*, const u8**);
11598
11599 /*
11600 ** Routines to read and write variable-length integers.  These used to
11601 ** be defined locally, but now we use the varint routines in the util.c
11602 ** file.  Code should use the MACRO forms below, as the Varint32 versions
11603 ** are coded to assume the single byte case is already handled (which 
11604 ** the MACRO form does).
11605 */
11606 SQLCIPHER_PRIVATE int sqlcipher3PutVarint(unsigned char*, u64);
11607 SQLCIPHER_PRIVATE int sqlcipher3PutVarint32(unsigned char*, u32);
11608 SQLCIPHER_PRIVATE u8 sqlcipher3GetVarint(const unsigned char *, u64 *);
11609 SQLCIPHER_PRIVATE u8 sqlcipher3GetVarint32(const unsigned char *, u32 *);
11610 SQLCIPHER_PRIVATE int sqlcipher3VarintLen(u64 v);
11611
11612 /*
11613 ** The header of a record consists of a sequence variable-length integers.
11614 ** These integers are almost always small and are encoded as a single byte.
11615 ** The following macros take advantage this fact to provide a fast encode
11616 ** and decode of the integers in a record header.  It is faster for the common
11617 ** case where the integer is a single byte.  It is a little slower when the
11618 ** integer is two or more bytes.  But overall it is faster.
11619 **
11620 ** The following expressions are equivalent:
11621 **
11622 **     x = sqlcipher3GetVarint32( A, &B );
11623 **     x = sqlcipher3PutVarint32( A, B );
11624 **
11625 **     x = getVarint32( A, B );
11626 **     x = putVarint32( A, B );
11627 **
11628 */
11629 #define getVarint32(A,B)  (u8)((*(A)<(u8)0x80) ? ((B) = (u32)*(A)),1 : sqlcipher3GetVarint32((A), (u32 *)&(B)))
11630 #define putVarint32(A,B)  (u8)(((u32)(B)<(u32)0x80) ? (*(A) = (unsigned char)(B)),1 : sqlcipher3PutVarint32((A), (B)))
11631 #define getVarint    sqlcipher3GetVarint
11632 #define putVarint    sqlcipher3PutVarint
11633
11634
11635 SQLCIPHER_PRIVATE const char *sqlcipher3IndexAffinityStr(Vdbe *, Index *);
11636 SQLCIPHER_PRIVATE void sqlcipher3TableAffinityStr(Vdbe *, Table *);
11637 SQLCIPHER_PRIVATE char sqlcipher3CompareAffinity(Expr *pExpr, char aff2);
11638 SQLCIPHER_PRIVATE int sqlcipher3IndexAffinityOk(Expr *pExpr, char idx_affinity);
11639 SQLCIPHER_PRIVATE char sqlcipher3ExprAffinity(Expr *pExpr);
11640 SQLCIPHER_PRIVATE int sqlcipher3Atoi64(const char*, i64*, int, u8);
11641 SQLCIPHER_PRIVATE void sqlcipher3Error(sqlcipher3*, int, const char*,...);
11642 SQLCIPHER_PRIVATE void *sqlcipher3HexToBlob(sqlcipher3*, const char *z, int n);
11643 SQLCIPHER_PRIVATE u8 sqlcipher3HexToInt(int h);
11644 SQLCIPHER_PRIVATE int sqlcipher3TwoPartName(Parse *, Token *, Token *, Token **);
11645 SQLCIPHER_PRIVATE const char *sqlcipher3ErrStr(int);
11646 SQLCIPHER_PRIVATE int sqlcipher3ReadSchema(Parse *pParse);
11647 SQLCIPHER_PRIVATE CollSeq *sqlcipher3FindCollSeq(sqlcipher3*,u8 enc, const char*,int);
11648 SQLCIPHER_PRIVATE CollSeq *sqlcipher3LocateCollSeq(Parse *pParse, const char*zName);
11649 SQLCIPHER_PRIVATE CollSeq *sqlcipher3ExprCollSeq(Parse *pParse, Expr *pExpr);
11650 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprSetColl(Expr*, CollSeq*);
11651 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprSetCollByToken(Parse *pParse, Expr*, Token*);
11652 SQLCIPHER_PRIVATE int sqlcipher3CheckCollSeq(Parse *, CollSeq *);
11653 SQLCIPHER_PRIVATE int sqlcipher3CheckObjectName(Parse *, const char *);
11654 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetChanges(sqlcipher3 *, int);
11655 SQLCIPHER_PRIVATE int sqlcipher3AddInt64(i64*,i64);
11656 SQLCIPHER_PRIVATE int sqlcipher3SubInt64(i64*,i64);
11657 SQLCIPHER_PRIVATE int sqlcipher3MulInt64(i64*,i64);
11658 SQLCIPHER_PRIVATE int sqlcipher3AbsInt32(int);
11659 #ifdef SQLCIPHER_ENABLE_8_3_NAMES
11660 SQLCIPHER_PRIVATE void sqlcipher3FileSuffix3(const char*, char*);
11661 #else
11662 # define sqlcipher3FileSuffix3(X,Y)
11663 #endif
11664 SQLCIPHER_PRIVATE u8 sqlcipher3GetBoolean(const char *z);
11665
11666 SQLCIPHER_PRIVATE const void *sqlcipher3ValueText(sqlcipher3_value*, u8);
11667 SQLCIPHER_PRIVATE int sqlcipher3ValueBytes(sqlcipher3_value*, u8);
11668 SQLCIPHER_PRIVATE void sqlcipher3ValueSetStr(sqlcipher3_value*, int, const void *,u8, 
11669                         void(*)(void*));
11670 SQLCIPHER_PRIVATE void sqlcipher3ValueFree(sqlcipher3_value*);
11671 SQLCIPHER_PRIVATE sqlcipher3_value *sqlcipher3ValueNew(sqlcipher3 *);
11672 SQLCIPHER_PRIVATE char *sqlcipher3Utf16to8(sqlcipher3 *, const void*, int, u8);
11673 #ifdef SQLCIPHER_ENABLE_STAT3
11674 SQLCIPHER_PRIVATE char *sqlcipher3Utf8to16(sqlcipher3 *, u8, char *, int, int *);
11675 #endif
11676 SQLCIPHER_PRIVATE int sqlcipher3ValueFromExpr(sqlcipher3 *, Expr *, u8, u8, sqlcipher3_value **);
11677 SQLCIPHER_PRIVATE void sqlcipher3ValueApplyAffinity(sqlcipher3_value *, u8, u8);
11678 #ifndef SQLCIPHER_AMALGAMATION
11679 SQLCIPHER_PRIVATE const unsigned char sqlcipher3OpcodeProperty[];
11680 SQLCIPHER_PRIVATE const unsigned char sqlcipher3UpperToLower[];
11681 SQLCIPHER_PRIVATE const unsigned char sqlcipher3CtypeMap[];
11682 SQLCIPHER_PRIVATE const Token sqlcipher3IntTokens[];
11683 SQLCIPHER_PRIVATE SQLCIPHER_WSD struct Sqlite3Config sqlcipher3Config;
11684 SQLCIPHER_PRIVATE SQLCIPHER_WSD FuncDefHash sqlcipher3GlobalFunctions;
11685 #ifndef SQLCIPHER_OMIT_WSD
11686 SQLCIPHER_PRIVATE int sqlcipher3PendingByte;
11687 #endif
11688 #endif
11689 SQLCIPHER_PRIVATE void sqlcipher3RootPageMoved(sqlcipher3*, int, int, int);
11690 SQLCIPHER_PRIVATE void sqlcipher3Reindex(Parse*, Token*, Token*);
11691 SQLCIPHER_PRIVATE void sqlcipher3AlterFunctions(void);
11692 SQLCIPHER_PRIVATE void sqlcipher3AlterRenameTable(Parse*, SrcList*, Token*);
11693 SQLCIPHER_PRIVATE int sqlcipher3GetToken(const unsigned char *, int *);
11694 SQLCIPHER_PRIVATE void sqlcipher3NestedParse(Parse*, const char*, ...);
11695 SQLCIPHER_PRIVATE void sqlcipher3ExpirePreparedStatements(sqlcipher3*);
11696 SQLCIPHER_PRIVATE int sqlcipher3CodeSubselect(Parse *, Expr *, int, int);
11697 SQLCIPHER_PRIVATE void sqlcipher3SelectPrep(Parse*, Select*, NameContext*);
11698 SQLCIPHER_PRIVATE int sqlcipher3ResolveExprNames(NameContext*, Expr*);
11699 SQLCIPHER_PRIVATE void sqlcipher3ResolveSelectNames(Parse*, Select*, NameContext*);
11700 SQLCIPHER_PRIVATE int sqlcipher3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
11701 SQLCIPHER_PRIVATE void sqlcipher3ColumnDefault(Vdbe *, Table *, int, int);
11702 SQLCIPHER_PRIVATE void sqlcipher3AlterFinishAddColumn(Parse *, Token *);
11703 SQLCIPHER_PRIVATE void sqlcipher3AlterBeginAddColumn(Parse *, SrcList *);
11704 SQLCIPHER_PRIVATE CollSeq *sqlcipher3GetCollSeq(sqlcipher3*, u8, CollSeq *, const char*);
11705 SQLCIPHER_PRIVATE char sqlcipher3AffinityType(const char*);
11706 SQLCIPHER_PRIVATE void sqlcipher3Analyze(Parse*, Token*, Token*);
11707 SQLCIPHER_PRIVATE int sqlcipher3InvokeBusyHandler(BusyHandler*);
11708 SQLCIPHER_PRIVATE int sqlcipher3FindDb(sqlcipher3*, Token*);
11709 SQLCIPHER_PRIVATE int sqlcipher3FindDbName(sqlcipher3 *, const char *);
11710 SQLCIPHER_PRIVATE int sqlcipher3AnalysisLoad(sqlcipher3*,int iDB);
11711 SQLCIPHER_PRIVATE void sqlcipher3DeleteIndexSamples(sqlcipher3*,Index*);
11712 SQLCIPHER_PRIVATE void sqlcipher3DefaultRowEst(Index*);
11713 SQLCIPHER_PRIVATE void sqlcipher3RegisterLikeFunctions(sqlcipher3*, int);
11714 SQLCIPHER_PRIVATE int sqlcipher3IsLikeFunction(sqlcipher3*,Expr*,int*,char*);
11715 SQLCIPHER_PRIVATE void sqlcipher3MinimumFileFormat(Parse*, int, int);
11716 SQLCIPHER_PRIVATE void sqlcipher3SchemaClear(void *);
11717 SQLCIPHER_PRIVATE Schema *sqlcipher3SchemaGet(sqlcipher3 *, Btree *);
11718 SQLCIPHER_PRIVATE int sqlcipher3SchemaToIndex(sqlcipher3 *db, Schema *);
11719 SQLCIPHER_PRIVATE KeyInfo *sqlcipher3IndexKeyinfo(Parse *, Index *);
11720 SQLCIPHER_PRIVATE int sqlcipher3CreateFunc(sqlcipher3 *, const char *, int, int, void *, 
11721   void (*)(sqlcipher3_context*,int,sqlcipher3_value **),
11722   void (*)(sqlcipher3_context*,int,sqlcipher3_value **), void (*)(sqlcipher3_context*),
11723   FuncDestructor *pDestructor
11724 );
11725 SQLCIPHER_PRIVATE int sqlcipher3ApiExit(sqlcipher3 *db, int);
11726 SQLCIPHER_PRIVATE int sqlcipher3OpenTempDatabase(Parse *);
11727
11728 SQLCIPHER_PRIVATE void sqlcipher3StrAccumInit(StrAccum*, char*, int, int);
11729 SQLCIPHER_PRIVATE void sqlcipher3StrAccumAppend(StrAccum*,const char*,int);
11730 SQLCIPHER_PRIVATE char *sqlcipher3StrAccumFinish(StrAccum*);
11731 SQLCIPHER_PRIVATE void sqlcipher3StrAccumReset(StrAccum*);
11732 SQLCIPHER_PRIVATE void sqlcipher3SelectDestInit(SelectDest*,int,int);
11733 SQLCIPHER_PRIVATE Expr *sqlcipher3CreateColumnExpr(sqlcipher3 *, SrcList *, int, int);
11734
11735 SQLCIPHER_PRIVATE void sqlcipher3BackupRestart(sqlcipher3_backup *);
11736 SQLCIPHER_PRIVATE void sqlcipher3BackupUpdate(sqlcipher3_backup *, Pgno, const u8 *);
11737
11738 /*
11739 ** The interface to the LEMON-generated parser
11740 */
11741 SQLCIPHER_PRIVATE void *sqlcipher3ParserAlloc(void*(*)(size_t));
11742 SQLCIPHER_PRIVATE void sqlcipher3ParserFree(void*, void(*)(void*));
11743 SQLCIPHER_PRIVATE void sqlcipher3Parser(void*, int, Token, Parse*);
11744 #ifdef YYTRACKMAXSTACKDEPTH
11745 SQLCIPHER_PRIVATE   int sqlcipher3ParserStackPeak(void*);
11746 #endif
11747
11748 SQLCIPHER_PRIVATE void sqlcipher3AutoLoadExtensions(sqlcipher3*);
11749 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
11750 SQLCIPHER_PRIVATE   void sqlcipher3CloseExtensions(sqlcipher3*);
11751 #else
11752 # define sqlcipher3CloseExtensions(X)
11753 #endif
11754
11755 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
11756 SQLCIPHER_PRIVATE   void sqlcipher3TableLock(Parse *, int, int, u8, const char *);
11757 #else
11758   #define sqlcipher3TableLock(v,w,x,y,z)
11759 #endif
11760
11761 #ifdef SQLCIPHER_TEST
11762 SQLCIPHER_PRIVATE   int sqlcipher3Utf8To8(unsigned char*);
11763 #endif
11764
11765 #ifdef SQLCIPHER_OMIT_VIRTUALTABLE
11766 #  define sqlcipher3VtabClear(Y)
11767 #  define sqlcipher3VtabSync(X,Y) SQLCIPHER_OK
11768 #  define sqlcipher3VtabRollback(X)
11769 #  define sqlcipher3VtabCommit(X)
11770 #  define sqlcipher3VtabInSync(db) 0
11771 #  define sqlcipher3VtabLock(X) 
11772 #  define sqlcipher3VtabUnlock(X)
11773 #  define sqlcipher3VtabUnlockList(X)
11774 #  define sqlcipher3VtabSavepoint(X, Y, Z) SQLCIPHER_OK
11775 #  define sqlcipher3GetVTable(X,Y)  ((VTable*)0)
11776 #else
11777 SQLCIPHER_PRIVATE    void sqlcipher3VtabClear(sqlcipher3 *db, Table*);
11778 SQLCIPHER_PRIVATE    int sqlcipher3VtabSync(sqlcipher3 *db, char **);
11779 SQLCIPHER_PRIVATE    int sqlcipher3VtabRollback(sqlcipher3 *db);
11780 SQLCIPHER_PRIVATE    int sqlcipher3VtabCommit(sqlcipher3 *db);
11781 SQLCIPHER_PRIVATE    void sqlcipher3VtabLock(VTable *);
11782 SQLCIPHER_PRIVATE    void sqlcipher3VtabUnlock(VTable *);
11783 SQLCIPHER_PRIVATE    void sqlcipher3VtabUnlockList(sqlcipher3*);
11784 SQLCIPHER_PRIVATE    int sqlcipher3VtabSavepoint(sqlcipher3 *, int, int);
11785 SQLCIPHER_PRIVATE    VTable *sqlcipher3GetVTable(sqlcipher3*, Table*);
11786 #  define sqlcipher3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
11787 #endif
11788 SQLCIPHER_PRIVATE void sqlcipher3VtabMakeWritable(Parse*,Table*);
11789 SQLCIPHER_PRIVATE void sqlcipher3VtabBeginParse(Parse*, Token*, Token*, Token*);
11790 SQLCIPHER_PRIVATE void sqlcipher3VtabFinishParse(Parse*, Token*);
11791 SQLCIPHER_PRIVATE void sqlcipher3VtabArgInit(Parse*);
11792 SQLCIPHER_PRIVATE void sqlcipher3VtabArgExtend(Parse*, Token*);
11793 SQLCIPHER_PRIVATE int sqlcipher3VtabCallCreate(sqlcipher3*, int, const char *, char **);
11794 SQLCIPHER_PRIVATE int sqlcipher3VtabCallConnect(Parse*, Table*);
11795 SQLCIPHER_PRIVATE int sqlcipher3VtabCallDestroy(sqlcipher3*, int, const char *);
11796 SQLCIPHER_PRIVATE int sqlcipher3VtabBegin(sqlcipher3 *, VTable *);
11797 SQLCIPHER_PRIVATE FuncDef *sqlcipher3VtabOverloadFunction(sqlcipher3 *,FuncDef*, int nArg, Expr*);
11798 SQLCIPHER_PRIVATE void sqlcipher3InvalidFunction(sqlcipher3_context*,int,sqlcipher3_value**);
11799 SQLCIPHER_PRIVATE int sqlcipher3VdbeParameterIndex(Vdbe*, const char*, int);
11800 SQLCIPHER_PRIVATE int sqlcipher3TransferBindings(sqlcipher3_stmt *, sqlcipher3_stmt *);
11801 SQLCIPHER_PRIVATE int sqlcipher3Reprepare(Vdbe*);
11802 SQLCIPHER_PRIVATE void sqlcipher3ExprListCheckLength(Parse*, ExprList*, const char*);
11803 SQLCIPHER_PRIVATE CollSeq *sqlcipher3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
11804 SQLCIPHER_PRIVATE int sqlcipher3TempInMemory(const sqlcipher3*);
11805 SQLCIPHER_PRIVATE const char *sqlcipher3JournalModename(int);
11806 SQLCIPHER_PRIVATE int sqlcipher3Checkpoint(sqlcipher3*, int, int, int*, int*);
11807 SQLCIPHER_PRIVATE int sqlcipher3WalDefaultHook(void*,sqlcipher3*,const char*,int);
11808
11809 /* Declarations for functions in fkey.c. All of these are replaced by
11810 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
11811 ** key functionality is available. If OMIT_TRIGGER is defined but
11812 ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
11813 ** this case foreign keys are parsed, but no other functionality is 
11814 ** provided (enforcement of FK constraints requires the triggers sub-system).
11815 */
11816 #if !defined(SQLCIPHER_OMIT_FOREIGN_KEY) && !defined(SQLCIPHER_OMIT_TRIGGER)
11817 SQLCIPHER_PRIVATE   void sqlcipher3FkCheck(Parse*, Table*, int, int);
11818 SQLCIPHER_PRIVATE   void sqlcipher3FkDropTable(Parse*, SrcList *, Table*);
11819 SQLCIPHER_PRIVATE   void sqlcipher3FkActions(Parse*, Table*, ExprList*, int);
11820 SQLCIPHER_PRIVATE   int sqlcipher3FkRequired(Parse*, Table*, int*, int);
11821 SQLCIPHER_PRIVATE   u32 sqlcipher3FkOldmask(Parse*, Table*);
11822 SQLCIPHER_PRIVATE   FKey *sqlcipher3FkReferences(Table *);
11823 #else
11824   #define sqlcipher3FkActions(a,b,c,d)
11825   #define sqlcipher3FkCheck(a,b,c,d)
11826   #define sqlcipher3FkDropTable(a,b,c)
11827   #define sqlcipher3FkOldmask(a,b)      0
11828   #define sqlcipher3FkRequired(a,b,c,d) 0
11829 #endif
11830 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
11831 SQLCIPHER_PRIVATE   void sqlcipher3FkDelete(sqlcipher3 *, Table*);
11832 #else
11833   #define sqlcipher3FkDelete(a,b)
11834 #endif
11835
11836
11837 /*
11838 ** Available fault injectors.  Should be numbered beginning with 0.
11839 */
11840 #define SQLCIPHER_FAULTINJECTOR_MALLOC     0
11841 #define SQLCIPHER_FAULTINJECTOR_COUNT      1
11842
11843 /*
11844 ** The interface to the code in fault.c used for identifying "benign"
11845 ** malloc failures. This is only present if SQLCIPHER_OMIT_BUILTIN_TEST
11846 ** is not defined.
11847 */
11848 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
11849 SQLCIPHER_PRIVATE   void sqlcipher3BeginBenignMalloc(void);
11850 SQLCIPHER_PRIVATE   void sqlcipher3EndBenignMalloc(void);
11851 #else
11852   #define sqlcipher3BeginBenignMalloc()
11853   #define sqlcipher3EndBenignMalloc()
11854 #endif
11855
11856 #define IN_INDEX_ROWID           1
11857 #define IN_INDEX_EPH             2
11858 #define IN_INDEX_INDEX           3
11859 SQLCIPHER_PRIVATE int sqlcipher3FindInIndex(Parse *, Expr *, int*);
11860
11861 #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
11862 SQLCIPHER_PRIVATE   int sqlcipher3JournalOpen(sqlcipher3_vfs *, const char *, sqlcipher3_file *, int, int);
11863 SQLCIPHER_PRIVATE   int sqlcipher3JournalSize(sqlcipher3_vfs *);
11864 SQLCIPHER_PRIVATE   int sqlcipher3JournalCreate(sqlcipher3_file *);
11865 #else
11866   #define sqlcipher3JournalSize(pVfs) ((pVfs)->szOsFile)
11867 #endif
11868
11869 SQLCIPHER_PRIVATE void sqlcipher3MemJournalOpen(sqlcipher3_file *);
11870 SQLCIPHER_PRIVATE int sqlcipher3MemJournalSize(void);
11871 SQLCIPHER_PRIVATE int sqlcipher3IsMemJournal(sqlcipher3_file *);
11872
11873 #if SQLCIPHER_MAX_EXPR_DEPTH>0
11874 SQLCIPHER_PRIVATE   void sqlcipher3ExprSetHeight(Parse *pParse, Expr *p);
11875 SQLCIPHER_PRIVATE   int sqlcipher3SelectExprHeight(Select *);
11876 SQLCIPHER_PRIVATE   int sqlcipher3ExprCheckHeight(Parse*, int);
11877 #else
11878   #define sqlcipher3ExprSetHeight(x,y)
11879   #define sqlcipher3SelectExprHeight(x) 0
11880   #define sqlcipher3ExprCheckHeight(x,y)
11881 #endif
11882
11883 SQLCIPHER_PRIVATE u32 sqlcipher3Get4byte(const u8*);
11884 SQLCIPHER_PRIVATE void sqlcipher3Put4byte(u8*, u32);
11885
11886 #ifdef SQLCIPHER_ENABLE_UNLOCK_NOTIFY
11887 SQLCIPHER_PRIVATE   void sqlcipher3ConnectionBlocked(sqlcipher3 *, sqlcipher3 *);
11888 SQLCIPHER_PRIVATE   void sqlcipher3ConnectionUnlocked(sqlcipher3 *db);
11889 SQLCIPHER_PRIVATE   void sqlcipher3ConnectionClosed(sqlcipher3 *db);
11890 #else
11891   #define sqlcipher3ConnectionBlocked(x,y)
11892   #define sqlcipher3ConnectionUnlocked(x)
11893   #define sqlcipher3ConnectionClosed(x)
11894 #endif
11895
11896 #ifdef SQLCIPHER_DEBUG
11897 SQLCIPHER_PRIVATE   void sqlcipher3ParserTrace(FILE*, char *);
11898 #endif
11899
11900 /*
11901 ** If the SQLCIPHER_ENABLE IOTRACE exists then the global variable
11902 ** sqlcipher3IoTrace is a pointer to a printf-like routine used to
11903 ** print I/O tracing messages. 
11904 */
11905 #ifdef SQLCIPHER_ENABLE_IOTRACE
11906 # define IOTRACE(A)  if( sqlcipher3IoTrace ){ sqlcipher3IoTrace A; }
11907 SQLCIPHER_PRIVATE   void sqlcipher3VdbeIOTraceSql(Vdbe*);
11908 SQLCIPHER_PRIVATE void (*sqlcipher3IoTrace)(const char*,...);
11909 #else
11910 # define IOTRACE(A)
11911 # define sqlcipher3VdbeIOTraceSql(X)
11912 #endif
11913
11914 /*
11915 ** These routines are available for the mem2.c debugging memory allocator
11916 ** only.  They are used to verify that different "types" of memory
11917 ** allocations are properly tracked by the system.
11918 **
11919 ** sqlcipher3MemdebugSetType() sets the "type" of an allocation to one of
11920 ** the MEMTYPE_* macros defined below.  The type must be a bitmask with
11921 ** a single bit set.
11922 **
11923 ** sqlcipher3MemdebugHasType() returns true if any of the bits in its second
11924 ** argument match the type set by the previous sqlcipher3MemdebugSetType().
11925 ** sqlcipher3MemdebugHasType() is intended for use inside assert() statements.
11926 **
11927 ** sqlcipher3MemdebugNoType() returns true if none of the bits in its second
11928 ** argument match the type set by the previous sqlcipher3MemdebugSetType().
11929 **
11930 ** Perhaps the most important point is the difference between MEMTYPE_HEAP
11931 ** and MEMTYPE_LOOKASIDE.  If an allocation is MEMTYPE_LOOKASIDE, that means
11932 ** it might have been allocated by lookaside, except the allocation was
11933 ** too large or lookaside was already full.  It is important to verify
11934 ** that allocations that might have been satisfied by lookaside are not
11935 ** passed back to non-lookaside free() routines.  Asserts such as the
11936 ** example above are placed on the non-lookaside free() routines to verify
11937 ** this constraint. 
11938 **
11939 ** All of this is no-op for a production build.  It only comes into
11940 ** play when the SQLCIPHER_MEMDEBUG compile-time option is used.
11941 */
11942 #ifdef SQLCIPHER_MEMDEBUG
11943 SQLCIPHER_PRIVATE   void sqlcipher3MemdebugSetType(void*,u8);
11944 SQLCIPHER_PRIVATE   int sqlcipher3MemdebugHasType(void*,u8);
11945 SQLCIPHER_PRIVATE   int sqlcipher3MemdebugNoType(void*,u8);
11946 #else
11947 # define sqlcipher3MemdebugSetType(X,Y)  /* no-op */
11948 # define sqlcipher3MemdebugHasType(X,Y)  1
11949 # define sqlcipher3MemdebugNoType(X,Y)   1
11950 #endif
11951 #define MEMTYPE_HEAP       0x01  /* General heap allocations */
11952 #define MEMTYPE_LOOKASIDE  0x02  /* Might have been lookaside memory */
11953 #define MEMTYPE_SCRATCH    0x04  /* Scratch allocations */
11954 #define MEMTYPE_PCACHE     0x08  /* Page cache allocations */
11955 #define MEMTYPE_DB         0x10  /* Uses sqlcipher3DbMalloc, not sqlcipher_malloc */
11956
11957 #endif /* _SQLCIPHERINT_H_ */
11958
11959 /************** End of sqlcipherInt.h *******************************************/
11960 /************** Begin file crypto.c ******************************************/
11961 /* 
11962 ** SQLCipher
11963 ** crypto.c developed by Stephen Lombardo (Zetetic LLC) 
11964 ** sjlombardo at zetetic dot net
11965 ** http://zetetic.net
11966 ** 
11967 ** Copyright (c) 2009, ZETETIC LLC
11968 ** All rights reserved.
11969 ** 
11970 ** Redistribution and use in source and binary forms, with or without
11971 ** modification, are permitted provided that the following conditions are met:
11972 **     * Redistributions of source code must retain the above copyright
11973 **       notice, this list of conditions and the following disclaimer.
11974 **     * Redistributions in binary form must reproduce the above copyright
11975 **       notice, this list of conditions and the following disclaimer in the
11976 **       documentation and/or other materials provided with the distribution.
11977 **     * Neither the name of the ZETETIC LLC nor the
11978 **       names of its contributors may be used to endorse or promote products
11979 **       derived from this software without specific prior written permission.
11980 ** 
11981 ** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
11982 ** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
11983 ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
11984 ** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
11985 ** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
11986 ** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
11987 ** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
11988 ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
11989 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
11990 ** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
11991 **  
11992 */
11993 /* BEGIN CRYPTO */
11994 #ifdef SQLCIPHER_HAS_CODEC
11995
11996 /* #include <assert.h> */
11997 /************** Include btreeInt.h in the middle of crypto.c *****************/
11998 /************** Begin file btreeInt.h ****************************************/
11999 /*
12000 ** 2004 April 6
12001 **
12002 ** The author disclaims copyright to this source code.  In place of
12003 ** a legal notice, here is a blessing:
12004 **
12005 **    May you do good and not evil.
12006 **    May you find forgiveness for yourself and forgive others.
12007 **    May you share freely, never taking more than you give.
12008 **
12009 *************************************************************************
12010 ** This file implements a external (disk-based) database using BTrees.
12011 ** For a detailed discussion of BTrees, refer to
12012 **
12013 **     Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
12014 **     "Sorting And Searching", pages 473-480. Addison-Wesley
12015 **     Publishing Company, Reading, Massachusetts.
12016 **
12017 ** The basic idea is that each page of the file contains N database
12018 ** entries and N+1 pointers to subpages.
12019 **
12020 **   ----------------------------------------------------------------
12021 **   |  Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) |
12022 **   ----------------------------------------------------------------
12023 **
12024 ** All of the keys on the page that Ptr(0) points to have values less
12025 ** than Key(0).  All of the keys on page Ptr(1) and its subpages have
12026 ** values greater than Key(0) and less than Key(1).  All of the keys
12027 ** on Ptr(N) and its subpages have values greater than Key(N-1).  And
12028 ** so forth.
12029 **
12030 ** Finding a particular key requires reading O(log(M)) pages from the 
12031 ** disk where M is the number of entries in the tree.
12032 **
12033 ** In this implementation, a single file can hold one or more separate 
12034 ** BTrees.  Each BTree is identified by the index of its root page.  The
12035 ** key and data for any entry are combined to form the "payload".  A
12036 ** fixed amount of payload can be carried directly on the database
12037 ** page.  If the payload is larger than the preset amount then surplus
12038 ** bytes are stored on overflow pages.  The payload for an entry
12039 ** and the preceding pointer are combined to form a "Cell".  Each 
12040 ** page has a small header which contains the Ptr(N) pointer and other
12041 ** information such as the size of key and data.
12042 **
12043 ** FORMAT DETAILS
12044 **
12045 ** The file is divided into pages.  The first page is called page 1,
12046 ** the second is page 2, and so forth.  A page number of zero indicates
12047 ** "no such page".  The page size can be any power of 2 between 512 and 65536.
12048 ** Each page can be either a btree page, a freelist page, an overflow
12049 ** page, or a pointer-map page.
12050 **
12051 ** The first page is always a btree page.  The first 100 bytes of the first
12052 ** page contain a special header (the "file header") that describes the file.
12053 ** The format of the file header is as follows:
12054 **
12055 **   OFFSET   SIZE    DESCRIPTION
12056 **      0      16     Header string: "SQLite format 3\000"
12057 **     16       2     Page size in bytes.  
12058 **     18       1     File format write version
12059 **     19       1     File format read version
12060 **     20       1     Bytes of unused space at the end of each page
12061 **     21       1     Max embedded payload fraction
12062 **     22       1     Min embedded payload fraction
12063 **     23       1     Min leaf payload fraction
12064 **     24       4     File change counter
12065 **     28       4     Reserved for future use
12066 **     32       4     First freelist page
12067 **     36       4     Number of freelist pages in the file
12068 **     40      60     15 4-byte meta values passed to higher layers
12069 **
12070 **     40       4     Schema cookie
12071 **     44       4     File format of schema layer
12072 **     48       4     Size of page cache
12073 **     52       4     Largest root-page (auto/incr_vacuum)
12074 **     56       4     1=UTF-8 2=UTF16le 3=UTF16be
12075 **     60       4     User version
12076 **     64       4     Incremental vacuum mode
12077 **     68       4     unused
12078 **     72       4     unused
12079 **     76       4     unused
12080 **
12081 ** All of the integer values are big-endian (most significant byte first).
12082 **
12083 ** The file change counter is incremented when the database is changed
12084 ** This counter allows other processes to know when the file has changed
12085 ** and thus when they need to flush their cache.
12086 **
12087 ** The max embedded payload fraction is the amount of the total usable
12088 ** space in a page that can be consumed by a single cell for standard
12089 ** B-tree (non-LEAFDATA) tables.  A value of 255 means 100%.  The default
12090 ** is to limit the maximum cell size so that at least 4 cells will fit
12091 ** on one page.  Thus the default max embedded payload fraction is 64.
12092 **
12093 ** If the payload for a cell is larger than the max payload, then extra
12094 ** payload is spilled to overflow pages.  Once an overflow page is allocated,
12095 ** as many bytes as possible are moved into the overflow pages without letting
12096 ** the cell size drop below the min embedded payload fraction.
12097 **
12098 ** The min leaf payload fraction is like the min embedded payload fraction
12099 ** except that it applies to leaf nodes in a LEAFDATA tree.  The maximum
12100 ** payload fraction for a LEAFDATA tree is always 100% (or 255) and it
12101 ** not specified in the header.
12102 **
12103 ** Each btree pages is divided into three sections:  The header, the
12104 ** cell pointer array, and the cell content area.  Page 1 also has a 100-byte
12105 ** file header that occurs before the page header.
12106 **
12107 **      |----------------|
12108 **      | file header    |   100 bytes.  Page 1 only.
12109 **      |----------------|
12110 **      | page header    |   8 bytes for leaves.  12 bytes for interior nodes
12111 **      |----------------|
12112 **      | cell pointer   |   |  2 bytes per cell.  Sorted order.
12113 **      | array          |   |  Grows downward
12114 **      |                |   v
12115 **      |----------------|
12116 **      | unallocated    |
12117 **      | space          |
12118 **      |----------------|   ^  Grows upwards
12119 **      | cell content   |   |  Arbitrary order interspersed with freeblocks.
12120 **      | area           |   |  and free space fragments.
12121 **      |----------------|
12122 **
12123 ** The page headers looks like this:
12124 **
12125 **   OFFSET   SIZE     DESCRIPTION
12126 **      0       1      Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
12127 **      1       2      byte offset to the first freeblock
12128 **      3       2      number of cells on this page
12129 **      5       2      first byte of the cell content area
12130 **      7       1      number of fragmented free bytes
12131 **      8       4      Right child (the Ptr(N) value).  Omitted on leaves.
12132 **
12133 ** The flags define the format of this btree page.  The leaf flag means that
12134 ** this page has no children.  The zerodata flag means that this page carries
12135 ** only keys and no data.  The intkey flag means that the key is a integer
12136 ** which is stored in the key size entry of the cell header rather than in
12137 ** the payload area.
12138 **
12139 ** The cell pointer array begins on the first byte after the page header.
12140 ** The cell pointer array contains zero or more 2-byte numbers which are
12141 ** offsets from the beginning of the page to the cell content in the cell
12142 ** content area.  The cell pointers occur in sorted order.  The system strives
12143 ** to keep free space after the last cell pointer so that new cells can
12144 ** be easily added without having to defragment the page.
12145 **
12146 ** Cell content is stored at the very end of the page and grows toward the
12147 ** beginning of the page.
12148 **
12149 ** Unused space within the cell content area is collected into a linked list of
12150 ** freeblocks.  Each freeblock is at least 4 bytes in size.  The byte offset
12151 ** to the first freeblock is given in the header.  Freeblocks occur in
12152 ** increasing order.  Because a freeblock must be at least 4 bytes in size,
12153 ** any group of 3 or fewer unused bytes in the cell content area cannot
12154 ** exist on the freeblock chain.  A group of 3 or fewer free bytes is called
12155 ** a fragment.  The total number of bytes in all fragments is recorded.
12156 ** in the page header at offset 7.
12157 **
12158 **    SIZE    DESCRIPTION
12159 **      2     Byte offset of the next freeblock
12160 **      2     Bytes in this freeblock
12161 **
12162 ** Cells are of variable length.  Cells are stored in the cell content area at
12163 ** the end of the page.  Pointers to the cells are in the cell pointer array
12164 ** that immediately follows the page header.  Cells is not necessarily
12165 ** contiguous or in order, but cell pointers are contiguous and in order.
12166 **
12167 ** Cell content makes use of variable length integers.  A variable
12168 ** length integer is 1 to 9 bytes where the lower 7 bits of each 
12169 ** byte are used.  The integer consists of all bytes that have bit 8 set and
12170 ** the first byte with bit 8 clear.  The most significant byte of the integer
12171 ** appears first.  A variable-length integer may not be more than 9 bytes long.
12172 ** As a special case, all 8 bytes of the 9th byte are used as data.  This
12173 ** allows a 64-bit integer to be encoded in 9 bytes.
12174 **
12175 **    0x00                      becomes  0x00000000
12176 **    0x7f                      becomes  0x0000007f
12177 **    0x81 0x00                 becomes  0x00000080
12178 **    0x82 0x00                 becomes  0x00000100
12179 **    0x80 0x7f                 becomes  0x0000007f
12180 **    0x8a 0x91 0xd1 0xac 0x78  becomes  0x12345678
12181 **    0x81 0x81 0x81 0x81 0x01  becomes  0x10204081
12182 **
12183 ** Variable length integers are used for rowids and to hold the number of
12184 ** bytes of key and data in a btree cell.
12185 **
12186 ** The content of a cell looks like this:
12187 **
12188 **    SIZE    DESCRIPTION
12189 **      4     Page number of the left child. Omitted if leaf flag is set.
12190 **     var    Number of bytes of data. Omitted if the zerodata flag is set.
12191 **     var    Number of bytes of key. Or the key itself if intkey flag is set.
12192 **      *     Payload
12193 **      4     First page of the overflow chain.  Omitted if no overflow
12194 **
12195 ** Overflow pages form a linked list.  Each page except the last is completely
12196 ** filled with data (pagesize - 4 bytes).  The last page can have as little
12197 ** as 1 byte of data.
12198 **
12199 **    SIZE    DESCRIPTION
12200 **      4     Page number of next overflow page
12201 **      *     Data
12202 **
12203 ** Freelist pages come in two subtypes: trunk pages and leaf pages.  The
12204 ** file header points to the first in a linked list of trunk page.  Each trunk
12205 ** page points to multiple leaf pages.  The content of a leaf page is
12206 ** unspecified.  A trunk page looks like this:
12207 **
12208 **    SIZE    DESCRIPTION
12209 **      4     Page number of next trunk page
12210 **      4     Number of leaf pointers on this page
12211 **      *     zero or more pages numbers of leaves
12212 */
12213
12214
12215 /* The following value is the maximum cell size assuming a maximum page
12216 ** size give above.
12217 */
12218 #define MX_CELL_SIZE(pBt)  ((int)(pBt->pageSize-8))
12219
12220 /* The maximum number of cells on a single page of the database.  This
12221 ** assumes a minimum cell size of 6 bytes  (4 bytes for the cell itself
12222 ** plus 2 bytes for the index to the cell in the page header).  Such
12223 ** small cells will be rare, but they are possible.
12224 */
12225 #define MX_CELL(pBt) ((pBt->pageSize-8)/6)
12226
12227 /* Forward declarations */
12228 typedef struct MemPage MemPage;
12229 typedef struct BtLock BtLock;
12230
12231 /*
12232 ** This is a magic string that appears at the beginning of every
12233 ** SQLite database in order to identify the file as a real database.
12234 **
12235 ** You can change this value at compile-time by specifying a
12236 ** -DSQLCIPHER_FILE_HEADER="..." on the compiler command-line.  The
12237 ** header must be exactly 16 bytes including the zero-terminator so
12238 ** the string itself should be 15 characters long.  If you change
12239 ** the header, then your custom library will not be able to read 
12240 ** databases generated by the standard tools and the standard tools
12241 ** will not be able to read databases created by your custom library.
12242 */
12243 #ifndef SQLCIPHER_FILE_HEADER /* 123456789 123456 */
12244 #  define SQLCIPHER_FILE_HEADER "SQLite format 3"
12245 #endif
12246
12247 /*
12248 ** Page type flags.  An ORed combination of these flags appear as the
12249 ** first byte of on-disk image of every BTree page.
12250 */
12251 #define PTF_INTKEY    0x01
12252 #define PTF_ZERODATA  0x02
12253 #define PTF_LEAFDATA  0x04
12254 #define PTF_LEAF      0x08
12255
12256 /*
12257 ** As each page of the file is loaded into memory, an instance of the following
12258 ** structure is appended and initialized to zero.  This structure stores
12259 ** information about the page that is decoded from the raw file page.
12260 **
12261 ** The pParent field points back to the parent page.  This allows us to
12262 ** walk up the BTree from any leaf to the root.  Care must be taken to
12263 ** unref() the parent page pointer when this page is no longer referenced.
12264 ** The pageDestructor() routine handles that chore.
12265 **
12266 ** Access to all fields of this structure is controlled by the mutex
12267 ** stored in MemPage.pBt->mutex.
12268 */
12269 struct MemPage {
12270   u8 isInit;           /* True if previously initialized. MUST BE FIRST! */
12271   u8 nOverflow;        /* Number of overflow cell bodies in aCell[] */
12272   u8 intKey;           /* True if intkey flag is set */
12273   u8 leaf;             /* True if leaf flag is set */
12274   u8 hasData;          /* True if this page stores data */
12275   u8 hdrOffset;        /* 100 for page 1.  0 otherwise */
12276   u8 childPtrSize;     /* 0 if leaf==1.  4 if leaf==0 */
12277   u16 maxLocal;        /* Copy of BtShared.maxLocal or BtShared.maxLeaf */
12278   u16 minLocal;        /* Copy of BtShared.minLocal or BtShared.minLeaf */
12279   u16 cellOffset;      /* Index in aData of first cell pointer */
12280   u16 nFree;           /* Number of free bytes on the page */
12281   u16 nCell;           /* Number of cells on this page, local and ovfl */
12282   u16 maskPage;        /* Mask for page offset */
12283   struct _OvflCell {   /* Cells that will not fit on aData[] */
12284     u8 *pCell;          /* Pointers to the body of the overflow cell */
12285     u16 idx;            /* Insert this cell before idx-th non-overflow cell */
12286   } aOvfl[5];
12287   BtShared *pBt;       /* Pointer to BtShared that this page is part of */
12288   u8 *aData;           /* Pointer to disk image of the page data */
12289   DbPage *pDbPage;     /* Pager page handle */
12290   Pgno pgno;           /* Page number for this page */
12291 };
12292
12293 /*
12294 ** The in-memory image of a disk page has the auxiliary information appended
12295 ** to the end.  EXTRA_SIZE is the number of bytes of space needed to hold
12296 ** that extra information.
12297 */
12298 #define EXTRA_SIZE sizeof(MemPage)
12299
12300 /*
12301 ** A linked list of the following structures is stored at BtShared.pLock.
12302 ** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor 
12303 ** is opened on the table with root page BtShared.iTable. Locks are removed
12304 ** from this list when a transaction is committed or rolled back, or when
12305 ** a btree handle is closed.
12306 */
12307 struct BtLock {
12308   Btree *pBtree;        /* Btree handle holding this lock */
12309   Pgno iTable;          /* Root page of table */
12310   u8 eLock;             /* READ_LOCK or WRITE_LOCK */
12311   BtLock *pNext;        /* Next in BtShared.pLock list */
12312 };
12313
12314 /* Candidate values for BtLock.eLock */
12315 #define READ_LOCK     1
12316 #define WRITE_LOCK    2
12317
12318 /* A Btree handle
12319 **
12320 ** A database connection contains a pointer to an instance of
12321 ** this object for every database file that it has open.  This structure
12322 ** is opaque to the database connection.  The database connection cannot
12323 ** see the internals of this structure and only deals with pointers to
12324 ** this structure.
12325 **
12326 ** For some database files, the same underlying database cache might be 
12327 ** shared between multiple connections.  In that case, each connection
12328 ** has it own instance of this object.  But each instance of this object
12329 ** points to the same BtShared object.  The database cache and the
12330 ** schema associated with the database file are all contained within
12331 ** the BtShared object.
12332 **
12333 ** All fields in this structure are accessed under sqlcipher3.mutex.
12334 ** The pBt pointer itself may not be changed while there exists cursors 
12335 ** in the referenced BtShared that point back to this Btree since those
12336 ** cursors have to go through this Btree to find their BtShared and
12337 ** they often do so without holding sqlcipher3.mutex.
12338 */
12339 struct Btree {
12340   sqlcipher3 *db;       /* The database connection holding this btree */
12341   BtShared *pBt;     /* Sharable content of this btree */
12342   u8 inTrans;        /* TRANS_NONE, TRANS_READ or TRANS_WRITE */
12343   u8 sharable;       /* True if we can share pBt with another db */
12344   u8 locked;         /* True if db currently has pBt locked */
12345   int wantToLock;    /* Number of nested calls to sqlcipher3BtreeEnter() */
12346   int nBackup;       /* Number of backup operations reading this btree */
12347   Btree *pNext;      /* List of other sharable Btrees from the same db */
12348   Btree *pPrev;      /* Back pointer of the same list */
12349 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
12350   BtLock lock;       /* Object used to lock page 1 */
12351 #endif
12352 };
12353
12354 /*
12355 ** Btree.inTrans may take one of the following values.
12356 **
12357 ** If the shared-data extension is enabled, there may be multiple users
12358 ** of the Btree structure. At most one of these may open a write transaction,
12359 ** but any number may have active read transactions.
12360 */
12361 #define TRANS_NONE  0
12362 #define TRANS_READ  1
12363 #define TRANS_WRITE 2
12364
12365 /*
12366 ** An instance of this object represents a single database file.
12367 ** 
12368 ** A single database file can be in use as the same time by two
12369 ** or more database connections.  When two or more connections are
12370 ** sharing the same database file, each connection has it own
12371 ** private Btree object for the file and each of those Btrees points
12372 ** to this one BtShared object.  BtShared.nRef is the number of
12373 ** connections currently sharing this database file.
12374 **
12375 ** Fields in this structure are accessed under the BtShared.mutex
12376 ** mutex, except for nRef and pNext which are accessed under the
12377 ** global SQLCIPHER_MUTEX_STATIC_MASTER mutex.  The pPager field
12378 ** may not be modified once it is initially set as long as nRef>0.
12379 ** The pSchema field may be set once under BtShared.mutex and
12380 ** thereafter is unchanged as long as nRef>0.
12381 **
12382 ** isPending:
12383 **
12384 **   If a BtShared client fails to obtain a write-lock on a database
12385 **   table (because there exists one or more read-locks on the table),
12386 **   the shared-cache enters 'pending-lock' state and isPending is
12387 **   set to true.
12388 **
12389 **   The shared-cache leaves the 'pending lock' state when either of
12390 **   the following occur:
12391 **
12392 **     1) The current writer (BtShared.pWriter) concludes its transaction, OR
12393 **     2) The number of locks held by other connections drops to zero.
12394 **
12395 **   while in the 'pending-lock' state, no connection may start a new
12396 **   transaction.
12397 **
12398 **   This feature is included to help prevent writer-starvation.
12399 */
12400 struct BtShared {
12401   Pager *pPager;        /* The page cache */
12402   sqlcipher3 *db;          /* Database connection currently using this Btree */
12403   BtCursor *pCursor;    /* A list of all open cursors */
12404   MemPage *pPage1;      /* First page of the database */
12405   u8 readOnly;          /* True if the underlying file is readonly */
12406   u8 pageSizeFixed;     /* True if the page size can no longer be changed */
12407   u8 secureDelete;      /* True if secure_delete is enabled */
12408   u8 initiallyEmpty;    /* Database is empty at start of transaction */
12409   u8 openFlags;         /* Flags to sqlcipher3BtreeOpen() */
12410 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
12411   u8 autoVacuum;        /* True if auto-vacuum is enabled */
12412   u8 incrVacuum;        /* True if incr-vacuum is enabled */
12413 #endif
12414   u8 inTransaction;     /* Transaction state */
12415   u8 doNotUseWAL;       /* If true, do not open write-ahead-log file */
12416   u16 maxLocal;         /* Maximum local payload in non-LEAFDATA tables */
12417   u16 minLocal;         /* Minimum local payload in non-LEAFDATA tables */
12418   u16 maxLeaf;          /* Maximum local payload in a LEAFDATA table */
12419   u16 minLeaf;          /* Minimum local payload in a LEAFDATA table */
12420   u32 pageSize;         /* Total number of bytes on a page */
12421   u32 usableSize;       /* Number of usable bytes on each page */
12422   int nTransaction;     /* Number of open transactions (read + write) */
12423   u32 nPage;            /* Number of pages in the database */
12424   void *pSchema;        /* Pointer to space allocated by sqlcipher3BtreeSchema() */
12425   void (*xFreeSchema)(void*);  /* Destructor for BtShared.pSchema */
12426   sqlcipher3_mutex *mutex; /* Non-recursive mutex required to access this object */
12427   Bitvec *pHasContent;  /* Set of pages moved to free-list this transaction */
12428 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
12429   int nRef;             /* Number of references to this structure */
12430   BtShared *pNext;      /* Next on a list of sharable BtShared structs */
12431   BtLock *pLock;        /* List of locks held on this shared-btree struct */
12432   Btree *pWriter;       /* Btree with currently open write transaction */
12433   u8 isExclusive;       /* True if pWriter has an EXCLUSIVE lock on the db */
12434   u8 isPending;         /* If waiting for read-locks to clear */
12435 #endif
12436   u8 *pTmpSpace;        /* BtShared.pageSize bytes of space for tmp use */
12437 };
12438
12439 /*
12440 ** An instance of the following structure is used to hold information
12441 ** about a cell.  The parseCellPtr() function fills in this structure
12442 ** based on information extract from the raw disk page.
12443 */
12444 typedef struct CellInfo CellInfo;
12445 struct CellInfo {
12446   i64 nKey;      /* The key for INTKEY tables, or number of bytes in key */
12447   u8 *pCell;     /* Pointer to the start of cell content */
12448   u32 nData;     /* Number of bytes of data */
12449   u32 nPayload;  /* Total amount of payload */
12450   u16 nHeader;   /* Size of the cell content header in bytes */
12451   u16 nLocal;    /* Amount of payload held locally */
12452   u16 iOverflow; /* Offset to overflow page number.  Zero if no overflow */
12453   u16 nSize;     /* Size of the cell content on the main b-tree page */
12454 };
12455
12456 /*
12457 ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
12458 ** this will be declared corrupt. This value is calculated based on a
12459 ** maximum database size of 2^31 pages a minimum fanout of 2 for a
12460 ** root-node and 3 for all other internal nodes.
12461 **
12462 ** If a tree that appears to be taller than this is encountered, it is
12463 ** assumed that the database is corrupt.
12464 */
12465 #define BTCURSOR_MAX_DEPTH 20
12466
12467 /*
12468 ** A cursor is a pointer to a particular entry within a particular
12469 ** b-tree within a database file.
12470 **
12471 ** The entry is identified by its MemPage and the index in
12472 ** MemPage.aCell[] of the entry.
12473 **
12474 ** A single database file can shared by two more database connections,
12475 ** but cursors cannot be shared.  Each cursor is associated with a
12476 ** particular database connection identified BtCursor.pBtree.db.
12477 **
12478 ** Fields in this structure are accessed under the BtShared.mutex
12479 ** found at self->pBt->mutex. 
12480 */
12481 struct BtCursor {
12482   Btree *pBtree;            /* The Btree to which this cursor belongs */
12483   BtShared *pBt;            /* The BtShared this cursor points to */
12484   BtCursor *pNext, *pPrev;  /* Forms a linked list of all cursors */
12485   struct KeyInfo *pKeyInfo; /* Argument passed to comparison function */
12486   Pgno pgnoRoot;            /* The root page of this tree */
12487   sqlcipher3_int64 cachedRowid; /* Next rowid cache.  0 means not valid */
12488   CellInfo info;            /* A parse of the cell we are pointing at */
12489   i64 nKey;        /* Size of pKey, or last integer key */
12490   void *pKey;      /* Saved key that was cursor's last known position */
12491   int skipNext;    /* Prev() is noop if negative. Next() is noop if positive */
12492   u8 wrFlag;                /* True if writable */
12493   u8 atLast;                /* Cursor pointing to the last entry */
12494   u8 validNKey;             /* True if info.nKey is valid */
12495   u8 eState;                /* One of the CURSOR_XXX constants (see below) */
12496 #ifndef SQLCIPHER_OMIT_INCRBLOB
12497   Pgno *aOverflow;          /* Cache of overflow page locations */
12498   u8 isIncrblobHandle;      /* True if this cursor is an incr. io handle */
12499 #endif
12500   i16 iPage;                            /* Index of current page in apPage */
12501   u16 aiIdx[BTCURSOR_MAX_DEPTH];        /* Current index in apPage[i] */
12502   MemPage *apPage[BTCURSOR_MAX_DEPTH];  /* Pages from root to current page */
12503 };
12504
12505 /*
12506 ** Potential values for BtCursor.eState.
12507 **
12508 ** CURSOR_VALID:
12509 **   Cursor points to a valid entry. getPayload() etc. may be called.
12510 **
12511 ** CURSOR_INVALID:
12512 **   Cursor does not point to a valid entry. This can happen (for example) 
12513 **   because the table is empty or because BtreeCursorFirst() has not been
12514 **   called.
12515 **
12516 ** CURSOR_REQUIRESEEK:
12517 **   The table that this cursor was opened on still exists, but has been 
12518 **   modified since the cursor was last used. The cursor position is saved
12519 **   in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in 
12520 **   this state, restoreCursorPosition() can be called to attempt to
12521 **   seek the cursor to the saved position.
12522 **
12523 ** CURSOR_FAULT:
12524 **   A unrecoverable error (an I/O error or a malloc failure) has occurred
12525 **   on a different connection that shares the BtShared cache with this
12526 **   cursor.  The error has left the cache in an inconsistent state.
12527 **   Do nothing else with this cursor.  Any attempt to use the cursor
12528 **   should return the error code stored in BtCursor.skip
12529 */
12530 #define CURSOR_INVALID           0
12531 #define CURSOR_VALID             1
12532 #define CURSOR_REQUIRESEEK       2
12533 #define CURSOR_FAULT             3
12534
12535 /* 
12536 ** The database page the PENDING_BYTE occupies. This page is never used.
12537 */
12538 # define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)
12539
12540 /*
12541 ** These macros define the location of the pointer-map entry for a 
12542 ** database page. The first argument to each is the number of usable
12543 ** bytes on each page of the database (often 1024). The second is the
12544 ** page number to look up in the pointer map.
12545 **
12546 ** PTRMAP_PAGENO returns the database page number of the pointer-map
12547 ** page that stores the required pointer. PTRMAP_PTROFFSET returns
12548 ** the offset of the requested map entry.
12549 **
12550 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
12551 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
12552 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
12553 ** this test.
12554 */
12555 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
12556 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
12557 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
12558
12559 /*
12560 ** The pointer map is a lookup table that identifies the parent page for
12561 ** each child page in the database file.  The parent page is the page that
12562 ** contains a pointer to the child.  Every page in the database contains
12563 ** 0 or 1 parent pages.  (In this context 'database page' refers
12564 ** to any page that is not part of the pointer map itself.)  Each pointer map
12565 ** entry consists of a single byte 'type' and a 4 byte parent page number.
12566 ** The PTRMAP_XXX identifiers below are the valid types.
12567 **
12568 ** The purpose of the pointer map is to facility moving pages from one
12569 ** position in the file to another as part of autovacuum.  When a page
12570 ** is moved, the pointer in its parent must be updated to point to the
12571 ** new location.  The pointer map is used to locate the parent page quickly.
12572 **
12573 ** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
12574 **                  used in this case.
12575 **
12576 ** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number 
12577 **                  is not used in this case.
12578 **
12579 ** PTRMAP_OVERFLOW1: The database page is the first page in a list of 
12580 **                   overflow pages. The page number identifies the page that
12581 **                   contains the cell with a pointer to this overflow page.
12582 **
12583 ** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of
12584 **                   overflow pages. The page-number identifies the previous
12585 **                   page in the overflow page list.
12586 **
12587 ** PTRMAP_BTREE: The database page is a non-root btree page. The page number
12588 **               identifies the parent page in the btree.
12589 */
12590 #define PTRMAP_ROOTPAGE 1
12591 #define PTRMAP_FREEPAGE 2
12592 #define PTRMAP_OVERFLOW1 3
12593 #define PTRMAP_OVERFLOW2 4
12594 #define PTRMAP_BTREE 5
12595
12596 /* A bunch of assert() statements to check the transaction state variables
12597 ** of handle p (type Btree*) are internally consistent.
12598 */
12599 #define btreeIntegrity(p) \
12600   assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
12601   assert( p->pBt->inTransaction>=p->inTrans ); 
12602
12603
12604 /*
12605 ** The ISAUTOVACUUM macro is used within balance_nonroot() to determine
12606 ** if the database supports auto-vacuum or not. Because it is used
12607 ** within an expression that is an argument to another macro 
12608 ** (sqlcipherMallocRaw), it is not possible to use conditional compilation.
12609 ** So, this macro is defined instead.
12610 */
12611 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
12612 #define ISAUTOVACUUM (pBt->autoVacuum)
12613 #else
12614 #define ISAUTOVACUUM 0
12615 #endif
12616
12617
12618 /*
12619 ** This structure is passed around through all the sanity checking routines
12620 ** in order to keep track of some global state information.
12621 */
12622 typedef struct IntegrityCk IntegrityCk;
12623 struct IntegrityCk {
12624   BtShared *pBt;    /* The tree being checked out */
12625   Pager *pPager;    /* The associated pager.  Also accessible by pBt->pPager */
12626   Pgno nPage;       /* Number of pages in the database */
12627   int *anRef;       /* Number of times each page is referenced */
12628   int mxErr;        /* Stop accumulating errors when this reaches zero */
12629   int nErr;         /* Number of messages written to zErrMsg so far */
12630   int mallocFailed; /* A memory allocation error has occurred */
12631   StrAccum errMsg;  /* Accumulate the error message text here */
12632 };
12633
12634 /*
12635 ** Read or write a two- and four-byte big-endian integer values.
12636 */
12637 #define get2byte(x)   ((x)[0]<<8 | (x)[1])
12638 #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))
12639 #define get4byte sqlcipher3Get4byte
12640 #define put4byte sqlcipher3Put4byte
12641
12642 /************** End of btreeInt.h ********************************************/
12643 /************** Continuing where we left off in crypto.c *********************/
12644 /************** Include crypto.h in the middle of crypto.c *******************/
12645 /************** Begin file crypto.h ******************************************/
12646 /* 
12647 ** SQLCipher
12648 ** crypto.h developed by Stephen Lombardo (Zetetic LLC) 
12649 ** sjlombardo at zetetic dot net
12650 ** http://zetetic.net
12651 ** 
12652 ** Copyright (c) 2008, ZETETIC LLC
12653 ** All rights reserved.
12654 ** 
12655 ** Redistribution and use in source and binary forms, with or without
12656 ** modification, are permitted provided that the following conditions are met:
12657 **     * Redistributions of source code must retain the above copyright
12658 **       notice, this list of conditions and the following disclaimer.
12659 **     * Redistributions in binary form must reproduce the above copyright
12660 **       notice, this list of conditions and the following disclaimer in the
12661 **       documentation and/or other materials provided with the distribution.
12662 **     * Neither the name of the ZETETIC LLC nor the
12663 **       names of its contributors may be used to endorse or promote products
12664 **       derived from this software without specific prior written permission.
12665 ** 
12666 ** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
12667 ** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
12668 ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
12669 ** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
12670 ** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
12671 ** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
12672 ** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
12673 ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12674 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
12675 ** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
12676 **  
12677 */
12678 /* BEGIN CRYPTO */
12679 #ifdef SQLCIPHER_HAS_CODEC
12680 #ifndef CRYPTO_H
12681 #define CRYPTO_H
12682
12683 #define FILE_HEADER_SZ 16
12684
12685 #ifndef CIPHER
12686 #define CIPHER "aes-256-cbc"
12687 #endif
12688
12689 #define CIPHER_DECRYPT 0
12690 #define CIPHER_ENCRYPT 1
12691
12692 #define CIPHER_READ_CTX 0
12693 #define CIPHER_WRITE_CTX 1
12694 #define CIPHER_READWRITE_CTX 2
12695
12696 #ifndef PBKDF2_ITER
12697 #define PBKDF2_ITER 4000
12698 #endif
12699
12700 #ifndef DEFAULT_USE_HMAC
12701 #define DEFAULT_USE_HMAC 1
12702 #endif
12703
12704 /* by default, sqlcipher will use a reduced number of iterations to generate
12705    the HMAC key / or transform a raw cipher key 
12706    */
12707 #ifndef FAST_PBKDF2_ITER
12708 #define FAST_PBKDF2_ITER 2
12709 #endif
12710
12711 /* this if a fixed random array that will be xor'd with the database salt to ensure that the
12712    salt passed to the HMAC key derivation function is not the same as that used to derive
12713    the encryption key. This can be overridden at compile time but it will make the resulting
12714    binary incompatible with the default builds when using HMAC. A future version of SQLcipher
12715    will likely allow this to be defined at runtime via pragma */ 
12716 #ifndef HMAC_SALT_MASK
12717 #define HMAC_SALT_MASK 0x3a
12718 #endif
12719
12720 #ifdef CODEC_DEBUG
12721 #define CODEC_TRACE(X)  {printf X;fflush(stdout);}
12722 #else
12723 #define CODEC_TRACE(X)
12724 #endif
12725
12726
12727 /* extensions defined in pragma.c */ 
12728    
12729 SQLCIPHER_PRIVATE void sqlcipher3pager_get_codec(Pager *pPager, void **ctx);
12730 SQLCIPHER_PRIVATE int sqlcipher3pager_is_mj_pgno(Pager *pPager, Pgno pgno);
12731 SQLCIPHER_PRIVATE sqlcipher3_file *sqlcipher3Pager_get_fd(Pager *pPager);
12732 SQLCIPHER_PRIVATE void sqlcipher3pager_sqlcipher3PagerSetCodec(
12733   Pager *pPager,
12734   void *(*xCodec)(void*,void*,Pgno,int),
12735   void (*xCodecSizeChng)(void*,int,int),
12736   void (*xCodecFree)(void*),
12737   void *pCodec
12738 );
12739 /* end extensions defined in pragma.c */
12740  
12741 /*
12742 **  Simple shared routines for converting hex char strings to binary data
12743  */
12744 static int cipher_hex2int(char c) {
12745   return (c>='0' && c<='9') ? (c)-'0' :
12746          (c>='A' && c<='F') ? (c)-'A'+10 :
12747          (c>='a' && c<='f') ? (c)-'a'+10 : 0;
12748 }
12749
12750 static void cipher_hex2bin(const char *hex, int sz, unsigned char *out){
12751   int i;
12752   for(i = 0; i < sz; i += 2){
12753     out[i/2] = (cipher_hex2int(hex[i])<<4) | cipher_hex2int(hex[i+1]);
12754   }
12755 }
12756
12757 /* extensions defined in crypto_impl.c */
12758
12759 typedef struct codec_ctx codec_ctx;
12760
12761 /* utility functions */
12762 int sqlcipher_memcmp(const unsigned char *a0, const unsigned char *a1, int len);
12763 int sqlcipher_pseudorandom(void *, int);
12764 void sqlcipher_free(void *, int);
12765
12766 /* activation and initialization */
12767 void sqlcipher_activate();
12768 int sqlcipher_codec_ctx_init(codec_ctx **, Db *, Pager *, sqlcipher3_file *, const void *, int);
12769 void sqlcipher_codec_ctx_free(codec_ctx **);
12770 int sqlcipher_codec_key_derive(codec_ctx *);
12771 int sqlcipher_codec_key_copy(codec_ctx *, int);
12772
12773 /* page cipher implementation */
12774 int sqlcipher_page_cipher(codec_ctx *, int, Pgno, int, int, unsigned char *, unsigned char *);
12775
12776 /* context setters & getters */
12777 void sqlcipher_codec_ctx_set_error(codec_ctx *, int);
12778
12779 int sqlcipher_codec_ctx_set_pass(codec_ctx *, const void *, int, int);
12780 void sqlcipher_codec_get_pass(codec_ctx *, void **zKey, int *nKey);
12781
12782 int sqlcipher_codec_ctx_set_pagesize(codec_ctx *, int);
12783 int sqlcipher_codec_ctx_get_pagesize(codec_ctx *);
12784 int sqlcipher_codec_ctx_get_reservesize(codec_ctx *);
12785
12786 int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *, int, int);
12787 void* sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx);
12788
12789 int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *, int, int);
12790
12791 int sqlcipher_codec_ctx_set_cipher(codec_ctx *, const char *, int);
12792
12793 void* sqlcipher_codec_ctx_get_data(codec_ctx *);
12794
12795 void sqlcipher_exportFunc(sqlcipher3_context *, int, sqlcipher3_value **);
12796
12797 int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use);
12798 /* end extensions defined in crypto_impl.c */
12799
12800 #endif
12801 #endif
12802 /* END CRYPTO */
12803
12804 /************** End of crypto.h **********************************************/
12805 /************** Continuing where we left off in crypto.c *********************/
12806
12807 int codec_set_kdf_iter(sqlcipher3* db, int nDb, int kdf_iter, int for_ctx) {
12808   struct Db *pDb = &db->aDb[nDb];
12809   CODEC_TRACE(("codec_set_kdf_iter: entered db=%d nDb=%d kdf_iter=%d for_ctx=%d\n", db, nDb, kdf_iter, for_ctx));
12810
12811   if(pDb->pBt) {
12812     codec_ctx *ctx;
12813     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
12814     if(ctx) return sqlcipher_codec_ctx_set_kdf_iter(ctx, kdf_iter, for_ctx);
12815   }
12816   return SQLCIPHER_ERROR;
12817 }
12818
12819 int codec_set_fast_kdf_iter(sqlcipher3* db, int nDb, int kdf_iter, int for_ctx) {
12820   struct Db *pDb = &db->aDb[nDb];
12821   CODEC_TRACE(("codec_set_kdf_iter: entered db=%d nDb=%d kdf_iter=%d for_ctx=%d\n", db, nDb, kdf_iter, for_ctx));
12822
12823   if(pDb->pBt) {
12824     codec_ctx *ctx;
12825     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
12826     if(ctx) return sqlcipher_codec_ctx_set_fast_kdf_iter(ctx, kdf_iter, for_ctx);
12827   }
12828   return SQLCIPHER_ERROR;
12829 }
12830
12831 static int codec_set_btree_to_codec_pagesize(sqlcipher3 *db, Db *pDb, codec_ctx *ctx) {
12832   int rc, page_sz, reserve_sz; 
12833
12834   page_sz = sqlcipher_codec_ctx_get_pagesize(ctx);
12835   reserve_sz = sqlcipher_codec_ctx_get_reservesize(ctx);
12836
12837   sqlcipher3_mutex_enter(db->mutex);
12838   db->nextPagesize = page_sz; 
12839   pDb->pBt->pBt->pageSizeFixed = 0; 
12840   CODEC_TRACE(("codec_set_btree_to_codec_pagesize: sqlcipher3BtreeSetPageSize() size=%d reserve=%d\n", page_sz, reserve_sz));
12841   rc = sqlcipher3BtreeSetPageSize(pDb->pBt, page_sz, reserve_sz, 0);
12842   sqlcipher3_mutex_leave(db->mutex);
12843   return rc;
12844 }
12845
12846 int codec_set_use_hmac(sqlcipher3* db, int nDb, int use) {
12847   struct Db *pDb = &db->aDb[nDb];
12848
12849   CODEC_TRACE(("codec_set_use_hmac: entered db=%d nDb=%d use=%d\n", db, nDb, use));
12850
12851   if(pDb->pBt) {
12852     int rc;
12853     codec_ctx *ctx;
12854     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
12855     if(ctx) {
12856       rc = sqlcipher_codec_ctx_set_use_hmac(ctx, use);
12857       if(rc != SQLCIPHER_OK) return rc;
12858       /* since the use of hmac has changed, the page size may also change */
12859       /* Note: before forcing the page size we need to force pageSizeFixed to 0, else  
12860              sqlcipherBtreeSetPageSize will block the change  */
12861       return codec_set_btree_to_codec_pagesize(db, pDb, ctx);
12862     }
12863   }
12864   return SQLCIPHER_ERROR;
12865 }
12866
12867 int codec_set_page_size(sqlcipher3* db, int nDb, int size) {
12868   struct Db *pDb = &db->aDb[nDb];
12869   CODEC_TRACE(("codec_set_page_size: entered db=%d nDb=%d size=%d\n", db, nDb, size));
12870
12871   if(pDb->pBt) {
12872     int rc;
12873     codec_ctx *ctx;
12874     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
12875
12876     if(ctx) {
12877       rc = sqlcipher_codec_ctx_set_pagesize(ctx, size);
12878       if(rc != SQLCIPHER_OK) return rc;
12879       return codec_set_btree_to_codec_pagesize(db, pDb, ctx);
12880     }
12881   }
12882   return SQLCIPHER_ERROR;
12883 }
12884
12885 /**
12886   * 
12887   * when for_ctx == 0 then it will change for read
12888   * when for_ctx == 1 then it will change for write
12889   * when for_ctx == 2 then it will change for both
12890   */
12891 int codec_set_cipher_name(sqlcipher3* db, int nDb, const char *cipher_name, int for_ctx) {
12892   struct Db *pDb = &db->aDb[nDb];
12893   CODEC_TRACE(("codec_set_cipher_name: entered db=%d nDb=%d cipher_name=%s for_ctx=%d\n", db, nDb, cipher_name, for_ctx));
12894
12895   if(pDb->pBt) {
12896     codec_ctx *ctx;
12897     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
12898     if(ctx) return sqlcipher_codec_ctx_set_cipher(ctx, cipher_name, for_ctx);
12899   }
12900   return SQLCIPHER_ERROR;
12901 }
12902
12903 int codec_set_pass_key(sqlcipher3* db, int nDb, const void *zKey, int nKey, int for_ctx) {
12904   struct Db *pDb = &db->aDb[nDb];
12905   CODEC_TRACE(("codec_set_pass_key: entered db=%d nDb=%d cipher_name=%s nKey=%d for_ctx=%d\n", db, nDb, zKey, nKey, for_ctx));
12906   if(pDb->pBt) {
12907     codec_ctx *ctx;
12908     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
12909     if(ctx) return sqlcipher_codec_ctx_set_pass(ctx, zKey, nKey, for_ctx);
12910   }
12911   return SQLCIPHER_ERROR;
12912
12913
12914 /*
12915  * sqlcipher3Codec can be called in multiple modes.
12916  * encrypt mode - expected to return a pointer to the 
12917  *   encrypted data without altering pData.
12918  * decrypt mode - expected to return a pointer to pData, with
12919  *   the data decrypted in the input buffer
12920  */
12921 void* sqlcipher3Codec(void *iCtx, void *data, Pgno pgno, int mode) {
12922   codec_ctx *ctx = (codec_ctx *) iCtx;
12923   int offset = 0, rc = 0;
12924   int page_sz = sqlcipher_codec_ctx_get_pagesize(ctx); 
12925   unsigned char *pData = (unsigned char *) data;
12926   void *buffer = sqlcipher_codec_ctx_get_data(ctx);
12927   void *kdf_salt = sqlcipher_codec_ctx_get_kdf_salt(ctx);
12928   CODEC_TRACE(("sqlcipher3Codec: entered pgno=%d, mode=%d, page_sz=%d\n", pgno, mode, page_sz));
12929
12930   /* call to derive keys if not present yet */
12931   if((rc = sqlcipher_codec_key_derive(ctx)) != SQLCIPHER_OK) {
12932    sqlcipher_codec_ctx_set_error(ctx, rc); 
12933    return NULL;
12934   }
12935
12936   if(pgno == 1) offset = FILE_HEADER_SZ; /* adjust starting pointers in data page for header offset on first page*/
12937
12938   CODEC_TRACE(("sqlcipher3Codec: switch mode=%d offset=%d\n",  mode, offset));
12939   switch(mode) {
12940     case 0: /* decrypt */
12941     case 2:
12942     case 3:
12943       if(pgno == 1) memcpy(buffer, SQLCIPHER_FILE_HEADER, FILE_HEADER_SZ); /* copy file header to the first 16 bytes of the page */ 
12944       rc = sqlcipher_page_cipher(ctx, CIPHER_READ_CTX, pgno, CIPHER_DECRYPT, page_sz - offset, pData + offset, (unsigned char*)buffer + offset);
12945       if(rc != SQLCIPHER_OK) sqlcipher_codec_ctx_set_error(ctx, rc);
12946       memcpy(pData, buffer, page_sz); /* copy buffer data back to pData and return */
12947       return pData;
12948       break;
12949     case 6: /* encrypt */
12950       if(pgno == 1) memcpy(buffer, kdf_salt, FILE_HEADER_SZ); /* copy salt to output buffer */ 
12951       rc = sqlcipher_page_cipher(ctx, CIPHER_WRITE_CTX, pgno, CIPHER_ENCRYPT, page_sz - offset, pData + offset, (unsigned char*)buffer + offset);
12952       if(rc != SQLCIPHER_OK) sqlcipher_codec_ctx_set_error(ctx, rc);
12953       return buffer; /* return persistent buffer data, pData remains intact */
12954       break;
12955     case 7:
12956       if(pgno == 1) memcpy(buffer, kdf_salt, FILE_HEADER_SZ); /* copy salt to output buffer */ 
12957       rc = sqlcipher_page_cipher(ctx, CIPHER_READ_CTX, pgno, CIPHER_ENCRYPT, page_sz - offset, pData + offset, (unsigned char*)buffer + offset);
12958       if(rc != SQLCIPHER_OK) sqlcipher_codec_ctx_set_error(ctx, rc);
12959       return buffer; /* return persistent buffer data, pData remains intact */
12960       break;
12961     default:
12962       return pData;
12963       break;
12964   }
12965 }
12966
12967 SQLCIPHER_PRIVATE void sqlcipher3FreeCodecArg(void *pCodecArg) {
12968   codec_ctx *ctx = (codec_ctx *) pCodecArg;
12969   if(pCodecArg == NULL) return;
12970   sqlcipher_codec_ctx_free(&ctx); // wipe and free allocated memory for the context 
12971 }
12972
12973 SQLCIPHER_PRIVATE int sqlcipher3CodecAttach(sqlcipher3* db, int nDb, const void *zKey, int nKey) {
12974   struct Db *pDb = &db->aDb[nDb];
12975
12976   CODEC_TRACE(("sqlcipher3CodecAttach: entered nDb=%d zKey=%s, nKey=%d\n", nDb, zKey, nKey));
12977
12978   sqlcipher_activate();
12979
12980   if(nKey && zKey && pDb->pBt) {
12981     Pager *pPager = pDb->pBt->pBt->pPager;
12982     sqlcipher3_file *fd = sqlcipher3Pager_get_fd(pPager);
12983     codec_ctx *ctx;
12984
12985     /* point the internal codec argument against the contet to be prepared */
12986     sqlcipher_codec_ctx_init(&ctx, pDb, pDb->pBt->pBt->pPager, fd, zKey, nKey); 
12987
12988     sqlcipher3pager_sqlcipher3PagerSetCodec(sqlcipher3BtreePager(pDb->pBt), sqlcipher3Codec, NULL, sqlcipher3FreeCodecArg, (void *) ctx);
12989
12990     codec_set_btree_to_codec_pagesize(db, pDb, ctx);
12991
12992     /* if fd is null, then this is an in-memory database and
12993        we dont' want to overwrite the AutoVacuum settings
12994        if not null, then set to the default */
12995     sqlcipher3_mutex_enter(db->mutex);
12996     if(fd != NULL) { 
12997       sqlcipher3BtreeSetAutoVacuum(pDb->pBt, SQLCIPHER_DEFAULT_AUTOVACUUM);
12998     }
12999     sqlcipher3_mutex_leave(db->mutex);
13000   }
13001   return SQLCIPHER_OK;
13002 }
13003
13004 SQLCIPHER_API void sqlcipher3_activate_see(const char* in) {
13005     (void) in;
13006   /* do nothing, security enhancements are always active */
13007 }
13008
13009 SQLCIPHER_API int sqlcipher3_key(sqlcipher3 *db, const void *pKey, int nKey) {
13010   CODEC_TRACE(("sqlcipher3_key: entered db=%d pKey=%s nKey=%d\n", db, pKey, nKey));
13011   /* attach key if db and pKey are not null and nKey is > 0 */
13012   if(db && pKey && nKey) {
13013     sqlcipher3CodecAttach(db, 0, pKey, nKey); // operate only on the main db 
13014     return SQLCIPHER_OK;
13015   }
13016   return SQLCIPHER_ERROR;
13017 }
13018
13019 /* sqlcipher3_rekey 
13020 ** Given a database, this will reencrypt the database using a new key.
13021 ** There is only one possible modes of operation - to encrypt a database
13022 ** that is already encrpyted. If the database is not already encrypted
13023 ** this should do nothing
13024 ** The proposed logic for this function follows:
13025 ** 1. Determine if the database is already encryptped
13026 ** 2. If there is NOT already a key present do nothing
13027 ** 3. If there is a key present, re-encrypt the database with the new key
13028 */
13029 SQLCIPHER_API int sqlcipher3_rekey(sqlcipher3 *db, const void *pKey, int nKey) {
13030   CODEC_TRACE(("sqlcipher3_rekey: entered db=%d pKey=%s, nKey=%d\n", db, pKey, nKey));
13031   sqlcipher_activate();
13032   if(db && pKey && nKey) {
13033     struct Db *pDb = &db->aDb[0];
13034     CODEC_TRACE(("sqlcipher3_rekey: database pDb=%d\n", pDb));
13035     if(pDb->pBt) {
13036       codec_ctx *ctx;
13037       int rc, page_count;
13038       Pgno pgno;
13039       PgHdr *page;
13040       Pager *pPager = pDb->pBt->pBt->pPager;
13041
13042       sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
13043      
13044       if(ctx == NULL) { 
13045         /* there was no codec attached to this database, so this should do nothing! */ 
13046         CODEC_TRACE(("sqlcipher3_rekey: no codec attached to db, exiting\n"));
13047         return SQLCIPHER_OK;
13048       }
13049
13050       sqlcipher3_mutex_enter(db->mutex);
13051
13052       codec_set_pass_key(db, 0, pKey, nKey, CIPHER_WRITE_CTX);
13053     
13054       /* do stuff here to rewrite the database 
13055       ** 1. Create a transaction on the database
13056       ** 2. Iterate through each page, reading it and then writing it.
13057       ** 3. If that goes ok then commit and put ctx->rekey into ctx->key
13058       **    note: don't deallocate rekey since it may be used in a subsequent iteration 
13059       */
13060       rc = sqlcipher3BtreeBeginTrans(pDb->pBt, 1); /* begin write transaction */
13061       sqlcipher3PagerPagecount(pPager, &page_count);
13062       for(pgno = 1; rc == SQLCIPHER_OK && pgno <= page_count; pgno++) { /* pgno's start at 1 see pager.c:pagerAcquire */
13063         if(!sqlcipher3pager_is_mj_pgno(pPager, pgno)) { /* skip this page (see pager.c:pagerAcquire for reasoning) */
13064           rc = sqlcipher3PagerGet(pPager, pgno, &page);
13065           if(rc == SQLCIPHER_OK) { /* write page see pager_incr_changecounter for example */
13066             rc = sqlcipher3PagerWrite(page);
13067             //printf("sqlcipher3PagerWrite(%d)\n", pgno);
13068             if(rc == SQLCIPHER_OK) {
13069               sqlcipher3PagerUnref(page);
13070             } 
13071           } 
13072         } 
13073       }
13074
13075       /* if commit was successful commit and copy the rekey data to current key, else rollback to release locks */
13076       if(rc == SQLCIPHER_OK) { 
13077         CODEC_TRACE(("sqlcipher3_rekey: committing\n"));
13078         rc = sqlcipher3BtreeCommit(pDb->pBt); 
13079         sqlcipher_codec_key_copy(ctx, CIPHER_WRITE_CTX);
13080       } else {
13081         CODEC_TRACE(("sqlcipher3_rekey: rollback\n"));
13082         sqlcipher3BtreeRollback(pDb->pBt);
13083       }
13084
13085       sqlcipher3_mutex_leave(db->mutex);
13086     }
13087     return SQLCIPHER_OK;
13088   }
13089   return SQLCIPHER_ERROR;
13090 }
13091
13092 SQLCIPHER_PRIVATE void sqlcipher3CodecGetKey(sqlcipher3* db, int nDb, void **zKey, int *nKey) {
13093   struct Db *pDb = &db->aDb[nDb];
13094   CODEC_TRACE(("sqlcipher3CodecGetKey: entered db=%d, nDb=%d\n", db, nDb));
13095   
13096   if( pDb->pBt ) {
13097     codec_ctx *ctx;
13098     sqlcipher3pager_get_codec(pDb->pBt->pBt->pPager, (void **) &ctx);
13099
13100     if(ctx) { /* if the codec has an attached codec_context user the raw key data */
13101       sqlcipher_codec_get_pass(ctx, zKey, nKey);
13102     } else {
13103       *zKey = NULL;
13104       *nKey = 0;
13105     }
13106   }
13107 }
13108
13109
13110 /* END CRYPTO */
13111 #endif
13112
13113 /************** End of crypto.c **********************************************/
13114 /************** Begin file crypto_impl.c *************************************/
13115 /* 
13116 ** SQLCipher
13117 ** crypto_impl.c developed by Stephen Lombardo (Zetetic LLC) 
13118 ** sjlombardo at zetetic dot net
13119 ** http://zetetic.net
13120 ** 
13121 ** Copyright (c) 2011, ZETETIC LLC
13122 ** All rights reserved.
13123 ** 
13124 ** Redistribution and use in source and binary forms, with or without
13125 ** modification, are permitted provided that the following conditions are met:
13126 **     * Redistributions of source code must retain the above copyright
13127 **       notice, this list of conditions and the following disclaimer.
13128 **     * Redistributions in binary form must reproduce the above copyright
13129 **       notice, this list of conditions and the following disclaimer in the
13130 **       documentation and/or other materials provided with the distribution.
13131 **     * Neither the name of the ZETETIC LLC nor the
13132 **       names of its contributors may be used to endorse or promote products
13133 **       derived from this software without specific prior written permission.
13134 ** 
13135 ** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
13136 ** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
13137 ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
13138 ** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
13139 ** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
13140 ** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
13141 ** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
13142 ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
13143 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
13144 ** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
13145 **  
13146 */
13147 /* BEGIN CRYPTO */
13148 #ifdef SQLCIPHER_HAS_CODEC
13149
13150 #include <openssl/rand.h>
13151 #include <openssl/evp.h>
13152 #include <openssl/hmac.h>
13153 #ifndef OMIT_MEMLOCK
13154 #if defined(__unix__) || defined(__APPLE__) 
13155 #include <sys/mman.h>
13156 #elif defined(_WIN32)
13157 /* # include <windows.h> */
13158 #endif
13159 #endif
13160
13161 /* the default implementation of SQLCipher uses a cipher_ctx
13162    to keep track of read / write state separately. The following
13163    struct and associated functions are defined here */
13164 typedef struct {
13165   int derive_key;
13166   EVP_CIPHER *evp_cipher;
13167   EVP_CIPHER_CTX ectx;
13168   HMAC_CTX hctx;
13169   int kdf_iter;
13170   int fast_kdf_iter;
13171   int key_sz;
13172   int iv_sz;
13173   int block_sz;
13174   int pass_sz;
13175   int reserve_sz;
13176   int hmac_sz;
13177   int use_hmac;
13178   unsigned char *key;
13179   unsigned char *hmac_key;
13180   char *pass;
13181 } cipher_ctx;
13182
13183 void sqlcipher_cipher_ctx_free(cipher_ctx **);
13184 int sqlcipher_cipher_ctx_cmp(cipher_ctx *, cipher_ctx *);
13185 int sqlcipher_cipher_ctx_copy(cipher_ctx *, cipher_ctx *);
13186 int sqlcipher_cipher_ctx_init(cipher_ctx **);
13187 int sqlcipher_cipher_ctx_set_pass(cipher_ctx *, const void *, int);
13188 int sqlcipher_cipher_ctx_key_derive(codec_ctx *, cipher_ctx *);
13189
13190 /* prototype for pager HMAC function */
13191 int sqlcipher_page_hmac(cipher_ctx *, Pgno, unsigned char *, int, unsigned char *);
13192
13193 struct codec_ctx {
13194   int kdf_salt_sz;
13195   int page_sz;
13196   unsigned char *kdf_salt;
13197   unsigned char *hmac_kdf_salt;
13198   unsigned char *buffer;
13199   Btree *pBt;
13200   cipher_ctx *read_ctx;
13201   cipher_ctx *write_ctx;
13202 };
13203
13204 void sqlcipher_activate() {
13205   sqlcipher3_mutex_enter(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
13206   if(EVP_get_cipherbyname(CIPHER) == NULL) {
13207     OpenSSL_add_all_algorithms();
13208   } 
13209   sqlcipher3_mutex_leave(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
13210 }
13211
13212 /* fixed time memory comparison routine */
13213 int sqlcipher_memcmp(const unsigned char *a0, const unsigned char *a1, int len) {
13214   int i = 0, noMatch = 0;
13215
13216   for(i = 0; i < len; i++) {
13217     noMatch = (noMatch || (a0[i] != a1[i]));
13218   }
13219   
13220   return noMatch;
13221 }
13222
13223 /* generate a defined number of pseudorandom bytes */
13224 int sqlcipher_random (void *buffer, int length) {
13225   return RAND_bytes((unsigned char *)buffer, length);
13226 }
13227
13228 /**
13229   * Free and wipe memory. Uses SQLites internal sqlcipher3_free so that memory
13230   * can be countend and memory leak detection works in the tet suite. 
13231   * If ptr is not null memory will be freed. 
13232   * If sz is greater than zero, the memory will be overwritten with zero before it is freed
13233   * If sz is > 0, and not compiled with OMIT_MEMLOCK, system will attempt to unlock the
13234   * memory segment so it can be paged
13235   */
13236 void sqlcipher_free(void *ptr, int sz) {
13237   if(ptr) {
13238     if(sz > 0) {
13239       memset(ptr, 0, sz);
13240 #ifndef OMIT_MEMLOCK
13241 #if defined(__unix__) || defined(__APPLE__) 
13242       munlock(ptr, sz);
13243 #elif defined(_WIN32)
13244       VirtualUnlock(ptr, sz);
13245 #endif
13246 #endif
13247     }
13248     sqlcipher3_free(ptr);
13249   }
13250 }
13251
13252 /**
13253   * allocate memory. Uses sqlcipher's internall malloc wrapper so memory can be 
13254   * reference counted and leak detection works. Unless compiled with OMIT_MEMLOCK
13255   * attempts to lock the memory pages so sensitive information won't be swapped
13256   */
13257 void* sqlcipher_malloc(int sz) {
13258   void *ptr = sqlcipher3Malloc(sz);
13259 #ifndef OMIT_MEMLOCK
13260   if(ptr) {
13261 #if defined(__unix__) || defined(__APPLE__) 
13262     mlock(ptr, sz);
13263 #elif defined(_WIN32)
13264     VirtualLock(ptr, sz);
13265 #endif
13266   }
13267 #endif
13268   return ptr;
13269 }
13270
13271
13272 /**
13273   * Initialize a a new cipher_ctx struct. This function will allocate memory
13274   * for the cipher context and for the key
13275   * 
13276   * returns SQLCIPHER_OK if initialization was successful
13277   * returns SQLCIPHER_NOMEM if an error occured allocating memory
13278   */
13279 int sqlcipher_cipher_ctx_init(cipher_ctx **iCtx) {
13280   cipher_ctx *ctx;
13281   *iCtx = (cipher_ctx *) sqlcipher_malloc(sizeof(cipher_ctx));
13282   ctx = *iCtx;
13283   if(ctx == NULL) return SQLCIPHER_NOMEM;
13284   memset(ctx, 0, sizeof(cipher_ctx)); 
13285   ctx->key = (unsigned char *) sqlcipher_malloc(EVP_MAX_KEY_LENGTH);
13286   ctx->hmac_key = (unsigned char *) sqlcipher_malloc(EVP_MAX_KEY_LENGTH);
13287   if(ctx->key == NULL) return SQLCIPHER_NOMEM;
13288   if(ctx->hmac_key == NULL) return SQLCIPHER_NOMEM;
13289   return SQLCIPHER_OK;
13290 }
13291
13292 /**
13293   * Free and wipe memory associated with a cipher_ctx
13294   */
13295 void sqlcipher_cipher_ctx_free(cipher_ctx **iCtx) {
13296   cipher_ctx *ctx = *iCtx;
13297   CODEC_TRACE(("cipher_ctx_free: entered iCtx=%d\n", iCtx));
13298   sqlcipher_free(ctx->key, ctx->key_sz);
13299   sqlcipher_free(ctx->hmac_key, ctx->key_sz);
13300   sqlcipher_free(ctx->pass, ctx->pass_sz);
13301   sqlcipher_free(ctx, sizeof(cipher_ctx)); 
13302 }
13303
13304 /**
13305   * Compare one cipher_ctx to another.
13306   *
13307   * returns 0 if all the parameters (except the derived key data) are the same
13308   * returns 1 otherwise
13309   */
13310 int sqlcipher_cipher_ctx_cmp(cipher_ctx *c1, cipher_ctx *c2) {
13311   CODEC_TRACE(("sqlcipher_cipher_ctx_cmp: entered c1=%d c2=%d\n", c1, c2));
13312
13313   if(
13314     c1->evp_cipher == c2->evp_cipher
13315     && c1->iv_sz == c2->iv_sz
13316     && c1->kdf_iter == c2->kdf_iter
13317     && c1->fast_kdf_iter == c2->fast_kdf_iter
13318     && c1->key_sz == c2->key_sz
13319     && c1->pass_sz == c2->pass_sz
13320     && (
13321       c1->pass == c2->pass
13322       || !sqlcipher_memcmp((const unsigned char*)c1->pass,
13323                            (const unsigned char*)c2->pass,
13324                            c1->pass_sz)
13325     ) 
13326   ) return 0;
13327   return 1;
13328 }
13329
13330 /**
13331   * Copy one cipher_ctx to another. For instance, assuming that read_ctx is a 
13332   * fully initialized context, you could copy it to write_ctx and all yet data
13333   * and pass information across
13334   *
13335   * returns SQLCIPHER_OK if initialization was successful
13336   * returns SQLCIPHER_NOMEM if an error occured allocating memory
13337   */
13338 int sqlcipher_cipher_ctx_copy(cipher_ctx *target, cipher_ctx *source) {
13339   void *key = target->key; 
13340   void *hmac_key = target->hmac_key; 
13341
13342   CODEC_TRACE(("sqlcipher_cipher_ctx_copy: entered target=%d, source=%d\n", target, source));
13343   sqlcipher_free(target->pass, target->pass_sz); 
13344   memcpy(target, source, sizeof(cipher_ctx));
13345   
13346   target->key = key; //restore pointer to previously allocated key data
13347   memcpy(target->key, source->key, EVP_MAX_KEY_LENGTH);
13348
13349   target->hmac_key = hmac_key; //restore pointer to previously allocated hmac key data
13350   memcpy(target->hmac_key, source->hmac_key, EVP_MAX_KEY_LENGTH);
13351
13352   target->pass = sqlcipher_malloc(source->pass_sz);
13353   if(target->pass == NULL) return SQLCIPHER_NOMEM;
13354   memcpy(target->pass, source->pass, source->pass_sz);
13355
13356   return SQLCIPHER_OK;
13357 }
13358
13359
13360 /**
13361   * Set the raw password / key data for a cipher context
13362   * 
13363   * returns SQLCIPHER_OK if assignment was successfull
13364   * returns SQLCIPHER_NOMEM if an error occured allocating memory
13365   * returns SQLCIPHER_ERROR if the key couldn't be set because the pass was null or size was zero
13366   */
13367 int sqlcipher_cipher_ctx_set_pass(cipher_ctx *ctx, const void *zKey, int nKey) {
13368   sqlcipher_free(ctx->pass, ctx->pass_sz);
13369   ctx->pass_sz = nKey;
13370   if(zKey && nKey) {
13371     ctx->pass = sqlcipher_malloc(nKey);
13372     if(ctx->pass == NULL) return SQLCIPHER_NOMEM;
13373     memcpy(ctx->pass, zKey, nKey);
13374     return SQLCIPHER_OK;
13375   }
13376   return SQLCIPHER_ERROR;
13377 }
13378
13379 int sqlcipher_codec_ctx_set_pass(codec_ctx *ctx, const void *zKey, int nKey, int for_ctx) {
13380   cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;
13381   int rc;
13382
13383   if((rc = sqlcipher_cipher_ctx_set_pass(c_ctx, zKey, nKey)) != SQLCIPHER_OK) return rc; 
13384   c_ctx->derive_key = 1;
13385
13386   if(for_ctx == 2)
13387     if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLCIPHER_OK) 
13388       return rc; 
13389
13390   return SQLCIPHER_OK;
13391
13392
13393 int sqlcipher_codec_ctx_set_cipher(codec_ctx *ctx, const char *cipher_name, int for_ctx) {
13394   cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;
13395   int rc;
13396
13397   c_ctx->evp_cipher = (EVP_CIPHER *) EVP_get_cipherbyname(cipher_name);
13398   c_ctx->key_sz = EVP_CIPHER_key_length(c_ctx->evp_cipher);
13399   c_ctx->iv_sz = EVP_CIPHER_iv_length(c_ctx->evp_cipher);
13400   c_ctx->block_sz = EVP_CIPHER_block_size(c_ctx->evp_cipher);
13401   c_ctx->hmac_sz = EVP_MD_size(EVP_sha1());
13402   c_ctx->derive_key = 1;
13403
13404   if(for_ctx == 2)
13405     if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLCIPHER_OK)
13406       return rc; 
13407
13408   return SQLCIPHER_OK;
13409 }
13410
13411 int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *ctx, int kdf_iter, int for_ctx) {
13412   cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;
13413   int rc;
13414
13415   c_ctx->kdf_iter = kdf_iter;
13416   c_ctx->derive_key = 1;
13417
13418   if(for_ctx == 2)
13419     if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLCIPHER_OK)
13420       return rc; 
13421
13422   return SQLCIPHER_OK;
13423 }
13424
13425 int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *ctx, int fast_kdf_iter, int for_ctx) {
13426   cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;
13427   int rc;
13428
13429   c_ctx->fast_kdf_iter = fast_kdf_iter;
13430   c_ctx->derive_key = 1;
13431
13432   if(for_ctx == 2)
13433     if((rc = sqlcipher_cipher_ctx_copy( for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLCIPHER_OK)
13434       return rc; 
13435
13436   return SQLCIPHER_OK;
13437 }
13438
13439
13440 int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use) {
13441   int reserve = EVP_MAX_IV_LENGTH; /* base reserve size will be IV only */ 
13442
13443   if(use) reserve += ctx->read_ctx->hmac_sz; /* if reserve will include hmac, update that size */
13444
13445   /* calculate the amount of reserve needed in even increments of the cipher block size */
13446
13447   reserve = ((reserve % ctx->read_ctx->block_sz) == 0) ? reserve :
13448                ((reserve / ctx->read_ctx->block_sz) + 1) * ctx->read_ctx->block_sz;  
13449
13450   CODEC_TRACE(("sqlcipher_codec_ctx_set_use_hmac: use=%d block_sz=%d md_size=%d reserve=%d\n", 
13451                 use, ctx->read_ctx->block_sz, ctx->read_ctx->hmac_sz, reserve)); 
13452
13453   ctx->write_ctx->use_hmac = ctx->read_ctx->use_hmac = use;
13454   ctx->write_ctx->reserve_sz = ctx->read_ctx->reserve_sz = reserve;
13455
13456   return SQLCIPHER_OK;
13457 }
13458
13459 void sqlcipher_codec_ctx_set_error(codec_ctx *ctx, int error) {
13460   ctx->pBt->db->errCode = error;
13461 }
13462
13463 int sqlcipher_codec_ctx_get_pagesize(codec_ctx *ctx) {
13464   return ctx->page_sz;
13465 }
13466
13467 int sqlcipher_codec_ctx_get_reservesize(codec_ctx *ctx) {
13468   return ctx->read_ctx->reserve_sz;
13469 }
13470
13471 void* sqlcipher_codec_ctx_get_data(codec_ctx *ctx) {
13472   return ctx->buffer;
13473 }
13474
13475 void* sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx) {
13476   return ctx->kdf_salt;
13477 }
13478
13479 void sqlcipher_codec_get_pass(codec_ctx *ctx, void **zKey, int *nKey) {
13480   *zKey = ctx->read_ctx->pass;
13481   *nKey = ctx->read_ctx->pass_sz;
13482 }
13483
13484 int sqlcipher_codec_ctx_set_pagesize(codec_ctx *ctx, int size) {
13485   /* attempt to free the existing page buffer */
13486   sqlcipher_free(ctx->buffer,ctx->page_sz);
13487   ctx->page_sz = size;
13488
13489   /* pre-allocate a page buffer of PageSize bytes. This will
13490      be used as a persistent buffer for encryption and decryption 
13491      operations to avoid overhead of multiple memory allocations*/
13492   ctx->buffer = sqlcipher_malloc(size);
13493   if(ctx->buffer == NULL) return SQLCIPHER_NOMEM;
13494   memset(ctx->buffer, 0, size);
13495
13496   return SQLCIPHER_OK;
13497 }
13498
13499 int sqlcipher_codec_ctx_init(codec_ctx **iCtx, Db *pDb, Pager *pPager, sqlcipher3_file *fd, const void *zKey, int nKey) {
13500   int rc;
13501   codec_ctx *ctx;
13502   *iCtx = sqlcipher_malloc(sizeof(codec_ctx));
13503   ctx = *iCtx;
13504
13505   (void) pPager;
13506
13507   if(ctx == NULL) return SQLCIPHER_NOMEM;
13508
13509   memset(ctx, 0, sizeof(codec_ctx)); /* initialize all pointers and values to 0 */
13510   ctx->pBt = pDb->pBt; /* assign pointer to database btree structure */
13511
13512   /* allocate space for salt data. Then read the first 16 bytes 
13513        directly off the database file. This is the salt for the
13514        key derivation function. If we get a short read allocate
13515        a new random salt value */
13516   ctx->kdf_salt_sz = FILE_HEADER_SZ;
13517   ctx->kdf_salt = sqlcipher_malloc(ctx->kdf_salt_sz);
13518   if(ctx->kdf_salt == NULL) return SQLCIPHER_NOMEM;
13519   memset(ctx->kdf_salt, 0, ctx->kdf_salt_sz);
13520
13521   /* allocate space for separate hmac salt data. We want the
13522      HMAC derivation salt to be different than the encryption
13523      key derivation salt */
13524   ctx->hmac_kdf_salt = sqlcipher_malloc(ctx->kdf_salt_sz);
13525   if(ctx->hmac_kdf_salt == NULL) return SQLCIPHER_NOMEM;
13526
13527
13528   /*
13529      Always overwrite page size and set to the default because the first page of the database
13530      in encrypted and thus sqlcipher can't effectively determine the pagesize. this causes an issue in 
13531      cases where bytes 16 & 17 of the page header are a power of 2 as reported by John Lehman
13532   */
13533   if((rc = sqlcipher_codec_ctx_set_pagesize(ctx, SQLCIPHER_DEFAULT_PAGE_SIZE)) != SQLCIPHER_OK) return rc;
13534
13535   if((rc = sqlcipher_cipher_ctx_init(&ctx->read_ctx)) != SQLCIPHER_OK) return rc; 
13536   if((rc = sqlcipher_cipher_ctx_init(&ctx->write_ctx)) != SQLCIPHER_OK) return rc; 
13537
13538   if(fd == NULL || sqlcipher3OsRead(fd, ctx->kdf_salt, FILE_HEADER_SZ, 0) != SQLCIPHER_OK) {
13539     /* if unable to read the bytes, generate random salt */
13540     if(sqlcipher_random(ctx->kdf_salt, FILE_HEADER_SZ) != 1) return SQLCIPHER_ERROR;
13541   }
13542
13543   if((rc = sqlcipher_codec_ctx_set_cipher(ctx, CIPHER, 0)) != SQLCIPHER_OK) return rc;
13544   if((rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, PBKDF2_ITER, 0)) != SQLCIPHER_OK) return rc;
13545   if((rc = sqlcipher_codec_ctx_set_fast_kdf_iter(ctx, FAST_PBKDF2_ITER, 0)) != SQLCIPHER_OK) return rc;
13546   if((rc = sqlcipher_codec_ctx_set_pass(ctx, zKey, nKey, 0)) != SQLCIPHER_OK) return rc;
13547
13548   /* Use HMAC signatures by default. Note that codec_set_use_hmac will implicity call
13549      codec_set_page_size to set the default */
13550   if((rc = sqlcipher_codec_ctx_set_use_hmac(ctx, DEFAULT_USE_HMAC)) != SQLCIPHER_OK) return rc;
13551
13552   if((rc = sqlcipher_cipher_ctx_copy(ctx->write_ctx, ctx->read_ctx)) != SQLCIPHER_OK) return rc;
13553
13554   return SQLCIPHER_OK;
13555 }
13556
13557 /**
13558   * Free and wipe memory associated with a cipher_ctx, including the allocated
13559   * read_ctx and write_ctx.
13560   */
13561 void sqlcipher_codec_ctx_free(codec_ctx **iCtx) {
13562   codec_ctx *ctx = *iCtx;
13563   CODEC_TRACE(("codec_ctx_free: entered iCtx=%d\n", iCtx));
13564   sqlcipher_free(ctx->kdf_salt, ctx->kdf_salt_sz);
13565   sqlcipher_free(ctx->hmac_kdf_salt, ctx->kdf_salt_sz);
13566   sqlcipher_free(ctx->buffer, 0);
13567   sqlcipher_cipher_ctx_free(&ctx->read_ctx);
13568   sqlcipher_cipher_ctx_free(&ctx->write_ctx);
13569   sqlcipher_free(ctx, sizeof(codec_ctx)); 
13570 }
13571
13572 int sqlcipher_page_hmac(cipher_ctx *ctx, Pgno pgno, unsigned char *in, int in_sz, unsigned char *out) {
13573   HMAC_CTX_init(&ctx->hctx);
13574   
13575   HMAC_Init_ex(&ctx->hctx, ctx->hmac_key, ctx->key_sz, EVP_sha1(), NULL);
13576
13577   /* include the encrypted page data,  initialization vector, and page number in HMAC. This will 
13578      prevent both tampering with the ciphertext, manipulation of the IV, or resequencing otherwise
13579      valid pages out of order in a database */ 
13580   HMAC_Update(&ctx->hctx, in, in_sz);
13581   HMAC_Update(&ctx->hctx, (const unsigned char*) &pgno, sizeof(Pgno));
13582   HMAC_Final(&ctx->hctx, out, NULL);
13583   HMAC_CTX_cleanup(&ctx->hctx);
13584   return SQLCIPHER_OK; 
13585 }
13586
13587 /*
13588  * ctx - codec context
13589  * pgno - page number in database
13590  * size - size in bytes of input and output buffers
13591  * mode - 1 to encrypt, 0 to decrypt
13592  * in - pointer to input bytes
13593  * out - pouter to output bytes
13594  */
13595 int sqlcipher_page_cipher(codec_ctx *ctx, int for_ctx, Pgno pgno, int mode, int page_sz, unsigned char *in, unsigned char *out) {
13596   cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx;
13597   unsigned char *iv_in, *iv_out, *hmac_in, *hmac_out, *out_start;
13598   int tmp_csz, csz, size;
13599
13600   /* calculate some required positions into various buffers */
13601   size = page_sz - c_ctx->reserve_sz; /* adjust size to useable size and memset reserve at end of page */
13602   iv_out = out + size;
13603   iv_in = in + size;
13604
13605   /* hmac will be written immediately after the initialization vector. the remainder of the page reserve will contain
13606      random bytes. note, these pointers are only valid when use_hmac is true */
13607   hmac_in = in + size + c_ctx->iv_sz; 
13608   hmac_out = out + size + c_ctx->iv_sz;
13609   out_start = out; /* note the original position of the output buffer pointer, as out will be rewritten during encryption */
13610
13611   CODEC_TRACE(("codec_cipher:entered pgno=%d, mode=%d, size=%d\n", pgno, mode, size));
13612
13613   /* just copy raw data from in to out when key size is 0
13614    * i.e. during a rekey of a plaintext database */ 
13615   if(c_ctx->key_sz == 0) {
13616     memcpy(out, in, size);
13617     return SQLCIPHER_OK;
13618   } 
13619
13620   if(mode == CIPHER_ENCRYPT) {
13621     /* start at front of the reserve block, write random data to the end */
13622     if(sqlcipher_random(iv_out, c_ctx->reserve_sz) != 1) return SQLCIPHER_ERROR; 
13623   } else { /* CIPHER_DECRYPT */
13624     memcpy(iv_out, iv_in, c_ctx->iv_sz); /* copy the iv from the input to output buffer */
13625   } 
13626
13627   if(c_ctx->use_hmac && (mode == CIPHER_DECRYPT)) {
13628     if(sqlcipher_page_hmac(c_ctx, pgno, in, size + c_ctx->iv_sz, hmac_out) != SQLCIPHER_OK) {
13629       memset(out, 0, page_sz); 
13630       CODEC_TRACE(("codec_cipher: hmac operations failed for pgno=%d\n", pgno));
13631       return SQLCIPHER_ERROR;
13632     }
13633
13634     CODEC_TRACE(("codec_cipher: comparing hmac on in=%d out=%d hmac_sz=%d\n", hmac_in, hmac_out, c_ctx->hmac_sz));
13635     if(sqlcipher_memcmp(hmac_in, hmac_out, c_ctx->hmac_sz) != 0) {
13636       /* the hmac check failed, which means the data was tampered with or
13637          corrupted in some way. we will return an error, and zero out the page data
13638          to force an error */
13639       memset(out, 0, page_sz); 
13640       CODEC_TRACE(("codec_cipher: hmac check failed for pgno=%d\n", pgno));
13641       return SQLCIPHER_ERROR;
13642     }
13643   } 
13644
13645   EVP_CipherInit(&c_ctx->ectx, c_ctx->evp_cipher, NULL, NULL, mode);
13646   EVP_CIPHER_CTX_set_padding(&c_ctx->ectx, 0);
13647   EVP_CipherInit(&c_ctx->ectx, NULL, c_ctx->key, iv_out, mode);
13648   EVP_CipherUpdate(&c_ctx->ectx, out, &tmp_csz, in, size);
13649   csz = tmp_csz;  
13650   out += tmp_csz;
13651   EVP_CipherFinal(&c_ctx->ectx, out, &tmp_csz);
13652   csz += tmp_csz;
13653   EVP_CIPHER_CTX_cleanup(&c_ctx->ectx);
13654   assert(size == csz);
13655
13656   if(c_ctx->use_hmac && (mode == CIPHER_ENCRYPT)) {
13657     sqlcipher_page_hmac(c_ctx, pgno, out_start, size + c_ctx->iv_sz, hmac_out); 
13658   }
13659
13660   return SQLCIPHER_OK;
13661 }
13662
13663 /**
13664   * Derive an encryption key for a cipher contex key based on the raw password.
13665   *
13666   * If the raw key data is formated as x'hex' and there are exactly enough hex chars to fill
13667   * the key space (i.e 64 hex chars for a 256 bit key) then the key data will be used directly. 
13668   * 
13669   * Otherwise, a key data will be derived using PBKDF2
13670   * 
13671   * returns SQLCIPHER_OK if initialization was successful
13672   * returns SQLCIPHER_ERROR if the key could't be derived (for instance if pass is NULL or pass_sz is 0)
13673   */
13674 int sqlcipher_cipher_ctx_key_derive(codec_ctx *ctx, cipher_ctx *c_ctx) {
13675   CODEC_TRACE(("codec_key_derive: entered c_ctx->pass=%s, c_ctx->pass_sz=%d \
13676                 ctx->kdf_salt=%d ctx->kdf_salt_sz=%d c_ctx->kdf_iter=%d \
13677                 ctx->hmac_kdf_salt=%d, c_ctx->fast_kdf_iter=%d c_ctx->key_sz=%d\n", 
13678                 c_ctx->pass, c_ctx->pass_sz, ctx->kdf_salt, ctx->kdf_salt_sz, c_ctx->kdf_iter, 
13679                 ctx->hmac_kdf_salt, c_ctx->fast_kdf_iter, c_ctx->key_sz)); 
13680                 
13681
13682   if(c_ctx->pass && c_ctx->pass_sz) { // if pass is not null
13683     if (c_ctx->pass_sz == ((c_ctx->key_sz*2)+3) && sqlcipher3StrNICmp(c_ctx->pass ,"x'", 2) == 0) { 
13684       int n = c_ctx->pass_sz - 3; /* adjust for leading x' and tailing ' */
13685       const char *z = c_ctx->pass + 2; /* adjust lead offset of x' */
13686       CODEC_TRACE(("codec_key_derive: using raw key from hex\n")); 
13687       cipher_hex2bin(z, n, c_ctx->key);
13688     } else { 
13689       CODEC_TRACE(("codec_key_derive: deriving key using full PBKDF2 with %d iterations\n", c_ctx->kdf_iter)); 
13690       PKCS5_PBKDF2_HMAC_SHA1( c_ctx->pass, c_ctx->pass_sz, 
13691                               ctx->kdf_salt, ctx->kdf_salt_sz, 
13692                               c_ctx->kdf_iter, c_ctx->key_sz, c_ctx->key);
13693                               
13694     }
13695
13696     /* if this context is setup to use hmac checks, generate a seperate and different 
13697        key for HMAC. In this case, we use the output of the previous KDF as the input to 
13698        this KDF run. This ensures a distinct but predictable HMAC key. */
13699     if(c_ctx->use_hmac) {
13700       int i;
13701
13702       /* start by copying the kdf key into the hmac salt slot
13703          then XOR it with the fixed hmac salt defined at compile time
13704          this ensures that the salt passed in to derive the hmac key, while 
13705          easy to derive and publically known, is not the same as the salt used 
13706          to generate the encryption key */ 
13707       memcpy(ctx->hmac_kdf_salt, ctx->kdf_salt, ctx->kdf_salt_sz);
13708       for(i = 0; i < ctx->kdf_salt_sz; i++) {
13709         ctx->hmac_kdf_salt[i] ^= HMAC_SALT_MASK;
13710       } 
13711
13712       CODEC_TRACE(("codec_key_derive: deriving hmac key from encryption key using PBKDF2 with %d iterations\n", 
13713         c_ctx->fast_kdf_iter)); 
13714       PKCS5_PBKDF2_HMAC_SHA1( (const char*)c_ctx->key, c_ctx->key_sz, 
13715                               ctx->hmac_kdf_salt, ctx->kdf_salt_sz, 
13716                               c_ctx->fast_kdf_iter, c_ctx->key_sz, c_ctx->hmac_key); 
13717     }
13718
13719     c_ctx->derive_key = 0;
13720     return SQLCIPHER_OK;
13721   };
13722   return SQLCIPHER_ERROR;
13723 }
13724
13725 int sqlcipher_codec_key_derive(codec_ctx *ctx) {
13726   /* derive key on first use if necessary */
13727   if(ctx->read_ctx->derive_key) {
13728     if(sqlcipher_cipher_ctx_key_derive(ctx, ctx->read_ctx) != SQLCIPHER_OK) return SQLCIPHER_ERROR;
13729   }
13730
13731   if(ctx->write_ctx->derive_key) {
13732     if(sqlcipher_cipher_ctx_cmp(ctx->write_ctx, ctx->read_ctx) == 0) {
13733       // the relevant parameters are the same, just copy read key
13734       if(sqlcipher_cipher_ctx_copy(ctx->write_ctx, ctx->read_ctx) != SQLCIPHER_OK) return SQLCIPHER_ERROR;
13735     } else {
13736       if(sqlcipher_cipher_ctx_key_derive(ctx, ctx->write_ctx) != SQLCIPHER_OK) return SQLCIPHER_ERROR;
13737     }
13738   }
13739   return SQLCIPHER_OK; 
13740 }
13741
13742 int sqlcipher_codec_key_copy(codec_ctx *ctx, int source) {
13743   if(source == CIPHER_READ_CTX) { 
13744       return sqlcipher_cipher_ctx_copy(ctx->write_ctx, ctx->read_ctx); 
13745   } else {
13746       return sqlcipher_cipher_ctx_copy(ctx->read_ctx, ctx->write_ctx); 
13747   }
13748 }
13749
13750
13751 #ifndef OMIT_EXPORT
13752
13753 /*
13754  * Implementation of an "export" function that allows a caller
13755  * to duplicate the main database to an attached database. This is intended
13756  * as a conveneince for users who need to:
13757  * 
13758  *   1. migrate from an non-encrypted database to an encrypted database
13759  *   2. move from an encrypted database to a non-encrypted database
13760  *   3. convert beween the various flavors of encrypted databases.  
13761  *
13762  * This implementation is based heavily on the procedure and code used
13763  * in vacuum.c, but is exposed as a function that allows export to any
13764  * named attached database.
13765  */
13766
13767 /*
13768 ** Finalize a prepared statement.  If there was an error, store the
13769 ** text of the error message in *pzErrMsg.  Return the result code.
13770 ** 
13771 ** Based on vacuumFinalize from vacuum.c
13772 */
13773 static int sqlcipher_finalize(sqlcipher3 *db, sqlcipher3_stmt *pStmt, char **pzErrMsg){
13774   int rc;
13775   rc = sqlcipher3VdbeFinalize((Vdbe*)pStmt);
13776   if( rc ){
13777     sqlcipher3SetString(pzErrMsg, db, sqlcipher3_errmsg(db));
13778   }
13779   return rc;
13780 }
13781
13782 /*
13783 ** Execute zSql on database db. Return an error code.
13784 ** 
13785 ** Based on execSql from vacuum.c
13786 */
13787 static int sqlcipher_execSql(sqlcipher3 *db, char **pzErrMsg, const char *zSql){
13788   sqlcipher3_stmt *pStmt;
13789   VVA_ONLY( int rc; )
13790   if( !zSql ){
13791     return SQLCIPHER_NOMEM;
13792   }
13793   if( SQLCIPHER_OK!=sqlcipher3_prepare(db, zSql, -1, &pStmt, 0) ){
13794     sqlcipher3SetString(pzErrMsg, db, sqlcipher3_errmsg(db));
13795     return sqlcipher3_errcode(db);
13796   }
13797   VVA_ONLY( rc = ) sqlcipher3_step(pStmt);
13798   assert( rc!=SQLCIPHER_ROW );
13799   return sqlcipher_finalize(db, pStmt, pzErrMsg);
13800 }
13801
13802 /*
13803 ** Execute zSql on database db. The statement returns exactly
13804 ** one column. Execute this as SQL on the same database.
13805 ** 
13806 ** Based on execExecSql from vacuum.c
13807 */
13808 static int sqlcipher_execExecSql(sqlcipher3 *db, char **pzErrMsg, const char *zSql){
13809   sqlcipher3_stmt *pStmt;
13810   int rc;
13811
13812   rc = sqlcipher3_prepare(db, zSql, -1, &pStmt, 0);
13813   if( rc!=SQLCIPHER_OK ) return rc;
13814
13815   while( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
13816     rc = sqlcipher_execSql(db, pzErrMsg, (char*)sqlcipher3_column_text(pStmt, 0));
13817     if( rc!=SQLCIPHER_OK ){
13818       sqlcipher_finalize(db, pStmt, pzErrMsg);
13819       return rc;
13820     }
13821   }
13822
13823   return sqlcipher_finalize(db, pStmt, pzErrMsg);
13824 }
13825
13826 /*
13827  * copy database and schema from the main database to an attached database
13828  * 
13829  * Based on sqlcipher3RunVacuum from vacuum.c
13830 */
13831 void sqlcipher_exportFunc(sqlcipher3_context *context, int argc, sqlcipher3_value **argv) {
13832   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
13833   const char* attachedDb = (const char*) sqlcipher3_value_text(argv[0]);
13834   int saved_flags;        /* Saved value of the db->flags */
13835   int saved_nChange;      /* Saved value of db->nChange */
13836   int saved_nTotalChange; /* Saved value of db->nTotalChange */
13837   void (*saved_xTrace)(void*,const char*);  /* Saved db->xTrace */
13838   int rc = SQLCIPHER_OK;     /* Return code from service routines */
13839   char *zSql = NULL;         /* SQL statements */
13840   char *pzErrMsg = NULL;
13841
13842   (void) argc;
13843
13844   saved_flags = db->flags;
13845   saved_nChange = db->nChange;
13846   saved_nTotalChange = db->nTotalChange;
13847   saved_xTrace = db->xTrace;
13848   db->flags |= SQLCIPHER_WriteSchema | SQLCIPHER_IgnoreChecks | SQLCIPHER_PreferBuiltin;
13849   db->flags &= ~(SQLCIPHER_ForeignKeys | SQLCIPHER_ReverseOrder);
13850   db->xTrace = 0;
13851
13852   /* Query the schema of the main database. Create a mirror schema
13853   ** in the temporary database.
13854   */
13855   zSql = sqlcipher3_mprintf(
13856     "SELECT 'CREATE TABLE %s.' || substr(sql,14) "
13857     "  FROM sqlcipher_master WHERE type='table' AND name!='sqlcipher_sequence'"
13858     "   AND rootpage>0"
13859   , attachedDb);
13860   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); 
13861   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13862   sqlcipher3_free(zSql);
13863
13864   zSql = sqlcipher3_mprintf(
13865     "SELECT 'CREATE INDEX %s.' || substr(sql,14)"
13866     "  FROM sqlcipher_master WHERE sql LIKE 'CREATE INDEX %%' "
13867   , attachedDb);
13868   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); 
13869   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13870   sqlcipher3_free(zSql);
13871
13872   zSql = sqlcipher3_mprintf(
13873     "SELECT 'CREATE UNIQUE INDEX %s.' || substr(sql,21) "
13874     "  FROM sqlcipher_master WHERE sql LIKE 'CREATE UNIQUE INDEX %%'"
13875   , attachedDb);
13876   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); 
13877   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13878   sqlcipher3_free(zSql);
13879
13880   /* Loop through the tables in the main database. For each, do
13881   ** an "INSERT INTO rekey_db.xxx SELECT * FROM main.xxx;" to copy
13882   ** the contents to the temporary database.
13883   */
13884   zSql = sqlcipher3_mprintf(
13885     "SELECT 'INSERT INTO %s.' || quote(name) "
13886     "|| ' SELECT * FROM main.' || quote(name) || ';'"
13887     "FROM main.sqlcipher_master "
13888     "WHERE type = 'table' AND name!='sqlcipher_sequence' "
13889     "  AND rootpage>0"
13890   , attachedDb);
13891   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); 
13892   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13893   sqlcipher3_free(zSql);
13894
13895   /* Copy over the sequence table
13896   */
13897   zSql = sqlcipher3_mprintf(
13898     "SELECT 'DELETE FROM %s.' || quote(name) || ';' "
13899     "FROM %s.sqlcipher_master WHERE name='sqlcipher_sequence' "
13900   , attachedDb, attachedDb);
13901   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); 
13902   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13903   sqlcipher3_free(zSql);
13904
13905   zSql = sqlcipher3_mprintf(
13906     "SELECT 'INSERT INTO %s.' || quote(name) "
13907     "|| ' SELECT * FROM main.' || quote(name) || ';' "
13908     "FROM %s.sqlcipher_master WHERE name=='sqlcipher_sequence';"
13909   , attachedDb, attachedDb);
13910   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); 
13911   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13912   sqlcipher3_free(zSql);
13913
13914   /* Copy the triggers, views, and virtual tables from the main database
13915   ** over to the temporary database.  None of these objects has any
13916   ** associated storage, so all we have to do is copy their entries
13917   ** from the SQLCIPHER_MASTER table.
13918   */
13919   zSql = sqlcipher3_mprintf(
13920     "INSERT INTO %s.sqlcipher_master "
13921     "  SELECT type, name, tbl_name, rootpage, sql"
13922     "    FROM main.sqlcipher_master"
13923     "   WHERE type='view' OR type='trigger'"
13924     "      OR (type='table' AND rootpage=0)"
13925   , attachedDb);
13926   rc = (zSql == NULL) ? SQLCIPHER_NOMEM : sqlcipher_execSql(db, &pzErrMsg, zSql); 
13927   if( rc!=SQLCIPHER_OK ) goto end_of_export;
13928   sqlcipher3_free(zSql);
13929
13930   zSql = NULL;
13931 end_of_export:
13932   db->flags = saved_flags;
13933   db->nChange = saved_nChange;
13934   db->nTotalChange = saved_nTotalChange;
13935   db->xTrace = saved_xTrace;
13936
13937   sqlcipher3_free(zSql);
13938
13939   if(rc) {
13940     if(pzErrMsg != NULL) {
13941       sqlcipher3_result_error(context, pzErrMsg, -1);
13942       sqlcipher3DbFree(db, pzErrMsg);
13943     } else {
13944       sqlcipher3_result_error(context, sqlcipher3ErrStr(rc), -1);
13945     }
13946   }
13947 }
13948
13949 #endif
13950 #endif
13951
13952 /************** End of crypto_impl.c *****************************************/
13953 /************** Begin file global.c ******************************************/
13954 /*
13955 ** 2008 June 13
13956 **
13957 ** The author disclaims copyright to this source code.  In place of
13958 ** a legal notice, here is a blessing:
13959 **
13960 **    May you do good and not evil.
13961 **    May you find forgiveness for yourself and forgive others.
13962 **    May you share freely, never taking more than you give.
13963 **
13964 *************************************************************************
13965 **
13966 ** This file contains definitions of global variables and contants.
13967 */
13968
13969 /* An array to map all upper-case characters into their corresponding
13970 ** lower-case character. 
13971 **
13972 ** SQLite only considers US-ASCII (or EBCDIC) characters.  We do not
13973 ** handle case conversions for the UTF character set since the tables
13974 ** involved are nearly as big or bigger than SQLite itself.
13975 */
13976 SQLCIPHER_PRIVATE const unsigned char sqlcipher3UpperToLower[] = {
13977 #ifdef SQLCIPHER_ASCII
13978       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
13979      18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
13980      36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
13981      54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
13982     104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
13983     122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
13984     108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
13985     126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
13986     144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
13987     162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
13988     180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
13989     198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
13990     216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
13991     234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
13992     252,253,254,255
13993 #endif
13994 #ifdef SQLCIPHER_EBCDIC
13995       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* 0x */
13996      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
13997      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
13998      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
13999      64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
14000      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
14001      96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
14002     112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
14003     128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
14004     144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */
14005     160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
14006     176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
14007     192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
14008     208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
14009     224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */
14010     239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */
14011 #endif
14012 };
14013
14014 /*
14015 ** The following 256 byte lookup table is used to support SQLites built-in
14016 ** equivalents to the following standard library functions:
14017 **
14018 **   isspace()                        0x01
14019 **   isalpha()                        0x02
14020 **   isdigit()                        0x04
14021 **   isalnum()                        0x06
14022 **   isxdigit()                       0x08
14023 **   toupper()                        0x20
14024 **   SQLite identifier character      0x40
14025 **
14026 ** Bit 0x20 is set if the mapped character requires translation to upper
14027 ** case. i.e. if the character is a lower-case ASCII character.
14028 ** If x is a lower-case ASCII character, then its upper-case equivalent
14029 ** is (x - 0x20). Therefore toupper() can be implemented as:
14030 **
14031 **   (x & ~(map[x]&0x20))
14032 **
14033 ** Standard function tolower() is implemented using the sqlcipher3UpperToLower[]
14034 ** array. tolower() is used more often than toupper() by SQLite.
14035 **
14036 ** Bit 0x40 is set if the character non-alphanumeric and can be used in an 
14037 ** SQLite identifier.  Identifiers are alphanumerics, "_", "$", and any
14038 ** non-ASCII UTF character. Hence the test for whether or not a character is
14039 ** part of an identifier is 0x46.
14040 **
14041 ** SQLite's versions are identical to the standard versions assuming a
14042 ** locale of "C". They are implemented as macros in sqlcipherInt.h.
14043 */
14044 #ifdef SQLCIPHER_ASCII
14045 SQLCIPHER_PRIVATE const unsigned char sqlcipher3CtypeMap[256] = {
14046   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 00..07    ........ */
14047   0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,  /* 08..0f    ........ */
14048   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 10..17    ........ */
14049   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 18..1f    ........ */
14050   0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,  /* 20..27     !"#$%&' */
14051   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 28..2f    ()*+,-./ */
14052   0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,  /* 30..37    01234567 */
14053   0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 38..3f    89:;<=>? */
14054
14055   0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02,  /* 40..47    @ABCDEFG */
14056   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 48..4f    HIJKLMNO */
14057   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  /* 50..57    PQRSTUVW */
14058   0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x40,  /* 58..5f    XYZ[\]^_ */
14059   0x00, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22,  /* 60..67    `abcdefg */
14060   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 68..6f    hijklmno */
14061   0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,  /* 70..77    pqrstuvw */
14062   0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00,  /* 78..7f    xyz{|}~. */
14063
14064   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 80..87    ........ */
14065   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 88..8f    ........ */
14066   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 90..97    ........ */
14067   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* 98..9f    ........ */
14068   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a0..a7    ........ */
14069   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* a8..af    ........ */
14070   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b0..b7    ........ */
14071   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* b8..bf    ........ */
14072
14073   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c0..c7    ........ */
14074   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* c8..cf    ........ */
14075   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d0..d7    ........ */
14076   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* d8..df    ........ */
14077   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* e0..e7    ........ */
14078   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* e8..ef    ........ */
14079   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  /* f0..f7    ........ */
14080   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40   /* f8..ff    ........ */
14081 };
14082 #endif
14083
14084 #ifndef SQLCIPHER_USE_URI
14085 # define  SQLCIPHER_USE_URI 0
14086 #endif
14087
14088 /*
14089 ** The following singleton contains the global configuration for
14090 ** the SQLite library.
14091 */
14092 SQLCIPHER_PRIVATE SQLCIPHER_WSD struct Sqlite3Config sqlcipher3Config = {
14093    SQLCIPHER_DEFAULT_MEMSTATUS,  /* bMemstat */
14094    1,                         /* bCoreMutex */
14095    SQLCIPHER_THREADSAFE==1,      /* bFullMutex */
14096    SQLCIPHER_USE_URI,            /* bOpenUri */
14097    0x7ffffffe,                /* mxStrlen */
14098    128,                       /* szLookaside */
14099    500,                       /* nLookaside */
14100    {0,0,0,0,0,0,0,0},         /* m */
14101    {0,0,0,0,0,0,0,0,0},       /* mutex */
14102    {0,0,0,0,0,0,0,0,0,0,0},   /* pcache */
14103    (void*)0,                  /* pHeap */
14104    0,                         /* nHeap */
14105    0, 0,                      /* mnHeap, mxHeap */
14106    (void*)0,                  /* pScratch */
14107    0,                         /* szScratch */
14108    0,                         /* nScratch */
14109    (void*)0,                  /* pPage */
14110    0,                         /* szPage */
14111    0,                         /* nPage */
14112    0,                         /* mxParserStack */
14113    0,                         /* sharedCacheEnabled */
14114    /* All the rest should always be initialized to zero */
14115    0,                         /* isInit */
14116    0,                         /* inProgress */
14117    0,                         /* isMutexInit */
14118    0,                         /* isMallocInit */
14119    0,                         /* isPCacheInit */
14120    0,                         /* pInitMutex */
14121    0,                         /* nRefInitMutex */
14122    0,                         /* xLog */
14123    0,                         /* pLogArg */
14124    0,                         /* bLocaltimeFault */
14125 };
14126
14127
14128 /*
14129 ** Hash table for global functions - functions common to all
14130 ** database connections.  After initialization, this table is
14131 ** read-only.
14132 */
14133 SQLCIPHER_PRIVATE SQLCIPHER_WSD FuncDefHash sqlcipher3GlobalFunctions;
14134
14135 /*
14136 ** Constant tokens for values 0 and 1.
14137 */
14138 SQLCIPHER_PRIVATE const Token sqlcipher3IntTokens[] = {
14139    { "0", 1 },
14140    { "1", 1 }
14141 };
14142
14143
14144 /*
14145 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
14146 ** 1-gibabyte boundary) in a compatible database.  SQLite never uses
14147 ** the database page that contains the pending byte.  It never attempts
14148 ** to read or write that page.  The pending byte page is set assign
14149 ** for use by the VFS layers as space for managing file locks.
14150 **
14151 ** During testing, it is often desirable to move the pending byte to
14152 ** a different position in the file.  This allows code that has to
14153 ** deal with the pending byte to run on files that are much smaller
14154 ** than 1 GiB.  The sqlcipher3_test_control() interface can be used to
14155 ** move the pending byte.
14156 **
14157 ** IMPORTANT:  Changing the pending byte to any value other than
14158 ** 0x40000000 results in an incompatible database file format!
14159 ** Changing the pending byte during operating results in undefined
14160 ** and dileterious behavior.
14161 */
14162 #ifndef SQLCIPHER_OMIT_WSD
14163 SQLCIPHER_PRIVATE int sqlcipher3PendingByte = 0x40000000;
14164 #endif
14165
14166 /*
14167 ** Properties of opcodes.  The OPFLG_INITIALIZER macro is
14168 ** created by mkopcodeh.awk during compilation.  Data is obtained
14169 ** from the comments following the "case OP_xxxx:" statements in
14170 ** the vdbe.c file.  
14171 */
14172 SQLCIPHER_PRIVATE const unsigned char sqlcipher3OpcodeProperty[] = OPFLG_INITIALIZER;
14173
14174 /************** End of global.c **********************************************/
14175 /************** Begin file ctime.c *******************************************/
14176 /*
14177 ** 2010 February 23
14178 **
14179 ** The author disclaims copyright to this source code.  In place of
14180 ** a legal notice, here is a blessing:
14181 **
14182 **    May you do good and not evil.
14183 **    May you find forgiveness for yourself and forgive others.
14184 **    May you share freely, never taking more than you give.
14185 **
14186 *************************************************************************
14187 **
14188 ** This file implements routines used to report what compile-time options
14189 ** SQLite was built with.
14190 */
14191
14192 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
14193
14194
14195 /*
14196 ** An array of names of all compile-time options.  This array should 
14197 ** be sorted A-Z.
14198 **
14199 ** This array looks large, but in a typical installation actually uses
14200 ** only a handful of compile-time options, so most times this array is usually
14201 ** rather short and uses little memory space.
14202 */
14203 static const char * const azCompileOpt[] = {
14204
14205 /* These macros are provided to "stringify" the value of the define
14206 ** for those options in which the value is meaningful. */
14207 #define CTIMEOPT_VAL_(opt) #opt
14208 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
14209
14210 #ifdef SQLCIPHER_32BIT_ROWID
14211   "32BIT_ROWID",
14212 #endif
14213 #ifdef SQLCIPHER_4_BYTE_ALIGNED_MALLOC
14214   "4_BYTE_ALIGNED_MALLOC",
14215 #endif
14216 #ifdef SQLCIPHER_CASE_SENSITIVE_LIKE
14217   "CASE_SENSITIVE_LIKE",
14218 #endif
14219 #ifdef SQLCIPHER_CHECK_PAGES
14220   "CHECK_PAGES",
14221 #endif
14222 #ifdef SQLCIPHER_COVERAGE_TEST
14223   "COVERAGE_TEST",
14224 #endif
14225 #ifdef SQLCIPHER_DEBUG
14226   "DEBUG",
14227 #endif
14228 #ifdef SQLCIPHER_DEFAULT_LOCKING_MODE
14229   "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLCIPHER_DEFAULT_LOCKING_MODE),
14230 #endif
14231 #ifdef SQLCIPHER_DISABLE_DIRSYNC
14232   "DISABLE_DIRSYNC",
14233 #endif
14234 #ifdef SQLCIPHER_DISABLE_LFS
14235   "DISABLE_LFS",
14236 #endif
14237 #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
14238   "ENABLE_ATOMIC_WRITE",
14239 #endif
14240 #ifdef SQLCIPHER_ENABLE_CEROD
14241   "ENABLE_CEROD",
14242 #endif
14243 #ifdef SQLCIPHER_ENABLE_COLUMN_METADATA
14244   "ENABLE_COLUMN_METADATA",
14245 #endif
14246 #ifdef SQLCIPHER_ENABLE_EXPENSIVE_ASSERT
14247   "ENABLE_EXPENSIVE_ASSERT",
14248 #endif
14249 #ifdef SQLCIPHER_ENABLE_FTS1
14250   "ENABLE_FTS1",
14251 #endif
14252 #ifdef SQLCIPHER_ENABLE_FTS2
14253   "ENABLE_FTS2",
14254 #endif
14255 #ifdef SQLCIPHER_ENABLE_FTS3
14256   "ENABLE_FTS3",
14257 #endif
14258 #ifdef SQLCIPHER_ENABLE_FTS3_PARENTHESIS
14259   "ENABLE_FTS3_PARENTHESIS",
14260 #endif
14261 #ifdef SQLCIPHER_ENABLE_FTS4
14262   "ENABLE_FTS4",
14263 #endif
14264 #ifdef SQLCIPHER_ENABLE_ICU
14265   "ENABLE_ICU",
14266 #endif
14267 #ifdef SQLCIPHER_ENABLE_IOTRACE
14268   "ENABLE_IOTRACE",
14269 #endif
14270 #ifdef SQLCIPHER_ENABLE_LOAD_EXTENSION
14271   "ENABLE_LOAD_EXTENSION",
14272 #endif
14273 #ifdef SQLCIPHER_ENABLE_LOCKING_STYLE
14274   "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLCIPHER_ENABLE_LOCKING_STYLE),
14275 #endif
14276 #ifdef SQLCIPHER_ENABLE_MEMORY_MANAGEMENT
14277   "ENABLE_MEMORY_MANAGEMENT",
14278 #endif
14279 #ifdef SQLCIPHER_ENABLE_MEMSYS3
14280   "ENABLE_MEMSYS3",
14281 #endif
14282 #ifdef SQLCIPHER_ENABLE_MEMSYS5
14283   "ENABLE_MEMSYS5",
14284 #endif
14285 #ifdef SQLCIPHER_ENABLE_OVERSIZE_CELL_CHECK
14286   "ENABLE_OVERSIZE_CELL_CHECK",
14287 #endif
14288 #ifdef SQLCIPHER_ENABLE_RTREE
14289   "ENABLE_RTREE",
14290 #endif
14291 #ifdef SQLCIPHER_ENABLE_STAT3
14292   "ENABLE_STAT3",
14293 #endif
14294 #ifdef SQLCIPHER_ENABLE_UNLOCK_NOTIFY
14295   "ENABLE_UNLOCK_NOTIFY",
14296 #endif
14297 #ifdef SQLCIPHER_ENABLE_UPDATE_DELETE_LIMIT
14298   "ENABLE_UPDATE_DELETE_LIMIT",
14299 #endif
14300 #ifdef SQLCIPHER_HAS_CODEC
14301   "HAS_CODEC",
14302 #endif
14303 #ifdef SQLCIPHER_HAVE_ISNAN
14304   "HAVE_ISNAN",
14305 #endif
14306 #ifdef SQLCIPHER_HOMEGROWN_RECURSIVE_MUTEX
14307   "HOMEGROWN_RECURSIVE_MUTEX",
14308 #endif
14309 #ifdef SQLCIPHER_IGNORE_AFP_LOCK_ERRORS
14310   "IGNORE_AFP_LOCK_ERRORS",
14311 #endif
14312 #ifdef SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS
14313   "IGNORE_FLOCK_LOCK_ERRORS",
14314 #endif
14315 #ifdef SQLCIPHER_INT64_TYPE
14316   "INT64_TYPE",
14317 #endif
14318 #ifdef SQLCIPHER_LOCK_TRACE
14319   "LOCK_TRACE",
14320 #endif
14321 #ifdef SQLCIPHER_MAX_SCHEMA_RETRY
14322   "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLCIPHER_MAX_SCHEMA_RETRY),
14323 #endif
14324 #ifdef SQLCIPHER_MEMDEBUG
14325   "MEMDEBUG",
14326 #endif
14327 #ifdef SQLCIPHER_MIXED_ENDIAN_64BIT_FLOAT
14328   "MIXED_ENDIAN_64BIT_FLOAT",
14329 #endif
14330 #ifdef SQLCIPHER_NO_SYNC
14331   "NO_SYNC",
14332 #endif
14333 #ifdef SQLCIPHER_OMIT_ALTERTABLE
14334   "OMIT_ALTERTABLE",
14335 #endif
14336 #ifdef SQLCIPHER_OMIT_ANALYZE
14337   "OMIT_ANALYZE",
14338 #endif
14339 #ifdef SQLCIPHER_OMIT_ATTACH
14340   "OMIT_ATTACH",
14341 #endif
14342 #ifdef SQLCIPHER_OMIT_AUTHORIZATION
14343   "OMIT_AUTHORIZATION",
14344 #endif
14345 #ifdef SQLCIPHER_OMIT_AUTOINCREMENT
14346   "OMIT_AUTOINCREMENT",
14347 #endif
14348 #ifdef SQLCIPHER_OMIT_AUTOINIT
14349   "OMIT_AUTOINIT",
14350 #endif
14351 #ifdef SQLCIPHER_OMIT_AUTOMATIC_INDEX
14352   "OMIT_AUTOMATIC_INDEX",
14353 #endif
14354 #ifdef SQLCIPHER_OMIT_AUTORESET
14355   "OMIT_AUTORESET",
14356 #endif
14357 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
14358   "OMIT_AUTOVACUUM",
14359 #endif
14360 #ifdef SQLCIPHER_OMIT_BETWEEN_OPTIMIZATION
14361   "OMIT_BETWEEN_OPTIMIZATION",
14362 #endif
14363 #ifdef SQLCIPHER_OMIT_BLOB_LITERAL
14364   "OMIT_BLOB_LITERAL",
14365 #endif
14366 #ifdef SQLCIPHER_OMIT_BTREECOUNT
14367   "OMIT_BTREECOUNT",
14368 #endif
14369 #ifdef SQLCIPHER_OMIT_BUILTIN_TEST
14370   "OMIT_BUILTIN_TEST",
14371 #endif
14372 #ifdef SQLCIPHER_OMIT_CAST
14373   "OMIT_CAST",
14374 #endif
14375 #ifdef SQLCIPHER_OMIT_CHECK
14376   "OMIT_CHECK",
14377 #endif
14378 /* // redundant
14379 ** #ifdef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
14380 **   "OMIT_COMPILEOPTION_DIAGS",
14381 ** #endif
14382 */
14383 #ifdef SQLCIPHER_OMIT_COMPLETE
14384   "OMIT_COMPLETE",
14385 #endif
14386 #ifdef SQLCIPHER_OMIT_COMPOUND_SELECT
14387   "OMIT_COMPOUND_SELECT",
14388 #endif
14389 #ifdef SQLCIPHER_OMIT_DATETIME_FUNCS
14390   "OMIT_DATETIME_FUNCS",
14391 #endif
14392 #ifdef SQLCIPHER_OMIT_DECLTYPE
14393   "OMIT_DECLTYPE",
14394 #endif
14395 #ifdef SQLCIPHER_OMIT_DEPRECATED
14396   "OMIT_DEPRECATED",
14397 #endif
14398 #ifdef SQLCIPHER_OMIT_DISKIO
14399   "OMIT_DISKIO",
14400 #endif
14401 #ifdef SQLCIPHER_OMIT_EXPLAIN
14402   "OMIT_EXPLAIN",
14403 #endif
14404 #ifdef SQLCIPHER_OMIT_FLAG_PRAGMAS
14405   "OMIT_FLAG_PRAGMAS",
14406 #endif
14407 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
14408   "OMIT_FLOATING_POINT",
14409 #endif
14410 #ifdef SQLCIPHER_OMIT_FOREIGN_KEY
14411   "OMIT_FOREIGN_KEY",
14412 #endif
14413 #ifdef SQLCIPHER_OMIT_GET_TABLE
14414   "OMIT_GET_TABLE",
14415 #endif
14416 #ifdef SQLCIPHER_OMIT_INCRBLOB
14417   "OMIT_INCRBLOB",
14418 #endif
14419 #ifdef SQLCIPHER_OMIT_INTEGRITY_CHECK
14420   "OMIT_INTEGRITY_CHECK",
14421 #endif
14422 #ifdef SQLCIPHER_OMIT_LIKE_OPTIMIZATION
14423   "OMIT_LIKE_OPTIMIZATION",
14424 #endif
14425 #ifdef SQLCIPHER_OMIT_LOAD_EXTENSION
14426   "OMIT_LOAD_EXTENSION",
14427 #endif
14428 #ifdef SQLCIPHER_OMIT_LOCALTIME
14429   "OMIT_LOCALTIME",
14430 #endif
14431 #ifdef SQLCIPHER_OMIT_LOOKASIDE
14432   "OMIT_LOOKASIDE",
14433 #endif
14434 #ifdef SQLCIPHER_OMIT_MEMORYDB
14435   "OMIT_MEMORYDB",
14436 #endif
14437 #ifdef SQLCIPHER_OMIT_MERGE_SORT
14438   "OMIT_MERGE_SORT",
14439 #endif
14440 #ifdef SQLCIPHER_OMIT_OR_OPTIMIZATION
14441   "OMIT_OR_OPTIMIZATION",
14442 #endif
14443 #ifdef SQLCIPHER_OMIT_PAGER_PRAGMAS
14444   "OMIT_PAGER_PRAGMAS",
14445 #endif
14446 #ifdef SQLCIPHER_OMIT_PRAGMA
14447   "OMIT_PRAGMA",
14448 #endif
14449 #ifdef SQLCIPHER_OMIT_PROGRESS_CALLBACK
14450   "OMIT_PROGRESS_CALLBACK",
14451 #endif
14452 #ifdef SQLCIPHER_OMIT_QUICKBALANCE
14453   "OMIT_QUICKBALANCE",
14454 #endif
14455 #ifdef SQLCIPHER_OMIT_REINDEX
14456   "OMIT_REINDEX",
14457 #endif
14458 #ifdef SQLCIPHER_OMIT_SCHEMA_PRAGMAS
14459   "OMIT_SCHEMA_PRAGMAS",
14460 #endif
14461 #ifdef SQLCIPHER_OMIT_SCHEMA_VERSION_PRAGMAS
14462   "OMIT_SCHEMA_VERSION_PRAGMAS",
14463 #endif
14464 #ifdef SQLCIPHER_OMIT_SHARED_CACHE
14465   "OMIT_SHARED_CACHE",
14466 #endif
14467 #ifdef SQLCIPHER_OMIT_SUBQUERY
14468   "OMIT_SUBQUERY",
14469 #endif
14470 #ifdef SQLCIPHER_OMIT_TCL_VARIABLE
14471   "OMIT_TCL_VARIABLE",
14472 #endif
14473 #ifdef SQLCIPHER_OMIT_TEMPDB
14474   "OMIT_TEMPDB",
14475 #endif
14476 #ifdef SQLCIPHER_OMIT_TRACE
14477   "OMIT_TRACE",
14478 #endif
14479 #ifdef SQLCIPHER_OMIT_TRIGGER
14480   "OMIT_TRIGGER",
14481 #endif
14482 #ifdef SQLCIPHER_OMIT_TRUNCATE_OPTIMIZATION
14483   "OMIT_TRUNCATE_OPTIMIZATION",
14484 #endif
14485 #ifdef SQLCIPHER_OMIT_UTF16
14486   "OMIT_UTF16",
14487 #endif
14488 #ifdef SQLCIPHER_OMIT_VACUUM
14489   "OMIT_VACUUM",
14490 #endif
14491 #ifdef SQLCIPHER_OMIT_VIEW
14492   "OMIT_VIEW",
14493 #endif
14494 #ifdef SQLCIPHER_OMIT_VIRTUALTABLE
14495   "OMIT_VIRTUALTABLE",
14496 #endif
14497 #ifdef SQLCIPHER_OMIT_WAL
14498   "OMIT_WAL",
14499 #endif
14500 #ifdef SQLCIPHER_OMIT_WSD
14501   "OMIT_WSD",
14502 #endif
14503 #ifdef SQLCIPHER_OMIT_XFER_OPT
14504   "OMIT_XFER_OPT",
14505 #endif
14506 #ifdef SQLCIPHER_PERFORMANCE_TRACE
14507   "PERFORMANCE_TRACE",
14508 #endif
14509 #ifdef SQLCIPHER_PROXY_DEBUG
14510   "PROXY_DEBUG",
14511 #endif
14512 #ifdef SQLCIPHER_SECURE_DELETE
14513   "SECURE_DELETE",
14514 #endif
14515 #ifdef SQLCIPHER_SMALL_STACK
14516   "SMALL_STACK",
14517 #endif
14518 #ifdef SQLCIPHER_SOUNDEX
14519   "SOUNDEX",
14520 #endif
14521 #ifdef SQLCIPHER_TCL
14522   "TCL",
14523 #endif
14524 #ifdef SQLCIPHER_TEMP_STORE
14525   "TEMP_STORE=" CTIMEOPT_VAL(SQLCIPHER_TEMP_STORE),
14526 #endif
14527 #ifdef SQLCIPHER_TEST
14528   "TEST",
14529 #endif
14530 #ifdef SQLCIPHER_THREADSAFE
14531   "THREADSAFE=" CTIMEOPT_VAL(SQLCIPHER_THREADSAFE),
14532 #endif
14533 #ifdef SQLCIPHER_USE_ALLOCA
14534   "USE_ALLOCA",
14535 #endif
14536 #ifdef SQLCIPHER_ZERO_MALLOC
14537   "ZERO_MALLOC"
14538 #endif
14539 };
14540
14541 /*
14542 ** Given the name of a compile-time option, return true if that option
14543 ** was used and false if not.
14544 **
14545 ** The name can optionally begin with "SQLCIPHER_" but the "SQLCIPHER_" prefix
14546 ** is not required for a match.
14547 */
14548 SQLCIPHER_API int sqlcipher3_compileoption_used(const char *zOptName){
14549   int i, n;
14550   if( sqlcipher3StrNICmp(zOptName, "SQLCIPHER_", 7)==0 ) zOptName += 7;
14551   n = sqlcipher3Strlen30(zOptName);
14552
14553   /* Since ArraySize(azCompileOpt) is normally in single digits, a
14554   ** linear search is adequate.  No need for a binary search. */
14555   for(i=0; i<ArraySize(azCompileOpt); i++){
14556     if(   (sqlcipher3StrNICmp(zOptName, azCompileOpt[i], n)==0)
14557        && ( (azCompileOpt[i][n]==0) || (azCompileOpt[i][n]=='=') ) ) return 1;
14558   }
14559   return 0;
14560 }
14561
14562 /*
14563 ** Return the N-th compile-time option string.  If N is out of range,
14564 ** return a NULL pointer.
14565 */
14566 SQLCIPHER_API const char *sqlcipher3_compileoption_get(int N){
14567   if( N>=0 && N<ArraySize(azCompileOpt) ){
14568     return azCompileOpt[N];
14569   }
14570   return 0;
14571 }
14572
14573 #endif /* SQLCIPHER_OMIT_COMPILEOPTION_DIAGS */
14574
14575 /************** End of ctime.c ***********************************************/
14576 /************** Begin file status.c ******************************************/
14577 /*
14578 ** 2008 June 18
14579 **
14580 ** The author disclaims copyright to this source code.  In place of
14581 ** a legal notice, here is a blessing:
14582 **
14583 **    May you do good and not evil.
14584 **    May you find forgiveness for yourself and forgive others.
14585 **    May you share freely, never taking more than you give.
14586 **
14587 *************************************************************************
14588 **
14589 ** This module implements the sqlcipher3_status() interface and related
14590 ** functionality.
14591 */
14592 /************** Include vdbeInt.h in the middle of status.c ******************/
14593 /************** Begin file vdbeInt.h *****************************************/
14594 /*
14595 ** 2003 September 6
14596 **
14597 ** The author disclaims copyright to this source code.  In place of
14598 ** a legal notice, here is a blessing:
14599 **
14600 **    May you do good and not evil.
14601 **    May you find forgiveness for yourself and forgive others.
14602 **    May you share freely, never taking more than you give.
14603 **
14604 *************************************************************************
14605 ** This is the header file for information that is private to the
14606 ** VDBE.  This information used to all be at the top of the single
14607 ** source code file "vdbe.c".  When that file became too big (over
14608 ** 6000 lines long) it was split up into several smaller files and
14609 ** this header information was factored out.
14610 */
14611 #ifndef _VDBEINT_H_
14612 #define _VDBEINT_H_
14613
14614 /*
14615 ** SQL is translated into a sequence of instructions to be
14616 ** executed by a virtual machine.  Each instruction is an instance
14617 ** of the following structure.
14618 */
14619 typedef struct VdbeOp Op;
14620
14621 /*
14622 ** Boolean values
14623 */
14624 typedef unsigned char Bool;
14625
14626 /* Opaque type used by code in vdbesort.c */
14627 typedef struct VdbeSorter VdbeSorter;
14628
14629 /*
14630 ** A cursor is a pointer into a single BTree within a database file.
14631 ** The cursor can seek to a BTree entry with a particular key, or
14632 ** loop over all entries of the Btree.  You can also insert new BTree
14633 ** entries or retrieve the key or data from the entry that the cursor
14634 ** is currently pointing to.
14635 ** 
14636 ** Every cursor that the virtual machine has open is represented by an
14637 ** instance of the following structure.
14638 */
14639 struct VdbeCursor {
14640   BtCursor *pCursor;    /* The cursor structure of the backend */
14641   Btree *pBt;           /* Separate file holding temporary table */
14642   KeyInfo *pKeyInfo;    /* Info about index keys needed by index cursors */
14643   int iDb;              /* Index of cursor database in db->aDb[] (or -1) */
14644   int pseudoTableReg;   /* Register holding pseudotable content. */
14645   int nField;           /* Number of fields in the header */
14646   Bool zeroed;          /* True if zeroed out and ready for reuse */
14647   Bool rowidIsValid;    /* True if lastRowid is valid */
14648   Bool atFirst;         /* True if pointing to first entry */
14649   Bool useRandomRowid;  /* Generate new record numbers semi-randomly */
14650   Bool nullRow;         /* True if pointing to a row with no data */
14651   Bool deferredMoveto;  /* A call to sqlcipher3BtreeMoveto() is needed */
14652   Bool isTable;         /* True if a table requiring integer keys */
14653   Bool isIndex;         /* True if an index containing keys only - no data */
14654   Bool isOrdered;       /* True if the underlying table is BTREE_UNORDERED */
14655   Bool isSorter;        /* True if a new-style sorter */
14656   sqlcipher3_vtab_cursor *pVtabCursor;  /* The cursor for a virtual table */
14657   const sqlcipher3_module *pModule;     /* Module for cursor pVtabCursor */
14658   i64 seqCount;         /* Sequence counter */
14659   i64 movetoTarget;     /* Argument to the deferred sqlcipher3BtreeMoveto() */
14660   i64 lastRowid;        /* Last rowid from a Next or NextIdx operation */
14661   VdbeSorter *pSorter;  /* Sorter object for OP_SorterOpen cursors */
14662
14663   /* Result of last sqlcipher3BtreeMoveto() done by an OP_NotExists or 
14664   ** OP_IsUnique opcode on this cursor. */
14665   int seekResult;
14666
14667   /* Cached information about the header for the data record that the
14668   ** cursor is currently pointing to.  Only valid if cacheStatus matches
14669   ** Vdbe.cacheCtr.  Vdbe.cacheCtr will never take on the value of
14670   ** CACHE_STALE and so setting cacheStatus=CACHE_STALE guarantees that
14671   ** the cache is out of date.
14672   **
14673   ** aRow might point to (ephemeral) data for the current row, or it might
14674   ** be NULL.
14675   */
14676   u32 cacheStatus;      /* Cache is valid if this matches Vdbe.cacheCtr */
14677   int payloadSize;      /* Total number of bytes in the record */
14678   u32 *aType;           /* Type values for all entries in the record */
14679   u32 *aOffset;         /* Cached offsets to the start of each columns data */
14680   u8 *aRow;             /* Data for the current row, if all on one page */
14681 };
14682 typedef struct VdbeCursor VdbeCursor;
14683
14684 /*
14685 ** When a sub-program is executed (OP_Program), a structure of this type
14686 ** is allocated to store the current value of the program counter, as
14687 ** well as the current memory cell array and various other frame specific
14688 ** values stored in the Vdbe struct. When the sub-program is finished, 
14689 ** these values are copied back to the Vdbe from the VdbeFrame structure,
14690 ** restoring the state of the VM to as it was before the sub-program
14691 ** began executing.
14692 **
14693 ** The memory for a VdbeFrame object is allocated and managed by a memory
14694 ** cell in the parent (calling) frame. When the memory cell is deleted or
14695 ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
14696 ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
14697 ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
14698 ** this instead of deleting the VdbeFrame immediately is to avoid recursive
14699 ** calls to sqlcipher3VdbeMemRelease() when the memory cells belonging to the
14700 ** child frame are released.
14701 **
14702 ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
14703 ** set to NULL if the currently executing frame is the main program.
14704 */
14705 typedef struct VdbeFrame VdbeFrame;
14706 struct VdbeFrame {
14707   Vdbe *v;                /* VM this frame belongs to */
14708   int pc;                 /* Program Counter in parent (calling) frame */
14709   Op *aOp;                /* Program instructions for parent frame */
14710   int nOp;                /* Size of aOp array */
14711   Mem *aMem;              /* Array of memory cells for parent frame */
14712   int nMem;               /* Number of entries in aMem */
14713   VdbeCursor **apCsr;     /* Array of Vdbe cursors for parent frame */
14714   u16 nCursor;            /* Number of entries in apCsr */
14715   void *token;            /* Copy of SubProgram.token */
14716   int nChildMem;          /* Number of memory cells for child frame */
14717   int nChildCsr;          /* Number of cursors for child frame */
14718   i64 lastRowid;          /* Last insert rowid (sqlcipher3.lastRowid) */
14719   int nChange;            /* Statement changes (Vdbe.nChanges)     */
14720   VdbeFrame *pParent;     /* Parent of this frame, or NULL if parent is main */
14721 };
14722
14723 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
14724
14725 /*
14726 ** A value for VdbeCursor.cacheValid that means the cache is always invalid.
14727 */
14728 #define CACHE_STALE 0
14729
14730 /*
14731 ** Internally, the vdbe manipulates nearly all SQL values as Mem
14732 ** structures. Each Mem struct may cache multiple representations (string,
14733 ** integer etc.) of the same value.
14734 */
14735 struct Mem {
14736   sqlcipher3 *db;        /* The associated database connection */
14737   char *z;            /* String or BLOB value */
14738   double r;           /* Real value */
14739   union {
14740     i64 i;              /* Integer value used when MEM_Int is set in flags */
14741     int nZero;          /* Used when bit MEM_Zero is set in flags */
14742     FuncDef *pDef;      /* Used only when flags==MEM_Agg */
14743     RowSet *pRowSet;    /* Used only when flags==MEM_RowSet */
14744     VdbeFrame *pFrame;  /* Used when flags==MEM_Frame */
14745   } u;
14746   int n;              /* Number of characters in string value, excluding '\0' */
14747   u16 flags;          /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
14748   u8  type;           /* One of SQLCIPHER_NULL, SQLCIPHER_TEXT, SQLCIPHER_INTEGER, etc */
14749   u8  enc;            /* SQLCIPHER_UTF8, SQLCIPHER_UTF16BE, SQLCIPHER_UTF16LE */
14750 #ifdef SQLCIPHER_DEBUG
14751   Mem *pScopyFrom;    /* This Mem is a shallow copy of pScopyFrom */
14752   void *pFiller;      /* So that sizeof(Mem) is a multiple of 8 */
14753 #endif
14754   void (*xDel)(void *);  /* If not null, call this function to delete Mem.z */
14755   char *zMalloc;      /* Dynamic buffer allocated by sqlcipher3_malloc() */
14756 };
14757
14758 /* One or more of the following flags are set to indicate the validOK
14759 ** representations of the value stored in the Mem struct.
14760 **
14761 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
14762 ** No other flags may be set in this case.
14763 **
14764 ** If the MEM_Str flag is set then Mem.z points at a string representation.
14765 ** Usually this is encoded in the same unicode encoding as the main
14766 ** database (see below for exceptions). If the MEM_Term flag is also
14767 ** set, then the string is nul terminated. The MEM_Int and MEM_Real 
14768 ** flags may coexist with the MEM_Str flag.
14769 */
14770 #define MEM_Null      0x0001   /* Value is NULL */
14771 #define MEM_Str       0x0002   /* Value is a string */
14772 #define MEM_Int       0x0004   /* Value is an integer */
14773 #define MEM_Real      0x0008   /* Value is a real number */
14774 #define MEM_Blob      0x0010   /* Value is a BLOB */
14775 #define MEM_RowSet    0x0020   /* Value is a RowSet object */
14776 #define MEM_Frame     0x0040   /* Value is a VdbeFrame object */
14777 #define MEM_Invalid   0x0080   /* Value is undefined */
14778 #define MEM_TypeMask  0x00ff   /* Mask of type bits */
14779
14780 /* Whenever Mem contains a valid string or blob representation, one of
14781 ** the following flags must be set to determine the memory management
14782 ** policy for Mem.z.  The MEM_Term flag tells us whether or not the
14783 ** string is \000 or \u0000 terminated
14784 */
14785 #define MEM_Term      0x0200   /* String rep is nul terminated */
14786 #define MEM_Dyn       0x0400   /* Need to call sqlcipherFree() on Mem.z */
14787 #define MEM_Static    0x0800   /* Mem.z points to a static string */
14788 #define MEM_Ephem     0x1000   /* Mem.z points to an ephemeral string */
14789 #define MEM_Agg       0x2000   /* Mem.z points to an agg function context */
14790 #define MEM_Zero      0x4000   /* Mem.i contains count of 0s appended to blob */
14791 #ifdef SQLCIPHER_OMIT_INCRBLOB
14792   #undef MEM_Zero
14793   #define MEM_Zero 0x0000
14794 #endif
14795
14796 /*
14797 ** Clear any existing type flags from a Mem and replace them with f
14798 */
14799 #define MemSetTypeFlag(p, f) \
14800    ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
14801
14802 /*
14803 ** Return true if a memory cell is not marked as invalid.  This macro
14804 ** is for use inside assert() statements only.
14805 */
14806 #ifdef SQLCIPHER_DEBUG
14807 #define memIsValid(M)  ((M)->flags & MEM_Invalid)==0
14808 #endif
14809
14810
14811 /* A VdbeFunc is just a FuncDef (defined in sqlcipherInt.h) that contains
14812 ** additional information about auxiliary information bound to arguments
14813 ** of the function.  This is used to implement the sqlcipher3_get_auxdata()
14814 ** and sqlcipher3_set_auxdata() APIs.  The "auxdata" is some auxiliary data
14815 ** that can be associated with a constant argument to a function.  This
14816 ** allows functions such as "regexp" to compile their constant regular
14817 ** expression argument once and reused the compiled code for multiple
14818 ** invocations.
14819 */
14820 struct VdbeFunc {
14821   FuncDef *pFunc;               /* The definition of the function */
14822   int nAux;                     /* Number of entries allocated for apAux[] */
14823   struct AuxData {
14824     void *pAux;                   /* Aux data for the i-th argument */
14825     void (*xDelete)(void *);      /* Destructor for the aux data */
14826   } apAux[1];                   /* One slot for each function argument */
14827 };
14828
14829 /*
14830 ** The "context" argument for a installable function.  A pointer to an
14831 ** instance of this structure is the first argument to the routines used
14832 ** implement the SQL functions.
14833 **
14834 ** There is a typedef for this structure in sqlcipher.h.  So all routines,
14835 ** even the public interface to SQLite, can use a pointer to this structure.
14836 ** But this file is the only place where the internal details of this
14837 ** structure are known.
14838 **
14839 ** This structure is defined inside of vdbeInt.h because it uses substructures
14840 ** (Mem) which are only defined there.
14841 */
14842 struct sqlcipher3_context {
14843   FuncDef *pFunc;       /* Pointer to function information.  MUST BE FIRST */
14844   VdbeFunc *pVdbeFunc;  /* Auxilary data, if created. */
14845   Mem s;                /* The return value is stored here */
14846   Mem *pMem;            /* Memory cell used to store aggregate context */
14847   int isError;          /* Error code returned by the function. */
14848   CollSeq *pColl;       /* Collating sequence */
14849 };
14850
14851 /*
14852 ** An instance of the virtual machine.  This structure contains the complete
14853 ** state of the virtual machine.
14854 **
14855 ** The "sqlcipher3_stmt" structure pointer that is returned by sqlcipher3_prepare()
14856 ** is really a pointer to an instance of this structure.
14857 **
14858 ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
14859 ** any virtual table method invocations made by the vdbe program. It is
14860 ** set to 2 for xDestroy method calls and 1 for all other methods. This
14861 ** variable is used for two purposes: to allow xDestroy methods to execute
14862 ** "DROP TABLE" statements and to prevent some nasty side effects of
14863 ** malloc failure when SQLite is invoked recursively by a virtual table 
14864 ** method function.
14865 */
14866 struct Vdbe {
14867   sqlcipher3 *db;            /* The database connection that owns this statement */
14868   Op *aOp;                /* Space to hold the virtual machine's program */
14869   Mem *aMem;              /* The memory locations */
14870   Mem **apArg;            /* Arguments to currently executing user function */
14871   Mem *aColName;          /* Column names to return */
14872   Mem *pResultSet;        /* Pointer to an array of results */
14873   int nMem;               /* Number of memory locations currently allocated */
14874   int nOp;                /* Number of instructions in the program */
14875   int nOpAlloc;           /* Number of slots allocated for aOp[] */
14876   int nLabel;             /* Number of labels used */
14877   int nLabelAlloc;        /* Number of slots allocated in aLabel[] */
14878   int *aLabel;            /* Space to hold the labels */
14879   u16 nResColumn;         /* Number of columns in one row of the result set */
14880   u16 nCursor;            /* Number of slots in apCsr[] */
14881   u32 magic;              /* Magic number for sanity checking */
14882   char *zErrMsg;          /* Error message written here */
14883   Vdbe *pPrev,*pNext;     /* Linked list of VDBEs with the same Vdbe.db */
14884   VdbeCursor **apCsr;     /* One element of this array for each open cursor */
14885   Mem *aVar;              /* Values for the OP_Variable opcode. */
14886   char **azVar;           /* Name of variables */
14887   ynVar nVar;             /* Number of entries in aVar[] */
14888   ynVar nzVar;            /* Number of entries in azVar[] */
14889   u32 cacheCtr;           /* VdbeCursor row cache generation counter */
14890   int pc;                 /* The program counter */
14891   int rc;                 /* Value to return */
14892   u8 errorAction;         /* Recovery action to do in case of an error */
14893   u8 explain;             /* True if EXPLAIN present on SQL command */
14894   u8 changeCntOn;         /* True to update the change-counter */
14895   u8 expired;             /* True if the VM needs to be recompiled */
14896   u8 runOnlyOnce;         /* Automatically expire on reset */
14897   u8 minWriteFileFormat;  /* Minimum file format for writable database files */
14898   u8 inVtabMethod;        /* See comments above */
14899   u8 usesStmtJournal;     /* True if uses a statement journal */
14900   u8 readOnly;            /* True for read-only statements */
14901   u8 isPrepareV2;         /* True if prepared with prepare_v2() */
14902   int nChange;            /* Number of db changes made since last reset */
14903   yDbMask btreeMask;      /* Bitmask of db->aDb[] entries referenced */
14904   yDbMask lockMask;       /* Subset of btreeMask that requires a lock */
14905   int iStatement;         /* Statement number (or 0 if has not opened stmt) */
14906   int aCounter[3];        /* Counters used by sqlcipher3_stmt_status() */
14907 #ifndef SQLCIPHER_OMIT_TRACE
14908   i64 startTime;          /* Time when query started - used for profiling */
14909 #endif
14910   i64 nFkConstraint;      /* Number of imm. FK constraints this VM */
14911   i64 nStmtDefCons;       /* Number of def. constraints when stmt started */
14912   char *zSql;             /* Text of the SQL statement that generated this */
14913   void *pFree;            /* Free this when deleting the vdbe */
14914 #ifdef SQLCIPHER_DEBUG
14915   FILE *trace;            /* Write an execution trace here, if not NULL */
14916 #endif
14917   VdbeFrame *pFrame;      /* Parent frame */
14918   VdbeFrame *pDelFrame;   /* List of frame objects to free on VM reset */
14919   int nFrame;             /* Number of frames in pFrame list */
14920   u32 expmask;            /* Binding to these vars invalidates VM */
14921   SubProgram *pProgram;   /* Linked list of all sub-programs used by VM */
14922 };
14923
14924 /*
14925 ** The following are allowed values for Vdbe.magic
14926 */
14927 #define VDBE_MAGIC_INIT     0x26bceaa5    /* Building a VDBE program */
14928 #define VDBE_MAGIC_RUN      0xbdf20da3    /* VDBE is ready to execute */
14929 #define VDBE_MAGIC_HALT     0x519c2973    /* VDBE has completed execution */
14930 #define VDBE_MAGIC_DEAD     0xb606c3c8    /* The VDBE has been deallocated */
14931
14932 /*
14933 ** Function prototypes
14934 */
14935 SQLCIPHER_PRIVATE void sqlcipher3VdbeFreeCursor(Vdbe *, VdbeCursor*);
14936 void sqlcipherVdbePopStack(Vdbe*,int);
14937 SQLCIPHER_PRIVATE int sqlcipher3VdbeCursorMoveto(VdbeCursor*);
14938 #if defined(SQLCIPHER_DEBUG) || defined(VDBE_PROFILE)
14939 SQLCIPHER_PRIVATE void sqlcipher3VdbePrintOp(FILE*, int, Op*);
14940 #endif
14941 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialTypeLen(u32);
14942 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialType(Mem*, int);
14943 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialPut(unsigned char*, int, Mem*, int);
14944 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialGet(const unsigned char*, u32, Mem*);
14945 SQLCIPHER_PRIVATE void sqlcipher3VdbeDeleteAuxData(VdbeFunc*, int);
14946
14947 int sqlcipher2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
14948 SQLCIPHER_PRIVATE int sqlcipher3VdbeIdxKeyCompare(VdbeCursor*,UnpackedRecord*,int*);
14949 SQLCIPHER_PRIVATE int sqlcipher3VdbeIdxRowid(sqlcipher3*, BtCursor *, i64 *);
14950 SQLCIPHER_PRIVATE int sqlcipher3MemCompare(const Mem*, const Mem*, const CollSeq*);
14951 SQLCIPHER_PRIVATE int sqlcipher3VdbeExec(Vdbe*);
14952 SQLCIPHER_PRIVATE int sqlcipher3VdbeList(Vdbe*);
14953 SQLCIPHER_PRIVATE int sqlcipher3VdbeHalt(Vdbe*);
14954 SQLCIPHER_PRIVATE int sqlcipher3VdbeChangeEncoding(Mem *, int);
14955 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemTooBig(Mem*);
14956 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemCopy(Mem*, const Mem*);
14957 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemShallowCopy(Mem*, const Mem*, int);
14958 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemMove(Mem*, Mem*);
14959 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemNulTerminate(Mem*);
14960 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
14961 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetInt64(Mem*, i64);
14962 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
14963 # define sqlcipher3VdbeMemSetDouble sqlcipher3VdbeMemSetInt64
14964 #else
14965 SQLCIPHER_PRIVATE   void sqlcipher3VdbeMemSetDouble(Mem*, double);
14966 #endif
14967 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetNull(Mem*);
14968 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetZeroBlob(Mem*,int);
14969 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetRowSet(Mem*);
14970 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemMakeWriteable(Mem*);
14971 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemStringify(Mem*, int);
14972 SQLCIPHER_PRIVATE i64 sqlcipher3VdbeIntValue(Mem*);
14973 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemIntegerify(Mem*);
14974 SQLCIPHER_PRIVATE double sqlcipher3VdbeRealValue(Mem*);
14975 SQLCIPHER_PRIVATE void sqlcipher3VdbeIntegerAffinity(Mem*);
14976 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemRealify(Mem*);
14977 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemNumerify(Mem*);
14978 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
14979 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemRelease(Mem *p);
14980 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemReleaseExternal(Mem *p);
14981 #define MemReleaseExt(X)  \
14982   if((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame)) \
14983     sqlcipher3VdbeMemReleaseExternal(X);
14984 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemFinalize(Mem*, FuncDef*);
14985 SQLCIPHER_PRIVATE const char *sqlcipher3OpcodeName(int);
14986 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemGrow(Mem *pMem, int n, int preserve);
14987 SQLCIPHER_PRIVATE int sqlcipher3VdbeCloseStatement(Vdbe *, int);
14988 SQLCIPHER_PRIVATE void sqlcipher3VdbeFrameDelete(VdbeFrame*);
14989 SQLCIPHER_PRIVATE int sqlcipher3VdbeFrameRestore(VdbeFrame *);
14990 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemStoreType(Mem *pMem);
14991 SQLCIPHER_PRIVATE int sqlcipher3VdbeTransferError(Vdbe *p);
14992
14993 #ifdef SQLCIPHER_OMIT_MERGE_SORT
14994 # define sqlcipher3VdbeSorterInit(Y,Z)      SQLCIPHER_OK
14995 # define sqlcipher3VdbeSorterWrite(X,Y,Z)   SQLCIPHER_OK
14996 # define sqlcipher3VdbeSorterClose(Y,Z)
14997 # define sqlcipher3VdbeSorterRowkey(Y,Z)    SQLCIPHER_OK
14998 # define sqlcipher3VdbeSorterRewind(X,Y,Z)  SQLCIPHER_OK
14999 # define sqlcipher3VdbeSorterNext(X,Y,Z)    SQLCIPHER_OK
15000 # define sqlcipher3VdbeSorterCompare(X,Y,Z) SQLCIPHER_OK
15001 #else
15002 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterInit(sqlcipher3 *, VdbeCursor *);
15003 SQLCIPHER_PRIVATE void sqlcipher3VdbeSorterClose(sqlcipher3 *, VdbeCursor *);
15004 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterRowkey(VdbeCursor *, Mem *);
15005 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterNext(sqlcipher3 *, VdbeCursor *, int *);
15006 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterRewind(sqlcipher3 *, VdbeCursor *, int *);
15007 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterWrite(sqlcipher3 *, VdbeCursor *, Mem *);
15008 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterCompare(VdbeCursor *, Mem *, int *);
15009 #endif
15010
15011 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && SQLCIPHER_THREADSAFE>0
15012 SQLCIPHER_PRIVATE   void sqlcipher3VdbeEnter(Vdbe*);
15013 SQLCIPHER_PRIVATE   void sqlcipher3VdbeLeave(Vdbe*);
15014 #else
15015 # define sqlcipher3VdbeEnter(X)
15016 # define sqlcipher3VdbeLeave(X)
15017 #endif
15018
15019 #ifdef SQLCIPHER_DEBUG
15020 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemPrepareToChange(Vdbe*,Mem*);
15021 #endif
15022
15023 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
15024 SQLCIPHER_PRIVATE int sqlcipher3VdbeCheckFk(Vdbe *, int);
15025 #else
15026 # define sqlcipher3VdbeCheckFk(p,i) 0
15027 #endif
15028
15029 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemTranslate(Mem*, u8);
15030 #ifdef SQLCIPHER_DEBUG
15031 SQLCIPHER_PRIVATE   void sqlcipher3VdbePrintSql(Vdbe*);
15032 SQLCIPHER_PRIVATE   void sqlcipher3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
15033 #endif
15034 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemHandleBom(Mem *pMem);
15035
15036 #ifndef SQLCIPHER_OMIT_INCRBLOB
15037 SQLCIPHER_PRIVATE   int sqlcipher3VdbeMemExpandBlob(Mem *);
15038 #else
15039   #define sqlcipher3VdbeMemExpandBlob(x) SQLCIPHER_OK
15040 #endif
15041
15042 #endif /* !defined(_VDBEINT_H_) */
15043
15044 /************** End of vdbeInt.h *********************************************/
15045 /************** Continuing where we left off in status.c *********************/
15046
15047 /*
15048 ** Variables in which to record status information.
15049 */
15050 typedef struct sqlcipher3StatType sqlcipher3StatType;
15051 static SQLCIPHER_WSD struct sqlcipher3StatType {
15052   int nowValue[10];         /* Current value */
15053   int mxValue[10];          /* Maximum value */
15054 } sqlcipher3Stat = { {0,}, {0,} };
15055
15056
15057 /* The "wsdStat" macro will resolve to the status information
15058 ** state vector.  If writable static data is unsupported on the target,
15059 ** we have to locate the state vector at run-time.  In the more common
15060 ** case where writable static data is supported, wsdStat can refer directly
15061 ** to the "sqlcipher3Stat" state vector declared above.
15062 */
15063 #ifdef SQLCIPHER_OMIT_WSD
15064 # define wsdStatInit  sqlcipher3StatType *x = &GLOBAL(sqlcipher3StatType,sqlcipher3Stat)
15065 # define wsdStat x[0]
15066 #else
15067 # define wsdStatInit
15068 # define wsdStat sqlcipher3Stat
15069 #endif
15070
15071 /*
15072 ** Return the current value of a status parameter.
15073 */
15074 SQLCIPHER_PRIVATE int sqlcipher3StatusValue(int op){
15075   wsdStatInit;
15076   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
15077   return wsdStat.nowValue[op];
15078 }
15079
15080 /*
15081 ** Add N to the value of a status record.  It is assumed that the
15082 ** caller holds appropriate locks.
15083 */
15084 SQLCIPHER_PRIVATE void sqlcipher3StatusAdd(int op, int N){
15085   wsdStatInit;
15086   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
15087   wsdStat.nowValue[op] += N;
15088   if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
15089     wsdStat.mxValue[op] = wsdStat.nowValue[op];
15090   }
15091 }
15092
15093 /*
15094 ** Set the value of a status to X.
15095 */
15096 SQLCIPHER_PRIVATE void sqlcipher3StatusSet(int op, int X){
15097   wsdStatInit;
15098   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
15099   wsdStat.nowValue[op] = X;
15100   if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
15101     wsdStat.mxValue[op] = wsdStat.nowValue[op];
15102   }
15103 }
15104
15105 /*
15106 ** Query status information.
15107 **
15108 ** This implementation assumes that reading or writing an aligned
15109 ** 32-bit integer is an atomic operation.  If that assumption is not true,
15110 ** then this routine is not threadsafe.
15111 */
15112 SQLCIPHER_API int sqlcipher3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
15113   wsdStatInit;
15114   if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
15115     return SQLCIPHER_MISUSE_BKPT;
15116   }
15117   *pCurrent = wsdStat.nowValue[op];
15118   *pHighwater = wsdStat.mxValue[op];
15119   if( resetFlag ){
15120     wsdStat.mxValue[op] = wsdStat.nowValue[op];
15121   }
15122   return SQLCIPHER_OK;
15123 }
15124
15125 /*
15126 ** Query status information for a single database connection
15127 */
15128 SQLCIPHER_API int sqlcipher3_db_status(
15129   sqlcipher3 *db,          /* The database connection whose status is desired */
15130   int op,               /* Status verb */
15131   int *pCurrent,        /* Write current value here */
15132   int *pHighwater,      /* Write high-water mark here */
15133   int resetFlag         /* Reset high-water mark if true */
15134 ){
15135   int rc = SQLCIPHER_OK;   /* Return code */
15136   sqlcipher3_mutex_enter(db->mutex);
15137   switch( op ){
15138     case SQLCIPHER_DBSTATUS_LOOKASIDE_USED: {
15139       *pCurrent = db->lookaside.nOut;
15140       *pHighwater = db->lookaside.mxOut;
15141       if( resetFlag ){
15142         db->lookaside.mxOut = db->lookaside.nOut;
15143       }
15144       break;
15145     }
15146
15147     case SQLCIPHER_DBSTATUS_LOOKASIDE_HIT:
15148     case SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_SIZE:
15149     case SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_FULL: {
15150       testcase( op==SQLCIPHER_DBSTATUS_LOOKASIDE_HIT );
15151       testcase( op==SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_SIZE );
15152       testcase( op==SQLCIPHER_DBSTATUS_LOOKASIDE_MISS_FULL );
15153       assert( (op-SQLCIPHER_DBSTATUS_LOOKASIDE_HIT)>=0 );
15154       assert( (op-SQLCIPHER_DBSTATUS_LOOKASIDE_HIT)<3 );
15155       *pCurrent = 0;
15156       *pHighwater = db->lookaside.anStat[op - SQLCIPHER_DBSTATUS_LOOKASIDE_HIT];
15157       if( resetFlag ){
15158         db->lookaside.anStat[op - SQLCIPHER_DBSTATUS_LOOKASIDE_HIT] = 0;
15159       }
15160       break;
15161     }
15162
15163     /* 
15164     ** Return an approximation for the amount of memory currently used
15165     ** by all pagers associated with the given database connection.  The
15166     ** highwater mark is meaningless and is returned as zero.
15167     */
15168     case SQLCIPHER_DBSTATUS_CACHE_USED: {
15169       int totalUsed = 0;
15170       int i;
15171       sqlcipher3BtreeEnterAll(db);
15172       for(i=0; i<db->nDb; i++){
15173         Btree *pBt = db->aDb[i].pBt;
15174         if( pBt ){
15175           Pager *pPager = sqlcipher3BtreePager(pBt);
15176           totalUsed += sqlcipher3PagerMemUsed(pPager);
15177         }
15178       }
15179       sqlcipher3BtreeLeaveAll(db);
15180       *pCurrent = totalUsed;
15181       *pHighwater = 0;
15182       break;
15183     }
15184
15185     /*
15186     ** *pCurrent gets an accurate estimate of the amount of memory used
15187     ** to store the schema for all databases (main, temp, and any ATTACHed
15188     ** databases.  *pHighwater is set to zero.
15189     */
15190     case SQLCIPHER_DBSTATUS_SCHEMA_USED: {
15191       int i;                      /* Used to iterate through schemas */
15192       int nByte = 0;              /* Used to accumulate return value */
15193
15194       sqlcipher3BtreeEnterAll(db);
15195       db->pnBytesFreed = &nByte;
15196       for(i=0; i<db->nDb; i++){
15197         Schema *pSchema = db->aDb[i].pSchema;
15198         if( ALWAYS(pSchema!=0) ){
15199           HashElem *p;
15200
15201           nByte += sqlcipher3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
15202               pSchema->tblHash.count 
15203             + pSchema->trigHash.count
15204             + pSchema->idxHash.count
15205             + pSchema->fkeyHash.count
15206           );
15207           nByte += sqlcipher3MallocSize(pSchema->tblHash.ht);
15208           nByte += sqlcipher3MallocSize(pSchema->trigHash.ht);
15209           nByte += sqlcipher3MallocSize(pSchema->idxHash.ht);
15210           nByte += sqlcipher3MallocSize(pSchema->fkeyHash.ht);
15211
15212           for(p=sqlcipherHashFirst(&pSchema->trigHash); p; p=sqlcipherHashNext(p)){
15213             sqlcipher3DeleteTrigger(db, (Trigger*)sqlcipherHashData(p));
15214           }
15215           for(p=sqlcipherHashFirst(&pSchema->tblHash); p; p=sqlcipherHashNext(p)){
15216             sqlcipher3DeleteTable(db, (Table *)sqlcipherHashData(p));
15217           }
15218         }
15219       }
15220       db->pnBytesFreed = 0;
15221       sqlcipher3BtreeLeaveAll(db);
15222
15223       *pHighwater = 0;
15224       *pCurrent = nByte;
15225       break;
15226     }
15227
15228     /*
15229     ** *pCurrent gets an accurate estimate of the amount of memory used
15230     ** to store all prepared statements.
15231     ** *pHighwater is set to zero.
15232     */
15233     case SQLCIPHER_DBSTATUS_STMT_USED: {
15234       struct Vdbe *pVdbe;         /* Used to iterate through VMs */
15235       int nByte = 0;              /* Used to accumulate return value */
15236
15237       db->pnBytesFreed = &nByte;
15238       for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
15239         sqlcipher3VdbeDeleteObject(db, pVdbe);
15240       }
15241       db->pnBytesFreed = 0;
15242
15243       *pHighwater = 0;
15244       *pCurrent = nByte;
15245
15246       break;
15247     }
15248
15249     /*
15250     ** Set *pCurrent to the total cache hits or misses encountered by all
15251     ** pagers the database handle is connected to. *pHighwater is always set 
15252     ** to zero.
15253     */
15254     case SQLCIPHER_DBSTATUS_CACHE_HIT:
15255     case SQLCIPHER_DBSTATUS_CACHE_MISS: {
15256       int i;
15257       int nRet = 0;
15258       assert( SQLCIPHER_DBSTATUS_CACHE_MISS==SQLCIPHER_DBSTATUS_CACHE_HIT+1 );
15259
15260       for(i=0; i<db->nDb; i++){
15261         if( db->aDb[i].pBt ){
15262           Pager *pPager = sqlcipher3BtreePager(db->aDb[i].pBt);
15263           sqlcipher3PagerCacheStat(pPager, op, resetFlag, &nRet);
15264         }
15265       }
15266       *pHighwater = 0;
15267       *pCurrent = nRet;
15268       break;
15269     }
15270
15271     default: {
15272       rc = SQLCIPHER_ERROR;
15273     }
15274   }
15275   sqlcipher3_mutex_leave(db->mutex);
15276   return rc;
15277 }
15278
15279 /************** End of status.c **********************************************/
15280 /************** Begin file date.c ********************************************/
15281 /*
15282 ** 2003 October 31
15283 **
15284 ** The author disclaims copyright to this source code.  In place of
15285 ** a legal notice, here is a blessing:
15286 **
15287 **    May you do good and not evil.
15288 **    May you find forgiveness for yourself and forgive others.
15289 **    May you share freely, never taking more than you give.
15290 **
15291 *************************************************************************
15292 ** This file contains the C functions that implement date and time
15293 ** functions for SQLite.  
15294 **
15295 ** There is only one exported symbol in this file - the function
15296 ** sqlcipher3RegisterDateTimeFunctions() found at the bottom of the file.
15297 ** All other code has file scope.
15298 **
15299 ** SQLite processes all times and dates as Julian Day numbers.  The
15300 ** dates and times are stored as the number of days since noon
15301 ** in Greenwich on November 24, 4714 B.C. according to the Gregorian
15302 ** calendar system. 
15303 **
15304 ** 1970-01-01 00:00:00 is JD 2440587.5
15305 ** 2000-01-01 00:00:00 is JD 2451544.5
15306 **
15307 ** This implemention requires years to be expressed as a 4-digit number
15308 ** which means that only dates between 0000-01-01 and 9999-12-31 can
15309 ** be represented, even though julian day numbers allow a much wider
15310 ** range of dates.
15311 **
15312 ** The Gregorian calendar system is used for all dates and times,
15313 ** even those that predate the Gregorian calendar.  Historians usually
15314 ** use the Julian calendar for dates prior to 1582-10-15 and for some
15315 ** dates afterwards, depending on locale.  Beware of this difference.
15316 **
15317 ** The conversion algorithms are implemented based on descriptions
15318 ** in the following text:
15319 **
15320 **      Jean Meeus
15321 **      Astronomical Algorithms, 2nd Edition, 1998
15322 **      ISBM 0-943396-61-1
15323 **      Willmann-Bell, Inc
15324 **      Richmond, Virginia (USA)
15325 */
15326 /* #include <stdlib.h> */
15327 /* #include <assert.h> */
15328 #include <time.h>
15329
15330 #ifndef SQLCIPHER_OMIT_DATETIME_FUNCS
15331
15332
15333 /*
15334 ** A structure for holding a single date and time.
15335 */
15336 typedef struct DateTime DateTime;
15337 struct DateTime {
15338   sqlcipher3_int64 iJD; /* The julian day number times 86400000 */
15339   int Y, M, D;       /* Year, month, and day */
15340   int h, m;          /* Hour and minutes */
15341   int tz;            /* Timezone offset in minutes */
15342   double s;          /* Seconds */
15343   char validYMD;     /* True (1) if Y,M,D are valid */
15344   char validHMS;     /* True (1) if h,m,s are valid */
15345   char validJD;      /* True (1) if iJD is valid */
15346   char validTZ;      /* True (1) if tz is valid */
15347 };
15348
15349
15350 /*
15351 ** Convert zDate into one or more integers.  Additional arguments
15352 ** come in groups of 5 as follows:
15353 **
15354 **       N       number of digits in the integer
15355 **       min     minimum allowed value of the integer
15356 **       max     maximum allowed value of the integer
15357 **       nextC   first character after the integer
15358 **       pVal    where to write the integers value.
15359 **
15360 ** Conversions continue until one with nextC==0 is encountered.
15361 ** The function returns the number of successful conversions.
15362 */
15363 static int getDigits(const char *zDate, ...){
15364   va_list ap;
15365   int val;
15366   int N;
15367   int min;
15368   int max;
15369   int nextC;
15370   int *pVal;
15371   int cnt = 0;
15372   va_start(ap, zDate);
15373   do{
15374     N = va_arg(ap, int);
15375     min = va_arg(ap, int);
15376     max = va_arg(ap, int);
15377     nextC = va_arg(ap, int);
15378     pVal = va_arg(ap, int*);
15379     val = 0;
15380     while( N-- ){
15381       if( !sqlcipher3Isdigit(*zDate) ){
15382         goto end_getDigits;
15383       }
15384       val = val*10 + *zDate - '0';
15385       zDate++;
15386     }
15387     if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
15388       goto end_getDigits;
15389     }
15390     *pVal = val;
15391     zDate++;
15392     cnt++;
15393   }while( nextC );
15394 end_getDigits:
15395   va_end(ap);
15396   return cnt;
15397 }
15398
15399 /*
15400 ** Parse a timezone extension on the end of a date-time.
15401 ** The extension is of the form:
15402 **
15403 **        (+/-)HH:MM
15404 **
15405 ** Or the "zulu" notation:
15406 **
15407 **        Z
15408 **
15409 ** If the parse is successful, write the number of minutes
15410 ** of change in p->tz and return 0.  If a parser error occurs,
15411 ** return non-zero.
15412 **
15413 ** A missing specifier is not considered an error.
15414 */
15415 static int parseTimezone(const char *zDate, DateTime *p){
15416   int sgn = 0;
15417   int nHr, nMn;
15418   int c;
15419   while( sqlcipher3Isspace(*zDate) ){ zDate++; }
15420   p->tz = 0;
15421   c = *zDate;
15422   if( c=='-' ){
15423     sgn = -1;
15424   }else if( c=='+' ){
15425     sgn = +1;
15426   }else if( c=='Z' || c=='z' ){
15427     zDate++;
15428     goto zulu_time;
15429   }else{
15430     return c!=0;
15431   }
15432   zDate++;
15433   if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
15434     return 1;
15435   }
15436   zDate += 5;
15437   p->tz = sgn*(nMn + nHr*60);
15438 zulu_time:
15439   while( sqlcipher3Isspace(*zDate) ){ zDate++; }
15440   return *zDate!=0;
15441 }
15442
15443 /*
15444 ** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.
15445 ** The HH, MM, and SS must each be exactly 2 digits.  The
15446 ** fractional seconds FFFF can be one or more digits.
15447 **
15448 ** Return 1 if there is a parsing error and 0 on success.
15449 */
15450 static int parseHhMmSs(const char *zDate, DateTime *p){
15451   int h, m, s;
15452   double ms = 0.0;
15453   if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
15454     return 1;
15455   }
15456   zDate += 5;
15457   if( *zDate==':' ){
15458     zDate++;
15459     if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
15460       return 1;
15461     }
15462     zDate += 2;
15463     if( *zDate=='.' && sqlcipher3Isdigit(zDate[1]) ){
15464       double rScale = 1.0;
15465       zDate++;
15466       while( sqlcipher3Isdigit(*zDate) ){
15467         ms = ms*10.0 + *zDate - '0';
15468         rScale *= 10.0;
15469         zDate++;
15470       }
15471       ms /= rScale;
15472     }
15473   }else{
15474     s = 0;
15475   }
15476   p->validJD = 0;
15477   p->validHMS = 1;
15478   p->h = h;
15479   p->m = m;
15480   p->s = s + ms;
15481   if( parseTimezone(zDate, p) ) return 1;
15482   p->validTZ = (p->tz!=0)?1:0;
15483   return 0;
15484 }
15485
15486 /*
15487 ** Convert from YYYY-MM-DD HH:MM:SS to julian day.  We always assume
15488 ** that the YYYY-MM-DD is according to the Gregorian calendar.
15489 **
15490 ** Reference:  Meeus page 61
15491 */
15492 static void computeJD(DateTime *p){
15493   int Y, M, D, A, B, X1, X2;
15494
15495   if( p->validJD ) return;
15496   if( p->validYMD ){
15497     Y = p->Y;
15498     M = p->M;
15499     D = p->D;
15500   }else{
15501     Y = 2000;  /* If no YMD specified, assume 2000-Jan-01 */
15502     M = 1;
15503     D = 1;
15504   }
15505   if( M<=2 ){
15506     Y--;
15507     M += 12;
15508   }
15509   A = Y/100;
15510   B = 2 - A + (A/4);
15511   X1 = 36525*(Y+4716)/100;
15512   X2 = 306001*(M+1)/10000;
15513   p->iJD = (sqlcipher3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
15514   p->validJD = 1;
15515   if( p->validHMS ){
15516     p->iJD += p->h*3600000 + p->m*60000 + (sqlcipher3_int64)(p->s*1000);
15517     if( p->validTZ ){
15518       p->iJD -= p->tz*60000;
15519       p->validYMD = 0;
15520       p->validHMS = 0;
15521       p->validTZ = 0;
15522     }
15523   }
15524 }
15525
15526 /*
15527 ** Parse dates of the form
15528 **
15529 **     YYYY-MM-DD HH:MM:SS.FFF
15530 **     YYYY-MM-DD HH:MM:SS
15531 **     YYYY-MM-DD HH:MM
15532 **     YYYY-MM-DD
15533 **
15534 ** Write the result into the DateTime structure and return 0
15535 ** on success and 1 if the input string is not a well-formed
15536 ** date.
15537 */
15538 static int parseYyyyMmDd(const char *zDate, DateTime *p){
15539   int Y, M, D, neg;
15540
15541   if( zDate[0]=='-' ){
15542     zDate++;
15543     neg = 1;
15544   }else{
15545     neg = 0;
15546   }
15547   if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
15548     return 1;
15549   }
15550   zDate += 10;
15551   while( sqlcipher3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }
15552   if( parseHhMmSs(zDate, p)==0 ){
15553     /* We got the time */
15554   }else if( *zDate==0 ){
15555     p->validHMS = 0;
15556   }else{
15557     return 1;
15558   }
15559   p->validJD = 0;
15560   p->validYMD = 1;
15561   p->Y = neg ? -Y : Y;
15562   p->M = M;
15563   p->D = D;
15564   if( p->validTZ ){
15565     computeJD(p);
15566   }
15567   return 0;
15568 }
15569
15570 /*
15571 ** Set the time to the current time reported by the VFS.
15572 **
15573 ** Return the number of errors.
15574 */
15575 static int setDateTimeToCurrent(sqlcipher3_context *context, DateTime *p){
15576   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
15577   if( sqlcipher3OsCurrentTimeInt64(db->pVfs, &p->iJD)==SQLCIPHER_OK ){
15578     p->validJD = 1;
15579     return 0;
15580   }else{
15581     return 1;
15582   }
15583 }
15584
15585 /*
15586 ** Attempt to parse the given string into a Julian Day Number.  Return
15587 ** the number of errors.
15588 **
15589 ** The following are acceptable forms for the input string:
15590 **
15591 **      YYYY-MM-DD HH:MM:SS.FFF  +/-HH:MM
15592 **      DDDD.DD 
15593 **      now
15594 **
15595 ** In the first form, the +/-HH:MM is always optional.  The fractional
15596 ** seconds extension (the ".FFF") is optional.  The seconds portion
15597 ** (":SS.FFF") is option.  The year and date can be omitted as long
15598 ** as there is a time string.  The time string can be omitted as long
15599 ** as there is a year and date.
15600 */
15601 static int parseDateOrTime(
15602   sqlcipher3_context *context, 
15603   const char *zDate, 
15604   DateTime *p
15605 ){
15606   double r;
15607   if( parseYyyyMmDd(zDate,p)==0 ){
15608     return 0;
15609   }else if( parseHhMmSs(zDate, p)==0 ){
15610     return 0;
15611   }else if( sqlcipher3StrICmp(zDate,"now")==0){
15612     return setDateTimeToCurrent(context, p);
15613   }else if( sqlcipher3AtoF(zDate, &r, sqlcipher3Strlen30(zDate), SQLCIPHER_UTF8) ){
15614     p->iJD = (sqlcipher3_int64)(r*86400000.0 + 0.5);
15615     p->validJD = 1;
15616     return 0;
15617   }
15618   return 1;
15619 }
15620
15621 /*
15622 ** Compute the Year, Month, and Day from the julian day number.
15623 */
15624 static void computeYMD(DateTime *p){
15625   int Z, A, B, C, D, E, X1;
15626   if( p->validYMD ) return;
15627   if( !p->validJD ){
15628     p->Y = 2000;
15629     p->M = 1;
15630     p->D = 1;
15631   }else{
15632     Z = (int)((p->iJD + 43200000)/86400000);
15633     A = (int)((Z - 1867216.25)/36524.25);
15634     A = Z + 1 + A - (A/4);
15635     B = A + 1524;
15636     C = (int)((B - 122.1)/365.25);
15637     D = (36525*C)/100;
15638     E = (int)((B-D)/30.6001);
15639     X1 = (int)(30.6001*E);
15640     p->D = B - D - X1;
15641     p->M = E<14 ? E-1 : E-13;
15642     p->Y = p->M>2 ? C - 4716 : C - 4715;
15643   }
15644   p->validYMD = 1;
15645 }
15646
15647 /*
15648 ** Compute the Hour, Minute, and Seconds from the julian day number.
15649 */
15650 static void computeHMS(DateTime *p){
15651   int s;
15652   if( p->validHMS ) return;
15653   computeJD(p);
15654   s = (int)((p->iJD + 43200000) % 86400000);
15655   p->s = s/1000.0;
15656   s = (int)p->s;
15657   p->s -= s;
15658   p->h = s/3600;
15659   s -= p->h*3600;
15660   p->m = s/60;
15661   p->s += s - p->m*60;
15662   p->validHMS = 1;
15663 }
15664
15665 /*
15666 ** Compute both YMD and HMS
15667 */
15668 static void computeYMD_HMS(DateTime *p){
15669   computeYMD(p);
15670   computeHMS(p);
15671 }
15672
15673 /*
15674 ** Clear the YMD and HMS and the TZ
15675 */
15676 static void clearYMD_HMS_TZ(DateTime *p){
15677   p->validYMD = 0;
15678   p->validHMS = 0;
15679   p->validTZ = 0;
15680 }
15681
15682 /*
15683 ** On recent Windows platforms, the localtime_s() function is available
15684 ** as part of the "Secure CRT". It is essentially equivalent to 
15685 ** localtime_r() available under most POSIX platforms, except that the 
15686 ** order of the parameters is reversed.
15687 **
15688 ** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx.
15689 **
15690 ** If the user has not indicated to use localtime_r() or localtime_s()
15691 ** already, check for an MSVC build environment that provides 
15692 ** localtime_s().
15693 */
15694 #if !defined(HAVE_LOCALTIME_R) && !defined(HAVE_LOCALTIME_S) && \
15695      defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE)
15696 #define HAVE_LOCALTIME_S 1
15697 #endif
15698
15699 #ifndef SQLCIPHER_OMIT_LOCALTIME
15700 /*
15701 ** The following routine implements the rough equivalent of localtime_r()
15702 ** using whatever operating-system specific localtime facility that
15703 ** is available.  This routine returns 0 on success and
15704 ** non-zero on any kind of error.
15705 **
15706 ** If the sqlcipher3GlobalConfig.bLocaltimeFault variable is true then this
15707 ** routine will always fail.
15708 */
15709 static int osLocaltime(time_t *t, struct tm *pTm){
15710   int rc;
15711 #if (!defined(HAVE_LOCALTIME_R) || !HAVE_LOCALTIME_R) \
15712       && (!defined(HAVE_LOCALTIME_S) || !HAVE_LOCALTIME_S)
15713   struct tm *pX;
15714 #if SQLCIPHER_THREADSAFE>0
15715   sqlcipher3_mutex *mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
15716 #endif
15717   sqlcipher3_mutex_enter(mutex);
15718   pX = localtime(t);
15719 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
15720   if( sqlcipher3GlobalConfig.bLocaltimeFault ) pX = 0;
15721 #endif
15722   if( pX ) *pTm = *pX;
15723   sqlcipher3_mutex_leave(mutex);
15724   rc = pX==0;
15725 #else
15726 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
15727   if( sqlcipher3GlobalConfig.bLocaltimeFault ) return 1;
15728 #endif
15729 #if defined(HAVE_LOCALTIME_R) && HAVE_LOCALTIME_R
15730   rc = localtime_r(t, pTm)==0;
15731 #else
15732   rc = localtime_s(pTm, t);
15733 #endif /* HAVE_LOCALTIME_R */
15734 #endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */
15735   return rc;
15736 }
15737 #endif /* SQLCIPHER_OMIT_LOCALTIME */
15738
15739
15740 #ifndef SQLCIPHER_OMIT_LOCALTIME
15741 /*
15742 ** Compute the difference (in milliseconds) between localtime and UTC
15743 ** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs,
15744 ** return this value and set *pRc to SQLCIPHER_OK. 
15745 **
15746 ** Or, if an error does occur, set *pRc to SQLCIPHER_ERROR. The returned value
15747 ** is undefined in this case.
15748 */
15749 static sqlcipher3_int64 localtimeOffset(
15750   DateTime *p,                    /* Date at which to calculate offset */
15751   sqlcipher3_context *pCtx,          /* Write error here if one occurs */
15752   int *pRc                        /* OUT: Error code. SQLCIPHER_OK or ERROR */
15753 ){
15754   DateTime x, y;
15755   time_t t;
15756   struct tm sLocal;
15757
15758   /* Initialize the contents of sLocal to avoid a compiler warning. */
15759   memset(&sLocal, 0, sizeof(sLocal));
15760
15761   x = *p;
15762   computeYMD_HMS(&x);
15763   if( x.Y<1971 || x.Y>=2038 ){
15764     x.Y = 2000;
15765     x.M = 1;
15766     x.D = 1;
15767     x.h = 0;
15768     x.m = 0;
15769     x.s = 0.0;
15770   } else {
15771     int s = (int)(x.s + 0.5);
15772     x.s = s;
15773   }
15774   x.tz = 0;
15775   x.validJD = 0;
15776   computeJD(&x);
15777   t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
15778   if( osLocaltime(&t, &sLocal) ){
15779     sqlcipher3_result_error(pCtx, "local time unavailable", -1);
15780     *pRc = SQLCIPHER_ERROR;
15781     return 0;
15782   }
15783   y.Y = sLocal.tm_year + 1900;
15784   y.M = sLocal.tm_mon + 1;
15785   y.D = sLocal.tm_mday;
15786   y.h = sLocal.tm_hour;
15787   y.m = sLocal.tm_min;
15788   y.s = sLocal.tm_sec;
15789   y.validYMD = 1;
15790   y.validHMS = 1;
15791   y.validJD = 0;
15792   y.validTZ = 0;
15793   computeJD(&y);
15794   *pRc = SQLCIPHER_OK;
15795   return y.iJD - x.iJD;
15796 }
15797 #endif /* SQLCIPHER_OMIT_LOCALTIME */
15798
15799 /*
15800 ** Process a modifier to a date-time stamp.  The modifiers are
15801 ** as follows:
15802 **
15803 **     NNN days
15804 **     NNN hours
15805 **     NNN minutes
15806 **     NNN.NNNN seconds
15807 **     NNN months
15808 **     NNN years
15809 **     start of month
15810 **     start of year
15811 **     start of week
15812 **     start of day
15813 **     weekday N
15814 **     unixepoch
15815 **     localtime
15816 **     utc
15817 **
15818 ** Return 0 on success and 1 if there is any kind of error. If the error
15819 ** is in a system call (i.e. localtime()), then an error message is written
15820 ** to context pCtx. If the error is an unrecognized modifier, no error is
15821 ** written to pCtx.
15822 */
15823 static int parseModifier(sqlcipher3_context *pCtx, const char *zMod, DateTime *p){
15824   int rc = 1;
15825   int n;
15826   double r;
15827   char *z, zBuf[30];
15828   z = zBuf;
15829   for(n=0; n<ArraySize(zBuf)-1 && zMod[n]; n++){
15830     z[n] = (char)sqlcipher3UpperToLower[(u8)zMod[n]];
15831   }
15832   z[n] = 0;
15833   switch( z[0] ){
15834 #ifndef SQLCIPHER_OMIT_LOCALTIME
15835     case 'l': {
15836       /*    localtime
15837       **
15838       ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
15839       ** show local time.
15840       */
15841       if( strcmp(z, "localtime")==0 ){
15842         computeJD(p);
15843         p->iJD += localtimeOffset(p, pCtx, &rc);
15844         clearYMD_HMS_TZ(p);
15845       }
15846       break;
15847     }
15848 #endif
15849     case 'u': {
15850       /*
15851       **    unixepoch
15852       **
15853       ** Treat the current value of p->iJD as the number of
15854       ** seconds since 1970.  Convert to a real julian day number.
15855       */
15856       if( strcmp(z, "unixepoch")==0 && p->validJD ){
15857         p->iJD = (p->iJD + 43200)/86400 + 21086676*(i64)10000000;
15858         clearYMD_HMS_TZ(p);
15859         rc = 0;
15860       }
15861 #ifndef SQLCIPHER_OMIT_LOCALTIME
15862       else if( strcmp(z, "utc")==0 ){
15863         sqlcipher3_int64 c1;
15864         computeJD(p);
15865         c1 = localtimeOffset(p, pCtx, &rc);
15866         if( rc==SQLCIPHER_OK ){
15867           p->iJD -= c1;
15868           clearYMD_HMS_TZ(p);
15869           p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
15870         }
15871       }
15872 #endif
15873       break;
15874     }
15875     case 'w': {
15876       /*
15877       **    weekday N
15878       **
15879       ** Move the date to the same time on the next occurrence of
15880       ** weekday N where 0==Sunday, 1==Monday, and so forth.  If the
15881       ** date is already on the appropriate weekday, this is a no-op.
15882       */
15883       if( strncmp(z, "weekday ", 8)==0
15884                && sqlcipher3AtoF(&z[8], &r, sqlcipher3Strlen30(&z[8]), SQLCIPHER_UTF8)
15885                && (n=(int)r)==r && n>=0 && r<7 ){
15886         sqlcipher3_int64 Z;
15887         computeYMD_HMS(p);
15888         p->validTZ = 0;
15889         p->validJD = 0;
15890         computeJD(p);
15891         Z = ((p->iJD + 129600000)/86400000) % 7;
15892         if( Z>n ) Z -= 7;
15893         p->iJD += (n - Z)*86400000;
15894         clearYMD_HMS_TZ(p);
15895         rc = 0;
15896       }
15897       break;
15898     }
15899     case 's': {
15900       /*
15901       **    start of TTTTT
15902       **
15903       ** Move the date backwards to the beginning of the current day,
15904       ** or month or year.
15905       */
15906       if( strncmp(z, "start of ", 9)!=0 ) break;
15907       z += 9;
15908       computeYMD(p);
15909       p->validHMS = 1;
15910       p->h = p->m = 0;
15911       p->s = 0.0;
15912       p->validTZ = 0;
15913       p->validJD = 0;
15914       if( strcmp(z,"month")==0 ){
15915         p->D = 1;
15916         rc = 0;
15917       }else if( strcmp(z,"year")==0 ){
15918         computeYMD(p);
15919         p->M = 1;
15920         p->D = 1;
15921         rc = 0;
15922       }else if( strcmp(z,"day")==0 ){
15923         rc = 0;
15924       }
15925       break;
15926     }
15927     case '+':
15928     case '-':
15929     case '0':
15930     case '1':
15931     case '2':
15932     case '3':
15933     case '4':
15934     case '5':
15935     case '6':
15936     case '7':
15937     case '8':
15938     case '9': {
15939       double rRounder;
15940       for(n=1; z[n] && z[n]!=':' && !sqlcipher3Isspace(z[n]); n++){}
15941       if( !sqlcipher3AtoF(z, &r, n, SQLCIPHER_UTF8) ){
15942         rc = 1;
15943         break;
15944       }
15945       if( z[n]==':' ){
15946         /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the
15947         ** specified number of hours, minutes, seconds, and fractional seconds
15948         ** to the time.  The ".FFF" may be omitted.  The ":SS.FFF" may be
15949         ** omitted.
15950         */
15951         const char *z2 = z;
15952         DateTime tx;
15953         sqlcipher3_int64 day;
15954         if( !sqlcipher3Isdigit(*z2) ) z2++;
15955         memset(&tx, 0, sizeof(tx));
15956         if( parseHhMmSs(z2, &tx) ) break;
15957         computeJD(&tx);
15958         tx.iJD -= 43200000;
15959         day = tx.iJD/86400000;
15960         tx.iJD -= day*86400000;
15961         if( z[0]=='-' ) tx.iJD = -tx.iJD;
15962         computeJD(p);
15963         clearYMD_HMS_TZ(p);
15964         p->iJD += tx.iJD;
15965         rc = 0;
15966         break;
15967       }
15968       z += n;
15969       while( sqlcipher3Isspace(*z) ) z++;
15970       n = sqlcipher3Strlen30(z);
15971       if( n>10 || n<3 ) break;
15972       if( z[n-1]=='s' ){ z[n-1] = 0; n--; }
15973       computeJD(p);
15974       rc = 0;
15975       rRounder = r<0 ? -0.5 : +0.5;
15976       if( n==3 && strcmp(z,"day")==0 ){
15977         p->iJD += (sqlcipher3_int64)(r*86400000.0 + rRounder);
15978       }else if( n==4 && strcmp(z,"hour")==0 ){
15979         p->iJD += (sqlcipher3_int64)(r*(86400000.0/24.0) + rRounder);
15980       }else if( n==6 && strcmp(z,"minute")==0 ){
15981         p->iJD += (sqlcipher3_int64)(r*(86400000.0/(24.0*60.0)) + rRounder);
15982       }else if( n==6 && strcmp(z,"second")==0 ){
15983         p->iJD += (sqlcipher3_int64)(r*(86400000.0/(24.0*60.0*60.0)) + rRounder);
15984       }else if( n==5 && strcmp(z,"month")==0 ){
15985         int x, y;
15986         computeYMD_HMS(p);
15987         p->M += (int)r;
15988         x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
15989         p->Y += x;
15990         p->M -= x*12;
15991         p->validJD = 0;
15992         computeJD(p);
15993         y = (int)r;
15994         if( y!=r ){
15995           p->iJD += (sqlcipher3_int64)((r - y)*30.0*86400000.0 + rRounder);
15996         }
15997       }else if( n==4 && strcmp(z,"year")==0 ){
15998         int y = (int)r;
15999         computeYMD_HMS(p);
16000         p->Y += y;
16001         p->validJD = 0;
16002         computeJD(p);
16003         if( y!=r ){
16004           p->iJD += (sqlcipher3_int64)((r - y)*365.0*86400000.0 + rRounder);
16005         }
16006       }else{
16007         rc = 1;
16008       }
16009       clearYMD_HMS_TZ(p);
16010       break;
16011     }
16012     default: {
16013       break;
16014     }
16015   }
16016   return rc;
16017 }
16018
16019 /*
16020 ** Process time function arguments.  argv[0] is a date-time stamp.
16021 ** argv[1] and following are modifiers.  Parse them all and write
16022 ** the resulting time into the DateTime structure p.  Return 0
16023 ** on success and 1 if there are any errors.
16024 **
16025 ** If there are zero parameters (if even argv[0] is undefined)
16026 ** then assume a default value of "now" for argv[0].
16027 */
16028 static int isDate(
16029   sqlcipher3_context *context, 
16030   int argc, 
16031   sqlcipher3_value **argv, 
16032   DateTime *p
16033 ){
16034   int i;
16035   const unsigned char *z;
16036   int eType;
16037   memset(p, 0, sizeof(*p));
16038   if( argc==0 ){
16039     return setDateTimeToCurrent(context, p);
16040   }
16041   if( (eType = sqlcipher3_value_type(argv[0]))==SQLCIPHER_FLOAT
16042                    || eType==SQLCIPHER_INTEGER ){
16043     p->iJD = (sqlcipher3_int64)(sqlcipher3_value_double(argv[0])*86400000.0 + 0.5);
16044     p->validJD = 1;
16045   }else{
16046     z = sqlcipher3_value_text(argv[0]);
16047     if( !z || parseDateOrTime(context, (char*)z, p) ){
16048       return 1;
16049     }
16050   }
16051   for(i=1; i<argc; i++){
16052     z = sqlcipher3_value_text(argv[i]);
16053     if( z==0 || parseModifier(context, (char*)z, p) ) return 1;
16054   }
16055   return 0;
16056 }
16057
16058
16059 /*
16060 ** The following routines implement the various date and time functions
16061 ** of SQLite.
16062 */
16063
16064 /*
16065 **    julianday( TIMESTRING, MOD, MOD, ...)
16066 **
16067 ** Return the julian day number of the date specified in the arguments
16068 */
16069 static void juliandayFunc(
16070   sqlcipher3_context *context,
16071   int argc,
16072   sqlcipher3_value **argv
16073 ){
16074   DateTime x;
16075   if( isDate(context, argc, argv, &x)==0 ){
16076     computeJD(&x);
16077     sqlcipher3_result_double(context, x.iJD/86400000.0);
16078   }
16079 }
16080
16081 /*
16082 **    datetime( TIMESTRING, MOD, MOD, ...)
16083 **
16084 ** Return YYYY-MM-DD HH:MM:SS
16085 */
16086 static void datetimeFunc(
16087   sqlcipher3_context *context,
16088   int argc,
16089   sqlcipher3_value **argv
16090 ){
16091   DateTime x;
16092   if( isDate(context, argc, argv, &x)==0 ){
16093     char zBuf[100];
16094     computeYMD_HMS(&x);
16095     sqlcipher3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
16096                      x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
16097     sqlcipher3_result_text(context, zBuf, -1, SQLCIPHER_TRANSIENT);
16098   }
16099 }
16100
16101 /*
16102 **    time( TIMESTRING, MOD, MOD, ...)
16103 **
16104 ** Return HH:MM:SS
16105 */
16106 static void timeFunc(
16107   sqlcipher3_context *context,
16108   int argc,
16109   sqlcipher3_value **argv
16110 ){
16111   DateTime x;
16112   if( isDate(context, argc, argv, &x)==0 ){
16113     char zBuf[100];
16114     computeHMS(&x);
16115     sqlcipher3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
16116     sqlcipher3_result_text(context, zBuf, -1, SQLCIPHER_TRANSIENT);
16117   }
16118 }
16119
16120 /*
16121 **    date( TIMESTRING, MOD, MOD, ...)
16122 **
16123 ** Return YYYY-MM-DD
16124 */
16125 static void dateFunc(
16126   sqlcipher3_context *context,
16127   int argc,
16128   sqlcipher3_value **argv
16129 ){
16130   DateTime x;
16131   if( isDate(context, argc, argv, &x)==0 ){
16132     char zBuf[100];
16133     computeYMD(&x);
16134     sqlcipher3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
16135     sqlcipher3_result_text(context, zBuf, -1, SQLCIPHER_TRANSIENT);
16136   }
16137 }
16138
16139 /*
16140 **    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
16141 **
16142 ** Return a string described by FORMAT.  Conversions as follows:
16143 **
16144 **   %d  day of month
16145 **   %f  ** fractional seconds  SS.SSS
16146 **   %H  hour 00-24
16147 **   %j  day of year 000-366
16148 **   %J  ** Julian day number
16149 **   %m  month 01-12
16150 **   %M  minute 00-59
16151 **   %s  seconds since 1970-01-01
16152 **   %S  seconds 00-59
16153 **   %w  day of week 0-6  sunday==0
16154 **   %W  week of year 00-53
16155 **   %Y  year 0000-9999
16156 **   %%  %
16157 */
16158 static void strftimeFunc(
16159   sqlcipher3_context *context,
16160   int argc,
16161   sqlcipher3_value **argv
16162 ){
16163   DateTime x;
16164   u64 n;
16165   size_t i,j;
16166   char *z;
16167   sqlcipher3 *db;
16168   const char *zFmt = (const char*)sqlcipher3_value_text(argv[0]);
16169   char zBuf[100];
16170   if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
16171   db = sqlcipher3_context_db_handle(context);
16172   for(i=0, n=1; zFmt[i]; i++, n++){
16173     if( zFmt[i]=='%' ){
16174       switch( zFmt[i+1] ){
16175         case 'd':
16176         case 'H':
16177         case 'm':
16178         case 'M':
16179         case 'S':
16180         case 'W':
16181           n++;
16182           /* fall thru */
16183         case 'w':
16184         case '%':
16185           break;
16186         case 'f':
16187           n += 8;
16188           break;
16189         case 'j':
16190           n += 3;
16191           break;
16192         case 'Y':
16193           n += 8;
16194           break;
16195         case 's':
16196         case 'J':
16197           n += 50;
16198           break;
16199         default:
16200           return;  /* ERROR.  return a NULL */
16201       }
16202       i++;
16203     }
16204   }
16205   testcase( n==sizeof(zBuf)-1 );
16206   testcase( n==sizeof(zBuf) );
16207   testcase( n==(u64)db->aLimit[SQLCIPHER_LIMIT_LENGTH]+1 );
16208   testcase( n==(u64)db->aLimit[SQLCIPHER_LIMIT_LENGTH] );
16209   if( n<sizeof(zBuf) ){
16210     z = zBuf;
16211   }else if( n>(u64)db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
16212     sqlcipher3_result_error_toobig(context);
16213     return;
16214   }else{
16215     z = sqlcipher3DbMallocRaw(db, (int)n);
16216     if( z==0 ){
16217       sqlcipher3_result_error_nomem(context);
16218       return;
16219     }
16220   }
16221   computeJD(&x);
16222   computeYMD_HMS(&x);
16223   for(i=j=0; zFmt[i]; i++){
16224     if( zFmt[i]!='%' ){
16225       z[j++] = zFmt[i];
16226     }else{
16227       i++;
16228       switch( zFmt[i] ){
16229         case 'd':  sqlcipher3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
16230         case 'f': {
16231           double s = x.s;
16232           if( s>59.999 ) s = 59.999;
16233           sqlcipher3_snprintf(7, &z[j],"%06.3f", s);
16234           j += sqlcipher3Strlen30(&z[j]);
16235           break;
16236         }
16237         case 'H':  sqlcipher3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
16238         case 'W': /* Fall thru */
16239         case 'j': {
16240           int nDay;             /* Number of days since 1st day of year */
16241           DateTime y = x;
16242           y.validJD = 0;
16243           y.M = 1;
16244           y.D = 1;
16245           computeJD(&y);
16246           nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
16247           if( zFmt[i]=='W' ){
16248             int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
16249             wd = (int)(((x.iJD+43200000)/86400000)%7);
16250             sqlcipher3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
16251             j += 2;
16252           }else{
16253             sqlcipher3_snprintf(4, &z[j],"%03d",nDay+1);
16254             j += 3;
16255           }
16256           break;
16257         }
16258         case 'J': {
16259           sqlcipher3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0);
16260           j+=sqlcipher3Strlen30(&z[j]);
16261           break;
16262         }
16263         case 'm':  sqlcipher3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
16264         case 'M':  sqlcipher3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
16265         case 's': {
16266           sqlcipher3_snprintf(30,&z[j],"%lld",
16267                            (i64)(x.iJD/1000 - 21086676*(i64)10000));
16268           j += sqlcipher3Strlen30(&z[j]);
16269           break;
16270         }
16271         case 'S':  sqlcipher3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
16272         case 'w': {
16273           z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
16274           break;
16275         }
16276         case 'Y': {
16277           sqlcipher3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlcipher3Strlen30(&z[j]);
16278           break;
16279         }
16280         default:   z[j++] = '%'; break;
16281       }
16282     }
16283   }
16284   z[j] = 0;
16285   sqlcipher3_result_text(context, z, -1,
16286                       z==zBuf ? SQLCIPHER_TRANSIENT : SQLCIPHER_DYNAMIC);
16287 }
16288
16289 /*
16290 ** current_time()
16291 **
16292 ** This function returns the same value as time('now').
16293 */
16294 static void ctimeFunc(
16295   sqlcipher3_context *context,
16296   int NotUsed,
16297   sqlcipher3_value **NotUsed2
16298 ){
16299   UNUSED_PARAMETER2(NotUsed, NotUsed2);
16300   timeFunc(context, 0, 0);
16301 }
16302
16303 /*
16304 ** current_date()
16305 **
16306 ** This function returns the same value as date('now').
16307 */
16308 static void cdateFunc(
16309   sqlcipher3_context *context,
16310   int NotUsed,
16311   sqlcipher3_value **NotUsed2
16312 ){
16313   UNUSED_PARAMETER2(NotUsed, NotUsed2);
16314   dateFunc(context, 0, 0);
16315 }
16316
16317 /*
16318 ** current_timestamp()
16319 **
16320 ** This function returns the same value as datetime('now').
16321 */
16322 static void ctimestampFunc(
16323   sqlcipher3_context *context,
16324   int NotUsed,
16325   sqlcipher3_value **NotUsed2
16326 ){
16327   UNUSED_PARAMETER2(NotUsed, NotUsed2);
16328   datetimeFunc(context, 0, 0);
16329 }
16330 #endif /* !defined(SQLCIPHER_OMIT_DATETIME_FUNCS) */
16331
16332 #ifdef SQLCIPHER_OMIT_DATETIME_FUNCS
16333 /*
16334 ** If the library is compiled to omit the full-scale date and time
16335 ** handling (to get a smaller binary), the following minimal version
16336 ** of the functions current_time(), current_date() and current_timestamp()
16337 ** are included instead. This is to support column declarations that
16338 ** include "DEFAULT CURRENT_TIME" etc.
16339 **
16340 ** This function uses the C-library functions time(), gmtime()
16341 ** and strftime(). The format string to pass to strftime() is supplied
16342 ** as the user-data for the function.
16343 */
16344 static void currentTimeFunc(
16345   sqlcipher3_context *context,
16346   int argc,
16347   sqlcipher3_value **argv
16348 ){
16349   time_t t;
16350   char *zFormat = (char *)sqlcipher3_user_data(context);
16351   sqlcipher3 *db;
16352   sqlcipher3_int64 iT;
16353   struct tm *pTm;
16354   struct tm sNow;
16355   char zBuf[20];
16356
16357   UNUSED_PARAMETER(argc);
16358   UNUSED_PARAMETER(argv);
16359
16360   db = sqlcipher3_context_db_handle(context);
16361   if( sqlcipher3OsCurrentTimeInt64(db->pVfs, &iT) ) return;
16362   t = iT/1000 - 10000*(sqlcipher3_int64)21086676;
16363 #ifdef HAVE_GMTIME_R
16364   pTm = gmtime_r(&t, &sNow);
16365 #else
16366   sqlcipher3_mutex_enter(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
16367   pTm = gmtime(&t);
16368   if( pTm ) memcpy(&sNow, pTm, sizeof(sNow));
16369   sqlcipher3_mutex_leave(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
16370 #endif
16371   if( pTm ){
16372     strftime(zBuf, 20, zFormat, &sNow);
16373     sqlcipher3_result_text(context, zBuf, -1, SQLCIPHER_TRANSIENT);
16374   }
16375 }
16376 #endif
16377
16378 /*
16379 ** This function registered all of the above C functions as SQL
16380 ** functions.  This should be the only routine in this file with
16381 ** external linkage.
16382 */
16383 SQLCIPHER_PRIVATE void sqlcipher3RegisterDateTimeFunctions(void){
16384   static SQLCIPHER_WSD FuncDef aDateTimeFuncs[] = {
16385 #ifndef SQLCIPHER_OMIT_DATETIME_FUNCS
16386     FUNCTION(julianday,        -1, 0, 0, juliandayFunc ),
16387     FUNCTION(date,             -1, 0, 0, dateFunc      ),
16388     FUNCTION(time,             -1, 0, 0, timeFunc      ),
16389     FUNCTION(datetime,         -1, 0, 0, datetimeFunc  ),
16390     FUNCTION(strftime,         -1, 0, 0, strftimeFunc  ),
16391     FUNCTION(current_time,      0, 0, 0, ctimeFunc     ),
16392     FUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
16393     FUNCTION(current_date,      0, 0, 0, cdateFunc     ),
16394 #else
16395     STR_FUNCTION(current_time,      0, "%H:%M:%S",          0, currentTimeFunc),
16396     STR_FUNCTION(current_date,      0, "%Y-%m-%d",          0, currentTimeFunc),
16397     STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc),
16398 #endif
16399   };
16400   int i;
16401   FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlcipher3GlobalFunctions);
16402   FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aDateTimeFuncs);
16403
16404   for(i=0; i<ArraySize(aDateTimeFuncs); i++){
16405     sqlcipher3FuncDefInsert(pHash, &aFunc[i]);
16406   }
16407 }
16408
16409 /************** End of date.c ************************************************/
16410 /************** Begin file os.c **********************************************/
16411 /*
16412 ** 2005 November 29
16413 **
16414 ** The author disclaims copyright to this source code.  In place of
16415 ** a legal notice, here is a blessing:
16416 **
16417 **    May you do good and not evil.
16418 **    May you find forgiveness for yourself and forgive others.
16419 **    May you share freely, never taking more than you give.
16420 **
16421 ******************************************************************************
16422 **
16423 ** This file contains OS interface code that is common to all
16424 ** architectures.
16425 */
16426 #define _SQLCIPHER_OS_C_ 1
16427 #undef _SQLCIPHER_OS_C_
16428
16429 /*
16430 ** The default SQLite sqlcipher3_vfs implementations do not allocate
16431 ** memory (actually, os_unix.c allocates a small amount of memory
16432 ** from within OsOpen()), but some third-party implementations may.
16433 ** So we test the effects of a malloc() failing and the sqlcipher3OsXXX()
16434 ** function returning SQLCIPHER_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
16435 **
16436 ** The following functions are instrumented for malloc() failure 
16437 ** testing:
16438 **
16439 **     sqlcipher3OsOpen()
16440 **     sqlcipher3OsRead()
16441 **     sqlcipher3OsWrite()
16442 **     sqlcipher3OsSync()
16443 **     sqlcipher3OsLock()
16444 **
16445 */
16446 #if defined(SQLCIPHER_TEST)
16447 SQLCIPHER_API int sqlcipher3_memdebug_vfs_oom_test = 1;
16448   #define DO_OS_MALLOC_TEST(x)                                       \
16449   if (sqlcipher3_memdebug_vfs_oom_test && (!x || !sqlcipher3IsMemJournal(x))) {  \
16450     void *pTstAlloc = sqlcipher3Malloc(10);                             \
16451     if (!pTstAlloc) return SQLCIPHER_IOERR_NOMEM;                       \
16452     sqlcipher3_free(pTstAlloc);                                         \
16453   }
16454 #else
16455   #define DO_OS_MALLOC_TEST(x)
16456 #endif
16457
16458 /*
16459 ** The following routines are convenience wrappers around methods
16460 ** of the sqlcipher3_file object.  This is mostly just syntactic sugar. All
16461 ** of this would be completely automatic if SQLite were coded using
16462 ** C++ instead of plain old C.
16463 */
16464 SQLCIPHER_PRIVATE int sqlcipher3OsClose(sqlcipher3_file *pId){
16465   int rc = SQLCIPHER_OK;
16466   if( pId->pMethods ){
16467     rc = pId->pMethods->xClose(pId);
16468     pId->pMethods = 0;
16469   }
16470   return rc;
16471 }
16472 SQLCIPHER_PRIVATE int sqlcipher3OsRead(sqlcipher3_file *id, void *pBuf, int amt, i64 offset){
16473   DO_OS_MALLOC_TEST(id);
16474   return id->pMethods->xRead(id, pBuf, amt, offset);
16475 }
16476 SQLCIPHER_PRIVATE int sqlcipher3OsWrite(sqlcipher3_file *id, const void *pBuf, int amt, i64 offset){
16477   DO_OS_MALLOC_TEST(id);
16478   return id->pMethods->xWrite(id, pBuf, amt, offset);
16479 }
16480 SQLCIPHER_PRIVATE int sqlcipher3OsTruncate(sqlcipher3_file *id, i64 size){
16481   return id->pMethods->xTruncate(id, size);
16482 }
16483 SQLCIPHER_PRIVATE int sqlcipher3OsSync(sqlcipher3_file *id, int flags){
16484   DO_OS_MALLOC_TEST(id);
16485   return id->pMethods->xSync(id, flags);
16486 }
16487 SQLCIPHER_PRIVATE int sqlcipher3OsFileSize(sqlcipher3_file *id, i64 *pSize){
16488   DO_OS_MALLOC_TEST(id);
16489   return id->pMethods->xFileSize(id, pSize);
16490 }
16491 SQLCIPHER_PRIVATE int sqlcipher3OsLock(sqlcipher3_file *id, int lockType){
16492   DO_OS_MALLOC_TEST(id);
16493   return id->pMethods->xLock(id, lockType);
16494 }
16495 SQLCIPHER_PRIVATE int sqlcipher3OsUnlock(sqlcipher3_file *id, int lockType){
16496   return id->pMethods->xUnlock(id, lockType);
16497 }
16498 SQLCIPHER_PRIVATE int sqlcipher3OsCheckReservedLock(sqlcipher3_file *id, int *pResOut){
16499   DO_OS_MALLOC_TEST(id);
16500   return id->pMethods->xCheckReservedLock(id, pResOut);
16501 }
16502 SQLCIPHER_PRIVATE int sqlcipher3OsFileControl(sqlcipher3_file *id, int op, void *pArg){
16503   return id->pMethods->xFileControl(id, op, pArg);
16504 }
16505 SQLCIPHER_PRIVATE int sqlcipher3OsSectorSize(sqlcipher3_file *id){
16506   int (*xSectorSize)(sqlcipher3_file*) = id->pMethods->xSectorSize;
16507   return (xSectorSize ? xSectorSize(id) : SQLCIPHER_DEFAULT_SECTOR_SIZE);
16508 }
16509 SQLCIPHER_PRIVATE int sqlcipher3OsDeviceCharacteristics(sqlcipher3_file *id){
16510   return id->pMethods->xDeviceCharacteristics(id);
16511 }
16512 SQLCIPHER_PRIVATE int sqlcipher3OsShmLock(sqlcipher3_file *id, int offset, int n, int flags){
16513   return id->pMethods->xShmLock(id, offset, n, flags);
16514 }
16515 SQLCIPHER_PRIVATE void sqlcipher3OsShmBarrier(sqlcipher3_file *id){
16516   id->pMethods->xShmBarrier(id);
16517 }
16518 SQLCIPHER_PRIVATE int sqlcipher3OsShmUnmap(sqlcipher3_file *id, int deleteFlag){
16519   return id->pMethods->xShmUnmap(id, deleteFlag);
16520 }
16521 SQLCIPHER_PRIVATE int sqlcipher3OsShmMap(
16522   sqlcipher3_file *id,               /* Database file handle */
16523   int iPage,
16524   int pgsz,
16525   int bExtend,                    /* True to extend file if necessary */
16526   void volatile **pp              /* OUT: Pointer to mapping */
16527 ){
16528   return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
16529 }
16530
16531 /*
16532 ** The next group of routines are convenience wrappers around the
16533 ** VFS methods.
16534 */
16535 SQLCIPHER_PRIVATE int sqlcipher3OsOpen(
16536   sqlcipher3_vfs *pVfs, 
16537   const char *zPath, 
16538   sqlcipher3_file *pFile, 
16539   int flags, 
16540   int *pFlagsOut
16541 ){
16542   int rc;
16543   DO_OS_MALLOC_TEST(0);
16544   /* 0x87f3f is a mask of SQLCIPHER_OPEN_ flags that are valid to be passed
16545   ** down into the VFS layer.  Some SQLCIPHER_OPEN_ flags (for example,
16546   ** SQLCIPHER_OPEN_FULLMUTEX or SQLCIPHER_OPEN_SHAREDCACHE) are blocked before
16547   ** reaching the VFS. */
16548   rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
16549   assert( rc==SQLCIPHER_OK || pFile->pMethods==0 );
16550   return rc;
16551 }
16552 SQLCIPHER_PRIVATE int sqlcipher3OsDelete(sqlcipher3_vfs *pVfs, const char *zPath, int dirSync){
16553   return pVfs->xDelete(pVfs, zPath, dirSync);
16554 }
16555 SQLCIPHER_PRIVATE int sqlcipher3OsAccess(
16556   sqlcipher3_vfs *pVfs, 
16557   const char *zPath, 
16558   int flags, 
16559   int *pResOut
16560 ){
16561   DO_OS_MALLOC_TEST(0);
16562   return pVfs->xAccess(pVfs, zPath, flags, pResOut);
16563 }
16564 SQLCIPHER_PRIVATE int sqlcipher3OsFullPathname(
16565   sqlcipher3_vfs *pVfs, 
16566   const char *zPath, 
16567   int nPathOut, 
16568   char *zPathOut
16569 ){
16570   zPathOut[0] = 0;
16571   return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
16572 }
16573 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
16574 SQLCIPHER_PRIVATE void *sqlcipher3OsDlOpen(sqlcipher3_vfs *pVfs, const char *zPath){
16575   return pVfs->xDlOpen(pVfs, zPath);
16576 }
16577 SQLCIPHER_PRIVATE void sqlcipher3OsDlError(sqlcipher3_vfs *pVfs, int nByte, char *zBufOut){
16578   pVfs->xDlError(pVfs, nByte, zBufOut);
16579 }
16580 SQLCIPHER_PRIVATE void (*sqlcipher3OsDlSym(sqlcipher3_vfs *pVfs, void *pHdle, const char *zSym))(void){
16581   return pVfs->xDlSym(pVfs, pHdle, zSym);
16582 }
16583 SQLCIPHER_PRIVATE void sqlcipher3OsDlClose(sqlcipher3_vfs *pVfs, void *pHandle){
16584   pVfs->xDlClose(pVfs, pHandle);
16585 }
16586 #endif /* SQLCIPHER_OMIT_LOAD_EXTENSION */
16587 SQLCIPHER_PRIVATE int sqlcipher3OsRandomness(sqlcipher3_vfs *pVfs, int nByte, char *zBufOut){
16588   return pVfs->xRandomness(pVfs, nByte, zBufOut);
16589 }
16590 SQLCIPHER_PRIVATE int sqlcipher3OsSleep(sqlcipher3_vfs *pVfs, int nMicro){
16591   return pVfs->xSleep(pVfs, nMicro);
16592 }
16593 SQLCIPHER_PRIVATE int sqlcipher3OsCurrentTimeInt64(sqlcipher3_vfs *pVfs, sqlcipher3_int64 *pTimeOut){
16594   int rc;
16595   /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
16596   ** method to get the current date and time if that method is available
16597   ** (if iVersion is 2 or greater and the function pointer is not NULL) and
16598   ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
16599   ** unavailable.
16600   */
16601   if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
16602     rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
16603   }else{
16604     double r;
16605     rc = pVfs->xCurrentTime(pVfs, &r);
16606     *pTimeOut = (sqlcipher3_int64)(r*86400000.0);
16607   }
16608   return rc;
16609 }
16610
16611 SQLCIPHER_PRIVATE int sqlcipher3OsOpenMalloc(
16612   sqlcipher3_vfs *pVfs, 
16613   const char *zFile, 
16614   sqlcipher3_file **ppFile, 
16615   int flags,
16616   int *pOutFlags
16617 ){
16618   int rc = SQLCIPHER_NOMEM;
16619   sqlcipher3_file *pFile;
16620   pFile = (sqlcipher3_file *)sqlcipher3MallocZero(pVfs->szOsFile);
16621   if( pFile ){
16622     rc = sqlcipher3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
16623     if( rc!=SQLCIPHER_OK ){
16624       sqlcipher3_free(pFile);
16625     }else{
16626       *ppFile = pFile;
16627     }
16628   }
16629   return rc;
16630 }
16631 SQLCIPHER_PRIVATE int sqlcipher3OsCloseFree(sqlcipher3_file *pFile){
16632   int rc = SQLCIPHER_OK;
16633   assert( pFile );
16634   rc = sqlcipher3OsClose(pFile);
16635   sqlcipher3_free(pFile);
16636   return rc;
16637 }
16638
16639 /*
16640 ** This function is a wrapper around the OS specific implementation of
16641 ** sqlcipher3_os_init(). The purpose of the wrapper is to provide the
16642 ** ability to simulate a malloc failure, so that the handling of an
16643 ** error in sqlcipher3_os_init() by the upper layers can be tested.
16644 */
16645 SQLCIPHER_PRIVATE int sqlcipher3OsInit(void){
16646   void *p = sqlcipher3_malloc(10);
16647   if( p==0 ) return SQLCIPHER_NOMEM;
16648   sqlcipher3_free(p);
16649   return sqlcipher3_os_init();
16650 }
16651
16652 /*
16653 ** The list of all registered VFS implementations.
16654 */
16655 static sqlcipher3_vfs * SQLCIPHER_WSD vfsList = 0;
16656 #define vfsList GLOBAL(sqlcipher3_vfs *, vfsList)
16657
16658 /*
16659 ** Locate a VFS by name.  If no name is given, simply return the
16660 ** first VFS on the list.
16661 */
16662 SQLCIPHER_API sqlcipher3_vfs *sqlcipher3_vfs_find(const char *zVfs){
16663   sqlcipher3_vfs *pVfs = 0;
16664 #if SQLCIPHER_THREADSAFE
16665   sqlcipher3_mutex *mutex;
16666 #endif
16667 #ifndef SQLCIPHER_OMIT_AUTOINIT
16668   int rc = sqlcipher3_initialize();
16669   if( rc ) return 0;
16670 #endif
16671 #if SQLCIPHER_THREADSAFE
16672   mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
16673 #endif
16674   sqlcipher3_mutex_enter(mutex);
16675   for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
16676     if( zVfs==0 ) break;
16677     if( strcmp(zVfs, pVfs->zName)==0 ) break;
16678   }
16679   sqlcipher3_mutex_leave(mutex);
16680   return pVfs;
16681 }
16682
16683 /*
16684 ** Unlink a VFS from the linked list
16685 */
16686 static void vfsUnlink(sqlcipher3_vfs *pVfs){
16687   assert( sqlcipher3_mutex_held(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER)) );
16688   if( pVfs==0 ){
16689     /* No-op */
16690   }else if( vfsList==pVfs ){
16691     vfsList = pVfs->pNext;
16692   }else if( vfsList ){
16693     sqlcipher3_vfs *p = vfsList;
16694     while( p->pNext && p->pNext!=pVfs ){
16695       p = p->pNext;
16696     }
16697     if( p->pNext==pVfs ){
16698       p->pNext = pVfs->pNext;
16699     }
16700   }
16701 }
16702
16703 /*
16704 ** Register a VFS with the system.  It is harmless to register the same
16705 ** VFS multiple times.  The new VFS becomes the default if makeDflt is
16706 ** true.
16707 */
16708 SQLCIPHER_API int sqlcipher3_vfs_register(sqlcipher3_vfs *pVfs, int makeDflt){
16709   MUTEX_LOGIC(sqlcipher3_mutex *mutex;)
16710 #ifndef SQLCIPHER_OMIT_AUTOINIT
16711   int rc = sqlcipher3_initialize();
16712   if( rc ) return rc;
16713 #endif
16714   MUTEX_LOGIC( mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER); )
16715   sqlcipher3_mutex_enter(mutex);
16716   vfsUnlink(pVfs);
16717   if( makeDflt || vfsList==0 ){
16718     pVfs->pNext = vfsList;
16719     vfsList = pVfs;
16720   }else{
16721     pVfs->pNext = vfsList->pNext;
16722     vfsList->pNext = pVfs;
16723   }
16724   assert(vfsList);
16725   sqlcipher3_mutex_leave(mutex);
16726   return SQLCIPHER_OK;
16727 }
16728
16729 /*
16730 ** Unregister a VFS so that it is no longer accessible.
16731 */
16732 SQLCIPHER_API int sqlcipher3_vfs_unregister(sqlcipher3_vfs *pVfs){
16733 #if SQLCIPHER_THREADSAFE
16734   sqlcipher3_mutex *mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
16735 #endif
16736   sqlcipher3_mutex_enter(mutex);
16737   vfsUnlink(pVfs);
16738   sqlcipher3_mutex_leave(mutex);
16739   return SQLCIPHER_OK;
16740 }
16741
16742 /************** End of os.c **************************************************/
16743 /************** Begin file fault.c *******************************************/
16744 /*
16745 ** 2008 Jan 22
16746 **
16747 ** The author disclaims copyright to this source code.  In place of
16748 ** a legal notice, here is a blessing:
16749 **
16750 **    May you do good and not evil.
16751 **    May you find forgiveness for yourself and forgive others.
16752 **    May you share freely, never taking more than you give.
16753 **
16754 *************************************************************************
16755 **
16756 ** This file contains code to support the concept of "benign" 
16757 ** malloc failures (when the xMalloc() or xRealloc() method of the
16758 ** sqlcipher3_mem_methods structure fails to allocate a block of memory
16759 ** and returns 0). 
16760 **
16761 ** Most malloc failures are non-benign. After they occur, SQLite
16762 ** abandons the current operation and returns an error code (usually
16763 ** SQLCIPHER_NOMEM) to the user. However, sometimes a fault is not necessarily
16764 ** fatal. For example, if a malloc fails while resizing a hash table, this 
16765 ** is completely recoverable simply by not carrying out the resize. The 
16766 ** hash table will continue to function normally.  So a malloc failure 
16767 ** during a hash table resize is a benign fault.
16768 */
16769
16770
16771 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
16772
16773 /*
16774 ** Global variables.
16775 */
16776 typedef struct BenignMallocHooks BenignMallocHooks;
16777 static SQLCIPHER_WSD struct BenignMallocHooks {
16778   void (*xBenignBegin)(void);
16779   void (*xBenignEnd)(void);
16780 } sqlcipher3Hooks = { 0, 0 };
16781
16782 /* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks
16783 ** structure.  If writable static data is unsupported on the target,
16784 ** we have to locate the state vector at run-time.  In the more common
16785 ** case where writable static data is supported, wsdHooks can refer directly
16786 ** to the "sqlcipher3Hooks" state vector declared above.
16787 */
16788 #ifdef SQLCIPHER_OMIT_WSD
16789 # define wsdHooksInit \
16790   BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlcipher3Hooks)
16791 # define wsdHooks x[0]
16792 #else
16793 # define wsdHooksInit
16794 # define wsdHooks sqlcipher3Hooks
16795 #endif
16796
16797
16798 /*
16799 ** Register hooks to call when sqlcipher3BeginBenignMalloc() and
16800 ** sqlcipher3EndBenignMalloc() are called, respectively.
16801 */
16802 SQLCIPHER_PRIVATE void sqlcipher3BenignMallocHooks(
16803   void (*xBenignBegin)(void),
16804   void (*xBenignEnd)(void)
16805 ){
16806   wsdHooksInit;
16807   wsdHooks.xBenignBegin = xBenignBegin;
16808   wsdHooks.xBenignEnd = xBenignEnd;
16809 }
16810
16811 /*
16812 ** This (sqlcipher3EndBenignMalloc()) is called by SQLite code to indicate that
16813 ** subsequent malloc failures are benign. A call to sqlcipher3EndBenignMalloc()
16814 ** indicates that subsequent malloc failures are non-benign.
16815 */
16816 SQLCIPHER_PRIVATE void sqlcipher3BeginBenignMalloc(void){
16817   wsdHooksInit;
16818   if( wsdHooks.xBenignBegin ){
16819     wsdHooks.xBenignBegin();
16820   }
16821 }
16822 SQLCIPHER_PRIVATE void sqlcipher3EndBenignMalloc(void){
16823   wsdHooksInit;
16824   if( wsdHooks.xBenignEnd ){
16825     wsdHooks.xBenignEnd();
16826   }
16827 }
16828
16829 #endif   /* #ifndef SQLCIPHER_OMIT_BUILTIN_TEST */
16830
16831 /************** End of fault.c ***********************************************/
16832 /************** Begin file mem0.c ********************************************/
16833 /*
16834 ** 2008 October 28
16835 **
16836 ** The author disclaims copyright to this source code.  In place of
16837 ** a legal notice, here is a blessing:
16838 **
16839 **    May you do good and not evil.
16840 **    May you find forgiveness for yourself and forgive others.
16841 **    May you share freely, never taking more than you give.
16842 **
16843 *************************************************************************
16844 **
16845 ** This file contains a no-op memory allocation drivers for use when
16846 ** SQLCIPHER_ZERO_MALLOC is defined.  The allocation drivers implemented
16847 ** here always fail.  SQLite will not operate with these drivers.  These
16848 ** are merely placeholders.  Real drivers must be substituted using
16849 ** sqlcipher3_config() before SQLite will operate.
16850 */
16851
16852 /*
16853 ** This version of the memory allocator is the default.  It is
16854 ** used when no other memory allocator is specified using compile-time
16855 ** macros.
16856 */
16857 #ifdef SQLCIPHER_ZERO_MALLOC
16858
16859 /*
16860 ** No-op versions of all memory allocation routines
16861 */
16862 static void *sqlcipher3MemMalloc(int nByte){ return 0; }
16863 static void sqlcipher3MemFree(void *pPrior){ return; }
16864 static void *sqlcipher3MemRealloc(void *pPrior, int nByte){ return 0; }
16865 static int sqlcipher3MemSize(void *pPrior){ return 0; }
16866 static int sqlcipher3MemRoundup(int n){ return n; }
16867 static int sqlcipher3MemInit(void *NotUsed){ return SQLCIPHER_OK; }
16868 static void sqlcipher3MemShutdown(void *NotUsed){ return; }
16869
16870 /*
16871 ** This routine is the only routine in this file with external linkage.
16872 **
16873 ** Populate the low-level memory allocation function pointers in
16874 ** sqlcipher3GlobalConfig.m with pointers to the routines in this file.
16875 */
16876 SQLCIPHER_PRIVATE void sqlcipher3MemSetDefault(void){
16877   static const sqlcipher3_mem_methods defaultMethods = {
16878      sqlcipher3MemMalloc,
16879      sqlcipher3MemFree,
16880      sqlcipher3MemRealloc,
16881      sqlcipher3MemSize,
16882      sqlcipher3MemRoundup,
16883      sqlcipher3MemInit,
16884      sqlcipher3MemShutdown,
16885      0
16886   };
16887   sqlcipher3_config(SQLCIPHER_CONFIG_MALLOC, &defaultMethods);
16888 }
16889
16890 #endif /* SQLCIPHER_ZERO_MALLOC */
16891
16892 /************** End of mem0.c ************************************************/
16893 /************** Begin file mem1.c ********************************************/
16894 /*
16895 ** 2007 August 14
16896 **
16897 ** The author disclaims copyright to this source code.  In place of
16898 ** a legal notice, here is a blessing:
16899 **
16900 **    May you do good and not evil.
16901 **    May you find forgiveness for yourself and forgive others.
16902 **    May you share freely, never taking more than you give.
16903 **
16904 *************************************************************************
16905 **
16906 ** This file contains low-level memory allocation drivers for when
16907 ** SQLite will use the standard C-library malloc/realloc/free interface
16908 ** to obtain the memory it needs.
16909 **
16910 ** This file contains implementations of the low-level memory allocation
16911 ** routines specified in the sqlcipher3_mem_methods object.
16912 */
16913
16914 /*
16915 ** This version of the memory allocator is the default.  It is
16916 ** used when no other memory allocator is specified using compile-time
16917 ** macros.
16918 */
16919 #ifdef SQLCIPHER_SYSTEM_MALLOC
16920
16921 /*
16922 ** Like malloc(), but remember the size of the allocation
16923 ** so that we can find it later using sqlcipher3MemSize().
16924 **
16925 ** For this low-level routine, we are guaranteed that nByte>0 because
16926 ** cases of nByte<=0 will be intercepted and dealt with by higher level
16927 ** routines.
16928 */
16929 static void *sqlcipher3MemMalloc(int nByte){
16930   sqlcipher3_int64 *p;
16931   assert( nByte>0 );
16932   nByte = ROUND8(nByte);
16933   p = malloc( nByte+8 );
16934   if( p ){
16935     p[0] = nByte;
16936     p++;
16937   }else{
16938     testcase( sqlcipher3GlobalConfig.xLog!=0 );
16939     sqlcipher3_log(SQLCIPHER_NOMEM, "failed to allocate %u bytes of memory", nByte);
16940   }
16941   return (void *)p;
16942 }
16943
16944 /*
16945 ** Like free() but works for allocations obtained from sqlcipher3MemMalloc()
16946 ** or sqlcipher3MemRealloc().
16947 **
16948 ** For this low-level routine, we already know that pPrior!=0 since
16949 ** cases where pPrior==0 will have been intecepted and dealt with
16950 ** by higher-level routines.
16951 */
16952 static void sqlcipher3MemFree(void *pPrior){
16953   sqlcipher3_int64 *p = (sqlcipher3_int64*)pPrior;
16954   assert( pPrior!=0 );
16955   p--;
16956   free(p);
16957 }
16958
16959 /*
16960 ** Report the allocated size of a prior return from xMalloc()
16961 ** or xRealloc().
16962 */
16963 static int sqlcipher3MemSize(void *pPrior){
16964   sqlcipher3_int64 *p;
16965   if( pPrior==0 ) return 0;
16966   p = (sqlcipher3_int64*)pPrior;
16967   p--;
16968   return (int)p[0];
16969 }
16970
16971 /*
16972 ** Like realloc().  Resize an allocation previously obtained from
16973 ** sqlcipher3MemMalloc().
16974 **
16975 ** For this low-level interface, we know that pPrior!=0.  Cases where
16976 ** pPrior==0 while have been intercepted by higher-level routine and
16977 ** redirected to xMalloc.  Similarly, we know that nByte>0 becauses
16978 ** cases where nByte<=0 will have been intercepted by higher-level
16979 ** routines and redirected to xFree.
16980 */
16981 static void *sqlcipher3MemRealloc(void *pPrior, int nByte){
16982   sqlcipher3_int64 *p = (sqlcipher3_int64*)pPrior;
16983   assert( pPrior!=0 && nByte>0 );
16984   assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
16985   p--;
16986   p = realloc(p, nByte+8 );
16987   if( p ){
16988     p[0] = nByte;
16989     p++;
16990   }else{
16991     testcase( sqlcipher3GlobalConfig.xLog!=0 );
16992     sqlcipher3_log(SQLCIPHER_NOMEM,
16993       "failed memory resize %u to %u bytes",
16994       sqlcipher3MemSize(pPrior), nByte);
16995   }
16996   return (void*)p;
16997 }
16998
16999 /*
17000 ** Round up a request size to the next valid allocation size.
17001 */
17002 static int sqlcipher3MemRoundup(int n){
17003   return ROUND8(n);
17004 }
17005
17006 /*
17007 ** Initialize this module.
17008 */
17009 static int sqlcipher3MemInit(void *NotUsed){
17010   UNUSED_PARAMETER(NotUsed);
17011   return SQLCIPHER_OK;
17012 }
17013
17014 /*
17015 ** Deinitialize this module.
17016 */
17017 static void sqlcipher3MemShutdown(void *NotUsed){
17018   UNUSED_PARAMETER(NotUsed);
17019   return;
17020 }
17021
17022 /*
17023 ** This routine is the only routine in this file with external linkage.
17024 **
17025 ** Populate the low-level memory allocation function pointers in
17026 ** sqlcipher3GlobalConfig.m with pointers to the routines in this file.
17027 */
17028 SQLCIPHER_PRIVATE void sqlcipher3MemSetDefault(void){
17029   static const sqlcipher3_mem_methods defaultMethods = {
17030      sqlcipher3MemMalloc,
17031      sqlcipher3MemFree,
17032      sqlcipher3MemRealloc,
17033      sqlcipher3MemSize,
17034      sqlcipher3MemRoundup,
17035      sqlcipher3MemInit,
17036      sqlcipher3MemShutdown,
17037      0
17038   };
17039   sqlcipher3_config(SQLCIPHER_CONFIG_MALLOC, &defaultMethods);
17040 }
17041
17042 #endif /* SQLCIPHER_SYSTEM_MALLOC */
17043
17044 /************** End of mem1.c ************************************************/
17045 /************** Begin file mem2.c ********************************************/
17046 /*
17047 ** 2007 August 15
17048 **
17049 ** The author disclaims copyright to this source code.  In place of
17050 ** a legal notice, here is a blessing:
17051 **
17052 **    May you do good and not evil.
17053 **    May you find forgiveness for yourself and forgive others.
17054 **    May you share freely, never taking more than you give.
17055 **
17056 *************************************************************************
17057 **
17058 ** This file contains low-level memory allocation drivers for when
17059 ** SQLite will use the standard C-library malloc/realloc/free interface
17060 ** to obtain the memory it needs while adding lots of additional debugging
17061 ** information to each allocation in order to help detect and fix memory
17062 ** leaks and memory usage errors.
17063 **
17064 ** This file contains implementations of the low-level memory allocation
17065 ** routines specified in the sqlcipher3_mem_methods object.
17066 */
17067
17068 /*
17069 ** This version of the memory allocator is used only if the
17070 ** SQLCIPHER_MEMDEBUG macro is defined
17071 */
17072 #ifdef SQLCIPHER_MEMDEBUG
17073
17074 /*
17075 ** The backtrace functionality is only available with GLIBC
17076 */
17077 #ifdef __GLIBC__
17078   extern int backtrace(void**,int);
17079   extern void backtrace_symbols_fd(void*const*,int,int);
17080 #else
17081 # define backtrace(A,B) 1
17082 # define backtrace_symbols_fd(A,B,C)
17083 #endif
17084 /* #include <stdio.h> */
17085
17086 /*
17087 ** Each memory allocation looks like this:
17088 **
17089 **  ------------------------------------------------------------------------
17090 **  | Title |  backtrace pointers |  MemBlockHdr |  allocation |  EndGuard |
17091 **  ------------------------------------------------------------------------
17092 **
17093 ** The application code sees only a pointer to the allocation.  We have
17094 ** to back up from the allocation pointer to find the MemBlockHdr.  The
17095 ** MemBlockHdr tells us the size of the allocation and the number of
17096 ** backtrace pointers.  There is also a guard word at the end of the
17097 ** MemBlockHdr.
17098 */
17099 struct MemBlockHdr {
17100   i64 iSize;                          /* Size of this allocation */
17101   struct MemBlockHdr *pNext, *pPrev;  /* Linked list of all unfreed memory */
17102   char nBacktrace;                    /* Number of backtraces on this alloc */
17103   char nBacktraceSlots;               /* Available backtrace slots */
17104   u8 nTitle;                          /* Bytes of title; includes '\0' */
17105   u8 eType;                           /* Allocation type code */
17106   int iForeGuard;                     /* Guard word for sanity */
17107 };
17108
17109 /*
17110 ** Guard words
17111 */
17112 #define FOREGUARD 0x80F5E153
17113 #define REARGUARD 0xE4676B53
17114
17115 /*
17116 ** Number of malloc size increments to track.
17117 */
17118 #define NCSIZE  1000
17119
17120 /*
17121 ** All of the static variables used by this module are collected
17122 ** into a single structure named "mem".  This is to keep the
17123 ** static variables organized and to reduce namespace pollution
17124 ** when this module is combined with other in the amalgamation.
17125 */
17126 static struct {
17127   
17128   /*
17129   ** Mutex to control access to the memory allocation subsystem.
17130   */
17131   sqlcipher3_mutex *mutex;
17132
17133   /*
17134   ** Head and tail of a linked list of all outstanding allocations
17135   */
17136   struct MemBlockHdr *pFirst;
17137   struct MemBlockHdr *pLast;
17138   
17139   /*
17140   ** The number of levels of backtrace to save in new allocations.
17141   */
17142   int nBacktrace;
17143   void (*xBacktrace)(int, int, void **);
17144
17145   /*
17146   ** Title text to insert in front of each block
17147   */
17148   int nTitle;        /* Bytes of zTitle to save.  Includes '\0' and padding */
17149   char zTitle[100];  /* The title text */
17150
17151   /* 
17152   ** sqlcipher3MallocDisallow() increments the following counter.
17153   ** sqlcipher3MallocAllow() decrements it.
17154   */
17155   int disallow; /* Do not allow memory allocation */
17156
17157   /*
17158   ** Gather statistics on the sizes of memory allocations.
17159   ** nAlloc[i] is the number of allocation attempts of i*8
17160   ** bytes.  i==NCSIZE is the number of allocation attempts for
17161   ** sizes more than NCSIZE*8 bytes.
17162   */
17163   int nAlloc[NCSIZE];      /* Total number of allocations */
17164   int nCurrent[NCSIZE];    /* Current number of allocations */
17165   int mxCurrent[NCSIZE];   /* Highwater mark for nCurrent */
17166
17167 } mem;
17168
17169
17170 /*
17171 ** Adjust memory usage statistics
17172 */
17173 static void adjustStats(int iSize, int increment){
17174   int i = ROUND8(iSize)/8;
17175   if( i>NCSIZE-1 ){
17176     i = NCSIZE - 1;
17177   }
17178   if( increment>0 ){
17179     mem.nAlloc[i]++;
17180     mem.nCurrent[i]++;
17181     if( mem.nCurrent[i]>mem.mxCurrent[i] ){
17182       mem.mxCurrent[i] = mem.nCurrent[i];
17183     }
17184   }else{
17185     mem.nCurrent[i]--;
17186     assert( mem.nCurrent[i]>=0 );
17187   }
17188 }
17189
17190 /*
17191 ** Given an allocation, find the MemBlockHdr for that allocation.
17192 **
17193 ** This routine checks the guards at either end of the allocation and
17194 ** if they are incorrect it asserts.
17195 */
17196 static struct MemBlockHdr *sqlcipher3MemsysGetHeader(void *pAllocation){
17197   struct MemBlockHdr *p;
17198   int *pInt;
17199   u8 *pU8;
17200   int nReserve;
17201
17202   p = (struct MemBlockHdr*)pAllocation;
17203   p--;
17204   assert( p->iForeGuard==(int)FOREGUARD );
17205   nReserve = ROUND8(p->iSize);
17206   pInt = (int*)pAllocation;
17207   pU8 = (u8*)pAllocation;
17208   assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD );
17209   /* This checks any of the "extra" bytes allocated due
17210   ** to rounding up to an 8 byte boundary to ensure 
17211   ** they haven't been overwritten.
17212   */
17213   while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 );
17214   return p;
17215 }
17216
17217 /*
17218 ** Return the number of bytes currently allocated at address p.
17219 */
17220 static int sqlcipher3MemSize(void *p){
17221   struct MemBlockHdr *pHdr;
17222   if( !p ){
17223     return 0;
17224   }
17225   pHdr = sqlcipher3MemsysGetHeader(p);
17226   return pHdr->iSize;
17227 }
17228
17229 /*
17230 ** Initialize the memory allocation subsystem.
17231 */
17232 static int sqlcipher3MemInit(void *NotUsed){
17233   UNUSED_PARAMETER(NotUsed);
17234   assert( (sizeof(struct MemBlockHdr)&7) == 0 );
17235   if( !sqlcipher3GlobalConfig.bMemstat ){
17236     /* If memory status is enabled, then the malloc.c wrapper will already
17237     ** hold the STATIC_MEM mutex when the routines here are invoked. */
17238     mem.mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MEM);
17239   }
17240   return SQLCIPHER_OK;
17241 }
17242
17243 /*
17244 ** Deinitialize the memory allocation subsystem.
17245 */
17246 static void sqlcipher3MemShutdown(void *NotUsed){
17247   UNUSED_PARAMETER(NotUsed);
17248   mem.mutex = 0;
17249 }
17250
17251 /*
17252 ** Round up a request size to the next valid allocation size.
17253 */
17254 static int sqlcipher3MemRoundup(int n){
17255   return ROUND8(n);
17256 }
17257
17258 /*
17259 ** Fill a buffer with pseudo-random bytes.  This is used to preset
17260 ** the content of a new memory allocation to unpredictable values and
17261 ** to clear the content of a freed allocation to unpredictable values.
17262 */
17263 static void randomFill(char *pBuf, int nByte){
17264   unsigned int x, y, r;
17265   x = SQLCIPHER_PTR_TO_INT(pBuf);
17266   y = nByte | 1;
17267   while( nByte >= 4 ){
17268     x = (x>>1) ^ (-(x&1) & 0xd0000001);
17269     y = y*1103515245 + 12345;
17270     r = x ^ y;
17271     *(int*)pBuf = r;
17272     pBuf += 4;
17273     nByte -= 4;
17274   }
17275   while( nByte-- > 0 ){
17276     x = (x>>1) ^ (-(x&1) & 0xd0000001);
17277     y = y*1103515245 + 12345;
17278     r = x ^ y;
17279     *(pBuf++) = r & 0xff;
17280   }
17281 }
17282
17283 /*
17284 ** Allocate nByte bytes of memory.
17285 */
17286 static void *sqlcipher3MemMalloc(int nByte){
17287   struct MemBlockHdr *pHdr;
17288   void **pBt;
17289   char *z;
17290   int *pInt;
17291   void *p = 0;
17292   int totalSize;
17293   int nReserve;
17294   sqlcipher3_mutex_enter(mem.mutex);
17295   assert( mem.disallow==0 );
17296   nReserve = ROUND8(nByte);
17297   totalSize = nReserve + sizeof(*pHdr) + sizeof(int) +
17298                mem.nBacktrace*sizeof(void*) + mem.nTitle;
17299   p = malloc(totalSize);
17300   if( p ){
17301     z = p;
17302     pBt = (void**)&z[mem.nTitle];
17303     pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
17304     pHdr->pNext = 0;
17305     pHdr->pPrev = mem.pLast;
17306     if( mem.pLast ){
17307       mem.pLast->pNext = pHdr;
17308     }else{
17309       mem.pFirst = pHdr;
17310     }
17311     mem.pLast = pHdr;
17312     pHdr->iForeGuard = FOREGUARD;
17313     pHdr->eType = MEMTYPE_HEAP;
17314     pHdr->nBacktraceSlots = mem.nBacktrace;
17315     pHdr->nTitle = mem.nTitle;
17316     if( mem.nBacktrace ){
17317       void *aAddr[40];
17318       pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
17319       memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
17320       assert(pBt[0]);
17321       if( mem.xBacktrace ){
17322         mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
17323       }
17324     }else{
17325       pHdr->nBacktrace = 0;
17326     }
17327     if( mem.nTitle ){
17328       memcpy(z, mem.zTitle, mem.nTitle);
17329     }
17330     pHdr->iSize = nByte;
17331     adjustStats(nByte, +1);
17332     pInt = (int*)&pHdr[1];
17333     pInt[nReserve/sizeof(int)] = REARGUARD;
17334     randomFill((char*)pInt, nByte);
17335     memset(((char*)pInt)+nByte, 0x65, nReserve-nByte);
17336     p = (void*)pInt;
17337   }
17338   sqlcipher3_mutex_leave(mem.mutex);
17339   return p; 
17340 }
17341
17342 /*
17343 ** Free memory.
17344 */
17345 static void sqlcipher3MemFree(void *pPrior){
17346   struct MemBlockHdr *pHdr;
17347   void **pBt;
17348   char *z;
17349   assert( sqlcipher3GlobalConfig.bMemstat || sqlcipher3GlobalConfig.bCoreMutex==0 
17350        || mem.mutex!=0 );
17351   pHdr = sqlcipher3MemsysGetHeader(pPrior);
17352   pBt = (void**)pHdr;
17353   pBt -= pHdr->nBacktraceSlots;
17354   sqlcipher3_mutex_enter(mem.mutex);
17355   if( pHdr->pPrev ){
17356     assert( pHdr->pPrev->pNext==pHdr );
17357     pHdr->pPrev->pNext = pHdr->pNext;
17358   }else{
17359     assert( mem.pFirst==pHdr );
17360     mem.pFirst = pHdr->pNext;
17361   }
17362   if( pHdr->pNext ){
17363     assert( pHdr->pNext->pPrev==pHdr );
17364     pHdr->pNext->pPrev = pHdr->pPrev;
17365   }else{
17366     assert( mem.pLast==pHdr );
17367     mem.pLast = pHdr->pPrev;
17368   }
17369   z = (char*)pBt;
17370   z -= pHdr->nTitle;
17371   adjustStats(pHdr->iSize, -1);
17372   randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
17373                 pHdr->iSize + sizeof(int) + pHdr->nTitle);
17374   free(z);
17375   sqlcipher3_mutex_leave(mem.mutex);  
17376 }
17377
17378 /*
17379 ** Change the size of an existing memory allocation.
17380 **
17381 ** For this debugging implementation, we *always* make a copy of the
17382 ** allocation into a new place in memory.  In this way, if the 
17383 ** higher level code is using pointer to the old allocation, it is 
17384 ** much more likely to break and we are much more liking to find
17385 ** the error.
17386 */
17387 static void *sqlcipher3MemRealloc(void *pPrior, int nByte){
17388   struct MemBlockHdr *pOldHdr;
17389   void *pNew;
17390   assert( mem.disallow==0 );
17391   assert( (nByte & 7)==0 );     /* EV: R-46199-30249 */
17392   pOldHdr = sqlcipher3MemsysGetHeader(pPrior);
17393   pNew = sqlcipher3MemMalloc(nByte);
17394   if( pNew ){
17395     memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
17396     if( nByte>pOldHdr->iSize ){
17397       randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
17398     }
17399     sqlcipher3MemFree(pPrior);
17400   }
17401   return pNew;
17402 }
17403
17404 /*
17405 ** Populate the low-level memory allocation function pointers in
17406 ** sqlcipher3GlobalConfig.m with pointers to the routines in this file.
17407 */
17408 SQLCIPHER_PRIVATE void sqlcipher3MemSetDefault(void){
17409   static const sqlcipher3_mem_methods defaultMethods = {
17410      sqlcipher3MemMalloc,
17411      sqlcipher3MemFree,
17412      sqlcipher3MemRealloc,
17413      sqlcipher3MemSize,
17414      sqlcipher3MemRoundup,
17415      sqlcipher3MemInit,
17416      sqlcipher3MemShutdown,
17417      0
17418   };
17419   sqlcipher3_config(SQLCIPHER_CONFIG_MALLOC, &defaultMethods);
17420 }
17421
17422 /*
17423 ** Set the "type" of an allocation.
17424 */
17425 SQLCIPHER_PRIVATE void sqlcipher3MemdebugSetType(void *p, u8 eType){
17426   if( p && sqlcipher3GlobalConfig.m.xMalloc==sqlcipher3MemMalloc ){
17427     struct MemBlockHdr *pHdr;
17428     pHdr = sqlcipher3MemsysGetHeader(p);
17429     assert( pHdr->iForeGuard==FOREGUARD );
17430     pHdr->eType = eType;
17431   }
17432 }
17433
17434 /*
17435 ** Return TRUE if the mask of type in eType matches the type of the
17436 ** allocation p.  Also return true if p==NULL.
17437 **
17438 ** This routine is designed for use within an assert() statement, to
17439 ** verify the type of an allocation.  For example:
17440 **
17441 **     assert( sqlcipher3MemdebugHasType(p, MEMTYPE_DB) );
17442 */
17443 SQLCIPHER_PRIVATE int sqlcipher3MemdebugHasType(void *p, u8 eType){
17444   int rc = 1;
17445   if( p && sqlcipher3GlobalConfig.m.xMalloc==sqlcipher3MemMalloc ){
17446     struct MemBlockHdr *pHdr;
17447     pHdr = sqlcipher3MemsysGetHeader(p);
17448     assert( pHdr->iForeGuard==FOREGUARD );         /* Allocation is valid */
17449     if( (pHdr->eType&eType)==0 ){
17450       rc = 0;
17451     }
17452   }
17453   return rc;
17454 }
17455
17456 /*
17457 ** Return TRUE if the mask of type in eType matches no bits of the type of the
17458 ** allocation p.  Also return true if p==NULL.
17459 **
17460 ** This routine is designed for use within an assert() statement, to
17461 ** verify the type of an allocation.  For example:
17462 **
17463 **     assert( sqlcipher3MemdebugNoType(p, MEMTYPE_DB) );
17464 */
17465 SQLCIPHER_PRIVATE int sqlcipher3MemdebugNoType(void *p, u8 eType){
17466   int rc = 1;
17467   if( p && sqlcipher3GlobalConfig.m.xMalloc==sqlcipher3MemMalloc ){
17468     struct MemBlockHdr *pHdr;
17469     pHdr = sqlcipher3MemsysGetHeader(p);
17470     assert( pHdr->iForeGuard==FOREGUARD );         /* Allocation is valid */
17471     if( (pHdr->eType&eType)!=0 ){
17472       rc = 0;
17473     }
17474   }
17475   return rc;
17476 }
17477
17478 /*
17479 ** Set the number of backtrace levels kept for each allocation.
17480 ** A value of zero turns off backtracing.  The number is always rounded
17481 ** up to a multiple of 2.
17482 */
17483 SQLCIPHER_PRIVATE void sqlcipher3MemdebugBacktrace(int depth){
17484   if( depth<0 ){ depth = 0; }
17485   if( depth>20 ){ depth = 20; }
17486   depth = (depth+1)&0xfe;
17487   mem.nBacktrace = depth;
17488 }
17489
17490 SQLCIPHER_PRIVATE void sqlcipher3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){
17491   mem.xBacktrace = xBacktrace;
17492 }
17493
17494 /*
17495 ** Set the title string for subsequent allocations.
17496 */
17497 SQLCIPHER_PRIVATE void sqlcipher3MemdebugSettitle(const char *zTitle){
17498   unsigned int n = sqlcipher3Strlen30(zTitle) + 1;
17499   sqlcipher3_mutex_enter(mem.mutex);
17500   if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
17501   memcpy(mem.zTitle, zTitle, n);
17502   mem.zTitle[n] = 0;
17503   mem.nTitle = ROUND8(n);
17504   sqlcipher3_mutex_leave(mem.mutex);
17505 }
17506
17507 SQLCIPHER_PRIVATE void sqlcipher3MemdebugSync(){
17508   struct MemBlockHdr *pHdr;
17509   for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
17510     void **pBt = (void**)pHdr;
17511     pBt -= pHdr->nBacktraceSlots;
17512     mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
17513   }
17514 }
17515
17516 /*
17517 ** Open the file indicated and write a log of all unfreed memory 
17518 ** allocations into that log.
17519 */
17520 SQLCIPHER_PRIVATE void sqlcipher3MemdebugDump(const char *zFilename){
17521   FILE *out;
17522   struct MemBlockHdr *pHdr;
17523   void **pBt;
17524   int i;
17525   out = fopen(zFilename, "w");
17526   if( out==0 ){
17527     fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
17528                     zFilename);
17529     return;
17530   }
17531   for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
17532     char *z = (char*)pHdr;
17533     z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
17534     fprintf(out, "**** %lld bytes at %p from %s ****\n", 
17535             pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
17536     if( pHdr->nBacktrace ){
17537       fflush(out);
17538       pBt = (void**)pHdr;
17539       pBt -= pHdr->nBacktraceSlots;
17540       backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
17541       fprintf(out, "\n");
17542     }
17543   }
17544   fprintf(out, "COUNTS:\n");
17545   for(i=0; i<NCSIZE-1; i++){
17546     if( mem.nAlloc[i] ){
17547       fprintf(out, "   %5d: %10d %10d %10d\n", 
17548             i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
17549     }
17550   }
17551   if( mem.nAlloc[NCSIZE-1] ){
17552     fprintf(out, "   %5d: %10d %10d %10d\n",
17553              NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
17554              mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
17555   }
17556   fclose(out);
17557 }
17558
17559 /*
17560 ** Return the number of times sqlcipher3MemMalloc() has been called.
17561 */
17562 SQLCIPHER_PRIVATE int sqlcipher3MemdebugMallocCount(){
17563   int i;
17564   int nTotal = 0;
17565   for(i=0; i<NCSIZE; i++){
17566     nTotal += mem.nAlloc[i];
17567   }
17568   return nTotal;
17569 }
17570
17571
17572 #endif /* SQLCIPHER_MEMDEBUG */
17573
17574 /************** End of mem2.c ************************************************/
17575 /************** Begin file mem3.c ********************************************/
17576 /*
17577 ** 2007 October 14
17578 **
17579 ** The author disclaims copyright to this source code.  In place of
17580 ** a legal notice, here is a blessing:
17581 **
17582 **    May you do good and not evil.
17583 **    May you find forgiveness for yourself and forgive others.
17584 **    May you share freely, never taking more than you give.
17585 **
17586 *************************************************************************
17587 ** This file contains the C functions that implement a memory
17588 ** allocation subsystem for use by SQLite. 
17589 **
17590 ** This version of the memory allocation subsystem omits all
17591 ** use of malloc(). The SQLite user supplies a block of memory
17592 ** before calling sqlcipher3_initialize() from which allocations
17593 ** are made and returned by the xMalloc() and xRealloc() 
17594 ** implementations. Once sqlcipher3_initialize() has been called,
17595 ** the amount of memory available to SQLite is fixed and cannot
17596 ** be changed.
17597 **
17598 ** This version of the memory allocation subsystem is included
17599 ** in the build only if SQLCIPHER_ENABLE_MEMSYS3 is defined.
17600 */
17601
17602 /*
17603 ** This version of the memory allocator is only built into the library
17604 ** SQLCIPHER_ENABLE_MEMSYS3 is defined. Defining this symbol does not
17605 ** mean that the library will use a memory-pool by default, just that
17606 ** it is available. The mempool allocator is activated by calling
17607 ** sqlcipher3_config().
17608 */
17609 #ifdef SQLCIPHER_ENABLE_MEMSYS3
17610
17611 /*
17612 ** Maximum size (in Mem3Blocks) of a "small" chunk.
17613 */
17614 #define MX_SMALL 10
17615
17616
17617 /*
17618 ** Number of freelist hash slots
17619 */
17620 #define N_HASH  61
17621
17622 /*
17623 ** A memory allocation (also called a "chunk") consists of two or 
17624 ** more blocks where each block is 8 bytes.  The first 8 bytes are 
17625 ** a header that is not returned to the user.
17626 **
17627 ** A chunk is two or more blocks that is either checked out or
17628 ** free.  The first block has format u.hdr.  u.hdr.size4x is 4 times the
17629 ** size of the allocation in blocks if the allocation is free.
17630 ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
17631 ** false if the chunk is on the freelist.  The u.hdr.size4x&2 bit
17632 ** is true if the previous chunk is checked out and false if the
17633 ** previous chunk is free.  The u.hdr.prevSize field is the size of
17634 ** the previous chunk in blocks if the previous chunk is on the
17635 ** freelist. If the previous chunk is checked out, then
17636 ** u.hdr.prevSize can be part of the data for that chunk and should
17637 ** not be read or written.
17638 **
17639 ** We often identify a chunk by its index in mem3.aPool[].  When
17640 ** this is done, the chunk index refers to the second block of
17641 ** the chunk.  In this way, the first chunk has an index of 1.
17642 ** A chunk index of 0 means "no such chunk" and is the equivalent
17643 ** of a NULL pointer.
17644 **
17645 ** The second block of free chunks is of the form u.list.  The
17646 ** two fields form a double-linked list of chunks of related sizes.
17647 ** Pointers to the head of the list are stored in mem3.aiSmall[] 
17648 ** for smaller chunks and mem3.aiHash[] for larger chunks.
17649 **
17650 ** The second block of a chunk is user data if the chunk is checked 
17651 ** out.  If a chunk is checked out, the user data may extend into
17652 ** the u.hdr.prevSize value of the following chunk.
17653 */
17654 typedef struct Mem3Block Mem3Block;
17655 struct Mem3Block {
17656   union {
17657     struct {
17658       u32 prevSize;   /* Size of previous chunk in Mem3Block elements */
17659       u32 size4x;     /* 4x the size of current chunk in Mem3Block elements */
17660     } hdr;
17661     struct {
17662       u32 next;       /* Index in mem3.aPool[] of next free chunk */
17663       u32 prev;       /* Index in mem3.aPool[] of previous free chunk */
17664     } list;
17665   } u;
17666 };
17667
17668 /*
17669 ** All of the static variables used by this module are collected
17670 ** into a single structure named "mem3".  This is to keep the
17671 ** static variables organized and to reduce namespace pollution
17672 ** when this module is combined with other in the amalgamation.
17673 */
17674 static SQLCIPHER_WSD struct Mem3Global {
17675   /*
17676   ** Memory available for allocation. nPool is the size of the array
17677   ** (in Mem3Blocks) pointed to by aPool less 2.
17678   */
17679   u32 nPool;
17680   Mem3Block *aPool;
17681
17682   /*
17683   ** True if we are evaluating an out-of-memory callback.
17684   */
17685   int alarmBusy;
17686   
17687   /*
17688   ** Mutex to control access to the memory allocation subsystem.
17689   */
17690   sqlcipher3_mutex *mutex;
17691   
17692   /*
17693   ** The minimum amount of free space that we have seen.
17694   */
17695   u32 mnMaster;
17696
17697   /*
17698   ** iMaster is the index of the master chunk.  Most new allocations
17699   ** occur off of this chunk.  szMaster is the size (in Mem3Blocks)
17700   ** of the current master.  iMaster is 0 if there is not master chunk.
17701   ** The master chunk is not in either the aiHash[] or aiSmall[].
17702   */
17703   u32 iMaster;
17704   u32 szMaster;
17705
17706   /*
17707   ** Array of lists of free blocks according to the block size 
17708   ** for smaller chunks, or a hash on the block size for larger
17709   ** chunks.
17710   */
17711   u32 aiSmall[MX_SMALL-1];   /* For sizes 2 through MX_SMALL, inclusive */
17712   u32 aiHash[N_HASH];        /* For sizes MX_SMALL+1 and larger */
17713 } mem3 = { 97535575 };
17714
17715 #define mem3 GLOBAL(struct Mem3Global, mem3)
17716
17717 /*
17718 ** Unlink the chunk at mem3.aPool[i] from list it is currently
17719 ** on.  *pRoot is the list that i is a member of.
17720 */
17721 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
17722   u32 next = mem3.aPool[i].u.list.next;
17723   u32 prev = mem3.aPool[i].u.list.prev;
17724   assert( sqlcipher3_mutex_held(mem3.mutex) );
17725   if( prev==0 ){
17726     *pRoot = next;
17727   }else{
17728     mem3.aPool[prev].u.list.next = next;
17729   }
17730   if( next ){
17731     mem3.aPool[next].u.list.prev = prev;
17732   }
17733   mem3.aPool[i].u.list.next = 0;
17734   mem3.aPool[i].u.list.prev = 0;
17735 }
17736
17737 /*
17738 ** Unlink the chunk at index i from 
17739 ** whatever list is currently a member of.
17740 */
17741 static void memsys3Unlink(u32 i){
17742   u32 size, hash;
17743   assert( sqlcipher3_mutex_held(mem3.mutex) );
17744   assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
17745   assert( i>=1 );
17746   size = mem3.aPool[i-1].u.hdr.size4x/4;
17747   assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
17748   assert( size>=2 );
17749   if( size <= MX_SMALL ){
17750     memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]);
17751   }else{
17752     hash = size % N_HASH;
17753     memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
17754   }
17755 }
17756
17757 /*
17758 ** Link the chunk at mem3.aPool[i] so that is on the list rooted
17759 ** at *pRoot.
17760 */
17761 static void memsys3LinkIntoList(u32 i, u32 *pRoot){
17762   assert( sqlcipher3_mutex_held(mem3.mutex) );
17763   mem3.aPool[i].u.list.next = *pRoot;
17764   mem3.aPool[i].u.list.prev = 0;
17765   if( *pRoot ){
17766     mem3.aPool[*pRoot].u.list.prev = i;
17767   }
17768   *pRoot = i;
17769 }
17770
17771 /*
17772 ** Link the chunk at index i into either the appropriate
17773 ** small chunk list, or into the large chunk hash table.
17774 */
17775 static void memsys3Link(u32 i){
17776   u32 size, hash;
17777   assert( sqlcipher3_mutex_held(mem3.mutex) );
17778   assert( i>=1 );
17779   assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
17780   size = mem3.aPool[i-1].u.hdr.size4x/4;
17781   assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
17782   assert( size>=2 );
17783   if( size <= MX_SMALL ){
17784     memsys3LinkIntoList(i, &mem3.aiSmall[size-2]);
17785   }else{
17786     hash = size % N_HASH;
17787     memsys3LinkIntoList(i, &mem3.aiHash[hash]);
17788   }
17789 }
17790
17791 /*
17792 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
17793 ** will already be held (obtained by code in malloc.c) if
17794 ** sqlcipher3GlobalConfig.bMemStat is true.
17795 */
17796 static void memsys3Enter(void){
17797   if( sqlcipher3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){
17798     mem3.mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MEM);
17799   }
17800   sqlcipher3_mutex_enter(mem3.mutex);
17801 }
17802 static void memsys3Leave(void){
17803   sqlcipher3_mutex_leave(mem3.mutex);
17804 }
17805
17806 /*
17807 ** Called when we are unable to satisfy an allocation of nBytes.
17808 */
17809 static void memsys3OutOfMemory(int nByte){
17810   if( !mem3.alarmBusy ){
17811     mem3.alarmBusy = 1;
17812     assert( sqlcipher3_mutex_held(mem3.mutex) );
17813     sqlcipher3_mutex_leave(mem3.mutex);
17814     sqlcipher3_release_memory(nByte);
17815     sqlcipher3_mutex_enter(mem3.mutex);
17816     mem3.alarmBusy = 0;
17817   }
17818 }
17819
17820
17821 /*
17822 ** Chunk i is a free chunk that has been unlinked.  Adjust its 
17823 ** size parameters for check-out and return a pointer to the 
17824 ** user portion of the chunk.
17825 */
17826 static void *memsys3Checkout(u32 i, u32 nBlock){
17827   u32 x;
17828   assert( sqlcipher3_mutex_held(mem3.mutex) );
17829   assert( i>=1 );
17830   assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
17831   assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
17832   x = mem3.aPool[i-1].u.hdr.size4x;
17833   mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
17834   mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
17835   mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
17836   return &mem3.aPool[i];
17837 }
17838
17839 /*
17840 ** Carve a piece off of the end of the mem3.iMaster free chunk.
17841 ** Return a pointer to the new allocation.  Or, if the master chunk
17842 ** is not large enough, return 0.
17843 */
17844 static void *memsys3FromMaster(u32 nBlock){
17845   assert( sqlcipher3_mutex_held(mem3.mutex) );
17846   assert( mem3.szMaster>=nBlock );
17847   if( nBlock>=mem3.szMaster-1 ){
17848     /* Use the entire master */
17849     void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
17850     mem3.iMaster = 0;
17851     mem3.szMaster = 0;
17852     mem3.mnMaster = 0;
17853     return p;
17854   }else{
17855     /* Split the master block.  Return the tail. */
17856     u32 newi, x;
17857     newi = mem3.iMaster + mem3.szMaster - nBlock;
17858     assert( newi > mem3.iMaster+1 );
17859     mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
17860     mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
17861     mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
17862     mem3.szMaster -= nBlock;
17863     mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
17864     x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
17865     mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
17866     if( mem3.szMaster < mem3.mnMaster ){
17867       mem3.mnMaster = mem3.szMaster;
17868     }
17869     return (void*)&mem3.aPool[newi];
17870   }
17871 }
17872
17873 /*
17874 ** *pRoot is the head of a list of free chunks of the same size
17875 ** or same size hash.  In other words, *pRoot is an entry in either
17876 ** mem3.aiSmall[] or mem3.aiHash[].  
17877 **
17878 ** This routine examines all entries on the given list and tries
17879 ** to coalesce each entries with adjacent free chunks.  
17880 **
17881 ** If it sees a chunk that is larger than mem3.iMaster, it replaces 
17882 ** the current mem3.iMaster with the new larger chunk.  In order for
17883 ** this mem3.iMaster replacement to work, the master chunk must be
17884 ** linked into the hash tables.  That is not the normal state of
17885 ** affairs, of course.  The calling routine must link the master
17886 ** chunk before invoking this routine, then must unlink the (possibly
17887 ** changed) master chunk once this routine has finished.
17888 */
17889 static void memsys3Merge(u32 *pRoot){
17890   u32 iNext, prev, size, i, x;
17891
17892   assert( sqlcipher3_mutex_held(mem3.mutex) );
17893   for(i=*pRoot; i>0; i=iNext){
17894     iNext = mem3.aPool[i].u.list.next;
17895     size = mem3.aPool[i-1].u.hdr.size4x;
17896     assert( (size&1)==0 );
17897     if( (size&2)==0 ){
17898       memsys3UnlinkFromList(i, pRoot);
17899       assert( i > mem3.aPool[i-1].u.hdr.prevSize );
17900       prev = i - mem3.aPool[i-1].u.hdr.prevSize;
17901       if( prev==iNext ){
17902         iNext = mem3.aPool[prev].u.list.next;
17903       }
17904       memsys3Unlink(prev);
17905       size = i + size/4 - prev;
17906       x = mem3.aPool[prev-1].u.hdr.size4x & 2;
17907       mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
17908       mem3.aPool[prev+size-1].u.hdr.prevSize = size;
17909       memsys3Link(prev);
17910       i = prev;
17911     }else{
17912       size /= 4;
17913     }
17914     if( size>mem3.szMaster ){
17915       mem3.iMaster = i;
17916       mem3.szMaster = size;
17917     }
17918   }
17919 }
17920
17921 /*
17922 ** Return a block of memory of at least nBytes in size.
17923 ** Return NULL if unable.
17924 **
17925 ** This function assumes that the necessary mutexes, if any, are
17926 ** already held by the caller. Hence "Unsafe".
17927 */
17928 static void *memsys3MallocUnsafe(int nByte){
17929   u32 i;
17930   u32 nBlock;
17931   u32 toFree;
17932
17933   assert( sqlcipher3_mutex_held(mem3.mutex) );
17934   assert( sizeof(Mem3Block)==8 );
17935   if( nByte<=12 ){
17936     nBlock = 2;
17937   }else{
17938     nBlock = (nByte + 11)/8;
17939   }
17940   assert( nBlock>=2 );
17941
17942   /* STEP 1:
17943   ** Look for an entry of the correct size in either the small
17944   ** chunk table or in the large chunk hash table.  This is
17945   ** successful most of the time (about 9 times out of 10).
17946   */
17947   if( nBlock <= MX_SMALL ){
17948     i = mem3.aiSmall[nBlock-2];
17949     if( i>0 ){
17950       memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]);
17951       return memsys3Checkout(i, nBlock);
17952     }
17953   }else{
17954     int hash = nBlock % N_HASH;
17955     for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
17956       if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
17957         memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
17958         return memsys3Checkout(i, nBlock);
17959       }
17960     }
17961   }
17962
17963   /* STEP 2:
17964   ** Try to satisfy the allocation by carving a piece off of the end
17965   ** of the master chunk.  This step usually works if step 1 fails.
17966   */
17967   if( mem3.szMaster>=nBlock ){
17968     return memsys3FromMaster(nBlock);
17969   }
17970
17971
17972   /* STEP 3:  
17973   ** Loop through the entire memory pool.  Coalesce adjacent free
17974   ** chunks.  Recompute the master chunk as the largest free chunk.
17975   ** Then try again to satisfy the allocation by carving a piece off
17976   ** of the end of the master chunk.  This step happens very
17977   ** rarely (we hope!)
17978   */
17979   for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){
17980     memsys3OutOfMemory(toFree);
17981     if( mem3.iMaster ){
17982       memsys3Link(mem3.iMaster);
17983       mem3.iMaster = 0;
17984       mem3.szMaster = 0;
17985     }
17986     for(i=0; i<N_HASH; i++){
17987       memsys3Merge(&mem3.aiHash[i]);
17988     }
17989     for(i=0; i<MX_SMALL-1; i++){
17990       memsys3Merge(&mem3.aiSmall[i]);
17991     }
17992     if( mem3.szMaster ){
17993       memsys3Unlink(mem3.iMaster);
17994       if( mem3.szMaster>=nBlock ){
17995         return memsys3FromMaster(nBlock);
17996       }
17997     }
17998   }
17999
18000   /* If none of the above worked, then we fail. */
18001   return 0;
18002 }
18003
18004 /*
18005 ** Free an outstanding memory allocation.
18006 **
18007 ** This function assumes that the necessary mutexes, if any, are
18008 ** already held by the caller. Hence "Unsafe".
18009 */
18010 static void memsys3FreeUnsafe(void *pOld){
18011   Mem3Block *p = (Mem3Block*)pOld;
18012   int i;
18013   u32 size, x;
18014   assert( sqlcipher3_mutex_held(mem3.mutex) );
18015   assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] );
18016   i = p - mem3.aPool;
18017   assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
18018   size = mem3.aPool[i-1].u.hdr.size4x/4;
18019   assert( i+size<=mem3.nPool+1 );
18020   mem3.aPool[i-1].u.hdr.size4x &= ~1;
18021   mem3.aPool[i+size-1].u.hdr.prevSize = size;
18022   mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
18023   memsys3Link(i);
18024
18025   /* Try to expand the master using the newly freed chunk */
18026   if( mem3.iMaster ){
18027     while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
18028       size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
18029       mem3.iMaster -= size;
18030       mem3.szMaster += size;
18031       memsys3Unlink(mem3.iMaster);
18032       x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
18033       mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
18034       mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
18035     }
18036     x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
18037     while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
18038       memsys3Unlink(mem3.iMaster+mem3.szMaster);
18039       mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
18040       mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
18041       mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
18042     }
18043   }
18044 }
18045
18046 /*
18047 ** Return the size of an outstanding allocation, in bytes.  The
18048 ** size returned omits the 8-byte header overhead.  This only
18049 ** works for chunks that are currently checked out.
18050 */
18051 static int memsys3Size(void *p){
18052   Mem3Block *pBlock;
18053   if( p==0 ) return 0;
18054   pBlock = (Mem3Block*)p;
18055   assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
18056   return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
18057 }
18058
18059 /*
18060 ** Round up a request size to the next valid allocation size.
18061 */
18062 static int memsys3Roundup(int n){
18063   if( n<=12 ){
18064     return 12;
18065   }else{
18066     return ((n+11)&~7) - 4;
18067   }
18068 }
18069
18070 /*
18071 ** Allocate nBytes of memory.
18072 */
18073 static void *memsys3Malloc(int nBytes){
18074   sqlcipher3_int64 *p;
18075   assert( nBytes>0 );          /* malloc.c filters out 0 byte requests */
18076   memsys3Enter();
18077   p = memsys3MallocUnsafe(nBytes);
18078   memsys3Leave();
18079   return (void*)p; 
18080 }
18081
18082 /*
18083 ** Free memory.
18084 */
18085 static void memsys3Free(void *pPrior){
18086   assert( pPrior );
18087   memsys3Enter();
18088   memsys3FreeUnsafe(pPrior);
18089   memsys3Leave();
18090 }
18091
18092 /*
18093 ** Change the size of an existing memory allocation
18094 */
18095 static void *memsys3Realloc(void *pPrior, int nBytes){
18096   int nOld;
18097   void *p;
18098   if( pPrior==0 ){
18099     return sqlcipher3_malloc(nBytes);
18100   }
18101   if( nBytes<=0 ){
18102     sqlcipher3_free(pPrior);
18103     return 0;
18104   }
18105   nOld = memsys3Size(pPrior);
18106   if( nBytes<=nOld && nBytes>=nOld-128 ){
18107     return pPrior;
18108   }
18109   memsys3Enter();
18110   p = memsys3MallocUnsafe(nBytes);
18111   if( p ){
18112     if( nOld<nBytes ){
18113       memcpy(p, pPrior, nOld);
18114     }else{
18115       memcpy(p, pPrior, nBytes);
18116     }
18117     memsys3FreeUnsafe(pPrior);
18118   }
18119   memsys3Leave();
18120   return p;
18121 }
18122
18123 /*
18124 ** Initialize this module.
18125 */
18126 static int memsys3Init(void *NotUsed){
18127   UNUSED_PARAMETER(NotUsed);
18128   if( !sqlcipher3GlobalConfig.pHeap ){
18129     return SQLCIPHER_ERROR;
18130   }
18131
18132   /* Store a pointer to the memory block in global structure mem3. */
18133   assert( sizeof(Mem3Block)==8 );
18134   mem3.aPool = (Mem3Block *)sqlcipher3GlobalConfig.pHeap;
18135   mem3.nPool = (sqlcipher3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
18136
18137   /* Initialize the master block. */
18138   mem3.szMaster = mem3.nPool;
18139   mem3.mnMaster = mem3.szMaster;
18140   mem3.iMaster = 1;
18141   mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
18142   mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
18143   mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
18144
18145   return SQLCIPHER_OK;
18146 }
18147
18148 /*
18149 ** Deinitialize this module.
18150 */
18151 static void memsys3Shutdown(void *NotUsed){
18152   UNUSED_PARAMETER(NotUsed);
18153   mem3.mutex = 0;
18154   return;
18155 }
18156
18157
18158
18159 /*
18160 ** Open the file indicated and write a log of all unfreed memory 
18161 ** allocations into that log.
18162 */
18163 SQLCIPHER_PRIVATE void sqlcipher3Memsys3Dump(const char *zFilename){
18164 #ifdef SQLCIPHER_DEBUG
18165   FILE *out;
18166   u32 i, j;
18167   u32 size;
18168   if( zFilename==0 || zFilename[0]==0 ){
18169     out = stdout;
18170   }else{
18171     out = fopen(zFilename, "w");
18172     if( out==0 ){
18173       fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
18174                       zFilename);
18175       return;
18176     }
18177   }
18178   memsys3Enter();
18179   fprintf(out, "CHUNKS:\n");
18180   for(i=1; i<=mem3.nPool; i+=size/4){
18181     size = mem3.aPool[i-1].u.hdr.size4x;
18182     if( size/4<=1 ){
18183       fprintf(out, "%p size error\n", &mem3.aPool[i]);
18184       assert( 0 );
18185       break;
18186     }
18187     if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
18188       fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
18189       assert( 0 );
18190       break;
18191     }
18192     if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
18193       fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
18194       assert( 0 );
18195       break;
18196     }
18197     if( size&1 ){
18198       fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
18199     }else{
18200       fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
18201                   i==mem3.iMaster ? " **master**" : "");
18202     }
18203   }
18204   for(i=0; i<MX_SMALL-1; i++){
18205     if( mem3.aiSmall[i]==0 ) continue;
18206     fprintf(out, "small(%2d):", i);
18207     for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
18208       fprintf(out, " %p(%d)", &mem3.aPool[j],
18209               (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
18210     }
18211     fprintf(out, "\n"); 
18212   }
18213   for(i=0; i<N_HASH; i++){
18214     if( mem3.aiHash[i]==0 ) continue;
18215     fprintf(out, "hash(%2d):", i);
18216     for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
18217       fprintf(out, " %p(%d)", &mem3.aPool[j],
18218               (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
18219     }
18220     fprintf(out, "\n"); 
18221   }
18222   fprintf(out, "master=%d\n", mem3.iMaster);
18223   fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
18224   fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
18225   sqlcipher3_mutex_leave(mem3.mutex);
18226   if( out==stdout ){
18227     fflush(stdout);
18228   }else{
18229     fclose(out);
18230   }
18231 #else
18232   UNUSED_PARAMETER(zFilename);
18233 #endif
18234 }
18235
18236 /*
18237 ** This routine is the only routine in this file with external 
18238 ** linkage.
18239 **
18240 ** Populate the low-level memory allocation function pointers in
18241 ** sqlcipher3GlobalConfig.m with pointers to the routines in this file. The
18242 ** arguments specify the block of memory to manage.
18243 **
18244 ** This routine is only called by sqlcipher3_config(), and therefore
18245 ** is not required to be threadsafe (it is not).
18246 */
18247 SQLCIPHER_PRIVATE const sqlcipher3_mem_methods *sqlcipher3MemGetMemsys3(void){
18248   static const sqlcipher3_mem_methods mempoolMethods = {
18249      memsys3Malloc,
18250      memsys3Free,
18251      memsys3Realloc,
18252      memsys3Size,
18253      memsys3Roundup,
18254      memsys3Init,
18255      memsys3Shutdown,
18256      0
18257   };
18258   return &mempoolMethods;
18259 }
18260
18261 #endif /* SQLCIPHER_ENABLE_MEMSYS3 */
18262
18263 /************** End of mem3.c ************************************************/
18264 /************** Begin file mem5.c ********************************************/
18265 /*
18266 ** 2007 October 14
18267 **
18268 ** The author disclaims copyright to this source code.  In place of
18269 ** a legal notice, here is a blessing:
18270 **
18271 **    May you do good and not evil.
18272 **    May you find forgiveness for yourself and forgive others.
18273 **    May you share freely, never taking more than you give.
18274 **
18275 *************************************************************************
18276 ** This file contains the C functions that implement a memory
18277 ** allocation subsystem for use by SQLite. 
18278 **
18279 ** This version of the memory allocation subsystem omits all
18280 ** use of malloc(). The application gives SQLite a block of memory
18281 ** before calling sqlcipher3_initialize() from which allocations
18282 ** are made and returned by the xMalloc() and xRealloc() 
18283 ** implementations. Once sqlcipher3_initialize() has been called,
18284 ** the amount of memory available to SQLite is fixed and cannot
18285 ** be changed.
18286 **
18287 ** This version of the memory allocation subsystem is included
18288 ** in the build only if SQLCIPHER_ENABLE_MEMSYS5 is defined.
18289 **
18290 ** This memory allocator uses the following algorithm:
18291 **
18292 **   1.  All memory allocations sizes are rounded up to a power of 2.
18293 **
18294 **   2.  If two adjacent free blocks are the halves of a larger block,
18295 **       then the two blocks are coalesed into the single larger block.
18296 **
18297 **   3.  New memory is allocated from the first available free block.
18298 **
18299 ** This algorithm is described in: J. M. Robson. "Bounds for Some Functions
18300 ** Concerning Dynamic Storage Allocation". Journal of the Association for
18301 ** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499.
18302 ** 
18303 ** Let n be the size of the largest allocation divided by the minimum
18304 ** allocation size (after rounding all sizes up to a power of 2.)  Let M
18305 ** be the maximum amount of memory ever outstanding at one time.  Let
18306 ** N be the total amount of memory available for allocation.  Robson
18307 ** proved that this memory allocator will never breakdown due to 
18308 ** fragmentation as long as the following constraint holds:
18309 **
18310 **      N >=  M*(1 + log2(n)/2) - n + 1
18311 **
18312 ** The sqlcipher3_status() logic tracks the maximum values of n and M so
18313 ** that an application can, at any time, verify this constraint.
18314 */
18315
18316 /*
18317 ** This version of the memory allocator is used only when 
18318 ** SQLCIPHER_ENABLE_MEMSYS5 is defined.
18319 */
18320 #ifdef SQLCIPHER_ENABLE_MEMSYS5
18321
18322 /*
18323 ** A minimum allocation is an instance of the following structure.
18324 ** Larger allocations are an array of these structures where the
18325 ** size of the array is a power of 2.
18326 **
18327 ** The size of this object must be a power of two.  That fact is
18328 ** verified in memsys5Init().
18329 */
18330 typedef struct Mem5Link Mem5Link;
18331 struct Mem5Link {
18332   int next;       /* Index of next free chunk */
18333   int prev;       /* Index of previous free chunk */
18334 };
18335
18336 /*
18337 ** Maximum size of any allocation is ((1<<LOGMAX)*mem5.szAtom). Since
18338 ** mem5.szAtom is always at least 8 and 32-bit integers are used,
18339 ** it is not actually possible to reach this limit.
18340 */
18341 #define LOGMAX 30
18342
18343 /*
18344 ** Masks used for mem5.aCtrl[] elements.
18345 */
18346 #define CTRL_LOGSIZE  0x1f    /* Log2 Size of this block */
18347 #define CTRL_FREE     0x20    /* True if not checked out */
18348
18349 /*
18350 ** All of the static variables used by this module are collected
18351 ** into a single structure named "mem5".  This is to keep the
18352 ** static variables organized and to reduce namespace pollution
18353 ** when this module is combined with other in the amalgamation.
18354 */
18355 static SQLCIPHER_WSD struct Mem5Global {
18356   /*
18357   ** Memory available for allocation
18358   */
18359   int szAtom;      /* Smallest possible allocation in bytes */
18360   int nBlock;      /* Number of szAtom sized blocks in zPool */
18361   u8 *zPool;       /* Memory available to be allocated */
18362   
18363   /*
18364   ** Mutex to control access to the memory allocation subsystem.
18365   */
18366   sqlcipher3_mutex *mutex;
18367
18368   /*
18369   ** Performance statistics
18370   */
18371   u64 nAlloc;         /* Total number of calls to malloc */
18372   u64 totalAlloc;     /* Total of all malloc calls - includes internal frag */
18373   u64 totalExcess;    /* Total internal fragmentation */
18374   u32 currentOut;     /* Current checkout, including internal fragmentation */
18375   u32 currentCount;   /* Current number of distinct checkouts */
18376   u32 maxOut;         /* Maximum instantaneous currentOut */
18377   u32 maxCount;       /* Maximum instantaneous currentCount */
18378   u32 maxRequest;     /* Largest allocation (exclusive of internal frag) */
18379   
18380   /*
18381   ** Lists of free blocks.  aiFreelist[0] is a list of free blocks of
18382   ** size mem5.szAtom.  aiFreelist[1] holds blocks of size szAtom*2.
18383   ** and so forth.
18384   */
18385   int aiFreelist[LOGMAX+1];
18386
18387   /*
18388   ** Space for tracking which blocks are checked out and the size
18389   ** of each block.  One byte per block.
18390   */
18391   u8 *aCtrl;
18392
18393 } mem5;
18394
18395 /*
18396 ** Access the static variable through a macro for SQLCIPHER_OMIT_WSD
18397 */
18398 #define mem5 GLOBAL(struct Mem5Global, mem5)
18399
18400 /*
18401 ** Assuming mem5.zPool is divided up into an array of Mem5Link
18402 ** structures, return a pointer to the idx-th such lik.
18403 */
18404 #define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom]))
18405
18406 /*
18407 ** Unlink the chunk at mem5.aPool[i] from list it is currently
18408 ** on.  It should be found on mem5.aiFreelist[iLogsize].
18409 */
18410 static void memsys5Unlink(int i, int iLogsize){
18411   int next, prev;
18412   assert( i>=0 && i<mem5.nBlock );
18413   assert( iLogsize>=0 && iLogsize<=LOGMAX );
18414   assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
18415
18416   next = MEM5LINK(i)->next;
18417   prev = MEM5LINK(i)->prev;
18418   if( prev<0 ){
18419     mem5.aiFreelist[iLogsize] = next;
18420   }else{
18421     MEM5LINK(prev)->next = next;
18422   }
18423   if( next>=0 ){
18424     MEM5LINK(next)->prev = prev;
18425   }
18426 }
18427
18428 /*
18429 ** Link the chunk at mem5.aPool[i] so that is on the iLogsize
18430 ** free list.
18431 */
18432 static void memsys5Link(int i, int iLogsize){
18433   int x;
18434   assert( sqlcipher3_mutex_held(mem5.mutex) );
18435   assert( i>=0 && i<mem5.nBlock );
18436   assert( iLogsize>=0 && iLogsize<=LOGMAX );
18437   assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
18438
18439   x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
18440   MEM5LINK(i)->prev = -1;
18441   if( x>=0 ){
18442     assert( x<mem5.nBlock );
18443     MEM5LINK(x)->prev = i;
18444   }
18445   mem5.aiFreelist[iLogsize] = i;
18446 }
18447
18448 /*
18449 ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
18450 ** will already be held (obtained by code in malloc.c) if
18451 ** sqlcipher3GlobalConfig.bMemStat is true.
18452 */
18453 static void memsys5Enter(void){
18454   sqlcipher3_mutex_enter(mem5.mutex);
18455 }
18456 static void memsys5Leave(void){
18457   sqlcipher3_mutex_leave(mem5.mutex);
18458 }
18459
18460 /*
18461 ** Return the size of an outstanding allocation, in bytes.  The
18462 ** size returned omits the 8-byte header overhead.  This only
18463 ** works for chunks that are currently checked out.
18464 */
18465 static int memsys5Size(void *p){
18466   int iSize = 0;
18467   if( p ){
18468     int i = ((u8 *)p-mem5.zPool)/mem5.szAtom;
18469     assert( i>=0 && i<mem5.nBlock );
18470     iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
18471   }
18472   return iSize;
18473 }
18474
18475 /*
18476 ** Find the first entry on the freelist iLogsize.  Unlink that
18477 ** entry and return its index. 
18478 */
18479 static int memsys5UnlinkFirst(int iLogsize){
18480   int i;
18481   int iFirst;
18482
18483   assert( iLogsize>=0 && iLogsize<=LOGMAX );
18484   i = iFirst = mem5.aiFreelist[iLogsize];
18485   assert( iFirst>=0 );
18486   while( i>0 ){
18487     if( i<iFirst ) iFirst = i;
18488     i = MEM5LINK(i)->next;
18489   }
18490   memsys5Unlink(iFirst, iLogsize);
18491   return iFirst;
18492 }
18493
18494 /*
18495 ** Return a block of memory of at least nBytes in size.
18496 ** Return NULL if unable.  Return NULL if nBytes==0.
18497 **
18498 ** The caller guarantees that nByte positive.
18499 **
18500 ** The caller has obtained a mutex prior to invoking this
18501 ** routine so there is never any chance that two or more
18502 ** threads can be in this routine at the same time.
18503 */
18504 static void *memsys5MallocUnsafe(int nByte){
18505   int i;           /* Index of a mem5.aPool[] slot */
18506   int iBin;        /* Index into mem5.aiFreelist[] */
18507   int iFullSz;     /* Size of allocation rounded up to power of 2 */
18508   int iLogsize;    /* Log2 of iFullSz/POW2_MIN */
18509
18510   /* nByte must be a positive */
18511   assert( nByte>0 );
18512
18513   /* Keep track of the maximum allocation request.  Even unfulfilled
18514   ** requests are counted */
18515   if( (u32)nByte>mem5.maxRequest ){
18516     mem5.maxRequest = nByte;
18517   }
18518
18519   /* Abort if the requested allocation size is larger than the largest
18520   ** power of two that we can represent using 32-bit signed integers.
18521   */
18522   if( nByte > 0x40000000 ){
18523     return 0;
18524   }
18525
18526   /* Round nByte up to the next valid power of two */
18527   for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
18528
18529   /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
18530   ** block.  If not, then split a block of the next larger power of
18531   ** two in order to create a new free block of size iLogsize.
18532   */
18533   for(iBin=iLogsize; mem5.aiFreelist[iBin]<0 && iBin<=LOGMAX; iBin++){}
18534   if( iBin>LOGMAX ){
18535     testcase( sqlcipher3GlobalConfig.xLog!=0 );
18536     sqlcipher3_log(SQLCIPHER_NOMEM, "failed to allocate %u bytes", nByte);
18537     return 0;
18538   }
18539   i = memsys5UnlinkFirst(iBin);
18540   while( iBin>iLogsize ){
18541     int newSize;
18542
18543     iBin--;
18544     newSize = 1 << iBin;
18545     mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
18546     memsys5Link(i+newSize, iBin);
18547   }
18548   mem5.aCtrl[i] = iLogsize;
18549
18550   /* Update allocator performance statistics. */
18551   mem5.nAlloc++;
18552   mem5.totalAlloc += iFullSz;
18553   mem5.totalExcess += iFullSz - nByte;
18554   mem5.currentCount++;
18555   mem5.currentOut += iFullSz;
18556   if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
18557   if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
18558
18559   /* Return a pointer to the allocated memory. */
18560   return (void*)&mem5.zPool[i*mem5.szAtom];
18561 }
18562
18563 /*
18564 ** Free an outstanding memory allocation.
18565 */
18566 static void memsys5FreeUnsafe(void *pOld){
18567   u32 size, iLogsize;
18568   int iBlock;
18569
18570   /* Set iBlock to the index of the block pointed to by pOld in 
18571   ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
18572   */
18573   iBlock = ((u8 *)pOld-mem5.zPool)/mem5.szAtom;
18574
18575   /* Check that the pointer pOld points to a valid, non-free block. */
18576   assert( iBlock>=0 && iBlock<mem5.nBlock );
18577   assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
18578   assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
18579
18580   iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
18581   size = 1<<iLogsize;
18582   assert( iBlock+size-1<(u32)mem5.nBlock );
18583
18584   mem5.aCtrl[iBlock] |= CTRL_FREE;
18585   mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
18586   assert( mem5.currentCount>0 );
18587   assert( mem5.currentOut>=(size*mem5.szAtom) );
18588   mem5.currentCount--;
18589   mem5.currentOut -= size*mem5.szAtom;
18590   assert( mem5.currentOut>0 || mem5.currentCount==0 );
18591   assert( mem5.currentCount>0 || mem5.currentOut==0 );
18592
18593   mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
18594   while( ALWAYS(iLogsize<LOGMAX) ){
18595     int iBuddy;
18596     if( (iBlock>>iLogsize) & 1 ){
18597       iBuddy = iBlock - size;
18598     }else{
18599       iBuddy = iBlock + size;
18600     }
18601     assert( iBuddy>=0 );
18602     if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break;
18603     if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
18604     memsys5Unlink(iBuddy, iLogsize);
18605     iLogsize++;
18606     if( iBuddy<iBlock ){
18607       mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
18608       mem5.aCtrl[iBlock] = 0;
18609       iBlock = iBuddy;
18610     }else{
18611       mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
18612       mem5.aCtrl[iBuddy] = 0;
18613     }
18614     size *= 2;
18615   }
18616   memsys5Link(iBlock, iLogsize);
18617 }
18618
18619 /*
18620 ** Allocate nBytes of memory
18621 */
18622 static void *memsys5Malloc(int nBytes){
18623   sqlcipher3_int64 *p = 0;
18624   if( nBytes>0 ){
18625     memsys5Enter();
18626     p = memsys5MallocUnsafe(nBytes);
18627     memsys5Leave();
18628   }
18629   return (void*)p; 
18630 }
18631
18632 /*
18633 ** Free memory.
18634 **
18635 ** The outer layer memory allocator prevents this routine from
18636 ** being called with pPrior==0.
18637 */
18638 static void memsys5Free(void *pPrior){
18639   assert( pPrior!=0 );
18640   memsys5Enter();
18641   memsys5FreeUnsafe(pPrior);
18642   memsys5Leave();  
18643 }
18644
18645 /*
18646 ** Change the size of an existing memory allocation.
18647 **
18648 ** The outer layer memory allocator prevents this routine from
18649 ** being called with pPrior==0.  
18650 **
18651 ** nBytes is always a value obtained from a prior call to
18652 ** memsys5Round().  Hence nBytes is always a non-negative power
18653 ** of two.  If nBytes==0 that means that an oversize allocation
18654 ** (an allocation larger than 0x40000000) was requested and this
18655 ** routine should return 0 without freeing pPrior.
18656 */
18657 static void *memsys5Realloc(void *pPrior, int nBytes){
18658   int nOld;
18659   void *p;
18660   assert( pPrior!=0 );
18661   assert( (nBytes&(nBytes-1))==0 );  /* EV: R-46199-30249 */
18662   assert( nBytes>=0 );
18663   if( nBytes==0 ){
18664     return 0;
18665   }
18666   nOld = memsys5Size(pPrior);
18667   if( nBytes<=nOld ){
18668     return pPrior;
18669   }
18670   memsys5Enter();
18671   p = memsys5MallocUnsafe(nBytes);
18672   if( p ){
18673     memcpy(p, pPrior, nOld);
18674     memsys5FreeUnsafe(pPrior);
18675   }
18676   memsys5Leave();
18677   return p;
18678 }
18679
18680 /*
18681 ** Round up a request size to the next valid allocation size.  If
18682 ** the allocation is too large to be handled by this allocation system,
18683 ** return 0.
18684 **
18685 ** All allocations must be a power of two and must be expressed by a
18686 ** 32-bit signed integer.  Hence the largest allocation is 0x40000000
18687 ** or 1073741824 bytes.
18688 */
18689 static int memsys5Roundup(int n){
18690   int iFullSz;
18691   if( n > 0x40000000 ) return 0;
18692   for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2);
18693   return iFullSz;
18694 }
18695
18696 /*
18697 ** Return the ceiling of the logarithm base 2 of iValue.
18698 **
18699 ** Examples:   memsys5Log(1) -> 0
18700 **             memsys5Log(2) -> 1
18701 **             memsys5Log(4) -> 2
18702 **             memsys5Log(5) -> 3
18703 **             memsys5Log(8) -> 3
18704 **             memsys5Log(9) -> 4
18705 */
18706 static int memsys5Log(int iValue){
18707   int iLog;
18708   for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++);
18709   return iLog;
18710 }
18711
18712 /*
18713 ** Initialize the memory allocator.
18714 **
18715 ** This routine is not threadsafe.  The caller must be holding a mutex
18716 ** to prevent multiple threads from entering at the same time.
18717 */
18718 static int memsys5Init(void *NotUsed){
18719   int ii;            /* Loop counter */
18720   int nByte;         /* Number of bytes of memory available to this allocator */
18721   u8 *zByte;         /* Memory usable by this allocator */
18722   int nMinLog;       /* Log base 2 of minimum allocation size in bytes */
18723   int iOffset;       /* An offset into mem5.aCtrl[] */
18724
18725   UNUSED_PARAMETER(NotUsed);
18726
18727   /* For the purposes of this routine, disable the mutex */
18728   mem5.mutex = 0;
18729
18730   /* The size of a Mem5Link object must be a power of two.  Verify that
18731   ** this is case.
18732   */
18733   assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
18734
18735   nByte = sqlcipher3GlobalConfig.nHeap;
18736   zByte = (u8*)sqlcipher3GlobalConfig.pHeap;
18737   assert( zByte!=0 );  /* sqlcipher3_config() does not allow otherwise */
18738
18739   /* boundaries on sqlcipher3GlobalConfig.mnReq are enforced in sqlcipher3_config() */
18740   nMinLog = memsys5Log(sqlcipher3GlobalConfig.mnReq);
18741   mem5.szAtom = (1<<nMinLog);
18742   while( (int)sizeof(Mem5Link)>mem5.szAtom ){
18743     mem5.szAtom = mem5.szAtom << 1;
18744   }
18745
18746   mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
18747   mem5.zPool = zByte;
18748   mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
18749
18750   for(ii=0; ii<=LOGMAX; ii++){
18751     mem5.aiFreelist[ii] = -1;
18752   }
18753
18754   iOffset = 0;
18755   for(ii=LOGMAX; ii>=0; ii--){
18756     int nAlloc = (1<<ii);
18757     if( (iOffset+nAlloc)<=mem5.nBlock ){
18758       mem5.aCtrl[iOffset] = ii | CTRL_FREE;
18759       memsys5Link(iOffset, ii);
18760       iOffset += nAlloc;
18761     }
18762     assert((iOffset+nAlloc)>mem5.nBlock);
18763   }
18764
18765   /* If a mutex is required for normal operation, allocate one */
18766   if( sqlcipher3GlobalConfig.bMemstat==0 ){
18767     mem5.mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MEM);
18768   }
18769
18770   return SQLCIPHER_OK;
18771 }
18772
18773 /*
18774 ** Deinitialize this module.
18775 */
18776 static void memsys5Shutdown(void *NotUsed){
18777   UNUSED_PARAMETER(NotUsed);
18778   mem5.mutex = 0;
18779   return;
18780 }
18781
18782 #ifdef SQLCIPHER_TEST
18783 /*
18784 ** Open the file indicated and write a log of all unfreed memory 
18785 ** allocations into that log.
18786 */
18787 SQLCIPHER_PRIVATE void sqlcipher3Memsys5Dump(const char *zFilename){
18788   FILE *out;
18789   int i, j, n;
18790   int nMinLog;
18791
18792   if( zFilename==0 || zFilename[0]==0 ){
18793     out = stdout;
18794   }else{
18795     out = fopen(zFilename, "w");
18796     if( out==0 ){
18797       fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
18798                       zFilename);
18799       return;
18800     }
18801   }
18802   memsys5Enter();
18803   nMinLog = memsys5Log(mem5.szAtom);
18804   for(i=0; i<=LOGMAX && i+nMinLog<32; i++){
18805     for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
18806     fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
18807   }
18808   fprintf(out, "mem5.nAlloc       = %llu\n", mem5.nAlloc);
18809   fprintf(out, "mem5.totalAlloc   = %llu\n", mem5.totalAlloc);
18810   fprintf(out, "mem5.totalExcess  = %llu\n", mem5.totalExcess);
18811   fprintf(out, "mem5.currentOut   = %u\n", mem5.currentOut);
18812   fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
18813   fprintf(out, "mem5.maxOut       = %u\n", mem5.maxOut);
18814   fprintf(out, "mem5.maxCount     = %u\n", mem5.maxCount);
18815   fprintf(out, "mem5.maxRequest   = %u\n", mem5.maxRequest);
18816   memsys5Leave();
18817   if( out==stdout ){
18818     fflush(stdout);
18819   }else{
18820     fclose(out);
18821   }
18822 }
18823 #endif
18824
18825 /*
18826 ** This routine is the only routine in this file with external 
18827 ** linkage. It returns a pointer to a static sqlcipher3_mem_methods
18828 ** struct populated with the memsys5 methods.
18829 */
18830 SQLCIPHER_PRIVATE const sqlcipher3_mem_methods *sqlcipher3MemGetMemsys5(void){
18831   static const sqlcipher3_mem_methods memsys5Methods = {
18832      memsys5Malloc,
18833      memsys5Free,
18834      memsys5Realloc,
18835      memsys5Size,
18836      memsys5Roundup,
18837      memsys5Init,
18838      memsys5Shutdown,
18839      0
18840   };
18841   return &memsys5Methods;
18842 }
18843
18844 #endif /* SQLCIPHER_ENABLE_MEMSYS5 */
18845
18846 /************** End of mem5.c ************************************************/
18847 /************** Begin file mutex.c *******************************************/
18848 /*
18849 ** 2007 August 14
18850 **
18851 ** The author disclaims copyright to this source code.  In place of
18852 ** a legal notice, here is a blessing:
18853 **
18854 **    May you do good and not evil.
18855 **    May you find forgiveness for yourself and forgive others.
18856 **    May you share freely, never taking more than you give.
18857 **
18858 *************************************************************************
18859 ** This file contains the C functions that implement mutexes.
18860 **
18861 ** This file contains code that is common across all mutex implementations.
18862 */
18863
18864 #if defined(SQLCIPHER_DEBUG) && !defined(SQLCIPHER_MUTEX_OMIT)
18865 /*
18866 ** For debugging purposes, record when the mutex subsystem is initialized
18867 ** and uninitialized so that we can assert() if there is an attempt to
18868 ** allocate a mutex while the system is uninitialized.
18869 */
18870 static SQLCIPHER_WSD int mutexIsInit = 0;
18871 #endif /* SQLCIPHER_DEBUG */
18872
18873
18874 #ifndef SQLCIPHER_MUTEX_OMIT
18875 /*
18876 ** Initialize the mutex system.
18877 */
18878 SQLCIPHER_PRIVATE int sqlcipher3MutexInit(void){ 
18879   int rc = SQLCIPHER_OK;
18880   if( !sqlcipher3GlobalConfig.mutex.xMutexAlloc ){
18881     /* If the xMutexAlloc method has not been set, then the user did not
18882     ** install a mutex implementation via sqlcipher3_config() prior to 
18883     ** sqlcipher3_initialize() being called. This block copies pointers to
18884     ** the default implementation into the sqlcipher3GlobalConfig structure.
18885     */
18886     sqlcipher3_mutex_methods const *pFrom;
18887     sqlcipher3_mutex_methods *pTo = &sqlcipher3GlobalConfig.mutex;
18888
18889     if( sqlcipher3GlobalConfig.bCoreMutex ){
18890       pFrom = sqlcipher3DefaultMutex();
18891     }else{
18892       pFrom = sqlcipher3NoopMutex();
18893     }
18894     memcpy(pTo, pFrom, offsetof(sqlcipher3_mutex_methods, xMutexAlloc));
18895     memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
18896            sizeof(*pTo) - offsetof(sqlcipher3_mutex_methods, xMutexFree));
18897     pTo->xMutexAlloc = pFrom->xMutexAlloc;
18898   }
18899   rc = sqlcipher3GlobalConfig.mutex.xMutexInit();
18900
18901 #ifdef SQLCIPHER_DEBUG
18902   GLOBAL(int, mutexIsInit) = 1;
18903 #endif
18904
18905   return rc;
18906 }
18907
18908 /*
18909 ** Shutdown the mutex system. This call frees resources allocated by
18910 ** sqlcipher3MutexInit().
18911 */
18912 SQLCIPHER_PRIVATE int sqlcipher3MutexEnd(void){
18913   int rc = SQLCIPHER_OK;
18914   if( sqlcipher3GlobalConfig.mutex.xMutexEnd ){
18915     rc = sqlcipher3GlobalConfig.mutex.xMutexEnd();
18916   }
18917
18918 #ifdef SQLCIPHER_DEBUG
18919   GLOBAL(int, mutexIsInit) = 0;
18920 #endif
18921
18922   return rc;
18923 }
18924
18925 /*
18926 ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
18927 */
18928 SQLCIPHER_API sqlcipher3_mutex *sqlcipher3_mutex_alloc(int id){
18929 #ifndef SQLCIPHER_OMIT_AUTOINIT
18930   if( sqlcipher3_initialize() ) return 0;
18931 #endif
18932   return sqlcipher3GlobalConfig.mutex.xMutexAlloc(id);
18933 }
18934
18935 SQLCIPHER_PRIVATE sqlcipher3_mutex *sqlcipher3MutexAlloc(int id){
18936   if( !sqlcipher3GlobalConfig.bCoreMutex ){
18937     return 0;
18938   }
18939   assert( GLOBAL(int, mutexIsInit) );
18940   return sqlcipher3GlobalConfig.mutex.xMutexAlloc(id);
18941 }
18942
18943 /*
18944 ** Free a dynamic mutex.
18945 */
18946 SQLCIPHER_API void sqlcipher3_mutex_free(sqlcipher3_mutex *p){
18947   if( p ){
18948     sqlcipher3GlobalConfig.mutex.xMutexFree(p);
18949   }
18950 }
18951
18952 /*
18953 ** Obtain the mutex p. If some other thread already has the mutex, block
18954 ** until it can be obtained.
18955 */
18956 SQLCIPHER_API void sqlcipher3_mutex_enter(sqlcipher3_mutex *p){
18957   if( p ){
18958     sqlcipher3GlobalConfig.mutex.xMutexEnter(p);
18959   }
18960 }
18961
18962 /*
18963 ** Obtain the mutex p. If successful, return SQLCIPHER_OK. Otherwise, if another
18964 ** thread holds the mutex and it cannot be obtained, return SQLCIPHER_BUSY.
18965 */
18966 SQLCIPHER_API int sqlcipher3_mutex_try(sqlcipher3_mutex *p){
18967   int rc = SQLCIPHER_OK;
18968   if( p ){
18969     return sqlcipher3GlobalConfig.mutex.xMutexTry(p);
18970   }
18971   return rc;
18972 }
18973
18974 /*
18975 ** The sqlcipher3_mutex_leave() routine exits a mutex that was previously
18976 ** entered by the same thread.  The behavior is undefined if the mutex 
18977 ** is not currently entered. If a NULL pointer is passed as an argument
18978 ** this function is a no-op.
18979 */
18980 SQLCIPHER_API void sqlcipher3_mutex_leave(sqlcipher3_mutex *p){
18981   if( p ){
18982     sqlcipher3GlobalConfig.mutex.xMutexLeave(p);
18983   }
18984 }
18985
18986 #ifndef NDEBUG
18987 /*
18988 ** The sqlcipher3_mutex_held() and sqlcipher3_mutex_notheld() routine are
18989 ** intended for use inside assert() statements.
18990 */
18991 SQLCIPHER_API int sqlcipher3_mutex_held(sqlcipher3_mutex *p){
18992   return p==0 || sqlcipher3GlobalConfig.mutex.xMutexHeld(p);
18993 }
18994 SQLCIPHER_API int sqlcipher3_mutex_notheld(sqlcipher3_mutex *p){
18995   return p==0 || sqlcipher3GlobalConfig.mutex.xMutexNotheld(p);
18996 }
18997 #endif
18998
18999 #endif /* SQLCIPHER_MUTEX_OMIT */
19000
19001 /************** End of mutex.c ***********************************************/
19002 /************** Begin file mutex_noop.c **************************************/
19003 /*
19004 ** 2008 October 07
19005 **
19006 ** The author disclaims copyright to this source code.  In place of
19007 ** a legal notice, here is a blessing:
19008 **
19009 **    May you do good and not evil.
19010 **    May you find forgiveness for yourself and forgive others.
19011 **    May you share freely, never taking more than you give.
19012 **
19013 *************************************************************************
19014 ** This file contains the C functions that implement mutexes.
19015 **
19016 ** This implementation in this file does not provide any mutual
19017 ** exclusion and is thus suitable for use only in applications
19018 ** that use SQLite in a single thread.  The routines defined
19019 ** here are place-holders.  Applications can substitute working
19020 ** mutex routines at start-time using the
19021 **
19022 **     sqlcipher3_config(SQLCIPHER_CONFIG_MUTEX,...)
19023 **
19024 ** interface.
19025 **
19026 ** If compiled with SQLCIPHER_DEBUG, then additional logic is inserted
19027 ** that does error checking on mutexes to make sure they are being
19028 ** called correctly.
19029 */
19030
19031 #ifndef SQLCIPHER_MUTEX_OMIT
19032
19033 #ifndef SQLCIPHER_DEBUG
19034 /*
19035 ** Stub routines for all mutex methods.
19036 **
19037 ** This routines provide no mutual exclusion or error checking.
19038 */
19039 static int noopMutexInit(void){ return SQLCIPHER_OK; }
19040 static int noopMutexEnd(void){ return SQLCIPHER_OK; }
19041 static sqlcipher3_mutex *noopMutexAlloc(int id){ 
19042   UNUSED_PARAMETER(id);
19043   return (sqlcipher3_mutex*)8; 
19044 }
19045 static void noopMutexFree(sqlcipher3_mutex *p){ UNUSED_PARAMETER(p); return; }
19046 static void noopMutexEnter(sqlcipher3_mutex *p){ UNUSED_PARAMETER(p); return; }
19047 static int noopMutexTry(sqlcipher3_mutex *p){
19048   UNUSED_PARAMETER(p);
19049   return SQLCIPHER_OK;
19050 }
19051 static void noopMutexLeave(sqlcipher3_mutex *p){ UNUSED_PARAMETER(p); return; }
19052
19053 SQLCIPHER_PRIVATE sqlcipher3_mutex_methods const *sqlcipher3NoopMutex(void){
19054   static const sqlcipher3_mutex_methods sMutex = {
19055     noopMutexInit,
19056     noopMutexEnd,
19057     noopMutexAlloc,
19058     noopMutexFree,
19059     noopMutexEnter,
19060     noopMutexTry,
19061     noopMutexLeave,
19062
19063     0,
19064     0,
19065   };
19066
19067   return &sMutex;
19068 }
19069 #endif /* !SQLCIPHER_DEBUG */
19070
19071 #ifdef SQLCIPHER_DEBUG
19072 /*
19073 ** In this implementation, error checking is provided for testing
19074 ** and debugging purposes.  The mutexes still do not provide any
19075 ** mutual exclusion.
19076 */
19077
19078 /*
19079 ** The mutex object
19080 */
19081 typedef struct sqlcipher3_debug_mutex {
19082   int id;     /* The mutex type */
19083   int cnt;    /* Number of entries without a matching leave */
19084 } sqlcipher3_debug_mutex;
19085
19086 /*
19087 ** The sqlcipher3_mutex_held() and sqlcipher3_mutex_notheld() routine are
19088 ** intended for use inside assert() statements.
19089 */
19090 static int debugMutexHeld(sqlcipher3_mutex *pX){
19091   sqlcipher3_debug_mutex *p = (sqlcipher3_debug_mutex*)pX;
19092   return p==0 || p->cnt>0;
19093 }
19094 static int debugMutexNotheld(sqlcipher3_mutex *pX){
19095   sqlcipher3_debug_mutex *p = (sqlcipher3_debug_mutex*)pX;
19096   return p==0 || p->cnt==0;
19097 }
19098
19099 /*
19100 ** Initialize and deinitialize the mutex subsystem.
19101 */
19102 static int debugMutexInit(void){ return SQLCIPHER_OK; }
19103 static int debugMutexEnd(void){ return SQLCIPHER_OK; }
19104
19105 /*
19106 ** The sqlcipher3_mutex_alloc() routine allocates a new
19107 ** mutex and returns a pointer to it.  If it returns NULL
19108 ** that means that a mutex could not be allocated. 
19109 */
19110 static sqlcipher3_mutex *debugMutexAlloc(int id){
19111   static sqlcipher3_debug_mutex aStatic[6];
19112   sqlcipher3_debug_mutex *pNew = 0;
19113   switch( id ){
19114     case SQLCIPHER_MUTEX_FAST:
19115     case SQLCIPHER_MUTEX_RECURSIVE: {
19116       pNew = sqlcipher3Malloc(sizeof(*pNew));
19117       if( pNew ){
19118         pNew->id = id;
19119         pNew->cnt = 0;
19120       }
19121       break;
19122     }
19123     default: {
19124       assert( id-2 >= 0 );
19125       assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
19126       pNew = &aStatic[id-2];
19127       pNew->id = id;
19128       break;
19129     }
19130   }
19131   return (sqlcipher3_mutex*)pNew;
19132 }
19133
19134 /*
19135 ** This routine deallocates a previously allocated mutex.
19136 */
19137 static void debugMutexFree(sqlcipher3_mutex *pX){
19138   sqlcipher3_debug_mutex *p = (sqlcipher3_debug_mutex*)pX;
19139   assert( p->cnt==0 );
19140   assert( p->id==SQLCIPHER_MUTEX_FAST || p->id==SQLCIPHER_MUTEX_RECURSIVE );
19141   sqlcipher3_free(p);
19142 }
19143
19144 /*
19145 ** The sqlcipher3_mutex_enter() and sqlcipher3_mutex_try() routines attempt
19146 ** to enter a mutex.  If another thread is already within the mutex,
19147 ** sqlcipher3_mutex_enter() will block and sqlcipher3_mutex_try() will return
19148 ** SQLCIPHER_BUSY.  The sqlcipher3_mutex_try() interface returns SQLCIPHER_OK
19149 ** upon successful entry.  Mutexes created using SQLCIPHER_MUTEX_RECURSIVE can
19150 ** be entered multiple times by the same thread.  In such cases the,
19151 ** mutex must be exited an equal number of times before another thread
19152 ** can enter.  If the same thread tries to enter any other kind of mutex
19153 ** more than once, the behavior is undefined.
19154 */
19155 static void debugMutexEnter(sqlcipher3_mutex *pX){
19156   sqlcipher3_debug_mutex *p = (sqlcipher3_debug_mutex*)pX;
19157   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
19158   p->cnt++;
19159 }
19160 static int debugMutexTry(sqlcipher3_mutex *pX){
19161   sqlcipher3_debug_mutex *p = (sqlcipher3_debug_mutex*)pX;
19162   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
19163   p->cnt++;
19164   return SQLCIPHER_OK;
19165 }
19166
19167 /*
19168 ** The sqlcipher3_mutex_leave() routine exits a mutex that was
19169 ** previously entered by the same thread.  The behavior
19170 ** is undefined if the mutex is not currently entered or
19171 ** is not currently allocated.  SQLite will never do either.
19172 */
19173 static void debugMutexLeave(sqlcipher3_mutex *pX){
19174   sqlcipher3_debug_mutex *p = (sqlcipher3_debug_mutex*)pX;
19175   assert( debugMutexHeld(pX) );
19176   p->cnt--;
19177   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
19178 }
19179
19180 SQLCIPHER_PRIVATE sqlcipher3_mutex_methods const *sqlcipher3NoopMutex(void){
19181   static const sqlcipher3_mutex_methods sMutex = {
19182     debugMutexInit,
19183     debugMutexEnd,
19184     debugMutexAlloc,
19185     debugMutexFree,
19186     debugMutexEnter,
19187     debugMutexTry,
19188     debugMutexLeave,
19189
19190     debugMutexHeld,
19191     debugMutexNotheld
19192   };
19193
19194   return &sMutex;
19195 }
19196 #endif /* SQLCIPHER_DEBUG */
19197
19198 /*
19199 ** If compiled with SQLCIPHER_MUTEX_NOOP, then the no-op mutex implementation
19200 ** is used regardless of the run-time threadsafety setting.
19201 */
19202 #ifdef SQLCIPHER_MUTEX_NOOP
19203 SQLCIPHER_PRIVATE sqlcipher3_mutex_methods const *sqlcipher3DefaultMutex(void){
19204   return sqlcipher3NoopMutex();
19205 }
19206 #endif /* SQLCIPHER_MUTEX_NOOP */
19207 #endif /* SQLCIPHER_MUTEX_OMIT */
19208
19209 /************** End of mutex_noop.c ******************************************/
19210 /************** Begin file mutex_os2.c ***************************************/
19211 /*
19212 ** 2007 August 28
19213 **
19214 ** The author disclaims copyright to this source code.  In place of
19215 ** a legal notice, here is a blessing:
19216 **
19217 **    May you do good and not evil.
19218 **    May you find forgiveness for yourself and forgive others.
19219 **    May you share freely, never taking more than you give.
19220 **
19221 *************************************************************************
19222 ** This file contains the C functions that implement mutexes for OS/2
19223 */
19224
19225 /*
19226 ** The code in this file is only used if SQLCIPHER_MUTEX_OS2 is defined.
19227 ** See the mutex.h file for details.
19228 */
19229 #ifdef SQLCIPHER_MUTEX_OS2
19230
19231 /********************** OS/2 Mutex Implementation **********************
19232 **
19233 ** This implementation of mutexes is built using the OS/2 API.
19234 */
19235
19236 /*
19237 ** The mutex object
19238 ** Each recursive mutex is an instance of the following structure.
19239 */
19240 struct sqlcipher3_mutex {
19241   HMTX mutex;       /* Mutex controlling the lock */
19242   int  id;          /* Mutex type */
19243 #ifdef SQLCIPHER_DEBUG
19244  int   trace;       /* True to trace changes */
19245 #endif
19246 };
19247
19248 #ifdef SQLCIPHER_DEBUG
19249 #define SQLCIPHER3_MUTEX_INITIALIZER { 0, 0, 0 }
19250 #else
19251 #define SQLCIPHER3_MUTEX_INITIALIZER { 0, 0 }
19252 #endif
19253
19254 /*
19255 ** Initialize and deinitialize the mutex subsystem.
19256 */
19257 static int os2MutexInit(void){ return SQLCIPHER_OK; }
19258 static int os2MutexEnd(void){ return SQLCIPHER_OK; }
19259
19260 /*
19261 ** The sqlcipher3_mutex_alloc() routine allocates a new
19262 ** mutex and returns a pointer to it.  If it returns NULL
19263 ** that means that a mutex could not be allocated. 
19264 ** SQLite will unwind its stack and return an error.  The argument
19265 ** to sqlcipher3_mutex_alloc() is one of these integer constants:
19266 **
19267 ** <ul>
19268 ** <li>  SQLCIPHER_MUTEX_FAST
19269 ** <li>  SQLCIPHER_MUTEX_RECURSIVE
19270 ** <li>  SQLCIPHER_MUTEX_STATIC_MASTER
19271 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM
19272 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM2
19273 ** <li>  SQLCIPHER_MUTEX_STATIC_PRNG
19274 ** <li>  SQLCIPHER_MUTEX_STATIC_LRU
19275 ** <li>  SQLCIPHER_MUTEX_STATIC_LRU2
19276 ** </ul>
19277 **
19278 ** The first two constants cause sqlcipher3_mutex_alloc() to create
19279 ** a new mutex.  The new mutex is recursive when SQLCIPHER_MUTEX_RECURSIVE
19280 ** is used but not necessarily so when SQLCIPHER_MUTEX_FAST is used.
19281 ** The mutex implementation does not need to make a distinction
19282 ** between SQLCIPHER_MUTEX_RECURSIVE and SQLCIPHER_MUTEX_FAST if it does
19283 ** not want to.  But SQLite will only request a recursive mutex in
19284 ** cases where it really needs one.  If a faster non-recursive mutex
19285 ** implementation is available on the host platform, the mutex subsystem
19286 ** might return such a mutex in response to SQLCIPHER_MUTEX_FAST.
19287 **
19288 ** The other allowed parameters to sqlcipher3_mutex_alloc() each return
19289 ** a pointer to a static preexisting mutex.  Six static mutexes are
19290 ** used by the current version of SQLite.  Future versions of SQLite
19291 ** may add additional static mutexes.  Static mutexes are for internal
19292 ** use by SQLite only.  Applications that use SQLite mutexes should
19293 ** use only the dynamic mutexes returned by SQLCIPHER_MUTEX_FAST or
19294 ** SQLCIPHER_MUTEX_RECURSIVE.
19295 **
19296 ** Note that if one of the dynamic mutex parameters (SQLCIPHER_MUTEX_FAST
19297 ** or SQLCIPHER_MUTEX_RECURSIVE) is used then sqlcipher3_mutex_alloc()
19298 ** returns a different mutex on every call.  But for the static
19299 ** mutex types, the same mutex is returned on every call that has
19300 ** the same type number.
19301 */
19302 static sqlcipher3_mutex *os2MutexAlloc(int iType){
19303   sqlcipher3_mutex *p = NULL;
19304   switch( iType ){
19305     case SQLCIPHER_MUTEX_FAST:
19306     case SQLCIPHER_MUTEX_RECURSIVE: {
19307       p = sqlcipher3MallocZero( sizeof(*p) );
19308       if( p ){
19309         p->id = iType;
19310         if( DosCreateMutexSem( 0, &p->mutex, 0, FALSE ) != NO_ERROR ){
19311           sqlcipher3_free( p );
19312           p = NULL;
19313         }
19314       }
19315       break;
19316     }
19317     default: {
19318       static volatile int isInit = 0;
19319       static sqlcipher3_mutex staticMutexes[6] = {
19320         SQLCIPHER3_MUTEX_INITIALIZER,
19321         SQLCIPHER3_MUTEX_INITIALIZER,
19322         SQLCIPHER3_MUTEX_INITIALIZER,
19323         SQLCIPHER3_MUTEX_INITIALIZER,
19324         SQLCIPHER3_MUTEX_INITIALIZER,
19325         SQLCIPHER3_MUTEX_INITIALIZER,
19326       };
19327       if ( !isInit ){
19328         APIRET rc;
19329         PTIB ptib;
19330         PPIB ppib;
19331         HMTX mutex;
19332         char name[32];
19333         DosGetInfoBlocks( &ptib, &ppib );
19334         sqlcipher3_snprintf( sizeof(name), name, "\\SEM32\\SQLCIPHER%04x",
19335                           ppib->pib_ulpid );
19336         while( !isInit ){
19337           mutex = 0;
19338           rc = DosCreateMutexSem( name, &mutex, 0, FALSE);
19339           if( rc == NO_ERROR ){
19340             unsigned int i;
19341             if( !isInit ){
19342               for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){
19343                 DosCreateMutexSem( 0, &staticMutexes[i].mutex, 0, FALSE );
19344               }
19345               isInit = 1;
19346             }
19347             DosCloseMutexSem( mutex );
19348           }else if( rc == ERROR_DUPLICATE_NAME ){
19349             DosSleep( 1 );
19350           }else{
19351             return p;
19352           }
19353         }
19354       }
19355       assert( iType-2 >= 0 );
19356       assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
19357       p = &staticMutexes[iType-2];
19358       p->id = iType;
19359       break;
19360     }
19361   }
19362   return p;
19363 }
19364
19365
19366 /*
19367 ** This routine deallocates a previously allocated mutex.
19368 ** SQLite is careful to deallocate every mutex that it allocates.
19369 */
19370 static void os2MutexFree(sqlcipher3_mutex *p){
19371 #ifdef SQLCIPHER_DEBUG
19372   TID tid;
19373   PID pid;
19374   ULONG ulCount;
19375   DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
19376   assert( ulCount==0 );
19377   assert( p->id==SQLCIPHER_MUTEX_FAST || p->id==SQLCIPHER_MUTEX_RECURSIVE );
19378 #endif
19379   DosCloseMutexSem( p->mutex );
19380   sqlcipher3_free( p );
19381 }
19382
19383 #ifdef SQLCIPHER_DEBUG
19384 /*
19385 ** The sqlcipher3_mutex_held() and sqlcipher3_mutex_notheld() routine are
19386 ** intended for use inside assert() statements.
19387 */
19388 static int os2MutexHeld(sqlcipher3_mutex *p){
19389   TID tid;
19390   PID pid;
19391   ULONG ulCount;
19392   PTIB ptib;
19393   DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
19394   if( ulCount==0 || ( ulCount>1 && p->id!=SQLCIPHER_MUTEX_RECURSIVE ) )
19395     return 0;
19396   DosGetInfoBlocks(&ptib, NULL);
19397   return tid==ptib->tib_ptib2->tib2_ultid;
19398 }
19399 static int os2MutexNotheld(sqlcipher3_mutex *p){
19400   TID tid;
19401   PID pid;
19402   ULONG ulCount;
19403   PTIB ptib;
19404   DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
19405   if( ulCount==0 )
19406     return 1;
19407   DosGetInfoBlocks(&ptib, NULL);
19408   return tid!=ptib->tib_ptib2->tib2_ultid;
19409 }
19410 static void os2MutexTrace(sqlcipher3_mutex *p, char *pAction){
19411   TID   tid;
19412   PID   pid;
19413   ULONG ulCount;
19414   DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
19415   printf("%s mutex %p (%d) with nRef=%ld\n", pAction, (void*)p, p->trace, ulCount);
19416 }
19417 #endif
19418
19419 /*
19420 ** The sqlcipher3_mutex_enter() and sqlcipher3_mutex_try() routines attempt
19421 ** to enter a mutex.  If another thread is already within the mutex,
19422 ** sqlcipher3_mutex_enter() will block and sqlcipher3_mutex_try() will return
19423 ** SQLCIPHER_BUSY.  The sqlcipher3_mutex_try() interface returns SQLCIPHER_OK
19424 ** upon successful entry.  Mutexes created using SQLCIPHER_MUTEX_RECURSIVE can
19425 ** be entered multiple times by the same thread.  In such cases the,
19426 ** mutex must be exited an equal number of times before another thread
19427 ** can enter.  If the same thread tries to enter any other kind of mutex
19428 ** more than once, the behavior is undefined.
19429 */
19430 static void os2MutexEnter(sqlcipher3_mutex *p){
19431   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || os2MutexNotheld(p) );
19432   DosRequestMutexSem(p->mutex, SEM_INDEFINITE_WAIT);
19433 #ifdef SQLCIPHER_DEBUG
19434   if( p->trace ) os2MutexTrace(p, "enter");
19435 #endif
19436 }
19437 static int os2MutexTry(sqlcipher3_mutex *p){
19438   int rc = SQLCIPHER_BUSY;
19439   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || os2MutexNotheld(p) );
19440   if( DosRequestMutexSem(p->mutex, SEM_IMMEDIATE_RETURN) == NO_ERROR ) {
19441     rc = SQLCIPHER_OK;
19442 #ifdef SQLCIPHER_DEBUG
19443     if( p->trace ) os2MutexTrace(p, "try");
19444 #endif
19445   }
19446   return rc;
19447 }
19448
19449 /*
19450 ** The sqlcipher3_mutex_leave() routine exits a mutex that was
19451 ** previously entered by the same thread.  The behavior
19452 ** is undefined if the mutex is not currently entered or
19453 ** is not currently allocated.  SQLite will never do either.
19454 */
19455 static void os2MutexLeave(sqlcipher3_mutex *p){
19456   assert( os2MutexHeld(p) );
19457   DosReleaseMutexSem(p->mutex);
19458 #ifdef SQLCIPHER_DEBUG
19459   if( p->trace ) os2MutexTrace(p, "leave");
19460 #endif
19461 }
19462
19463 SQLCIPHER_PRIVATE sqlcipher3_mutex_methods const *sqlcipher3DefaultMutex(void){
19464   static const sqlcipher3_mutex_methods sMutex = {
19465     os2MutexInit,
19466     os2MutexEnd,
19467     os2MutexAlloc,
19468     os2MutexFree,
19469     os2MutexEnter,
19470     os2MutexTry,
19471     os2MutexLeave,
19472 #ifdef SQLCIPHER_DEBUG
19473     os2MutexHeld,
19474     os2MutexNotheld
19475 #else
19476     0,
19477     0
19478 #endif
19479   };
19480
19481   return &sMutex;
19482 }
19483 #endif /* SQLCIPHER_MUTEX_OS2 */
19484
19485 /************** End of mutex_os2.c *******************************************/
19486 /************** Begin file mutex_unix.c **************************************/
19487 /*
19488 ** 2007 August 28
19489 **
19490 ** The author disclaims copyright to this source code.  In place of
19491 ** a legal notice, here is a blessing:
19492 **
19493 **    May you do good and not evil.
19494 **    May you find forgiveness for yourself and forgive others.
19495 **    May you share freely, never taking more than you give.
19496 **
19497 *************************************************************************
19498 ** This file contains the C functions that implement mutexes for pthreads
19499 */
19500
19501 /*
19502 ** The code in this file is only used if we are compiling threadsafe
19503 ** under unix with pthreads.
19504 **
19505 ** Note that this implementation requires a version of pthreads that
19506 ** supports recursive mutexes.
19507 */
19508 #ifdef SQLCIPHER_MUTEX_PTHREADS
19509
19510 #include <pthread.h>
19511
19512 /*
19513 ** The sqlcipher3_mutex.id, sqlcipher3_mutex.nRef, and sqlcipher3_mutex.owner fields
19514 ** are necessary under two condidtions:  (1) Debug builds and (2) using
19515 ** home-grown mutexes.  Encapsulate these conditions into a single #define.
19516 */
19517 #if defined(SQLCIPHER_DEBUG) || defined(SQLCIPHER_HOMEGROWN_RECURSIVE_MUTEX)
19518 # define SQLCIPHER_MUTEX_NREF 1
19519 #else
19520 # define SQLCIPHER_MUTEX_NREF 0
19521 #endif
19522
19523 /*
19524 ** Each recursive mutex is an instance of the following structure.
19525 */
19526 struct sqlcipher3_mutex {
19527   pthread_mutex_t mutex;     /* Mutex controlling the lock */
19528 #if SQLCIPHER_MUTEX_NREF
19529   int id;                    /* Mutex type */
19530   volatile int nRef;         /* Number of entrances */
19531   volatile pthread_t owner;  /* Thread that is within this mutex */
19532   int trace;                 /* True to trace changes */
19533 #endif
19534 };
19535 #if SQLCIPHER_MUTEX_NREF
19536 #define SQLCIPHER3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0, 0, (pthread_t)0, 0 }
19537 #else
19538 #define SQLCIPHER3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
19539 #endif
19540
19541 /*
19542 ** The sqlcipher3_mutex_held() and sqlcipher3_mutex_notheld() routine are
19543 ** intended for use only inside assert() statements.  On some platforms,
19544 ** there might be race conditions that can cause these routines to
19545 ** deliver incorrect results.  In particular, if pthread_equal() is
19546 ** not an atomic operation, then these routines might delivery
19547 ** incorrect results.  On most platforms, pthread_equal() is a 
19548 ** comparison of two integers and is therefore atomic.  But we are
19549 ** told that HPUX is not such a platform.  If so, then these routines
19550 ** will not always work correctly on HPUX.
19551 **
19552 ** On those platforms where pthread_equal() is not atomic, SQLite
19553 ** should be compiled without -DSQLCIPHER_DEBUG and with -DNDEBUG to
19554 ** make sure no assert() statements are evaluated and hence these
19555 ** routines are never called.
19556 */
19557 #if !defined(NDEBUG) || defined(SQLCIPHER_DEBUG)
19558 static int pthreadMutexHeld(sqlcipher3_mutex *p){
19559   return (p->nRef!=0 && pthread_equal(p->owner, pthread_self()));
19560 }
19561 static int pthreadMutexNotheld(sqlcipher3_mutex *p){
19562   return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0;
19563 }
19564 #endif
19565
19566 /*
19567 ** Initialize and deinitialize the mutex subsystem.
19568 */
19569 static int pthreadMutexInit(void){ return SQLCIPHER_OK; }
19570 static int pthreadMutexEnd(void){ return SQLCIPHER_OK; }
19571
19572 /*
19573 ** The sqlcipher3_mutex_alloc() routine allocates a new
19574 ** mutex and returns a pointer to it.  If it returns NULL
19575 ** that means that a mutex could not be allocated.  SQLite
19576 ** will unwind its stack and return an error.  The argument
19577 ** to sqlcipher3_mutex_alloc() is one of these integer constants:
19578 **
19579 ** <ul>
19580 ** <li>  SQLCIPHER_MUTEX_FAST
19581 ** <li>  SQLCIPHER_MUTEX_RECURSIVE
19582 ** <li>  SQLCIPHER_MUTEX_STATIC_MASTER
19583 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM
19584 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM2
19585 ** <li>  SQLCIPHER_MUTEX_STATIC_PRNG
19586 ** <li>  SQLCIPHER_MUTEX_STATIC_LRU
19587 ** <li>  SQLCIPHER_MUTEX_STATIC_PMEM
19588 ** </ul>
19589 **
19590 ** The first two constants cause sqlcipher3_mutex_alloc() to create
19591 ** a new mutex.  The new mutex is recursive when SQLCIPHER_MUTEX_RECURSIVE
19592 ** is used but not necessarily so when SQLCIPHER_MUTEX_FAST is used.
19593 ** The mutex implementation does not need to make a distinction
19594 ** between SQLCIPHER_MUTEX_RECURSIVE and SQLCIPHER_MUTEX_FAST if it does
19595 ** not want to.  But SQLite will only request a recursive mutex in
19596 ** cases where it really needs one.  If a faster non-recursive mutex
19597 ** implementation is available on the host platform, the mutex subsystem
19598 ** might return such a mutex in response to SQLCIPHER_MUTEX_FAST.
19599 **
19600 ** The other allowed parameters to sqlcipher3_mutex_alloc() each return
19601 ** a pointer to a static preexisting mutex.  Six static mutexes are
19602 ** used by the current version of SQLite.  Future versions of SQLite
19603 ** may add additional static mutexes.  Static mutexes are for internal
19604 ** use by SQLite only.  Applications that use SQLite mutexes should
19605 ** use only the dynamic mutexes returned by SQLCIPHER_MUTEX_FAST or
19606 ** SQLCIPHER_MUTEX_RECURSIVE.
19607 **
19608 ** Note that if one of the dynamic mutex parameters (SQLCIPHER_MUTEX_FAST
19609 ** or SQLCIPHER_MUTEX_RECURSIVE) is used then sqlcipher3_mutex_alloc()
19610 ** returns a different mutex on every call.  But for the static 
19611 ** mutex types, the same mutex is returned on every call that has
19612 ** the same type number.
19613 */
19614 static sqlcipher3_mutex *pthreadMutexAlloc(int iType){
19615   static sqlcipher3_mutex staticMutexes[] = {
19616     SQLCIPHER3_MUTEX_INITIALIZER,
19617     SQLCIPHER3_MUTEX_INITIALIZER,
19618     SQLCIPHER3_MUTEX_INITIALIZER,
19619     SQLCIPHER3_MUTEX_INITIALIZER,
19620     SQLCIPHER3_MUTEX_INITIALIZER,
19621     SQLCIPHER3_MUTEX_INITIALIZER
19622   };
19623   sqlcipher3_mutex *p;
19624   switch( iType ){
19625     case SQLCIPHER_MUTEX_RECURSIVE: {
19626       p = sqlcipher3MallocZero( sizeof(*p) );
19627       if( p ){
19628 #ifdef SQLCIPHER_HOMEGROWN_RECURSIVE_MUTEX
19629         /* If recursive mutexes are not available, we will have to
19630         ** build our own.  See below. */
19631         pthread_mutex_init(&p->mutex, 0);
19632 #else
19633         /* Use a recursive mutex if it is available */
19634         pthread_mutexattr_t recursiveAttr;
19635         pthread_mutexattr_init(&recursiveAttr);
19636         pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
19637         pthread_mutex_init(&p->mutex, &recursiveAttr);
19638         pthread_mutexattr_destroy(&recursiveAttr);
19639 #endif
19640 #if SQLCIPHER_MUTEX_NREF
19641         p->id = iType;
19642 #endif
19643       }
19644       break;
19645     }
19646     case SQLCIPHER_MUTEX_FAST: {
19647       p = sqlcipher3MallocZero( sizeof(*p) );
19648       if( p ){
19649 #if SQLCIPHER_MUTEX_NREF
19650         p->id = iType;
19651 #endif
19652         pthread_mutex_init(&p->mutex, 0);
19653       }
19654       break;
19655     }
19656     default: {
19657       assert( iType-2 >= 0 );
19658       assert( iType-2 < ArraySize(staticMutexes) );
19659       p = &staticMutexes[iType-2];
19660 #if SQLCIPHER_MUTEX_NREF
19661       p->id = iType;
19662 #endif
19663       break;
19664     }
19665   }
19666   return p;
19667 }
19668
19669
19670 /*
19671 ** This routine deallocates a previously
19672 ** allocated mutex.  SQLite is careful to deallocate every
19673 ** mutex that it allocates.
19674 */
19675 static void pthreadMutexFree(sqlcipher3_mutex *p){
19676   assert( p->nRef==0 );
19677   assert( p->id==SQLCIPHER_MUTEX_FAST || p->id==SQLCIPHER_MUTEX_RECURSIVE );
19678   pthread_mutex_destroy(&p->mutex);
19679   sqlcipher3_free(p);
19680 }
19681
19682 /*
19683 ** The sqlcipher3_mutex_enter() and sqlcipher3_mutex_try() routines attempt
19684 ** to enter a mutex.  If another thread is already within the mutex,
19685 ** sqlcipher3_mutex_enter() will block and sqlcipher3_mutex_try() will return
19686 ** SQLCIPHER_BUSY.  The sqlcipher3_mutex_try() interface returns SQLCIPHER_OK
19687 ** upon successful entry.  Mutexes created using SQLCIPHER_MUTEX_RECURSIVE can
19688 ** be entered multiple times by the same thread.  In such cases the,
19689 ** mutex must be exited an equal number of times before another thread
19690 ** can enter.  If the same thread tries to enter any other kind of mutex
19691 ** more than once, the behavior is undefined.
19692 */
19693 static void pthreadMutexEnter(sqlcipher3_mutex *p){
19694   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
19695
19696 #ifdef SQLCIPHER_HOMEGROWN_RECURSIVE_MUTEX
19697   /* If recursive mutexes are not available, then we have to grow
19698   ** our own.  This implementation assumes that pthread_equal()
19699   ** is atomic - that it cannot be deceived into thinking self
19700   ** and p->owner are equal if p->owner changes between two values
19701   ** that are not equal to self while the comparison is taking place.
19702   ** This implementation also assumes a coherent cache - that 
19703   ** separate processes cannot read different values from the same
19704   ** address at the same time.  If either of these two conditions
19705   ** are not met, then the mutexes will fail and problems will result.
19706   */
19707   {
19708     pthread_t self = pthread_self();
19709     if( p->nRef>0 && pthread_equal(p->owner, self) ){
19710       p->nRef++;
19711     }else{
19712       pthread_mutex_lock(&p->mutex);
19713       assert( p->nRef==0 );
19714       p->owner = self;
19715       p->nRef = 1;
19716     }
19717   }
19718 #else
19719   /* Use the built-in recursive mutexes if they are available.
19720   */
19721   pthread_mutex_lock(&p->mutex);
19722 #if SQLCIPHER_MUTEX_NREF
19723   assert( p->nRef>0 || p->owner==0 );
19724   p->owner = pthread_self();
19725   p->nRef++;
19726 #endif
19727 #endif
19728
19729 #ifdef SQLCIPHER_DEBUG
19730   if( p->trace ){
19731     printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
19732   }
19733 #endif
19734 }
19735 static int pthreadMutexTry(sqlcipher3_mutex *p){
19736   int rc;
19737   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
19738
19739 #ifdef SQLCIPHER_HOMEGROWN_RECURSIVE_MUTEX
19740   /* If recursive mutexes are not available, then we have to grow
19741   ** our own.  This implementation assumes that pthread_equal()
19742   ** is atomic - that it cannot be deceived into thinking self
19743   ** and p->owner are equal if p->owner changes between two values
19744   ** that are not equal to self while the comparison is taking place.
19745   ** This implementation also assumes a coherent cache - that 
19746   ** separate processes cannot read different values from the same
19747   ** address at the same time.  If either of these two conditions
19748   ** are not met, then the mutexes will fail and problems will result.
19749   */
19750   {
19751     pthread_t self = pthread_self();
19752     if( p->nRef>0 && pthread_equal(p->owner, self) ){
19753       p->nRef++;
19754       rc = SQLCIPHER_OK;
19755     }else if( pthread_mutex_trylock(&p->mutex)==0 ){
19756       assert( p->nRef==0 );
19757       p->owner = self;
19758       p->nRef = 1;
19759       rc = SQLCIPHER_OK;
19760     }else{
19761       rc = SQLCIPHER_BUSY;
19762     }
19763   }
19764 #else
19765   /* Use the built-in recursive mutexes if they are available.
19766   */
19767   if( pthread_mutex_trylock(&p->mutex)==0 ){
19768 #if SQLCIPHER_MUTEX_NREF
19769     p->owner = pthread_self();
19770     p->nRef++;
19771 #endif
19772     rc = SQLCIPHER_OK;
19773   }else{
19774     rc = SQLCIPHER_BUSY;
19775   }
19776 #endif
19777
19778 #ifdef SQLCIPHER_DEBUG
19779   if( rc==SQLCIPHER_OK && p->trace ){
19780     printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
19781   }
19782 #endif
19783   return rc;
19784 }
19785
19786 /*
19787 ** The sqlcipher3_mutex_leave() routine exits a mutex that was
19788 ** previously entered by the same thread.  The behavior
19789 ** is undefined if the mutex is not currently entered or
19790 ** is not currently allocated.  SQLite will never do either.
19791 */
19792 static void pthreadMutexLeave(sqlcipher3_mutex *p){
19793   assert( pthreadMutexHeld(p) );
19794 #if SQLCIPHER_MUTEX_NREF
19795   p->nRef--;
19796   if( p->nRef==0 ) p->owner = 0;
19797 #endif
19798   assert( p->nRef==0 || p->id==SQLCIPHER_MUTEX_RECURSIVE );
19799
19800 #ifdef SQLCIPHER_HOMEGROWN_RECURSIVE_MUTEX
19801   if( p->nRef==0 ){
19802     pthread_mutex_unlock(&p->mutex);
19803   }
19804 #else
19805   pthread_mutex_unlock(&p->mutex);
19806 #endif
19807
19808 #ifdef SQLCIPHER_DEBUG
19809   if( p->trace ){
19810     printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
19811   }
19812 #endif
19813 }
19814
19815 SQLCIPHER_PRIVATE sqlcipher3_mutex_methods const *sqlcipher3DefaultMutex(void){
19816   static const sqlcipher3_mutex_methods sMutex = {
19817     pthreadMutexInit,
19818     pthreadMutexEnd,
19819     pthreadMutexAlloc,
19820     pthreadMutexFree,
19821     pthreadMutexEnter,
19822     pthreadMutexTry,
19823     pthreadMutexLeave,
19824 #ifdef SQLCIPHER_DEBUG
19825     pthreadMutexHeld,
19826     pthreadMutexNotheld
19827 #else
19828     0,
19829     0
19830 #endif
19831   };
19832
19833   return &sMutex;
19834 }
19835
19836 #endif /* SQLCIPHER_MUTEX_PTHREAD */
19837
19838 /************** End of mutex_unix.c ******************************************/
19839 /************** Begin file mutex_w32.c ***************************************/
19840 /*
19841 ** 2007 August 14
19842 **
19843 ** The author disclaims copyright to this source code.  In place of
19844 ** a legal notice, here is a blessing:
19845 **
19846 **    May you do good and not evil.
19847 **    May you find forgiveness for yourself and forgive others.
19848 **    May you share freely, never taking more than you give.
19849 **
19850 *************************************************************************
19851 ** This file contains the C functions that implement mutexes for win32
19852 */
19853
19854 /*
19855 ** The code in this file is only used if we are compiling multithreaded
19856 ** on a win32 system.
19857 */
19858 #ifdef SQLCIPHER_MUTEX_W32
19859
19860 /*
19861 ** Each recursive mutex is an instance of the following structure.
19862 */
19863 struct sqlcipher3_mutex {
19864   CRITICAL_SECTION mutex;    /* Mutex controlling the lock */
19865   int id;                    /* Mutex type */
19866 #ifdef SQLCIPHER_DEBUG
19867   volatile int nRef;         /* Number of enterances */
19868   volatile DWORD owner;      /* Thread holding this mutex */
19869   int trace;                 /* True to trace changes */
19870 #endif
19871 };
19872 #define SQLCIPHER_W32_MUTEX_INITIALIZER { 0 }
19873 #ifdef SQLCIPHER_DEBUG
19874 #define SQLCIPHER3_MUTEX_INITIALIZER { SQLCIPHER_W32_MUTEX_INITIALIZER, 0, 0L, (DWORD)0, 0 }
19875 #else
19876 #define SQLCIPHER3_MUTEX_INITIALIZER { SQLCIPHER_W32_MUTEX_INITIALIZER, 0 }
19877 #endif
19878
19879 /*
19880 ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
19881 ** or WinCE.  Return false (zero) for Win95, Win98, or WinME.
19882 **
19883 ** Here is an interesting observation:  Win95, Win98, and WinME lack
19884 ** the LockFileEx() API.  But we can still statically link against that
19885 ** API as long as we don't call it win running Win95/98/ME.  A call to
19886 ** this routine is used to determine if the host is Win95/98/ME or
19887 ** WinNT/2K/XP so that we will know whether or not we can safely call
19888 ** the LockFileEx() API.
19889 **
19890 ** mutexIsNT() is only used for the TryEnterCriticalSection() API call,
19891 ** which is only available if your application was compiled with 
19892 ** _WIN32_WINNT defined to a value >= 0x0400.  Currently, the only
19893 ** call to TryEnterCriticalSection() is #ifdef'ed out, so #ifdef 
19894 ** this out as well.
19895 */
19896 #if 0
19897 #if SQLCIPHER_OS_WINCE
19898 # define mutexIsNT()  (1)
19899 #else
19900   static int mutexIsNT(void){
19901     static int osType = 0;
19902     if( osType==0 ){
19903       OSVERSIONINFO sInfo;
19904       sInfo.dwOSVersionInfoSize = sizeof(sInfo);
19905       GetVersionEx(&sInfo);
19906       osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
19907     }
19908     return osType==2;
19909   }
19910 #endif /* SQLCIPHER_OS_WINCE */
19911 #endif
19912
19913 #ifdef SQLCIPHER_DEBUG
19914 /*
19915 ** The sqlcipher3_mutex_held() and sqlcipher3_mutex_notheld() routine are
19916 ** intended for use only inside assert() statements.
19917 */
19918 static int winMutexHeld(sqlcipher3_mutex *p){
19919   return p->nRef!=0 && p->owner==GetCurrentThreadId();
19920 }
19921 static int winMutexNotheld2(sqlcipher3_mutex *p, DWORD tid){
19922   return p->nRef==0 || p->owner!=tid;
19923 }
19924 static int winMutexNotheld(sqlcipher3_mutex *p){
19925   DWORD tid = GetCurrentThreadId(); 
19926   return winMutexNotheld2(p, tid);
19927 }
19928 #endif
19929
19930
19931 /*
19932 ** Initialize and deinitialize the mutex subsystem.
19933 */
19934 static sqlcipher3_mutex winMutex_staticMutexes[6] = {
19935   SQLCIPHER3_MUTEX_INITIALIZER,
19936   SQLCIPHER3_MUTEX_INITIALIZER,
19937   SQLCIPHER3_MUTEX_INITIALIZER,
19938   SQLCIPHER3_MUTEX_INITIALIZER,
19939   SQLCIPHER3_MUTEX_INITIALIZER,
19940   SQLCIPHER3_MUTEX_INITIALIZER
19941 };
19942 static int winMutex_isInit = 0;
19943 /* As winMutexInit() and winMutexEnd() are called as part
19944 ** of the sqlcipher3_initialize and sqlcipher3_shutdown()
19945 ** processing, the "interlocked" magic is probably not
19946 ** strictly necessary.
19947 */
19948 static long winMutex_lock = 0;
19949
19950 static int winMutexInit(void){ 
19951   /* The first to increment to 1 does actual initialization */
19952   if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){
19953     int i;
19954     for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
19955       InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
19956     }
19957     winMutex_isInit = 1;
19958   }else{
19959     /* Someone else is in the process of initing the static mutexes */
19960     while( !winMutex_isInit ){
19961       Sleep(1);
19962     }
19963   }
19964   return SQLCIPHER_OK; 
19965 }
19966
19967 static int winMutexEnd(void){ 
19968   /* The first to decrement to 0 does actual shutdown 
19969   ** (which should be the last to shutdown.) */
19970   if( InterlockedCompareExchange(&winMutex_lock, 0, 1)==1 ){
19971     if( winMutex_isInit==1 ){
19972       int i;
19973       for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
19974         DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
19975       }
19976       winMutex_isInit = 0;
19977     }
19978   }
19979   return SQLCIPHER_OK; 
19980 }
19981
19982 /*
19983 ** The sqlcipher3_mutex_alloc() routine allocates a new
19984 ** mutex and returns a pointer to it.  If it returns NULL
19985 ** that means that a mutex could not be allocated.  SQLite
19986 ** will unwind its stack and return an error.  The argument
19987 ** to sqlcipher3_mutex_alloc() is one of these integer constants:
19988 **
19989 ** <ul>
19990 ** <li>  SQLCIPHER_MUTEX_FAST
19991 ** <li>  SQLCIPHER_MUTEX_RECURSIVE
19992 ** <li>  SQLCIPHER_MUTEX_STATIC_MASTER
19993 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM
19994 ** <li>  SQLCIPHER_MUTEX_STATIC_MEM2
19995 ** <li>  SQLCIPHER_MUTEX_STATIC_PRNG
19996 ** <li>  SQLCIPHER_MUTEX_STATIC_LRU
19997 ** <li>  SQLCIPHER_MUTEX_STATIC_PMEM
19998 ** </ul>
19999 **
20000 ** The first two constants cause sqlcipher3_mutex_alloc() to create
20001 ** a new mutex.  The new mutex is recursive when SQLCIPHER_MUTEX_RECURSIVE
20002 ** is used but not necessarily so when SQLCIPHER_MUTEX_FAST is used.
20003 ** The mutex implementation does not need to make a distinction
20004 ** between SQLCIPHER_MUTEX_RECURSIVE and SQLCIPHER_MUTEX_FAST if it does
20005 ** not want to.  But SQLite will only request a recursive mutex in
20006 ** cases where it really needs one.  If a faster non-recursive mutex
20007 ** implementation is available on the host platform, the mutex subsystem
20008 ** might return such a mutex in response to SQLCIPHER_MUTEX_FAST.
20009 **
20010 ** The other allowed parameters to sqlcipher3_mutex_alloc() each return
20011 ** a pointer to a static preexisting mutex.  Six static mutexes are
20012 ** used by the current version of SQLite.  Future versions of SQLite
20013 ** may add additional static mutexes.  Static mutexes are for internal
20014 ** use by SQLite only.  Applications that use SQLite mutexes should
20015 ** use only the dynamic mutexes returned by SQLCIPHER_MUTEX_FAST or
20016 ** SQLCIPHER_MUTEX_RECURSIVE.
20017 **
20018 ** Note that if one of the dynamic mutex parameters (SQLCIPHER_MUTEX_FAST
20019 ** or SQLCIPHER_MUTEX_RECURSIVE) is used then sqlcipher3_mutex_alloc()
20020 ** returns a different mutex on every call.  But for the static 
20021 ** mutex types, the same mutex is returned on every call that has
20022 ** the same type number.
20023 */
20024 static sqlcipher3_mutex *winMutexAlloc(int iType){
20025   sqlcipher3_mutex *p;
20026
20027   switch( iType ){
20028     case SQLCIPHER_MUTEX_FAST:
20029     case SQLCIPHER_MUTEX_RECURSIVE: {
20030       p = sqlcipher3MallocZero( sizeof(*p) );
20031       if( p ){  
20032 #ifdef SQLCIPHER_DEBUG
20033         p->id = iType;
20034 #endif
20035         InitializeCriticalSection(&p->mutex);
20036       }
20037       break;
20038     }
20039     default: {
20040       assert( winMutex_isInit==1 );
20041       assert( iType-2 >= 0 );
20042       assert( iType-2 < ArraySize(winMutex_staticMutexes) );
20043       p = &winMutex_staticMutexes[iType-2];
20044 #ifdef SQLCIPHER_DEBUG
20045       p->id = iType;
20046 #endif
20047       break;
20048     }
20049   }
20050   return p;
20051 }
20052
20053
20054 /*
20055 ** This routine deallocates a previously
20056 ** allocated mutex.  SQLite is careful to deallocate every
20057 ** mutex that it allocates.
20058 */
20059 static void winMutexFree(sqlcipher3_mutex *p){
20060   assert( p );
20061   assert( p->nRef==0 && p->owner==0 );
20062   assert( p->id==SQLCIPHER_MUTEX_FAST || p->id==SQLCIPHER_MUTEX_RECURSIVE );
20063   DeleteCriticalSection(&p->mutex);
20064   sqlcipher3_free(p);
20065 }
20066
20067 /*
20068 ** The sqlcipher3_mutex_enter() and sqlcipher3_mutex_try() routines attempt
20069 ** to enter a mutex.  If another thread is already within the mutex,
20070 ** sqlcipher3_mutex_enter() will block and sqlcipher3_mutex_try() will return
20071 ** SQLCIPHER_BUSY.  The sqlcipher3_mutex_try() interface returns SQLCIPHER_OK
20072 ** upon successful entry.  Mutexes created using SQLCIPHER_MUTEX_RECURSIVE can
20073 ** be entered multiple times by the same thread.  In such cases the,
20074 ** mutex must be exited an equal number of times before another thread
20075 ** can enter.  If the same thread tries to enter any other kind of mutex
20076 ** more than once, the behavior is undefined.
20077 */
20078 static void winMutexEnter(sqlcipher3_mutex *p){
20079 #ifdef SQLCIPHER_DEBUG
20080   DWORD tid = GetCurrentThreadId(); 
20081   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
20082 #endif
20083   EnterCriticalSection(&p->mutex);
20084 #ifdef SQLCIPHER_DEBUG
20085   assert( p->nRef>0 || p->owner==0 );
20086   p->owner = tid; 
20087   p->nRef++;
20088   if( p->trace ){
20089     printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
20090   }
20091 #endif
20092 }
20093 static int winMutexTry(sqlcipher3_mutex *p){
20094 #ifndef NDEBUG
20095   DWORD tid = GetCurrentThreadId(); 
20096 #endif
20097   int rc = SQLCIPHER_BUSY;
20098   assert( p->id==SQLCIPHER_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
20099   /*
20100   ** The sqlcipher3_mutex_try() routine is very rarely used, and when it
20101   ** is used it is merely an optimization.  So it is OK for it to always
20102   ** fail.  
20103   **
20104   ** The TryEnterCriticalSection() interface is only available on WinNT.
20105   ** And some windows compilers complain if you try to use it without
20106   ** first doing some #defines that prevent SQLite from building on Win98.
20107   ** For that reason, we will omit this optimization for now.  See
20108   ** ticket #2685.
20109   */
20110 #if 0
20111   if( mutexIsNT() && TryEnterCriticalSection(&p->mutex) ){
20112     p->owner = tid;
20113     p->nRef++;
20114     rc = SQLCIPHER_OK;
20115   }
20116 #else
20117   UNUSED_PARAMETER(p);
20118 #endif
20119 #ifdef SQLCIPHER_DEBUG
20120   if( rc==SQLCIPHER_OK && p->trace ){
20121     printf("try mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
20122   }
20123 #endif
20124   return rc;
20125 }
20126
20127 /*
20128 ** The sqlcipher3_mutex_leave() routine exits a mutex that was
20129 ** previously entered by the same thread.  The behavior
20130 ** is undefined if the mutex is not currently entered or
20131 ** is not currently allocated.  SQLite will never do either.
20132 */
20133 static void winMutexLeave(sqlcipher3_mutex *p){
20134 #ifndef NDEBUG
20135   DWORD tid = GetCurrentThreadId();
20136   assert( p->nRef>0 );
20137   assert( p->owner==tid );
20138   p->nRef--;
20139   if( p->nRef==0 ) p->owner = 0;
20140   assert( p->nRef==0 || p->id==SQLCIPHER_MUTEX_RECURSIVE );
20141 #endif
20142   LeaveCriticalSection(&p->mutex);
20143 #ifdef SQLCIPHER_DEBUG
20144   if( p->trace ){
20145     printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
20146   }
20147 #endif
20148 }
20149
20150 SQLCIPHER_PRIVATE sqlcipher3_mutex_methods const *sqlcipher3DefaultMutex(void){
20151   static const sqlcipher3_mutex_methods sMutex = {
20152     winMutexInit,
20153     winMutexEnd,
20154     winMutexAlloc,
20155     winMutexFree,
20156     winMutexEnter,
20157     winMutexTry,
20158     winMutexLeave,
20159 #ifdef SQLCIPHER_DEBUG
20160     winMutexHeld,
20161     winMutexNotheld
20162 #else
20163     0,
20164     0
20165 #endif
20166   };
20167
20168   return &sMutex;
20169 }
20170 #endif /* SQLCIPHER_MUTEX_W32 */
20171
20172 /************** End of mutex_w32.c *******************************************/
20173 /************** Begin file malloc.c ******************************************/
20174 /*
20175 ** 2001 September 15
20176 **
20177 ** The author disclaims copyright to this source code.  In place of
20178 ** a legal notice, here is a blessing:
20179 **
20180 **    May you do good and not evil.
20181 **    May you find forgiveness for yourself and forgive others.
20182 **    May you share freely, never taking more than you give.
20183 **
20184 *************************************************************************
20185 **
20186 ** Memory allocation functions used throughout sqlcipher.
20187 */
20188 /* #include <stdarg.h> */
20189
20190 /*
20191 ** Attempt to release up to n bytes of non-essential memory currently
20192 ** held by SQLite. An example of non-essential memory is memory used to
20193 ** cache database pages that are not currently in use.
20194 */
20195 SQLCIPHER_API int sqlcipher3_release_memory(int n){
20196 #ifdef SQLCIPHER_ENABLE_MEMORY_MANAGEMENT
20197   return sqlcipher3PcacheReleaseMemory(n);
20198 #else
20199   /* IMPLEMENTATION-OF: R-34391-24921 The sqlcipher3_release_memory() routine
20200   ** is a no-op returning zero if SQLite is not compiled with
20201   ** SQLCIPHER_ENABLE_MEMORY_MANAGEMENT. */
20202   UNUSED_PARAMETER(n);
20203   return 0;
20204 #endif
20205 }
20206
20207 /*
20208 ** An instance of the following object records the location of
20209 ** each unused scratch buffer.
20210 */
20211 typedef struct ScratchFreeslot {
20212   struct ScratchFreeslot *pNext;   /* Next unused scratch buffer */
20213 } ScratchFreeslot;
20214
20215 /*
20216 ** State information local to the memory allocation subsystem.
20217 */
20218 static SQLCIPHER_WSD struct Mem0Global {
20219   sqlcipher3_mutex *mutex;         /* Mutex to serialize access */
20220
20221   /*
20222   ** The alarm callback and its arguments.  The mem0.mutex lock will
20223   ** be held while the callback is running.  Recursive calls into
20224   ** the memory subsystem are allowed, but no new callbacks will be
20225   ** issued.
20226   */
20227   sqlcipher3_int64 alarmThreshold;
20228   void (*alarmCallback)(void*, sqlcipher3_int64,int);
20229   void *alarmArg;
20230
20231   /*
20232   ** Pointers to the end of sqlcipher3GlobalConfig.pScratch memory
20233   ** (so that a range test can be used to determine if an allocation
20234   ** being freed came from pScratch) and a pointer to the list of
20235   ** unused scratch allocations.
20236   */
20237   void *pScratchEnd;
20238   ScratchFreeslot *pScratchFree;
20239   u32 nScratchFree;
20240
20241   /*
20242   ** True if heap is nearly "full" where "full" is defined by the
20243   ** sqlcipher3_soft_heap_limit() setting.
20244   */
20245   int nearlyFull;
20246 } mem0 = { 0, 0, 0, 0, 0, 0, 0, 0 };
20247
20248 #define mem0 GLOBAL(struct Mem0Global, mem0)
20249
20250 /*
20251 ** This routine runs when the memory allocator sees that the
20252 ** total memory allocation is about to exceed the soft heap
20253 ** limit.
20254 */
20255 static void softHeapLimitEnforcer(
20256   void *NotUsed, 
20257   sqlcipher3_int64 NotUsed2,
20258   int allocSize
20259 ){
20260   UNUSED_PARAMETER2(NotUsed, NotUsed2);
20261   sqlcipher3_release_memory(allocSize);
20262 }
20263
20264 /*
20265 ** Change the alarm callback
20266 */
20267 static int sqlcipher3MemoryAlarm(
20268   void(*xCallback)(void *pArg, sqlcipher3_int64 used,int N),
20269   void *pArg,
20270   sqlcipher3_int64 iThreshold
20271 ){
20272   int nUsed;
20273   sqlcipher3_mutex_enter(mem0.mutex);
20274   mem0.alarmCallback = xCallback;
20275   mem0.alarmArg = pArg;
20276   mem0.alarmThreshold = iThreshold;
20277   nUsed = sqlcipher3StatusValue(SQLCIPHER_STATUS_MEMORY_USED);
20278   mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);
20279   sqlcipher3_mutex_leave(mem0.mutex);
20280   return SQLCIPHER_OK;
20281 }
20282
20283 #ifndef SQLCIPHER_OMIT_DEPRECATED
20284 /*
20285 ** Deprecated external interface.  Internal/core SQLite code
20286 ** should call sqlcipher3MemoryAlarm.
20287 */
20288 SQLCIPHER_API int sqlcipher3_memory_alarm(
20289   void(*xCallback)(void *pArg, sqlcipher3_int64 used,int N),
20290   void *pArg,
20291   sqlcipher3_int64 iThreshold
20292 ){
20293   return sqlcipher3MemoryAlarm(xCallback, pArg, iThreshold);
20294 }
20295 #endif
20296
20297 /*
20298 ** Set the soft heap-size limit for the library. Passing a zero or 
20299 ** negative value indicates no limit.
20300 */
20301 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_soft_heap_limit64(sqlcipher3_int64 n){
20302   sqlcipher3_int64 priorLimit;
20303   sqlcipher3_int64 excess;
20304 #ifndef SQLCIPHER_OMIT_AUTOINIT
20305   sqlcipher3_initialize();
20306 #endif
20307   sqlcipher3_mutex_enter(mem0.mutex);
20308   priorLimit = mem0.alarmThreshold;
20309   sqlcipher3_mutex_leave(mem0.mutex);
20310   if( n<0 ) return priorLimit;
20311   if( n>0 ){
20312     sqlcipher3MemoryAlarm(softHeapLimitEnforcer, 0, n);
20313   }else{
20314     sqlcipher3MemoryAlarm(0, 0, 0);
20315   }
20316   excess = sqlcipher3_memory_used() - n;
20317   if( excess>0 ) sqlcipher3_release_memory((int)(excess & 0x7fffffff));
20318   return priorLimit;
20319 }
20320 SQLCIPHER_API void sqlcipher3_soft_heap_limit(int n){
20321   if( n<0 ) n = 0;
20322   sqlcipher3_soft_heap_limit64(n);
20323 }
20324
20325 /*
20326 ** Initialize the memory allocation subsystem.
20327 */
20328 SQLCIPHER_PRIVATE int sqlcipher3MallocInit(void){
20329   if( sqlcipher3GlobalConfig.m.xMalloc==0 ){
20330     sqlcipher3MemSetDefault();
20331   }
20332   memset(&mem0, 0, sizeof(mem0));
20333   if( sqlcipher3GlobalConfig.bCoreMutex ){
20334     mem0.mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MEM);
20335   }
20336   if( sqlcipher3GlobalConfig.pScratch && sqlcipher3GlobalConfig.szScratch>=100
20337       && sqlcipher3GlobalConfig.nScratch>0 ){
20338     int i, n, sz;
20339     ScratchFreeslot *pSlot;
20340     sz = ROUNDDOWN8(sqlcipher3GlobalConfig.szScratch);
20341     sqlcipher3GlobalConfig.szScratch = sz;
20342     pSlot = (ScratchFreeslot*)sqlcipher3GlobalConfig.pScratch;
20343     n = sqlcipher3GlobalConfig.nScratch;
20344     mem0.pScratchFree = pSlot;
20345     mem0.nScratchFree = n;
20346     for(i=0; i<n-1; i++){
20347       pSlot->pNext = (ScratchFreeslot*)(sz+(char*)pSlot);
20348       pSlot = pSlot->pNext;
20349     }
20350     pSlot->pNext = 0;
20351     mem0.pScratchEnd = (void*)&pSlot[1];
20352   }else{
20353     mem0.pScratchEnd = 0;
20354     sqlcipher3GlobalConfig.pScratch = 0;
20355     sqlcipher3GlobalConfig.szScratch = 0;
20356     sqlcipher3GlobalConfig.nScratch = 0;
20357   }
20358   if( sqlcipher3GlobalConfig.pPage==0 || sqlcipher3GlobalConfig.szPage<512
20359       || sqlcipher3GlobalConfig.nPage<1 ){
20360     sqlcipher3GlobalConfig.pPage = 0;
20361     sqlcipher3GlobalConfig.szPage = 0;
20362     sqlcipher3GlobalConfig.nPage = 0;
20363   }
20364   return sqlcipher3GlobalConfig.m.xInit(sqlcipher3GlobalConfig.m.pAppData);
20365 }
20366
20367 /*
20368 ** Return true if the heap is currently under memory pressure - in other
20369 ** words if the amount of heap used is close to the limit set by
20370 ** sqlcipher3_soft_heap_limit().
20371 */
20372 SQLCIPHER_PRIVATE int sqlcipher3HeapNearlyFull(void){
20373   return mem0.nearlyFull;
20374 }
20375
20376 /*
20377 ** Deinitialize the memory allocation subsystem.
20378 */
20379 SQLCIPHER_PRIVATE void sqlcipher3MallocEnd(void){
20380   if( sqlcipher3GlobalConfig.m.xShutdown ){
20381     sqlcipher3GlobalConfig.m.xShutdown(sqlcipher3GlobalConfig.m.pAppData);
20382   }
20383   memset(&mem0, 0, sizeof(mem0));
20384 }
20385
20386 /*
20387 ** Return the amount of memory currently checked out.
20388 */
20389 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_memory_used(void){
20390   int n, mx;
20391   sqlcipher3_int64 res;
20392   sqlcipher3_status(SQLCIPHER_STATUS_MEMORY_USED, &n, &mx, 0);
20393   res = (sqlcipher3_int64)n;  /* Work around bug in Borland C. Ticket #3216 */
20394   return res;
20395 }
20396
20397 /*
20398 ** Return the maximum amount of memory that has ever been
20399 ** checked out since either the beginning of this process
20400 ** or since the most recent reset.
20401 */
20402 SQLCIPHER_API sqlcipher3_int64 sqlcipher3_memory_highwater(int resetFlag){
20403   int n, mx;
20404   sqlcipher3_int64 res;
20405   sqlcipher3_status(SQLCIPHER_STATUS_MEMORY_USED, &n, &mx, resetFlag);
20406   res = (sqlcipher3_int64)mx;  /* Work around bug in Borland C. Ticket #3216 */
20407   return res;
20408 }
20409
20410 /*
20411 ** Trigger the alarm 
20412 */
20413 static void sqlcipher3MallocAlarm(int nByte){
20414   void (*xCallback)(void*,sqlcipher3_int64,int);
20415   sqlcipher3_int64 nowUsed;
20416   void *pArg;
20417   if( mem0.alarmCallback==0 ) return;
20418   xCallback = mem0.alarmCallback;
20419   nowUsed = sqlcipher3StatusValue(SQLCIPHER_STATUS_MEMORY_USED);
20420   pArg = mem0.alarmArg;
20421   mem0.alarmCallback = 0;
20422   sqlcipher3_mutex_leave(mem0.mutex);
20423   xCallback(pArg, nowUsed, nByte);
20424   sqlcipher3_mutex_enter(mem0.mutex);
20425   mem0.alarmCallback = xCallback;
20426   mem0.alarmArg = pArg;
20427 }
20428
20429 /*
20430 ** Do a memory allocation with statistics and alarms.  Assume the
20431 ** lock is already held.
20432 */
20433 static int mallocWithAlarm(int n, void **pp){
20434   int nFull;
20435   void *p;
20436   assert( sqlcipher3_mutex_held(mem0.mutex) );
20437   nFull = sqlcipher3GlobalConfig.m.xRoundup(n);
20438   sqlcipher3StatusSet(SQLCIPHER_STATUS_MALLOC_SIZE, n);
20439   if( mem0.alarmCallback!=0 ){
20440     int nUsed = sqlcipher3StatusValue(SQLCIPHER_STATUS_MEMORY_USED);
20441     if( nUsed >= mem0.alarmThreshold - nFull ){
20442       mem0.nearlyFull = 1;
20443       sqlcipher3MallocAlarm(nFull);
20444     }else{
20445       mem0.nearlyFull = 0;
20446     }
20447   }
20448   p = sqlcipher3GlobalConfig.m.xMalloc(nFull);
20449 #ifdef SQLCIPHER_ENABLE_MEMORY_MANAGEMENT
20450   if( p==0 && mem0.alarmCallback ){
20451     sqlcipher3MallocAlarm(nFull);
20452     p = sqlcipher3GlobalConfig.m.xMalloc(nFull);
20453   }
20454 #endif
20455   if( p ){
20456     nFull = sqlcipher3MallocSize(p);
20457     sqlcipher3StatusAdd(SQLCIPHER_STATUS_MEMORY_USED, nFull);
20458     sqlcipher3StatusAdd(SQLCIPHER_STATUS_MALLOC_COUNT, 1);
20459   }
20460   *pp = p;
20461   return nFull;
20462 }
20463
20464 /*
20465 ** Allocate memory.  This routine is like sqlcipher3_malloc() except that it
20466 ** assumes the memory subsystem has already been initialized.
20467 */
20468 SQLCIPHER_PRIVATE void *sqlcipher3Malloc(int n){
20469   void *p;
20470   if( n<=0               /* IMP: R-65312-04917 */ 
20471    || n>=0x7fffff00
20472   ){
20473     /* A memory allocation of a number of bytes which is near the maximum
20474     ** signed integer value might cause an integer overflow inside of the
20475     ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
20476     ** 255 bytes of overhead.  SQLite itself will never use anything near
20477     ** this amount.  The only way to reach the limit is with sqlcipher3_malloc() */
20478     p = 0;
20479   }else if( sqlcipher3GlobalConfig.bMemstat ){
20480     sqlcipher3_mutex_enter(mem0.mutex);
20481     mallocWithAlarm(n, &p);
20482     sqlcipher3_mutex_leave(mem0.mutex);
20483   }else{
20484     p = sqlcipher3GlobalConfig.m.xMalloc(n);
20485   }
20486   assert( EIGHT_BYTE_ALIGNMENT(p) );  /* IMP: R-04675-44850 */
20487   return p;
20488 }
20489
20490 /*
20491 ** This version of the memory allocation is for use by the application.
20492 ** First make sure the memory subsystem is initialized, then do the
20493 ** allocation.
20494 */
20495 SQLCIPHER_API void *sqlcipher3_malloc(int n){
20496 #ifndef SQLCIPHER_OMIT_AUTOINIT
20497   if( sqlcipher3_initialize() ) return 0;
20498 #endif
20499   return sqlcipher3Malloc(n);
20500 }
20501
20502 /*
20503 ** Each thread may only have a single outstanding allocation from
20504 ** xScratchMalloc().  We verify this constraint in the single-threaded
20505 ** case by setting scratchAllocOut to 1 when an allocation
20506 ** is outstanding clearing it when the allocation is freed.
20507 */
20508 #if SQLCIPHER_THREADSAFE==0 && !defined(NDEBUG)
20509 static int scratchAllocOut = 0;
20510 #endif
20511
20512
20513 /*
20514 ** Allocate memory that is to be used and released right away.
20515 ** This routine is similar to alloca() in that it is not intended
20516 ** for situations where the memory might be held long-term.  This
20517 ** routine is intended to get memory to old large transient data
20518 ** structures that would not normally fit on the stack of an
20519 ** embedded processor.
20520 */
20521 SQLCIPHER_PRIVATE void *sqlcipher3ScratchMalloc(int n){
20522   void *p;
20523   assert( n>0 );
20524
20525   sqlcipher3_mutex_enter(mem0.mutex);
20526   if( mem0.nScratchFree && sqlcipher3GlobalConfig.szScratch>=n ){
20527     p = mem0.pScratchFree;
20528     mem0.pScratchFree = mem0.pScratchFree->pNext;
20529     mem0.nScratchFree--;
20530     sqlcipher3StatusAdd(SQLCIPHER_STATUS_SCRATCH_USED, 1);
20531     sqlcipher3StatusSet(SQLCIPHER_STATUS_SCRATCH_SIZE, n);
20532     sqlcipher3_mutex_leave(mem0.mutex);
20533   }else{
20534     if( sqlcipher3GlobalConfig.bMemstat ){
20535       sqlcipher3StatusSet(SQLCIPHER_STATUS_SCRATCH_SIZE, n);
20536       n = mallocWithAlarm(n, &p);
20537       if( p ) sqlcipher3StatusAdd(SQLCIPHER_STATUS_SCRATCH_OVERFLOW, n);
20538       sqlcipher3_mutex_leave(mem0.mutex);
20539     }else{
20540       sqlcipher3_mutex_leave(mem0.mutex);
20541       p = sqlcipher3GlobalConfig.m.xMalloc(n);
20542     }
20543     sqlcipher3MemdebugSetType(p, MEMTYPE_SCRATCH);
20544   }
20545   assert( sqlcipher3_mutex_notheld(mem0.mutex) );
20546
20547
20548 #if SQLCIPHER_THREADSAFE==0 && !defined(NDEBUG)
20549   /* Verify that no more than two scratch allocations per thread
20550   ** are outstanding at one time.  (This is only checked in the
20551   ** single-threaded case since checking in the multi-threaded case
20552   ** would be much more complicated.) */
20553   assert( scratchAllocOut<=1 );
20554   if( p ) scratchAllocOut++;
20555 #endif
20556
20557   return p;
20558 }
20559 SQLCIPHER_PRIVATE void sqlcipher3ScratchFree(void *p){
20560   if( p ){
20561
20562 #if SQLCIPHER_THREADSAFE==0 && !defined(NDEBUG)
20563     /* Verify that no more than two scratch allocation per thread
20564     ** is outstanding at one time.  (This is only checked in the
20565     ** single-threaded case since checking in the multi-threaded case
20566     ** would be much more complicated.) */
20567     assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
20568     scratchAllocOut--;
20569 #endif
20570
20571     if( p>=sqlcipher3GlobalConfig.pScratch && p<mem0.pScratchEnd ){
20572       /* Release memory from the SQLCIPHER_CONFIG_SCRATCH allocation */
20573       ScratchFreeslot *pSlot;
20574       pSlot = (ScratchFreeslot*)p;
20575       sqlcipher3_mutex_enter(mem0.mutex);
20576       pSlot->pNext = mem0.pScratchFree;
20577       mem0.pScratchFree = pSlot;
20578       mem0.nScratchFree++;
20579       assert( mem0.nScratchFree <= (u32)sqlcipher3GlobalConfig.nScratch );
20580       sqlcipher3StatusAdd(SQLCIPHER_STATUS_SCRATCH_USED, -1);
20581       sqlcipher3_mutex_leave(mem0.mutex);
20582     }else{
20583       /* Release memory back to the heap */
20584       assert( sqlcipher3MemdebugHasType(p, MEMTYPE_SCRATCH) );
20585       assert( sqlcipher3MemdebugNoType(p, ~MEMTYPE_SCRATCH) );
20586       sqlcipher3MemdebugSetType(p, MEMTYPE_HEAP);
20587       if( sqlcipher3GlobalConfig.bMemstat ){
20588         int iSize = sqlcipher3MallocSize(p);
20589         sqlcipher3_mutex_enter(mem0.mutex);
20590         sqlcipher3StatusAdd(SQLCIPHER_STATUS_SCRATCH_OVERFLOW, -iSize);
20591         sqlcipher3StatusAdd(SQLCIPHER_STATUS_MEMORY_USED, -iSize);
20592         sqlcipher3StatusAdd(SQLCIPHER_STATUS_MALLOC_COUNT, -1);
20593         sqlcipher3GlobalConfig.m.xFree(p);
20594         sqlcipher3_mutex_leave(mem0.mutex);
20595       }else{
20596         sqlcipher3GlobalConfig.m.xFree(p);
20597       }
20598     }
20599   }
20600 }
20601
20602 /*
20603 ** TRUE if p is a lookaside memory allocation from db
20604 */
20605 #ifndef SQLCIPHER_OMIT_LOOKASIDE
20606 static int isLookaside(sqlcipher3 *db, void *p){
20607   return p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
20608 }
20609 #else
20610 #define isLookaside(A,B) 0
20611 #endif
20612
20613 /*
20614 ** Return the size of a memory allocation previously obtained from
20615 ** sqlcipher3Malloc() or sqlcipher3_malloc().
20616 */
20617 SQLCIPHER_PRIVATE int sqlcipher3MallocSize(void *p){
20618   assert( sqlcipher3MemdebugHasType(p, MEMTYPE_HEAP) );
20619   assert( sqlcipher3MemdebugNoType(p, MEMTYPE_DB) );
20620   return sqlcipher3GlobalConfig.m.xSize(p);
20621 }
20622 SQLCIPHER_PRIVATE int sqlcipher3DbMallocSize(sqlcipher3 *db, void *p){
20623   assert( db==0 || sqlcipher3_mutex_held(db->mutex) );
20624   if( db && isLookaside(db, p) ){
20625     return db->lookaside.sz;
20626   }else{
20627     assert( sqlcipher3MemdebugHasType(p, MEMTYPE_DB) );
20628     assert( sqlcipher3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
20629     assert( db!=0 || sqlcipher3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
20630     return sqlcipher3GlobalConfig.m.xSize(p);
20631   }
20632 }
20633
20634 /*
20635 ** Free memory previously obtained from sqlcipher3Malloc().
20636 */
20637 SQLCIPHER_API void sqlcipher3_free(void *p){
20638   if( p==0 ) return;  /* IMP: R-49053-54554 */
20639   assert( sqlcipher3MemdebugNoType(p, MEMTYPE_DB) );
20640   assert( sqlcipher3MemdebugHasType(p, MEMTYPE_HEAP) );
20641   if( sqlcipher3GlobalConfig.bMemstat ){
20642     sqlcipher3_mutex_enter(mem0.mutex);
20643     sqlcipher3StatusAdd(SQLCIPHER_STATUS_MEMORY_USED, -sqlcipher3MallocSize(p));
20644     sqlcipher3StatusAdd(SQLCIPHER_STATUS_MALLOC_COUNT, -1);
20645     sqlcipher3GlobalConfig.m.xFree(p);
20646     sqlcipher3_mutex_leave(mem0.mutex);
20647   }else{
20648     sqlcipher3GlobalConfig.m.xFree(p);
20649   }
20650 }
20651
20652 /*
20653 ** Free memory that might be associated with a particular database
20654 ** connection.
20655 */
20656 SQLCIPHER_PRIVATE void sqlcipher3DbFree(sqlcipher3 *db, void *p){
20657   assert( db==0 || sqlcipher3_mutex_held(db->mutex) );
20658   if( db ){
20659     if( db->pnBytesFreed ){
20660       *db->pnBytesFreed += sqlcipher3DbMallocSize(db, p);
20661       return;
20662     }
20663     if( isLookaside(db, p) ){
20664       LookasideSlot *pBuf = (LookasideSlot*)p;
20665       pBuf->pNext = db->lookaside.pFree;
20666       db->lookaside.pFree = pBuf;
20667       db->lookaside.nOut--;
20668       return;
20669     }
20670   }
20671   assert( sqlcipher3MemdebugHasType(p, MEMTYPE_DB) );
20672   assert( sqlcipher3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
20673   assert( db!=0 || sqlcipher3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
20674   sqlcipher3MemdebugSetType(p, MEMTYPE_HEAP);
20675   sqlcipher3_free(p);
20676 }
20677
20678 /*
20679 ** Change the size of an existing memory allocation
20680 */
20681 SQLCIPHER_PRIVATE void *sqlcipher3Realloc(void *pOld, int nBytes){
20682   int nOld, nNew, nDiff;
20683   void *pNew;
20684   if( pOld==0 ){
20685     return sqlcipher3Malloc(nBytes); /* IMP: R-28354-25769 */
20686   }
20687   if( nBytes<=0 ){
20688     sqlcipher3_free(pOld); /* IMP: R-31593-10574 */
20689     return 0;
20690   }
20691   if( nBytes>=0x7fffff00 ){
20692     /* The 0x7ffff00 limit term is explained in comments on sqlcipher3Malloc() */
20693     return 0;
20694   }
20695   nOld = sqlcipher3MallocSize(pOld);
20696   /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
20697   ** argument to xRealloc is always a value returned by a prior call to
20698   ** xRoundup. */
20699   nNew = sqlcipher3GlobalConfig.m.xRoundup(nBytes);
20700   if( nOld==nNew ){
20701     pNew = pOld;
20702   }else if( sqlcipher3GlobalConfig.bMemstat ){
20703     sqlcipher3_mutex_enter(mem0.mutex);
20704     sqlcipher3StatusSet(SQLCIPHER_STATUS_MALLOC_SIZE, nBytes);
20705     nDiff = nNew - nOld;
20706     if( sqlcipher3StatusValue(SQLCIPHER_STATUS_MEMORY_USED) >= 
20707           mem0.alarmThreshold-nDiff ){
20708       sqlcipher3MallocAlarm(nDiff);
20709     }
20710     assert( sqlcipher3MemdebugHasType(pOld, MEMTYPE_HEAP) );
20711     assert( sqlcipher3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
20712     pNew = sqlcipher3GlobalConfig.m.xRealloc(pOld, nNew);
20713     if( pNew==0 && mem0.alarmCallback ){
20714       sqlcipher3MallocAlarm(nBytes);
20715       pNew = sqlcipher3GlobalConfig.m.xRealloc(pOld, nNew);
20716     }
20717     if( pNew ){
20718       nNew = sqlcipher3MallocSize(pNew);
20719       sqlcipher3StatusAdd(SQLCIPHER_STATUS_MEMORY_USED, nNew-nOld);
20720     }
20721     sqlcipher3_mutex_leave(mem0.mutex);
20722   }else{
20723     pNew = sqlcipher3GlobalConfig.m.xRealloc(pOld, nNew);
20724   }
20725   assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
20726   return pNew;
20727 }
20728
20729 /*
20730 ** The public interface to sqlcipher3Realloc.  Make sure that the memory
20731 ** subsystem is initialized prior to invoking sqlcipherRealloc.
20732 */
20733 SQLCIPHER_API void *sqlcipher3_realloc(void *pOld, int n){
20734 #ifndef SQLCIPHER_OMIT_AUTOINIT
20735   if( sqlcipher3_initialize() ) return 0;
20736 #endif
20737   return sqlcipher3Realloc(pOld, n);
20738 }
20739
20740
20741 /*
20742 ** Allocate and zero memory.
20743 */ 
20744 SQLCIPHER_PRIVATE void *sqlcipher3MallocZero(int n){
20745   void *p = sqlcipher3Malloc(n);
20746   if( p ){
20747     memset(p, 0, n);
20748   }
20749   return p;
20750 }
20751
20752 /*
20753 ** Allocate and zero memory.  If the allocation fails, make
20754 ** the mallocFailed flag in the connection pointer.
20755 */
20756 SQLCIPHER_PRIVATE void *sqlcipher3DbMallocZero(sqlcipher3 *db, int n){
20757   void *p = sqlcipher3DbMallocRaw(db, n);
20758   if( p ){
20759     memset(p, 0, n);
20760   }
20761   return p;
20762 }
20763
20764 /*
20765 ** Allocate and zero memory.  If the allocation fails, make
20766 ** the mallocFailed flag in the connection pointer.
20767 **
20768 ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
20769 ** failure on the same database connection) then always return 0.
20770 ** Hence for a particular database connection, once malloc starts
20771 ** failing, it fails consistently until mallocFailed is reset.
20772 ** This is an important assumption.  There are many places in the
20773 ** code that do things like this:
20774 **
20775 **         int *a = (int*)sqlcipher3DbMallocRaw(db, 100);
20776 **         int *b = (int*)sqlcipher3DbMallocRaw(db, 200);
20777 **         if( b ) a[10] = 9;
20778 **
20779 ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
20780 ** that all prior mallocs (ex: "a") worked too.
20781 */
20782 SQLCIPHER_PRIVATE void *sqlcipher3DbMallocRaw(sqlcipher3 *db, int n){
20783   void *p;
20784   assert( db==0 || sqlcipher3_mutex_held(db->mutex) );
20785   assert( db==0 || db->pnBytesFreed==0 );
20786 #ifndef SQLCIPHER_OMIT_LOOKASIDE
20787   if( db ){
20788     LookasideSlot *pBuf;
20789     if( db->mallocFailed ){
20790       return 0;
20791     }
20792     if( db->lookaside.bEnabled ){
20793       if( n>db->lookaside.sz ){
20794         db->lookaside.anStat[1]++;
20795       }else if( (pBuf = db->lookaside.pFree)==0 ){
20796         db->lookaside.anStat[2]++;
20797       }else{
20798         db->lookaside.pFree = pBuf->pNext;
20799         db->lookaside.nOut++;
20800         db->lookaside.anStat[0]++;
20801         if( db->lookaside.nOut>db->lookaside.mxOut ){
20802           db->lookaside.mxOut = db->lookaside.nOut;
20803         }
20804         return (void*)pBuf;
20805       }
20806     }
20807   }
20808 #else
20809   if( db && db->mallocFailed ){
20810     return 0;
20811   }
20812 #endif
20813   p = sqlcipher3Malloc(n);
20814   if( !p && db ){
20815     db->mallocFailed = 1;
20816   }
20817   sqlcipher3MemdebugSetType(p, MEMTYPE_DB |
20818          ((db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
20819   return p;
20820 }
20821
20822 /*
20823 ** Resize the block of memory pointed to by p to n bytes. If the
20824 ** resize fails, set the mallocFailed flag in the connection object.
20825 */
20826 SQLCIPHER_PRIVATE void *sqlcipher3DbRealloc(sqlcipher3 *db, void *p, int n){
20827   void *pNew = 0;
20828   assert( db!=0 );
20829   assert( sqlcipher3_mutex_held(db->mutex) );
20830   if( db->mallocFailed==0 ){
20831     if( p==0 ){
20832       return sqlcipher3DbMallocRaw(db, n);
20833     }
20834     if( isLookaside(db, p) ){
20835       if( n<=db->lookaside.sz ){
20836         return p;
20837       }
20838       pNew = sqlcipher3DbMallocRaw(db, n);
20839       if( pNew ){
20840         memcpy(pNew, p, db->lookaside.sz);
20841         sqlcipher3DbFree(db, p);
20842       }
20843     }else{
20844       assert( sqlcipher3MemdebugHasType(p, MEMTYPE_DB) );
20845       assert( sqlcipher3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
20846       sqlcipher3MemdebugSetType(p, MEMTYPE_HEAP);
20847       pNew = sqlcipher3_realloc(p, n);
20848       if( !pNew ){
20849         sqlcipher3MemdebugSetType(p, MEMTYPE_DB|MEMTYPE_HEAP);
20850         db->mallocFailed = 1;
20851       }
20852       sqlcipher3MemdebugSetType(pNew, MEMTYPE_DB | 
20853             (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
20854     }
20855   }
20856   return pNew;
20857 }
20858
20859 /*
20860 ** Attempt to reallocate p.  If the reallocation fails, then free p
20861 ** and set the mallocFailed flag in the database connection.
20862 */
20863 SQLCIPHER_PRIVATE void *sqlcipher3DbReallocOrFree(sqlcipher3 *db, void *p, int n){
20864   void *pNew;
20865   pNew = sqlcipher3DbRealloc(db, p, n);
20866   if( !pNew ){
20867     sqlcipher3DbFree(db, p);
20868   }
20869   return pNew;
20870 }
20871
20872 /*
20873 ** Make a copy of a string in memory obtained from sqlcipherMalloc(). These 
20874 ** functions call sqlcipher3MallocRaw() directly instead of sqlcipherMalloc(). This
20875 ** is because when memory debugging is turned on, these two functions are 
20876 ** called via macros that record the current file and line number in the
20877 ** ThreadData structure.
20878 */
20879 SQLCIPHER_PRIVATE char *sqlcipher3DbStrDup(sqlcipher3 *db, const char *z){
20880   char *zNew;
20881   size_t n;
20882   if( z==0 ){
20883     return 0;
20884   }
20885   n = sqlcipher3Strlen30(z) + 1;
20886   assert( (n&0x7fffffff)==n );
20887   zNew = sqlcipher3DbMallocRaw(db, (int)n);
20888   if( zNew ){
20889     memcpy(zNew, z, n);
20890   }
20891   return zNew;
20892 }
20893 SQLCIPHER_PRIVATE char *sqlcipher3DbStrNDup(sqlcipher3 *db, const char *z, int n){
20894   char *zNew;
20895   if( z==0 ){
20896     return 0;
20897   }
20898   assert( (n&0x7fffffff)==n );
20899   zNew = sqlcipher3DbMallocRaw(db, n+1);
20900   if( zNew ){
20901     memcpy(zNew, z, n);
20902     zNew[n] = 0;
20903   }
20904   return zNew;
20905 }
20906
20907 /*
20908 ** Create a string from the zFromat argument and the va_list that follows.
20909 ** Store the string in memory obtained from sqlcipherMalloc() and make *pz
20910 ** point to that string.
20911 */
20912 SQLCIPHER_PRIVATE void sqlcipher3SetString(char **pz, sqlcipher3 *db, const char *zFormat, ...){
20913   va_list ap;
20914   char *z;
20915
20916   va_start(ap, zFormat);
20917   z = sqlcipher3VMPrintf(db, zFormat, ap);
20918   va_end(ap);
20919   sqlcipher3DbFree(db, *pz);
20920   *pz = z;
20921 }
20922
20923
20924 /*
20925 ** This function must be called before exiting any API function (i.e. 
20926 ** returning control to the user) that has called sqlcipher3_malloc or
20927 ** sqlcipher3_realloc.
20928 **
20929 ** The returned value is normally a copy of the second argument to this
20930 ** function. However, if a malloc() failure has occurred since the previous
20931 ** invocation SQLCIPHER_NOMEM is returned instead. 
20932 **
20933 ** If the first argument, db, is not NULL and a malloc() error has occurred,
20934 ** then the connection error-code (the value returned by sqlcipher3_errcode())
20935 ** is set to SQLCIPHER_NOMEM.
20936 */
20937 SQLCIPHER_PRIVATE int sqlcipher3ApiExit(sqlcipher3* db, int rc){
20938   /* If the db handle is not NULL, then we must hold the connection handle
20939   ** mutex here. Otherwise the read (and possible write) of db->mallocFailed 
20940   ** is unsafe, as is the call to sqlcipher3Error().
20941   */
20942   assert( !db || sqlcipher3_mutex_held(db->mutex) );
20943   if( db && (db->mallocFailed || rc==SQLCIPHER_IOERR_NOMEM) ){
20944     sqlcipher3Error(db, SQLCIPHER_NOMEM, 0);
20945     db->mallocFailed = 0;
20946     rc = SQLCIPHER_NOMEM;
20947   }
20948   return rc & (db ? db->errMask : 0xff);
20949 }
20950
20951 /************** End of malloc.c **********************************************/
20952 /************** Begin file printf.c ******************************************/
20953 /*
20954 ** The "printf" code that follows dates from the 1980's.  It is in
20955 ** the public domain.  The original comments are included here for
20956 ** completeness.  They are very out-of-date but might be useful as
20957 ** an historical reference.  Most of the "enhancements" have been backed
20958 ** out so that the functionality is now the same as standard printf().
20959 **
20960 **************************************************************************
20961 **
20962 ** This file contains code for a set of "printf"-like routines.  These
20963 ** routines format strings much like the printf() from the standard C
20964 ** library, though the implementation here has enhancements to support
20965 ** SQLlite.
20966 */
20967
20968 /*
20969 ** Conversion types fall into various categories as defined by the
20970 ** following enumeration.
20971 */
20972 #define etRADIX       1 /* Integer types.  %d, %x, %o, and so forth */
20973 #define etFLOAT       2 /* Floating point.  %f */
20974 #define etEXP         3 /* Exponentional notation. %e and %E */
20975 #define etGENERIC     4 /* Floating or exponential, depending on exponent. %g */
20976 #define etSIZE        5 /* Return number of characters processed so far. %n */
20977 #define etSTRING      6 /* Strings. %s */
20978 #define etDYNSTRING   7 /* Dynamically allocated strings. %z */
20979 #define etPERCENT     8 /* Percent symbol. %% */
20980 #define etCHARX       9 /* Characters. %c */
20981 /* The rest are extensions, not normally found in printf() */
20982 #define etSQLESCAPE  10 /* Strings with '\'' doubled.  %q */
20983 #define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '',
20984                           NULL pointers replaced by SQL NULL.  %Q */
20985 #define etTOKEN      12 /* a pointer to a Token structure */
20986 #define etSRCLIST    13 /* a pointer to a SrcList */
20987 #define etPOINTER    14 /* The %p conversion */
20988 #define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */
20989 #define etORDINAL    16 /* %r -> 1st, 2nd, 3rd, 4th, etc.  English only */
20990
20991 #define etINVALID     0 /* Any unrecognized conversion type */
20992
20993
20994 /*
20995 ** An "etByte" is an 8-bit unsigned value.
20996 */
20997 typedef unsigned char etByte;
20998
20999 /*
21000 ** Each builtin conversion character (ex: the 'd' in "%d") is described
21001 ** by an instance of the following structure
21002 */
21003 typedef struct et_info {   /* Information about each format field */
21004   char fmttype;            /* The format field code letter */
21005   etByte base;             /* The base for radix conversion */
21006   etByte flags;            /* One or more of FLAG_ constants below */
21007   etByte type;             /* Conversion paradigm */
21008   etByte charset;          /* Offset into aDigits[] of the digits string */
21009   etByte prefix;           /* Offset into aPrefix[] of the prefix string */
21010 } et_info;
21011
21012 /*
21013 ** Allowed values for et_info.flags
21014 */
21015 #define FLAG_SIGNED  1     /* True if the value to convert is signed */
21016 #define FLAG_INTERN  2     /* True if for internal use only */
21017 #define FLAG_STRING  4     /* Allow infinity precision */
21018
21019
21020 /*
21021 ** The following table is searched linearly, so it is good to put the
21022 ** most frequently used conversion types first.
21023 */
21024 static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
21025 static const char aPrefix[] = "-x0\000X0";
21026 static const et_info fmtinfo[] = {
21027   {  'd', 10, 1, etRADIX,      0,  0 },
21028   {  's',  0, 4, etSTRING,     0,  0 },
21029   {  'g',  0, 1, etGENERIC,    30, 0 },
21030   {  'z',  0, 4, etDYNSTRING,  0,  0 },
21031   {  'q',  0, 4, etSQLESCAPE,  0,  0 },
21032   {  'Q',  0, 4, etSQLESCAPE2, 0,  0 },
21033   {  'w',  0, 4, etSQLESCAPE3, 0,  0 },
21034   {  'c',  0, 0, etCHARX,      0,  0 },
21035   {  'o',  8, 0, etRADIX,      0,  2 },
21036   {  'u', 10, 0, etRADIX,      0,  0 },
21037   {  'x', 16, 0, etRADIX,      16, 1 },
21038   {  'X', 16, 0, etRADIX,      0,  4 },
21039 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
21040   {  'f',  0, 1, etFLOAT,      0,  0 },
21041   {  'e',  0, 1, etEXP,        30, 0 },
21042   {  'E',  0, 1, etEXP,        14, 0 },
21043   {  'G',  0, 1, etGENERIC,    14, 0 },
21044 #endif
21045   {  'i', 10, 1, etRADIX,      0,  0 },
21046   {  'n',  0, 0, etSIZE,       0,  0 },
21047   {  '%',  0, 0, etPERCENT,    0,  0 },
21048   {  'p', 16, 0, etPOINTER,    0,  1 },
21049
21050 /* All the rest have the FLAG_INTERN bit set and are thus for internal
21051 ** use only */
21052   {  'T',  0, 2, etTOKEN,      0,  0 },
21053   {  'S',  0, 2, etSRCLIST,    0,  0 },
21054   {  'r', 10, 3, etORDINAL,    0,  0 },
21055 };
21056
21057 /*
21058 ** If SQLCIPHER_OMIT_FLOATING_POINT is defined, then none of the floating point
21059 ** conversions will work.
21060 */
21061 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
21062 /*
21063 ** "*val" is a double such that 0.1 <= *val < 10.0
21064 ** Return the ascii code for the leading digit of *val, then
21065 ** multiply "*val" by 10.0 to renormalize.
21066 **
21067 ** Example:
21068 **     input:     *val = 3.14159
21069 **     output:    *val = 1.4159    function return = '3'
21070 **
21071 ** The counter *cnt is incremented each time.  After counter exceeds
21072 ** 16 (the number of significant digits in a 64-bit float) '0' is
21073 ** always returned.
21074 */
21075 static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
21076   int digit;
21077   LONGDOUBLE_TYPE d;
21078   if( (*cnt)++ >= 16 ) return '0';
21079   digit = (int)*val;
21080   d = digit;
21081   digit += '0';
21082   *val = (*val - d)*10.0;
21083   return (char)digit;
21084 }
21085 #endif /* SQLCIPHER_OMIT_FLOATING_POINT */
21086
21087 /*
21088 ** Append N space characters to the given string buffer.
21089 */
21090 static void appendSpace(StrAccum *pAccum, int N){
21091   static const char zSpaces[] = "                             ";
21092   while( N>=(int)sizeof(zSpaces)-1 ){
21093     sqlcipher3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
21094     N -= sizeof(zSpaces)-1;
21095   }
21096   if( N>0 ){
21097     sqlcipher3StrAccumAppend(pAccum, zSpaces, N);
21098   }
21099 }
21100
21101 /*
21102 ** On machines with a small stack size, you can redefine the
21103 ** SQLCIPHER_PRINT_BUF_SIZE to be something smaller, if desired.
21104 */
21105 #ifndef SQLCIPHER_PRINT_BUF_SIZE
21106 # define SQLCIPHER_PRINT_BUF_SIZE 70
21107 #endif
21108 #define etBUFSIZE SQLCIPHER_PRINT_BUF_SIZE  /* Size of the output buffer */
21109
21110 /*
21111 ** Render a string given by "fmt" into the StrAccum object.
21112 */
21113 SQLCIPHER_PRIVATE void sqlcipher3VXPrintf(
21114   StrAccum *pAccum,                  /* Accumulate results here */
21115   int useExtended,                   /* Allow extended %-conversions */
21116   const char *fmt,                   /* Format string */
21117   va_list ap                         /* arguments */
21118 ){
21119   int c;                     /* Next character in the format string */
21120   char *bufpt;               /* Pointer to the conversion buffer */
21121   int precision;             /* Precision of the current field */
21122   int length;                /* Length of the field */
21123   int idx;                   /* A general purpose loop counter */
21124   int width;                 /* Width of the current field */
21125   etByte flag_leftjustify;   /* True if "-" flag is present */
21126   etByte flag_plussign;      /* True if "+" flag is present */
21127   etByte flag_blanksign;     /* True if " " flag is present */
21128   etByte flag_alternateform; /* True if "#" flag is present */
21129   etByte flag_altform2;      /* True if "!" flag is present */
21130   etByte flag_zeropad;       /* True if field width constant starts with zero */
21131   etByte flag_long;          /* True if "l" flag is present */
21132   etByte flag_longlong;      /* True if the "ll" flag is present */
21133   etByte done;               /* Loop termination flag */
21134   etByte xtype = 0;          /* Conversion paradigm */
21135   char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
21136   sqlcipher_uint64 longvalue;   /* Value for integer types */
21137   LONGDOUBLE_TYPE realvalue; /* Value for real types */
21138   const et_info *infop;      /* Pointer to the appropriate info structure */
21139   char *zOut;                /* Rendering buffer */
21140   int nOut;                  /* Size of the rendering buffer */
21141   char *zExtra;              /* Malloced memory used by some conversion */
21142 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
21143   int  exp, e2;              /* exponent of real numbers */
21144   int nsd;                   /* Number of significant digits returned */
21145   double rounder;            /* Used for rounding floating point values */
21146   etByte flag_dp;            /* True if decimal point should be shown */
21147   etByte flag_rtz;           /* True if trailing zeros should be removed */
21148 #endif
21149   char buf[etBUFSIZE];       /* Conversion buffer */
21150
21151   bufpt = 0;
21152   for(; (c=(*fmt))!=0; ++fmt){
21153     if( c!='%' ){
21154       int amt;
21155       bufpt = (char *)fmt;
21156       amt = 1;
21157       while( (c=(*++fmt))!='%' && c!=0 ) amt++;
21158       sqlcipher3StrAccumAppend(pAccum, bufpt, amt);
21159       if( c==0 ) break;
21160     }
21161     if( (c=(*++fmt))==0 ){
21162       sqlcipher3StrAccumAppend(pAccum, "%", 1);
21163       break;
21164     }
21165     /* Find out what flags are present */
21166     flag_leftjustify = flag_plussign = flag_blanksign = 
21167      flag_alternateform = flag_altform2 = flag_zeropad = 0;
21168     done = 0;
21169     do{
21170       switch( c ){
21171         case '-':   flag_leftjustify = 1;     break;
21172         case '+':   flag_plussign = 1;        break;
21173         case ' ':   flag_blanksign = 1;       break;
21174         case '#':   flag_alternateform = 1;   break;
21175         case '!':   flag_altform2 = 1;        break;
21176         case '0':   flag_zeropad = 1;         break;
21177         default:    done = 1;                 break;
21178       }
21179     }while( !done && (c=(*++fmt))!=0 );
21180     /* Get the field width */
21181     width = 0;
21182     if( c=='*' ){
21183       width = va_arg(ap,int);
21184       if( width<0 ){
21185         flag_leftjustify = 1;
21186         width = -width;
21187       }
21188       c = *++fmt;
21189     }else{
21190       while( c>='0' && c<='9' ){
21191         width = width*10 + c - '0';
21192         c = *++fmt;
21193       }
21194     }
21195     /* Get the precision */
21196     if( c=='.' ){
21197       precision = 0;
21198       c = *++fmt;
21199       if( c=='*' ){
21200         precision = va_arg(ap,int);
21201         if( precision<0 ) precision = -precision;
21202         c = *++fmt;
21203       }else{
21204         while( c>='0' && c<='9' ){
21205           precision = precision*10 + c - '0';
21206           c = *++fmt;
21207         }
21208       }
21209     }else{
21210       precision = -1;
21211     }
21212     /* Get the conversion type modifier */
21213     if( c=='l' ){
21214       flag_long = 1;
21215       c = *++fmt;
21216       if( c=='l' ){
21217         flag_longlong = 1;
21218         c = *++fmt;
21219       }else{
21220         flag_longlong = 0;
21221       }
21222     }else{
21223       flag_long = flag_longlong = 0;
21224     }
21225     /* Fetch the info entry for the field */
21226     infop = &fmtinfo[0];
21227     xtype = etINVALID;
21228     for(idx=0; idx<ArraySize(fmtinfo); idx++){
21229       if( c==fmtinfo[idx].fmttype ){
21230         infop = &fmtinfo[idx];
21231         if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
21232           xtype = infop->type;
21233         }else{
21234           return;
21235         }
21236         break;
21237       }
21238     }
21239     zExtra = 0;
21240
21241     /*
21242     ** At this point, variables are initialized as follows:
21243     **
21244     **   flag_alternateform          TRUE if a '#' is present.
21245     **   flag_altform2               TRUE if a '!' is present.
21246     **   flag_plussign               TRUE if a '+' is present.
21247     **   flag_leftjustify            TRUE if a '-' is present or if the
21248     **                               field width was negative.
21249     **   flag_zeropad                TRUE if the width began with 0.
21250     **   flag_long                   TRUE if the letter 'l' (ell) prefixed
21251     **                               the conversion character.
21252     **   flag_longlong               TRUE if the letter 'll' (ell ell) prefixed
21253     **                               the conversion character.
21254     **   flag_blanksign              TRUE if a ' ' is present.
21255     **   width                       The specified field width.  This is
21256     **                               always non-negative.  Zero is the default.
21257     **   precision                   The specified precision.  The default
21258     **                               is -1.
21259     **   xtype                       The class of the conversion.
21260     **   infop                       Pointer to the appropriate info struct.
21261     */
21262     switch( xtype ){
21263       case etPOINTER:
21264         flag_longlong = sizeof(char*)==sizeof(i64);
21265         flag_long = sizeof(char*)==sizeof(long int);
21266         /* Fall through into the next case */
21267       case etORDINAL:
21268       case etRADIX:
21269         if( infop->flags & FLAG_SIGNED ){
21270           i64 v;
21271           if( flag_longlong ){
21272             v = va_arg(ap,i64);
21273           }else if( flag_long ){
21274             v = va_arg(ap,long int);
21275           }else{
21276             v = va_arg(ap,int);
21277           }
21278           if( v<0 ){
21279             if( v==SMALLEST_INT64 ){
21280               longvalue = ((u64)1)<<63;
21281             }else{
21282               longvalue = -v;
21283             }
21284             prefix = '-';
21285           }else{
21286             longvalue = v;
21287             if( flag_plussign )        prefix = '+';
21288             else if( flag_blanksign )  prefix = ' ';
21289             else                       prefix = 0;
21290           }
21291         }else{
21292           if( flag_longlong ){
21293             longvalue = va_arg(ap,u64);
21294           }else if( flag_long ){
21295             longvalue = va_arg(ap,unsigned long int);
21296           }else{
21297             longvalue = va_arg(ap,unsigned int);
21298           }
21299           prefix = 0;
21300         }
21301         if( longvalue==0 ) flag_alternateform = 0;
21302         if( flag_zeropad && precision<width-(prefix!=0) ){
21303           precision = width-(prefix!=0);
21304         }
21305         if( precision<etBUFSIZE-10 ){
21306           nOut = etBUFSIZE;
21307           zOut = buf;
21308         }else{
21309           nOut = precision + 10;
21310           zOut = zExtra = sqlcipher3Malloc( nOut );
21311           if( zOut==0 ){
21312             pAccum->mallocFailed = 1;
21313             return;
21314           }
21315         }
21316         bufpt = &zOut[nOut-1];
21317         if( xtype==etORDINAL ){
21318           static const char zOrd[] = "thstndrd";
21319           int x = (int)(longvalue % 10);
21320           if( x>=4 || (longvalue/10)%10==1 ){
21321             x = 0;
21322           }
21323           *(--bufpt) = zOrd[x*2+1];
21324           *(--bufpt) = zOrd[x*2];
21325         }
21326         {
21327           register const char *cset;      /* Use registers for speed */
21328           register int base;
21329           cset = &aDigits[infop->charset];
21330           base = infop->base;
21331           do{                                           /* Convert to ascii */
21332             *(--bufpt) = cset[longvalue%base];
21333             longvalue = longvalue/base;
21334           }while( longvalue>0 );
21335         }
21336         length = (int)(&zOut[nOut-1]-bufpt);
21337         for(idx=precision-length; idx>0; idx--){
21338           *(--bufpt) = '0';                             /* Zero pad */
21339         }
21340         if( prefix ) *(--bufpt) = prefix;               /* Add sign */
21341         if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
21342           const char *pre;
21343           char x;
21344           pre = &aPrefix[infop->prefix];
21345           for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
21346         }
21347         length = (int)(&zOut[nOut-1]-bufpt);
21348         break;
21349       case etFLOAT:
21350       case etEXP:
21351       case etGENERIC:
21352         realvalue = va_arg(ap,double);
21353 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
21354         length = 0;
21355 #else
21356         if( precision<0 ) precision = 6;         /* Set default precision */
21357         if( realvalue<0.0 ){
21358           realvalue = -realvalue;
21359           prefix = '-';
21360         }else{
21361           if( flag_plussign )          prefix = '+';
21362           else if( flag_blanksign )    prefix = ' ';
21363           else                         prefix = 0;
21364         }
21365         if( xtype==etGENERIC && precision>0 ) precision--;
21366 #if 0
21367         /* Rounding works like BSD when the constant 0.4999 is used.  Wierd! */
21368         for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
21369 #else
21370         /* It makes more sense to use 0.5 */
21371         for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
21372 #endif
21373         if( xtype==etFLOAT ) realvalue += rounder;
21374         /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
21375         exp = 0;
21376         if( sqlcipher3IsNaN((double)realvalue) ){
21377           bufpt = "NaN";
21378           length = 3;
21379           break;
21380         }
21381         if( realvalue>0.0 ){
21382           while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }
21383           while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
21384           while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
21385           while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
21386           while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
21387           if( exp>350 ){
21388             if( prefix=='-' ){
21389               bufpt = "-Inf";
21390             }else if( prefix=='+' ){
21391               bufpt = "+Inf";
21392             }else{
21393               bufpt = "Inf";
21394             }
21395             length = sqlcipher3Strlen30(bufpt);
21396             break;
21397           }
21398         }
21399         bufpt = buf;
21400         /*
21401         ** If the field type is etGENERIC, then convert to either etEXP
21402         ** or etFLOAT, as appropriate.
21403         */
21404         if( xtype!=etFLOAT ){
21405           realvalue += rounder;
21406           if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
21407         }
21408         if( xtype==etGENERIC ){
21409           flag_rtz = !flag_alternateform;
21410           if( exp<-4 || exp>precision ){
21411             xtype = etEXP;
21412           }else{
21413             precision = precision - exp;
21414             xtype = etFLOAT;
21415           }
21416         }else{
21417           flag_rtz = 0;
21418         }
21419         if( xtype==etEXP ){
21420           e2 = 0;
21421         }else{
21422           e2 = exp;
21423         }
21424         if( e2+precision+width > etBUFSIZE - 15 ){
21425           bufpt = zExtra = sqlcipher3Malloc( e2+precision+width+15 );
21426           if( bufpt==0 ){
21427             pAccum->mallocFailed = 1;
21428             return;
21429           }
21430         }
21431         zOut = bufpt;
21432         nsd = 0;
21433         flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
21434         /* The sign in front of the number */
21435         if( prefix ){
21436           *(bufpt++) = prefix;
21437         }
21438         /* Digits prior to the decimal point */
21439         if( e2<0 ){
21440           *(bufpt++) = '0';
21441         }else{
21442           for(; e2>=0; e2--){
21443             *(bufpt++) = et_getdigit(&realvalue,&nsd);
21444           }
21445         }
21446         /* The decimal point */
21447         if( flag_dp ){
21448           *(bufpt++) = '.';
21449         }
21450         /* "0" digits after the decimal point but before the first
21451         ** significant digit of the number */
21452         for(e2++; e2<0; precision--, e2++){
21453           assert( precision>0 );
21454           *(bufpt++) = '0';
21455         }
21456         /* Significant digits after the decimal point */
21457         while( (precision--)>0 ){
21458           *(bufpt++) = et_getdigit(&realvalue,&nsd);
21459         }
21460         /* Remove trailing zeros and the "." if no digits follow the "." */
21461         if( flag_rtz && flag_dp ){
21462           while( bufpt[-1]=='0' ) *(--bufpt) = 0;
21463           assert( bufpt>zOut );
21464           if( bufpt[-1]=='.' ){
21465             if( flag_altform2 ){
21466               *(bufpt++) = '0';
21467             }else{
21468               *(--bufpt) = 0;
21469             }
21470           }
21471         }
21472         /* Add the "eNNN" suffix */
21473         if( xtype==etEXP ){
21474           *(bufpt++) = aDigits[infop->charset];
21475           if( exp<0 ){
21476             *(bufpt++) = '-'; exp = -exp;
21477           }else{
21478             *(bufpt++) = '+';
21479           }
21480           if( exp>=100 ){
21481             *(bufpt++) = (char)((exp/100)+'0');        /* 100's digit */
21482             exp %= 100;
21483           }
21484           *(bufpt++) = (char)(exp/10+'0');             /* 10's digit */
21485           *(bufpt++) = (char)(exp%10+'0');             /* 1's digit */
21486         }
21487         *bufpt = 0;
21488
21489         /* The converted number is in buf[] and zero terminated. Output it.
21490         ** Note that the number is in the usual order, not reversed as with
21491         ** integer conversions. */
21492         length = (int)(bufpt-zOut);
21493         bufpt = zOut;
21494
21495         /* Special case:  Add leading zeros if the flag_zeropad flag is
21496         ** set and we are not left justified */
21497         if( flag_zeropad && !flag_leftjustify && length < width){
21498           int i;
21499           int nPad = width - length;
21500           for(i=width; i>=nPad; i--){
21501             bufpt[i] = bufpt[i-nPad];
21502           }
21503           i = prefix!=0;
21504           while( nPad-- ) bufpt[i++] = '0';
21505           length = width;
21506         }
21507 #endif /* !defined(SQLCIPHER_OMIT_FLOATING_POINT) */
21508         break;
21509       case etSIZE:
21510         *(va_arg(ap,int*)) = pAccum->nChar;
21511         length = width = 0;
21512         break;
21513       case etPERCENT:
21514         buf[0] = '%';
21515         bufpt = buf;
21516         length = 1;
21517         break;
21518       case etCHARX:
21519         c = va_arg(ap,int);
21520         buf[0] = (char)c;
21521         if( precision>=0 ){
21522           for(idx=1; idx<precision; idx++) buf[idx] = (char)c;
21523           length = precision;
21524         }else{
21525           length =1;
21526         }
21527         bufpt = buf;
21528         break;
21529       case etSTRING:
21530       case etDYNSTRING:
21531         bufpt = va_arg(ap,char*);
21532         if( bufpt==0 ){
21533           bufpt = "";
21534         }else if( xtype==etDYNSTRING ){
21535           zExtra = bufpt;
21536         }
21537         if( precision>=0 ){
21538           for(length=0; length<precision && bufpt[length]; length++){}
21539         }else{
21540           length = sqlcipher3Strlen30(bufpt);
21541         }
21542         break;
21543       case etSQLESCAPE:
21544       case etSQLESCAPE2:
21545       case etSQLESCAPE3: {
21546         int i, j, k, n, isnull;
21547         int needQuote;
21548         char ch;
21549         char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
21550         char *escarg = va_arg(ap,char*);
21551         isnull = escarg==0;
21552         if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
21553         k = precision;
21554         for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
21555           if( ch==q )  n++;
21556         }
21557         needQuote = !isnull && xtype==etSQLESCAPE2;
21558         n += i + 1 + needQuote*2;
21559         if( n>etBUFSIZE ){
21560           bufpt = zExtra = sqlcipher3Malloc( n );
21561           if( bufpt==0 ){
21562             pAccum->mallocFailed = 1;
21563             return;
21564           }
21565         }else{
21566           bufpt = buf;
21567         }
21568         j = 0;
21569         if( needQuote ) bufpt[j++] = q;
21570         k = i;
21571         for(i=0; i<k; i++){
21572           bufpt[j++] = ch = escarg[i];
21573           if( ch==q ) bufpt[j++] = ch;
21574         }
21575         if( needQuote ) bufpt[j++] = q;
21576         bufpt[j] = 0;
21577         length = j;
21578         /* The precision in %q and %Q means how many input characters to
21579         ** consume, not the length of the output...
21580         ** if( precision>=0 && precision<length ) length = precision; */
21581         break;
21582       }
21583       case etTOKEN: {
21584         Token *pToken = va_arg(ap, Token*);
21585         if( pToken ){
21586           sqlcipher3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
21587         }
21588         length = width = 0;
21589         break;
21590       }
21591       case etSRCLIST: {
21592         SrcList *pSrc = va_arg(ap, SrcList*);
21593         int k = va_arg(ap, int);
21594         struct SrcList_item *pItem = &pSrc->a[k];
21595         assert( k>=0 && k<pSrc->nSrc );
21596         if( pItem->zDatabase ){
21597           sqlcipher3StrAccumAppend(pAccum, pItem->zDatabase, -1);
21598           sqlcipher3StrAccumAppend(pAccum, ".", 1);
21599         }
21600         sqlcipher3StrAccumAppend(pAccum, pItem->zName, -1);
21601         length = width = 0;
21602         break;
21603       }
21604       default: {
21605         assert( xtype==etINVALID );
21606         return;
21607       }
21608     }/* End switch over the format type */
21609     /*
21610     ** The text of the conversion is pointed to by "bufpt" and is
21611     ** "length" characters long.  The field width is "width".  Do
21612     ** the output.
21613     */
21614     if( !flag_leftjustify ){
21615       register int nspace;
21616       nspace = width-length;
21617       if( nspace>0 ){
21618         appendSpace(pAccum, nspace);
21619       }
21620     }
21621     if( length>0 ){
21622       sqlcipher3StrAccumAppend(pAccum, bufpt, length);
21623     }
21624     if( flag_leftjustify ){
21625       register int nspace;
21626       nspace = width-length;
21627       if( nspace>0 ){
21628         appendSpace(pAccum, nspace);
21629       }
21630     }
21631     sqlcipher3_free(zExtra);
21632   }/* End for loop over the format string */
21633 } /* End of function */
21634
21635 /*
21636 ** Append N bytes of text from z to the StrAccum object.
21637 */
21638 SQLCIPHER_PRIVATE void sqlcipher3StrAccumAppend(StrAccum *p, const char *z, int N){
21639   assert( z!=0 || N==0 );
21640   if( p->tooBig | p->mallocFailed ){
21641     testcase(p->tooBig);
21642     testcase(p->mallocFailed);
21643     return;
21644   }
21645   assert( p->zText!=0 || p->nChar==0 );
21646   if( N<0 ){
21647     N = sqlcipher3Strlen30(z);
21648   }
21649   if( N==0 || NEVER(z==0) ){
21650     return;
21651   }
21652   if( p->nChar+N >= p->nAlloc ){
21653     char *zNew;
21654     if( !p->useMalloc ){
21655       p->tooBig = 1;
21656       N = p->nAlloc - p->nChar - 1;
21657       if( N<=0 ){
21658         return;
21659       }
21660     }else{
21661       char *zOld = (p->zText==p->zBase ? 0 : p->zText);
21662       i64 szNew = p->nChar;
21663       szNew += N + 1;
21664       if( szNew > p->mxAlloc ){
21665         sqlcipher3StrAccumReset(p);
21666         p->tooBig = 1;
21667         return;
21668       }else{
21669         p->nAlloc = (int)szNew;
21670       }
21671       if( p->useMalloc==1 ){
21672         zNew = sqlcipher3DbRealloc(p->db, zOld, p->nAlloc);
21673       }else{
21674         zNew = sqlcipher3_realloc(zOld, p->nAlloc);
21675       }
21676       if( zNew ){
21677         if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
21678         p->zText = zNew;
21679       }else{
21680         p->mallocFailed = 1;
21681         sqlcipher3StrAccumReset(p);
21682         return;
21683       }
21684     }
21685   }
21686   assert( p->zText );
21687   memcpy(&p->zText[p->nChar], z, N);
21688   p->nChar += N;
21689 }
21690
21691 /*
21692 ** Finish off a string by making sure it is zero-terminated.
21693 ** Return a pointer to the resulting string.  Return a NULL
21694 ** pointer if any kind of error was encountered.
21695 */
21696 SQLCIPHER_PRIVATE char *sqlcipher3StrAccumFinish(StrAccum *p){
21697   if( p->zText ){
21698     p->zText[p->nChar] = 0;
21699     if( p->useMalloc && p->zText==p->zBase ){
21700       if( p->useMalloc==1 ){
21701         p->zText = sqlcipher3DbMallocRaw(p->db, p->nChar+1 );
21702       }else{
21703         p->zText = sqlcipher3_malloc(p->nChar+1);
21704       }
21705       if( p->zText ){
21706         memcpy(p->zText, p->zBase, p->nChar+1);
21707       }else{
21708         p->mallocFailed = 1;
21709       }
21710     }
21711   }
21712   return p->zText;
21713 }
21714
21715 /*
21716 ** Reset an StrAccum string.  Reclaim all malloced memory.
21717 */
21718 SQLCIPHER_PRIVATE void sqlcipher3StrAccumReset(StrAccum *p){
21719   if( p->zText!=p->zBase ){
21720     if( p->useMalloc==1 ){
21721       sqlcipher3DbFree(p->db, p->zText);
21722     }else{
21723       sqlcipher3_free(p->zText);
21724     }
21725   }
21726   p->zText = 0;
21727 }
21728
21729 /*
21730 ** Initialize a string accumulator
21731 */
21732 SQLCIPHER_PRIVATE void sqlcipher3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
21733   p->zText = p->zBase = zBase;
21734   p->db = 0;
21735   p->nChar = 0;
21736   p->nAlloc = n;
21737   p->mxAlloc = mx;
21738   p->useMalloc = 1;
21739   p->tooBig = 0;
21740   p->mallocFailed = 0;
21741 }
21742
21743 /*
21744 ** Print into memory obtained from sqlcipherMalloc().  Use the internal
21745 ** %-conversion extensions.
21746 */
21747 SQLCIPHER_PRIVATE char *sqlcipher3VMPrintf(sqlcipher3 *db, const char *zFormat, va_list ap){
21748   char *z;
21749   char zBase[SQLCIPHER_PRINT_BUF_SIZE];
21750   StrAccum acc;
21751   assert( db!=0 );
21752   sqlcipher3StrAccumInit(&acc, zBase, sizeof(zBase),
21753                       db->aLimit[SQLCIPHER_LIMIT_LENGTH]);
21754   acc.db = db;
21755   sqlcipher3VXPrintf(&acc, 1, zFormat, ap);
21756   z = sqlcipher3StrAccumFinish(&acc);
21757   if( acc.mallocFailed ){
21758     db->mallocFailed = 1;
21759   }
21760   return z;
21761 }
21762
21763 /*
21764 ** Print into memory obtained from sqlcipherMalloc().  Use the internal
21765 ** %-conversion extensions.
21766 */
21767 SQLCIPHER_PRIVATE char *sqlcipher3MPrintf(sqlcipher3 *db, const char *zFormat, ...){
21768   va_list ap;
21769   char *z;
21770   va_start(ap, zFormat);
21771   z = sqlcipher3VMPrintf(db, zFormat, ap);
21772   va_end(ap);
21773   return z;
21774 }
21775
21776 /*
21777 ** Like sqlcipher3MPrintf(), but call sqlcipher3DbFree() on zStr after formatting
21778 ** the string and before returnning.  This routine is intended to be used
21779 ** to modify an existing string.  For example:
21780 **
21781 **       x = sqlcipher3MPrintf(db, x, "prefix %s suffix", x);
21782 **
21783 */
21784 SQLCIPHER_PRIVATE char *sqlcipher3MAppendf(sqlcipher3 *db, char *zStr, const char *zFormat, ...){
21785   va_list ap;
21786   char *z;
21787   va_start(ap, zFormat);
21788   z = sqlcipher3VMPrintf(db, zFormat, ap);
21789   va_end(ap);
21790   sqlcipher3DbFree(db, zStr);
21791   return z;
21792 }
21793
21794 /*
21795 ** Print into memory obtained from sqlcipher3_malloc().  Omit the internal
21796 ** %-conversion extensions.
21797 */
21798 SQLCIPHER_API char *sqlcipher3_vmprintf(const char *zFormat, va_list ap){
21799   char *z;
21800   char zBase[SQLCIPHER_PRINT_BUF_SIZE];
21801   StrAccum acc;
21802 #ifndef SQLCIPHER_OMIT_AUTOINIT
21803   if( sqlcipher3_initialize() ) return 0;
21804 #endif
21805   sqlcipher3StrAccumInit(&acc, zBase, sizeof(zBase), SQLCIPHER_MAX_LENGTH);
21806   acc.useMalloc = 2;
21807   sqlcipher3VXPrintf(&acc, 0, zFormat, ap);
21808   z = sqlcipher3StrAccumFinish(&acc);
21809   return z;
21810 }
21811
21812 /*
21813 ** Print into memory obtained from sqlcipher3_malloc()().  Omit the internal
21814 ** %-conversion extensions.
21815 */
21816 SQLCIPHER_API char *sqlcipher3_mprintf(const char *zFormat, ...){
21817   va_list ap;
21818   char *z;
21819 #ifndef SQLCIPHER_OMIT_AUTOINIT
21820   if( sqlcipher3_initialize() ) return 0;
21821 #endif
21822   va_start(ap, zFormat);
21823   z = sqlcipher3_vmprintf(zFormat, ap);
21824   va_end(ap);
21825   return z;
21826 }
21827
21828 /*
21829 ** sqlcipher3_snprintf() works like snprintf() except that it ignores the
21830 ** current locale settings.  This is important for SQLite because we
21831 ** are not able to use a "," as the decimal point in place of "." as
21832 ** specified by some locales.
21833 **
21834 ** Oops:  The first two arguments of sqlcipher3_snprintf() are backwards
21835 ** from the snprintf() standard.  Unfortunately, it is too late to change
21836 ** this without breaking compatibility, so we just have to live with the
21837 ** mistake.
21838 **
21839 ** sqlcipher3_vsnprintf() is the varargs version.
21840 */
21841 SQLCIPHER_API char *sqlcipher3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
21842   StrAccum acc;
21843   if( n<=0 ) return zBuf;
21844   sqlcipher3StrAccumInit(&acc, zBuf, n, 0);
21845   acc.useMalloc = 0;
21846   sqlcipher3VXPrintf(&acc, 0, zFormat, ap);
21847   return sqlcipher3StrAccumFinish(&acc);
21848 }
21849 SQLCIPHER_API char *sqlcipher3_snprintf(int n, char *zBuf, const char *zFormat, ...){
21850   char *z;
21851   va_list ap;
21852   va_start(ap,zFormat);
21853   z = sqlcipher3_vsnprintf(n, zBuf, zFormat, ap);
21854   va_end(ap);
21855   return z;
21856 }
21857
21858 /*
21859 ** This is the routine that actually formats the sqlcipher3_log() message.
21860 ** We house it in a separate routine from sqlcipher3_log() to avoid using
21861 ** stack space on small-stack systems when logging is disabled.
21862 **
21863 ** sqlcipher3_log() must render into a static buffer.  It cannot dynamically
21864 ** allocate memory because it might be called while the memory allocator
21865 ** mutex is held.
21866 */
21867 static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
21868   StrAccum acc;                          /* String accumulator */
21869   char zMsg[SQLCIPHER_PRINT_BUF_SIZE*3];    /* Complete log message */
21870
21871   sqlcipher3StrAccumInit(&acc, zMsg, sizeof(zMsg), 0);
21872   acc.useMalloc = 0;
21873   sqlcipher3VXPrintf(&acc, 0, zFormat, ap);
21874   sqlcipher3GlobalConfig.xLog(sqlcipher3GlobalConfig.pLogArg, iErrCode,
21875                            sqlcipher3StrAccumFinish(&acc));
21876 }
21877
21878 /*
21879 ** Format and write a message to the log if logging is enabled.
21880 */
21881 SQLCIPHER_API void sqlcipher3_log(int iErrCode, const char *zFormat, ...){
21882   va_list ap;                             /* Vararg list */
21883   if( sqlcipher3GlobalConfig.xLog ){
21884     va_start(ap, zFormat);
21885     renderLogMsg(iErrCode, zFormat, ap);
21886     va_end(ap);
21887   }
21888 }
21889
21890 #if defined(SQLCIPHER_DEBUG)
21891 /*
21892 ** A version of printf() that understands %lld.  Used for debugging.
21893 ** The printf() built into some versions of windows does not understand %lld
21894 ** and segfaults if you give it a long long int.
21895 */
21896 SQLCIPHER_PRIVATE void sqlcipher3DebugPrintf(const char *zFormat, ...){
21897   va_list ap;
21898   StrAccum acc;
21899   char zBuf[500];
21900   sqlcipher3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);
21901   acc.useMalloc = 0;
21902   va_start(ap,zFormat);
21903   sqlcipher3VXPrintf(&acc, 0, zFormat, ap);
21904   va_end(ap);
21905   sqlcipher3StrAccumFinish(&acc);
21906   fprintf(stdout,"%s", zBuf);
21907   fflush(stdout);
21908 }
21909 #endif
21910
21911 #ifndef SQLCIPHER_OMIT_TRACE
21912 /*
21913 ** variable-argument wrapper around sqlcipher3VXPrintf().
21914 */
21915 SQLCIPHER_PRIVATE void sqlcipher3XPrintf(StrAccum *p, const char *zFormat, ...){
21916   va_list ap;
21917   va_start(ap,zFormat);
21918   sqlcipher3VXPrintf(p, 1, zFormat, ap);
21919   va_end(ap);
21920 }
21921 #endif
21922
21923 /************** End of printf.c **********************************************/
21924 /************** Begin file random.c ******************************************/
21925 /*
21926 ** 2001 September 15
21927 **
21928 ** The author disclaims copyright to this source code.  In place of
21929 ** a legal notice, here is a blessing:
21930 **
21931 **    May you do good and not evil.
21932 **    May you find forgiveness for yourself and forgive others.
21933 **    May you share freely, never taking more than you give.
21934 **
21935 *************************************************************************
21936 ** This file contains code to implement a pseudo-random number
21937 ** generator (PRNG) for SQLite.
21938 **
21939 ** Random numbers are used by some of the database backends in order
21940 ** to generate random integer keys for tables or random filenames.
21941 */
21942
21943
21944 /* All threads share a single random number generator.
21945 ** This structure is the current state of the generator.
21946 */
21947 static SQLCIPHER_WSD struct sqlcipher3PrngType {
21948   unsigned char isInit;          /* True if initialized */
21949   unsigned char i, j;            /* State variables */
21950   unsigned char s[256];          /* State variables */
21951 } sqlcipher3Prng;
21952
21953 /*
21954 ** Get a single 8-bit random value from the RC4 PRNG.  The Mutex
21955 ** must be held while executing this routine.
21956 **
21957 ** Why not just use a library random generator like lrand48() for this?
21958 ** Because the OP_NewRowid opcode in the VDBE depends on having a very
21959 ** good source of random numbers.  The lrand48() library function may
21960 ** well be good enough.  But maybe not.  Or maybe lrand48() has some
21961 ** subtle problems on some systems that could cause problems.  It is hard
21962 ** to know.  To minimize the risk of problems due to bad lrand48()
21963 ** implementations, SQLite uses this random number generator based
21964 ** on RC4, which we know works very well.
21965 **
21966 ** (Later):  Actually, OP_NewRowid does not depend on a good source of
21967 ** randomness any more.  But we will leave this code in all the same.
21968 */
21969 static u8 randomByte(void){
21970   unsigned char t;
21971
21972
21973   /* The "wsdPrng" macro will resolve to the pseudo-random number generator
21974   ** state vector.  If writable static data is unsupported on the target,
21975   ** we have to locate the state vector at run-time.  In the more common
21976   ** case where writable static data is supported, wsdPrng can refer directly
21977   ** to the "sqlcipher3Prng" state vector declared above.
21978   */
21979 #ifdef SQLCIPHER_OMIT_WSD
21980   struct sqlcipher3PrngType *p = &GLOBAL(struct sqlcipher3PrngType, sqlcipher3Prng);
21981 # define wsdPrng p[0]
21982 #else
21983 # define wsdPrng sqlcipher3Prng
21984 #endif
21985
21986
21987   /* Initialize the state of the random number generator once,
21988   ** the first time this routine is called.  The seed value does
21989   ** not need to contain a lot of randomness since we are not
21990   ** trying to do secure encryption or anything like that...
21991   **
21992   ** Nothing in this file or anywhere else in SQLite does any kind of
21993   ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
21994   ** number generator) not as an encryption device.
21995   */
21996   if( !wsdPrng.isInit ){
21997     int i;
21998     char k[256];
21999     wsdPrng.j = 0;
22000     wsdPrng.i = 0;
22001     sqlcipher3OsRandomness(sqlcipher3_vfs_find(0), 256, k);
22002     for(i=0; i<256; i++){
22003       wsdPrng.s[i] = (u8)i;
22004     }
22005     for(i=0; i<256; i++){
22006       wsdPrng.j += wsdPrng.s[i] + k[i];
22007       t = wsdPrng.s[wsdPrng.j];
22008       wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
22009       wsdPrng.s[i] = t;
22010     }
22011     wsdPrng.isInit = 1;
22012   }
22013
22014   /* Generate and return single random byte
22015   */
22016   wsdPrng.i++;
22017   t = wsdPrng.s[wsdPrng.i];
22018   wsdPrng.j += t;
22019   wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];
22020   wsdPrng.s[wsdPrng.j] = t;
22021   t += wsdPrng.s[wsdPrng.i];
22022   return wsdPrng.s[t];
22023 }
22024
22025 /*
22026 ** Return N random bytes.
22027 */
22028 SQLCIPHER_API void sqlcipher3_randomness(int N, void *pBuf){
22029   unsigned char *zBuf = pBuf;
22030 #if SQLCIPHER_THREADSAFE
22031   sqlcipher3_mutex *mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_PRNG);
22032 #endif
22033   sqlcipher3_mutex_enter(mutex);
22034   while( N-- ){
22035     *(zBuf++) = randomByte();
22036   }
22037   sqlcipher3_mutex_leave(mutex);
22038 }
22039
22040 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
22041 /*
22042 ** For testing purposes, we sometimes want to preserve the state of
22043 ** PRNG and restore the PRNG to its saved state at a later time, or
22044 ** to reset the PRNG to its initial state.  These routines accomplish
22045 ** those tasks.
22046 **
22047 ** The sqlcipher3_test_control() interface calls these routines to
22048 ** control the PRNG.
22049 */
22050 static SQLCIPHER_WSD struct sqlcipher3PrngType sqlcipher3SavedPrng;
22051 SQLCIPHER_PRIVATE void sqlcipher3PrngSaveState(void){
22052   memcpy(
22053     &GLOBAL(struct sqlcipher3PrngType, sqlcipher3SavedPrng),
22054     &GLOBAL(struct sqlcipher3PrngType, sqlcipher3Prng),
22055     sizeof(sqlcipher3Prng)
22056   );
22057 }
22058 SQLCIPHER_PRIVATE void sqlcipher3PrngRestoreState(void){
22059   memcpy(
22060     &GLOBAL(struct sqlcipher3PrngType, sqlcipher3Prng),
22061     &GLOBAL(struct sqlcipher3PrngType, sqlcipher3SavedPrng),
22062     sizeof(sqlcipher3Prng)
22063   );
22064 }
22065 SQLCIPHER_PRIVATE void sqlcipher3PrngResetState(void){
22066   GLOBAL(struct sqlcipher3PrngType, sqlcipher3Prng).isInit = 0;
22067 }
22068 #endif /* SQLCIPHER_OMIT_BUILTIN_TEST */
22069
22070 /************** End of random.c **********************************************/
22071 /************** Begin file utf.c *********************************************/
22072 /*
22073 ** 2004 April 13
22074 **
22075 ** The author disclaims copyright to this source code.  In place of
22076 ** a legal notice, here is a blessing:
22077 **
22078 **    May you do good and not evil.
22079 **    May you find forgiveness for yourself and forgive others.
22080 **    May you share freely, never taking more than you give.
22081 **
22082 *************************************************************************
22083 ** This file contains routines used to translate between UTF-8, 
22084 ** UTF-16, UTF-16BE, and UTF-16LE.
22085 **
22086 ** Notes on UTF-8:
22087 **
22088 **   Byte-0    Byte-1    Byte-2    Byte-3    Value
22089 **  0xxxxxxx                                 00000000 00000000 0xxxxxxx
22090 **  110yyyyy  10xxxxxx                       00000000 00000yyy yyxxxxxx
22091 **  1110zzzz  10yyyyyy  10xxxxxx             00000000 zzzzyyyy yyxxxxxx
22092 **  11110uuu  10uuzzzz  10yyyyyy  10xxxxxx   000uuuuu zzzzyyyy yyxxxxxx
22093 **
22094 **
22095 ** Notes on UTF-16:  (with wwww+1==uuuuu)
22096 **
22097 **      Word-0               Word-1          Value
22098 **  110110ww wwzzzzyy   110111yy yyxxxxxx    000uuuuu zzzzyyyy yyxxxxxx
22099 **  zzzzyyyy yyxxxxxx                        00000000 zzzzyyyy yyxxxxxx
22100 **
22101 **
22102 ** BOM or Byte Order Mark:
22103 **     0xff 0xfe   little-endian utf-16 follows
22104 **     0xfe 0xff   big-endian utf-16 follows
22105 **
22106 */
22107 /* #include <assert.h> */
22108
22109 #ifndef SQLCIPHER_AMALGAMATION
22110 /*
22111 ** The following constant value is used by the SQLCIPHER_BIGENDIAN and
22112 ** SQLCIPHER_LITTLEENDIAN macros.
22113 */
22114 SQLCIPHER_PRIVATE const int sqlcipher3one = 1;
22115 #endif /* SQLCIPHER_AMALGAMATION */
22116
22117 /*
22118 ** This lookup table is used to help decode the first byte of
22119 ** a multi-byte UTF8 character.
22120 */
22121 static const unsigned char sqlcipher3Utf8Trans1[] = {
22122   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
22123   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
22124   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
22125   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
22126   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
22127   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
22128   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
22129   0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
22130 };
22131
22132
22133 #define WRITE_UTF8(zOut, c) {                          \
22134   if( c<0x00080 ){                                     \
22135     *zOut++ = (u8)(c&0xFF);                            \
22136   }                                                    \
22137   else if( c<0x00800 ){                                \
22138     *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);                \
22139     *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
22140   }                                                    \
22141   else if( c<0x10000 ){                                \
22142     *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);               \
22143     *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
22144     *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
22145   }else{                                               \
22146     *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);             \
22147     *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);             \
22148     *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);              \
22149     *zOut++ = 0x80 + (u8)(c & 0x3F);                   \
22150   }                                                    \
22151 }
22152
22153 #define WRITE_UTF16LE(zOut, c) {                                    \
22154   if( c<=0xFFFF ){                                                  \
22155     *zOut++ = (u8)(c&0x00FF);                                       \
22156     *zOut++ = (u8)((c>>8)&0x00FF);                                  \
22157   }else{                                                            \
22158     *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
22159     *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
22160     *zOut++ = (u8)(c&0x00FF);                                       \
22161     *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
22162   }                                                                 \
22163 }
22164
22165 #define WRITE_UTF16BE(zOut, c) {                                    \
22166   if( c<=0xFFFF ){                                                  \
22167     *zOut++ = (u8)((c>>8)&0x00FF);                                  \
22168     *zOut++ = (u8)(c&0x00FF);                                       \
22169   }else{                                                            \
22170     *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03));              \
22171     *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0));  \
22172     *zOut++ = (u8)(0x00DC + ((c>>8)&0x03));                         \
22173     *zOut++ = (u8)(c&0x00FF);                                       \
22174   }                                                                 \
22175 }
22176
22177 #define READ_UTF16LE(zIn, TERM, c){                                   \
22178   c = (*zIn++);                                                       \
22179   c += ((*zIn++)<<8);                                                 \
22180   if( c>=0xD800 && c<0xE000 && TERM ){                                \
22181     int c2 = (*zIn++);                                                \
22182     c2 += ((*zIn++)<<8);                                              \
22183     c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
22184   }                                                                   \
22185 }
22186
22187 #define READ_UTF16BE(zIn, TERM, c){                                   \
22188   c = ((*zIn++)<<8);                                                  \
22189   c += (*zIn++);                                                      \
22190   if( c>=0xD800 && c<0xE000 && TERM ){                                \
22191     int c2 = ((*zIn++)<<8);                                           \
22192     c2 += (*zIn++);                                                   \
22193     c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10);   \
22194   }                                                                   \
22195 }
22196
22197 /*
22198 ** Translate a single UTF-8 character.  Return the unicode value.
22199 **
22200 ** During translation, assume that the byte that zTerm points
22201 ** is a 0x00.
22202 **
22203 ** Write a pointer to the next unread byte back into *pzNext.
22204 **
22205 ** Notes On Invalid UTF-8:
22206 **
22207 **  *  This routine never allows a 7-bit character (0x00 through 0x7f) to
22208 **     be encoded as a multi-byte character.  Any multi-byte character that
22209 **     attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
22210 **
22211 **  *  This routine never allows a UTF16 surrogate value to be encoded.
22212 **     If a multi-byte character attempts to encode a value between
22213 **     0xd800 and 0xe000 then it is rendered as 0xfffd.
22214 **
22215 **  *  Bytes in the range of 0x80 through 0xbf which occur as the first
22216 **     byte of a character are interpreted as single-byte characters
22217 **     and rendered as themselves even though they are technically
22218 **     invalid characters.
22219 **
22220 **  *  This routine accepts an infinite number of different UTF8 encodings
22221 **     for unicode values 0x80 and greater.  It do not change over-length
22222 **     encodings to 0xfffd as some systems recommend.
22223 */
22224 #define READ_UTF8(zIn, zTerm, c)                           \
22225   c = *(zIn++);                                            \
22226   if( c>=0xc0 ){                                           \
22227     c = sqlcipher3Utf8Trans1[c-0xc0];                         \
22228     while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){            \
22229       c = (c<<6) + (0x3f & *(zIn++));                      \
22230     }                                                      \
22231     if( c<0x80                                             \
22232         || (c&0xFFFFF800)==0xD800                          \
22233         || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }        \
22234   }
22235 SQLCIPHER_PRIVATE u32 sqlcipher3Utf8Read(
22236   const unsigned char *zIn,       /* First byte of UTF-8 character */
22237   const unsigned char **pzNext    /* Write first byte past UTF-8 char here */
22238 ){
22239   unsigned int c;
22240
22241   /* Same as READ_UTF8() above but without the zTerm parameter.
22242   ** For this routine, we assume the UTF8 string is always zero-terminated.
22243   */
22244   c = *(zIn++);
22245   if( c>=0xc0 ){
22246     c = sqlcipher3Utf8Trans1[c-0xc0];
22247     while( (*zIn & 0xc0)==0x80 ){
22248       c = (c<<6) + (0x3f & *(zIn++));
22249     }
22250     if( c<0x80
22251         || (c&0xFFFFF800)==0xD800
22252         || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }
22253   }
22254   *pzNext = zIn;
22255   return c;
22256 }
22257
22258
22259
22260
22261 /*
22262 ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
22263 ** printed on stderr on the way into and out of sqlcipher3VdbeMemTranslate().
22264 */ 
22265 /* #define TRANSLATE_TRACE 1 */
22266
22267 #ifndef SQLCIPHER_OMIT_UTF16
22268 /*
22269 ** This routine transforms the internal text encoding used by pMem to
22270 ** desiredEnc. It is an error if the string is already of the desired
22271 ** encoding, or if *pMem does not contain a string value.
22272 */
22273 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
22274   int len;                    /* Maximum length of output string in bytes */
22275   unsigned char *zOut;                  /* Output buffer */
22276   unsigned char *zIn;                   /* Input iterator */
22277   unsigned char *zTerm;                 /* End of input */
22278   unsigned char *z;                     /* Output iterator */
22279   unsigned int c;
22280
22281   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
22282   assert( pMem->flags&MEM_Str );
22283   assert( pMem->enc!=desiredEnc );
22284   assert( pMem->enc!=0 );
22285   assert( pMem->n>=0 );
22286
22287 #if defined(TRANSLATE_TRACE) && defined(SQLCIPHER_DEBUG)
22288   {
22289     char zBuf[100];
22290     sqlcipher3VdbeMemPrettyPrint(pMem, zBuf);
22291     fprintf(stderr, "INPUT:  %s\n", zBuf);
22292   }
22293 #endif
22294
22295   /* If the translation is between UTF-16 little and big endian, then 
22296   ** all that is required is to swap the byte order. This case is handled
22297   ** differently from the others.
22298   */
22299   if( pMem->enc!=SQLCIPHER_UTF8 && desiredEnc!=SQLCIPHER_UTF8 ){
22300     u8 temp;
22301     int rc;
22302     rc = sqlcipher3VdbeMemMakeWriteable(pMem);
22303     if( rc!=SQLCIPHER_OK ){
22304       assert( rc==SQLCIPHER_NOMEM );
22305       return SQLCIPHER_NOMEM;
22306     }
22307     zIn = (u8*)pMem->z;
22308     zTerm = &zIn[pMem->n&~1];
22309     while( zIn<zTerm ){
22310       temp = *zIn;
22311       *zIn = *(zIn+1);
22312       zIn++;
22313       *zIn++ = temp;
22314     }
22315     pMem->enc = desiredEnc;
22316     goto translate_out;
22317   }
22318
22319   /* Set len to the maximum number of bytes required in the output buffer. */
22320   if( desiredEnc==SQLCIPHER_UTF8 ){
22321     /* When converting from UTF-16, the maximum growth results from
22322     ** translating a 2-byte character to a 4-byte UTF-8 character.
22323     ** A single byte is required for the output string
22324     ** nul-terminator.
22325     */
22326     pMem->n &= ~1;
22327     len = pMem->n * 2 + 1;
22328   }else{
22329     /* When converting from UTF-8 to UTF-16 the maximum growth is caused
22330     ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
22331     ** character. Two bytes are required in the output buffer for the
22332     ** nul-terminator.
22333     */
22334     len = pMem->n * 2 + 2;
22335   }
22336
22337   /* Set zIn to point at the start of the input buffer and zTerm to point 1
22338   ** byte past the end.
22339   **
22340   ** Variable zOut is set to point at the output buffer, space obtained
22341   ** from sqlcipher3_malloc().
22342   */
22343   zIn = (u8*)pMem->z;
22344   zTerm = &zIn[pMem->n];
22345   zOut = sqlcipher3DbMallocRaw(pMem->db, len);
22346   if( !zOut ){
22347     return SQLCIPHER_NOMEM;
22348   }
22349   z = zOut;
22350
22351   if( pMem->enc==SQLCIPHER_UTF8 ){
22352     if( desiredEnc==SQLCIPHER_UTF16LE ){
22353       /* UTF-8 -> UTF-16 Little-endian */
22354       while( zIn<zTerm ){
22355         /* c = sqlcipher3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
22356         READ_UTF8(zIn, zTerm, c);
22357         WRITE_UTF16LE(z, c);
22358       }
22359     }else{
22360       assert( desiredEnc==SQLCIPHER_UTF16BE );
22361       /* UTF-8 -> UTF-16 Big-endian */
22362       while( zIn<zTerm ){
22363         /* c = sqlcipher3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
22364         READ_UTF8(zIn, zTerm, c);
22365         WRITE_UTF16BE(z, c);
22366       }
22367     }
22368     pMem->n = (int)(z - zOut);
22369     *z++ = 0;
22370   }else{
22371     assert( desiredEnc==SQLCIPHER_UTF8 );
22372     if( pMem->enc==SQLCIPHER_UTF16LE ){
22373       /* UTF-16 Little-endian -> UTF-8 */
22374       while( zIn<zTerm ){
22375         READ_UTF16LE(zIn, zIn<zTerm, c); 
22376         WRITE_UTF8(z, c);
22377       }
22378     }else{
22379       /* UTF-16 Big-endian -> UTF-8 */
22380       while( zIn<zTerm ){
22381         READ_UTF16BE(zIn, zIn<zTerm, c); 
22382         WRITE_UTF8(z, c);
22383       }
22384     }
22385     pMem->n = (int)(z - zOut);
22386   }
22387   *z = 0;
22388   assert( (pMem->n+(desiredEnc==SQLCIPHER_UTF8?1:2))<=len );
22389
22390   sqlcipher3VdbeMemRelease(pMem);
22391   pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
22392   pMem->enc = desiredEnc;
22393   pMem->flags |= (MEM_Term|MEM_Dyn);
22394   pMem->z = (char*)zOut;
22395   pMem->zMalloc = pMem->z;
22396
22397 translate_out:
22398 #if defined(TRANSLATE_TRACE) && defined(SQLCIPHER_DEBUG)
22399   {
22400     char zBuf[100];
22401     sqlcipher3VdbeMemPrettyPrint(pMem, zBuf);
22402     fprintf(stderr, "OUTPUT: %s\n", zBuf);
22403   }
22404 #endif
22405   return SQLCIPHER_OK;
22406 }
22407
22408 /*
22409 ** This routine checks for a byte-order mark at the beginning of the 
22410 ** UTF-16 string stored in *pMem. If one is present, it is removed and
22411 ** the encoding of the Mem adjusted. This routine does not do any
22412 ** byte-swapping, it just sets Mem.enc appropriately.
22413 **
22414 ** The allocation (static, dynamic etc.) and encoding of the Mem may be
22415 ** changed by this function.
22416 */
22417 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemHandleBom(Mem *pMem){
22418   int rc = SQLCIPHER_OK;
22419   u8 bom = 0;
22420
22421   assert( pMem->n>=0 );
22422   if( pMem->n>1 ){
22423     u8 b1 = *(u8 *)pMem->z;
22424     u8 b2 = *(((u8 *)pMem->z) + 1);
22425     if( b1==0xFE && b2==0xFF ){
22426       bom = SQLCIPHER_UTF16BE;
22427     }
22428     if( b1==0xFF && b2==0xFE ){
22429       bom = SQLCIPHER_UTF16LE;
22430     }
22431   }
22432   
22433   if( bom ){
22434     rc = sqlcipher3VdbeMemMakeWriteable(pMem);
22435     if( rc==SQLCIPHER_OK ){
22436       pMem->n -= 2;
22437       memmove(pMem->z, &pMem->z[2], pMem->n);
22438       pMem->z[pMem->n] = '\0';
22439       pMem->z[pMem->n+1] = '\0';
22440       pMem->flags |= MEM_Term;
22441       pMem->enc = bom;
22442     }
22443   }
22444   return rc;
22445 }
22446 #endif /* SQLCIPHER_OMIT_UTF16 */
22447
22448 /*
22449 ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
22450 ** return the number of unicode characters in pZ up to (but not including)
22451 ** the first 0x00 byte. If nByte is not less than zero, return the
22452 ** number of unicode characters in the first nByte of pZ (or up to 
22453 ** the first 0x00, whichever comes first).
22454 */
22455 SQLCIPHER_PRIVATE int sqlcipher3Utf8CharLen(const char *zIn, int nByte){
22456   int r = 0;
22457   const u8 *z = (const u8*)zIn;
22458   const u8 *zTerm;
22459   if( nByte>=0 ){
22460     zTerm = &z[nByte];
22461   }else{
22462     zTerm = (const u8*)(-1);
22463   }
22464   assert( z<=zTerm );
22465   while( *z!=0 && z<zTerm ){
22466     SQLCIPHER_SKIP_UTF8(z);
22467     r++;
22468   }
22469   return r;
22470 }
22471
22472 /* This test function is not currently used by the automated test-suite. 
22473 ** Hence it is only available in debug builds.
22474 */
22475 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
22476 /*
22477 ** Translate UTF-8 to UTF-8.
22478 **
22479 ** This has the effect of making sure that the string is well-formed
22480 ** UTF-8.  Miscoded characters are removed.
22481 **
22482 ** The translation is done in-place and aborted if the output
22483 ** overruns the input.
22484 */
22485 SQLCIPHER_PRIVATE int sqlcipher3Utf8To8(unsigned char *zIn){
22486   unsigned char *zOut = zIn;
22487   unsigned char *zStart = zIn;
22488   u32 c;
22489
22490   while( zIn[0] && zOut<=zIn ){
22491     c = sqlcipher3Utf8Read(zIn, (const u8**)&zIn);
22492     if( c!=0xfffd ){
22493       WRITE_UTF8(zOut, c);
22494     }
22495   }
22496   *zOut = 0;
22497   return (int)(zOut - zStart);
22498 }
22499 #endif
22500
22501 #ifndef SQLCIPHER_OMIT_UTF16
22502 /*
22503 ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
22504 ** Memory to hold the UTF-8 string is obtained from sqlcipher3_malloc and must
22505 ** be freed by the calling function.
22506 **
22507 ** NULL is returned if there is an allocation error.
22508 */
22509 SQLCIPHER_PRIVATE char *sqlcipher3Utf16to8(sqlcipher3 *db, const void *z, int nByte, u8 enc){
22510   Mem m;
22511   memset(&m, 0, sizeof(m));
22512   m.db = db;
22513   sqlcipher3VdbeMemSetStr(&m, z, nByte, enc, SQLCIPHER_STATIC);
22514   sqlcipher3VdbeChangeEncoding(&m, SQLCIPHER_UTF8);
22515   if( db->mallocFailed ){
22516     sqlcipher3VdbeMemRelease(&m);
22517     m.z = 0;
22518   }
22519   assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
22520   assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
22521   assert( (m.flags & MEM_Dyn)!=0 || db->mallocFailed );
22522   assert( m.z || db->mallocFailed );
22523   return m.z;
22524 }
22525
22526 /*
22527 ** Convert a UTF-8 string to the UTF-16 encoding specified by parameter
22528 ** enc. A pointer to the new string is returned, and the value of *pnOut
22529 ** is set to the length of the returned string in bytes. The call should
22530 ** arrange to call sqlcipher3DbFree() on the returned pointer when it is
22531 ** no longer required.
22532 ** 
22533 ** If a malloc failure occurs, NULL is returned and the db.mallocFailed
22534 ** flag set.
22535 */
22536 #ifdef SQLCIPHER_ENABLE_STAT3
22537 SQLCIPHER_PRIVATE char *sqlcipher3Utf8to16(sqlcipher3 *db, u8 enc, char *z, int n, int *pnOut){
22538   Mem m;
22539   memset(&m, 0, sizeof(m));
22540   m.db = db;
22541   sqlcipher3VdbeMemSetStr(&m, z, n, SQLCIPHER_UTF8, SQLCIPHER_STATIC);
22542   if( sqlcipher3VdbeMemTranslate(&m, enc) ){
22543     assert( db->mallocFailed );
22544     return 0;
22545   }
22546   assert( m.z==m.zMalloc );
22547   *pnOut = m.n;
22548   return m.z;
22549 }
22550 #endif
22551
22552 /*
22553 ** zIn is a UTF-16 encoded unicode string at least nChar characters long.
22554 ** Return the number of bytes in the first nChar unicode characters
22555 ** in pZ.  nChar must be non-negative.
22556 */
22557 SQLCIPHER_PRIVATE int sqlcipher3Utf16ByteLen(const void *zIn, int nChar){
22558   int c;
22559   unsigned char const *z = zIn;
22560   int n = 0;
22561   
22562   if( SQLCIPHER_UTF16NATIVE==SQLCIPHER_UTF16BE ){
22563     while( n<nChar ){
22564       READ_UTF16BE(z, 1, c);
22565       n++;
22566     }
22567   }else{
22568     while( n<nChar ){
22569       READ_UTF16LE(z, 1, c);
22570       n++;
22571     }
22572   }
22573   return (int)(z-(unsigned char const *)zIn);
22574 }
22575
22576 #if defined(SQLCIPHER_TEST)
22577 /*
22578 ** This routine is called from the TCL test function "translate_selftest".
22579 ** It checks that the primitives for serializing and deserializing
22580 ** characters in each encoding are inverses of each other.
22581 */
22582 SQLCIPHER_PRIVATE void sqlcipher3UtfSelfTest(void){
22583   unsigned int i, t;
22584   unsigned char zBuf[20];
22585   unsigned char *z;
22586   int n;
22587   unsigned int c;
22588
22589   for(i=0; i<0x00110000; i++){
22590     z = zBuf;
22591     WRITE_UTF8(z, i);
22592     n = (int)(z-zBuf);
22593     assert( n>0 && n<=4 );
22594     z[0] = 0;
22595     z = zBuf;
22596     c = sqlcipher3Utf8Read(z, (const u8**)&z);
22597     t = i;
22598     if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
22599     if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
22600     assert( c==t );
22601     assert( (z-zBuf)==n );
22602   }
22603   for(i=0; i<0x00110000; i++){
22604     if( i>=0xD800 && i<0xE000 ) continue;
22605     z = zBuf;
22606     WRITE_UTF16LE(z, i);
22607     n = (int)(z-zBuf);
22608     assert( n>0 && n<=4 );
22609     z[0] = 0;
22610     z = zBuf;
22611     READ_UTF16LE(z, 1, c);
22612     assert( c==i );
22613     assert( (z-zBuf)==n );
22614   }
22615   for(i=0; i<0x00110000; i++){
22616     if( i>=0xD800 && i<0xE000 ) continue;
22617     z = zBuf;
22618     WRITE_UTF16BE(z, i);
22619     n = (int)(z-zBuf);
22620     assert( n>0 && n<=4 );
22621     z[0] = 0;
22622     z = zBuf;
22623     READ_UTF16BE(z, 1, c);
22624     assert( c==i );
22625     assert( (z-zBuf)==n );
22626   }
22627 }
22628 #endif /* SQLCIPHER_TEST */
22629 #endif /* SQLCIPHER_OMIT_UTF16 */
22630
22631 /************** End of utf.c *************************************************/
22632 /************** Begin file util.c ********************************************/
22633 /*
22634 ** 2001 September 15
22635 **
22636 ** The author disclaims copyright to this source code.  In place of
22637 ** a legal notice, here is a blessing:
22638 **
22639 **    May you do good and not evil.
22640 **    May you find forgiveness for yourself and forgive others.
22641 **    May you share freely, never taking more than you give.
22642 **
22643 *************************************************************************
22644 ** Utility functions used throughout sqlcipher.
22645 **
22646 ** This file contains functions for allocating memory, comparing
22647 ** strings, and stuff like that.
22648 **
22649 */
22650 /* #include <stdarg.h> */
22651 #ifdef SQLCIPHER_HAVE_ISNAN
22652 # include <math.h>
22653 #endif
22654
22655 /*
22656 ** Routine needed to support the testcase() macro.
22657 */
22658 #ifdef SQLCIPHER_COVERAGE_TEST
22659 SQLCIPHER_PRIVATE void sqlcipher3Coverage(int x){
22660   static unsigned dummy = 0;
22661   dummy += (unsigned)x;
22662 }
22663 #endif
22664
22665 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
22666 /*
22667 ** Return true if the floating point value is Not a Number (NaN).
22668 **
22669 ** Use the math library isnan() function if compiled with SQLCIPHER_HAVE_ISNAN.
22670 ** Otherwise, we have our own implementation that works on most systems.
22671 */
22672 SQLCIPHER_PRIVATE int sqlcipher3IsNaN(double x){
22673   int rc;   /* The value return */
22674 #if !defined(SQLCIPHER_HAVE_ISNAN)
22675   /*
22676   ** Systems that support the isnan() library function should probably
22677   ** make use of it by compiling with -DSQLCIPHER_HAVE_ISNAN.  But we have
22678   ** found that many systems do not have a working isnan() function so
22679   ** this implementation is provided as an alternative.
22680   **
22681   ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
22682   ** On the other hand, the use of -ffast-math comes with the following
22683   ** warning:
22684   **
22685   **      This option [-ffast-math] should never be turned on by any
22686   **      -O option since it can result in incorrect output for programs
22687   **      which depend on an exact implementation of IEEE or ISO 
22688   **      rules/specifications for math functions.
22689   **
22690   ** Under MSVC, this NaN test may fail if compiled with a floating-
22691   ** point precision mode other than /fp:precise.  From the MSDN 
22692   ** documentation:
22693   **
22694   **      The compiler [with /fp:precise] will properly handle comparisons 
22695   **      involving NaN. For example, x != x evaluates to true if x is NaN 
22696   **      ...
22697   */
22698 #ifdef __FAST_MATH__
22699 # error SQLite will not work correctly with the -ffast-math option of GCC.
22700 #endif
22701   volatile double y = x;
22702   volatile double z = y;
22703   rc = (y!=z);
22704 #else  /* if defined(SQLCIPHER_HAVE_ISNAN) */
22705   rc = isnan(x);
22706 #endif /* SQLCIPHER_HAVE_ISNAN */
22707   testcase( rc );
22708   return rc;
22709 }
22710 #endif /* SQLCIPHER_OMIT_FLOATING_POINT */
22711
22712 /*
22713 ** Compute a string length that is limited to what can be stored in
22714 ** lower 30 bits of a 32-bit signed integer.
22715 **
22716 ** The value returned will never be negative.  Nor will it ever be greater
22717 ** than the actual length of the string.  For very long strings (greater
22718 ** than 1GiB) the value returned might be less than the true string length.
22719 */
22720 SQLCIPHER_PRIVATE int sqlcipher3Strlen30(const char *z){
22721   const char *z2 = z;
22722   if( z==0 ) return 0;
22723   while( *z2 ){ z2++; }
22724   return 0x3fffffff & (int)(z2 - z);
22725 }
22726
22727 /*
22728 ** Set the most recent error code and error string for the sqlcipher
22729 ** handle "db". The error code is set to "err_code".
22730 **
22731 ** If it is not NULL, string zFormat specifies the format of the
22732 ** error string in the style of the printf functions: The following
22733 ** format characters are allowed:
22734 **
22735 **      %s      Insert a string
22736 **      %z      A string that should be freed after use
22737 **      %d      Insert an integer
22738 **      %T      Insert a token
22739 **      %S      Insert the first element of a SrcList
22740 **
22741 ** zFormat and any string tokens that follow it are assumed to be
22742 ** encoded in UTF-8.
22743 **
22744 ** To clear the most recent error for sqlcipher handle "db", sqlcipher3Error
22745 ** should be called with err_code set to SQLCIPHER_OK and zFormat set
22746 ** to NULL.
22747 */
22748 SQLCIPHER_PRIVATE void sqlcipher3Error(sqlcipher3 *db, int err_code, const char *zFormat, ...){
22749   if( db && (db->pErr || (db->pErr = sqlcipher3ValueNew(db))!=0) ){
22750     db->errCode = err_code;
22751     if( zFormat ){
22752       char *z;
22753       va_list ap;
22754       va_start(ap, zFormat);
22755       z = sqlcipher3VMPrintf(db, zFormat, ap);
22756       va_end(ap);
22757       sqlcipher3ValueSetStr(db->pErr, -1, z, SQLCIPHER_UTF8, SQLCIPHER_DYNAMIC);
22758     }else{
22759       sqlcipher3ValueSetStr(db->pErr, 0, 0, SQLCIPHER_UTF8, SQLCIPHER_STATIC);
22760     }
22761   }
22762 }
22763
22764 /*
22765 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
22766 ** The following formatting characters are allowed:
22767 **
22768 **      %s      Insert a string
22769 **      %z      A string that should be freed after use
22770 **      %d      Insert an integer
22771 **      %T      Insert a token
22772 **      %S      Insert the first element of a SrcList
22773 **
22774 ** This function should be used to report any error that occurs whilst
22775 ** compiling an SQL statement (i.e. within sqlcipher3_prepare()). The
22776 ** last thing the sqlcipher3_prepare() function does is copy the error
22777 ** stored by this function into the database handle using sqlcipher3Error().
22778 ** Function sqlcipher3Error() should be used during statement execution
22779 ** (sqlcipher3_step() etc.).
22780 */
22781 SQLCIPHER_PRIVATE void sqlcipher3ErrorMsg(Parse *pParse, const char *zFormat, ...){
22782   char *zMsg;
22783   va_list ap;
22784   sqlcipher3 *db = pParse->db;
22785   va_start(ap, zFormat);
22786   zMsg = sqlcipher3VMPrintf(db, zFormat, ap);
22787   va_end(ap);
22788   if( db->suppressErr ){
22789     sqlcipher3DbFree(db, zMsg);
22790   }else{
22791     pParse->nErr++;
22792     sqlcipher3DbFree(db, pParse->zErrMsg);
22793     pParse->zErrMsg = zMsg;
22794     pParse->rc = SQLCIPHER_ERROR;
22795   }
22796 }
22797
22798 /*
22799 ** Convert an SQL-style quoted string into a normal string by removing
22800 ** the quote characters.  The conversion is done in-place.  If the
22801 ** input does not begin with a quote character, then this routine
22802 ** is a no-op.
22803 **
22804 ** The input string must be zero-terminated.  A new zero-terminator
22805 ** is added to the dequoted string.
22806 **
22807 ** The return value is -1 if no dequoting occurs or the length of the
22808 ** dequoted string, exclusive of the zero terminator, if dequoting does
22809 ** occur.
22810 **
22811 ** 2002-Feb-14: This routine is extended to remove MS-Access style
22812 ** brackets from around identifers.  For example:  "[a-b-c]" becomes
22813 ** "a-b-c".
22814 */
22815 SQLCIPHER_PRIVATE int sqlcipher3Dequote(char *z){
22816   char quote;
22817   int i, j;
22818   if( z==0 ) return -1;
22819   quote = z[0];
22820   switch( quote ){
22821     case '\'':  break;
22822     case '"':   break;
22823     case '`':   break;                /* For MySQL compatibility */
22824     case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
22825     default:    return -1;
22826   }
22827   for(i=1, j=0; ALWAYS(z[i]); i++){
22828     if( z[i]==quote ){
22829       if( z[i+1]==quote ){
22830         z[j++] = quote;
22831         i++;
22832       }else{
22833         break;
22834       }
22835     }else{
22836       z[j++] = z[i];
22837     }
22838   }
22839   z[j] = 0;
22840   return j;
22841 }
22842
22843 /* Convenient short-hand */
22844 #define UpperToLower sqlcipher3UpperToLower
22845
22846 /*
22847 ** Some systems have stricmp().  Others have strcasecmp().  Because
22848 ** there is no consistency, we will define our own.
22849 **
22850 ** IMPLEMENTATION-OF: R-20522-24639 The sqlcipher3_strnicmp() API allows
22851 ** applications and extensions to compare the contents of two buffers
22852 ** containing UTF-8 strings in a case-independent fashion, using the same
22853 ** definition of case independence that SQLite uses internally when
22854 ** comparing identifiers.
22855 */
22856 SQLCIPHER_PRIVATE int sqlcipher3StrICmp(const char *zLeft, const char *zRight){
22857   register unsigned char *a, *b;
22858   a = (unsigned char *)zLeft;
22859   b = (unsigned char *)zRight;
22860   while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
22861   return UpperToLower[*a] - UpperToLower[*b];
22862 }
22863 SQLCIPHER_API int sqlcipher3_strnicmp(const char *zLeft, const char *zRight, int N){
22864   register unsigned char *a, *b;
22865   a = (unsigned char *)zLeft;
22866   b = (unsigned char *)zRight;
22867   while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
22868   return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
22869 }
22870
22871 /*
22872 ** The string z[] is an text representation of a real number.
22873 ** Convert this string to a double and write it into *pResult.
22874 **
22875 ** The string z[] is length bytes in length (bytes, not characters) and
22876 ** uses the encoding enc.  The string is not necessarily zero-terminated.
22877 **
22878 ** Return TRUE if the result is a valid real number (or integer) and FALSE
22879 ** if the string is empty or contains extraneous text.  Valid numbers
22880 ** are in one of these formats:
22881 **
22882 **    [+-]digits[E[+-]digits]
22883 **    [+-]digits.[digits][E[+-]digits]
22884 **    [+-].digits[E[+-]digits]
22885 **
22886 ** Leading and trailing whitespace is ignored for the purpose of determining
22887 ** validity.
22888 **
22889 ** If some prefix of the input string is a valid number, this routine
22890 ** returns FALSE but it still converts the prefix and writes the result
22891 ** into *pResult.
22892 */
22893 SQLCIPHER_PRIVATE int sqlcipher3AtoF(const char *z, double *pResult, int length, u8 enc){
22894 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
22895   int incr = (enc==SQLCIPHER_UTF8?1:2);
22896   const char *zEnd = z + length;
22897   /* sign * significand * (10 ^ (esign * exponent)) */
22898   int sign = 1;    /* sign of significand */
22899   i64 s = 0;       /* significand */
22900   int d = 0;       /* adjust exponent for shifting decimal point */
22901   int esign = 1;   /* sign of exponent */
22902   int e = 0;       /* exponent */
22903   int eValid = 1;  /* True exponent is either not used or is well-formed */
22904   double result;
22905   int nDigits = 0;
22906
22907   *pResult = 0.0;   /* Default return value, in case of an error */
22908
22909   if( enc==SQLCIPHER_UTF16BE ) z++;
22910
22911   /* skip leading spaces */
22912   while( z<zEnd && sqlcipher3Isspace(*z) ) z+=incr;
22913   if( z>=zEnd ) return 0;
22914
22915   /* get sign of significand */
22916   if( *z=='-' ){
22917     sign = -1;
22918     z+=incr;
22919   }else if( *z=='+' ){
22920     z+=incr;
22921   }
22922
22923   /* skip leading zeroes */
22924   while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;
22925
22926   /* copy max significant digits to significand */
22927   while( z<zEnd && sqlcipher3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
22928     s = s*10 + (*z - '0');
22929     z+=incr, nDigits++;
22930   }
22931
22932   /* skip non-significant significand digits
22933   ** (increase exponent by d to shift decimal left) */
22934   while( z<zEnd && sqlcipher3Isdigit(*z) ) z+=incr, nDigits++, d++;
22935   if( z>=zEnd ) goto do_atof_calc;
22936
22937   /* if decimal point is present */
22938   if( *z=='.' ){
22939     z+=incr;
22940     /* copy digits from after decimal to significand
22941     ** (decrease exponent by d to shift decimal right) */
22942     while( z<zEnd && sqlcipher3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
22943       s = s*10 + (*z - '0');
22944       z+=incr, nDigits++, d--;
22945     }
22946     /* skip non-significant digits */
22947     while( z<zEnd && sqlcipher3Isdigit(*z) ) z+=incr, nDigits++;
22948   }
22949   if( z>=zEnd ) goto do_atof_calc;
22950
22951   /* if exponent is present */
22952   if( *z=='e' || *z=='E' ){
22953     z+=incr;
22954     eValid = 0;
22955     if( z>=zEnd ) goto do_atof_calc;
22956     /* get sign of exponent */
22957     if( *z=='-' ){
22958       esign = -1;
22959       z+=incr;
22960     }else if( *z=='+' ){
22961       z+=incr;
22962     }
22963     /* copy digits to exponent */
22964     while( z<zEnd && sqlcipher3Isdigit(*z) ){
22965       e = e<10000 ? (e*10 + (*z - '0')) : 10000;
22966       z+=incr;
22967       eValid = 1;
22968     }
22969   }
22970
22971   /* skip trailing spaces */
22972   if( nDigits && eValid ){
22973     while( z<zEnd && sqlcipher3Isspace(*z) ) z+=incr;
22974   }
22975
22976 do_atof_calc:
22977   /* adjust exponent by d, and update sign */
22978   e = (e*esign) + d;
22979   if( e<0 ) {
22980     esign = -1;
22981     e *= -1;
22982   } else {
22983     esign = 1;
22984   }
22985
22986   /* if 0 significand */
22987   if( !s ) {
22988     /* In the IEEE 754 standard, zero is signed.
22989     ** Add the sign if we've seen at least one digit */
22990     result = (sign<0 && nDigits) ? -(double)0 : (double)0;
22991   } else {
22992     /* attempt to reduce exponent */
22993     if( esign>0 ){
22994       while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
22995     }else{
22996       while( !(s%10) && e>0 ) e--,s/=10;
22997     }
22998
22999     /* adjust the sign of significand */
23000     s = sign<0 ? -s : s;
23001
23002     /* if exponent, scale significand as appropriate
23003     ** and store in result. */
23004     if( e ){
23005       double scale = 1.0;
23006       /* attempt to handle extremely small/large numbers better */
23007       if( e>307 && e<342 ){
23008         while( e%308 ) { scale *= 1.0e+1; e -= 1; }
23009         if( esign<0 ){
23010           result = s / scale;
23011           result /= 1.0e+308;
23012         }else{
23013           result = s * scale;
23014           result *= 1.0e+308;
23015         }
23016       }else if( e>=342 ){
23017         if( esign<0 ){
23018           result = 0.0*s;
23019         }else{
23020           result = 1e308*1e308*s;  /* Infinity */
23021         }
23022       }else{
23023         /* 1.0e+22 is the largest power of 10 than can be 
23024         ** represented exactly. */
23025         while( e%22 ) { scale *= 1.0e+1; e -= 1; }
23026         while( e>0 ) { scale *= 1.0e+22; e -= 22; }
23027         if( esign<0 ){
23028           result = s / scale;
23029         }else{
23030           result = s * scale;
23031         }
23032       }
23033     } else {
23034       result = (double)s;
23035     }
23036   }
23037
23038   /* store the result */
23039   *pResult = result;
23040
23041   /* return true if number and no extra non-whitespace chracters after */
23042   return z>=zEnd && nDigits>0 && eValid;
23043 #else
23044   return !sqlcipher3Atoi64(z, pResult, length, enc);
23045 #endif /* SQLCIPHER_OMIT_FLOATING_POINT */
23046 }
23047
23048 /*
23049 ** Compare the 19-character string zNum against the text representation
23050 ** value 2^63:  9223372036854775808.  Return negative, zero, or positive
23051 ** if zNum is less than, equal to, or greater than the string.
23052 ** Note that zNum must contain exactly 19 characters.
23053 **
23054 ** Unlike memcmp() this routine is guaranteed to return the difference
23055 ** in the values of the last digit if the only difference is in the
23056 ** last digit.  So, for example,
23057 **
23058 **      compare2pow63("9223372036854775800", 1)
23059 **
23060 ** will return -8.
23061 */
23062 static int compare2pow63(const char *zNum, int incr){
23063   int c = 0;
23064   int i;
23065                     /* 012345678901234567 */
23066   const char *pow63 = "922337203685477580";
23067   for(i=0; c==0 && i<18; i++){
23068     c = (zNum[i*incr]-pow63[i])*10;
23069   }
23070   if( c==0 ){
23071     c = zNum[18*incr] - '8';
23072     testcase( c==(-1) );
23073     testcase( c==0 );
23074     testcase( c==(+1) );
23075   }
23076   return c;
23077 }
23078
23079
23080 /*
23081 ** Convert zNum to a 64-bit signed integer.
23082 **
23083 ** If the zNum value is representable as a 64-bit twos-complement 
23084 ** integer, then write that value into *pNum and return 0.
23085 **
23086 ** If zNum is exactly 9223372036854665808, return 2.  This special
23087 ** case is broken out because while 9223372036854665808 cannot be a 
23088 ** signed 64-bit integer, its negative -9223372036854665808 can be.
23089 **
23090 ** If zNum is too big for a 64-bit integer and is not
23091 ** 9223372036854665808 then return 1.
23092 **
23093 ** length is the number of bytes in the string (bytes, not characters).
23094 ** The string is not necessarily zero-terminated.  The encoding is
23095 ** given by enc.
23096 */
23097 SQLCIPHER_PRIVATE int sqlcipher3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
23098   int incr = (enc==SQLCIPHER_UTF8?1:2);
23099   u64 u = 0;
23100   int neg = 0; /* assume positive */
23101   int i;
23102   int c = 0;
23103   const char *zStart;
23104   const char *zEnd = zNum + length;
23105   if( enc==SQLCIPHER_UTF16BE ) zNum++;
23106   while( zNum<zEnd && sqlcipher3Isspace(*zNum) ) zNum+=incr;
23107   if( zNum<zEnd ){
23108     if( *zNum=='-' ){
23109       neg = 1;
23110       zNum+=incr;
23111     }else if( *zNum=='+' ){
23112       zNum+=incr;
23113     }
23114   }
23115   zStart = zNum;
23116   while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
23117   for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
23118     u = u*10 + c - '0';
23119   }
23120   if( u>LARGEST_INT64 ){
23121     *pNum = SMALLEST_INT64;
23122   }else if( neg ){
23123     *pNum = -(i64)u;
23124   }else{
23125     *pNum = (i64)u;
23126   }
23127   testcase( i==18 );
23128   testcase( i==19 );
23129   testcase( i==20 );
23130   if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr ){
23131     /* zNum is empty or contains non-numeric text or is longer
23132     ** than 19 digits (thus guaranteeing that it is too large) */
23133     return 1;
23134   }else if( i<19*incr ){
23135     /* Less than 19 digits, so we know that it fits in 64 bits */
23136     assert( u<=LARGEST_INT64 );
23137     return 0;
23138   }else{
23139     /* zNum is a 19-digit numbers.  Compare it against 9223372036854775808. */
23140     c = compare2pow63(zNum, incr);
23141     if( c<0 ){
23142       /* zNum is less than 9223372036854775808 so it fits */
23143       assert( u<=LARGEST_INT64 );
23144       return 0;
23145     }else if( c>0 ){
23146       /* zNum is greater than 9223372036854775808 so it overflows */
23147       return 1;
23148     }else{
23149       /* zNum is exactly 9223372036854775808.  Fits if negative.  The
23150       ** special case 2 overflow if positive */
23151       assert( u-1==LARGEST_INT64 );
23152       assert( (*pNum)==SMALLEST_INT64 );
23153       return neg ? 0 : 2;
23154     }
23155   }
23156 }
23157
23158 /*
23159 ** If zNum represents an integer that will fit in 32-bits, then set
23160 ** *pValue to that integer and return true.  Otherwise return false.
23161 **
23162 ** Any non-numeric characters that following zNum are ignored.
23163 ** This is different from sqlcipher3Atoi64() which requires the
23164 ** input number to be zero-terminated.
23165 */
23166 SQLCIPHER_PRIVATE int sqlcipher3GetInt32(const char *zNum, int *pValue){
23167   sqlcipher_int64 v = 0;
23168   int i, c;
23169   int neg = 0;
23170   if( zNum[0]=='-' ){
23171     neg = 1;
23172     zNum++;
23173   }else if( zNum[0]=='+' ){
23174     zNum++;
23175   }
23176   while( zNum[0]=='0' ) zNum++;
23177   for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
23178     v = v*10 + c;
23179   }
23180
23181   /* The longest decimal representation of a 32 bit integer is 10 digits:
23182   **
23183   **             1234567890
23184   **     2^31 -> 2147483648
23185   */
23186   testcase( i==10 );
23187   if( i>10 ){
23188     return 0;
23189   }
23190   testcase( v-neg==2147483647 );
23191   if( v-neg>2147483647 ){
23192     return 0;
23193   }
23194   if( neg ){
23195     v = -v;
23196   }
23197   *pValue = (int)v;
23198   return 1;
23199 }
23200
23201 /*
23202 ** Return a 32-bit integer value extracted from a string.  If the
23203 ** string is not an integer, just return 0.
23204 */
23205 SQLCIPHER_PRIVATE int sqlcipher3Atoi(const char *z){
23206   int x = 0;
23207   if( z ) sqlcipher3GetInt32(z, &x);
23208   return x;
23209 }
23210
23211 /*
23212 ** The variable-length integer encoding is as follows:
23213 **
23214 ** KEY:
23215 **         A = 0xxxxxxx    7 bits of data and one flag bit
23216 **         B = 1xxxxxxx    7 bits of data and one flag bit
23217 **         C = xxxxxxxx    8 bits of data
23218 **
23219 **  7 bits - A
23220 ** 14 bits - BA
23221 ** 21 bits - BBA
23222 ** 28 bits - BBBA
23223 ** 35 bits - BBBBA
23224 ** 42 bits - BBBBBA
23225 ** 49 bits - BBBBBBA
23226 ** 56 bits - BBBBBBBA
23227 ** 64 bits - BBBBBBBBC
23228 */
23229
23230 /*
23231 ** Write a 64-bit variable-length integer to memory starting at p[0].
23232 ** The length of data write will be between 1 and 9 bytes.  The number
23233 ** of bytes written is returned.
23234 **
23235 ** A variable-length integer consists of the lower 7 bits of each byte
23236 ** for all bytes that have the 8th bit set and one byte with the 8th
23237 ** bit clear.  Except, if we get to the 9th byte, it stores the full
23238 ** 8 bits and is the last byte.
23239 */
23240 SQLCIPHER_PRIVATE int sqlcipher3PutVarint(unsigned char *p, u64 v){
23241   int i, j, n;
23242   u8 buf[10];
23243   if( v & (((u64)0xff000000)<<32) ){
23244     p[8] = (u8)v;
23245     v >>= 8;
23246     for(i=7; i>=0; i--){
23247       p[i] = (u8)((v & 0x7f) | 0x80);
23248       v >>= 7;
23249     }
23250     return 9;
23251   }    
23252   n = 0;
23253   do{
23254     buf[n++] = (u8)((v & 0x7f) | 0x80);
23255     v >>= 7;
23256   }while( v!=0 );
23257   buf[0] &= 0x7f;
23258   assert( n<=9 );
23259   for(i=0, j=n-1; j>=0; j--, i++){
23260     p[i] = buf[j];
23261   }
23262   return n;
23263 }
23264
23265 /*
23266 ** This routine is a faster version of sqlcipher3PutVarint() that only
23267 ** works for 32-bit positive integers and which is optimized for
23268 ** the common case of small integers.  A MACRO version, putVarint32,
23269 ** is provided which inlines the single-byte case.  All code should use
23270 ** the MACRO version as this function assumes the single-byte case has
23271 ** already been handled.
23272 */
23273 SQLCIPHER_PRIVATE int sqlcipher3PutVarint32(unsigned char *p, u32 v){
23274 #ifndef putVarint32
23275   if( (v & ~0x7f)==0 ){
23276     p[0] = v;
23277     return 1;
23278   }
23279 #endif
23280   if( (v & ~0x3fff)==0 ){
23281     p[0] = (u8)((v>>7) | 0x80);
23282     p[1] = (u8)(v & 0x7f);
23283     return 2;
23284   }
23285   return sqlcipher3PutVarint(p, v);
23286 }
23287
23288 /*
23289 ** Bitmasks used by sqlcipher3GetVarint().  These precomputed constants
23290 ** are defined here rather than simply putting the constant expressions
23291 ** inline in order to work around bugs in the RVT compiler.
23292 **
23293 ** SLOT_2_0     A mask for  (0x7f<<14) | 0x7f
23294 **
23295 ** SLOT_4_2_0   A mask for  (0x7f<<28) | SLOT_2_0
23296 */
23297 #define SLOT_2_0     0x001fc07f
23298 #define SLOT_4_2_0   0xf01fc07f
23299
23300
23301 /*
23302 ** Read a 64-bit variable-length integer from memory starting at p[0].
23303 ** Return the number of bytes read.  The value is stored in *v.
23304 */
23305 SQLCIPHER_PRIVATE u8 sqlcipher3GetVarint(const unsigned char *p, u64 *v){
23306   u32 a,b,s;
23307
23308   a = *p;
23309   /* a: p0 (unmasked) */
23310   if (!(a&0x80))
23311   {
23312     *v = a;
23313     return 1;
23314   }
23315
23316   p++;
23317   b = *p;
23318   /* b: p1 (unmasked) */
23319   if (!(b&0x80))
23320   {
23321     a &= 0x7f;
23322     a = a<<7;
23323     a |= b;
23324     *v = a;
23325     return 2;
23326   }
23327
23328   /* Verify that constants are precomputed correctly */
23329   assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
23330   assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
23331
23332   p++;
23333   a = a<<14;
23334   a |= *p;
23335   /* a: p0<<14 | p2 (unmasked) */
23336   if (!(a&0x80))
23337   {
23338     a &= SLOT_2_0;
23339     b &= 0x7f;
23340     b = b<<7;
23341     a |= b;
23342     *v = a;
23343     return 3;
23344   }
23345
23346   /* CSE1 from below */
23347   a &= SLOT_2_0;
23348   p++;
23349   b = b<<14;
23350   b |= *p;
23351   /* b: p1<<14 | p3 (unmasked) */
23352   if (!(b&0x80))
23353   {
23354     b &= SLOT_2_0;
23355     /* moved CSE1 up */
23356     /* a &= (0x7f<<14)|(0x7f); */
23357     a = a<<7;
23358     a |= b;
23359     *v = a;
23360     return 4;
23361   }
23362
23363   /* a: p0<<14 | p2 (masked) */
23364   /* b: p1<<14 | p3 (unmasked) */
23365   /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
23366   /* moved CSE1 up */
23367   /* a &= (0x7f<<14)|(0x7f); */
23368   b &= SLOT_2_0;
23369   s = a;
23370   /* s: p0<<14 | p2 (masked) */
23371
23372   p++;
23373   a = a<<14;
23374   a |= *p;
23375   /* a: p0<<28 | p2<<14 | p4 (unmasked) */
23376   if (!(a&0x80))
23377   {
23378     /* we can skip these cause they were (effectively) done above in calc'ing s */
23379     /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
23380     /* b &= (0x7f<<14)|(0x7f); */
23381     b = b<<7;
23382     a |= b;
23383     s = s>>18;
23384     *v = ((u64)s)<<32 | a;
23385     return 5;
23386   }
23387
23388   /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
23389   s = s<<7;
23390   s |= b;
23391   /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
23392
23393   p++;
23394   b = b<<14;
23395   b |= *p;
23396   /* b: p1<<28 | p3<<14 | p5 (unmasked) */
23397   if (!(b&0x80))
23398   {
23399     /* we can skip this cause it was (effectively) done above in calc'ing s */
23400     /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
23401     a &= SLOT_2_0;
23402     a = a<<7;
23403     a |= b;
23404     s = s>>18;
23405     *v = ((u64)s)<<32 | a;
23406     return 6;
23407   }
23408
23409   p++;
23410   a = a<<14;
23411   a |= *p;
23412   /* a: p2<<28 | p4<<14 | p6 (unmasked) */
23413   if (!(a&0x80))
23414   {
23415     a &= SLOT_4_2_0;
23416     b &= SLOT_2_0;
23417     b = b<<7;
23418     a |= b;
23419     s = s>>11;
23420     *v = ((u64)s)<<32 | a;
23421     return 7;
23422   }
23423
23424   /* CSE2 from below */
23425   a &= SLOT_2_0;
23426   p++;
23427   b = b<<14;
23428   b |= *p;
23429   /* b: p3<<28 | p5<<14 | p7 (unmasked) */
23430   if (!(b&0x80))
23431   {
23432     b &= SLOT_4_2_0;
23433     /* moved CSE2 up */
23434     /* a &= (0x7f<<14)|(0x7f); */
23435     a = a<<7;
23436     a |= b;
23437     s = s>>4;
23438     *v = ((u64)s)<<32 | a;
23439     return 8;
23440   }
23441
23442   p++;
23443   a = a<<15;
23444   a |= *p;
23445   /* a: p4<<29 | p6<<15 | p8 (unmasked) */
23446
23447   /* moved CSE2 up */
23448   /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
23449   b &= SLOT_2_0;
23450   b = b<<8;
23451   a |= b;
23452
23453   s = s<<4;
23454   b = p[-4];
23455   b &= 0x7f;
23456   b = b>>3;
23457   s |= b;
23458
23459   *v = ((u64)s)<<32 | a;
23460
23461   return 9;
23462 }
23463
23464 /*
23465 ** Read a 32-bit variable-length integer from memory starting at p[0].
23466 ** Return the number of bytes read.  The value is stored in *v.
23467 **
23468 ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
23469 ** integer, then set *v to 0xffffffff.
23470 **
23471 ** A MACRO version, getVarint32, is provided which inlines the 
23472 ** single-byte case.  All code should use the MACRO version as 
23473 ** this function assumes the single-byte case has already been handled.
23474 */
23475 SQLCIPHER_PRIVATE u8 sqlcipher3GetVarint32(const unsigned char *p, u32 *v){
23476   u32 a,b;
23477
23478   /* The 1-byte case.  Overwhelmingly the most common.  Handled inline
23479   ** by the getVarin32() macro */
23480   a = *p;
23481   /* a: p0 (unmasked) */
23482 #ifndef getVarint32
23483   if (!(a&0x80))
23484   {
23485     /* Values between 0 and 127 */
23486     *v = a;
23487     return 1;
23488   }
23489 #endif
23490
23491   /* The 2-byte case */
23492   p++;
23493   b = *p;
23494   /* b: p1 (unmasked) */
23495   if (!(b&0x80))
23496   {
23497     /* Values between 128 and 16383 */
23498     a &= 0x7f;
23499     a = a<<7;
23500     *v = a | b;
23501     return 2;
23502   }
23503
23504   /* The 3-byte case */
23505   p++;
23506   a = a<<14;
23507   a |= *p;
23508   /* a: p0<<14 | p2 (unmasked) */
23509   if (!(a&0x80))
23510   {
23511     /* Values between 16384 and 2097151 */
23512     a &= (0x7f<<14)|(0x7f);
23513     b &= 0x7f;
23514     b = b<<7;
23515     *v = a | b;
23516     return 3;
23517   }
23518
23519   /* A 32-bit varint is used to store size information in btrees.
23520   ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
23521   ** A 3-byte varint is sufficient, for example, to record the size
23522   ** of a 1048569-byte BLOB or string.
23523   **
23524   ** We only unroll the first 1-, 2-, and 3- byte cases.  The very
23525   ** rare larger cases can be handled by the slower 64-bit varint
23526   ** routine.
23527   */
23528 #if 1
23529   {
23530     u64 v64;
23531     u8 n;
23532
23533     p -= 2;
23534     n = sqlcipher3GetVarint(p, &v64);
23535     assert( n>3 && n<=9 );
23536     if( (v64 & SQLCIPHER_MAX_U32)!=v64 ){
23537       *v = 0xffffffff;
23538     }else{
23539       *v = (u32)v64;
23540     }
23541     return n;
23542   }
23543
23544 #else
23545   /* For following code (kept for historical record only) shows an
23546   ** unrolling for the 3- and 4-byte varint cases.  This code is
23547   ** slightly faster, but it is also larger and much harder to test.
23548   */
23549   p++;
23550   b = b<<14;
23551   b |= *p;
23552   /* b: p1<<14 | p3 (unmasked) */
23553   if (!(b&0x80))
23554   {
23555     /* Values between 2097152 and 268435455 */
23556     b &= (0x7f<<14)|(0x7f);
23557     a &= (0x7f<<14)|(0x7f);
23558     a = a<<7;
23559     *v = a | b;
23560     return 4;
23561   }
23562
23563   p++;
23564   a = a<<14;
23565   a |= *p;
23566   /* a: p0<<28 | p2<<14 | p4 (unmasked) */
23567   if (!(a&0x80))
23568   {
23569     /* Values  between 268435456 and 34359738367 */
23570     a &= SLOT_4_2_0;
23571     b &= SLOT_4_2_0;
23572     b = b<<7;
23573     *v = a | b;
23574     return 5;
23575   }
23576
23577   /* We can only reach this point when reading a corrupt database
23578   ** file.  In that case we are not in any hurry.  Use the (relatively
23579   ** slow) general-purpose sqlcipher3GetVarint() routine to extract the
23580   ** value. */
23581   {
23582     u64 v64;
23583     u8 n;
23584
23585     p -= 4;
23586     n = sqlcipher3GetVarint(p, &v64);
23587     assert( n>5 && n<=9 );
23588     *v = (u32)v64;
23589     return n;
23590   }
23591 #endif
23592 }
23593
23594 /*
23595 ** Return the number of bytes that will be needed to store the given
23596 ** 64-bit integer.
23597 */
23598 SQLCIPHER_PRIVATE int sqlcipher3VarintLen(u64 v){
23599   int i = 0;
23600   do{
23601     i++;
23602     v >>= 7;
23603   }while( v!=0 && ALWAYS(i<9) );
23604   return i;
23605 }
23606
23607
23608 /*
23609 ** Read or write a four-byte big-endian integer value.
23610 */
23611 SQLCIPHER_PRIVATE u32 sqlcipher3Get4byte(const u8 *p){
23612   return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
23613 }
23614 SQLCIPHER_PRIVATE void sqlcipher3Put4byte(unsigned char *p, u32 v){
23615   p[0] = (u8)(v>>24);
23616   p[1] = (u8)(v>>16);
23617   p[2] = (u8)(v>>8);
23618   p[3] = (u8)v;
23619 }
23620
23621
23622
23623 /*
23624 ** Translate a single byte of Hex into an integer.
23625 ** This routine only works if h really is a valid hexadecimal
23626 ** character:  0..9a..fA..F
23627 */
23628 SQLCIPHER_PRIVATE u8 sqlcipher3HexToInt(int h){
23629   assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
23630 #ifdef SQLCIPHER_ASCII
23631   h += 9*(1&(h>>6));
23632 #endif
23633 #ifdef SQLCIPHER_EBCDIC
23634   h += 9*(1&~(h>>4));
23635 #endif
23636   return (u8)(h & 0xf);
23637 }
23638
23639 #if !defined(SQLCIPHER_OMIT_BLOB_LITERAL) || defined(SQLCIPHER_HAS_CODEC)
23640 /*
23641 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
23642 ** value.  Return a pointer to its binary value.  Space to hold the
23643 ** binary value has been obtained from malloc and must be freed by
23644 ** the calling routine.
23645 */
23646 SQLCIPHER_PRIVATE void *sqlcipher3HexToBlob(sqlcipher3 *db, const char *z, int n){
23647   char *zBlob;
23648   int i;
23649
23650   zBlob = (char *)sqlcipher3DbMallocRaw(db, n/2 + 1);
23651   n--;
23652   if( zBlob ){
23653     for(i=0; i<n; i+=2){
23654       zBlob[i/2] = (sqlcipher3HexToInt(z[i])<<4) | sqlcipher3HexToInt(z[i+1]);
23655     }
23656     zBlob[i/2] = 0;
23657   }
23658   return zBlob;
23659 }
23660 #endif /* !SQLCIPHER_OMIT_BLOB_LITERAL || SQLCIPHER_HAS_CODEC */
23661
23662 /*
23663 ** Log an error that is an API call on a connection pointer that should
23664 ** not have been used.  The "type" of connection pointer is given as the
23665 ** argument.  The zType is a word like "NULL" or "closed" or "invalid".
23666 */
23667 static void logBadConnection(const char *zType){
23668   sqlcipher3_log(SQLCIPHER_MISUSE, 
23669      "API call with %s database connection pointer",
23670      zType
23671   );
23672 }
23673
23674 /*
23675 ** Check to make sure we have a valid db pointer.  This test is not
23676 ** foolproof but it does provide some measure of protection against
23677 ** misuse of the interface such as passing in db pointers that are
23678 ** NULL or which have been previously closed.  If this routine returns
23679 ** 1 it means that the db pointer is valid and 0 if it should not be
23680 ** dereferenced for any reason.  The calling function should invoke
23681 ** SQLCIPHER_MISUSE immediately.
23682 **
23683 ** sqlcipher3SafetyCheckOk() requires that the db pointer be valid for
23684 ** use.  sqlcipher3SafetyCheckSickOrOk() allows a db pointer that failed to
23685 ** open properly and is not fit for general use but which can be
23686 ** used as an argument to sqlcipher3_errmsg() or sqlcipher3_close().
23687 */
23688 SQLCIPHER_PRIVATE int sqlcipher3SafetyCheckOk(sqlcipher3 *db){
23689   u32 magic;
23690   if( db==0 ){
23691     logBadConnection("NULL");
23692     return 0;
23693   }
23694   magic = db->magic;
23695   if( magic!=SQLCIPHER_MAGIC_OPEN ){
23696     if( sqlcipher3SafetyCheckSickOrOk(db) ){
23697       testcase( sqlcipher3GlobalConfig.xLog!=0 );
23698       logBadConnection("unopened");
23699     }
23700     return 0;
23701   }else{
23702     return 1;
23703   }
23704 }
23705 SQLCIPHER_PRIVATE int sqlcipher3SafetyCheckSickOrOk(sqlcipher3 *db){
23706   u32 magic;
23707   magic = db->magic;
23708   if( magic!=SQLCIPHER_MAGIC_SICK &&
23709       magic!=SQLCIPHER_MAGIC_OPEN &&
23710       magic!=SQLCIPHER_MAGIC_BUSY ){
23711     testcase( sqlcipher3GlobalConfig.xLog!=0 );
23712     logBadConnection("invalid");
23713     return 0;
23714   }else{
23715     return 1;
23716   }
23717 }
23718
23719 /*
23720 ** Attempt to add, substract, or multiply the 64-bit signed value iB against
23721 ** the other 64-bit signed integer at *pA and store the result in *pA.
23722 ** Return 0 on success.  Or if the operation would have resulted in an
23723 ** overflow, leave *pA unchanged and return 1.
23724 */
23725 SQLCIPHER_PRIVATE int sqlcipher3AddInt64(i64 *pA, i64 iB){
23726   i64 iA = *pA;
23727   testcase( iA==0 ); testcase( iA==1 );
23728   testcase( iB==-1 ); testcase( iB==0 );
23729   if( iB>=0 ){
23730     testcase( iA>0 && LARGEST_INT64 - iA == iB );
23731     testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
23732     if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
23733     *pA += iB;
23734   }else{
23735     testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
23736     testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
23737     if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
23738     *pA += iB;
23739   }
23740   return 0; 
23741 }
23742 SQLCIPHER_PRIVATE int sqlcipher3SubInt64(i64 *pA, i64 iB){
23743   testcase( iB==SMALLEST_INT64+1 );
23744   if( iB==SMALLEST_INT64 ){
23745     testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
23746     if( (*pA)>=0 ) return 1;
23747     *pA -= iB;
23748     return 0;
23749   }else{
23750     return sqlcipher3AddInt64(pA, -iB);
23751   }
23752 }
23753 #define TWOPOWER32 (((i64)1)<<32)
23754 #define TWOPOWER31 (((i64)1)<<31)
23755 SQLCIPHER_PRIVATE int sqlcipher3MulInt64(i64 *pA, i64 iB){
23756   i64 iA = *pA;
23757   i64 iA1, iA0, iB1, iB0, r;
23758
23759   iA1 = iA/TWOPOWER32;
23760   iA0 = iA % TWOPOWER32;
23761   iB1 = iB/TWOPOWER32;
23762   iB0 = iB % TWOPOWER32;
23763   if( iA1*iB1 != 0 ) return 1;
23764   assert( iA1*iB0==0 || iA0*iB1==0 );
23765   r = iA1*iB0 + iA0*iB1;
23766   testcase( r==(-TWOPOWER31)-1 );
23767   testcase( r==(-TWOPOWER31) );
23768   testcase( r==TWOPOWER31 );
23769   testcase( r==TWOPOWER31-1 );
23770   if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1;
23771   r *= TWOPOWER32;
23772   if( sqlcipher3AddInt64(&r, iA0*iB0) ) return 1;
23773   *pA = r;
23774   return 0;
23775 }
23776
23777 /*
23778 ** Compute the absolute value of a 32-bit signed integer, of possible.  Or 
23779 ** if the integer has a value of -2147483648, return +2147483647
23780 */
23781 SQLCIPHER_PRIVATE int sqlcipher3AbsInt32(int x){
23782   if( x>=0 ) return x;
23783   if( x==(int)0x80000000 ) return 0x7fffffff;
23784   return -x;
23785 }
23786
23787 #ifdef SQLCIPHER_ENABLE_8_3_NAMES
23788 /*
23789 ** If SQLCIPHER_ENABLE_8_3_NAMES is set at compile-time and if the database
23790 ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
23791 ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
23792 ** three characters, then shorten the suffix on z[] to be the last three
23793 ** characters of the original suffix.
23794 **
23795 ** If SQLCIPHER_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
23796 ** do the suffix shortening regardless of URI parameter.
23797 **
23798 ** Examples:
23799 **
23800 **     test.db-journal    =>   test.nal
23801 **     test.db-wal        =>   test.wal
23802 **     test.db-shm        =>   test.shm
23803 */
23804 SQLCIPHER_PRIVATE void sqlcipher3FileSuffix3(const char *zBaseFilename, char *z){
23805 #if SQLCIPHER_ENABLE_8_3_NAMES<2
23806   const char *zOk;
23807   zOk = sqlcipher3_uri_parameter(zBaseFilename, "8_3_names");
23808   if( zOk && sqlcipher3GetBoolean(zOk) )
23809 #endif
23810   {
23811     int i, sz;
23812     sz = sqlcipher3Strlen30(z);
23813     for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
23814     if( z[i]=='.' && ALWAYS(sz>i+4) ) memcpy(&z[i+1], &z[sz-3], 4);
23815   }
23816 }
23817 #endif
23818
23819 /************** End of util.c ************************************************/
23820 /************** Begin file hash.c ********************************************/
23821 /*
23822 ** 2001 September 22
23823 **
23824 ** The author disclaims copyright to this source code.  In place of
23825 ** a legal notice, here is a blessing:
23826 **
23827 **    May you do good and not evil.
23828 **    May you find forgiveness for yourself and forgive others.
23829 **    May you share freely, never taking more than you give.
23830 **
23831 *************************************************************************
23832 ** This is the implementation of generic hash-tables
23833 ** used in SQLite.
23834 */
23835 /* #include <assert.h> */
23836
23837 /* Turn bulk memory into a hash table object by initializing the
23838 ** fields of the Hash structure.
23839 **
23840 ** "pNew" is a pointer to the hash table that is to be initialized.
23841 */
23842 SQLCIPHER_PRIVATE void sqlcipher3HashInit(Hash *pNew){
23843   assert( pNew!=0 );
23844   pNew->first = 0;
23845   pNew->count = 0;
23846   pNew->htsize = 0;
23847   pNew->ht = 0;
23848 }
23849
23850 /* Remove all entries from a hash table.  Reclaim all memory.
23851 ** Call this routine to delete a hash table or to reset a hash table
23852 ** to the empty state.
23853 */
23854 SQLCIPHER_PRIVATE void sqlcipher3HashClear(Hash *pH){
23855   HashElem *elem;         /* For looping over all elements of the table */
23856
23857   assert( pH!=0 );
23858   elem = pH->first;
23859   pH->first = 0;
23860   sqlcipher3_free(pH->ht);
23861   pH->ht = 0;
23862   pH->htsize = 0;
23863   while( elem ){
23864     HashElem *next_elem = elem->next;
23865     sqlcipher3_free(elem);
23866     elem = next_elem;
23867   }
23868   pH->count = 0;
23869 }
23870
23871 /*
23872 ** The hashing function.
23873 */
23874 static unsigned int strHash(const char *z, int nKey){
23875   int h = 0;
23876   assert( nKey>=0 );
23877   while( nKey > 0  ){
23878     h = (h<<3) ^ h ^ sqlcipher3UpperToLower[(unsigned char)*z++];
23879     nKey--;
23880   }
23881   return h;
23882 }
23883
23884
23885 /* Link pNew element into the hash table pH.  If pEntry!=0 then also
23886 ** insert pNew into the pEntry hash bucket.
23887 */
23888 static void insertElement(
23889   Hash *pH,              /* The complete hash table */
23890   struct _ht *pEntry,    /* The entry into which pNew is inserted */
23891   HashElem *pNew         /* The element to be inserted */
23892 ){
23893   HashElem *pHead;       /* First element already in pEntry */
23894   if( pEntry ){
23895     pHead = pEntry->count ? pEntry->chain : 0;
23896     pEntry->count++;
23897     pEntry->chain = pNew;
23898   }else{
23899     pHead = 0;
23900   }
23901   if( pHead ){
23902     pNew->next = pHead;
23903     pNew->prev = pHead->prev;
23904     if( pHead->prev ){ pHead->prev->next = pNew; }
23905     else             { pH->first = pNew; }
23906     pHead->prev = pNew;
23907   }else{
23908     pNew->next = pH->first;
23909     if( pH->first ){ pH->first->prev = pNew; }
23910     pNew->prev = 0;
23911     pH->first = pNew;
23912   }
23913 }
23914
23915
23916 /* Resize the hash table so that it cantains "new_size" buckets.
23917 **
23918 ** The hash table might fail to resize if sqlcipher3_malloc() fails or
23919 ** if the new size is the same as the prior size.
23920 ** Return TRUE if the resize occurs and false if not.
23921 */
23922 static int rehash(Hash *pH, unsigned int new_size){
23923   struct _ht *new_ht;            /* The new hash table */
23924   HashElem *elem, *next_elem;    /* For looping over existing elements */
23925
23926 #if SQLCIPHER_MALLOC_SOFT_LIMIT>0
23927   if( new_size*sizeof(struct _ht)>SQLCIPHER_MALLOC_SOFT_LIMIT ){
23928     new_size = SQLCIPHER_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
23929   }
23930   if( new_size==pH->htsize ) return 0;
23931 #endif
23932
23933   /* The inability to allocates space for a larger hash table is
23934   ** a performance hit but it is not a fatal error.  So mark the
23935   ** allocation as a benign.
23936   */
23937   sqlcipher3BeginBenignMalloc();
23938   new_ht = (struct _ht *)sqlcipher3Malloc( new_size*sizeof(struct _ht) );
23939   sqlcipher3EndBenignMalloc();
23940
23941   if( new_ht==0 ) return 0;
23942   sqlcipher3_free(pH->ht);
23943   pH->ht = new_ht;
23944   pH->htsize = new_size = sqlcipher3MallocSize(new_ht)/sizeof(struct _ht);
23945   memset(new_ht, 0, new_size*sizeof(struct _ht));
23946   for(elem=pH->first, pH->first=0; elem; elem = next_elem){
23947     unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
23948     next_elem = elem->next;
23949     insertElement(pH, &new_ht[h], elem);
23950   }
23951   return 1;
23952 }
23953
23954 /* This function (for internal use only) locates an element in an
23955 ** hash table that matches the given key.  The hash for this key has
23956 ** already been computed and is passed as the 4th parameter.
23957 */
23958 static HashElem *findElementGivenHash(
23959   const Hash *pH,     /* The pH to be searched */
23960   const char *pKey,   /* The key we are searching for */
23961   int nKey,           /* Bytes in key (not counting zero terminator) */
23962   unsigned int h      /* The hash for this key. */
23963 ){
23964   HashElem *elem;                /* Used to loop thru the element list */
23965   int count;                     /* Number of elements left to test */
23966
23967   if( pH->ht ){
23968     struct _ht *pEntry = &pH->ht[h];
23969     elem = pEntry->chain;
23970     count = pEntry->count;
23971   }else{
23972     elem = pH->first;
23973     count = pH->count;
23974   }
23975   while( count-- && ALWAYS(elem) ){
23976     if( elem->nKey==nKey && sqlcipher3StrNICmp(elem->pKey,pKey,nKey)==0 ){ 
23977       return elem;
23978     }
23979     elem = elem->next;
23980   }
23981   return 0;
23982 }
23983
23984 /* Remove a single entry from the hash table given a pointer to that
23985 ** element and a hash on the element's key.
23986 */
23987 static void removeElementGivenHash(
23988   Hash *pH,         /* The pH containing "elem" */
23989   HashElem* elem,   /* The element to be removed from the pH */
23990   unsigned int h    /* Hash value for the element */
23991 ){
23992   struct _ht *pEntry;
23993   if( elem->prev ){
23994     elem->prev->next = elem->next; 
23995   }else{
23996     pH->first = elem->next;
23997   }
23998   if( elem->next ){
23999     elem->next->prev = elem->prev;
24000   }
24001   if( pH->ht ){
24002     pEntry = &pH->ht[h];
24003     if( pEntry->chain==elem ){
24004       pEntry->chain = elem->next;
24005     }
24006     pEntry->count--;
24007     assert( pEntry->count>=0 );
24008   }
24009   sqlcipher3_free( elem );
24010   pH->count--;
24011   if( pH->count<=0 ){
24012     assert( pH->first==0 );
24013     assert( pH->count==0 );
24014     sqlcipher3HashClear(pH);
24015   }
24016 }
24017
24018 /* Attempt to locate an element of the hash table pH with a key
24019 ** that matches pKey,nKey.  Return the data for this element if it is
24020 ** found, or NULL if there is no match.
24021 */
24022 SQLCIPHER_PRIVATE void *sqlcipher3HashFind(const Hash *pH, const char *pKey, int nKey){
24023   HashElem *elem;    /* The element that matches key */
24024   unsigned int h;    /* A hash on key */
24025
24026   assert( pH!=0 );
24027   assert( pKey!=0 );
24028   assert( nKey>=0 );
24029   if( pH->ht ){
24030     h = strHash(pKey, nKey) % pH->htsize;
24031   }else{
24032     h = 0;
24033   }
24034   elem = findElementGivenHash(pH, pKey, nKey, h);
24035   return elem ? elem->data : 0;
24036 }
24037
24038 /* Insert an element into the hash table pH.  The key is pKey,nKey
24039 ** and the data is "data".
24040 **
24041 ** If no element exists with a matching key, then a new
24042 ** element is created and NULL is returned.
24043 **
24044 ** If another element already exists with the same key, then the
24045 ** new data replaces the old data and the old data is returned.
24046 ** The key is not copied in this instance.  If a malloc fails, then
24047 ** the new data is returned and the hash table is unchanged.
24048 **
24049 ** If the "data" parameter to this function is NULL, then the
24050 ** element corresponding to "key" is removed from the hash table.
24051 */
24052 SQLCIPHER_PRIVATE void *sqlcipher3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
24053   unsigned int h;       /* the hash of the key modulo hash table size */
24054   HashElem *elem;       /* Used to loop thru the element list */
24055   HashElem *new_elem;   /* New element added to the pH */
24056
24057   assert( pH!=0 );
24058   assert( pKey!=0 );
24059   assert( nKey>=0 );
24060   if( pH->htsize ){
24061     h = strHash(pKey, nKey) % pH->htsize;
24062   }else{
24063     h = 0;
24064   }
24065   elem = findElementGivenHash(pH,pKey,nKey,h);
24066   if( elem ){
24067     void *old_data = elem->data;
24068     if( data==0 ){
24069       removeElementGivenHash(pH,elem,h);
24070     }else{
24071       elem->data = data;
24072       elem->pKey = pKey;
24073       assert(nKey==elem->nKey);
24074     }
24075     return old_data;
24076   }
24077   if( data==0 ) return 0;
24078   new_elem = (HashElem*)sqlcipher3Malloc( sizeof(HashElem) );
24079   if( new_elem==0 ) return data;
24080   new_elem->pKey = pKey;
24081   new_elem->nKey = nKey;
24082   new_elem->data = data;
24083   pH->count++;
24084   if( pH->count>=10 && pH->count > 2*pH->htsize ){
24085     if( rehash(pH, pH->count*2) ){
24086       assert( pH->htsize>0 );
24087       h = strHash(pKey, nKey) % pH->htsize;
24088     }
24089   }
24090   if( pH->ht ){
24091     insertElement(pH, &pH->ht[h], new_elem);
24092   }else{
24093     insertElement(pH, 0, new_elem);
24094   }
24095   return 0;
24096 }
24097
24098 /************** End of hash.c ************************************************/
24099 /************** Begin file opcodes.c *****************************************/
24100 /* Automatically generated.  Do not edit */
24101 /* See the mkopcodec.awk script for details. */
24102 #if !defined(SQLCIPHER_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLCIPHER_DEBUG)
24103 SQLCIPHER_PRIVATE const char *sqlcipher3OpcodeName(int i){
24104  static const char *const azName[] = { "?",
24105      /*   1 */ "Goto",
24106      /*   2 */ "Gosub",
24107      /*   3 */ "Return",
24108      /*   4 */ "Yield",
24109      /*   5 */ "HaltIfNull",
24110      /*   6 */ "Halt",
24111      /*   7 */ "Integer",
24112      /*   8 */ "Int64",
24113      /*   9 */ "String",
24114      /*  10 */ "Null",
24115      /*  11 */ "Blob",
24116      /*  12 */ "Variable",
24117      /*  13 */ "Move",
24118      /*  14 */ "Copy",
24119      /*  15 */ "SCopy",
24120      /*  16 */ "ResultRow",
24121      /*  17 */ "CollSeq",
24122      /*  18 */ "Function",
24123      /*  19 */ "Not",
24124      /*  20 */ "AddImm",
24125      /*  21 */ "MustBeInt",
24126      /*  22 */ "RealAffinity",
24127      /*  23 */ "Permutation",
24128      /*  24 */ "Compare",
24129      /*  25 */ "Jump",
24130      /*  26 */ "Once",
24131      /*  27 */ "If",
24132      /*  28 */ "IfNot",
24133      /*  29 */ "Column",
24134      /*  30 */ "Affinity",
24135      /*  31 */ "MakeRecord",
24136      /*  32 */ "Count",
24137      /*  33 */ "Savepoint",
24138      /*  34 */ "AutoCommit",
24139      /*  35 */ "Transaction",
24140      /*  36 */ "ReadCookie",
24141      /*  37 */ "SetCookie",
24142      /*  38 */ "VerifyCookie",
24143      /*  39 */ "OpenRead",
24144      /*  40 */ "OpenWrite",
24145      /*  41 */ "OpenAutoindex",
24146      /*  42 */ "OpenEphemeral",
24147      /*  43 */ "SorterOpen",
24148      /*  44 */ "OpenPseudo",
24149      /*  45 */ "Close",
24150      /*  46 */ "SeekLt",
24151      /*  47 */ "SeekLe",
24152      /*  48 */ "SeekGe",
24153      /*  49 */ "SeekGt",
24154      /*  50 */ "Seek",
24155      /*  51 */ "NotFound",
24156      /*  52 */ "Found",
24157      /*  53 */ "IsUnique",
24158      /*  54 */ "NotExists",
24159      /*  55 */ "Sequence",
24160      /*  56 */ "NewRowid",
24161      /*  57 */ "Insert",
24162      /*  58 */ "InsertInt",
24163      /*  59 */ "Delete",
24164      /*  60 */ "ResetCount",
24165      /*  61 */ "SorterCompare",
24166      /*  62 */ "SorterData",
24167      /*  63 */ "RowKey",
24168      /*  64 */ "RowData",
24169      /*  65 */ "Rowid",
24170      /*  66 */ "NullRow",
24171      /*  67 */ "Last",
24172      /*  68 */ "Or",
24173      /*  69 */ "And",
24174      /*  70 */ "SorterSort",
24175      /*  71 */ "Sort",
24176      /*  72 */ "Rewind",
24177      /*  73 */ "IsNull",
24178      /*  74 */ "NotNull",
24179      /*  75 */ "Ne",
24180      /*  76 */ "Eq",
24181      /*  77 */ "Gt",
24182      /*  78 */ "Le",
24183      /*  79 */ "Lt",
24184      /*  80 */ "Ge",
24185      /*  81 */ "SorterNext",
24186      /*  82 */ "BitAnd",
24187      /*  83 */ "BitOr",
24188      /*  84 */ "ShiftLeft",
24189      /*  85 */ "ShiftRight",
24190      /*  86 */ "Add",
24191      /*  87 */ "Subtract",
24192      /*  88 */ "Multiply",
24193      /*  89 */ "Divide",
24194      /*  90 */ "Remainder",
24195      /*  91 */ "Concat",
24196      /*  92 */ "Prev",
24197      /*  93 */ "BitNot",
24198      /*  94 */ "String8",
24199      /*  95 */ "Next",
24200      /*  96 */ "SorterInsert",
24201      /*  97 */ "IdxInsert",
24202      /*  98 */ "IdxDelete",
24203      /*  99 */ "IdxRowid",
24204      /* 100 */ "IdxLT",
24205      /* 101 */ "IdxGE",
24206      /* 102 */ "Destroy",
24207      /* 103 */ "Clear",
24208      /* 104 */ "CreateIndex",
24209      /* 105 */ "CreateTable",
24210      /* 106 */ "ParseSchema",
24211      /* 107 */ "LoadAnalysis",
24212      /* 108 */ "DropTable",
24213      /* 109 */ "DropIndex",
24214      /* 110 */ "DropTrigger",
24215      /* 111 */ "IntegrityCk",
24216      /* 112 */ "RowSetAdd",
24217      /* 113 */ "RowSetRead",
24218      /* 114 */ "RowSetTest",
24219      /* 115 */ "Program",
24220      /* 116 */ "Param",
24221      /* 117 */ "FkCounter",
24222      /* 118 */ "FkIfZero",
24223      /* 119 */ "MemMax",
24224      /* 120 */ "IfPos",
24225      /* 121 */ "IfNeg",
24226      /* 122 */ "IfZero",
24227      /* 123 */ "AggStep",
24228      /* 124 */ "AggFinal",
24229      /* 125 */ "Checkpoint",
24230      /* 126 */ "JournalMode",
24231      /* 127 */ "Vacuum",
24232      /* 128 */ "IncrVacuum",
24233      /* 129 */ "Expire",
24234      /* 130 */ "Real",
24235      /* 131 */ "TableLock",
24236      /* 132 */ "VBegin",
24237      /* 133 */ "VCreate",
24238      /* 134 */ "VDestroy",
24239      /* 135 */ "VOpen",
24240      /* 136 */ "VFilter",
24241      /* 137 */ "VColumn",
24242      /* 138 */ "VNext",
24243      /* 139 */ "VRename",
24244      /* 140 */ "VUpdate",
24245      /* 141 */ "ToText",
24246      /* 142 */ "ToBlob",
24247      /* 143 */ "ToNumeric",
24248      /* 144 */ "ToInt",
24249      /* 145 */ "ToReal",
24250      /* 146 */ "Pagecount",
24251      /* 147 */ "MaxPgcnt",
24252      /* 148 */ "Trace",
24253      /* 149 */ "Noop",
24254      /* 150 */ "Explain",
24255   };
24256   return azName[i];
24257 }
24258 #endif
24259
24260 /************** End of opcodes.c *********************************************/
24261 /************** Begin file os_os2.c ******************************************/
24262 /*
24263 ** 2006 Feb 14
24264 **
24265 ** The author disclaims copyright to this source code.  In place of
24266 ** a legal notice, here is a blessing:
24267 **
24268 **    May you do good and not evil.
24269 **    May you find forgiveness for yourself and forgive others.
24270 **    May you share freely, never taking more than you give.
24271 **
24272 ******************************************************************************
24273 **
24274 ** This file contains code that is specific to OS/2.
24275 */
24276
24277
24278 #if SQLCIPHER_OS_OS2
24279
24280 /*
24281 ** A Note About Memory Allocation:
24282 **
24283 ** This driver uses malloc()/free() directly rather than going through
24284 ** the SQLite-wrappers sqlcipher3_malloc()/sqlcipher3_free().  Those wrappers
24285 ** are designed for use on embedded systems where memory is scarce and
24286 ** malloc failures happen frequently.  OS/2 does not typically run on
24287 ** embedded systems, and when it does the developers normally have bigger
24288 ** problems to worry about than running out of memory.  So there is not
24289 ** a compelling need to use the wrappers.
24290 **
24291 ** But there is a good reason to not use the wrappers.  If we use the
24292 ** wrappers then we will get simulated malloc() failures within this
24293 ** driver.  And that causes all kinds of problems for our tests.  We
24294 ** could enhance SQLite to deal with simulated malloc failures within
24295 ** the OS driver, but the code to deal with those failure would not
24296 ** be exercised on Linux (which does not need to malloc() in the driver)
24297 ** and so we would have difficulty writing coverage tests for that
24298 ** code.  Better to leave the code out, we think.
24299 **
24300 ** The point of this discussion is as follows:  When creating a new
24301 ** OS layer for an embedded system, if you use this file as an example,
24302 ** avoid the use of malloc()/free().  Those routines work ok on OS/2
24303 ** desktops but not so well in embedded systems.
24304 */
24305
24306 /*
24307 ** Macros used to determine whether or not to use threads.
24308 */
24309 #if defined(SQLCIPHER_THREADSAFE) && SQLCIPHER_THREADSAFE
24310 # define SQLCIPHER_OS2_THREADS 1
24311 #endif
24312
24313 /*
24314 ** Include code that is common to all os_*.c files
24315 */
24316 /************** Include os_common.h in the middle of os_os2.c ****************/
24317 /************** Begin file os_common.h ***************************************/
24318 /*
24319 ** 2004 May 22
24320 **
24321 ** The author disclaims copyright to this source code.  In place of
24322 ** a legal notice, here is a blessing:
24323 **
24324 **    May you do good and not evil.
24325 **    May you find forgiveness for yourself and forgive others.
24326 **    May you share freely, never taking more than you give.
24327 **
24328 ******************************************************************************
24329 **
24330 ** This file contains macros and a little bit of code that is common to
24331 ** all of the platform-specific files (os_*.c) and is #included into those
24332 ** files.
24333 **
24334 ** This file should be #included by the os_*.c files only.  It is not a
24335 ** general purpose header file.
24336 */
24337 #ifndef _OS_COMMON_H_
24338 #define _OS_COMMON_H_
24339
24340 /*
24341 ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
24342 ** macro to SQLCIPHER_DEBUG and some older makefiles have not yet made the
24343 ** switch.  The following code should catch this problem at compile-time.
24344 */
24345 #ifdef MEMORY_DEBUG
24346 # error "The MEMORY_DEBUG macro is obsolete.  Use SQLCIPHER_DEBUG instead."
24347 #endif
24348
24349 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
24350 # ifndef SQLCIPHER_DEBUG_OS_TRACE
24351 #   define SQLCIPHER_DEBUG_OS_TRACE 0
24352 # endif
24353   int sqlcipher3OSTrace = SQLCIPHER_DEBUG_OS_TRACE;
24354 # define OSTRACE(X)          if( sqlcipher3OSTrace ) sqlcipher3DebugPrintf X
24355 #else
24356 # define OSTRACE(X)
24357 #endif
24358
24359 /*
24360 ** Macros for performance tracing.  Normally turned off.  Only works
24361 ** on i486 hardware.
24362 */
24363 #ifdef SQLCIPHER_PERFORMANCE_TRACE
24364
24365 /* 
24366 ** hwtime.h contains inline assembler code for implementing 
24367 ** high-performance timing routines.
24368 */
24369 /************** Include hwtime.h in the middle of os_common.h ****************/
24370 /************** Begin file hwtime.h ******************************************/
24371 /*
24372 ** 2008 May 27
24373 **
24374 ** The author disclaims copyright to this source code.  In place of
24375 ** a legal notice, here is a blessing:
24376 **
24377 **    May you do good and not evil.
24378 **    May you find forgiveness for yourself and forgive others.
24379 **    May you share freely, never taking more than you give.
24380 **
24381 ******************************************************************************
24382 **
24383 ** This file contains inline asm code for retrieving "high-performance"
24384 ** counters for x86 class CPUs.
24385 */
24386 #ifndef _HWTIME_H_
24387 #define _HWTIME_H_
24388
24389 /*
24390 ** The following routine only works on pentium-class (or newer) processors.
24391 ** It uses the RDTSC opcode to read the cycle count value out of the
24392 ** processor and returns that value.  This can be used for high-res
24393 ** profiling.
24394 */
24395 #if (defined(__GNUC__) || defined(_MSC_VER)) && \
24396       (defined(i386) || defined(__i386__) || defined(_M_IX86))
24397
24398   #if defined(__GNUC__)
24399
24400   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
24401      unsigned int lo, hi;
24402      __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
24403      return (sqlcipher_uint64)hi << 32 | lo;
24404   }
24405
24406   #elif defined(_MSC_VER)
24407
24408   __declspec(naked) __inline sqlcipher_uint64 __cdecl sqlcipher3Hwtime(void){
24409      __asm {
24410         rdtsc
24411         ret       ; return value at EDX:EAX
24412      }
24413   }
24414
24415   #endif
24416
24417 #elif (defined(__GNUC__) && defined(__x86_64__))
24418
24419   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
24420       unsigned long val;
24421       __asm__ __volatile__ ("rdtsc" : "=A" (val));
24422       return val;
24423   }
24424  
24425 #elif (defined(__GNUC__) && defined(__ppc__))
24426
24427   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
24428       unsigned long long retval;
24429       unsigned long junk;
24430       __asm__ __volatile__ ("\n\
24431           1:      mftbu   %1\n\
24432                   mftb    %L0\n\
24433                   mftbu   %0\n\
24434                   cmpw    %0,%1\n\
24435                   bne     1b"
24436                   : "=r" (retval), "=r" (junk));
24437       return retval;
24438   }
24439
24440 #else
24441
24442   #error Need implementation of sqlcipher3Hwtime() for your platform.
24443
24444   /*
24445   ** To compile without implementing sqlcipher3Hwtime() for your platform,
24446   ** you can remove the above #error and use the following
24447   ** stub function.  You will lose timing support for many
24448   ** of the debugging and testing utilities, but it should at
24449   ** least compile and run.
24450   */
24451 SQLCIPHER_PRIVATE   sqlcipher_uint64 sqlcipher3Hwtime(void){ return ((sqlcipher_uint64)0); }
24452
24453 #endif
24454
24455 #endif /* !defined(_HWTIME_H_) */
24456
24457 /************** End of hwtime.h **********************************************/
24458 /************** Continuing where we left off in os_common.h ******************/
24459
24460 static sqlcipher_uint64 g_start;
24461 static sqlcipher_uint64 g_elapsed;
24462 #define TIMER_START       g_start=sqlcipher3Hwtime()
24463 #define TIMER_END         g_elapsed=sqlcipher3Hwtime()-g_start
24464 #define TIMER_ELAPSED     g_elapsed
24465 #else
24466 #define TIMER_START
24467 #define TIMER_END
24468 #define TIMER_ELAPSED     ((sqlcipher_uint64)0)
24469 #endif
24470
24471 /*
24472 ** If we compile with the SQLCIPHER_TEST macro set, then the following block
24473 ** of code will give us the ability to simulate a disk I/O error.  This
24474 ** is used for testing the I/O recovery logic.
24475 */
24476 #ifdef SQLCIPHER_TEST
24477 SQLCIPHER_API int sqlcipher3_io_error_hit = 0;            /* Total number of I/O Errors */
24478 SQLCIPHER_API int sqlcipher3_io_error_hardhit = 0;        /* Number of non-benign errors */
24479 SQLCIPHER_API int sqlcipher3_io_error_pending = 0;        /* Count down to first I/O error */
24480 SQLCIPHER_API int sqlcipher3_io_error_persist = 0;        /* True if I/O errors persist */
24481 SQLCIPHER_API int sqlcipher3_io_error_benign = 0;         /* True if errors are benign */
24482 SQLCIPHER_API int sqlcipher3_diskfull_pending = 0;
24483 SQLCIPHER_API int sqlcipher3_diskfull = 0;
24484 #define SimulateIOErrorBenign(X) sqlcipher3_io_error_benign=(X)
24485 #define SimulateIOError(CODE)  \
24486   if( (sqlcipher3_io_error_persist && sqlcipher3_io_error_hit) \
24487        || sqlcipher3_io_error_pending-- == 1 )  \
24488               { local_ioerr(); CODE; }
24489 static void local_ioerr(){
24490   IOTRACE(("IOERR\n"));
24491   sqlcipher3_io_error_hit++;
24492   if( !sqlcipher3_io_error_benign ) sqlcipher3_io_error_hardhit++;
24493 }
24494 #define SimulateDiskfullError(CODE) \
24495    if( sqlcipher3_diskfull_pending ){ \
24496      if( sqlcipher3_diskfull_pending == 1 ){ \
24497        local_ioerr(); \
24498        sqlcipher3_diskfull = 1; \
24499        sqlcipher3_io_error_hit = 1; \
24500        CODE; \
24501      }else{ \
24502        sqlcipher3_diskfull_pending--; \
24503      } \
24504    }
24505 #else
24506 #define SimulateIOErrorBenign(X)
24507 #define SimulateIOError(A)
24508 #define SimulateDiskfullError(A)
24509 #endif
24510
24511 /*
24512 ** When testing, keep a count of the number of open files.
24513 */
24514 #ifdef SQLCIPHER_TEST
24515 SQLCIPHER_API int sqlcipher3_open_file_count = 0;
24516 #define OpenCounter(X)  sqlcipher3_open_file_count+=(X)
24517 #else
24518 #define OpenCounter(X)
24519 #endif
24520
24521 #endif /* !defined(_OS_COMMON_H_) */
24522
24523 /************** End of os_common.h *******************************************/
24524 /************** Continuing where we left off in os_os2.c *********************/
24525
24526 /* Forward references */
24527 typedef struct os2File os2File;         /* The file structure */
24528 typedef struct os2ShmNode os2ShmNode;   /* A shared descritive memory node */
24529 typedef struct os2ShmLink os2ShmLink;   /* A connection to shared-memory */
24530
24531 /*
24532 ** The os2File structure is subclass of sqlcipher3_file specific for the OS/2
24533 ** protability layer.
24534 */
24535 struct os2File {
24536   const sqlcipher3_io_methods *pMethod;  /* Always the first entry */
24537   HFILE h;                  /* Handle for accessing the file */
24538   int flags;                /* Flags provided to os2Open() */
24539   int locktype;             /* Type of lock currently held on this file */
24540   int szChunk;              /* Chunk size configured by FCNTL_CHUNK_SIZE */
24541   char *zFullPathCp;        /* Full path name of this file */
24542   os2ShmLink *pShmLink;     /* Instance of shared memory on this file */
24543 };
24544
24545 #define LOCK_TIMEOUT 10L /* the default locking timeout */
24546
24547 /*
24548 ** Missing from some versions of the OS/2 toolkit -
24549 ** used to allocate from high memory if possible
24550 */
24551 #ifndef OBJ_ANY
24552 # define OBJ_ANY 0x00000400
24553 #endif
24554
24555 /*****************************************************************************
24556 ** The next group of routines implement the I/O methods specified
24557 ** by the sqlcipher3_io_methods object.
24558 ******************************************************************************/
24559
24560 /*
24561 ** Close a file.
24562 */
24563 static int os2Close( sqlcipher3_file *id ){
24564   APIRET rc;
24565   os2File *pFile = (os2File*)id;
24566
24567   assert( id!=0 );
24568   OSTRACE(( "CLOSE %d (%s)\n", pFile->h, pFile->zFullPathCp ));
24569
24570   rc = DosClose( pFile->h );
24571
24572   if( pFile->flags & SQLCIPHER_OPEN_DELETEONCLOSE )
24573     DosForceDelete( (PSZ)pFile->zFullPathCp );
24574
24575   free( pFile->zFullPathCp );
24576   pFile->zFullPathCp = NULL;
24577   pFile->locktype = NO_LOCK;
24578   pFile->h = (HFILE)-1;
24579   pFile->flags = 0;
24580
24581   OpenCounter( -1 );
24582   return rc == NO_ERROR ? SQLCIPHER_OK : SQLCIPHER_IOERR;
24583 }
24584
24585 /*
24586 ** Read data from a file into a buffer.  Return SQLCIPHER_OK if all
24587 ** bytes were read successfully and SQLCIPHER_IOERR if anything goes
24588 ** wrong.
24589 */
24590 static int os2Read(
24591   sqlcipher3_file *id,               /* File to read from */
24592   void *pBuf,                     /* Write content into this buffer */
24593   int amt,                        /* Number of bytes to read */
24594   sqlcipher3_int64 offset            /* Begin reading at this offset */
24595 ){
24596   ULONG fileLocation = 0L;
24597   ULONG got;
24598   os2File *pFile = (os2File*)id;
24599   assert( id!=0 );
24600   SimulateIOError( return SQLCIPHER_IOERR_READ );
24601   OSTRACE(( "READ %d lock=%d\n", pFile->h, pFile->locktype ));
24602   if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
24603     return SQLCIPHER_IOERR;
24604   }
24605   if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
24606     return SQLCIPHER_IOERR_READ;
24607   }
24608   if( got == (ULONG)amt )
24609     return SQLCIPHER_OK;
24610   else {
24611     /* Unread portions of the input buffer must be zero-filled */
24612     memset(&((char*)pBuf)[got], 0, amt-got);
24613     return SQLCIPHER_IOERR_SHORT_READ;
24614   }
24615 }
24616
24617 /*
24618 ** Write data from a buffer into a file.  Return SQLCIPHER_OK on success
24619 ** or some other error code on failure.
24620 */
24621 static int os2Write(
24622   sqlcipher3_file *id,               /* File to write into */
24623   const void *pBuf,               /* The bytes to be written */
24624   int amt,                        /* Number of bytes to write */
24625   sqlcipher3_int64 offset            /* Offset into the file to begin writing at */
24626 ){
24627   ULONG fileLocation = 0L;
24628   APIRET rc = NO_ERROR;
24629   ULONG wrote;
24630   os2File *pFile = (os2File*)id;
24631   assert( id!=0 );
24632   SimulateIOError( return SQLCIPHER_IOERR_WRITE );
24633   SimulateDiskfullError( return SQLCIPHER_FULL );
24634   OSTRACE(( "WRITE %d lock=%d\n", pFile->h, pFile->locktype ));
24635   if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
24636     return SQLCIPHER_IOERR;
24637   }
24638   assert( amt>0 );
24639   while( amt > 0 &&
24640          ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&
24641          wrote > 0
24642   ){
24643     amt -= wrote;
24644     pBuf = &((char*)pBuf)[wrote];
24645   }
24646
24647   return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLCIPHER_FULL : SQLCIPHER_OK;
24648 }
24649
24650 /*
24651 ** Truncate an open file to a specified size
24652 */
24653 static int os2Truncate( sqlcipher3_file *id, i64 nByte ){
24654   APIRET rc;
24655   os2File *pFile = (os2File*)id;
24656   assert( id!=0 );
24657   OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
24658   SimulateIOError( return SQLCIPHER_IOERR_TRUNCATE );
24659
24660   /* If the user has configured a chunk-size for this file, truncate the
24661   ** file so that it consists of an integer number of chunks (i.e. the
24662   ** actual file size after the operation may be larger than the requested
24663   ** size).
24664   */
24665   if( pFile->szChunk ){
24666     nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
24667   }
24668   
24669   rc = DosSetFileSize( pFile->h, nByte );
24670   return rc == NO_ERROR ? SQLCIPHER_OK : SQLCIPHER_IOERR_TRUNCATE;
24671 }
24672
24673 #ifdef SQLCIPHER_TEST
24674 /*
24675 ** Count the number of fullsyncs and normal syncs.  This is used to test
24676 ** that syncs and fullsyncs are occuring at the right times.
24677 */
24678 SQLCIPHER_API int sqlcipher3_sync_count = 0;
24679 SQLCIPHER_API int sqlcipher3_fullsync_count = 0;
24680 #endif
24681
24682 /*
24683 ** Make sure all writes to a particular file are committed to disk.
24684 */
24685 static int os2Sync( sqlcipher3_file *id, int flags ){
24686   os2File *pFile = (os2File*)id;
24687   OSTRACE(( "SYNC %d lock=%d\n", pFile->h, pFile->locktype ));
24688 #ifdef SQLCIPHER_TEST
24689   if( flags & SQLCIPHER_SYNC_FULL){
24690     sqlcipher3_fullsync_count++;
24691   }
24692   sqlcipher3_sync_count++;
24693 #endif
24694   /* If we compiled with the SQLCIPHER_NO_SYNC flag, then syncing is a
24695   ** no-op
24696   */
24697 #ifdef SQLCIPHER_NO_SYNC
24698   UNUSED_PARAMETER(pFile);
24699   return SQLCIPHER_OK;
24700 #else
24701   return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLCIPHER_OK : SQLCIPHER_IOERR;
24702 #endif
24703 }
24704
24705 /*
24706 ** Determine the current size of a file in bytes
24707 */
24708 static int os2FileSize( sqlcipher3_file *id, sqlcipher3_int64 *pSize ){
24709   APIRET rc = NO_ERROR;
24710   FILESTATUS3 fsts3FileInfo;
24711   memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
24712   assert( id!=0 );
24713   SimulateIOError( return SQLCIPHER_IOERR_FSTAT );
24714   rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
24715   if( rc == NO_ERROR ){
24716     *pSize = fsts3FileInfo.cbFile;
24717     return SQLCIPHER_OK;
24718   }else{
24719     return SQLCIPHER_IOERR_FSTAT;
24720   }
24721 }
24722
24723 /*
24724 ** Acquire a reader lock.
24725 */
24726 static int getReadLock( os2File *pFile ){
24727   FILELOCK  LockArea,
24728             UnlockArea;
24729   APIRET res;
24730   memset(&LockArea, 0, sizeof(LockArea));
24731   memset(&UnlockArea, 0, sizeof(UnlockArea));
24732   LockArea.lOffset = SHARED_FIRST;
24733   LockArea.lRange = SHARED_SIZE;
24734   UnlockArea.lOffset = 0L;
24735   UnlockArea.lRange = 0L;
24736   res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
24737   OSTRACE(( "GETREADLOCK %d res=%d\n", pFile->h, res ));
24738   return res;
24739 }
24740
24741 /*
24742 ** Undo a readlock
24743 */
24744 static int unlockReadLock( os2File *id ){
24745   FILELOCK  LockArea,
24746             UnlockArea;
24747   APIRET res;
24748   memset(&LockArea, 0, sizeof(LockArea));
24749   memset(&UnlockArea, 0, sizeof(UnlockArea));
24750   LockArea.lOffset = 0L;
24751   LockArea.lRange = 0L;
24752   UnlockArea.lOffset = SHARED_FIRST;
24753   UnlockArea.lRange = SHARED_SIZE;
24754   res = DosSetFileLocks( id->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
24755   OSTRACE(( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res ));
24756   return res;
24757 }
24758
24759 /*
24760 ** Lock the file with the lock specified by parameter locktype - one
24761 ** of the following:
24762 **
24763 **     (1) SHARED_LOCK
24764 **     (2) RESERVED_LOCK
24765 **     (3) PENDING_LOCK
24766 **     (4) EXCLUSIVE_LOCK
24767 **
24768 ** Sometimes when requesting one lock state, additional lock states
24769 ** are inserted in between.  The locking might fail on one of the later
24770 ** transitions leaving the lock state different from what it started but
24771 ** still short of its goal.  The following chart shows the allowed
24772 ** transitions and the inserted intermediate states:
24773 **
24774 **    UNLOCKED -> SHARED
24775 **    SHARED -> RESERVED
24776 **    SHARED -> (PENDING) -> EXCLUSIVE
24777 **    RESERVED -> (PENDING) -> EXCLUSIVE
24778 **    PENDING -> EXCLUSIVE
24779 **
24780 ** This routine will only increase a lock.  The os2Unlock() routine
24781 ** erases all locks at once and returns us immediately to locking level 0.
24782 ** It is not possible to lower the locking level one step at a time.  You
24783 ** must go straight to locking level 0.
24784 */
24785 static int os2Lock( sqlcipher3_file *id, int locktype ){
24786   int rc = SQLCIPHER_OK;       /* Return code from subroutines */
24787   APIRET res = NO_ERROR;    /* Result of an OS/2 lock call */
24788   int newLocktype;       /* Set pFile->locktype to this value before exiting */
24789   int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
24790   FILELOCK  LockArea,
24791             UnlockArea;
24792   os2File *pFile = (os2File*)id;
24793   memset(&LockArea, 0, sizeof(LockArea));
24794   memset(&UnlockArea, 0, sizeof(UnlockArea));
24795   assert( pFile!=0 );
24796   OSTRACE(( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype ));
24797
24798   /* If there is already a lock of this type or more restrictive on the
24799   ** os2File, do nothing. Don't use the end_lock: exit path, as
24800   ** sqlcipher3_mutex_enter() hasn't been called yet.
24801   */
24802   if( pFile->locktype>=locktype ){
24803     OSTRACE(( "LOCK %d %d ok (already held)\n", pFile->h, locktype ));
24804     return SQLCIPHER_OK;
24805   }
24806
24807   /* Make sure the locking sequence is correct
24808   */
24809   assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
24810   assert( locktype!=PENDING_LOCK );
24811   assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
24812
24813   /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
24814   ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of
24815   ** the PENDING_LOCK byte is temporary.
24816   */
24817   newLocktype = pFile->locktype;
24818   if( pFile->locktype==NO_LOCK
24819       || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
24820   ){
24821     LockArea.lOffset = PENDING_BYTE;
24822     LockArea.lRange = 1L;
24823     UnlockArea.lOffset = 0L;
24824     UnlockArea.lRange = 0L;
24825
24826     /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
24827     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 100L, 0L );
24828     if( res == NO_ERROR ){
24829       gotPendingLock = 1;
24830       OSTRACE(( "LOCK %d pending lock boolean set.  res=%d\n", pFile->h, res ));
24831     }
24832   }
24833
24834   /* Acquire a shared lock
24835   */
24836   if( locktype==SHARED_LOCK && res == NO_ERROR ){
24837     assert( pFile->locktype==NO_LOCK );
24838     res = getReadLock(pFile);
24839     if( res == NO_ERROR ){
24840       newLocktype = SHARED_LOCK;
24841     }
24842     OSTRACE(( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res ));
24843   }
24844
24845   /* Acquire a RESERVED lock
24846   */
24847   if( locktype==RESERVED_LOCK && res == NO_ERROR ){
24848     assert( pFile->locktype==SHARED_LOCK );
24849     LockArea.lOffset = RESERVED_BYTE;
24850     LockArea.lRange = 1L;
24851     UnlockArea.lOffset = 0L;
24852     UnlockArea.lRange = 0L;
24853     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
24854     if( res == NO_ERROR ){
24855       newLocktype = RESERVED_LOCK;
24856     }
24857     OSTRACE(( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res ));
24858   }
24859
24860   /* Acquire a PENDING lock
24861   */
24862   if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
24863     newLocktype = PENDING_LOCK;
24864     gotPendingLock = 0;
24865     OSTRACE(( "LOCK %d acquire pending lock. pending lock boolean unset.\n",
24866                pFile->h ));
24867   }
24868
24869   /* Acquire an EXCLUSIVE lock
24870   */
24871   if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
24872     assert( pFile->locktype>=SHARED_LOCK );
24873     res = unlockReadLock(pFile);
24874     OSTRACE(( "unreadlock = %d\n", res ));
24875     LockArea.lOffset = SHARED_FIRST;
24876     LockArea.lRange = SHARED_SIZE;
24877     UnlockArea.lOffset = 0L;
24878     UnlockArea.lRange = 0L;
24879     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
24880     if( res == NO_ERROR ){
24881       newLocktype = EXCLUSIVE_LOCK;
24882     }else{
24883       OSTRACE(( "OS/2 error-code = %d\n", res ));
24884       getReadLock(pFile);
24885     }
24886     OSTRACE(( "LOCK %d acquire exclusive lock.  res=%d\n", pFile->h, res ));
24887   }
24888
24889   /* If we are holding a PENDING lock that ought to be released, then
24890   ** release it now.
24891   */
24892   if( gotPendingLock && locktype==SHARED_LOCK ){
24893     int r;
24894     LockArea.lOffset = 0L;
24895     LockArea.lRange = 0L;
24896     UnlockArea.lOffset = PENDING_BYTE;
24897     UnlockArea.lRange = 1L;
24898     r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
24899     OSTRACE(( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r ));
24900   }
24901
24902   /* Update the state of the lock has held in the file descriptor then
24903   ** return the appropriate result code.
24904   */
24905   if( res == NO_ERROR ){
24906     rc = SQLCIPHER_OK;
24907   }else{
24908     OSTRACE(( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
24909               locktype, newLocktype ));
24910     rc = SQLCIPHER_BUSY;
24911   }
24912   pFile->locktype = newLocktype;
24913   OSTRACE(( "LOCK %d now %d\n", pFile->h, pFile->locktype ));
24914   return rc;
24915 }
24916
24917 /*
24918 ** This routine checks if there is a RESERVED lock held on the specified
24919 ** file by this or any other process. If such a lock is held, return
24920 ** non-zero, otherwise zero.
24921 */
24922 static int os2CheckReservedLock( sqlcipher3_file *id, int *pOut ){
24923   int r = 0;
24924   os2File *pFile = (os2File*)id;
24925   assert( pFile!=0 );
24926   if( pFile->locktype>=RESERVED_LOCK ){
24927     r = 1;
24928     OSTRACE(( "TEST WR-LOCK %d %d (local)\n", pFile->h, r ));
24929   }else{
24930     FILELOCK  LockArea,
24931               UnlockArea;
24932     APIRET rc = NO_ERROR;
24933     memset(&LockArea, 0, sizeof(LockArea));
24934     memset(&UnlockArea, 0, sizeof(UnlockArea));
24935     LockArea.lOffset = RESERVED_BYTE;
24936     LockArea.lRange = 1L;
24937     UnlockArea.lOffset = 0L;
24938     UnlockArea.lRange = 0L;
24939     rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
24940     OSTRACE(( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc ));
24941     if( rc == NO_ERROR ){
24942       APIRET rcu = NO_ERROR; /* return code for unlocking */
24943       LockArea.lOffset = 0L;
24944       LockArea.lRange = 0L;
24945       UnlockArea.lOffset = RESERVED_BYTE;
24946       UnlockArea.lRange = 1L;
24947       rcu = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
24948       OSTRACE(( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, rcu ));
24949     }
24950     r = !(rc == NO_ERROR);
24951     OSTRACE(( "TEST WR-LOCK %d %d (remote)\n", pFile->h, r ));
24952   }
24953   *pOut = r;
24954   return SQLCIPHER_OK;
24955 }
24956
24957 /*
24958 ** Lower the locking level on file descriptor id to locktype.  locktype
24959 ** must be either NO_LOCK or SHARED_LOCK.
24960 **
24961 ** If the locking level of the file descriptor is already at or below
24962 ** the requested locking level, this routine is a no-op.
24963 **
24964 ** It is not possible for this routine to fail if the second argument
24965 ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
24966 ** might return SQLCIPHER_IOERR;
24967 */
24968 static int os2Unlock( sqlcipher3_file *id, int locktype ){
24969   int type;
24970   os2File *pFile = (os2File*)id;
24971   APIRET rc = SQLCIPHER_OK;
24972   APIRET res = NO_ERROR;
24973   FILELOCK  LockArea,
24974             UnlockArea;
24975   memset(&LockArea, 0, sizeof(LockArea));
24976   memset(&UnlockArea, 0, sizeof(UnlockArea));
24977   assert( pFile!=0 );
24978   assert( locktype<=SHARED_LOCK );
24979   OSTRACE(( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype ));
24980   type = pFile->locktype;
24981   if( type>=EXCLUSIVE_LOCK ){
24982     LockArea.lOffset = 0L;
24983     LockArea.lRange = 0L;
24984     UnlockArea.lOffset = SHARED_FIRST;
24985     UnlockArea.lRange = SHARED_SIZE;
24986     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
24987     OSTRACE(( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res ));
24988     if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
24989       /* This should never happen.  We should always be able to
24990       ** reacquire the read lock */
24991       OSTRACE(( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype ));
24992       rc = SQLCIPHER_IOERR_UNLOCK;
24993     }
24994   }
24995   if( type>=RESERVED_LOCK ){
24996     LockArea.lOffset = 0L;
24997     LockArea.lRange = 0L;
24998     UnlockArea.lOffset = RESERVED_BYTE;
24999     UnlockArea.lRange = 1L;
25000     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
25001     OSTRACE(( "UNLOCK %d reserved res=%d\n", pFile->h, res ));
25002   }
25003   if( locktype==NO_LOCK && type>=SHARED_LOCK ){
25004     res = unlockReadLock(pFile);
25005     OSTRACE(( "UNLOCK %d is %d want %d res=%d\n",
25006               pFile->h, type, locktype, res ));
25007   }
25008   if( type>=PENDING_LOCK ){
25009     LockArea.lOffset = 0L;
25010     LockArea.lRange = 0L;
25011     UnlockArea.lOffset = PENDING_BYTE;
25012     UnlockArea.lRange = 1L;
25013     res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
25014     OSTRACE(( "UNLOCK %d pending res=%d\n", pFile->h, res ));
25015   }
25016   pFile->locktype = locktype;
25017   OSTRACE(( "UNLOCK %d now %d\n", pFile->h, pFile->locktype ));
25018   return rc;
25019 }
25020
25021 /*
25022 ** Control and query of the open file handle.
25023 */
25024 static int os2FileControl(sqlcipher3_file *id, int op, void *pArg){
25025   switch( op ){
25026     case SQLCIPHER_FCNTL_LOCKSTATE: {
25027       *(int*)pArg = ((os2File*)id)->locktype;
25028       OSTRACE(( "FCNTL_LOCKSTATE %d lock=%d\n",
25029                 ((os2File*)id)->h, ((os2File*)id)->locktype ));
25030       return SQLCIPHER_OK;
25031     }
25032     case SQLCIPHER_FCNTL_CHUNK_SIZE: {
25033       ((os2File*)id)->szChunk = *(int*)pArg;
25034       return SQLCIPHER_OK;
25035     }
25036     case SQLCIPHER_FCNTL_SIZE_HINT: {
25037       sqlcipher3_int64 sz = *(sqlcipher3_int64*)pArg;
25038       SimulateIOErrorBenign(1);
25039       os2Truncate(id, sz);
25040       SimulateIOErrorBenign(0);
25041       return SQLCIPHER_OK;
25042     }
25043     case SQLCIPHER_FCNTL_SYNC_OMITTED: {
25044       return SQLCIPHER_OK;
25045     }
25046   }
25047   return SQLCIPHER_NOTFOUND;
25048 }
25049
25050 /*
25051 ** Return the sector size in bytes of the underlying block device for
25052 ** the specified file. This is almost always 512 bytes, but may be
25053 ** larger for some devices.
25054 **
25055 ** SQLite code assumes this function cannot fail. It also assumes that
25056 ** if two files are created in the same file-system directory (i.e.
25057 ** a database and its journal file) that the sector size will be the
25058 ** same for both.
25059 */
25060 static int os2SectorSize(sqlcipher3_file *id){
25061   UNUSED_PARAMETER(id);
25062   return SQLCIPHER_DEFAULT_SECTOR_SIZE;
25063 }
25064
25065 /*
25066 ** Return a vector of device characteristics.
25067 */
25068 static int os2DeviceCharacteristics(sqlcipher3_file *id){
25069   UNUSED_PARAMETER(id);
25070   return SQLCIPHER_IOCAP_UNDELETABLE_WHEN_OPEN;
25071 }
25072
25073
25074 /*
25075 ** Character set conversion objects used by conversion routines.
25076 */
25077 static UconvObject ucUtf8 = NULL; /* convert between UTF-8 and UCS-2 */
25078 static UconvObject uclCp = NULL;  /* convert between local codepage and UCS-2 */
25079
25080 /*
25081 ** Helper function to initialize the conversion objects from and to UTF-8.
25082 */
25083 static void initUconvObjects( void ){
25084   if( UniCreateUconvObject( UTF_8, &ucUtf8 ) != ULS_SUCCESS )
25085     ucUtf8 = NULL;
25086   if ( UniCreateUconvObject( (UniChar *)L"@path=yes", &uclCp ) != ULS_SUCCESS )
25087     uclCp = NULL;
25088 }
25089
25090 /*
25091 ** Helper function to free the conversion objects from and to UTF-8.
25092 */
25093 static void freeUconvObjects( void ){
25094   if ( ucUtf8 )
25095     UniFreeUconvObject( ucUtf8 );
25096   if ( uclCp )
25097     UniFreeUconvObject( uclCp );
25098   ucUtf8 = NULL;
25099   uclCp = NULL;
25100 }
25101
25102 /*
25103 ** Helper function to convert UTF-8 filenames to local OS/2 codepage.
25104 ** The two-step process: first convert the incoming UTF-8 string
25105 ** into UCS-2 and then from UCS-2 to the current codepage.
25106 ** The returned char pointer has to be freed.
25107 */
25108 static char *convertUtf8PathToCp( const char *in ){
25109   UniChar tempPath[CCHMAXPATH];
25110   char *out = (char *)calloc( CCHMAXPATH, 1 );
25111
25112   if( !out )
25113     return NULL;
25114
25115   if( !ucUtf8 || !uclCp )
25116     initUconvObjects();
25117
25118   /* determine string for the conversion of UTF-8 which is CP1208 */
25119   if( UniStrToUcs( ucUtf8, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
25120     return out; /* if conversion fails, return the empty string */
25121
25122   /* conversion for current codepage which can be used for paths */
25123   UniStrFromUcs( uclCp, out, tempPath, CCHMAXPATH );
25124
25125   return out;
25126 }
25127
25128 /*
25129 ** Helper function to convert filenames from local codepage to UTF-8.
25130 ** The two-step process: first convert the incoming codepage-specific
25131 ** string into UCS-2 and then from UCS-2 to the codepage of UTF-8.
25132 ** The returned char pointer has to be freed.
25133 **
25134 ** This function is non-static to be able to use this in shell.c and
25135 ** similar applications that take command line arguments.
25136 */
25137 char *convertCpPathToUtf8( const char *in ){
25138   UniChar tempPath[CCHMAXPATH];
25139   char *out = (char *)calloc( CCHMAXPATH, 1 );
25140
25141   if( !out )
25142     return NULL;
25143
25144   if( !ucUtf8 || !uclCp )
25145     initUconvObjects();
25146
25147   /* conversion for current codepage which can be used for paths */
25148   if( UniStrToUcs( uclCp, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
25149     return out; /* if conversion fails, return the empty string */
25150
25151   /* determine string for the conversion of UTF-8 which is CP1208 */
25152   UniStrFromUcs( ucUtf8, out, tempPath, CCHMAXPATH );
25153
25154   return out;
25155 }
25156
25157
25158 #ifndef SQLCIPHER_OMIT_WAL
25159
25160 /*
25161 ** Use main database file for interprocess locking. If un-defined
25162 ** a separate file is created for this purpose. The file will be
25163 ** used only to set file locks. There will be no data written to it.
25164 */
25165 #define SQLCIPHER_OS2_NO_WAL_LOCK_FILE     
25166
25167 #if 0
25168 static void _ERR_TRACE( const char *fmt, ... ) {
25169   va_list  ap;
25170   va_start(ap, fmt);
25171   vfprintf(stderr, fmt, ap);
25172   fflush(stderr);
25173 }
25174 #define ERR_TRACE(rc, msg)        \
25175         if( (rc) != SQLCIPHER_OK ) _ERR_TRACE msg;
25176 #else
25177 #define ERR_TRACE(rc, msg)
25178 #endif
25179
25180 /*
25181 ** Helper functions to obtain and relinquish the global mutex. The
25182 ** global mutex is used to protect os2ShmNodeList.
25183 **
25184 ** Function os2ShmMutexHeld() is used to assert() that the global mutex 
25185 ** is held when required. This function is only used as part of assert() 
25186 ** statements. e.g.
25187 **
25188 **   os2ShmEnterMutex()
25189 **     assert( os2ShmMutexHeld() );
25190 **   os2ShmLeaveMutex()
25191 */
25192 static void os2ShmEnterMutex(void){
25193   sqlcipher3_mutex_enter(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
25194 }
25195 static void os2ShmLeaveMutex(void){
25196   sqlcipher3_mutex_leave(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
25197 }
25198 #ifdef SQLCIPHER_DEBUG
25199 static int os2ShmMutexHeld(void) {
25200   return sqlcipher3_mutex_held(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
25201 }
25202 int GetCurrentProcessId(void) {
25203   PPIB pib;
25204   DosGetInfoBlocks(NULL, &pib);
25205   return (int)pib->pib_ulpid;
25206 }
25207 #endif
25208
25209 /*
25210 ** Object used to represent a the shared memory area for a single log file.
25211 ** When multiple threads all reference the same log-summary, each thread has
25212 ** its own os2File object, but they all point to a single instance of this 
25213 ** object.  In other words, each log-summary is opened only once per process.
25214 **
25215 ** os2ShmMutexHeld() must be true when creating or destroying
25216 ** this object or while reading or writing the following fields:
25217 **
25218 **      nRef
25219 **      pNext 
25220 **
25221 ** The following fields are read-only after the object is created:
25222 ** 
25223 **      szRegion
25224 **      hLockFile
25225 **      shmBaseName
25226 **
25227 ** Either os2ShmNode.mutex must be held or os2ShmNode.nRef==0 and
25228 ** os2ShmMutexHeld() is true when reading or writing any other field
25229 ** in this structure.
25230 **
25231 */
25232 struct os2ShmNode {
25233   sqlcipher3_mutex *mutex;      /* Mutex to access this object */
25234   os2ShmNode *pNext;         /* Next in list of all os2ShmNode objects */
25235
25236   int szRegion;              /* Size of shared-memory regions */
25237
25238   int nRegion;               /* Size of array apRegion */
25239   void **apRegion;           /* Array of pointers to shared-memory regions */
25240
25241   int nRef;                  /* Number of os2ShmLink objects pointing to this */
25242   os2ShmLink *pFirst;        /* First os2ShmLink object pointing to this */
25243
25244   HFILE hLockFile;           /* File used for inter-process memory locking */
25245   char shmBaseName[1];       /* Name of the memory object !!! must last !!! */
25246 };
25247
25248
25249 /*
25250 ** Structure used internally by this VFS to record the state of an
25251 ** open shared memory connection.
25252 **
25253 ** The following fields are initialized when this object is created and
25254 ** are read-only thereafter:
25255 **
25256 **    os2Shm.pShmNode
25257 **    os2Shm.id
25258 **
25259 ** All other fields are read/write.  The os2Shm.pShmNode->mutex must be held
25260 ** while accessing any read/write fields.
25261 */
25262 struct os2ShmLink {
25263   os2ShmNode *pShmNode;      /* The underlying os2ShmNode object */
25264   os2ShmLink *pNext;         /* Next os2Shm with the same os2ShmNode */
25265   u32 sharedMask;            /* Mask of shared locks held */
25266   u32 exclMask;              /* Mask of exclusive locks held */
25267 #ifdef SQLCIPHER_DEBUG
25268   u8 id;                     /* Id of this connection with its os2ShmNode */
25269 #endif
25270 };
25271
25272
25273 /*
25274 ** A global list of all os2ShmNode objects.
25275 **
25276 ** The os2ShmMutexHeld() must be true while reading or writing this list.
25277 */
25278 static os2ShmNode *os2ShmNodeList = NULL;
25279
25280 /*
25281 ** Constants used for locking
25282 */
25283 #ifdef  SQLCIPHER_OS2_NO_WAL_LOCK_FILE
25284 #define OS2_SHM_BASE   (PENDING_BYTE + 0x10000)         /* first lock byte */
25285 #else
25286 #define OS2_SHM_BASE   ((22+SQLCIPHER_SHM_NLOCK)*4)        /* first lock byte */
25287 #endif
25288
25289 #define OS2_SHM_DMS    (OS2_SHM_BASE+SQLCIPHER_SHM_NLOCK)  /* deadman switch */
25290
25291 /*
25292 ** Apply advisory locks for all n bytes beginning at ofst.
25293 */
25294 #define _SHM_UNLCK  1   /* no lock */
25295 #define _SHM_RDLCK  2   /* shared lock, no wait */
25296 #define _SHM_WRLCK  3   /* exlusive lock, no wait */
25297 #define _SHM_WRLCK_WAIT 4 /* exclusive lock, wait */
25298 static int os2ShmSystemLock(
25299   os2ShmNode *pNode,    /* Apply locks to this open shared-memory segment */
25300   int lockType,         /* _SHM_UNLCK, _SHM_RDLCK, _SHM_WRLCK or _SHM_WRLCK_WAIT */
25301   int ofst,             /* Offset to first byte to be locked/unlocked */
25302   int nByte             /* Number of bytes to lock or unlock */
25303 ){
25304   APIRET rc;
25305   FILELOCK area;
25306   ULONG mode, timeout;
25307
25308   /* Access to the os2ShmNode object is serialized by the caller */
25309   assert( sqlcipher3_mutex_held(pNode->mutex) || pNode->nRef==0 );
25310
25311   mode = 1;     /* shared lock */
25312   timeout = 0;  /* no wait */
25313   area.lOffset = ofst;
25314   area.lRange = nByte;
25315
25316   switch( lockType ) {
25317     case _SHM_WRLCK_WAIT:
25318       timeout = (ULONG)-1;      /* wait forever */
25319     case _SHM_WRLCK:
25320       mode = 0;                 /* exclusive lock */
25321     case _SHM_RDLCK:
25322       rc = DosSetFileLocks(pNode->hLockFile, 
25323                            NULL, &area, timeout, mode);
25324       break;
25325     /* case _SHM_UNLCK: */
25326     default:
25327       rc = DosSetFileLocks(pNode->hLockFile, 
25328                            &area, NULL, 0, 0);
25329       break;
25330   }
25331                           
25332   OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n", 
25333            pNode->hLockFile,
25334            rc==SQLCIPHER_OK ? "ok" : "failed",
25335            lockType==_SHM_UNLCK ? "Unlock" : "Lock",
25336            rc));
25337
25338   ERR_TRACE(rc, ("os2ShmSystemLock: %d %s\n", rc, pNode->shmBaseName))
25339
25340   return ( rc == 0 ) ?  SQLCIPHER_OK : SQLCIPHER_BUSY;
25341 }
25342
25343 /*
25344 ** Find an os2ShmNode in global list or allocate a new one, if not found.
25345 **
25346 ** This is not a VFS shared-memory method; it is a utility function called
25347 ** by VFS shared-memory methods.
25348 */
25349 static int os2OpenSharedMemory( os2File *fd, int szRegion ) {
25350   os2ShmLink *pLink;
25351   os2ShmNode *pNode;
25352   int cbShmName, rc = SQLCIPHER_OK;
25353   char shmName[CCHMAXPATH + 30];
25354 #ifndef SQLCIPHER_OS2_NO_WAL_LOCK_FILE
25355   ULONG action;
25356 #endif
25357   
25358   /* We need some additional space at the end to append the region number */
25359   cbShmName = sprintf(shmName, "\\SHAREMEM\\%s", fd->zFullPathCp );
25360   if( cbShmName >= CCHMAXPATH-8 )
25361     return SQLCIPHER_IOERR_SHMOPEN; 
25362
25363   /* Replace colon in file name to form a valid shared memory name */
25364   shmName[10+1] = '!';
25365
25366   /* Allocate link object (we free it later in case of failure) */
25367   pLink = sqlcipher3_malloc( sizeof(*pLink) );
25368   if( !pLink )
25369     return SQLCIPHER_NOMEM;
25370
25371   /* Access node list */
25372   os2ShmEnterMutex();
25373
25374   /* Find node by it's shared memory base name */
25375   for( pNode = os2ShmNodeList; 
25376        pNode && stricmp(shmName, pNode->shmBaseName) != 0; 
25377        pNode = pNode->pNext )   ;
25378
25379   /* Not found: allocate a new node */
25380   if( !pNode ) {
25381     pNode = sqlcipher3_malloc( sizeof(*pNode) + cbShmName );
25382     if( pNode ) {
25383       memset(pNode, 0, sizeof(*pNode) );
25384       pNode->szRegion = szRegion;
25385       pNode->hLockFile = (HFILE)-1;      
25386       strcpy(pNode->shmBaseName, shmName);
25387
25388 #ifdef SQLCIPHER_OS2_NO_WAL_LOCK_FILE
25389       if( DosDupHandle(fd->h, &pNode->hLockFile) != 0 ) {
25390 #else
25391       sprintf(shmName, "%s-lck", fd->zFullPathCp);
25392       if( DosOpen((PSZ)shmName, &pNode->hLockFile, &action, 0, FILE_NORMAL, 
25393                   OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
25394                   OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE | 
25395                   OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR,
25396                   NULL) != 0 ) {
25397 #endif
25398         sqlcipher3_free(pNode);  
25399         rc = SQLCIPHER_IOERR;
25400       } else {
25401         pNode->mutex = sqlcipher3_mutex_alloc(SQLCIPHER_MUTEX_FAST);
25402         if( !pNode->mutex ) {
25403           sqlcipher3_free(pNode);  
25404           rc = SQLCIPHER_NOMEM;
25405         }
25406       }   
25407     } else {
25408       rc = SQLCIPHER_NOMEM;
25409     }
25410     
25411     if( rc == SQLCIPHER_OK ) {
25412       pNode->pNext = os2ShmNodeList;
25413       os2ShmNodeList = pNode;
25414     } else {
25415       pNode = NULL;
25416     }
25417   } else if( pNode->szRegion != szRegion ) {
25418     rc = SQLCIPHER_IOERR_SHMSIZE;
25419     pNode = NULL;
25420   }
25421
25422   if( pNode ) {
25423     sqlcipher3_mutex_enter(pNode->mutex);
25424
25425     memset(pLink, 0, sizeof(*pLink));
25426
25427     pLink->pShmNode = pNode;
25428     pLink->pNext = pNode->pFirst;
25429     pNode->pFirst = pLink;
25430     pNode->nRef++;
25431
25432     fd->pShmLink = pLink;
25433
25434     sqlcipher3_mutex_leave(pNode->mutex);
25435     
25436   } else {
25437     /* Error occured. Free our link object. */
25438     sqlcipher3_free(pLink);  
25439   }
25440
25441   os2ShmLeaveMutex();
25442
25443   ERR_TRACE(rc, ("os2OpenSharedMemory: %d  %s\n", rc, fd->zFullPathCp))  
25444   
25445   return rc;
25446 }
25447
25448 /*
25449 ** Purge the os2ShmNodeList list of all entries with nRef==0.
25450 **
25451 ** This is not a VFS shared-memory method; it is a utility function called
25452 ** by VFS shared-memory methods.
25453 */
25454 static void os2PurgeShmNodes( int deleteFlag ) {
25455   os2ShmNode *pNode;
25456   os2ShmNode **ppNode;
25457
25458   os2ShmEnterMutex();
25459   
25460   ppNode = &os2ShmNodeList;
25461
25462   while( *ppNode ) {
25463     pNode = *ppNode;
25464
25465     if( pNode->nRef == 0 ) {
25466       *ppNode = pNode->pNext;   
25467      
25468       if( pNode->apRegion ) {
25469         /* Prevent other processes from resizing the shared memory */
25470         os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
25471
25472         while( pNode->nRegion-- ) {
25473 #ifdef SQLCIPHER_DEBUG
25474           int rc = 
25475 #endif          
25476           DosFreeMem(pNode->apRegion[pNode->nRegion]);
25477
25478           OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
25479                   (int)GetCurrentProcessId(), pNode->nRegion,
25480                   rc == 0 ? "ok" : "failed"));
25481         }
25482
25483         /* Allow other processes to resize the shared memory */
25484         os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
25485
25486         sqlcipher3_free(pNode->apRegion);
25487       }  
25488
25489       DosClose(pNode->hLockFile);
25490       
25491 #ifndef SQLCIPHER_OS2_NO_WAL_LOCK_FILE
25492       if( deleteFlag ) {
25493          char fileName[CCHMAXPATH];
25494          /* Skip "\\SHAREMEM\\" */
25495          sprintf(fileName, "%s-lck", pNode->shmBaseName + 10);
25496          /* restore colon */
25497          fileName[1] = ':';
25498          
25499          DosForceDelete(fileName); 
25500       }
25501 #endif
25502
25503       sqlcipher3_mutex_free(pNode->mutex);
25504
25505       sqlcipher3_free(pNode);
25506       
25507     } else {
25508       ppNode = &pNode->pNext;
25509     }
25510   } 
25511
25512   os2ShmLeaveMutex();
25513 }
25514
25515 /*
25516 ** This function is called to obtain a pointer to region iRegion of the
25517 ** shared-memory associated with the database file id. Shared-memory regions
25518 ** are numbered starting from zero. Each shared-memory region is szRegion
25519 ** bytes in size.
25520 **
25521 ** If an error occurs, an error code is returned and *pp is set to NULL.
25522 **
25523 ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
25524 ** region has not been allocated (by any client, including one running in a
25525 ** separate process), then *pp is set to NULL and SQLCIPHER_OK returned. If
25526 ** bExtend is non-zero and the requested shared-memory region has not yet
25527 ** been allocated, it is allocated by this function.
25528 **
25529 ** If the shared-memory region has already been allocated or is allocated by
25530 ** this call as described above, then it is mapped into this processes
25531 ** address space (if it is not already), *pp is set to point to the mapped
25532 ** memory and SQLCIPHER_OK returned.
25533 */
25534 static int os2ShmMap(
25535   sqlcipher3_file *id,               /* Handle open on database file */
25536   int iRegion,                    /* Region to retrieve */
25537   int szRegion,                   /* Size of regions */
25538   int bExtend,                    /* True to extend block if necessary */
25539   void volatile **pp              /* OUT: Mapped memory */
25540 ){
25541   PVOID pvTemp;
25542   void **apRegion;
25543   os2ShmNode *pNode;
25544   int n, rc = SQLCIPHER_OK;
25545   char shmName[CCHMAXPATH];
25546   os2File *pFile = (os2File*)id;
25547   
25548   *pp = NULL;
25549
25550   if( !pFile->pShmLink )
25551     rc = os2OpenSharedMemory( pFile, szRegion );
25552   
25553   if( rc == SQLCIPHER_OK ) {
25554     pNode = pFile->pShmLink->pShmNode ;
25555     
25556     sqlcipher3_mutex_enter(pNode->mutex);
25557     
25558     assert( szRegion==pNode->szRegion );
25559
25560     /* Unmapped region ? */
25561     if( iRegion >= pNode->nRegion ) {
25562       /* Prevent other processes from resizing the shared memory */
25563       os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
25564
25565       apRegion = sqlcipher3_realloc(
25566         pNode->apRegion, (iRegion + 1) * sizeof(apRegion[0]));
25567
25568       if( apRegion ) {
25569         pNode->apRegion = apRegion;
25570
25571         while( pNode->nRegion <= iRegion ) {
25572           sprintf(shmName, "%s-%u", 
25573                   pNode->shmBaseName, pNode->nRegion);
25574
25575           if( DosGetNamedSharedMem(&pvTemp, (PSZ)shmName, 
25576                 PAG_READ | PAG_WRITE) != NO_ERROR ) {
25577             if( !bExtend )
25578               break;
25579
25580             if( DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
25581                   PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_ANY) != NO_ERROR && 
25582                 DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
25583                   PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR ) { 
25584               rc = SQLCIPHER_NOMEM;
25585               break;
25586             }
25587           }
25588
25589           apRegion[pNode->nRegion++] = pvTemp;
25590         }
25591
25592         /* zero out remaining entries */ 
25593         for( n = pNode->nRegion; n <= iRegion; n++ )
25594           pNode->apRegion[n] = NULL;
25595
25596         /* Return this region (maybe zero) */
25597         *pp = pNode->apRegion[iRegion];
25598       } else {
25599         rc = SQLCIPHER_NOMEM;
25600       }
25601
25602       /* Allow other processes to resize the shared memory */
25603       os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
25604       
25605     } else {
25606       /* Region has been mapped previously */
25607       *pp = pNode->apRegion[iRegion];
25608     }
25609
25610     sqlcipher3_mutex_leave(pNode->mutex);
25611   } 
25612
25613   ERR_TRACE(rc, ("os2ShmMap: %s iRgn = %d, szRgn = %d, bExt = %d : %d\n", 
25614                  pFile->zFullPathCp, iRegion, szRegion, bExtend, rc))
25615           
25616   return rc;
25617 }
25618
25619 /*
25620 ** Close a connection to shared-memory.  Delete the underlying
25621 ** storage if deleteFlag is true.
25622 **
25623 ** If there is no shared memory associated with the connection then this
25624 ** routine is a harmless no-op.
25625 */
25626 static int os2ShmUnmap(
25627   sqlcipher3_file *id,               /* The underlying database file */
25628   int deleteFlag                  /* Delete shared-memory if true */
25629 ){
25630   os2File *pFile = (os2File*)id;
25631   os2ShmLink *pLink = pFile->pShmLink;
25632   
25633   if( pLink ) {
25634     int nRef = -1;
25635     os2ShmLink **ppLink;
25636     os2ShmNode *pNode = pLink->pShmNode;
25637
25638     sqlcipher3_mutex_enter(pNode->mutex);
25639     
25640     for( ppLink = &pNode->pFirst;
25641          *ppLink && *ppLink != pLink;
25642          ppLink = &(*ppLink)->pNext )   ;
25643          
25644     assert(*ppLink);
25645
25646     if( *ppLink ) {
25647       *ppLink = pLink->pNext;
25648       nRef = --pNode->nRef;
25649     } else {
25650       ERR_TRACE(1, ("os2ShmUnmap: link not found ! %s\n", 
25651                     pNode->shmBaseName))
25652     }
25653     
25654     pFile->pShmLink = NULL;
25655     sqlcipher3_free(pLink);
25656
25657     sqlcipher3_mutex_leave(pNode->mutex);
25658     
25659     if( nRef == 0 )
25660       os2PurgeShmNodes( deleteFlag );
25661   }
25662
25663   return SQLCIPHER_OK;
25664 }
25665
25666 /*
25667 ** Change the lock state for a shared-memory segment.
25668 **
25669 ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
25670 ** different here than in posix.  In xShmLock(), one can go from unlocked
25671 ** to shared and back or from unlocked to exclusive and back.  But one may
25672 ** not go from shared to exclusive or from exclusive to shared.
25673 */
25674 static int os2ShmLock(
25675   sqlcipher3_file *id,          /* Database file holding the shared memory */
25676   int ofst,                  /* First lock to acquire or release */
25677   int n,                     /* Number of locks to acquire or release */
25678   int flags                  /* What to do with the lock */
25679 ){
25680   u32 mask;                             /* Mask of locks to take or release */
25681   int rc = SQLCIPHER_OK;                   /* Result code */
25682   os2File *pFile = (os2File*)id;
25683   os2ShmLink *p = pFile->pShmLink;      /* The shared memory being locked */
25684   os2ShmLink *pX;                       /* For looping over all siblings */
25685   os2ShmNode *pShmNode = p->pShmNode;   /* Our node */
25686   
25687   assert( ofst>=0 && ofst+n<=SQLCIPHER_SHM_NLOCK );
25688   assert( n>=1 );
25689   assert( flags==(SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_SHARED)
25690        || flags==(SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_EXCLUSIVE)
25691        || flags==(SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_SHARED)
25692        || flags==(SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_EXCLUSIVE) );
25693   assert( n==1 || (flags & SQLCIPHER_SHM_EXCLUSIVE)!=0 );
25694
25695   mask = (u32)((1U<<(ofst+n)) - (1U<<ofst));
25696   assert( n>1 || mask==(1<<ofst) );
25697
25698
25699   sqlcipher3_mutex_enter(pShmNode->mutex);
25700
25701   if( flags & SQLCIPHER_SHM_UNLOCK ){
25702     u32 allMask = 0; /* Mask of locks held by siblings */
25703
25704     /* See if any siblings hold this same lock */
25705     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
25706       if( pX==p ) continue;
25707       assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
25708       allMask |= pX->sharedMask;
25709     }
25710
25711     /* Unlock the system-level locks */
25712     if( (mask & allMask)==0 ){
25713       rc = os2ShmSystemLock(pShmNode, _SHM_UNLCK, ofst+OS2_SHM_BASE, n);
25714     }else{
25715       rc = SQLCIPHER_OK;
25716     }
25717
25718     /* Undo the local locks */
25719     if( rc==SQLCIPHER_OK ){
25720       p->exclMask &= ~mask;
25721       p->sharedMask &= ~mask;
25722     } 
25723   }else if( flags & SQLCIPHER_SHM_SHARED ){
25724     u32 allShared = 0;  /* Union of locks held by connections other than "p" */
25725
25726     /* Find out which shared locks are already held by sibling connections.
25727     ** If any sibling already holds an exclusive lock, go ahead and return
25728     ** SQLCIPHER_BUSY.
25729     */
25730     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
25731       if( (pX->exclMask & mask)!=0 ){
25732         rc = SQLCIPHER_BUSY;
25733         break;
25734       }
25735       allShared |= pX->sharedMask;
25736     }
25737
25738     /* Get shared locks at the system level, if necessary */
25739     if( rc==SQLCIPHER_OK ){
25740       if( (allShared & mask)==0 ){
25741         rc = os2ShmSystemLock(pShmNode, _SHM_RDLCK, ofst+OS2_SHM_BASE, n);
25742       }else{
25743         rc = SQLCIPHER_OK;
25744       }
25745     }
25746
25747     /* Get the local shared locks */
25748     if( rc==SQLCIPHER_OK ){
25749       p->sharedMask |= mask;
25750     }
25751   }else{
25752     /* Make sure no sibling connections hold locks that will block this
25753     ** lock.  If any do, return SQLCIPHER_BUSY right away.
25754     */
25755     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
25756       if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
25757         rc = SQLCIPHER_BUSY;
25758         break;
25759       }
25760     }
25761   
25762     /* Get the exclusive locks at the system level.  Then if successful
25763     ** also mark the local connection as being locked.
25764     */
25765     if( rc==SQLCIPHER_OK ){
25766       rc = os2ShmSystemLock(pShmNode, _SHM_WRLCK, ofst+OS2_SHM_BASE, n);
25767       if( rc==SQLCIPHER_OK ){
25768         assert( (p->sharedMask & mask)==0 );
25769         p->exclMask |= mask;
25770       }
25771     }
25772   }
25773
25774   sqlcipher3_mutex_leave(pShmNode->mutex);
25775   
25776   OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
25777            p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
25778            rc ? "failed" : "ok"));
25779
25780   ERR_TRACE(rc, ("os2ShmLock: ofst = %d, n = %d, flags = 0x%x -> %d \n", 
25781                  ofst, n, flags, rc))
25782                   
25783   return rc; 
25784 }
25785
25786 /*
25787 ** Implement a memory barrier or memory fence on shared memory.
25788 **
25789 ** All loads and stores begun before the barrier must complete before
25790 ** any load or store begun after the barrier.
25791 */
25792 static void os2ShmBarrier(
25793   sqlcipher3_file *id                /* Database file holding the shared memory */
25794 ){
25795   UNUSED_PARAMETER(id);
25796   os2ShmEnterMutex();
25797   os2ShmLeaveMutex();
25798 }
25799
25800 #else
25801 # define os2ShmMap     0
25802 # define os2ShmLock    0
25803 # define os2ShmBarrier 0
25804 # define os2ShmUnmap   0
25805 #endif /* #ifndef SQLCIPHER_OMIT_WAL */
25806
25807
25808 /*
25809 ** This vector defines all the methods that can operate on an
25810 ** sqlcipher3_file for os2.
25811 */
25812 static const sqlcipher3_io_methods os2IoMethod = {
25813   2,                              /* iVersion */
25814   os2Close,                       /* xClose */
25815   os2Read,                        /* xRead */
25816   os2Write,                       /* xWrite */
25817   os2Truncate,                    /* xTruncate */
25818   os2Sync,                        /* xSync */
25819   os2FileSize,                    /* xFileSize */
25820   os2Lock,                        /* xLock */
25821   os2Unlock,                      /* xUnlock */
25822   os2CheckReservedLock,           /* xCheckReservedLock */
25823   os2FileControl,                 /* xFileControl */
25824   os2SectorSize,                  /* xSectorSize */
25825   os2DeviceCharacteristics,       /* xDeviceCharacteristics */
25826   os2ShmMap,                      /* xShmMap */
25827   os2ShmLock,                     /* xShmLock */
25828   os2ShmBarrier,                  /* xShmBarrier */
25829   os2ShmUnmap                     /* xShmUnmap */
25830 };
25831
25832
25833 /***************************************************************************
25834 ** Here ends the I/O methods that form the sqlcipher3_io_methods object.
25835 **
25836 ** The next block of code implements the VFS methods.
25837 ****************************************************************************/
25838
25839 /*
25840 ** Create a temporary file name in zBuf.  zBuf must be big enough to
25841 ** hold at pVfs->mxPathname characters.
25842 */
25843 static int getTempname(int nBuf, char *zBuf ){
25844   static const char zChars[] =
25845     "abcdefghijklmnopqrstuvwxyz"
25846     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
25847     "0123456789";
25848   int i, j;
25849   PSZ zTempPathCp;      
25850   char zTempPath[CCHMAXPATH];
25851   ULONG ulDriveNum, ulDriveMap;
25852   
25853   /* It's odd to simulate an io-error here, but really this is just
25854   ** using the io-error infrastructure to test that SQLite handles this
25855   ** function failing. 
25856   */
25857   SimulateIOError( return SQLCIPHER_IOERR );
25858
25859   if( sqlcipher3_temp_directory ) {
25860     sqlcipher3_snprintf(CCHMAXPATH-30, zTempPath, "%s", sqlcipher3_temp_directory);
25861   } else if( DosScanEnv( (PSZ)"TEMP",   &zTempPathCp ) == NO_ERROR ||
25862              DosScanEnv( (PSZ)"TMP",    &zTempPathCp ) == NO_ERROR ||
25863              DosScanEnv( (PSZ)"TMPDIR", &zTempPathCp ) == NO_ERROR ) {
25864     char *zTempPathUTF = convertCpPathToUtf8( (char *)zTempPathCp );
25865     sqlcipher3_snprintf(CCHMAXPATH-30, zTempPath, "%s", zTempPathUTF);
25866     free( zTempPathUTF );
25867   } else if( DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ) == NO_ERROR ) {
25868     zTempPath[0] = (char)('A' + ulDriveNum - 1);
25869     zTempPath[1] = ':'; 
25870     zTempPath[2] = '\0'; 
25871   } else {
25872     zTempPath[0] = '\0'; 
25873   }
25874   
25875   /* Strip off a trailing slashes or backslashes, otherwise we would get *
25876    * multiple (back)slashes which causes DosOpen() to fail.              *
25877    * Trailing spaces are not allowed, either.                            */
25878   j = sqlcipher3Strlen30(zTempPath);
25879   while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' || 
25880                     zTempPath[j-1] == ' ' ) ){
25881     j--;
25882   }
25883   zTempPath[j] = '\0';
25884   
25885   /* We use 20 bytes to randomize the name */
25886   sqlcipher3_snprintf(nBuf-22, zBuf,
25887                    "%s\\"SQLCIPHER_TEMP_FILE_PREFIX, zTempPath);
25888   j = sqlcipher3Strlen30(zBuf);
25889   sqlcipher3_randomness( 20, &zBuf[j] );
25890   for( i = 0; i < 20; i++, j++ ){
25891     zBuf[j] = zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
25892   }
25893   zBuf[j] = 0;
25894
25895   OSTRACE(( "TEMP FILENAME: %s\n", zBuf ));
25896   return SQLCIPHER_OK;
25897 }
25898
25899
25900 /*
25901 ** Turn a relative pathname into a full pathname.  Write the full
25902 ** pathname into zFull[].  zFull[] will be at least pVfs->mxPathname
25903 ** bytes in size.
25904 */
25905 static int os2FullPathname(
25906   sqlcipher3_vfs *pVfs,          /* Pointer to vfs object */
25907   const char *zRelative,      /* Possibly relative input path */
25908   int nFull,                  /* Size of output buffer in bytes */
25909   char *zFull                 /* Output buffer */
25910 ){
25911   char *zRelativeCp = convertUtf8PathToCp( zRelative );
25912   char zFullCp[CCHMAXPATH] = "\0";
25913   char *zFullUTF;
25914   APIRET rc = DosQueryPathInfo( (PSZ)zRelativeCp, FIL_QUERYFULLNAME, 
25915                                 zFullCp, CCHMAXPATH );
25916   free( zRelativeCp );
25917   zFullUTF = convertCpPathToUtf8( zFullCp );
25918   sqlcipher3_snprintf( nFull, zFull, zFullUTF );
25919   free( zFullUTF );
25920   return rc == NO_ERROR ? SQLCIPHER_OK : SQLCIPHER_IOERR;
25921 }
25922
25923
25924 /*
25925 ** Open a file.
25926 */
25927 static int os2Open(
25928   sqlcipher3_vfs *pVfs,            /* Not used */
25929   const char *zName,            /* Name of the file (UTF-8) */
25930   sqlcipher3_file *id,             /* Write the SQLite file handle here */
25931   int flags,                    /* Open mode flags */
25932   int *pOutFlags                /* Status return flags */
25933 ){
25934   HFILE h;
25935   ULONG ulOpenFlags = 0;
25936   ULONG ulOpenMode = 0;
25937   ULONG ulAction = 0;
25938   ULONG rc;
25939   os2File *pFile = (os2File*)id;
25940   const char *zUtf8Name = zName;
25941   char *zNameCp;
25942   char  zTmpname[CCHMAXPATH];
25943
25944   int isExclusive  = (flags & SQLCIPHER_OPEN_EXCLUSIVE);
25945   int isCreate     = (flags & SQLCIPHER_OPEN_CREATE);
25946   int isReadWrite  = (flags & SQLCIPHER_OPEN_READWRITE);
25947 #ifndef NDEBUG
25948   int isDelete     = (flags & SQLCIPHER_OPEN_DELETEONCLOSE);
25949   int isReadonly   = (flags & SQLCIPHER_OPEN_READONLY);
25950   int eType        = (flags & 0xFFFFFF00);
25951   int isOpenJournal = (isCreate && (
25952         eType==SQLCIPHER_OPEN_MASTER_JOURNAL 
25953      || eType==SQLCIPHER_OPEN_MAIN_JOURNAL 
25954      || eType==SQLCIPHER_OPEN_WAL
25955   ));
25956 #endif
25957
25958   UNUSED_PARAMETER(pVfs);
25959   assert( id!=0 );
25960
25961   /* Check the following statements are true: 
25962   **
25963   **   (a) Exactly one of the READWRITE and READONLY flags must be set, and 
25964   **   (b) if CREATE is set, then READWRITE must also be set, and
25965   **   (c) if EXCLUSIVE is set, then CREATE must also be set.
25966   **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
25967   */
25968   assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
25969   assert(isCreate==0 || isReadWrite);
25970   assert(isExclusive==0 || isCreate);
25971   assert(isDelete==0 || isCreate);
25972
25973   /* The main DB, main journal, WAL file and master journal are never 
25974   ** automatically deleted. Nor are they ever temporary files.  */
25975   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MAIN_DB );
25976   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MAIN_JOURNAL );
25977   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MASTER_JOURNAL );
25978   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_WAL );
25979
25980   /* Assert that the upper layer has set one of the "file-type" flags. */
25981   assert( eType==SQLCIPHER_OPEN_MAIN_DB      || eType==SQLCIPHER_OPEN_TEMP_DB 
25982        || eType==SQLCIPHER_OPEN_MAIN_JOURNAL || eType==SQLCIPHER_OPEN_TEMP_JOURNAL 
25983        || eType==SQLCIPHER_OPEN_SUBJOURNAL   || eType==SQLCIPHER_OPEN_MASTER_JOURNAL 
25984        || eType==SQLCIPHER_OPEN_TRANSIENT_DB || eType==SQLCIPHER_OPEN_WAL
25985   );
25986
25987   memset( pFile, 0, sizeof(*pFile) );
25988   pFile->h = (HFILE)-1;
25989
25990   /* If the second argument to this function is NULL, generate a 
25991   ** temporary file name to use 
25992   */
25993   if( !zUtf8Name ){
25994     assert(isDelete && !isOpenJournal);
25995     rc = getTempname(CCHMAXPATH, zTmpname);
25996     if( rc!=SQLCIPHER_OK ){
25997       return rc;
25998     }
25999     zUtf8Name = zTmpname;
26000   }
26001
26002   if( isReadWrite ){
26003     ulOpenMode |= OPEN_ACCESS_READWRITE;
26004   }else{
26005     ulOpenMode |= OPEN_ACCESS_READONLY;
26006   }
26007
26008   /* Open in random access mode for possibly better speed.  Allow full
26009   ** sharing because file locks will provide exclusive access when needed.
26010   ** The handle should not be inherited by child processes and we don't 
26011   ** want popups from the critical error handler.
26012   */
26013   ulOpenMode |= OPEN_FLAGS_RANDOM | OPEN_SHARE_DENYNONE | 
26014                 OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR;
26015
26016   /* SQLCIPHER_OPEN_EXCLUSIVE is used to make sure that a new file is 
26017   ** created. SQLite doesn't use it to indicate "exclusive access" 
26018   ** as it is usually understood.
26019   */
26020   if( isExclusive ){
26021     /* Creates a new file, only if it does not already exist. */
26022     /* If the file exists, it fails. */
26023     ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
26024   }else if( isCreate ){
26025     /* Open existing file, or create if it doesn't exist */
26026     ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
26027   }else{
26028     /* Opens a file, only if it exists. */
26029     ulOpenFlags |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
26030   }
26031
26032   zNameCp = convertUtf8PathToCp( zUtf8Name );
26033   rc = DosOpen( (PSZ)zNameCp,
26034                 &h,
26035                 &ulAction,
26036                 0L,
26037                 FILE_NORMAL,
26038                 ulOpenFlags,
26039                 ulOpenMode,
26040                 (PEAOP2)NULL );
26041   free( zNameCp );
26042
26043   if( rc != NO_ERROR ){
26044     OSTRACE(( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
26045               rc, zUtf8Name, ulAction, ulOpenFlags, ulOpenMode ));
26046
26047     if( isReadWrite ){
26048       return os2Open( pVfs, zName, id,
26049                       ((flags|SQLCIPHER_OPEN_READONLY)&~(SQLCIPHER_OPEN_CREATE|SQLCIPHER_OPEN_READWRITE)),
26050                       pOutFlags );
26051     }else{
26052       return SQLCIPHER_CANTOPEN;
26053     }
26054   }
26055
26056   if( pOutFlags ){
26057     *pOutFlags = isReadWrite ? SQLCIPHER_OPEN_READWRITE : SQLCIPHER_OPEN_READONLY;
26058   }
26059
26060   os2FullPathname( pVfs, zUtf8Name, sizeof( zTmpname ), zTmpname );
26061   pFile->zFullPathCp = convertUtf8PathToCp( zTmpname );
26062   pFile->pMethod = &os2IoMethod;
26063   pFile->flags = flags;
26064   pFile->h = h;
26065
26066   OpenCounter(+1);
26067   OSTRACE(( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags ));
26068   return SQLCIPHER_OK;
26069 }
26070
26071 /*
26072 ** Delete the named file.
26073 */
26074 static int os2Delete(
26075   sqlcipher3_vfs *pVfs,                     /* Not used on os2 */
26076   const char *zFilename,                 /* Name of file to delete */
26077   int syncDir                            /* Not used on os2 */
26078 ){
26079   APIRET rc;
26080   char *zFilenameCp;
26081   SimulateIOError( return SQLCIPHER_IOERR_DELETE );
26082   zFilenameCp = convertUtf8PathToCp( zFilename );
26083   rc = DosDelete( (PSZ)zFilenameCp );
26084   free( zFilenameCp );
26085   OSTRACE(( "DELETE \"%s\"\n", zFilename ));
26086   return (rc == NO_ERROR ||
26087           rc == ERROR_FILE_NOT_FOUND ||
26088           rc == ERROR_PATH_NOT_FOUND ) ? SQLCIPHER_OK : SQLCIPHER_IOERR_DELETE;
26089 }
26090
26091 /*
26092 ** Check the existance and status of a file.
26093 */
26094 static int os2Access(
26095   sqlcipher3_vfs *pVfs,        /* Not used on os2 */
26096   const char *zFilename,    /* Name of file to check */
26097   int flags,                /* Type of test to make on this file */
26098   int *pOut                 /* Write results here */
26099 ){
26100   APIRET rc;
26101   FILESTATUS3 fsts3ConfigInfo;
26102   char *zFilenameCp;
26103
26104   UNUSED_PARAMETER(pVfs);
26105   SimulateIOError( return SQLCIPHER_IOERR_ACCESS; );
26106   
26107   zFilenameCp = convertUtf8PathToCp( zFilename );
26108   rc = DosQueryPathInfo( (PSZ)zFilenameCp, FIL_STANDARD,
26109                          &fsts3ConfigInfo, sizeof(FILESTATUS3) );
26110   free( zFilenameCp );
26111   OSTRACE(( "ACCESS fsts3ConfigInfo.attrFile=%d flags=%d rc=%d\n",
26112             fsts3ConfigInfo.attrFile, flags, rc ));
26113
26114   switch( flags ){
26115     case SQLCIPHER_ACCESS_EXISTS:
26116       /* For an SQLCIPHER_ACCESS_EXISTS query, treat a zero-length file
26117       ** as if it does not exist.
26118       */
26119       if( fsts3ConfigInfo.cbFile == 0 ) 
26120         rc = ERROR_FILE_NOT_FOUND;
26121       break;
26122     case SQLCIPHER_ACCESS_READ:
26123       break;
26124     case SQLCIPHER_ACCESS_READWRITE:
26125       if( fsts3ConfigInfo.attrFile & FILE_READONLY )
26126         rc = ERROR_ACCESS_DENIED;
26127       break;
26128     default:
26129       rc = ERROR_FILE_NOT_FOUND;
26130       assert( !"Invalid flags argument" );
26131   }
26132
26133   *pOut = (rc == NO_ERROR);
26134   OSTRACE(( "ACCESS %s flags %d: rc=%d\n", zFilename, flags, *pOut ));
26135
26136   return SQLCIPHER_OK;
26137 }
26138
26139
26140 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
26141 /*
26142 ** Interfaces for opening a shared library, finding entry points
26143 ** within the shared library, and closing the shared library.
26144 */
26145 /*
26146 ** Interfaces for opening a shared library, finding entry points
26147 ** within the shared library, and closing the shared library.
26148 */
26149 static void *os2DlOpen(sqlcipher3_vfs *pVfs, const char *zFilename){
26150   HMODULE hmod;
26151   APIRET rc;
26152   char *zFilenameCp = convertUtf8PathToCp(zFilename);
26153   rc = DosLoadModule(NULL, 0, (PSZ)zFilenameCp, &hmod);
26154   free(zFilenameCp);
26155   return rc != NO_ERROR ? 0 : (void*)hmod;
26156 }
26157 /*
26158 ** A no-op since the error code is returned on the DosLoadModule call.
26159 ** os2Dlopen returns zero if DosLoadModule is not successful.
26160 */
26161 static void os2DlError(sqlcipher3_vfs *pVfs, int nBuf, char *zBufOut){
26162 /* no-op */
26163 }
26164 static void (*os2DlSym(sqlcipher3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
26165   PFN pfn;
26166   APIRET rc;
26167   rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)zSymbol, &pfn);
26168   if( rc != NO_ERROR ){
26169     /* if the symbol itself was not found, search again for the same
26170      * symbol with an extra underscore, that might be needed depending
26171      * on the calling convention */
26172     char _zSymbol[256] = "_";
26173     strncat(_zSymbol, zSymbol, 254);
26174     rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)_zSymbol, &pfn);
26175   }
26176   return rc != NO_ERROR ? 0 : (void(*)(void))pfn;
26177 }
26178 static void os2DlClose(sqlcipher3_vfs *pVfs, void *pHandle){
26179   DosFreeModule((HMODULE)pHandle);
26180 }
26181 #else /* if SQLCIPHER_OMIT_LOAD_EXTENSION is defined: */
26182   #define os2DlOpen 0
26183   #define os2DlError 0
26184   #define os2DlSym 0
26185   #define os2DlClose 0
26186 #endif
26187
26188
26189 /*
26190 ** Write up to nBuf bytes of randomness into zBuf.
26191 */
26192 static int os2Randomness(sqlcipher3_vfs *pVfs, int nBuf, char *zBuf ){
26193   int n = 0;
26194 #if defined(SQLCIPHER_TEST)
26195   n = nBuf;
26196   memset(zBuf, 0, nBuf);
26197 #else
26198   int i;                           
26199   PPIB ppib;
26200   PTIB ptib;
26201   DATETIME dt; 
26202   static unsigned c = 0;
26203   /* Ordered by variation probability */
26204   static ULONG svIdx[6] = { QSV_MS_COUNT, QSV_TIME_LOW,
26205                             QSV_MAXPRMEM, QSV_MAXSHMEM,
26206                             QSV_TOTAVAILMEM, QSV_TOTRESMEM };
26207
26208   /* 8 bytes; timezone and weekday don't increase the randomness much */
26209   if( (int)sizeof(dt)-3 <= nBuf - n ){
26210     c += 0x0100;
26211     DosGetDateTime(&dt);
26212     dt.year = (USHORT)((dt.year - 1900) | c);
26213     memcpy(&zBuf[n], &dt, sizeof(dt)-3);
26214     n += sizeof(dt)-3;
26215   }
26216
26217   /* 4 bytes; PIDs and TIDs are 16 bit internally, so combine them */
26218   if( (int)sizeof(ULONG) <= nBuf - n ){
26219     DosGetInfoBlocks(&ptib, &ppib);
26220     *(PULONG)&zBuf[n] = MAKELONG(ppib->pib_ulpid,
26221                                  ptib->tib_ptib2->tib2_ultid);
26222     n += sizeof(ULONG);
26223   }
26224
26225   /* Up to 6 * 4 bytes; variables depend on the system state */
26226   for( i = 0; i < 6 && (int)sizeof(ULONG) <= nBuf - n; i++ ){
26227     DosQuerySysInfo(svIdx[i], svIdx[i], 
26228                     (PULONG)&zBuf[n], sizeof(ULONG));
26229     n += sizeof(ULONG);
26230   } 
26231 #endif
26232
26233   return n;
26234 }
26235
26236 /*
26237 ** Sleep for a little while.  Return the amount of time slept.
26238 ** The argument is the number of microseconds we want to sleep.
26239 ** The return value is the number of microseconds of sleep actually
26240 ** requested from the underlying operating system, a number which
26241 ** might be greater than or equal to the argument, but not less
26242 ** than the argument.
26243 */
26244 static int os2Sleep( sqlcipher3_vfs *pVfs, int microsec ){
26245   DosSleep( (microsec/1000) );
26246   return microsec;
26247 }
26248
26249 /*
26250 ** The following variable, if set to a non-zero value, becomes the result
26251 ** returned from sqlcipher3OsCurrentTime().  This is used for testing.
26252 */
26253 #ifdef SQLCIPHER_TEST
26254 SQLCIPHER_API int sqlcipher3_current_time = 0;
26255 #endif
26256
26257 /*
26258 ** Find the current time (in Universal Coordinated Time).  Write into *piNow
26259 ** the current time and date as a Julian Day number times 86_400_000.  In
26260 ** other words, write into *piNow the number of milliseconds since the Julian
26261 ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
26262 ** proleptic Gregorian calendar.
26263 **
26264 ** On success, return 0.  Return 1 if the time and date cannot be found.
26265 */
26266 static int os2CurrentTimeInt64(sqlcipher3_vfs *pVfs, sqlcipher3_int64 *piNow){
26267 #ifdef SQLCIPHER_TEST
26268   static const sqlcipher3_int64 unixEpoch = 24405875*(sqlcipher3_int64)8640000;
26269 #endif
26270   int year, month, datepart, timepart;
26271  
26272   DATETIME dt;
26273   DosGetDateTime( &dt );
26274
26275   year = dt.year;
26276   month = dt.month;
26277
26278   /* Calculations from http://www.astro.keele.ac.uk/~rno/Astronomy/hjd.html
26279   ** http://www.astro.keele.ac.uk/~rno/Astronomy/hjd-0.1.c
26280   ** Calculate the Julian days
26281   */
26282   datepart = (int)dt.day - 32076 +
26283     1461*(year + 4800 + (month - 14)/12)/4 +
26284     367*(month - 2 - (month - 14)/12*12)/12 -
26285     3*((year + 4900 + (month - 14)/12)/100)/4;
26286
26287   /* Time in milliseconds, hours to noon added */
26288   timepart = 12*3600*1000 + dt.hundredths*10 + dt.seconds*1000 +
26289     ((int)dt.minutes + dt.timezone)*60*1000 + dt.hours*3600*1000;
26290
26291   *piNow = (sqlcipher3_int64)datepart*86400*1000 + timepart;
26292    
26293 #ifdef SQLCIPHER_TEST
26294   if( sqlcipher3_current_time ){
26295     *piNow = 1000*(sqlcipher3_int64)sqlcipher3_current_time + unixEpoch;
26296   }
26297 #endif
26298
26299   UNUSED_PARAMETER(pVfs);
26300   return 0;
26301 }
26302
26303 /*
26304 ** Find the current time (in Universal Coordinated Time).  Write the
26305 ** current time and date as a Julian Day number into *prNow and
26306 ** return 0.  Return 1 if the time and date cannot be found.
26307 */
26308 static int os2CurrentTime( sqlcipher3_vfs *pVfs, double *prNow ){
26309   int rc;
26310   sqlcipher3_int64 i;
26311   rc = os2CurrentTimeInt64(pVfs, &i);
26312   if( !rc ){
26313     *prNow = i/86400000.0;
26314   }
26315   return rc;
26316 }
26317
26318 /*
26319 ** The idea is that this function works like a combination of
26320 ** GetLastError() and FormatMessage() on windows (or errno and
26321 ** strerror_r() on unix). After an error is returned by an OS
26322 ** function, SQLite calls this function with zBuf pointing to
26323 ** a buffer of nBuf bytes. The OS layer should populate the
26324 ** buffer with a nul-terminated UTF-8 encoded error message
26325 ** describing the last IO error to have occurred within the calling
26326 ** thread.
26327 **
26328 ** If the error message is too large for the supplied buffer,
26329 ** it should be truncated. The return value of xGetLastError
26330 ** is zero if the error message fits in the buffer, or non-zero
26331 ** otherwise (if the message was truncated). If non-zero is returned,
26332 ** then it is not necessary to include the nul-terminator character
26333 ** in the output buffer.
26334 **
26335 ** Not supplying an error message will have no adverse effect
26336 ** on SQLite. It is fine to have an implementation that never
26337 ** returns an error message:
26338 **
26339 **   int xGetLastError(sqlcipher3_vfs *pVfs, int nBuf, char *zBuf){
26340 **     assert(zBuf[0]=='\0');
26341 **     return 0;
26342 **   }
26343 **
26344 ** However if an error message is supplied, it will be incorporated
26345 ** by sqlcipher into the error message available to the user using
26346 ** sqlcipher3_errmsg(), possibly making IO errors easier to debug.
26347 */
26348 static int os2GetLastError(sqlcipher3_vfs *pVfs, int nBuf, char *zBuf){
26349   assert(zBuf[0]=='\0');
26350   return 0;
26351 }
26352
26353 /*
26354 ** Initialize and deinitialize the operating system interface.
26355 */
26356 SQLCIPHER_API int sqlcipher3_os_init(void){
26357   static sqlcipher3_vfs os2Vfs = {
26358     3,                 /* iVersion */
26359     sizeof(os2File),   /* szOsFile */
26360     CCHMAXPATH,        /* mxPathname */
26361     0,                 /* pNext */
26362     "os2",             /* zName */
26363     0,                 /* pAppData */
26364
26365     os2Open,           /* xOpen */
26366     os2Delete,         /* xDelete */
26367     os2Access,         /* xAccess */
26368     os2FullPathname,   /* xFullPathname */
26369     os2DlOpen,         /* xDlOpen */
26370     os2DlError,        /* xDlError */
26371     os2DlSym,          /* xDlSym */
26372     os2DlClose,        /* xDlClose */
26373     os2Randomness,     /* xRandomness */
26374     os2Sleep,          /* xSleep */
26375     os2CurrentTime,    /* xCurrentTime */
26376     os2GetLastError,   /* xGetLastError */
26377     os2CurrentTimeInt64, /* xCurrentTimeInt64 */
26378     0,                 /* xSetSystemCall */
26379     0,                 /* xGetSystemCall */
26380     0                  /* xNextSystemCall */
26381   };
26382   sqlcipher3_vfs_register(&os2Vfs, 1);
26383   initUconvObjects();
26384 /*  sqlcipher3OSTrace = 1; */
26385   return SQLCIPHER_OK;
26386 }
26387 SQLCIPHER_API int sqlcipher3_os_end(void){
26388   freeUconvObjects();
26389   return SQLCIPHER_OK;
26390 }
26391
26392 #endif /* SQLCIPHER_OS_OS2 */
26393
26394 /************** End of os_os2.c **********************************************/
26395 /************** Begin file os_unix.c *****************************************/
26396 /*
26397 ** 2004 May 22
26398 **
26399 ** The author disclaims copyright to this source code.  In place of
26400 ** a legal notice, here is a blessing:
26401 **
26402 **    May you do good and not evil.
26403 **    May you find forgiveness for yourself and forgive others.
26404 **    May you share freely, never taking more than you give.
26405 **
26406 ******************************************************************************
26407 **
26408 ** This file contains the VFS implementation for unix-like operating systems
26409 ** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.
26410 **
26411 ** There are actually several different VFS implementations in this file.
26412 ** The differences are in the way that file locking is done.  The default
26413 ** implementation uses Posix Advisory Locks.  Alternative implementations
26414 ** use flock(), dot-files, various proprietary locking schemas, or simply
26415 ** skip locking all together.
26416 **
26417 ** This source file is organized into divisions where the logic for various
26418 ** subfunctions is contained within the appropriate division.  PLEASE
26419 ** KEEP THE STRUCTURE OF THIS FILE INTACT.  New code should be placed
26420 ** in the correct division and should be clearly labeled.
26421 **
26422 ** The layout of divisions is as follows:
26423 **
26424 **   *  General-purpose declarations and utility functions.
26425 **   *  Unique file ID logic used by VxWorks.
26426 **   *  Various locking primitive implementations (all except proxy locking):
26427 **      + for Posix Advisory Locks
26428 **      + for no-op locks
26429 **      + for dot-file locks
26430 **      + for flock() locking
26431 **      + for named semaphore locks (VxWorks only)
26432 **      + for AFP filesystem locks (MacOSX only)
26433 **   *  sqlcipher3_file methods not associated with locking.
26434 **   *  Definitions of sqlcipher3_io_methods objects for all locking
26435 **      methods plus "finder" functions for each locking method.
26436 **   *  sqlcipher3_vfs method implementations.
26437 **   *  Locking primitives for the proxy uber-locking-method. (MacOSX only)
26438 **   *  Definitions of sqlcipher3_vfs objects for all locking methods
26439 **      plus implementations of sqlcipher3_os_init() and sqlcipher3_os_end().
26440 */
26441 #if SQLCIPHER_OS_UNIX              /* This file is used on unix only */
26442
26443 /*
26444 ** There are various methods for file locking used for concurrency
26445 ** control:
26446 **
26447 **   1. POSIX locking (the default),
26448 **   2. No locking,
26449 **   3. Dot-file locking,
26450 **   4. flock() locking,
26451 **   5. AFP locking (OSX only),
26452 **   6. Named POSIX semaphores (VXWorks only),
26453 **   7. proxy locking. (OSX only)
26454 **
26455 ** Styles 4, 5, and 7 are only available of SQLCIPHER_ENABLE_LOCKING_STYLE
26456 ** is defined to 1.  The SQLCIPHER_ENABLE_LOCKING_STYLE also enables automatic
26457 ** selection of the appropriate locking style based on the filesystem
26458 ** where the database is located.  
26459 */
26460 #if !defined(SQLCIPHER_ENABLE_LOCKING_STYLE)
26461 #  if defined(__APPLE__)
26462 #    define SQLCIPHER_ENABLE_LOCKING_STYLE 1
26463 #  else
26464 #    define SQLCIPHER_ENABLE_LOCKING_STYLE 0
26465 #  endif
26466 #endif
26467
26468 /*
26469 ** Define the OS_VXWORKS pre-processor macro to 1 if building on 
26470 ** vxworks, or 0 otherwise.
26471 */
26472 #ifndef OS_VXWORKS
26473 #  if defined(__RTP__) || defined(_WRS_KERNEL)
26474 #    define OS_VXWORKS 1
26475 #  else
26476 #    define OS_VXWORKS 0
26477 #  endif
26478 #endif
26479
26480 /*
26481 ** These #defines should enable >2GB file support on Posix if the
26482 ** underlying operating system supports it.  If the OS lacks
26483 ** large file support, these should be no-ops.
26484 **
26485 ** Large file support can be disabled using the -DSQLCIPHER_DISABLE_LFS switch
26486 ** on the compiler command line.  This is necessary if you are compiling
26487 ** on a recent machine (ex: RedHat 7.2) but you want your code to work
26488 ** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2
26489 ** without this option, LFS is enable.  But LFS does not exist in the kernel
26490 ** in RedHat 6.0, so the code won't work.  Hence, for maximum binary
26491 ** portability you should omit LFS.
26492 **
26493 ** The previous paragraph was written in 2005.  (This paragraph is written
26494 ** on 2008-11-28.) These days, all Linux kernels support large files, so
26495 ** you should probably leave LFS enabled.  But some embedded platforms might
26496 ** lack LFS in which case the SQLCIPHER_DISABLE_LFS macro might still be useful.
26497 */
26498 #ifndef SQLCIPHER_DISABLE_LFS
26499 # define _LARGE_FILE       1
26500 # ifndef _FILE_OFFSET_BITS
26501 #   define _FILE_OFFSET_BITS 64
26502 # endif
26503 # define _LARGEFILE_SOURCE 1
26504 #endif
26505
26506 /*
26507 ** standard include files.
26508 */
26509 #include <sys/types.h>
26510 #include <sys/stat.h>
26511 #include <fcntl.h>
26512 #include <unistd.h>
26513 /* #include <time.h> */
26514 #include <sys/time.h>
26515 #include <errno.h>
26516 #ifndef SQLCIPHER_OMIT_WAL
26517 /* #include <sys/mman.h> */
26518 #endif
26519
26520 #if SQLCIPHER_ENABLE_LOCKING_STYLE
26521 # include <sys/ioctl.h>
26522 # if OS_VXWORKS
26523 #  include <semaphore.h>
26524 #  include <limits.h>
26525 # else
26526 #  include <sys/file.h>
26527 #  include <sys/param.h>
26528 # endif
26529 #endif /* SQLCIPHER_ENABLE_LOCKING_STYLE */
26530
26531 #if defined(__APPLE__) || (SQLCIPHER_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
26532 # include <sys/mount.h>
26533 #endif
26534
26535 #ifdef HAVE_UTIME
26536 # include <utime.h>
26537 #endif
26538
26539 /*
26540 ** Allowed values of unixFile.fsFlags
26541 */
26542 #define SQLCIPHER_FSFLAGS_IS_MSDOS     0x1
26543
26544 /*
26545 ** If we are to be thread-safe, include the pthreads header and define
26546 ** the SQLCIPHER_UNIX_THREADS macro.
26547 */
26548 #if SQLCIPHER_THREADSAFE
26549 /* # include <pthread.h> */
26550 # define SQLCIPHER_UNIX_THREADS 1
26551 #endif
26552
26553 /*
26554 ** Default permissions when creating a new file
26555 */
26556 #ifndef SQLCIPHER_DEFAULT_FILE_PERMISSIONS
26557 # define SQLCIPHER_DEFAULT_FILE_PERMISSIONS 0644
26558 #endif
26559
26560 /*
26561  ** Default permissions when creating auto proxy dir
26562  */
26563 #ifndef SQLCIPHER_DEFAULT_PROXYDIR_PERMISSIONS
26564 # define SQLCIPHER_DEFAULT_PROXYDIR_PERMISSIONS 0755
26565 #endif
26566
26567 /*
26568 ** Maximum supported path-length.
26569 */
26570 #define MAX_PATHNAME 512
26571
26572 /*
26573 ** Only set the lastErrno if the error code is a real error and not 
26574 ** a normal expected return code of SQLCIPHER_BUSY or SQLCIPHER_OK
26575 */
26576 #define IS_LOCK_ERROR(x)  ((x != SQLCIPHER_OK) && (x != SQLCIPHER_BUSY))
26577
26578 /* Forward references */
26579 typedef struct unixShm unixShm;               /* Connection shared memory */
26580 typedef struct unixShmNode unixShmNode;       /* Shared memory instance */
26581 typedef struct unixInodeInfo unixInodeInfo;   /* An i-node */
26582 typedef struct UnixUnusedFd UnixUnusedFd;     /* An unused file descriptor */
26583
26584 /*
26585 ** Sometimes, after a file handle is closed by SQLite, the file descriptor
26586 ** cannot be closed immediately. In these cases, instances of the following
26587 ** structure are used to store the file descriptor while waiting for an
26588 ** opportunity to either close or reuse it.
26589 */
26590 struct UnixUnusedFd {
26591   int fd;                   /* File descriptor to close */
26592   int flags;                /* Flags this file descriptor was opened with */
26593   UnixUnusedFd *pNext;      /* Next unused file descriptor on same file */
26594 };
26595
26596 /*
26597 ** The unixFile structure is subclass of sqlcipher3_file specific to the unix
26598 ** VFS implementations.
26599 */
26600 typedef struct unixFile unixFile;
26601 struct unixFile {
26602   sqlcipher3_io_methods const *pMethod;  /* Always the first entry */
26603   unixInodeInfo *pInode;              /* Info about locks on this inode */
26604   int h;                              /* The file descriptor */
26605   unsigned char eFileLock;            /* The type of lock held on this fd */
26606   unsigned char ctrlFlags;            /* Behavioral bits.  UNIXFILE_* flags */
26607   int lastErrno;                      /* The unix errno from last I/O error */
26608   void *lockingContext;               /* Locking style specific state */
26609   UnixUnusedFd *pUnused;              /* Pre-allocated UnixUnusedFd */
26610   const char *zPath;                  /* Name of the file */
26611   unixShm *pShm;                      /* Shared memory segment information */
26612   int szChunk;                        /* Configured by FCNTL_CHUNK_SIZE */
26613 #if SQLCIPHER_ENABLE_LOCKING_STYLE
26614   int openFlags;                      /* The flags specified at open() */
26615 #endif
26616 #if SQLCIPHER_ENABLE_LOCKING_STYLE || defined(__APPLE__)
26617   unsigned fsFlags;                   /* cached details from statfs() */
26618 #endif
26619 #if OS_VXWORKS
26620   int isDelete;                       /* Delete on close if true */
26621   struct vxworksFileId *pId;          /* Unique file ID */
26622 #endif
26623 #ifndef NDEBUG
26624   /* The next group of variables are used to track whether or not the
26625   ** transaction counter in bytes 24-27 of database files are updated
26626   ** whenever any part of the database changes.  An assertion fault will
26627   ** occur if a file is updated without also updating the transaction
26628   ** counter.  This test is made to avoid new problems similar to the
26629   ** one described by ticket #3584. 
26630   */
26631   unsigned char transCntrChng;   /* True if the transaction counter changed */
26632   unsigned char dbUpdate;        /* True if any part of database file changed */
26633   unsigned char inNormalWrite;   /* True if in a normal write operation */
26634 #endif
26635 #ifdef SQLCIPHER_TEST
26636   /* In test mode, increase the size of this structure a bit so that 
26637   ** it is larger than the struct CrashFile defined in test6.c.
26638   */
26639   char aPadding[32];
26640 #endif
26641 };
26642
26643 /*
26644 ** Allowed values for the unixFile.ctrlFlags bitmask:
26645 */
26646 #define UNIXFILE_EXCL        0x01     /* Connections from one process only */
26647 #define UNIXFILE_RDONLY      0x02     /* Connection is read only */
26648 #define UNIXFILE_PERSIST_WAL 0x04     /* Persistent WAL mode */
26649 #ifndef SQLCIPHER_DISABLE_DIRSYNC
26650 # define UNIXFILE_DIRSYNC    0x08     /* Directory sync needed */
26651 #else
26652 # define UNIXFILE_DIRSYNC    0x00
26653 #endif
26654
26655 /*
26656 ** Include code that is common to all os_*.c files
26657 */
26658 /************** Include os_common.h in the middle of os_unix.c ***************/
26659 /************** Begin file os_common.h ***************************************/
26660 /*
26661 ** 2004 May 22
26662 **
26663 ** The author disclaims copyright to this source code.  In place of
26664 ** a legal notice, here is a blessing:
26665 **
26666 **    May you do good and not evil.
26667 **    May you find forgiveness for yourself and forgive others.
26668 **    May you share freely, never taking more than you give.
26669 **
26670 ******************************************************************************
26671 **
26672 ** This file contains macros and a little bit of code that is common to
26673 ** all of the platform-specific files (os_*.c) and is #included into those
26674 ** files.
26675 **
26676 ** This file should be #included by the os_*.c files only.  It is not a
26677 ** general purpose header file.
26678 */
26679 #ifndef _OS_COMMON_H_
26680 #define _OS_COMMON_H_
26681
26682 /*
26683 ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
26684 ** macro to SQLCIPHER_DEBUG and some older makefiles have not yet made the
26685 ** switch.  The following code should catch this problem at compile-time.
26686 */
26687 #ifdef MEMORY_DEBUG
26688 # error "The MEMORY_DEBUG macro is obsolete.  Use SQLCIPHER_DEBUG instead."
26689 #endif
26690
26691 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
26692 # ifndef SQLCIPHER_DEBUG_OS_TRACE
26693 #   define SQLCIPHER_DEBUG_OS_TRACE 0
26694 # endif
26695   int sqlcipher3OSTrace = SQLCIPHER_DEBUG_OS_TRACE;
26696 # define OSTRACE(X)          if( sqlcipher3OSTrace ) sqlcipher3DebugPrintf X
26697 #else
26698 # define OSTRACE(X)
26699 #endif
26700
26701 /*
26702 ** Macros for performance tracing.  Normally turned off.  Only works
26703 ** on i486 hardware.
26704 */
26705 #ifdef SQLCIPHER_PERFORMANCE_TRACE
26706
26707 /* 
26708 ** hwtime.h contains inline assembler code for implementing 
26709 ** high-performance timing routines.
26710 */
26711 /************** Include hwtime.h in the middle of os_common.h ****************/
26712 /************** Begin file hwtime.h ******************************************/
26713 /*
26714 ** 2008 May 27
26715 **
26716 ** The author disclaims copyright to this source code.  In place of
26717 ** a legal notice, here is a blessing:
26718 **
26719 **    May you do good and not evil.
26720 **    May you find forgiveness for yourself and forgive others.
26721 **    May you share freely, never taking more than you give.
26722 **
26723 ******************************************************************************
26724 **
26725 ** This file contains inline asm code for retrieving "high-performance"
26726 ** counters for x86 class CPUs.
26727 */
26728 #ifndef _HWTIME_H_
26729 #define _HWTIME_H_
26730
26731 /*
26732 ** The following routine only works on pentium-class (or newer) processors.
26733 ** It uses the RDTSC opcode to read the cycle count value out of the
26734 ** processor and returns that value.  This can be used for high-res
26735 ** profiling.
26736 */
26737 #if (defined(__GNUC__) || defined(_MSC_VER)) && \
26738       (defined(i386) || defined(__i386__) || defined(_M_IX86))
26739
26740   #if defined(__GNUC__)
26741
26742   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
26743      unsigned int lo, hi;
26744      __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
26745      return (sqlcipher_uint64)hi << 32 | lo;
26746   }
26747
26748   #elif defined(_MSC_VER)
26749
26750   __declspec(naked) __inline sqlcipher_uint64 __cdecl sqlcipher3Hwtime(void){
26751      __asm {
26752         rdtsc
26753         ret       ; return value at EDX:EAX
26754      }
26755   }
26756
26757   #endif
26758
26759 #elif (defined(__GNUC__) && defined(__x86_64__))
26760
26761   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
26762       unsigned long val;
26763       __asm__ __volatile__ ("rdtsc" : "=A" (val));
26764       return val;
26765   }
26766  
26767 #elif (defined(__GNUC__) && defined(__ppc__))
26768
26769   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
26770       unsigned long long retval;
26771       unsigned long junk;
26772       __asm__ __volatile__ ("\n\
26773           1:      mftbu   %1\n\
26774                   mftb    %L0\n\
26775                   mftbu   %0\n\
26776                   cmpw    %0,%1\n\
26777                   bne     1b"
26778                   : "=r" (retval), "=r" (junk));
26779       return retval;
26780   }
26781
26782 #else
26783
26784   #error Need implementation of sqlcipher3Hwtime() for your platform.
26785
26786   /*
26787   ** To compile without implementing sqlcipher3Hwtime() for your platform,
26788   ** you can remove the above #error and use the following
26789   ** stub function.  You will lose timing support for many
26790   ** of the debugging and testing utilities, but it should at
26791   ** least compile and run.
26792   */
26793 SQLCIPHER_PRIVATE   sqlcipher_uint64 sqlcipher3Hwtime(void){ return ((sqlcipher_uint64)0); }
26794
26795 #endif
26796
26797 #endif /* !defined(_HWTIME_H_) */
26798
26799 /************** End of hwtime.h **********************************************/
26800 /************** Continuing where we left off in os_common.h ******************/
26801
26802 static sqlcipher_uint64 g_start;
26803 static sqlcipher_uint64 g_elapsed;
26804 #define TIMER_START       g_start=sqlcipher3Hwtime()
26805 #define TIMER_END         g_elapsed=sqlcipher3Hwtime()-g_start
26806 #define TIMER_ELAPSED     g_elapsed
26807 #else
26808 #define TIMER_START
26809 #define TIMER_END
26810 #define TIMER_ELAPSED     ((sqlcipher_uint64)0)
26811 #endif
26812
26813 /*
26814 ** If we compile with the SQLCIPHER_TEST macro set, then the following block
26815 ** of code will give us the ability to simulate a disk I/O error.  This
26816 ** is used for testing the I/O recovery logic.
26817 */
26818 #ifdef SQLCIPHER_TEST
26819 SQLCIPHER_API int sqlcipher3_io_error_hit = 0;            /* Total number of I/O Errors */
26820 SQLCIPHER_API int sqlcipher3_io_error_hardhit = 0;        /* Number of non-benign errors */
26821 SQLCIPHER_API int sqlcipher3_io_error_pending = 0;        /* Count down to first I/O error */
26822 SQLCIPHER_API int sqlcipher3_io_error_persist = 0;        /* True if I/O errors persist */
26823 SQLCIPHER_API int sqlcipher3_io_error_benign = 0;         /* True if errors are benign */
26824 SQLCIPHER_API int sqlcipher3_diskfull_pending = 0;
26825 SQLCIPHER_API int sqlcipher3_diskfull = 0;
26826 #define SimulateIOErrorBenign(X) sqlcipher3_io_error_benign=(X)
26827 #define SimulateIOError(CODE)  \
26828   if( (sqlcipher3_io_error_persist && sqlcipher3_io_error_hit) \
26829        || sqlcipher3_io_error_pending-- == 1 )  \
26830               { local_ioerr(); CODE; }
26831 static void local_ioerr(){
26832   IOTRACE(("IOERR\n"));
26833   sqlcipher3_io_error_hit++;
26834   if( !sqlcipher3_io_error_benign ) sqlcipher3_io_error_hardhit++;
26835 }
26836 #define SimulateDiskfullError(CODE) \
26837    if( sqlcipher3_diskfull_pending ){ \
26838      if( sqlcipher3_diskfull_pending == 1 ){ \
26839        local_ioerr(); \
26840        sqlcipher3_diskfull = 1; \
26841        sqlcipher3_io_error_hit = 1; \
26842        CODE; \
26843      }else{ \
26844        sqlcipher3_diskfull_pending--; \
26845      } \
26846    }
26847 #else
26848 #define SimulateIOErrorBenign(X)
26849 #define SimulateIOError(A)
26850 #define SimulateDiskfullError(A)
26851 #endif
26852
26853 /*
26854 ** When testing, keep a count of the number of open files.
26855 */
26856 #ifdef SQLCIPHER_TEST
26857 SQLCIPHER_API int sqlcipher3_open_file_count = 0;
26858 #define OpenCounter(X)  sqlcipher3_open_file_count+=(X)
26859 #else
26860 #define OpenCounter(X)
26861 #endif
26862
26863 #endif /* !defined(_OS_COMMON_H_) */
26864
26865 /************** End of os_common.h *******************************************/
26866 /************** Continuing where we left off in os_unix.c ********************/
26867
26868 /*
26869 ** Define various macros that are missing from some systems.
26870 */
26871 #ifndef O_LARGEFILE
26872 # define O_LARGEFILE 0
26873 #endif
26874 #ifdef SQLCIPHER_DISABLE_LFS
26875 # undef O_LARGEFILE
26876 # define O_LARGEFILE 0
26877 #endif
26878 #ifndef O_NOFOLLOW
26879 # define O_NOFOLLOW 0
26880 #endif
26881 #ifndef O_BINARY
26882 # define O_BINARY 0
26883 #endif
26884
26885 /*
26886 ** The threadid macro resolves to the thread-id or to 0.  Used for
26887 ** testing and debugging only.
26888 */
26889 #if SQLCIPHER_THREADSAFE
26890 #define threadid pthread_self()
26891 #else
26892 #define threadid 0
26893 #endif
26894
26895 /*
26896 ** Different Unix systems declare open() in different ways.  Same use
26897 ** open(const char*,int,mode_t).  Others use open(const char*,int,...).
26898 ** The difference is important when using a pointer to the function.
26899 **
26900 ** The safest way to deal with the problem is to always use this wrapper
26901 ** which always has the same well-defined interface.
26902 */
26903 static int posixOpen(const char *zFile, int flags, int mode){
26904   return open(zFile, flags, mode);
26905 }
26906
26907 /* Forward reference */
26908 static int openDirectory(const char*, int*);
26909
26910 /*
26911 ** Many system calls are accessed through pointer-to-functions so that
26912 ** they may be overridden at runtime to facilitate fault injection during
26913 ** testing and sandboxing.  The following array holds the names and pointers
26914 ** to all overrideable system calls.
26915 */
26916 static struct unix_syscall {
26917   const char *zName;            /* Name of the sytem call */
26918   sqlcipher3_syscall_ptr pCurrent; /* Current value of the system call */
26919   sqlcipher3_syscall_ptr pDefault; /* Default value */
26920 } aSyscall[] = {
26921   { "open",         (sqlcipher3_syscall_ptr)posixOpen,  0  },
26922 #define osOpen      ((int(*)(const char*,int,int))aSyscall[0].pCurrent)
26923
26924   { "close",        (sqlcipher3_syscall_ptr)close,      0  },
26925 #define osClose     ((int(*)(int))aSyscall[1].pCurrent)
26926
26927   { "access",       (sqlcipher3_syscall_ptr)access,     0  },
26928 #define osAccess    ((int(*)(const char*,int))aSyscall[2].pCurrent)
26929
26930   { "getcwd",       (sqlcipher3_syscall_ptr)getcwd,     0  },
26931 #define osGetcwd    ((char*(*)(char*,size_t))aSyscall[3].pCurrent)
26932
26933   { "stat",         (sqlcipher3_syscall_ptr)stat,       0  },
26934 #define osStat      ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)
26935
26936 /*
26937 ** The DJGPP compiler environment looks mostly like Unix, but it
26938 ** lacks the fcntl() system call.  So redefine fcntl() to be something
26939 ** that always succeeds.  This means that locking does not occur under
26940 ** DJGPP.  But it is DOS - what did you expect?
26941 */
26942 #ifdef __DJGPP__
26943   { "fstat",        0,                 0  },
26944 #define osFstat(a,b,c)    0
26945 #else     
26946   { "fstat",        (sqlcipher3_syscall_ptr)fstat,      0  },
26947 #define osFstat     ((int(*)(int,struct stat*))aSyscall[5].pCurrent)
26948 #endif
26949
26950   { "ftruncate",    (sqlcipher3_syscall_ptr)ftruncate,  0  },
26951 #define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)
26952
26953   { "fcntl",        (sqlcipher3_syscall_ptr)fcntl,      0  },
26954 #define osFcntl     ((int(*)(int,int,...))aSyscall[7].pCurrent)
26955
26956   { "read",         (sqlcipher3_syscall_ptr)read,       0  },
26957 #define osRead      ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
26958
26959 #if defined(USE_PREAD) || SQLCIPHER_ENABLE_LOCKING_STYLE
26960   { "pread",        (sqlcipher3_syscall_ptr)pread,      0  },
26961 #else
26962   { "pread",        (sqlcipher3_syscall_ptr)0,          0  },
26963 #endif
26964 #define osPread     ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
26965
26966 #if defined(USE_PREAD64)
26967   { "pread64",      (sqlcipher3_syscall_ptr)pread64,    0  },
26968 #else
26969   { "pread64",      (sqlcipher3_syscall_ptr)0,          0  },
26970 #endif
26971 #define osPread64   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
26972
26973   { "write",        (sqlcipher3_syscall_ptr)write,      0  },
26974 #define osWrite     ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
26975
26976 #if defined(USE_PREAD) || SQLCIPHER_ENABLE_LOCKING_STYLE
26977   { "pwrite",       (sqlcipher3_syscall_ptr)pwrite,     0  },
26978 #else
26979   { "pwrite",       (sqlcipher3_syscall_ptr)0,          0  },
26980 #endif
26981 #define osPwrite    ((ssize_t(*)(int,const void*,size_t,off_t))\
26982                     aSyscall[12].pCurrent)
26983
26984 #if defined(USE_PREAD64)
26985   { "pwrite64",     (sqlcipher3_syscall_ptr)pwrite64,   0  },
26986 #else
26987   { "pwrite64",     (sqlcipher3_syscall_ptr)0,          0  },
26988 #endif
26989 #define osPwrite64  ((ssize_t(*)(int,const void*,size_t,off_t))\
26990                     aSyscall[13].pCurrent)
26991
26992 #if SQLCIPHER_ENABLE_LOCKING_STYLE
26993   { "fchmod",       (sqlcipher3_syscall_ptr)fchmod,     0  },
26994 #else
26995   { "fchmod",       (sqlcipher3_syscall_ptr)0,          0  },
26996 #endif
26997 #define osFchmod    ((int(*)(int,mode_t))aSyscall[14].pCurrent)
26998
26999 #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
27000   { "fallocate",    (sqlcipher3_syscall_ptr)posix_fallocate,  0 },
27001 #else
27002   { "fallocate",    (sqlcipher3_syscall_ptr)0,                0 },
27003 #endif
27004 #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
27005
27006   { "unlink",       (sqlcipher3_syscall_ptr)unlink,           0 },
27007 #define osUnlink    ((int(*)(const char*))aSyscall[16].pCurrent)
27008
27009   { "openDirectory",    (sqlcipher3_syscall_ptr)openDirectory,      0 },
27010 #define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
27011
27012 }; /* End of the overrideable system calls */
27013
27014 /*
27015 ** This is the xSetSystemCall() method of sqlcipher3_vfs for all of the
27016 ** "unix" VFSes.  Return SQLCIPHER_OK opon successfully updating the
27017 ** system call pointer, or SQLCIPHER_NOTFOUND if there is no configurable
27018 ** system call named zName.
27019 */
27020 static int unixSetSystemCall(
27021   sqlcipher3_vfs *pNotUsed,        /* The VFS pointer.  Not used */
27022   const char *zName,            /* Name of system call to override */
27023   sqlcipher3_syscall_ptr pNewFunc  /* Pointer to new system call value */
27024 ){
27025   unsigned int i;
27026   int rc = SQLCIPHER_NOTFOUND;
27027
27028   UNUSED_PARAMETER(pNotUsed);
27029   if( zName==0 ){
27030     /* If no zName is given, restore all system calls to their default
27031     ** settings and return NULL
27032     */
27033     rc = SQLCIPHER_OK;
27034     for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
27035       if( aSyscall[i].pDefault ){
27036         aSyscall[i].pCurrent = aSyscall[i].pDefault;
27037       }
27038     }
27039   }else{
27040     /* If zName is specified, operate on only the one system call
27041     ** specified.
27042     */
27043     for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
27044       if( strcmp(zName, aSyscall[i].zName)==0 ){
27045         if( aSyscall[i].pDefault==0 ){
27046           aSyscall[i].pDefault = aSyscall[i].pCurrent;
27047         }
27048         rc = SQLCIPHER_OK;
27049         if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
27050         aSyscall[i].pCurrent = pNewFunc;
27051         break;
27052       }
27053     }
27054   }
27055   return rc;
27056 }
27057
27058 /*
27059 ** Return the value of a system call.  Return NULL if zName is not a
27060 ** recognized system call name.  NULL is also returned if the system call
27061 ** is currently undefined.
27062 */
27063 static sqlcipher3_syscall_ptr unixGetSystemCall(
27064   sqlcipher3_vfs *pNotUsed,
27065   const char *zName
27066 ){
27067   unsigned int i;
27068
27069   UNUSED_PARAMETER(pNotUsed);
27070   for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
27071     if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
27072   }
27073   return 0;
27074 }
27075
27076 /*
27077 ** Return the name of the first system call after zName.  If zName==NULL
27078 ** then return the name of the first system call.  Return NULL if zName
27079 ** is the last system call or if zName is not the name of a valid
27080 ** system call.
27081 */
27082 static const char *unixNextSystemCall(sqlcipher3_vfs *p, const char *zName){
27083   int i = -1;
27084
27085   UNUSED_PARAMETER(p);
27086   if( zName ){
27087     for(i=0; i<ArraySize(aSyscall)-1; i++){
27088       if( strcmp(zName, aSyscall[i].zName)==0 ) break;
27089     }
27090   }
27091   for(i++; i<ArraySize(aSyscall); i++){
27092     if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
27093   }
27094   return 0;
27095 }
27096
27097 /*
27098 ** Retry open() calls that fail due to EINTR
27099 */
27100 static int robust_open(const char *z, int f, int m){
27101   int rc;
27102   do{ rc = osOpen(z,f,m); }while( rc<0 && errno==EINTR );
27103   return rc;
27104 }
27105
27106 /*
27107 ** Helper functions to obtain and relinquish the global mutex. The
27108 ** global mutex is used to protect the unixInodeInfo and
27109 ** vxworksFileId objects used by this file, all of which may be 
27110 ** shared by multiple threads.
27111 **
27112 ** Function unixMutexHeld() is used to assert() that the global mutex 
27113 ** is held when required. This function is only used as part of assert() 
27114 ** statements. e.g.
27115 **
27116 **   unixEnterMutex()
27117 **     assert( unixMutexHeld() );
27118 **   unixEnterLeave()
27119 */
27120 static void unixEnterMutex(void){
27121   sqlcipher3_mutex_enter(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
27122 }
27123 static void unixLeaveMutex(void){
27124   sqlcipher3_mutex_leave(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
27125 }
27126 #ifdef SQLCIPHER_DEBUG
27127 static int unixMutexHeld(void) {
27128   return sqlcipher3_mutex_held(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
27129 }
27130 #endif
27131
27132
27133 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
27134 /*
27135 ** Helper function for printing out trace information from debugging
27136 ** binaries. This returns the string represetation of the supplied
27137 ** integer lock-type.
27138 */
27139 static const char *azFileLock(int eFileLock){
27140   switch( eFileLock ){
27141     case NO_LOCK: return "NONE";
27142     case SHARED_LOCK: return "SHARED";
27143     case RESERVED_LOCK: return "RESERVED";
27144     case PENDING_LOCK: return "PENDING";
27145     case EXCLUSIVE_LOCK: return "EXCLUSIVE";
27146   }
27147   return "ERROR";
27148 }
27149 #endif
27150
27151 #ifdef SQLCIPHER_LOCK_TRACE
27152 /*
27153 ** Print out information about all locking operations.
27154 **
27155 ** This routine is used for troubleshooting locks on multithreaded
27156 ** platforms.  Enable by compiling with the -DSQLCIPHER_LOCK_TRACE
27157 ** command-line option on the compiler.  This code is normally
27158 ** turned off.
27159 */
27160 static int lockTrace(int fd, int op, struct flock *p){
27161   char *zOpName, *zType;
27162   int s;
27163   int savedErrno;
27164   if( op==F_GETLK ){
27165     zOpName = "GETLK";
27166   }else if( op==F_SETLK ){
27167     zOpName = "SETLK";
27168   }else{
27169     s = osFcntl(fd, op, p);
27170     sqlcipher3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
27171     return s;
27172   }
27173   if( p->l_type==F_RDLCK ){
27174     zType = "RDLCK";
27175   }else if( p->l_type==F_WRLCK ){
27176     zType = "WRLCK";
27177   }else if( p->l_type==F_UNLCK ){
27178     zType = "UNLCK";
27179   }else{
27180     assert( 0 );
27181   }
27182   assert( p->l_whence==SEEK_SET );
27183   s = osFcntl(fd, op, p);
27184   savedErrno = errno;
27185   sqlcipher3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
27186      threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
27187      (int)p->l_pid, s);
27188   if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
27189     struct flock l2;
27190     l2 = *p;
27191     osFcntl(fd, F_GETLK, &l2);
27192     if( l2.l_type==F_RDLCK ){
27193       zType = "RDLCK";
27194     }else if( l2.l_type==F_WRLCK ){
27195       zType = "WRLCK";
27196     }else if( l2.l_type==F_UNLCK ){
27197       zType = "UNLCK";
27198     }else{
27199       assert( 0 );
27200     }
27201     sqlcipher3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
27202        zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
27203   }
27204   errno = savedErrno;
27205   return s;
27206 }
27207 #undef osFcntl
27208 #define osFcntl lockTrace
27209 #endif /* SQLCIPHER_LOCK_TRACE */
27210
27211 /*
27212 ** Retry ftruncate() calls that fail due to EINTR
27213 */
27214 static int robust_ftruncate(int h, sqlcipher3_int64 sz){
27215   int rc;
27216   do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR );
27217   return rc;
27218 }
27219
27220 /*
27221 ** This routine translates a standard POSIX errno code into something
27222 ** useful to the clients of the sqlcipher3 functions.  Specifically, it is
27223 ** intended to translate a variety of "try again" errors into SQLCIPHER_BUSY
27224 ** and a variety of "please close the file descriptor NOW" errors into 
27225 ** SQLCIPHER_IOERR
27226 ** 
27227 ** Errors during initialization of locks, or file system support for locks,
27228 ** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
27229 */
27230 static int sqlcipherErrorFromPosixError(int posixError, int sqlcipherIOErr) {
27231   switch (posixError) {
27232 #if 0
27233   /* At one point this code was not commented out. In theory, this branch
27234   ** should never be hit, as this function should only be called after
27235   ** a locking-related function (i.e. fcntl()) has returned non-zero with
27236   ** the value of errno as the first argument. Since a system call has failed,
27237   ** errno should be non-zero.
27238   **
27239   ** Despite this, if errno really is zero, we still don't want to return
27240   ** SQLCIPHER_OK. The system call failed, and *some* SQLite error should be
27241   ** propagated back to the caller. Commenting this branch out means errno==0
27242   ** will be handled by the "default:" case below.
27243   */
27244   case 0: 
27245     return SQLCIPHER_OK;
27246 #endif
27247
27248   case EAGAIN:
27249   case ETIMEDOUT:
27250   case EBUSY:
27251   case EINTR:
27252   case ENOLCK:  
27253     /* random NFS retry error, unless during file system support 
27254      * introspection, in which it actually means what it says */
27255     return SQLCIPHER_BUSY;
27256     
27257   case EACCES: 
27258     /* EACCES is like EAGAIN during locking operations, but not any other time*/
27259     if( (sqlcipherIOErr == SQLCIPHER_IOERR_LOCK) || 
27260         (sqlcipherIOErr == SQLCIPHER_IOERR_UNLOCK) || 
27261         (sqlcipherIOErr == SQLCIPHER_IOERR_RDLOCK) ||
27262         (sqlcipherIOErr == SQLCIPHER_IOERR_CHECKRESERVEDLOCK) ){
27263       return SQLCIPHER_BUSY;
27264     }
27265     /* else fall through */
27266   case EPERM: 
27267     return SQLCIPHER_PERM;
27268     
27269   /* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And
27270   ** this module never makes such a call. And the code in SQLite itself 
27271   ** asserts that SQLCIPHER_IOERR_BLOCKED is never returned. For these reasons
27272   ** this case is also commented out. If the system does set errno to EDEADLK,
27273   ** the default SQLCIPHER_IOERR_XXX code will be returned. */
27274 #if 0
27275   case EDEADLK:
27276     return SQLCIPHER_IOERR_BLOCKED;
27277 #endif
27278     
27279 #if EOPNOTSUPP!=ENOTSUP
27280   case EOPNOTSUPP: 
27281     /* something went terribly awry, unless during file system support 
27282      * introspection, in which it actually means what it says */
27283 #endif
27284 #ifdef ENOTSUP
27285   case ENOTSUP: 
27286     /* invalid fd, unless during file system support introspection, in which 
27287      * it actually means what it says */
27288 #endif
27289   case EIO:
27290   case EBADF:
27291   case EINVAL:
27292   case ENOTCONN:
27293   case ENODEV:
27294   case ENXIO:
27295   case ENOENT:
27296 #ifdef ESTALE                     /* ESTALE is not defined on Interix systems */
27297   case ESTALE:
27298 #endif
27299   case ENOSYS:
27300     /* these should force the client to close the file and reconnect */
27301     
27302   default: 
27303     return sqlcipherIOErr;
27304   }
27305 }
27306
27307
27308
27309 /******************************************************************************
27310 ****************** Begin Unique File ID Utility Used By VxWorks ***************
27311 **
27312 ** On most versions of unix, we can get a unique ID for a file by concatenating
27313 ** the device number and the inode number.  But this does not work on VxWorks.
27314 ** On VxWorks, a unique file id must be based on the canonical filename.
27315 **
27316 ** A pointer to an instance of the following structure can be used as a
27317 ** unique file ID in VxWorks.  Each instance of this structure contains
27318 ** a copy of the canonical filename.  There is also a reference count.  
27319 ** The structure is reclaimed when the number of pointers to it drops to
27320 ** zero.
27321 **
27322 ** There are never very many files open at one time and lookups are not
27323 ** a performance-critical path, so it is sufficient to put these
27324 ** structures on a linked list.
27325 */
27326 struct vxworksFileId {
27327   struct vxworksFileId *pNext;  /* Next in a list of them all */
27328   int nRef;                     /* Number of references to this one */
27329   int nName;                    /* Length of the zCanonicalName[] string */
27330   char *zCanonicalName;         /* Canonical filename */
27331 };
27332
27333 #if OS_VXWORKS
27334 /* 
27335 ** All unique filenames are held on a linked list headed by this
27336 ** variable:
27337 */
27338 static struct vxworksFileId *vxworksFileList = 0;
27339
27340 /*
27341 ** Simplify a filename into its canonical form
27342 ** by making the following changes:
27343 **
27344 **  * removing any trailing and duplicate /
27345 **  * convert /./ into just /
27346 **  * convert /A/../ where A is any simple name into just /
27347 **
27348 ** Changes are made in-place.  Return the new name length.
27349 **
27350 ** The original filename is in z[0..n-1].  Return the number of
27351 ** characters in the simplified name.
27352 */
27353 static int vxworksSimplifyName(char *z, int n){
27354   int i, j;
27355   while( n>1 && z[n-1]=='/' ){ n--; }
27356   for(i=j=0; i<n; i++){
27357     if( z[i]=='/' ){
27358       if( z[i+1]=='/' ) continue;
27359       if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
27360         i += 1;
27361         continue;
27362       }
27363       if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
27364         while( j>0 && z[j-1]!='/' ){ j--; }
27365         if( j>0 ){ j--; }
27366         i += 2;
27367         continue;
27368       }
27369     }
27370     z[j++] = z[i];
27371   }
27372   z[j] = 0;
27373   return j;
27374 }
27375
27376 /*
27377 ** Find a unique file ID for the given absolute pathname.  Return
27378 ** a pointer to the vxworksFileId object.  This pointer is the unique
27379 ** file ID.
27380 **
27381 ** The nRef field of the vxworksFileId object is incremented before
27382 ** the object is returned.  A new vxworksFileId object is created
27383 ** and added to the global list if necessary.
27384 **
27385 ** If a memory allocation error occurs, return NULL.
27386 */
27387 static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){
27388   struct vxworksFileId *pNew;         /* search key and new file ID */
27389   struct vxworksFileId *pCandidate;   /* For looping over existing file IDs */
27390   int n;                              /* Length of zAbsoluteName string */
27391
27392   assert( zAbsoluteName[0]=='/' );
27393   n = (int)strlen(zAbsoluteName);
27394   pNew = sqlcipher3_malloc( sizeof(*pNew) + (n+1) );
27395   if( pNew==0 ) return 0;
27396   pNew->zCanonicalName = (char*)&pNew[1];
27397   memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
27398   n = vxworksSimplifyName(pNew->zCanonicalName, n);
27399
27400   /* Search for an existing entry that matching the canonical name.
27401   ** If found, increment the reference count and return a pointer to
27402   ** the existing file ID.
27403   */
27404   unixEnterMutex();
27405   for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
27406     if( pCandidate->nName==n 
27407      && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
27408     ){
27409        sqlcipher3_free(pNew);
27410        pCandidate->nRef++;
27411        unixLeaveMutex();
27412        return pCandidate;
27413     }
27414   }
27415
27416   /* No match was found.  We will make a new file ID */
27417   pNew->nRef = 1;
27418   pNew->nName = n;
27419   pNew->pNext = vxworksFileList;
27420   vxworksFileList = pNew;
27421   unixLeaveMutex();
27422   return pNew;
27423 }
27424
27425 /*
27426 ** Decrement the reference count on a vxworksFileId object.  Free
27427 ** the object when the reference count reaches zero.
27428 */
27429 static void vxworksReleaseFileId(struct vxworksFileId *pId){
27430   unixEnterMutex();
27431   assert( pId->nRef>0 );
27432   pId->nRef--;
27433   if( pId->nRef==0 ){
27434     struct vxworksFileId **pp;
27435     for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
27436     assert( *pp==pId );
27437     *pp = pId->pNext;
27438     sqlcipher3_free(pId);
27439   }
27440   unixLeaveMutex();
27441 }
27442 #endif /* OS_VXWORKS */
27443 /*************** End of Unique File ID Utility Used By VxWorks ****************
27444 ******************************************************************************/
27445
27446
27447 /******************************************************************************
27448 *************************** Posix Advisory Locking ****************************
27449 **
27450 ** POSIX advisory locks are broken by design.  ANSI STD 1003.1 (1996)
27451 ** section 6.5.2.2 lines 483 through 490 specify that when a process
27452 ** sets or clears a lock, that operation overrides any prior locks set
27453 ** by the same process.  It does not explicitly say so, but this implies
27454 ** that it overrides locks set by the same process using a different
27455 ** file descriptor.  Consider this test case:
27456 **
27457 **       int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
27458 **       int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
27459 **
27460 ** Suppose ./file1 and ./file2 are really the same file (because
27461 ** one is a hard or symbolic link to the other) then if you set
27462 ** an exclusive lock on fd1, then try to get an exclusive lock
27463 ** on fd2, it works.  I would have expected the second lock to
27464 ** fail since there was already a lock on the file due to fd1.
27465 ** But not so.  Since both locks came from the same process, the
27466 ** second overrides the first, even though they were on different
27467 ** file descriptors opened on different file names.
27468 **
27469 ** This means that we cannot use POSIX locks to synchronize file access
27470 ** among competing threads of the same process.  POSIX locks will work fine
27471 ** to synchronize access for threads in separate processes, but not
27472 ** threads within the same process.
27473 **
27474 ** To work around the problem, SQLite has to manage file locks internally
27475 ** on its own.  Whenever a new database is opened, we have to find the
27476 ** specific inode of the database file (the inode is determined by the
27477 ** st_dev and st_ino fields of the stat structure that fstat() fills in)
27478 ** and check for locks already existing on that inode.  When locks are
27479 ** created or removed, we have to look at our own internal record of the
27480 ** locks to see if another thread has previously set a lock on that same
27481 ** inode.
27482 **
27483 ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
27484 ** For VxWorks, we have to use the alternative unique ID system based on
27485 ** canonical filename and implemented in the previous division.)
27486 **
27487 ** The sqlcipher3_file structure for POSIX is no longer just an integer file
27488 ** descriptor.  It is now a structure that holds the integer file
27489 ** descriptor and a pointer to a structure that describes the internal
27490 ** locks on the corresponding inode.  There is one locking structure
27491 ** per inode, so if the same inode is opened twice, both unixFile structures
27492 ** point to the same locking structure.  The locking structure keeps
27493 ** a reference count (so we will know when to delete it) and a "cnt"
27494 ** field that tells us its internal lock status.  cnt==0 means the
27495 ** file is unlocked.  cnt==-1 means the file has an exclusive lock.
27496 ** cnt>0 means there are cnt shared locks on the file.
27497 **
27498 ** Any attempt to lock or unlock a file first checks the locking
27499 ** structure.  The fcntl() system call is only invoked to set a 
27500 ** POSIX lock if the internal lock structure transitions between
27501 ** a locked and an unlocked state.
27502 **
27503 ** But wait:  there are yet more problems with POSIX advisory locks.
27504 **
27505 ** If you close a file descriptor that points to a file that has locks,
27506 ** all locks on that file that are owned by the current process are
27507 ** released.  To work around this problem, each unixInodeInfo object
27508 ** maintains a count of the number of pending locks on tha inode.
27509 ** When an attempt is made to close an unixFile, if there are
27510 ** other unixFile open on the same inode that are holding locks, the call
27511 ** to close() the file descriptor is deferred until all of the locks clear.
27512 ** The unixInodeInfo structure keeps a list of file descriptors that need to
27513 ** be closed and that list is walked (and cleared) when the last lock
27514 ** clears.
27515 **
27516 ** Yet another problem:  LinuxThreads do not play well with posix locks.
27517 **
27518 ** Many older versions of linux use the LinuxThreads library which is
27519 ** not posix compliant.  Under LinuxThreads, a lock created by thread
27520 ** A cannot be modified or overridden by a different thread B.
27521 ** Only thread A can modify the lock.  Locking behavior is correct
27522 ** if the appliation uses the newer Native Posix Thread Library (NPTL)
27523 ** on linux - with NPTL a lock created by thread A can override locks
27524 ** in thread B.  But there is no way to know at compile-time which
27525 ** threading library is being used.  So there is no way to know at
27526 ** compile-time whether or not thread A can override locks on thread B.
27527 ** One has to do a run-time check to discover the behavior of the
27528 ** current process.
27529 **
27530 ** SQLite used to support LinuxThreads.  But support for LinuxThreads
27531 ** was dropped beginning with version 3.7.0.  SQLite will still work with
27532 ** LinuxThreads provided that (1) there is no more than one connection 
27533 ** per database file in the same process and (2) database connections
27534 ** do not move across threads.
27535 */
27536
27537 /*
27538 ** An instance of the following structure serves as the key used
27539 ** to locate a particular unixInodeInfo object.
27540 */
27541 struct unixFileId {
27542   dev_t dev;                  /* Device number */
27543 #if OS_VXWORKS
27544   struct vxworksFileId *pId;  /* Unique file ID for vxworks. */
27545 #else
27546   ino_t ino;                  /* Inode number */
27547 #endif
27548 };
27549
27550 /*
27551 ** An instance of the following structure is allocated for each open
27552 ** inode.  Or, on LinuxThreads, there is one of these structures for
27553 ** each inode opened by each thread.
27554 **
27555 ** A single inode can have multiple file descriptors, so each unixFile
27556 ** structure contains a pointer to an instance of this object and this
27557 ** object keeps a count of the number of unixFile pointing to it.
27558 */
27559 struct unixInodeInfo {
27560   struct unixFileId fileId;       /* The lookup key */
27561   int nShared;                    /* Number of SHARED locks held */
27562   unsigned char eFileLock;        /* One of SHARED_LOCK, RESERVED_LOCK etc. */
27563   unsigned char bProcessLock;     /* An exclusive process lock is held */
27564   int nRef;                       /* Number of pointers to this structure */
27565   unixShmNode *pShmNode;          /* Shared memory associated with this inode */
27566   int nLock;                      /* Number of outstanding file locks */
27567   UnixUnusedFd *pUnused;          /* Unused file descriptors to close */
27568   unixInodeInfo *pNext;           /* List of all unixInodeInfo objects */
27569   unixInodeInfo *pPrev;           /*    .... doubly linked */
27570 #if SQLCIPHER_ENABLE_LOCKING_STYLE
27571   unsigned long long sharedByte;  /* for AFP simulated shared lock */
27572 #endif
27573 #if OS_VXWORKS
27574   sem_t *pSem;                    /* Named POSIX semaphore */
27575   char aSemName[MAX_PATHNAME+2];  /* Name of that semaphore */
27576 #endif
27577 };
27578
27579 /*
27580 ** A lists of all unixInodeInfo objects.
27581 */
27582 static unixInodeInfo *inodeList = 0;
27583
27584 /*
27585 **
27586 ** This function - unixLogError_x(), is only ever called via the macro
27587 ** unixLogError().
27588 **
27589 ** It is invoked after an error occurs in an OS function and errno has been
27590 ** set. It logs a message using sqlcipher3_log() containing the current value of
27591 ** errno and, if possible, the human-readable equivalent from strerror() or
27592 ** strerror_r().
27593 **
27594 ** The first argument passed to the macro should be the error code that
27595 ** will be returned to SQLite (e.g. SQLCIPHER_IOERR_DELETE, SQLCIPHER_CANTOPEN). 
27596 ** The two subsequent arguments should be the name of the OS function that
27597 ** failed (e.g. "unlink", "open") and the the associated file-system path,
27598 ** if any.
27599 */
27600 #define unixLogError(a,b,c)     unixLogErrorAtLine(a,b,c,__LINE__)
27601 static int unixLogErrorAtLine(
27602   int errcode,                    /* SQLite error code */
27603   const char *zFunc,              /* Name of OS function that failed */
27604   const char *zPath,              /* File path associated with error */
27605   int iLine                       /* Source line number where error occurred */
27606 ){
27607   char *zErr;                     /* Message from strerror() or equivalent */
27608   int iErrno = errno;             /* Saved syscall error number */
27609
27610   /* If this is not a threadsafe build (SQLCIPHER_THREADSAFE==0), then use
27611   ** the strerror() function to obtain the human-readable error message
27612   ** equivalent to errno. Otherwise, use strerror_r().
27613   */ 
27614 #if SQLCIPHER_THREADSAFE && defined(HAVE_STRERROR_R)
27615   char aErr[80];
27616   memset(aErr, 0, sizeof(aErr));
27617   zErr = aErr;
27618
27619   /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
27620   ** assume that the system provides the the GNU version of strerror_r() that 
27621   ** returns a pointer to a buffer containing the error message. That pointer 
27622   ** may point to aErr[], or it may point to some static storage somewhere. 
27623   ** Otherwise, assume that the system provides the POSIX version of 
27624   ** strerror_r(), which always writes an error message into aErr[].
27625   **
27626   ** If the code incorrectly assumes that it is the POSIX version that is
27627   ** available, the error message will often be an empty string. Not a
27628   ** huge problem. Incorrectly concluding that the GNU version is available 
27629   ** could lead to a segfault though.
27630   */
27631 #if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
27632   zErr = 
27633 # endif
27634   strerror_r(iErrno, aErr, sizeof(aErr)-1);
27635
27636 #elif SQLCIPHER_THREADSAFE
27637   /* This is a threadsafe build, but strerror_r() is not available. */
27638   zErr = "";
27639 #else
27640   /* Non-threadsafe build, use strerror(). */
27641   zErr = strerror(iErrno);
27642 #endif
27643
27644   assert( errcode!=SQLCIPHER_OK );
27645   if( zPath==0 ) zPath = "";
27646   sqlcipher3_log(errcode,
27647       "os_unix.c:%d: (%d) %s(%s) - %s",
27648       iLine, iErrno, zFunc, zPath, zErr
27649   );
27650
27651   return errcode;
27652 }
27653
27654 /*
27655 ** Close a file descriptor.
27656 **
27657 ** We assume that close() almost always works, since it is only in a
27658 ** very sick application or on a very sick platform that it might fail.
27659 ** If it does fail, simply leak the file descriptor, but do log the
27660 ** error.
27661 **
27662 ** Note that it is not safe to retry close() after EINTR since the
27663 ** file descriptor might have already been reused by another thread.
27664 ** So we don't even try to recover from an EINTR.  Just log the error
27665 ** and move on.
27666 */
27667 static void robust_close(unixFile *pFile, int h, int lineno){
27668   if( osClose(h) ){
27669     unixLogErrorAtLine(SQLCIPHER_IOERR_CLOSE, "close",
27670                        pFile ? pFile->zPath : 0, lineno);
27671   }
27672 }
27673
27674 /*
27675 ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
27676 */ 
27677 static void closePendingFds(unixFile *pFile){
27678   unixInodeInfo *pInode = pFile->pInode;
27679   UnixUnusedFd *p;
27680   UnixUnusedFd *pNext;
27681   for(p=pInode->pUnused; p; p=pNext){
27682     pNext = p->pNext;
27683     robust_close(pFile, p->fd, __LINE__);
27684     sqlcipher3_free(p);
27685   }
27686   pInode->pUnused = 0;
27687 }
27688
27689 /*
27690 ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
27691 **
27692 ** The mutex entered using the unixEnterMutex() function must be held
27693 ** when this function is called.
27694 */
27695 static void releaseInodeInfo(unixFile *pFile){
27696   unixInodeInfo *pInode = pFile->pInode;
27697   assert( unixMutexHeld() );
27698   if( ALWAYS(pInode) ){
27699     pInode->nRef--;
27700     if( pInode->nRef==0 ){
27701       assert( pInode->pShmNode==0 );
27702       closePendingFds(pFile);
27703       if( pInode->pPrev ){
27704         assert( pInode->pPrev->pNext==pInode );
27705         pInode->pPrev->pNext = pInode->pNext;
27706       }else{
27707         assert( inodeList==pInode );
27708         inodeList = pInode->pNext;
27709       }
27710       if( pInode->pNext ){
27711         assert( pInode->pNext->pPrev==pInode );
27712         pInode->pNext->pPrev = pInode->pPrev;
27713       }
27714       sqlcipher3_free(pInode);
27715     }
27716   }
27717 }
27718
27719 /*
27720 ** Given a file descriptor, locate the unixInodeInfo object that
27721 ** describes that file descriptor.  Create a new one if necessary.  The
27722 ** return value might be uninitialized if an error occurs.
27723 **
27724 ** The mutex entered using the unixEnterMutex() function must be held
27725 ** when this function is called.
27726 **
27727 ** Return an appropriate error code.
27728 */
27729 static int findInodeInfo(
27730   unixFile *pFile,               /* Unix file with file desc used in the key */
27731   unixInodeInfo **ppInode        /* Return the unixInodeInfo object here */
27732 ){
27733   int rc;                        /* System call return code */
27734   int fd;                        /* The file descriptor for pFile */
27735   struct unixFileId fileId;      /* Lookup key for the unixInodeInfo */
27736   struct stat statbuf;           /* Low-level file information */
27737   unixInodeInfo *pInode = 0;     /* Candidate unixInodeInfo object */
27738
27739   assert( unixMutexHeld() );
27740
27741   /* Get low-level information about the file that we can used to
27742   ** create a unique name for the file.
27743   */
27744   fd = pFile->h;
27745   rc = osFstat(fd, &statbuf);
27746   if( rc!=0 ){
27747     pFile->lastErrno = errno;
27748 #ifdef EOVERFLOW
27749     if( pFile->lastErrno==EOVERFLOW ) return SQLCIPHER_NOLFS;
27750 #endif
27751     return SQLCIPHER_IOERR;
27752   }
27753
27754 #ifdef __APPLE__
27755   /* On OS X on an msdos filesystem, the inode number is reported
27756   ** incorrectly for zero-size files.  See ticket #3260.  To work
27757   ** around this problem (we consider it a bug in OS X, not SQLite)
27758   ** we always increase the file size to 1 by writing a single byte
27759   ** prior to accessing the inode number.  The one byte written is
27760   ** an ASCII 'S' character which also happens to be the first byte
27761   ** in the header of every SQLite database.  In this way, if there
27762   ** is a race condition such that another thread has already populated
27763   ** the first page of the database, no damage is done.
27764   */
27765   if( statbuf.st_size==0 && (pFile->fsFlags & SQLCIPHER_FSFLAGS_IS_MSDOS)!=0 ){
27766     do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
27767     if( rc!=1 ){
27768       pFile->lastErrno = errno;
27769       return SQLCIPHER_IOERR;
27770     }
27771     rc = osFstat(fd, &statbuf);
27772     if( rc!=0 ){
27773       pFile->lastErrno = errno;
27774       return SQLCIPHER_IOERR;
27775     }
27776   }
27777 #endif
27778
27779   memset(&fileId, 0, sizeof(fileId));
27780   fileId.dev = statbuf.st_dev;
27781 #if OS_VXWORKS
27782   fileId.pId = pFile->pId;
27783 #else
27784   fileId.ino = statbuf.st_ino;
27785 #endif
27786   pInode = inodeList;
27787   while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
27788     pInode = pInode->pNext;
27789   }
27790   if( pInode==0 ){
27791     pInode = sqlcipher3_malloc( sizeof(*pInode) );
27792     if( pInode==0 ){
27793       return SQLCIPHER_NOMEM;
27794     }
27795     memset(pInode, 0, sizeof(*pInode));
27796     memcpy(&pInode->fileId, &fileId, sizeof(fileId));
27797     pInode->nRef = 1;
27798     pInode->pNext = inodeList;
27799     pInode->pPrev = 0;
27800     if( inodeList ) inodeList->pPrev = pInode;
27801     inodeList = pInode;
27802   }else{
27803     pInode->nRef++;
27804   }
27805   *ppInode = pInode;
27806   return SQLCIPHER_OK;
27807 }
27808
27809
27810 /*
27811 ** This routine checks if there is a RESERVED lock held on the specified
27812 ** file by this or any other process. If such a lock is held, set *pResOut
27813 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
27814 ** is set to SQLCIPHER_OK unless an I/O error occurs during lock checking.
27815 */
27816 static int unixCheckReservedLock(sqlcipher3_file *id, int *pResOut){
27817   int rc = SQLCIPHER_OK;
27818   int reserved = 0;
27819   unixFile *pFile = (unixFile*)id;
27820
27821   SimulateIOError( return SQLCIPHER_IOERR_CHECKRESERVEDLOCK; );
27822
27823   assert( pFile );
27824   unixEnterMutex(); /* Because pFile->pInode is shared across threads */
27825
27826   /* Check if a thread in this process holds such a lock */
27827   if( pFile->pInode->eFileLock>SHARED_LOCK ){
27828     reserved = 1;
27829   }
27830
27831   /* Otherwise see if some other process holds it.
27832   */
27833 #ifndef __DJGPP__
27834   if( !reserved && !pFile->pInode->bProcessLock ){
27835     struct flock lock;
27836     lock.l_whence = SEEK_SET;
27837     lock.l_start = RESERVED_BYTE;
27838     lock.l_len = 1;
27839     lock.l_type = F_WRLCK;
27840     if( osFcntl(pFile->h, F_GETLK, &lock) ){
27841       rc = SQLCIPHER_IOERR_CHECKRESERVEDLOCK;
27842       pFile->lastErrno = errno;
27843     } else if( lock.l_type!=F_UNLCK ){
27844       reserved = 1;
27845     }
27846   }
27847 #endif
27848   
27849   unixLeaveMutex();
27850   OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
27851
27852   *pResOut = reserved;
27853   return rc;
27854 }
27855
27856 /*
27857 ** Attempt to set a system-lock on the file pFile.  The lock is 
27858 ** described by pLock.
27859 **
27860 ** If the pFile was opened read/write from unix-excl, then the only lock
27861 ** ever obtained is an exclusive lock, and it is obtained exactly once
27862 ** the first time any lock is attempted.  All subsequent system locking
27863 ** operations become no-ops.  Locking operations still happen internally,
27864 ** in order to coordinate access between separate database connections
27865 ** within this process, but all of that is handled in memory and the
27866 ** operating system does not participate.
27867 **
27868 ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
27869 ** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
27870 ** and is read-only.
27871 **
27872 ** Zero is returned if the call completes successfully, or -1 if a call
27873 ** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
27874 */
27875 static int unixFileLock(unixFile *pFile, struct flock *pLock){
27876   int rc;
27877   unixInodeInfo *pInode = pFile->pInode;
27878   assert( unixMutexHeld() );
27879   assert( pInode!=0 );
27880   if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock)
27881    && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0)
27882   ){
27883     if( pInode->bProcessLock==0 ){
27884       struct flock lock;
27885       assert( pInode->nLock==0 );
27886       lock.l_whence = SEEK_SET;
27887       lock.l_start = SHARED_FIRST;
27888       lock.l_len = SHARED_SIZE;
27889       lock.l_type = F_WRLCK;
27890       rc = osFcntl(pFile->h, F_SETLK, &lock);
27891       if( rc<0 ) return rc;
27892       pInode->bProcessLock = 1;
27893       pInode->nLock++;
27894     }else{
27895       rc = 0;
27896     }
27897   }else{
27898     rc = osFcntl(pFile->h, F_SETLK, pLock);
27899   }
27900   return rc;
27901 }
27902
27903 /*
27904 ** Lock the file with the lock specified by parameter eFileLock - one
27905 ** of the following:
27906 **
27907 **     (1) SHARED_LOCK
27908 **     (2) RESERVED_LOCK
27909 **     (3) PENDING_LOCK
27910 **     (4) EXCLUSIVE_LOCK
27911 **
27912 ** Sometimes when requesting one lock state, additional lock states
27913 ** are inserted in between.  The locking might fail on one of the later
27914 ** transitions leaving the lock state different from what it started but
27915 ** still short of its goal.  The following chart shows the allowed
27916 ** transitions and the inserted intermediate states:
27917 **
27918 **    UNLOCKED -> SHARED
27919 **    SHARED -> RESERVED
27920 **    SHARED -> (PENDING) -> EXCLUSIVE
27921 **    RESERVED -> (PENDING) -> EXCLUSIVE
27922 **    PENDING -> EXCLUSIVE
27923 **
27924 ** This routine will only increase a lock.  Use the sqlcipher3OsUnlock()
27925 ** routine to lower a locking level.
27926 */
27927 static int unixLock(sqlcipher3_file *id, int eFileLock){
27928   /* The following describes the implementation of the various locks and
27929   ** lock transitions in terms of the POSIX advisory shared and exclusive
27930   ** lock primitives (called read-locks and write-locks below, to avoid
27931   ** confusion with SQLite lock names). The algorithms are complicated
27932   ** slightly in order to be compatible with windows systems simultaneously
27933   ** accessing the same database file, in case that is ever required.
27934   **
27935   ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
27936   ** byte', each single bytes at well known offsets, and the 'shared byte
27937   ** range', a range of 510 bytes at a well known offset.
27938   **
27939   ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
27940   ** byte'.  If this is successful, a random byte from the 'shared byte
27941   ** range' is read-locked and the lock on the 'pending byte' released.
27942   **
27943   ** A process may only obtain a RESERVED lock after it has a SHARED lock.
27944   ** A RESERVED lock is implemented by grabbing a write-lock on the
27945   ** 'reserved byte'. 
27946   **
27947   ** A process may only obtain a PENDING lock after it has obtained a
27948   ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
27949   ** on the 'pending byte'. This ensures that no new SHARED locks can be
27950   ** obtained, but existing SHARED locks are allowed to persist. A process
27951   ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
27952   ** This property is used by the algorithm for rolling back a journal file
27953   ** after a crash.
27954   **
27955   ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
27956   ** implemented by obtaining a write-lock on the entire 'shared byte
27957   ** range'. Since all other locks require a read-lock on one of the bytes
27958   ** within this range, this ensures that no other locks are held on the
27959   ** database. 
27960   **
27961   ** The reason a single byte cannot be used instead of the 'shared byte
27962   ** range' is that some versions of windows do not support read-locks. By
27963   ** locking a random byte from a range, concurrent SHARED locks may exist
27964   ** even if the locking primitive used is always a write-lock.
27965   */
27966   int rc = SQLCIPHER_OK;
27967   unixFile *pFile = (unixFile*)id;
27968   unixInodeInfo *pInode;
27969   struct flock lock;
27970   int tErrno = 0;
27971
27972   assert( pFile );
27973   OSTRACE(("LOCK    %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
27974       azFileLock(eFileLock), azFileLock(pFile->eFileLock),
27975       azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared , getpid()));
27976
27977   /* If there is already a lock of this type or more restrictive on the
27978   ** unixFile, do nothing. Don't use the end_lock: exit path, as
27979   ** unixEnterMutex() hasn't been called yet.
27980   */
27981   if( pFile->eFileLock>=eFileLock ){
27982     OSTRACE(("LOCK    %d %s ok (already held) (unix)\n", pFile->h,
27983             azFileLock(eFileLock)));
27984     return SQLCIPHER_OK;
27985   }
27986
27987   /* Make sure the locking sequence is correct.
27988   **  (1) We never move from unlocked to anything higher than shared lock.
27989   **  (2) SQLite never explicitly requests a pendig lock.
27990   **  (3) A shared lock is always held when a reserve lock is requested.
27991   */
27992   assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
27993   assert( eFileLock!=PENDING_LOCK );
27994   assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
27995
27996   /* This mutex is needed because pFile->pInode is shared across threads
27997   */
27998   unixEnterMutex();
27999   pInode = pFile->pInode;
28000
28001   /* If some thread using this PID has a lock via a different unixFile*
28002   ** handle that precludes the requested lock, return BUSY.
28003   */
28004   if( (pFile->eFileLock!=pInode->eFileLock && 
28005           (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
28006   ){
28007     rc = SQLCIPHER_BUSY;
28008     goto end_lock;
28009   }
28010
28011   /* If a SHARED lock is requested, and some thread using this PID already
28012   ** has a SHARED or RESERVED lock, then increment reference counts and
28013   ** return SQLCIPHER_OK.
28014   */
28015   if( eFileLock==SHARED_LOCK && 
28016       (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
28017     assert( eFileLock==SHARED_LOCK );
28018     assert( pFile->eFileLock==0 );
28019     assert( pInode->nShared>0 );
28020     pFile->eFileLock = SHARED_LOCK;
28021     pInode->nShared++;
28022     pInode->nLock++;
28023     goto end_lock;
28024   }
28025
28026
28027   /* A PENDING lock is needed before acquiring a SHARED lock and before
28028   ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
28029   ** be released.
28030   */
28031   lock.l_len = 1L;
28032   lock.l_whence = SEEK_SET;
28033   if( eFileLock==SHARED_LOCK 
28034       || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
28035   ){
28036     lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
28037     lock.l_start = PENDING_BYTE;
28038     if( unixFileLock(pFile, &lock) ){
28039       tErrno = errno;
28040       rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_LOCK);
28041       if( rc!=SQLCIPHER_BUSY ){
28042         pFile->lastErrno = tErrno;
28043       }
28044       goto end_lock;
28045     }
28046   }
28047
28048
28049   /* If control gets to this point, then actually go ahead and make
28050   ** operating system calls for the specified lock.
28051   */
28052   if( eFileLock==SHARED_LOCK ){
28053     assert( pInode->nShared==0 );
28054     assert( pInode->eFileLock==0 );
28055     assert( rc==SQLCIPHER_OK );
28056
28057     /* Now get the read-lock */
28058     lock.l_start = SHARED_FIRST;
28059     lock.l_len = SHARED_SIZE;
28060     if( unixFileLock(pFile, &lock) ){
28061       tErrno = errno;
28062       rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_LOCK);
28063     }
28064
28065     /* Drop the temporary PENDING lock */
28066     lock.l_start = PENDING_BYTE;
28067     lock.l_len = 1L;
28068     lock.l_type = F_UNLCK;
28069     if( unixFileLock(pFile, &lock) && rc==SQLCIPHER_OK ){
28070       /* This could happen with a network mount */
28071       tErrno = errno;
28072       rc = SQLCIPHER_IOERR_UNLOCK; 
28073     }
28074
28075     if( rc ){
28076       if( rc!=SQLCIPHER_BUSY ){
28077         pFile->lastErrno = tErrno;
28078       }
28079       goto end_lock;
28080     }else{
28081       pFile->eFileLock = SHARED_LOCK;
28082       pInode->nLock++;
28083       pInode->nShared = 1;
28084     }
28085   }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
28086     /* We are trying for an exclusive lock but another thread in this
28087     ** same process is still holding a shared lock. */
28088     rc = SQLCIPHER_BUSY;
28089   }else{
28090     /* The request was for a RESERVED or EXCLUSIVE lock.  It is
28091     ** assumed that there is a SHARED or greater lock on the file
28092     ** already.
28093     */
28094     assert( 0!=pFile->eFileLock );
28095     lock.l_type = F_WRLCK;
28096
28097     assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
28098     if( eFileLock==RESERVED_LOCK ){
28099       lock.l_start = RESERVED_BYTE;
28100       lock.l_len = 1L;
28101     }else{
28102       lock.l_start = SHARED_FIRST;
28103       lock.l_len = SHARED_SIZE;
28104     }
28105
28106     if( unixFileLock(pFile, &lock) ){
28107       tErrno = errno;
28108       rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_LOCK);
28109       if( rc!=SQLCIPHER_BUSY ){
28110         pFile->lastErrno = tErrno;
28111       }
28112     }
28113   }
28114   
28115
28116 #ifndef NDEBUG
28117   /* Set up the transaction-counter change checking flags when
28118   ** transitioning from a SHARED to a RESERVED lock.  The change
28119   ** from SHARED to RESERVED marks the beginning of a normal
28120   ** write operation (not a hot journal rollback).
28121   */
28122   if( rc==SQLCIPHER_OK
28123    && pFile->eFileLock<=SHARED_LOCK
28124    && eFileLock==RESERVED_LOCK
28125   ){
28126     pFile->transCntrChng = 0;
28127     pFile->dbUpdate = 0;
28128     pFile->inNormalWrite = 1;
28129   }
28130 #endif
28131
28132
28133   if( rc==SQLCIPHER_OK ){
28134     pFile->eFileLock = eFileLock;
28135     pInode->eFileLock = eFileLock;
28136   }else if( eFileLock==EXCLUSIVE_LOCK ){
28137     pFile->eFileLock = PENDING_LOCK;
28138     pInode->eFileLock = PENDING_LOCK;
28139   }
28140
28141 end_lock:
28142   unixLeaveMutex();
28143   OSTRACE(("LOCK    %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock), 
28144       rc==SQLCIPHER_OK ? "ok" : "failed"));
28145   return rc;
28146 }
28147
28148 /*
28149 ** Add the file descriptor used by file handle pFile to the corresponding
28150 ** pUnused list.
28151 */
28152 static void setPendingFd(unixFile *pFile){
28153   unixInodeInfo *pInode = pFile->pInode;
28154   UnixUnusedFd *p = pFile->pUnused;
28155   p->pNext = pInode->pUnused;
28156   pInode->pUnused = p;
28157   pFile->h = -1;
28158   pFile->pUnused = 0;
28159 }
28160
28161 /*
28162 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
28163 ** must be either NO_LOCK or SHARED_LOCK.
28164 **
28165 ** If the locking level of the file descriptor is already at or below
28166 ** the requested locking level, this routine is a no-op.
28167 ** 
28168 ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
28169 ** the byte range is divided into 2 parts and the first part is unlocked then
28170 ** set to a read lock, then the other part is simply unlocked.  This works 
28171 ** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to 
28172 ** remove the write lock on a region when a read lock is set.
28173 */
28174 static int posixUnlock(sqlcipher3_file *id, int eFileLock, int handleNFSUnlock){
28175   unixFile *pFile = (unixFile*)id;
28176   unixInodeInfo *pInode;
28177   struct flock lock;
28178   int rc = SQLCIPHER_OK;
28179
28180   assert( pFile );
28181   OSTRACE(("UNLOCK  %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
28182       pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
28183       getpid()));
28184
28185   assert( eFileLock<=SHARED_LOCK );
28186   if( pFile->eFileLock<=eFileLock ){
28187     return SQLCIPHER_OK;
28188   }
28189   unixEnterMutex();
28190   pInode = pFile->pInode;
28191   assert( pInode->nShared!=0 );
28192   if( pFile->eFileLock>SHARED_LOCK ){
28193     assert( pInode->eFileLock==pFile->eFileLock );
28194
28195 #ifndef NDEBUG
28196     /* When reducing a lock such that other processes can start
28197     ** reading the database file again, make sure that the
28198     ** transaction counter was updated if any part of the database
28199     ** file changed.  If the transaction counter is not updated,
28200     ** other connections to the same file might not realize that
28201     ** the file has changed and hence might not know to flush their
28202     ** cache.  The use of a stale cache can lead to database corruption.
28203     */
28204     pFile->inNormalWrite = 0;
28205 #endif
28206
28207     /* downgrading to a shared lock on NFS involves clearing the write lock
28208     ** before establishing the readlock - to avoid a race condition we downgrade
28209     ** the lock in 2 blocks, so that part of the range will be covered by a 
28210     ** write lock until the rest is covered by a read lock:
28211     **  1:   [WWWWW]
28212     **  2:   [....W]
28213     **  3:   [RRRRW]
28214     **  4:   [RRRR.]
28215     */
28216     if( eFileLock==SHARED_LOCK ){
28217
28218 #if !defined(__APPLE__) || !SQLCIPHER_ENABLE_LOCKING_STYLE
28219       (void)handleNFSUnlock;
28220       assert( handleNFSUnlock==0 );
28221 #endif
28222 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
28223       if( handleNFSUnlock ){
28224         int tErrno;               /* Error code from system call errors */
28225         off_t divSize = SHARED_SIZE - 1;
28226         
28227         lock.l_type = F_UNLCK;
28228         lock.l_whence = SEEK_SET;
28229         lock.l_start = SHARED_FIRST;
28230         lock.l_len = divSize;
28231         if( unixFileLock(pFile, &lock)==(-1) ){
28232           tErrno = errno;
28233           rc = SQLCIPHER_IOERR_UNLOCK;
28234           if( IS_LOCK_ERROR(rc) ){
28235             pFile->lastErrno = tErrno;
28236           }
28237           goto end_unlock;
28238         }
28239         lock.l_type = F_RDLCK;
28240         lock.l_whence = SEEK_SET;
28241         lock.l_start = SHARED_FIRST;
28242         lock.l_len = divSize;
28243         if( unixFileLock(pFile, &lock)==(-1) ){
28244           tErrno = errno;
28245           rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_RDLOCK);
28246           if( IS_LOCK_ERROR(rc) ){
28247             pFile->lastErrno = tErrno;
28248           }
28249           goto end_unlock;
28250         }
28251         lock.l_type = F_UNLCK;
28252         lock.l_whence = SEEK_SET;
28253         lock.l_start = SHARED_FIRST+divSize;
28254         lock.l_len = SHARED_SIZE-divSize;
28255         if( unixFileLock(pFile, &lock)==(-1) ){
28256           tErrno = errno;
28257           rc = SQLCIPHER_IOERR_UNLOCK;
28258           if( IS_LOCK_ERROR(rc) ){
28259             pFile->lastErrno = tErrno;
28260           }
28261           goto end_unlock;
28262         }
28263       }else
28264 #endif /* defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE */
28265       {
28266         lock.l_type = F_RDLCK;
28267         lock.l_whence = SEEK_SET;
28268         lock.l_start = SHARED_FIRST;
28269         lock.l_len = SHARED_SIZE;
28270         if( unixFileLock(pFile, &lock) ){
28271           /* In theory, the call to unixFileLock() cannot fail because another
28272           ** process is holding an incompatible lock. If it does, this 
28273           ** indicates that the other process is not following the locking
28274           ** protocol. If this happens, return SQLCIPHER_IOERR_RDLOCK. Returning
28275           ** SQLCIPHER_BUSY would confuse the upper layer (in practice it causes 
28276           ** an assert to fail). */ 
28277           rc = SQLCIPHER_IOERR_RDLOCK;
28278           pFile->lastErrno = errno;
28279           goto end_unlock;
28280         }
28281       }
28282     }
28283     lock.l_type = F_UNLCK;
28284     lock.l_whence = SEEK_SET;
28285     lock.l_start = PENDING_BYTE;
28286     lock.l_len = 2L;  assert( PENDING_BYTE+1==RESERVED_BYTE );
28287     if( unixFileLock(pFile, &lock)==0 ){
28288       pInode->eFileLock = SHARED_LOCK;
28289     }else{
28290       rc = SQLCIPHER_IOERR_UNLOCK;
28291       pFile->lastErrno = errno;
28292       goto end_unlock;
28293     }
28294   }
28295   if( eFileLock==NO_LOCK ){
28296     /* Decrement the shared lock counter.  Release the lock using an
28297     ** OS call only when all threads in this same process have released
28298     ** the lock.
28299     */
28300     pInode->nShared--;
28301     if( pInode->nShared==0 ){
28302       lock.l_type = F_UNLCK;
28303       lock.l_whence = SEEK_SET;
28304       lock.l_start = lock.l_len = 0L;
28305       if( unixFileLock(pFile, &lock)==0 ){
28306         pInode->eFileLock = NO_LOCK;
28307       }else{
28308         rc = SQLCIPHER_IOERR_UNLOCK;
28309         pFile->lastErrno = errno;
28310         pInode->eFileLock = NO_LOCK;
28311         pFile->eFileLock = NO_LOCK;
28312       }
28313     }
28314
28315     /* Decrement the count of locks against this same file.  When the
28316     ** count reaches zero, close any other file descriptors whose close
28317     ** was deferred because of outstanding locks.
28318     */
28319     pInode->nLock--;
28320     assert( pInode->nLock>=0 );
28321     if( pInode->nLock==0 ){
28322       closePendingFds(pFile);
28323     }
28324   }
28325         
28326 end_unlock:
28327   unixLeaveMutex();
28328   if( rc==SQLCIPHER_OK ) pFile->eFileLock = eFileLock;
28329   return rc;
28330 }
28331
28332 /*
28333 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
28334 ** must be either NO_LOCK or SHARED_LOCK.
28335 **
28336 ** If the locking level of the file descriptor is already at or below
28337 ** the requested locking level, this routine is a no-op.
28338 */
28339 static int unixUnlock(sqlcipher3_file *id, int eFileLock){
28340   return posixUnlock(id, eFileLock, 0);
28341 }
28342
28343 /*
28344 ** This function performs the parts of the "close file" operation 
28345 ** common to all locking schemes. It closes the directory and file
28346 ** handles, if they are valid, and sets all fields of the unixFile
28347 ** structure to 0.
28348 **
28349 ** It is *not* necessary to hold the mutex when this routine is called,
28350 ** even on VxWorks.  A mutex will be acquired on VxWorks by the
28351 ** vxworksReleaseFileId() routine.
28352 */
28353 static int closeUnixFile(sqlcipher3_file *id){
28354   unixFile *pFile = (unixFile*)id;
28355   if( pFile->h>=0 ){
28356     robust_close(pFile, pFile->h, __LINE__);
28357     pFile->h = -1;
28358   }
28359 #if OS_VXWORKS
28360   if( pFile->pId ){
28361     if( pFile->isDelete ){
28362       osUnlink(pFile->pId->zCanonicalName);
28363     }
28364     vxworksReleaseFileId(pFile->pId);
28365     pFile->pId = 0;
28366   }
28367 #endif
28368   OSTRACE(("CLOSE   %-3d\n", pFile->h));
28369   OpenCounter(-1);
28370   sqlcipher3_free(pFile->pUnused);
28371   memset(pFile, 0, sizeof(unixFile));
28372   return SQLCIPHER_OK;
28373 }
28374
28375 /*
28376 ** Close a file.
28377 */
28378 static int unixClose(sqlcipher3_file *id){
28379   int rc = SQLCIPHER_OK;
28380   unixFile *pFile = (unixFile *)id;
28381   unixUnlock(id, NO_LOCK);
28382   unixEnterMutex();
28383
28384   /* unixFile.pInode is always valid here. Otherwise, a different close
28385   ** routine (e.g. nolockClose()) would be called instead.
28386   */
28387   assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
28388   if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
28389     /* If there are outstanding locks, do not actually close the file just
28390     ** yet because that would clear those locks.  Instead, add the file
28391     ** descriptor to pInode->pUnused list.  It will be automatically closed 
28392     ** when the last lock is cleared.
28393     */
28394     setPendingFd(pFile);
28395   }
28396   releaseInodeInfo(pFile);
28397   rc = closeUnixFile(id);
28398   unixLeaveMutex();
28399   return rc;
28400 }
28401
28402 /************** End of the posix advisory lock implementation *****************
28403 ******************************************************************************/
28404
28405 /******************************************************************************
28406 ****************************** No-op Locking **********************************
28407 **
28408 ** Of the various locking implementations available, this is by far the
28409 ** simplest:  locking is ignored.  No attempt is made to lock the database
28410 ** file for reading or writing.
28411 **
28412 ** This locking mode is appropriate for use on read-only databases
28413 ** (ex: databases that are burned into CD-ROM, for example.)  It can
28414 ** also be used if the application employs some external mechanism to
28415 ** prevent simultaneous access of the same database by two or more
28416 ** database connections.  But there is a serious risk of database
28417 ** corruption if this locking mode is used in situations where multiple
28418 ** database connections are accessing the same database file at the same
28419 ** time and one or more of those connections are writing.
28420 */
28421
28422 static int nolockCheckReservedLock(sqlcipher3_file *NotUsed, int *pResOut){
28423   UNUSED_PARAMETER(NotUsed);
28424   *pResOut = 0;
28425   return SQLCIPHER_OK;
28426 }
28427 static int nolockLock(sqlcipher3_file *NotUsed, int NotUsed2){
28428   UNUSED_PARAMETER2(NotUsed, NotUsed2);
28429   return SQLCIPHER_OK;
28430 }
28431 static int nolockUnlock(sqlcipher3_file *NotUsed, int NotUsed2){
28432   UNUSED_PARAMETER2(NotUsed, NotUsed2);
28433   return SQLCIPHER_OK;
28434 }
28435
28436 /*
28437 ** Close the file.
28438 */
28439 static int nolockClose(sqlcipher3_file *id) {
28440   return closeUnixFile(id);
28441 }
28442
28443 /******************* End of the no-op lock implementation *********************
28444 ******************************************************************************/
28445
28446 /******************************************************************************
28447 ************************* Begin dot-file Locking ******************************
28448 **
28449 ** The dotfile locking implementation uses the existance of separate lock
28450 ** files in order to control access to the database.  This works on just
28451 ** about every filesystem imaginable.  But there are serious downsides:
28452 **
28453 **    (1)  There is zero concurrency.  A single reader blocks all other
28454 **         connections from reading or writing the database.
28455 **
28456 **    (2)  An application crash or power loss can leave stale lock files
28457 **         sitting around that need to be cleared manually.
28458 **
28459 ** Nevertheless, a dotlock is an appropriate locking mode for use if no
28460 ** other locking strategy is available.
28461 **
28462 ** Dotfile locking works by creating a file in the same directory as the
28463 ** database and with the same name but with a ".lock" extension added.
28464 ** The existance of a lock file implies an EXCLUSIVE lock.  All other lock
28465 ** types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE.
28466 */
28467
28468 /*
28469 ** The file suffix added to the data base filename in order to create the
28470 ** lock file.
28471 */
28472 #define DOTLOCK_SUFFIX ".lock"
28473
28474 /*
28475 ** This routine checks if there is a RESERVED lock held on the specified
28476 ** file by this or any other process. If such a lock is held, set *pResOut
28477 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
28478 ** is set to SQLCIPHER_OK unless an I/O error occurs during lock checking.
28479 **
28480 ** In dotfile locking, either a lock exists or it does not.  So in this
28481 ** variation of CheckReservedLock(), *pResOut is set to true if any lock
28482 ** is held on the file and false if the file is unlocked.
28483 */
28484 static int dotlockCheckReservedLock(sqlcipher3_file *id, int *pResOut) {
28485   int rc = SQLCIPHER_OK;
28486   int reserved = 0;
28487   unixFile *pFile = (unixFile*)id;
28488
28489   SimulateIOError( return SQLCIPHER_IOERR_CHECKRESERVEDLOCK; );
28490   
28491   assert( pFile );
28492
28493   /* Check if a thread in this process holds such a lock */
28494   if( pFile->eFileLock>SHARED_LOCK ){
28495     /* Either this connection or some other connection in the same process
28496     ** holds a lock on the file.  No need to check further. */
28497     reserved = 1;
28498   }else{
28499     /* The lock is held if and only if the lockfile exists */
28500     const char *zLockFile = (const char*)pFile->lockingContext;
28501     reserved = osAccess(zLockFile, 0)==0;
28502   }
28503   OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
28504   *pResOut = reserved;
28505   return rc;
28506 }
28507
28508 /*
28509 ** Lock the file with the lock specified by parameter eFileLock - one
28510 ** of the following:
28511 **
28512 **     (1) SHARED_LOCK
28513 **     (2) RESERVED_LOCK
28514 **     (3) PENDING_LOCK
28515 **     (4) EXCLUSIVE_LOCK
28516 **
28517 ** Sometimes when requesting one lock state, additional lock states
28518 ** are inserted in between.  The locking might fail on one of the later
28519 ** transitions leaving the lock state different from what it started but
28520 ** still short of its goal.  The following chart shows the allowed
28521 ** transitions and the inserted intermediate states:
28522 **
28523 **    UNLOCKED -> SHARED
28524 **    SHARED -> RESERVED
28525 **    SHARED -> (PENDING) -> EXCLUSIVE
28526 **    RESERVED -> (PENDING) -> EXCLUSIVE
28527 **    PENDING -> EXCLUSIVE
28528 **
28529 ** This routine will only increase a lock.  Use the sqlcipher3OsUnlock()
28530 ** routine to lower a locking level.
28531 **
28532 ** With dotfile locking, we really only support state (4): EXCLUSIVE.
28533 ** But we track the other locking levels internally.
28534 */
28535 static int dotlockLock(sqlcipher3_file *id, int eFileLock) {
28536   unixFile *pFile = (unixFile*)id;
28537   int fd;
28538   char *zLockFile = (char *)pFile->lockingContext;
28539   int rc = SQLCIPHER_OK;
28540
28541
28542   /* If we have any lock, then the lock file already exists.  All we have
28543   ** to do is adjust our internal record of the lock level.
28544   */
28545   if( pFile->eFileLock > NO_LOCK ){
28546     pFile->eFileLock = eFileLock;
28547     /* Always update the timestamp on the old file */
28548 #ifdef HAVE_UTIME
28549     utime(zLockFile, NULL);
28550 #else
28551     utimes(zLockFile, NULL);
28552 #endif
28553     return SQLCIPHER_OK;
28554   }
28555   
28556   /* grab an exclusive lock */
28557   fd = robust_open(zLockFile,O_RDONLY|O_CREAT|O_EXCL,0600);
28558   if( fd<0 ){
28559     /* failed to open/create the file, someone else may have stolen the lock */
28560     int tErrno = errno;
28561     if( EEXIST == tErrno ){
28562       rc = SQLCIPHER_BUSY;
28563     } else {
28564       rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_LOCK);
28565       if( IS_LOCK_ERROR(rc) ){
28566         pFile->lastErrno = tErrno;
28567       }
28568     }
28569     return rc;
28570   } 
28571   robust_close(pFile, fd, __LINE__);
28572   
28573   /* got it, set the type and return ok */
28574   pFile->eFileLock = eFileLock;
28575   return rc;
28576 }
28577
28578 /*
28579 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
28580 ** must be either NO_LOCK or SHARED_LOCK.
28581 **
28582 ** If the locking level of the file descriptor is already at or below
28583 ** the requested locking level, this routine is a no-op.
28584 **
28585 ** When the locking level reaches NO_LOCK, delete the lock file.
28586 */
28587 static int dotlockUnlock(sqlcipher3_file *id, int eFileLock) {
28588   unixFile *pFile = (unixFile*)id;
28589   char *zLockFile = (char *)pFile->lockingContext;
28590
28591   assert( pFile );
28592   OSTRACE(("UNLOCK  %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
28593            pFile->eFileLock, getpid()));
28594   assert( eFileLock<=SHARED_LOCK );
28595   
28596   /* no-op if possible */
28597   if( pFile->eFileLock==eFileLock ){
28598     return SQLCIPHER_OK;
28599   }
28600
28601   /* To downgrade to shared, simply update our internal notion of the
28602   ** lock state.  No need to mess with the file on disk.
28603   */
28604   if( eFileLock==SHARED_LOCK ){
28605     pFile->eFileLock = SHARED_LOCK;
28606     return SQLCIPHER_OK;
28607   }
28608   
28609   /* To fully unlock the database, delete the lock file */
28610   assert( eFileLock==NO_LOCK );
28611   if( osUnlink(zLockFile) ){
28612     int rc = 0;
28613     int tErrno = errno;
28614     if( ENOENT != tErrno ){
28615       rc = SQLCIPHER_IOERR_UNLOCK;
28616     }
28617     if( IS_LOCK_ERROR(rc) ){
28618       pFile->lastErrno = tErrno;
28619     }
28620     return rc; 
28621   }
28622   pFile->eFileLock = NO_LOCK;
28623   return SQLCIPHER_OK;
28624 }
28625
28626 /*
28627 ** Close a file.  Make sure the lock has been released before closing.
28628 */
28629 static int dotlockClose(sqlcipher3_file *id) {
28630   int rc;
28631   if( id ){
28632     unixFile *pFile = (unixFile*)id;
28633     dotlockUnlock(id, NO_LOCK);
28634     sqlcipher3_free(pFile->lockingContext);
28635   }
28636   rc = closeUnixFile(id);
28637   return rc;
28638 }
28639 /****************** End of the dot-file lock implementation *******************
28640 ******************************************************************************/
28641
28642 /******************************************************************************
28643 ************************** Begin flock Locking ********************************
28644 **
28645 ** Use the flock() system call to do file locking.
28646 **
28647 ** flock() locking is like dot-file locking in that the various
28648 ** fine-grain locking levels supported by SQLite are collapsed into
28649 ** a single exclusive lock.  In other words, SHARED, RESERVED, and
28650 ** PENDING locks are the same thing as an EXCLUSIVE lock.  SQLite
28651 ** still works when you do this, but concurrency is reduced since
28652 ** only a single process can be reading the database at a time.
28653 **
28654 ** Omit this section if SQLCIPHER_ENABLE_LOCKING_STYLE is turned off or if
28655 ** compiling for VXWORKS.
28656 */
28657 #if SQLCIPHER_ENABLE_LOCKING_STYLE && !OS_VXWORKS
28658
28659 /*
28660 ** Retry flock() calls that fail with EINTR
28661 */
28662 #ifdef EINTR
28663 static int robust_flock(int fd, int op){
28664   int rc;
28665   do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR );
28666   return rc;
28667 }
28668 #else
28669 # define robust_flock(a,b) flock(a,b)
28670 #endif
28671      
28672
28673 /*
28674 ** This routine checks if there is a RESERVED lock held on the specified
28675 ** file by this or any other process. If such a lock is held, set *pResOut
28676 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
28677 ** is set to SQLCIPHER_OK unless an I/O error occurs during lock checking.
28678 */
28679 static int flockCheckReservedLock(sqlcipher3_file *id, int *pResOut){
28680   int rc = SQLCIPHER_OK;
28681   int reserved = 0;
28682   unixFile *pFile = (unixFile*)id;
28683   
28684   SimulateIOError( return SQLCIPHER_IOERR_CHECKRESERVEDLOCK; );
28685   
28686   assert( pFile );
28687   
28688   /* Check if a thread in this process holds such a lock */
28689   if( pFile->eFileLock>SHARED_LOCK ){
28690     reserved = 1;
28691   }
28692   
28693   /* Otherwise see if some other process holds it. */
28694   if( !reserved ){
28695     /* attempt to get the lock */
28696     int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
28697     if( !lrc ){
28698       /* got the lock, unlock it */
28699       lrc = robust_flock(pFile->h, LOCK_UN);
28700       if ( lrc ) {
28701         int tErrno = errno;
28702         /* unlock failed with an error */
28703         lrc = SQLCIPHER_IOERR_UNLOCK; 
28704         if( IS_LOCK_ERROR(lrc) ){
28705           pFile->lastErrno = tErrno;
28706           rc = lrc;
28707         }
28708       }
28709     } else {
28710       int tErrno = errno;
28711       reserved = 1;
28712       /* someone else might have it reserved */
28713       lrc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_LOCK); 
28714       if( IS_LOCK_ERROR(lrc) ){
28715         pFile->lastErrno = tErrno;
28716         rc = lrc;
28717       }
28718     }
28719   }
28720   OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
28721
28722 #ifdef SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS
28723   if( (rc & SQLCIPHER_IOERR) == SQLCIPHER_IOERR ){
28724     rc = SQLCIPHER_OK;
28725     reserved=1;
28726   }
28727 #endif /* SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS */
28728   *pResOut = reserved;
28729   return rc;
28730 }
28731
28732 /*
28733 ** Lock the file with the lock specified by parameter eFileLock - one
28734 ** of the following:
28735 **
28736 **     (1) SHARED_LOCK
28737 **     (2) RESERVED_LOCK
28738 **     (3) PENDING_LOCK
28739 **     (4) EXCLUSIVE_LOCK
28740 **
28741 ** Sometimes when requesting one lock state, additional lock states
28742 ** are inserted in between.  The locking might fail on one of the later
28743 ** transitions leaving the lock state different from what it started but
28744 ** still short of its goal.  The following chart shows the allowed
28745 ** transitions and the inserted intermediate states:
28746 **
28747 **    UNLOCKED -> SHARED
28748 **    SHARED -> RESERVED
28749 **    SHARED -> (PENDING) -> EXCLUSIVE
28750 **    RESERVED -> (PENDING) -> EXCLUSIVE
28751 **    PENDING -> EXCLUSIVE
28752 **
28753 ** flock() only really support EXCLUSIVE locks.  We track intermediate
28754 ** lock states in the sqlcipher3_file structure, but all locks SHARED or
28755 ** above are really EXCLUSIVE locks and exclude all other processes from
28756 ** access the file.
28757 **
28758 ** This routine will only increase a lock.  Use the sqlcipher3OsUnlock()
28759 ** routine to lower a locking level.
28760 */
28761 static int flockLock(sqlcipher3_file *id, int eFileLock) {
28762   int rc = SQLCIPHER_OK;
28763   unixFile *pFile = (unixFile*)id;
28764
28765   assert( pFile );
28766
28767   /* if we already have a lock, it is exclusive.  
28768   ** Just adjust level and punt on outta here. */
28769   if (pFile->eFileLock > NO_LOCK) {
28770     pFile->eFileLock = eFileLock;
28771     return SQLCIPHER_OK;
28772   }
28773   
28774   /* grab an exclusive lock */
28775   
28776   if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
28777     int tErrno = errno;
28778     /* didn't get, must be busy */
28779     rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_LOCK);
28780     if( IS_LOCK_ERROR(rc) ){
28781       pFile->lastErrno = tErrno;
28782     }
28783   } else {
28784     /* got it, set the type and return ok */
28785     pFile->eFileLock = eFileLock;
28786   }
28787   OSTRACE(("LOCK    %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock), 
28788            rc==SQLCIPHER_OK ? "ok" : "failed"));
28789 #ifdef SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS
28790   if( (rc & SQLCIPHER_IOERR) == SQLCIPHER_IOERR ){
28791     rc = SQLCIPHER_BUSY;
28792   }
28793 #endif /* SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS */
28794   return rc;
28795 }
28796
28797
28798 /*
28799 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
28800 ** must be either NO_LOCK or SHARED_LOCK.
28801 **
28802 ** If the locking level of the file descriptor is already at or below
28803 ** the requested locking level, this routine is a no-op.
28804 */
28805 static int flockUnlock(sqlcipher3_file *id, int eFileLock) {
28806   unixFile *pFile = (unixFile*)id;
28807   
28808   assert( pFile );
28809   OSTRACE(("UNLOCK  %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
28810            pFile->eFileLock, getpid()));
28811   assert( eFileLock<=SHARED_LOCK );
28812   
28813   /* no-op if possible */
28814   if( pFile->eFileLock==eFileLock ){
28815     return SQLCIPHER_OK;
28816   }
28817   
28818   /* shared can just be set because we always have an exclusive */
28819   if (eFileLock==SHARED_LOCK) {
28820     pFile->eFileLock = eFileLock;
28821     return SQLCIPHER_OK;
28822   }
28823   
28824   /* no, really, unlock. */
28825   if( robust_flock(pFile->h, LOCK_UN) ){
28826 #ifdef SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS
28827     return SQLCIPHER_OK;
28828 #endif /* SQLCIPHER_IGNORE_FLOCK_LOCK_ERRORS */
28829     return SQLCIPHER_IOERR_UNLOCK;
28830   }else{
28831     pFile->eFileLock = NO_LOCK;
28832     return SQLCIPHER_OK;
28833   }
28834 }
28835
28836 /*
28837 ** Close a file.
28838 */
28839 static int flockClose(sqlcipher3_file *id) {
28840   if( id ){
28841     flockUnlock(id, NO_LOCK);
28842   }
28843   return closeUnixFile(id);
28844 }
28845
28846 #endif /* SQLCIPHER_ENABLE_LOCKING_STYLE && !OS_VXWORK */
28847
28848 /******************* End of the flock lock implementation *********************
28849 ******************************************************************************/
28850
28851 /******************************************************************************
28852 ************************ Begin Named Semaphore Locking ************************
28853 **
28854 ** Named semaphore locking is only supported on VxWorks.
28855 **
28856 ** Semaphore locking is like dot-lock and flock in that it really only
28857 ** supports EXCLUSIVE locking.  Only a single process can read or write
28858 ** the database file at a time.  This reduces potential concurrency, but
28859 ** makes the lock implementation much easier.
28860 */
28861 #if OS_VXWORKS
28862
28863 /*
28864 ** This routine checks if there is a RESERVED lock held on the specified
28865 ** file by this or any other process. If such a lock is held, set *pResOut
28866 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
28867 ** is set to SQLCIPHER_OK unless an I/O error occurs during lock checking.
28868 */
28869 static int semCheckReservedLock(sqlcipher3_file *id, int *pResOut) {
28870   int rc = SQLCIPHER_OK;
28871   int reserved = 0;
28872   unixFile *pFile = (unixFile*)id;
28873
28874   SimulateIOError( return SQLCIPHER_IOERR_CHECKRESERVEDLOCK; );
28875   
28876   assert( pFile );
28877
28878   /* Check if a thread in this process holds such a lock */
28879   if( pFile->eFileLock>SHARED_LOCK ){
28880     reserved = 1;
28881   }
28882   
28883   /* Otherwise see if some other process holds it. */
28884   if( !reserved ){
28885     sem_t *pSem = pFile->pInode->pSem;
28886     struct stat statBuf;
28887
28888     if( sem_trywait(pSem)==-1 ){
28889       int tErrno = errno;
28890       if( EAGAIN != tErrno ){
28891         rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_CHECKRESERVEDLOCK);
28892         pFile->lastErrno = tErrno;
28893       } else {
28894         /* someone else has the lock when we are in NO_LOCK */
28895         reserved = (pFile->eFileLock < SHARED_LOCK);
28896       }
28897     }else{
28898       /* we could have it if we want it */
28899       sem_post(pSem);
28900     }
28901   }
28902   OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
28903
28904   *pResOut = reserved;
28905   return rc;
28906 }
28907
28908 /*
28909 ** Lock the file with the lock specified by parameter eFileLock - one
28910 ** of the following:
28911 **
28912 **     (1) SHARED_LOCK
28913 **     (2) RESERVED_LOCK
28914 **     (3) PENDING_LOCK
28915 **     (4) EXCLUSIVE_LOCK
28916 **
28917 ** Sometimes when requesting one lock state, additional lock states
28918 ** are inserted in between.  The locking might fail on one of the later
28919 ** transitions leaving the lock state different from what it started but
28920 ** still short of its goal.  The following chart shows the allowed
28921 ** transitions and the inserted intermediate states:
28922 **
28923 **    UNLOCKED -> SHARED
28924 **    SHARED -> RESERVED
28925 **    SHARED -> (PENDING) -> EXCLUSIVE
28926 **    RESERVED -> (PENDING) -> EXCLUSIVE
28927 **    PENDING -> EXCLUSIVE
28928 **
28929 ** Semaphore locks only really support EXCLUSIVE locks.  We track intermediate
28930 ** lock states in the sqlcipher3_file structure, but all locks SHARED or
28931 ** above are really EXCLUSIVE locks and exclude all other processes from
28932 ** access the file.
28933 **
28934 ** This routine will only increase a lock.  Use the sqlcipher3OsUnlock()
28935 ** routine to lower a locking level.
28936 */
28937 static int semLock(sqlcipher3_file *id, int eFileLock) {
28938   unixFile *pFile = (unixFile*)id;
28939   int fd;
28940   sem_t *pSem = pFile->pInode->pSem;
28941   int rc = SQLCIPHER_OK;
28942
28943   /* if we already have a lock, it is exclusive.  
28944   ** Just adjust level and punt on outta here. */
28945   if (pFile->eFileLock > NO_LOCK) {
28946     pFile->eFileLock = eFileLock;
28947     rc = SQLCIPHER_OK;
28948     goto sem_end_lock;
28949   }
28950   
28951   /* lock semaphore now but bail out when already locked. */
28952   if( sem_trywait(pSem)==-1 ){
28953     rc = SQLCIPHER_BUSY;
28954     goto sem_end_lock;
28955   }
28956
28957   /* got it, set the type and return ok */
28958   pFile->eFileLock = eFileLock;
28959
28960  sem_end_lock:
28961   return rc;
28962 }
28963
28964 /*
28965 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
28966 ** must be either NO_LOCK or SHARED_LOCK.
28967 **
28968 ** If the locking level of the file descriptor is already at or below
28969 ** the requested locking level, this routine is a no-op.
28970 */
28971 static int semUnlock(sqlcipher3_file *id, int eFileLock) {
28972   unixFile *pFile = (unixFile*)id;
28973   sem_t *pSem = pFile->pInode->pSem;
28974
28975   assert( pFile );
28976   assert( pSem );
28977   OSTRACE(("UNLOCK  %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
28978            pFile->eFileLock, getpid()));
28979   assert( eFileLock<=SHARED_LOCK );
28980   
28981   /* no-op if possible */
28982   if( pFile->eFileLock==eFileLock ){
28983     return SQLCIPHER_OK;
28984   }
28985   
28986   /* shared can just be set because we always have an exclusive */
28987   if (eFileLock==SHARED_LOCK) {
28988     pFile->eFileLock = eFileLock;
28989     return SQLCIPHER_OK;
28990   }
28991   
28992   /* no, really unlock. */
28993   if ( sem_post(pSem)==-1 ) {
28994     int rc, tErrno = errno;
28995     rc = sqlcipherErrorFromPosixError(tErrno, SQLCIPHER_IOERR_UNLOCK);
28996     if( IS_LOCK_ERROR(rc) ){
28997       pFile->lastErrno = tErrno;
28998     }
28999     return rc; 
29000   }
29001   pFile->eFileLock = NO_LOCK;
29002   return SQLCIPHER_OK;
29003 }
29004
29005 /*
29006  ** Close a file.
29007  */
29008 static int semClose(sqlcipher3_file *id) {
29009   if( id ){
29010     unixFile *pFile = (unixFile*)id;
29011     semUnlock(id, NO_LOCK);
29012     assert( pFile );
29013     unixEnterMutex();
29014     releaseInodeInfo(pFile);
29015     unixLeaveMutex();
29016     closeUnixFile(id);
29017   }
29018   return SQLCIPHER_OK;
29019 }
29020
29021 #endif /* OS_VXWORKS */
29022 /*
29023 ** Named semaphore locking is only available on VxWorks.
29024 **
29025 *************** End of the named semaphore lock implementation ****************
29026 ******************************************************************************/
29027
29028
29029 /******************************************************************************
29030 *************************** Begin AFP Locking *********************************
29031 **
29032 ** AFP is the Apple Filing Protocol.  AFP is a network filesystem found
29033 ** on Apple Macintosh computers - both OS9 and OSX.
29034 **
29035 ** Third-party implementations of AFP are available.  But this code here
29036 ** only works on OSX.
29037 */
29038
29039 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
29040 /*
29041 ** The afpLockingContext structure contains all afp lock specific state
29042 */
29043 typedef struct afpLockingContext afpLockingContext;
29044 struct afpLockingContext {
29045   int reserved;
29046   const char *dbPath;             /* Name of the open file */
29047 };
29048
29049 struct ByteRangeLockPB2
29050 {
29051   unsigned long long offset;        /* offset to first byte to lock */
29052   unsigned long long length;        /* nbr of bytes to lock */
29053   unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
29054   unsigned char unLockFlag;         /* 1 = unlock, 0 = lock */
29055   unsigned char startEndFlag;       /* 1=rel to end of fork, 0=rel to start */
29056   int fd;                           /* file desc to assoc this lock with */
29057 };
29058
29059 #define afpfsByteRangeLock2FSCTL        _IOWR('z', 23, struct ByteRangeLockPB2)
29060
29061 /*
29062 ** This is a utility for setting or clearing a bit-range lock on an
29063 ** AFP filesystem.
29064 ** 
29065 ** Return SQLCIPHER_OK on success, SQLCIPHER_BUSY on failure.
29066 */
29067 static int afpSetLock(
29068   const char *path,              /* Name of the file to be locked or unlocked */
29069   unixFile *pFile,               /* Open file descriptor on path */
29070   unsigned long long offset,     /* First byte to be locked */
29071   unsigned long long length,     /* Number of bytes to lock */
29072   int setLockFlag                /* True to set lock.  False to clear lock */
29073 ){
29074   struct ByteRangeLockPB2 pb;
29075   int err;
29076   
29077   pb.unLockFlag = setLockFlag ? 0 : 1;
29078   pb.startEndFlag = 0;
29079   pb.offset = offset;
29080   pb.length = length; 
29081   pb.fd = pFile->h;
29082   
29083   OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n", 
29084     (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
29085     offset, length));
29086   err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
29087   if ( err==-1 ) {
29088     int rc;
29089     int tErrno = errno;
29090     OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n",
29091              path, tErrno, strerror(tErrno)));
29092 #ifdef SQLCIPHER_IGNORE_AFP_LOCK_ERRORS
29093     rc = SQLCIPHER_BUSY;
29094 #else
29095     rc = sqlcipherErrorFromPosixError(tErrno,
29096                     setLockFlag ? SQLCIPHER_IOERR_LOCK : SQLCIPHER_IOERR_UNLOCK);
29097 #endif /* SQLCIPHER_IGNORE_AFP_LOCK_ERRORS */
29098     if( IS_LOCK_ERROR(rc) ){
29099       pFile->lastErrno = tErrno;
29100     }
29101     return rc;
29102   } else {
29103     return SQLCIPHER_OK;
29104   }
29105 }
29106
29107 /*
29108 ** This routine checks if there is a RESERVED lock held on the specified
29109 ** file by this or any other process. If such a lock is held, set *pResOut
29110 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
29111 ** is set to SQLCIPHER_OK unless an I/O error occurs during lock checking.
29112 */
29113 static int afpCheckReservedLock(sqlcipher3_file *id, int *pResOut){
29114   int rc = SQLCIPHER_OK;
29115   int reserved = 0;
29116   unixFile *pFile = (unixFile*)id;
29117   afpLockingContext *context;
29118   
29119   SimulateIOError( return SQLCIPHER_IOERR_CHECKRESERVEDLOCK; );
29120   
29121   assert( pFile );
29122   context = (afpLockingContext *) pFile->lockingContext;
29123   if( context->reserved ){
29124     *pResOut = 1;
29125     return SQLCIPHER_OK;
29126   }
29127   unixEnterMutex(); /* Because pFile->pInode is shared across threads */
29128   
29129   /* Check if a thread in this process holds such a lock */
29130   if( pFile->pInode->eFileLock>SHARED_LOCK ){
29131     reserved = 1;
29132   }
29133   
29134   /* Otherwise see if some other process holds it.
29135    */
29136   if( !reserved ){
29137     /* lock the RESERVED byte */
29138     int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);  
29139     if( SQLCIPHER_OK==lrc ){
29140       /* if we succeeded in taking the reserved lock, unlock it to restore
29141       ** the original state */
29142       lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
29143     } else {
29144       /* if we failed to get the lock then someone else must have it */
29145       reserved = 1;
29146     }
29147     if( IS_LOCK_ERROR(lrc) ){
29148       rc=lrc;
29149     }
29150   }
29151   
29152   unixLeaveMutex();
29153   OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
29154   
29155   *pResOut = reserved;
29156   return rc;
29157 }
29158
29159 /*
29160 ** Lock the file with the lock specified by parameter eFileLock - one
29161 ** of the following:
29162 **
29163 **     (1) SHARED_LOCK
29164 **     (2) RESERVED_LOCK
29165 **     (3) PENDING_LOCK
29166 **     (4) EXCLUSIVE_LOCK
29167 **
29168 ** Sometimes when requesting one lock state, additional lock states
29169 ** are inserted in between.  The locking might fail on one of the later
29170 ** transitions leaving the lock state different from what it started but
29171 ** still short of its goal.  The following chart shows the allowed
29172 ** transitions and the inserted intermediate states:
29173 **
29174 **    UNLOCKED -> SHARED
29175 **    SHARED -> RESERVED
29176 **    SHARED -> (PENDING) -> EXCLUSIVE
29177 **    RESERVED -> (PENDING) -> EXCLUSIVE
29178 **    PENDING -> EXCLUSIVE
29179 **
29180 ** This routine will only increase a lock.  Use the sqlcipher3OsUnlock()
29181 ** routine to lower a locking level.
29182 */
29183 static int afpLock(sqlcipher3_file *id, int eFileLock){
29184   int rc = SQLCIPHER_OK;
29185   unixFile *pFile = (unixFile*)id;
29186   unixInodeInfo *pInode = pFile->pInode;
29187   afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
29188   
29189   assert( pFile );
29190   OSTRACE(("LOCK    %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
29191            azFileLock(eFileLock), azFileLock(pFile->eFileLock),
29192            azFileLock(pInode->eFileLock), pInode->nShared , getpid()));
29193
29194   /* If there is already a lock of this type or more restrictive on the
29195   ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
29196   ** unixEnterMutex() hasn't been called yet.
29197   */
29198   if( pFile->eFileLock>=eFileLock ){
29199     OSTRACE(("LOCK    %d %s ok (already held) (afp)\n", pFile->h,
29200            azFileLock(eFileLock)));
29201     return SQLCIPHER_OK;
29202   }
29203
29204   /* Make sure the locking sequence is correct
29205   **  (1) We never move from unlocked to anything higher than shared lock.
29206   **  (2) SQLite never explicitly requests a pendig lock.
29207   **  (3) A shared lock is always held when a reserve lock is requested.
29208   */
29209   assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
29210   assert( eFileLock!=PENDING_LOCK );
29211   assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
29212   
29213   /* This mutex is needed because pFile->pInode is shared across threads
29214   */
29215   unixEnterMutex();
29216   pInode = pFile->pInode;
29217
29218   /* If some thread using this PID has a lock via a different unixFile*
29219   ** handle that precludes the requested lock, return BUSY.
29220   */
29221   if( (pFile->eFileLock!=pInode->eFileLock && 
29222        (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
29223      ){
29224     rc = SQLCIPHER_BUSY;
29225     goto afp_end_lock;
29226   }
29227   
29228   /* If a SHARED lock is requested, and some thread using this PID already
29229   ** has a SHARED or RESERVED lock, then increment reference counts and
29230   ** return SQLCIPHER_OK.
29231   */
29232   if( eFileLock==SHARED_LOCK && 
29233      (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
29234     assert( eFileLock==SHARED_LOCK );
29235     assert( pFile->eFileLock==0 );
29236     assert( pInode->nShared>0 );
29237     pFile->eFileLock = SHARED_LOCK;
29238     pInode->nShared++;
29239     pInode->nLock++;
29240     goto afp_end_lock;
29241   }
29242     
29243   /* A PENDING lock is needed before acquiring a SHARED lock and before
29244   ** acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
29245   ** be released.
29246   */
29247   if( eFileLock==SHARED_LOCK 
29248       || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
29249   ){
29250     int failed;
29251     failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
29252     if (failed) {
29253       rc = failed;
29254       goto afp_end_lock;
29255     }
29256   }
29257   
29258   /* If control gets to this point, then actually go ahead and make
29259   ** operating system calls for the specified lock.
29260   */
29261   if( eFileLock==SHARED_LOCK ){
29262     int lrc1, lrc2, lrc1Errno = 0;
29263     long lk, mask;
29264     
29265     assert( pInode->nShared==0 );
29266     assert( pInode->eFileLock==0 );
29267         
29268     mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff;
29269     /* Now get the read-lock SHARED_LOCK */
29270     /* note that the quality of the randomness doesn't matter that much */
29271     lk = random(); 
29272     pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
29273     lrc1 = afpSetLock(context->dbPath, pFile, 
29274           SHARED_FIRST+pInode->sharedByte, 1, 1);
29275     if( IS_LOCK_ERROR(lrc1) ){
29276       lrc1Errno = pFile->lastErrno;
29277     }
29278     /* Drop the temporary PENDING lock */
29279     lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
29280     
29281     if( IS_LOCK_ERROR(lrc1) ) {
29282       pFile->lastErrno = lrc1Errno;
29283       rc = lrc1;
29284       goto afp_end_lock;
29285     } else if( IS_LOCK_ERROR(lrc2) ){
29286       rc = lrc2;
29287       goto afp_end_lock;
29288     } else if( lrc1 != SQLCIPHER_OK ) {
29289       rc = lrc1;
29290     } else {
29291       pFile->eFileLock = SHARED_LOCK;
29292       pInode->nLock++;
29293       pInode->nShared = 1;
29294     }
29295   }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
29296     /* We are trying for an exclusive lock but another thread in this
29297      ** same process is still holding a shared lock. */
29298     rc = SQLCIPHER_BUSY;
29299   }else{
29300     /* The request was for a RESERVED or EXCLUSIVE lock.  It is
29301     ** assumed that there is a SHARED or greater lock on the file
29302     ** already.
29303     */
29304     int failed = 0;
29305     assert( 0!=pFile->eFileLock );
29306     if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
29307         /* Acquire a RESERVED lock */
29308         failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
29309       if( !failed ){
29310         context->reserved = 1;
29311       }
29312     }
29313     if (!failed && eFileLock == EXCLUSIVE_LOCK) {
29314       /* Acquire an EXCLUSIVE lock */
29315         
29316       /* Remove the shared lock before trying the range.  we'll need to 
29317       ** reestablish the shared lock if we can't get the  afpUnlock
29318       */
29319       if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
29320                          pInode->sharedByte, 1, 0)) ){
29321         int failed2 = SQLCIPHER_OK;
29322         /* now attemmpt to get the exclusive lock range */
29323         failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST, 
29324                                SHARED_SIZE, 1);
29325         if( failed && (failed2 = afpSetLock(context->dbPath, pFile, 
29326                        SHARED_FIRST + pInode->sharedByte, 1, 1)) ){
29327           /* Can't reestablish the shared lock.  Sqlite can't deal, this is
29328           ** a critical I/O error
29329           */
29330           rc = ((failed & SQLCIPHER_IOERR) == SQLCIPHER_IOERR) ? failed2 : 
29331                SQLCIPHER_IOERR_LOCK;
29332           goto afp_end_lock;
29333         } 
29334       }else{
29335         rc = failed; 
29336       }
29337     }
29338     if( failed ){
29339       rc = failed;
29340     }
29341   }
29342   
29343   if( rc==SQLCIPHER_OK ){
29344     pFile->eFileLock = eFileLock;
29345     pInode->eFileLock = eFileLock;
29346   }else if( eFileLock==EXCLUSIVE_LOCK ){
29347     pFile->eFileLock = PENDING_LOCK;
29348     pInode->eFileLock = PENDING_LOCK;
29349   }
29350   
29351 afp_end_lock:
29352   unixLeaveMutex();
29353   OSTRACE(("LOCK    %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock), 
29354          rc==SQLCIPHER_OK ? "ok" : "failed"));
29355   return rc;
29356 }
29357
29358 /*
29359 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
29360 ** must be either NO_LOCK or SHARED_LOCK.
29361 **
29362 ** If the locking level of the file descriptor is already at or below
29363 ** the requested locking level, this routine is a no-op.
29364 */
29365 static int afpUnlock(sqlcipher3_file *id, int eFileLock) {
29366   int rc = SQLCIPHER_OK;
29367   unixFile *pFile = (unixFile*)id;
29368   unixInodeInfo *pInode;
29369   afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
29370   int skipShared = 0;
29371 #ifdef SQLCIPHER_TEST
29372   int h = pFile->h;
29373 #endif
29374
29375   assert( pFile );
29376   OSTRACE(("UNLOCK  %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
29377            pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
29378            getpid()));
29379
29380   assert( eFileLock<=SHARED_LOCK );
29381   if( pFile->eFileLock<=eFileLock ){
29382     return SQLCIPHER_OK;
29383   }
29384   unixEnterMutex();
29385   pInode = pFile->pInode;
29386   assert( pInode->nShared!=0 );
29387   if( pFile->eFileLock>SHARED_LOCK ){
29388     assert( pInode->eFileLock==pFile->eFileLock );
29389     SimulateIOErrorBenign(1);
29390     SimulateIOError( h=(-1) )
29391     SimulateIOErrorBenign(0);
29392     
29393 #ifndef NDEBUG
29394     /* When reducing a lock such that other processes can start
29395     ** reading the database file again, make sure that the
29396     ** transaction counter was updated if any part of the database
29397     ** file changed.  If the transaction counter is not updated,
29398     ** other connections to the same file might not realize that
29399     ** the file has changed and hence might not know to flush their
29400     ** cache.  The use of a stale cache can lead to database corruption.
29401     */
29402     assert( pFile->inNormalWrite==0
29403            || pFile->dbUpdate==0
29404            || pFile->transCntrChng==1 );
29405     pFile->inNormalWrite = 0;
29406 #endif
29407     
29408     if( pFile->eFileLock==EXCLUSIVE_LOCK ){
29409       rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
29410       if( rc==SQLCIPHER_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
29411         /* only re-establish the shared lock if necessary */
29412         int sharedLockByte = SHARED_FIRST+pInode->sharedByte;
29413         rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
29414       } else {
29415         skipShared = 1;
29416       }
29417     }
29418     if( rc==SQLCIPHER_OK && pFile->eFileLock>=PENDING_LOCK ){
29419       rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
29420     } 
29421     if( rc==SQLCIPHER_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
29422       rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
29423       if( !rc ){ 
29424         context->reserved = 0; 
29425       }
29426     }
29427     if( rc==SQLCIPHER_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
29428       pInode->eFileLock = SHARED_LOCK;
29429     }
29430   }
29431   if( rc==SQLCIPHER_OK && eFileLock==NO_LOCK ){
29432
29433     /* Decrement the shared lock counter.  Release the lock using an
29434     ** OS call only when all threads in this same process have released
29435     ** the lock.
29436     */
29437     unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte;
29438     pInode->nShared--;
29439     if( pInode->nShared==0 ){
29440       SimulateIOErrorBenign(1);
29441       SimulateIOError( h=(-1) )
29442       SimulateIOErrorBenign(0);
29443       if( !skipShared ){
29444         rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
29445       }
29446       if( !rc ){
29447         pInode->eFileLock = NO_LOCK;
29448         pFile->eFileLock = NO_LOCK;
29449       }
29450     }
29451     if( rc==SQLCIPHER_OK ){
29452       pInode->nLock--;
29453       assert( pInode->nLock>=0 );
29454       if( pInode->nLock==0 ){
29455         closePendingFds(pFile);
29456       }
29457     }
29458   }
29459   
29460   unixLeaveMutex();
29461   if( rc==SQLCIPHER_OK ) pFile->eFileLock = eFileLock;
29462   return rc;
29463 }
29464
29465 /*
29466 ** Close a file & cleanup AFP specific locking context 
29467 */
29468 static int afpClose(sqlcipher3_file *id) {
29469   int rc = SQLCIPHER_OK;
29470   if( id ){
29471     unixFile *pFile = (unixFile*)id;
29472     afpUnlock(id, NO_LOCK);
29473     unixEnterMutex();
29474     if( pFile->pInode && pFile->pInode->nLock ){
29475       /* If there are outstanding locks, do not actually close the file just
29476       ** yet because that would clear those locks.  Instead, add the file
29477       ** descriptor to pInode->aPending.  It will be automatically closed when
29478       ** the last lock is cleared.
29479       */
29480       setPendingFd(pFile);
29481     }
29482     releaseInodeInfo(pFile);
29483     sqlcipher3_free(pFile->lockingContext);
29484     rc = closeUnixFile(id);
29485     unixLeaveMutex();
29486   }
29487   return rc;
29488 }
29489
29490 #endif /* defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE */
29491 /*
29492 ** The code above is the AFP lock implementation.  The code is specific
29493 ** to MacOSX and does not work on other unix platforms.  No alternative
29494 ** is available.  If you don't compile for a mac, then the "unix-afp"
29495 ** VFS is not available.
29496 **
29497 ********************* End of the AFP lock implementation **********************
29498 ******************************************************************************/
29499
29500 /******************************************************************************
29501 *************************** Begin NFS Locking ********************************/
29502
29503 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
29504 /*
29505  ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
29506  ** must be either NO_LOCK or SHARED_LOCK.
29507  **
29508  ** If the locking level of the file descriptor is already at or below
29509  ** the requested locking level, this routine is a no-op.
29510  */
29511 static int nfsUnlock(sqlcipher3_file *id, int eFileLock){
29512   return posixUnlock(id, eFileLock, 1);
29513 }
29514
29515 #endif /* defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE */
29516 /*
29517 ** The code above is the NFS lock implementation.  The code is specific
29518 ** to MacOSX and does not work on other unix platforms.  No alternative
29519 ** is available.  
29520 **
29521 ********************* End of the NFS lock implementation **********************
29522 ******************************************************************************/
29523
29524 /******************************************************************************
29525 **************** Non-locking sqlcipher3_file methods *****************************
29526 **
29527 ** The next division contains implementations for all methods of the 
29528 ** sqlcipher3_file object other than the locking methods.  The locking
29529 ** methods were defined in divisions above (one locking method per
29530 ** division).  Those methods that are common to all locking modes
29531 ** are gather together into this division.
29532 */
29533
29534 /*
29535 ** Seek to the offset passed as the second argument, then read cnt 
29536 ** bytes into pBuf. Return the number of bytes actually read.
29537 **
29538 ** NB:  If you define USE_PREAD or USE_PREAD64, then it might also
29539 ** be necessary to define _XOPEN_SOURCE to be 500.  This varies from
29540 ** one system to another.  Since SQLite does not define USE_PREAD
29541 ** any any form by default, we will not attempt to define _XOPEN_SOURCE.
29542 ** See tickets #2741 and #2681.
29543 **
29544 ** To avoid stomping the errno value on a failed read the lastErrno value
29545 ** is set before returning.
29546 */
29547 static int seekAndRead(unixFile *id, sqlcipher3_int64 offset, void *pBuf, int cnt){
29548   int got;
29549 #if (!defined(USE_PREAD) && !defined(USE_PREAD64))
29550   i64 newOffset;
29551 #endif
29552   TIMER_START;
29553 #if defined(USE_PREAD)
29554   do{ got = osPread(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR );
29555   SimulateIOError( got = -1 );
29556 #elif defined(USE_PREAD64)
29557   do{ got = osPread64(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR);
29558   SimulateIOError( got = -1 );
29559 #else
29560   newOffset = lseek(id->h, offset, SEEK_SET);
29561   SimulateIOError( newOffset-- );
29562   if( newOffset!=offset ){
29563     if( newOffset == -1 ){
29564       ((unixFile*)id)->lastErrno = errno;
29565     }else{
29566       ((unixFile*)id)->lastErrno = 0;                   
29567     }
29568     return -1;
29569   }
29570   do{ got = osRead(id->h, pBuf, cnt); }while( got<0 && errno==EINTR );
29571 #endif
29572   TIMER_END;
29573   if( got<0 ){
29574     ((unixFile*)id)->lastErrno = errno;
29575   }
29576   OSTRACE(("READ    %-3d %5d %7lld %llu\n", id->h, got, offset, TIMER_ELAPSED));
29577   return got;
29578 }
29579
29580 /*
29581 ** Read data from a file into a buffer.  Return SQLCIPHER_OK if all
29582 ** bytes were read successfully and SQLCIPHER_IOERR if anything goes
29583 ** wrong.
29584 */
29585 static int unixRead(
29586   sqlcipher3_file *id, 
29587   void *pBuf, 
29588   int amt,
29589   sqlcipher3_int64 offset
29590 ){
29591   unixFile *pFile = (unixFile *)id;
29592   int got;
29593   assert( id );
29594
29595   /* If this is a database file (not a journal, master-journal or temp
29596   ** file), the bytes in the locking range should never be read or written. */
29597 #if 0
29598   assert( pFile->pUnused==0
29599        || offset>=PENDING_BYTE+512
29600        || offset+amt<=PENDING_BYTE 
29601   );
29602 #endif
29603
29604   got = seekAndRead(pFile, offset, pBuf, amt);
29605   if( got==amt ){
29606     return SQLCIPHER_OK;
29607   }else if( got<0 ){
29608     /* lastErrno set by seekAndRead */
29609     return SQLCIPHER_IOERR_READ;
29610   }else{
29611     pFile->lastErrno = 0; /* not a system error */
29612     /* Unread parts of the buffer must be zero-filled */
29613     memset(&((char*)pBuf)[got], 0, amt-got);
29614     return SQLCIPHER_IOERR_SHORT_READ;
29615   }
29616 }
29617
29618 /*
29619 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
29620 ** Return the number of bytes actually read.  Update the offset.
29621 **
29622 ** To avoid stomping the errno value on a failed write the lastErrno value
29623 ** is set before returning.
29624 */
29625 static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
29626   int got;
29627 #if (!defined(USE_PREAD) && !defined(USE_PREAD64))
29628   i64 newOffset;
29629 #endif
29630   TIMER_START;
29631 #if defined(USE_PREAD)
29632   do{ got = osPwrite(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR );
29633 #elif defined(USE_PREAD64)
29634   do{ got = osPwrite64(id->h, pBuf, cnt, offset);}while( got<0 && errno==EINTR);
29635 #else
29636   do{
29637     newOffset = lseek(id->h, offset, SEEK_SET);
29638     SimulateIOError( newOffset-- );
29639     if( newOffset!=offset ){
29640       if( newOffset == -1 ){
29641         ((unixFile*)id)->lastErrno = errno;
29642       }else{
29643         ((unixFile*)id)->lastErrno = 0;                 
29644       }
29645       return -1;
29646     }
29647     got = osWrite(id->h, pBuf, cnt);
29648   }while( got<0 && errno==EINTR );
29649 #endif
29650   TIMER_END;
29651   if( got<0 ){
29652     ((unixFile*)id)->lastErrno = errno;
29653   }
29654
29655   OSTRACE(("WRITE   %-3d %5d %7lld %llu\n", id->h, got, offset, TIMER_ELAPSED));
29656   return got;
29657 }
29658
29659
29660 /*
29661 ** Write data from a buffer into a file.  Return SQLCIPHER_OK on success
29662 ** or some other error code on failure.
29663 */
29664 static int unixWrite(
29665   sqlcipher3_file *id, 
29666   const void *pBuf, 
29667   int amt,
29668   sqlcipher3_int64 offset 
29669 ){
29670   unixFile *pFile = (unixFile*)id;
29671   int wrote = 0;
29672   assert( id );
29673   assert( amt>0 );
29674
29675   /* If this is a database file (not a journal, master-journal or temp
29676   ** file), the bytes in the locking range should never be read or written. */
29677 #if 0
29678   assert( pFile->pUnused==0
29679        || offset>=PENDING_BYTE+512
29680        || offset+amt<=PENDING_BYTE 
29681   );
29682 #endif
29683
29684 #ifndef NDEBUG
29685   /* If we are doing a normal write to a database file (as opposed to
29686   ** doing a hot-journal rollback or a write to some file other than a
29687   ** normal database file) then record the fact that the database
29688   ** has changed.  If the transaction counter is modified, record that
29689   ** fact too.
29690   */
29691   if( pFile->inNormalWrite ){
29692     pFile->dbUpdate = 1;  /* The database has been modified */
29693     if( offset<=24 && offset+amt>=27 ){
29694       int rc;
29695       char oldCntr[4];
29696       SimulateIOErrorBenign(1);
29697       rc = seekAndRead(pFile, 24, oldCntr, 4);
29698       SimulateIOErrorBenign(0);
29699       if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
29700         pFile->transCntrChng = 1;  /* The transaction counter has changed */
29701       }
29702     }
29703   }
29704 #endif
29705
29706   while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
29707     amt -= wrote;
29708     offset += wrote;
29709     pBuf = &((char*)pBuf)[wrote];
29710   }
29711   SimulateIOError(( wrote=(-1), amt=1 ));
29712   SimulateDiskfullError(( wrote=0, amt=1 ));
29713
29714   if( amt>0 ){
29715     if( wrote<0 && pFile->lastErrno!=ENOSPC ){
29716       /* lastErrno set by seekAndWrite */
29717       return SQLCIPHER_IOERR_WRITE;
29718     }else{
29719       pFile->lastErrno = 0; /* not a system error */
29720       return SQLCIPHER_FULL;
29721     }
29722   }
29723
29724   return SQLCIPHER_OK;
29725 }
29726
29727 #ifdef SQLCIPHER_TEST
29728 /*
29729 ** Count the number of fullsyncs and normal syncs.  This is used to test
29730 ** that syncs and fullsyncs are occurring at the right times.
29731 */
29732 SQLCIPHER_API int sqlcipher3_sync_count = 0;
29733 SQLCIPHER_API int sqlcipher3_fullsync_count = 0;
29734 #endif
29735
29736 /*
29737 ** We do not trust systems to provide a working fdatasync().  Some do.
29738 ** Others do no.  To be safe, we will stick with the (slightly slower)
29739 ** fsync(). If you know that your system does support fdatasync() correctly,
29740 ** then simply compile with -Dfdatasync=fdatasync
29741 */
29742 #if !defined(fdatasync)
29743 # define fdatasync fsync
29744 #endif
29745
29746 /*
29747 ** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
29748 ** the F_FULLFSYNC macro is defined.  F_FULLFSYNC is currently
29749 ** only available on Mac OS X.  But that could change.
29750 */
29751 #ifdef F_FULLFSYNC
29752 # define HAVE_FULLFSYNC 1
29753 #else
29754 # define HAVE_FULLFSYNC 0
29755 #endif
29756
29757
29758 /*
29759 ** The fsync() system call does not work as advertised on many
29760 ** unix systems.  The following procedure is an attempt to make
29761 ** it work better.
29762 **
29763 ** The SQLCIPHER_NO_SYNC macro disables all fsync()s.  This is useful
29764 ** for testing when we want to run through the test suite quickly.
29765 ** You are strongly advised *not* to deploy with SQLCIPHER_NO_SYNC
29766 ** enabled, however, since with SQLCIPHER_NO_SYNC enabled, an OS crash
29767 ** or power failure will likely corrupt the database file.
29768 **
29769 ** SQLite sets the dataOnly flag if the size of the file is unchanged.
29770 ** The idea behind dataOnly is that it should only write the file content
29771 ** to disk, not the inode.  We only set dataOnly if the file size is 
29772 ** unchanged since the file size is part of the inode.  However, 
29773 ** Ted Ts'o tells us that fdatasync() will also write the inode if the
29774 ** file size has changed.  The only real difference between fdatasync()
29775 ** and fsync(), Ted tells us, is that fdatasync() will not flush the
29776 ** inode if the mtime or owner or other inode attributes have changed.
29777 ** We only care about the file size, not the other file attributes, so
29778 ** as far as SQLite is concerned, an fdatasync() is always adequate.
29779 ** So, we always use fdatasync() if it is available, regardless of
29780 ** the value of the dataOnly flag.
29781 */
29782 static int full_fsync(int fd, int fullSync, int dataOnly){
29783   int rc;
29784
29785   /* The following "ifdef/elif/else/" block has the same structure as
29786   ** the one below. It is replicated here solely to avoid cluttering 
29787   ** up the real code with the UNUSED_PARAMETER() macros.
29788   */
29789 #ifdef SQLCIPHER_NO_SYNC
29790   UNUSED_PARAMETER(fd);
29791   UNUSED_PARAMETER(fullSync);
29792   UNUSED_PARAMETER(dataOnly);
29793 #elif HAVE_FULLFSYNC
29794   UNUSED_PARAMETER(dataOnly);
29795 #else
29796   UNUSED_PARAMETER(fullSync);
29797   UNUSED_PARAMETER(dataOnly);
29798 #endif
29799
29800   /* Record the number of times that we do a normal fsync() and 
29801   ** FULLSYNC.  This is used during testing to verify that this procedure
29802   ** gets called with the correct arguments.
29803   */
29804 #ifdef SQLCIPHER_TEST
29805   if( fullSync ) sqlcipher3_fullsync_count++;
29806   sqlcipher3_sync_count++;
29807 #endif
29808
29809   /* If we compiled with the SQLCIPHER_NO_SYNC flag, then syncing is a
29810   ** no-op
29811   */
29812 #ifdef SQLCIPHER_NO_SYNC
29813   rc = SQLCIPHER_OK;
29814 #elif HAVE_FULLFSYNC
29815   if( fullSync ){
29816     rc = osFcntl(fd, F_FULLFSYNC, 0);
29817   }else{
29818     rc = 1;
29819   }
29820   /* If the FULLFSYNC failed, fall back to attempting an fsync().
29821   ** It shouldn't be possible for fullfsync to fail on the local 
29822   ** file system (on OSX), so failure indicates that FULLFSYNC
29823   ** isn't supported for this file system. So, attempt an fsync 
29824   ** and (for now) ignore the overhead of a superfluous fcntl call.  
29825   ** It'd be better to detect fullfsync support once and avoid 
29826   ** the fcntl call every time sync is called.
29827   */
29828   if( rc ) rc = fsync(fd);
29829
29830 #elif defined(__APPLE__)
29831   /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly
29832   ** so currently we default to the macro that redefines fdatasync to fsync
29833   */
29834   rc = fsync(fd);
29835 #else 
29836   rc = fdatasync(fd);
29837 #if OS_VXWORKS
29838   if( rc==-1 && errno==ENOTSUP ){
29839     rc = fsync(fd);
29840   }
29841 #endif /* OS_VXWORKS */
29842 #endif /* ifdef SQLCIPHER_NO_SYNC elif HAVE_FULLFSYNC */
29843
29844   if( OS_VXWORKS && rc!= -1 ){
29845     rc = 0;
29846   }
29847   return rc;
29848 }
29849
29850 /*
29851 ** Open a file descriptor to the directory containing file zFilename.
29852 ** If successful, *pFd is set to the opened file descriptor and
29853 ** SQLCIPHER_OK is returned. If an error occurs, either SQLCIPHER_NOMEM
29854 ** or SQLCIPHER_CANTOPEN is returned and *pFd is set to an undefined
29855 ** value.
29856 **
29857 ** The directory file descriptor is used for only one thing - to
29858 ** fsync() a directory to make sure file creation and deletion events
29859 ** are flushed to disk.  Such fsyncs are not needed on newer
29860 ** journaling filesystems, but are required on older filesystems.
29861 **
29862 ** This routine can be overridden using the xSetSysCall interface.
29863 ** The ability to override this routine was added in support of the
29864 ** chromium sandbox.  Opening a directory is a security risk (we are
29865 ** told) so making it overrideable allows the chromium sandbox to
29866 ** replace this routine with a harmless no-op.  To make this routine
29867 ** a no-op, replace it with a stub that returns SQLCIPHER_OK but leaves
29868 ** *pFd set to a negative number.
29869 **
29870 ** If SQLCIPHER_OK is returned, the caller is responsible for closing
29871 ** the file descriptor *pFd using close().
29872 */
29873 static int openDirectory(const char *zFilename, int *pFd){
29874   int ii;
29875   int fd = -1;
29876   char zDirname[MAX_PATHNAME+1];
29877
29878   sqlcipher3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
29879   for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
29880   if( ii>0 ){
29881     zDirname[ii] = '\0';
29882     fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
29883     if( fd>=0 ){
29884 #ifdef FD_CLOEXEC
29885       osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
29886 #endif
29887       OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
29888     }
29889   }
29890   *pFd = fd;
29891   return (fd>=0?SQLCIPHER_OK:unixLogError(SQLCIPHER_CANTOPEN_BKPT, "open", zDirname));
29892 }
29893
29894 /*
29895 ** Make sure all writes to a particular file are committed to disk.
29896 **
29897 ** If dataOnly==0 then both the file itself and its metadata (file
29898 ** size, access time, etc) are synced.  If dataOnly!=0 then only the
29899 ** file data is synced.
29900 **
29901 ** Under Unix, also make sure that the directory entry for the file
29902 ** has been created by fsync-ing the directory that contains the file.
29903 ** If we do not do this and we encounter a power failure, the directory
29904 ** entry for the journal might not exist after we reboot.  The next
29905 ** SQLite to access the file will not know that the journal exists (because
29906 ** the directory entry for the journal was never created) and the transaction
29907 ** will not roll back - possibly leading to database corruption.
29908 */
29909 static int unixSync(sqlcipher3_file *id, int flags){
29910   int rc;
29911   unixFile *pFile = (unixFile*)id;
29912
29913   int isDataOnly = (flags&SQLCIPHER_SYNC_DATAONLY);
29914   int isFullsync = (flags&0x0F)==SQLCIPHER_SYNC_FULL;
29915
29916   /* Check that one of SQLCIPHER_SYNC_NORMAL or FULL was passed */
29917   assert((flags&0x0F)==SQLCIPHER_SYNC_NORMAL
29918       || (flags&0x0F)==SQLCIPHER_SYNC_FULL
29919   );
29920
29921   /* Unix cannot, but some systems may return SQLCIPHER_FULL from here. This
29922   ** line is to test that doing so does not cause any problems.
29923   */
29924   SimulateDiskfullError( return SQLCIPHER_FULL );
29925
29926   assert( pFile );
29927   OSTRACE(("SYNC    %-3d\n", pFile->h));
29928   rc = full_fsync(pFile->h, isFullsync, isDataOnly);
29929   SimulateIOError( rc=1 );
29930   if( rc ){
29931     pFile->lastErrno = errno;
29932     return unixLogError(SQLCIPHER_IOERR_FSYNC, "full_fsync", pFile->zPath);
29933   }
29934
29935   /* Also fsync the directory containing the file if the DIRSYNC flag
29936   ** is set.  This is a one-time occurrance.  Many systems (examples: AIX)
29937   ** are unable to fsync a directory, so ignore errors on the fsync.
29938   */
29939   if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
29940     int dirfd;
29941     OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
29942             HAVE_FULLFSYNC, isFullsync));
29943     rc = osOpenDirectory(pFile->zPath, &dirfd);
29944     if( rc==SQLCIPHER_OK && dirfd>=0 ){
29945       full_fsync(dirfd, 0, 0);
29946       robust_close(pFile, dirfd, __LINE__);
29947     }else if( rc==SQLCIPHER_CANTOPEN ){
29948       rc = SQLCIPHER_OK;
29949     }
29950     pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
29951   }
29952   return rc;
29953 }
29954
29955 /*
29956 ** Truncate an open file to a specified size
29957 */
29958 static int unixTruncate(sqlcipher3_file *id, i64 nByte){
29959   unixFile *pFile = (unixFile *)id;
29960   int rc;
29961   assert( pFile );
29962   SimulateIOError( return SQLCIPHER_IOERR_TRUNCATE );
29963
29964   /* If the user has configured a chunk-size for this file, truncate the
29965   ** file so that it consists of an integer number of chunks (i.e. the
29966   ** actual file size after the operation may be larger than the requested
29967   ** size).
29968   */
29969   if( pFile->szChunk ){
29970     nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
29971   }
29972
29973   rc = robust_ftruncate(pFile->h, (off_t)nByte);
29974   if( rc ){
29975     pFile->lastErrno = errno;
29976     return unixLogError(SQLCIPHER_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
29977   }else{
29978 #ifndef NDEBUG
29979     /* If we are doing a normal write to a database file (as opposed to
29980     ** doing a hot-journal rollback or a write to some file other than a
29981     ** normal database file) and we truncate the file to zero length,
29982     ** that effectively updates the change counter.  This might happen
29983     ** when restoring a database using the backup API from a zero-length
29984     ** source.
29985     */
29986     if( pFile->inNormalWrite && nByte==0 ){
29987       pFile->transCntrChng = 1;
29988     }
29989 #endif
29990
29991     return SQLCIPHER_OK;
29992   }
29993 }
29994
29995 /*
29996 ** Determine the current size of a file in bytes
29997 */
29998 static int unixFileSize(sqlcipher3_file *id, i64 *pSize){
29999   int rc;
30000   struct stat buf;
30001   assert( id );
30002   rc = osFstat(((unixFile*)id)->h, &buf);
30003   SimulateIOError( rc=1 );
30004   if( rc!=0 ){
30005     ((unixFile*)id)->lastErrno = errno;
30006     return SQLCIPHER_IOERR_FSTAT;
30007   }
30008   *pSize = buf.st_size;
30009
30010   /* When opening a zero-size database, the findInodeInfo() procedure
30011   ** writes a single byte into that file in order to work around a bug
30012   ** in the OS-X msdos filesystem.  In order to avoid problems with upper
30013   ** layers, we need to report this file size as zero even though it is
30014   ** really 1.   Ticket #3260.
30015   */
30016   if( *pSize==1 ) *pSize = 0;
30017
30018
30019   return SQLCIPHER_OK;
30020 }
30021
30022 #if SQLCIPHER_ENABLE_LOCKING_STYLE && defined(__APPLE__)
30023 /*
30024 ** Handler for proxy-locking file-control verbs.  Defined below in the
30025 ** proxying locking division.
30026 */
30027 static int proxyFileControl(sqlcipher3_file*,int,void*);
30028 #endif
30029
30030 /* 
30031 ** This function is called to handle the SQLCIPHER_FCNTL_SIZE_HINT 
30032 ** file-control operation.  Enlarge the database to nBytes in size
30033 ** (rounded up to the next chunk-size).  If the database is already
30034 ** nBytes or larger, this routine is a no-op.
30035 */
30036 static int fcntlSizeHint(unixFile *pFile, i64 nByte){
30037   if( pFile->szChunk>0 ){
30038     i64 nSize;                    /* Required file size */
30039     struct stat buf;              /* Used to hold return values of fstat() */
30040    
30041     if( osFstat(pFile->h, &buf) ) return SQLCIPHER_IOERR_FSTAT;
30042
30043     nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
30044     if( nSize>(i64)buf.st_size ){
30045
30046 #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
30047       /* The code below is handling the return value of osFallocate() 
30048       ** correctly. posix_fallocate() is defined to "returns zero on success, 
30049       ** or an error number on  failure". See the manpage for details. */
30050       int err;
30051       do{
30052         err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
30053       }while( err==EINTR );
30054       if( err ) return SQLCIPHER_IOERR_WRITE;
30055 #else
30056       /* If the OS does not have posix_fallocate(), fake it. First use
30057       ** ftruncate() to set the file size, then write a single byte to
30058       ** the last byte in each block within the extended region. This
30059       ** is the same technique used by glibc to implement posix_fallocate()
30060       ** on systems that do not have a real fallocate() system call.
30061       */
30062       int nBlk = buf.st_blksize;  /* File-system block size */
30063       i64 iWrite;                 /* Next offset to write to */
30064
30065       if( robust_ftruncate(pFile->h, nSize) ){
30066         pFile->lastErrno = errno;
30067         return unixLogError(SQLCIPHER_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
30068       }
30069       iWrite = ((buf.st_size + 2*nBlk - 1)/nBlk)*nBlk-1;
30070       while( iWrite<nSize ){
30071         int nWrite = seekAndWrite(pFile, iWrite, "", 1);
30072         if( nWrite!=1 ) return SQLCIPHER_IOERR_WRITE;
30073         iWrite += nBlk;
30074       }
30075 #endif
30076     }
30077   }
30078
30079   return SQLCIPHER_OK;
30080 }
30081
30082 /*
30083 ** Information and control of an open file handle.
30084 */
30085 static int unixFileControl(sqlcipher3_file *id, int op, void *pArg){
30086   unixFile *pFile = (unixFile*)id;
30087   switch( op ){
30088     case SQLCIPHER_FCNTL_LOCKSTATE: {
30089       *(int*)pArg = pFile->eFileLock;
30090       return SQLCIPHER_OK;
30091     }
30092     case SQLCIPHER_LAST_ERRNO: {
30093       *(int*)pArg = pFile->lastErrno;
30094       return SQLCIPHER_OK;
30095     }
30096     case SQLCIPHER_FCNTL_CHUNK_SIZE: {
30097       pFile->szChunk = *(int *)pArg;
30098       return SQLCIPHER_OK;
30099     }
30100     case SQLCIPHER_FCNTL_SIZE_HINT: {
30101       int rc;
30102       SimulateIOErrorBenign(1);
30103       rc = fcntlSizeHint(pFile, *(i64 *)pArg);
30104       SimulateIOErrorBenign(0);
30105       return rc;
30106     }
30107     case SQLCIPHER_FCNTL_PERSIST_WAL: {
30108       int bPersist = *(int*)pArg;
30109       if( bPersist<0 ){
30110         *(int*)pArg = (pFile->ctrlFlags & UNIXFILE_PERSIST_WAL)!=0;
30111       }else if( bPersist==0 ){
30112         pFile->ctrlFlags &= ~UNIXFILE_PERSIST_WAL;
30113       }else{
30114         pFile->ctrlFlags |= UNIXFILE_PERSIST_WAL;
30115       }
30116       return SQLCIPHER_OK;
30117     }
30118 #ifndef NDEBUG
30119     /* The pager calls this method to signal that it has done
30120     ** a rollback and that the database is therefore unchanged and
30121     ** it hence it is OK for the transaction change counter to be
30122     ** unchanged.
30123     */
30124     case SQLCIPHER_FCNTL_DB_UNCHANGED: {
30125       ((unixFile*)id)->dbUpdate = 0;
30126       return SQLCIPHER_OK;
30127     }
30128 #endif
30129 #if SQLCIPHER_ENABLE_LOCKING_STYLE && defined(__APPLE__)
30130     case SQLCIPHER_SET_LOCKPROXYFILE:
30131     case SQLCIPHER_GET_LOCKPROXYFILE: {
30132       return proxyFileControl(id,op,pArg);
30133     }
30134 #endif /* SQLCIPHER_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
30135     case SQLCIPHER_FCNTL_SYNC_OMITTED: {
30136       return SQLCIPHER_OK;  /* A no-op */
30137     }
30138   }
30139   return SQLCIPHER_NOTFOUND;
30140 }
30141
30142 /*
30143 ** Return the sector size in bytes of the underlying block device for
30144 ** the specified file. This is almost always 512 bytes, but may be
30145 ** larger for some devices.
30146 **
30147 ** SQLite code assumes this function cannot fail. It also assumes that
30148 ** if two files are created in the same file-system directory (i.e.
30149 ** a database and its journal file) that the sector size will be the
30150 ** same for both.
30151 */
30152 static int unixSectorSize(sqlcipher3_file *NotUsed){
30153   UNUSED_PARAMETER(NotUsed);
30154   return SQLCIPHER_DEFAULT_SECTOR_SIZE;
30155 }
30156
30157 /*
30158 ** Return the device characteristics for the file. This is always 0 for unix.
30159 */
30160 static int unixDeviceCharacteristics(sqlcipher3_file *NotUsed){
30161   UNUSED_PARAMETER(NotUsed);
30162   return 0;
30163 }
30164
30165 #ifndef SQLCIPHER_OMIT_WAL
30166
30167
30168 /*
30169 ** Object used to represent an shared memory buffer.  
30170 **
30171 ** When multiple threads all reference the same wal-index, each thread
30172 ** has its own unixShm object, but they all point to a single instance
30173 ** of this unixShmNode object.  In other words, each wal-index is opened
30174 ** only once per process.
30175 **
30176 ** Each unixShmNode object is connected to a single unixInodeInfo object.
30177 ** We could coalesce this object into unixInodeInfo, but that would mean
30178 ** every open file that does not use shared memory (in other words, most
30179 ** open files) would have to carry around this extra information.  So
30180 ** the unixInodeInfo object contains a pointer to this unixShmNode object
30181 ** and the unixShmNode object is created only when needed.
30182 **
30183 ** unixMutexHeld() must be true when creating or destroying
30184 ** this object or while reading or writing the following fields:
30185 **
30186 **      nRef
30187 **
30188 ** The following fields are read-only after the object is created:
30189 ** 
30190 **      fid
30191 **      zFilename
30192 **
30193 ** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and
30194 ** unixMutexHeld() is true when reading or writing any other field
30195 ** in this structure.
30196 */
30197 struct unixShmNode {
30198   unixInodeInfo *pInode;     /* unixInodeInfo that owns this SHM node */
30199   sqlcipher3_mutex *mutex;      /* Mutex to access this object */
30200   char *zFilename;           /* Name of the mmapped file */
30201   int h;                     /* Open file descriptor */
30202   int szRegion;              /* Size of shared-memory regions */
30203   u16 nRegion;               /* Size of array apRegion */
30204   u8 isReadonly;             /* True if read-only */
30205   char **apRegion;           /* Array of mapped shared-memory regions */
30206   int nRef;                  /* Number of unixShm objects pointing to this */
30207   unixShm *pFirst;           /* All unixShm objects pointing to this */
30208 #ifdef SQLCIPHER_DEBUG
30209   u8 exclMask;               /* Mask of exclusive locks held */
30210   u8 sharedMask;             /* Mask of shared locks held */
30211   u8 nextShmId;              /* Next available unixShm.id value */
30212 #endif
30213 };
30214
30215 /*
30216 ** Structure used internally by this VFS to record the state of an
30217 ** open shared memory connection.
30218 **
30219 ** The following fields are initialized when this object is created and
30220 ** are read-only thereafter:
30221 **
30222 **    unixShm.pFile
30223 **    unixShm.id
30224 **
30225 ** All other fields are read/write.  The unixShm.pFile->mutex must be held
30226 ** while accessing any read/write fields.
30227 */
30228 struct unixShm {
30229   unixShmNode *pShmNode;     /* The underlying unixShmNode object */
30230   unixShm *pNext;            /* Next unixShm with the same unixShmNode */
30231   u8 hasMutex;               /* True if holding the unixShmNode mutex */
30232   u8 id;                     /* Id of this connection within its unixShmNode */
30233   u16 sharedMask;            /* Mask of shared locks held */
30234   u16 exclMask;              /* Mask of exclusive locks held */
30235 };
30236
30237 /*
30238 ** Constants used for locking
30239 */
30240 #define UNIX_SHM_BASE   ((22+SQLCIPHER_SHM_NLOCK)*4)         /* first lock byte */
30241 #define UNIX_SHM_DMS    (UNIX_SHM_BASE+SQLCIPHER_SHM_NLOCK)  /* deadman switch */
30242
30243 /*
30244 ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
30245 **
30246 ** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
30247 ** otherwise.
30248 */
30249 static int unixShmSystemLock(
30250   unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
30251   int lockType,          /* F_UNLCK, F_RDLCK, or F_WRLCK */
30252   int ofst,              /* First byte of the locking range */
30253   int n                  /* Number of bytes to lock */
30254 ){
30255   struct flock f;       /* The posix advisory locking structure */
30256   int rc = SQLCIPHER_OK;   /* Result code form fcntl() */
30257
30258   /* Access to the unixShmNode object is serialized by the caller */
30259   assert( sqlcipher3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
30260
30261   /* Shared locks never span more than one byte */
30262   assert( n==1 || lockType!=F_RDLCK );
30263
30264   /* Locks are within range */
30265   assert( n>=1 && n<SQLCIPHER_SHM_NLOCK );
30266
30267   if( pShmNode->h>=0 ){
30268     /* Initialize the locking parameters */
30269     memset(&f, 0, sizeof(f));
30270     f.l_type = lockType;
30271     f.l_whence = SEEK_SET;
30272     f.l_start = ofst;
30273     f.l_len = n;
30274
30275     rc = osFcntl(pShmNode->h, F_SETLK, &f);
30276     rc = (rc!=(-1)) ? SQLCIPHER_OK : SQLCIPHER_BUSY;
30277   }
30278
30279   /* Update the global lock state and do debug tracing */
30280 #ifdef SQLCIPHER_DEBUG
30281   { u16 mask;
30282   OSTRACE(("SHM-LOCK "));
30283   mask = (1<<(ofst+n)) - (1<<ofst);
30284   if( rc==SQLCIPHER_OK ){
30285     if( lockType==F_UNLCK ){
30286       OSTRACE(("unlock %d ok", ofst));
30287       pShmNode->exclMask &= ~mask;
30288       pShmNode->sharedMask &= ~mask;
30289     }else if( lockType==F_RDLCK ){
30290       OSTRACE(("read-lock %d ok", ofst));
30291       pShmNode->exclMask &= ~mask;
30292       pShmNode->sharedMask |= mask;
30293     }else{
30294       assert( lockType==F_WRLCK );
30295       OSTRACE(("write-lock %d ok", ofst));
30296       pShmNode->exclMask |= mask;
30297       pShmNode->sharedMask &= ~mask;
30298     }
30299   }else{
30300     if( lockType==F_UNLCK ){
30301       OSTRACE(("unlock %d failed", ofst));
30302     }else if( lockType==F_RDLCK ){
30303       OSTRACE(("read-lock failed"));
30304     }else{
30305       assert( lockType==F_WRLCK );
30306       OSTRACE(("write-lock %d failed", ofst));
30307     }
30308   }
30309   OSTRACE((" - afterwards %03x,%03x\n",
30310            pShmNode->sharedMask, pShmNode->exclMask));
30311   }
30312 #endif
30313
30314   return rc;        
30315 }
30316
30317
30318 /*
30319 ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
30320 **
30321 ** This is not a VFS shared-memory method; it is a utility function called
30322 ** by VFS shared-memory methods.
30323 */
30324 static void unixShmPurge(unixFile *pFd){
30325   unixShmNode *p = pFd->pInode->pShmNode;
30326   assert( unixMutexHeld() );
30327   if( p && p->nRef==0 ){
30328     int i;
30329     assert( p->pInode==pFd->pInode );
30330     sqlcipher3_mutex_free(p->mutex);
30331     for(i=0; i<p->nRegion; i++){
30332       if( p->h>=0 ){
30333         munmap(p->apRegion[i], p->szRegion);
30334       }else{
30335         sqlcipher3_free(p->apRegion[i]);
30336       }
30337     }
30338     sqlcipher3_free(p->apRegion);
30339     if( p->h>=0 ){
30340       robust_close(pFd, p->h, __LINE__);
30341       p->h = -1;
30342     }
30343     p->pInode->pShmNode = 0;
30344     sqlcipher3_free(p);
30345   }
30346 }
30347
30348 /*
30349 ** Open a shared-memory area associated with open database file pDbFd.  
30350 ** This particular implementation uses mmapped files.
30351 **
30352 ** The file used to implement shared-memory is in the same directory
30353 ** as the open database file and has the same name as the open database
30354 ** file with the "-shm" suffix added.  For example, if the database file
30355 ** is "/home/user1/config.db" then the file that is created and mmapped
30356 ** for shared memory will be called "/home/user1/config.db-shm".  
30357 **
30358 ** Another approach to is to use files in /dev/shm or /dev/tmp or an
30359 ** some other tmpfs mount. But if a file in a different directory
30360 ** from the database file is used, then differing access permissions
30361 ** or a chroot() might cause two different processes on the same
30362 ** database to end up using different files for shared memory - 
30363 ** meaning that their memory would not really be shared - resulting
30364 ** in database corruption.  Nevertheless, this tmpfs file usage
30365 ** can be enabled at compile-time using -DSQLCIPHER_SHM_DIRECTORY="/dev/shm"
30366 ** or the equivalent.  The use of the SQLCIPHER_SHM_DIRECTORY compile-time
30367 ** option results in an incompatible build of SQLite;  builds of SQLite
30368 ** that with differing SQLCIPHER_SHM_DIRECTORY settings attempt to use the
30369 ** same database file at the same time, database corruption will likely
30370 ** result. The SQLCIPHER_SHM_DIRECTORY compile-time option is considered
30371 ** "unsupported" and may go away in a future SQLite release.
30372 **
30373 ** When opening a new shared-memory file, if no other instances of that
30374 ** file are currently open, in this process or in other processes, then
30375 ** the file must be truncated to zero length or have its header cleared.
30376 **
30377 ** If the original database file (pDbFd) is using the "unix-excl" VFS
30378 ** that means that an exclusive lock is held on the database file and
30379 ** that no other processes are able to read or write the database.  In
30380 ** that case, we do not really need shared memory.  No shared memory
30381 ** file is created.  The shared memory will be simulated with heap memory.
30382 */
30383 static int unixOpenSharedMemory(unixFile *pDbFd){
30384   struct unixShm *p = 0;          /* The connection to be opened */
30385   struct unixShmNode *pShmNode;   /* The underlying mmapped file */
30386   int rc;                         /* Result code */
30387   unixInodeInfo *pInode;          /* The inode of fd */
30388   char *zShmFilename;             /* Name of the file used for SHM */
30389   int nShmFilename;               /* Size of the SHM filename in bytes */
30390
30391   /* Allocate space for the new unixShm object. */
30392   p = sqlcipher3_malloc( sizeof(*p) );
30393   if( p==0 ) return SQLCIPHER_NOMEM;
30394   memset(p, 0, sizeof(*p));
30395   assert( pDbFd->pShm==0 );
30396
30397   /* Check to see if a unixShmNode object already exists. Reuse an existing
30398   ** one if present. Create a new one if necessary.
30399   */
30400   unixEnterMutex();
30401   pInode = pDbFd->pInode;
30402   pShmNode = pInode->pShmNode;
30403   if( pShmNode==0 ){
30404     struct stat sStat;                 /* fstat() info for database file */
30405
30406     /* Call fstat() to figure out the permissions on the database file. If
30407     ** a new *-shm file is created, an attempt will be made to create it
30408     ** with the same permissions. The actual permissions the file is created
30409     ** with are subject to the current umask setting.
30410     */
30411     if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){
30412       rc = SQLCIPHER_IOERR_FSTAT;
30413       goto shm_open_err;
30414     }
30415
30416 #ifdef SQLCIPHER_SHM_DIRECTORY
30417     nShmFilename = sizeof(SQLCIPHER_SHM_DIRECTORY) + 30;
30418 #else
30419     nShmFilename = 5 + (int)strlen(pDbFd->zPath);
30420 #endif
30421     pShmNode = sqlcipher3_malloc( sizeof(*pShmNode) + nShmFilename );
30422     if( pShmNode==0 ){
30423       rc = SQLCIPHER_NOMEM;
30424       goto shm_open_err;
30425     }
30426     memset(pShmNode, 0, sizeof(*pShmNode));
30427     zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];
30428 #ifdef SQLCIPHER_SHM_DIRECTORY
30429     sqlcipher3_snprintf(nShmFilename, zShmFilename, 
30430                      SQLCIPHER_SHM_DIRECTORY "/sqlcipher-shm-%x-%x",
30431                      (u32)sStat.st_ino, (u32)sStat.st_dev);
30432 #else
30433     sqlcipher3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
30434     sqlcipher3FileSuffix3(pDbFd->zPath, zShmFilename);
30435 #endif
30436     pShmNode->h = -1;
30437     pDbFd->pInode->pShmNode = pShmNode;
30438     pShmNode->pInode = pDbFd->pInode;
30439     pShmNode->mutex = sqlcipher3_mutex_alloc(SQLCIPHER_MUTEX_FAST);
30440     if( pShmNode->mutex==0 ){
30441       rc = SQLCIPHER_NOMEM;
30442       goto shm_open_err;
30443     }
30444
30445     if( pInode->bProcessLock==0 ){
30446       const char *zRO;
30447       int openFlags = O_RDWR | O_CREAT;
30448       zRO = sqlcipher3_uri_parameter(pDbFd->zPath, "readonly_shm");
30449       if( zRO && sqlcipher3GetBoolean(zRO) ){
30450         openFlags = O_RDONLY;
30451         pShmNode->isReadonly = 1;
30452       }
30453       pShmNode->h = robust_open(zShmFilename, openFlags, (sStat.st_mode&0777));
30454       if( pShmNode->h<0 ){
30455         if( pShmNode->h<0 ){
30456           rc = unixLogError(SQLCIPHER_CANTOPEN_BKPT, "open", zShmFilename);
30457           goto shm_open_err;
30458         }
30459       }
30460   
30461       /* Check to see if another process is holding the dead-man switch.
30462       ** If not, truncate the file to zero length. 
30463       */
30464       rc = SQLCIPHER_OK;
30465       if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLCIPHER_OK ){
30466         if( robust_ftruncate(pShmNode->h, 0) ){
30467           rc = unixLogError(SQLCIPHER_IOERR_SHMOPEN, "ftruncate", zShmFilename);
30468         }
30469       }
30470       if( rc==SQLCIPHER_OK ){
30471         rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1);
30472       }
30473       if( rc ) goto shm_open_err;
30474     }
30475   }
30476
30477   /* Make the new connection a child of the unixShmNode */
30478   p->pShmNode = pShmNode;
30479 #ifdef SQLCIPHER_DEBUG
30480   p->id = pShmNode->nextShmId++;
30481 #endif
30482   pShmNode->nRef++;
30483   pDbFd->pShm = p;
30484   unixLeaveMutex();
30485
30486   /* The reference count on pShmNode has already been incremented under
30487   ** the cover of the unixEnterMutex() mutex and the pointer from the
30488   ** new (struct unixShm) object to the pShmNode has been set. All that is
30489   ** left to do is to link the new object into the linked list starting
30490   ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex 
30491   ** mutex.
30492   */
30493   sqlcipher3_mutex_enter(pShmNode->mutex);
30494   p->pNext = pShmNode->pFirst;
30495   pShmNode->pFirst = p;
30496   sqlcipher3_mutex_leave(pShmNode->mutex);
30497   return SQLCIPHER_OK;
30498
30499   /* Jump here on any error */
30500 shm_open_err:
30501   unixShmPurge(pDbFd);       /* This call frees pShmNode if required */
30502   sqlcipher3_free(p);
30503   unixLeaveMutex();
30504   return rc;
30505 }
30506
30507 /*
30508 ** This function is called to obtain a pointer to region iRegion of the 
30509 ** shared-memory associated with the database file fd. Shared-memory regions 
30510 ** are numbered starting from zero. Each shared-memory region is szRegion 
30511 ** bytes in size.
30512 **
30513 ** If an error occurs, an error code is returned and *pp is set to NULL.
30514 **
30515 ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
30516 ** region has not been allocated (by any client, including one running in a
30517 ** separate process), then *pp is set to NULL and SQLCIPHER_OK returned. If 
30518 ** bExtend is non-zero and the requested shared-memory region has not yet 
30519 ** been allocated, it is allocated by this function.
30520 **
30521 ** If the shared-memory region has already been allocated or is allocated by
30522 ** this call as described above, then it is mapped into this processes 
30523 ** address space (if it is not already), *pp is set to point to the mapped 
30524 ** memory and SQLCIPHER_OK returned.
30525 */
30526 static int unixShmMap(
30527   sqlcipher3_file *fd,               /* Handle open on database file */
30528   int iRegion,                    /* Region to retrieve */
30529   int szRegion,                   /* Size of regions */
30530   int bExtend,                    /* True to extend file if necessary */
30531   void volatile **pp              /* OUT: Mapped memory */
30532 ){
30533   unixFile *pDbFd = (unixFile*)fd;
30534   unixShm *p;
30535   unixShmNode *pShmNode;
30536   int rc = SQLCIPHER_OK;
30537
30538   /* If the shared-memory file has not yet been opened, open it now. */
30539   if( pDbFd->pShm==0 ){
30540     rc = unixOpenSharedMemory(pDbFd);
30541     if( rc!=SQLCIPHER_OK ) return rc;
30542   }
30543
30544   p = pDbFd->pShm;
30545   pShmNode = p->pShmNode;
30546   sqlcipher3_mutex_enter(pShmNode->mutex);
30547   assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
30548   assert( pShmNode->pInode==pDbFd->pInode );
30549   assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
30550   assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
30551
30552   if( pShmNode->nRegion<=iRegion ){
30553     char **apNew;                      /* New apRegion[] array */
30554     int nByte = (iRegion+1)*szRegion;  /* Minimum required file size */
30555     struct stat sStat;                 /* Used by fstat() */
30556
30557     pShmNode->szRegion = szRegion;
30558
30559     if( pShmNode->h>=0 ){
30560       /* The requested region is not mapped into this processes address space.
30561       ** Check to see if it has been allocated (i.e. if the wal-index file is
30562       ** large enough to contain the requested region).
30563       */
30564       if( osFstat(pShmNode->h, &sStat) ){
30565         rc = SQLCIPHER_IOERR_SHMSIZE;
30566         goto shmpage_out;
30567       }
30568   
30569       if( sStat.st_size<nByte ){
30570         /* The requested memory region does not exist. If bExtend is set to
30571         ** false, exit early. *pp will be set to NULL and SQLCIPHER_OK returned.
30572         **
30573         ** Alternatively, if bExtend is true, use ftruncate() to allocate
30574         ** the requested memory region.
30575         */
30576         if( !bExtend ) goto shmpage_out;
30577         if( robust_ftruncate(pShmNode->h, nByte) ){
30578           rc = unixLogError(SQLCIPHER_IOERR_SHMSIZE, "ftruncate",
30579                             pShmNode->zFilename);
30580           goto shmpage_out;
30581         }
30582       }
30583     }
30584
30585     /* Map the requested memory region into this processes address space. */
30586     apNew = (char **)sqlcipher3_realloc(
30587         pShmNode->apRegion, (iRegion+1)*sizeof(char *)
30588     );
30589     if( !apNew ){
30590       rc = SQLCIPHER_IOERR_NOMEM;
30591       goto shmpage_out;
30592     }
30593     pShmNode->apRegion = apNew;
30594     while(pShmNode->nRegion<=iRegion){
30595       void *pMem;
30596       if( pShmNode->h>=0 ){
30597         pMem = mmap(0, szRegion,
30598             pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE, 
30599             MAP_SHARED, pShmNode->h, pShmNode->nRegion*szRegion
30600         );
30601         if( pMem==MAP_FAILED ){
30602           rc = unixLogError(SQLCIPHER_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
30603           goto shmpage_out;
30604         }
30605       }else{
30606         pMem = sqlcipher3_malloc(szRegion);
30607         if( pMem==0 ){
30608           rc = SQLCIPHER_NOMEM;
30609           goto shmpage_out;
30610         }
30611         memset(pMem, 0, szRegion);
30612       }
30613       pShmNode->apRegion[pShmNode->nRegion] = pMem;
30614       pShmNode->nRegion++;
30615     }
30616   }
30617
30618 shmpage_out:
30619   if( pShmNode->nRegion>iRegion ){
30620     *pp = pShmNode->apRegion[iRegion];
30621   }else{
30622     *pp = 0;
30623   }
30624   if( pShmNode->isReadonly && rc==SQLCIPHER_OK ) rc = SQLCIPHER_READONLY;
30625   sqlcipher3_mutex_leave(pShmNode->mutex);
30626   return rc;
30627 }
30628
30629 /*
30630 ** Change the lock state for a shared-memory segment.
30631 **
30632 ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
30633 ** different here than in posix.  In xShmLock(), one can go from unlocked
30634 ** to shared and back or from unlocked to exclusive and back.  But one may
30635 ** not go from shared to exclusive or from exclusive to shared.
30636 */
30637 static int unixShmLock(
30638   sqlcipher3_file *fd,          /* Database file holding the shared memory */
30639   int ofst,                  /* First lock to acquire or release */
30640   int n,                     /* Number of locks to acquire or release */
30641   int flags                  /* What to do with the lock */
30642 ){
30643   unixFile *pDbFd = (unixFile*)fd;      /* Connection holding shared memory */
30644   unixShm *p = pDbFd->pShm;             /* The shared memory being locked */
30645   unixShm *pX;                          /* For looping over all siblings */
30646   unixShmNode *pShmNode = p->pShmNode;  /* The underlying file iNode */
30647   int rc = SQLCIPHER_OK;                   /* Result code */
30648   u16 mask;                             /* Mask of locks to take or release */
30649
30650   assert( pShmNode==pDbFd->pInode->pShmNode );
30651   assert( pShmNode->pInode==pDbFd->pInode );
30652   assert( ofst>=0 && ofst+n<=SQLCIPHER_SHM_NLOCK );
30653   assert( n>=1 );
30654   assert( flags==(SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_SHARED)
30655        || flags==(SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_EXCLUSIVE)
30656        || flags==(SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_SHARED)
30657        || flags==(SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_EXCLUSIVE) );
30658   assert( n==1 || (flags & SQLCIPHER_SHM_EXCLUSIVE)!=0 );
30659   assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
30660   assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
30661
30662   mask = (1<<(ofst+n)) - (1<<ofst);
30663   assert( n>1 || mask==(1<<ofst) );
30664   sqlcipher3_mutex_enter(pShmNode->mutex);
30665   if( flags & SQLCIPHER_SHM_UNLOCK ){
30666     u16 allMask = 0; /* Mask of locks held by siblings */
30667
30668     /* See if any siblings hold this same lock */
30669     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
30670       if( pX==p ) continue;
30671       assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
30672       allMask |= pX->sharedMask;
30673     }
30674
30675     /* Unlock the system-level locks */
30676     if( (mask & allMask)==0 ){
30677       rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n);
30678     }else{
30679       rc = SQLCIPHER_OK;
30680     }
30681
30682     /* Undo the local locks */
30683     if( rc==SQLCIPHER_OK ){
30684       p->exclMask &= ~mask;
30685       p->sharedMask &= ~mask;
30686     } 
30687   }else if( flags & SQLCIPHER_SHM_SHARED ){
30688     u16 allShared = 0;  /* Union of locks held by connections other than "p" */
30689
30690     /* Find out which shared locks are already held by sibling connections.
30691     ** If any sibling already holds an exclusive lock, go ahead and return
30692     ** SQLCIPHER_BUSY.
30693     */
30694     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
30695       if( (pX->exclMask & mask)!=0 ){
30696         rc = SQLCIPHER_BUSY;
30697         break;
30698       }
30699       allShared |= pX->sharedMask;
30700     }
30701
30702     /* Get shared locks at the system level, if necessary */
30703     if( rc==SQLCIPHER_OK ){
30704       if( (allShared & mask)==0 ){
30705         rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n);
30706       }else{
30707         rc = SQLCIPHER_OK;
30708       }
30709     }
30710
30711     /* Get the local shared locks */
30712     if( rc==SQLCIPHER_OK ){
30713       p->sharedMask |= mask;
30714     }
30715   }else{
30716     /* Make sure no sibling connections hold locks that will block this
30717     ** lock.  If any do, return SQLCIPHER_BUSY right away.
30718     */
30719     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
30720       if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
30721         rc = SQLCIPHER_BUSY;
30722         break;
30723       }
30724     }
30725   
30726     /* Get the exclusive locks at the system level.  Then if successful
30727     ** also mark the local connection as being locked.
30728     */
30729     if( rc==SQLCIPHER_OK ){
30730       rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n);
30731       if( rc==SQLCIPHER_OK ){
30732         assert( (p->sharedMask & mask)==0 );
30733         p->exclMask |= mask;
30734       }
30735     }
30736   }
30737   sqlcipher3_mutex_leave(pShmNode->mutex);
30738   OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
30739            p->id, getpid(), p->sharedMask, p->exclMask));
30740   return rc;
30741 }
30742
30743 /*
30744 ** Implement a memory barrier or memory fence on shared memory.  
30745 **
30746 ** All loads and stores begun before the barrier must complete before
30747 ** any load or store begun after the barrier.
30748 */
30749 static void unixShmBarrier(
30750   sqlcipher3_file *fd                /* Database file holding the shared memory */
30751 ){
30752   UNUSED_PARAMETER(fd);
30753   unixEnterMutex();
30754   unixLeaveMutex();
30755 }
30756
30757 /*
30758 ** Close a connection to shared-memory.  Delete the underlying 
30759 ** storage if deleteFlag is true.
30760 **
30761 ** If there is no shared memory associated with the connection then this
30762 ** routine is a harmless no-op.
30763 */
30764 static int unixShmUnmap(
30765   sqlcipher3_file *fd,               /* The underlying database file */
30766   int deleteFlag                  /* Delete shared-memory if true */
30767 ){
30768   unixShm *p;                     /* The connection to be closed */
30769   unixShmNode *pShmNode;          /* The underlying shared-memory file */
30770   unixShm **pp;                   /* For looping over sibling connections */
30771   unixFile *pDbFd;                /* The underlying database file */
30772
30773   pDbFd = (unixFile*)fd;
30774   p = pDbFd->pShm;
30775   if( p==0 ) return SQLCIPHER_OK;
30776   pShmNode = p->pShmNode;
30777
30778   assert( pShmNode==pDbFd->pInode->pShmNode );
30779   assert( pShmNode->pInode==pDbFd->pInode );
30780
30781   /* Remove connection p from the set of connections associated
30782   ** with pShmNode */
30783   sqlcipher3_mutex_enter(pShmNode->mutex);
30784   for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
30785   *pp = p->pNext;
30786
30787   /* Free the connection p */
30788   sqlcipher3_free(p);
30789   pDbFd->pShm = 0;
30790   sqlcipher3_mutex_leave(pShmNode->mutex);
30791
30792   /* If pShmNode->nRef has reached 0, then close the underlying
30793   ** shared-memory file, too */
30794   unixEnterMutex();
30795   assert( pShmNode->nRef>0 );
30796   pShmNode->nRef--;
30797   if( pShmNode->nRef==0 ){
30798     if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
30799     unixShmPurge(pDbFd);
30800   }
30801   unixLeaveMutex();
30802
30803   return SQLCIPHER_OK;
30804 }
30805
30806
30807 #else
30808 # define unixShmMap     0
30809 # define unixShmLock    0
30810 # define unixShmBarrier 0
30811 # define unixShmUnmap   0
30812 #endif /* #ifndef SQLCIPHER_OMIT_WAL */
30813
30814 /*
30815 ** Here ends the implementation of all sqlcipher3_file methods.
30816 **
30817 ********************** End sqlcipher3_file Methods *******************************
30818 ******************************************************************************/
30819
30820 /*
30821 ** This division contains definitions of sqlcipher3_io_methods objects that
30822 ** implement various file locking strategies.  It also contains definitions
30823 ** of "finder" functions.  A finder-function is used to locate the appropriate
30824 ** sqlcipher3_io_methods object for a particular database file.  The pAppData
30825 ** field of the sqlcipher3_vfs VFS objects are initialized to be pointers to
30826 ** the correct finder-function for that VFS.
30827 **
30828 ** Most finder functions return a pointer to a fixed sqlcipher3_io_methods
30829 ** object.  The only interesting finder-function is autolockIoFinder, which
30830 ** looks at the filesystem type and tries to guess the best locking
30831 ** strategy from that.
30832 **
30833 ** For finder-funtion F, two objects are created:
30834 **
30835 **    (1) The real finder-function named "FImpt()".
30836 **
30837 **    (2) A constant pointer to this function named just "F".
30838 **
30839 **
30840 ** A pointer to the F pointer is used as the pAppData value for VFS
30841 ** objects.  We have to do this instead of letting pAppData point
30842 ** directly at the finder-function since C90 rules prevent a void*
30843 ** from be cast into a function pointer.
30844 **
30845 **
30846 ** Each instance of this macro generates two objects:
30847 **
30848 **   *  A constant sqlcipher3_io_methods object call METHOD that has locking
30849 **      methods CLOSE, LOCK, UNLOCK, CKRESLOCK.
30850 **
30851 **   *  An I/O method finder function called FINDER that returns a pointer
30852 **      to the METHOD object in the previous bullet.
30853 */
30854 #define IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK)      \
30855 static const sqlcipher3_io_methods METHOD = {                                   \
30856    VERSION,                    /* iVersion */                                \
30857    CLOSE,                      /* xClose */                                  \
30858    unixRead,                   /* xRead */                                   \
30859    unixWrite,                  /* xWrite */                                  \
30860    unixTruncate,               /* xTruncate */                               \
30861    unixSync,                   /* xSync */                                   \
30862    unixFileSize,               /* xFileSize */                               \
30863    LOCK,                       /* xLock */                                   \
30864    UNLOCK,                     /* xUnlock */                                 \
30865    CKLOCK,                     /* xCheckReservedLock */                      \
30866    unixFileControl,            /* xFileControl */                            \
30867    unixSectorSize,             /* xSectorSize */                             \
30868    unixDeviceCharacteristics,  /* xDeviceCapabilities */                     \
30869    unixShmMap,                 /* xShmMap */                                 \
30870    unixShmLock,                /* xShmLock */                                \
30871    unixShmBarrier,             /* xShmBarrier */                             \
30872    unixShmUnmap                /* xShmUnmap */                               \
30873 };                                                                           \
30874 static const sqlcipher3_io_methods *FINDER##Impl(const char *z, unixFile *p){   \
30875   UNUSED_PARAMETER(z); UNUSED_PARAMETER(p);                                  \
30876   return &METHOD;                                                            \
30877 }                                                                            \
30878 static const sqlcipher3_io_methods *(*const FINDER)(const char*,unixFile *p)    \
30879     = FINDER##Impl;
30880
30881 /*
30882 ** Here are all of the sqlcipher3_io_methods objects for each of the
30883 ** locking strategies.  Functions that return pointers to these methods
30884 ** are also created.
30885 */
30886 IOMETHODS(
30887   posixIoFinder,            /* Finder function name */
30888   posixIoMethods,           /* sqlcipher3_io_methods object name */
30889   2,                        /* shared memory is enabled */
30890   unixClose,                /* xClose method */
30891   unixLock,                 /* xLock method */
30892   unixUnlock,               /* xUnlock method */
30893   unixCheckReservedLock     /* xCheckReservedLock method */
30894 )
30895 IOMETHODS(
30896   nolockIoFinder,           /* Finder function name */
30897   nolockIoMethods,          /* sqlcipher3_io_methods object name */
30898   1,                        /* shared memory is disabled */
30899   nolockClose,              /* xClose method */
30900   nolockLock,               /* xLock method */
30901   nolockUnlock,             /* xUnlock method */
30902   nolockCheckReservedLock   /* xCheckReservedLock method */
30903 )
30904 IOMETHODS(
30905   dotlockIoFinder,          /* Finder function name */
30906   dotlockIoMethods,         /* sqlcipher3_io_methods object name */
30907   1,                        /* shared memory is disabled */
30908   dotlockClose,             /* xClose method */
30909   dotlockLock,              /* xLock method */
30910   dotlockUnlock,            /* xUnlock method */
30911   dotlockCheckReservedLock  /* xCheckReservedLock method */
30912 )
30913
30914 #if SQLCIPHER_ENABLE_LOCKING_STYLE && !OS_VXWORKS
30915 IOMETHODS(
30916   flockIoFinder,            /* Finder function name */
30917   flockIoMethods,           /* sqlcipher3_io_methods object name */
30918   1,                        /* shared memory is disabled */
30919   flockClose,               /* xClose method */
30920   flockLock,                /* xLock method */
30921   flockUnlock,              /* xUnlock method */
30922   flockCheckReservedLock    /* xCheckReservedLock method */
30923 )
30924 #endif
30925
30926 #if OS_VXWORKS
30927 IOMETHODS(
30928   semIoFinder,              /* Finder function name */
30929   semIoMethods,             /* sqlcipher3_io_methods object name */
30930   1,                        /* shared memory is disabled */
30931   semClose,                 /* xClose method */
30932   semLock,                  /* xLock method */
30933   semUnlock,                /* xUnlock method */
30934   semCheckReservedLock      /* xCheckReservedLock method */
30935 )
30936 #endif
30937
30938 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
30939 IOMETHODS(
30940   afpIoFinder,              /* Finder function name */
30941   afpIoMethods,             /* sqlcipher3_io_methods object name */
30942   1,                        /* shared memory is disabled */
30943   afpClose,                 /* xClose method */
30944   afpLock,                  /* xLock method */
30945   afpUnlock,                /* xUnlock method */
30946   afpCheckReservedLock      /* xCheckReservedLock method */
30947 )
30948 #endif
30949
30950 /*
30951 ** The proxy locking method is a "super-method" in the sense that it
30952 ** opens secondary file descriptors for the conch and lock files and
30953 ** it uses proxy, dot-file, AFP, and flock() locking methods on those
30954 ** secondary files.  For this reason, the division that implements
30955 ** proxy locking is located much further down in the file.  But we need
30956 ** to go ahead and define the sqlcipher3_io_methods and finder function
30957 ** for proxy locking here.  So we forward declare the I/O methods.
30958 */
30959 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
30960 static int proxyClose(sqlcipher3_file*);
30961 static int proxyLock(sqlcipher3_file*, int);
30962 static int proxyUnlock(sqlcipher3_file*, int);
30963 static int proxyCheckReservedLock(sqlcipher3_file*, int*);
30964 IOMETHODS(
30965   proxyIoFinder,            /* Finder function name */
30966   proxyIoMethods,           /* sqlcipher3_io_methods object name */
30967   1,                        /* shared memory is disabled */
30968   proxyClose,               /* xClose method */
30969   proxyLock,                /* xLock method */
30970   proxyUnlock,              /* xUnlock method */
30971   proxyCheckReservedLock    /* xCheckReservedLock method */
30972 )
30973 #endif
30974
30975 /* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
30976 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
30977 IOMETHODS(
30978   nfsIoFinder,               /* Finder function name */
30979   nfsIoMethods,              /* sqlcipher3_io_methods object name */
30980   1,                         /* shared memory is disabled */
30981   unixClose,                 /* xClose method */
30982   unixLock,                  /* xLock method */
30983   nfsUnlock,                 /* xUnlock method */
30984   unixCheckReservedLock      /* xCheckReservedLock method */
30985 )
30986 #endif
30987
30988 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
30989 /* 
30990 ** This "finder" function attempts to determine the best locking strategy 
30991 ** for the database file "filePath".  It then returns the sqlcipher3_io_methods
30992 ** object that implements that strategy.
30993 **
30994 ** This is for MacOSX only.
30995 */
30996 static const sqlcipher3_io_methods *autolockIoFinderImpl(
30997   const char *filePath,    /* name of the database file */
30998   unixFile *pNew           /* open file object for the database file */
30999 ){
31000   static const struct Mapping {
31001     const char *zFilesystem;              /* Filesystem type name */
31002     const sqlcipher3_io_methods *pMethods;   /* Appropriate locking method */
31003   } aMap[] = {
31004     { "hfs",    &posixIoMethods },
31005     { "ufs",    &posixIoMethods },
31006     { "afpfs",  &afpIoMethods },
31007     { "smbfs",  &afpIoMethods },
31008     { "webdav", &nolockIoMethods },
31009     { 0, 0 }
31010   };
31011   int i;
31012   struct statfs fsInfo;
31013   struct flock lockInfo;
31014
31015   if( !filePath ){
31016     /* If filePath==NULL that means we are dealing with a transient file
31017     ** that does not need to be locked. */
31018     return &nolockIoMethods;
31019   }
31020   if( statfs(filePath, &fsInfo) != -1 ){
31021     if( fsInfo.f_flags & MNT_RDONLY ){
31022       return &nolockIoMethods;
31023     }
31024     for(i=0; aMap[i].zFilesystem; i++){
31025       if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){
31026         return aMap[i].pMethods;
31027       }
31028     }
31029   }
31030
31031   /* Default case. Handles, amongst others, "nfs".
31032   ** Test byte-range lock using fcntl(). If the call succeeds, 
31033   ** assume that the file-system supports POSIX style locks. 
31034   */
31035   lockInfo.l_len = 1;
31036   lockInfo.l_start = 0;
31037   lockInfo.l_whence = SEEK_SET;
31038   lockInfo.l_type = F_RDLCK;
31039   if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
31040     if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){
31041       return &nfsIoMethods;
31042     } else {
31043       return &posixIoMethods;
31044     }
31045   }else{
31046     return &dotlockIoMethods;
31047   }
31048 }
31049 static const sqlcipher3_io_methods 
31050   *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
31051
31052 #endif /* defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE */
31053
31054 #if OS_VXWORKS && SQLCIPHER_ENABLE_LOCKING_STYLE
31055 /* 
31056 ** This "finder" function attempts to determine the best locking strategy 
31057 ** for the database file "filePath".  It then returns the sqlcipher3_io_methods
31058 ** object that implements that strategy.
31059 **
31060 ** This is for VXWorks only.
31061 */
31062 static const sqlcipher3_io_methods *autolockIoFinderImpl(
31063   const char *filePath,    /* name of the database file */
31064   unixFile *pNew           /* the open file object */
31065 ){
31066   struct flock lockInfo;
31067
31068   if( !filePath ){
31069     /* If filePath==NULL that means we are dealing with a transient file
31070     ** that does not need to be locked. */
31071     return &nolockIoMethods;
31072   }
31073
31074   /* Test if fcntl() is supported and use POSIX style locks.
31075   ** Otherwise fall back to the named semaphore method.
31076   */
31077   lockInfo.l_len = 1;
31078   lockInfo.l_start = 0;
31079   lockInfo.l_whence = SEEK_SET;
31080   lockInfo.l_type = F_RDLCK;
31081   if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
31082     return &posixIoMethods;
31083   }else{
31084     return &semIoMethods;
31085   }
31086 }
31087 static const sqlcipher3_io_methods 
31088   *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
31089
31090 #endif /* OS_VXWORKS && SQLCIPHER_ENABLE_LOCKING_STYLE */
31091
31092 /*
31093 ** An abstract type for a pointer to a IO method finder function:
31094 */
31095 typedef const sqlcipher3_io_methods *(*finder_type)(const char*,unixFile*);
31096
31097
31098 /****************************************************************************
31099 **************************** sqlcipher3_vfs methods ****************************
31100 **
31101 ** This division contains the implementation of methods on the
31102 ** sqlcipher3_vfs object.
31103 */
31104
31105 /*
31106 ** Initialize the contents of the unixFile structure pointed to by pId.
31107 */
31108 static int fillInUnixFile(
31109   sqlcipher3_vfs *pVfs,      /* Pointer to vfs object */
31110   int h,                  /* Open file descriptor of file being opened */
31111   int syncDir,            /* True to sync directory on first sync */
31112   sqlcipher3_file *pId,      /* Write to the unixFile structure here */
31113   const char *zFilename,  /* Name of the file being opened */
31114   int noLock,             /* Omit locking if true */
31115   int isDelete,           /* Delete on close if true */
31116   int isReadOnly          /* True if the file is opened read-only */
31117 ){
31118   const sqlcipher3_io_methods *pLockingStyle;
31119   unixFile *pNew = (unixFile *)pId;
31120   int rc = SQLCIPHER_OK;
31121
31122   assert( pNew->pInode==NULL );
31123
31124   /* Parameter isDelete is only used on vxworks. Express this explicitly 
31125   ** here to prevent compiler warnings about unused parameters.
31126   */
31127   UNUSED_PARAMETER(isDelete);
31128
31129   /* Usually the path zFilename should not be a relative pathname. The
31130   ** exception is when opening the proxy "conch" file in builds that
31131   ** include the special Apple locking styles.
31132   */
31133 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
31134   assert( zFilename==0 || zFilename[0]=='/' 
31135     || pVfs->pAppData==(void*)&autolockIoFinder );
31136 #else
31137   assert( zFilename==0 || zFilename[0]=='/' );
31138 #endif
31139
31140   /* No locking occurs in temporary files */
31141   assert( zFilename!=0 || noLock );
31142
31143   OSTRACE(("OPEN    %-3d %s\n", h, zFilename));
31144   pNew->h = h;
31145   pNew->zPath = zFilename;
31146   if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
31147     pNew->ctrlFlags = UNIXFILE_EXCL;
31148   }else{
31149     pNew->ctrlFlags = 0;
31150   }
31151   if( isReadOnly ){
31152     pNew->ctrlFlags |= UNIXFILE_RDONLY;
31153   }
31154   if( syncDir ){
31155     pNew->ctrlFlags |= UNIXFILE_DIRSYNC;
31156   }
31157
31158 #if OS_VXWORKS
31159   pNew->pId = vxworksFindFileId(zFilename);
31160   if( pNew->pId==0 ){
31161     noLock = 1;
31162     rc = SQLCIPHER_NOMEM;
31163   }
31164 #endif
31165
31166   if( noLock ){
31167     pLockingStyle = &nolockIoMethods;
31168   }else{
31169     pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
31170 #if SQLCIPHER_ENABLE_LOCKING_STYLE
31171     /* Cache zFilename in the locking context (AFP and dotlock override) for
31172     ** proxyLock activation is possible (remote proxy is based on db name)
31173     ** zFilename remains valid until file is closed, to support */
31174     pNew->lockingContext = (void*)zFilename;
31175 #endif
31176   }
31177
31178   if( pLockingStyle == &posixIoMethods
31179 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
31180     || pLockingStyle == &nfsIoMethods
31181 #endif
31182   ){
31183     unixEnterMutex();
31184     rc = findInodeInfo(pNew, &pNew->pInode);
31185     if( rc!=SQLCIPHER_OK ){
31186       /* If an error occured in findInodeInfo(), close the file descriptor
31187       ** immediately, before releasing the mutex. findInodeInfo() may fail
31188       ** in two scenarios:
31189       **
31190       **   (a) A call to fstat() failed.
31191       **   (b) A malloc failed.
31192       **
31193       ** Scenario (b) may only occur if the process is holding no other
31194       ** file descriptors open on the same file. If there were other file
31195       ** descriptors on this file, then no malloc would be required by
31196       ** findInodeInfo(). If this is the case, it is quite safe to close
31197       ** handle h - as it is guaranteed that no posix locks will be released
31198       ** by doing so.
31199       **
31200       ** If scenario (a) caused the error then things are not so safe. The
31201       ** implicit assumption here is that if fstat() fails, things are in
31202       ** such bad shape that dropping a lock or two doesn't matter much.
31203       */
31204       robust_close(pNew, h, __LINE__);
31205       h = -1;
31206     }
31207     unixLeaveMutex();
31208   }
31209
31210 #if SQLCIPHER_ENABLE_LOCKING_STYLE && defined(__APPLE__)
31211   else if( pLockingStyle == &afpIoMethods ){
31212     /* AFP locking uses the file path so it needs to be included in
31213     ** the afpLockingContext.
31214     */
31215     afpLockingContext *pCtx;
31216     pNew->lockingContext = pCtx = sqlcipher3_malloc( sizeof(*pCtx) );
31217     if( pCtx==0 ){
31218       rc = SQLCIPHER_NOMEM;
31219     }else{
31220       /* NB: zFilename exists and remains valid until the file is closed
31221       ** according to requirement F11141.  So we do not need to make a
31222       ** copy of the filename. */
31223       pCtx->dbPath = zFilename;
31224       pCtx->reserved = 0;
31225       srandomdev();
31226       unixEnterMutex();
31227       rc = findInodeInfo(pNew, &pNew->pInode);
31228       if( rc!=SQLCIPHER_OK ){
31229         sqlcipher3_free(pNew->lockingContext);
31230         robust_close(pNew, h, __LINE__);
31231         h = -1;
31232       }
31233       unixLeaveMutex();        
31234     }
31235   }
31236 #endif
31237
31238   else if( pLockingStyle == &dotlockIoMethods ){
31239     /* Dotfile locking uses the file path so it needs to be included in
31240     ** the dotlockLockingContext 
31241     */
31242     char *zLockFile;
31243     int nFilename;
31244     assert( zFilename!=0 );
31245     nFilename = (int)strlen(zFilename) + 6;
31246     zLockFile = (char *)sqlcipher3_malloc(nFilename);
31247     if( zLockFile==0 ){
31248       rc = SQLCIPHER_NOMEM;
31249     }else{
31250       sqlcipher3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
31251     }
31252     pNew->lockingContext = zLockFile;
31253   }
31254
31255 #if OS_VXWORKS
31256   else if( pLockingStyle == &semIoMethods ){
31257     /* Named semaphore locking uses the file path so it needs to be
31258     ** included in the semLockingContext
31259     */
31260     unixEnterMutex();
31261     rc = findInodeInfo(pNew, &pNew->pInode);
31262     if( (rc==SQLCIPHER_OK) && (pNew->pInode->pSem==NULL) ){
31263       char *zSemName = pNew->pInode->aSemName;
31264       int n;
31265       sqlcipher3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
31266                        pNew->pId->zCanonicalName);
31267       for( n=1; zSemName[n]; n++ )
31268         if( zSemName[n]=='/' ) zSemName[n] = '_';
31269       pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
31270       if( pNew->pInode->pSem == SEM_FAILED ){
31271         rc = SQLCIPHER_NOMEM;
31272         pNew->pInode->aSemName[0] = '\0';
31273       }
31274     }
31275     unixLeaveMutex();
31276   }
31277 #endif
31278   
31279   pNew->lastErrno = 0;
31280 #if OS_VXWORKS
31281   if( rc!=SQLCIPHER_OK ){
31282     if( h>=0 ) robust_close(pNew, h, __LINE__);
31283     h = -1;
31284     osUnlink(zFilename);
31285     isDelete = 0;
31286   }
31287   pNew->isDelete = isDelete;
31288 #endif
31289   if( rc!=SQLCIPHER_OK ){
31290     if( h>=0 ) robust_close(pNew, h, __LINE__);
31291   }else{
31292     pNew->pMethod = pLockingStyle;
31293     OpenCounter(+1);
31294   }
31295   return rc;
31296 }
31297
31298 /*
31299 ** Return the name of a directory in which to put temporary files.
31300 ** If no suitable temporary file directory can be found, return NULL.
31301 */
31302 static const char *unixTempFileDir(void){
31303   static const char *azDirs[] = {
31304      0,
31305      0,
31306      "/var/tmp",
31307      "/usr/tmp",
31308      "/tmp",
31309      0        /* List terminator */
31310   };
31311   unsigned int i;
31312   struct stat buf;
31313   const char *zDir = 0;
31314
31315   azDirs[0] = sqlcipher3_temp_directory;
31316   if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR");
31317   for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
31318     if( zDir==0 ) continue;
31319     if( osStat(zDir, &buf) ) continue;
31320     if( !S_ISDIR(buf.st_mode) ) continue;
31321     if( osAccess(zDir, 07) ) continue;
31322     break;
31323   }
31324   return zDir;
31325 }
31326
31327 /*
31328 ** Create a temporary file name in zBuf.  zBuf must be allocated
31329 ** by the calling process and must be big enough to hold at least
31330 ** pVfs->mxPathname bytes.
31331 */
31332 static int unixGetTempname(int nBuf, char *zBuf){
31333   static const unsigned char zChars[] =
31334     "abcdefghijklmnopqrstuvwxyz"
31335     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
31336     "0123456789";
31337   unsigned int i, j;
31338   const char *zDir;
31339
31340   /* It's odd to simulate an io-error here, but really this is just
31341   ** using the io-error infrastructure to test that SQLite handles this
31342   ** function failing. 
31343   */
31344   SimulateIOError( return SQLCIPHER_IOERR );
31345
31346   zDir = unixTempFileDir();
31347   if( zDir==0 ) zDir = ".";
31348
31349   /* Check that the output buffer is large enough for the temporary file 
31350   ** name. If it is not, return SQLCIPHER_ERROR.
31351   */
31352   if( (strlen(zDir) + strlen(SQLCIPHER_TEMP_FILE_PREFIX) + 17) >= (size_t)nBuf ){
31353     return SQLCIPHER_ERROR;
31354   }
31355
31356   do{
31357     sqlcipher3_snprintf(nBuf-17, zBuf, "%s/"SQLCIPHER_TEMP_FILE_PREFIX, zDir);
31358     j = (int)strlen(zBuf);
31359     sqlcipher3_randomness(15, &zBuf[j]);
31360     for(i=0; i<15; i++, j++){
31361       zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
31362     }
31363     zBuf[j] = 0;
31364   }while( osAccess(zBuf,0)==0 );
31365   return SQLCIPHER_OK;
31366 }
31367
31368 #if SQLCIPHER_ENABLE_LOCKING_STYLE && defined(__APPLE__)
31369 /*
31370 ** Routine to transform a unixFile into a proxy-locking unixFile.
31371 ** Implementation in the proxy-lock division, but used by unixOpen()
31372 ** if SQLCIPHER_PREFER_PROXY_LOCKING is defined.
31373 */
31374 static int proxyTransformUnixFile(unixFile*, const char*);
31375 #endif
31376
31377 /*
31378 ** Search for an unused file descriptor that was opened on the database 
31379 ** file (not a journal or master-journal file) identified by pathname
31380 ** zPath with SQLCIPHER_OPEN_XXX flags matching those passed as the second
31381 ** argument to this function.
31382 **
31383 ** Such a file descriptor may exist if a database connection was closed
31384 ** but the associated file descriptor could not be closed because some
31385 ** other file descriptor open on the same file is holding a file-lock.
31386 ** Refer to comments in the unixClose() function and the lengthy comment
31387 ** describing "Posix Advisory Locking" at the start of this file for 
31388 ** further details. Also, ticket #4018.
31389 **
31390 ** If a suitable file descriptor is found, then it is returned. If no
31391 ** such file descriptor is located, -1 is returned.
31392 */
31393 static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
31394   UnixUnusedFd *pUnused = 0;
31395
31396   /* Do not search for an unused file descriptor on vxworks. Not because
31397   ** vxworks would not benefit from the change (it might, we're not sure),
31398   ** but because no way to test it is currently available. It is better 
31399   ** not to risk breaking vxworks support for the sake of such an obscure 
31400   ** feature.  */
31401 #if !OS_VXWORKS
31402   struct stat sStat;                   /* Results of stat() call */
31403
31404   /* A stat() call may fail for various reasons. If this happens, it is
31405   ** almost certain that an open() call on the same path will also fail.
31406   ** For this reason, if an error occurs in the stat() call here, it is
31407   ** ignored and -1 is returned. The caller will try to open a new file
31408   ** descriptor on the same path, fail, and return an error to SQLite.
31409   **
31410   ** Even if a subsequent open() call does succeed, the consequences of
31411   ** not searching for a resusable file descriptor are not dire.  */
31412   if( 0==osStat(zPath, &sStat) ){
31413     unixInodeInfo *pInode;
31414
31415     unixEnterMutex();
31416     pInode = inodeList;
31417     while( pInode && (pInode->fileId.dev!=sStat.st_dev
31418                      || pInode->fileId.ino!=sStat.st_ino) ){
31419        pInode = pInode->pNext;
31420     }
31421     if( pInode ){
31422       UnixUnusedFd **pp;
31423       for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
31424       pUnused = *pp;
31425       if( pUnused ){
31426         *pp = pUnused->pNext;
31427       }
31428     }
31429     unixLeaveMutex();
31430   }
31431 #endif    /* if !OS_VXWORKS */
31432   return pUnused;
31433 }
31434
31435 /*
31436 ** This function is called by unixOpen() to determine the unix permissions
31437 ** to create new files with. If no error occurs, then SQLCIPHER_OK is returned
31438 ** and a value suitable for passing as the third argument to open(2) is
31439 ** written to *pMode. If an IO error occurs, an SQLite error code is 
31440 ** returned and the value of *pMode is not modified.
31441 **
31442 ** If the file being opened is a temporary file, it is always created with
31443 ** the octal permissions 0600 (read/writable by owner only). If the file
31444 ** is a database or master journal file, it is created with the permissions 
31445 ** mask SQLCIPHER_DEFAULT_FILE_PERMISSIONS.
31446 **
31447 ** Finally, if the file being opened is a WAL or regular journal file, then 
31448 ** this function queries the file-system for the permissions on the 
31449 ** corresponding database file and sets *pMode to this value. Whenever 
31450 ** possible, WAL and journal files are created using the same permissions 
31451 ** as the associated database file.
31452 **
31453 ** If the SQLCIPHER_ENABLE_8_3_NAMES option is enabled, then the
31454 ** original filename is unavailable.  But 8_3_NAMES is only used for
31455 ** FAT filesystems and permissions do not matter there, so just use
31456 ** the default permissions.
31457 */
31458 static int findCreateFileMode(
31459   const char *zPath,              /* Path of file (possibly) being created */
31460   int flags,                      /* Flags passed as 4th argument to xOpen() */
31461   mode_t *pMode                   /* OUT: Permissions to open file with */
31462 ){
31463   int rc = SQLCIPHER_OK;             /* Return Code */
31464   *pMode = SQLCIPHER_DEFAULT_FILE_PERMISSIONS;
31465   if( flags & (SQLCIPHER_OPEN_WAL|SQLCIPHER_OPEN_MAIN_JOURNAL) ){
31466     char zDb[MAX_PATHNAME+1];     /* Database file path */
31467     int nDb;                      /* Number of valid bytes in zDb */
31468     struct stat sStat;            /* Output of stat() on database file */
31469
31470     /* zPath is a path to a WAL or journal file. The following block derives
31471     ** the path to the associated database file from zPath. This block handles
31472     ** the following naming conventions:
31473     **
31474     **   "<path to db>-journal"
31475     **   "<path to db>-wal"
31476     **   "<path to db>-journalNN"
31477     **   "<path to db>-walNN"
31478     **
31479     ** where NN is a decimal number. The NN naming schemes are 
31480     ** used by the test_multiplex.c module.
31481     */
31482     nDb = sqlcipher3Strlen30(zPath) - 1; 
31483 #ifdef SQLCIPHER_ENABLE_8_3_NAMES
31484     while( nDb>0 && !sqlcipher3Isalnum(zPath[nDb]) ) nDb--;
31485     if( nDb==0 || zPath[nDb]!='-' ) return SQLCIPHER_OK;
31486 #else
31487     while( zPath[nDb]!='-' ){
31488       assert( nDb>0 );
31489       assert( zPath[nDb]!='\n' );
31490       nDb--;
31491     }
31492 #endif
31493     memcpy(zDb, zPath, nDb);
31494     zDb[nDb] = '\0';
31495
31496     if( 0==osStat(zDb, &sStat) ){
31497       *pMode = sStat.st_mode & 0777;
31498     }else{
31499       rc = SQLCIPHER_IOERR_FSTAT;
31500     }
31501   }else if( flags & SQLCIPHER_OPEN_DELETEONCLOSE ){
31502     *pMode = 0600;
31503   }
31504   return rc;
31505 }
31506
31507 /*
31508 ** Open the file zPath.
31509 ** 
31510 ** Previously, the SQLite OS layer used three functions in place of this
31511 ** one:
31512 **
31513 **     sqlcipher3OsOpenReadWrite();
31514 **     sqlcipher3OsOpenReadOnly();
31515 **     sqlcipher3OsOpenExclusive();
31516 **
31517 ** These calls correspond to the following combinations of flags:
31518 **
31519 **     ReadWrite() ->     (READWRITE | CREATE)
31520 **     ReadOnly()  ->     (READONLY) 
31521 **     OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
31522 **
31523 ** The old OpenExclusive() accepted a boolean argument - "delFlag". If
31524 ** true, the file was configured to be automatically deleted when the
31525 ** file handle closed. To achieve the same effect using this new 
31526 ** interface, add the DELETEONCLOSE flag to those specified above for 
31527 ** OpenExclusive().
31528 */
31529 static int unixOpen(
31530   sqlcipher3_vfs *pVfs,           /* The VFS for which this is the xOpen method */
31531   const char *zPath,           /* Pathname of file to be opened */
31532   sqlcipher3_file *pFile,         /* The file descriptor to be filled in */
31533   int flags,                   /* Input flags to control the opening */
31534   int *pOutFlags               /* Output flags returned to SQLite core */
31535 ){
31536   unixFile *p = (unixFile *)pFile;
31537   int fd = -1;                   /* File descriptor returned by open() */
31538   int openFlags = 0;             /* Flags to pass to open() */
31539   int eType = flags&0xFFFFFF00;  /* Type of file to open */
31540   int noLock;                    /* True to omit locking primitives */
31541   int rc = SQLCIPHER_OK;            /* Function Return Code */
31542
31543   int isExclusive  = (flags & SQLCIPHER_OPEN_EXCLUSIVE);
31544   int isDelete     = (flags & SQLCIPHER_OPEN_DELETEONCLOSE);
31545   int isCreate     = (flags & SQLCIPHER_OPEN_CREATE);
31546   int isReadonly   = (flags & SQLCIPHER_OPEN_READONLY);
31547   int isReadWrite  = (flags & SQLCIPHER_OPEN_READWRITE);
31548 #if SQLCIPHER_ENABLE_LOCKING_STYLE
31549   int isAutoProxy  = (flags & SQLCIPHER_OPEN_AUTOPROXY);
31550 #endif
31551 #if defined(__APPLE__) || SQLCIPHER_ENABLE_LOCKING_STYLE
31552   struct statfs fsInfo;
31553 #endif
31554
31555   /* If creating a master or main-file journal, this function will open
31556   ** a file-descriptor on the directory too. The first time unixSync()
31557   ** is called the directory file descriptor will be fsync()ed and close()d.
31558   */
31559   int syncDir = (isCreate && (
31560         eType==SQLCIPHER_OPEN_MASTER_JOURNAL 
31561      || eType==SQLCIPHER_OPEN_MAIN_JOURNAL 
31562      || eType==SQLCIPHER_OPEN_WAL
31563   ));
31564
31565   /* If argument zPath is a NULL pointer, this function is required to open
31566   ** a temporary file. Use this buffer to store the file name in.
31567   */
31568   char zTmpname[MAX_PATHNAME+1];
31569   const char *zName = zPath;
31570
31571   /* Check the following statements are true: 
31572   **
31573   **   (a) Exactly one of the READWRITE and READONLY flags must be set, and 
31574   **   (b) if CREATE is set, then READWRITE must also be set, and
31575   **   (c) if EXCLUSIVE is set, then CREATE must also be set.
31576   **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
31577   */
31578   assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
31579   assert(isCreate==0 || isReadWrite);
31580   assert(isExclusive==0 || isCreate);
31581   assert(isDelete==0 || isCreate);
31582
31583   /* The main DB, main journal, WAL file and master journal are never 
31584   ** automatically deleted. Nor are they ever temporary files.  */
31585   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MAIN_DB );
31586   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MAIN_JOURNAL );
31587   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MASTER_JOURNAL );
31588   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_WAL );
31589
31590   /* Assert that the upper layer has set one of the "file-type" flags. */
31591   assert( eType==SQLCIPHER_OPEN_MAIN_DB      || eType==SQLCIPHER_OPEN_TEMP_DB 
31592        || eType==SQLCIPHER_OPEN_MAIN_JOURNAL || eType==SQLCIPHER_OPEN_TEMP_JOURNAL 
31593        || eType==SQLCIPHER_OPEN_SUBJOURNAL   || eType==SQLCIPHER_OPEN_MASTER_JOURNAL 
31594        || eType==SQLCIPHER_OPEN_TRANSIENT_DB || eType==SQLCIPHER_OPEN_WAL
31595   );
31596
31597   memset(p, 0, sizeof(unixFile));
31598
31599   if( eType==SQLCIPHER_OPEN_MAIN_DB ){
31600     UnixUnusedFd *pUnused;
31601     pUnused = findReusableFd(zName, flags);
31602     if( pUnused ){
31603       fd = pUnused->fd;
31604     }else{
31605       pUnused = sqlcipher3_malloc(sizeof(*pUnused));
31606       if( !pUnused ){
31607         return SQLCIPHER_NOMEM;
31608       }
31609     }
31610     p->pUnused = pUnused;
31611   }else if( !zName ){
31612     /* If zName is NULL, the upper layer is requesting a temp file. */
31613     assert(isDelete && !syncDir);
31614     rc = unixGetTempname(MAX_PATHNAME+1, zTmpname);
31615     if( rc!=SQLCIPHER_OK ){
31616       return rc;
31617     }
31618     zName = zTmpname;
31619   }
31620
31621   /* Determine the value of the flags parameter passed to POSIX function
31622   ** open(). These must be calculated even if open() is not called, as
31623   ** they may be stored as part of the file handle and used by the 
31624   ** 'conch file' locking functions later on.  */
31625   if( isReadonly )  openFlags |= O_RDONLY;
31626   if( isReadWrite ) openFlags |= O_RDWR;
31627   if( isCreate )    openFlags |= O_CREAT;
31628   if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
31629   openFlags |= (O_LARGEFILE|O_BINARY);
31630
31631   if( fd<0 ){
31632     mode_t openMode;              /* Permissions to create file with */
31633     rc = findCreateFileMode(zName, flags, &openMode);
31634     if( rc!=SQLCIPHER_OK ){
31635       assert( !p->pUnused );
31636       assert( eType==SQLCIPHER_OPEN_WAL || eType==SQLCIPHER_OPEN_MAIN_JOURNAL );
31637       return rc;
31638     }
31639     fd = robust_open(zName, openFlags, openMode);
31640     OSTRACE(("OPENX   %-3d %s 0%o\n", fd, zName, openFlags));
31641     if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
31642       /* Failed to open the file for read/write access. Try read-only. */
31643       flags &= ~(SQLCIPHER_OPEN_READWRITE|SQLCIPHER_OPEN_CREATE);
31644       openFlags &= ~(O_RDWR|O_CREAT);
31645       flags |= SQLCIPHER_OPEN_READONLY;
31646       openFlags |= O_RDONLY;
31647       isReadonly = 1;
31648       fd = robust_open(zName, openFlags, openMode);
31649     }
31650     if( fd<0 ){
31651       rc = unixLogError(SQLCIPHER_CANTOPEN_BKPT, "open", zName);
31652       goto open_finished;
31653     }
31654   }
31655   assert( fd>=0 );
31656   if( pOutFlags ){
31657     *pOutFlags = flags;
31658   }
31659
31660   if( p->pUnused ){
31661     p->pUnused->fd = fd;
31662     p->pUnused->flags = flags;
31663   }
31664
31665   if( isDelete ){
31666 #if OS_VXWORKS
31667     zPath = zName;
31668 #else
31669     osUnlink(zName);
31670 #endif
31671   }
31672 #if SQLCIPHER_ENABLE_LOCKING_STYLE
31673   else{
31674     p->openFlags = openFlags;
31675   }
31676 #endif
31677
31678 #ifdef FD_CLOEXEC
31679   osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
31680 #endif
31681
31682   noLock = eType!=SQLCIPHER_OPEN_MAIN_DB;
31683
31684   
31685 #if defined(__APPLE__) || SQLCIPHER_ENABLE_LOCKING_STYLE
31686   if( fstatfs(fd, &fsInfo) == -1 ){
31687     ((unixFile*)pFile)->lastErrno = errno;
31688     robust_close(p, fd, __LINE__);
31689     return SQLCIPHER_IOERR_ACCESS;
31690   }
31691   if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
31692     ((unixFile*)pFile)->fsFlags |= SQLCIPHER_FSFLAGS_IS_MSDOS;
31693   }
31694 #endif
31695   
31696 #if SQLCIPHER_ENABLE_LOCKING_STYLE
31697 #if SQLCIPHER_PREFER_PROXY_LOCKING
31698   isAutoProxy = 1;
31699 #endif
31700   if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
31701     char *envforce = getenv("SQLCIPHER_FORCE_PROXY_LOCKING");
31702     int useProxy = 0;
31703
31704     /* SQLCIPHER_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means 
31705     ** never use proxy, NULL means use proxy for non-local files only.  */
31706     if( envforce!=NULL ){
31707       useProxy = atoi(envforce)>0;
31708     }else{
31709       if( statfs(zPath, &fsInfo) == -1 ){
31710         /* In theory, the close(fd) call is sub-optimal. If the file opened
31711         ** with fd is a database file, and there are other connections open
31712         ** on that file that are currently holding advisory locks on it,
31713         ** then the call to close() will cancel those locks. In practice,
31714         ** we're assuming that statfs() doesn't fail very often. At least
31715         ** not while other file descriptors opened by the same process on
31716         ** the same file are working.  */
31717         p->lastErrno = errno;
31718         robust_close(p, fd, __LINE__);
31719         rc = SQLCIPHER_IOERR_ACCESS;
31720         goto open_finished;
31721       }
31722       useProxy = !(fsInfo.f_flags&MNT_LOCAL);
31723     }
31724     if( useProxy ){
31725       rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
31726                           isDelete, isReadonly);
31727       if( rc==SQLCIPHER_OK ){
31728         rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
31729         if( rc!=SQLCIPHER_OK ){
31730           /* Use unixClose to clean up the resources added in fillInUnixFile 
31731           ** and clear all the structure's references.  Specifically, 
31732           ** pFile->pMethods will be NULL so sqlcipher3OsClose will be a no-op 
31733           */
31734           unixClose(pFile);
31735           return rc;
31736         }
31737       }
31738       goto open_finished;
31739     }
31740   }
31741 #endif
31742   
31743   rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
31744                       isDelete, isReadonly);
31745 open_finished:
31746   if( rc!=SQLCIPHER_OK ){
31747     sqlcipher3_free(p->pUnused);
31748   }
31749   return rc;
31750 }
31751
31752
31753 /*
31754 ** Delete the file at zPath. If the dirSync argument is true, fsync()
31755 ** the directory after deleting the file.
31756 */
31757 static int unixDelete(
31758   sqlcipher3_vfs *NotUsed,     /* VFS containing this as the xDelete method */
31759   const char *zPath,        /* Name of file to be deleted */
31760   int dirSync               /* If true, fsync() directory after deleting file */
31761 ){
31762   int rc = SQLCIPHER_OK;
31763   UNUSED_PARAMETER(NotUsed);
31764   SimulateIOError(return SQLCIPHER_IOERR_DELETE);
31765   if( osUnlink(zPath)==(-1) && errno!=ENOENT ){
31766     return unixLogError(SQLCIPHER_IOERR_DELETE, "unlink", zPath);
31767   }
31768 #ifndef SQLCIPHER_DISABLE_DIRSYNC
31769   if( dirSync ){
31770     int fd;
31771     rc = osOpenDirectory(zPath, &fd);
31772     if( rc==SQLCIPHER_OK ){
31773 #if OS_VXWORKS
31774       if( fsync(fd)==-1 )
31775 #else
31776       if( fsync(fd) )
31777 #endif
31778       {
31779         rc = unixLogError(SQLCIPHER_IOERR_DIR_FSYNC, "fsync", zPath);
31780       }
31781       robust_close(0, fd, __LINE__);
31782     }else if( rc==SQLCIPHER_CANTOPEN ){
31783       rc = SQLCIPHER_OK;
31784     }
31785   }
31786 #endif
31787   return rc;
31788 }
31789
31790 /*
31791 ** Test the existance of or access permissions of file zPath. The
31792 ** test performed depends on the value of flags:
31793 **
31794 **     SQLCIPHER_ACCESS_EXISTS: Return 1 if the file exists
31795 **     SQLCIPHER_ACCESS_READWRITE: Return 1 if the file is read and writable.
31796 **     SQLCIPHER_ACCESS_READONLY: Return 1 if the file is readable.
31797 **
31798 ** Otherwise return 0.
31799 */
31800 static int unixAccess(
31801   sqlcipher3_vfs *NotUsed,   /* The VFS containing this xAccess method */
31802   const char *zPath,      /* Path of the file to examine */
31803   int flags,              /* What do we want to learn about the zPath file? */
31804   int *pResOut            /* Write result boolean here */
31805 ){
31806   int amode = 0;
31807   UNUSED_PARAMETER(NotUsed);
31808   SimulateIOError( return SQLCIPHER_IOERR_ACCESS; );
31809   switch( flags ){
31810     case SQLCIPHER_ACCESS_EXISTS:
31811       amode = F_OK;
31812       break;
31813     case SQLCIPHER_ACCESS_READWRITE:
31814       amode = W_OK|R_OK;
31815       break;
31816     case SQLCIPHER_ACCESS_READ:
31817       amode = R_OK;
31818       break;
31819
31820     default:
31821       assert(!"Invalid flags argument");
31822   }
31823   *pResOut = (osAccess(zPath, amode)==0);
31824   if( flags==SQLCIPHER_ACCESS_EXISTS && *pResOut ){
31825     struct stat buf;
31826     if( 0==osStat(zPath, &buf) && buf.st_size==0 ){
31827       *pResOut = 0;
31828     }
31829   }
31830   return SQLCIPHER_OK;
31831 }
31832
31833
31834 /*
31835 ** Turn a relative pathname into a full pathname. The relative path
31836 ** is stored as a nul-terminated string in the buffer pointed to by
31837 ** zPath. 
31838 **
31839 ** zOut points to a buffer of at least sqlcipher3_vfs.mxPathname bytes 
31840 ** (in this case, MAX_PATHNAME bytes). The full-path is written to
31841 ** this buffer before returning.
31842 */
31843 static int unixFullPathname(
31844   sqlcipher3_vfs *pVfs,            /* Pointer to vfs object */
31845   const char *zPath,            /* Possibly relative input path */
31846   int nOut,                     /* Size of output buffer in bytes */
31847   char *zOut                    /* Output buffer */
31848 ){
31849
31850   /* It's odd to simulate an io-error here, but really this is just
31851   ** using the io-error infrastructure to test that SQLite handles this
31852   ** function failing. This function could fail if, for example, the
31853   ** current working directory has been unlinked.
31854   */
31855   SimulateIOError( return SQLCIPHER_ERROR );
31856
31857   assert( pVfs->mxPathname==MAX_PATHNAME );
31858   UNUSED_PARAMETER(pVfs);
31859
31860   zOut[nOut-1] = '\0';
31861   if( zPath[0]=='/' ){
31862     sqlcipher3_snprintf(nOut, zOut, "%s", zPath);
31863   }else{
31864     int nCwd;
31865     if( osGetcwd(zOut, nOut-1)==0 ){
31866       return unixLogError(SQLCIPHER_CANTOPEN_BKPT, "getcwd", zPath);
31867     }
31868     nCwd = (int)strlen(zOut);
31869     sqlcipher3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
31870   }
31871   return SQLCIPHER_OK;
31872 }
31873
31874
31875 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
31876 /*
31877 ** Interfaces for opening a shared library, finding entry points
31878 ** within the shared library, and closing the shared library.
31879 */
31880 #include <dlfcn.h>
31881 static void *unixDlOpen(sqlcipher3_vfs *NotUsed, const char *zFilename){
31882   UNUSED_PARAMETER(NotUsed);
31883   return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
31884 }
31885
31886 /*
31887 ** SQLite calls this function immediately after a call to unixDlSym() or
31888 ** unixDlOpen() fails (returns a null pointer). If a more detailed error
31889 ** message is available, it is written to zBufOut. If no error message
31890 ** is available, zBufOut is left unmodified and SQLite uses a default
31891 ** error message.
31892 */
31893 static void unixDlError(sqlcipher3_vfs *NotUsed, int nBuf, char *zBufOut){
31894   const char *zErr;
31895   UNUSED_PARAMETER(NotUsed);
31896   unixEnterMutex();
31897   zErr = dlerror();
31898   if( zErr ){
31899     sqlcipher3_snprintf(nBuf, zBufOut, "%s", zErr);
31900   }
31901   unixLeaveMutex();
31902 }
31903 static void (*unixDlSym(sqlcipher3_vfs *NotUsed, void *p, const char*zSym))(void){
31904   /* 
31905   ** GCC with -pedantic-errors says that C90 does not allow a void* to be
31906   ** cast into a pointer to a function.  And yet the library dlsym() routine
31907   ** returns a void* which is really a pointer to a function.  So how do we
31908   ** use dlsym() with -pedantic-errors?
31909   **
31910   ** Variable x below is defined to be a pointer to a function taking
31911   ** parameters void* and const char* and returning a pointer to a function.
31912   ** We initialize x by assigning it a pointer to the dlsym() function.
31913   ** (That assignment requires a cast.)  Then we call the function that
31914   ** x points to.  
31915   **
31916   ** This work-around is unlikely to work correctly on any system where
31917   ** you really cannot cast a function pointer into void*.  But then, on the
31918   ** other hand, dlsym() will not work on such a system either, so we have
31919   ** not really lost anything.
31920   */
31921   void (*(*x)(void*,const char*))(void);
31922   UNUSED_PARAMETER(NotUsed);
31923   x = (void(*(*)(void*,const char*))(void))dlsym;
31924   return (*x)(p, zSym);
31925 }
31926 static void unixDlClose(sqlcipher3_vfs *NotUsed, void *pHandle){
31927   UNUSED_PARAMETER(NotUsed);
31928   dlclose(pHandle);
31929 }
31930 #else /* if SQLCIPHER_OMIT_LOAD_EXTENSION is defined: */
31931   #define unixDlOpen  0
31932   #define unixDlError 0
31933   #define unixDlSym   0
31934   #define unixDlClose 0
31935 #endif
31936
31937 /*
31938 ** Write nBuf bytes of random data to the supplied buffer zBuf.
31939 */
31940 static int unixRandomness(sqlcipher3_vfs *NotUsed, int nBuf, char *zBuf){
31941   UNUSED_PARAMETER(NotUsed);
31942   assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
31943
31944   /* We have to initialize zBuf to prevent valgrind from reporting
31945   ** errors.  The reports issued by valgrind are incorrect - we would
31946   ** prefer that the randomness be increased by making use of the
31947   ** uninitialized space in zBuf - but valgrind errors tend to worry
31948   ** some users.  Rather than argue, it seems easier just to initialize
31949   ** the whole array and silence valgrind, even if that means less randomness
31950   ** in the random seed.
31951   **
31952   ** When testing, initializing zBuf[] to zero is all we do.  That means
31953   ** that we always use the same random number sequence.  This makes the
31954   ** tests repeatable.
31955   */
31956   memset(zBuf, 0, nBuf);
31957 #if !defined(SQLCIPHER_TEST)
31958   {
31959     int pid, fd;
31960     fd = robust_open("/dev/urandom", O_RDONLY, 0);
31961     if( fd<0 ){
31962       time_t t;
31963       time(&t);
31964       memcpy(zBuf, &t, sizeof(t));
31965       pid = getpid();
31966       memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
31967       assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
31968       nBuf = sizeof(t) + sizeof(pid);
31969     }else{
31970       do{ nBuf = osRead(fd, zBuf, nBuf); }while( nBuf<0 && errno==EINTR );
31971       robust_close(0, fd, __LINE__);
31972     }
31973   }
31974 #endif
31975   return nBuf;
31976 }
31977
31978
31979 /*
31980 ** Sleep for a little while.  Return the amount of time slept.
31981 ** The argument is the number of microseconds we want to sleep.
31982 ** The return value is the number of microseconds of sleep actually
31983 ** requested from the underlying operating system, a number which
31984 ** might be greater than or equal to the argument, but not less
31985 ** than the argument.
31986 */
31987 static int unixSleep(sqlcipher3_vfs *NotUsed, int microseconds){
31988 #if OS_VXWORKS
31989   struct timespec sp;
31990
31991   sp.tv_sec = microseconds / 1000000;
31992   sp.tv_nsec = (microseconds % 1000000) * 1000;
31993   nanosleep(&sp, NULL);
31994   UNUSED_PARAMETER(NotUsed);
31995   return microseconds;
31996 #elif defined(HAVE_USLEEP) && HAVE_USLEEP
31997   usleep(microseconds);
31998   UNUSED_PARAMETER(NotUsed);
31999   return microseconds;
32000 #else
32001   int seconds = (microseconds+999999)/1000000;
32002   sleep(seconds);
32003   UNUSED_PARAMETER(NotUsed);
32004   return seconds*1000000;
32005 #endif
32006 }
32007
32008 /*
32009 ** The following variable, if set to a non-zero value, is interpreted as
32010 ** the number of seconds since 1970 and is used to set the result of
32011 ** sqlcipher3OsCurrentTime() during testing.
32012 */
32013 #ifdef SQLCIPHER_TEST
32014 SQLCIPHER_API int sqlcipher3_current_time = 0;  /* Fake system time in seconds since 1970. */
32015 #endif
32016
32017 /*
32018 ** Find the current time (in Universal Coordinated Time).  Write into *piNow
32019 ** the current time and date as a Julian Day number times 86_400_000.  In
32020 ** other words, write into *piNow the number of milliseconds since the Julian
32021 ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
32022 ** proleptic Gregorian calendar.
32023 **
32024 ** On success, return SQLCIPHER_OK.  Return SQLCIPHER_ERROR if the time and date 
32025 ** cannot be found.
32026 */
32027 static int unixCurrentTimeInt64(sqlcipher3_vfs *NotUsed, sqlcipher3_int64 *piNow){
32028   static const sqlcipher3_int64 unixEpoch = 24405875*(sqlcipher3_int64)8640000;
32029   int rc = SQLCIPHER_OK;
32030 #if defined(NO_GETTOD)
32031   time_t t;
32032   time(&t);
32033   *piNow = ((sqlcipher3_int64)t)*1000 + unixEpoch;
32034 #elif OS_VXWORKS
32035   struct timespec sNow;
32036   clock_gettime(CLOCK_REALTIME, &sNow);
32037   *piNow = unixEpoch + 1000*(sqlcipher3_int64)sNow.tv_sec + sNow.tv_nsec/1000000;
32038 #else
32039   struct timeval sNow;
32040   if( gettimeofday(&sNow, 0)==0 ){
32041     *piNow = unixEpoch + 1000*(sqlcipher3_int64)sNow.tv_sec + sNow.tv_usec/1000;
32042   }else{
32043     rc = SQLCIPHER_ERROR;
32044   }
32045 #endif
32046
32047 #ifdef SQLCIPHER_TEST
32048   if( sqlcipher3_current_time ){
32049     *piNow = 1000*(sqlcipher3_int64)sqlcipher3_current_time + unixEpoch;
32050   }
32051 #endif
32052   UNUSED_PARAMETER(NotUsed);
32053   return rc;
32054 }
32055
32056 /*
32057 ** Find the current time (in Universal Coordinated Time).  Write the
32058 ** current time and date as a Julian Day number into *prNow and
32059 ** return 0.  Return 1 if the time and date cannot be found.
32060 */
32061 static int unixCurrentTime(sqlcipher3_vfs *NotUsed, double *prNow){
32062   sqlcipher3_int64 i = 0;
32063   int rc;
32064   UNUSED_PARAMETER(NotUsed);
32065   rc = unixCurrentTimeInt64(0, &i);
32066   *prNow = i/86400000.0;
32067   return rc;
32068 }
32069
32070 /*
32071 ** We added the xGetLastError() method with the intention of providing
32072 ** better low-level error messages when operating-system problems come up
32073 ** during SQLite operation.  But so far, none of that has been implemented
32074 ** in the core.  So this routine is never called.  For now, it is merely
32075 ** a place-holder.
32076 */
32077 static int unixGetLastError(sqlcipher3_vfs *NotUsed, int NotUsed2, char *NotUsed3){
32078   UNUSED_PARAMETER(NotUsed);
32079   UNUSED_PARAMETER(NotUsed2);
32080   UNUSED_PARAMETER(NotUsed3);
32081   return 0;
32082 }
32083
32084
32085 /*
32086 ************************ End of sqlcipher3_vfs methods ***************************
32087 ******************************************************************************/
32088
32089 /******************************************************************************
32090 ************************** Begin Proxy Locking ********************************
32091 **
32092 ** Proxy locking is a "uber-locking-method" in this sense:  It uses the
32093 ** other locking methods on secondary lock files.  Proxy locking is a
32094 ** meta-layer over top of the primitive locking implemented above.  For
32095 ** this reason, the division that implements of proxy locking is deferred
32096 ** until late in the file (here) after all of the other I/O methods have
32097 ** been defined - so that the primitive locking methods are available
32098 ** as services to help with the implementation of proxy locking.
32099 **
32100 ****
32101 **
32102 ** The default locking schemes in SQLite use byte-range locks on the
32103 ** database file to coordinate safe, concurrent access by multiple readers
32104 ** and writers [http://sqlcipher.org/lockingv3.html].  The five file locking
32105 ** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented
32106 ** as POSIX read & write locks over fixed set of locations (via fsctl),
32107 ** on AFP and SMB only exclusive byte-range locks are available via fsctl
32108 ** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states.
32109 ** To simulate a F_RDLCK on the shared range, on AFP a randomly selected
32110 ** address in the shared range is taken for a SHARED lock, the entire
32111 ** shared range is taken for an EXCLUSIVE lock):
32112 **
32113 **      PENDING_BYTE        0x40000000                  
32114 **      RESERVED_BYTE       0x40000001
32115 **      SHARED_RANGE        0x40000002 -> 0x40000200
32116 **
32117 ** This works well on the local file system, but shows a nearly 100x
32118 ** slowdown in read performance on AFP because the AFP client disables
32119 ** the read cache when byte-range locks are present.  Enabling the read
32120 ** cache exposes a cache coherency problem that is present on all OS X
32121 ** supported network file systems.  NFS and AFP both observe the
32122 ** close-to-open semantics for ensuring cache coherency
32123 ** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
32124 ** address the requirements for concurrent database access by multiple
32125 ** readers and writers
32126 ** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html].
32127 **
32128 ** To address the performance and cache coherency issues, proxy file locking
32129 ** changes the way database access is controlled by limiting access to a
32130 ** single host at a time and moving file locks off of the database file
32131 ** and onto a proxy file on the local file system.  
32132 **
32133 **
32134 ** Using proxy locks
32135 ** -----------------
32136 **
32137 ** C APIs
32138 **
32139 **  sqlcipher3_file_control(db, dbname, SQLCIPHER_SET_LOCKPROXYFILE,
32140 **                       <proxy_path> | ":auto:");
32141 **  sqlcipher3_file_control(db, dbname, SQLCIPHER_GET_LOCKPROXYFILE, &<proxy_path>);
32142 **
32143 **
32144 ** SQL pragmas
32145 **
32146 **  PRAGMA [database.]lock_proxy_file=<proxy_path> | :auto:
32147 **  PRAGMA [database.]lock_proxy_file
32148 **
32149 ** Specifying ":auto:" means that if there is a conch file with a matching
32150 ** host ID in it, the proxy path in the conch file will be used, otherwise
32151 ** a proxy path based on the user's temp dir
32152 ** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the
32153 ** actual proxy file name is generated from the name and path of the
32154 ** database file.  For example:
32155 **
32156 **       For database path "/Users/me/foo.db" 
32157 **       The lock path will be "<tmpdir>/sqlcipherplocks/_Users_me_foo.db:auto:")
32158 **
32159 ** Once a lock proxy is configured for a database connection, it can not
32160 ** be removed, however it may be switched to a different proxy path via
32161 ** the above APIs (assuming the conch file is not being held by another
32162 ** connection or process). 
32163 **
32164 **
32165 ** How proxy locking works
32166 ** -----------------------
32167 **
32168 ** Proxy file locking relies primarily on two new supporting files: 
32169 **
32170 **   *  conch file to limit access to the database file to a single host
32171 **      at a time
32172 **
32173 **   *  proxy file to act as a proxy for the advisory locks normally
32174 **      taken on the database
32175 **
32176 ** The conch file - to use a proxy file, sqlcipher must first "hold the conch"
32177 ** by taking an sqlcipher-style shared lock on the conch file, reading the
32178 ** contents and comparing the host's unique host ID (see below) and lock
32179 ** proxy path against the values stored in the conch.  The conch file is
32180 ** stored in the same directory as the database file and the file name
32181 ** is patterned after the database file name as ".<databasename>-conch".
32182 ** If the conch file does not exist, or it's contents do not match the
32183 ** host ID and/or proxy path, then the lock is escalated to an exclusive
32184 ** lock and the conch file contents is updated with the host ID and proxy
32185 ** path and the lock is downgraded to a shared lock again.  If the conch
32186 ** is held by another process (with a shared lock), the exclusive lock
32187 ** will fail and SQLCIPHER_BUSY is returned.
32188 **
32189 ** The proxy file - a single-byte file used for all advisory file locks
32190 ** normally taken on the database file.   This allows for safe sharing
32191 ** of the database file for multiple readers and writers on the same
32192 ** host (the conch ensures that they all use the same local lock file).
32193 **
32194 ** Requesting the lock proxy does not immediately take the conch, it is
32195 ** only taken when the first request to lock database file is made.  
32196 ** This matches the semantics of the traditional locking behavior, where
32197 ** opening a connection to a database file does not take a lock on it.
32198 ** The shared lock and an open file descriptor are maintained until 
32199 ** the connection to the database is closed. 
32200 **
32201 ** The proxy file and the lock file are never deleted so they only need
32202 ** to be created the first time they are used.
32203 **
32204 ** Configuration options
32205 ** ---------------------
32206 **
32207 **  SQLCIPHER_PREFER_PROXY_LOCKING
32208 **
32209 **       Database files accessed on non-local file systems are
32210 **       automatically configured for proxy locking, lock files are
32211 **       named automatically using the same logic as
32212 **       PRAGMA lock_proxy_file=":auto:"
32213 **    
32214 **  SQLCIPHER_PROXY_DEBUG
32215 **
32216 **       Enables the logging of error messages during host id file
32217 **       retrieval and creation
32218 **
32219 **  LOCKPROXYDIR
32220 **
32221 **       Overrides the default directory used for lock proxy files that
32222 **       are named automatically via the ":auto:" setting
32223 **
32224 **  SQLCIPHER_DEFAULT_PROXYDIR_PERMISSIONS
32225 **
32226 **       Permissions to use when creating a directory for storing the
32227 **       lock proxy files, only used when LOCKPROXYDIR is not set.
32228 **    
32229 **    
32230 ** As mentioned above, when compiled with SQLCIPHER_PREFER_PROXY_LOCKING,
32231 ** setting the environment variable SQLCIPHER_FORCE_PROXY_LOCKING to 1 will
32232 ** force proxy locking to be used for every database file opened, and 0
32233 ** will force automatic proxy locking to be disabled for all database
32234 ** files (explicity calling the SQLCIPHER_SET_LOCKPROXYFILE pragma or
32235 ** sqlcipher_file_control API is not affected by SQLCIPHER_FORCE_PROXY_LOCKING).
32236 */
32237
32238 /*
32239 ** Proxy locking is only available on MacOSX 
32240 */
32241 #if defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE
32242
32243 /*
32244 ** The proxyLockingContext has the path and file structures for the remote 
32245 ** and local proxy files in it
32246 */
32247 typedef struct proxyLockingContext proxyLockingContext;
32248 struct proxyLockingContext {
32249   unixFile *conchFile;         /* Open conch file */
32250   char *conchFilePath;         /* Name of the conch file */
32251   unixFile *lockProxy;         /* Open proxy lock file */
32252   char *lockProxyPath;         /* Name of the proxy lock file */
32253   char *dbPath;                /* Name of the open file */
32254   int conchHeld;               /* 1 if the conch is held, -1 if lockless */
32255   void *oldLockingContext;     /* Original lockingcontext to restore on close */
32256   sqlcipher3_io_methods const *pOldMethod;     /* Original I/O methods for close */
32257 };
32258
32259 /* 
32260 ** The proxy lock file path for the database at dbPath is written into lPath, 
32261 ** which must point to valid, writable memory large enough for a maxLen length
32262 ** file path. 
32263 */
32264 static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){
32265   int len;
32266   int dbLen;
32267   int i;
32268
32269 #ifdef LOCKPROXYDIR
32270   len = strlcpy(lPath, LOCKPROXYDIR, maxLen);
32271 #else
32272 # ifdef _CS_DARWIN_USER_TEMP_DIR
32273   {
32274     if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){
32275       OSTRACE(("GETLOCKPATH  failed %s errno=%d pid=%d\n",
32276                lPath, errno, getpid()));
32277       return SQLCIPHER_IOERR_LOCK;
32278     }
32279     len = strlcat(lPath, "sqlcipherplocks", maxLen);    
32280   }
32281 # else
32282   len = strlcpy(lPath, "/tmp/", maxLen);
32283 # endif
32284 #endif
32285
32286   if( lPath[len-1]!='/' ){
32287     len = strlcat(lPath, "/", maxLen);
32288   }
32289   
32290   /* transform the db path to a unique cache name */
32291   dbLen = (int)strlen(dbPath);
32292   for( i=0; i<dbLen && (i+len+7)<(int)maxLen; i++){
32293     char c = dbPath[i];
32294     lPath[i+len] = (c=='/')?'_':c;
32295   }
32296   lPath[i+len]='\0';
32297   strlcat(lPath, ":auto:", maxLen);
32298   OSTRACE(("GETLOCKPATH  proxy lock path=%s pid=%d\n", lPath, getpid()));
32299   return SQLCIPHER_OK;
32300 }
32301
32302 /* 
32303  ** Creates the lock file and any missing directories in lockPath
32304  */
32305 static int proxyCreateLockPath(const char *lockPath){
32306   int i, len;
32307   char buf[MAXPATHLEN];
32308   int start = 0;
32309   
32310   assert(lockPath!=NULL);
32311   /* try to create all the intermediate directories */
32312   len = (int)strlen(lockPath);
32313   buf[0] = lockPath[0];
32314   for( i=1; i<len; i++ ){
32315     if( lockPath[i] == '/' && (i - start > 0) ){
32316       /* only mkdir if leaf dir != "." or "/" or ".." */
32317       if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/') 
32318          || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){
32319         buf[i]='\0';
32320         if( mkdir(buf, SQLCIPHER_DEFAULT_PROXYDIR_PERMISSIONS) ){
32321           int err=errno;
32322           if( err!=EEXIST ) {
32323             OSTRACE(("CREATELOCKPATH  FAILED creating %s, "
32324                      "'%s' proxy lock path=%s pid=%d\n",
32325                      buf, strerror(err), lockPath, getpid()));
32326             return err;
32327           }
32328         }
32329       }
32330       start=i+1;
32331     }
32332     buf[i] = lockPath[i];
32333   }
32334   OSTRACE(("CREATELOCKPATH  proxy lock path=%s pid=%d\n", lockPath, getpid()));
32335   return 0;
32336 }
32337
32338 /*
32339 ** Create a new VFS file descriptor (stored in memory obtained from
32340 ** sqlcipher3_malloc) and open the file named "path" in the file descriptor.
32341 **
32342 ** The caller is responsible not only for closing the file descriptor
32343 ** but also for freeing the memory associated with the file descriptor.
32344 */
32345 static int proxyCreateUnixFile(
32346     const char *path,        /* path for the new unixFile */
32347     unixFile **ppFile,       /* unixFile created and returned by ref */
32348     int islockfile           /* if non zero missing dirs will be created */
32349 ) {
32350   int fd = -1;
32351   unixFile *pNew;
32352   int rc = SQLCIPHER_OK;
32353   int openFlags = O_RDWR | O_CREAT;
32354   sqlcipher3_vfs dummyVfs;
32355   int terrno = 0;
32356   UnixUnusedFd *pUnused = NULL;
32357
32358   /* 1. first try to open/create the file
32359   ** 2. if that fails, and this is a lock file (not-conch), try creating
32360   ** the parent directories and then try again.
32361   ** 3. if that fails, try to open the file read-only
32362   ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file
32363   */
32364   pUnused = findReusableFd(path, openFlags);
32365   if( pUnused ){
32366     fd = pUnused->fd;
32367   }else{
32368     pUnused = sqlcipher3_malloc(sizeof(*pUnused));
32369     if( !pUnused ){
32370       return SQLCIPHER_NOMEM;
32371     }
32372   }
32373   if( fd<0 ){
32374     fd = robust_open(path, openFlags, SQLCIPHER_DEFAULT_FILE_PERMISSIONS);
32375     terrno = errno;
32376     if( fd<0 && errno==ENOENT && islockfile ){
32377       if( proxyCreateLockPath(path) == SQLCIPHER_OK ){
32378         fd = robust_open(path, openFlags, SQLCIPHER_DEFAULT_FILE_PERMISSIONS);
32379       }
32380     }
32381   }
32382   if( fd<0 ){
32383     openFlags = O_RDONLY;
32384     fd = robust_open(path, openFlags, SQLCIPHER_DEFAULT_FILE_PERMISSIONS);
32385     terrno = errno;
32386   }
32387   if( fd<0 ){
32388     if( islockfile ){
32389       return SQLCIPHER_BUSY;
32390     }
32391     switch (terrno) {
32392       case EACCES:
32393         return SQLCIPHER_PERM;
32394       case EIO: 
32395         return SQLCIPHER_IOERR_LOCK; /* even though it is the conch */
32396       default:
32397         return SQLCIPHER_CANTOPEN_BKPT;
32398     }
32399   }
32400   
32401   pNew = (unixFile *)sqlcipher3_malloc(sizeof(*pNew));
32402   if( pNew==NULL ){
32403     rc = SQLCIPHER_NOMEM;
32404     goto end_create_proxy;
32405   }
32406   memset(pNew, 0, sizeof(unixFile));
32407   pNew->openFlags = openFlags;
32408   memset(&dummyVfs, 0, sizeof(dummyVfs));
32409   dummyVfs.pAppData = (void*)&autolockIoFinder;
32410   dummyVfs.zName = "dummy";
32411   pUnused->fd = fd;
32412   pUnused->flags = openFlags;
32413   pNew->pUnused = pUnused;
32414   
32415   rc = fillInUnixFile(&dummyVfs, fd, 0, (sqlcipher3_file*)pNew, path, 0, 0, 0);
32416   if( rc==SQLCIPHER_OK ){
32417     *ppFile = pNew;
32418     return SQLCIPHER_OK;
32419   }
32420 end_create_proxy:    
32421   robust_close(pNew, fd, __LINE__);
32422   sqlcipher3_free(pNew);
32423   sqlcipher3_free(pUnused);
32424   return rc;
32425 }
32426
32427 #ifdef SQLCIPHER_TEST
32428 /* simulate multiple hosts by creating unique hostid file paths */
32429 SQLCIPHER_API int sqlcipher3_hostid_num = 0;
32430 #endif
32431
32432 #define PROXY_HOSTIDLEN    16  /* conch file host id length */
32433
32434 /* Not always defined in the headers as it ought to be */
32435 extern int gethostuuid(uuid_t id, const struct timespec *wait);
32436
32437 /* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN 
32438 ** bytes of writable memory.
32439 */
32440 static int proxyGetHostID(unsigned char *pHostID, int *pError){
32441   assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
32442   memset(pHostID, 0, PROXY_HOSTIDLEN);
32443 #if defined(__MAX_OS_X_VERSION_MIN_REQUIRED)\
32444                && __MAC_OS_X_VERSION_MIN_REQUIRED<1050
32445   {
32446     static const struct timespec timeout = {1, 0}; /* 1 sec timeout */
32447     if( gethostuuid(pHostID, &timeout) ){
32448       int err = errno;
32449       if( pError ){
32450         *pError = err;
32451       }
32452       return SQLCIPHER_IOERR;
32453     }
32454   }
32455 #else
32456   UNUSED_PARAMETER(pError);
32457 #endif
32458 #ifdef SQLCIPHER_TEST
32459   /* simulate multiple hosts by creating unique hostid file paths */
32460   if( sqlcipher3_hostid_num != 0){
32461     pHostID[0] = (char)(pHostID[0] + (char)(sqlcipher3_hostid_num & 0xFF));
32462   }
32463 #endif
32464   
32465   return SQLCIPHER_OK;
32466 }
32467
32468 /* The conch file contains the header, host id and lock file path
32469  */
32470 #define PROXY_CONCHVERSION 2   /* 1-byte header, 16-byte host id, path */
32471 #define PROXY_HEADERLEN    1   /* conch file header length */
32472 #define PROXY_PATHINDEX    (PROXY_HEADERLEN+PROXY_HOSTIDLEN)
32473 #define PROXY_MAXCONCHLEN  (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN)
32474
32475 /* 
32476 ** Takes an open conch file, copies the contents to a new path and then moves 
32477 ** it back.  The newly created file's file descriptor is assigned to the
32478 ** conch file structure and finally the original conch file descriptor is 
32479 ** closed.  Returns zero if successful.
32480 */
32481 static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
32482   proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; 
32483   unixFile *conchFile = pCtx->conchFile;
32484   char tPath[MAXPATHLEN];
32485   char buf[PROXY_MAXCONCHLEN];
32486   char *cPath = pCtx->conchFilePath;
32487   size_t readLen = 0;
32488   size_t pathLen = 0;
32489   char errmsg[64] = "";
32490   int fd = -1;
32491   int rc = -1;
32492   UNUSED_PARAMETER(myHostID);
32493
32494   /* create a new path by replace the trailing '-conch' with '-break' */
32495   pathLen = strlcpy(tPath, cPath, MAXPATHLEN);
32496   if( pathLen>MAXPATHLEN || pathLen<6 || 
32497      (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){
32498     sqlcipher3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
32499     goto end_breaklock;
32500   }
32501   /* read the conch content */
32502   readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
32503   if( readLen<PROXY_PATHINDEX ){
32504     sqlcipher3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
32505     goto end_breaklock;
32506   }
32507   /* write it out to the temporary break file */
32508   fd = robust_open(tPath, (O_RDWR|O_CREAT|O_EXCL),
32509                    SQLCIPHER_DEFAULT_FILE_PERMISSIONS);
32510   if( fd<0 ){
32511     sqlcipher3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
32512     goto end_breaklock;
32513   }
32514   if( osPwrite(fd, buf, readLen, 0) != (ssize_t)readLen ){
32515     sqlcipher3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
32516     goto end_breaklock;
32517   }
32518   if( rename(tPath, cPath) ){
32519     sqlcipher3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
32520     goto end_breaklock;
32521   }
32522   rc = 0;
32523   fprintf(stderr, "broke stale lock on %s\n", cPath);
32524   robust_close(pFile, conchFile->h, __LINE__);
32525   conchFile->h = fd;
32526   conchFile->openFlags = O_RDWR | O_CREAT;
32527
32528 end_breaklock:
32529   if( rc ){
32530     if( fd>=0 ){
32531       osUnlink(tPath);
32532       robust_close(pFile, fd, __LINE__);
32533     }
32534     fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg);
32535   }
32536   return rc;
32537 }
32538
32539 /* Take the requested lock on the conch file and break a stale lock if the 
32540 ** host id matches.
32541 */
32542 static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
32543   proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; 
32544   unixFile *conchFile = pCtx->conchFile;
32545   int rc = SQLCIPHER_OK;
32546   int nTries = 0;
32547   struct timespec conchModTime;
32548   
32549   memset(&conchModTime, 0, sizeof(conchModTime));
32550   do {
32551     rc = conchFile->pMethod->xLock((sqlcipher3_file*)conchFile, lockType);
32552     nTries ++;
32553     if( rc==SQLCIPHER_BUSY ){
32554       /* If the lock failed (busy):
32555        * 1st try: get the mod time of the conch, wait 0.5s and try again. 
32556        * 2nd try: fail if the mod time changed or host id is different, wait 
32557        *           10 sec and try again
32558        * 3rd try: break the lock unless the mod time has changed.
32559        */
32560       struct stat buf;
32561       if( osFstat(conchFile->h, &buf) ){
32562         pFile->lastErrno = errno;
32563         return SQLCIPHER_IOERR_LOCK;
32564       }
32565       
32566       if( nTries==1 ){
32567         conchModTime = buf.st_mtimespec;
32568         usleep(500000); /* wait 0.5 sec and try the lock again*/
32569         continue;  
32570       }
32571
32572       assert( nTries>1 );
32573       if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec || 
32574          conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){
32575         return SQLCIPHER_BUSY;
32576       }
32577       
32578       if( nTries==2 ){  
32579         char tBuf[PROXY_MAXCONCHLEN];
32580         int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
32581         if( len<0 ){
32582           pFile->lastErrno = errno;
32583           return SQLCIPHER_IOERR_LOCK;
32584         }
32585         if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){
32586           /* don't break the lock if the host id doesn't match */
32587           if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){
32588             return SQLCIPHER_BUSY;
32589           }
32590         }else{
32591           /* don't break the lock on short read or a version mismatch */
32592           return SQLCIPHER_BUSY;
32593         }
32594         usleep(10000000); /* wait 10 sec and try the lock again */
32595         continue; 
32596       }
32597       
32598       assert( nTries==3 );
32599       if( 0==proxyBreakConchLock(pFile, myHostID) ){
32600         rc = SQLCIPHER_OK;
32601         if( lockType==EXCLUSIVE_LOCK ){
32602           rc = conchFile->pMethod->xLock((sqlcipher3_file*)conchFile, SHARED_LOCK);          
32603         }
32604         if( !rc ){
32605           rc = conchFile->pMethod->xLock((sqlcipher3_file*)conchFile, lockType);
32606         }
32607       }
32608     }
32609   } while( rc==SQLCIPHER_BUSY && nTries<3 );
32610   
32611   return rc;
32612 }
32613
32614 /* Takes the conch by taking a shared lock and read the contents conch, if 
32615 ** lockPath is non-NULL, the host ID and lock file path must match.  A NULL 
32616 ** lockPath means that the lockPath in the conch file will be used if the 
32617 ** host IDs match, or a new lock path will be generated automatically 
32618 ** and written to the conch file.
32619 */
32620 static int proxyTakeConch(unixFile *pFile){
32621   proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; 
32622   
32623   if( pCtx->conchHeld!=0 ){
32624     return SQLCIPHER_OK;
32625   }else{
32626     unixFile *conchFile = pCtx->conchFile;
32627     uuid_t myHostID;
32628     int pError = 0;
32629     char readBuf[PROXY_MAXCONCHLEN];
32630     char lockPath[MAXPATHLEN];
32631     char *tempLockPath = NULL;
32632     int rc = SQLCIPHER_OK;
32633     int createConch = 0;
32634     int hostIdMatch = 0;
32635     int readLen = 0;
32636     int tryOldLockPath = 0;
32637     int forceNewLockPath = 0;
32638     
32639     OSTRACE(("TAKECONCH  %d for %s pid=%d\n", conchFile->h,
32640              (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), getpid()));
32641
32642     rc = proxyGetHostID(myHostID, &pError);
32643     if( (rc&0xff)==SQLCIPHER_IOERR ){
32644       pFile->lastErrno = pError;
32645       goto end_takeconch;
32646     }
32647     rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
32648     if( rc!=SQLCIPHER_OK ){
32649       goto end_takeconch;
32650     }
32651     /* read the existing conch file */
32652     readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN);
32653     if( readLen<0 ){
32654       /* I/O error: lastErrno set by seekAndRead */
32655       pFile->lastErrno = conchFile->lastErrno;
32656       rc = SQLCIPHER_IOERR_READ;
32657       goto end_takeconch;
32658     }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) || 
32659              readBuf[0]!=(char)PROXY_CONCHVERSION ){
32660       /* a short read or version format mismatch means we need to create a new 
32661       ** conch file. 
32662       */
32663       createConch = 1;
32664     }
32665     /* if the host id matches and the lock path already exists in the conch
32666     ** we'll try to use the path there, if we can't open that path, we'll 
32667     ** retry with a new auto-generated path 
32668     */
32669     do { /* in case we need to try again for an :auto: named lock file */
32670
32671       if( !createConch && !forceNewLockPath ){
32672         hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID, 
32673                                   PROXY_HOSTIDLEN);
32674         /* if the conch has data compare the contents */
32675         if( !pCtx->lockProxyPath ){
32676           /* for auto-named local lock file, just check the host ID and we'll
32677            ** use the local lock file path that's already in there
32678            */
32679           if( hostIdMatch ){
32680             size_t pathLen = (readLen - PROXY_PATHINDEX);
32681             
32682             if( pathLen>=MAXPATHLEN ){
32683               pathLen=MAXPATHLEN-1;
32684             }
32685             memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen);
32686             lockPath[pathLen] = 0;
32687             tempLockPath = lockPath;
32688             tryOldLockPath = 1;
32689             /* create a copy of the lock path if the conch is taken */
32690             goto end_takeconch;
32691           }
32692         }else if( hostIdMatch
32693                && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
32694                            readLen-PROXY_PATHINDEX)
32695         ){
32696           /* conch host and lock path match */
32697           goto end_takeconch; 
32698         }
32699       }
32700       
32701       /* if the conch isn't writable and doesn't match, we can't take it */
32702       if( (conchFile->openFlags&O_RDWR) == 0 ){
32703         rc = SQLCIPHER_BUSY;
32704         goto end_takeconch;
32705       }
32706       
32707       /* either the conch didn't match or we need to create a new one */
32708       if( !pCtx->lockProxyPath ){
32709         proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
32710         tempLockPath = lockPath;
32711         /* create a copy of the lock path _only_ if the conch is taken */
32712       }
32713       
32714       /* update conch with host and path (this will fail if other process
32715       ** has a shared lock already), if the host id matches, use the big
32716       ** stick.
32717       */
32718       futimes(conchFile->h, NULL);
32719       if( hostIdMatch && !createConch ){
32720         if( conchFile->pInode && conchFile->pInode->nShared>1 ){
32721           /* We are trying for an exclusive lock but another thread in this
32722            ** same process is still holding a shared lock. */
32723           rc = SQLCIPHER_BUSY;
32724         } else {          
32725           rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
32726         }
32727       }else{
32728         rc = conchFile->pMethod->xLock((sqlcipher3_file*)conchFile, EXCLUSIVE_LOCK);
32729       }
32730       if( rc==SQLCIPHER_OK ){
32731         char writeBuffer[PROXY_MAXCONCHLEN];
32732         int writeSize = 0;
32733         
32734         writeBuffer[0] = (char)PROXY_CONCHVERSION;
32735         memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
32736         if( pCtx->lockProxyPath!=NULL ){
32737           strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, MAXPATHLEN);
32738         }else{
32739           strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN);
32740         }
32741         writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
32742         robust_ftruncate(conchFile->h, writeSize);
32743         rc = unixWrite((sqlcipher3_file *)conchFile, writeBuffer, writeSize, 0);
32744         fsync(conchFile->h);
32745         /* If we created a new conch file (not just updated the contents of a 
32746          ** valid conch file), try to match the permissions of the database 
32747          */
32748         if( rc==SQLCIPHER_OK && createConch ){
32749           struct stat buf;
32750           int err = osFstat(pFile->h, &buf);
32751           if( err==0 ){
32752             mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP |
32753                                         S_IROTH|S_IWOTH);
32754             /* try to match the database file R/W permissions, ignore failure */
32755 #ifndef SQLCIPHER_PROXY_DEBUG
32756             osFchmod(conchFile->h, cmode);
32757 #else
32758             do{
32759               rc = osFchmod(conchFile->h, cmode);
32760             }while( rc==(-1) && errno==EINTR );
32761             if( rc!=0 ){
32762               int code = errno;
32763               fprintf(stderr, "fchmod %o FAILED with %d %s\n",
32764                       cmode, code, strerror(code));
32765             } else {
32766               fprintf(stderr, "fchmod %o SUCCEDED\n",cmode);
32767             }
32768           }else{
32769             int code = errno;
32770             fprintf(stderr, "STAT FAILED[%d] with %d %s\n", 
32771                     err, code, strerror(code));
32772 #endif
32773           }
32774         }
32775       }
32776       conchFile->pMethod->xUnlock((sqlcipher3_file*)conchFile, SHARED_LOCK);
32777       
32778     end_takeconch:
32779       OSTRACE(("TRANSPROXY: CLOSE  %d\n", pFile->h));
32780       if( rc==SQLCIPHER_OK && pFile->openFlags ){
32781         int fd;
32782         if( pFile->h>=0 ){
32783           robust_close(pFile, pFile->h, __LINE__);
32784         }
32785         pFile->h = -1;
32786         fd = robust_open(pCtx->dbPath, pFile->openFlags,
32787                       SQLCIPHER_DEFAULT_FILE_PERMISSIONS);
32788         OSTRACE(("TRANSPROXY: OPEN  %d\n", fd));
32789         if( fd>=0 ){
32790           pFile->h = fd;
32791         }else{
32792           rc=SQLCIPHER_CANTOPEN_BKPT; /* SQLCIPHER_BUSY? proxyTakeConch called
32793            during locking */
32794         }
32795       }
32796       if( rc==SQLCIPHER_OK && !pCtx->lockProxy ){
32797         char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
32798         rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
32799         if( rc!=SQLCIPHER_OK && rc!=SQLCIPHER_NOMEM && tryOldLockPath ){
32800           /* we couldn't create the proxy lock file with the old lock file path
32801            ** so try again via auto-naming 
32802            */
32803           forceNewLockPath = 1;
32804           tryOldLockPath = 0;
32805           continue; /* go back to the do {} while start point, try again */
32806         }
32807       }
32808       if( rc==SQLCIPHER_OK ){
32809         /* Need to make a copy of path if we extracted the value
32810          ** from the conch file or the path was allocated on the stack
32811          */
32812         if( tempLockPath ){
32813           pCtx->lockProxyPath = sqlcipher3DbStrDup(0, tempLockPath);
32814           if( !pCtx->lockProxyPath ){
32815             rc = SQLCIPHER_NOMEM;
32816           }
32817         }
32818       }
32819       if( rc==SQLCIPHER_OK ){
32820         pCtx->conchHeld = 1;
32821         
32822         if( pCtx->lockProxy->pMethod == &afpIoMethods ){
32823           afpLockingContext *afpCtx;
32824           afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
32825           afpCtx->dbPath = pCtx->lockProxyPath;
32826         }
32827       } else {
32828         conchFile->pMethod->xUnlock((sqlcipher3_file*)conchFile, NO_LOCK);
32829       }
32830       OSTRACE(("TAKECONCH  %d %s\n", conchFile->h,
32831                rc==SQLCIPHER_OK?"ok":"failed"));
32832       return rc;
32833     } while (1); /* in case we need to retry the :auto: lock file - 
32834                  ** we should never get here except via the 'continue' call. */
32835   }
32836 }
32837
32838 /*
32839 ** If pFile holds a lock on a conch file, then release that lock.
32840 */
32841 static int proxyReleaseConch(unixFile *pFile){
32842   int rc = SQLCIPHER_OK;         /* Subroutine return code */
32843   proxyLockingContext *pCtx;  /* The locking context for the proxy lock */
32844   unixFile *conchFile;        /* Name of the conch file */
32845
32846   pCtx = (proxyLockingContext *)pFile->lockingContext;
32847   conchFile = pCtx->conchFile;
32848   OSTRACE(("RELEASECONCH  %d for %s pid=%d\n", conchFile->h,
32849            (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), 
32850            getpid()));
32851   if( pCtx->conchHeld>0 ){
32852     rc = conchFile->pMethod->xUnlock((sqlcipher3_file*)conchFile, NO_LOCK);
32853   }
32854   pCtx->conchHeld = 0;
32855   OSTRACE(("RELEASECONCH  %d %s\n", conchFile->h,
32856            (rc==SQLCIPHER_OK ? "ok" : "failed")));
32857   return rc;
32858 }
32859
32860 /*
32861 ** Given the name of a database file, compute the name of its conch file.
32862 ** Store the conch filename in memory obtained from sqlcipher3_malloc().
32863 ** Make *pConchPath point to the new name.  Return SQLCIPHER_OK on success
32864 ** or SQLCIPHER_NOMEM if unable to obtain memory.
32865 **
32866 ** The caller is responsible for ensuring that the allocated memory
32867 ** space is eventually freed.
32868 **
32869 ** *pConchPath is set to NULL if a memory allocation error occurs.
32870 */
32871 static int proxyCreateConchPathname(char *dbPath, char **pConchPath){
32872   int i;                        /* Loop counter */
32873   int len = (int)strlen(dbPath); /* Length of database filename - dbPath */
32874   char *conchPath;              /* buffer in which to construct conch name */
32875
32876   /* Allocate space for the conch filename and initialize the name to
32877   ** the name of the original database file. */  
32878   *pConchPath = conchPath = (char *)sqlcipher3_malloc(len + 8);
32879   if( conchPath==0 ){
32880     return SQLCIPHER_NOMEM;
32881   }
32882   memcpy(conchPath, dbPath, len+1);
32883   
32884   /* now insert a "." before the last / character */
32885   for( i=(len-1); i>=0; i-- ){
32886     if( conchPath[i]=='/' ){
32887       i++;
32888       break;
32889     }
32890   }
32891   conchPath[i]='.';
32892   while ( i<len ){
32893     conchPath[i+1]=dbPath[i];
32894     i++;
32895   }
32896
32897   /* append the "-conch" suffix to the file */
32898   memcpy(&conchPath[i+1], "-conch", 7);
32899   assert( (int)strlen(conchPath) == len+7 );
32900
32901   return SQLCIPHER_OK;
32902 }
32903
32904
32905 /* Takes a fully configured proxy locking-style unix file and switches
32906 ** the local lock file path 
32907 */
32908 static int switchLockProxyPath(unixFile *pFile, const char *path) {
32909   proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
32910   char *oldPath = pCtx->lockProxyPath;
32911   int rc = SQLCIPHER_OK;
32912
32913   if( pFile->eFileLock!=NO_LOCK ){
32914     return SQLCIPHER_BUSY;
32915   }  
32916
32917   /* nothing to do if the path is NULL, :auto: or matches the existing path */
32918   if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ||
32919     (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){
32920     return SQLCIPHER_OK;
32921   }else{
32922     unixFile *lockProxy = pCtx->lockProxy;
32923     pCtx->lockProxy=NULL;
32924     pCtx->conchHeld = 0;
32925     if( lockProxy!=NULL ){
32926       rc=lockProxy->pMethod->xClose((sqlcipher3_file *)lockProxy);
32927       if( rc ) return rc;
32928       sqlcipher3_free(lockProxy);
32929     }
32930     sqlcipher3_free(oldPath);
32931     pCtx->lockProxyPath = sqlcipher3DbStrDup(0, path);
32932   }
32933   
32934   return rc;
32935 }
32936
32937 /*
32938 ** pFile is a file that has been opened by a prior xOpen call.  dbPath
32939 ** is a string buffer at least MAXPATHLEN+1 characters in size.
32940 **
32941 ** This routine find the filename associated with pFile and writes it
32942 ** int dbPath.
32943 */
32944 static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
32945 #if defined(__APPLE__)
32946   if( pFile->pMethod == &afpIoMethods ){
32947     /* afp style keeps a reference to the db path in the filePath field 
32948     ** of the struct */
32949     assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
32950     strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, MAXPATHLEN);
32951   } else
32952 #endif
32953   if( pFile->pMethod == &dotlockIoMethods ){
32954     /* dot lock style uses the locking context to store the dot lock
32955     ** file path */
32956     int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
32957     memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
32958   }else{
32959     /* all other styles use the locking context to store the db file path */
32960     assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
32961     strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
32962   }
32963   return SQLCIPHER_OK;
32964 }
32965
32966 /*
32967 ** Takes an already filled in unix file and alters it so all file locking 
32968 ** will be performed on the local proxy lock file.  The following fields
32969 ** are preserved in the locking context so that they can be restored and 
32970 ** the unix structure properly cleaned up at close time:
32971 **  ->lockingContext
32972 **  ->pMethod
32973 */
32974 static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
32975   proxyLockingContext *pCtx;
32976   char dbPath[MAXPATHLEN+1];       /* Name of the database file */
32977   char *lockPath=NULL;
32978   int rc = SQLCIPHER_OK;
32979   
32980   if( pFile->eFileLock!=NO_LOCK ){
32981     return SQLCIPHER_BUSY;
32982   }
32983   proxyGetDbPathForUnixFile(pFile, dbPath);
32984   if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){
32985     lockPath=NULL;
32986   }else{
32987     lockPath=(char *)path;
32988   }
32989   
32990   OSTRACE(("TRANSPROXY  %d for %s pid=%d\n", pFile->h,
32991            (lockPath ? lockPath : ":auto:"), getpid()));
32992
32993   pCtx = sqlcipher3_malloc( sizeof(*pCtx) );
32994   if( pCtx==0 ){
32995     return SQLCIPHER_NOMEM;
32996   }
32997   memset(pCtx, 0, sizeof(*pCtx));
32998
32999   rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
33000   if( rc==SQLCIPHER_OK ){
33001     rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
33002     if( rc==SQLCIPHER_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
33003       /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
33004       ** (c) the file system is read-only, then enable no-locking access.
33005       ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts
33006       ** that openFlags will have only one of O_RDONLY or O_RDWR.
33007       */
33008       struct statfs fsInfo;
33009       struct stat conchInfo;
33010       int goLockless = 0;
33011
33012       if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
33013         int err = errno;
33014         if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){
33015           goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY;
33016         }
33017       }
33018       if( goLockless ){
33019         pCtx->conchHeld = -1; /* read only FS/ lockless */
33020         rc = SQLCIPHER_OK;
33021       }
33022     }
33023   }  
33024   if( rc==SQLCIPHER_OK && lockPath ){
33025     pCtx->lockProxyPath = sqlcipher3DbStrDup(0, lockPath);
33026   }
33027
33028   if( rc==SQLCIPHER_OK ){
33029     pCtx->dbPath = sqlcipher3DbStrDup(0, dbPath);
33030     if( pCtx->dbPath==NULL ){
33031       rc = SQLCIPHER_NOMEM;
33032     }
33033   }
33034   if( rc==SQLCIPHER_OK ){
33035     /* all memory is allocated, proxys are created and assigned, 
33036     ** switch the locking context and pMethod then return.
33037     */
33038     pCtx->oldLockingContext = pFile->lockingContext;
33039     pFile->lockingContext = pCtx;
33040     pCtx->pOldMethod = pFile->pMethod;
33041     pFile->pMethod = &proxyIoMethods;
33042   }else{
33043     if( pCtx->conchFile ){ 
33044       pCtx->conchFile->pMethod->xClose((sqlcipher3_file *)pCtx->conchFile);
33045       sqlcipher3_free(pCtx->conchFile);
33046     }
33047     sqlcipher3DbFree(0, pCtx->lockProxyPath);
33048     sqlcipher3_free(pCtx->conchFilePath); 
33049     sqlcipher3_free(pCtx);
33050   }
33051   OSTRACE(("TRANSPROXY  %d %s\n", pFile->h,
33052            (rc==SQLCIPHER_OK ? "ok" : "failed")));
33053   return rc;
33054 }
33055
33056
33057 /*
33058 ** This routine handles sqlcipher3_file_control() calls that are specific
33059 ** to proxy locking.
33060 */
33061 static int proxyFileControl(sqlcipher3_file *id, int op, void *pArg){
33062   switch( op ){
33063     case SQLCIPHER_GET_LOCKPROXYFILE: {
33064       unixFile *pFile = (unixFile*)id;
33065       if( pFile->pMethod == &proxyIoMethods ){
33066         proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
33067         proxyTakeConch(pFile);
33068         if( pCtx->lockProxyPath ){
33069           *(const char **)pArg = pCtx->lockProxyPath;
33070         }else{
33071           *(const char **)pArg = ":auto: (not held)";
33072         }
33073       } else {
33074         *(const char **)pArg = NULL;
33075       }
33076       return SQLCIPHER_OK;
33077     }
33078     case SQLCIPHER_SET_LOCKPROXYFILE: {
33079       unixFile *pFile = (unixFile*)id;
33080       int rc = SQLCIPHER_OK;
33081       int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
33082       if( pArg==NULL || (const char *)pArg==0 ){
33083         if( isProxyStyle ){
33084           /* turn off proxy locking - not supported */
33085           rc = SQLCIPHER_ERROR /*SQLCIPHER_PROTOCOL? SQLCIPHER_MISUSE?*/;
33086         }else{
33087           /* turn off proxy locking - already off - NOOP */
33088           rc = SQLCIPHER_OK;
33089         }
33090       }else{
33091         const char *proxyPath = (const char *)pArg;
33092         if( isProxyStyle ){
33093           proxyLockingContext *pCtx = 
33094             (proxyLockingContext*)pFile->lockingContext;
33095           if( !strcmp(pArg, ":auto:") 
33096            || (pCtx->lockProxyPath &&
33097                !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
33098           ){
33099             rc = SQLCIPHER_OK;
33100           }else{
33101             rc = switchLockProxyPath(pFile, proxyPath);
33102           }
33103         }else{
33104           /* turn on proxy file locking */
33105           rc = proxyTransformUnixFile(pFile, proxyPath);
33106         }
33107       }
33108       return rc;
33109     }
33110     default: {
33111       assert( 0 );  /* The call assures that only valid opcodes are sent */
33112     }
33113   }
33114   /*NOTREACHED*/
33115   return SQLCIPHER_ERROR;
33116 }
33117
33118 /*
33119 ** Within this division (the proxying locking implementation) the procedures
33120 ** above this point are all utilities.  The lock-related methods of the
33121 ** proxy-locking sqlcipher3_io_method object follow.
33122 */
33123
33124
33125 /*
33126 ** This routine checks if there is a RESERVED lock held on the specified
33127 ** file by this or any other process. If such a lock is held, set *pResOut
33128 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
33129 ** is set to SQLCIPHER_OK unless an I/O error occurs during lock checking.
33130 */
33131 static int proxyCheckReservedLock(sqlcipher3_file *id, int *pResOut) {
33132   unixFile *pFile = (unixFile*)id;
33133   int rc = proxyTakeConch(pFile);
33134   if( rc==SQLCIPHER_OK ){
33135     proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
33136     if( pCtx->conchHeld>0 ){
33137       unixFile *proxy = pCtx->lockProxy;
33138       return proxy->pMethod->xCheckReservedLock((sqlcipher3_file*)proxy, pResOut);
33139     }else{ /* conchHeld < 0 is lockless */
33140       pResOut=0;
33141     }
33142   }
33143   return rc;
33144 }
33145
33146 /*
33147 ** Lock the file with the lock specified by parameter eFileLock - one
33148 ** of the following:
33149 **
33150 **     (1) SHARED_LOCK
33151 **     (2) RESERVED_LOCK
33152 **     (3) PENDING_LOCK
33153 **     (4) EXCLUSIVE_LOCK
33154 **
33155 ** Sometimes when requesting one lock state, additional lock states
33156 ** are inserted in between.  The locking might fail on one of the later
33157 ** transitions leaving the lock state different from what it started but
33158 ** still short of its goal.  The following chart shows the allowed
33159 ** transitions and the inserted intermediate states:
33160 **
33161 **    UNLOCKED -> SHARED
33162 **    SHARED -> RESERVED
33163 **    SHARED -> (PENDING) -> EXCLUSIVE
33164 **    RESERVED -> (PENDING) -> EXCLUSIVE
33165 **    PENDING -> EXCLUSIVE
33166 **
33167 ** This routine will only increase a lock.  Use the sqlcipher3OsUnlock()
33168 ** routine to lower a locking level.
33169 */
33170 static int proxyLock(sqlcipher3_file *id, int eFileLock) {
33171   unixFile *pFile = (unixFile*)id;
33172   int rc = proxyTakeConch(pFile);
33173   if( rc==SQLCIPHER_OK ){
33174     proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
33175     if( pCtx->conchHeld>0 ){
33176       unixFile *proxy = pCtx->lockProxy;
33177       rc = proxy->pMethod->xLock((sqlcipher3_file*)proxy, eFileLock);
33178       pFile->eFileLock = proxy->eFileLock;
33179     }else{
33180       /* conchHeld < 0 is lockless */
33181     }
33182   }
33183   return rc;
33184 }
33185
33186
33187 /*
33188 ** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
33189 ** must be either NO_LOCK or SHARED_LOCK.
33190 **
33191 ** If the locking level of the file descriptor is already at or below
33192 ** the requested locking level, this routine is a no-op.
33193 */
33194 static int proxyUnlock(sqlcipher3_file *id, int eFileLock) {
33195   unixFile *pFile = (unixFile*)id;
33196   int rc = proxyTakeConch(pFile);
33197   if( rc==SQLCIPHER_OK ){
33198     proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
33199     if( pCtx->conchHeld>0 ){
33200       unixFile *proxy = pCtx->lockProxy;
33201       rc = proxy->pMethod->xUnlock((sqlcipher3_file*)proxy, eFileLock);
33202       pFile->eFileLock = proxy->eFileLock;
33203     }else{
33204       /* conchHeld < 0 is lockless */
33205     }
33206   }
33207   return rc;
33208 }
33209
33210 /*
33211 ** Close a file that uses proxy locks.
33212 */
33213 static int proxyClose(sqlcipher3_file *id) {
33214   if( id ){
33215     unixFile *pFile = (unixFile*)id;
33216     proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
33217     unixFile *lockProxy = pCtx->lockProxy;
33218     unixFile *conchFile = pCtx->conchFile;
33219     int rc = SQLCIPHER_OK;
33220     
33221     if( lockProxy ){
33222       rc = lockProxy->pMethod->xUnlock((sqlcipher3_file*)lockProxy, NO_LOCK);
33223       if( rc ) return rc;
33224       rc = lockProxy->pMethod->xClose((sqlcipher3_file*)lockProxy);
33225       if( rc ) return rc;
33226       sqlcipher3_free(lockProxy);
33227       pCtx->lockProxy = 0;
33228     }
33229     if( conchFile ){
33230       if( pCtx->conchHeld ){
33231         rc = proxyReleaseConch(pFile);
33232         if( rc ) return rc;
33233       }
33234       rc = conchFile->pMethod->xClose((sqlcipher3_file*)conchFile);
33235       if( rc ) return rc;
33236       sqlcipher3_free(conchFile);
33237     }
33238     sqlcipher3DbFree(0, pCtx->lockProxyPath);
33239     sqlcipher3_free(pCtx->conchFilePath);
33240     sqlcipher3DbFree(0, pCtx->dbPath);
33241     /* restore the original locking context and pMethod then close it */
33242     pFile->lockingContext = pCtx->oldLockingContext;
33243     pFile->pMethod = pCtx->pOldMethod;
33244     sqlcipher3_free(pCtx);
33245     return pFile->pMethod->xClose(id);
33246   }
33247   return SQLCIPHER_OK;
33248 }
33249
33250
33251
33252 #endif /* defined(__APPLE__) && SQLCIPHER_ENABLE_LOCKING_STYLE */
33253 /*
33254 ** The proxy locking style is intended for use with AFP filesystems.
33255 ** And since AFP is only supported on MacOSX, the proxy locking is also
33256 ** restricted to MacOSX.
33257 ** 
33258 **
33259 ******************* End of the proxy lock implementation **********************
33260 ******************************************************************************/
33261
33262 /*
33263 ** Initialize the operating system interface.
33264 **
33265 ** This routine registers all VFS implementations for unix-like operating
33266 ** systems.  This routine, and the sqlcipher3_os_end() routine that follows,
33267 ** should be the only routines in this file that are visible from other
33268 ** files.
33269 **
33270 ** This routine is called once during SQLite initialization and by a
33271 ** single thread.  The memory allocation and mutex subsystems have not
33272 ** necessarily been initialized when this routine is called, and so they
33273 ** should not be used.
33274 */
33275 SQLCIPHER_API int sqlcipher3_os_init(void){ 
33276   /* 
33277   ** The following macro defines an initializer for an sqlcipher3_vfs object.
33278   ** The name of the VFS is NAME.  The pAppData is a pointer to a pointer
33279   ** to the "finder" function.  (pAppData is a pointer to a pointer because
33280   ** silly C90 rules prohibit a void* from being cast to a function pointer
33281   ** and so we have to go through the intermediate pointer to avoid problems
33282   ** when compiling with -pedantic-errors on GCC.)
33283   **
33284   ** The FINDER parameter to this macro is the name of the pointer to the
33285   ** finder-function.  The finder-function returns a pointer to the
33286   ** sqlcipher_io_methods object that implements the desired locking
33287   ** behaviors.  See the division above that contains the IOMETHODS
33288   ** macro for addition information on finder-functions.
33289   **
33290   ** Most finders simply return a pointer to a fixed sqlcipher3_io_methods
33291   ** object.  But the "autolockIoFinder" available on MacOSX does a little
33292   ** more than that; it looks at the filesystem type that hosts the 
33293   ** database file and tries to choose an locking method appropriate for
33294   ** that filesystem time.
33295   */
33296   #define UNIXVFS(VFSNAME, FINDER) {                        \
33297     3,                    /* iVersion */                    \
33298     sizeof(unixFile),     /* szOsFile */                    \
33299     MAX_PATHNAME,         /* mxPathname */                  \
33300     0,                    /* pNext */                       \
33301     VFSNAME,              /* zName */                       \
33302     (void*)&FINDER,       /* pAppData */                    \
33303     unixOpen,             /* xOpen */                       \
33304     unixDelete,           /* xDelete */                     \
33305     unixAccess,           /* xAccess */                     \
33306     unixFullPathname,     /* xFullPathname */               \
33307     unixDlOpen,           /* xDlOpen */                     \
33308     unixDlError,          /* xDlError */                    \
33309     unixDlSym,            /* xDlSym */                      \
33310     unixDlClose,          /* xDlClose */                    \
33311     unixRandomness,       /* xRandomness */                 \
33312     unixSleep,            /* xSleep */                      \
33313     unixCurrentTime,      /* xCurrentTime */                \
33314     unixGetLastError,     /* xGetLastError */               \
33315     unixCurrentTimeInt64, /* xCurrentTimeInt64 */           \
33316     unixSetSystemCall,    /* xSetSystemCall */              \
33317     unixGetSystemCall,    /* xGetSystemCall */              \
33318     unixNextSystemCall,   /* xNextSystemCall */             \
33319   }
33320
33321   /*
33322   ** All default VFSes for unix are contained in the following array.
33323   **
33324   ** Note that the sqlcipher3_vfs.pNext field of the VFS object is modified
33325   ** by the SQLite core when the VFS is registered.  So the following
33326   ** array cannot be const.
33327   */
33328   static sqlcipher3_vfs aVfs[] = {
33329 #if SQLCIPHER_ENABLE_LOCKING_STYLE && (OS_VXWORKS || defined(__APPLE__))
33330     UNIXVFS("unix",          autolockIoFinder ),
33331 #else
33332     UNIXVFS("unix",          posixIoFinder ),
33333 #endif
33334     UNIXVFS("unix-none",     nolockIoFinder ),
33335     UNIXVFS("unix-dotfile",  dotlockIoFinder ),
33336     UNIXVFS("unix-excl",     posixIoFinder ),
33337 #if OS_VXWORKS
33338     UNIXVFS("unix-namedsem", semIoFinder ),
33339 #endif
33340 #if SQLCIPHER_ENABLE_LOCKING_STYLE
33341     UNIXVFS("unix-posix",    posixIoFinder ),
33342 #if !OS_VXWORKS
33343     UNIXVFS("unix-flock",    flockIoFinder ),
33344 #endif
33345 #endif
33346 #if SQLCIPHER_ENABLE_LOCKING_STYLE && defined(__APPLE__)
33347     UNIXVFS("unix-afp",      afpIoFinder ),
33348     UNIXVFS("unix-nfs",      nfsIoFinder ),
33349     UNIXVFS("unix-proxy",    proxyIoFinder ),
33350 #endif
33351   };
33352   unsigned int i;          /* Loop counter */
33353
33354   /* Double-check that the aSyscall[] array has been constructed
33355   ** correctly.  See ticket [bb3a86e890c8e96ab] */
33356   assert( ArraySize(aSyscall)==18 );
33357
33358   /* Register all VFSes defined in the aVfs[] array */
33359   for(i=0; i<(sizeof(aVfs)/sizeof(sqlcipher3_vfs)); i++){
33360     sqlcipher3_vfs_register(&aVfs[i], i==0);
33361   }
33362   return SQLCIPHER_OK; 
33363 }
33364
33365 /*
33366 ** Shutdown the operating system interface.
33367 **
33368 ** Some operating systems might need to do some cleanup in this routine,
33369 ** to release dynamically allocated objects.  But not on unix.
33370 ** This routine is a no-op for unix.
33371 */
33372 SQLCIPHER_API int sqlcipher3_os_end(void){ 
33373   return SQLCIPHER_OK; 
33374 }
33375  
33376 #endif /* SQLCIPHER_OS_UNIX */
33377
33378 /************** End of os_unix.c *********************************************/
33379 /************** Begin file os_win.c ******************************************/
33380 /*
33381 ** 2004 May 22
33382 **
33383 ** The author disclaims copyright to this source code.  In place of
33384 ** a legal notice, here is a blessing:
33385 **
33386 **    May you do good and not evil.
33387 **    May you find forgiveness for yourself and forgive others.
33388 **    May you share freely, never taking more than you give.
33389 **
33390 ******************************************************************************
33391 **
33392 ** This file contains code that is specific to windows.
33393 */
33394 #if SQLCIPHER_OS_WIN               /* This file is used for windows only */
33395
33396
33397 /*
33398 ** A Note About Memory Allocation:
33399 **
33400 ** This driver uses malloc()/free() directly rather than going through
33401 ** the SQLite-wrappers sqlcipher3_malloc()/sqlcipher3_free().  Those wrappers
33402 ** are designed for use on embedded systems where memory is scarce and
33403 ** malloc failures happen frequently.  Win32 does not typically run on
33404 ** embedded systems, and when it does the developers normally have bigger
33405 ** problems to worry about than running out of memory.  So there is not
33406 ** a compelling need to use the wrappers.
33407 **
33408 ** But there is a good reason to not use the wrappers.  If we use the
33409 ** wrappers then we will get simulated malloc() failures within this
33410 ** driver.  And that causes all kinds of problems for our tests.  We
33411 ** could enhance SQLite to deal with simulated malloc failures within
33412 ** the OS driver, but the code to deal with those failure would not
33413 ** be exercised on Linux (which does not need to malloc() in the driver)
33414 ** and so we would have difficulty writing coverage tests for that
33415 ** code.  Better to leave the code out, we think.
33416 **
33417 ** The point of this discussion is as follows:  When creating a new
33418 ** OS layer for an embedded system, if you use this file as an example,
33419 ** avoid the use of malloc()/free().  Those routines work ok on windows
33420 ** desktops but not so well in embedded systems.
33421 */
33422
33423 #include <winbase.h>
33424
33425 #ifdef __CYGWIN__
33426 # include <sys/cygwin.h>
33427 #endif
33428
33429 /*
33430 ** Macros used to determine whether or not to use threads.
33431 */
33432 #if defined(THREADSAFE) && THREADSAFE
33433 # define SQLCIPHER_W32_THREADS 1
33434 #endif
33435
33436 /*
33437 ** Include code that is common to all os_*.c files
33438 */
33439 /************** Include os_common.h in the middle of os_win.c ****************/
33440 /************** Begin file os_common.h ***************************************/
33441 /*
33442 ** 2004 May 22
33443 **
33444 ** The author disclaims copyright to this source code.  In place of
33445 ** a legal notice, here is a blessing:
33446 **
33447 **    May you do good and not evil.
33448 **    May you find forgiveness for yourself and forgive others.
33449 **    May you share freely, never taking more than you give.
33450 **
33451 ******************************************************************************
33452 **
33453 ** This file contains macros and a little bit of code that is common to
33454 ** all of the platform-specific files (os_*.c) and is #included into those
33455 ** files.
33456 **
33457 ** This file should be #included by the os_*.c files only.  It is not a
33458 ** general purpose header file.
33459 */
33460 #ifndef _OS_COMMON_H_
33461 #define _OS_COMMON_H_
33462
33463 /*
33464 ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
33465 ** macro to SQLCIPHER_DEBUG and some older makefiles have not yet made the
33466 ** switch.  The following code should catch this problem at compile-time.
33467 */
33468 #ifdef MEMORY_DEBUG
33469 # error "The MEMORY_DEBUG macro is obsolete.  Use SQLCIPHER_DEBUG instead."
33470 #endif
33471
33472 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
33473 # ifndef SQLCIPHER_DEBUG_OS_TRACE
33474 #   define SQLCIPHER_DEBUG_OS_TRACE 0
33475 # endif
33476   int sqlcipher3OSTrace = SQLCIPHER_DEBUG_OS_TRACE;
33477 # define OSTRACE(X)          if( sqlcipher3OSTrace ) sqlcipher3DebugPrintf X
33478 #else
33479 # define OSTRACE(X)
33480 #endif
33481
33482 /*
33483 ** Macros for performance tracing.  Normally turned off.  Only works
33484 ** on i486 hardware.
33485 */
33486 #ifdef SQLCIPHER_PERFORMANCE_TRACE
33487
33488 /* 
33489 ** hwtime.h contains inline assembler code for implementing 
33490 ** high-performance timing routines.
33491 */
33492 /************** Include hwtime.h in the middle of os_common.h ****************/
33493 /************** Begin file hwtime.h ******************************************/
33494 /*
33495 ** 2008 May 27
33496 **
33497 ** The author disclaims copyright to this source code.  In place of
33498 ** a legal notice, here is a blessing:
33499 **
33500 **    May you do good and not evil.
33501 **    May you find forgiveness for yourself and forgive others.
33502 **    May you share freely, never taking more than you give.
33503 **
33504 ******************************************************************************
33505 **
33506 ** This file contains inline asm code for retrieving "high-performance"
33507 ** counters for x86 class CPUs.
33508 */
33509 #ifndef _HWTIME_H_
33510 #define _HWTIME_H_
33511
33512 /*
33513 ** The following routine only works on pentium-class (or newer) processors.
33514 ** It uses the RDTSC opcode to read the cycle count value out of the
33515 ** processor and returns that value.  This can be used for high-res
33516 ** profiling.
33517 */
33518 #if (defined(__GNUC__) || defined(_MSC_VER)) && \
33519       (defined(i386) || defined(__i386__) || defined(_M_IX86))
33520
33521   #if defined(__GNUC__)
33522
33523   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
33524      unsigned int lo, hi;
33525      __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
33526      return (sqlcipher_uint64)hi << 32 | lo;
33527   }
33528
33529   #elif defined(_MSC_VER)
33530
33531   __declspec(naked) __inline sqlcipher_uint64 __cdecl sqlcipher3Hwtime(void){
33532      __asm {
33533         rdtsc
33534         ret       ; return value at EDX:EAX
33535      }
33536   }
33537
33538   #endif
33539
33540 #elif (defined(__GNUC__) && defined(__x86_64__))
33541
33542   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
33543       unsigned long val;
33544       __asm__ __volatile__ ("rdtsc" : "=A" (val));
33545       return val;
33546   }
33547  
33548 #elif (defined(__GNUC__) && defined(__ppc__))
33549
33550   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
33551       unsigned long long retval;
33552       unsigned long junk;
33553       __asm__ __volatile__ ("\n\
33554           1:      mftbu   %1\n\
33555                   mftb    %L0\n\
33556                   mftbu   %0\n\
33557                   cmpw    %0,%1\n\
33558                   bne     1b"
33559                   : "=r" (retval), "=r" (junk));
33560       return retval;
33561   }
33562
33563 #else
33564
33565   #error Need implementation of sqlcipher3Hwtime() for your platform.
33566
33567   /*
33568   ** To compile without implementing sqlcipher3Hwtime() for your platform,
33569   ** you can remove the above #error and use the following
33570   ** stub function.  You will lose timing support for many
33571   ** of the debugging and testing utilities, but it should at
33572   ** least compile and run.
33573   */
33574 SQLCIPHER_PRIVATE   sqlcipher_uint64 sqlcipher3Hwtime(void){ return ((sqlcipher_uint64)0); }
33575
33576 #endif
33577
33578 #endif /* !defined(_HWTIME_H_) */
33579
33580 /************** End of hwtime.h **********************************************/
33581 /************** Continuing where we left off in os_common.h ******************/
33582
33583 static sqlcipher_uint64 g_start;
33584 static sqlcipher_uint64 g_elapsed;
33585 #define TIMER_START       g_start=sqlcipher3Hwtime()
33586 #define TIMER_END         g_elapsed=sqlcipher3Hwtime()-g_start
33587 #define TIMER_ELAPSED     g_elapsed
33588 #else
33589 #define TIMER_START
33590 #define TIMER_END
33591 #define TIMER_ELAPSED     ((sqlcipher_uint64)0)
33592 #endif
33593
33594 /*
33595 ** If we compile with the SQLCIPHER_TEST macro set, then the following block
33596 ** of code will give us the ability to simulate a disk I/O error.  This
33597 ** is used for testing the I/O recovery logic.
33598 */
33599 #ifdef SQLCIPHER_TEST
33600 SQLCIPHER_API int sqlcipher3_io_error_hit = 0;            /* Total number of I/O Errors */
33601 SQLCIPHER_API int sqlcipher3_io_error_hardhit = 0;        /* Number of non-benign errors */
33602 SQLCIPHER_API int sqlcipher3_io_error_pending = 0;        /* Count down to first I/O error */
33603 SQLCIPHER_API int sqlcipher3_io_error_persist = 0;        /* True if I/O errors persist */
33604 SQLCIPHER_API int sqlcipher3_io_error_benign = 0;         /* True if errors are benign */
33605 SQLCIPHER_API int sqlcipher3_diskfull_pending = 0;
33606 SQLCIPHER_API int sqlcipher3_diskfull = 0;
33607 #define SimulateIOErrorBenign(X) sqlcipher3_io_error_benign=(X)
33608 #define SimulateIOError(CODE)  \
33609   if( (sqlcipher3_io_error_persist && sqlcipher3_io_error_hit) \
33610        || sqlcipher3_io_error_pending-- == 1 )  \
33611               { local_ioerr(); CODE; }
33612 static void local_ioerr(){
33613   IOTRACE(("IOERR\n"));
33614   sqlcipher3_io_error_hit++;
33615   if( !sqlcipher3_io_error_benign ) sqlcipher3_io_error_hardhit++;
33616 }
33617 #define SimulateDiskfullError(CODE) \
33618    if( sqlcipher3_diskfull_pending ){ \
33619      if( sqlcipher3_diskfull_pending == 1 ){ \
33620        local_ioerr(); \
33621        sqlcipher3_diskfull = 1; \
33622        sqlcipher3_io_error_hit = 1; \
33623        CODE; \
33624      }else{ \
33625        sqlcipher3_diskfull_pending--; \
33626      } \
33627    }
33628 #else
33629 #define SimulateIOErrorBenign(X)
33630 #define SimulateIOError(A)
33631 #define SimulateDiskfullError(A)
33632 #endif
33633
33634 /*
33635 ** When testing, keep a count of the number of open files.
33636 */
33637 #ifdef SQLCIPHER_TEST
33638 SQLCIPHER_API int sqlcipher3_open_file_count = 0;
33639 #define OpenCounter(X)  sqlcipher3_open_file_count+=(X)
33640 #else
33641 #define OpenCounter(X)
33642 #endif
33643
33644 #endif /* !defined(_OS_COMMON_H_) */
33645
33646 /************** End of os_common.h *******************************************/
33647 /************** Continuing where we left off in os_win.c *********************/
33648
33649 /*
33650 ** Some microsoft compilers lack this definition.
33651 */
33652 #ifndef INVALID_FILE_ATTRIBUTES
33653 # define INVALID_FILE_ATTRIBUTES ((DWORD)-1) 
33654 #endif
33655
33656 /*
33657 ** Determine if we are dealing with WindowsCE - which has a much
33658 ** reduced API.
33659 */
33660 #if SQLCIPHER_OS_WINCE
33661 # define AreFileApisANSI() 1
33662 # define FormatMessageW(a,b,c,d,e,f,g) 0
33663 #endif
33664
33665 /* Forward references */
33666 typedef struct winShm winShm;           /* A connection to shared-memory */
33667 typedef struct winShmNode winShmNode;   /* A region of shared-memory */
33668
33669 /*
33670 ** WinCE lacks native support for file locking so we have to fake it
33671 ** with some code of our own.
33672 */
33673 #if SQLCIPHER_OS_WINCE
33674 typedef struct winceLock {
33675   int nReaders;       /* Number of reader locks obtained */
33676   BOOL bPending;      /* Indicates a pending lock has been obtained */
33677   BOOL bReserved;     /* Indicates a reserved lock has been obtained */
33678   BOOL bExclusive;    /* Indicates an exclusive lock has been obtained */
33679 } winceLock;
33680 #endif
33681
33682 /*
33683 ** The winFile structure is a subclass of sqlcipher3_file* specific to the win32
33684 ** portability layer.
33685 */
33686 typedef struct winFile winFile;
33687 struct winFile {
33688   const sqlcipher3_io_methods *pMethod; /*** Must be first ***/
33689   sqlcipher3_vfs *pVfs;      /* The VFS used to open this file */
33690   HANDLE h;               /* Handle for accessing the file */
33691   u8 locktype;            /* Type of lock currently held on this file */
33692   short sharedLockByte;   /* Randomly chosen byte used as a shared lock */
33693   u8 bPersistWal;         /* True to persist WAL files */
33694   DWORD lastErrno;        /* The Windows errno from the last I/O error */
33695   DWORD sectorSize;       /* Sector size of the device file is on */
33696   winShm *pShm;           /* Instance of shared memory on this file */
33697   const char *zPath;      /* Full pathname of this file */
33698   int szChunk;            /* Chunk size configured by FCNTL_CHUNK_SIZE */
33699 #if SQLCIPHER_OS_WINCE
33700   WCHAR *zDeleteOnClose;  /* Name of file to delete when closing */
33701   HANDLE hMutex;          /* Mutex used to control access to shared lock */  
33702   HANDLE hShared;         /* Shared memory segment used for locking */
33703   winceLock local;        /* Locks obtained by this instance of winFile */
33704   winceLock *shared;      /* Global shared lock memory for the file  */
33705 #endif
33706 };
33707
33708 /*
33709  * If compiled with SQLCIPHER_WIN32_MALLOC on Windows, we will use the
33710  * various Win32 API heap functions instead of our own.
33711  */
33712 #ifdef SQLCIPHER_WIN32_MALLOC
33713 /*
33714  * The initial size of the Win32-specific heap.  This value may be zero.
33715  */
33716 #ifndef SQLCIPHER_WIN32_HEAP_INIT_SIZE
33717 #  define SQLCIPHER_WIN32_HEAP_INIT_SIZE ((SQLCIPHER_DEFAULT_CACHE_SIZE) * \
33718                                        (SQLCIPHER_DEFAULT_PAGE_SIZE) + 4194304)
33719 #endif
33720
33721 /*
33722  * The maximum size of the Win32-specific heap.  This value may be zero.
33723  */
33724 #ifndef SQLCIPHER_WIN32_HEAP_MAX_SIZE
33725 #  define SQLCIPHER_WIN32_HEAP_MAX_SIZE  (0)
33726 #endif
33727
33728 /*
33729  * The extra flags to use in calls to the Win32 heap APIs.  This value may be
33730  * zero for the default behavior.
33731  */
33732 #ifndef SQLCIPHER_WIN32_HEAP_FLAGS
33733 #  define SQLCIPHER_WIN32_HEAP_FLAGS     (0)
33734 #endif
33735
33736 /*
33737 ** The winMemData structure stores information required by the Win32-specific
33738 ** sqlcipher3_mem_methods implementation.
33739 */
33740 typedef struct winMemData winMemData;
33741 struct winMemData {
33742 #ifndef NDEBUG
33743   u32 magic;    /* Magic number to detect structure corruption. */
33744 #endif
33745   HANDLE hHeap; /* The handle to our heap. */
33746   BOOL bOwned;  /* Do we own the heap (i.e. destroy it on shutdown)? */
33747 };
33748
33749 #ifndef NDEBUG
33750 #define WINMEM_MAGIC     0x42b2830b
33751 #endif
33752
33753 static struct winMemData win_mem_data = {
33754 #ifndef NDEBUG
33755   WINMEM_MAGIC,
33756 #endif
33757   NULL, FALSE
33758 };
33759
33760 #ifndef NDEBUG
33761 #define winMemAssertMagic() assert( win_mem_data.magic==WINMEM_MAGIC )
33762 #else
33763 #define winMemAssertMagic()
33764 #endif
33765
33766 #define winMemGetHeap() win_mem_data.hHeap
33767
33768 static void *winMemMalloc(int nBytes);
33769 static void winMemFree(void *pPrior);
33770 static void *winMemRealloc(void *pPrior, int nBytes);
33771 static int winMemSize(void *p);
33772 static int winMemRoundup(int n);
33773 static int winMemInit(void *pAppData);
33774 static void winMemShutdown(void *pAppData);
33775
33776 SQLCIPHER_PRIVATE const sqlcipher3_mem_methods *sqlcipher3MemGetWin32(void);
33777 #endif /* SQLCIPHER_WIN32_MALLOC */
33778
33779 /*
33780 ** Forward prototypes.
33781 */
33782 static int getSectorSize(
33783     sqlcipher3_vfs *pVfs,
33784     const char *zRelative     /* UTF-8 file name */
33785 );
33786
33787 /*
33788 ** The following variable is (normally) set once and never changes
33789 ** thereafter.  It records whether the operating system is Win95
33790 ** or WinNT.
33791 **
33792 ** 0:   Operating system unknown.
33793 ** 1:   Operating system is Win95.
33794 ** 2:   Operating system is WinNT.
33795 **
33796 ** In order to facilitate testing on a WinNT system, the test fixture
33797 ** can manually set this value to 1 to emulate Win98 behavior.
33798 */
33799 #ifdef SQLCIPHER_TEST
33800 SQLCIPHER_API int sqlcipher3_os_type = 0;
33801 #else
33802 static int sqlcipher3_os_type = 0;
33803 #endif
33804
33805 /*
33806 ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
33807 ** or WinCE.  Return false (zero) for Win95, Win98, or WinME.
33808 **
33809 ** Here is an interesting observation:  Win95, Win98, and WinME lack
33810 ** the LockFileEx() API.  But we can still statically link against that
33811 ** API as long as we don't call it when running Win95/98/ME.  A call to
33812 ** this routine is used to determine if the host is Win95/98/ME or
33813 ** WinNT/2K/XP so that we will know whether or not we can safely call
33814 ** the LockFileEx() API.
33815 */
33816 #if SQLCIPHER_OS_WINCE
33817 # define isNT()  (1)
33818 #else
33819   static int isNT(void){
33820     if( sqlcipher3_os_type==0 ){
33821       OSVERSIONINFO sInfo;
33822       sInfo.dwOSVersionInfoSize = sizeof(sInfo);
33823       GetVersionEx(&sInfo);
33824       sqlcipher3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
33825     }
33826     return sqlcipher3_os_type==2;
33827   }
33828 #endif /* SQLCIPHER_OS_WINCE */
33829
33830 #ifdef SQLCIPHER_WIN32_MALLOC
33831 /*
33832 ** Allocate nBytes of memory.
33833 */
33834 static void *winMemMalloc(int nBytes){
33835   HANDLE hHeap;
33836   void *p;
33837
33838   winMemAssertMagic();
33839   hHeap = winMemGetHeap();
33840   assert( hHeap!=0 );
33841   assert( hHeap!=INVALID_HANDLE_VALUE );
33842 #ifdef SQLCIPHER_WIN32_MALLOC_VALIDATE
33843   assert ( HeapValidate(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, NULL) );
33844 #endif
33845   assert( nBytes>=0 );
33846   p = HeapAlloc(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
33847   if( !p ){
33848     sqlcipher3_log(SQLCIPHER_NOMEM, "failed to HeapAlloc %u bytes (%d), heap=%p",
33849         nBytes, GetLastError(), (void*)hHeap);
33850   }
33851   return p;
33852 }
33853
33854 /*
33855 ** Free memory.
33856 */
33857 static void winMemFree(void *pPrior){
33858   HANDLE hHeap;
33859
33860   winMemAssertMagic();
33861   hHeap = winMemGetHeap();
33862   assert( hHeap!=0 );
33863   assert( hHeap!=INVALID_HANDLE_VALUE );
33864 #ifdef SQLCIPHER_WIN32_MALLOC_VALIDATE
33865   assert ( HeapValidate(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, pPrior) );
33866 #endif
33867   if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
33868   if( !HeapFree(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, pPrior) ){
33869     sqlcipher3_log(SQLCIPHER_NOMEM, "failed to HeapFree block %p (%d), heap=%p",
33870         pPrior, GetLastError(), (void*)hHeap);
33871   }
33872 }
33873
33874 /*
33875 ** Change the size of an existing memory allocation
33876 */
33877 static void *winMemRealloc(void *pPrior, int nBytes){
33878   HANDLE hHeap;
33879   void *p;
33880
33881   winMemAssertMagic();
33882   hHeap = winMemGetHeap();
33883   assert( hHeap!=0 );
33884   assert( hHeap!=INVALID_HANDLE_VALUE );
33885 #ifdef SQLCIPHER_WIN32_MALLOC_VALIDATE
33886   assert ( HeapValidate(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, pPrior) );
33887 #endif
33888   assert( nBytes>=0 );
33889   if( !pPrior ){
33890     p = HeapAlloc(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
33891   }else{
33892     p = HeapReAlloc(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
33893   }
33894   if( !p ){
33895     sqlcipher3_log(SQLCIPHER_NOMEM, "failed to %s %u bytes (%d), heap=%p",
33896         pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, GetLastError(),
33897         (void*)hHeap);
33898   }
33899   return p;
33900 }
33901
33902 /*
33903 ** Return the size of an outstanding allocation, in bytes.
33904 */
33905 static int winMemSize(void *p){
33906   HANDLE hHeap;
33907   SIZE_T n;
33908
33909   winMemAssertMagic();
33910   hHeap = winMemGetHeap();
33911   assert( hHeap!=0 );
33912   assert( hHeap!=INVALID_HANDLE_VALUE );
33913 #ifdef SQLCIPHER_WIN32_MALLOC_VALIDATE
33914   assert ( HeapValidate(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, NULL) );
33915 #endif
33916   if( !p ) return 0;
33917   n = HeapSize(hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, p);
33918   if( n==(SIZE_T)-1 ){
33919     sqlcipher3_log(SQLCIPHER_NOMEM, "failed to HeapSize block %p (%d), heap=%p",
33920         p, GetLastError(), (void*)hHeap);
33921     return 0;
33922   }
33923   return (int)n;
33924 }
33925
33926 /*
33927 ** Round up a request size to the next valid allocation size.
33928 */
33929 static int winMemRoundup(int n){
33930   return n;
33931 }
33932
33933 /*
33934 ** Initialize this module.
33935 */
33936 static int winMemInit(void *pAppData){
33937   winMemData *pWinMemData = (winMemData *)pAppData;
33938
33939   if( !pWinMemData ) return SQLCIPHER_ERROR;
33940   assert( pWinMemData->magic==WINMEM_MAGIC );
33941   if( !pWinMemData->hHeap ){
33942     pWinMemData->hHeap = HeapCreate(SQLCIPHER_WIN32_HEAP_FLAGS,
33943                                     SQLCIPHER_WIN32_HEAP_INIT_SIZE,
33944                                     SQLCIPHER_WIN32_HEAP_MAX_SIZE);
33945     if( !pWinMemData->hHeap ){
33946       sqlcipher3_log(SQLCIPHER_NOMEM,
33947           "failed to HeapCreate (%d), flags=%u, initSize=%u, maxSize=%u",
33948           GetLastError(), SQLCIPHER_WIN32_HEAP_FLAGS, SQLCIPHER_WIN32_HEAP_INIT_SIZE,
33949           SQLCIPHER_WIN32_HEAP_MAX_SIZE);
33950       return SQLCIPHER_NOMEM;
33951     }
33952     pWinMemData->bOwned = TRUE;
33953   }
33954   assert( pWinMemData->hHeap!=0 );
33955   assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
33956 #ifdef SQLCIPHER_WIN32_MALLOC_VALIDATE
33957   assert( HeapValidate(pWinMemData->hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, NULL) );
33958 #endif
33959   return SQLCIPHER_OK;
33960 }
33961
33962 /*
33963 ** Deinitialize this module.
33964 */
33965 static void winMemShutdown(void *pAppData){
33966   winMemData *pWinMemData = (winMemData *)pAppData;
33967
33968   if( !pWinMemData ) return;
33969   if( pWinMemData->hHeap ){
33970     assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
33971 #ifdef SQLCIPHER_WIN32_MALLOC_VALIDATE
33972     assert( HeapValidate(pWinMemData->hHeap, SQLCIPHER_WIN32_HEAP_FLAGS, NULL) );
33973 #endif
33974     if( pWinMemData->bOwned ){
33975       if( !HeapDestroy(pWinMemData->hHeap) ){
33976         sqlcipher3_log(SQLCIPHER_NOMEM, "failed to HeapDestroy (%d), heap=%p",
33977             GetLastError(), (void*)pWinMemData->hHeap);
33978       }
33979       pWinMemData->bOwned = FALSE;
33980     }
33981     pWinMemData->hHeap = NULL;
33982   }
33983 }
33984
33985 /*
33986 ** Populate the low-level memory allocation function pointers in
33987 ** sqlcipher3GlobalConfig.m with pointers to the routines in this file. The
33988 ** arguments specify the block of memory to manage.
33989 **
33990 ** This routine is only called by sqlcipher3_config(), and therefore
33991 ** is not required to be threadsafe (it is not).
33992 */
33993 SQLCIPHER_PRIVATE const sqlcipher3_mem_methods *sqlcipher3MemGetWin32(void){
33994   static const sqlcipher3_mem_methods winMemMethods = {
33995     winMemMalloc,
33996     winMemFree,
33997     winMemRealloc,
33998     winMemSize,
33999     winMemRoundup,
34000     winMemInit,
34001     winMemShutdown,
34002     &win_mem_data
34003   };
34004   return &winMemMethods;
34005 }
34006
34007 SQLCIPHER_PRIVATE void sqlcipher3MemSetDefault(void){
34008   sqlcipher3_config(SQLCIPHER_CONFIG_MALLOC, sqlcipher3MemGetWin32());
34009 }
34010 #endif /* SQLCIPHER_WIN32_MALLOC */
34011
34012 /*
34013 ** Convert a UTF-8 string to microsoft unicode (UTF-16?). 
34014 **
34015 ** Space to hold the returned string is obtained from malloc.
34016 */
34017 static WCHAR *utf8ToUnicode(const char *zFilename){
34018   int nChar;
34019   WCHAR *zWideFilename;
34020
34021   nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
34022   zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
34023   if( zWideFilename==0 ){
34024     return 0;
34025   }
34026   nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
34027   if( nChar==0 ){
34028     free(zWideFilename);
34029     zWideFilename = 0;
34030   }
34031   return zWideFilename;
34032 }
34033
34034 /*
34035 ** Convert microsoft unicode to UTF-8.  Space to hold the returned string is
34036 ** obtained from malloc().
34037 */
34038 static char *unicodeToUtf8(const WCHAR *zWideFilename){
34039   int nByte;
34040   char *zFilename;
34041
34042   nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
34043   zFilename = malloc( nByte );
34044   if( zFilename==0 ){
34045     return 0;
34046   }
34047   nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
34048                               0, 0);
34049   if( nByte == 0 ){
34050     free(zFilename);
34051     zFilename = 0;
34052   }
34053   return zFilename;
34054 }
34055
34056 /*
34057 ** Convert an ansi string to microsoft unicode, based on the
34058 ** current codepage settings for file apis.
34059 ** 
34060 ** Space to hold the returned string is obtained
34061 ** from malloc.
34062 */
34063 static WCHAR *mbcsToUnicode(const char *zFilename){
34064   int nByte;
34065   WCHAR *zMbcsFilename;
34066   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
34067
34068   nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
34069   zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
34070   if( zMbcsFilename==0 ){
34071     return 0;
34072   }
34073   nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
34074   if( nByte==0 ){
34075     free(zMbcsFilename);
34076     zMbcsFilename = 0;
34077   }
34078   return zMbcsFilename;
34079 }
34080
34081 /*
34082 ** Convert microsoft unicode to multibyte character string, based on the
34083 ** user's Ansi codepage.
34084 **
34085 ** Space to hold the returned string is obtained from
34086 ** malloc().
34087 */
34088 static char *unicodeToMbcs(const WCHAR *zWideFilename){
34089   int nByte;
34090   char *zFilename;
34091   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
34092
34093   nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
34094   zFilename = malloc( nByte );
34095   if( zFilename==0 ){
34096     return 0;
34097   }
34098   nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
34099                               0, 0);
34100   if( nByte == 0 ){
34101     free(zFilename);
34102     zFilename = 0;
34103   }
34104   return zFilename;
34105 }
34106
34107 /*
34108 ** Convert multibyte character string to UTF-8.  Space to hold the
34109 ** returned string is obtained from malloc().
34110 */
34111 SQLCIPHER_API char *sqlcipher3_win32_mbcs_to_utf8(const char *zFilename){
34112   char *zFilenameUtf8;
34113   WCHAR *zTmpWide;
34114
34115   zTmpWide = mbcsToUnicode(zFilename);
34116   if( zTmpWide==0 ){
34117     return 0;
34118   }
34119   zFilenameUtf8 = unicodeToUtf8(zTmpWide);
34120   free(zTmpWide);
34121   return zFilenameUtf8;
34122 }
34123
34124 /*
34125 ** Convert UTF-8 to multibyte character string.  Space to hold the 
34126 ** returned string is obtained from malloc().
34127 */
34128 SQLCIPHER_API char *sqlcipher3_win32_utf8_to_mbcs(const char *zFilename){
34129   char *zFilenameMbcs;
34130   WCHAR *zTmpWide;
34131
34132   zTmpWide = utf8ToUnicode(zFilename);
34133   if( zTmpWide==0 ){
34134     return 0;
34135   }
34136   zFilenameMbcs = unicodeToMbcs(zTmpWide);
34137   free(zTmpWide);
34138   return zFilenameMbcs;
34139 }
34140
34141
34142 /*
34143 ** The return value of getLastErrorMsg
34144 ** is zero if the error message fits in the buffer, or non-zero
34145 ** otherwise (if the message was truncated).
34146 */
34147 static int getLastErrorMsg(int nBuf, char *zBuf){
34148   /* FormatMessage returns 0 on failure.  Otherwise it
34149   ** returns the number of TCHARs written to the output
34150   ** buffer, excluding the terminating null char.
34151   */
34152   DWORD error = GetLastError();
34153   DWORD dwLen = 0;
34154   char *zOut = 0;
34155
34156   if( isNT() ){
34157     WCHAR *zTempWide = NULL;
34158     dwLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
34159                            NULL,
34160                            error,
34161                            0,
34162                            (LPWSTR) &zTempWide,
34163                            0,
34164                            0);
34165     if( dwLen > 0 ){
34166       /* allocate a buffer and convert to UTF8 */
34167       zOut = unicodeToUtf8(zTempWide);
34168       /* free the system buffer allocated by FormatMessage */
34169       LocalFree(zTempWide);
34170     }
34171 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
34172 ** Since the ASCII version of these Windows API do not exist for WINCE,
34173 ** it's important to not reference them for WINCE builds.
34174 */
34175 #if SQLCIPHER_OS_WINCE==0
34176   }else{
34177     char *zTemp = NULL;
34178     dwLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
34179                            NULL,
34180                            error,
34181                            0,
34182                            (LPSTR) &zTemp,
34183                            0,
34184                            0);
34185     if( dwLen > 0 ){
34186       /* allocate a buffer and convert to UTF8 */
34187       zOut = sqlcipher3_win32_mbcs_to_utf8(zTemp);
34188       /* free the system buffer allocated by FormatMessage */
34189       LocalFree(zTemp);
34190     }
34191 #endif
34192   }
34193   if( 0 == dwLen ){
34194     sqlcipher3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
34195   }else{
34196     /* copy a maximum of nBuf chars to output buffer */
34197     sqlcipher3_snprintf(nBuf, zBuf, "%s", zOut);
34198     /* free the UTF8 buffer */
34199     free(zOut);
34200   }
34201   return 0;
34202 }
34203
34204 /*
34205 **
34206 ** This function - winLogErrorAtLine() - is only ever called via the macro
34207 ** winLogError().
34208 **
34209 ** This routine is invoked after an error occurs in an OS function.
34210 ** It logs a message using sqlcipher3_log() containing the current value of
34211 ** error code and, if possible, the human-readable equivalent from 
34212 ** FormatMessage.
34213 **
34214 ** The first argument passed to the macro should be the error code that
34215 ** will be returned to SQLite (e.g. SQLCIPHER_IOERR_DELETE, SQLCIPHER_CANTOPEN). 
34216 ** The two subsequent arguments should be the name of the OS function that
34217 ** failed and the the associated file-system path, if any.
34218 */
34219 #define winLogError(a,b,c)     winLogErrorAtLine(a,b,c,__LINE__)
34220 static int winLogErrorAtLine(
34221   int errcode,                    /* SQLite error code */
34222   const char *zFunc,              /* Name of OS function that failed */
34223   const char *zPath,              /* File path associated with error */
34224   int iLine                       /* Source line number where error occurred */
34225 ){
34226   char zMsg[500];                 /* Human readable error text */
34227   int i;                          /* Loop counter */
34228   DWORD iErrno = GetLastError();  /* Error code */
34229
34230   zMsg[0] = 0;
34231   getLastErrorMsg(sizeof(zMsg), zMsg);
34232   assert( errcode!=SQLCIPHER_OK );
34233   if( zPath==0 ) zPath = "";
34234   for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){}
34235   zMsg[i] = 0;
34236   sqlcipher3_log(errcode,
34237       "os_win.c:%d: (%d) %s(%s) - %s",
34238       iLine, iErrno, zFunc, zPath, zMsg
34239   );
34240
34241   return errcode;
34242 }
34243
34244 /*
34245 ** The number of times that a ReadFile(), WriteFile(), and DeleteFile()
34246 ** will be retried following a locking error - probably caused by 
34247 ** antivirus software.  Also the initial delay before the first retry.
34248 ** The delay increases linearly with each retry.
34249 */
34250 #ifndef SQLCIPHER_WIN32_IOERR_RETRY
34251 # define SQLCIPHER_WIN32_IOERR_RETRY 10
34252 #endif
34253 #ifndef SQLCIPHER_WIN32_IOERR_RETRY_DELAY
34254 # define SQLCIPHER_WIN32_IOERR_RETRY_DELAY 25
34255 #endif
34256 static int win32IoerrRetry = SQLCIPHER_WIN32_IOERR_RETRY;
34257 static int win32IoerrRetryDelay = SQLCIPHER_WIN32_IOERR_RETRY_DELAY;
34258
34259 /*
34260 ** If a ReadFile() or WriteFile() error occurs, invoke this routine
34261 ** to see if it should be retried.  Return TRUE to retry.  Return FALSE
34262 ** to give up with an error.
34263 */
34264 static int retryIoerr(int *pnRetry){
34265   DWORD e;
34266   if( *pnRetry>=win32IoerrRetry ){
34267     return 0;
34268   }
34269   e = GetLastError();
34270   if( e==ERROR_ACCESS_DENIED ||
34271       e==ERROR_LOCK_VIOLATION ||
34272       e==ERROR_SHARING_VIOLATION ){
34273     Sleep(win32IoerrRetryDelay*(1+*pnRetry));
34274     ++*pnRetry;
34275     return 1;
34276   }
34277   return 0;
34278 }
34279
34280 /*
34281 ** Log a I/O error retry episode.
34282 */
34283 static void logIoerr(int nRetry){
34284   if( nRetry ){
34285     sqlcipher3_log(SQLCIPHER_IOERR, 
34286       "delayed %dms for lock/sharing conflict",
34287       win32IoerrRetryDelay*nRetry*(nRetry+1)/2
34288     );
34289   }
34290 }
34291
34292 #if SQLCIPHER_OS_WINCE
34293 /*************************************************************************
34294 ** This section contains code for WinCE only.
34295 */
34296 /*
34297 ** WindowsCE does not have a localtime() function.  So create a
34298 ** substitute.
34299 */
34300 /* #include <time.h> */
34301 struct tm *__cdecl localtime(const time_t *t)
34302 {
34303   static struct tm y;
34304   FILETIME uTm, lTm;
34305   SYSTEMTIME pTm;
34306   sqlcipher3_int64 t64;
34307   t64 = *t;
34308   t64 = (t64 + 11644473600)*10000000;
34309   uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF);
34310   uTm.dwHighDateTime= (DWORD)(t64 >> 32);
34311   FileTimeToLocalFileTime(&uTm,&lTm);
34312   FileTimeToSystemTime(&lTm,&pTm);
34313   y.tm_year = pTm.wYear - 1900;
34314   y.tm_mon = pTm.wMonth - 1;
34315   y.tm_wday = pTm.wDayOfWeek;
34316   y.tm_mday = pTm.wDay;
34317   y.tm_hour = pTm.wHour;
34318   y.tm_min = pTm.wMinute;
34319   y.tm_sec = pTm.wSecond;
34320   return &y;
34321 }
34322
34323 /* This will never be called, but defined to make the code compile */
34324 #define GetTempPathA(a,b)
34325
34326 #define LockFile(a,b,c,d,e)       winceLockFile(&a, b, c, d, e)
34327 #define UnlockFile(a,b,c,d,e)     winceUnlockFile(&a, b, c, d, e)
34328 #define LockFileEx(a,b,c,d,e,f)   winceLockFileEx(&a, b, c, d, e, f)
34329
34330 #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)]
34331
34332 /*
34333 ** Acquire a lock on the handle h
34334 */
34335 static void winceMutexAcquire(HANDLE h){
34336    DWORD dwErr;
34337    do {
34338      dwErr = WaitForSingleObject(h, INFINITE);
34339    } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
34340 }
34341 /*
34342 ** Release a lock acquired by winceMutexAcquire()
34343 */
34344 #define winceMutexRelease(h) ReleaseMutex(h)
34345
34346 /*
34347 ** Create the mutex and shared memory used for locking in the file
34348 ** descriptor pFile
34349 */
34350 static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
34351   WCHAR *zTok;
34352   WCHAR *zName = utf8ToUnicode(zFilename);
34353   BOOL bInit = TRUE;
34354
34355   /* Initialize the local lockdata */
34356   ZeroMemory(&pFile->local, sizeof(pFile->local));
34357
34358   /* Replace the backslashes from the filename and lowercase it
34359   ** to derive a mutex name. */
34360   zTok = CharLowerW(zName);
34361   for (;*zTok;zTok++){
34362     if (*zTok == '\\') *zTok = '_';
34363   }
34364
34365   /* Create/open the named mutex */
34366   pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
34367   if (!pFile->hMutex){
34368     pFile->lastErrno = GetLastError();
34369     winLogError(SQLCIPHER_ERROR, "winceCreateLock1", zFilename);
34370     free(zName);
34371     return FALSE;
34372   }
34373
34374   /* Acquire the mutex before continuing */
34375   winceMutexAcquire(pFile->hMutex);
34376   
34377   /* Since the names of named mutexes, semaphores, file mappings etc are 
34378   ** case-sensitive, take advantage of that by uppercasing the mutex name
34379   ** and using that as the shared filemapping name.
34380   */
34381   CharUpperW(zName);
34382   pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
34383                                        PAGE_READWRITE, 0, sizeof(winceLock),
34384                                        zName);  
34385
34386   /* Set a flag that indicates we're the first to create the memory so it 
34387   ** must be zero-initialized */
34388   if (GetLastError() == ERROR_ALREADY_EXISTS){
34389     bInit = FALSE;
34390   }
34391
34392   free(zName);
34393
34394   /* If we succeeded in making the shared memory handle, map it. */
34395   if (pFile->hShared){
34396     pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared, 
34397              FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
34398     /* If mapping failed, close the shared memory handle and erase it */
34399     if (!pFile->shared){
34400       pFile->lastErrno = GetLastError();
34401       winLogError(SQLCIPHER_ERROR, "winceCreateLock2", zFilename);
34402       CloseHandle(pFile->hShared);
34403       pFile->hShared = NULL;
34404     }
34405   }
34406
34407   /* If shared memory could not be created, then close the mutex and fail */
34408   if (pFile->hShared == NULL){
34409     winceMutexRelease(pFile->hMutex);
34410     CloseHandle(pFile->hMutex);
34411     pFile->hMutex = NULL;
34412     return FALSE;
34413   }
34414   
34415   /* Initialize the shared memory if we're supposed to */
34416   if (bInit) {
34417     ZeroMemory(pFile->shared, sizeof(winceLock));
34418   }
34419
34420   winceMutexRelease(pFile->hMutex);
34421   return TRUE;
34422 }
34423
34424 /*
34425 ** Destroy the part of winFile that deals with wince locks
34426 */
34427 static void winceDestroyLock(winFile *pFile){
34428   if (pFile->hMutex){
34429     /* Acquire the mutex */
34430     winceMutexAcquire(pFile->hMutex);
34431
34432     /* The following blocks should probably assert in debug mode, but they
34433        are to cleanup in case any locks remained open */
34434     if (pFile->local.nReaders){
34435       pFile->shared->nReaders --;
34436     }
34437     if (pFile->local.bReserved){
34438       pFile->shared->bReserved = FALSE;
34439     }
34440     if (pFile->local.bPending){
34441       pFile->shared->bPending = FALSE;
34442     }
34443     if (pFile->local.bExclusive){
34444       pFile->shared->bExclusive = FALSE;
34445     }
34446
34447     /* De-reference and close our copy of the shared memory handle */
34448     UnmapViewOfFile(pFile->shared);
34449     CloseHandle(pFile->hShared);
34450
34451     /* Done with the mutex */
34452     winceMutexRelease(pFile->hMutex);    
34453     CloseHandle(pFile->hMutex);
34454     pFile->hMutex = NULL;
34455   }
34456 }
34457
34458 /* 
34459 ** An implementation of the LockFile() API of windows for wince
34460 */
34461 static BOOL winceLockFile(
34462   HANDLE *phFile,
34463   DWORD dwFileOffsetLow,
34464   DWORD dwFileOffsetHigh,
34465   DWORD nNumberOfBytesToLockLow,
34466   DWORD nNumberOfBytesToLockHigh
34467 ){
34468   winFile *pFile = HANDLE_TO_WINFILE(phFile);
34469   BOOL bReturn = FALSE;
34470
34471   UNUSED_PARAMETER(dwFileOffsetHigh);
34472   UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
34473
34474   if (!pFile->hMutex) return TRUE;
34475   winceMutexAcquire(pFile->hMutex);
34476
34477   /* Wanting an exclusive lock? */
34478   if (dwFileOffsetLow == (DWORD)SHARED_FIRST
34479        && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
34480     if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
34481        pFile->shared->bExclusive = TRUE;
34482        pFile->local.bExclusive = TRUE;
34483        bReturn = TRUE;
34484     }
34485   }
34486
34487   /* Want a read-only lock? */
34488   else if (dwFileOffsetLow == (DWORD)SHARED_FIRST &&
34489            nNumberOfBytesToLockLow == 1){
34490     if (pFile->shared->bExclusive == 0){
34491       pFile->local.nReaders ++;
34492       if (pFile->local.nReaders == 1){
34493         pFile->shared->nReaders ++;
34494       }
34495       bReturn = TRUE;
34496     }
34497   }
34498
34499   /* Want a pending lock? */
34500   else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToLockLow == 1){
34501     /* If no pending lock has been acquired, then acquire it */
34502     if (pFile->shared->bPending == 0) {
34503       pFile->shared->bPending = TRUE;
34504       pFile->local.bPending = TRUE;
34505       bReturn = TRUE;
34506     }
34507   }
34508
34509   /* Want a reserved lock? */
34510   else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
34511     if (pFile->shared->bReserved == 0) {
34512       pFile->shared->bReserved = TRUE;
34513       pFile->local.bReserved = TRUE;
34514       bReturn = TRUE;
34515     }
34516   }
34517
34518   winceMutexRelease(pFile->hMutex);
34519   return bReturn;
34520 }
34521
34522 /*
34523 ** An implementation of the UnlockFile API of windows for wince
34524 */
34525 static BOOL winceUnlockFile(
34526   HANDLE *phFile,
34527   DWORD dwFileOffsetLow,
34528   DWORD dwFileOffsetHigh,
34529   DWORD nNumberOfBytesToUnlockLow,
34530   DWORD nNumberOfBytesToUnlockHigh
34531 ){
34532   winFile *pFile = HANDLE_TO_WINFILE(phFile);
34533   BOOL bReturn = FALSE;
34534
34535   UNUSED_PARAMETER(dwFileOffsetHigh);
34536   UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh);
34537
34538   if (!pFile->hMutex) return TRUE;
34539   winceMutexAcquire(pFile->hMutex);
34540
34541   /* Releasing a reader lock or an exclusive lock */
34542   if (dwFileOffsetLow == (DWORD)SHARED_FIRST){
34543     /* Did we have an exclusive lock? */
34544     if (pFile->local.bExclusive){
34545       assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
34546       pFile->local.bExclusive = FALSE;
34547       pFile->shared->bExclusive = FALSE;
34548       bReturn = TRUE;
34549     }
34550
34551     /* Did we just have a reader lock? */
34552     else if (pFile->local.nReaders){
34553       assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE || nNumberOfBytesToUnlockLow == 1);
34554       pFile->local.nReaders --;
34555       if (pFile->local.nReaders == 0)
34556       {
34557         pFile->shared->nReaders --;
34558       }
34559       bReturn = TRUE;
34560     }
34561   }
34562
34563   /* Releasing a pending lock */
34564   else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
34565     if (pFile->local.bPending){
34566       pFile->local.bPending = FALSE;
34567       pFile->shared->bPending = FALSE;
34568       bReturn = TRUE;
34569     }
34570   }
34571   /* Releasing a reserved lock */
34572   else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
34573     if (pFile->local.bReserved) {
34574       pFile->local.bReserved = FALSE;
34575       pFile->shared->bReserved = FALSE;
34576       bReturn = TRUE;
34577     }
34578   }
34579
34580   winceMutexRelease(pFile->hMutex);
34581   return bReturn;
34582 }
34583
34584 /*
34585 ** An implementation of the LockFileEx() API of windows for wince
34586 */
34587 static BOOL winceLockFileEx(
34588   HANDLE *phFile,
34589   DWORD dwFlags,
34590   DWORD dwReserved,
34591   DWORD nNumberOfBytesToLockLow,
34592   DWORD nNumberOfBytesToLockHigh,
34593   LPOVERLAPPED lpOverlapped
34594 ){
34595   UNUSED_PARAMETER(dwReserved);
34596   UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
34597
34598   /* If the caller wants a shared read lock, forward this call
34599   ** to winceLockFile */
34600   if (lpOverlapped->Offset == (DWORD)SHARED_FIRST &&
34601       dwFlags == 1 &&
34602       nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
34603     return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
34604   }
34605   return FALSE;
34606 }
34607 /*
34608 ** End of the special code for wince
34609 *****************************************************************************/
34610 #endif /* SQLCIPHER_OS_WINCE */
34611
34612 /*****************************************************************************
34613 ** The next group of routines implement the I/O methods specified
34614 ** by the sqlcipher3_io_methods object.
34615 ******************************************************************************/
34616
34617 /*
34618 ** Some microsoft compilers lack this definition.
34619 */
34620 #ifndef INVALID_SET_FILE_POINTER
34621 # define INVALID_SET_FILE_POINTER ((DWORD)-1)
34622 #endif
34623
34624 /*
34625 ** Move the current position of the file handle passed as the first 
34626 ** argument to offset iOffset within the file. If successful, return 0. 
34627 ** Otherwise, set pFile->lastErrno and return non-zero.
34628 */
34629 static int seekWinFile(winFile *pFile, sqlcipher3_int64 iOffset){
34630   LONG upperBits;                 /* Most sig. 32 bits of new offset */
34631   LONG lowerBits;                 /* Least sig. 32 bits of new offset */
34632   DWORD dwRet;                    /* Value returned by SetFilePointer() */
34633
34634   upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
34635   lowerBits = (LONG)(iOffset & 0xffffffff);
34636
34637   /* API oddity: If successful, SetFilePointer() returns a dword 
34638   ** containing the lower 32-bits of the new file-offset. Or, if it fails,
34639   ** it returns INVALID_SET_FILE_POINTER. However according to MSDN, 
34640   ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine 
34641   ** whether an error has actually occured, it is also necessary to call 
34642   ** GetLastError().
34643   */
34644   dwRet = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
34645   if( (dwRet==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR) ){
34646     pFile->lastErrno = GetLastError();
34647     winLogError(SQLCIPHER_IOERR_SEEK, "seekWinFile", pFile->zPath);
34648     return 1;
34649   }
34650
34651   return 0;
34652 }
34653
34654 /*
34655 ** Close a file.
34656 **
34657 ** It is reported that an attempt to close a handle might sometimes
34658 ** fail.  This is a very unreasonable result, but windows is notorious
34659 ** for being unreasonable so I do not doubt that it might happen.  If
34660 ** the close fails, we pause for 100 milliseconds and try again.  As
34661 ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
34662 ** giving up and returning an error.
34663 */
34664 #define MX_CLOSE_ATTEMPT 3
34665 static int winClose(sqlcipher3_file *id){
34666   int rc, cnt = 0;
34667   winFile *pFile = (winFile*)id;
34668
34669   assert( id!=0 );
34670   assert( pFile->pShm==0 );
34671   OSTRACE(("CLOSE %d\n", pFile->h));
34672   do{
34673     rc = CloseHandle(pFile->h);
34674     /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */
34675   }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
34676 #if SQLCIPHER_OS_WINCE
34677 #define WINCE_DELETION_ATTEMPTS 3
34678   winceDestroyLock(pFile);
34679   if( pFile->zDeleteOnClose ){
34680     int cnt = 0;
34681     while(
34682            DeleteFileW(pFile->zDeleteOnClose)==0
34683         && GetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff 
34684         && cnt++ < WINCE_DELETION_ATTEMPTS
34685     ){
34686        Sleep(100);  /* Wait a little before trying again */
34687     }
34688     free(pFile->zDeleteOnClose);
34689   }
34690 #endif
34691   OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
34692   OpenCounter(-1);
34693   return rc ? SQLCIPHER_OK
34694             : winLogError(SQLCIPHER_IOERR_CLOSE, "winClose", pFile->zPath);
34695 }
34696
34697 /*
34698 ** Read data from a file into a buffer.  Return SQLCIPHER_OK if all
34699 ** bytes were read successfully and SQLCIPHER_IOERR if anything goes
34700 ** wrong.
34701 */
34702 static int winRead(
34703   sqlcipher3_file *id,          /* File to read from */
34704   void *pBuf,                /* Write content into this buffer */
34705   int amt,                   /* Number of bytes to read */
34706   sqlcipher3_int64 offset       /* Begin reading at this offset */
34707 ){
34708   winFile *pFile = (winFile*)id;  /* file handle */
34709   DWORD nRead;                    /* Number of bytes actually read from file */
34710   int nRetry = 0;                 /* Number of retrys */
34711
34712   assert( id!=0 );
34713   SimulateIOError(return SQLCIPHER_IOERR_READ);
34714   OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
34715
34716   if( seekWinFile(pFile, offset) ){
34717     return SQLCIPHER_FULL;
34718   }
34719   while( !ReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
34720     if( retryIoerr(&nRetry) ) continue;
34721     pFile->lastErrno = GetLastError();
34722     return winLogError(SQLCIPHER_IOERR_READ, "winRead", pFile->zPath);
34723   }
34724   logIoerr(nRetry);
34725   if( nRead<(DWORD)amt ){
34726     /* Unread parts of the buffer must be zero-filled */
34727     memset(&((char*)pBuf)[nRead], 0, amt-nRead);
34728     return SQLCIPHER_IOERR_SHORT_READ;
34729   }
34730
34731   return SQLCIPHER_OK;
34732 }
34733
34734 /*
34735 ** Write data from a buffer into a file.  Return SQLCIPHER_OK on success
34736 ** or some other error code on failure.
34737 */
34738 static int winWrite(
34739   sqlcipher3_file *id,               /* File to write into */
34740   const void *pBuf,               /* The bytes to be written */
34741   int amt,                        /* Number of bytes to write */
34742   sqlcipher3_int64 offset            /* Offset into the file to begin writing at */
34743 ){
34744   int rc;                         /* True if error has occured, else false */
34745   winFile *pFile = (winFile*)id;  /* File handle */
34746   int nRetry = 0;                 /* Number of retries */
34747
34748   assert( amt>0 );
34749   assert( pFile );
34750   SimulateIOError(return SQLCIPHER_IOERR_WRITE);
34751   SimulateDiskfullError(return SQLCIPHER_FULL);
34752
34753   OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype));
34754
34755   rc = seekWinFile(pFile, offset);
34756   if( rc==0 ){
34757     u8 *aRem = (u8 *)pBuf;        /* Data yet to be written */
34758     int nRem = amt;               /* Number of bytes yet to be written */
34759     DWORD nWrite;                 /* Bytes written by each WriteFile() call */
34760
34761     while( nRem>0 ){
34762       if( !WriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
34763         if( retryIoerr(&nRetry) ) continue;
34764         break;
34765       }
34766       if( nWrite<=0 ) break;
34767       aRem += nWrite;
34768       nRem -= nWrite;
34769     }
34770     if( nRem>0 ){
34771       pFile->lastErrno = GetLastError();
34772       rc = 1;
34773     }
34774   }
34775
34776   if( rc ){
34777     if(   ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
34778        || ( pFile->lastErrno==ERROR_DISK_FULL )){
34779       return SQLCIPHER_FULL;
34780     }
34781     return winLogError(SQLCIPHER_IOERR_WRITE, "winWrite", pFile->zPath);
34782   }else{
34783     logIoerr(nRetry);
34784   }
34785   return SQLCIPHER_OK;
34786 }
34787
34788 /*
34789 ** Truncate an open file to a specified size
34790 */
34791 static int winTruncate(sqlcipher3_file *id, sqlcipher3_int64 nByte){
34792   winFile *pFile = (winFile*)id;  /* File handle object */
34793   int rc = SQLCIPHER_OK;             /* Return code for this function */
34794
34795   assert( pFile );
34796
34797   OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
34798   SimulateIOError(return SQLCIPHER_IOERR_TRUNCATE);
34799
34800   /* If the user has configured a chunk-size for this file, truncate the
34801   ** file so that it consists of an integer number of chunks (i.e. the
34802   ** actual file size after the operation may be larger than the requested
34803   ** size).
34804   */
34805   if( pFile->szChunk>0 ){
34806     nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
34807   }
34808
34809   /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
34810   if( seekWinFile(pFile, nByte) ){
34811     rc = winLogError(SQLCIPHER_IOERR_TRUNCATE, "winTruncate1", pFile->zPath);
34812   }else if( 0==SetEndOfFile(pFile->h) ){
34813     pFile->lastErrno = GetLastError();
34814     rc = winLogError(SQLCIPHER_IOERR_TRUNCATE, "winTruncate2", pFile->zPath);
34815   }
34816
34817   OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
34818   return rc;
34819 }
34820
34821 #ifdef SQLCIPHER_TEST
34822 /*
34823 ** Count the number of fullsyncs and normal syncs.  This is used to test
34824 ** that syncs and fullsyncs are occuring at the right times.
34825 */
34826 SQLCIPHER_API int sqlcipher3_sync_count = 0;
34827 SQLCIPHER_API int sqlcipher3_fullsync_count = 0;
34828 #endif
34829
34830 /*
34831 ** Make sure all writes to a particular file are committed to disk.
34832 */
34833 static int winSync(sqlcipher3_file *id, int flags){
34834 #ifndef SQLCIPHER_NO_SYNC
34835   /*
34836   ** Used only when SQLCIPHER_NO_SYNC is not defined.
34837    */
34838   BOOL rc;
34839 #endif
34840 #if !defined(NDEBUG) || !defined(SQLCIPHER_NO_SYNC) || \
34841     (defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG))
34842   /*
34843   ** Used when SQLCIPHER_NO_SYNC is not defined and by the assert() and/or
34844   ** OSTRACE() macros.
34845    */
34846   winFile *pFile = (winFile*)id;
34847 #else
34848   UNUSED_PARAMETER(id);
34849 #endif
34850
34851   assert( pFile );
34852   /* Check that one of SQLCIPHER_SYNC_NORMAL or FULL was passed */
34853   assert((flags&0x0F)==SQLCIPHER_SYNC_NORMAL
34854       || (flags&0x0F)==SQLCIPHER_SYNC_FULL
34855   );
34856
34857   OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
34858
34859   /* Unix cannot, but some systems may return SQLCIPHER_FULL from here. This
34860   ** line is to test that doing so does not cause any problems.
34861   */
34862   SimulateDiskfullError( return SQLCIPHER_FULL );
34863
34864 #ifndef SQLCIPHER_TEST
34865   UNUSED_PARAMETER(flags);
34866 #else
34867   if( (flags&0x0F)==SQLCIPHER_SYNC_FULL ){
34868     sqlcipher3_fullsync_count++;
34869   }
34870   sqlcipher3_sync_count++;
34871 #endif
34872
34873   /* If we compiled with the SQLCIPHER_NO_SYNC flag, then syncing is a
34874   ** no-op
34875   */
34876 #ifdef SQLCIPHER_NO_SYNC
34877   return SQLCIPHER_OK;
34878 #else
34879   rc = FlushFileBuffers(pFile->h);
34880   SimulateIOError( rc=FALSE );
34881   if( rc ){
34882     return SQLCIPHER_OK;
34883   }else{
34884     pFile->lastErrno = GetLastError();
34885     return winLogError(SQLCIPHER_IOERR_FSYNC, "winSync", pFile->zPath);
34886   }
34887 #endif
34888 }
34889
34890 /*
34891 ** Determine the current size of a file in bytes
34892 */
34893 static int winFileSize(sqlcipher3_file *id, sqlcipher3_int64 *pSize){
34894   DWORD upperBits;
34895   DWORD lowerBits;
34896   winFile *pFile = (winFile*)id;
34897   DWORD error;
34898
34899   assert( id!=0 );
34900   SimulateIOError(return SQLCIPHER_IOERR_FSTAT);
34901   lowerBits = GetFileSize(pFile->h, &upperBits);
34902   if(   (lowerBits == INVALID_FILE_SIZE)
34903      && ((error = GetLastError()) != NO_ERROR) )
34904   {
34905     pFile->lastErrno = error;
34906     return winLogError(SQLCIPHER_IOERR_FSTAT, "winFileSize", pFile->zPath);
34907   }
34908   *pSize = (((sqlcipher3_int64)upperBits)<<32) + lowerBits;
34909   return SQLCIPHER_OK;
34910 }
34911
34912 /*
34913 ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
34914 */
34915 #ifndef LOCKFILE_FAIL_IMMEDIATELY
34916 # define LOCKFILE_FAIL_IMMEDIATELY 1
34917 #endif
34918
34919 /*
34920 ** Acquire a reader lock.
34921 ** Different API routines are called depending on whether or not this
34922 ** is Win95 or WinNT.
34923 */
34924 static int getReadLock(winFile *pFile){
34925   int res;
34926   if( isNT() ){
34927     OVERLAPPED ovlp;
34928     ovlp.Offset = SHARED_FIRST;
34929     ovlp.OffsetHigh = 0;
34930     ovlp.hEvent = 0;
34931     res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
34932                      0, SHARED_SIZE, 0, &ovlp);
34933 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
34934 */
34935 #if SQLCIPHER_OS_WINCE==0
34936   }else{
34937     int lk;
34938     sqlcipher3_randomness(sizeof(lk), &lk);
34939     pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
34940     res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
34941 #endif
34942   }
34943   if( res == 0 ){
34944     pFile->lastErrno = GetLastError();
34945     /* No need to log a failure to lock */
34946   }
34947   return res;
34948 }
34949
34950 /*
34951 ** Undo a readlock
34952 */
34953 static int unlockReadLock(winFile *pFile){
34954   int res;
34955   if( isNT() ){
34956     res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
34957 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
34958 */
34959 #if SQLCIPHER_OS_WINCE==0
34960   }else{
34961     res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
34962 #endif
34963   }
34964   if( res==0 && GetLastError()!=ERROR_NOT_LOCKED ){
34965     pFile->lastErrno = GetLastError();
34966     winLogError(SQLCIPHER_IOERR_UNLOCK, "unlockReadLock", pFile->zPath);
34967   }
34968   return res;
34969 }
34970
34971 /*
34972 ** Lock the file with the lock specified by parameter locktype - one
34973 ** of the following:
34974 **
34975 **     (1) SHARED_LOCK
34976 **     (2) RESERVED_LOCK
34977 **     (3) PENDING_LOCK
34978 **     (4) EXCLUSIVE_LOCK
34979 **
34980 ** Sometimes when requesting one lock state, additional lock states
34981 ** are inserted in between.  The locking might fail on one of the later
34982 ** transitions leaving the lock state different from what it started but
34983 ** still short of its goal.  The following chart shows the allowed
34984 ** transitions and the inserted intermediate states:
34985 **
34986 **    UNLOCKED -> SHARED
34987 **    SHARED -> RESERVED
34988 **    SHARED -> (PENDING) -> EXCLUSIVE
34989 **    RESERVED -> (PENDING) -> EXCLUSIVE
34990 **    PENDING -> EXCLUSIVE
34991 **
34992 ** This routine will only increase a lock.  The winUnlock() routine
34993 ** erases all locks at once and returns us immediately to locking level 0.
34994 ** It is not possible to lower the locking level one step at a time.  You
34995 ** must go straight to locking level 0.
34996 */
34997 static int winLock(sqlcipher3_file *id, int locktype){
34998   int rc = SQLCIPHER_OK;    /* Return code from subroutines */
34999   int res = 1;           /* Result of a windows lock call */
35000   int newLocktype;       /* Set pFile->locktype to this value before exiting */
35001   int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
35002   winFile *pFile = (winFile*)id;
35003   DWORD error = NO_ERROR;
35004
35005   assert( id!=0 );
35006   OSTRACE(("LOCK %d %d was %d(%d)\n",
35007            pFile->h, locktype, pFile->locktype, pFile->sharedLockByte));
35008
35009   /* If there is already a lock of this type or more restrictive on the
35010   ** OsFile, do nothing. Don't use the end_lock: exit path, as
35011   ** sqlcipher3OsEnterMutex() hasn't been called yet.
35012   */
35013   if( pFile->locktype>=locktype ){
35014     return SQLCIPHER_OK;
35015   }
35016
35017   /* Make sure the locking sequence is correct
35018   */
35019   assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
35020   assert( locktype!=PENDING_LOCK );
35021   assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
35022
35023   /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
35024   ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of
35025   ** the PENDING_LOCK byte is temporary.
35026   */
35027   newLocktype = pFile->locktype;
35028   if(   (pFile->locktype==NO_LOCK)
35029      || (   (locktype==EXCLUSIVE_LOCK)
35030          && (pFile->locktype==RESERVED_LOCK))
35031   ){
35032     int cnt = 3;
35033     while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
35034       /* Try 3 times to get the pending lock.  The pending lock might be
35035       ** held by another reader process who will release it momentarily.
35036       */
35037       OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt));
35038       Sleep(1);
35039     }
35040     gotPendingLock = res;
35041     if( !res ){
35042       error = GetLastError();
35043     }
35044   }
35045
35046   /* Acquire a shared lock
35047   */
35048   if( locktype==SHARED_LOCK && res ){
35049     assert( pFile->locktype==NO_LOCK );
35050     res = getReadLock(pFile);
35051     if( res ){
35052       newLocktype = SHARED_LOCK;
35053     }else{
35054       error = GetLastError();
35055     }
35056   }
35057
35058   /* Acquire a RESERVED lock
35059   */
35060   if( locktype==RESERVED_LOCK && res ){
35061     assert( pFile->locktype==SHARED_LOCK );
35062     res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
35063     if( res ){
35064       newLocktype = RESERVED_LOCK;
35065     }else{
35066       error = GetLastError();
35067     }
35068   }
35069
35070   /* Acquire a PENDING lock
35071   */
35072   if( locktype==EXCLUSIVE_LOCK && res ){
35073     newLocktype = PENDING_LOCK;
35074     gotPendingLock = 0;
35075   }
35076
35077   /* Acquire an EXCLUSIVE lock
35078   */
35079   if( locktype==EXCLUSIVE_LOCK && res ){
35080     assert( pFile->locktype>=SHARED_LOCK );
35081     res = unlockReadLock(pFile);
35082     OSTRACE(("unreadlock = %d\n", res));
35083     res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
35084     if( res ){
35085       newLocktype = EXCLUSIVE_LOCK;
35086     }else{
35087       error = GetLastError();
35088       OSTRACE(("error-code = %d\n", error));
35089       getReadLock(pFile);
35090     }
35091   }
35092
35093   /* If we are holding a PENDING lock that ought to be released, then
35094   ** release it now.
35095   */
35096   if( gotPendingLock && locktype==SHARED_LOCK ){
35097     UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
35098   }
35099
35100   /* Update the state of the lock has held in the file descriptor then
35101   ** return the appropriate result code.
35102   */
35103   if( res ){
35104     rc = SQLCIPHER_OK;
35105   }else{
35106     OSTRACE(("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
35107            locktype, newLocktype));
35108     pFile->lastErrno = error;
35109     rc = SQLCIPHER_BUSY;
35110   }
35111   pFile->locktype = (u8)newLocktype;
35112   return rc;
35113 }
35114
35115 /*
35116 ** This routine checks if there is a RESERVED lock held on the specified
35117 ** file by this or any other process. If such a lock is held, return
35118 ** non-zero, otherwise zero.
35119 */
35120 static int winCheckReservedLock(sqlcipher3_file *id, int *pResOut){
35121   int rc;
35122   winFile *pFile = (winFile*)id;
35123
35124   SimulateIOError( return SQLCIPHER_IOERR_CHECKRESERVEDLOCK; );
35125
35126   assert( id!=0 );
35127   if( pFile->locktype>=RESERVED_LOCK ){
35128     rc = 1;
35129     OSTRACE(("TEST WR-LOCK %d %d (local)\n", pFile->h, rc));
35130   }else{
35131     rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
35132     if( rc ){
35133       UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
35134     }
35135     rc = !rc;
35136     OSTRACE(("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc));
35137   }
35138   *pResOut = rc;
35139   return SQLCIPHER_OK;
35140 }
35141
35142 /*
35143 ** Lower the locking level on file descriptor id to locktype.  locktype
35144 ** must be either NO_LOCK or SHARED_LOCK.
35145 **
35146 ** If the locking level of the file descriptor is already at or below
35147 ** the requested locking level, this routine is a no-op.
35148 **
35149 ** It is not possible for this routine to fail if the second argument
35150 ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
35151 ** might return SQLCIPHER_IOERR;
35152 */
35153 static int winUnlock(sqlcipher3_file *id, int locktype){
35154   int type;
35155   winFile *pFile = (winFile*)id;
35156   int rc = SQLCIPHER_OK;
35157   assert( pFile!=0 );
35158   assert( locktype<=SHARED_LOCK );
35159   OSTRACE(("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
35160           pFile->locktype, pFile->sharedLockByte));
35161   type = pFile->locktype;
35162   if( type>=EXCLUSIVE_LOCK ){
35163     UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
35164     if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
35165       /* This should never happen.  We should always be able to
35166       ** reacquire the read lock */
35167       rc = winLogError(SQLCIPHER_IOERR_UNLOCK, "winUnlock", pFile->zPath);
35168     }
35169   }
35170   if( type>=RESERVED_LOCK ){
35171     UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
35172   }
35173   if( locktype==NO_LOCK && type>=SHARED_LOCK ){
35174     unlockReadLock(pFile);
35175   }
35176   if( type>=PENDING_LOCK ){
35177     UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
35178   }
35179   pFile->locktype = (u8)locktype;
35180   return rc;
35181 }
35182
35183 /*
35184 ** Control and query of the open file handle.
35185 */
35186 static int winFileControl(sqlcipher3_file *id, int op, void *pArg){
35187   winFile *pFile = (winFile*)id;
35188   switch( op ){
35189     case SQLCIPHER_FCNTL_LOCKSTATE: {
35190       *(int*)pArg = pFile->locktype;
35191       return SQLCIPHER_OK;
35192     }
35193     case SQLCIPHER_LAST_ERRNO: {
35194       *(int*)pArg = (int)pFile->lastErrno;
35195       return SQLCIPHER_OK;
35196     }
35197     case SQLCIPHER_FCNTL_CHUNK_SIZE: {
35198       pFile->szChunk = *(int *)pArg;
35199       return SQLCIPHER_OK;
35200     }
35201     case SQLCIPHER_FCNTL_SIZE_HINT: {
35202       if( pFile->szChunk>0 ){
35203         sqlcipher3_int64 oldSz;
35204         int rc = winFileSize(id, &oldSz);
35205         if( rc==SQLCIPHER_OK ){
35206           sqlcipher3_int64 newSz = *(sqlcipher3_int64*)pArg;
35207           if( newSz>oldSz ){
35208             SimulateIOErrorBenign(1);
35209             rc = winTruncate(id, newSz);
35210             SimulateIOErrorBenign(0);
35211           }
35212         }
35213         return rc;
35214       }
35215       return SQLCIPHER_OK;
35216     }
35217     case SQLCIPHER_FCNTL_PERSIST_WAL: {
35218       int bPersist = *(int*)pArg;
35219       if( bPersist<0 ){
35220         *(int*)pArg = pFile->bPersistWal;
35221       }else{
35222         pFile->bPersistWal = bPersist!=0;
35223       }
35224       return SQLCIPHER_OK;
35225     }
35226     case SQLCIPHER_FCNTL_SYNC_OMITTED: {
35227       return SQLCIPHER_OK;
35228     }
35229     case SQLCIPHER_FCNTL_WIN32_AV_RETRY: {
35230       int *a = (int*)pArg;
35231       if( a[0]>0 ){
35232         win32IoerrRetry = a[0];
35233       }else{
35234         a[0] = win32IoerrRetry;
35235       }
35236       if( a[1]>0 ){
35237         win32IoerrRetryDelay = a[1];
35238       }else{
35239         a[1] = win32IoerrRetryDelay;
35240       }
35241       return SQLCIPHER_OK;
35242     }
35243   }
35244   return SQLCIPHER_NOTFOUND;
35245 }
35246
35247 /*
35248 ** Return the sector size in bytes of the underlying block device for
35249 ** the specified file. This is almost always 512 bytes, but may be
35250 ** larger for some devices.
35251 **
35252 ** SQLite code assumes this function cannot fail. It also assumes that
35253 ** if two files are created in the same file-system directory (i.e.
35254 ** a database and its journal file) that the sector size will be the
35255 ** same for both.
35256 */
35257 static int winSectorSize(sqlcipher3_file *id){
35258   assert( id!=0 );
35259   return (int)(((winFile*)id)->sectorSize);
35260 }
35261
35262 /*
35263 ** Return a vector of device characteristics.
35264 */
35265 static int winDeviceCharacteristics(sqlcipher3_file *id){
35266   UNUSED_PARAMETER(id);
35267   return SQLCIPHER_IOCAP_UNDELETABLE_WHEN_OPEN;
35268 }
35269
35270 #ifndef SQLCIPHER_OMIT_WAL
35271
35272 /* 
35273 ** Windows will only let you create file view mappings
35274 ** on allocation size granularity boundaries.
35275 ** During sqlcipher3_os_init() we do a GetSystemInfo()
35276 ** to get the granularity size.
35277 */
35278 SYSTEM_INFO winSysInfo;
35279
35280 /*
35281 ** Helper functions to obtain and relinquish the global mutex. The
35282 ** global mutex is used to protect the winLockInfo objects used by 
35283 ** this file, all of which may be shared by multiple threads.
35284 **
35285 ** Function winShmMutexHeld() is used to assert() that the global mutex 
35286 ** is held when required. This function is only used as part of assert() 
35287 ** statements. e.g.
35288 **
35289 **   winShmEnterMutex()
35290 **     assert( winShmMutexHeld() );
35291 **   winShmLeaveMutex()
35292 */
35293 static void winShmEnterMutex(void){
35294   sqlcipher3_mutex_enter(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
35295 }
35296 static void winShmLeaveMutex(void){
35297   sqlcipher3_mutex_leave(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
35298 }
35299 #ifdef SQLCIPHER_DEBUG
35300 static int winShmMutexHeld(void) {
35301   return sqlcipher3_mutex_held(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
35302 }
35303 #endif
35304
35305 /*
35306 ** Object used to represent a single file opened and mmapped to provide
35307 ** shared memory.  When multiple threads all reference the same
35308 ** log-summary, each thread has its own winFile object, but they all
35309 ** point to a single instance of this object.  In other words, each
35310 ** log-summary is opened only once per process.
35311 **
35312 ** winShmMutexHeld() must be true when creating or destroying
35313 ** this object or while reading or writing the following fields:
35314 **
35315 **      nRef
35316 **      pNext 
35317 **
35318 ** The following fields are read-only after the object is created:
35319 ** 
35320 **      fid
35321 **      zFilename
35322 **
35323 ** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
35324 ** winShmMutexHeld() is true when reading or writing any other field
35325 ** in this structure.
35326 **
35327 */
35328 struct winShmNode {
35329   sqlcipher3_mutex *mutex;      /* Mutex to access this object */
35330   char *zFilename;           /* Name of the file */
35331   winFile hFile;             /* File handle from winOpen */
35332
35333   int szRegion;              /* Size of shared-memory regions */
35334   int nRegion;               /* Size of array apRegion */
35335   struct ShmRegion {
35336     HANDLE hMap;             /* File handle from CreateFileMapping */
35337     void *pMap;
35338   } *aRegion;
35339   DWORD lastErrno;           /* The Windows errno from the last I/O error */
35340
35341   int nRef;                  /* Number of winShm objects pointing to this */
35342   winShm *pFirst;            /* All winShm objects pointing to this */
35343   winShmNode *pNext;         /* Next in list of all winShmNode objects */
35344 #ifdef SQLCIPHER_DEBUG
35345   u8 nextShmId;              /* Next available winShm.id value */
35346 #endif
35347 };
35348
35349 /*
35350 ** A global array of all winShmNode objects.
35351 **
35352 ** The winShmMutexHeld() must be true while reading or writing this list.
35353 */
35354 static winShmNode *winShmNodeList = 0;
35355
35356 /*
35357 ** Structure used internally by this VFS to record the state of an
35358 ** open shared memory connection.
35359 **
35360 ** The following fields are initialized when this object is created and
35361 ** are read-only thereafter:
35362 **
35363 **    winShm.pShmNode
35364 **    winShm.id
35365 **
35366 ** All other fields are read/write.  The winShm.pShmNode->mutex must be held
35367 ** while accessing any read/write fields.
35368 */
35369 struct winShm {
35370   winShmNode *pShmNode;      /* The underlying winShmNode object */
35371   winShm *pNext;             /* Next winShm with the same winShmNode */
35372   u8 hasMutex;               /* True if holding the winShmNode mutex */
35373   u16 sharedMask;            /* Mask of shared locks held */
35374   u16 exclMask;              /* Mask of exclusive locks held */
35375 #ifdef SQLCIPHER_DEBUG
35376   u8 id;                     /* Id of this connection with its winShmNode */
35377 #endif
35378 };
35379
35380 /*
35381 ** Constants used for locking
35382 */
35383 #define WIN_SHM_BASE   ((22+SQLCIPHER_SHM_NLOCK)*4)        /* first lock byte */
35384 #define WIN_SHM_DMS    (WIN_SHM_BASE+SQLCIPHER_SHM_NLOCK)  /* deadman switch */
35385
35386 /*
35387 ** Apply advisory locks for all n bytes beginning at ofst.
35388 */
35389 #define _SHM_UNLCK  1
35390 #define _SHM_RDLCK  2
35391 #define _SHM_WRLCK  3
35392 static int winShmSystemLock(
35393   winShmNode *pFile,    /* Apply locks to this open shared-memory segment */
35394   int lockType,         /* _SHM_UNLCK, _SHM_RDLCK, or _SHM_WRLCK */
35395   int ofst,             /* Offset to first byte to be locked/unlocked */
35396   int nByte             /* Number of bytes to lock or unlock */
35397 ){
35398   OVERLAPPED ovlp;
35399   DWORD dwFlags;
35400   int rc = 0;           /* Result code form Lock/UnlockFileEx() */
35401
35402   /* Access to the winShmNode object is serialized by the caller */
35403   assert( sqlcipher3_mutex_held(pFile->mutex) || pFile->nRef==0 );
35404
35405   /* Initialize the locking parameters */
35406   dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
35407   if( lockType == _SHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
35408
35409   memset(&ovlp, 0, sizeof(OVERLAPPED));
35410   ovlp.Offset = ofst;
35411
35412   /* Release/Acquire the system-level lock */
35413   if( lockType==_SHM_UNLCK ){
35414     rc = UnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
35415   }else{
35416     rc = LockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
35417   }
35418   
35419   if( rc!= 0 ){
35420     rc = SQLCIPHER_OK;
35421   }else{
35422     pFile->lastErrno =  GetLastError();
35423     rc = SQLCIPHER_BUSY;
35424   }
35425
35426   OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n", 
35427            pFile->hFile.h,
35428            rc==SQLCIPHER_OK ? "ok" : "failed",
35429            lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
35430            pFile->lastErrno));
35431
35432   return rc;
35433 }
35434
35435 /* Forward references to VFS methods */
35436 static int winOpen(sqlcipher3_vfs*,const char*,sqlcipher3_file*,int,int*);
35437 static int winDelete(sqlcipher3_vfs *,const char*,int);
35438
35439 /*
35440 ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
35441 **
35442 ** This is not a VFS shared-memory method; it is a utility function called
35443 ** by VFS shared-memory methods.
35444 */
35445 static void winShmPurge(sqlcipher3_vfs *pVfs, int deleteFlag){
35446   winShmNode **pp;
35447   winShmNode *p;
35448   BOOL bRc;
35449   assert( winShmMutexHeld() );
35450   pp = &winShmNodeList;
35451   while( (p = *pp)!=0 ){
35452     if( p->nRef==0 ){
35453       int i;
35454       if( p->mutex ) sqlcipher3_mutex_free(p->mutex);
35455       for(i=0; i<p->nRegion; i++){
35456         bRc = UnmapViewOfFile(p->aRegion[i].pMap);
35457         OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
35458                  (int)GetCurrentProcessId(), i,
35459                  bRc ? "ok" : "failed"));
35460         bRc = CloseHandle(p->aRegion[i].hMap);
35461         OSTRACE(("SHM-PURGE pid-%d close region=%d %s\n",
35462                  (int)GetCurrentProcessId(), i,
35463                  bRc ? "ok" : "failed"));
35464       }
35465       if( p->hFile.h != INVALID_HANDLE_VALUE ){
35466         SimulateIOErrorBenign(1);
35467         winClose((sqlcipher3_file *)&p->hFile);
35468         SimulateIOErrorBenign(0);
35469       }
35470       if( deleteFlag ){
35471         SimulateIOErrorBenign(1);
35472         winDelete(pVfs, p->zFilename, 0);
35473         SimulateIOErrorBenign(0);
35474       }
35475       *pp = p->pNext;
35476       sqlcipher3_free(p->aRegion);
35477       sqlcipher3_free(p);
35478     }else{
35479       pp = &p->pNext;
35480     }
35481   }
35482 }
35483
35484 /*
35485 ** Open the shared-memory area associated with database file pDbFd.
35486 **
35487 ** When opening a new shared-memory file, if no other instances of that
35488 ** file are currently open, in this process or in other processes, then
35489 ** the file must be truncated to zero length or have its header cleared.
35490 */
35491 static int winOpenSharedMemory(winFile *pDbFd){
35492   struct winShm *p;                  /* The connection to be opened */
35493   struct winShmNode *pShmNode = 0;   /* The underlying mmapped file */
35494   int rc;                            /* Result code */
35495   struct winShmNode *pNew;           /* Newly allocated winShmNode */
35496   int nName;                         /* Size of zName in bytes */
35497
35498   assert( pDbFd->pShm==0 );    /* Not previously opened */
35499
35500   /* Allocate space for the new sqlcipher3_shm object.  Also speculatively
35501   ** allocate space for a new winShmNode and filename.
35502   */
35503   p = sqlcipher3_malloc( sizeof(*p) );
35504   if( p==0 ) return SQLCIPHER_NOMEM;
35505   memset(p, 0, sizeof(*p));
35506   nName = sqlcipher3Strlen30(pDbFd->zPath);
35507   pNew = sqlcipher3_malloc( sizeof(*pShmNode) + nName + 15 );
35508   if( pNew==0 ){
35509     sqlcipher3_free(p);
35510     return SQLCIPHER_NOMEM;
35511   }
35512   memset(pNew, 0, sizeof(*pNew));
35513   pNew->zFilename = (char*)&pNew[1];
35514   sqlcipher3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
35515   sqlcipher3FileSuffix3(pDbFd->zPath, pNew->zFilename); 
35516
35517   /* Look to see if there is an existing winShmNode that can be used.
35518   ** If no matching winShmNode currently exists, create a new one.
35519   */
35520   winShmEnterMutex();
35521   for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
35522     /* TBD need to come up with better match here.  Perhaps
35523     ** use FILE_ID_BOTH_DIR_INFO Structure.
35524     */
35525     if( sqlcipher3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
35526   }
35527   if( pShmNode ){
35528     sqlcipher3_free(pNew);
35529   }else{
35530     pShmNode = pNew;
35531     pNew = 0;
35532     ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE;
35533     pShmNode->pNext = winShmNodeList;
35534     winShmNodeList = pShmNode;
35535
35536     pShmNode->mutex = sqlcipher3_mutex_alloc(SQLCIPHER_MUTEX_FAST);
35537     if( pShmNode->mutex==0 ){
35538       rc = SQLCIPHER_NOMEM;
35539       goto shm_open_err;
35540     }
35541
35542     rc = winOpen(pDbFd->pVfs,
35543                  pShmNode->zFilename,             /* Name of the file (UTF-8) */
35544                  (sqlcipher3_file*)&pShmNode->hFile,  /* File handle here */
35545                  SQLCIPHER_OPEN_WAL | SQLCIPHER_OPEN_READWRITE | SQLCIPHER_OPEN_CREATE, /* Mode flags */
35546                  0);
35547     if( SQLCIPHER_OK!=rc ){
35548       rc = SQLCIPHER_CANTOPEN_BKPT;
35549       goto shm_open_err;
35550     }
35551
35552     /* Check to see if another process is holding the dead-man switch.
35553     ** If not, truncate the file to zero length. 
35554     */
35555     if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLCIPHER_OK ){
35556       rc = winTruncate((sqlcipher3_file *)&pShmNode->hFile, 0);
35557       if( rc!=SQLCIPHER_OK ){
35558         rc = winLogError(SQLCIPHER_IOERR_SHMOPEN, "winOpenShm", pDbFd->zPath);
35559       }
35560     }
35561     if( rc==SQLCIPHER_OK ){
35562       winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
35563       rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1);
35564     }
35565     if( rc ) goto shm_open_err;
35566   }
35567
35568   /* Make the new connection a child of the winShmNode */
35569   p->pShmNode = pShmNode;
35570 #ifdef SQLCIPHER_DEBUG
35571   p->id = pShmNode->nextShmId++;
35572 #endif
35573   pShmNode->nRef++;
35574   pDbFd->pShm = p;
35575   winShmLeaveMutex();
35576
35577   /* The reference count on pShmNode has already been incremented under
35578   ** the cover of the winShmEnterMutex() mutex and the pointer from the
35579   ** new (struct winShm) object to the pShmNode has been set. All that is
35580   ** left to do is to link the new object into the linked list starting
35581   ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex 
35582   ** mutex.
35583   */
35584   sqlcipher3_mutex_enter(pShmNode->mutex);
35585   p->pNext = pShmNode->pFirst;
35586   pShmNode->pFirst = p;
35587   sqlcipher3_mutex_leave(pShmNode->mutex);
35588   return SQLCIPHER_OK;
35589
35590   /* Jump here on any error */
35591 shm_open_err:
35592   winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
35593   winShmPurge(pDbFd->pVfs, 0);      /* This call frees pShmNode if required */
35594   sqlcipher3_free(p);
35595   sqlcipher3_free(pNew);
35596   winShmLeaveMutex();
35597   return rc;
35598 }
35599
35600 /*
35601 ** Close a connection to shared-memory.  Delete the underlying 
35602 ** storage if deleteFlag is true.
35603 */
35604 static int winShmUnmap(
35605   sqlcipher3_file *fd,          /* Database holding shared memory */
35606   int deleteFlag             /* Delete after closing if true */
35607 ){
35608   winFile *pDbFd;       /* Database holding shared-memory */
35609   winShm *p;            /* The connection to be closed */
35610   winShmNode *pShmNode; /* The underlying shared-memory file */
35611   winShm **pp;          /* For looping over sibling connections */
35612
35613   pDbFd = (winFile*)fd;
35614   p = pDbFd->pShm;
35615   if( p==0 ) return SQLCIPHER_OK;
35616   pShmNode = p->pShmNode;
35617
35618   /* Remove connection p from the set of connections associated
35619   ** with pShmNode */
35620   sqlcipher3_mutex_enter(pShmNode->mutex);
35621   for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
35622   *pp = p->pNext;
35623
35624   /* Free the connection p */
35625   sqlcipher3_free(p);
35626   pDbFd->pShm = 0;
35627   sqlcipher3_mutex_leave(pShmNode->mutex);
35628
35629   /* If pShmNode->nRef has reached 0, then close the underlying
35630   ** shared-memory file, too */
35631   winShmEnterMutex();
35632   assert( pShmNode->nRef>0 );
35633   pShmNode->nRef--;
35634   if( pShmNode->nRef==0 ){
35635     winShmPurge(pDbFd->pVfs, deleteFlag);
35636   }
35637   winShmLeaveMutex();
35638
35639   return SQLCIPHER_OK;
35640 }
35641
35642 /*
35643 ** Change the lock state for a shared-memory segment.
35644 */
35645 static int winShmLock(
35646   sqlcipher3_file *fd,          /* Database file holding the shared memory */
35647   int ofst,                  /* First lock to acquire or release */
35648   int n,                     /* Number of locks to acquire or release */
35649   int flags                  /* What to do with the lock */
35650 ){
35651   winFile *pDbFd = (winFile*)fd;        /* Connection holding shared memory */
35652   winShm *p = pDbFd->pShm;              /* The shared memory being locked */
35653   winShm *pX;                           /* For looping over all siblings */
35654   winShmNode *pShmNode = p->pShmNode;
35655   int rc = SQLCIPHER_OK;                   /* Result code */
35656   u16 mask;                             /* Mask of locks to take or release */
35657
35658   assert( ofst>=0 && ofst+n<=SQLCIPHER_SHM_NLOCK );
35659   assert( n>=1 );
35660   assert( flags==(SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_SHARED)
35661        || flags==(SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_EXCLUSIVE)
35662        || flags==(SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_SHARED)
35663        || flags==(SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_EXCLUSIVE) );
35664   assert( n==1 || (flags & SQLCIPHER_SHM_EXCLUSIVE)!=0 );
35665
35666   mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
35667   assert( n>1 || mask==(1<<ofst) );
35668   sqlcipher3_mutex_enter(pShmNode->mutex);
35669   if( flags & SQLCIPHER_SHM_UNLOCK ){
35670     u16 allMask = 0; /* Mask of locks held by siblings */
35671
35672     /* See if any siblings hold this same lock */
35673     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
35674       if( pX==p ) continue;
35675       assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
35676       allMask |= pX->sharedMask;
35677     }
35678
35679     /* Unlock the system-level locks */
35680     if( (mask & allMask)==0 ){
35681       rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
35682     }else{
35683       rc = SQLCIPHER_OK;
35684     }
35685
35686     /* Undo the local locks */
35687     if( rc==SQLCIPHER_OK ){
35688       p->exclMask &= ~mask;
35689       p->sharedMask &= ~mask;
35690     } 
35691   }else if( flags & SQLCIPHER_SHM_SHARED ){
35692     u16 allShared = 0;  /* Union of locks held by connections other than "p" */
35693
35694     /* Find out which shared locks are already held by sibling connections.
35695     ** If any sibling already holds an exclusive lock, go ahead and return
35696     ** SQLCIPHER_BUSY.
35697     */
35698     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
35699       if( (pX->exclMask & mask)!=0 ){
35700         rc = SQLCIPHER_BUSY;
35701         break;
35702       }
35703       allShared |= pX->sharedMask;
35704     }
35705
35706     /* Get shared locks at the system level, if necessary */
35707     if( rc==SQLCIPHER_OK ){
35708       if( (allShared & mask)==0 ){
35709         rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
35710       }else{
35711         rc = SQLCIPHER_OK;
35712       }
35713     }
35714
35715     /* Get the local shared locks */
35716     if( rc==SQLCIPHER_OK ){
35717       p->sharedMask |= mask;
35718     }
35719   }else{
35720     /* Make sure no sibling connections hold locks that will block this
35721     ** lock.  If any do, return SQLCIPHER_BUSY right away.
35722     */
35723     for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
35724       if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
35725         rc = SQLCIPHER_BUSY;
35726         break;
35727       }
35728     }
35729   
35730     /* Get the exclusive locks at the system level.  Then if successful
35731     ** also mark the local connection as being locked.
35732     */
35733     if( rc==SQLCIPHER_OK ){
35734       rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
35735       if( rc==SQLCIPHER_OK ){
35736         assert( (p->sharedMask & mask)==0 );
35737         p->exclMask |= mask;
35738       }
35739     }
35740   }
35741   sqlcipher3_mutex_leave(pShmNode->mutex);
35742   OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
35743            p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
35744            rc ? "failed" : "ok"));
35745   return rc;
35746 }
35747
35748 /*
35749 ** Implement a memory barrier or memory fence on shared memory.  
35750 **
35751 ** All loads and stores begun before the barrier must complete before
35752 ** any load or store begun after the barrier.
35753 */
35754 static void winShmBarrier(
35755   sqlcipher3_file *fd          /* Database holding the shared memory */
35756 ){
35757   UNUSED_PARAMETER(fd);
35758   /* MemoryBarrier(); // does not work -- do not know why not */
35759   winShmEnterMutex();
35760   winShmLeaveMutex();
35761 }
35762
35763 /*
35764 ** This function is called to obtain a pointer to region iRegion of the 
35765 ** shared-memory associated with the database file fd. Shared-memory regions 
35766 ** are numbered starting from zero. Each shared-memory region is szRegion 
35767 ** bytes in size.
35768 **
35769 ** If an error occurs, an error code is returned and *pp is set to NULL.
35770 **
35771 ** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
35772 ** region has not been allocated (by any client, including one running in a
35773 ** separate process), then *pp is set to NULL and SQLCIPHER_OK returned. If 
35774 ** isWrite is non-zero and the requested shared-memory region has not yet 
35775 ** been allocated, it is allocated by this function.
35776 **
35777 ** If the shared-memory region has already been allocated or is allocated by
35778 ** this call as described above, then it is mapped into this processes 
35779 ** address space (if it is not already), *pp is set to point to the mapped 
35780 ** memory and SQLCIPHER_OK returned.
35781 */
35782 static int winShmMap(
35783   sqlcipher3_file *fd,               /* Handle open on database file */
35784   int iRegion,                    /* Region to retrieve */
35785   int szRegion,                   /* Size of regions */
35786   int isWrite,                    /* True to extend file if necessary */
35787   void volatile **pp              /* OUT: Mapped memory */
35788 ){
35789   winFile *pDbFd = (winFile*)fd;
35790   winShm *p = pDbFd->pShm;
35791   winShmNode *pShmNode;
35792   int rc = SQLCIPHER_OK;
35793
35794   if( !p ){
35795     rc = winOpenSharedMemory(pDbFd);
35796     if( rc!=SQLCIPHER_OK ) return rc;
35797     p = pDbFd->pShm;
35798   }
35799   pShmNode = p->pShmNode;
35800
35801   sqlcipher3_mutex_enter(pShmNode->mutex);
35802   assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
35803
35804   if( pShmNode->nRegion<=iRegion ){
35805     struct ShmRegion *apNew;           /* New aRegion[] array */
35806     int nByte = (iRegion+1)*szRegion;  /* Minimum required file size */
35807     sqlcipher3_int64 sz;                  /* Current size of wal-index file */
35808
35809     pShmNode->szRegion = szRegion;
35810
35811     /* The requested region is not mapped into this processes address space.
35812     ** Check to see if it has been allocated (i.e. if the wal-index file is
35813     ** large enough to contain the requested region).
35814     */
35815     rc = winFileSize((sqlcipher3_file *)&pShmNode->hFile, &sz);
35816     if( rc!=SQLCIPHER_OK ){
35817       rc = winLogError(SQLCIPHER_IOERR_SHMSIZE, "winShmMap1", pDbFd->zPath);
35818       goto shmpage_out;
35819     }
35820
35821     if( sz<nByte ){
35822       /* The requested memory region does not exist. If isWrite is set to
35823       ** zero, exit early. *pp will be set to NULL and SQLCIPHER_OK returned.
35824       **
35825       ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
35826       ** the requested memory region.
35827       */
35828       if( !isWrite ) goto shmpage_out;
35829       rc = winTruncate((sqlcipher3_file *)&pShmNode->hFile, nByte);
35830       if( rc!=SQLCIPHER_OK ){
35831         rc = winLogError(SQLCIPHER_IOERR_SHMSIZE, "winShmMap2", pDbFd->zPath);
35832         goto shmpage_out;
35833       }
35834     }
35835
35836     /* Map the requested memory region into this processes address space. */
35837     apNew = (struct ShmRegion *)sqlcipher3_realloc(
35838         pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0])
35839     );
35840     if( !apNew ){
35841       rc = SQLCIPHER_IOERR_NOMEM;
35842       goto shmpage_out;
35843     }
35844     pShmNode->aRegion = apNew;
35845
35846     while( pShmNode->nRegion<=iRegion ){
35847       HANDLE hMap;                /* file-mapping handle */
35848       void *pMap = 0;             /* Mapped memory region */
35849      
35850       hMap = CreateFileMapping(pShmNode->hFile.h, 
35851           NULL, PAGE_READWRITE, 0, nByte, NULL
35852       );
35853       OSTRACE(("SHM-MAP pid-%d create region=%d nbyte=%d %s\n",
35854                (int)GetCurrentProcessId(), pShmNode->nRegion, nByte,
35855                hMap ? "ok" : "failed"));
35856       if( hMap ){
35857         int iOffset = pShmNode->nRegion*szRegion;
35858         int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
35859         pMap = MapViewOfFile(hMap, FILE_MAP_WRITE | FILE_MAP_READ,
35860             0, iOffset - iOffsetShift, szRegion + iOffsetShift
35861         );
35862         OSTRACE(("SHM-MAP pid-%d map region=%d offset=%d size=%d %s\n",
35863                  (int)GetCurrentProcessId(), pShmNode->nRegion, iOffset, szRegion,
35864                  pMap ? "ok" : "failed"));
35865       }
35866       if( !pMap ){
35867         pShmNode->lastErrno = GetLastError();
35868         rc = winLogError(SQLCIPHER_IOERR_SHMMAP, "winShmMap3", pDbFd->zPath);
35869         if( hMap ) CloseHandle(hMap);
35870         goto shmpage_out;
35871       }
35872
35873       pShmNode->aRegion[pShmNode->nRegion].pMap = pMap;
35874       pShmNode->aRegion[pShmNode->nRegion].hMap = hMap;
35875       pShmNode->nRegion++;
35876     }
35877   }
35878
35879 shmpage_out:
35880   if( pShmNode->nRegion>iRegion ){
35881     int iOffset = iRegion*szRegion;
35882     int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
35883     char *p = (char *)pShmNode->aRegion[iRegion].pMap;
35884     *pp = (void *)&p[iOffsetShift];
35885   }else{
35886     *pp = 0;
35887   }
35888   sqlcipher3_mutex_leave(pShmNode->mutex);
35889   return rc;
35890 }
35891
35892 #else
35893 # define winShmMap     0
35894 # define winShmLock    0
35895 # define winShmBarrier 0
35896 # define winShmUnmap   0
35897 #endif /* #ifndef SQLCIPHER_OMIT_WAL */
35898
35899 /*
35900 ** Here ends the implementation of all sqlcipher3_file methods.
35901 **
35902 ********************** End sqlcipher3_file Methods *******************************
35903 ******************************************************************************/
35904
35905 /*
35906 ** This vector defines all the methods that can operate on an
35907 ** sqlcipher3_file for win32.
35908 */
35909 static const sqlcipher3_io_methods winIoMethod = {
35910   2,                              /* iVersion */
35911   winClose,                       /* xClose */
35912   winRead,                        /* xRead */
35913   winWrite,                       /* xWrite */
35914   winTruncate,                    /* xTruncate */
35915   winSync,                        /* xSync */
35916   winFileSize,                    /* xFileSize */
35917   winLock,                        /* xLock */
35918   winUnlock,                      /* xUnlock */
35919   winCheckReservedLock,           /* xCheckReservedLock */
35920   winFileControl,                 /* xFileControl */
35921   winSectorSize,                  /* xSectorSize */
35922   winDeviceCharacteristics,       /* xDeviceCharacteristics */
35923   winShmMap,                      /* xShmMap */
35924   winShmLock,                     /* xShmLock */
35925   winShmBarrier,                  /* xShmBarrier */
35926   winShmUnmap                     /* xShmUnmap */
35927 };
35928
35929 /****************************************************************************
35930 **************************** sqlcipher3_vfs methods ****************************
35931 **
35932 ** This division contains the implementation of methods on the
35933 ** sqlcipher3_vfs object.
35934 */
35935
35936 /*
35937 ** Convert a UTF-8 filename into whatever form the underlying
35938 ** operating system wants filenames in.  Space to hold the result
35939 ** is obtained from malloc and must be freed by the calling
35940 ** function.
35941 */
35942 static void *convertUtf8Filename(const char *zFilename){
35943   void *zConverted = 0;
35944   if( isNT() ){
35945     zConverted = utf8ToUnicode(zFilename);
35946 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
35947 */
35948 #if SQLCIPHER_OS_WINCE==0
35949   }else{
35950     zConverted = sqlcipher3_win32_utf8_to_mbcs(zFilename);
35951 #endif
35952   }
35953   /* caller will handle out of memory */
35954   return zConverted;
35955 }
35956
35957 /*
35958 ** Create a temporary file name in zBuf.  zBuf must be big enough to
35959 ** hold at pVfs->mxPathname characters.
35960 */
35961 static int getTempname(int nBuf, char *zBuf){
35962   static char zChars[] =
35963     "abcdefghijklmnopqrstuvwxyz"
35964     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
35965     "0123456789";
35966   size_t i, j;
35967   char zTempPath[MAX_PATH+1];
35968
35969   /* It's odd to simulate an io-error here, but really this is just
35970   ** using the io-error infrastructure to test that SQLite handles this
35971   ** function failing. 
35972   */
35973   SimulateIOError( return SQLCIPHER_IOERR );
35974
35975   if( sqlcipher3_temp_directory ){
35976     sqlcipher3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlcipher3_temp_directory);
35977   }else if( isNT() ){
35978     char *zMulti;
35979     WCHAR zWidePath[MAX_PATH];
35980     GetTempPathW(MAX_PATH-30, zWidePath);
35981     zMulti = unicodeToUtf8(zWidePath);
35982     if( zMulti ){
35983       sqlcipher3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
35984       free(zMulti);
35985     }else{
35986       return SQLCIPHER_NOMEM;
35987     }
35988 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
35989 ** Since the ASCII version of these Windows API do not exist for WINCE,
35990 ** it's important to not reference them for WINCE builds.
35991 */
35992 #if SQLCIPHER_OS_WINCE==0
35993   }else{
35994     char *zUtf8;
35995     char zMbcsPath[MAX_PATH];
35996     GetTempPathA(MAX_PATH-30, zMbcsPath);
35997     zUtf8 = sqlcipher3_win32_mbcs_to_utf8(zMbcsPath);
35998     if( zUtf8 ){
35999       sqlcipher3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
36000       free(zUtf8);
36001     }else{
36002       return SQLCIPHER_NOMEM;
36003     }
36004 #endif
36005   }
36006
36007   /* Check that the output buffer is large enough for the temporary file 
36008   ** name. If it is not, return SQLCIPHER_ERROR.
36009   */
36010   if( (sqlcipher3Strlen30(zTempPath) + sqlcipher3Strlen30(SQLCIPHER_TEMP_FILE_PREFIX) + 17) >= nBuf ){
36011     return SQLCIPHER_ERROR;
36012   }
36013
36014   for(i=sqlcipher3Strlen30(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
36015   zTempPath[i] = 0;
36016
36017   sqlcipher3_snprintf(nBuf-17, zBuf,
36018                    "%s\\"SQLCIPHER_TEMP_FILE_PREFIX, zTempPath);
36019   j = sqlcipher3Strlen30(zBuf);
36020   sqlcipher3_randomness(15, &zBuf[j]);
36021   for(i=0; i<15; i++, j++){
36022     zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
36023   }
36024   zBuf[j] = 0;
36025
36026   OSTRACE(("TEMP FILENAME: %s\n", zBuf));
36027   return SQLCIPHER_OK; 
36028 }
36029
36030 /*
36031 ** Open a file.
36032 */
36033 static int winOpen(
36034   sqlcipher3_vfs *pVfs,        /* Not used */
36035   const char *zName,        /* Name of the file (UTF-8) */
36036   sqlcipher3_file *id,         /* Write the SQLite file handle here */
36037   int flags,                /* Open mode flags */
36038   int *pOutFlags            /* Status return flags */
36039 ){
36040   HANDLE h;
36041   DWORD dwDesiredAccess;
36042   DWORD dwShareMode;
36043   DWORD dwCreationDisposition;
36044   DWORD dwFlagsAndAttributes = 0;
36045 #if SQLCIPHER_OS_WINCE
36046   int isTemp = 0;
36047 #endif
36048   winFile *pFile = (winFile*)id;
36049   void *zConverted;              /* Filename in OS encoding */
36050   const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
36051   int cnt = 0;
36052
36053   /* If argument zPath is a NULL pointer, this function is required to open
36054   ** a temporary file. Use this buffer to store the file name in.
36055   */
36056   char zTmpname[MAX_PATH+1];     /* Buffer used to create temp filename */
36057
36058   int rc = SQLCIPHER_OK;            /* Function Return Code */
36059 #if !defined(NDEBUG) || SQLCIPHER_OS_WINCE
36060   int eType = flags&0xFFFFFF00;  /* Type of file to open */
36061 #endif
36062
36063   int isExclusive  = (flags & SQLCIPHER_OPEN_EXCLUSIVE);
36064   int isDelete     = (flags & SQLCIPHER_OPEN_DELETEONCLOSE);
36065   int isCreate     = (flags & SQLCIPHER_OPEN_CREATE);
36066 #ifndef NDEBUG
36067   int isReadonly   = (flags & SQLCIPHER_OPEN_READONLY);
36068 #endif
36069   int isReadWrite  = (flags & SQLCIPHER_OPEN_READWRITE);
36070
36071 #ifndef NDEBUG
36072   int isOpenJournal = (isCreate && (
36073         eType==SQLCIPHER_OPEN_MASTER_JOURNAL 
36074      || eType==SQLCIPHER_OPEN_MAIN_JOURNAL 
36075      || eType==SQLCIPHER_OPEN_WAL
36076   ));
36077 #endif
36078
36079   /* Check the following statements are true: 
36080   **
36081   **   (a) Exactly one of the READWRITE and READONLY flags must be set, and 
36082   **   (b) if CREATE is set, then READWRITE must also be set, and
36083   **   (c) if EXCLUSIVE is set, then CREATE must also be set.
36084   **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
36085   */
36086   assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
36087   assert(isCreate==0 || isReadWrite);
36088   assert(isExclusive==0 || isCreate);
36089   assert(isDelete==0 || isCreate);
36090
36091   /* The main DB, main journal, WAL file and master journal are never 
36092   ** automatically deleted. Nor are they ever temporary files.  */
36093   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MAIN_DB );
36094   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MAIN_JOURNAL );
36095   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_MASTER_JOURNAL );
36096   assert( (!isDelete && zName) || eType!=SQLCIPHER_OPEN_WAL );
36097
36098   /* Assert that the upper layer has set one of the "file-type" flags. */
36099   assert( eType==SQLCIPHER_OPEN_MAIN_DB      || eType==SQLCIPHER_OPEN_TEMP_DB 
36100        || eType==SQLCIPHER_OPEN_MAIN_JOURNAL || eType==SQLCIPHER_OPEN_TEMP_JOURNAL 
36101        || eType==SQLCIPHER_OPEN_SUBJOURNAL   || eType==SQLCIPHER_OPEN_MASTER_JOURNAL 
36102        || eType==SQLCIPHER_OPEN_TRANSIENT_DB || eType==SQLCIPHER_OPEN_WAL
36103   );
36104
36105   assert( id!=0 );
36106   UNUSED_PARAMETER(pVfs);
36107
36108   pFile->h = INVALID_HANDLE_VALUE;
36109
36110   /* If the second argument to this function is NULL, generate a 
36111   ** temporary file name to use 
36112   */
36113   if( !zUtf8Name ){
36114     assert(isDelete && !isOpenJournal);
36115     rc = getTempname(MAX_PATH+1, zTmpname);
36116     if( rc!=SQLCIPHER_OK ){
36117       return rc;
36118     }
36119     zUtf8Name = zTmpname;
36120   }
36121
36122   /* Convert the filename to the system encoding. */
36123   zConverted = convertUtf8Filename(zUtf8Name);
36124   if( zConverted==0 ){
36125     return SQLCIPHER_NOMEM;
36126   }
36127
36128   if( isReadWrite ){
36129     dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
36130   }else{
36131     dwDesiredAccess = GENERIC_READ;
36132   }
36133
36134   /* SQLCIPHER_OPEN_EXCLUSIVE is used to make sure that a new file is 
36135   ** created. SQLite doesn't use it to indicate "exclusive access" 
36136   ** as it is usually understood.
36137   */
36138   if( isExclusive ){
36139     /* Creates a new file, only if it does not already exist. */
36140     /* If the file exists, it fails. */
36141     dwCreationDisposition = CREATE_NEW;
36142   }else if( isCreate ){
36143     /* Open existing file, or create if it doesn't exist */
36144     dwCreationDisposition = OPEN_ALWAYS;
36145   }else{
36146     /* Opens a file, only if it exists. */
36147     dwCreationDisposition = OPEN_EXISTING;
36148   }
36149
36150   dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
36151
36152   if( isDelete ){
36153 #if SQLCIPHER_OS_WINCE
36154     dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
36155     isTemp = 1;
36156 #else
36157     dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
36158                                | FILE_ATTRIBUTE_HIDDEN
36159                                | FILE_FLAG_DELETE_ON_CLOSE;
36160 #endif
36161   }else{
36162     dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
36163   }
36164   /* Reports from the internet are that performance is always
36165   ** better if FILE_FLAG_RANDOM_ACCESS is used.  Ticket #2699. */
36166 #if SQLCIPHER_OS_WINCE
36167   dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
36168 #endif
36169
36170   if( isNT() ){
36171     while( (h = CreateFileW((WCHAR*)zConverted,
36172                             dwDesiredAccess,
36173                             dwShareMode, NULL,
36174                             dwCreationDisposition,
36175                             dwFlagsAndAttributes,
36176                             NULL))==INVALID_HANDLE_VALUE &&
36177                             retryIoerr(&cnt) ){}
36178 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
36179 ** Since the ASCII version of these Windows API do not exist for WINCE,
36180 ** it's important to not reference them for WINCE builds.
36181 */
36182 #if SQLCIPHER_OS_WINCE==0
36183   }else{
36184     while( (h = CreateFileA((char*)zConverted,
36185                             dwDesiredAccess,
36186                             dwShareMode, NULL,
36187                             dwCreationDisposition,
36188                             dwFlagsAndAttributes,
36189                             NULL))==INVALID_HANDLE_VALUE &&
36190                             retryIoerr(&cnt) ){}
36191 #endif
36192   }
36193
36194   logIoerr(cnt);
36195
36196   OSTRACE(("OPEN %d %s 0x%lx %s\n", 
36197            h, zName, dwDesiredAccess, 
36198            h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
36199
36200   if( h==INVALID_HANDLE_VALUE ){
36201     pFile->lastErrno = GetLastError();
36202     winLogError(SQLCIPHER_CANTOPEN, "winOpen", zUtf8Name);
36203     free(zConverted);
36204     if( isReadWrite && !isExclusive ){
36205       return winOpen(pVfs, zName, id, 
36206              ((flags|SQLCIPHER_OPEN_READONLY)&~(SQLCIPHER_OPEN_CREATE|SQLCIPHER_OPEN_READWRITE)), pOutFlags);
36207     }else{
36208       return SQLCIPHER_CANTOPEN_BKPT;
36209     }
36210   }
36211
36212   if( pOutFlags ){
36213     if( isReadWrite ){
36214       *pOutFlags = SQLCIPHER_OPEN_READWRITE;
36215     }else{
36216       *pOutFlags = SQLCIPHER_OPEN_READONLY;
36217     }
36218   }
36219
36220   memset(pFile, 0, sizeof(*pFile));
36221   pFile->pMethod = &winIoMethod;
36222   pFile->h = h;
36223   pFile->lastErrno = NO_ERROR;
36224   pFile->pVfs = pVfs;
36225   pFile->pShm = 0;
36226   pFile->zPath = zName;
36227   pFile->sectorSize = getSectorSize(pVfs, zUtf8Name);
36228
36229 #if SQLCIPHER_OS_WINCE
36230   if( isReadWrite && eType==SQLCIPHER_OPEN_MAIN_DB
36231        && !winceCreateLock(zName, pFile)
36232   ){
36233     CloseHandle(h);
36234     free(zConverted);
36235     return SQLCIPHER_CANTOPEN_BKPT;
36236   }
36237   if( isTemp ){
36238     pFile->zDeleteOnClose = zConverted;
36239   }else
36240 #endif
36241   {
36242     free(zConverted);
36243   }
36244
36245   OpenCounter(+1);
36246   return rc;
36247 }
36248
36249 /*
36250 ** Delete the named file.
36251 **
36252 ** Note that windows does not allow a file to be deleted if some other
36253 ** process has it open.  Sometimes a virus scanner or indexing program
36254 ** will open a journal file shortly after it is created in order to do
36255 ** whatever it does.  While this other process is holding the
36256 ** file open, we will be unable to delete it.  To work around this
36257 ** problem, we delay 100 milliseconds and try to delete again.  Up
36258 ** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
36259 ** up and returning an error.
36260 */
36261 static int winDelete(
36262   sqlcipher3_vfs *pVfs,          /* Not used on win32 */
36263   const char *zFilename,      /* Name of file to delete */
36264   int syncDir                 /* Not used on win32 */
36265 ){
36266   int cnt = 0;
36267   int rc;
36268   void *zConverted;
36269   UNUSED_PARAMETER(pVfs);
36270   UNUSED_PARAMETER(syncDir);
36271
36272   SimulateIOError(return SQLCIPHER_IOERR_DELETE);
36273   zConverted = convertUtf8Filename(zFilename);
36274   if( zConverted==0 ){
36275     return SQLCIPHER_NOMEM;
36276   }
36277   if( isNT() ){
36278     rc = 1;
36279     while( GetFileAttributesW(zConverted)!=INVALID_FILE_ATTRIBUTES &&
36280            (rc = DeleteFileW(zConverted))==0 && retryIoerr(&cnt) ){}
36281     rc = rc ? SQLCIPHER_OK : SQLCIPHER_ERROR;
36282 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
36283 ** Since the ASCII version of these Windows API do not exist for WINCE,
36284 ** it's important to not reference them for WINCE builds.
36285 */
36286 #if SQLCIPHER_OS_WINCE==0
36287   }else{
36288     rc = 1;
36289     while( GetFileAttributesA(zConverted)!=INVALID_FILE_ATTRIBUTES &&
36290            (rc = DeleteFileA(zConverted))==0 && retryIoerr(&cnt) ){}
36291     rc = rc ? SQLCIPHER_OK : SQLCIPHER_ERROR;
36292 #endif
36293   }
36294   if( rc ){
36295     rc = winLogError(SQLCIPHER_IOERR_DELETE, "winDelete", zFilename);
36296   }else{
36297     logIoerr(cnt);
36298   }
36299   free(zConverted);
36300   OSTRACE(("DELETE \"%s\" %s\n", zFilename, (rc ? "failed" : "ok" )));
36301   return rc;
36302 }
36303
36304 /*
36305 ** Check the existance and status of a file.
36306 */
36307 static int winAccess(
36308   sqlcipher3_vfs *pVfs,         /* Not used on win32 */
36309   const char *zFilename,     /* Name of file to check */
36310   int flags,                 /* Type of test to make on this file */
36311   int *pResOut               /* OUT: Result */
36312 ){
36313   DWORD attr;
36314   int rc = 0;
36315   void *zConverted;
36316   UNUSED_PARAMETER(pVfs);
36317
36318   SimulateIOError( return SQLCIPHER_IOERR_ACCESS; );
36319   zConverted = convertUtf8Filename(zFilename);
36320   if( zConverted==0 ){
36321     return SQLCIPHER_NOMEM;
36322   }
36323   if( isNT() ){
36324     int cnt = 0;
36325     WIN32_FILE_ATTRIBUTE_DATA sAttrData;
36326     memset(&sAttrData, 0, sizeof(sAttrData));
36327     while( !(rc = GetFileAttributesExW((WCHAR*)zConverted,
36328                              GetFileExInfoStandard, 
36329                              &sAttrData)) && retryIoerr(&cnt) ){}
36330     if( rc ){
36331       /* For an SQLCIPHER_ACCESS_EXISTS query, treat a zero-length file
36332       ** as if it does not exist.
36333       */
36334       if(    flags==SQLCIPHER_ACCESS_EXISTS
36335           && sAttrData.nFileSizeHigh==0 
36336           && sAttrData.nFileSizeLow==0 ){
36337         attr = INVALID_FILE_ATTRIBUTES;
36338       }else{
36339         attr = sAttrData.dwFileAttributes;
36340       }
36341     }else{
36342       logIoerr(cnt);
36343       if( GetLastError()!=ERROR_FILE_NOT_FOUND ){
36344         winLogError(SQLCIPHER_IOERR_ACCESS, "winAccess", zFilename);
36345         free(zConverted);
36346         return SQLCIPHER_IOERR_ACCESS;
36347       }else{
36348         attr = INVALID_FILE_ATTRIBUTES;
36349       }
36350     }
36351 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
36352 ** Since the ASCII version of these Windows API do not exist for WINCE,
36353 ** it's important to not reference them for WINCE builds.
36354 */
36355 #if SQLCIPHER_OS_WINCE==0
36356   }else{
36357     attr = GetFileAttributesA((char*)zConverted);
36358 #endif
36359   }
36360   free(zConverted);
36361   switch( flags ){
36362     case SQLCIPHER_ACCESS_READ:
36363     case SQLCIPHER_ACCESS_EXISTS:
36364       rc = attr!=INVALID_FILE_ATTRIBUTES;
36365       break;
36366     case SQLCIPHER_ACCESS_READWRITE:
36367       rc = attr!=INVALID_FILE_ATTRIBUTES &&
36368              (attr & FILE_ATTRIBUTE_READONLY)==0;
36369       break;
36370     default:
36371       assert(!"Invalid flags argument");
36372   }
36373   *pResOut = rc;
36374   return SQLCIPHER_OK;
36375 }
36376
36377
36378 /*
36379 ** Turn a relative pathname into a full pathname.  Write the full
36380 ** pathname into zOut[].  zOut[] will be at least pVfs->mxPathname
36381 ** bytes in size.
36382 */
36383 static int winFullPathname(
36384   sqlcipher3_vfs *pVfs,            /* Pointer to vfs object */
36385   const char *zRelative,        /* Possibly relative input path */
36386   int nFull,                    /* Size of output buffer in bytes */
36387   char *zFull                   /* Output buffer */
36388 ){
36389   
36390 #if defined(__CYGWIN__)
36391   SimulateIOError( return SQLCIPHER_ERROR );
36392   UNUSED_PARAMETER(nFull);
36393   cygwin_conv_to_full_win32_path(zRelative, zFull);
36394   return SQLCIPHER_OK;
36395 #endif
36396
36397 #if SQLCIPHER_OS_WINCE
36398   SimulateIOError( return SQLCIPHER_ERROR );
36399   UNUSED_PARAMETER(nFull);
36400   /* WinCE has no concept of a relative pathname, or so I am told. */
36401   sqlcipher3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
36402   return SQLCIPHER_OK;
36403 #endif
36404
36405 #if !SQLCIPHER_OS_WINCE && !defined(__CYGWIN__)
36406   int nByte;
36407   void *zConverted;
36408   char *zOut;
36409
36410   /* If this path name begins with "/X:", where "X" is any alphabetic
36411   ** character, discard the initial "/" from the pathname.
36412   */
36413   if( zRelative[0]=='/' && sqlcipher3Isalpha(zRelative[1]) && zRelative[2]==':' ){
36414     zRelative++;
36415   }
36416
36417   /* It's odd to simulate an io-error here, but really this is just
36418   ** using the io-error infrastructure to test that SQLite handles this
36419   ** function failing. This function could fail if, for example, the
36420   ** current working directory has been unlinked.
36421   */
36422   SimulateIOError( return SQLCIPHER_ERROR );
36423   UNUSED_PARAMETER(nFull);
36424   zConverted = convertUtf8Filename(zRelative);
36425   if( isNT() ){
36426     WCHAR *zTemp;
36427     nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
36428     zTemp = malloc( nByte*sizeof(zTemp[0]) );
36429     if( zTemp==0 ){
36430       free(zConverted);
36431       return SQLCIPHER_NOMEM;
36432     }
36433     GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
36434     free(zConverted);
36435     zOut = unicodeToUtf8(zTemp);
36436     free(zTemp);
36437 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
36438 ** Since the ASCII version of these Windows API do not exist for WINCE,
36439 ** it's important to not reference them for WINCE builds.
36440 */
36441 #if SQLCIPHER_OS_WINCE==0
36442   }else{
36443     char *zTemp;
36444     nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
36445     zTemp = malloc( nByte*sizeof(zTemp[0]) );
36446     if( zTemp==0 ){
36447       free(zConverted);
36448       return SQLCIPHER_NOMEM;
36449     }
36450     GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
36451     free(zConverted);
36452     zOut = sqlcipher3_win32_mbcs_to_utf8(zTemp);
36453     free(zTemp);
36454 #endif
36455   }
36456   if( zOut ){
36457     sqlcipher3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
36458     free(zOut);
36459     return SQLCIPHER_OK;
36460   }else{
36461     return SQLCIPHER_NOMEM;
36462   }
36463 #endif
36464 }
36465
36466 /*
36467 ** Get the sector size of the device used to store
36468 ** file.
36469 */
36470 static int getSectorSize(
36471     sqlcipher3_vfs *pVfs,
36472     const char *zRelative     /* UTF-8 file name */
36473 ){
36474   DWORD bytesPerSector = SQLCIPHER_DEFAULT_SECTOR_SIZE;
36475   /* GetDiskFreeSpace is not supported under WINCE */
36476 #if SQLCIPHER_OS_WINCE
36477   UNUSED_PARAMETER(pVfs);
36478   UNUSED_PARAMETER(zRelative);
36479 #else
36480   char zFullpath[MAX_PATH+1];
36481   int rc;
36482   DWORD dwRet = 0;
36483   DWORD dwDummy;
36484
36485   /*
36486   ** We need to get the full path name of the file
36487   ** to get the drive letter to look up the sector
36488   ** size.
36489   */
36490   SimulateIOErrorBenign(1);
36491   rc = winFullPathname(pVfs, zRelative, MAX_PATH, zFullpath);
36492   SimulateIOErrorBenign(0);
36493   if( rc == SQLCIPHER_OK )
36494   {
36495     void *zConverted = convertUtf8Filename(zFullpath);
36496     if( zConverted ){
36497       if( isNT() ){
36498         /* trim path to just drive reference */
36499         WCHAR *p = zConverted;
36500         for(;*p;p++){
36501           if( *p == '\\' ){
36502             *p = '\0';
36503             break;
36504           }
36505         }
36506         dwRet = GetDiskFreeSpaceW((WCHAR*)zConverted,
36507                                   &dwDummy,
36508                                   &bytesPerSector,
36509                                   &dwDummy,
36510                                   &dwDummy);
36511       }else{
36512         /* trim path to just drive reference */
36513         char *p = (char *)zConverted;
36514         for(;*p;p++){
36515           if( *p == '\\' ){
36516             *p = '\0';
36517             break;
36518           }
36519         }
36520         dwRet = GetDiskFreeSpaceA((char*)zConverted,
36521                                   &dwDummy,
36522                                   &bytesPerSector,
36523                                   &dwDummy,
36524                                   &dwDummy);
36525       }
36526       free(zConverted);
36527     }
36528     if( !dwRet ){
36529       bytesPerSector = SQLCIPHER_DEFAULT_SECTOR_SIZE;
36530     }
36531   }
36532 #endif
36533   return (int) bytesPerSector; 
36534 }
36535
36536 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
36537 /*
36538 ** Interfaces for opening a shared library, finding entry points
36539 ** within the shared library, and closing the shared library.
36540 */
36541 /*
36542 ** Interfaces for opening a shared library, finding entry points
36543 ** within the shared library, and closing the shared library.
36544 */
36545 static void *winDlOpen(sqlcipher3_vfs *pVfs, const char *zFilename){
36546   HANDLE h;
36547   void *zConverted = convertUtf8Filename(zFilename);
36548   UNUSED_PARAMETER(pVfs);
36549   if( zConverted==0 ){
36550     return 0;
36551   }
36552   if( isNT() ){
36553     h = LoadLibraryW((WCHAR*)zConverted);
36554 /* isNT() is 1 if SQLCIPHER_OS_WINCE==1, so this else is never executed. 
36555 ** Since the ASCII version of these Windows API do not exist for WINCE,
36556 ** it's important to not reference them for WINCE builds.
36557 */
36558 #if SQLCIPHER_OS_WINCE==0
36559   }else{
36560     h = LoadLibraryA((char*)zConverted);
36561 #endif
36562   }
36563   free(zConverted);
36564   return (void*)h;
36565 }
36566 static void winDlError(sqlcipher3_vfs *pVfs, int nBuf, char *zBufOut){
36567   UNUSED_PARAMETER(pVfs);
36568   getLastErrorMsg(nBuf, zBufOut);
36569 }
36570 static void (*winDlSym(sqlcipher3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
36571   UNUSED_PARAMETER(pVfs);
36572 #if SQLCIPHER_OS_WINCE
36573   /* The GetProcAddressA() routine is only available on wince. */
36574   return (void(*)(void))GetProcAddressA((HANDLE)pHandle, zSymbol);
36575 #else
36576   /* All other windows platforms expect GetProcAddress() to take
36577   ** an Ansi string regardless of the _UNICODE setting */
36578   return (void(*)(void))GetProcAddress((HANDLE)pHandle, zSymbol);
36579 #endif
36580 }
36581 static void winDlClose(sqlcipher3_vfs *pVfs, void *pHandle){
36582   UNUSED_PARAMETER(pVfs);
36583   FreeLibrary((HANDLE)pHandle);
36584 }
36585 #else /* if SQLCIPHER_OMIT_LOAD_EXTENSION is defined: */
36586   #define winDlOpen  0
36587   #define winDlError 0
36588   #define winDlSym   0
36589   #define winDlClose 0
36590 #endif
36591
36592
36593 /*
36594 ** Write up to nBuf bytes of randomness into zBuf.
36595 */
36596 static int winRandomness(sqlcipher3_vfs *pVfs, int nBuf, char *zBuf){
36597   int n = 0;
36598   UNUSED_PARAMETER(pVfs);
36599 #if defined(SQLCIPHER_TEST)
36600   n = nBuf;
36601   memset(zBuf, 0, nBuf);
36602 #else
36603   if( sizeof(SYSTEMTIME)<=nBuf-n ){
36604     SYSTEMTIME x;
36605     GetSystemTime(&x);
36606     memcpy(&zBuf[n], &x, sizeof(x));
36607     n += sizeof(x);
36608   }
36609   if( sizeof(DWORD)<=nBuf-n ){
36610     DWORD pid = GetCurrentProcessId();
36611     memcpy(&zBuf[n], &pid, sizeof(pid));
36612     n += sizeof(pid);
36613   }
36614   if( sizeof(DWORD)<=nBuf-n ){
36615     DWORD cnt = GetTickCount();
36616     memcpy(&zBuf[n], &cnt, sizeof(cnt));
36617     n += sizeof(cnt);
36618   }
36619   if( sizeof(LARGE_INTEGER)<=nBuf-n ){
36620     LARGE_INTEGER i;
36621     QueryPerformanceCounter(&i);
36622     memcpy(&zBuf[n], &i, sizeof(i));
36623     n += sizeof(i);
36624   }
36625 #endif
36626   return n;
36627 }
36628
36629
36630 /*
36631 ** Sleep for a little while.  Return the amount of time slept.
36632 */
36633 static int winSleep(sqlcipher3_vfs *pVfs, int microsec){
36634   Sleep((microsec+999)/1000);
36635   UNUSED_PARAMETER(pVfs);
36636   return ((microsec+999)/1000)*1000;
36637 }
36638
36639 /*
36640 ** The following variable, if set to a non-zero value, is interpreted as
36641 ** the number of seconds since 1970 and is used to set the result of
36642 ** sqlcipher3OsCurrentTime() during testing.
36643 */
36644 #ifdef SQLCIPHER_TEST
36645 SQLCIPHER_API int sqlcipher3_current_time = 0;  /* Fake system time in seconds since 1970. */
36646 #endif
36647
36648 /*
36649 ** Find the current time (in Universal Coordinated Time).  Write into *piNow
36650 ** the current time and date as a Julian Day number times 86_400_000.  In
36651 ** other words, write into *piNow the number of milliseconds since the Julian
36652 ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
36653 ** proleptic Gregorian calendar.
36654 **
36655 ** On success, return SQLCIPHER_OK.  Return SQLCIPHER_ERROR if the time and date 
36656 ** cannot be found.
36657 */
36658 static int winCurrentTimeInt64(sqlcipher3_vfs *pVfs, sqlcipher3_int64 *piNow){
36659   /* FILETIME structure is a 64-bit value representing the number of 
36660      100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). 
36661   */
36662   FILETIME ft;
36663   static const sqlcipher3_int64 winFiletimeEpoch = 23058135*(sqlcipher3_int64)8640000;
36664 #ifdef SQLCIPHER_TEST
36665   static const sqlcipher3_int64 unixEpoch = 24405875*(sqlcipher3_int64)8640000;
36666 #endif
36667   /* 2^32 - to avoid use of LL and warnings in gcc */
36668   static const sqlcipher3_int64 max32BitValue = 
36669       (sqlcipher3_int64)2000000000 + (sqlcipher3_int64)2000000000 + (sqlcipher3_int64)294967296;
36670
36671 #if SQLCIPHER_OS_WINCE
36672   SYSTEMTIME time;
36673   GetSystemTime(&time);
36674   /* if SystemTimeToFileTime() fails, it returns zero. */
36675   if (!SystemTimeToFileTime(&time,&ft)){
36676     return SQLCIPHER_ERROR;
36677   }
36678 #else
36679   GetSystemTimeAsFileTime( &ft );
36680 #endif
36681
36682   *piNow = winFiletimeEpoch +
36683             ((((sqlcipher3_int64)ft.dwHighDateTime)*max32BitValue) + 
36684                (sqlcipher3_int64)ft.dwLowDateTime)/(sqlcipher3_int64)10000;
36685
36686 #ifdef SQLCIPHER_TEST
36687   if( sqlcipher3_current_time ){
36688     *piNow = 1000*(sqlcipher3_int64)sqlcipher3_current_time + unixEpoch;
36689   }
36690 #endif
36691   UNUSED_PARAMETER(pVfs);
36692   return SQLCIPHER_OK;
36693 }
36694
36695 /*
36696 ** Find the current time (in Universal Coordinated Time).  Write the
36697 ** current time and date as a Julian Day number into *prNow and
36698 ** return 0.  Return 1 if the time and date cannot be found.
36699 */
36700 static int winCurrentTime(sqlcipher3_vfs *pVfs, double *prNow){
36701   int rc;
36702   sqlcipher3_int64 i;
36703   rc = winCurrentTimeInt64(pVfs, &i);
36704   if( !rc ){
36705     *prNow = i/86400000.0;
36706   }
36707   return rc;
36708 }
36709
36710 /*
36711 ** The idea is that this function works like a combination of
36712 ** GetLastError() and FormatMessage() on windows (or errno and
36713 ** strerror_r() on unix). After an error is returned by an OS
36714 ** function, SQLite calls this function with zBuf pointing to
36715 ** a buffer of nBuf bytes. The OS layer should populate the
36716 ** buffer with a nul-terminated UTF-8 encoded error message
36717 ** describing the last IO error to have occurred within the calling
36718 ** thread.
36719 **
36720 ** If the error message is too large for the supplied buffer,
36721 ** it should be truncated. The return value of xGetLastError
36722 ** is zero if the error message fits in the buffer, or non-zero
36723 ** otherwise (if the message was truncated). If non-zero is returned,
36724 ** then it is not necessary to include the nul-terminator character
36725 ** in the output buffer.
36726 **
36727 ** Not supplying an error message will have no adverse effect
36728 ** on SQLite. It is fine to have an implementation that never
36729 ** returns an error message:
36730 **
36731 **   int xGetLastError(sqlcipher3_vfs *pVfs, int nBuf, char *zBuf){
36732 **     assert(zBuf[0]=='\0');
36733 **     return 0;
36734 **   }
36735 **
36736 ** However if an error message is supplied, it will be incorporated
36737 ** by sqlcipher into the error message available to the user using
36738 ** sqlcipher3_errmsg(), possibly making IO errors easier to debug.
36739 */
36740 static int winGetLastError(sqlcipher3_vfs *pVfs, int nBuf, char *zBuf){
36741   UNUSED_PARAMETER(pVfs);
36742   return getLastErrorMsg(nBuf, zBuf);
36743 }
36744
36745
36746
36747 /*
36748 ** Initialize and deinitialize the operating system interface.
36749 */
36750 SQLCIPHER_API int sqlcipher3_os_init(void){
36751   static sqlcipher3_vfs winVfs = {
36752     3,                   /* iVersion */
36753     sizeof(winFile),     /* szOsFile */
36754     MAX_PATH,            /* mxPathname */
36755     0,                   /* pNext */
36756     "win32",             /* zName */
36757     0,                   /* pAppData */
36758     winOpen,             /* xOpen */
36759     winDelete,           /* xDelete */
36760     winAccess,           /* xAccess */
36761     winFullPathname,     /* xFullPathname */
36762     winDlOpen,           /* xDlOpen */
36763     winDlError,          /* xDlError */
36764     winDlSym,            /* xDlSym */
36765     winDlClose,          /* xDlClose */
36766     winRandomness,       /* xRandomness */
36767     winSleep,            /* xSleep */
36768     winCurrentTime,      /* xCurrentTime */
36769     winGetLastError,     /* xGetLastError */
36770     winCurrentTimeInt64, /* xCurrentTimeInt64 */
36771     0,                   /* xSetSystemCall */
36772     0,                   /* xGetSystemCall */
36773     0,                   /* xNextSystemCall */
36774   };
36775
36776 #ifndef SQLCIPHER_OMIT_WAL
36777   /* get memory map allocation granularity */
36778   memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
36779   GetSystemInfo(&winSysInfo);
36780   assert(winSysInfo.dwAllocationGranularity > 0);
36781 #endif
36782
36783   sqlcipher3_vfs_register(&winVfs, 1);
36784   return SQLCIPHER_OK; 
36785 }
36786 SQLCIPHER_API int sqlcipher3_os_end(void){ 
36787   return SQLCIPHER_OK;
36788 }
36789
36790 #endif /* SQLCIPHER_OS_WIN */
36791
36792 /************** End of os_win.c **********************************************/
36793 /************** Begin file bitvec.c ******************************************/
36794 /*
36795 ** 2008 February 16
36796 **
36797 ** The author disclaims copyright to this source code.  In place of
36798 ** a legal notice, here is a blessing:
36799 **
36800 **    May you do good and not evil.
36801 **    May you find forgiveness for yourself and forgive others.
36802 **    May you share freely, never taking more than you give.
36803 **
36804 *************************************************************************
36805 ** This file implements an object that represents a fixed-length
36806 ** bitmap.  Bits are numbered starting with 1.
36807 **
36808 ** A bitmap is used to record which pages of a database file have been
36809 ** journalled during a transaction, or which pages have the "dont-write"
36810 ** property.  Usually only a few pages are meet either condition.
36811 ** So the bitmap is usually sparse and has low cardinality.
36812 ** But sometimes (for example when during a DROP of a large table) most
36813 ** or all of the pages in a database can get journalled.  In those cases, 
36814 ** the bitmap becomes dense with high cardinality.  The algorithm needs 
36815 ** to handle both cases well.
36816 **
36817 ** The size of the bitmap is fixed when the object is created.
36818 **
36819 ** All bits are clear when the bitmap is created.  Individual bits
36820 ** may be set or cleared one at a time.
36821 **
36822 ** Test operations are about 100 times more common that set operations.
36823 ** Clear operations are exceedingly rare.  There are usually between
36824 ** 5 and 500 set operations per Bitvec object, though the number of sets can
36825 ** sometimes grow into tens of thousands or larger.  The size of the
36826 ** Bitvec object is the number of pages in the database file at the
36827 ** start of a transaction, and is thus usually less than a few thousand,
36828 ** but can be as large as 2 billion for a really big database.
36829 */
36830
36831 /* Size of the Bitvec structure in bytes. */
36832 #define BITVEC_SZ        512
36833
36834 /* Round the union size down to the nearest pointer boundary, since that's how 
36835 ** it will be aligned within the Bitvec struct. */
36836 #define BITVEC_USIZE     (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
36837
36838 /* Type of the array "element" for the bitmap representation. 
36839 ** Should be a power of 2, and ideally, evenly divide into BITVEC_USIZE. 
36840 ** Setting this to the "natural word" size of your CPU may improve
36841 ** performance. */
36842 #define BITVEC_TELEM     u8
36843 /* Size, in bits, of the bitmap element. */
36844 #define BITVEC_SZELEM    8
36845 /* Number of elements in a bitmap array. */
36846 #define BITVEC_NELEM     (BITVEC_USIZE/sizeof(BITVEC_TELEM))
36847 /* Number of bits in the bitmap array. */
36848 #define BITVEC_NBIT      (BITVEC_NELEM*BITVEC_SZELEM)
36849
36850 /* Number of u32 values in hash table. */
36851 #define BITVEC_NINT      (BITVEC_USIZE/sizeof(u32))
36852 /* Maximum number of entries in hash table before 
36853 ** sub-dividing and re-hashing. */
36854 #define BITVEC_MXHASH    (BITVEC_NINT/2)
36855 /* Hashing function for the aHash representation.
36856 ** Empirical testing showed that the *37 multiplier 
36857 ** (an arbitrary prime)in the hash function provided 
36858 ** no fewer collisions than the no-op *1. */
36859 #define BITVEC_HASH(X)   (((X)*1)%BITVEC_NINT)
36860
36861 #define BITVEC_NPTR      (BITVEC_USIZE/sizeof(Bitvec *))
36862
36863
36864 /*
36865 ** A bitmap is an instance of the following structure.
36866 **
36867 ** This bitmap records the existance of zero or more bits
36868 ** with values between 1 and iSize, inclusive.
36869 **
36870 ** There are three possible representations of the bitmap.
36871 ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
36872 ** bitmap.  The least significant bit is bit 1.
36873 **
36874 ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is
36875 ** a hash table that will hold up to BITVEC_MXHASH distinct values.
36876 **
36877 ** Otherwise, the value i is redirected into one of BITVEC_NPTR
36878 ** sub-bitmaps pointed to by Bitvec.u.apSub[].  Each subbitmap
36879 ** handles up to iDivisor separate values of i.  apSub[0] holds
36880 ** values between 1 and iDivisor.  apSub[1] holds values between
36881 ** iDivisor+1 and 2*iDivisor.  apSub[N] holds values between
36882 ** N*iDivisor+1 and (N+1)*iDivisor.  Each subbitmap is normalized
36883 ** to hold deal with values between 1 and iDivisor.
36884 */
36885 struct Bitvec {
36886   u32 iSize;      /* Maximum bit index.  Max iSize is 4,294,967,296. */
36887   u32 nSet;       /* Number of bits that are set - only valid for aHash
36888                   ** element.  Max is BITVEC_NINT.  For BITVEC_SZ of 512,
36889                   ** this would be 125. */
36890   u32 iDivisor;   /* Number of bits handled by each apSub[] entry. */
36891                   /* Should >=0 for apSub element. */
36892                   /* Max iDivisor is max(u32) / BITVEC_NPTR + 1.  */
36893                   /* For a BITVEC_SZ of 512, this would be 34,359,739. */
36894   union {
36895     BITVEC_TELEM aBitmap[BITVEC_NELEM];    /* Bitmap representation */
36896     u32 aHash[BITVEC_NINT];      /* Hash table representation */
36897     Bitvec *apSub[BITVEC_NPTR];  /* Recursive representation */
36898   } u;
36899 };
36900
36901 /*
36902 ** Create a new bitmap object able to handle bits between 0 and iSize,
36903 ** inclusive.  Return a pointer to the new object.  Return NULL if 
36904 ** malloc fails.
36905 */
36906 SQLCIPHER_PRIVATE Bitvec *sqlcipher3BitvecCreate(u32 iSize){
36907   Bitvec *p;
36908   assert( sizeof(*p)==BITVEC_SZ );
36909   p = sqlcipher3MallocZero( sizeof(*p) );
36910   if( p ){
36911     p->iSize = iSize;
36912   }
36913   return p;
36914 }
36915
36916 /*
36917 ** Check to see if the i-th bit is set.  Return true or false.
36918 ** If p is NULL (if the bitmap has not been created) or if
36919 ** i is out of range, then return false.
36920 */
36921 SQLCIPHER_PRIVATE int sqlcipher3BitvecTest(Bitvec *p, u32 i){
36922   if( p==0 ) return 0;
36923   if( i>p->iSize || i==0 ) return 0;
36924   i--;
36925   while( p->iDivisor ){
36926     u32 bin = i/p->iDivisor;
36927     i = i%p->iDivisor;
36928     p = p->u.apSub[bin];
36929     if (!p) {
36930       return 0;
36931     }
36932   }
36933   if( p->iSize<=BITVEC_NBIT ){
36934     return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
36935   } else{
36936     u32 h = BITVEC_HASH(i++);
36937     while( p->u.aHash[h] ){
36938       if( p->u.aHash[h]==i ) return 1;
36939       h = (h+1) % BITVEC_NINT;
36940     }
36941     return 0;
36942   }
36943 }
36944
36945 /*
36946 ** Set the i-th bit.  Return 0 on success and an error code if
36947 ** anything goes wrong.
36948 **
36949 ** This routine might cause sub-bitmaps to be allocated.  Failing
36950 ** to get the memory needed to hold the sub-bitmap is the only
36951 ** that can go wrong with an insert, assuming p and i are valid.
36952 **
36953 ** The calling function must ensure that p is a valid Bitvec object
36954 ** and that the value for "i" is within range of the Bitvec object.
36955 ** Otherwise the behavior is undefined.
36956 */
36957 SQLCIPHER_PRIVATE int sqlcipher3BitvecSet(Bitvec *p, u32 i){
36958   u32 h;
36959   if( p==0 ) return SQLCIPHER_OK;
36960   assert( i>0 );
36961   assert( i<=p->iSize );
36962   i--;
36963   while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
36964     u32 bin = i/p->iDivisor;
36965     i = i%p->iDivisor;
36966     if( p->u.apSub[bin]==0 ){
36967       p->u.apSub[bin] = sqlcipher3BitvecCreate( p->iDivisor );
36968       if( p->u.apSub[bin]==0 ) return SQLCIPHER_NOMEM;
36969     }
36970     p = p->u.apSub[bin];
36971   }
36972   if( p->iSize<=BITVEC_NBIT ){
36973     p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
36974     return SQLCIPHER_OK;
36975   }
36976   h = BITVEC_HASH(i++);
36977   /* if there wasn't a hash collision, and this doesn't */
36978   /* completely fill the hash, then just add it without */
36979   /* worring about sub-dividing and re-hashing. */
36980   if( !p->u.aHash[h] ){
36981     if (p->nSet<(BITVEC_NINT-1)) {
36982       goto bitvec_set_end;
36983     } else {
36984       goto bitvec_set_rehash;
36985     }
36986   }
36987   /* there was a collision, check to see if it's already */
36988   /* in hash, if not, try to find a spot for it */
36989   do {
36990     if( p->u.aHash[h]==i ) return SQLCIPHER_OK;
36991     h++;
36992     if( h>=BITVEC_NINT ) h = 0;
36993   } while( p->u.aHash[h] );
36994   /* we didn't find it in the hash.  h points to the first */
36995   /* available free spot. check to see if this is going to */
36996   /* make our hash too "full".  */
36997 bitvec_set_rehash:
36998   if( p->nSet>=BITVEC_MXHASH ){
36999     unsigned int j;
37000     int rc;
37001     u32 *aiValues = sqlcipher3StackAllocRaw(0, sizeof(p->u.aHash));
37002     if( aiValues==0 ){
37003       return SQLCIPHER_NOMEM;
37004     }else{
37005       memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
37006       memset(p->u.apSub, 0, sizeof(p->u.apSub));
37007       p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
37008       rc = sqlcipher3BitvecSet(p, i);
37009       for(j=0; j<BITVEC_NINT; j++){
37010         if( aiValues[j] ) rc |= sqlcipher3BitvecSet(p, aiValues[j]);
37011       }
37012       sqlcipher3StackFree(0, aiValues);
37013       return rc;
37014     }
37015   }
37016 bitvec_set_end:
37017   p->nSet++;
37018   p->u.aHash[h] = i;
37019   return SQLCIPHER_OK;
37020 }
37021
37022 /*
37023 ** Clear the i-th bit.
37024 **
37025 ** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage
37026 ** that BitvecClear can use to rebuilt its hash table.
37027 */
37028 SQLCIPHER_PRIVATE void sqlcipher3BitvecClear(Bitvec *p, u32 i, void *pBuf){
37029   if( p==0 ) return;
37030   assert( i>0 );
37031   i--;
37032   while( p->iDivisor ){
37033     u32 bin = i/p->iDivisor;
37034     i = i%p->iDivisor;
37035     p = p->u.apSub[bin];
37036     if (!p) {
37037       return;
37038     }
37039   }
37040   if( p->iSize<=BITVEC_NBIT ){
37041     p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
37042   }else{
37043     unsigned int j;
37044     u32 *aiValues = pBuf;
37045     memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
37046     memset(p->u.aHash, 0, sizeof(p->u.aHash));
37047     p->nSet = 0;
37048     for(j=0; j<BITVEC_NINT; j++){
37049       if( aiValues[j] && aiValues[j]!=(i+1) ){
37050         u32 h = BITVEC_HASH(aiValues[j]-1);
37051         p->nSet++;
37052         while( p->u.aHash[h] ){
37053           h++;
37054           if( h>=BITVEC_NINT ) h = 0;
37055         }
37056         p->u.aHash[h] = aiValues[j];
37057       }
37058     }
37059   }
37060 }
37061
37062 /*
37063 ** Destroy a bitmap object.  Reclaim all memory used.
37064 */
37065 SQLCIPHER_PRIVATE void sqlcipher3BitvecDestroy(Bitvec *p){
37066   if( p==0 ) return;
37067   if( p->iDivisor ){
37068     unsigned int i;
37069     for(i=0; i<BITVEC_NPTR; i++){
37070       sqlcipher3BitvecDestroy(p->u.apSub[i]);
37071     }
37072   }
37073   sqlcipher3_free(p);
37074 }
37075
37076 /*
37077 ** Return the value of the iSize parameter specified when Bitvec *p
37078 ** was created.
37079 */
37080 SQLCIPHER_PRIVATE u32 sqlcipher3BitvecSize(Bitvec *p){
37081   return p->iSize;
37082 }
37083
37084 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
37085 /*
37086 ** Let V[] be an array of unsigned characters sufficient to hold
37087 ** up to N bits.  Let I be an integer between 0 and N.  0<=I<N.
37088 ** Then the following macros can be used to set, clear, or test
37089 ** individual bits within V.
37090 */
37091 #define SETBIT(V,I)      V[I>>3] |= (1<<(I&7))
37092 #define CLEARBIT(V,I)    V[I>>3] &= ~(1<<(I&7))
37093 #define TESTBIT(V,I)     (V[I>>3]&(1<<(I&7)))!=0
37094
37095 /*
37096 ** This routine runs an extensive test of the Bitvec code.
37097 **
37098 ** The input is an array of integers that acts as a program
37099 ** to test the Bitvec.  The integers are opcodes followed
37100 ** by 0, 1, or 3 operands, depending on the opcode.  Another
37101 ** opcode follows immediately after the last operand.
37102 **
37103 ** There are 6 opcodes numbered from 0 through 5.  0 is the
37104 ** "halt" opcode and causes the test to end.
37105 **
37106 **    0          Halt and return the number of errors
37107 **    1 N S X    Set N bits beginning with S and incrementing by X
37108 **    2 N S X    Clear N bits beginning with S and incrementing by X
37109 **    3 N        Set N randomly chosen bits
37110 **    4 N        Clear N randomly chosen bits
37111 **    5 N S X    Set N bits from S increment X in array only, not in bitvec
37112 **
37113 ** The opcodes 1 through 4 perform set and clear operations are performed
37114 ** on both a Bitvec object and on a linear array of bits obtained from malloc.
37115 ** Opcode 5 works on the linear array only, not on the Bitvec.
37116 ** Opcode 5 is used to deliberately induce a fault in order to
37117 ** confirm that error detection works.
37118 **
37119 ** At the conclusion of the test the linear array is compared
37120 ** against the Bitvec object.  If there are any differences,
37121 ** an error is returned.  If they are the same, zero is returned.
37122 **
37123 ** If a memory allocation error occurs, return -1.
37124 */
37125 SQLCIPHER_PRIVATE int sqlcipher3BitvecBuiltinTest(int sz, int *aOp){
37126   Bitvec *pBitvec = 0;
37127   unsigned char *pV = 0;
37128   int rc = -1;
37129   int i, nx, pc, op;
37130   void *pTmpSpace;
37131
37132   /* Allocate the Bitvec to be tested and a linear array of
37133   ** bits to act as the reference */
37134   pBitvec = sqlcipher3BitvecCreate( sz );
37135   pV = sqlcipher3_malloc( (sz+7)/8 + 1 );
37136   pTmpSpace = sqlcipher3_malloc(BITVEC_SZ);
37137   if( pBitvec==0 || pV==0 || pTmpSpace==0  ) goto bitvec_end;
37138   memset(pV, 0, (sz+7)/8 + 1);
37139
37140   /* NULL pBitvec tests */
37141   sqlcipher3BitvecSet(0, 1);
37142   sqlcipher3BitvecClear(0, 1, pTmpSpace);
37143
37144   /* Run the program */
37145   pc = 0;
37146   while( (op = aOp[pc])!=0 ){
37147     switch( op ){
37148       case 1:
37149       case 2:
37150       case 5: {
37151         nx = 4;
37152         i = aOp[pc+2] - 1;
37153         aOp[pc+2] += aOp[pc+3];
37154         break;
37155       }
37156       case 3:
37157       case 4: 
37158       default: {
37159         nx = 2;
37160         sqlcipher3_randomness(sizeof(i), &i);
37161         break;
37162       }
37163     }
37164     if( (--aOp[pc+1]) > 0 ) nx = 0;
37165     pc += nx;
37166     i = (i & 0x7fffffff)%sz;
37167     if( (op & 1)!=0 ){
37168       SETBIT(pV, (i+1));
37169       if( op!=5 ){
37170         if( sqlcipher3BitvecSet(pBitvec, i+1) ) goto bitvec_end;
37171       }
37172     }else{
37173       CLEARBIT(pV, (i+1));
37174       sqlcipher3BitvecClear(pBitvec, i+1, pTmpSpace);
37175     }
37176   }
37177
37178   /* Test to make sure the linear array exactly matches the
37179   ** Bitvec object.  Start with the assumption that they do
37180   ** match (rc==0).  Change rc to non-zero if a discrepancy
37181   ** is found.
37182   */
37183   rc = sqlcipher3BitvecTest(0,0) + sqlcipher3BitvecTest(pBitvec, sz+1)
37184           + sqlcipher3BitvecTest(pBitvec, 0)
37185           + (sqlcipher3BitvecSize(pBitvec) - sz);
37186   for(i=1; i<=sz; i++){
37187     if(  (TESTBIT(pV,i))!=sqlcipher3BitvecTest(pBitvec,i) ){
37188       rc = i;
37189       break;
37190     }
37191   }
37192
37193   /* Free allocated structure */
37194 bitvec_end:
37195   sqlcipher3_free(pTmpSpace);
37196   sqlcipher3_free(pV);
37197   sqlcipher3BitvecDestroy(pBitvec);
37198   return rc;
37199 }
37200 #endif /* SQLCIPHER_OMIT_BUILTIN_TEST */
37201
37202 /************** End of bitvec.c **********************************************/
37203 /************** Begin file pcache.c ******************************************/
37204 /*
37205 ** 2008 August 05
37206 **
37207 ** The author disclaims copyright to this source code.  In place of
37208 ** a legal notice, here is a blessing:
37209 **
37210 **    May you do good and not evil.
37211 **    May you find forgiveness for yourself and forgive others.
37212 **    May you share freely, never taking more than you give.
37213 **
37214 *************************************************************************
37215 ** This file implements that page cache.
37216 */
37217
37218 /*
37219 ** A complete page cache is an instance of this structure.
37220 */
37221 struct PCache {
37222   PgHdr *pDirty, *pDirtyTail;         /* List of dirty pages in LRU order */
37223   PgHdr *pSynced;                     /* Last synced page in dirty page list */
37224   int nRef;                           /* Number of referenced pages */
37225   int nMax;                           /* Configured cache size */
37226   int szPage;                         /* Size of every page in this cache */
37227   int szExtra;                        /* Size of extra space for each page */
37228   int bPurgeable;                     /* True if pages are on backing store */
37229   int (*xStress)(void*,PgHdr*);       /* Call to try make a page clean */
37230   void *pStress;                      /* Argument to xStress */
37231   sqlcipher3_pcache *pCache;             /* Pluggable cache module */
37232   PgHdr *pPage1;                      /* Reference to page 1 */
37233 };
37234
37235 /*
37236 ** Some of the assert() macros in this code are too expensive to run
37237 ** even during normal debugging.  Use them only rarely on long-running
37238 ** tests.  Enable the expensive asserts using the
37239 ** -DSQLCIPHER_ENABLE_EXPENSIVE_ASSERT=1 compile-time option.
37240 */
37241 #ifdef SQLCIPHER_ENABLE_EXPENSIVE_ASSERT
37242 # define expensive_assert(X)  assert(X)
37243 #else
37244 # define expensive_assert(X)
37245 #endif
37246
37247 /********************************** Linked List Management ********************/
37248
37249 #if !defined(NDEBUG) && defined(SQLCIPHER_ENABLE_EXPENSIVE_ASSERT)
37250 /*
37251 ** Check that the pCache->pSynced variable is set correctly. If it
37252 ** is not, either fail an assert or return zero. Otherwise, return
37253 ** non-zero. This is only used in debugging builds, as follows:
37254 **
37255 **   expensive_assert( pcacheCheckSynced(pCache) );
37256 */
37257 static int pcacheCheckSynced(PCache *pCache){
37258   PgHdr *p;
37259   for(p=pCache->pDirtyTail; p!=pCache->pSynced; p=p->pDirtyPrev){
37260     assert( p->nRef || (p->flags&PGHDR_NEED_SYNC) );
37261   }
37262   return (p==0 || p->nRef || (p->flags&PGHDR_NEED_SYNC)==0);
37263 }
37264 #endif /* !NDEBUG && SQLCIPHER_ENABLE_EXPENSIVE_ASSERT */
37265
37266 /*
37267 ** Remove page pPage from the list of dirty pages.
37268 */
37269 static void pcacheRemoveFromDirtyList(PgHdr *pPage){
37270   PCache *p = pPage->pCache;
37271
37272   assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
37273   assert( pPage->pDirtyPrev || pPage==p->pDirty );
37274
37275   /* Update the PCache1.pSynced variable if necessary. */
37276   if( p->pSynced==pPage ){
37277     PgHdr *pSynced = pPage->pDirtyPrev;
37278     while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){
37279       pSynced = pSynced->pDirtyPrev;
37280     }
37281     p->pSynced = pSynced;
37282   }
37283
37284   if( pPage->pDirtyNext ){
37285     pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev;
37286   }else{
37287     assert( pPage==p->pDirtyTail );
37288     p->pDirtyTail = pPage->pDirtyPrev;
37289   }
37290   if( pPage->pDirtyPrev ){
37291     pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext;
37292   }else{
37293     assert( pPage==p->pDirty );
37294     p->pDirty = pPage->pDirtyNext;
37295   }
37296   pPage->pDirtyNext = 0;
37297   pPage->pDirtyPrev = 0;
37298
37299   expensive_assert( pcacheCheckSynced(p) );
37300 }
37301
37302 /*
37303 ** Add page pPage to the head of the dirty list (PCache1.pDirty is set to
37304 ** pPage).
37305 */
37306 static void pcacheAddToDirtyList(PgHdr *pPage){
37307   PCache *p = pPage->pCache;
37308
37309   assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
37310
37311   pPage->pDirtyNext = p->pDirty;
37312   if( pPage->pDirtyNext ){
37313     assert( pPage->pDirtyNext->pDirtyPrev==0 );
37314     pPage->pDirtyNext->pDirtyPrev = pPage;
37315   }
37316   p->pDirty = pPage;
37317   if( !p->pDirtyTail ){
37318     p->pDirtyTail = pPage;
37319   }
37320   if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
37321     p->pSynced = pPage;
37322   }
37323   expensive_assert( pcacheCheckSynced(p) );
37324 }
37325
37326 /*
37327 ** Wrapper around the pluggable caches xUnpin method. If the cache is
37328 ** being used for an in-memory database, this function is a no-op.
37329 */
37330 static void pcacheUnpin(PgHdr *p){
37331   PCache *pCache = p->pCache;
37332   if( pCache->bPurgeable ){
37333     if( p->pgno==1 ){
37334       pCache->pPage1 = 0;
37335     }
37336     sqlcipher3GlobalConfig.pcache.xUnpin(pCache->pCache, p, 0);
37337   }
37338 }
37339
37340 /*************************************************** General Interfaces ******
37341 **
37342 ** Initialize and shutdown the page cache subsystem. Neither of these 
37343 ** functions are threadsafe.
37344 */
37345 SQLCIPHER_PRIVATE int sqlcipher3PcacheInitialize(void){
37346   if( sqlcipher3GlobalConfig.pcache.xInit==0 ){
37347     /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the
37348     ** built-in default page cache is used instead of the application defined
37349     ** page cache. */
37350     sqlcipher3PCacheSetDefault();
37351   }
37352   return sqlcipher3GlobalConfig.pcache.xInit(sqlcipher3GlobalConfig.pcache.pArg);
37353 }
37354 SQLCIPHER_PRIVATE void sqlcipher3PcacheShutdown(void){
37355   if( sqlcipher3GlobalConfig.pcache.xShutdown ){
37356     /* IMPLEMENTATION-OF: R-26000-56589 The xShutdown() method may be NULL. */
37357     sqlcipher3GlobalConfig.pcache.xShutdown(sqlcipher3GlobalConfig.pcache.pArg);
37358   }
37359 }
37360
37361 /*
37362 ** Return the size in bytes of a PCache object.
37363 */
37364 SQLCIPHER_PRIVATE int sqlcipher3PcacheSize(void){ return sizeof(PCache); }
37365
37366 /*
37367 ** Create a new PCache object. Storage space to hold the object
37368 ** has already been allocated and is passed in as the p pointer. 
37369 ** The caller discovers how much space needs to be allocated by 
37370 ** calling sqlcipher3PcacheSize().
37371 */
37372 SQLCIPHER_PRIVATE void sqlcipher3PcacheOpen(
37373   int szPage,                  /* Size of every page */
37374   int szExtra,                 /* Extra space associated with each page */
37375   int bPurgeable,              /* True if pages are on backing store */
37376   int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */
37377   void *pStress,               /* Argument to xStress */
37378   PCache *p                    /* Preallocated space for the PCache */
37379 ){
37380   memset(p, 0, sizeof(PCache));
37381   p->szPage = szPage;
37382   p->szExtra = szExtra;
37383   p->bPurgeable = bPurgeable;
37384   p->xStress = xStress;
37385   p->pStress = pStress;
37386   p->nMax = 100;
37387 }
37388
37389 /*
37390 ** Change the page size for PCache object. The caller must ensure that there
37391 ** are no outstanding page references when this function is called.
37392 */
37393 SQLCIPHER_PRIVATE void sqlcipher3PcacheSetPageSize(PCache *pCache, int szPage){
37394   assert( pCache->nRef==0 && pCache->pDirty==0 );
37395   if( pCache->pCache ){
37396     sqlcipher3GlobalConfig.pcache.xDestroy(pCache->pCache);
37397     pCache->pCache = 0;
37398     pCache->pPage1 = 0;
37399   }
37400   pCache->szPage = szPage;
37401 }
37402
37403 /*
37404 ** Try to obtain a page from the cache.
37405 */
37406 SQLCIPHER_PRIVATE int sqlcipher3PcacheFetch(
37407   PCache *pCache,       /* Obtain the page from this cache */
37408   Pgno pgno,            /* Page number to obtain */
37409   int createFlag,       /* If true, create page if it does not exist already */
37410   PgHdr **ppPage        /* Write the page here */
37411 ){
37412   PgHdr *pPage = 0;
37413   int eCreate;
37414
37415   assert( pCache!=0 );
37416   assert( createFlag==1 || createFlag==0 );
37417   assert( pgno>0 );
37418
37419   /* If the pluggable cache (sqlcipher3_pcache*) has not been allocated,
37420   ** allocate it now.
37421   */
37422   if( !pCache->pCache && createFlag ){
37423     sqlcipher3_pcache *p;
37424     int nByte;
37425     nByte = pCache->szPage + pCache->szExtra + sizeof(PgHdr);
37426     p = sqlcipher3GlobalConfig.pcache.xCreate(nByte, pCache->bPurgeable);
37427     if( !p ){
37428       return SQLCIPHER_NOMEM;
37429     }
37430     sqlcipher3GlobalConfig.pcache.xCachesize(p, pCache->nMax);
37431     pCache->pCache = p;
37432   }
37433
37434   eCreate = createFlag * (1 + (!pCache->bPurgeable || !pCache->pDirty));
37435   if( pCache->pCache ){
37436     pPage = sqlcipher3GlobalConfig.pcache.xFetch(pCache->pCache, pgno, eCreate);
37437   }
37438
37439   if( !pPage && eCreate==1 ){
37440     PgHdr *pPg;
37441
37442     /* Find a dirty page to write-out and recycle. First try to find a 
37443     ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
37444     ** cleared), but if that is not possible settle for any other 
37445     ** unreferenced dirty page.
37446     */
37447     expensive_assert( pcacheCheckSynced(pCache) );
37448     for(pPg=pCache->pSynced; 
37449         pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC)); 
37450         pPg=pPg->pDirtyPrev
37451     );
37452     pCache->pSynced = pPg;
37453     if( !pPg ){
37454       for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
37455     }
37456     if( pPg ){
37457       int rc;
37458 #ifdef SQLCIPHER_LOG_CACHE_SPILL
37459       sqlcipher3_log(SQLCIPHER_FULL, 
37460                   "spill page %d making room for %d - cache used: %d/%d",
37461                   pPg->pgno, pgno,
37462                   sqlcipher3GlobalConfig.pcache.xPagecount(pCache->pCache),
37463                   pCache->nMax);
37464 #endif
37465       rc = pCache->xStress(pCache->pStress, pPg);
37466       if( rc!=SQLCIPHER_OK && rc!=SQLCIPHER_BUSY ){
37467         return rc;
37468       }
37469     }
37470
37471     pPage = sqlcipher3GlobalConfig.pcache.xFetch(pCache->pCache, pgno, 2);
37472   }
37473
37474   if( pPage ){
37475     if( !pPage->pData ){
37476       memset(pPage, 0, sizeof(PgHdr));
37477       pPage->pData = (void *)&pPage[1];
37478       pPage->pExtra = (void*)&((char *)pPage->pData)[pCache->szPage];
37479       memset(pPage->pExtra, 0, pCache->szExtra);
37480       pPage->pCache = pCache;
37481       pPage->pgno = pgno;
37482     }
37483     assert( pPage->pCache==pCache );
37484     assert( pPage->pgno==pgno );
37485     assert( pPage->pData==(void *)&pPage[1] );
37486     assert( pPage->pExtra==(void *)&((char *)&pPage[1])[pCache->szPage] );
37487
37488     if( 0==pPage->nRef ){
37489       pCache->nRef++;
37490     }
37491     pPage->nRef++;
37492     if( pgno==1 ){
37493       pCache->pPage1 = pPage;
37494     }
37495   }
37496   *ppPage = pPage;
37497   return (pPage==0 && eCreate) ? SQLCIPHER_NOMEM : SQLCIPHER_OK;
37498 }
37499
37500 /*
37501 ** Decrement the reference count on a page. If the page is clean and the
37502 ** reference count drops to 0, then it is made elible for recycling.
37503 */
37504 SQLCIPHER_PRIVATE void sqlcipher3PcacheRelease(PgHdr *p){
37505   assert( p->nRef>0 );
37506   p->nRef--;
37507   if( p->nRef==0 ){
37508     PCache *pCache = p->pCache;
37509     pCache->nRef--;
37510     if( (p->flags&PGHDR_DIRTY)==0 ){
37511       pcacheUnpin(p);
37512     }else{
37513       /* Move the page to the head of the dirty list. */
37514       pcacheRemoveFromDirtyList(p);
37515       pcacheAddToDirtyList(p);
37516     }
37517   }
37518 }
37519
37520 /*
37521 ** Increase the reference count of a supplied page by 1.
37522 */
37523 SQLCIPHER_PRIVATE void sqlcipher3PcacheRef(PgHdr *p){
37524   assert(p->nRef>0);
37525   p->nRef++;
37526 }
37527
37528 /*
37529 ** Drop a page from the cache. There must be exactly one reference to the
37530 ** page. This function deletes that reference, so after it returns the
37531 ** page pointed to by p is invalid.
37532 */
37533 SQLCIPHER_PRIVATE void sqlcipher3PcacheDrop(PgHdr *p){
37534   PCache *pCache;
37535   assert( p->nRef==1 );
37536   if( p->flags&PGHDR_DIRTY ){
37537     pcacheRemoveFromDirtyList(p);
37538   }
37539   pCache = p->pCache;
37540   pCache->nRef--;
37541   if( p->pgno==1 ){
37542     pCache->pPage1 = 0;
37543   }
37544   sqlcipher3GlobalConfig.pcache.xUnpin(pCache->pCache, p, 1);
37545 }
37546
37547 /*
37548 ** Make sure the page is marked as dirty. If it isn't dirty already,
37549 ** make it so.
37550 */
37551 SQLCIPHER_PRIVATE void sqlcipher3PcacheMakeDirty(PgHdr *p){
37552   p->flags &= ~PGHDR_DONT_WRITE;
37553   assert( p->nRef>0 );
37554   if( 0==(p->flags & PGHDR_DIRTY) ){
37555     p->flags |= PGHDR_DIRTY;
37556     pcacheAddToDirtyList( p);
37557   }
37558 }
37559
37560 /*
37561 ** Make sure the page is marked as clean. If it isn't clean already,
37562 ** make it so.
37563 */
37564 SQLCIPHER_PRIVATE void sqlcipher3PcacheMakeClean(PgHdr *p){
37565   if( (p->flags & PGHDR_DIRTY) ){
37566     pcacheRemoveFromDirtyList(p);
37567     p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC);
37568     if( p->nRef==0 ){
37569       pcacheUnpin(p);
37570     }
37571   }
37572 }
37573
37574 /*
37575 ** Make every page in the cache clean.
37576 */
37577 SQLCIPHER_PRIVATE void sqlcipher3PcacheCleanAll(PCache *pCache){
37578   PgHdr *p;
37579   while( (p = pCache->pDirty)!=0 ){
37580     sqlcipher3PcacheMakeClean(p);
37581   }
37582 }
37583
37584 /*
37585 ** Clear the PGHDR_NEED_SYNC flag from all dirty pages.
37586 */
37587 SQLCIPHER_PRIVATE void sqlcipher3PcacheClearSyncFlags(PCache *pCache){
37588   PgHdr *p;
37589   for(p=pCache->pDirty; p; p=p->pDirtyNext){
37590     p->flags &= ~PGHDR_NEED_SYNC;
37591   }
37592   pCache->pSynced = pCache->pDirtyTail;
37593 }
37594
37595 /*
37596 ** Change the page number of page p to newPgno. 
37597 */
37598 SQLCIPHER_PRIVATE void sqlcipher3PcacheMove(PgHdr *p, Pgno newPgno){
37599   PCache *pCache = p->pCache;
37600   assert( p->nRef>0 );
37601   assert( newPgno>0 );
37602   sqlcipher3GlobalConfig.pcache.xRekey(pCache->pCache, p, p->pgno, newPgno);
37603   p->pgno = newPgno;
37604   if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
37605     pcacheRemoveFromDirtyList(p);
37606     pcacheAddToDirtyList(p);
37607   }
37608 }
37609
37610 /*
37611 ** Drop every cache entry whose page number is greater than "pgno". The
37612 ** caller must ensure that there are no outstanding references to any pages
37613 ** other than page 1 with a page number greater than pgno.
37614 **
37615 ** If there is a reference to page 1 and the pgno parameter passed to this
37616 ** function is 0, then the data area associated with page 1 is zeroed, but
37617 ** the page object is not dropped.
37618 */
37619 SQLCIPHER_PRIVATE void sqlcipher3PcacheTruncate(PCache *pCache, Pgno pgno){
37620   if( pCache->pCache ){
37621     PgHdr *p;
37622     PgHdr *pNext;
37623     for(p=pCache->pDirty; p; p=pNext){
37624       pNext = p->pDirtyNext;
37625       /* This routine never gets call with a positive pgno except right
37626       ** after sqlcipher3PcacheCleanAll().  So if there are dirty pages,
37627       ** it must be that pgno==0.
37628       */
37629       assert( p->pgno>0 );
37630       if( ALWAYS(p->pgno>pgno) ){
37631         assert( p->flags&PGHDR_DIRTY );
37632         sqlcipher3PcacheMakeClean(p);
37633       }
37634     }
37635     if( pgno==0 && pCache->pPage1 ){
37636       memset(pCache->pPage1->pData, 0, pCache->szPage);
37637       pgno = 1;
37638     }
37639     sqlcipher3GlobalConfig.pcache.xTruncate(pCache->pCache, pgno+1);
37640   }
37641 }
37642
37643 /*
37644 ** Close a cache.
37645 */
37646 SQLCIPHER_PRIVATE void sqlcipher3PcacheClose(PCache *pCache){
37647   if( pCache->pCache ){
37648     sqlcipher3GlobalConfig.pcache.xDestroy(pCache->pCache);
37649   }
37650 }
37651
37652 /* 
37653 ** Discard the contents of the cache.
37654 */
37655 SQLCIPHER_PRIVATE void sqlcipher3PcacheClear(PCache *pCache){
37656   sqlcipher3PcacheTruncate(pCache, 0);
37657 }
37658
37659 /*
37660 ** Merge two lists of pages connected by pDirty and in pgno order.
37661 ** Do not both fixing the pDirtyPrev pointers.
37662 */
37663 static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){
37664   PgHdr result, *pTail;
37665   pTail = &result;
37666   while( pA && pB ){
37667     if( pA->pgno<pB->pgno ){
37668       pTail->pDirty = pA;
37669       pTail = pA;
37670       pA = pA->pDirty;
37671     }else{
37672       pTail->pDirty = pB;
37673       pTail = pB;
37674       pB = pB->pDirty;
37675     }
37676   }
37677   if( pA ){
37678     pTail->pDirty = pA;
37679   }else if( pB ){
37680     pTail->pDirty = pB;
37681   }else{
37682     pTail->pDirty = 0;
37683   }
37684   return result.pDirty;
37685 }
37686
37687 /*
37688 ** Sort the list of pages in accending order by pgno.  Pages are
37689 ** connected by pDirty pointers.  The pDirtyPrev pointers are
37690 ** corrupted by this sort.
37691 **
37692 ** Since there cannot be more than 2^31 distinct pages in a database,
37693 ** there cannot be more than 31 buckets required by the merge sorter.
37694 ** One extra bucket is added to catch overflow in case something
37695 ** ever changes to make the previous sentence incorrect.
37696 */
37697 #define N_SORT_BUCKET  32
37698 static PgHdr *pcacheSortDirtyList(PgHdr *pIn){
37699   PgHdr *a[N_SORT_BUCKET], *p;
37700   int i;
37701   memset(a, 0, sizeof(a));
37702   while( pIn ){
37703     p = pIn;
37704     pIn = p->pDirty;
37705     p->pDirty = 0;
37706     for(i=0; ALWAYS(i<N_SORT_BUCKET-1); i++){
37707       if( a[i]==0 ){
37708         a[i] = p;
37709         break;
37710       }else{
37711         p = pcacheMergeDirtyList(a[i], p);
37712         a[i] = 0;
37713       }
37714     }
37715     if( NEVER(i==N_SORT_BUCKET-1) ){
37716       /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
37717       ** the input list.  But that is impossible.
37718       */
37719       a[i] = pcacheMergeDirtyList(a[i], p);
37720     }
37721   }
37722   p = a[0];
37723   for(i=1; i<N_SORT_BUCKET; i++){
37724     p = pcacheMergeDirtyList(p, a[i]);
37725   }
37726   return p;
37727 }
37728
37729 /*
37730 ** Return a list of all dirty pages in the cache, sorted by page number.
37731 */
37732 SQLCIPHER_PRIVATE PgHdr *sqlcipher3PcacheDirtyList(PCache *pCache){
37733   PgHdr *p;
37734   for(p=pCache->pDirty; p; p=p->pDirtyNext){
37735     p->pDirty = p->pDirtyNext;
37736   }
37737   return pcacheSortDirtyList(pCache->pDirty);
37738 }
37739
37740 /* 
37741 ** Return the total number of referenced pages held by the cache.
37742 */
37743 SQLCIPHER_PRIVATE int sqlcipher3PcacheRefCount(PCache *pCache){
37744   return pCache->nRef;
37745 }
37746
37747 /*
37748 ** Return the number of references to the page supplied as an argument.
37749 */
37750 SQLCIPHER_PRIVATE int sqlcipher3PcachePageRefcount(PgHdr *p){
37751   return p->nRef;
37752 }
37753
37754 /* 
37755 ** Return the total number of pages in the cache.
37756 */
37757 SQLCIPHER_PRIVATE int sqlcipher3PcachePagecount(PCache *pCache){
37758   int nPage = 0;
37759   if( pCache->pCache ){
37760     nPage = sqlcipher3GlobalConfig.pcache.xPagecount(pCache->pCache);
37761   }
37762   return nPage;
37763 }
37764
37765 #ifdef SQLCIPHER_TEST
37766 /*
37767 ** Get the suggested cache-size value.
37768 */
37769 SQLCIPHER_PRIVATE int sqlcipher3PcacheGetCachesize(PCache *pCache){
37770   return pCache->nMax;
37771 }
37772 #endif
37773
37774 /*
37775 ** Set the suggested cache-size value.
37776 */
37777 SQLCIPHER_PRIVATE void sqlcipher3PcacheSetCachesize(PCache *pCache, int mxPage){
37778   pCache->nMax = mxPage;
37779   if( pCache->pCache ){
37780     sqlcipher3GlobalConfig.pcache.xCachesize(pCache->pCache, mxPage);
37781   }
37782 }
37783
37784 #if defined(SQLCIPHER_CHECK_PAGES) || defined(SQLCIPHER_DEBUG)
37785 /*
37786 ** For all dirty pages currently in the cache, invoke the specified
37787 ** callback. This is only used if the SQLCIPHER_CHECK_PAGES macro is
37788 ** defined.
37789 */
37790 SQLCIPHER_PRIVATE void sqlcipher3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){
37791   PgHdr *pDirty;
37792   for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext){
37793     xIter(pDirty);
37794   }
37795 }
37796 #endif
37797
37798 /************** End of pcache.c **********************************************/
37799 /************** Begin file pcache1.c *****************************************/
37800 /*
37801 ** 2008 November 05
37802 **
37803 ** The author disclaims copyright to this source code.  In place of
37804 ** a legal notice, here is a blessing:
37805 **
37806 **    May you do good and not evil.
37807 **    May you find forgiveness for yourself and forgive others.
37808 **    May you share freely, never taking more than you give.
37809 **
37810 *************************************************************************
37811 **
37812 ** This file implements the default page cache implementation (the
37813 ** sqlcipher3_pcache interface). It also contains part of the implementation
37814 ** of the SQLCIPHER_CONFIG_PAGECACHE and sqlcipher3_release_memory() features.
37815 ** If the default page cache implementation is overriden, then neither of
37816 ** these two features are available.
37817 */
37818
37819
37820 typedef struct PCache1 PCache1;
37821 typedef struct PgHdr1 PgHdr1;
37822 typedef struct PgFreeslot PgFreeslot;
37823 typedef struct PGroup PGroup;
37824
37825
37826 /* Each page cache (or PCache) belongs to a PGroup.  A PGroup is a set 
37827 ** of one or more PCaches that are able to recycle each others unpinned
37828 ** pages when they are under memory pressure.  A PGroup is an instance of
37829 ** the following object.
37830 **
37831 ** This page cache implementation works in one of two modes:
37832 **
37833 **   (1)  Every PCache is the sole member of its own PGroup.  There is
37834 **        one PGroup per PCache.
37835 **
37836 **   (2)  There is a single global PGroup that all PCaches are a member
37837 **        of.
37838 **
37839 ** Mode 1 uses more memory (since PCache instances are not able to rob
37840 ** unused pages from other PCaches) but it also operates without a mutex,
37841 ** and is therefore often faster.  Mode 2 requires a mutex in order to be
37842 ** threadsafe, but is able recycle pages more efficient.
37843 **
37844 ** For mode (1), PGroup.mutex is NULL.  For mode (2) there is only a single
37845 ** PGroup which is the pcache1.grp global variable and its mutex is
37846 ** SQLCIPHER_MUTEX_STATIC_LRU.
37847 */
37848 struct PGroup {
37849   sqlcipher3_mutex *mutex;          /* MUTEX_STATIC_LRU or NULL */
37850   int nMaxPage;                  /* Sum of nMax for purgeable caches */
37851   int nMinPage;                  /* Sum of nMin for purgeable caches */
37852   int mxPinned;                  /* nMaxpage + 10 - nMinPage */
37853   int nCurrentPage;              /* Number of purgeable pages allocated */
37854   PgHdr1 *pLruHead, *pLruTail;   /* LRU list of unpinned pages */
37855 };
37856
37857 /* Each page cache is an instance of the following object.  Every
37858 ** open database file (including each in-memory database and each
37859 ** temporary or transient database) has a single page cache which
37860 ** is an instance of this object.
37861 **
37862 ** Pointers to structures of this type are cast and returned as 
37863 ** opaque sqlcipher3_pcache* handles.
37864 */
37865 struct PCache1 {
37866   /* Cache configuration parameters. Page size (szPage) and the purgeable
37867   ** flag (bPurgeable) are set when the cache is created. nMax may be 
37868   ** modified at any time by a call to the pcache1CacheSize() method.
37869   ** The PGroup mutex must be held when accessing nMax.
37870   */
37871   PGroup *pGroup;                     /* PGroup this cache belongs to */
37872   int szPage;                         /* Size of allocated pages in bytes */
37873   int bPurgeable;                     /* True if cache is purgeable */
37874   unsigned int nMin;                  /* Minimum number of pages reserved */
37875   unsigned int nMax;                  /* Configured "cache_size" value */
37876   unsigned int n90pct;                /* nMax*9/10 */
37877
37878   /* Hash table of all pages. The following variables may only be accessed
37879   ** when the accessor is holding the PGroup mutex.
37880   */
37881   unsigned int nRecyclable;           /* Number of pages in the LRU list */
37882   unsigned int nPage;                 /* Total number of pages in apHash */
37883   unsigned int nHash;                 /* Number of slots in apHash[] */
37884   PgHdr1 **apHash;                    /* Hash table for fast lookup by key */
37885
37886   unsigned int iMaxKey;               /* Largest key seen since xTruncate() */
37887 };
37888
37889 /*
37890 ** Each cache entry is represented by an instance of the following 
37891 ** structure. A buffer of PgHdr1.pCache->szPage bytes is allocated 
37892 ** directly before this structure in memory (see the PGHDR1_TO_PAGE() 
37893 ** macro below).
37894 */
37895 struct PgHdr1 {
37896   unsigned int iKey;             /* Key value (page number) */
37897   PgHdr1 *pNext;                 /* Next in hash table chain */
37898   PCache1 *pCache;               /* Cache that currently owns this page */
37899   PgHdr1 *pLruNext;              /* Next in LRU list of unpinned pages */
37900   PgHdr1 *pLruPrev;              /* Previous in LRU list of unpinned pages */
37901 };
37902
37903 /*
37904 ** Free slots in the allocator used to divide up the buffer provided using
37905 ** the SQLCIPHER_CONFIG_PAGECACHE mechanism.
37906 */
37907 struct PgFreeslot {
37908   PgFreeslot *pNext;  /* Next free slot */
37909 };
37910
37911 /*
37912 ** Global data used by this cache.
37913 */
37914 static SQLCIPHER_WSD struct PCacheGlobal {
37915   PGroup grp;                    /* The global PGroup for mode (2) */
37916
37917   /* Variables related to SQLCIPHER_CONFIG_PAGECACHE settings.  The
37918   ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
37919   ** fixed at sqlcipher3_initialize() time and do not require mutex protection.
37920   ** The nFreeSlot and pFree values do require mutex protection.
37921   */
37922   int isInit;                    /* True if initialized */
37923   int szSlot;                    /* Size of each free slot */
37924   int nSlot;                     /* The number of pcache slots */
37925   int nReserve;                  /* Try to keep nFreeSlot above this */
37926   void *pStart, *pEnd;           /* Bounds of pagecache malloc range */
37927   /* Above requires no mutex.  Use mutex below for variable that follow. */
37928   sqlcipher3_mutex *mutex;          /* Mutex for accessing the following: */
37929   int nFreeSlot;                 /* Number of unused pcache slots */
37930   PgFreeslot *pFree;             /* Free page blocks */
37931   /* The following value requires a mutex to change.  We skip the mutex on
37932   ** reading because (1) most platforms read a 32-bit integer atomically and
37933   ** (2) even if an incorrect value is read, no great harm is done since this
37934   ** is really just an optimization. */
37935   int bUnderPressure;            /* True if low on PAGECACHE memory */
37936 } pcache1_g;
37937
37938 /*
37939 ** All code in this file should access the global structure above via the
37940 ** alias "pcache1". This ensures that the WSD emulation is used when
37941 ** compiling for systems that do not support real WSD.
37942 */
37943 #define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))
37944
37945 /*
37946 ** When a PgHdr1 structure is allocated, the associated PCache1.szPage
37947 ** bytes of data are located directly before it in memory (i.e. the total
37948 ** size of the allocation is sizeof(PgHdr1)+PCache1.szPage byte). The
37949 ** PGHDR1_TO_PAGE() macro takes a pointer to a PgHdr1 structure as
37950 ** an argument and returns a pointer to the associated block of szPage
37951 ** bytes. The PAGE_TO_PGHDR1() macro does the opposite: its argument is
37952 ** a pointer to a block of szPage bytes of data and the return value is
37953 ** a pointer to the associated PgHdr1 structure.
37954 **
37955 **   assert( PGHDR1_TO_PAGE(PAGE_TO_PGHDR1(pCache, X))==X );
37956 */
37957 #define PGHDR1_TO_PAGE(p)    (void*)(((char*)p) - p->pCache->szPage)
37958 #define PAGE_TO_PGHDR1(c, p) (PgHdr1*)(((char*)p) + c->szPage)
37959
37960 /*
37961 ** Macros to enter and leave the PCache LRU mutex.
37962 */
37963 #define pcache1EnterMutex(X) sqlcipher3_mutex_enter((X)->mutex)
37964 #define pcache1LeaveMutex(X) sqlcipher3_mutex_leave((X)->mutex)
37965
37966 /******************************************************************************/
37967 /******** Page Allocation/SQLCIPHER_CONFIG_PCACHE Related Functions **************/
37968
37969 /*
37970 ** This function is called during initialization if a static buffer is 
37971 ** supplied to use for the page-cache by passing the SQLCIPHER_CONFIG_PAGECACHE
37972 ** verb to sqlcipher3_config(). Parameter pBuf points to an allocation large
37973 ** enough to contain 'n' buffers of 'sz' bytes each.
37974 **
37975 ** This routine is called from sqlcipher3_initialize() and so it is guaranteed
37976 ** to be serialized already.  There is no need for further mutexing.
37977 */
37978 SQLCIPHER_PRIVATE void sqlcipher3PCacheBufferSetup(void *pBuf, int sz, int n){
37979   if( pcache1.isInit ){
37980     PgFreeslot *p;
37981     sz = ROUNDDOWN8(sz);
37982     pcache1.szSlot = sz;
37983     pcache1.nSlot = pcache1.nFreeSlot = n;
37984     pcache1.nReserve = n>90 ? 10 : (n/10 + 1);
37985     pcache1.pStart = pBuf;
37986     pcache1.pFree = 0;
37987     pcache1.bUnderPressure = 0;
37988     while( n-- ){
37989       p = (PgFreeslot*)pBuf;
37990       p->pNext = pcache1.pFree;
37991       pcache1.pFree = p;
37992       pBuf = (void*)&((char*)pBuf)[sz];
37993     }
37994     pcache1.pEnd = pBuf;
37995   }
37996 }
37997
37998 /*
37999 ** Malloc function used within this file to allocate space from the buffer
38000 ** configured using sqlcipher3_config(SQLCIPHER_CONFIG_PAGECACHE) option. If no 
38001 ** such buffer exists or there is no space left in it, this function falls 
38002 ** back to sqlcipher3Malloc().
38003 **
38004 ** Multiple threads can run this routine at the same time.  Global variables
38005 ** in pcache1 need to be protected via mutex.
38006 */
38007 static void *pcache1Alloc(int nByte){
38008   void *p = 0;
38009   assert( sqlcipher3_mutex_notheld(pcache1.grp.mutex) );
38010   sqlcipher3StatusSet(SQLCIPHER_STATUS_PAGECACHE_SIZE, nByte);
38011   if( nByte<=pcache1.szSlot ){
38012     sqlcipher3_mutex_enter(pcache1.mutex);
38013     p = (PgHdr1 *)pcache1.pFree;
38014     if( p ){
38015       pcache1.pFree = pcache1.pFree->pNext;
38016       pcache1.nFreeSlot--;
38017       pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
38018       assert( pcache1.nFreeSlot>=0 );
38019       sqlcipher3StatusAdd(SQLCIPHER_STATUS_PAGECACHE_USED, 1);
38020     }
38021     sqlcipher3_mutex_leave(pcache1.mutex);
38022   }
38023   if( p==0 ){
38024     /* Memory is not available in the SQLCIPHER_CONFIG_PAGECACHE pool.  Get
38025     ** it from sqlcipher3Malloc instead.
38026     */
38027     p = sqlcipher3Malloc(nByte);
38028     if( p ){
38029       int sz = sqlcipher3MallocSize(p);
38030       sqlcipher3_mutex_enter(pcache1.mutex);
38031       sqlcipher3StatusAdd(SQLCIPHER_STATUS_PAGECACHE_OVERFLOW, sz);
38032       sqlcipher3_mutex_leave(pcache1.mutex);
38033     }
38034     sqlcipher3MemdebugSetType(p, MEMTYPE_PCACHE);
38035   }
38036   return p;
38037 }
38038
38039 /*
38040 ** Free an allocated buffer obtained from pcache1Alloc().
38041 */
38042 static void pcache1Free(void *p){
38043   if( p==0 ) return;
38044   if( p>=pcache1.pStart && p<pcache1.pEnd ){
38045     PgFreeslot *pSlot;
38046     sqlcipher3_mutex_enter(pcache1.mutex);
38047     sqlcipher3StatusAdd(SQLCIPHER_STATUS_PAGECACHE_USED, -1);
38048     pSlot = (PgFreeslot*)p;
38049     pSlot->pNext = pcache1.pFree;
38050     pcache1.pFree = pSlot;
38051     pcache1.nFreeSlot++;
38052     pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
38053     assert( pcache1.nFreeSlot<=pcache1.nSlot );
38054     sqlcipher3_mutex_leave(pcache1.mutex);
38055   }else{
38056     int iSize;
38057     assert( sqlcipher3MemdebugHasType(p, MEMTYPE_PCACHE) );
38058     sqlcipher3MemdebugSetType(p, MEMTYPE_HEAP);
38059     iSize = sqlcipher3MallocSize(p);
38060     sqlcipher3_mutex_enter(pcache1.mutex);
38061     sqlcipher3StatusAdd(SQLCIPHER_STATUS_PAGECACHE_OVERFLOW, -iSize);
38062     sqlcipher3_mutex_leave(pcache1.mutex);
38063     sqlcipher3_free(p);
38064   }
38065 }
38066
38067 #ifdef SQLCIPHER_ENABLE_MEMORY_MANAGEMENT
38068 /*
38069 ** Return the size of a pcache allocation
38070 */
38071 static int pcache1MemSize(void *p){
38072   if( p>=pcache1.pStart && p<pcache1.pEnd ){
38073     return pcache1.szSlot;
38074   }else{
38075     int iSize;
38076     assert( sqlcipher3MemdebugHasType(p, MEMTYPE_PCACHE) );
38077     sqlcipher3MemdebugSetType(p, MEMTYPE_HEAP);
38078     iSize = sqlcipher3MallocSize(p);
38079     sqlcipher3MemdebugSetType(p, MEMTYPE_PCACHE);
38080     return iSize;
38081   }
38082 }
38083 #endif /* SQLCIPHER_ENABLE_MEMORY_MANAGEMENT */
38084
38085 /*
38086 ** Allocate a new page object initially associated with cache pCache.
38087 */
38088 static PgHdr1 *pcache1AllocPage(PCache1 *pCache){
38089   int nByte = sizeof(PgHdr1) + pCache->szPage;
38090   PgHdr1 *p = 0;
38091   void *pPg;
38092
38093   /* The group mutex must be released before pcache1Alloc() is called. This
38094   ** is because it may call sqlcipher3_release_memory(), which assumes that 
38095   ** this mutex is not held. */
38096   assert( sqlcipher3_mutex_held(pCache->pGroup->mutex) );
38097   pcache1LeaveMutex(pCache->pGroup);
38098   pPg = pcache1Alloc(nByte);
38099   pcache1EnterMutex(pCache->pGroup);
38100
38101   if( pPg ){
38102     p = PAGE_TO_PGHDR1(pCache, pPg);
38103     if( pCache->bPurgeable ){
38104       pCache->pGroup->nCurrentPage++;
38105     }
38106   }
38107   return p;
38108 }
38109
38110 /*
38111 ** Free a page object allocated by pcache1AllocPage().
38112 **
38113 ** The pointer is allowed to be NULL, which is prudent.  But it turns out
38114 ** that the current implementation happens to never call this routine
38115 ** with a NULL pointer, so we mark the NULL test with ALWAYS().
38116 */
38117 static void pcache1FreePage(PgHdr1 *p){
38118   if( ALWAYS(p) ){
38119     PCache1 *pCache = p->pCache;
38120     assert( sqlcipher3_mutex_held(p->pCache->pGroup->mutex) );
38121     pcache1Free(PGHDR1_TO_PAGE(p));
38122     if( pCache->bPurgeable ){
38123       pCache->pGroup->nCurrentPage--;
38124     }
38125   }
38126 }
38127
38128 /*
38129 ** Malloc function used by SQLite to obtain space from the buffer configured
38130 ** using sqlcipher3_config(SQLCIPHER_CONFIG_PAGECACHE) option. If no such buffer
38131 ** exists, this function falls back to sqlcipher3Malloc().
38132 */
38133 SQLCIPHER_PRIVATE void *sqlcipher3PageMalloc(int sz){
38134   return pcache1Alloc(sz);
38135 }
38136
38137 /*
38138 ** Free an allocated buffer obtained from sqlcipher3PageMalloc().
38139 */
38140 SQLCIPHER_PRIVATE void sqlcipher3PageFree(void *p){
38141   pcache1Free(p);
38142 }
38143
38144
38145 /*
38146 ** Return true if it desirable to avoid allocating a new page cache
38147 ** entry.
38148 **
38149 ** If memory was allocated specifically to the page cache using
38150 ** SQLCIPHER_CONFIG_PAGECACHE but that memory has all been used, then
38151 ** it is desirable to avoid allocating a new page cache entry because
38152 ** presumably SQLCIPHER_CONFIG_PAGECACHE was suppose to be sufficient
38153 ** for all page cache needs and we should not need to spill the
38154 ** allocation onto the heap.
38155 **
38156 ** Or, the heap is used for all page cache memory put the heap is
38157 ** under memory pressure, then again it is desirable to avoid
38158 ** allocating a new page cache entry in order to avoid stressing
38159 ** the heap even further.
38160 */
38161 static int pcache1UnderMemoryPressure(PCache1 *pCache){
38162   if( pcache1.nSlot && pCache->szPage<=pcache1.szSlot ){
38163     return pcache1.bUnderPressure;
38164   }else{
38165     return sqlcipher3HeapNearlyFull();
38166   }
38167 }
38168
38169 /******************************************************************************/
38170 /******** General Implementation Functions ************************************/
38171
38172 /*
38173 ** This function is used to resize the hash table used by the cache passed
38174 ** as the first argument.
38175 **
38176 ** The PCache mutex must be held when this function is called.
38177 */
38178 static int pcache1ResizeHash(PCache1 *p){
38179   PgHdr1 **apNew;
38180   unsigned int nNew;
38181   unsigned int i;
38182
38183   assert( sqlcipher3_mutex_held(p->pGroup->mutex) );
38184
38185   nNew = p->nHash*2;
38186   if( nNew<256 ){
38187     nNew = 256;
38188   }
38189
38190   pcache1LeaveMutex(p->pGroup);
38191   if( p->nHash ){ sqlcipher3BeginBenignMalloc(); }
38192   apNew = (PgHdr1 **)sqlcipher3_malloc(sizeof(PgHdr1 *)*nNew);
38193   if( p->nHash ){ sqlcipher3EndBenignMalloc(); }
38194   pcache1EnterMutex(p->pGroup);
38195   if( apNew ){
38196     memset(apNew, 0, sizeof(PgHdr1 *)*nNew);
38197     for(i=0; i<p->nHash; i++){
38198       PgHdr1 *pPage;
38199       PgHdr1 *pNext = p->apHash[i];
38200       while( (pPage = pNext)!=0 ){
38201         unsigned int h = pPage->iKey % nNew;
38202         pNext = pPage->pNext;
38203         pPage->pNext = apNew[h];
38204         apNew[h] = pPage;
38205       }
38206     }
38207     sqlcipher3_free(p->apHash);
38208     p->apHash = apNew;
38209     p->nHash = nNew;
38210   }
38211
38212   return (p->apHash ? SQLCIPHER_OK : SQLCIPHER_NOMEM);
38213 }
38214
38215 /*
38216 ** This function is used internally to remove the page pPage from the 
38217 ** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
38218 ** LRU list, then this function is a no-op.
38219 **
38220 ** The PGroup mutex must be held when this function is called.
38221 **
38222 ** If pPage is NULL then this routine is a no-op.
38223 */
38224 static void pcache1PinPage(PgHdr1 *pPage){
38225   PCache1 *pCache;
38226   PGroup *pGroup;
38227
38228   if( pPage==0 ) return;
38229   pCache = pPage->pCache;
38230   pGroup = pCache->pGroup;
38231   assert( sqlcipher3_mutex_held(pGroup->mutex) );
38232   if( pPage->pLruNext || pPage==pGroup->pLruTail ){
38233     if( pPage->pLruPrev ){
38234       pPage->pLruPrev->pLruNext = pPage->pLruNext;
38235     }
38236     if( pPage->pLruNext ){
38237       pPage->pLruNext->pLruPrev = pPage->pLruPrev;
38238     }
38239     if( pGroup->pLruHead==pPage ){
38240       pGroup->pLruHead = pPage->pLruNext;
38241     }
38242     if( pGroup->pLruTail==pPage ){
38243       pGroup->pLruTail = pPage->pLruPrev;
38244     }
38245     pPage->pLruNext = 0;
38246     pPage->pLruPrev = 0;
38247     pPage->pCache->nRecyclable--;
38248   }
38249 }
38250
38251
38252 /*
38253 ** Remove the page supplied as an argument from the hash table 
38254 ** (PCache1.apHash structure) that it is currently stored in.
38255 **
38256 ** The PGroup mutex must be held when this function is called.
38257 */
38258 static void pcache1RemoveFromHash(PgHdr1 *pPage){
38259   unsigned int h;
38260   PCache1 *pCache = pPage->pCache;
38261   PgHdr1 **pp;
38262
38263   assert( sqlcipher3_mutex_held(pCache->pGroup->mutex) );
38264   h = pPage->iKey % pCache->nHash;
38265   for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
38266   *pp = (*pp)->pNext;
38267
38268   pCache->nPage--;
38269 }
38270
38271 /*
38272 ** If there are currently more than nMaxPage pages allocated, try
38273 ** to recycle pages to reduce the number allocated to nMaxPage.
38274 */
38275 static void pcache1EnforceMaxPage(PGroup *pGroup){
38276   assert( sqlcipher3_mutex_held(pGroup->mutex) );
38277   while( pGroup->nCurrentPage>pGroup->nMaxPage && pGroup->pLruTail ){
38278     PgHdr1 *p = pGroup->pLruTail;
38279     assert( p->pCache->pGroup==pGroup );
38280     pcache1PinPage(p);
38281     pcache1RemoveFromHash(p);
38282     pcache1FreePage(p);
38283   }
38284 }
38285
38286 /*
38287 ** Discard all pages from cache pCache with a page number (key value) 
38288 ** greater than or equal to iLimit. Any pinned pages that meet this 
38289 ** criteria are unpinned before they are discarded.
38290 **
38291 ** The PCache mutex must be held when this function is called.
38292 */
38293 static void pcache1TruncateUnsafe(
38294   PCache1 *pCache,             /* The cache to truncate */
38295   unsigned int iLimit          /* Drop pages with this pgno or larger */
38296 ){
38297   TESTONLY( unsigned int nPage = 0; )  /* To assert pCache->nPage is correct */
38298   unsigned int h;
38299   assert( sqlcipher3_mutex_held(pCache->pGroup->mutex) );
38300   for(h=0; h<pCache->nHash; h++){
38301     PgHdr1 **pp = &pCache->apHash[h]; 
38302     PgHdr1 *pPage;
38303     while( (pPage = *pp)!=0 ){
38304       if( pPage->iKey>=iLimit ){
38305         pCache->nPage--;
38306         *pp = pPage->pNext;
38307         pcache1PinPage(pPage);
38308         pcache1FreePage(pPage);
38309       }else{
38310         pp = &pPage->pNext;
38311         TESTONLY( nPage++; )
38312       }
38313     }
38314   }
38315   assert( pCache->nPage==nPage );
38316 }
38317
38318 /******************************************************************************/
38319 /******** sqlcipher3_pcache Methods **********************************************/
38320
38321 /*
38322 ** Implementation of the sqlcipher3_pcache.xInit method.
38323 */
38324 static int pcache1Init(void *NotUsed){
38325   UNUSED_PARAMETER(NotUsed);
38326   assert( pcache1.isInit==0 );
38327   memset(&pcache1, 0, sizeof(pcache1));
38328   if( sqlcipher3GlobalConfig.bCoreMutex ){
38329     pcache1.grp.mutex = sqlcipher3_mutex_alloc(SQLCIPHER_MUTEX_STATIC_LRU);
38330     pcache1.mutex = sqlcipher3_mutex_alloc(SQLCIPHER_MUTEX_STATIC_PMEM);
38331   }
38332   pcache1.grp.mxPinned = 10;
38333   pcache1.isInit = 1;
38334   return SQLCIPHER_OK;
38335 }
38336
38337 /*
38338 ** Implementation of the sqlcipher3_pcache.xShutdown method.
38339 ** Note that the static mutex allocated in xInit does 
38340 ** not need to be freed.
38341 */
38342 static void pcache1Shutdown(void *NotUsed){
38343   UNUSED_PARAMETER(NotUsed);
38344   assert( pcache1.isInit!=0 );
38345   memset(&pcache1, 0, sizeof(pcache1));
38346 }
38347
38348 /*
38349 ** Implementation of the sqlcipher3_pcache.xCreate method.
38350 **
38351 ** Allocate a new cache.
38352 */
38353 static sqlcipher3_pcache *pcache1Create(int szPage, int bPurgeable){
38354   PCache1 *pCache;      /* The newly created page cache */
38355   PGroup *pGroup;       /* The group the new page cache will belong to */
38356   int sz;               /* Bytes of memory required to allocate the new cache */
38357
38358   /*
38359   ** The seperateCache variable is true if each PCache has its own private
38360   ** PGroup.  In other words, separateCache is true for mode (1) where no
38361   ** mutexing is required.
38362   **
38363   **   *  Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
38364   **
38365   **   *  Always use a unified cache in single-threaded applications
38366   **
38367   **   *  Otherwise (if multi-threaded and ENABLE_MEMORY_MANAGEMENT is off)
38368   **      use separate caches (mode-1)
38369   */
38370 #if defined(SQLCIPHER_ENABLE_MEMORY_MANAGEMENT) || SQLCIPHER_THREADSAFE==0
38371   const int separateCache = 0;
38372 #else
38373   int separateCache = sqlcipher3GlobalConfig.bCoreMutex>0;
38374 #endif
38375
38376   sz = sizeof(PCache1) + sizeof(PGroup)*separateCache;
38377   pCache = (PCache1 *)sqlcipher3_malloc(sz);
38378   if( pCache ){
38379     memset(pCache, 0, sz);
38380     if( separateCache ){
38381       pGroup = (PGroup*)&pCache[1];
38382       pGroup->mxPinned = 10;
38383     }else{
38384       pGroup = &pcache1.grp;
38385     }
38386     pCache->pGroup = pGroup;
38387     pCache->szPage = szPage;
38388     pCache->bPurgeable = (bPurgeable ? 1 : 0);
38389     if( bPurgeable ){
38390       pCache->nMin = 10;
38391       pcache1EnterMutex(pGroup);
38392       pGroup->nMinPage += pCache->nMin;
38393       pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
38394       pcache1LeaveMutex(pGroup);
38395     }
38396   }
38397   return (sqlcipher3_pcache *)pCache;
38398 }
38399
38400 /*
38401 ** Implementation of the sqlcipher3_pcache.xCachesize method. 
38402 **
38403 ** Configure the cache_size limit for a cache.
38404 */
38405 static void pcache1Cachesize(sqlcipher3_pcache *p, int nMax){
38406   PCache1 *pCache = (PCache1 *)p;
38407   if( pCache->bPurgeable ){
38408     PGroup *pGroup = pCache->pGroup;
38409     pcache1EnterMutex(pGroup);
38410     pGroup->nMaxPage += (nMax - pCache->nMax);
38411     pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
38412     pCache->nMax = nMax;
38413     pCache->n90pct = pCache->nMax*9/10;
38414     pcache1EnforceMaxPage(pGroup);
38415     pcache1LeaveMutex(pGroup);
38416   }
38417 }
38418
38419 /*
38420 ** Implementation of the sqlcipher3_pcache.xPagecount method. 
38421 */
38422 static int pcache1Pagecount(sqlcipher3_pcache *p){
38423   int n;
38424   PCache1 *pCache = (PCache1*)p;
38425   pcache1EnterMutex(pCache->pGroup);
38426   n = pCache->nPage;
38427   pcache1LeaveMutex(pCache->pGroup);
38428   return n;
38429 }
38430
38431 /*
38432 ** Implementation of the sqlcipher3_pcache.xFetch method. 
38433 **
38434 ** Fetch a page by key value.
38435 **
38436 ** Whether or not a new page may be allocated by this function depends on
38437 ** the value of the createFlag argument.  0 means do not allocate a new
38438 ** page.  1 means allocate a new page if space is easily available.  2 
38439 ** means to try really hard to allocate a new page.
38440 **
38441 ** For a non-purgeable cache (a cache used as the storage for an in-memory
38442 ** database) there is really no difference between createFlag 1 and 2.  So
38443 ** the calling function (pcache.c) will never have a createFlag of 1 on
38444 ** a non-purgable cache.
38445 **
38446 ** There are three different approaches to obtaining space for a page,
38447 ** depending on the value of parameter createFlag (which may be 0, 1 or 2).
38448 **
38449 **   1. Regardless of the value of createFlag, the cache is searched for a 
38450 **      copy of the requested page. If one is found, it is returned.
38451 **
38452 **   2. If createFlag==0 and the page is not already in the cache, NULL is
38453 **      returned.
38454 **
38455 **   3. If createFlag is 1, and the page is not already in the cache, then
38456 **      return NULL (do not allocate a new page) if any of the following
38457 **      conditions are true:
38458 **
38459 **       (a) the number of pages pinned by the cache is greater than
38460 **           PCache1.nMax, or
38461 **
38462 **       (b) the number of pages pinned by the cache is greater than
38463 **           the sum of nMax for all purgeable caches, less the sum of 
38464 **           nMin for all other purgeable caches, or
38465 **
38466 **   4. If none of the first three conditions apply and the cache is marked
38467 **      as purgeable, and if one of the following is true:
38468 **
38469 **       (a) The number of pages allocated for the cache is already 
38470 **           PCache1.nMax, or
38471 **
38472 **       (b) The number of pages allocated for all purgeable caches is
38473 **           already equal to or greater than the sum of nMax for all
38474 **           purgeable caches,
38475 **
38476 **       (c) The system is under memory pressure and wants to avoid
38477 **           unnecessary pages cache entry allocations
38478 **
38479 **      then attempt to recycle a page from the LRU list. If it is the right
38480 **      size, return the recycled buffer. Otherwise, free the buffer and
38481 **      proceed to step 5. 
38482 **
38483 **   5. Otherwise, allocate and return a new page buffer.
38484 */
38485 static void *pcache1Fetch(sqlcipher3_pcache *p, unsigned int iKey, int createFlag){
38486   int nPinned;
38487   PCache1 *pCache = (PCache1 *)p;
38488   PGroup *pGroup;
38489   PgHdr1 *pPage = 0;
38490
38491   assert( pCache->bPurgeable || createFlag!=1 );
38492   assert( pCache->bPurgeable || pCache->nMin==0 );
38493   assert( pCache->bPurgeable==0 || pCache->nMin==10 );
38494   assert( pCache->nMin==0 || pCache->bPurgeable );
38495   pcache1EnterMutex(pGroup = pCache->pGroup);
38496
38497   /* Step 1: Search the hash table for an existing entry. */
38498   if( pCache->nHash>0 ){
38499     unsigned int h = iKey % pCache->nHash;
38500     for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
38501   }
38502
38503   /* Step 2: Abort if no existing page is found and createFlag is 0 */
38504   if( pPage || createFlag==0 ){
38505     pcache1PinPage(pPage);
38506     goto fetch_out;
38507   }
38508
38509   /* The pGroup local variable will normally be initialized by the
38510   ** pcache1EnterMutex() macro above.  But if SQLCIPHER_MUTEX_OMIT is defined,
38511   ** then pcache1EnterMutex() is a no-op, so we have to initialize the
38512   ** local variable here.  Delaying the initialization of pGroup is an
38513   ** optimization:  The common case is to exit the module before reaching
38514   ** this point.
38515   */
38516 #ifdef SQLCIPHER_MUTEX_OMIT
38517   pGroup = pCache->pGroup;
38518 #endif
38519
38520
38521   /* Step 3: Abort if createFlag is 1 but the cache is nearly full */
38522   nPinned = pCache->nPage - pCache->nRecyclable;
38523   assert( nPinned>=0 );
38524   assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
38525   assert( pCache->n90pct == pCache->nMax*9/10 );
38526   if( createFlag==1 && (
38527         nPinned>=pGroup->mxPinned
38528      || nPinned>=(int)pCache->n90pct
38529      || pcache1UnderMemoryPressure(pCache)
38530   )){
38531     goto fetch_out;
38532   }
38533
38534   if( pCache->nPage>=pCache->nHash && pcache1ResizeHash(pCache) ){
38535     goto fetch_out;
38536   }
38537
38538   /* Step 4. Try to recycle a page. */
38539   if( pCache->bPurgeable && pGroup->pLruTail && (
38540          (pCache->nPage+1>=pCache->nMax)
38541       || pGroup->nCurrentPage>=pGroup->nMaxPage
38542       || pcache1UnderMemoryPressure(pCache)
38543   )){
38544     PCache1 *pOtherCache;
38545     pPage = pGroup->pLruTail;
38546     pcache1RemoveFromHash(pPage);
38547     pcache1PinPage(pPage);
38548     if( (pOtherCache = pPage->pCache)->szPage!=pCache->szPage ){
38549       pcache1FreePage(pPage);
38550       pPage = 0;
38551     }else{
38552       pGroup->nCurrentPage -= 
38553                (pOtherCache->bPurgeable - pCache->bPurgeable);
38554     }
38555   }
38556
38557   /* Step 5. If a usable page buffer has still not been found, 
38558   ** attempt to allocate a new one. 
38559   */
38560   if( !pPage ){
38561     if( createFlag==1 ) sqlcipher3BeginBenignMalloc();
38562     pPage = pcache1AllocPage(pCache);
38563     if( createFlag==1 ) sqlcipher3EndBenignMalloc();
38564   }
38565
38566   if( pPage ){
38567     unsigned int h = iKey % pCache->nHash;
38568     pCache->nPage++;
38569     pPage->iKey = iKey;
38570     pPage->pNext = pCache->apHash[h];
38571     pPage->pCache = pCache;
38572     pPage->pLruPrev = 0;
38573     pPage->pLruNext = 0;
38574     *(void **)(PGHDR1_TO_PAGE(pPage)) = 0;
38575     pCache->apHash[h] = pPage;
38576   }
38577
38578 fetch_out:
38579   if( pPage && iKey>pCache->iMaxKey ){
38580     pCache->iMaxKey = iKey;
38581   }
38582   pcache1LeaveMutex(pGroup);
38583   return (pPage ? PGHDR1_TO_PAGE(pPage) : 0);
38584 }
38585
38586
38587 /*
38588 ** Implementation of the sqlcipher3_pcache.xUnpin method.
38589 **
38590 ** Mark a page as unpinned (eligible for asynchronous recycling).
38591 */
38592 static void pcache1Unpin(sqlcipher3_pcache *p, void *pPg, int reuseUnlikely){
38593   PCache1 *pCache = (PCache1 *)p;
38594   PgHdr1 *pPage = PAGE_TO_PGHDR1(pCache, pPg);
38595   PGroup *pGroup = pCache->pGroup;
38596  
38597   assert( pPage->pCache==pCache );
38598   pcache1EnterMutex(pGroup);
38599
38600   /* It is an error to call this function if the page is already 
38601   ** part of the PGroup LRU list.
38602   */
38603   assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
38604   assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );
38605
38606   if( reuseUnlikely || pGroup->nCurrentPage>pGroup->nMaxPage ){
38607     pcache1RemoveFromHash(pPage);
38608     pcache1FreePage(pPage);
38609   }else{
38610     /* Add the page to the PGroup LRU list. */
38611     if( pGroup->pLruHead ){
38612       pGroup->pLruHead->pLruPrev = pPage;
38613       pPage->pLruNext = pGroup->pLruHead;
38614       pGroup->pLruHead = pPage;
38615     }else{
38616       pGroup->pLruTail = pPage;
38617       pGroup->pLruHead = pPage;
38618     }
38619     pCache->nRecyclable++;
38620   }
38621
38622   pcache1LeaveMutex(pCache->pGroup);
38623 }
38624
38625 /*
38626 ** Implementation of the sqlcipher3_pcache.xRekey method. 
38627 */
38628 static void pcache1Rekey(
38629   sqlcipher3_pcache *p,
38630   void *pPg,
38631   unsigned int iOld,
38632   unsigned int iNew
38633 ){
38634   PCache1 *pCache = (PCache1 *)p;
38635   PgHdr1 *pPage = PAGE_TO_PGHDR1(pCache, pPg);
38636   PgHdr1 **pp;
38637   unsigned int h; 
38638   assert( pPage->iKey==iOld );
38639   assert( pPage->pCache==pCache );
38640
38641   pcache1EnterMutex(pCache->pGroup);
38642
38643   h = iOld%pCache->nHash;
38644   pp = &pCache->apHash[h];
38645   while( (*pp)!=pPage ){
38646     pp = &(*pp)->pNext;
38647   }
38648   *pp = pPage->pNext;
38649
38650   h = iNew%pCache->nHash;
38651   pPage->iKey = iNew;
38652   pPage->pNext = pCache->apHash[h];
38653   pCache->apHash[h] = pPage;
38654   if( iNew>pCache->iMaxKey ){
38655     pCache->iMaxKey = iNew;
38656   }
38657
38658   pcache1LeaveMutex(pCache->pGroup);
38659 }
38660
38661 /*
38662 ** Implementation of the sqlcipher3_pcache.xTruncate method. 
38663 **
38664 ** Discard all unpinned pages in the cache with a page number equal to
38665 ** or greater than parameter iLimit. Any pinned pages with a page number
38666 ** equal to or greater than iLimit are implicitly unpinned.
38667 */
38668 static void pcache1Truncate(sqlcipher3_pcache *p, unsigned int iLimit){
38669   PCache1 *pCache = (PCache1 *)p;
38670   pcache1EnterMutex(pCache->pGroup);
38671   if( iLimit<=pCache->iMaxKey ){
38672     pcache1TruncateUnsafe(pCache, iLimit);
38673     pCache->iMaxKey = iLimit-1;
38674   }
38675   pcache1LeaveMutex(pCache->pGroup);
38676 }
38677
38678 /*
38679 ** Implementation of the sqlcipher3_pcache.xDestroy method. 
38680 **
38681 ** Destroy a cache allocated using pcache1Create().
38682 */
38683 static void pcache1Destroy(sqlcipher3_pcache *p){
38684   PCache1 *pCache = (PCache1 *)p;
38685   PGroup *pGroup = pCache->pGroup;
38686   assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
38687   pcache1EnterMutex(pGroup);
38688   pcache1TruncateUnsafe(pCache, 0);
38689   pGroup->nMaxPage -= pCache->nMax;
38690   pGroup->nMinPage -= pCache->nMin;
38691   pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
38692   pcache1EnforceMaxPage(pGroup);
38693   pcache1LeaveMutex(pGroup);
38694   sqlcipher3_free(pCache->apHash);
38695   sqlcipher3_free(pCache);
38696 }
38697
38698 /*
38699 ** This function is called during initialization (sqlcipher3_initialize()) to
38700 ** install the default pluggable cache module, assuming the user has not
38701 ** already provided an alternative.
38702 */
38703 SQLCIPHER_PRIVATE void sqlcipher3PCacheSetDefault(void){
38704   static const sqlcipher3_pcache_methods defaultMethods = {
38705     0,                       /* pArg */
38706     pcache1Init,             /* xInit */
38707     pcache1Shutdown,         /* xShutdown */
38708     pcache1Create,           /* xCreate */
38709     pcache1Cachesize,        /* xCachesize */
38710     pcache1Pagecount,        /* xPagecount */
38711     pcache1Fetch,            /* xFetch */
38712     pcache1Unpin,            /* xUnpin */
38713     pcache1Rekey,            /* xRekey */
38714     pcache1Truncate,         /* xTruncate */
38715     pcache1Destroy           /* xDestroy */
38716   };
38717   sqlcipher3_config(SQLCIPHER_CONFIG_PCACHE, &defaultMethods);
38718 }
38719
38720 #ifdef SQLCIPHER_ENABLE_MEMORY_MANAGEMENT
38721 /*
38722 ** This function is called to free superfluous dynamically allocated memory
38723 ** held by the pager system. Memory in use by any SQLite pager allocated
38724 ** by the current thread may be sqlcipher3_free()ed.
38725 **
38726 ** nReq is the number of bytes of memory required. Once this much has
38727 ** been released, the function returns. The return value is the total number 
38728 ** of bytes of memory released.
38729 */
38730 SQLCIPHER_PRIVATE int sqlcipher3PcacheReleaseMemory(int nReq){
38731   int nFree = 0;
38732   assert( sqlcipher3_mutex_notheld(pcache1.grp.mutex) );
38733   assert( sqlcipher3_mutex_notheld(pcache1.mutex) );
38734   if( pcache1.pStart==0 ){
38735     PgHdr1 *p;
38736     pcache1EnterMutex(&pcache1.grp);
38737     while( (nReq<0 || nFree<nReq) && ((p=pcache1.grp.pLruTail)!=0) ){
38738       nFree += pcache1MemSize(PGHDR1_TO_PAGE(p));
38739       pcache1PinPage(p);
38740       pcache1RemoveFromHash(p);
38741       pcache1FreePage(p);
38742     }
38743     pcache1LeaveMutex(&pcache1.grp);
38744   }
38745   return nFree;
38746 }
38747 #endif /* SQLCIPHER_ENABLE_MEMORY_MANAGEMENT */
38748
38749 #ifdef SQLCIPHER_TEST
38750 /*
38751 ** This function is used by test procedures to inspect the internal state
38752 ** of the global cache.
38753 */
38754 SQLCIPHER_PRIVATE void sqlcipher3PcacheStats(
38755   int *pnCurrent,      /* OUT: Total number of pages cached */
38756   int *pnMax,          /* OUT: Global maximum cache size */
38757   int *pnMin,          /* OUT: Sum of PCache1.nMin for purgeable caches */
38758   int *pnRecyclable    /* OUT: Total number of pages available for recycling */
38759 ){
38760   PgHdr1 *p;
38761   int nRecyclable = 0;
38762   for(p=pcache1.grp.pLruHead; p; p=p->pLruNext){
38763     nRecyclable++;
38764   }
38765   *pnCurrent = pcache1.grp.nCurrentPage;
38766   *pnMax = pcache1.grp.nMaxPage;
38767   *pnMin = pcache1.grp.nMinPage;
38768   *pnRecyclable = nRecyclable;
38769 }
38770 #endif
38771
38772 /************** End of pcache1.c *********************************************/
38773 /************** Begin file rowset.c ******************************************/
38774 /*
38775 ** 2008 December 3
38776 **
38777 ** The author disclaims copyright to this source code.  In place of
38778 ** a legal notice, here is a blessing:
38779 **
38780 **    May you do good and not evil.
38781 **    May you find forgiveness for yourself and forgive others.
38782 **    May you share freely, never taking more than you give.
38783 **
38784 *************************************************************************
38785 **
38786 ** This module implements an object we call a "RowSet".
38787 **
38788 ** The RowSet object is a collection of rowids.  Rowids
38789 ** are inserted into the RowSet in an arbitrary order.  Inserts
38790 ** can be intermixed with tests to see if a given rowid has been
38791 ** previously inserted into the RowSet.
38792 **
38793 ** After all inserts are finished, it is possible to extract the
38794 ** elements of the RowSet in sorted order.  Once this extraction
38795 ** process has started, no new elements may be inserted.
38796 **
38797 ** Hence, the primitive operations for a RowSet are:
38798 **
38799 **    CREATE
38800 **    INSERT
38801 **    TEST
38802 **    SMALLEST
38803 **    DESTROY
38804 **
38805 ** The CREATE and DESTROY primitives are the constructor and destructor,
38806 ** obviously.  The INSERT primitive adds a new element to the RowSet.
38807 ** TEST checks to see if an element is already in the RowSet.  SMALLEST
38808 ** extracts the least value from the RowSet.
38809 **
38810 ** The INSERT primitive might allocate additional memory.  Memory is
38811 ** allocated in chunks so most INSERTs do no allocation.  There is an 
38812 ** upper bound on the size of allocated memory.  No memory is freed
38813 ** until DESTROY.
38814 **
38815 ** The TEST primitive includes a "batch" number.  The TEST primitive
38816 ** will only see elements that were inserted before the last change
38817 ** in the batch number.  In other words, if an INSERT occurs between
38818 ** two TESTs where the TESTs have the same batch nubmer, then the
38819 ** value added by the INSERT will not be visible to the second TEST.
38820 ** The initial batch number is zero, so if the very first TEST contains
38821 ** a non-zero batch number, it will see all prior INSERTs.
38822 **
38823 ** No INSERTs may occurs after a SMALLEST.  An assertion will fail if
38824 ** that is attempted.
38825 **
38826 ** The cost of an INSERT is roughly constant.  (Sometime new memory
38827 ** has to be allocated on an INSERT.)  The cost of a TEST with a new
38828 ** batch number is O(NlogN) where N is the number of elements in the RowSet.
38829 ** The cost of a TEST using the same batch number is O(logN).  The cost
38830 ** of the first SMALLEST is O(NlogN).  Second and subsequent SMALLEST
38831 ** primitives are constant time.  The cost of DESTROY is O(N).
38832 **
38833 ** There is an added cost of O(N) when switching between TEST and
38834 ** SMALLEST primitives.
38835 */
38836
38837
38838 /*
38839 ** Target size for allocation chunks.
38840 */
38841 #define ROWSET_ALLOCATION_SIZE 1024
38842
38843 /*
38844 ** The number of rowset entries per allocation chunk.
38845 */
38846 #define ROWSET_ENTRY_PER_CHUNK  \
38847                        ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))
38848
38849 /*
38850 ** Each entry in a RowSet is an instance of the following object.
38851 */
38852 struct RowSetEntry {            
38853   i64 v;                        /* ROWID value for this entry */
38854   struct RowSetEntry *pRight;   /* Right subtree (larger entries) or list */
38855   struct RowSetEntry *pLeft;    /* Left subtree (smaller entries) */
38856 };
38857
38858 /*
38859 ** RowSetEntry objects are allocated in large chunks (instances of the
38860 ** following structure) to reduce memory allocation overhead.  The
38861 ** chunks are kept on a linked list so that they can be deallocated
38862 ** when the RowSet is destroyed.
38863 */
38864 struct RowSetChunk {
38865   struct RowSetChunk *pNextChunk;        /* Next chunk on list of them all */
38866   struct RowSetEntry aEntry[ROWSET_ENTRY_PER_CHUNK]; /* Allocated entries */
38867 };
38868
38869 /*
38870 ** A RowSet in an instance of the following structure.
38871 **
38872 ** A typedef of this structure if found in sqlcipherInt.h.
38873 */
38874 struct RowSet {
38875   struct RowSetChunk *pChunk;    /* List of all chunk allocations */
38876   sqlcipher3 *db;                   /* The database connection */
38877   struct RowSetEntry *pEntry;    /* List of entries using pRight */
38878   struct RowSetEntry *pLast;     /* Last entry on the pEntry list */
38879   struct RowSetEntry *pFresh;    /* Source of new entry objects */
38880   struct RowSetEntry *pTree;     /* Binary tree of entries */
38881   u16 nFresh;                    /* Number of objects on pFresh */
38882   u8 isSorted;                   /* True if pEntry is sorted */
38883   u8 iBatch;                     /* Current insert batch */
38884 };
38885
38886 /*
38887 ** Turn bulk memory into a RowSet object.  N bytes of memory
38888 ** are available at pSpace.  The db pointer is used as a memory context
38889 ** for any subsequent allocations that need to occur.
38890 ** Return a pointer to the new RowSet object.
38891 **
38892 ** It must be the case that N is sufficient to make a Rowset.  If not
38893 ** an assertion fault occurs.
38894 ** 
38895 ** If N is larger than the minimum, use the surplus as an initial
38896 ** allocation of entries available to be filled.
38897 */
38898 SQLCIPHER_PRIVATE RowSet *sqlcipher3RowSetInit(sqlcipher3 *db, void *pSpace, unsigned int N){
38899   RowSet *p;
38900   assert( N >= ROUND8(sizeof(*p)) );
38901   p = pSpace;
38902   p->pChunk = 0;
38903   p->db = db;
38904   p->pEntry = 0;
38905   p->pLast = 0;
38906   p->pTree = 0;
38907   p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
38908   p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
38909   p->isSorted = 1;
38910   p->iBatch = 0;
38911   return p;
38912 }
38913
38914 /*
38915 ** Deallocate all chunks from a RowSet.  This frees all memory that
38916 ** the RowSet has allocated over its lifetime.  This routine is
38917 ** the destructor for the RowSet.
38918 */
38919 SQLCIPHER_PRIVATE void sqlcipher3RowSetClear(RowSet *p){
38920   struct RowSetChunk *pChunk, *pNextChunk;
38921   for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
38922     pNextChunk = pChunk->pNextChunk;
38923     sqlcipher3DbFree(p->db, pChunk);
38924   }
38925   p->pChunk = 0;
38926   p->nFresh = 0;
38927   p->pEntry = 0;
38928   p->pLast = 0;
38929   p->pTree = 0;
38930   p->isSorted = 1;
38931 }
38932
38933 /*
38934 ** Insert a new value into a RowSet.
38935 **
38936 ** The mallocFailed flag of the database connection is set if a
38937 ** memory allocation fails.
38938 */
38939 SQLCIPHER_PRIVATE void sqlcipher3RowSetInsert(RowSet *p, i64 rowid){
38940   struct RowSetEntry *pEntry;  /* The new entry */
38941   struct RowSetEntry *pLast;   /* The last prior entry */
38942   assert( p!=0 );
38943   if( p->nFresh==0 ){
38944     struct RowSetChunk *pNew;
38945     pNew = sqlcipher3DbMallocRaw(p->db, sizeof(*pNew));
38946     if( pNew==0 ){
38947       return;
38948     }
38949     pNew->pNextChunk = p->pChunk;
38950     p->pChunk = pNew;
38951     p->pFresh = pNew->aEntry;
38952     p->nFresh = ROWSET_ENTRY_PER_CHUNK;
38953   }
38954   pEntry = p->pFresh++;
38955   p->nFresh--;
38956   pEntry->v = rowid;
38957   pEntry->pRight = 0;
38958   pLast = p->pLast;
38959   if( pLast ){
38960     if( p->isSorted && rowid<=pLast->v ){
38961       p->isSorted = 0;
38962     }
38963     pLast->pRight = pEntry;
38964   }else{
38965     assert( p->pEntry==0 ); /* Fires if INSERT after SMALLEST */
38966     p->pEntry = pEntry;
38967   }
38968   p->pLast = pEntry;
38969 }
38970
38971 /*
38972 ** Merge two lists of RowSetEntry objects.  Remove duplicates.
38973 **
38974 ** The input lists are connected via pRight pointers and are 
38975 ** assumed to each already be in sorted order.
38976 */
38977 static struct RowSetEntry *rowSetMerge(
38978   struct RowSetEntry *pA,    /* First sorted list to be merged */
38979   struct RowSetEntry *pB     /* Second sorted list to be merged */
38980 ){
38981   struct RowSetEntry head;
38982   struct RowSetEntry *pTail;
38983
38984   pTail = &head;
38985   while( pA && pB ){
38986     assert( pA->pRight==0 || pA->v<=pA->pRight->v );
38987     assert( pB->pRight==0 || pB->v<=pB->pRight->v );
38988     if( pA->v<pB->v ){
38989       pTail->pRight = pA;
38990       pA = pA->pRight;
38991       pTail = pTail->pRight;
38992     }else if( pB->v<pA->v ){
38993       pTail->pRight = pB;
38994       pB = pB->pRight;
38995       pTail = pTail->pRight;
38996     }else{
38997       pA = pA->pRight;
38998     }
38999   }
39000   if( pA ){
39001     assert( pA->pRight==0 || pA->v<=pA->pRight->v );
39002     pTail->pRight = pA;
39003   }else{
39004     assert( pB==0 || pB->pRight==0 || pB->v<=pB->pRight->v );
39005     pTail->pRight = pB;
39006   }
39007   return head.pRight;
39008 }
39009
39010 /*
39011 ** Sort all elements on the pEntry list of the RowSet into ascending order.
39012 */ 
39013 static void rowSetSort(RowSet *p){
39014   unsigned int i;
39015   struct RowSetEntry *pEntry;
39016   struct RowSetEntry *aBucket[40];
39017
39018   assert( p->isSorted==0 );
39019   memset(aBucket, 0, sizeof(aBucket));
39020   while( p->pEntry ){
39021     pEntry = p->pEntry;
39022     p->pEntry = pEntry->pRight;
39023     pEntry->pRight = 0;
39024     for(i=0; aBucket[i]; i++){
39025       pEntry = rowSetMerge(aBucket[i], pEntry);
39026       aBucket[i] = 0;
39027     }
39028     aBucket[i] = pEntry;
39029   }
39030   pEntry = 0;
39031   for(i=0; i<sizeof(aBucket)/sizeof(aBucket[0]); i++){
39032     pEntry = rowSetMerge(pEntry, aBucket[i]);
39033   }
39034   p->pEntry = pEntry;
39035   p->pLast = 0;
39036   p->isSorted = 1;
39037 }
39038
39039
39040 /*
39041 ** The input, pIn, is a binary tree (or subtree) of RowSetEntry objects.
39042 ** Convert this tree into a linked list connected by the pRight pointers
39043 ** and return pointers to the first and last elements of the new list.
39044 */
39045 static void rowSetTreeToList(
39046   struct RowSetEntry *pIn,         /* Root of the input tree */
39047   struct RowSetEntry **ppFirst,    /* Write head of the output list here */
39048   struct RowSetEntry **ppLast      /* Write tail of the output list here */
39049 ){
39050   assert( pIn!=0 );
39051   if( pIn->pLeft ){
39052     struct RowSetEntry *p;
39053     rowSetTreeToList(pIn->pLeft, ppFirst, &p);
39054     p->pRight = pIn;
39055   }else{
39056     *ppFirst = pIn;
39057   }
39058   if( pIn->pRight ){
39059     rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast);
39060   }else{
39061     *ppLast = pIn;
39062   }
39063   assert( (*ppLast)->pRight==0 );
39064 }
39065
39066
39067 /*
39068 ** Convert a sorted list of elements (connected by pRight) into a binary
39069 ** tree with depth of iDepth.  A depth of 1 means the tree contains a single
39070 ** node taken from the head of *ppList.  A depth of 2 means a tree with
39071 ** three nodes.  And so forth.
39072 **
39073 ** Use as many entries from the input list as required and update the
39074 ** *ppList to point to the unused elements of the list.  If the input
39075 ** list contains too few elements, then construct an incomplete tree
39076 ** and leave *ppList set to NULL.
39077 **
39078 ** Return a pointer to the root of the constructed binary tree.
39079 */
39080 static struct RowSetEntry *rowSetNDeepTree(
39081   struct RowSetEntry **ppList,
39082   int iDepth
39083 ){
39084   struct RowSetEntry *p;         /* Root of the new tree */
39085   struct RowSetEntry *pLeft;     /* Left subtree */
39086   if( *ppList==0 ){
39087     return 0;
39088   }
39089   if( iDepth==1 ){
39090     p = *ppList;
39091     *ppList = p->pRight;
39092     p->pLeft = p->pRight = 0;
39093     return p;
39094   }
39095   pLeft = rowSetNDeepTree(ppList, iDepth-1);
39096   p = *ppList;
39097   if( p==0 ){
39098     return pLeft;
39099   }
39100   p->pLeft = pLeft;
39101   *ppList = p->pRight;
39102   p->pRight = rowSetNDeepTree(ppList, iDepth-1);
39103   return p;
39104 }
39105
39106 /*
39107 ** Convert a sorted list of elements into a binary tree. Make the tree
39108 ** as deep as it needs to be in order to contain the entire list.
39109 */
39110 static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){
39111   int iDepth;           /* Depth of the tree so far */
39112   struct RowSetEntry *p;       /* Current tree root */
39113   struct RowSetEntry *pLeft;   /* Left subtree */
39114
39115   assert( pList!=0 );
39116   p = pList;
39117   pList = p->pRight;
39118   p->pLeft = p->pRight = 0;
39119   for(iDepth=1; pList; iDepth++){
39120     pLeft = p;
39121     p = pList;
39122     pList = p->pRight;
39123     p->pLeft = pLeft;
39124     p->pRight = rowSetNDeepTree(&pList, iDepth);
39125   }
39126   return p;
39127 }
39128
39129 /*
39130 ** Convert the list in p->pEntry into a sorted list if it is not
39131 ** sorted already.  If there is a binary tree on p->pTree, then
39132 ** convert it into a list too and merge it into the p->pEntry list.
39133 */
39134 static void rowSetToList(RowSet *p){
39135   if( !p->isSorted ){
39136     rowSetSort(p);
39137   }
39138   if( p->pTree ){
39139     struct RowSetEntry *pHead, *pTail;
39140     rowSetTreeToList(p->pTree, &pHead, &pTail);
39141     p->pTree = 0;
39142     p->pEntry = rowSetMerge(p->pEntry, pHead);
39143   }
39144 }
39145
39146 /*
39147 ** Extract the smallest element from the RowSet.
39148 ** Write the element into *pRowid.  Return 1 on success.  Return
39149 ** 0 if the RowSet is already empty.
39150 **
39151 ** After this routine has been called, the sqlcipher3RowSetInsert()
39152 ** routine may not be called again.  
39153 */
39154 SQLCIPHER_PRIVATE int sqlcipher3RowSetNext(RowSet *p, i64 *pRowid){
39155   rowSetToList(p);
39156   if( p->pEntry ){
39157     *pRowid = p->pEntry->v;
39158     p->pEntry = p->pEntry->pRight;
39159     if( p->pEntry==0 ){
39160       sqlcipher3RowSetClear(p);
39161     }
39162     return 1;
39163   }else{
39164     return 0;
39165   }
39166 }
39167
39168 /*
39169 ** Check to see if element iRowid was inserted into the the rowset as
39170 ** part of any insert batch prior to iBatch.  Return 1 or 0.
39171 */
39172 SQLCIPHER_PRIVATE int sqlcipher3RowSetTest(RowSet *pRowSet, u8 iBatch, sqlcipher3_int64 iRowid){
39173   struct RowSetEntry *p;
39174   if( iBatch!=pRowSet->iBatch ){
39175     if( pRowSet->pEntry ){
39176       rowSetToList(pRowSet);
39177       pRowSet->pTree = rowSetListToTree(pRowSet->pEntry);
39178       pRowSet->pEntry = 0;
39179       pRowSet->pLast = 0;
39180     }
39181     pRowSet->iBatch = iBatch;
39182   }
39183   p = pRowSet->pTree;
39184   while( p ){
39185     if( p->v<iRowid ){
39186       p = p->pRight;
39187     }else if( p->v>iRowid ){
39188       p = p->pLeft;
39189     }else{
39190       return 1;
39191     }
39192   }
39193   return 0;
39194 }
39195
39196 /************** End of rowset.c **********************************************/
39197 /************** Begin file pager.c *******************************************/
39198 /*
39199 ** 2001 September 15
39200 **
39201 ** The author disclaims copyright to this source code.  In place of
39202 ** a legal notice, here is a blessing:
39203 **
39204 **    May you do good and not evil.
39205 **    May you find forgiveness for yourself and forgive others.
39206 **    May you share freely, never taking more than you give.
39207 **
39208 *************************************************************************
39209 ** This is the implementation of the page cache subsystem or "pager".
39210 ** 
39211 ** The pager is used to access a database disk file.  It implements
39212 ** atomic commit and rollback through the use of a journal file that
39213 ** is separate from the database file.  The pager also implements file
39214 ** locking to prevent two processes from writing the same database
39215 ** file simultaneously, or one process from reading the database while
39216 ** another is writing.
39217 */
39218 #ifndef SQLCIPHER_OMIT_DISKIO
39219 /************** Include wal.h in the middle of pager.c ***********************/
39220 /************** Begin file wal.h *********************************************/
39221 /*
39222 ** 2010 February 1
39223 **
39224 ** The author disclaims copyright to this source code.  In place of
39225 ** a legal notice, here is a blessing:
39226 **
39227 **    May you do good and not evil.
39228 **    May you find forgiveness for yourself and forgive others.
39229 **    May you share freely, never taking more than you give.
39230 **
39231 *************************************************************************
39232 ** This header file defines the interface to the write-ahead logging 
39233 ** system. Refer to the comments below and the header comment attached to 
39234 ** the implementation of each function in log.c for further details.
39235 */
39236
39237 #ifndef _WAL_H_
39238 #define _WAL_H_
39239
39240
39241 #ifdef SQLCIPHER_OMIT_WAL
39242 # define sqlcipher3WalOpen(x,y,z)                   0
39243 # define sqlcipher3WalLimit(x,y)
39244 # define sqlcipher3WalClose(w,x,y,z)                0
39245 # define sqlcipher3WalBeginReadTransaction(y,z)     0
39246 # define sqlcipher3WalEndReadTransaction(z)
39247 # define sqlcipher3WalRead(v,w,x,y,z)               0
39248 # define sqlcipher3WalDbsize(y)                     0
39249 # define sqlcipher3WalBeginWriteTransaction(y)      0
39250 # define sqlcipher3WalEndWriteTransaction(x)        0
39251 # define sqlcipher3WalUndo(x,y,z)                   0
39252 # define sqlcipher3WalSavepoint(y,z)
39253 # define sqlcipher3WalSavepointUndo(y,z)            0
39254 # define sqlcipher3WalFrames(u,v,w,x,y,z)           0
39255 # define sqlcipher3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0
39256 # define sqlcipher3WalCallback(z)                   0
39257 # define sqlcipher3WalExclusiveMode(y,z)            0
39258 # define sqlcipher3WalHeapMemory(z)                 0
39259 #else
39260
39261 #define WAL_SAVEPOINT_NDATA 4
39262
39263 /* Connection to a write-ahead log (WAL) file. 
39264 ** There is one object of this type for each pager. 
39265 */
39266 typedef struct Wal Wal;
39267
39268 /* Open and close a connection to a write-ahead log. */
39269 SQLCIPHER_PRIVATE int sqlcipher3WalOpen(sqlcipher3_vfs*, sqlcipher3_file*, const char *, int, i64, Wal**);
39270 SQLCIPHER_PRIVATE int sqlcipher3WalClose(Wal *pWal, int sync_flags, int, u8 *);
39271
39272 /* Set the limiting size of a WAL file. */
39273 SQLCIPHER_PRIVATE void sqlcipher3WalLimit(Wal*, i64);
39274
39275 /* Used by readers to open (lock) and close (unlock) a snapshot.  A 
39276 ** snapshot is like a read-transaction.  It is the state of the database
39277 ** at an instant in time.  sqlcipher3WalOpenSnapshot gets a read lock and
39278 ** preserves the current state even if the other threads or processes
39279 ** write to or checkpoint the WAL.  sqlcipher3WalCloseSnapshot() closes the
39280 ** transaction and releases the lock.
39281 */
39282 SQLCIPHER_PRIVATE int sqlcipher3WalBeginReadTransaction(Wal *pWal, int *);
39283 SQLCIPHER_PRIVATE void sqlcipher3WalEndReadTransaction(Wal *pWal);
39284
39285 /* Read a page from the write-ahead log, if it is present. */
39286 SQLCIPHER_PRIVATE int sqlcipher3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
39287
39288 /* If the WAL is not empty, return the size of the database. */
39289 SQLCIPHER_PRIVATE Pgno sqlcipher3WalDbsize(Wal *pWal);
39290
39291 /* Obtain or release the WRITER lock. */
39292 SQLCIPHER_PRIVATE int sqlcipher3WalBeginWriteTransaction(Wal *pWal);
39293 SQLCIPHER_PRIVATE int sqlcipher3WalEndWriteTransaction(Wal *pWal);
39294
39295 /* Undo any frames written (but not committed) to the log */
39296 SQLCIPHER_PRIVATE int sqlcipher3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
39297
39298 /* Return an integer that records the current (uncommitted) write
39299 ** position in the WAL */
39300 SQLCIPHER_PRIVATE void sqlcipher3WalSavepoint(Wal *pWal, u32 *aWalData);
39301
39302 /* Move the write position of the WAL back to iFrame.  Called in
39303 ** response to a ROLLBACK TO command. */
39304 SQLCIPHER_PRIVATE int sqlcipher3WalSavepointUndo(Wal *pWal, u32 *aWalData);
39305
39306 /* Write a frame or frames to the log. */
39307 SQLCIPHER_PRIVATE int sqlcipher3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
39308
39309 /* Copy pages from the log to the database file */ 
39310 SQLCIPHER_PRIVATE int sqlcipher3WalCheckpoint(
39311   Wal *pWal,                      /* Write-ahead log connection */
39312   int eMode,                      /* One of PASSIVE, FULL and RESTART */
39313   int (*xBusy)(void*),            /* Function to call when busy */
39314   void *pBusyArg,                 /* Context argument for xBusyHandler */
39315   int sync_flags,                 /* Flags to sync db file with (or 0) */
39316   int nBuf,                       /* Size of buffer nBuf */
39317   u8 *zBuf,                       /* Temporary buffer to use */
39318   int *pnLog,                     /* OUT: Number of frames in WAL */
39319   int *pnCkpt                     /* OUT: Number of backfilled frames in WAL */
39320 );
39321
39322 /* Return the value to pass to a sqlcipher3_wal_hook callback, the
39323 ** number of frames in the WAL at the point of the last commit since
39324 ** sqlcipher3WalCallback() was called.  If no commits have occurred since
39325 ** the last call, then return 0.
39326 */
39327 SQLCIPHER_PRIVATE int sqlcipher3WalCallback(Wal *pWal);
39328
39329 /* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released)
39330 ** by the pager layer on the database file.
39331 */
39332 SQLCIPHER_PRIVATE int sqlcipher3WalExclusiveMode(Wal *pWal, int op);
39333
39334 /* Return true if the argument is non-NULL and the WAL module is using
39335 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
39336 ** WAL module is using shared-memory, return false. 
39337 */
39338 SQLCIPHER_PRIVATE int sqlcipher3WalHeapMemory(Wal *pWal);
39339
39340 #endif /* ifndef SQLCIPHER_OMIT_WAL */
39341 #endif /* _WAL_H_ */
39342
39343 /************** End of wal.h *************************************************/
39344 /************** Continuing where we left off in pager.c **********************/
39345
39346
39347 /******************* NOTES ON THE DESIGN OF THE PAGER ************************
39348 **
39349 ** This comment block describes invariants that hold when using a rollback
39350 ** journal.  These invariants do not apply for journal_mode=WAL,
39351 ** journal_mode=MEMORY, or journal_mode=OFF.
39352 **
39353 ** Within this comment block, a page is deemed to have been synced
39354 ** automatically as soon as it is written when PRAGMA synchronous=OFF.
39355 ** Otherwise, the page is not synced until the xSync method of the VFS
39356 ** is called successfully on the file containing the page.
39357 **
39358 ** Definition:  A page of the database file is said to be "overwriteable" if
39359 ** one or more of the following are true about the page:
39360 ** 
39361 **     (a)  The original content of the page as it was at the beginning of
39362 **          the transaction has been written into the rollback journal and
39363 **          synced.
39364 ** 
39365 **     (b)  The page was a freelist leaf page at the start of the transaction.
39366 ** 
39367 **     (c)  The page number is greater than the largest page that existed in
39368 **          the database file at the start of the transaction.
39369 ** 
39370 ** (1) A page of the database file is never overwritten unless one of the
39371 **     following are true:
39372 ** 
39373 **     (a) The page and all other pages on the same sector are overwriteable.
39374 ** 
39375 **     (b) The atomic page write optimization is enabled, and the entire
39376 **         transaction other than the update of the transaction sequence
39377 **         number consists of a single page change.
39378 ** 
39379 ** (2) The content of a page written into the rollback journal exactly matches
39380 **     both the content in the database when the rollback journal was written
39381 **     and the content in the database at the beginning of the current
39382 **     transaction.
39383 ** 
39384 ** (3) Writes to the database file are an integer multiple of the page size
39385 **     in length and are aligned on a page boundary.
39386 ** 
39387 ** (4) Reads from the database file are either aligned on a page boundary and
39388 **     an integer multiple of the page size in length or are taken from the
39389 **     first 100 bytes of the database file.
39390 ** 
39391 ** (5) All writes to the database file are synced prior to the rollback journal
39392 **     being deleted, truncated, or zeroed.
39393 ** 
39394 ** (6) If a master journal file is used, then all writes to the database file
39395 **     are synced prior to the master journal being deleted.
39396 ** 
39397 ** Definition: Two databases (or the same database at two points it time)
39398 ** are said to be "logically equivalent" if they give the same answer to
39399 ** all queries.  Note in particular the the content of freelist leaf
39400 ** pages can be changed arbitarily without effecting the logical equivalence
39401 ** of the database.
39402 ** 
39403 ** (7) At any time, if any subset, including the empty set and the total set,
39404 **     of the unsynced changes to a rollback journal are removed and the 
39405 **     journal is rolled back, the resulting database file will be logical
39406 **     equivalent to the database file at the beginning of the transaction.
39407 ** 
39408 ** (8) When a transaction is rolled back, the xTruncate method of the VFS
39409 **     is called to restore the database file to the same size it was at
39410 **     the beginning of the transaction.  (In some VFSes, the xTruncate
39411 **     method is a no-op, but that does not change the fact the SQLite will
39412 **     invoke it.)
39413 ** 
39414 ** (9) Whenever the database file is modified, at least one bit in the range
39415 **     of bytes from 24 through 39 inclusive will be changed prior to releasing
39416 **     the EXCLUSIVE lock, thus signaling other connections on the same
39417 **     database to flush their caches.
39418 **
39419 ** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
39420 **      than one billion transactions.
39421 **
39422 ** (11) A database file is well-formed at the beginning and at the conclusion
39423 **      of every transaction.
39424 **
39425 ** (12) An EXCLUSIVE lock is held on the database file when writing to
39426 **      the database file.
39427 **
39428 ** (13) A SHARED lock is held on the database file while reading any
39429 **      content out of the database file.
39430 **
39431 ******************************************************************************/
39432
39433 /*
39434 ** Macros for troubleshooting.  Normally turned off
39435 */
39436 #if 0
39437 int sqlcipher3PagerTrace=1;  /* True to enable tracing */
39438 #define sqlcipher3DebugPrintf printf
39439 #define PAGERTRACE(X)     if( sqlcipher3PagerTrace ){ sqlcipher3DebugPrintf X; }
39440 #else
39441 #define PAGERTRACE(X)
39442 #endif
39443
39444 /*
39445 ** The following two macros are used within the PAGERTRACE() macros above
39446 ** to print out file-descriptors. 
39447 **
39448 ** PAGERID() takes a pointer to a Pager struct as its argument. The
39449 ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlcipher3_file
39450 ** struct as its argument.
39451 */
39452 #define PAGERID(p) ((int)(p->fd))
39453 #define FILEHANDLEID(fd) ((int)fd)
39454
39455 /*
39456 ** The Pager.eState variable stores the current 'state' of a pager. A
39457 ** pager may be in any one of the seven states shown in the following
39458 ** state diagram.
39459 **
39460 **                            OPEN <------+------+
39461 **                              |         |      |
39462 **                              V         |      |
39463 **               +---------> READER-------+      |
39464 **               |              |                |
39465 **               |              V                |
39466 **               |<-------WRITER_LOCKED------> ERROR
39467 **               |              |                ^  
39468 **               |              V                |
39469 **               |<------WRITER_CACHEMOD-------->|
39470 **               |              |                |
39471 **               |              V                |
39472 **               |<-------WRITER_DBMOD---------->|
39473 **               |              |                |
39474 **               |              V                |
39475 **               +<------WRITER_FINISHED-------->+
39476 **
39477 **
39478 ** List of state transitions and the C [function] that performs each:
39479 ** 
39480 **   OPEN              -> READER              [sqlcipher3PagerSharedLock]
39481 **   READER            -> OPEN                [pager_unlock]
39482 **
39483 **   READER            -> WRITER_LOCKED       [sqlcipher3PagerBegin]
39484 **   WRITER_LOCKED     -> WRITER_CACHEMOD     [pager_open_journal]
39485 **   WRITER_CACHEMOD   -> WRITER_DBMOD        [syncJournal]
39486 **   WRITER_DBMOD      -> WRITER_FINISHED     [sqlcipher3PagerCommitPhaseOne]
39487 **   WRITER_***        -> READER              [pager_end_transaction]
39488 **
39489 **   WRITER_***        -> ERROR               [pager_error]
39490 **   ERROR             -> OPEN                [pager_unlock]
39491 ** 
39492 **
39493 **  OPEN:
39494 **
39495 **    The pager starts up in this state. Nothing is guaranteed in this
39496 **    state - the file may or may not be locked and the database size is
39497 **    unknown. The database may not be read or written.
39498 **
39499 **    * No read or write transaction is active.
39500 **    * Any lock, or no lock at all, may be held on the database file.
39501 **    * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
39502 **
39503 **  READER:
39504 **
39505 **    In this state all the requirements for reading the database in 
39506 **    rollback (non-WAL) mode are met. Unless the pager is (or recently
39507 **    was) in exclusive-locking mode, a user-level read transaction is 
39508 **    open. The database size is known in this state.
39509 **
39510 **    A connection running with locking_mode=normal enters this state when
39511 **    it opens a read-transaction on the database and returns to state
39512 **    OPEN after the read-transaction is completed. However a connection
39513 **    running in locking_mode=exclusive (including temp databases) remains in
39514 **    this state even after the read-transaction is closed. The only way
39515 **    a locking_mode=exclusive connection can transition from READER to OPEN
39516 **    is via the ERROR state (see below).
39517 ** 
39518 **    * A read transaction may be active (but a write-transaction cannot).
39519 **    * A SHARED or greater lock is held on the database file.
39520 **    * The dbSize variable may be trusted (even if a user-level read 
39521 **      transaction is not active). The dbOrigSize and dbFileSize variables
39522 **      may not be trusted at this point.
39523 **    * If the database is a WAL database, then the WAL connection is open.
39524 **    * Even if a read-transaction is not open, it is guaranteed that 
39525 **      there is no hot-journal in the file-system.
39526 **
39527 **  WRITER_LOCKED:
39528 **
39529 **    The pager moves to this state from READER when a write-transaction
39530 **    is first opened on the database. In WRITER_LOCKED state, all locks 
39531 **    required to start a write-transaction are held, but no actual 
39532 **    modifications to the cache or database have taken place.
39533 **
39534 **    In rollback mode, a RESERVED or (if the transaction was opened with 
39535 **    BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when
39536 **    moving to this state, but the journal file is not written to or opened 
39537 **    to in this state. If the transaction is committed or rolled back while 
39538 **    in WRITER_LOCKED state, all that is required is to unlock the database 
39539 **    file.
39540 **
39541 **    IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
39542 **    If the connection is running with locking_mode=exclusive, an attempt
39543 **    is made to obtain an EXCLUSIVE lock on the database file.
39544 **
39545 **    * A write transaction is active.
39546 **    * If the connection is open in rollback-mode, a RESERVED or greater 
39547 **      lock is held on the database file.
39548 **    * If the connection is open in WAL-mode, a WAL write transaction
39549 **      is open (i.e. sqlcipher3WalBeginWriteTransaction() has been successfully
39550 **      called).
39551 **    * The dbSize, dbOrigSize and dbFileSize variables are all valid.
39552 **    * The contents of the pager cache have not been modified.
39553 **    * The journal file may or may not be open.
39554 **    * Nothing (not even the first header) has been written to the journal.
39555 **
39556 **  WRITER_CACHEMOD:
39557 **
39558 **    A pager moves from WRITER_LOCKED state to this state when a page is
39559 **    first modified by the upper layer. In rollback mode the journal file
39560 **    is opened (if it is not already open) and a header written to the
39561 **    start of it. The database file on disk has not been modified.
39562 **
39563 **    * A write transaction is active.
39564 **    * A RESERVED or greater lock is held on the database file.
39565 **    * The journal file is open and the first header has been written 
39566 **      to it, but the header has not been synced to disk.
39567 **    * The contents of the page cache have been modified.
39568 **
39569 **  WRITER_DBMOD:
39570 **
39571 **    The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
39572 **    when it modifies the contents of the database file. WAL connections
39573 **    never enter this state (since they do not modify the database file,
39574 **    just the log file).
39575 **
39576 **    * A write transaction is active.
39577 **    * An EXCLUSIVE or greater lock is held on the database file.
39578 **    * The journal file is open and the first header has been written 
39579 **      and synced to disk.
39580 **    * The contents of the page cache have been modified (and possibly
39581 **      written to disk).
39582 **
39583 **  WRITER_FINISHED:
39584 **
39585 **    It is not possible for a WAL connection to enter this state.
39586 **
39587 **    A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
39588 **    state after the entire transaction has been successfully written into the
39589 **    database file. In this state the transaction may be committed simply
39590 **    by finalizing the journal file. Once in WRITER_FINISHED state, it is 
39591 **    not possible to modify the database further. At this point, the upper 
39592 **    layer must either commit or rollback the transaction.
39593 **
39594 **    * A write transaction is active.
39595 **    * An EXCLUSIVE or greater lock is held on the database file.
39596 **    * All writing and syncing of journal and database data has finished.
39597 **      If no error occured, all that remains is to finalize the journal to
39598 **      commit the transaction. If an error did occur, the caller will need
39599 **      to rollback the transaction. 
39600 **
39601 **  ERROR:
39602 **
39603 **    The ERROR state is entered when an IO or disk-full error (including
39604 **    SQLCIPHER_IOERR_NOMEM) occurs at a point in the code that makes it 
39605 **    difficult to be sure that the in-memory pager state (cache contents, 
39606 **    db size etc.) are consistent with the contents of the file-system.
39607 **
39608 **    Temporary pager files may enter the ERROR state, but in-memory pagers
39609 **    cannot.
39610 **
39611 **    For example, if an IO error occurs while performing a rollback, 
39612 **    the contents of the page-cache may be left in an inconsistent state.
39613 **    At this point it would be dangerous to change back to READER state
39614 **    (as usually happens after a rollback). Any subsequent readers might
39615 **    report database corruption (due to the inconsistent cache), and if
39616 **    they upgrade to writers, they may inadvertently corrupt the database
39617 **    file. To avoid this hazard, the pager switches into the ERROR state
39618 **    instead of READER following such an error.
39619 **
39620 **    Once it has entered the ERROR state, any attempt to use the pager
39621 **    to read or write data returns an error. Eventually, once all 
39622 **    outstanding transactions have been abandoned, the pager is able to
39623 **    transition back to OPEN state, discarding the contents of the 
39624 **    page-cache and any other in-memory state at the same time. Everything
39625 **    is reloaded from disk (and, if necessary, hot-journal rollback peformed)
39626 **    when a read-transaction is next opened on the pager (transitioning
39627 **    the pager into READER state). At that point the system has recovered 
39628 **    from the error.
39629 **
39630 **    Specifically, the pager jumps into the ERROR state if:
39631 **
39632 **      1. An error occurs while attempting a rollback. This happens in
39633 **         function sqlcipher3PagerRollback().
39634 **
39635 **      2. An error occurs while attempting to finalize a journal file
39636 **         following a commit in function sqlcipher3PagerCommitPhaseTwo().
39637 **
39638 **      3. An error occurs while attempting to write to the journal or
39639 **         database file in function pagerStress() in order to free up
39640 **         memory.
39641 **
39642 **    In other cases, the error is returned to the b-tree layer. The b-tree
39643 **    layer then attempts a rollback operation. If the error condition 
39644 **    persists, the pager enters the ERROR state via condition (1) above.
39645 **
39646 **    Condition (3) is necessary because it can be triggered by a read-only
39647 **    statement executed within a transaction. In this case, if the error
39648 **    code were simply returned to the user, the b-tree layer would not
39649 **    automatically attempt a rollback, as it assumes that an error in a
39650 **    read-only statement cannot leave the pager in an internally inconsistent 
39651 **    state.
39652 **
39653 **    * The Pager.errCode variable is set to something other than SQLCIPHER_OK.
39654 **    * There are one or more outstanding references to pages (after the
39655 **      last reference is dropped the pager should move back to OPEN state).
39656 **    * The pager is not an in-memory pager.
39657 **    
39658 **
39659 ** Notes:
39660 **
39661 **   * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the
39662 **     connection is open in WAL mode. A WAL connection is always in one
39663 **     of the first four states.
39664 **
39665 **   * Normally, a connection open in exclusive mode is never in PAGER_OPEN
39666 **     state. There are two exceptions: immediately after exclusive-mode has
39667 **     been turned on (and before any read or write transactions are 
39668 **     executed), and when the pager is leaving the "error state".
39669 **
39670 **   * See also: assert_pager_state().
39671 */
39672 #define PAGER_OPEN                  0
39673 #define PAGER_READER                1
39674 #define PAGER_WRITER_LOCKED         2
39675 #define PAGER_WRITER_CACHEMOD       3
39676 #define PAGER_WRITER_DBMOD          4
39677 #define PAGER_WRITER_FINISHED       5
39678 #define PAGER_ERROR                 6
39679
39680 /*
39681 ** The Pager.eLock variable is almost always set to one of the 
39682 ** following locking-states, according to the lock currently held on
39683 ** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
39684 ** This variable is kept up to date as locks are taken and released by
39685 ** the pagerLockDb() and pagerUnlockDb() wrappers.
39686 **
39687 ** If the VFS xLock() or xUnlock() returns an error other than SQLCIPHER_BUSY
39688 ** (i.e. one of the SQLCIPHER_IOERR subtypes), it is not clear whether or not
39689 ** the operation was successful. In these circumstances pagerLockDb() and
39690 ** pagerUnlockDb() take a conservative approach - eLock is always updated
39691 ** when unlocking the file, and only updated when locking the file if the
39692 ** VFS call is successful. This way, the Pager.eLock variable may be set
39693 ** to a less exclusive (lower) value than the lock that is actually held
39694 ** at the system level, but it is never set to a more exclusive value.
39695 **
39696 ** This is usually safe. If an xUnlock fails or appears to fail, there may 
39697 ** be a few redundant xLock() calls or a lock may be held for longer than
39698 ** required, but nothing really goes wrong.
39699 **
39700 ** The exception is when the database file is unlocked as the pager moves
39701 ** from ERROR to OPEN state. At this point there may be a hot-journal file 
39702 ** in the file-system that needs to be rolled back (as part of a OPEN->SHARED
39703 ** transition, by the same pager or any other). If the call to xUnlock()
39704 ** fails at this point and the pager is left holding an EXCLUSIVE lock, this
39705 ** can confuse the call to xCheckReservedLock() call made later as part
39706 ** of hot-journal detection.
39707 **
39708 ** xCheckReservedLock() is defined as returning true "if there is a RESERVED 
39709 ** lock held by this process or any others". So xCheckReservedLock may 
39710 ** return true because the caller itself is holding an EXCLUSIVE lock (but
39711 ** doesn't know it because of a previous error in xUnlock). If this happens
39712 ** a hot-journal may be mistaken for a journal being created by an active
39713 ** transaction in another process, causing SQLite to read from the database
39714 ** without rolling it back.
39715 **
39716 ** To work around this, if a call to xUnlock() fails when unlocking the
39717 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
39718 ** is only changed back to a real locking state after a successful call
39719 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
39720 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK 
39721 ** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
39722 ** lock on the database file before attempting to roll it back. See function
39723 ** PagerSharedLock() for more detail.
39724 **
39725 ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in 
39726 ** PAGER_OPEN state.
39727 */
39728 #define UNKNOWN_LOCK                (EXCLUSIVE_LOCK+1)
39729
39730 /*
39731 ** A macro used for invoking the codec if there is one
39732 */
39733 #ifdef SQLCIPHER_HAS_CODEC
39734 # define CODEC1(P,D,N,X,E) \
39735     if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
39736 # define CODEC2(P,D,N,X,E,O) \
39737     if( P->xCodec==0 ){ O=(char*)D; }else \
39738     if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
39739 #else
39740 # define CODEC1(P,D,N,X,E)   /* NO-OP */
39741 # define CODEC2(P,D,N,X,E,O) O=(char*)D
39742 #endif
39743
39744 /*
39745 ** The maximum allowed sector size. 64KiB. If the xSectorsize() method 
39746 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
39747 ** This could conceivably cause corruption following a power failure on
39748 ** such a system. This is currently an undocumented limit.
39749 */
39750 #define MAX_SECTOR_SIZE 0x10000
39751
39752 /*
39753 ** An instance of the following structure is allocated for each active
39754 ** savepoint and statement transaction in the system. All such structures
39755 ** are stored in the Pager.aSavepoint[] array, which is allocated and
39756 ** resized using sqlcipher3Realloc().
39757 **
39758 ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
39759 ** set to 0. If a journal-header is written into the main journal while
39760 ** the savepoint is active, then iHdrOffset is set to the byte offset 
39761 ** immediately following the last journal record written into the main
39762 ** journal before the journal-header. This is required during savepoint
39763 ** rollback (see pagerPlaybackSavepoint()).
39764 */
39765 typedef struct PagerSavepoint PagerSavepoint;
39766 struct PagerSavepoint {
39767   i64 iOffset;                 /* Starting offset in main journal */
39768   i64 iHdrOffset;              /* See above */
39769   Bitvec *pInSavepoint;        /* Set of pages in this savepoint */
39770   Pgno nOrig;                  /* Original number of pages in file */
39771   Pgno iSubRec;                /* Index of first record in sub-journal */
39772 #ifndef SQLCIPHER_OMIT_WAL
39773   u32 aWalData[WAL_SAVEPOINT_NDATA];        /* WAL savepoint context */
39774 #endif
39775 };
39776
39777 /*
39778 ** A open page cache is an instance of struct Pager. A description of
39779 ** some of the more important member variables follows:
39780 **
39781 ** eState
39782 **
39783 **   The current 'state' of the pager object. See the comment and state
39784 **   diagram above for a description of the pager state.
39785 **
39786 ** eLock
39787 **
39788 **   For a real on-disk database, the current lock held on the database file -
39789 **   NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
39790 **
39791 **   For a temporary or in-memory database (neither of which require any
39792 **   locks), this variable is always set to EXCLUSIVE_LOCK. Since such
39793 **   databases always have Pager.exclusiveMode==1, this tricks the pager
39794 **   logic into thinking that it already has all the locks it will ever
39795 **   need (and no reason to release them).
39796 **
39797 **   In some (obscure) circumstances, this variable may also be set to
39798 **   UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
39799 **   details.
39800 **
39801 ** changeCountDone
39802 **
39803 **   This boolean variable is used to make sure that the change-counter 
39804 **   (the 4-byte header field at byte offset 24 of the database file) is 
39805 **   not updated more often than necessary. 
39806 **
39807 **   It is set to true when the change-counter field is updated, which 
39808 **   can only happen if an exclusive lock is held on the database file.
39809 **   It is cleared (set to false) whenever an exclusive lock is 
39810 **   relinquished on the database file. Each time a transaction is committed,
39811 **   The changeCountDone flag is inspected. If it is true, the work of
39812 **   updating the change-counter is omitted for the current transaction.
39813 **
39814 **   This mechanism means that when running in exclusive mode, a connection 
39815 **   need only update the change-counter once, for the first transaction
39816 **   committed.
39817 **
39818 ** setMaster
39819 **
39820 **   When PagerCommitPhaseOne() is called to commit a transaction, it may
39821 **   (or may not) specify a master-journal name to be written into the 
39822 **   journal file before it is synced to disk.
39823 **
39824 **   Whether or not a journal file contains a master-journal pointer affects 
39825 **   the way in which the journal file is finalized after the transaction is 
39826 **   committed or rolled back when running in "journal_mode=PERSIST" mode.
39827 **   If a journal file does not contain a master-journal pointer, it is
39828 **   finalized by overwriting the first journal header with zeroes. If
39829 **   it does contain a master-journal pointer the journal file is finalized 
39830 **   by truncating it to zero bytes, just as if the connection were 
39831 **   running in "journal_mode=truncate" mode.
39832 **
39833 **   Journal files that contain master journal pointers cannot be finalized
39834 **   simply by overwriting the first journal-header with zeroes, as the
39835 **   master journal pointer could interfere with hot-journal rollback of any
39836 **   subsequently interrupted transaction that reuses the journal file.
39837 **
39838 **   The flag is cleared as soon as the journal file is finalized (either
39839 **   by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
39840 **   journal file from being successfully finalized, the setMaster flag
39841 **   is cleared anyway (and the pager will move to ERROR state).
39842 **
39843 ** doNotSpill, doNotSyncSpill
39844 **
39845 **   These two boolean variables control the behaviour of cache-spills
39846 **   (calls made by the pcache module to the pagerStress() routine to
39847 **   write cached data to the file-system in order to free up memory).
39848 **
39849 **   When doNotSpill is non-zero, writing to the database from pagerStress()
39850 **   is disabled altogether. This is done in a very obscure case that
39851 **   comes up during savepoint rollback that requires the pcache module
39852 **   to allocate a new page to prevent the journal file from being written
39853 **   while it is being traversed by code in pager_playback().
39854 ** 
39855 **   If doNotSyncSpill is non-zero, writing to the database from pagerStress()
39856 **   is permitted, but syncing the journal file is not. This flag is set
39857 **   by sqlcipher3PagerWrite() when the file-system sector-size is larger than
39858 **   the database page-size in order to prevent a journal sync from happening 
39859 **   in between the journalling of two pages on the same sector. 
39860 **
39861 ** subjInMemory
39862 **
39863 **   This is a boolean variable. If true, then any required sub-journal
39864 **   is opened as an in-memory journal file. If false, then in-memory
39865 **   sub-journals are only used for in-memory pager files.
39866 **
39867 **   This variable is updated by the upper layer each time a new 
39868 **   write-transaction is opened.
39869 **
39870 ** dbSize, dbOrigSize, dbFileSize
39871 **
39872 **   Variable dbSize is set to the number of pages in the database file.
39873 **   It is valid in PAGER_READER and higher states (all states except for
39874 **   OPEN and ERROR). 
39875 **
39876 **   dbSize is set based on the size of the database file, which may be 
39877 **   larger than the size of the database (the value stored at offset
39878 **   28 of the database header by the btree). If the size of the file
39879 **   is not an integer multiple of the page-size, the value stored in
39880 **   dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
39881 **   Except, any file that is greater than 0 bytes in size is considered
39882 **   to have at least one page. (i.e. a 1KB file with 2K page-size leads
39883 **   to dbSize==1).
39884 **
39885 **   During a write-transaction, if pages with page-numbers greater than
39886 **   dbSize are modified in the cache, dbSize is updated accordingly.
39887 **   Similarly, if the database is truncated using PagerTruncateImage(), 
39888 **   dbSize is updated.
39889 **
39890 **   Variables dbOrigSize and dbFileSize are valid in states 
39891 **   PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
39892 **   variable at the start of the transaction. It is used during rollback,
39893 **   and to determine whether or not pages need to be journalled before
39894 **   being modified.
39895 **
39896 **   Throughout a write-transaction, dbFileSize contains the size of
39897 **   the file on disk in pages. It is set to a copy of dbSize when the
39898 **   write-transaction is first opened, and updated when VFS calls are made
39899 **   to write or truncate the database file on disk. 
39900 **
39901 **   The only reason the dbFileSize variable is required is to suppress 
39902 **   unnecessary calls to xTruncate() after committing a transaction. If, 
39903 **   when a transaction is committed, the dbFileSize variable indicates 
39904 **   that the database file is larger than the database image (Pager.dbSize), 
39905 **   pager_truncate() is called. The pager_truncate() call uses xFilesize()
39906 **   to measure the database file on disk, and then truncates it if required.
39907 **   dbFileSize is not used when rolling back a transaction. In this case
39908 **   pager_truncate() is called unconditionally (which means there may be
39909 **   a call to xFilesize() that is not strictly required). In either case,
39910 **   pager_truncate() may cause the file to become smaller or larger.
39911 **
39912 ** dbHintSize
39913 **
39914 **   The dbHintSize variable is used to limit the number of calls made to
39915 **   the VFS xFileControl(FCNTL_SIZE_HINT) method. 
39916 **
39917 **   dbHintSize is set to a copy of the dbSize variable when a
39918 **   write-transaction is opened (at the same time as dbFileSize and
39919 **   dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
39920 **   dbHintSize is increased to the number of pages that correspond to the
39921 **   size-hint passed to the method call. See pager_write_pagelist() for 
39922 **   details.
39923 **
39924 ** errCode
39925 **
39926 **   The Pager.errCode variable is only ever used in PAGER_ERROR state. It
39927 **   is set to zero in all other states. In PAGER_ERROR state, Pager.errCode 
39928 **   is always set to SQLCIPHER_FULL, SQLCIPHER_IOERR or one of the SQLCIPHER_IOERR_XXX 
39929 **   sub-codes.
39930 */
39931 struct Pager {
39932   sqlcipher3_vfs *pVfs;          /* OS functions to use for IO */
39933   u8 exclusiveMode;           /* Boolean. True if locking_mode==EXCLUSIVE */
39934   u8 journalMode;             /* One of the PAGER_JOURNALMODE_* values */
39935   u8 useJournal;              /* Use a rollback journal on this file */
39936   u8 noReadlock;              /* Do not bother to obtain readlocks */
39937   u8 noSync;                  /* Do not sync the journal if true */
39938   u8 fullSync;                /* Do extra syncs of the journal for robustness */
39939   u8 ckptSyncFlags;           /* SYNC_NORMAL or SYNC_FULL for checkpoint */
39940   u8 syncFlags;               /* SYNC_NORMAL or SYNC_FULL otherwise */
39941   u8 tempFile;                /* zFilename is a temporary file */
39942   u8 readOnly;                /* True for a read-only database */
39943   u8 memDb;                   /* True to inhibit all file I/O */
39944
39945   /**************************************************************************
39946   ** The following block contains those class members that change during
39947   ** routine opertion.  Class members not in this block are either fixed
39948   ** when the pager is first created or else only change when there is a
39949   ** significant mode change (such as changing the page_size, locking_mode,
39950   ** or the journal_mode).  From another view, these class members describe
39951   ** the "state" of the pager, while other class members describe the
39952   ** "configuration" of the pager.
39953   */
39954   u8 eState;                  /* Pager state (OPEN, READER, WRITER_LOCKED..) */
39955   u8 eLock;                   /* Current lock held on database file */
39956   u8 changeCountDone;         /* Set after incrementing the change-counter */
39957   u8 setMaster;               /* True if a m-j name has been written to jrnl */
39958   u8 doNotSpill;              /* Do not spill the cache when non-zero */
39959   u8 doNotSyncSpill;          /* Do not do a spill that requires jrnl sync */
39960   u8 subjInMemory;            /* True to use in-memory sub-journals */
39961   Pgno dbSize;                /* Number of pages in the database */
39962   Pgno dbOrigSize;            /* dbSize before the current transaction */
39963   Pgno dbFileSize;            /* Number of pages in the database file */
39964   Pgno dbHintSize;            /* Value passed to FCNTL_SIZE_HINT call */
39965   int errCode;                /* One of several kinds of errors */
39966   int nRec;                   /* Pages journalled since last j-header written */
39967   u32 cksumInit;              /* Quasi-random value added to every checksum */
39968   u32 nSubRec;                /* Number of records written to sub-journal */
39969   Bitvec *pInJournal;         /* One bit for each page in the database file */
39970   sqlcipher3_file *fd;           /* File descriptor for database */
39971   sqlcipher3_file *jfd;          /* File descriptor for main journal */
39972   sqlcipher3_file *sjfd;         /* File descriptor for sub-journal */
39973   i64 journalOff;             /* Current write offset in the journal file */
39974   i64 journalHdr;             /* Byte offset to previous journal header */
39975   sqlcipher3_backup *pBackup;    /* Pointer to list of ongoing backup processes */
39976   PagerSavepoint *aSavepoint; /* Array of active savepoints */
39977   int nSavepoint;             /* Number of elements in aSavepoint[] */
39978   char dbFileVers[16];        /* Changes whenever database file changes */
39979   /*
39980   ** End of the routinely-changing class members
39981   ***************************************************************************/
39982
39983   u16 nExtra;                 /* Add this many bytes to each in-memory page */
39984   i16 nReserve;               /* Number of unused bytes at end of each page */
39985   u32 vfsFlags;               /* Flags for sqlcipher3_vfs.xOpen() */
39986   u32 sectorSize;             /* Assumed sector size during rollback */
39987   int pageSize;               /* Number of bytes in a page */
39988   Pgno mxPgno;                /* Maximum allowed size of the database */
39989   i64 journalSizeLimit;       /* Size limit for persistent journal files */
39990   char *zFilename;            /* Name of the database file */
39991   char *zJournal;             /* Name of the journal file */
39992   int (*xBusyHandler)(void*); /* Function to call when busy */
39993   void *pBusyHandlerArg;      /* Context argument for xBusyHandler */
39994   int nHit, nMiss;            /* Total cache hits and misses */
39995 #ifdef SQLCIPHER_TEST
39996   int nRead, nWrite;          /* Database pages read/written */
39997 #endif
39998   void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
39999 #ifdef SQLCIPHER_HAS_CODEC
40000   void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
40001   void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
40002   void (*xCodecFree)(void*);             /* Destructor for the codec */
40003   void *pCodec;               /* First argument to xCodec... methods */
40004 #endif
40005   char *pTmpSpace;            /* Pager.pageSize bytes of space for tmp use */
40006   PCache *pPCache;            /* Pointer to page cache object */
40007 #ifndef SQLCIPHER_OMIT_WAL
40008   Wal *pWal;                  /* Write-ahead log used by "journal_mode=wal" */
40009   char *zWal;                 /* File name for write-ahead log */
40010 #endif
40011 };
40012
40013 /*
40014 ** The following global variables hold counters used for
40015 ** testing purposes only.  These variables do not exist in
40016 ** a non-testing build.  These variables are not thread-safe.
40017 */
40018 #ifdef SQLCIPHER_TEST
40019 SQLCIPHER_API int sqlcipher3_pager_readdb_count = 0;    /* Number of full pages read from DB */
40020 SQLCIPHER_API int sqlcipher3_pager_writedb_count = 0;   /* Number of full pages written to DB */
40021 SQLCIPHER_API int sqlcipher3_pager_writej_count = 0;    /* Number of pages written to journal */
40022 # define PAGER_INCR(v)  v++
40023 #else
40024 # define PAGER_INCR(v)
40025 #endif
40026
40027
40028
40029 /*
40030 ** Journal files begin with the following magic string.  The data
40031 ** was obtained from /dev/random.  It is used only as a sanity check.
40032 **
40033 ** Since version 2.8.0, the journal format contains additional sanity
40034 ** checking information.  If the power fails while the journal is being
40035 ** written, semi-random garbage data might appear in the journal
40036 ** file after power is restored.  If an attempt is then made
40037 ** to roll the journal back, the database could be corrupted.  The additional
40038 ** sanity checking data is an attempt to discover the garbage in the
40039 ** journal and ignore it.
40040 **
40041 ** The sanity checking information for the new journal format consists
40042 ** of a 32-bit checksum on each page of data.  The checksum covers both
40043 ** the page number and the pPager->pageSize bytes of data for the page.
40044 ** This cksum is initialized to a 32-bit random value that appears in the
40045 ** journal file right after the header.  The random initializer is important,
40046 ** because garbage data that appears at the end of a journal is likely
40047 ** data that was once in other files that have now been deleted.  If the
40048 ** garbage data came from an obsolete journal file, the checksums might
40049 ** be correct.  But by initializing the checksum to random value which
40050 ** is different for every journal, we minimize that risk.
40051 */
40052 static const unsigned char aJournalMagic[] = {
40053   0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
40054 };
40055
40056 /*
40057 ** The size of the of each page record in the journal is given by
40058 ** the following macro.
40059 */
40060 #define JOURNAL_PG_SZ(pPager)  ((pPager->pageSize) + 8)
40061
40062 /*
40063 ** The journal header size for this pager. This is usually the same 
40064 ** size as a single disk sector. See also setSectorSize().
40065 */
40066 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
40067
40068 /*
40069 ** The macro MEMDB is true if we are dealing with an in-memory database.
40070 ** We do this as a macro so that if the SQLCIPHER_OMIT_MEMORYDB macro is set,
40071 ** the value of MEMDB will be a constant and the compiler will optimize
40072 ** out code that would never execute.
40073 */
40074 #ifdef SQLCIPHER_OMIT_MEMORYDB
40075 # define MEMDB 0
40076 #else
40077 # define MEMDB pPager->memDb
40078 #endif
40079
40080 /*
40081 ** The maximum legal page number is (2^31 - 1).
40082 */
40083 #define PAGER_MAX_PGNO 2147483647
40084
40085 /*
40086 ** The argument to this macro is a file descriptor (type sqlcipher3_file*).
40087 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
40088 **
40089 ** This is so that expressions can be written as:
40090 **
40091 **   if( isOpen(pPager->jfd) ){ ...
40092 **
40093 ** instead of
40094 **
40095 **   if( pPager->jfd->pMethods ){ ...
40096 */
40097 #define isOpen(pFd) ((pFd)->pMethods)
40098
40099 /*
40100 ** Return true if this pager uses a write-ahead log instead of the usual
40101 ** rollback journal. Otherwise false.
40102 */
40103 #ifndef SQLCIPHER_OMIT_WAL
40104 static int pagerUseWal(Pager *pPager){
40105   return (pPager->pWal!=0);
40106 }
40107 #else
40108 # define pagerUseWal(x) 0
40109 # define pagerRollbackWal(x) 0
40110 # define pagerWalFrames(v,w,x,y,z) 0
40111 # define pagerOpenWalIfPresent(z) SQLCIPHER_OK
40112 # define pagerBeginReadTransaction(z) SQLCIPHER_OK
40113 #endif
40114
40115 #ifndef NDEBUG 
40116 /*
40117 ** Usage:
40118 **
40119 **   assert( assert_pager_state(pPager) );
40120 **
40121 ** This function runs many asserts to try to find inconsistencies in
40122 ** the internal state of the Pager object.
40123 */
40124 static int assert_pager_state(Pager *p){
40125   Pager *pPager = p;
40126
40127   /* State must be valid. */
40128   assert( p->eState==PAGER_OPEN
40129        || p->eState==PAGER_READER
40130        || p->eState==PAGER_WRITER_LOCKED
40131        || p->eState==PAGER_WRITER_CACHEMOD
40132        || p->eState==PAGER_WRITER_DBMOD
40133        || p->eState==PAGER_WRITER_FINISHED
40134        || p->eState==PAGER_ERROR
40135   );
40136
40137   /* Regardless of the current state, a temp-file connection always behaves
40138   ** as if it has an exclusive lock on the database file. It never updates
40139   ** the change-counter field, so the changeCountDone flag is always set.
40140   */
40141   assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
40142   assert( p->tempFile==0 || pPager->changeCountDone );
40143
40144   /* If the useJournal flag is clear, the journal-mode must be "OFF". 
40145   ** And if the journal-mode is "OFF", the journal file must not be open.
40146   */
40147   assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
40148   assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
40149
40150   /* Check that MEMDB implies noSync. And an in-memory journal. Since 
40151   ** this means an in-memory pager performs no IO at all, it cannot encounter 
40152   ** either SQLCIPHER_IOERR or SQLCIPHER_FULL during rollback or while finalizing 
40153   ** a journal file. (although the in-memory journal implementation may 
40154   ** return SQLCIPHER_IOERR_NOMEM while the journal file is being written). It 
40155   ** is therefore not possible for an in-memory pager to enter the ERROR 
40156   ** state.
40157   */
40158   if( MEMDB ){
40159     assert( p->noSync );
40160     assert( p->journalMode==PAGER_JOURNALMODE_OFF 
40161          || p->journalMode==PAGER_JOURNALMODE_MEMORY 
40162     );
40163     assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
40164     assert( pagerUseWal(p)==0 );
40165   }
40166
40167   /* If changeCountDone is set, a RESERVED lock or greater must be held
40168   ** on the file.
40169   */
40170   assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
40171   assert( p->eLock!=PENDING_LOCK );
40172
40173   switch( p->eState ){
40174     case PAGER_OPEN:
40175       assert( !MEMDB );
40176       assert( pPager->errCode==SQLCIPHER_OK );
40177       assert( sqlcipher3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
40178       break;
40179
40180     case PAGER_READER:
40181       assert( pPager->errCode==SQLCIPHER_OK );
40182       assert( p->eLock!=UNKNOWN_LOCK );
40183       assert( p->eLock>=SHARED_LOCK || p->noReadlock );
40184       break;
40185
40186     case PAGER_WRITER_LOCKED:
40187       assert( p->eLock!=UNKNOWN_LOCK );
40188       assert( pPager->errCode==SQLCIPHER_OK );
40189       if( !pagerUseWal(pPager) ){
40190         assert( p->eLock>=RESERVED_LOCK );
40191       }
40192       assert( pPager->dbSize==pPager->dbOrigSize );
40193       assert( pPager->dbOrigSize==pPager->dbFileSize );
40194       assert( pPager->dbOrigSize==pPager->dbHintSize );
40195       assert( pPager->setMaster==0 );
40196       break;
40197
40198     case PAGER_WRITER_CACHEMOD:
40199       assert( p->eLock!=UNKNOWN_LOCK );
40200       assert( pPager->errCode==SQLCIPHER_OK );
40201       if( !pagerUseWal(pPager) ){
40202         /* It is possible that if journal_mode=wal here that neither the
40203         ** journal file nor the WAL file are open. This happens during
40204         ** a rollback transaction that switches from journal_mode=off
40205         ** to journal_mode=wal.
40206         */
40207         assert( p->eLock>=RESERVED_LOCK );
40208         assert( isOpen(p->jfd) 
40209              || p->journalMode==PAGER_JOURNALMODE_OFF 
40210              || p->journalMode==PAGER_JOURNALMODE_WAL 
40211         );
40212       }
40213       assert( pPager->dbOrigSize==pPager->dbFileSize );
40214       assert( pPager->dbOrigSize==pPager->dbHintSize );
40215       break;
40216
40217     case PAGER_WRITER_DBMOD:
40218       assert( p->eLock==EXCLUSIVE_LOCK );
40219       assert( pPager->errCode==SQLCIPHER_OK );
40220       assert( !pagerUseWal(pPager) );
40221       assert( p->eLock>=EXCLUSIVE_LOCK );
40222       assert( isOpen(p->jfd) 
40223            || p->journalMode==PAGER_JOURNALMODE_OFF 
40224            || p->journalMode==PAGER_JOURNALMODE_WAL 
40225       );
40226       assert( pPager->dbOrigSize<=pPager->dbHintSize );
40227       break;
40228
40229     case PAGER_WRITER_FINISHED:
40230       assert( p->eLock==EXCLUSIVE_LOCK );
40231       assert( pPager->errCode==SQLCIPHER_OK );
40232       assert( !pagerUseWal(pPager) );
40233       assert( isOpen(p->jfd) 
40234            || p->journalMode==PAGER_JOURNALMODE_OFF 
40235            || p->journalMode==PAGER_JOURNALMODE_WAL 
40236       );
40237       break;
40238
40239     case PAGER_ERROR:
40240       /* There must be at least one outstanding reference to the pager if
40241       ** in ERROR state. Otherwise the pager should have already dropped
40242       ** back to OPEN state.
40243       */
40244       assert( pPager->errCode!=SQLCIPHER_OK );
40245       assert( sqlcipher3PcacheRefCount(pPager->pPCache)>0 );
40246       break;
40247   }
40248
40249   return 1;
40250 }
40251 #endif /* ifndef NDEBUG */
40252
40253 #ifdef SQLCIPHER_DEBUG 
40254 /*
40255 ** Return a pointer to a human readable string in a static buffer
40256 ** containing the state of the Pager object passed as an argument. This
40257 ** is intended to be used within debuggers. For example, as an alternative
40258 ** to "print *pPager" in gdb:
40259 **
40260 ** (gdb) printf "%s", print_pager_state(pPager)
40261 */
40262 static char *print_pager_state(Pager *p){
40263   static char zRet[1024];
40264
40265   sqlcipher3_snprintf(1024, zRet,
40266       "Filename:      %s\n"
40267       "State:         %s errCode=%d\n"
40268       "Lock:          %s\n"
40269       "Locking mode:  locking_mode=%s\n"
40270       "Journal mode:  journal_mode=%s\n"
40271       "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
40272       "Journal:       journalOff=%lld journalHdr=%lld\n"
40273       "Size:          dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
40274       , p->zFilename
40275       , p->eState==PAGER_OPEN            ? "OPEN" :
40276         p->eState==PAGER_READER          ? "READER" :
40277         p->eState==PAGER_WRITER_LOCKED   ? "WRITER_LOCKED" :
40278         p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
40279         p->eState==PAGER_WRITER_DBMOD    ? "WRITER_DBMOD" :
40280         p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
40281         p->eState==PAGER_ERROR           ? "ERROR" : "?error?"
40282       , (int)p->errCode
40283       , p->eLock==NO_LOCK         ? "NO_LOCK" :
40284         p->eLock==RESERVED_LOCK   ? "RESERVED" :
40285         p->eLock==EXCLUSIVE_LOCK  ? "EXCLUSIVE" :
40286         p->eLock==SHARED_LOCK     ? "SHARED" :
40287         p->eLock==UNKNOWN_LOCK    ? "UNKNOWN" : "?error?"
40288       , p->exclusiveMode ? "exclusive" : "normal"
40289       , p->journalMode==PAGER_JOURNALMODE_MEMORY   ? "memory" :
40290         p->journalMode==PAGER_JOURNALMODE_OFF      ? "off" :
40291         p->journalMode==PAGER_JOURNALMODE_DELETE   ? "delete" :
40292         p->journalMode==PAGER_JOURNALMODE_PERSIST  ? "persist" :
40293         p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
40294         p->journalMode==PAGER_JOURNALMODE_WAL      ? "wal" : "?error?"
40295       , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
40296       , p->journalOff, p->journalHdr
40297       , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
40298   );
40299
40300   return zRet;
40301 }
40302 #endif
40303
40304 /*
40305 ** Return true if it is necessary to write page *pPg into the sub-journal.
40306 ** A page needs to be written into the sub-journal if there exists one
40307 ** or more open savepoints for which:
40308 **
40309 **   * The page-number is less than or equal to PagerSavepoint.nOrig, and
40310 **   * The bit corresponding to the page-number is not set in
40311 **     PagerSavepoint.pInSavepoint.
40312 */
40313 static int subjRequiresPage(PgHdr *pPg){
40314   Pgno pgno = pPg->pgno;
40315   Pager *pPager = pPg->pPager;
40316   int i;
40317   for(i=0; i<pPager->nSavepoint; i++){
40318     PagerSavepoint *p = &pPager->aSavepoint[i];
40319     if( p->nOrig>=pgno && 0==sqlcipher3BitvecTest(p->pInSavepoint, pgno) ){
40320       return 1;
40321     }
40322   }
40323   return 0;
40324 }
40325
40326 /*
40327 ** Return true if the page is already in the journal file.
40328 */
40329 static int pageInJournal(PgHdr *pPg){
40330   return sqlcipher3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
40331 }
40332
40333 /*
40334 ** Read a 32-bit integer from the given file descriptor.  Store the integer
40335 ** that is read in *pRes.  Return SQLCIPHER_OK if everything worked, or an
40336 ** error code is something goes wrong.
40337 **
40338 ** All values are stored on disk as big-endian.
40339 */
40340 static int read32bits(sqlcipher3_file *fd, i64 offset, u32 *pRes){
40341   unsigned char ac[4];
40342   int rc = sqlcipher3OsRead(fd, ac, sizeof(ac), offset);
40343   if( rc==SQLCIPHER_OK ){
40344     *pRes = sqlcipher3Get4byte(ac);
40345   }
40346   return rc;
40347 }
40348
40349 /*
40350 ** Write a 32-bit integer into a string buffer in big-endian byte order.
40351 */
40352 #define put32bits(A,B)  sqlcipher3Put4byte((u8*)A,B)
40353
40354
40355 /*
40356 ** Write a 32-bit integer into the given file descriptor.  Return SQLCIPHER_OK
40357 ** on success or an error code is something goes wrong.
40358 */
40359 static int write32bits(sqlcipher3_file *fd, i64 offset, u32 val){
40360   char ac[4];
40361   put32bits(ac, val);
40362   return sqlcipher3OsWrite(fd, ac, 4, offset);
40363 }
40364
40365 /*
40366 ** Unlock the database file to level eLock, which must be either NO_LOCK
40367 ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
40368 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
40369 **
40370 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
40371 ** called, do not modify it. See the comment above the #define of 
40372 ** UNKNOWN_LOCK for an explanation of this.
40373 */
40374 static int pagerUnlockDb(Pager *pPager, int eLock){
40375   int rc = SQLCIPHER_OK;
40376
40377   assert( !pPager->exclusiveMode || pPager->eLock==eLock );
40378   assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
40379   assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
40380   if( isOpen(pPager->fd) ){
40381     assert( pPager->eLock>=eLock );
40382     rc = sqlcipher3OsUnlock(pPager->fd, eLock);
40383     if( pPager->eLock!=UNKNOWN_LOCK ){
40384       pPager->eLock = (u8)eLock;
40385     }
40386     IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
40387   }
40388   return rc;
40389 }
40390
40391 /*
40392 ** Lock the database file to level eLock, which must be either SHARED_LOCK,
40393 ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
40394 ** Pager.eLock variable to the new locking state. 
40395 **
40396 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is 
40397 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK. 
40398 ** See the comment above the #define of UNKNOWN_LOCK for an explanation 
40399 ** of this.
40400 */
40401 static int pagerLockDb(Pager *pPager, int eLock){
40402   int rc = SQLCIPHER_OK;
40403
40404   assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
40405   if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
40406     rc = sqlcipher3OsLock(pPager->fd, eLock);
40407     if( rc==SQLCIPHER_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
40408       pPager->eLock = (u8)eLock;
40409       IOTRACE(("LOCK %p %d\n", pPager, eLock))
40410     }
40411   }
40412   return rc;
40413 }
40414
40415 /*
40416 ** This function determines whether or not the atomic-write optimization
40417 ** can be used with this pager. The optimization can be used if:
40418 **
40419 **  (a) the value returned by OsDeviceCharacteristics() indicates that
40420 **      a database page may be written atomically, and
40421 **  (b) the value returned by OsSectorSize() is less than or equal
40422 **      to the page size.
40423 **
40424 ** The optimization is also always enabled for temporary files. It is
40425 ** an error to call this function if pPager is opened on an in-memory
40426 ** database.
40427 **
40428 ** If the optimization cannot be used, 0 is returned. If it can be used,
40429 ** then the value returned is the size of the journal file when it
40430 ** contains rollback data for exactly one page.
40431 */
40432 #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
40433 static int jrnlBufferSize(Pager *pPager){
40434   assert( !MEMDB );
40435   if( !pPager->tempFile ){
40436     int dc;                           /* Device characteristics */
40437     int nSector;                      /* Sector size */
40438     int szPage;                       /* Page size */
40439
40440     assert( isOpen(pPager->fd) );
40441     dc = sqlcipher3OsDeviceCharacteristics(pPager->fd);
40442     nSector = pPager->sectorSize;
40443     szPage = pPager->pageSize;
40444
40445     assert(SQLCIPHER_IOCAP_ATOMIC512==(512>>8));
40446     assert(SQLCIPHER_IOCAP_ATOMIC64K==(65536>>8));
40447     if( 0==(dc&(SQLCIPHER_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
40448       return 0;
40449     }
40450   }
40451
40452   return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
40453 }
40454 #endif
40455
40456 /*
40457 ** If SQLCIPHER_CHECK_PAGES is defined then we do some sanity checking
40458 ** on the cache using a hash function.  This is used for testing
40459 ** and debugging only.
40460 */
40461 #ifdef SQLCIPHER_CHECK_PAGES
40462 /*
40463 ** Return a 32-bit hash of the page data for pPage.
40464 */
40465 static u32 pager_datahash(int nByte, unsigned char *pData){
40466   u32 hash = 0;
40467   int i;
40468   for(i=0; i<nByte; i++){
40469     hash = (hash*1039) + pData[i];
40470   }
40471   return hash;
40472 }
40473 static u32 pager_pagehash(PgHdr *pPage){
40474   return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
40475 }
40476 static void pager_set_pagehash(PgHdr *pPage){
40477   pPage->pageHash = pager_pagehash(pPage);
40478 }
40479
40480 /*
40481 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLCIPHER_CHECK_PAGES
40482 ** is defined, and NDEBUG is not defined, an assert() statement checks
40483 ** that the page is either dirty or still matches the calculated page-hash.
40484 */
40485 #define CHECK_PAGE(x) checkPage(x)
40486 static void checkPage(PgHdr *pPg){
40487   Pager *pPager = pPg->pPager;
40488   assert( pPager->eState!=PAGER_ERROR );
40489   assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
40490 }
40491
40492 #else
40493 #define pager_datahash(X,Y)  0
40494 #define pager_pagehash(X)  0
40495 #define pager_set_pagehash(X)
40496 #define CHECK_PAGE(x)
40497 #endif  /* SQLCIPHER_CHECK_PAGES */
40498
40499 /*
40500 ** When this is called the journal file for pager pPager must be open.
40501 ** This function attempts to read a master journal file name from the 
40502 ** end of the file and, if successful, copies it into memory supplied 
40503 ** by the caller. See comments above writeMasterJournal() for the format
40504 ** used to store a master journal file name at the end of a journal file.
40505 **
40506 ** zMaster must point to a buffer of at least nMaster bytes allocated by
40507 ** the caller. This should be sqlcipher3_vfs.mxPathname+1 (to ensure there is
40508 ** enough space to write the master journal name). If the master journal
40509 ** name in the journal is longer than nMaster bytes (including a
40510 ** nul-terminator), then this is handled as if no master journal name
40511 ** were present in the journal.
40512 **
40513 ** If a master journal file name is present at the end of the journal
40514 ** file, then it is copied into the buffer pointed to by zMaster. A
40515 ** nul-terminator byte is appended to the buffer following the master
40516 ** journal file name.
40517 **
40518 ** If it is determined that no master journal file name is present 
40519 ** zMaster[0] is set to 0 and SQLCIPHER_OK returned.
40520 **
40521 ** If an error occurs while reading from the journal file, an SQLite
40522 ** error code is returned.
40523 */
40524 static int readMasterJournal(sqlcipher3_file *pJrnl, char *zMaster, u32 nMaster){
40525   int rc;                    /* Return code */
40526   u32 len;                   /* Length in bytes of master journal name */
40527   i64 szJ;                   /* Total size in bytes of journal file pJrnl */
40528   u32 cksum;                 /* MJ checksum value read from journal */
40529   u32 u;                     /* Unsigned loop counter */
40530   unsigned char aMagic[8];   /* A buffer to hold the magic header */
40531   zMaster[0] = '\0';
40532
40533   if( SQLCIPHER_OK!=(rc = sqlcipher3OsFileSize(pJrnl, &szJ))
40534    || szJ<16
40535    || SQLCIPHER_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
40536    || len>=nMaster 
40537    || SQLCIPHER_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
40538    || SQLCIPHER_OK!=(rc = sqlcipher3OsRead(pJrnl, aMagic, 8, szJ-8))
40539    || memcmp(aMagic, aJournalMagic, 8)
40540    || SQLCIPHER_OK!=(rc = sqlcipher3OsRead(pJrnl, zMaster, len, szJ-16-len))
40541   ){
40542     return rc;
40543   }
40544
40545   /* See if the checksum matches the master journal name */
40546   for(u=0; u<len; u++){
40547     cksum -= zMaster[u];
40548   }
40549   if( cksum ){
40550     /* If the checksum doesn't add up, then one or more of the disk sectors
40551     ** containing the master journal filename is corrupted. This means
40552     ** definitely roll back, so just return SQLCIPHER_OK and report a (nul)
40553     ** master-journal filename.
40554     */
40555     len = 0;
40556   }
40557   zMaster[len] = '\0';
40558    
40559   return SQLCIPHER_OK;
40560 }
40561
40562 /*
40563 ** Return the offset of the sector boundary at or immediately 
40564 ** following the value in pPager->journalOff, assuming a sector 
40565 ** size of pPager->sectorSize bytes.
40566 **
40567 ** i.e for a sector size of 512:
40568 **
40569 **   Pager.journalOff          Return value
40570 **   ---------------------------------------
40571 **   0                         0
40572 **   512                       512
40573 **   100                       512
40574 **   2000                      2048
40575 ** 
40576 */
40577 static i64 journalHdrOffset(Pager *pPager){
40578   i64 offset = 0;
40579   i64 c = pPager->journalOff;
40580   if( c ){
40581     offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
40582   }
40583   assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
40584   assert( offset>=c );
40585   assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
40586   return offset;
40587 }
40588
40589 /*
40590 ** The journal file must be open when this function is called.
40591 **
40592 ** This function is a no-op if the journal file has not been written to
40593 ** within the current transaction (i.e. if Pager.journalOff==0).
40594 **
40595 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
40596 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
40597 ** zero the 28-byte header at the start of the journal file. In either case, 
40598 ** if the pager is not in no-sync mode, sync the journal file immediately 
40599 ** after writing or truncating it.
40600 **
40601 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
40602 ** following the truncation or zeroing described above the size of the 
40603 ** journal file in bytes is larger than this value, then truncate the
40604 ** journal file to Pager.journalSizeLimit bytes. The journal file does
40605 ** not need to be synced following this operation.
40606 **
40607 ** If an IO error occurs, abandon processing and return the IO error code.
40608 ** Otherwise, return SQLCIPHER_OK.
40609 */
40610 static int zeroJournalHdr(Pager *pPager, int doTruncate){
40611   int rc = SQLCIPHER_OK;                               /* Return code */
40612   assert( isOpen(pPager->jfd) );
40613   if( pPager->journalOff ){
40614     const i64 iLimit = pPager->journalSizeLimit;    /* Local cache of jsl */
40615
40616     IOTRACE(("JZEROHDR %p\n", pPager))
40617     if( doTruncate || iLimit==0 ){
40618       rc = sqlcipher3OsTruncate(pPager->jfd, 0);
40619     }else{
40620       static const char zeroHdr[28] = {0};
40621       rc = sqlcipher3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
40622     }
40623     if( rc==SQLCIPHER_OK && !pPager->noSync ){
40624       rc = sqlcipher3OsSync(pPager->jfd, SQLCIPHER_SYNC_DATAONLY|pPager->syncFlags);
40625     }
40626
40627     /* At this point the transaction is committed but the write lock 
40628     ** is still held on the file. If there is a size limit configured for 
40629     ** the persistent journal and the journal file currently consumes more
40630     ** space than that limit allows for, truncate it now. There is no need
40631     ** to sync the file following this operation.
40632     */
40633     if( rc==SQLCIPHER_OK && iLimit>0 ){
40634       i64 sz;
40635       rc = sqlcipher3OsFileSize(pPager->jfd, &sz);
40636       if( rc==SQLCIPHER_OK && sz>iLimit ){
40637         rc = sqlcipher3OsTruncate(pPager->jfd, iLimit);
40638       }
40639     }
40640   }
40641   return rc;
40642 }
40643
40644 /*
40645 ** The journal file must be open when this routine is called. A journal
40646 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
40647 ** current location.
40648 **
40649 ** The format for the journal header is as follows:
40650 ** - 8 bytes: Magic identifying journal format.
40651 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
40652 ** - 4 bytes: Random number used for page hash.
40653 ** - 4 bytes: Initial database page count.
40654 ** - 4 bytes: Sector size used by the process that wrote this journal.
40655 ** - 4 bytes: Database page size.
40656 ** 
40657 ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
40658 */
40659 static int writeJournalHdr(Pager *pPager){
40660   int rc = SQLCIPHER_OK;                 /* Return code */
40661   char *zHeader = pPager->pTmpSpace;  /* Temporary space used to build header */
40662   u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
40663   u32 nWrite;                         /* Bytes of header sector written */
40664   int ii;                             /* Loop counter */
40665
40666   assert( isOpen(pPager->jfd) );      /* Journal file must be open. */
40667
40668   if( nHeader>JOURNAL_HDR_SZ(pPager) ){
40669     nHeader = JOURNAL_HDR_SZ(pPager);
40670   }
40671
40672   /* If there are active savepoints and any of them were created 
40673   ** since the most recent journal header was written, update the 
40674   ** PagerSavepoint.iHdrOffset fields now.
40675   */
40676   for(ii=0; ii<pPager->nSavepoint; ii++){
40677     if( pPager->aSavepoint[ii].iHdrOffset==0 ){
40678       pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
40679     }
40680   }
40681
40682   pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
40683
40684   /* 
40685   ** Write the nRec Field - the number of page records that follow this
40686   ** journal header. Normally, zero is written to this value at this time.
40687   ** After the records are added to the journal (and the journal synced, 
40688   ** if in full-sync mode), the zero is overwritten with the true number
40689   ** of records (see syncJournal()).
40690   **
40691   ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
40692   ** reading the journal this value tells SQLite to assume that the
40693   ** rest of the journal file contains valid page records. This assumption
40694   ** is dangerous, as if a failure occurred whilst writing to the journal
40695   ** file it may contain some garbage data. There are two scenarios
40696   ** where this risk can be ignored:
40697   **
40698   **   * When the pager is in no-sync mode. Corruption can follow a
40699   **     power failure in this case anyway.
40700   **
40701   **   * When the SQLCIPHER_IOCAP_SAFE_APPEND flag is set. This guarantees
40702   **     that garbage data is never appended to the journal file.
40703   */
40704   assert( isOpen(pPager->fd) || pPager->noSync );
40705   if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
40706    || (sqlcipher3OsDeviceCharacteristics(pPager->fd)&SQLCIPHER_IOCAP_SAFE_APPEND) 
40707   ){
40708     memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
40709     put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
40710   }else{
40711     memset(zHeader, 0, sizeof(aJournalMagic)+4);
40712   }
40713
40714   /* The random check-hash initialiser */ 
40715   sqlcipher3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
40716   put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
40717   /* The initial database size */
40718   put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
40719   /* The assumed sector size for this process */
40720   put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
40721
40722   /* The page size */
40723   put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
40724
40725   /* Initializing the tail of the buffer is not necessary.  Everything
40726   ** works find if the following memset() is omitted.  But initializing
40727   ** the memory prevents valgrind from complaining, so we are willing to
40728   ** take the performance hit.
40729   */
40730   memset(&zHeader[sizeof(aJournalMagic)+20], 0,
40731          nHeader-(sizeof(aJournalMagic)+20));
40732
40733   /* In theory, it is only necessary to write the 28 bytes that the 
40734   ** journal header consumes to the journal file here. Then increment the 
40735   ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next 
40736   ** record is written to the following sector (leaving a gap in the file
40737   ** that will be implicitly filled in by the OS).
40738   **
40739   ** However it has been discovered that on some systems this pattern can 
40740   ** be significantly slower than contiguously writing data to the file,
40741   ** even if that means explicitly writing data to the block of 
40742   ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
40743   ** is done. 
40744   **
40745   ** The loop is required here in case the sector-size is larger than the 
40746   ** database page size. Since the zHeader buffer is only Pager.pageSize
40747   ** bytes in size, more than one call to sqlcipher3OsWrite() may be required
40748   ** to populate the entire journal header sector.
40749   */ 
40750   for(nWrite=0; rc==SQLCIPHER_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
40751     IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
40752     rc = sqlcipher3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
40753     assert( pPager->journalHdr <= pPager->journalOff );
40754     pPager->journalOff += nHeader;
40755   }
40756
40757   return rc;
40758 }
40759
40760 /*
40761 ** The journal file must be open when this is called. A journal header file
40762 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
40763 ** file. The current location in the journal file is given by
40764 ** pPager->journalOff. See comments above function writeJournalHdr() for
40765 ** a description of the journal header format.
40766 **
40767 ** If the header is read successfully, *pNRec is set to the number of
40768 ** page records following this header and *pDbSize is set to the size of the
40769 ** database before the transaction began, in pages. Also, pPager->cksumInit
40770 ** is set to the value read from the journal header. SQLCIPHER_OK is returned
40771 ** in this case.
40772 **
40773 ** If the journal header file appears to be corrupted, SQLCIPHER_DONE is
40774 ** returned and *pNRec and *PDbSize are undefined.  If JOURNAL_HDR_SZ bytes
40775 ** cannot be read from the journal file an error code is returned.
40776 */
40777 static int readJournalHdr(
40778   Pager *pPager,               /* Pager object */
40779   int isHot,
40780   i64 journalSize,             /* Size of the open journal file in bytes */
40781   u32 *pNRec,                  /* OUT: Value read from the nRec field */
40782   u32 *pDbSize                 /* OUT: Value of original database size field */
40783 ){
40784   int rc;                      /* Return code */
40785   unsigned char aMagic[8];     /* A buffer to hold the magic header */
40786   i64 iHdrOff;                 /* Offset of journal header being read */
40787
40788   assert( isOpen(pPager->jfd) );      /* Journal file must be open. */
40789
40790   /* Advance Pager.journalOff to the start of the next sector. If the
40791   ** journal file is too small for there to be a header stored at this
40792   ** point, return SQLCIPHER_DONE.
40793   */
40794   pPager->journalOff = journalHdrOffset(pPager);
40795   if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
40796     return SQLCIPHER_DONE;
40797   }
40798   iHdrOff = pPager->journalOff;
40799
40800   /* Read in the first 8 bytes of the journal header. If they do not match
40801   ** the  magic string found at the start of each journal header, return
40802   ** SQLCIPHER_DONE. If an IO error occurs, return an error code. Otherwise,
40803   ** proceed.
40804   */
40805   if( isHot || iHdrOff!=pPager->journalHdr ){
40806     rc = sqlcipher3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
40807     if( rc ){
40808       return rc;
40809     }
40810     if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
40811       return SQLCIPHER_DONE;
40812     }
40813   }
40814
40815   /* Read the first three 32-bit fields of the journal header: The nRec
40816   ** field, the checksum-initializer and the database size at the start
40817   ** of the transaction. Return an error code if anything goes wrong.
40818   */
40819   if( SQLCIPHER_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
40820    || SQLCIPHER_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
40821    || SQLCIPHER_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
40822   ){
40823     return rc;
40824   }
40825
40826   if( pPager->journalOff==0 ){
40827     u32 iPageSize;               /* Page-size field of journal header */
40828     u32 iSectorSize;             /* Sector-size field of journal header */
40829
40830     /* Read the page-size and sector-size journal header fields. */
40831     if( SQLCIPHER_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
40832      || SQLCIPHER_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
40833     ){
40834       return rc;
40835     }
40836
40837     /* Versions of SQLite prior to 3.5.8 set the page-size field of the
40838     ** journal header to zero. In this case, assume that the Pager.pageSize
40839     ** variable is already set to the correct page size.
40840     */
40841     if( iPageSize==0 ){
40842       iPageSize = pPager->pageSize;
40843     }
40844
40845     /* Check that the values read from the page-size and sector-size fields
40846     ** are within range. To be 'in range', both values need to be a power
40847     ** of two greater than or equal to 512 or 32, and not greater than their 
40848     ** respective compile time maximum limits.
40849     */
40850     if( iPageSize<512                  || iSectorSize<32
40851      || iPageSize>SQLCIPHER_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
40852      || ((iPageSize-1)&iPageSize)!=0   || ((iSectorSize-1)&iSectorSize)!=0 
40853     ){
40854       /* If the either the page-size or sector-size in the journal-header is 
40855       ** invalid, then the process that wrote the journal-header must have 
40856       ** crashed before the header was synced. In this case stop reading 
40857       ** the journal file here.
40858       */
40859       return SQLCIPHER_DONE;
40860     }
40861
40862     /* Update the page-size to match the value read from the journal. 
40863     ** Use a testcase() macro to make sure that malloc failure within 
40864     ** PagerSetPagesize() is tested.
40865     */
40866     rc = sqlcipher3PagerSetPagesize(pPager, &iPageSize, -1);
40867     testcase( rc!=SQLCIPHER_OK );
40868
40869     /* Update the assumed sector-size to match the value used by 
40870     ** the process that created this journal. If this journal was
40871     ** created by a process other than this one, then this routine
40872     ** is being called from within pager_playback(). The local value
40873     ** of Pager.sectorSize is restored at the end of that routine.
40874     */
40875     pPager->sectorSize = iSectorSize;
40876   }
40877
40878   pPager->journalOff += JOURNAL_HDR_SZ(pPager);
40879   return rc;
40880 }
40881
40882
40883 /*
40884 ** Write the supplied master journal name into the journal file for pager
40885 ** pPager at the current location. The master journal name must be the last
40886 ** thing written to a journal file. If the pager is in full-sync mode, the
40887 ** journal file descriptor is advanced to the next sector boundary before
40888 ** anything is written. The format is:
40889 **
40890 **   + 4 bytes: PAGER_MJ_PGNO.
40891 **   + N bytes: Master journal filename in utf-8.
40892 **   + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
40893 **   + 4 bytes: Master journal name checksum.
40894 **   + 8 bytes: aJournalMagic[].
40895 **
40896 ** The master journal page checksum is the sum of the bytes in the master
40897 ** journal name, where each byte is interpreted as a signed 8-bit integer.
40898 **
40899 ** If zMaster is a NULL pointer (occurs for a single database transaction), 
40900 ** this call is a no-op.
40901 */
40902 static int writeMasterJournal(Pager *pPager, const char *zMaster){
40903   int rc;                          /* Return code */
40904   int nMaster;                     /* Length of string zMaster */
40905   i64 iHdrOff;                     /* Offset of header in journal file */
40906   i64 jrnlSize;                    /* Size of journal file on disk */
40907   u32 cksum = 0;                   /* Checksum of string zMaster */
40908
40909   assert( pPager->setMaster==0 );
40910   assert( !pagerUseWal(pPager) );
40911
40912   if( !zMaster 
40913    || pPager->journalMode==PAGER_JOURNALMODE_MEMORY 
40914    || pPager->journalMode==PAGER_JOURNALMODE_OFF 
40915   ){
40916     return SQLCIPHER_OK;
40917   }
40918   pPager->setMaster = 1;
40919   assert( isOpen(pPager->jfd) );
40920   assert( pPager->journalHdr <= pPager->journalOff );
40921
40922   /* Calculate the length in bytes and the checksum of zMaster */
40923   for(nMaster=0; zMaster[nMaster]; nMaster++){
40924     cksum += zMaster[nMaster];
40925   }
40926
40927   /* If in full-sync mode, advance to the next disk sector before writing
40928   ** the master journal name. This is in case the previous page written to
40929   ** the journal has already been synced.
40930   */
40931   if( pPager->fullSync ){
40932     pPager->journalOff = journalHdrOffset(pPager);
40933   }
40934   iHdrOff = pPager->journalOff;
40935
40936   /* Write the master journal data to the end of the journal file. If
40937   ** an error occurs, return the error code to the caller.
40938   */
40939   if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
40940    || (0 != (rc = sqlcipher3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
40941    || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
40942    || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
40943    || (0 != (rc = sqlcipher3OsWrite(pPager->jfd, aJournalMagic, 8, iHdrOff+4+nMaster+8)))
40944   ){
40945     return rc;
40946   }
40947   pPager->journalOff += (nMaster+20);
40948
40949   /* If the pager is in peristent-journal mode, then the physical 
40950   ** journal-file may extend past the end of the master-journal name
40951   ** and 8 bytes of magic data just written to the file. This is 
40952   ** dangerous because the code to rollback a hot-journal file
40953   ** will not be able to find the master-journal name to determine 
40954   ** whether or not the journal is hot. 
40955   **
40956   ** Easiest thing to do in this scenario is to truncate the journal 
40957   ** file to the required size.
40958   */ 
40959   if( SQLCIPHER_OK==(rc = sqlcipher3OsFileSize(pPager->jfd, &jrnlSize))
40960    && jrnlSize>pPager->journalOff
40961   ){
40962     rc = sqlcipher3OsTruncate(pPager->jfd, pPager->journalOff);
40963   }
40964   return rc;
40965 }
40966
40967 /*
40968 ** Find a page in the hash table given its page number. Return
40969 ** a pointer to the page or NULL if the requested page is not 
40970 ** already in memory.
40971 */
40972 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
40973   PgHdr *p;                         /* Return value */
40974
40975   /* It is not possible for a call to PcacheFetch() with createFlag==0 to
40976   ** fail, since no attempt to allocate dynamic memory will be made.
40977   */
40978   (void)sqlcipher3PcacheFetch(pPager->pPCache, pgno, 0, &p);
40979   return p;
40980 }
40981
40982 /*
40983 ** Discard the entire contents of the in-memory page-cache.
40984 */
40985 static void pager_reset(Pager *pPager){
40986   sqlcipher3BackupRestart(pPager->pBackup);
40987   sqlcipher3PcacheClear(pPager->pPCache);
40988 }
40989
40990 /*
40991 ** Free all structures in the Pager.aSavepoint[] array and set both
40992 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
40993 ** if it is open and the pager is not in exclusive mode.
40994 */
40995 static void releaseAllSavepoints(Pager *pPager){
40996   int ii;               /* Iterator for looping through Pager.aSavepoint */
40997   for(ii=0; ii<pPager->nSavepoint; ii++){
40998     sqlcipher3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
40999   }
41000   if( !pPager->exclusiveMode || sqlcipher3IsMemJournal(pPager->sjfd) ){
41001     sqlcipher3OsClose(pPager->sjfd);
41002   }
41003   sqlcipher3_free(pPager->aSavepoint);
41004   pPager->aSavepoint = 0;
41005   pPager->nSavepoint = 0;
41006   pPager->nSubRec = 0;
41007 }
41008
41009 /*
41010 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint 
41011 ** bitvecs of all open savepoints. Return SQLCIPHER_OK if successful
41012 ** or SQLCIPHER_NOMEM if a malloc failure occurs.
41013 */
41014 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
41015   int ii;                   /* Loop counter */
41016   int rc = SQLCIPHER_OK;       /* Result code */
41017
41018   for(ii=0; ii<pPager->nSavepoint; ii++){
41019     PagerSavepoint *p = &pPager->aSavepoint[ii];
41020     if( pgno<=p->nOrig ){
41021       rc |= sqlcipher3BitvecSet(p->pInSavepoint, pgno);
41022       testcase( rc==SQLCIPHER_NOMEM );
41023       assert( rc==SQLCIPHER_OK || rc==SQLCIPHER_NOMEM );
41024     }
41025   }
41026   return rc;
41027 }
41028
41029 /*
41030 ** This function is a no-op if the pager is in exclusive mode and not
41031 ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
41032 ** state.
41033 **
41034 ** If the pager is not in exclusive-access mode, the database file is
41035 ** completely unlocked. If the file is unlocked and the file-system does
41036 ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
41037 ** closed (if it is open).
41038 **
41039 ** If the pager is in ERROR state when this function is called, the 
41040 ** contents of the pager cache are discarded before switching back to 
41041 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
41042 ** or not, any journal file left in the file-system will be treated
41043 ** as a hot-journal and rolled back the next time a read-transaction
41044 ** is opened (by this or by any other connection).
41045 */
41046 static void pager_unlock(Pager *pPager){
41047
41048   assert( pPager->eState==PAGER_READER 
41049        || pPager->eState==PAGER_OPEN 
41050        || pPager->eState==PAGER_ERROR 
41051   );
41052
41053   sqlcipher3BitvecDestroy(pPager->pInJournal);
41054   pPager->pInJournal = 0;
41055   releaseAllSavepoints(pPager);
41056
41057   if( pagerUseWal(pPager) ){
41058     assert( !isOpen(pPager->jfd) );
41059     sqlcipher3WalEndReadTransaction(pPager->pWal);
41060     pPager->eState = PAGER_OPEN;
41061   }else if( !pPager->exclusiveMode ){
41062     int rc;                       /* Error code returned by pagerUnlockDb() */
41063     int iDc = isOpen(pPager->fd)?sqlcipher3OsDeviceCharacteristics(pPager->fd):0;
41064
41065     /* If the operating system support deletion of open files, then
41066     ** close the journal file when dropping the database lock.  Otherwise
41067     ** another connection with journal_mode=delete might delete the file
41068     ** out from under us.
41069     */
41070     assert( (PAGER_JOURNALMODE_MEMORY   & 5)!=1 );
41071     assert( (PAGER_JOURNALMODE_OFF      & 5)!=1 );
41072     assert( (PAGER_JOURNALMODE_WAL      & 5)!=1 );
41073     assert( (PAGER_JOURNALMODE_DELETE   & 5)!=1 );
41074     assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
41075     assert( (PAGER_JOURNALMODE_PERSIST  & 5)==1 );
41076     if( 0==(iDc & SQLCIPHER_IOCAP_UNDELETABLE_WHEN_OPEN)
41077      || 1!=(pPager->journalMode & 5)
41078     ){
41079       sqlcipher3OsClose(pPager->jfd);
41080     }
41081
41082     /* If the pager is in the ERROR state and the call to unlock the database
41083     ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
41084     ** above the #define for UNKNOWN_LOCK for an explanation of why this
41085     ** is necessary.
41086     */
41087     rc = pagerUnlockDb(pPager, NO_LOCK);
41088     if( rc!=SQLCIPHER_OK && pPager->eState==PAGER_ERROR ){
41089       pPager->eLock = UNKNOWN_LOCK;
41090     }
41091
41092     /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
41093     ** without clearing the error code. This is intentional - the error
41094     ** code is cleared and the cache reset in the block below.
41095     */
41096     assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
41097     pPager->changeCountDone = 0;
41098     pPager->eState = PAGER_OPEN;
41099   }
41100
41101   /* If Pager.errCode is set, the contents of the pager cache cannot be
41102   ** trusted. Now that there are no outstanding references to the pager,
41103   ** it can safely move back to PAGER_OPEN state. This happens in both
41104   ** normal and exclusive-locking mode.
41105   */
41106   if( pPager->errCode ){
41107     assert( !MEMDB );
41108     pager_reset(pPager);
41109     pPager->changeCountDone = pPager->tempFile;
41110     pPager->eState = PAGER_OPEN;
41111     pPager->errCode = SQLCIPHER_OK;
41112   }
41113
41114   pPager->journalOff = 0;
41115   pPager->journalHdr = 0;
41116   pPager->setMaster = 0;
41117 }
41118
41119 /*
41120 ** This function is called whenever an IOERR or FULL error that requires
41121 ** the pager to transition into the ERROR state may ahve occurred.
41122 ** The first argument is a pointer to the pager structure, the second 
41123 ** the error-code about to be returned by a pager API function. The 
41124 ** value returned is a copy of the second argument to this function. 
41125 **
41126 ** If the second argument is SQLCIPHER_FULL, SQLCIPHER_IOERR or one of the
41127 ** IOERR sub-codes, the pager enters the ERROR state and the error code
41128 ** is stored in Pager.errCode. While the pager remains in the ERROR state,
41129 ** all major API calls on the Pager will immediately return Pager.errCode.
41130 **
41131 ** The ERROR state indicates that the contents of the pager-cache 
41132 ** cannot be trusted. This state can be cleared by completely discarding 
41133 ** the contents of the pager-cache. If a transaction was active when
41134 ** the persistent error occurred, then the rollback journal may need
41135 ** to be replayed to restore the contents of the database file (as if
41136 ** it were a hot-journal).
41137 */
41138 static int pager_error(Pager *pPager, int rc){
41139   int rc2 = rc & 0xff;
41140   assert( rc==SQLCIPHER_OK || !MEMDB );
41141   assert(
41142        pPager->errCode==SQLCIPHER_FULL ||
41143        pPager->errCode==SQLCIPHER_OK ||
41144        (pPager->errCode & 0xff)==SQLCIPHER_IOERR
41145   );
41146   if( rc2==SQLCIPHER_FULL || rc2==SQLCIPHER_IOERR ){
41147     pPager->errCode = rc;
41148     pPager->eState = PAGER_ERROR;
41149   }
41150   return rc;
41151 }
41152
41153 /*
41154 ** This routine ends a transaction. A transaction is usually ended by 
41155 ** either a COMMIT or a ROLLBACK operation. This routine may be called 
41156 ** after rollback of a hot-journal, or if an error occurs while opening
41157 ** the journal file or writing the very first journal-header of a
41158 ** database transaction.
41159 ** 
41160 ** This routine is never called in PAGER_ERROR state. If it is called
41161 ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
41162 ** exclusive than a RESERVED lock, it is a no-op.
41163 **
41164 ** Otherwise, any active savepoints are released.
41165 **
41166 ** If the journal file is open, then it is "finalized". Once a journal 
41167 ** file has been finalized it is not possible to use it to roll back a 
41168 ** transaction. Nor will it be considered to be a hot-journal by this
41169 ** or any other database connection. Exactly how a journal is finalized
41170 ** depends on whether or not the pager is running in exclusive mode and
41171 ** the current journal-mode (Pager.journalMode value), as follows:
41172 **
41173 **   journalMode==MEMORY
41174 **     Journal file descriptor is simply closed. This destroys an 
41175 **     in-memory journal.
41176 **
41177 **   journalMode==TRUNCATE
41178 **     Journal file is truncated to zero bytes in size.
41179 **
41180 **   journalMode==PERSIST
41181 **     The first 28 bytes of the journal file are zeroed. This invalidates
41182 **     the first journal header in the file, and hence the entire journal
41183 **     file. An invalid journal file cannot be rolled back.
41184 **
41185 **   journalMode==DELETE
41186 **     The journal file is closed and deleted using sqlcipher3OsDelete().
41187 **
41188 **     If the pager is running in exclusive mode, this method of finalizing
41189 **     the journal file is never used. Instead, if the journalMode is
41190 **     DELETE and the pager is in exclusive mode, the method described under
41191 **     journalMode==PERSIST is used instead.
41192 **
41193 ** After the journal is finalized, the pager moves to PAGER_READER state.
41194 ** If running in non-exclusive rollback mode, the lock on the file is 
41195 ** downgraded to a SHARED_LOCK.
41196 **
41197 ** SQLCIPHER_OK is returned if no error occurs. If an error occurs during
41198 ** any of the IO operations to finalize the journal file or unlock the
41199 ** database then the IO error code is returned to the user. If the 
41200 ** operation to finalize the journal file fails, then the code still
41201 ** tries to unlock the database file if not in exclusive mode. If the
41202 ** unlock operation fails as well, then the first error code related
41203 ** to the first error encountered (the journal finalization one) is
41204 ** returned.
41205 */
41206 static int pager_end_transaction(Pager *pPager, int hasMaster){
41207   int rc = SQLCIPHER_OK;      /* Error code from journal finalization operation */
41208   int rc2 = SQLCIPHER_OK;     /* Error code from db file unlock operation */
41209
41210   /* Do nothing if the pager does not have an open write transaction
41211   ** or at least a RESERVED lock. This function may be called when there
41212   ** is no write-transaction active but a RESERVED or greater lock is
41213   ** held under two circumstances:
41214   **
41215   **   1. After a successful hot-journal rollback, it is called with
41216   **      eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
41217   **
41218   **   2. If a connection with locking_mode=exclusive holding an EXCLUSIVE 
41219   **      lock switches back to locking_mode=normal and then executes a
41220   **      read-transaction, this function is called with eState==PAGER_READER 
41221   **      and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
41222   */
41223   assert( assert_pager_state(pPager) );
41224   assert( pPager->eState!=PAGER_ERROR );
41225   if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
41226     return SQLCIPHER_OK;
41227   }
41228
41229   releaseAllSavepoints(pPager);
41230   assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
41231   if( isOpen(pPager->jfd) ){
41232     assert( !pagerUseWal(pPager) );
41233
41234     /* Finalize the journal file. */
41235     if( sqlcipher3IsMemJournal(pPager->jfd) ){
41236       assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
41237       sqlcipher3OsClose(pPager->jfd);
41238     }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
41239       if( pPager->journalOff==0 ){
41240         rc = SQLCIPHER_OK;
41241       }else{
41242         rc = sqlcipher3OsTruncate(pPager->jfd, 0);
41243       }
41244       pPager->journalOff = 0;
41245     }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
41246       || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
41247     ){
41248       rc = zeroJournalHdr(pPager, hasMaster);
41249       pPager->journalOff = 0;
41250     }else{
41251       /* This branch may be executed with Pager.journalMode==MEMORY if
41252       ** a hot-journal was just rolled back. In this case the journal
41253       ** file should be closed and deleted. If this connection writes to
41254       ** the database file, it will do so using an in-memory journal. 
41255       */
41256       assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE 
41257            || pPager->journalMode==PAGER_JOURNALMODE_MEMORY 
41258            || pPager->journalMode==PAGER_JOURNALMODE_WAL 
41259       );
41260       sqlcipher3OsClose(pPager->jfd);
41261       if( !pPager->tempFile ){
41262         rc = sqlcipher3OsDelete(pPager->pVfs, pPager->zJournal, 0);
41263       }
41264     }
41265   }
41266
41267 #ifdef SQLCIPHER_CHECK_PAGES
41268   sqlcipher3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
41269   if( pPager->dbSize==0 && sqlcipher3PcacheRefCount(pPager->pPCache)>0 ){
41270     PgHdr *p = pager_lookup(pPager, 1);
41271     if( p ){
41272       p->pageHash = 0;
41273       sqlcipher3PagerUnref(p);
41274     }
41275   }
41276 #endif
41277
41278   sqlcipher3BitvecDestroy(pPager->pInJournal);
41279   pPager->pInJournal = 0;
41280   pPager->nRec = 0;
41281   sqlcipher3PcacheCleanAll(pPager->pPCache);
41282   sqlcipher3PcacheTruncate(pPager->pPCache, pPager->dbSize);
41283
41284   if( pagerUseWal(pPager) ){
41285     /* Drop the WAL write-lock, if any. Also, if the connection was in 
41286     ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE 
41287     ** lock held on the database file.
41288     */
41289     rc2 = sqlcipher3WalEndWriteTransaction(pPager->pWal);
41290     assert( rc2==SQLCIPHER_OK );
41291   }
41292   if( !pPager->exclusiveMode 
41293    && (!pagerUseWal(pPager) || sqlcipher3WalExclusiveMode(pPager->pWal, 0))
41294   ){
41295     rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
41296     pPager->changeCountDone = 0;
41297   }
41298   pPager->eState = PAGER_READER;
41299   pPager->setMaster = 0;
41300
41301   return (rc==SQLCIPHER_OK?rc2:rc);
41302 }
41303
41304 /*
41305 ** Execute a rollback if a transaction is active and unlock the 
41306 ** database file. 
41307 **
41308 ** If the pager has already entered the ERROR state, do not attempt 
41309 ** the rollback at this time. Instead, pager_unlock() is called. The
41310 ** call to pager_unlock() will discard all in-memory pages, unlock
41311 ** the database file and move the pager back to OPEN state. If this 
41312 ** means that there is a hot-journal left in the file-system, the next 
41313 ** connection to obtain a shared lock on the pager (which may be this one) 
41314 ** will roll it back.
41315 **
41316 ** If the pager has not already entered the ERROR state, but an IO or
41317 ** malloc error occurs during a rollback, then this will itself cause 
41318 ** the pager to enter the ERROR state. Which will be cleared by the
41319 ** call to pager_unlock(), as described above.
41320 */
41321 static void pagerUnlockAndRollback(Pager *pPager){
41322   if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
41323     assert( assert_pager_state(pPager) );
41324     if( pPager->eState>=PAGER_WRITER_LOCKED ){
41325       sqlcipher3BeginBenignMalloc();
41326       sqlcipher3PagerRollback(pPager);
41327       sqlcipher3EndBenignMalloc();
41328     }else if( !pPager->exclusiveMode ){
41329       assert( pPager->eState==PAGER_READER );
41330       pager_end_transaction(pPager, 0);
41331     }
41332   }
41333   pager_unlock(pPager);
41334 }
41335
41336 /*
41337 ** Parameter aData must point to a buffer of pPager->pageSize bytes
41338 ** of data. Compute and return a checksum based ont the contents of the 
41339 ** page of data and the current value of pPager->cksumInit.
41340 **
41341 ** This is not a real checksum. It is really just the sum of the 
41342 ** random initial value (pPager->cksumInit) and every 200th byte
41343 ** of the page data, starting with byte offset (pPager->pageSize%200).
41344 ** Each byte is interpreted as an 8-bit unsigned integer.
41345 **
41346 ** Changing the formula used to compute this checksum results in an
41347 ** incompatible journal file format.
41348 **
41349 ** If journal corruption occurs due to a power failure, the most likely 
41350 ** scenario is that one end or the other of the record will be changed. 
41351 ** It is much less likely that the two ends of the journal record will be
41352 ** correct and the middle be corrupt.  Thus, this "checksum" scheme,
41353 ** though fast and simple, catches the mostly likely kind of corruption.
41354 */
41355 static u32 pager_cksum(Pager *pPager, const u8 *aData){
41356   u32 cksum = pPager->cksumInit;         /* Checksum value to return */
41357   int i = pPager->pageSize-200;          /* Loop counter */
41358   while( i>0 ){
41359     cksum += aData[i];
41360     i -= 200;
41361   }
41362   return cksum;
41363 }
41364
41365 /*
41366 ** Report the current page size and number of reserved bytes back
41367 ** to the codec.
41368 */
41369 #ifdef SQLCIPHER_HAS_CODEC
41370 static void pagerReportSize(Pager *pPager){
41371   if( pPager->xCodecSizeChng ){
41372     pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
41373                            (int)pPager->nReserve);
41374   }
41375 }
41376 #else
41377 # define pagerReportSize(X)     /* No-op if we do not support a codec */
41378 #endif
41379
41380 /*
41381 ** Read a single page from either the journal file (if isMainJrnl==1) or
41382 ** from the sub-journal (if isMainJrnl==0) and playback that page.
41383 ** The page begins at offset *pOffset into the file. The *pOffset
41384 ** value is increased to the start of the next page in the journal.
41385 **
41386 ** The main rollback journal uses checksums - the statement journal does 
41387 ** not.
41388 **
41389 ** If the page number of the page record read from the (sub-)journal file
41390 ** is greater than the current value of Pager.dbSize, then playback is
41391 ** skipped and SQLCIPHER_OK is returned.
41392 **
41393 ** If pDone is not NULL, then it is a record of pages that have already
41394 ** been played back.  If the page at *pOffset has already been played back
41395 ** (if the corresponding pDone bit is set) then skip the playback.
41396 ** Make sure the pDone bit corresponding to the *pOffset page is set
41397 ** prior to returning.
41398 **
41399 ** If the page record is successfully read from the (sub-)journal file
41400 ** and played back, then SQLCIPHER_OK is returned. If an IO error occurs
41401 ** while reading the record from the (sub-)journal file or while writing
41402 ** to the database file, then the IO error code is returned. If data
41403 ** is successfully read from the (sub-)journal file but appears to be
41404 ** corrupted, SQLCIPHER_DONE is returned. Data is considered corrupted in
41405 ** two circumstances:
41406 ** 
41407 **   * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
41408 **   * If the record is being rolled back from the main journal file
41409 **     and the checksum field does not match the record content.
41410 **
41411 ** Neither of these two scenarios are possible during a savepoint rollback.
41412 **
41413 ** If this is a savepoint rollback, then memory may have to be dynamically
41414 ** allocated by this function. If this is the case and an allocation fails,
41415 ** SQLCIPHER_NOMEM is returned.
41416 */
41417 static int pager_playback_one_page(
41418   Pager *pPager,                /* The pager being played back */
41419   i64 *pOffset,                 /* Offset of record to playback */
41420   Bitvec *pDone,                /* Bitvec of pages already played back */
41421   int isMainJrnl,               /* 1 -> main journal. 0 -> sub-journal. */
41422   int isSavepnt                 /* True for a savepoint rollback */
41423 ){
41424   int rc;
41425   PgHdr *pPg;                   /* An existing page in the cache */
41426   Pgno pgno;                    /* The page number of a page in journal */
41427   u32 cksum;                    /* Checksum used for sanity checking */
41428   char *aData;                  /* Temporary storage for the page */
41429   sqlcipher3_file *jfd;            /* The file descriptor for the journal file */
41430   int isSynced;                 /* True if journal page is synced */
41431
41432   assert( (isMainJrnl&~1)==0 );      /* isMainJrnl is 0 or 1 */
41433   assert( (isSavepnt&~1)==0 );       /* isSavepnt is 0 or 1 */
41434   assert( isMainJrnl || pDone );     /* pDone always used on sub-journals */
41435   assert( isSavepnt || pDone==0 );   /* pDone never used on non-savepoint */
41436
41437   aData = pPager->pTmpSpace;
41438   assert( aData );         /* Temp storage must have already been allocated */
41439   assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
41440
41441   /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction 
41442   ** or savepoint rollback done at the request of the caller) or this is
41443   ** a hot-journal rollback. If it is a hot-journal rollback, the pager
41444   ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
41445   ** only reads from the main journal, not the sub-journal.
41446   */
41447   assert( pPager->eState>=PAGER_WRITER_CACHEMOD
41448        || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
41449   );
41450   assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
41451
41452   /* Read the page number and page data from the journal or sub-journal
41453   ** file. Return an error code to the caller if an IO error occurs.
41454   */
41455   jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
41456   rc = read32bits(jfd, *pOffset, &pgno);
41457   if( rc!=SQLCIPHER_OK ) return rc;
41458   rc = sqlcipher3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
41459   if( rc!=SQLCIPHER_OK ) return rc;
41460   *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
41461
41462   /* Sanity checking on the page.  This is more important that I originally
41463   ** thought.  If a power failure occurs while the journal is being written,
41464   ** it could cause invalid data to be written into the journal.  We need to
41465   ** detect this invalid data (with high probability) and ignore it.
41466   */
41467   if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
41468     assert( !isSavepnt );
41469     return SQLCIPHER_DONE;
41470   }
41471   if( pgno>(Pgno)pPager->dbSize || sqlcipher3BitvecTest(pDone, pgno) ){
41472     return SQLCIPHER_OK;
41473   }
41474   if( isMainJrnl ){
41475     rc = read32bits(jfd, (*pOffset)-4, &cksum);
41476     if( rc ) return rc;
41477     if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
41478       return SQLCIPHER_DONE;
41479     }
41480   }
41481
41482   /* If this page has already been played by before during the current
41483   ** rollback, then don't bother to play it back again.
41484   */
41485   if( pDone && (rc = sqlcipher3BitvecSet(pDone, pgno))!=SQLCIPHER_OK ){
41486     return rc;
41487   }
41488
41489   /* When playing back page 1, restore the nReserve setting
41490   */
41491   if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
41492     pPager->nReserve = ((u8*)aData)[20];
41493     pagerReportSize(pPager);
41494   }
41495
41496   /* If the pager is in CACHEMOD state, then there must be a copy of this
41497   ** page in the pager cache. In this case just update the pager cache,
41498   ** not the database file. The page is left marked dirty in this case.
41499   **
41500   ** An exception to the above rule: If the database is in no-sync mode
41501   ** and a page is moved during an incremental vacuum then the page may
41502   ** not be in the pager cache. Later: if a malloc() or IO error occurs
41503   ** during a Movepage() call, then the page may not be in the cache
41504   ** either. So the condition described in the above paragraph is not
41505   ** assert()able.
41506   **
41507   ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
41508   ** pager cache if it exists and the main file. The page is then marked 
41509   ** not dirty. Since this code is only executed in PAGER_OPEN state for
41510   ** a hot-journal rollback, it is guaranteed that the page-cache is empty
41511   ** if the pager is in OPEN state.
41512   **
41513   ** Ticket #1171:  The statement journal might contain page content that is
41514   ** different from the page content at the start of the transaction.
41515   ** This occurs when a page is changed prior to the start of a statement
41516   ** then changed again within the statement.  When rolling back such a
41517   ** statement we must not write to the original database unless we know
41518   ** for certain that original page contents are synced into the main rollback
41519   ** journal.  Otherwise, a power loss might leave modified data in the
41520   ** database file without an entry in the rollback journal that can
41521   ** restore the database to its original form.  Two conditions must be
41522   ** met before writing to the database files. (1) the database must be
41523   ** locked.  (2) we know that the original page content is fully synced
41524   ** in the main journal either because the page is not in cache or else
41525   ** the page is marked as needSync==0.
41526   **
41527   ** 2008-04-14:  When attempting to vacuum a corrupt database file, it
41528   ** is possible to fail a statement on a database that does not yet exist.
41529   ** Do not attempt to write if database file has never been opened.
41530   */
41531   if( pagerUseWal(pPager) ){
41532     pPg = 0;
41533   }else{
41534     pPg = pager_lookup(pPager, pgno);
41535   }
41536   assert( pPg || !MEMDB );
41537   assert( pPager->eState!=PAGER_OPEN || pPg==0 );
41538   PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
41539            PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
41540            (isMainJrnl?"main-journal":"sub-journal")
41541   ));
41542   if( isMainJrnl ){
41543     isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
41544   }else{
41545     isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
41546   }
41547   if( isOpen(pPager->fd)
41548    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
41549    && isSynced
41550   ){
41551     i64 ofst = (pgno-1)*(i64)pPager->pageSize;
41552     testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
41553     assert( !pagerUseWal(pPager) );
41554     rc = sqlcipher3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
41555     if( pgno>pPager->dbFileSize ){
41556       pPager->dbFileSize = pgno;
41557     }
41558     if( pPager->pBackup ){
41559       CODEC1(pPager, aData, pgno, 3, rc=SQLCIPHER_NOMEM);
41560       sqlcipher3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
41561       CODEC2(pPager, aData, pgno, 7, rc=SQLCIPHER_NOMEM, aData);
41562     }
41563   }else if( !isMainJrnl && pPg==0 ){
41564     /* If this is a rollback of a savepoint and data was not written to
41565     ** the database and the page is not in-memory, there is a potential
41566     ** problem. When the page is next fetched by the b-tree layer, it 
41567     ** will be read from the database file, which may or may not be 
41568     ** current. 
41569     **
41570     ** There are a couple of different ways this can happen. All are quite
41571     ** obscure. When running in synchronous mode, this can only happen 
41572     ** if the page is on the free-list at the start of the transaction, then
41573     ** populated, then moved using sqlcipher3PagerMovepage().
41574     **
41575     ** The solution is to add an in-memory page to the cache containing
41576     ** the data just read from the sub-journal. Mark the page as dirty 
41577     ** and if the pager requires a journal-sync, then mark the page as 
41578     ** requiring a journal-sync before it is written.
41579     */
41580     assert( isSavepnt );
41581     assert( pPager->doNotSpill==0 );
41582     pPager->doNotSpill++;
41583     rc = sqlcipher3PagerAcquire(pPager, pgno, &pPg, 1);
41584     assert( pPager->doNotSpill==1 );
41585     pPager->doNotSpill--;
41586     if( rc!=SQLCIPHER_OK ) return rc;
41587     pPg->flags &= ~PGHDR_NEED_READ;
41588     sqlcipher3PcacheMakeDirty(pPg);
41589   }
41590   if( pPg ){
41591     /* No page should ever be explicitly rolled back that is in use, except
41592     ** for page 1 which is held in use in order to keep the lock on the
41593     ** database active. However such a page may be rolled back as a result
41594     ** of an internal error resulting in an automatic call to
41595     ** sqlcipher3PagerRollback().
41596     */
41597     void *pData;
41598     pData = pPg->pData;
41599     memcpy(pData, (u8*)aData, pPager->pageSize);
41600     pPager->xReiniter(pPg);
41601     if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
41602       /* If the contents of this page were just restored from the main 
41603       ** journal file, then its content must be as they were when the 
41604       ** transaction was first opened. In this case we can mark the page
41605       ** as clean, since there will be no need to write it out to the
41606       ** database.
41607       **
41608       ** There is one exception to this rule. If the page is being rolled
41609       ** back as part of a savepoint (or statement) rollback from an 
41610       ** unsynced portion of the main journal file, then it is not safe
41611       ** to mark the page as clean. This is because marking the page as
41612       ** clean will clear the PGHDR_NEED_SYNC flag. Since the page is
41613       ** already in the journal file (recorded in Pager.pInJournal) and
41614       ** the PGHDR_NEED_SYNC flag is cleared, if the page is written to
41615       ** again within this transaction, it will be marked as dirty but
41616       ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
41617       ** be written out into the database file before its journal file
41618       ** segment is synced. If a crash occurs during or following this,
41619       ** database corruption may ensue.
41620       */
41621       assert( !pagerUseWal(pPager) );
41622       sqlcipher3PcacheMakeClean(pPg);
41623     }
41624     pager_set_pagehash(pPg);
41625
41626     /* If this was page 1, then restore the value of Pager.dbFileVers.
41627     ** Do this before any decoding. */
41628     if( pgno==1 ){
41629       memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
41630     }
41631
41632     /* Decode the page just read from disk */
41633     CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLCIPHER_NOMEM);
41634     sqlcipher3PcacheRelease(pPg);
41635   }
41636   return rc;
41637 }
41638
41639 /*
41640 ** Parameter zMaster is the name of a master journal file. A single journal
41641 ** file that referred to the master journal file has just been rolled back.
41642 ** This routine checks if it is possible to delete the master journal file,
41643 ** and does so if it is.
41644 **
41645 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not 
41646 ** available for use within this function.
41647 **
41648 ** When a master journal file is created, it is populated with the names 
41649 ** of all of its child journals, one after another, formatted as utf-8 
41650 ** encoded text. The end of each child journal file is marked with a 
41651 ** nul-terminator byte (0x00). i.e. the entire contents of a master journal
41652 ** file for a transaction involving two databases might be:
41653 **
41654 **   "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
41655 **
41656 ** A master journal file may only be deleted once all of its child 
41657 ** journals have been rolled back.
41658 **
41659 ** This function reads the contents of the master-journal file into 
41660 ** memory and loops through each of the child journal names. For
41661 ** each child journal, it checks if:
41662 **
41663 **   * if the child journal exists, and if so
41664 **   * if the child journal contains a reference to master journal 
41665 **     file zMaster
41666 **
41667 ** If a child journal can be found that matches both of the criteria
41668 ** above, this function returns without doing anything. Otherwise, if
41669 ** no such child journal can be found, file zMaster is deleted from
41670 ** the file-system using sqlcipher3OsDelete().
41671 **
41672 ** If an IO error within this function, an error code is returned. This
41673 ** function allocates memory by calling sqlcipher3Malloc(). If an allocation
41674 ** fails, SQLCIPHER_NOMEM is returned. Otherwise, if no IO or malloc errors 
41675 ** occur, SQLCIPHER_OK is returned.
41676 **
41677 ** TODO: This function allocates a single block of memory to load
41678 ** the entire contents of the master journal file. This could be
41679 ** a couple of kilobytes or so - potentially larger than the page 
41680 ** size.
41681 */
41682 static int pager_delmaster(Pager *pPager, const char *zMaster){
41683   sqlcipher3_vfs *pVfs = pPager->pVfs;
41684   int rc;                   /* Return code */
41685   sqlcipher3_file *pMaster;    /* Malloc'd master-journal file descriptor */
41686   sqlcipher3_file *pJournal;   /* Malloc'd child-journal file descriptor */
41687   char *zMasterJournal = 0; /* Contents of master journal file */
41688   i64 nMasterJournal;       /* Size of master journal file */
41689   char *zJournal;           /* Pointer to one journal within MJ file */
41690   char *zMasterPtr;         /* Space to hold MJ filename from a journal file */
41691   int nMasterPtr;           /* Amount of space allocated to zMasterPtr[] */
41692
41693   /* Allocate space for both the pJournal and pMaster file descriptors.
41694   ** If successful, open the master journal file for reading.
41695   */
41696   pMaster = (sqlcipher3_file *)sqlcipher3MallocZero(pVfs->szOsFile * 2);
41697   pJournal = (sqlcipher3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
41698   if( !pMaster ){
41699     rc = SQLCIPHER_NOMEM;
41700   }else{
41701     const int flags = (SQLCIPHER_OPEN_READONLY|SQLCIPHER_OPEN_MASTER_JOURNAL);
41702     rc = sqlcipher3OsOpen(pVfs, zMaster, pMaster, flags, 0);
41703   }
41704   if( rc!=SQLCIPHER_OK ) goto delmaster_out;
41705
41706   /* Load the entire master journal file into space obtained from
41707   ** sqlcipher3_malloc() and pointed to by zMasterJournal.   Also obtain
41708   ** sufficient space (in zMasterPtr) to hold the names of master
41709   ** journal files extracted from regular rollback-journals.
41710   */
41711   rc = sqlcipher3OsFileSize(pMaster, &nMasterJournal);
41712   if( rc!=SQLCIPHER_OK ) goto delmaster_out;
41713   nMasterPtr = pVfs->mxPathname+1;
41714   zMasterJournal = sqlcipher3Malloc((int)nMasterJournal + nMasterPtr + 1);
41715   if( !zMasterJournal ){
41716     rc = SQLCIPHER_NOMEM;
41717     goto delmaster_out;
41718   }
41719   zMasterPtr = &zMasterJournal[nMasterJournal+1];
41720   rc = sqlcipher3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
41721   if( rc!=SQLCIPHER_OK ) goto delmaster_out;
41722   zMasterJournal[nMasterJournal] = 0;
41723
41724   zJournal = zMasterJournal;
41725   while( (zJournal-zMasterJournal)<nMasterJournal ){
41726     int exists;
41727     rc = sqlcipher3OsAccess(pVfs, zJournal, SQLCIPHER_ACCESS_EXISTS, &exists);
41728     if( rc!=SQLCIPHER_OK ){
41729       goto delmaster_out;
41730     }
41731     if( exists ){
41732       /* One of the journals pointed to by the master journal exists.
41733       ** Open it and check if it points at the master journal. If
41734       ** so, return without deleting the master journal file.
41735       */
41736       int c;
41737       int flags = (SQLCIPHER_OPEN_READONLY|SQLCIPHER_OPEN_MAIN_JOURNAL);
41738       rc = sqlcipher3OsOpen(pVfs, zJournal, pJournal, flags, 0);
41739       if( rc!=SQLCIPHER_OK ){
41740         goto delmaster_out;
41741       }
41742
41743       rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
41744       sqlcipher3OsClose(pJournal);
41745       if( rc!=SQLCIPHER_OK ){
41746         goto delmaster_out;
41747       }
41748
41749       c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
41750       if( c ){
41751         /* We have a match. Do not delete the master journal file. */
41752         goto delmaster_out;
41753       }
41754     }
41755     zJournal += (sqlcipher3Strlen30(zJournal)+1);
41756   }
41757  
41758   sqlcipher3OsClose(pMaster);
41759   rc = sqlcipher3OsDelete(pVfs, zMaster, 0);
41760
41761 delmaster_out:
41762   sqlcipher3_free(zMasterJournal);
41763   if( pMaster ){
41764     sqlcipher3OsClose(pMaster);
41765     assert( !isOpen(pJournal) );
41766     sqlcipher3_free(pMaster);
41767   }
41768   return rc;
41769 }
41770
41771
41772 /*
41773 ** This function is used to change the actual size of the database 
41774 ** file in the file-system. This only happens when committing a transaction,
41775 ** or rolling back a transaction (including rolling back a hot-journal).
41776 **
41777 ** If the main database file is not open, or the pager is not in either
41778 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size 
41779 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes). 
41780 ** If the file on disk is currently larger than nPage pages, then use the VFS
41781 ** xTruncate() method to truncate it.
41782 **
41783 ** Or, it might might be the case that the file on disk is smaller than 
41784 ** nPage pages. Some operating system implementations can get confused if 
41785 ** you try to truncate a file to some size that is larger than it 
41786 ** currently is, so detect this case and write a single zero byte to 
41787 ** the end of the new file instead.
41788 **
41789 ** If successful, return SQLCIPHER_OK. If an IO error occurs while modifying
41790 ** the database file, return the error code to the caller.
41791 */
41792 static int pager_truncate(Pager *pPager, Pgno nPage){
41793   int rc = SQLCIPHER_OK;
41794   assert( pPager->eState!=PAGER_ERROR );
41795   assert( pPager->eState!=PAGER_READER );
41796   
41797   if( isOpen(pPager->fd) 
41798    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) 
41799   ){
41800     i64 currentSize, newSize;
41801     int szPage = pPager->pageSize;
41802     assert( pPager->eLock==EXCLUSIVE_LOCK );
41803     /* TODO: Is it safe to use Pager.dbFileSize here? */
41804     rc = sqlcipher3OsFileSize(pPager->fd, &currentSize);
41805     newSize = szPage*(i64)nPage;
41806     if( rc==SQLCIPHER_OK && currentSize!=newSize ){
41807       if( currentSize>newSize ){
41808         rc = sqlcipher3OsTruncate(pPager->fd, newSize);
41809       }else{
41810         char *pTmp = pPager->pTmpSpace;
41811         memset(pTmp, 0, szPage);
41812         testcase( (newSize-szPage) <  currentSize );
41813         testcase( (newSize-szPage) == currentSize );
41814         testcase( (newSize-szPage) >  currentSize );
41815         rc = sqlcipher3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
41816       }
41817       if( rc==SQLCIPHER_OK ){
41818         pPager->dbFileSize = nPage;
41819       }
41820     }
41821   }
41822   return rc;
41823 }
41824
41825 /*
41826 ** Set the value of the Pager.sectorSize variable for the given
41827 ** pager based on the value returned by the xSectorSize method
41828 ** of the open database file. The sector size will be used used 
41829 ** to determine the size and alignment of journal header and 
41830 ** master journal pointers within created journal files.
41831 **
41832 ** For temporary files the effective sector size is always 512 bytes.
41833 **
41834 ** Otherwise, for non-temporary files, the effective sector size is
41835 ** the value returned by the xSectorSize() method rounded up to 32 if
41836 ** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
41837 ** is greater than MAX_SECTOR_SIZE.
41838 */
41839 static void setSectorSize(Pager *pPager){
41840   assert( isOpen(pPager->fd) || pPager->tempFile );
41841
41842   if( !pPager->tempFile ){
41843     /* Sector size doesn't matter for temporary files. Also, the file
41844     ** may not have been opened yet, in which case the OsSectorSize()
41845     ** call will segfault.
41846     */
41847     pPager->sectorSize = sqlcipher3OsSectorSize(pPager->fd);
41848   }
41849   if( pPager->sectorSize<32 ){
41850     pPager->sectorSize = 512;
41851   }
41852   if( pPager->sectorSize>MAX_SECTOR_SIZE ){
41853     assert( MAX_SECTOR_SIZE>=512 );
41854     pPager->sectorSize = MAX_SECTOR_SIZE;
41855   }
41856 }
41857
41858 /*
41859 ** Playback the journal and thus restore the database file to
41860 ** the state it was in before we started making changes.  
41861 **
41862 ** The journal file format is as follows: 
41863 **
41864 **  (1)  8 byte prefix.  A copy of aJournalMagic[].
41865 **  (2)  4 byte big-endian integer which is the number of valid page records
41866 **       in the journal.  If this value is 0xffffffff, then compute the
41867 **       number of page records from the journal size.
41868 **  (3)  4 byte big-endian integer which is the initial value for the 
41869 **       sanity checksum.
41870 **  (4)  4 byte integer which is the number of pages to truncate the
41871 **       database to during a rollback.
41872 **  (5)  4 byte big-endian integer which is the sector size.  The header
41873 **       is this many bytes in size.
41874 **  (6)  4 byte big-endian integer which is the page size.
41875 **  (7)  zero padding out to the next sector size.
41876 **  (8)  Zero or more pages instances, each as follows:
41877 **        +  4 byte page number.
41878 **        +  pPager->pageSize bytes of data.
41879 **        +  4 byte checksum
41880 **
41881 ** When we speak of the journal header, we mean the first 7 items above.
41882 ** Each entry in the journal is an instance of the 8th item.
41883 **
41884 ** Call the value from the second bullet "nRec".  nRec is the number of
41885 ** valid page entries in the journal.  In most cases, you can compute the
41886 ** value of nRec from the size of the journal file.  But if a power
41887 ** failure occurred while the journal was being written, it could be the
41888 ** case that the size of the journal file had already been increased but
41889 ** the extra entries had not yet made it safely to disk.  In such a case,
41890 ** the value of nRec computed from the file size would be too large.  For
41891 ** that reason, we always use the nRec value in the header.
41892 **
41893 ** If the nRec value is 0xffffffff it means that nRec should be computed
41894 ** from the file size.  This value is used when the user selects the
41895 ** no-sync option for the journal.  A power failure could lead to corruption
41896 ** in this case.  But for things like temporary table (which will be
41897 ** deleted when the power is restored) we don't care.  
41898 **
41899 ** If the file opened as the journal file is not a well-formed
41900 ** journal file then all pages up to the first corrupted page are rolled
41901 ** back (or no pages if the journal header is corrupted). The journal file
41902 ** is then deleted and SQLCIPHER_OK returned, just as if no corruption had
41903 ** been encountered.
41904 **
41905 ** If an I/O or malloc() error occurs, the journal-file is not deleted
41906 ** and an error code is returned.
41907 **
41908 ** The isHot parameter indicates that we are trying to rollback a journal
41909 ** that might be a hot journal.  Or, it could be that the journal is 
41910 ** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
41911 ** If the journal really is hot, reset the pager cache prior rolling
41912 ** back any content.  If the journal is merely persistent, no reset is
41913 ** needed.
41914 */
41915 static int pager_playback(Pager *pPager, int isHot){
41916   sqlcipher3_vfs *pVfs = pPager->pVfs;
41917   i64 szJ;                 /* Size of the journal file in bytes */
41918   u32 nRec;                /* Number of Records in the journal */
41919   u32 u;                   /* Unsigned loop counter */
41920   Pgno mxPg = 0;           /* Size of the original file in pages */
41921   int rc;                  /* Result code of a subroutine */
41922   int res = 1;             /* Value returned by sqlcipher3OsAccess() */
41923   char *zMaster = 0;       /* Name of master journal file if any */
41924   int needPagerReset;      /* True to reset page prior to first page rollback */
41925
41926   /* Figure out how many records are in the journal.  Abort early if
41927   ** the journal is empty.
41928   */
41929   assert( isOpen(pPager->jfd) );
41930   rc = sqlcipher3OsFileSize(pPager->jfd, &szJ);
41931   if( rc!=SQLCIPHER_OK ){
41932     goto end_playback;
41933   }
41934
41935   /* Read the master journal name from the journal, if it is present.
41936   ** If a master journal file name is specified, but the file is not
41937   ** present on disk, then the journal is not hot and does not need to be
41938   ** played back.
41939   **
41940   ** TODO: Technically the following is an error because it assumes that
41941   ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
41942   ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
41943   **  mxPathname is 512, which is the same as the minimum allowable value
41944   ** for pageSize.
41945   */
41946   zMaster = pPager->pTmpSpace;
41947   rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
41948   if( rc==SQLCIPHER_OK && zMaster[0] ){
41949     rc = sqlcipher3OsAccess(pVfs, zMaster, SQLCIPHER_ACCESS_EXISTS, &res);
41950   }
41951   zMaster = 0;
41952   if( rc!=SQLCIPHER_OK || !res ){
41953     goto end_playback;
41954   }
41955   pPager->journalOff = 0;
41956   needPagerReset = isHot;
41957
41958   /* This loop terminates either when a readJournalHdr() or 
41959   ** pager_playback_one_page() call returns SQLCIPHER_DONE or an IO error 
41960   ** occurs. 
41961   */
41962   while( 1 ){
41963     /* Read the next journal header from the journal file.  If there are
41964     ** not enough bytes left in the journal file for a complete header, or
41965     ** it is corrupted, then a process must have failed while writing it.
41966     ** This indicates nothing more needs to be rolled back.
41967     */
41968     rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
41969     if( rc!=SQLCIPHER_OK ){ 
41970       if( rc==SQLCIPHER_DONE ){
41971         rc = SQLCIPHER_OK;
41972       }
41973       goto end_playback;
41974     }
41975
41976     /* If nRec is 0xffffffff, then this journal was created by a process
41977     ** working in no-sync mode. This means that the rest of the journal
41978     ** file consists of pages, there are no more journal headers. Compute
41979     ** the value of nRec based on this assumption.
41980     */
41981     if( nRec==0xffffffff ){
41982       assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
41983       nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
41984     }
41985
41986     /* If nRec is 0 and this rollback is of a transaction created by this
41987     ** process and if this is the final header in the journal, then it means
41988     ** that this part of the journal was being filled but has not yet been
41989     ** synced to disk.  Compute the number of pages based on the remaining
41990     ** size of the file.
41991     **
41992     ** The third term of the test was added to fix ticket #2565.
41993     ** When rolling back a hot journal, nRec==0 always means that the next
41994     ** chunk of the journal contains zero pages to be rolled back.  But
41995     ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
41996     ** the journal, it means that the journal might contain additional
41997     ** pages that need to be rolled back and that the number of pages 
41998     ** should be computed based on the journal file size.
41999     */
42000     if( nRec==0 && !isHot &&
42001         pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
42002       nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
42003     }
42004
42005     /* If this is the first header read from the journal, truncate the
42006     ** database file back to its original size.
42007     */
42008     if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
42009       rc = pager_truncate(pPager, mxPg);
42010       if( rc!=SQLCIPHER_OK ){
42011         goto end_playback;
42012       }
42013       pPager->dbSize = mxPg;
42014     }
42015
42016     /* Copy original pages out of the journal and back into the 
42017     ** database file and/or page cache.
42018     */
42019     for(u=0; u<nRec; u++){
42020       if( needPagerReset ){
42021         pager_reset(pPager);
42022         needPagerReset = 0;
42023       }
42024       rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
42025       if( rc!=SQLCIPHER_OK ){
42026         if( rc==SQLCIPHER_DONE ){
42027           pPager->journalOff = szJ;
42028           break;
42029         }else if( rc==SQLCIPHER_IOERR_SHORT_READ ){
42030           /* If the journal has been truncated, simply stop reading and
42031           ** processing the journal. This might happen if the journal was
42032           ** not completely written and synced prior to a crash.  In that
42033           ** case, the database should have never been written in the
42034           ** first place so it is OK to simply abandon the rollback. */
42035           rc = SQLCIPHER_OK;
42036           goto end_playback;
42037         }else{
42038           /* If we are unable to rollback, quit and return the error
42039           ** code.  This will cause the pager to enter the error state
42040           ** so that no further harm will be done.  Perhaps the next
42041           ** process to come along will be able to rollback the database.
42042           */
42043           goto end_playback;
42044         }
42045       }
42046     }
42047   }
42048   /*NOTREACHED*/
42049   assert( 0 );
42050
42051 end_playback:
42052   /* Following a rollback, the database file should be back in its original
42053   ** state prior to the start of the transaction, so invoke the
42054   ** SQLCIPHER_FCNTL_DB_UNCHANGED file-control method to disable the
42055   ** assertion that the transaction counter was modified.
42056   */
42057   assert(
42058     pPager->fd->pMethods==0 ||
42059     sqlcipher3OsFileControl(pPager->fd,SQLCIPHER_FCNTL_DB_UNCHANGED,0)>=SQLCIPHER_OK
42060   );
42061
42062   /* If this playback is happening automatically as a result of an IO or 
42063   ** malloc error that occurred after the change-counter was updated but 
42064   ** before the transaction was committed, then the change-counter 
42065   ** modification may just have been reverted. If this happens in exclusive 
42066   ** mode, then subsequent transactions performed by the connection will not
42067   ** update the change-counter at all. This may lead to cache inconsistency
42068   ** problems for other processes at some point in the future. So, just
42069   ** in case this has happened, clear the changeCountDone flag now.
42070   */
42071   pPager->changeCountDone = pPager->tempFile;
42072
42073   if( rc==SQLCIPHER_OK ){
42074     zMaster = pPager->pTmpSpace;
42075     rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
42076     testcase( rc!=SQLCIPHER_OK );
42077   }
42078   if( rc==SQLCIPHER_OK
42079    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
42080   ){
42081     rc = sqlcipher3PagerSync(pPager);
42082   }
42083   if( rc==SQLCIPHER_OK ){
42084     rc = pager_end_transaction(pPager, zMaster[0]!='\0');
42085     testcase( rc!=SQLCIPHER_OK );
42086   }
42087   if( rc==SQLCIPHER_OK && zMaster[0] && res ){
42088     /* If there was a master journal and this routine will return success,
42089     ** see if it is possible to delete the master journal.
42090     */
42091     rc = pager_delmaster(pPager, zMaster);
42092     testcase( rc!=SQLCIPHER_OK );
42093   }
42094
42095   /* The Pager.sectorSize variable may have been updated while rolling
42096   ** back a journal created by a process with a different sector size
42097   ** value. Reset it to the correct value for this process.
42098   */
42099   setSectorSize(pPager);
42100   return rc;
42101 }
42102
42103
42104 /*
42105 ** Read the content for page pPg out of the database file and into 
42106 ** pPg->pData. A shared lock or greater must be held on the database
42107 ** file before this function is called.
42108 **
42109 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
42110 ** the value read from the database file.
42111 **
42112 ** If an IO error occurs, then the IO error is returned to the caller.
42113 ** Otherwise, SQLCIPHER_OK is returned.
42114 */
42115 static int readDbPage(PgHdr *pPg){
42116   Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
42117   Pgno pgno = pPg->pgno;       /* Page number to read */
42118   int rc = SQLCIPHER_OK;          /* Return code */
42119   int isInWal = 0;             /* True if page is in log file */
42120   int pgsz = pPager->pageSize; /* Number of bytes to read */
42121
42122   assert( pPager->eState>=PAGER_READER && !MEMDB );
42123   assert( isOpen(pPager->fd) );
42124
42125   if( NEVER(!isOpen(pPager->fd)) ){
42126     assert( pPager->tempFile );
42127     memset(pPg->pData, 0, pPager->pageSize);
42128     return SQLCIPHER_OK;
42129   }
42130
42131   if( pagerUseWal(pPager) ){
42132     /* Try to pull the page from the write-ahead log. */
42133     rc = sqlcipher3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
42134   }
42135   if( rc==SQLCIPHER_OK && !isInWal ){
42136     i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
42137     rc = sqlcipher3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
42138     if( rc==SQLCIPHER_IOERR_SHORT_READ ){
42139       rc = SQLCIPHER_OK;
42140     }
42141   }
42142
42143   if( pgno==1 ){
42144     if( rc ){
42145       /* If the read is unsuccessful, set the dbFileVers[] to something
42146       ** that will never be a valid file version.  dbFileVers[] is a copy
42147       ** of bytes 24..39 of the database.  Bytes 28..31 should always be
42148       ** zero or the size of the database in page. Bytes 32..35 and 35..39
42149       ** should be page numbers which are never 0xffffffff.  So filling
42150       ** pPager->dbFileVers[] with all 0xff bytes should suffice.
42151       **
42152       ** For an encrypted database, the situation is more complex:  bytes
42153       ** 24..39 of the database are white noise.  But the probability of
42154       ** white noising equaling 16 bytes of 0xff is vanishingly small so
42155       ** we should still be ok.
42156       */
42157       memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
42158     }else{
42159       u8 *dbFileVers = &((u8*)pPg->pData)[24];
42160       memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
42161     }
42162   }
42163   CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLCIPHER_NOMEM);
42164
42165   PAGER_INCR(sqlcipher3_pager_readdb_count);
42166   PAGER_INCR(pPager->nRead);
42167   IOTRACE(("PGIN %p %d\n", pPager, pgno));
42168   PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
42169                PAGERID(pPager), pgno, pager_pagehash(pPg)));
42170
42171   return rc;
42172 }
42173
42174 /*
42175 ** Update the value of the change-counter at offsets 24 and 92 in
42176 ** the header and the sqlcipher version number at offset 96.
42177 **
42178 ** This is an unconditional update.  See also the pager_incr_changecounter()
42179 ** routine which only updates the change-counter if the update is actually
42180 ** needed, as determined by the pPager->changeCountDone state variable.
42181 */
42182 static void pager_write_changecounter(PgHdr *pPg){
42183   u32 change_counter;
42184
42185   /* Increment the value just read and write it back to byte 24. */
42186   change_counter = sqlcipher3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
42187   put32bits(((char*)pPg->pData)+24, change_counter);
42188
42189   /* Also store the SQLite version number in bytes 96..99 and in
42190   ** bytes 92..95 store the change counter for which the version number
42191   ** is valid. */
42192   put32bits(((char*)pPg->pData)+92, change_counter);
42193   put32bits(((char*)pPg->pData)+96, SQLCIPHER_VERSION_NUMBER);
42194 }
42195
42196 #ifndef SQLCIPHER_OMIT_WAL
42197 /*
42198 ** This function is invoked once for each page that has already been 
42199 ** written into the log file when a WAL transaction is rolled back.
42200 ** Parameter iPg is the page number of said page. The pCtx argument 
42201 ** is actually a pointer to the Pager structure.
42202 **
42203 ** If page iPg is present in the cache, and has no outstanding references,
42204 ** it is discarded. Otherwise, if there are one or more outstanding
42205 ** references, the page content is reloaded from the database. If the
42206 ** attempt to reload content from the database is required and fails, 
42207 ** return an SQLite error code. Otherwise, SQLCIPHER_OK.
42208 */
42209 static int pagerUndoCallback(void *pCtx, Pgno iPg){
42210   int rc = SQLCIPHER_OK;
42211   Pager *pPager = (Pager *)pCtx;
42212   PgHdr *pPg;
42213
42214   pPg = sqlcipher3PagerLookup(pPager, iPg);
42215   if( pPg ){
42216     if( sqlcipher3PcachePageRefcount(pPg)==1 ){
42217       sqlcipher3PcacheDrop(pPg);
42218     }else{
42219       rc = readDbPage(pPg);
42220       if( rc==SQLCIPHER_OK ){
42221         pPager->xReiniter(pPg);
42222       }
42223       sqlcipher3PagerUnref(pPg);
42224     }
42225   }
42226
42227   /* Normally, if a transaction is rolled back, any backup processes are
42228   ** updated as data is copied out of the rollback journal and into the
42229   ** database. This is not generally possible with a WAL database, as
42230   ** rollback involves simply truncating the log file. Therefore, if one
42231   ** or more frames have already been written to the log (and therefore 
42232   ** also copied into the backup databases) as part of this transaction,
42233   ** the backups must be restarted.
42234   */
42235   sqlcipher3BackupRestart(pPager->pBackup);
42236
42237   return rc;
42238 }
42239
42240 /*
42241 ** This function is called to rollback a transaction on a WAL database.
42242 */
42243 static int pagerRollbackWal(Pager *pPager){
42244   int rc;                         /* Return Code */
42245   PgHdr *pList;                   /* List of dirty pages to revert */
42246
42247   /* For all pages in the cache that are currently dirty or have already
42248   ** been written (but not committed) to the log file, do one of the 
42249   ** following:
42250   **
42251   **   + Discard the cached page (if refcount==0), or
42252   **   + Reload page content from the database (if refcount>0).
42253   */
42254   pPager->dbSize = pPager->dbOrigSize;
42255   rc = sqlcipher3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
42256   pList = sqlcipher3PcacheDirtyList(pPager->pPCache);
42257   while( pList && rc==SQLCIPHER_OK ){
42258     PgHdr *pNext = pList->pDirty;
42259     rc = pagerUndoCallback((void *)pPager, pList->pgno);
42260     pList = pNext;
42261   }
42262
42263   return rc;
42264 }
42265
42266 /*
42267 ** This function is a wrapper around sqlcipher3WalFrames(). As well as logging
42268 ** the contents of the list of pages headed by pList (connected by pDirty),
42269 ** this function notifies any active backup processes that the pages have
42270 ** changed. 
42271 **
42272 ** The list of pages passed into this routine is always sorted by page number.
42273 ** Hence, if page 1 appears anywhere on the list, it will be the first page.
42274 */ 
42275 static int pagerWalFrames(
42276   Pager *pPager,                  /* Pager object */
42277   PgHdr *pList,                   /* List of frames to log */
42278   Pgno nTruncate,                 /* Database size after this commit */
42279   int isCommit,                   /* True if this is a commit */
42280   int syncFlags                   /* Flags to pass to OsSync() (or 0) */
42281 ){
42282   int rc;                         /* Return code */
42283 #if defined(SQLCIPHER_DEBUG) || defined(SQLCIPHER_CHECK_PAGES)
42284   PgHdr *p;                       /* For looping over pages */
42285 #endif
42286
42287   assert( pPager->pWal );
42288   assert( pList );
42289 #ifdef SQLCIPHER_DEBUG
42290   /* Verify that the page list is in accending order */
42291   for(p=pList; p && p->pDirty; p=p->pDirty){
42292     assert( p->pgno < p->pDirty->pgno );
42293   }
42294 #endif
42295
42296   if( isCommit ){
42297     /* If a WAL transaction is being committed, there is no point in writing
42298     ** any pages with page numbers greater than nTruncate into the WAL file.
42299     ** They will never be read by any client. So remove them from the pDirty
42300     ** list here. */
42301     PgHdr *p;
42302     PgHdr **ppNext = &pList;
42303     for(p=pList; (*ppNext = p); p=p->pDirty){
42304       if( p->pgno<=nTruncate ) ppNext = &p->pDirty;
42305     }
42306     assert( pList );
42307   }
42308
42309   if( pList->pgno==1 ) pager_write_changecounter(pList);
42310   rc = sqlcipher3WalFrames(pPager->pWal, 
42311       pPager->pageSize, pList, nTruncate, isCommit, syncFlags
42312   );
42313   if( rc==SQLCIPHER_OK && pPager->pBackup ){
42314     PgHdr *p;
42315     for(p=pList; p; p=p->pDirty){
42316       sqlcipher3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
42317     }
42318   }
42319
42320 #ifdef SQLCIPHER_CHECK_PAGES
42321   pList = sqlcipher3PcacheDirtyList(pPager->pPCache);
42322   for(p=pList; p; p=p->pDirty){
42323     pager_set_pagehash(p);
42324   }
42325 #endif
42326
42327   return rc;
42328 }
42329
42330 /*
42331 ** Begin a read transaction on the WAL.
42332 **
42333 ** This routine used to be called "pagerOpenSnapshot()" because it essentially
42334 ** makes a snapshot of the database at the current point in time and preserves
42335 ** that snapshot for use by the reader in spite of concurrently changes by
42336 ** other writers or checkpointers.
42337 */
42338 static int pagerBeginReadTransaction(Pager *pPager){
42339   int rc;                         /* Return code */
42340   int changed = 0;                /* True if cache must be reset */
42341
42342   assert( pagerUseWal(pPager) );
42343   assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
42344
42345   /* sqlcipher3WalEndReadTransaction() was not called for the previous
42346   ** transaction in locking_mode=EXCLUSIVE.  So call it now.  If we
42347   ** are in locking_mode=NORMAL and EndRead() was previously called,
42348   ** the duplicate call is harmless.
42349   */
42350   sqlcipher3WalEndReadTransaction(pPager->pWal);
42351
42352   rc = sqlcipher3WalBeginReadTransaction(pPager->pWal, &changed);
42353   if( rc!=SQLCIPHER_OK || changed ){
42354     pager_reset(pPager);
42355   }
42356
42357   return rc;
42358 }
42359 #endif
42360
42361 /*
42362 ** This function is called as part of the transition from PAGER_OPEN
42363 ** to PAGER_READER state to determine the size of the database file
42364 ** in pages (assuming the page size currently stored in Pager.pageSize).
42365 **
42366 ** If no error occurs, SQLCIPHER_OK is returned and the size of the database
42367 ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
42368 ** SQLCIPHER_IOERR_FSTAT) is returned and *pnPage is left unmodified.
42369 */
42370 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
42371   Pgno nPage;                     /* Value to return via *pnPage */
42372
42373   /* Query the WAL sub-system for the database size. The WalDbsize()
42374   ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
42375   ** if the database size is not available. The database size is not
42376   ** available from the WAL sub-system if the log file is empty or
42377   ** contains no valid committed transactions.
42378   */
42379   assert( pPager->eState==PAGER_OPEN );
42380   assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
42381   nPage = sqlcipher3WalDbsize(pPager->pWal);
42382
42383   /* If the database size was not available from the WAL sub-system,
42384   ** determine it based on the size of the database file. If the size
42385   ** of the database file is not an integer multiple of the page-size,
42386   ** round down to the nearest page. Except, any file larger than 0
42387   ** bytes in size is considered to contain at least one page.
42388   */
42389   if( nPage==0 ){
42390     i64 n = 0;                    /* Size of db file in bytes */
42391     assert( isOpen(pPager->fd) || pPager->tempFile );
42392     if( isOpen(pPager->fd) ){
42393       int rc = sqlcipher3OsFileSize(pPager->fd, &n);
42394       if( rc!=SQLCIPHER_OK ){
42395         return rc;
42396       }
42397     }
42398     nPage = (Pgno)(n / pPager->pageSize);
42399     if( nPage==0 && n>0 ){
42400       nPage = 1;
42401     }
42402   }
42403
42404   /* If the current number of pages in the file is greater than the
42405   ** configured maximum pager number, increase the allowed limit so
42406   ** that the file can be read.
42407   */
42408   if( nPage>pPager->mxPgno ){
42409     pPager->mxPgno = (Pgno)nPage;
42410   }
42411
42412   *pnPage = nPage;
42413   return SQLCIPHER_OK;
42414 }
42415
42416 #ifndef SQLCIPHER_OMIT_WAL
42417 /*
42418 ** Check if the *-wal file that corresponds to the database opened by pPager
42419 ** exists if the database is not empy, or verify that the *-wal file does
42420 ** not exist (by deleting it) if the database file is empty.
42421 **
42422 ** If the database is not empty and the *-wal file exists, open the pager
42423 ** in WAL mode.  If the database is empty or if no *-wal file exists and
42424 ** if no error occurs, make sure Pager.journalMode is not set to
42425 ** PAGER_JOURNALMODE_WAL.
42426 **
42427 ** Return SQLCIPHER_OK or an error code.
42428 **
42429 ** The caller must hold a SHARED lock on the database file to call this
42430 ** function. Because an EXCLUSIVE lock on the db file is required to delete 
42431 ** a WAL on a none-empty database, this ensures there is no race condition 
42432 ** between the xAccess() below and an xDelete() being executed by some 
42433 ** other connection.
42434 */
42435 static int pagerOpenWalIfPresent(Pager *pPager){
42436   int rc = SQLCIPHER_OK;
42437   assert( pPager->eState==PAGER_OPEN );
42438   assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
42439
42440   if( !pPager->tempFile ){
42441     int isWal;                    /* True if WAL file exists */
42442     Pgno nPage;                   /* Size of the database file */
42443
42444     rc = pagerPagecount(pPager, &nPage);
42445     if( rc ) return rc;
42446     if( nPage==0 ){
42447       rc = sqlcipher3OsDelete(pPager->pVfs, pPager->zWal, 0);
42448       isWal = 0;
42449     }else{
42450       rc = sqlcipher3OsAccess(
42451           pPager->pVfs, pPager->zWal, SQLCIPHER_ACCESS_EXISTS, &isWal
42452       );
42453     }
42454     if( rc==SQLCIPHER_OK ){
42455       if( isWal ){
42456         testcase( sqlcipher3PcachePagecount(pPager->pPCache)==0 );
42457         rc = sqlcipher3PagerOpenWal(pPager, 0);
42458       }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
42459         pPager->journalMode = PAGER_JOURNALMODE_DELETE;
42460       }
42461     }
42462   }
42463   return rc;
42464 }
42465 #endif
42466
42467 /*
42468 ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
42469 ** the entire master journal file. The case pSavepoint==NULL occurs when 
42470 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction 
42471 ** savepoint.
42472 **
42473 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is 
42474 ** being rolled back), then the rollback consists of up to three stages,
42475 ** performed in the order specified:
42476 **
42477 **   * Pages are played back from the main journal starting at byte
42478 **     offset PagerSavepoint.iOffset and continuing to 
42479 **     PagerSavepoint.iHdrOffset, or to the end of the main journal
42480 **     file if PagerSavepoint.iHdrOffset is zero.
42481 **
42482 **   * If PagerSavepoint.iHdrOffset is not zero, then pages are played
42483 **     back starting from the journal header immediately following 
42484 **     PagerSavepoint.iHdrOffset to the end of the main journal file.
42485 **
42486 **   * Pages are then played back from the sub-journal file, starting
42487 **     with the PagerSavepoint.iSubRec and continuing to the end of
42488 **     the journal file.
42489 **
42490 ** Throughout the rollback process, each time a page is rolled back, the
42491 ** corresponding bit is set in a bitvec structure (variable pDone in the
42492 ** implementation below). This is used to ensure that a page is only
42493 ** rolled back the first time it is encountered in either journal.
42494 **
42495 ** If pSavepoint is NULL, then pages are only played back from the main
42496 ** journal file. There is no need for a bitvec in this case.
42497 **
42498 ** In either case, before playback commences the Pager.dbSize variable
42499 ** is reset to the value that it held at the start of the savepoint 
42500 ** (or transaction). No page with a page-number greater than this value
42501 ** is played back. If one is encountered it is simply skipped.
42502 */
42503 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
42504   i64 szJ;                 /* Effective size of the main journal */
42505   i64 iHdrOff;             /* End of first segment of main-journal records */
42506   int rc = SQLCIPHER_OK;      /* Return code */
42507   Bitvec *pDone = 0;       /* Bitvec to ensure pages played back only once */
42508
42509   assert( pPager->eState!=PAGER_ERROR );
42510   assert( pPager->eState>=PAGER_WRITER_LOCKED );
42511
42512   /* Allocate a bitvec to use to store the set of pages rolled back */
42513   if( pSavepoint ){
42514     pDone = sqlcipher3BitvecCreate(pSavepoint->nOrig);
42515     if( !pDone ){
42516       return SQLCIPHER_NOMEM;
42517     }
42518   }
42519
42520   /* Set the database size back to the value it was before the savepoint 
42521   ** being reverted was opened.
42522   */
42523   pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
42524   pPager->changeCountDone = pPager->tempFile;
42525
42526   if( !pSavepoint && pagerUseWal(pPager) ){
42527     return pagerRollbackWal(pPager);
42528   }
42529
42530   /* Use pPager->journalOff as the effective size of the main rollback
42531   ** journal.  The actual file might be larger than this in
42532   ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST.  But anything
42533   ** past pPager->journalOff is off-limits to us.
42534   */
42535   szJ = pPager->journalOff;
42536   assert( pagerUseWal(pPager)==0 || szJ==0 );
42537
42538   /* Begin by rolling back records from the main journal starting at
42539   ** PagerSavepoint.iOffset and continuing to the next journal header.
42540   ** There might be records in the main journal that have a page number
42541   ** greater than the current database size (pPager->dbSize) but those
42542   ** will be skipped automatically.  Pages are added to pDone as they
42543   ** are played back.
42544   */
42545   if( pSavepoint && !pagerUseWal(pPager) ){
42546     iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
42547     pPager->journalOff = pSavepoint->iOffset;
42548     while( rc==SQLCIPHER_OK && pPager->journalOff<iHdrOff ){
42549       rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
42550     }
42551     assert( rc!=SQLCIPHER_DONE );
42552   }else{
42553     pPager->journalOff = 0;
42554   }
42555
42556   /* Continue rolling back records out of the main journal starting at
42557   ** the first journal header seen and continuing until the effective end
42558   ** of the main journal file.  Continue to skip out-of-range pages and
42559   ** continue adding pages rolled back to pDone.
42560   */
42561   while( rc==SQLCIPHER_OK && pPager->journalOff<szJ ){
42562     u32 ii;            /* Loop counter */
42563     u32 nJRec = 0;     /* Number of Journal Records */
42564     u32 dummy;
42565     rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
42566     assert( rc!=SQLCIPHER_DONE );
42567
42568     /*
42569     ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
42570     ** test is related to ticket #2565.  See the discussion in the
42571     ** pager_playback() function for additional information.
42572     */
42573     if( nJRec==0 
42574      && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
42575     ){
42576       nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
42577     }
42578     for(ii=0; rc==SQLCIPHER_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
42579       rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
42580     }
42581     assert( rc!=SQLCIPHER_DONE );
42582   }
42583   assert( rc!=SQLCIPHER_OK || pPager->journalOff>=szJ );
42584
42585   /* Finally,  rollback pages from the sub-journal.  Page that were
42586   ** previously rolled back out of the main journal (and are hence in pDone)
42587   ** will be skipped.  Out-of-range pages are also skipped.
42588   */
42589   if( pSavepoint ){
42590     u32 ii;            /* Loop counter */
42591     i64 offset = pSavepoint->iSubRec*(4+pPager->pageSize);
42592
42593     if( pagerUseWal(pPager) ){
42594       rc = sqlcipher3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
42595     }
42596     for(ii=pSavepoint->iSubRec; rc==SQLCIPHER_OK && ii<pPager->nSubRec; ii++){
42597       assert( offset==ii*(4+pPager->pageSize) );
42598       rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
42599     }
42600     assert( rc!=SQLCIPHER_DONE );
42601   }
42602
42603   sqlcipher3BitvecDestroy(pDone);
42604   if( rc==SQLCIPHER_OK ){
42605     pPager->journalOff = szJ;
42606   }
42607
42608   return rc;
42609 }
42610
42611 /*
42612 ** Change the maximum number of in-memory pages that are allowed.
42613 */
42614 SQLCIPHER_PRIVATE void sqlcipher3PagerSetCachesize(Pager *pPager, int mxPage){
42615   sqlcipher3PcacheSetCachesize(pPager->pPCache, mxPage);
42616 }
42617
42618 /*
42619 ** Adjust the robustness of the database to damage due to OS crashes
42620 ** or power failures by changing the number of syncs()s when writing
42621 ** the rollback journal.  There are three levels:
42622 **
42623 **    OFF       sqlcipher3OsSync() is never called.  This is the default
42624 **              for temporary and transient files.
42625 **
42626 **    NORMAL    The journal is synced once before writes begin on the
42627 **              database.  This is normally adequate protection, but
42628 **              it is theoretically possible, though very unlikely,
42629 **              that an inopertune power failure could leave the journal
42630 **              in a state which would cause damage to the database
42631 **              when it is rolled back.
42632 **
42633 **    FULL      The journal is synced twice before writes begin on the
42634 **              database (with some additional information - the nRec field
42635 **              of the journal header - being written in between the two
42636 **              syncs).  If we assume that writing a
42637 **              single disk sector is atomic, then this mode provides
42638 **              assurance that the journal will not be corrupted to the
42639 **              point of causing damage to the database during rollback.
42640 **
42641 ** The above is for a rollback-journal mode.  For WAL mode, OFF continues
42642 ** to mean that no syncs ever occur.  NORMAL means that the WAL is synced
42643 ** prior to the start of checkpoint and that the database file is synced
42644 ** at the conclusion of the checkpoint if the entire content of the WAL
42645 ** was written back into the database.  But no sync operations occur for
42646 ** an ordinary commit in NORMAL mode with WAL.  FULL means that the WAL
42647 ** file is synced following each commit operation, in addition to the
42648 ** syncs associated with NORMAL.
42649 **
42650 ** Do not confuse synchronous=FULL with SQLCIPHER_SYNC_FULL.  The
42651 ** SQLCIPHER_SYNC_FULL macro means to use the MacOSX-style full-fsync
42652 ** using fcntl(F_FULLFSYNC).  SQLCIPHER_SYNC_NORMAL means to do an
42653 ** ordinary fsync() call.  There is no difference between SQLCIPHER_SYNC_FULL
42654 ** and SQLCIPHER_SYNC_NORMAL on platforms other than MacOSX.  But the
42655 ** synchronous=FULL versus synchronous=NORMAL setting determines when
42656 ** the xSync primitive is called and is relevant to all platforms.
42657 **
42658 ** Numeric values associated with these states are OFF==1, NORMAL=2,
42659 ** and FULL=3.
42660 */
42661 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
42662 SQLCIPHER_PRIVATE void sqlcipher3PagerSetSafetyLevel(
42663   Pager *pPager,        /* The pager to set safety level for */
42664   int level,            /* PRAGMA synchronous.  1=OFF, 2=NORMAL, 3=FULL */  
42665   int bFullFsync,       /* PRAGMA fullfsync */
42666   int bCkptFullFsync    /* PRAGMA checkpoint_fullfsync */
42667 ){
42668   assert( level>=1 && level<=3 );
42669   pPager->noSync =  (level==1 || pPager->tempFile) ?1:0;
42670   pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
42671   if( pPager->noSync ){
42672     pPager->syncFlags = 0;
42673     pPager->ckptSyncFlags = 0;
42674   }else if( bFullFsync ){
42675     pPager->syncFlags = SQLCIPHER_SYNC_FULL;
42676     pPager->ckptSyncFlags = SQLCIPHER_SYNC_FULL;
42677   }else if( bCkptFullFsync ){
42678     pPager->syncFlags = SQLCIPHER_SYNC_NORMAL;
42679     pPager->ckptSyncFlags = SQLCIPHER_SYNC_FULL;
42680   }else{
42681     pPager->syncFlags = SQLCIPHER_SYNC_NORMAL;
42682     pPager->ckptSyncFlags = SQLCIPHER_SYNC_NORMAL;
42683   }
42684 }
42685 #endif
42686
42687 /*
42688 ** The following global variable is incremented whenever the library
42689 ** attempts to open a temporary file.  This information is used for
42690 ** testing and analysis only.  
42691 */
42692 #ifdef SQLCIPHER_TEST
42693 SQLCIPHER_API int sqlcipher3_opentemp_count = 0;
42694 #endif
42695
42696 /*
42697 ** Open a temporary file.
42698 **
42699 ** Write the file descriptor into *pFile. Return SQLCIPHER_OK on success 
42700 ** or some other error code if we fail. The OS will automatically 
42701 ** delete the temporary file when it is closed.
42702 **
42703 ** The flags passed to the VFS layer xOpen() call are those specified
42704 ** by parameter vfsFlags ORed with the following:
42705 **
42706 **     SQLCIPHER_OPEN_READWRITE
42707 **     SQLCIPHER_OPEN_CREATE
42708 **     SQLCIPHER_OPEN_EXCLUSIVE
42709 **     SQLCIPHER_OPEN_DELETEONCLOSE
42710 */
42711 static int pagerOpentemp(
42712   Pager *pPager,        /* The pager object */
42713   sqlcipher3_file *pFile,  /* Write the file descriptor here */
42714   int vfsFlags          /* Flags passed through to the VFS */
42715 ){
42716   int rc;               /* Return code */
42717
42718 #ifdef SQLCIPHER_TEST
42719   sqlcipher3_opentemp_count++;  /* Used for testing and analysis only */
42720 #endif
42721
42722   vfsFlags |=  SQLCIPHER_OPEN_READWRITE | SQLCIPHER_OPEN_CREATE |
42723             SQLCIPHER_OPEN_EXCLUSIVE | SQLCIPHER_OPEN_DELETEONCLOSE;
42724   rc = sqlcipher3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
42725   assert( rc!=SQLCIPHER_OK || isOpen(pFile) );
42726   return rc;
42727 }
42728
42729 /*
42730 ** Set the busy handler function.
42731 **
42732 ** The pager invokes the busy-handler if sqlcipher3OsLock() returns 
42733 ** SQLCIPHER_BUSY when trying to upgrade from no-lock to a SHARED lock,
42734 ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE 
42735 ** lock. It does *not* invoke the busy handler when upgrading from
42736 ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
42737 ** (which occurs during hot-journal rollback). Summary:
42738 **
42739 **   Transition                        | Invokes xBusyHandler
42740 **   --------------------------------------------------------
42741 **   NO_LOCK       -> SHARED_LOCK      | Yes
42742 **   SHARED_LOCK   -> RESERVED_LOCK    | No
42743 **   SHARED_LOCK   -> EXCLUSIVE_LOCK   | No
42744 **   RESERVED_LOCK -> EXCLUSIVE_LOCK   | Yes
42745 **
42746 ** If the busy-handler callback returns non-zero, the lock is 
42747 ** retried. If it returns zero, then the SQLCIPHER_BUSY error is
42748 ** returned to the caller of the pager API function.
42749 */
42750 SQLCIPHER_PRIVATE void sqlcipher3PagerSetBusyhandler(
42751   Pager *pPager,                       /* Pager object */
42752   int (*xBusyHandler)(void *),         /* Pointer to busy-handler function */
42753   void *pBusyHandlerArg                /* Argument to pass to xBusyHandler */
42754 ){  
42755   pPager->xBusyHandler = xBusyHandler;
42756   pPager->pBusyHandlerArg = pBusyHandlerArg;
42757 }
42758
42759 /*
42760 ** Change the page size used by the Pager object. The new page size 
42761 ** is passed in *pPageSize.
42762 **
42763 ** If the pager is in the error state when this function is called, it
42764 ** is a no-op. The value returned is the error state error code (i.e. 
42765 ** one of SQLCIPHER_IOERR, an SQLCIPHER_IOERR_xxx sub-code or SQLCIPHER_FULL).
42766 **
42767 ** Otherwise, if all of the following are true:
42768 **
42769 **   * the new page size (value of *pPageSize) is valid (a power 
42770 **     of two between 512 and SQLCIPHER_MAX_PAGE_SIZE, inclusive), and
42771 **
42772 **   * there are no outstanding page references, and
42773 **
42774 **   * the database is either not an in-memory database or it is
42775 **     an in-memory database that currently consists of zero pages.
42776 **
42777 ** then the pager object page size is set to *pPageSize.
42778 **
42779 ** If the page size is changed, then this function uses sqlcipher3PagerMalloc() 
42780 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt 
42781 ** fails, SQLCIPHER_NOMEM is returned and the page size remains unchanged. 
42782 ** In all other cases, SQLCIPHER_OK is returned.
42783 **
42784 ** If the page size is not changed, either because one of the enumerated
42785 ** conditions above is not true, the pager was in error state when this
42786 ** function was called, or because the memory allocation attempt failed, 
42787 ** then *pPageSize is set to the old, retained page size before returning.
42788 */
42789 SQLCIPHER_PRIVATE int sqlcipher3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
42790   int rc = SQLCIPHER_OK;
42791
42792   /* It is not possible to do a full assert_pager_state() here, as this
42793   ** function may be called from within PagerOpen(), before the state
42794   ** of the Pager object is internally consistent.
42795   **
42796   ** At one point this function returned an error if the pager was in 
42797   ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
42798   ** there is at least one outstanding page reference, this function
42799   ** is a no-op for that case anyhow.
42800   */
42801
42802   u32 pageSize = *pPageSize;
42803   assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLCIPHER_MAX_PAGE_SIZE) );
42804   if( (pPager->memDb==0 || pPager->dbSize==0)
42805    && sqlcipher3PcacheRefCount(pPager->pPCache)==0 
42806    && pageSize && pageSize!=(u32)pPager->pageSize 
42807   ){
42808     char *pNew = NULL;             /* New temp space */
42809     i64 nByte = 0;
42810
42811     if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
42812       rc = sqlcipher3OsFileSize(pPager->fd, &nByte);
42813     }
42814     if( rc==SQLCIPHER_OK ){
42815       pNew = (char *)sqlcipher3PageMalloc(pageSize);
42816       if( !pNew ) rc = SQLCIPHER_NOMEM;
42817     }
42818
42819     if( rc==SQLCIPHER_OK ){
42820       pager_reset(pPager);
42821       pPager->dbSize = (Pgno)(nByte/pageSize);
42822       pPager->pageSize = pageSize;
42823       sqlcipher3PageFree(pPager->pTmpSpace);
42824       pPager->pTmpSpace = pNew;
42825       sqlcipher3PcacheSetPageSize(pPager->pPCache, pageSize);
42826     }
42827   }
42828
42829   *pPageSize = pPager->pageSize;
42830   if( rc==SQLCIPHER_OK ){
42831     if( nReserve<0 ) nReserve = pPager->nReserve;
42832     assert( nReserve>=0 && nReserve<1000 );
42833     pPager->nReserve = (i16)nReserve;
42834     pagerReportSize(pPager);
42835   }
42836   return rc;
42837 }
42838
42839 /*
42840 ** Return a pointer to the "temporary page" buffer held internally
42841 ** by the pager.  This is a buffer that is big enough to hold the
42842 ** entire content of a database page.  This buffer is used internally
42843 ** during rollback and will be overwritten whenever a rollback
42844 ** occurs.  But other modules are free to use it too, as long as
42845 ** no rollbacks are happening.
42846 */
42847 SQLCIPHER_PRIVATE void *sqlcipher3PagerTempSpace(Pager *pPager){
42848   return pPager->pTmpSpace;
42849 }
42850
42851 /*
42852 ** Attempt to set the maximum database page count if mxPage is positive. 
42853 ** Make no changes if mxPage is zero or negative.  And never reduce the
42854 ** maximum page count below the current size of the database.
42855 **
42856 ** Regardless of mxPage, return the current maximum page count.
42857 */
42858 SQLCIPHER_PRIVATE int sqlcipher3PagerMaxPageCount(Pager *pPager, int mxPage){
42859   if( mxPage>0 ){
42860     pPager->mxPgno = mxPage;
42861   }
42862   assert( pPager->eState!=PAGER_OPEN );      /* Called only by OP_MaxPgcnt */
42863   assert( pPager->mxPgno>=pPager->dbSize );  /* OP_MaxPgcnt enforces this */
42864   return pPager->mxPgno;
42865 }
42866
42867 /*
42868 ** The following set of routines are used to disable the simulated
42869 ** I/O error mechanism.  These routines are used to avoid simulated
42870 ** errors in places where we do not care about errors.
42871 **
42872 ** Unless -DSQLCIPHER_TEST=1 is used, these routines are all no-ops
42873 ** and generate no code.
42874 */
42875 #ifdef SQLCIPHER_TEST
42876 SQLCIPHER_API extern int sqlcipher3_io_error_pending;
42877 SQLCIPHER_API extern int sqlcipher3_io_error_hit;
42878 static int saved_cnt;
42879 void disable_simulated_io_errors(void){
42880   saved_cnt = sqlcipher3_io_error_pending;
42881   sqlcipher3_io_error_pending = -1;
42882 }
42883 void enable_simulated_io_errors(void){
42884   sqlcipher3_io_error_pending = saved_cnt;
42885 }
42886 #else
42887 # define disable_simulated_io_errors()
42888 # define enable_simulated_io_errors()
42889 #endif
42890
42891 /*
42892 ** Read the first N bytes from the beginning of the file into memory
42893 ** that pDest points to. 
42894 **
42895 ** If the pager was opened on a transient file (zFilename==""), or
42896 ** opened on a file less than N bytes in size, the output buffer is
42897 ** zeroed and SQLCIPHER_OK returned. The rationale for this is that this 
42898 ** function is used to read database headers, and a new transient or
42899 ** zero sized database has a header than consists entirely of zeroes.
42900 **
42901 ** If any IO error apart from SQLCIPHER_IOERR_SHORT_READ is encountered,
42902 ** the error code is returned to the caller and the contents of the
42903 ** output buffer undefined.
42904 */
42905 SQLCIPHER_PRIVATE int sqlcipher3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
42906   int rc = SQLCIPHER_OK;
42907   memset(pDest, 0, N);
42908   assert( isOpen(pPager->fd) || pPager->tempFile );
42909
42910   /* This routine is only called by btree immediately after creating
42911   ** the Pager object.  There has not been an opportunity to transition
42912   ** to WAL mode yet.
42913   */
42914   assert( !pagerUseWal(pPager) );
42915
42916   if( isOpen(pPager->fd) ){
42917     IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
42918     rc = sqlcipher3OsRead(pPager->fd, pDest, N, 0);
42919     if( rc==SQLCIPHER_IOERR_SHORT_READ ){
42920       rc = SQLCIPHER_OK;
42921     }
42922   }
42923   return rc;
42924 }
42925
42926 /*
42927 ** This function may only be called when a read-transaction is open on
42928 ** the pager. It returns the total number of pages in the database.
42929 **
42930 ** However, if the file is between 1 and <page-size> bytes in size, then 
42931 ** this is considered a 1 page file.
42932 */
42933 SQLCIPHER_PRIVATE void sqlcipher3PagerPagecount(Pager *pPager, int *pnPage){
42934   assert( pPager->eState>=PAGER_READER );
42935   assert( pPager->eState!=PAGER_WRITER_FINISHED );
42936   *pnPage = (int)pPager->dbSize;
42937 }
42938
42939
42940 /*
42941 ** Try to obtain a lock of type locktype on the database file. If
42942 ** a similar or greater lock is already held, this function is a no-op
42943 ** (returning SQLCIPHER_OK immediately).
42944 **
42945 ** Otherwise, attempt to obtain the lock using sqlcipher3OsLock(). Invoke 
42946 ** the busy callback if the lock is currently not available. Repeat 
42947 ** until the busy callback returns false or until the attempt to 
42948 ** obtain the lock succeeds.
42949 **
42950 ** Return SQLCIPHER_OK on success and an error code if we cannot obtain
42951 ** the lock. If the lock is obtained successfully, set the Pager.state 
42952 ** variable to locktype before returning.
42953 */
42954 static int pager_wait_on_lock(Pager *pPager, int locktype){
42955   int rc;                              /* Return code */
42956
42957   /* Check that this is either a no-op (because the requested lock is 
42958   ** already held, or one of the transistions that the busy-handler
42959   ** may be invoked during, according to the comment above
42960   ** sqlcipher3PagerSetBusyhandler().
42961   */
42962   assert( (pPager->eLock>=locktype)
42963        || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
42964        || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
42965   );
42966
42967   do {
42968     rc = pagerLockDb(pPager, locktype);
42969   }while( rc==SQLCIPHER_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
42970   return rc;
42971 }
42972
42973 /*
42974 ** Function assertTruncateConstraint(pPager) checks that one of the 
42975 ** following is true for all dirty pages currently in the page-cache:
42976 **
42977 **   a) The page number is less than or equal to the size of the 
42978 **      current database image, in pages, OR
42979 **
42980 **   b) if the page content were written at this time, it would not
42981 **      be necessary to write the current content out to the sub-journal
42982 **      (as determined by function subjRequiresPage()).
42983 **
42984 ** If the condition asserted by this function were not true, and the
42985 ** dirty page were to be discarded from the cache via the pagerStress()
42986 ** routine, pagerStress() would not write the current page content to
42987 ** the database file. If a savepoint transaction were rolled back after
42988 ** this happened, the correct behaviour would be to restore the current
42989 ** content of the page. However, since this content is not present in either
42990 ** the database file or the portion of the rollback journal and 
42991 ** sub-journal rolled back the content could not be restored and the
42992 ** database image would become corrupt. It is therefore fortunate that 
42993 ** this circumstance cannot arise.
42994 */
42995 #if defined(SQLCIPHER_DEBUG)
42996 static void assertTruncateConstraintCb(PgHdr *pPg){
42997   assert( pPg->flags&PGHDR_DIRTY );
42998   assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
42999 }
43000 static void assertTruncateConstraint(Pager *pPager){
43001   sqlcipher3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
43002 }
43003 #else
43004 # define assertTruncateConstraint(pPager)
43005 #endif
43006
43007 /*
43008 ** Truncate the in-memory database file image to nPage pages. This 
43009 ** function does not actually modify the database file on disk. It 
43010 ** just sets the internal state of the pager object so that the 
43011 ** truncation will be done when the current transaction is committed.
43012 */
43013 SQLCIPHER_PRIVATE void sqlcipher3PagerTruncateImage(Pager *pPager, Pgno nPage){
43014   assert( pPager->dbSize>=nPage );
43015   assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
43016   pPager->dbSize = nPage;
43017   assertTruncateConstraint(pPager);
43018 }
43019
43020
43021 /*
43022 ** This function is called before attempting a hot-journal rollback. It
43023 ** syncs the journal file to disk, then sets pPager->journalHdr to the
43024 ** size of the journal file so that the pager_playback() routine knows
43025 ** that the entire journal file has been synced.
43026 **
43027 ** Syncing a hot-journal to disk before attempting to roll it back ensures 
43028 ** that if a power-failure occurs during the rollback, the process that
43029 ** attempts rollback following system recovery sees the same journal
43030 ** content as this process.
43031 **
43032 ** If everything goes as planned, SQLCIPHER_OK is returned. Otherwise, 
43033 ** an SQLite error code.
43034 */
43035 static int pagerSyncHotJournal(Pager *pPager){
43036   int rc = SQLCIPHER_OK;
43037   if( !pPager->noSync ){
43038     rc = sqlcipher3OsSync(pPager->jfd, SQLCIPHER_SYNC_NORMAL);
43039   }
43040   if( rc==SQLCIPHER_OK ){
43041     rc = sqlcipher3OsFileSize(pPager->jfd, &pPager->journalHdr);
43042   }
43043   return rc;
43044 }
43045
43046 /*
43047 ** Shutdown the page cache.  Free all memory and close all files.
43048 **
43049 ** If a transaction was in progress when this routine is called, that
43050 ** transaction is rolled back.  All outstanding pages are invalidated
43051 ** and their memory is freed.  Any attempt to use a page associated
43052 ** with this page cache after this function returns will likely
43053 ** result in a coredump.
43054 **
43055 ** This function always succeeds. If a transaction is active an attempt
43056 ** is made to roll it back. If an error occurs during the rollback 
43057 ** a hot journal may be left in the filesystem but no error is returned
43058 ** to the caller.
43059 */
43060 SQLCIPHER_PRIVATE int sqlcipher3PagerClose(Pager *pPager){
43061   u8 *pTmp = (u8 *)pPager->pTmpSpace;
43062
43063   assert( assert_pager_state(pPager) );
43064   disable_simulated_io_errors();
43065   sqlcipher3BeginBenignMalloc();
43066   /* pPager->errCode = 0; */
43067   pPager->exclusiveMode = 0;
43068 #ifndef SQLCIPHER_OMIT_WAL
43069   sqlcipher3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
43070   pPager->pWal = 0;
43071 #endif
43072   pager_reset(pPager);
43073   if( MEMDB ){
43074     pager_unlock(pPager);
43075   }else{
43076     /* If it is open, sync the journal file before calling UnlockAndRollback.
43077     ** If this is not done, then an unsynced portion of the open journal 
43078     ** file may be played back into the database. If a power failure occurs 
43079     ** while this is happening, the database could become corrupt.
43080     **
43081     ** If an error occurs while trying to sync the journal, shift the pager
43082     ** into the ERROR state. This causes UnlockAndRollback to unlock the
43083     ** database and close the journal file without attempting to roll it
43084     ** back or finalize it. The next database user will have to do hot-journal
43085     ** rollback before accessing the database file.
43086     */
43087     if( isOpen(pPager->jfd) ){
43088       pager_error(pPager, pagerSyncHotJournal(pPager));
43089     }
43090     pagerUnlockAndRollback(pPager);
43091   }
43092   sqlcipher3EndBenignMalloc();
43093   enable_simulated_io_errors();
43094   PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
43095   IOTRACE(("CLOSE %p\n", pPager))
43096   sqlcipher3OsClose(pPager->jfd);
43097   sqlcipher3OsClose(pPager->fd);
43098   sqlcipher3PageFree(pTmp);
43099   sqlcipher3PcacheClose(pPager->pPCache);
43100
43101 #ifdef SQLCIPHER_HAS_CODEC
43102   if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
43103 #endif
43104
43105   assert( !pPager->aSavepoint && !pPager->pInJournal );
43106   assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
43107
43108   sqlcipher3_free(pPager);
43109   return SQLCIPHER_OK;
43110 }
43111
43112 #if !defined(NDEBUG) || defined(SQLCIPHER_TEST)
43113 /*
43114 ** Return the page number for page pPg.
43115 */
43116 SQLCIPHER_PRIVATE Pgno sqlcipher3PagerPagenumber(DbPage *pPg){
43117   return pPg->pgno;
43118 }
43119 #endif
43120
43121 /*
43122 ** Increment the reference count for page pPg.
43123 */
43124 SQLCIPHER_PRIVATE void sqlcipher3PagerRef(DbPage *pPg){
43125   sqlcipher3PcacheRef(pPg);
43126 }
43127
43128 /*
43129 ** Sync the journal. In other words, make sure all the pages that have
43130 ** been written to the journal have actually reached the surface of the
43131 ** disk and can be restored in the event of a hot-journal rollback.
43132 **
43133 ** If the Pager.noSync flag is set, then this function is a no-op.
43134 ** Otherwise, the actions required depend on the journal-mode and the 
43135 ** device characteristics of the the file-system, as follows:
43136 **
43137 **   * If the journal file is an in-memory journal file, no action need
43138 **     be taken.
43139 **
43140 **   * Otherwise, if the device does not support the SAFE_APPEND property,
43141 **     then the nRec field of the most recently written journal header
43142 **     is updated to contain the number of journal records that have
43143 **     been written following it. If the pager is operating in full-sync
43144 **     mode, then the journal file is synced before this field is updated.
43145 **
43146 **   * If the device does not support the SEQUENTIAL property, then 
43147 **     journal file is synced.
43148 **
43149 ** Or, in pseudo-code:
43150 **
43151 **   if( NOT <in-memory journal> ){
43152 **     if( NOT SAFE_APPEND ){
43153 **       if( <full-sync mode> ) xSync(<journal file>);
43154 **       <update nRec field>
43155 **     } 
43156 **     if( NOT SEQUENTIAL ) xSync(<journal file>);
43157 **   }
43158 **
43159 ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every 
43160 ** page currently held in memory before returning SQLCIPHER_OK. If an IO
43161 ** error is encountered, then the IO error code is returned to the caller.
43162 */
43163 static int syncJournal(Pager *pPager, int newHdr){
43164   int rc;                         /* Return code */
43165
43166   assert( pPager->eState==PAGER_WRITER_CACHEMOD
43167        || pPager->eState==PAGER_WRITER_DBMOD
43168   );
43169   assert( assert_pager_state(pPager) );
43170   assert( !pagerUseWal(pPager) );
43171
43172   rc = sqlcipher3PagerExclusiveLock(pPager);
43173   if( rc!=SQLCIPHER_OK ) return rc;
43174
43175   if( !pPager->noSync ){
43176     assert( !pPager->tempFile );
43177     if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
43178       const int iDc = sqlcipher3OsDeviceCharacteristics(pPager->fd);
43179       assert( isOpen(pPager->jfd) );
43180
43181       if( 0==(iDc&SQLCIPHER_IOCAP_SAFE_APPEND) ){
43182         /* This block deals with an obscure problem. If the last connection
43183         ** that wrote to this database was operating in persistent-journal
43184         ** mode, then the journal file may at this point actually be larger
43185         ** than Pager.journalOff bytes. If the next thing in the journal
43186         ** file happens to be a journal-header (written as part of the
43187         ** previous connection's transaction), and a crash or power-failure 
43188         ** occurs after nRec is updated but before this connection writes 
43189         ** anything else to the journal file (or commits/rolls back its 
43190         ** transaction), then SQLite may become confused when doing the 
43191         ** hot-journal rollback following recovery. It may roll back all
43192         ** of this connections data, then proceed to rolling back the old,
43193         ** out-of-date data that follows it. Database corruption.
43194         **
43195         ** To work around this, if the journal file does appear to contain
43196         ** a valid header following Pager.journalOff, then write a 0x00
43197         ** byte to the start of it to prevent it from being recognized.
43198         **
43199         ** Variable iNextHdrOffset is set to the offset at which this
43200         ** problematic header will occur, if it exists. aMagic is used 
43201         ** as a temporary buffer to inspect the first couple of bytes of
43202         ** the potential journal header.
43203         */
43204         i64 iNextHdrOffset;
43205         u8 aMagic[8];
43206         u8 zHeader[sizeof(aJournalMagic)+4];
43207
43208         memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
43209         put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
43210
43211         iNextHdrOffset = journalHdrOffset(pPager);
43212         rc = sqlcipher3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
43213         if( rc==SQLCIPHER_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
43214           static const u8 zerobyte = 0;
43215           rc = sqlcipher3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
43216         }
43217         if( rc!=SQLCIPHER_OK && rc!=SQLCIPHER_IOERR_SHORT_READ ){
43218           return rc;
43219         }
43220
43221         /* Write the nRec value into the journal file header. If in
43222         ** full-synchronous mode, sync the journal first. This ensures that
43223         ** all data has really hit the disk before nRec is updated to mark
43224         ** it as a candidate for rollback.
43225         **
43226         ** This is not required if the persistent media supports the
43227         ** SAFE_APPEND property. Because in this case it is not possible 
43228         ** for garbage data to be appended to the file, the nRec field
43229         ** is populated with 0xFFFFFFFF when the journal header is written
43230         ** and never needs to be updated.
43231         */
43232         if( pPager->fullSync && 0==(iDc&SQLCIPHER_IOCAP_SEQUENTIAL) ){
43233           PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
43234           IOTRACE(("JSYNC %p\n", pPager))
43235           rc = sqlcipher3OsSync(pPager->jfd, pPager->syncFlags);
43236           if( rc!=SQLCIPHER_OK ) return rc;
43237         }
43238         IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
43239         rc = sqlcipher3OsWrite(
43240             pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
43241         );
43242         if( rc!=SQLCIPHER_OK ) return rc;
43243       }
43244       if( 0==(iDc&SQLCIPHER_IOCAP_SEQUENTIAL) ){
43245         PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
43246         IOTRACE(("JSYNC %p\n", pPager))
43247         rc = sqlcipher3OsSync(pPager->jfd, pPager->syncFlags| 
43248           (pPager->syncFlags==SQLCIPHER_SYNC_FULL?SQLCIPHER_SYNC_DATAONLY:0)
43249         );
43250         if( rc!=SQLCIPHER_OK ) return rc;
43251       }
43252
43253       pPager->journalHdr = pPager->journalOff;
43254       if( newHdr && 0==(iDc&SQLCIPHER_IOCAP_SAFE_APPEND) ){
43255         pPager->nRec = 0;
43256         rc = writeJournalHdr(pPager);
43257         if( rc!=SQLCIPHER_OK ) return rc;
43258       }
43259     }else{
43260       pPager->journalHdr = pPager->journalOff;
43261     }
43262   }
43263
43264   /* Unless the pager is in noSync mode, the journal file was just 
43265   ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on 
43266   ** all pages.
43267   */
43268   sqlcipher3PcacheClearSyncFlags(pPager->pPCache);
43269   pPager->eState = PAGER_WRITER_DBMOD;
43270   assert( assert_pager_state(pPager) );
43271   return SQLCIPHER_OK;
43272 }
43273
43274 /*
43275 ** The argument is the first in a linked list of dirty pages connected
43276 ** by the PgHdr.pDirty pointer. This function writes each one of the
43277 ** in-memory pages in the list to the database file. The argument may
43278 ** be NULL, representing an empty list. In this case this function is
43279 ** a no-op.
43280 **
43281 ** The pager must hold at least a RESERVED lock when this function
43282 ** is called. Before writing anything to the database file, this lock
43283 ** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
43284 ** SQLCIPHER_BUSY is returned and no data is written to the database file.
43285 ** 
43286 ** If the pager is a temp-file pager and the actual file-system file
43287 ** is not yet open, it is created and opened before any data is 
43288 ** written out.
43289 **
43290 ** Once the lock has been upgraded and, if necessary, the file opened,
43291 ** the pages are written out to the database file in list order. Writing
43292 ** a page is skipped if it meets either of the following criteria:
43293 **
43294 **   * The page number is greater than Pager.dbSize, or
43295 **   * The PGHDR_DONT_WRITE flag is set on the page.
43296 **
43297 ** If writing out a page causes the database file to grow, Pager.dbFileSize
43298 ** is updated accordingly. If page 1 is written out, then the value cached
43299 ** in Pager.dbFileVers[] is updated to match the new value stored in
43300 ** the database file.
43301 **
43302 ** If everything is successful, SQLCIPHER_OK is returned. If an IO error 
43303 ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
43304 ** be obtained, SQLCIPHER_BUSY is returned.
43305 */
43306 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
43307   int rc = SQLCIPHER_OK;                  /* Return code */
43308
43309   /* This function is only called for rollback pagers in WRITER_DBMOD state. */
43310   assert( !pagerUseWal(pPager) );
43311   assert( pPager->eState==PAGER_WRITER_DBMOD );
43312   assert( pPager->eLock==EXCLUSIVE_LOCK );
43313
43314   /* If the file is a temp-file has not yet been opened, open it now. It
43315   ** is not possible for rc to be other than SQLCIPHER_OK if this branch
43316   ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
43317   */
43318   if( !isOpen(pPager->fd) ){
43319     assert( pPager->tempFile && rc==SQLCIPHER_OK );
43320     rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
43321   }
43322
43323   /* Before the first write, give the VFS a hint of what the final
43324   ** file size will be.
43325   */
43326   assert( rc!=SQLCIPHER_OK || isOpen(pPager->fd) );
43327   if( rc==SQLCIPHER_OK && pPager->dbSize>pPager->dbHintSize ){
43328     sqlcipher3_int64 szFile = pPager->pageSize * (sqlcipher3_int64)pPager->dbSize;
43329     sqlcipher3OsFileControl(pPager->fd, SQLCIPHER_FCNTL_SIZE_HINT, &szFile);
43330     pPager->dbHintSize = pPager->dbSize;
43331   }
43332
43333   while( rc==SQLCIPHER_OK && pList ){
43334     Pgno pgno = pList->pgno;
43335
43336     /* If there are dirty pages in the page cache with page numbers greater
43337     ** than Pager.dbSize, this means sqlcipher3PagerTruncateImage() was called to
43338     ** make the file smaller (presumably by auto-vacuum code). Do not write
43339     ** any such pages to the file.
43340     **
43341     ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
43342     ** set (set by sqlcipher3PagerDontWrite()).
43343     */
43344     if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
43345       i64 offset = (pgno-1)*(i64)pPager->pageSize;   /* Offset to write */
43346       char *pData;                                   /* Data to write */    
43347
43348       assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
43349       if( pList->pgno==1 ) pager_write_changecounter(pList);
43350
43351       /* Encode the database */
43352       CODEC2(pPager, pList->pData, pgno, 6, return SQLCIPHER_NOMEM, pData);
43353
43354       /* Write out the page data. */
43355       rc = sqlcipher3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
43356
43357       /* If page 1 was just written, update Pager.dbFileVers to match
43358       ** the value now stored in the database file. If writing this 
43359       ** page caused the database file to grow, update dbFileSize. 
43360       */
43361       if( pgno==1 ){
43362         memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
43363       }
43364       if( pgno>pPager->dbFileSize ){
43365         pPager->dbFileSize = pgno;
43366       }
43367
43368       /* Update any backup objects copying the contents of this pager. */
43369       sqlcipher3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
43370
43371       PAGERTRACE(("STORE %d page %d hash(%08x)\n",
43372                    PAGERID(pPager), pgno, pager_pagehash(pList)));
43373       IOTRACE(("PGOUT %p %d\n", pPager, pgno));
43374       PAGER_INCR(sqlcipher3_pager_writedb_count);
43375       PAGER_INCR(pPager->nWrite);
43376     }else{
43377       PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
43378     }
43379     pager_set_pagehash(pList);
43380     pList = pList->pDirty;
43381   }
43382
43383   return rc;
43384 }
43385
43386 /*
43387 ** Ensure that the sub-journal file is open. If it is already open, this 
43388 ** function is a no-op.
43389 **
43390 ** SQLCIPHER_OK is returned if everything goes according to plan. An 
43391 ** SQLCIPHER_IOERR_XXX error code is returned if a call to sqlcipher3OsOpen() 
43392 ** fails.
43393 */
43394 static int openSubJournal(Pager *pPager){
43395   int rc = SQLCIPHER_OK;
43396   if( !isOpen(pPager->sjfd) ){
43397     if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
43398       sqlcipher3MemJournalOpen(pPager->sjfd);
43399     }else{
43400       rc = pagerOpentemp(pPager, pPager->sjfd, SQLCIPHER_OPEN_SUBJOURNAL);
43401     }
43402   }
43403   return rc;
43404 }
43405
43406 /*
43407 ** Append a record of the current state of page pPg to the sub-journal. 
43408 ** It is the callers responsibility to use subjRequiresPage() to check 
43409 ** that it is really required before calling this function.
43410 **
43411 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
43412 ** for all open savepoints before returning.
43413 **
43414 ** This function returns SQLCIPHER_OK if everything is successful, an IO
43415 ** error code if the attempt to write to the sub-journal fails, or 
43416 ** SQLCIPHER_NOMEM if a malloc fails while setting a bit in a savepoint
43417 ** bitvec.
43418 */
43419 static int subjournalPage(PgHdr *pPg){
43420   int rc = SQLCIPHER_OK;
43421   Pager *pPager = pPg->pPager;
43422   if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
43423
43424     /* Open the sub-journal, if it has not already been opened */
43425     assert( pPager->useJournal );
43426     assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
43427     assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
43428     assert( pagerUseWal(pPager) 
43429          || pageInJournal(pPg) 
43430          || pPg->pgno>pPager->dbOrigSize 
43431     );
43432     rc = openSubJournal(pPager);
43433
43434     /* If the sub-journal was opened successfully (or was already open),
43435     ** write the journal record into the file.  */
43436     if( rc==SQLCIPHER_OK ){
43437       void *pData = pPg->pData;
43438       i64 offset = pPager->nSubRec*(4+pPager->pageSize);
43439       char *pData2;
43440   
43441       CODEC2(pPager, pData, pPg->pgno, 7, return SQLCIPHER_NOMEM, pData2);
43442       PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
43443       rc = write32bits(pPager->sjfd, offset, pPg->pgno);
43444       if( rc==SQLCIPHER_OK ){
43445         rc = sqlcipher3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
43446       }
43447     }
43448   }
43449   if( rc==SQLCIPHER_OK ){
43450     pPager->nSubRec++;
43451     assert( pPager->nSavepoint>0 );
43452     rc = addToSavepointBitvecs(pPager, pPg->pgno);
43453   }
43454   return rc;
43455 }
43456
43457 /*
43458 ** This function is called by the pcache layer when it has reached some
43459 ** soft memory limit. The first argument is a pointer to a Pager object
43460 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
43461 ** database). The second argument is a reference to a page that is 
43462 ** currently dirty but has no outstanding references. The page
43463 ** is always associated with the Pager object passed as the first 
43464 ** argument.
43465 **
43466 ** The job of this function is to make pPg clean by writing its contents
43467 ** out to the database file, if possible. This may involve syncing the
43468 ** journal file. 
43469 **
43470 ** If successful, sqlcipher3PcacheMakeClean() is called on the page and
43471 ** SQLCIPHER_OK returned. If an IO error occurs while trying to make the
43472 ** page clean, the IO error code is returned. If the page cannot be
43473 ** made clean for some other reason, but no error occurs, then SQLCIPHER_OK
43474 ** is returned by sqlcipher3PcacheMakeClean() is not called.
43475 */
43476 static int pagerStress(void *p, PgHdr *pPg){
43477   Pager *pPager = (Pager *)p;
43478   int rc = SQLCIPHER_OK;
43479
43480   assert( pPg->pPager==pPager );
43481   assert( pPg->flags&PGHDR_DIRTY );
43482
43483   /* The doNotSyncSpill flag is set during times when doing a sync of
43484   ** journal (and adding a new header) is not allowed.  This occurs
43485   ** during calls to sqlcipher3PagerWrite() while trying to journal multiple
43486   ** pages belonging to the same sector.
43487   **
43488   ** The doNotSpill flag inhibits all cache spilling regardless of whether
43489   ** or not a sync is required.  This is set during a rollback.
43490   **
43491   ** Spilling is also prohibited when in an error state since that could
43492   ** lead to database corruption.   In the current implementaton it 
43493   ** is impossible for sqlcipher3PcacheFetch() to be called with createFlag==1
43494   ** while in the error state, hence it is impossible for this routine to
43495   ** be called in the error state.  Nevertheless, we include a NEVER()
43496   ** test for the error state as a safeguard against future changes.
43497   */
43498   if( NEVER(pPager->errCode) ) return SQLCIPHER_OK;
43499   if( pPager->doNotSpill ) return SQLCIPHER_OK;
43500   if( pPager->doNotSyncSpill && (pPg->flags & PGHDR_NEED_SYNC)!=0 ){
43501     return SQLCIPHER_OK;
43502   }
43503
43504   pPg->pDirty = 0;
43505   if( pagerUseWal(pPager) ){
43506     /* Write a single frame for this page to the log. */
43507     if( subjRequiresPage(pPg) ){ 
43508       rc = subjournalPage(pPg); 
43509     }
43510     if( rc==SQLCIPHER_OK ){
43511       rc = pagerWalFrames(pPager, pPg, 0, 0, 0);
43512     }
43513   }else{
43514   
43515     /* Sync the journal file if required. */
43516     if( pPg->flags&PGHDR_NEED_SYNC 
43517      || pPager->eState==PAGER_WRITER_CACHEMOD
43518     ){
43519       rc = syncJournal(pPager, 1);
43520     }
43521   
43522     /* If the page number of this page is larger than the current size of
43523     ** the database image, it may need to be written to the sub-journal.
43524     ** This is because the call to pager_write_pagelist() below will not
43525     ** actually write data to the file in this case.
43526     **
43527     ** Consider the following sequence of events:
43528     **
43529     **   BEGIN;
43530     **     <journal page X>
43531     **     <modify page X>
43532     **     SAVEPOINT sp;
43533     **       <shrink database file to Y pages>
43534     **       pagerStress(page X)
43535     **     ROLLBACK TO sp;
43536     **
43537     ** If (X>Y), then when pagerStress is called page X will not be written
43538     ** out to the database file, but will be dropped from the cache. Then,
43539     ** following the "ROLLBACK TO sp" statement, reading page X will read
43540     ** data from the database file. This will be the copy of page X as it
43541     ** was when the transaction started, not as it was when "SAVEPOINT sp"
43542     ** was executed.
43543     **
43544     ** The solution is to write the current data for page X into the 
43545     ** sub-journal file now (if it is not already there), so that it will
43546     ** be restored to its current value when the "ROLLBACK TO sp" is 
43547     ** executed.
43548     */
43549     if( NEVER(
43550         rc==SQLCIPHER_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
43551     ) ){
43552       rc = subjournalPage(pPg);
43553     }
43554   
43555     /* Write the contents of the page out to the database file. */
43556     if( rc==SQLCIPHER_OK ){
43557       assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
43558       rc = pager_write_pagelist(pPager, pPg);
43559     }
43560   }
43561
43562   /* Mark the page as clean. */
43563   if( rc==SQLCIPHER_OK ){
43564     PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
43565     sqlcipher3PcacheMakeClean(pPg);
43566   }
43567
43568   return pager_error(pPager, rc); 
43569 }
43570
43571
43572 /*
43573 ** Allocate and initialize a new Pager object and put a pointer to it
43574 ** in *ppPager. The pager should eventually be freed by passing it
43575 ** to sqlcipher3PagerClose().
43576 **
43577 ** The zFilename argument is the path to the database file to open.
43578 ** If zFilename is NULL then a randomly-named temporary file is created
43579 ** and used as the file to be cached. Temporary files are be deleted
43580 ** automatically when they are closed. If zFilename is ":memory:" then 
43581 ** all information is held in cache. It is never written to disk. 
43582 ** This can be used to implement an in-memory database.
43583 **
43584 ** The nExtra parameter specifies the number of bytes of space allocated
43585 ** along with each page reference. This space is available to the user
43586 ** via the sqlcipher3PagerGetExtra() API.
43587 **
43588 ** The flags argument is used to specify properties that affect the
43589 ** operation of the pager. It should be passed some bitwise combination
43590 ** of the PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK flags.
43591 **
43592 ** The vfsFlags parameter is a bitmask to pass to the flags parameter
43593 ** of the xOpen() method of the supplied VFS when opening files. 
43594 **
43595 ** If the pager object is allocated and the specified file opened 
43596 ** successfully, SQLCIPHER_OK is returned and *ppPager set to point to
43597 ** the new pager object. If an error occurs, *ppPager is set to NULL
43598 ** and error code returned. This function may return SQLCIPHER_NOMEM
43599 ** (sqlcipher3Malloc() is used to allocate memory), SQLCIPHER_CANTOPEN or 
43600 ** various SQLCIPHER_IO_XXX errors.
43601 */
43602 SQLCIPHER_PRIVATE int sqlcipher3PagerOpen(
43603   sqlcipher3_vfs *pVfs,       /* The virtual file system to use */
43604   Pager **ppPager,         /* OUT: Return the Pager structure here */
43605   const char *zFilename,   /* Name of the database file to open */
43606   int nExtra,              /* Extra bytes append to each in-memory page */
43607   int flags,               /* flags controlling this file */
43608   int vfsFlags,            /* flags passed through to sqlcipher3_vfs.xOpen() */
43609   void (*xReinit)(DbPage*) /* Function to reinitialize pages */
43610 ){
43611   u8 *pPtr;
43612   Pager *pPager = 0;       /* Pager object to allocate and return */
43613   int rc = SQLCIPHER_OK;      /* Return code */
43614   int tempFile = 0;        /* True for temp files (incl. in-memory files) */
43615   int memDb = 0;           /* True if this is an in-memory file */
43616   int readOnly = 0;        /* True if this is a read-only file */
43617   int journalFileSize;     /* Bytes to allocate for each journal fd */
43618   char *zPathname = 0;     /* Full path to database file */
43619   int nPathname = 0;       /* Number of bytes in zPathname */
43620   int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
43621   int noReadlock = (flags & PAGER_NO_READLOCK)!=0;  /* True to omit read-lock */
43622   int pcacheSize = sqlcipher3PcacheSize();       /* Bytes to allocate for PCache */
43623   u32 szPageDflt = SQLCIPHER_DEFAULT_PAGE_SIZE;  /* Default page size */
43624   const char *zUri = 0;    /* URI args to copy */
43625   int nUri = 0;            /* Number of bytes of URI args at *zUri */
43626
43627   /* Figure out how much space is required for each journal file-handle
43628   ** (there are two of them, the main journal and the sub-journal). This
43629   ** is the maximum space required for an in-memory journal file handle 
43630   ** and a regular journal file-handle. Note that a "regular journal-handle"
43631   ** may be a wrapper capable of caching the first portion of the journal
43632   ** file in memory to implement the atomic-write optimization (see 
43633   ** source file journal.c).
43634   */
43635   if( sqlcipher3JournalSize(pVfs)>sqlcipher3MemJournalSize() ){
43636     journalFileSize = ROUND8(sqlcipher3JournalSize(pVfs));
43637   }else{
43638     journalFileSize = ROUND8(sqlcipher3MemJournalSize());
43639   }
43640
43641   /* Set the output variable to NULL in case an error occurs. */
43642   *ppPager = 0;
43643
43644 #ifndef SQLCIPHER_OMIT_MEMORYDB
43645   if( flags & PAGER_MEMORY ){
43646     memDb = 1;
43647     zFilename = 0;
43648   }
43649 #endif
43650
43651   /* Compute and store the full pathname in an allocated buffer pointed
43652   ** to by zPathname, length nPathname. Or, if this is a temporary file,
43653   ** leave both nPathname and zPathname set to 0.
43654   */
43655   if( zFilename && zFilename[0] ){
43656     const char *z;
43657     nPathname = pVfs->mxPathname+1;
43658     zPathname = sqlcipher3Malloc(nPathname*2);
43659     if( zPathname==0 ){
43660       return SQLCIPHER_NOMEM;
43661     }
43662     zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
43663     rc = sqlcipher3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
43664     nPathname = sqlcipher3Strlen30(zPathname);
43665     z = zUri = &zFilename[sqlcipher3Strlen30(zFilename)+1];
43666     while( *z ){
43667       z += sqlcipher3Strlen30(z)+1;
43668       z += sqlcipher3Strlen30(z)+1;
43669     }
43670     nUri = &z[1] - zUri;
43671     if( rc==SQLCIPHER_OK && nPathname+8>pVfs->mxPathname ){
43672       /* This branch is taken when the journal path required by
43673       ** the database being opened will be more than pVfs->mxPathname
43674       ** bytes in length. This means the database cannot be opened,
43675       ** as it will not be possible to open the journal file or even
43676       ** check for a hot-journal before reading.
43677       */
43678       rc = SQLCIPHER_CANTOPEN_BKPT;
43679     }
43680     if( rc!=SQLCIPHER_OK ){
43681       sqlcipher3_free(zPathname);
43682       return rc;
43683     }
43684   }
43685
43686   /* Allocate memory for the Pager structure, PCache object, the
43687   ** three file descriptors, the database file name and the journal 
43688   ** file name. The layout in memory is as follows:
43689   **
43690   **     Pager object                    (sizeof(Pager) bytes)
43691   **     PCache object                   (sqlcipher3PcacheSize() bytes)
43692   **     Database file handle            (pVfs->szOsFile bytes)
43693   **     Sub-journal file handle         (journalFileSize bytes)
43694   **     Main journal file handle        (journalFileSize bytes)
43695   **     Database file name              (nPathname+1 bytes)
43696   **     Journal file name               (nPathname+8+1 bytes)
43697   */
43698   pPtr = (u8 *)sqlcipher3MallocZero(
43699     ROUND8(sizeof(*pPager)) +      /* Pager structure */
43700     ROUND8(pcacheSize) +           /* PCache object */
43701     ROUND8(pVfs->szOsFile) +       /* The main db file */
43702     journalFileSize * 2 +          /* The two journal files */ 
43703     nPathname + 1 + nUri +         /* zFilename */
43704     nPathname + 8 + 1              /* zJournal */
43705 #ifndef SQLCIPHER_OMIT_WAL
43706     + nPathname + 4 + 1              /* zWal */
43707 #endif
43708   );
43709   assert( EIGHT_BYTE_ALIGNMENT(SQLCIPHER_INT_TO_PTR(journalFileSize)) );
43710   if( !pPtr ){
43711     sqlcipher3_free(zPathname);
43712     return SQLCIPHER_NOMEM;
43713   }
43714   pPager =              (Pager*)(pPtr);
43715   pPager->pPCache =    (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
43716   pPager->fd =   (sqlcipher3_file*)(pPtr += ROUND8(pcacheSize));
43717   pPager->sjfd = (sqlcipher3_file*)(pPtr += ROUND8(pVfs->szOsFile));
43718   pPager->jfd =  (sqlcipher3_file*)(pPtr += journalFileSize);
43719   pPager->zFilename =    (char*)(pPtr += journalFileSize);
43720   assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
43721
43722   /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
43723   if( zPathname ){
43724     assert( nPathname>0 );
43725     pPager->zJournal =   (char*)(pPtr += nPathname + 1 + nUri);
43726     memcpy(pPager->zFilename, zPathname, nPathname);
43727     memcpy(&pPager->zFilename[nPathname+1], zUri, nUri);
43728     memcpy(pPager->zJournal, zPathname, nPathname);
43729     memcpy(&pPager->zJournal[nPathname], "-journal", 8);
43730     sqlcipher3FileSuffix3(pPager->zFilename, pPager->zJournal);
43731 #ifndef SQLCIPHER_OMIT_WAL
43732     pPager->zWal = &pPager->zJournal[nPathname+8+1];
43733     memcpy(pPager->zWal, zPathname, nPathname);
43734     memcpy(&pPager->zWal[nPathname], "-wal", 4);
43735     sqlcipher3FileSuffix3(pPager->zFilename, pPager->zWal);
43736 #endif
43737     sqlcipher3_free(zPathname);
43738   }
43739   pPager->pVfs = pVfs;
43740   pPager->vfsFlags = vfsFlags;
43741
43742   /* Open the pager file.
43743   */
43744   if( zFilename && zFilename[0] ){
43745     int fout = 0;                    /* VFS flags returned by xOpen() */
43746     rc = sqlcipher3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
43747     assert( !memDb );
43748     readOnly = (fout&SQLCIPHER_OPEN_READONLY);
43749
43750     /* If the file was successfully opened for read/write access,
43751     ** choose a default page size in case we have to create the
43752     ** database file. The default page size is the maximum of:
43753     **
43754     **    + SQLCIPHER_DEFAULT_PAGE_SIZE,
43755     **    + The value returned by sqlcipher3OsSectorSize()
43756     **    + The largest page size that can be written atomically.
43757     */
43758     if( rc==SQLCIPHER_OK && !readOnly ){
43759       setSectorSize(pPager);
43760       assert(SQLCIPHER_DEFAULT_PAGE_SIZE<=SQLCIPHER_MAX_DEFAULT_PAGE_SIZE);
43761       if( szPageDflt<pPager->sectorSize ){
43762         if( pPager->sectorSize>SQLCIPHER_MAX_DEFAULT_PAGE_SIZE ){
43763           szPageDflt = SQLCIPHER_MAX_DEFAULT_PAGE_SIZE;
43764         }else{
43765           szPageDflt = (u32)pPager->sectorSize;
43766         }
43767       }
43768 #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
43769       {
43770         int iDc = sqlcipher3OsDeviceCharacteristics(pPager->fd);
43771         int ii;
43772         assert(SQLCIPHER_IOCAP_ATOMIC512==(512>>8));
43773         assert(SQLCIPHER_IOCAP_ATOMIC64K==(65536>>8));
43774         assert(SQLCIPHER_MAX_DEFAULT_PAGE_SIZE<=65536);
43775         for(ii=szPageDflt; ii<=SQLCIPHER_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
43776           if( iDc&(SQLCIPHER_IOCAP_ATOMIC|(ii>>8)) ){
43777             szPageDflt = ii;
43778           }
43779         }
43780       }
43781 #endif
43782     }
43783   }else{
43784     /* If a temporary file is requested, it is not opened immediately.
43785     ** In this case we accept the default page size and delay actually
43786     ** opening the file until the first call to OsWrite().
43787     **
43788     ** This branch is also run for an in-memory database. An in-memory
43789     ** database is the same as a temp-file that is never written out to
43790     ** disk and uses an in-memory rollback journal.
43791     */ 
43792     tempFile = 1;
43793     pPager->eState = PAGER_READER;
43794     pPager->eLock = EXCLUSIVE_LOCK;
43795     readOnly = (vfsFlags&SQLCIPHER_OPEN_READONLY);
43796   }
43797
43798   /* The following call to PagerSetPagesize() serves to set the value of 
43799   ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
43800   */
43801   if( rc==SQLCIPHER_OK ){
43802     assert( pPager->memDb==0 );
43803     rc = sqlcipher3PagerSetPagesize(pPager, &szPageDflt, -1);
43804     testcase( rc!=SQLCIPHER_OK );
43805   }
43806
43807   /* If an error occurred in either of the blocks above, free the 
43808   ** Pager structure and close the file.
43809   */
43810   if( rc!=SQLCIPHER_OK ){
43811     assert( !pPager->pTmpSpace );
43812     sqlcipher3OsClose(pPager->fd);
43813     sqlcipher3_free(pPager);
43814     return rc;
43815   }
43816
43817   /* Initialize the PCache object. */
43818   assert( nExtra<1000 );
43819   nExtra = ROUND8(nExtra);
43820   sqlcipher3PcacheOpen(szPageDflt, nExtra, !memDb,
43821                     !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
43822
43823   PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
43824   IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
43825
43826   pPager->useJournal = (u8)useJournal;
43827   pPager->noReadlock = (noReadlock && readOnly) ?1:0;
43828   /* pPager->stmtOpen = 0; */
43829   /* pPager->stmtInUse = 0; */
43830   /* pPager->nRef = 0; */
43831   /* pPager->stmtSize = 0; */
43832   /* pPager->stmtJSize = 0; */
43833   /* pPager->nPage = 0; */
43834   pPager->mxPgno = SQLCIPHER_MAX_PAGE_COUNT;
43835   /* pPager->state = PAGER_UNLOCK; */
43836 #if 0
43837   assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
43838 #endif
43839   /* pPager->errMask = 0; */
43840   pPager->tempFile = (u8)tempFile;
43841   assert( tempFile==PAGER_LOCKINGMODE_NORMAL 
43842           || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
43843   assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
43844   pPager->exclusiveMode = (u8)tempFile; 
43845   pPager->changeCountDone = pPager->tempFile;
43846   pPager->memDb = (u8)memDb;
43847   pPager->readOnly = (u8)readOnly;
43848   assert( useJournal || pPager->tempFile );
43849   pPager->noSync = pPager->tempFile;
43850   pPager->fullSync = pPager->noSync ?0:1;
43851   pPager->syncFlags = pPager->noSync ? 0 : SQLCIPHER_SYNC_NORMAL;
43852   pPager->ckptSyncFlags = pPager->syncFlags;
43853   /* pPager->pFirst = 0; */
43854   /* pPager->pFirstSynced = 0; */
43855   /* pPager->pLast = 0; */
43856   pPager->nExtra = (u16)nExtra;
43857   pPager->journalSizeLimit = SQLCIPHER_DEFAULT_JOURNAL_SIZE_LIMIT;
43858   assert( isOpen(pPager->fd) || tempFile );
43859   setSectorSize(pPager);
43860   if( !useJournal ){
43861     pPager->journalMode = PAGER_JOURNALMODE_OFF;
43862   }else if( memDb ){
43863     pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
43864   }
43865   /* pPager->xBusyHandler = 0; */
43866   /* pPager->pBusyHandlerArg = 0; */
43867   pPager->xReiniter = xReinit;
43868   /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
43869
43870   *ppPager = pPager;
43871   return SQLCIPHER_OK;
43872 }
43873
43874
43875
43876 /*
43877 ** This function is called after transitioning from PAGER_UNLOCK to
43878 ** PAGER_SHARED state. It tests if there is a hot journal present in
43879 ** the file-system for the given pager. A hot journal is one that 
43880 ** needs to be played back. According to this function, a hot-journal
43881 ** file exists if the following criteria are met:
43882 **
43883 **   * The journal file exists in the file system, and
43884 **   * No process holds a RESERVED or greater lock on the database file, and
43885 **   * The database file itself is greater than 0 bytes in size, and
43886 **   * The first byte of the journal file exists and is not 0x00.
43887 **
43888 ** If the current size of the database file is 0 but a journal file
43889 ** exists, that is probably an old journal left over from a prior
43890 ** database with the same name. In this case the journal file is
43891 ** just deleted using OsDelete, *pExists is set to 0 and SQLCIPHER_OK
43892 ** is returned.
43893 **
43894 ** This routine does not check if there is a master journal filename
43895 ** at the end of the file. If there is, and that master journal file
43896 ** does not exist, then the journal file is not really hot. In this
43897 ** case this routine will return a false-positive. The pager_playback()
43898 ** routine will discover that the journal file is not really hot and 
43899 ** will not roll it back. 
43900 **
43901 ** If a hot-journal file is found to exist, *pExists is set to 1 and 
43902 ** SQLCIPHER_OK returned. If no hot-journal file is present, *pExists is
43903 ** set to 0 and SQLCIPHER_OK returned. If an IO error occurs while trying
43904 ** to determine whether or not a hot-journal file exists, the IO error
43905 ** code is returned and the value of *pExists is undefined.
43906 */
43907 static int hasHotJournal(Pager *pPager, int *pExists){
43908   sqlcipher3_vfs * const pVfs = pPager->pVfs;
43909   int rc = SQLCIPHER_OK;           /* Return code */
43910   int exists = 1;               /* True if a journal file is present */
43911   int jrnlOpen = !!isOpen(pPager->jfd);
43912
43913   assert( pPager->useJournal );
43914   assert( isOpen(pPager->fd) );
43915   assert( pPager->eState==PAGER_OPEN );
43916
43917   assert( jrnlOpen==0 || ( sqlcipher3OsDeviceCharacteristics(pPager->jfd) &
43918     SQLCIPHER_IOCAP_UNDELETABLE_WHEN_OPEN
43919   ));
43920
43921   *pExists = 0;
43922   if( !jrnlOpen ){
43923     rc = sqlcipher3OsAccess(pVfs, pPager->zJournal, SQLCIPHER_ACCESS_EXISTS, &exists);
43924   }
43925   if( rc==SQLCIPHER_OK && exists ){
43926     int locked = 0;             /* True if some process holds a RESERVED lock */
43927
43928     /* Race condition here:  Another process might have been holding the
43929     ** the RESERVED lock and have a journal open at the sqlcipher3OsAccess() 
43930     ** call above, but then delete the journal and drop the lock before
43931     ** we get to the following sqlcipher3OsCheckReservedLock() call.  If that
43932     ** is the case, this routine might think there is a hot journal when
43933     ** in fact there is none.  This results in a false-positive which will
43934     ** be dealt with by the playback routine.  Ticket #3883.
43935     */
43936     rc = sqlcipher3OsCheckReservedLock(pPager->fd, &locked);
43937     if( rc==SQLCIPHER_OK && !locked ){
43938       Pgno nPage;                 /* Number of pages in database file */
43939
43940       /* Check the size of the database file. If it consists of 0 pages,
43941       ** then delete the journal file. See the header comment above for 
43942       ** the reasoning here.  Delete the obsolete journal file under
43943       ** a RESERVED lock to avoid race conditions and to avoid violating
43944       ** [H33020].
43945       */
43946       rc = pagerPagecount(pPager, &nPage);
43947       if( rc==SQLCIPHER_OK ){
43948         if( nPage==0 ){
43949           sqlcipher3BeginBenignMalloc();
43950           if( pagerLockDb(pPager, RESERVED_LOCK)==SQLCIPHER_OK ){
43951             sqlcipher3OsDelete(pVfs, pPager->zJournal, 0);
43952             if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
43953           }
43954           sqlcipher3EndBenignMalloc();
43955         }else{
43956           /* The journal file exists and no other connection has a reserved
43957           ** or greater lock on the database file. Now check that there is
43958           ** at least one non-zero bytes at the start of the journal file.
43959           ** If there is, then we consider this journal to be hot. If not, 
43960           ** it can be ignored.
43961           */
43962           if( !jrnlOpen ){
43963             int f = SQLCIPHER_OPEN_READONLY|SQLCIPHER_OPEN_MAIN_JOURNAL;
43964             rc = sqlcipher3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
43965           }
43966           if( rc==SQLCIPHER_OK ){
43967             u8 first = 0;
43968             rc = sqlcipher3OsRead(pPager->jfd, (void *)&first, 1, 0);
43969             if( rc==SQLCIPHER_IOERR_SHORT_READ ){
43970               rc = SQLCIPHER_OK;
43971             }
43972             if( !jrnlOpen ){
43973               sqlcipher3OsClose(pPager->jfd);
43974             }
43975             *pExists = (first!=0);
43976           }else if( rc==SQLCIPHER_CANTOPEN ){
43977             /* If we cannot open the rollback journal file in order to see if
43978             ** its has a zero header, that might be due to an I/O error, or
43979             ** it might be due to the race condition described above and in
43980             ** ticket #3883.  Either way, assume that the journal is hot.
43981             ** This might be a false positive.  But if it is, then the
43982             ** automatic journal playback and recovery mechanism will deal
43983             ** with it under an EXCLUSIVE lock where we do not need to
43984             ** worry so much with race conditions.
43985             */
43986             *pExists = 1;
43987             rc = SQLCIPHER_OK;
43988           }
43989         }
43990       }
43991     }
43992   }
43993
43994   return rc;
43995 }
43996
43997 /*
43998 ** This function is called to obtain a shared lock on the database file.
43999 ** It is illegal to call sqlcipher3PagerAcquire() until after this function
44000 ** has been successfully called. If a shared-lock is already held when
44001 ** this function is called, it is a no-op.
44002 **
44003 ** The following operations are also performed by this function.
44004 **
44005 **   1) If the pager is currently in PAGER_OPEN state (no lock held
44006 **      on the database file), then an attempt is made to obtain a
44007 **      SHARED lock on the database file. Immediately after obtaining
44008 **      the SHARED lock, the file-system is checked for a hot-journal,
44009 **      which is played back if present. Following any hot-journal 
44010 **      rollback, the contents of the cache are validated by checking
44011 **      the 'change-counter' field of the database file header and
44012 **      discarded if they are found to be invalid.
44013 **
44014 **   2) If the pager is running in exclusive-mode, and there are currently
44015 **      no outstanding references to any pages, and is in the error state,
44016 **      then an attempt is made to clear the error state by discarding
44017 **      the contents of the page cache and rolling back any open journal
44018 **      file.
44019 **
44020 ** If everything is successful, SQLCIPHER_OK is returned. If an IO error 
44021 ** occurs while locking the database, checking for a hot-journal file or 
44022 ** rolling back a journal file, the IO error code is returned.
44023 */
44024 SQLCIPHER_PRIVATE int sqlcipher3PagerSharedLock(Pager *pPager){
44025   int rc = SQLCIPHER_OK;                /* Return code */
44026
44027   /* This routine is only called from b-tree and only when there are no
44028   ** outstanding pages. This implies that the pager state should either
44029   ** be OPEN or READER. READER is only possible if the pager is or was in 
44030   ** exclusive access mode.
44031   */
44032   assert( sqlcipher3PcacheRefCount(pPager->pPCache)==0 );
44033   assert( assert_pager_state(pPager) );
44034   assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
44035   if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
44036
44037   if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
44038     int bHotJournal = 1;          /* True if there exists a hot journal-file */
44039
44040     assert( !MEMDB );
44041     assert( pPager->noReadlock==0 || pPager->readOnly );
44042
44043     if( pPager->noReadlock==0 ){
44044       rc = pager_wait_on_lock(pPager, SHARED_LOCK);
44045       if( rc!=SQLCIPHER_OK ){
44046         assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
44047         goto failed;
44048       }
44049     }
44050
44051     /* If a journal file exists, and there is no RESERVED lock on the
44052     ** database file, then it either needs to be played back or deleted.
44053     */
44054     if( pPager->eLock<=SHARED_LOCK ){
44055       rc = hasHotJournal(pPager, &bHotJournal);
44056     }
44057     if( rc!=SQLCIPHER_OK ){
44058       goto failed;
44059     }
44060     if( bHotJournal ){
44061       /* Get an EXCLUSIVE lock on the database file. At this point it is
44062       ** important that a RESERVED lock is not obtained on the way to the
44063       ** EXCLUSIVE lock. If it were, another process might open the
44064       ** database file, detect the RESERVED lock, and conclude that the
44065       ** database is safe to read while this process is still rolling the 
44066       ** hot-journal back.
44067       ** 
44068       ** Because the intermediate RESERVED lock is not requested, any
44069       ** other process attempting to access the database file will get to 
44070       ** this point in the code and fail to obtain its own EXCLUSIVE lock 
44071       ** on the database file.
44072       **
44073       ** Unless the pager is in locking_mode=exclusive mode, the lock is
44074       ** downgraded to SHARED_LOCK before this function returns.
44075       */
44076       rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
44077       if( rc!=SQLCIPHER_OK ){
44078         goto failed;
44079       }
44080  
44081       /* If it is not already open and the file exists on disk, open the 
44082       ** journal for read/write access. Write access is required because 
44083       ** in exclusive-access mode the file descriptor will be kept open 
44084       ** and possibly used for a transaction later on. Also, write-access 
44085       ** is usually required to finalize the journal in journal_mode=persist 
44086       ** mode (and also for journal_mode=truncate on some systems).
44087       **
44088       ** If the journal does not exist, it usually means that some 
44089       ** other connection managed to get in and roll it back before 
44090       ** this connection obtained the exclusive lock above. Or, it 
44091       ** may mean that the pager was in the error-state when this
44092       ** function was called and the journal file does not exist.
44093       */
44094       if( !isOpen(pPager->jfd) ){
44095         sqlcipher3_vfs * const pVfs = pPager->pVfs;
44096         int bExists;              /* True if journal file exists */
44097         rc = sqlcipher3OsAccess(
44098             pVfs, pPager->zJournal, SQLCIPHER_ACCESS_EXISTS, &bExists);
44099         if( rc==SQLCIPHER_OK && bExists ){
44100           int fout = 0;
44101           int f = SQLCIPHER_OPEN_READWRITE|SQLCIPHER_OPEN_MAIN_JOURNAL;
44102           assert( !pPager->tempFile );
44103           rc = sqlcipher3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
44104           assert( rc!=SQLCIPHER_OK || isOpen(pPager->jfd) );
44105           if( rc==SQLCIPHER_OK && fout&SQLCIPHER_OPEN_READONLY ){
44106             rc = SQLCIPHER_CANTOPEN_BKPT;
44107             sqlcipher3OsClose(pPager->jfd);
44108           }
44109         }
44110       }
44111  
44112       /* Playback and delete the journal.  Drop the database write
44113       ** lock and reacquire the read lock. Purge the cache before
44114       ** playing back the hot-journal so that we don't end up with
44115       ** an inconsistent cache.  Sync the hot journal before playing
44116       ** it back since the process that crashed and left the hot journal
44117       ** probably did not sync it and we are required to always sync
44118       ** the journal before playing it back.
44119       */
44120       if( isOpen(pPager->jfd) ){
44121         assert( rc==SQLCIPHER_OK );
44122         rc = pagerSyncHotJournal(pPager);
44123         if( rc==SQLCIPHER_OK ){
44124           rc = pager_playback(pPager, 1);
44125           pPager->eState = PAGER_OPEN;
44126         }
44127       }else if( !pPager->exclusiveMode ){
44128         pagerUnlockDb(pPager, SHARED_LOCK);
44129       }
44130
44131       if( rc!=SQLCIPHER_OK ){
44132         /* This branch is taken if an error occurs while trying to open
44133         ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
44134         ** pager_unlock() routine will be called before returning to unlock
44135         ** the file. If the unlock attempt fails, then Pager.eLock must be
44136         ** set to UNKNOWN_LOCK (see the comment above the #define for 
44137         ** UNKNOWN_LOCK above for an explanation). 
44138         **
44139         ** In order to get pager_unlock() to do this, set Pager.eState to
44140         ** PAGER_ERROR now. This is not actually counted as a transition
44141         ** to ERROR state in the state diagram at the top of this file,
44142         ** since we know that the same call to pager_unlock() will very
44143         ** shortly transition the pager object to the OPEN state. Calling
44144         ** assert_pager_state() would fail now, as it should not be possible
44145         ** to be in ERROR state when there are zero outstanding page 
44146         ** references.
44147         */
44148         pager_error(pPager, rc);
44149         goto failed;
44150       }
44151
44152       assert( pPager->eState==PAGER_OPEN );
44153       assert( (pPager->eLock==SHARED_LOCK)
44154            || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
44155       );
44156     }
44157
44158     if( !pPager->tempFile 
44159      && (pPager->pBackup || sqlcipher3PcachePagecount(pPager->pPCache)>0) 
44160     ){
44161       /* The shared-lock has just been acquired on the database file
44162       ** and there are already pages in the cache (from a previous
44163       ** read or write transaction).  Check to see if the database
44164       ** has been modified.  If the database has changed, flush the
44165       ** cache.
44166       **
44167       ** Database changes is detected by looking at 15 bytes beginning
44168       ** at offset 24 into the file.  The first 4 of these 16 bytes are
44169       ** a 32-bit counter that is incremented with each change.  The
44170       ** other bytes change randomly with each file change when
44171       ** a codec is in use.
44172       ** 
44173       ** There is a vanishingly small chance that a change will not be 
44174       ** detected.  The chance of an undetected change is so small that
44175       ** it can be neglected.
44176       */
44177       Pgno nPage = 0;
44178       char dbFileVers[sizeof(pPager->dbFileVers)];
44179
44180       rc = pagerPagecount(pPager, &nPage);
44181       if( rc ) goto failed;
44182
44183       if( nPage>0 ){
44184         IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
44185         rc = sqlcipher3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
44186         if( rc!=SQLCIPHER_OK ){
44187           goto failed;
44188         }
44189       }else{
44190         memset(dbFileVers, 0, sizeof(dbFileVers));
44191       }
44192
44193       if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
44194         pager_reset(pPager);
44195       }
44196     }
44197
44198     /* If there is a WAL file in the file-system, open this database in WAL
44199     ** mode. Otherwise, the following function call is a no-op.
44200     */
44201     rc = pagerOpenWalIfPresent(pPager);
44202 #ifndef SQLCIPHER_OMIT_WAL
44203     assert( pPager->pWal==0 || rc==SQLCIPHER_OK );
44204 #endif
44205   }
44206
44207   if( pagerUseWal(pPager) ){
44208     assert( rc==SQLCIPHER_OK );
44209     rc = pagerBeginReadTransaction(pPager);
44210   }
44211
44212   if( pPager->eState==PAGER_OPEN && rc==SQLCIPHER_OK ){
44213     rc = pagerPagecount(pPager, &pPager->dbSize);
44214   }
44215
44216  failed:
44217   if( rc!=SQLCIPHER_OK ){
44218     assert( !MEMDB );
44219     pager_unlock(pPager);
44220     assert( pPager->eState==PAGER_OPEN );
44221   }else{
44222     pPager->eState = PAGER_READER;
44223   }
44224   return rc;
44225 }
44226
44227 /*
44228 ** If the reference count has reached zero, rollback any active
44229 ** transaction and unlock the pager.
44230 **
44231 ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
44232 ** the rollback journal, the unlock is not performed and there is
44233 ** nothing to rollback, so this routine is a no-op.
44234 */ 
44235 static void pagerUnlockIfUnused(Pager *pPager){
44236   if( (sqlcipher3PcacheRefCount(pPager->pPCache)==0) ){
44237     pagerUnlockAndRollback(pPager);
44238   }
44239 }
44240
44241 /*
44242 ** Acquire a reference to page number pgno in pager pPager (a page
44243 ** reference has type DbPage*). If the requested reference is 
44244 ** successfully obtained, it is copied to *ppPage and SQLCIPHER_OK returned.
44245 **
44246 ** If the requested page is already in the cache, it is returned. 
44247 ** Otherwise, a new page object is allocated and populated with data
44248 ** read from the database file. In some cases, the pcache module may
44249 ** choose not to allocate a new page object and may reuse an existing
44250 ** object with no outstanding references.
44251 **
44252 ** The extra data appended to a page is always initialized to zeros the 
44253 ** first time a page is loaded into memory. If the page requested is 
44254 ** already in the cache when this function is called, then the extra
44255 ** data is left as it was when the page object was last used.
44256 **
44257 ** If the database image is smaller than the requested page or if a 
44258 ** non-zero value is passed as the noContent parameter and the 
44259 ** requested page is not already stored in the cache, then no 
44260 ** actual disk read occurs. In this case the memory image of the 
44261 ** page is initialized to all zeros. 
44262 **
44263 ** If noContent is true, it means that we do not care about the contents
44264 ** of the page. This occurs in two seperate scenarios:
44265 **
44266 **   a) When reading a free-list leaf page from the database, and
44267 **
44268 **   b) When a savepoint is being rolled back and we need to load
44269 **      a new page into the cache to be filled with the data read
44270 **      from the savepoint journal.
44271 **
44272 ** If noContent is true, then the data returned is zeroed instead of
44273 ** being read from the database. Additionally, the bits corresponding
44274 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
44275 ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
44276 ** savepoints are set. This means if the page is made writable at any
44277 ** point in the future, using a call to sqlcipher3PagerWrite(), its contents
44278 ** will not be journaled. This saves IO.
44279 **
44280 ** The acquisition might fail for several reasons.  In all cases,
44281 ** an appropriate error code is returned and *ppPage is set to NULL.
44282 **
44283 ** See also sqlcipher3PagerLookup().  Both this routine and Lookup() attempt
44284 ** to find a page in the in-memory cache first.  If the page is not already
44285 ** in memory, this routine goes to disk to read it in whereas Lookup()
44286 ** just returns 0.  This routine acquires a read-lock the first time it
44287 ** has to go to disk, and could also playback an old journal if necessary.
44288 ** Since Lookup() never goes to disk, it never has to deal with locks
44289 ** or journal files.
44290 */
44291 SQLCIPHER_PRIVATE int sqlcipher3PagerAcquire(
44292   Pager *pPager,      /* The pager open on the database file */
44293   Pgno pgno,          /* Page number to fetch */
44294   DbPage **ppPage,    /* Write a pointer to the page here */
44295   int noContent       /* Do not bother reading content from disk if true */
44296 ){
44297   int rc;
44298   PgHdr *pPg;
44299
44300   assert( pPager->eState>=PAGER_READER );
44301   assert( assert_pager_state(pPager) );
44302
44303   if( pgno==0 ){
44304     return SQLCIPHER_CORRUPT_BKPT;
44305   }
44306
44307   /* If the pager is in the error state, return an error immediately. 
44308   ** Otherwise, request the page from the PCache layer. */
44309   if( pPager->errCode!=SQLCIPHER_OK ){
44310     rc = pPager->errCode;
44311   }else{
44312     rc = sqlcipher3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
44313   }
44314
44315   if( rc!=SQLCIPHER_OK ){
44316     /* Either the call to sqlcipher3PcacheFetch() returned an error or the
44317     ** pager was already in the error-state when this function was called.
44318     ** Set pPg to 0 and jump to the exception handler.  */
44319     pPg = 0;
44320     goto pager_acquire_err;
44321   }
44322   assert( (*ppPage)->pgno==pgno );
44323   assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
44324
44325   if( (*ppPage)->pPager && !noContent ){
44326     /* In this case the pcache already contains an initialized copy of
44327     ** the page. Return without further ado.  */
44328     assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
44329     pPager->nHit++;
44330     return SQLCIPHER_OK;
44331
44332   }else{
44333     /* The pager cache has created a new page. Its content needs to 
44334     ** be initialized.  */
44335
44336     pPg = *ppPage;
44337     pPg->pPager = pPager;
44338
44339     /* The maximum page number is 2^31. Return SQLCIPHER_CORRUPT if a page
44340     ** number greater than this, or the unused locking-page, is requested. */
44341     if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
44342       rc = SQLCIPHER_CORRUPT_BKPT;
44343       goto pager_acquire_err;
44344     }
44345
44346     if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
44347       if( pgno>pPager->mxPgno ){
44348         rc = SQLCIPHER_FULL;
44349         goto pager_acquire_err;
44350       }
44351       if( noContent ){
44352         /* Failure to set the bits in the InJournal bit-vectors is benign.
44353         ** It merely means that we might do some extra work to journal a 
44354         ** page that does not need to be journaled.  Nevertheless, be sure 
44355         ** to test the case where a malloc error occurs while trying to set 
44356         ** a bit in a bit vector.
44357         */
44358         sqlcipher3BeginBenignMalloc();
44359         if( pgno<=pPager->dbOrigSize ){
44360           TESTONLY( rc = ) sqlcipher3BitvecSet(pPager->pInJournal, pgno);
44361           testcase( rc==SQLCIPHER_NOMEM );
44362         }
44363         TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
44364         testcase( rc==SQLCIPHER_NOMEM );
44365         sqlcipher3EndBenignMalloc();
44366       }
44367       memset(pPg->pData, 0, pPager->pageSize);
44368       IOTRACE(("ZERO %p %d\n", pPager, pgno));
44369     }else{
44370       assert( pPg->pPager==pPager );
44371       pPager->nMiss++;
44372       rc = readDbPage(pPg);
44373       if( rc!=SQLCIPHER_OK ){
44374         goto pager_acquire_err;
44375       }
44376     }
44377     pager_set_pagehash(pPg);
44378   }
44379
44380   return SQLCIPHER_OK;
44381
44382 pager_acquire_err:
44383   assert( rc!=SQLCIPHER_OK );
44384   if( pPg ){
44385     sqlcipher3PcacheDrop(pPg);
44386   }
44387   pagerUnlockIfUnused(pPager);
44388
44389   *ppPage = 0;
44390   return rc;
44391 }
44392
44393 /*
44394 ** Acquire a page if it is already in the in-memory cache.  Do
44395 ** not read the page from disk.  Return a pointer to the page,
44396 ** or 0 if the page is not in cache. 
44397 **
44398 ** See also sqlcipher3PagerGet().  The difference between this routine
44399 ** and sqlcipher3PagerGet() is that _get() will go to the disk and read
44400 ** in the page if the page is not already in cache.  This routine
44401 ** returns NULL if the page is not in cache or if a disk I/O error 
44402 ** has ever happened.
44403 */
44404 SQLCIPHER_PRIVATE DbPage *sqlcipher3PagerLookup(Pager *pPager, Pgno pgno){
44405   PgHdr *pPg = 0;
44406   assert( pPager!=0 );
44407   assert( pgno!=0 );
44408   assert( pPager->pPCache!=0 );
44409   assert( pPager->eState>=PAGER_READER && pPager->eState!=PAGER_ERROR );
44410   sqlcipher3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
44411   return pPg;
44412 }
44413
44414 /*
44415 ** Release a page reference.
44416 **
44417 ** If the number of references to the page drop to zero, then the
44418 ** page is added to the LRU list.  When all references to all pages
44419 ** are released, a rollback occurs and the lock on the database is
44420 ** removed.
44421 */
44422 SQLCIPHER_PRIVATE void sqlcipher3PagerUnref(DbPage *pPg){
44423   if( pPg ){
44424     Pager *pPager = pPg->pPager;
44425     sqlcipher3PcacheRelease(pPg);
44426     pagerUnlockIfUnused(pPager);
44427   }
44428 }
44429
44430 /*
44431 ** This function is called at the start of every write transaction.
44432 ** There must already be a RESERVED or EXCLUSIVE lock on the database 
44433 ** file when this routine is called.
44434 **
44435 ** Open the journal file for pager pPager and write a journal header
44436 ** to the start of it. If there are active savepoints, open the sub-journal
44437 ** as well. This function is only used when the journal file is being 
44438 ** opened to write a rollback log for a transaction. It is not used 
44439 ** when opening a hot journal file to roll it back.
44440 **
44441 ** If the journal file is already open (as it may be in exclusive mode),
44442 ** then this function just writes a journal header to the start of the
44443 ** already open file. 
44444 **
44445 ** Whether or not the journal file is opened by this function, the
44446 ** Pager.pInJournal bitvec structure is allocated.
44447 **
44448 ** Return SQLCIPHER_OK if everything is successful. Otherwise, return 
44449 ** SQLCIPHER_NOMEM if the attempt to allocate Pager.pInJournal fails, or 
44450 ** an IO error code if opening or writing the journal file fails.
44451 */
44452 static int pager_open_journal(Pager *pPager){
44453   int rc = SQLCIPHER_OK;                        /* Return code */
44454   sqlcipher3_vfs * const pVfs = pPager->pVfs;   /* Local cache of vfs pointer */
44455
44456   assert( pPager->eState==PAGER_WRITER_LOCKED );
44457   assert( assert_pager_state(pPager) );
44458   assert( pPager->pInJournal==0 );
44459   
44460   /* If already in the error state, this function is a no-op.  But on
44461   ** the other hand, this routine is never called if we are already in
44462   ** an error state. */
44463   if( NEVER(pPager->errCode) ) return pPager->errCode;
44464
44465   if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
44466     pPager->pInJournal = sqlcipher3BitvecCreate(pPager->dbSize);
44467     if( pPager->pInJournal==0 ){
44468       return SQLCIPHER_NOMEM;
44469     }
44470   
44471     /* Open the journal file if it is not already open. */
44472     if( !isOpen(pPager->jfd) ){
44473       if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
44474         sqlcipher3MemJournalOpen(pPager->jfd);
44475       }else{
44476         const int flags =                   /* VFS flags to open journal file */
44477           SQLCIPHER_OPEN_READWRITE|SQLCIPHER_OPEN_CREATE|
44478           (pPager->tempFile ? 
44479             (SQLCIPHER_OPEN_DELETEONCLOSE|SQLCIPHER_OPEN_TEMP_JOURNAL):
44480             (SQLCIPHER_OPEN_MAIN_JOURNAL)
44481           );
44482   #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
44483         rc = sqlcipher3JournalOpen(
44484             pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
44485         );
44486   #else
44487         rc = sqlcipher3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
44488   #endif
44489       }
44490       assert( rc!=SQLCIPHER_OK || isOpen(pPager->jfd) );
44491     }
44492   
44493   
44494     /* Write the first journal header to the journal file and open 
44495     ** the sub-journal if necessary.
44496     */
44497     if( rc==SQLCIPHER_OK ){
44498       /* TODO: Check if all of these are really required. */
44499       pPager->nRec = 0;
44500       pPager->journalOff = 0;
44501       pPager->setMaster = 0;
44502       pPager->journalHdr = 0;
44503       rc = writeJournalHdr(pPager);
44504     }
44505   }
44506
44507   if( rc!=SQLCIPHER_OK ){
44508     sqlcipher3BitvecDestroy(pPager->pInJournal);
44509     pPager->pInJournal = 0;
44510   }else{
44511     assert( pPager->eState==PAGER_WRITER_LOCKED );
44512     pPager->eState = PAGER_WRITER_CACHEMOD;
44513   }
44514
44515   return rc;
44516 }
44517
44518 /*
44519 ** Begin a write-transaction on the specified pager object. If a 
44520 ** write-transaction has already been opened, this function is a no-op.
44521 **
44522 ** If the exFlag argument is false, then acquire at least a RESERVED
44523 ** lock on the database file. If exFlag is true, then acquire at least
44524 ** an EXCLUSIVE lock. If such a lock is already held, no locking 
44525 ** functions need be called.
44526 **
44527 ** If the subjInMemory argument is non-zero, then any sub-journal opened
44528 ** within this transaction will be opened as an in-memory file. This
44529 ** has no effect if the sub-journal is already opened (as it may be when
44530 ** running in exclusive mode) or if the transaction does not require a
44531 ** sub-journal. If the subjInMemory argument is zero, then any required
44532 ** sub-journal is implemented in-memory if pPager is an in-memory database, 
44533 ** or using a temporary file otherwise.
44534 */
44535 SQLCIPHER_PRIVATE int sqlcipher3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
44536   int rc = SQLCIPHER_OK;
44537
44538   if( pPager->errCode ) return pPager->errCode;
44539   assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
44540   pPager->subjInMemory = (u8)subjInMemory;
44541
44542   if( ALWAYS(pPager->eState==PAGER_READER) ){
44543     assert( pPager->pInJournal==0 );
44544
44545     if( pagerUseWal(pPager) ){
44546       /* If the pager is configured to use locking_mode=exclusive, and an
44547       ** exclusive lock on the database is not already held, obtain it now.
44548       */
44549       if( pPager->exclusiveMode && sqlcipher3WalExclusiveMode(pPager->pWal, -1) ){
44550         rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
44551         if( rc!=SQLCIPHER_OK ){
44552           return rc;
44553         }
44554         sqlcipher3WalExclusiveMode(pPager->pWal, 1);
44555       }
44556
44557       /* Grab the write lock on the log file. If successful, upgrade to
44558       ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
44559       ** The busy-handler is not invoked if another connection already
44560       ** holds the write-lock. If possible, the upper layer will call it.
44561       */
44562       rc = sqlcipher3WalBeginWriteTransaction(pPager->pWal);
44563     }else{
44564       /* Obtain a RESERVED lock on the database file. If the exFlag parameter
44565       ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
44566       ** busy-handler callback can be used when upgrading to the EXCLUSIVE
44567       ** lock, but not when obtaining the RESERVED lock.
44568       */
44569       rc = pagerLockDb(pPager, RESERVED_LOCK);
44570       if( rc==SQLCIPHER_OK && exFlag ){
44571         rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
44572       }
44573     }
44574
44575     if( rc==SQLCIPHER_OK ){
44576       /* Change to WRITER_LOCKED state.
44577       **
44578       ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
44579       ** when it has an open transaction, but never to DBMOD or FINISHED.
44580       ** This is because in those states the code to roll back savepoint 
44581       ** transactions may copy data from the sub-journal into the database 
44582       ** file as well as into the page cache. Which would be incorrect in 
44583       ** WAL mode.
44584       */
44585       pPager->eState = PAGER_WRITER_LOCKED;
44586       pPager->dbHintSize = pPager->dbSize;
44587       pPager->dbFileSize = pPager->dbSize;
44588       pPager->dbOrigSize = pPager->dbSize;
44589       pPager->journalOff = 0;
44590     }
44591
44592     assert( rc==SQLCIPHER_OK || pPager->eState==PAGER_READER );
44593     assert( rc!=SQLCIPHER_OK || pPager->eState==PAGER_WRITER_LOCKED );
44594     assert( assert_pager_state(pPager) );
44595   }
44596
44597   PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
44598   return rc;
44599 }
44600
44601 /*
44602 ** Mark a single data page as writeable. The page is written into the 
44603 ** main journal or sub-journal as required. If the page is written into
44604 ** one of the journals, the corresponding bit is set in the 
44605 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
44606 ** of any open savepoints as appropriate.
44607 */
44608 static int pager_write(PgHdr *pPg){
44609   void *pData = pPg->pData;
44610   Pager *pPager = pPg->pPager;
44611   int rc = SQLCIPHER_OK;
44612
44613   /* This routine is not called unless a write-transaction has already 
44614   ** been started. The journal file may or may not be open at this point.
44615   ** It is never called in the ERROR state.
44616   */
44617   assert( pPager->eState==PAGER_WRITER_LOCKED
44618        || pPager->eState==PAGER_WRITER_CACHEMOD
44619        || pPager->eState==PAGER_WRITER_DBMOD
44620   );
44621   assert( assert_pager_state(pPager) );
44622
44623   /* If an error has been previously detected, report the same error
44624   ** again. This should not happen, but the check provides robustness. */
44625   if( NEVER(pPager->errCode) )  return pPager->errCode;
44626
44627   /* Higher-level routines never call this function if database is not
44628   ** writable.  But check anyway, just for robustness. */
44629   if( NEVER(pPager->readOnly) ) return SQLCIPHER_PERM;
44630
44631   CHECK_PAGE(pPg);
44632
44633   /* The journal file needs to be opened. Higher level routines have already
44634   ** obtained the necessary locks to begin the write-transaction, but the
44635   ** rollback journal might not yet be open. Open it now if this is the case.
44636   **
44637   ** This is done before calling sqlcipher3PcacheMakeDirty() on the page. 
44638   ** Otherwise, if it were done after calling sqlcipher3PcacheMakeDirty(), then
44639   ** an error might occur and the pager would end up in WRITER_LOCKED state
44640   ** with pages marked as dirty in the cache.
44641   */
44642   if( pPager->eState==PAGER_WRITER_LOCKED ){
44643     rc = pager_open_journal(pPager);
44644     if( rc!=SQLCIPHER_OK ) return rc;
44645   }
44646   assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
44647   assert( assert_pager_state(pPager) );
44648
44649   /* Mark the page as dirty.  If the page has already been written
44650   ** to the journal then we can return right away.
44651   */
44652   sqlcipher3PcacheMakeDirty(pPg);
44653   if( pageInJournal(pPg) && !subjRequiresPage(pPg) ){
44654     assert( !pagerUseWal(pPager) );
44655   }else{
44656   
44657     /* The transaction journal now exists and we have a RESERVED or an
44658     ** EXCLUSIVE lock on the main database file.  Write the current page to
44659     ** the transaction journal if it is not there already.
44660     */
44661     if( !pageInJournal(pPg) && !pagerUseWal(pPager) ){
44662       assert( pagerUseWal(pPager)==0 );
44663       if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
44664         u32 cksum;
44665         char *pData2;
44666         i64 iOff = pPager->journalOff;
44667
44668         /* We should never write to the journal file the page that
44669         ** contains the database locks.  The following assert verifies
44670         ** that we do not. */
44671         assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
44672
44673         assert( pPager->journalHdr<=pPager->journalOff );
44674         CODEC2(pPager, pData, pPg->pgno, 7, return SQLCIPHER_NOMEM, pData2);
44675         cksum = pager_cksum(pPager, (u8*)pData2);
44676
44677         /* Even if an IO or diskfull error occurs while journalling the
44678         ** page in the block above, set the need-sync flag for the page.
44679         ** Otherwise, when the transaction is rolled back, the logic in
44680         ** playback_one_page() will think that the page needs to be restored
44681         ** in the database file. And if an IO error occurs while doing so,
44682         ** then corruption may follow.
44683         */
44684         pPg->flags |= PGHDR_NEED_SYNC;
44685
44686         rc = write32bits(pPager->jfd, iOff, pPg->pgno);
44687         if( rc!=SQLCIPHER_OK ) return rc;
44688         rc = sqlcipher3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
44689         if( rc!=SQLCIPHER_OK ) return rc;
44690         rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
44691         if( rc!=SQLCIPHER_OK ) return rc;
44692
44693         IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, 
44694                  pPager->journalOff, pPager->pageSize));
44695         PAGER_INCR(sqlcipher3_pager_writej_count);
44696         PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
44697              PAGERID(pPager), pPg->pgno, 
44698              ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
44699
44700         pPager->journalOff += 8 + pPager->pageSize;
44701         pPager->nRec++;
44702         assert( pPager->pInJournal!=0 );
44703         rc = sqlcipher3BitvecSet(pPager->pInJournal, pPg->pgno);
44704         testcase( rc==SQLCIPHER_NOMEM );
44705         assert( rc==SQLCIPHER_OK || rc==SQLCIPHER_NOMEM );
44706         rc |= addToSavepointBitvecs(pPager, pPg->pgno);
44707         if( rc!=SQLCIPHER_OK ){
44708           assert( rc==SQLCIPHER_NOMEM );
44709           return rc;
44710         }
44711       }else{
44712         if( pPager->eState!=PAGER_WRITER_DBMOD ){
44713           pPg->flags |= PGHDR_NEED_SYNC;
44714         }
44715         PAGERTRACE(("APPEND %d page %d needSync=%d\n",
44716                 PAGERID(pPager), pPg->pgno,
44717                ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
44718       }
44719     }
44720   
44721     /* If the statement journal is open and the page is not in it,
44722     ** then write the current page to the statement journal.  Note that
44723     ** the statement journal format differs from the standard journal format
44724     ** in that it omits the checksums and the header.
44725     */
44726     if( subjRequiresPage(pPg) ){
44727       rc = subjournalPage(pPg);
44728     }
44729   }
44730
44731   /* Update the database size and return.
44732   */
44733   if( pPager->dbSize<pPg->pgno ){
44734     pPager->dbSize = pPg->pgno;
44735   }
44736   return rc;
44737 }
44738
44739 /*
44740 ** Mark a data page as writeable. This routine must be called before 
44741 ** making changes to a page. The caller must check the return value 
44742 ** of this function and be careful not to change any page data unless 
44743 ** this routine returns SQLCIPHER_OK.
44744 **
44745 ** The difference between this function and pager_write() is that this
44746 ** function also deals with the special case where 2 or more pages
44747 ** fit on a single disk sector. In this case all co-resident pages
44748 ** must have been written to the journal file before returning.
44749 **
44750 ** If an error occurs, SQLCIPHER_NOMEM or an IO error code is returned
44751 ** as appropriate. Otherwise, SQLCIPHER_OK.
44752 */
44753 SQLCIPHER_PRIVATE int sqlcipher3PagerWrite(DbPage *pDbPage){
44754   int rc = SQLCIPHER_OK;
44755
44756   PgHdr *pPg = pDbPage;
44757   Pager *pPager = pPg->pPager;
44758   Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
44759
44760   assert( pPager->eState>=PAGER_WRITER_LOCKED );
44761   assert( pPager->eState!=PAGER_ERROR );
44762   assert( assert_pager_state(pPager) );
44763
44764   if( nPagePerSector>1 ){
44765     Pgno nPageCount;          /* Total number of pages in database file */
44766     Pgno pg1;                 /* First page of the sector pPg is located on. */
44767     int nPage = 0;            /* Number of pages starting at pg1 to journal */
44768     int ii;                   /* Loop counter */
44769     int needSync = 0;         /* True if any page has PGHDR_NEED_SYNC */
44770
44771     /* Set the doNotSyncSpill flag to 1. This is because we cannot allow
44772     ** a journal header to be written between the pages journaled by
44773     ** this function.
44774     */
44775     assert( !MEMDB );
44776     assert( pPager->doNotSyncSpill==0 );
44777     pPager->doNotSyncSpill++;
44778
44779     /* This trick assumes that both the page-size and sector-size are
44780     ** an integer power of 2. It sets variable pg1 to the identifier
44781     ** of the first page of the sector pPg is located on.
44782     */
44783     pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
44784
44785     nPageCount = pPager->dbSize;
44786     if( pPg->pgno>nPageCount ){
44787       nPage = (pPg->pgno - pg1)+1;
44788     }else if( (pg1+nPagePerSector-1)>nPageCount ){
44789       nPage = nPageCount+1-pg1;
44790     }else{
44791       nPage = nPagePerSector;
44792     }
44793     assert(nPage>0);
44794     assert(pg1<=pPg->pgno);
44795     assert((pg1+nPage)>pPg->pgno);
44796
44797     for(ii=0; ii<nPage && rc==SQLCIPHER_OK; ii++){
44798       Pgno pg = pg1+ii;
44799       PgHdr *pPage;
44800       if( pg==pPg->pgno || !sqlcipher3BitvecTest(pPager->pInJournal, pg) ){
44801         if( pg!=PAGER_MJ_PGNO(pPager) ){
44802           rc = sqlcipher3PagerGet(pPager, pg, &pPage);
44803           if( rc==SQLCIPHER_OK ){
44804             rc = pager_write(pPage);
44805             if( pPage->flags&PGHDR_NEED_SYNC ){
44806               needSync = 1;
44807             }
44808             sqlcipher3PagerUnref(pPage);
44809           }
44810         }
44811       }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
44812         if( pPage->flags&PGHDR_NEED_SYNC ){
44813           needSync = 1;
44814         }
44815         sqlcipher3PagerUnref(pPage);
44816       }
44817     }
44818
44819     /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages 
44820     ** starting at pg1, then it needs to be set for all of them. Because
44821     ** writing to any of these nPage pages may damage the others, the
44822     ** journal file must contain sync()ed copies of all of them
44823     ** before any of them can be written out to the database file.
44824     */
44825     if( rc==SQLCIPHER_OK && needSync ){
44826       assert( !MEMDB );
44827       for(ii=0; ii<nPage; ii++){
44828         PgHdr *pPage = pager_lookup(pPager, pg1+ii);
44829         if( pPage ){
44830           pPage->flags |= PGHDR_NEED_SYNC;
44831           sqlcipher3PagerUnref(pPage);
44832         }
44833       }
44834     }
44835
44836     assert( pPager->doNotSyncSpill==1 );
44837     pPager->doNotSyncSpill--;
44838   }else{
44839     rc = pager_write(pDbPage);
44840   }
44841   return rc;
44842 }
44843
44844 /*
44845 ** Return TRUE if the page given in the argument was previously passed
44846 ** to sqlcipher3PagerWrite().  In other words, return TRUE if it is ok
44847 ** to change the content of the page.
44848 */
44849 #ifndef NDEBUG
44850 SQLCIPHER_PRIVATE int sqlcipher3PagerIswriteable(DbPage *pPg){
44851   return pPg->flags&PGHDR_DIRTY;
44852 }
44853 #endif
44854
44855 /*
44856 ** A call to this routine tells the pager that it is not necessary to
44857 ** write the information on page pPg back to the disk, even though
44858 ** that page might be marked as dirty.  This happens, for example, when
44859 ** the page has been added as a leaf of the freelist and so its
44860 ** content no longer matters.
44861 **
44862 ** The overlying software layer calls this routine when all of the data
44863 ** on the given page is unused. The pager marks the page as clean so
44864 ** that it does not get written to disk.
44865 **
44866 ** Tests show that this optimization can quadruple the speed of large 
44867 ** DELETE operations.
44868 */
44869 SQLCIPHER_PRIVATE void sqlcipher3PagerDontWrite(PgHdr *pPg){
44870   Pager *pPager = pPg->pPager;
44871   if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
44872     PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
44873     IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
44874     pPg->flags |= PGHDR_DONT_WRITE;
44875     pager_set_pagehash(pPg);
44876   }
44877 }
44878
44879 /*
44880 ** This routine is called to increment the value of the database file 
44881 ** change-counter, stored as a 4-byte big-endian integer starting at 
44882 ** byte offset 24 of the pager file.  The secondary change counter at
44883 ** 92 is also updated, as is the SQLite version number at offset 96.
44884 **
44885 ** But this only happens if the pPager->changeCountDone flag is false.
44886 ** To avoid excess churning of page 1, the update only happens once.
44887 ** See also the pager_write_changecounter() routine that does an 
44888 ** unconditional update of the change counters.
44889 **
44890 ** If the isDirectMode flag is zero, then this is done by calling 
44891 ** sqlcipher3PagerWrite() on page 1, then modifying the contents of the
44892 ** page data. In this case the file will be updated when the current
44893 ** transaction is committed.
44894 **
44895 ** The isDirectMode flag may only be non-zero if the library was compiled
44896 ** with the SQLCIPHER_ENABLE_ATOMIC_WRITE macro defined. In this case,
44897 ** if isDirect is non-zero, then the database file is updated directly
44898 ** by writing an updated version of page 1 using a call to the 
44899 ** sqlcipher3OsWrite() function.
44900 */
44901 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
44902   int rc = SQLCIPHER_OK;
44903
44904   assert( pPager->eState==PAGER_WRITER_CACHEMOD
44905        || pPager->eState==PAGER_WRITER_DBMOD
44906   );
44907   assert( assert_pager_state(pPager) );
44908
44909   /* Declare and initialize constant integer 'isDirect'. If the
44910   ** atomic-write optimization is enabled in this build, then isDirect
44911   ** is initialized to the value passed as the isDirectMode parameter
44912   ** to this function. Otherwise, it is always set to zero.
44913   **
44914   ** The idea is that if the atomic-write optimization is not
44915   ** enabled at compile time, the compiler can omit the tests of
44916   ** 'isDirect' below, as well as the block enclosed in the
44917   ** "if( isDirect )" condition.
44918   */
44919 #ifndef SQLCIPHER_ENABLE_ATOMIC_WRITE
44920 # define DIRECT_MODE 0
44921   assert( isDirectMode==0 );
44922   UNUSED_PARAMETER(isDirectMode);
44923 #else
44924 # define DIRECT_MODE isDirectMode
44925 #endif
44926
44927   if( !pPager->changeCountDone && pPager->dbSize>0 ){
44928     PgHdr *pPgHdr;                /* Reference to page 1 */
44929
44930     assert( !pPager->tempFile && isOpen(pPager->fd) );
44931
44932     /* Open page 1 of the file for writing. */
44933     rc = sqlcipher3PagerGet(pPager, 1, &pPgHdr);
44934     assert( pPgHdr==0 || rc==SQLCIPHER_OK );
44935
44936     /* If page one was fetched successfully, and this function is not
44937     ** operating in direct-mode, make page 1 writable.  When not in 
44938     ** direct mode, page 1 is always held in cache and hence the PagerGet()
44939     ** above is always successful - hence the ALWAYS on rc==SQLCIPHER_OK.
44940     */
44941     if( !DIRECT_MODE && ALWAYS(rc==SQLCIPHER_OK) ){
44942       rc = sqlcipher3PagerWrite(pPgHdr);
44943     }
44944
44945     if( rc==SQLCIPHER_OK ){
44946       /* Actually do the update of the change counter */
44947       pager_write_changecounter(pPgHdr);
44948
44949       /* If running in direct mode, write the contents of page 1 to the file. */
44950       if( DIRECT_MODE ){
44951         const void *zBuf;
44952         assert( pPager->dbFileSize>0 );
44953         CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLCIPHER_NOMEM, zBuf);
44954         if( rc==SQLCIPHER_OK ){
44955           rc = sqlcipher3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
44956         }
44957         if( rc==SQLCIPHER_OK ){
44958           pPager->changeCountDone = 1;
44959         }
44960       }else{
44961         pPager->changeCountDone = 1;
44962       }
44963     }
44964
44965     /* Release the page reference. */
44966     sqlcipher3PagerUnref(pPgHdr);
44967   }
44968   return rc;
44969 }
44970
44971 /*
44972 ** Sync the database file to disk. This is a no-op for in-memory databases
44973 ** or pages with the Pager.noSync flag set.
44974 **
44975 ** If successful, or if called on a pager for which it is a no-op, this
44976 ** function returns SQLCIPHER_OK. Otherwise, an IO error code is returned.
44977 */
44978 SQLCIPHER_PRIVATE int sqlcipher3PagerSync(Pager *pPager){
44979   int rc = SQLCIPHER_OK;
44980   if( !pPager->noSync ){
44981     assert( !MEMDB );
44982     rc = sqlcipher3OsSync(pPager->fd, pPager->syncFlags);
44983   }else if( isOpen(pPager->fd) ){
44984     assert( !MEMDB );
44985     sqlcipher3OsFileControl(pPager->fd, SQLCIPHER_FCNTL_SYNC_OMITTED, (void *)&rc);
44986   }
44987   return rc;
44988 }
44989
44990 /*
44991 ** This function may only be called while a write-transaction is active in
44992 ** rollback. If the connection is in WAL mode, this call is a no-op. 
44993 ** Otherwise, if the connection does not already have an EXCLUSIVE lock on 
44994 ** the database file, an attempt is made to obtain one.
44995 **
44996 ** If the EXCLUSIVE lock is already held or the attempt to obtain it is
44997 ** successful, or the connection is in WAL mode, SQLCIPHER_OK is returned.
44998 ** Otherwise, either SQLCIPHER_BUSY or an SQLCIPHER_IOERR_XXX error code is 
44999 ** returned.
45000 */
45001 SQLCIPHER_PRIVATE int sqlcipher3PagerExclusiveLock(Pager *pPager){
45002   int rc = SQLCIPHER_OK;
45003   assert( pPager->eState==PAGER_WRITER_CACHEMOD 
45004        || pPager->eState==PAGER_WRITER_DBMOD 
45005        || pPager->eState==PAGER_WRITER_LOCKED 
45006   );
45007   assert( assert_pager_state(pPager) );
45008   if( 0==pagerUseWal(pPager) ){
45009     rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
45010   }
45011   return rc;
45012 }
45013
45014 /*
45015 ** Sync the database file for the pager pPager. zMaster points to the name
45016 ** of a master journal file that should be written into the individual
45017 ** journal file. zMaster may be NULL, which is interpreted as no master
45018 ** journal (a single database transaction).
45019 **
45020 ** This routine ensures that:
45021 **
45022 **   * The database file change-counter is updated,
45023 **   * the journal is synced (unless the atomic-write optimization is used),
45024 **   * all dirty pages are written to the database file, 
45025 **   * the database file is truncated (if required), and
45026 **   * the database file synced. 
45027 **
45028 ** The only thing that remains to commit the transaction is to finalize 
45029 ** (delete, truncate or zero the first part of) the journal file (or 
45030 ** delete the master journal file if specified).
45031 **
45032 ** Note that if zMaster==NULL, this does not overwrite a previous value
45033 ** passed to an sqlcipher3PagerCommitPhaseOne() call.
45034 **
45035 ** If the final parameter - noSync - is true, then the database file itself
45036 ** is not synced. The caller must call sqlcipher3PagerSync() directly to
45037 ** sync the database file before calling CommitPhaseTwo() to delete the
45038 ** journal file in this case.
45039 */
45040 SQLCIPHER_PRIVATE int sqlcipher3PagerCommitPhaseOne(
45041   Pager *pPager,                  /* Pager object */
45042   const char *zMaster,            /* If not NULL, the master journal name */
45043   int noSync                      /* True to omit the xSync on the db file */
45044 ){
45045   int rc = SQLCIPHER_OK;             /* Return code */
45046
45047   assert( pPager->eState==PAGER_WRITER_LOCKED
45048        || pPager->eState==PAGER_WRITER_CACHEMOD
45049        || pPager->eState==PAGER_WRITER_DBMOD
45050        || pPager->eState==PAGER_ERROR
45051   );
45052   assert( assert_pager_state(pPager) );
45053
45054   /* If a prior error occurred, report that error again. */
45055   if( NEVER(pPager->errCode) ) return pPager->errCode;
45056
45057   PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n", 
45058       pPager->zFilename, zMaster, pPager->dbSize));
45059
45060   /* If no database changes have been made, return early. */
45061   if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLCIPHER_OK;
45062
45063   if( MEMDB ){
45064     /* If this is an in-memory db, or no pages have been written to, or this
45065     ** function has already been called, it is mostly a no-op.  However, any
45066     ** backup in progress needs to be restarted.
45067     */
45068     sqlcipher3BackupRestart(pPager->pBackup);
45069   }else{
45070     if( pagerUseWal(pPager) ){
45071       PgHdr *pList = sqlcipher3PcacheDirtyList(pPager->pPCache);
45072       PgHdr *pPageOne = 0;
45073       if( pList==0 ){
45074         /* Must have at least one page for the WAL commit flag.
45075         ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
45076         rc = sqlcipher3PagerGet(pPager, 1, &pPageOne);
45077         pList = pPageOne;
45078         pList->pDirty = 0;
45079       }
45080       assert( rc==SQLCIPHER_OK );
45081       if( ALWAYS(pList) ){
45082         rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1, 
45083             (pPager->fullSync ? pPager->syncFlags : 0)
45084         );
45085       }
45086       sqlcipher3PagerUnref(pPageOne);
45087       if( rc==SQLCIPHER_OK ){
45088         sqlcipher3PcacheCleanAll(pPager->pPCache);
45089       }
45090     }else{
45091       /* The following block updates the change-counter. Exactly how it
45092       ** does this depends on whether or not the atomic-update optimization
45093       ** was enabled at compile time, and if this transaction meets the 
45094       ** runtime criteria to use the operation: 
45095       **
45096       **    * The file-system supports the atomic-write property for
45097       **      blocks of size page-size, and 
45098       **    * This commit is not part of a multi-file transaction, and
45099       **    * Exactly one page has been modified and store in the journal file.
45100       **
45101       ** If the optimization was not enabled at compile time, then the
45102       ** pager_incr_changecounter() function is called to update the change
45103       ** counter in 'indirect-mode'. If the optimization is compiled in but
45104       ** is not applicable to this transaction, call sqlcipher3JournalCreate()
45105       ** to make sure the journal file has actually been created, then call
45106       ** pager_incr_changecounter() to update the change-counter in indirect
45107       ** mode. 
45108       **
45109       ** Otherwise, if the optimization is both enabled and applicable,
45110       ** then call pager_incr_changecounter() to update the change-counter
45111       ** in 'direct' mode. In this case the journal file will never be
45112       ** created for this transaction.
45113       */
45114   #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
45115       PgHdr *pPg;
45116       assert( isOpen(pPager->jfd) 
45117            || pPager->journalMode==PAGER_JOURNALMODE_OFF 
45118            || pPager->journalMode==PAGER_JOURNALMODE_WAL 
45119       );
45120       if( !zMaster && isOpen(pPager->jfd) 
45121        && pPager->journalOff==jrnlBufferSize(pPager) 
45122        && pPager->dbSize>=pPager->dbOrigSize
45123        && (0==(pPg = sqlcipher3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
45124       ){
45125         /* Update the db file change counter via the direct-write method. The 
45126         ** following call will modify the in-memory representation of page 1 
45127         ** to include the updated change counter and then write page 1 
45128         ** directly to the database file. Because of the atomic-write 
45129         ** property of the host file-system, this is safe.
45130         */
45131         rc = pager_incr_changecounter(pPager, 1);
45132       }else{
45133         rc = sqlcipher3JournalCreate(pPager->jfd);
45134         if( rc==SQLCIPHER_OK ){
45135           rc = pager_incr_changecounter(pPager, 0);
45136         }
45137       }
45138   #else
45139       rc = pager_incr_changecounter(pPager, 0);
45140   #endif
45141       if( rc!=SQLCIPHER_OK ) goto commit_phase_one_exit;
45142   
45143       /* If this transaction has made the database smaller, then all pages
45144       ** being discarded by the truncation must be written to the journal
45145       ** file. This can only happen in auto-vacuum mode.
45146       **
45147       ** Before reading the pages with page numbers larger than the 
45148       ** current value of Pager.dbSize, set dbSize back to the value
45149       ** that it took at the start of the transaction. Otherwise, the
45150       ** calls to sqlcipher3PagerGet() return zeroed pages instead of 
45151       ** reading data from the database file.
45152       */
45153   #ifndef SQLCIPHER_OMIT_AUTOVACUUM
45154       if( pPager->dbSize<pPager->dbOrigSize 
45155        && pPager->journalMode!=PAGER_JOURNALMODE_OFF
45156       ){
45157         Pgno i;                                   /* Iterator variable */
45158         const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
45159         const Pgno dbSize = pPager->dbSize;       /* Database image size */ 
45160         pPager->dbSize = pPager->dbOrigSize;
45161         for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
45162           if( !sqlcipher3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
45163             PgHdr *pPage;             /* Page to journal */
45164             rc = sqlcipher3PagerGet(pPager, i, &pPage);
45165             if( rc!=SQLCIPHER_OK ) goto commit_phase_one_exit;
45166             rc = sqlcipher3PagerWrite(pPage);
45167             sqlcipher3PagerUnref(pPage);
45168             if( rc!=SQLCIPHER_OK ) goto commit_phase_one_exit;
45169           }
45170         }
45171         pPager->dbSize = dbSize;
45172       } 
45173   #endif
45174   
45175       /* Write the master journal name into the journal file. If a master 
45176       ** journal file name has already been written to the journal file, 
45177       ** or if zMaster is NULL (no master journal), then this call is a no-op.
45178       */
45179       rc = writeMasterJournal(pPager, zMaster);
45180       if( rc!=SQLCIPHER_OK ) goto commit_phase_one_exit;
45181   
45182       /* Sync the journal file and write all dirty pages to the database.
45183       ** If the atomic-update optimization is being used, this sync will not 
45184       ** create the journal file or perform any real IO.
45185       **
45186       ** Because the change-counter page was just modified, unless the
45187       ** atomic-update optimization is used it is almost certain that the
45188       ** journal requires a sync here. However, in locking_mode=exclusive
45189       ** on a system under memory pressure it is just possible that this is 
45190       ** not the case. In this case it is likely enough that the redundant
45191       ** xSync() call will be changed to a no-op by the OS anyhow. 
45192       */
45193       rc = syncJournal(pPager, 0);
45194       if( rc!=SQLCIPHER_OK ) goto commit_phase_one_exit;
45195   
45196       rc = pager_write_pagelist(pPager,sqlcipher3PcacheDirtyList(pPager->pPCache));
45197       if( rc!=SQLCIPHER_OK ){
45198         assert( rc!=SQLCIPHER_IOERR_BLOCKED );
45199         goto commit_phase_one_exit;
45200       }
45201       sqlcipher3PcacheCleanAll(pPager->pPCache);
45202   
45203       /* If the file on disk is not the same size as the database image,
45204       ** then use pager_truncate to grow or shrink the file here.
45205       */
45206       if( pPager->dbSize!=pPager->dbFileSize ){
45207         Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
45208         assert( pPager->eState==PAGER_WRITER_DBMOD );
45209         rc = pager_truncate(pPager, nNew);
45210         if( rc!=SQLCIPHER_OK ) goto commit_phase_one_exit;
45211       }
45212   
45213       /* Finally, sync the database file. */
45214       if( !noSync ){
45215         rc = sqlcipher3PagerSync(pPager);
45216       }
45217       IOTRACE(("DBSYNC %p\n", pPager))
45218     }
45219   }
45220
45221 commit_phase_one_exit:
45222   if( rc==SQLCIPHER_OK && !pagerUseWal(pPager) ){
45223     pPager->eState = PAGER_WRITER_FINISHED;
45224   }
45225   return rc;
45226 }
45227
45228
45229 /*
45230 ** When this function is called, the database file has been completely
45231 ** updated to reflect the changes made by the current transaction and
45232 ** synced to disk. The journal file still exists in the file-system 
45233 ** though, and if a failure occurs at this point it will eventually
45234 ** be used as a hot-journal and the current transaction rolled back.
45235 **
45236 ** This function finalizes the journal file, either by deleting, 
45237 ** truncating or partially zeroing it, so that it cannot be used 
45238 ** for hot-journal rollback. Once this is done the transaction is
45239 ** irrevocably committed.
45240 **
45241 ** If an error occurs, an IO error code is returned and the pager
45242 ** moves into the error state. Otherwise, SQLCIPHER_OK is returned.
45243 */
45244 SQLCIPHER_PRIVATE int sqlcipher3PagerCommitPhaseTwo(Pager *pPager){
45245   int rc = SQLCIPHER_OK;                  /* Return code */
45246
45247   /* This routine should not be called if a prior error has occurred.
45248   ** But if (due to a coding error elsewhere in the system) it does get
45249   ** called, just return the same error code without doing anything. */
45250   if( NEVER(pPager->errCode) ) return pPager->errCode;
45251
45252   assert( pPager->eState==PAGER_WRITER_LOCKED
45253        || pPager->eState==PAGER_WRITER_FINISHED
45254        || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
45255   );
45256   assert( assert_pager_state(pPager) );
45257
45258   /* An optimization. If the database was not actually modified during
45259   ** this transaction, the pager is running in exclusive-mode and is
45260   ** using persistent journals, then this function is a no-op.
45261   **
45262   ** The start of the journal file currently contains a single journal 
45263   ** header with the nRec field set to 0. If such a journal is used as
45264   ** a hot-journal during hot-journal rollback, 0 changes will be made
45265   ** to the database file. So there is no need to zero the journal 
45266   ** header. Since the pager is in exclusive mode, there is no need
45267   ** to drop any locks either.
45268   */
45269   if( pPager->eState==PAGER_WRITER_LOCKED 
45270    && pPager->exclusiveMode 
45271    && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
45272   ){
45273     assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
45274     pPager->eState = PAGER_READER;
45275     return SQLCIPHER_OK;
45276   }
45277
45278   PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
45279   rc = pager_end_transaction(pPager, pPager->setMaster);
45280   return pager_error(pPager, rc);
45281 }
45282
45283 /*
45284 ** If a write transaction is open, then all changes made within the 
45285 ** transaction are reverted and the current write-transaction is closed.
45286 ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
45287 ** state if an error occurs.
45288 **
45289 ** If the pager is already in PAGER_ERROR state when this function is called,
45290 ** it returns Pager.errCode immediately. No work is performed in this case.
45291 **
45292 ** Otherwise, in rollback mode, this function performs two functions:
45293 **
45294 **   1) It rolls back the journal file, restoring all database file and 
45295 **      in-memory cache pages to the state they were in when the transaction
45296 **      was opened, and
45297 **
45298 **   2) It finalizes the journal file, so that it is not used for hot
45299 **      rollback at any point in the future.
45300 **
45301 ** Finalization of the journal file (task 2) is only performed if the 
45302 ** rollback is successful.
45303 **
45304 ** In WAL mode, all cache-entries containing data modified within the
45305 ** current transaction are either expelled from the cache or reverted to
45306 ** their pre-transaction state by re-reading data from the database or
45307 ** WAL files. The WAL transaction is then closed.
45308 */
45309 SQLCIPHER_PRIVATE int sqlcipher3PagerRollback(Pager *pPager){
45310   int rc = SQLCIPHER_OK;                  /* Return code */
45311   PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
45312
45313   /* PagerRollback() is a no-op if called in READER or OPEN state. If
45314   ** the pager is already in the ERROR state, the rollback is not 
45315   ** attempted here. Instead, the error code is returned to the caller.
45316   */
45317   assert( assert_pager_state(pPager) );
45318   if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
45319   if( pPager->eState<=PAGER_READER ) return SQLCIPHER_OK;
45320
45321   if( pagerUseWal(pPager) ){
45322     int rc2;
45323     rc = sqlcipher3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
45324     rc2 = pager_end_transaction(pPager, pPager->setMaster);
45325     if( rc==SQLCIPHER_OK ) rc = rc2;
45326   }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
45327     int eState = pPager->eState;
45328     rc = pager_end_transaction(pPager, 0);
45329     if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
45330       /* This can happen using journal_mode=off. Move the pager to the error 
45331       ** state to indicate that the contents of the cache may not be trusted.
45332       ** Any active readers will get SQLCIPHER_ABORT.
45333       */
45334       pPager->errCode = SQLCIPHER_ABORT;
45335       pPager->eState = PAGER_ERROR;
45336       return rc;
45337     }
45338   }else{
45339     rc = pager_playback(pPager, 0);
45340   }
45341
45342   assert( pPager->eState==PAGER_READER || rc!=SQLCIPHER_OK );
45343   assert( rc==SQLCIPHER_OK || rc==SQLCIPHER_FULL || (rc&0xFF)==SQLCIPHER_IOERR );
45344
45345   /* If an error occurs during a ROLLBACK, we can no longer trust the pager
45346   ** cache. So call pager_error() on the way out to make any error persistent.
45347   */
45348   return pager_error(pPager, rc);
45349 }
45350
45351 /*
45352 ** Return TRUE if the database file is opened read-only.  Return FALSE
45353 ** if the database is (in theory) writable.
45354 */
45355 SQLCIPHER_PRIVATE u8 sqlcipher3PagerIsreadonly(Pager *pPager){
45356   return pPager->readOnly;
45357 }
45358
45359 /*
45360 ** Return the number of references to the pager.
45361 */
45362 SQLCIPHER_PRIVATE int sqlcipher3PagerRefcount(Pager *pPager){
45363   return sqlcipher3PcacheRefCount(pPager->pPCache);
45364 }
45365
45366 /*
45367 ** Return the approximate number of bytes of memory currently
45368 ** used by the pager and its associated cache.
45369 */
45370 SQLCIPHER_PRIVATE int sqlcipher3PagerMemUsed(Pager *pPager){
45371   int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
45372                                      + 5*sizeof(void*);
45373   return perPageSize*sqlcipher3PcachePagecount(pPager->pPCache)
45374            + sqlcipher3MallocSize(pPager)
45375            + pPager->pageSize;
45376 }
45377
45378 /*
45379 ** Return the number of references to the specified page.
45380 */
45381 SQLCIPHER_PRIVATE int sqlcipher3PagerPageRefcount(DbPage *pPage){
45382   return sqlcipher3PcachePageRefcount(pPage);
45383 }
45384
45385 #ifdef SQLCIPHER_TEST
45386 /*
45387 ** This routine is used for testing and analysis only.
45388 */
45389 SQLCIPHER_PRIVATE int *sqlcipher3PagerStats(Pager *pPager){
45390   static int a[11];
45391   a[0] = sqlcipher3PcacheRefCount(pPager->pPCache);
45392   a[1] = sqlcipher3PcachePagecount(pPager->pPCache);
45393   a[2] = sqlcipher3PcacheGetCachesize(pPager->pPCache);
45394   a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
45395   a[4] = pPager->eState;
45396   a[5] = pPager->errCode;
45397   a[6] = pPager->nHit;
45398   a[7] = pPager->nMiss;
45399   a[8] = 0;  /* Used to be pPager->nOvfl */
45400   a[9] = pPager->nRead;
45401   a[10] = pPager->nWrite;
45402   return a;
45403 }
45404 #endif
45405
45406 /*
45407 ** Parameter eStat must be either SQLCIPHER_DBSTATUS_CACHE_HIT or
45408 ** SQLCIPHER_DBSTATUS_CACHE_MISS. Before returning, *pnVal is incremented by the
45409 ** current cache hit or miss count, according to the value of eStat. If the 
45410 ** reset parameter is non-zero, the cache hit or miss count is zeroed before 
45411 ** returning.
45412 */
45413 SQLCIPHER_PRIVATE void sqlcipher3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
45414   int *piStat;
45415
45416   assert( eStat==SQLCIPHER_DBSTATUS_CACHE_HIT
45417        || eStat==SQLCIPHER_DBSTATUS_CACHE_MISS
45418   );
45419   if( eStat==SQLCIPHER_DBSTATUS_CACHE_HIT ){
45420     piStat = &pPager->nHit;
45421   }else{
45422     piStat = &pPager->nMiss;
45423   }
45424
45425   *pnVal += *piStat;
45426   if( reset ){
45427     *piStat = 0;
45428   }
45429 }
45430
45431 /*
45432 ** Return true if this is an in-memory pager.
45433 */
45434 SQLCIPHER_PRIVATE int sqlcipher3PagerIsMemdb(Pager *pPager){
45435   return MEMDB;
45436 }
45437
45438 /*
45439 ** Check that there are at least nSavepoint savepoints open. If there are
45440 ** currently less than nSavepoints open, then open one or more savepoints
45441 ** to make up the difference. If the number of savepoints is already
45442 ** equal to nSavepoint, then this function is a no-op.
45443 **
45444 ** If a memory allocation fails, SQLCIPHER_NOMEM is returned. If an error 
45445 ** occurs while opening the sub-journal file, then an IO error code is
45446 ** returned. Otherwise, SQLCIPHER_OK.
45447 */
45448 SQLCIPHER_PRIVATE int sqlcipher3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
45449   int rc = SQLCIPHER_OK;                       /* Return code */
45450   int nCurrent = pPager->nSavepoint;        /* Current number of savepoints */
45451
45452   assert( pPager->eState>=PAGER_WRITER_LOCKED );
45453   assert( assert_pager_state(pPager) );
45454
45455   if( nSavepoint>nCurrent && pPager->useJournal ){
45456     int ii;                                 /* Iterator variable */
45457     PagerSavepoint *aNew;                   /* New Pager.aSavepoint array */
45458
45459     /* Grow the Pager.aSavepoint array using realloc(). Return SQLCIPHER_NOMEM
45460     ** if the allocation fails. Otherwise, zero the new portion in case a 
45461     ** malloc failure occurs while populating it in the for(...) loop below.
45462     */
45463     aNew = (PagerSavepoint *)sqlcipher3Realloc(
45464         pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
45465     );
45466     if( !aNew ){
45467       return SQLCIPHER_NOMEM;
45468     }
45469     memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
45470     pPager->aSavepoint = aNew;
45471
45472     /* Populate the PagerSavepoint structures just allocated. */
45473     for(ii=nCurrent; ii<nSavepoint; ii++){
45474       aNew[ii].nOrig = pPager->dbSize;
45475       if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
45476         aNew[ii].iOffset = pPager->journalOff;
45477       }else{
45478         aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
45479       }
45480       aNew[ii].iSubRec = pPager->nSubRec;
45481       aNew[ii].pInSavepoint = sqlcipher3BitvecCreate(pPager->dbSize);
45482       if( !aNew[ii].pInSavepoint ){
45483         return SQLCIPHER_NOMEM;
45484       }
45485       if( pagerUseWal(pPager) ){
45486         sqlcipher3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
45487       }
45488       pPager->nSavepoint = ii+1;
45489     }
45490     assert( pPager->nSavepoint==nSavepoint );
45491     assertTruncateConstraint(pPager);
45492   }
45493
45494   return rc;
45495 }
45496
45497 /*
45498 ** This function is called to rollback or release (commit) a savepoint.
45499 ** The savepoint to release or rollback need not be the most recently 
45500 ** created savepoint.
45501 **
45502 ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
45503 ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
45504 ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
45505 ** that have occurred since the specified savepoint was created.
45506 **
45507 ** The savepoint to rollback or release is identified by parameter 
45508 ** iSavepoint. A value of 0 means to operate on the outermost savepoint
45509 ** (the first created). A value of (Pager.nSavepoint-1) means operate
45510 ** on the most recently created savepoint. If iSavepoint is greater than
45511 ** (Pager.nSavepoint-1), then this function is a no-op.
45512 **
45513 ** If a negative value is passed to this function, then the current
45514 ** transaction is rolled back. This is different to calling 
45515 ** sqlcipher3PagerRollback() because this function does not terminate
45516 ** the transaction or unlock the database, it just restores the 
45517 ** contents of the database to its original state. 
45518 **
45519 ** In any case, all savepoints with an index greater than iSavepoint 
45520 ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
45521 ** then savepoint iSavepoint is also destroyed.
45522 **
45523 ** This function may return SQLCIPHER_NOMEM if a memory allocation fails,
45524 ** or an IO error code if an IO error occurs while rolling back a 
45525 ** savepoint. If no errors occur, SQLCIPHER_OK is returned.
45526 */ 
45527 SQLCIPHER_PRIVATE int sqlcipher3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
45528   int rc = pPager->errCode;       /* Return code */
45529
45530   assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
45531   assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
45532
45533   if( rc==SQLCIPHER_OK && iSavepoint<pPager->nSavepoint ){
45534     int ii;            /* Iterator variable */
45535     int nNew;          /* Number of remaining savepoints after this op. */
45536
45537     /* Figure out how many savepoints will still be active after this
45538     ** operation. Store this value in nNew. Then free resources associated 
45539     ** with any savepoints that are destroyed by this operation.
45540     */
45541     nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
45542     for(ii=nNew; ii<pPager->nSavepoint; ii++){
45543       sqlcipher3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
45544     }
45545     pPager->nSavepoint = nNew;
45546
45547     /* If this is a release of the outermost savepoint, truncate 
45548     ** the sub-journal to zero bytes in size. */
45549     if( op==SAVEPOINT_RELEASE ){
45550       if( nNew==0 && isOpen(pPager->sjfd) ){
45551         /* Only truncate if it is an in-memory sub-journal. */
45552         if( sqlcipher3IsMemJournal(pPager->sjfd) ){
45553           rc = sqlcipher3OsTruncate(pPager->sjfd, 0);
45554           assert( rc==SQLCIPHER_OK );
45555         }
45556         pPager->nSubRec = 0;
45557       }
45558     }
45559     /* Else this is a rollback operation, playback the specified savepoint.
45560     ** If this is a temp-file, it is possible that the journal file has
45561     ** not yet been opened. In this case there have been no changes to
45562     ** the database file, so the playback operation can be skipped.
45563     */
45564     else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
45565       PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
45566       rc = pagerPlaybackSavepoint(pPager, pSavepoint);
45567       assert(rc!=SQLCIPHER_DONE);
45568     }
45569   }
45570
45571   return rc;
45572 }
45573
45574 /*
45575 ** Return the full pathname of the database file.
45576 */
45577 SQLCIPHER_PRIVATE const char *sqlcipher3PagerFilename(Pager *pPager){
45578   return pPager->zFilename;
45579 }
45580
45581 /*
45582 ** Return the VFS structure for the pager.
45583 */
45584 SQLCIPHER_PRIVATE const sqlcipher3_vfs *sqlcipher3PagerVfs(Pager *pPager){
45585   return pPager->pVfs;
45586 }
45587
45588 /*
45589 ** Return the file handle for the database file associated
45590 ** with the pager.  This might return NULL if the file has
45591 ** not yet been opened.
45592 */
45593 SQLCIPHER_PRIVATE sqlcipher3_file *sqlcipher3PagerFile(Pager *pPager){
45594   return pPager->fd;
45595 }
45596
45597 /*
45598 ** Return the full pathname of the journal file.
45599 */
45600 SQLCIPHER_PRIVATE const char *sqlcipher3PagerJournalname(Pager *pPager){
45601   return pPager->zJournal;
45602 }
45603
45604 /*
45605 ** Return true if fsync() calls are disabled for this pager.  Return FALSE
45606 ** if fsync()s are executed normally.
45607 */
45608 SQLCIPHER_PRIVATE int sqlcipher3PagerNosync(Pager *pPager){
45609   return pPager->noSync;
45610 }
45611
45612 #ifdef SQLCIPHER_HAS_CODEC
45613 /*
45614 ** Set or retrieve the codec for this pager
45615 */
45616 SQLCIPHER_PRIVATE void sqlcipher3PagerSetCodec(
45617   Pager *pPager,
45618   void *(*xCodec)(void*,void*,Pgno,int),
45619   void (*xCodecSizeChng)(void*,int,int),
45620   void (*xCodecFree)(void*),
45621   void *pCodec
45622 ){
45623   if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
45624   pPager->xCodec = pPager->memDb ? 0 : xCodec;
45625   pPager->xCodecSizeChng = xCodecSizeChng;
45626   pPager->xCodecFree = xCodecFree;
45627   pPager->pCodec = pCodec;
45628   pagerReportSize(pPager);
45629 }
45630 SQLCIPHER_PRIVATE void *sqlcipher3PagerGetCodec(Pager *pPager){
45631   return pPager->pCodec;
45632 }
45633 #endif
45634
45635 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
45636 /*
45637 ** Move the page pPg to location pgno in the file.
45638 **
45639 ** There must be no references to the page previously located at
45640 ** pgno (which we call pPgOld) though that page is allowed to be
45641 ** in cache.  If the page previously located at pgno is not already
45642 ** in the rollback journal, it is not put there by by this routine.
45643 **
45644 ** References to the page pPg remain valid. Updating any
45645 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
45646 ** allocated along with the page) is the responsibility of the caller.
45647 **
45648 ** A transaction must be active when this routine is called. It used to be
45649 ** required that a statement transaction was not active, but this restriction
45650 ** has been removed (CREATE INDEX needs to move a page when a statement
45651 ** transaction is active).
45652 **
45653 ** If the fourth argument, isCommit, is non-zero, then this page is being
45654 ** moved as part of a database reorganization just before the transaction 
45655 ** is being committed. In this case, it is guaranteed that the database page 
45656 ** pPg refers to will not be written to again within this transaction.
45657 **
45658 ** This function may return SQLCIPHER_NOMEM or an IO error code if an error
45659 ** occurs. Otherwise, it returns SQLCIPHER_OK.
45660 */
45661 SQLCIPHER_PRIVATE int sqlcipher3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
45662   PgHdr *pPgOld;               /* The page being overwritten. */
45663   Pgno needSyncPgno = 0;       /* Old value of pPg->pgno, if sync is required */
45664   int rc;                      /* Return code */
45665   Pgno origPgno;               /* The original page number */
45666
45667   assert( pPg->nRef>0 );
45668   assert( pPager->eState==PAGER_WRITER_CACHEMOD
45669        || pPager->eState==PAGER_WRITER_DBMOD
45670   );
45671   assert( assert_pager_state(pPager) );
45672
45673   /* In order to be able to rollback, an in-memory database must journal
45674   ** the page we are moving from.
45675   */
45676   if( MEMDB ){
45677     rc = sqlcipher3PagerWrite(pPg);
45678     if( rc ) return rc;
45679   }
45680
45681   /* If the page being moved is dirty and has not been saved by the latest
45682   ** savepoint, then save the current contents of the page into the 
45683   ** sub-journal now. This is required to handle the following scenario:
45684   **
45685   **   BEGIN;
45686   **     <journal page X, then modify it in memory>
45687   **     SAVEPOINT one;
45688   **       <Move page X to location Y>
45689   **     ROLLBACK TO one;
45690   **
45691   ** If page X were not written to the sub-journal here, it would not
45692   ** be possible to restore its contents when the "ROLLBACK TO one"
45693   ** statement were is processed.
45694   **
45695   ** subjournalPage() may need to allocate space to store pPg->pgno into
45696   ** one or more savepoint bitvecs. This is the reason this function
45697   ** may return SQLCIPHER_NOMEM.
45698   */
45699   if( pPg->flags&PGHDR_DIRTY
45700    && subjRequiresPage(pPg)
45701    && SQLCIPHER_OK!=(rc = subjournalPage(pPg))
45702   ){
45703     return rc;
45704   }
45705
45706   PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n", 
45707       PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
45708   IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
45709
45710   /* If the journal needs to be sync()ed before page pPg->pgno can
45711   ** be written to, store pPg->pgno in local variable needSyncPgno.
45712   **
45713   ** If the isCommit flag is set, there is no need to remember that
45714   ** the journal needs to be sync()ed before database page pPg->pgno 
45715   ** can be written to. The caller has already promised not to write to it.
45716   */
45717   if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
45718     needSyncPgno = pPg->pgno;
45719     assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
45720     assert( pPg->flags&PGHDR_DIRTY );
45721   }
45722
45723   /* If the cache contains a page with page-number pgno, remove it
45724   ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for 
45725   ** page pgno before the 'move' operation, it needs to be retained 
45726   ** for the page moved there.
45727   */
45728   pPg->flags &= ~PGHDR_NEED_SYNC;
45729   pPgOld = pager_lookup(pPager, pgno);
45730   assert( !pPgOld || pPgOld->nRef==1 );
45731   if( pPgOld ){
45732     pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
45733     if( MEMDB ){
45734       /* Do not discard pages from an in-memory database since we might
45735       ** need to rollback later.  Just move the page out of the way. */
45736       sqlcipher3PcacheMove(pPgOld, pPager->dbSize+1);
45737     }else{
45738       sqlcipher3PcacheDrop(pPgOld);
45739     }
45740   }
45741
45742   origPgno = pPg->pgno;
45743   sqlcipher3PcacheMove(pPg, pgno);
45744   sqlcipher3PcacheMakeDirty(pPg);
45745
45746   /* For an in-memory database, make sure the original page continues
45747   ** to exist, in case the transaction needs to roll back.  Use pPgOld
45748   ** as the original page since it has already been allocated.
45749   */
45750   if( MEMDB ){
45751     assert( pPgOld );
45752     sqlcipher3PcacheMove(pPgOld, origPgno);
45753     sqlcipher3PagerUnref(pPgOld);
45754   }
45755
45756   if( needSyncPgno ){
45757     /* If needSyncPgno is non-zero, then the journal file needs to be 
45758     ** sync()ed before any data is written to database file page needSyncPgno.
45759     ** Currently, no such page exists in the page-cache and the 
45760     ** "is journaled" bitvec flag has been set. This needs to be remedied by
45761     ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
45762     ** flag.
45763     **
45764     ** If the attempt to load the page into the page-cache fails, (due
45765     ** to a malloc() or IO failure), clear the bit in the pInJournal[]
45766     ** array. Otherwise, if the page is loaded and written again in
45767     ** this transaction, it may be written to the database file before
45768     ** it is synced into the journal file. This way, it may end up in
45769     ** the journal file twice, but that is not a problem.
45770     */
45771     PgHdr *pPgHdr;
45772     rc = sqlcipher3PagerGet(pPager, needSyncPgno, &pPgHdr);
45773     if( rc!=SQLCIPHER_OK ){
45774       if( needSyncPgno<=pPager->dbOrigSize ){
45775         assert( pPager->pTmpSpace!=0 );
45776         sqlcipher3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
45777       }
45778       return rc;
45779     }
45780     pPgHdr->flags |= PGHDR_NEED_SYNC;
45781     sqlcipher3PcacheMakeDirty(pPgHdr);
45782     sqlcipher3PagerUnref(pPgHdr);
45783   }
45784
45785   return SQLCIPHER_OK;
45786 }
45787 #endif
45788
45789 /*
45790 ** Return a pointer to the data for the specified page.
45791 */
45792 SQLCIPHER_PRIVATE void *sqlcipher3PagerGetData(DbPage *pPg){
45793   assert( pPg->nRef>0 || pPg->pPager->memDb );
45794   return pPg->pData;
45795 }
45796
45797 /*
45798 ** Return a pointer to the Pager.nExtra bytes of "extra" space 
45799 ** allocated along with the specified page.
45800 */
45801 SQLCIPHER_PRIVATE void *sqlcipher3PagerGetExtra(DbPage *pPg){
45802   return pPg->pExtra;
45803 }
45804
45805 /*
45806 ** Get/set the locking-mode for this pager. Parameter eMode must be one
45807 ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or 
45808 ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
45809 ** the locking-mode is set to the value specified.
45810 **
45811 ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
45812 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
45813 ** locking-mode.
45814 */
45815 SQLCIPHER_PRIVATE int sqlcipher3PagerLockingMode(Pager *pPager, int eMode){
45816   assert( eMode==PAGER_LOCKINGMODE_QUERY
45817             || eMode==PAGER_LOCKINGMODE_NORMAL
45818             || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
45819   assert( PAGER_LOCKINGMODE_QUERY<0 );
45820   assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
45821   assert( pPager->exclusiveMode || 0==sqlcipher3WalHeapMemory(pPager->pWal) );
45822   if( eMode>=0 && !pPager->tempFile && !sqlcipher3WalHeapMemory(pPager->pWal) ){
45823     pPager->exclusiveMode = (u8)eMode;
45824   }
45825   return (int)pPager->exclusiveMode;
45826 }
45827
45828 /*
45829 ** Set the journal-mode for this pager. Parameter eMode must be one of:
45830 **
45831 **    PAGER_JOURNALMODE_DELETE
45832 **    PAGER_JOURNALMODE_TRUNCATE
45833 **    PAGER_JOURNALMODE_PERSIST
45834 **    PAGER_JOURNALMODE_OFF
45835 **    PAGER_JOURNALMODE_MEMORY
45836 **    PAGER_JOURNALMODE_WAL
45837 **
45838 ** The journalmode is set to the value specified if the change is allowed.
45839 ** The change may be disallowed for the following reasons:
45840 **
45841 **   *  An in-memory database can only have its journal_mode set to _OFF
45842 **      or _MEMORY.
45843 **
45844 **   *  Temporary databases cannot have _WAL journalmode.
45845 **
45846 ** The returned indicate the current (possibly updated) journal-mode.
45847 */
45848 SQLCIPHER_PRIVATE int sqlcipher3PagerSetJournalMode(Pager *pPager, int eMode){
45849   u8 eOld = pPager->journalMode;    /* Prior journalmode */
45850
45851 #ifdef SQLCIPHER_DEBUG
45852   /* The print_pager_state() routine is intended to be used by the debugger
45853   ** only.  We invoke it once here to suppress a compiler warning. */
45854   print_pager_state(pPager);
45855 #endif
45856
45857
45858   /* The eMode parameter is always valid */
45859   assert(      eMode==PAGER_JOURNALMODE_DELETE
45860             || eMode==PAGER_JOURNALMODE_TRUNCATE
45861             || eMode==PAGER_JOURNALMODE_PERSIST
45862             || eMode==PAGER_JOURNALMODE_OFF 
45863             || eMode==PAGER_JOURNALMODE_WAL 
45864             || eMode==PAGER_JOURNALMODE_MEMORY );
45865
45866   /* This routine is only called from the OP_JournalMode opcode, and
45867   ** the logic there will never allow a temporary file to be changed
45868   ** to WAL mode.
45869   */
45870   assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
45871
45872   /* Do allow the journalmode of an in-memory database to be set to
45873   ** anything other than MEMORY or OFF
45874   */
45875   if( MEMDB ){
45876     assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
45877     if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
45878       eMode = eOld;
45879     }
45880   }
45881
45882   if( eMode!=eOld ){
45883
45884     /* Change the journal mode. */
45885     assert( pPager->eState!=PAGER_ERROR );
45886     pPager->journalMode = (u8)eMode;
45887
45888     /* When transistioning from TRUNCATE or PERSIST to any other journal
45889     ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
45890     ** delete the journal file.
45891     */
45892     assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
45893     assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
45894     assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
45895     assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
45896     assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
45897     assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
45898
45899     assert( isOpen(pPager->fd) || pPager->exclusiveMode );
45900     if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
45901
45902       /* In this case we would like to delete the journal file. If it is
45903       ** not possible, then that is not a problem. Deleting the journal file
45904       ** here is an optimization only.
45905       **
45906       ** Before deleting the journal file, obtain a RESERVED lock on the
45907       ** database file. This ensures that the journal file is not deleted
45908       ** while it is in use by some other client.
45909       */
45910       sqlcipher3OsClose(pPager->jfd);
45911       if( pPager->eLock>=RESERVED_LOCK ){
45912         sqlcipher3OsDelete(pPager->pVfs, pPager->zJournal, 0);
45913       }else{
45914         int rc = SQLCIPHER_OK;
45915         int state = pPager->eState;
45916         assert( state==PAGER_OPEN || state==PAGER_READER );
45917         if( state==PAGER_OPEN ){
45918           rc = sqlcipher3PagerSharedLock(pPager);
45919         }
45920         if( pPager->eState==PAGER_READER ){
45921           assert( rc==SQLCIPHER_OK );
45922           rc = pagerLockDb(pPager, RESERVED_LOCK);
45923         }
45924         if( rc==SQLCIPHER_OK ){
45925           sqlcipher3OsDelete(pPager->pVfs, pPager->zJournal, 0);
45926         }
45927         if( rc==SQLCIPHER_OK && state==PAGER_READER ){
45928           pagerUnlockDb(pPager, SHARED_LOCK);
45929         }else if( state==PAGER_OPEN ){
45930           pager_unlock(pPager);
45931         }
45932         assert( state==pPager->eState );
45933       }
45934     }
45935   }
45936
45937   /* Return the new journal mode */
45938   return (int)pPager->journalMode;
45939 }
45940
45941 /*
45942 ** Return the current journal mode.
45943 */
45944 SQLCIPHER_PRIVATE int sqlcipher3PagerGetJournalMode(Pager *pPager){
45945   return (int)pPager->journalMode;
45946 }
45947
45948 /*
45949 ** Return TRUE if the pager is in a state where it is OK to change the
45950 ** journalmode.  Journalmode changes can only happen when the database
45951 ** is unmodified.
45952 */
45953 SQLCIPHER_PRIVATE int sqlcipher3PagerOkToChangeJournalMode(Pager *pPager){
45954   assert( assert_pager_state(pPager) );
45955   if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
45956   if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
45957   return 1;
45958 }
45959
45960 /*
45961 ** Get/set the size-limit used for persistent journal files.
45962 **
45963 ** Setting the size limit to -1 means no limit is enforced.
45964 ** An attempt to set a limit smaller than -1 is a no-op.
45965 */
45966 SQLCIPHER_PRIVATE i64 sqlcipher3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
45967   if( iLimit>=-1 ){
45968     pPager->journalSizeLimit = iLimit;
45969     sqlcipher3WalLimit(pPager->pWal, iLimit);
45970   }
45971   return pPager->journalSizeLimit;
45972 }
45973
45974 /*
45975 ** Return a pointer to the pPager->pBackup variable. The backup module
45976 ** in backup.c maintains the content of this variable. This module
45977 ** uses it opaquely as an argument to sqlcipher3BackupRestart() and
45978 ** sqlcipher3BackupUpdate() only.
45979 */
45980 SQLCIPHER_PRIVATE sqlcipher3_backup **sqlcipher3PagerBackupPtr(Pager *pPager){
45981   return &pPager->pBackup;
45982 }
45983
45984 #ifndef SQLCIPHER_OMIT_WAL
45985 /*
45986 ** This function is called when the user invokes "PRAGMA wal_checkpoint",
45987 ** "PRAGMA wal_blocking_checkpoint" or calls the sqlcipher3_wal_checkpoint()
45988 ** or wal_blocking_checkpoint() API functions.
45989 **
45990 ** Parameter eMode is one of SQLCIPHER_CHECKPOINT_PASSIVE, FULL or RESTART.
45991 */
45992 SQLCIPHER_PRIVATE int sqlcipher3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
45993   int rc = SQLCIPHER_OK;
45994   if( pPager->pWal ){
45995     rc = sqlcipher3WalCheckpoint(pPager->pWal, eMode,
45996         pPager->xBusyHandler, pPager->pBusyHandlerArg,
45997         pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
45998         pnLog, pnCkpt
45999     );
46000   }
46001   return rc;
46002 }
46003
46004 SQLCIPHER_PRIVATE int sqlcipher3PagerWalCallback(Pager *pPager){
46005   return sqlcipher3WalCallback(pPager->pWal);
46006 }
46007
46008 /*
46009 ** Return true if the underlying VFS for the given pager supports the
46010 ** primitives necessary for write-ahead logging.
46011 */
46012 SQLCIPHER_PRIVATE int sqlcipher3PagerWalSupported(Pager *pPager){
46013   const sqlcipher3_io_methods *pMethods = pPager->fd->pMethods;
46014   return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
46015 }
46016
46017 /*
46018 ** Attempt to take an exclusive lock on the database file. If a PENDING lock
46019 ** is obtained instead, immediately release it.
46020 */
46021 static int pagerExclusiveLock(Pager *pPager){
46022   int rc;                         /* Return code */
46023
46024   assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
46025   rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
46026   if( rc!=SQLCIPHER_OK ){
46027     /* If the attempt to grab the exclusive lock failed, release the 
46028     ** pending lock that may have been obtained instead.  */
46029     pagerUnlockDb(pPager, SHARED_LOCK);
46030   }
46031
46032   return rc;
46033 }
46034
46035 /*
46036 ** Call sqlcipher3WalOpen() to open the WAL handle. If the pager is in 
46037 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
46038 ** lock on the database file and use heap-memory to store the wal-index
46039 ** in. Otherwise, use the normal shared-memory.
46040 */
46041 static int pagerOpenWal(Pager *pPager){
46042   int rc = SQLCIPHER_OK;
46043
46044   assert( pPager->pWal==0 && pPager->tempFile==0 );
46045   assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK || pPager->noReadlock);
46046
46047   /* If the pager is already in exclusive-mode, the WAL module will use 
46048   ** heap-memory for the wal-index instead of the VFS shared-memory 
46049   ** implementation. Take the exclusive lock now, before opening the WAL
46050   ** file, to make sure this is safe.
46051   */
46052   if( pPager->exclusiveMode ){
46053     rc = pagerExclusiveLock(pPager);
46054   }
46055
46056   /* Open the connection to the log file. If this operation fails, 
46057   ** (e.g. due to malloc() failure), return an error code.
46058   */
46059   if( rc==SQLCIPHER_OK ){
46060     rc = sqlcipher3WalOpen(pPager->pVfs, 
46061         pPager->fd, pPager->zWal, pPager->exclusiveMode,
46062         pPager->journalSizeLimit, &pPager->pWal
46063     );
46064   }
46065
46066   return rc;
46067 }
46068
46069
46070 /*
46071 ** The caller must be holding a SHARED lock on the database file to call
46072 ** this function.
46073 **
46074 ** If the pager passed as the first argument is open on a real database
46075 ** file (not a temp file or an in-memory database), and the WAL file
46076 ** is not already open, make an attempt to open it now. If successful,
46077 ** return SQLCIPHER_OK. If an error occurs or the VFS used by the pager does 
46078 ** not support the xShmXXX() methods, return an error code. *pbOpen is
46079 ** not modified in either case.
46080 **
46081 ** If the pager is open on a temp-file (or in-memory database), or if
46082 ** the WAL file is already open, set *pbOpen to 1 and return SQLCIPHER_OK
46083 ** without doing anything.
46084 */
46085 SQLCIPHER_PRIVATE int sqlcipher3PagerOpenWal(
46086   Pager *pPager,                  /* Pager object */
46087   int *pbOpen                     /* OUT: Set to true if call is a no-op */
46088 ){
46089   int rc = SQLCIPHER_OK;             /* Return code */
46090
46091   assert( assert_pager_state(pPager) );
46092   assert( pPager->eState==PAGER_OPEN   || pbOpen );
46093   assert( pPager->eState==PAGER_READER || !pbOpen );
46094   assert( pbOpen==0 || *pbOpen==0 );
46095   assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
46096
46097   if( !pPager->tempFile && !pPager->pWal ){
46098     if( !sqlcipher3PagerWalSupported(pPager) ) return SQLCIPHER_CANTOPEN;
46099
46100     /* Close any rollback journal previously open */
46101     sqlcipher3OsClose(pPager->jfd);
46102
46103     rc = pagerOpenWal(pPager);
46104     if( rc==SQLCIPHER_OK ){
46105       pPager->journalMode = PAGER_JOURNALMODE_WAL;
46106       pPager->eState = PAGER_OPEN;
46107     }
46108   }else{
46109     *pbOpen = 1;
46110   }
46111
46112   return rc;
46113 }
46114
46115 /*
46116 ** This function is called to close the connection to the log file prior
46117 ** to switching from WAL to rollback mode.
46118 **
46119 ** Before closing the log file, this function attempts to take an 
46120 ** EXCLUSIVE lock on the database file. If this cannot be obtained, an
46121 ** error (SQLCIPHER_BUSY) is returned and the log connection is not closed.
46122 ** If successful, the EXCLUSIVE lock is not released before returning.
46123 */
46124 SQLCIPHER_PRIVATE int sqlcipher3PagerCloseWal(Pager *pPager){
46125   int rc = SQLCIPHER_OK;
46126
46127   assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
46128
46129   /* If the log file is not already open, but does exist in the file-system,
46130   ** it may need to be checkpointed before the connection can switch to
46131   ** rollback mode. Open it now so this can happen.
46132   */
46133   if( !pPager->pWal ){
46134     int logexists = 0;
46135     rc = pagerLockDb(pPager, SHARED_LOCK);
46136     if( rc==SQLCIPHER_OK ){
46137       rc = sqlcipher3OsAccess(
46138           pPager->pVfs, pPager->zWal, SQLCIPHER_ACCESS_EXISTS, &logexists
46139       );
46140     }
46141     if( rc==SQLCIPHER_OK && logexists ){
46142       rc = pagerOpenWal(pPager);
46143     }
46144   }
46145     
46146   /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
46147   ** the database file, the log and log-summary files will be deleted.
46148   */
46149   if( rc==SQLCIPHER_OK && pPager->pWal ){
46150     rc = pagerExclusiveLock(pPager);
46151     if( rc==SQLCIPHER_OK ){
46152       rc = sqlcipher3WalClose(pPager->pWal, pPager->ckptSyncFlags,
46153                            pPager->pageSize, (u8*)pPager->pTmpSpace);
46154       pPager->pWal = 0;
46155     }
46156   }
46157   return rc;
46158 }
46159
46160 /*
46161 ** Unless this is an in-memory or temporary database, clear the pager cache.
46162 */
46163 SQLCIPHER_PRIVATE void sqlcipher3PagerClearCache(Pager *pPager){
46164   if( !MEMDB && pPager->tempFile==0 ) pager_reset(pPager);
46165 }
46166
46167 #ifdef SQLCIPHER_HAS_CODEC
46168 /*
46169 ** This function is called by the wal module when writing page content
46170 ** into the log file.
46171 **
46172 ** This function returns a pointer to a buffer containing the encrypted
46173 ** page content. If a malloc fails, this function may return NULL.
46174 */
46175 SQLCIPHER_PRIVATE void *sqlcipher3PagerCodec(PgHdr *pPg){
46176   void *aData = 0;
46177   CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
46178   return aData;
46179 }
46180 #endif /* SQLCIPHER_HAS_CODEC */
46181
46182 #endif /* !SQLCIPHER_OMIT_WAL */
46183
46184 #endif /* SQLCIPHER_OMIT_DISKIO */
46185
46186 /* BEGIN CRYPTO */
46187 #ifdef SQLCIPHER_HAS_CODEC
46188 SQLCIPHER_PRIVATE void sqlcipher3pager_get_codec(Pager *pPager, void **ctx) {
46189   *ctx = pPager->pCodec;
46190 }
46191
46192 SQLCIPHER_PRIVATE int sqlcipher3pager_is_mj_pgno(Pager *pPager, Pgno pgno) {
46193   return (PAGER_MJ_PGNO(pPager) == pgno) ? 1 : 0;
46194 }
46195
46196 SQLCIPHER_PRIVATE sqlcipher3_file *sqlcipher3Pager_get_fd(Pager *pPager) {
46197   return (isOpen(pPager->fd)) ? pPager->fd : NULL;
46198 }
46199
46200 SQLCIPHER_PRIVATE void sqlcipher3pager_sqlcipher3PagerSetCodec(
46201   Pager *pPager,
46202   void *(*xCodec)(void*,void*,Pgno,int),
46203   void (*xCodecSizeChng)(void*,int,int),
46204   void (*xCodecFree)(void*),
46205   void *pCodec
46206 ){
46207   sqlcipher3PagerSetCodec(pPager, xCodec, xCodecSizeChng, xCodecFree, pCodec); 
46208 }
46209
46210
46211 #endif
46212 /* END CRYPTO */
46213
46214
46215 /************** End of pager.c ***********************************************/
46216 /************** Begin file wal.c *********************************************/
46217 /*
46218 ** 2010 February 1
46219 **
46220 ** The author disclaims copyright to this source code.  In place of
46221 ** a legal notice, here is a blessing:
46222 **
46223 **    May you do good and not evil.
46224 **    May you find forgiveness for yourself and forgive others.
46225 **    May you share freely, never taking more than you give.
46226 **
46227 *************************************************************************
46228 **
46229 ** This file contains the implementation of a write-ahead log (WAL) used in 
46230 ** "journal_mode=WAL" mode.
46231 **
46232 ** WRITE-AHEAD LOG (WAL) FILE FORMAT
46233 **
46234 ** A WAL file consists of a header followed by zero or more "frames".
46235 ** Each frame records the revised content of a single page from the
46236 ** database file.  All changes to the database are recorded by writing
46237 ** frames into the WAL.  Transactions commit when a frame is written that
46238 ** contains a commit marker.  A single WAL can and usually does record 
46239 ** multiple transactions.  Periodically, the content of the WAL is
46240 ** transferred back into the database file in an operation called a
46241 ** "checkpoint".
46242 **
46243 ** A single WAL file can be used multiple times.  In other words, the
46244 ** WAL can fill up with frames and then be checkpointed and then new
46245 ** frames can overwrite the old ones.  A WAL always grows from beginning
46246 ** toward the end.  Checksums and counters attached to each frame are
46247 ** used to determine which frames within the WAL are valid and which
46248 ** are leftovers from prior checkpoints.
46249 **
46250 ** The WAL header is 32 bytes in size and consists of the following eight
46251 ** big-endian 32-bit unsigned integer values:
46252 **
46253 **     0: Magic number.  0x377f0682 or 0x377f0683
46254 **     4: File format version.  Currently 3007000
46255 **     8: Database page size.  Example: 1024
46256 **    12: Checkpoint sequence number
46257 **    16: Salt-1, random integer incremented with each checkpoint
46258 **    20: Salt-2, a different random integer changing with each ckpt
46259 **    24: Checksum-1 (first part of checksum for first 24 bytes of header).
46260 **    28: Checksum-2 (second part of checksum for first 24 bytes of header).
46261 **
46262 ** Immediately following the wal-header are zero or more frames. Each
46263 ** frame consists of a 24-byte frame-header followed by a <page-size> bytes
46264 ** of page data. The frame-header is six big-endian 32-bit unsigned 
46265 ** integer values, as follows:
46266 **
46267 **     0: Page number.
46268 **     4: For commit records, the size of the database image in pages 
46269 **        after the commit. For all other records, zero.
46270 **     8: Salt-1 (copied from the header)
46271 **    12: Salt-2 (copied from the header)
46272 **    16: Checksum-1.
46273 **    20: Checksum-2.
46274 **
46275 ** A frame is considered valid if and only if the following conditions are
46276 ** true:
46277 **
46278 **    (1) The salt-1 and salt-2 values in the frame-header match
46279 **        salt values in the wal-header
46280 **
46281 **    (2) The checksum values in the final 8 bytes of the frame-header
46282 **        exactly match the checksum computed consecutively on the
46283 **        WAL header and the first 8 bytes and the content of all frames
46284 **        up to and including the current frame.
46285 **
46286 ** The checksum is computed using 32-bit big-endian integers if the
46287 ** magic number in the first 4 bytes of the WAL is 0x377f0683 and it
46288 ** is computed using little-endian if the magic number is 0x377f0682.
46289 ** The checksum values are always stored in the frame header in a
46290 ** big-endian format regardless of which byte order is used to compute
46291 ** the checksum.  The checksum is computed by interpreting the input as
46292 ** an even number of unsigned 32-bit integers: x[0] through x[N].  The
46293 ** algorithm used for the checksum is as follows:
46294 ** 
46295 **   for i from 0 to n-1 step 2:
46296 **     s0 += x[i] + s1;
46297 **     s1 += x[i+1] + s0;
46298 **   endfor
46299 **
46300 ** Note that s0 and s1 are both weighted checksums using fibonacci weights
46301 ** in reverse order (the largest fibonacci weight occurs on the first element
46302 ** of the sequence being summed.)  The s1 value spans all 32-bit 
46303 ** terms of the sequence whereas s0 omits the final term.
46304 **
46305 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
46306 ** WAL is transferred into the database, then the database is VFS.xSync-ed.
46307 ** The VFS.xSync operations serve as write barriers - all writes launched
46308 ** before the xSync must complete before any write that launches after the
46309 ** xSync begins.
46310 **
46311 ** After each checkpoint, the salt-1 value is incremented and the salt-2
46312 ** value is randomized.  This prevents old and new frames in the WAL from
46313 ** being considered valid at the same time and being checkpointing together
46314 ** following a crash.
46315 **
46316 ** READER ALGORITHM
46317 **
46318 ** To read a page from the database (call it page number P), a reader
46319 ** first checks the WAL to see if it contains page P.  If so, then the
46320 ** last valid instance of page P that is a followed by a commit frame
46321 ** or is a commit frame itself becomes the value read.  If the WAL
46322 ** contains no copies of page P that are valid and which are a commit
46323 ** frame or are followed by a commit frame, then page P is read from
46324 ** the database file.
46325 **
46326 ** To start a read transaction, the reader records the index of the last
46327 ** valid frame in the WAL.  The reader uses this recorded "mxFrame" value
46328 ** for all subsequent read operations.  New transactions can be appended
46329 ** to the WAL, but as long as the reader uses its original mxFrame value
46330 ** and ignores the newly appended content, it will see a consistent snapshot
46331 ** of the database from a single point in time.  This technique allows
46332 ** multiple concurrent readers to view different versions of the database
46333 ** content simultaneously.
46334 **
46335 ** The reader algorithm in the previous paragraphs works correctly, but 
46336 ** because frames for page P can appear anywhere within the WAL, the
46337 ** reader has to scan the entire WAL looking for page P frames.  If the
46338 ** WAL is large (multiple megabytes is typical) that scan can be slow,
46339 ** and read performance suffers.  To overcome this problem, a separate
46340 ** data structure called the wal-index is maintained to expedite the
46341 ** search for frames of a particular page.
46342 ** 
46343 ** WAL-INDEX FORMAT
46344 **
46345 ** Conceptually, the wal-index is shared memory, though VFS implementations
46346 ** might choose to implement the wal-index using a mmapped file.  Because
46347 ** the wal-index is shared memory, SQLite does not support journal_mode=WAL 
46348 ** on a network filesystem.  All users of the database must be able to
46349 ** share memory.
46350 **
46351 ** The wal-index is transient.  After a crash, the wal-index can (and should
46352 ** be) reconstructed from the original WAL file.  In fact, the VFS is required
46353 ** to either truncate or zero the header of the wal-index when the last
46354 ** connection to it closes.  Because the wal-index is transient, it can
46355 ** use an architecture-specific format; it does not have to be cross-platform.
46356 ** Hence, unlike the database and WAL file formats which store all values
46357 ** as big endian, the wal-index can store multi-byte values in the native
46358 ** byte order of the host computer.
46359 **
46360 ** The purpose of the wal-index is to answer this question quickly:  Given
46361 ** a page number P, return the index of the last frame for page P in the WAL,
46362 ** or return NULL if there are no frames for page P in the WAL.
46363 **
46364 ** The wal-index consists of a header region, followed by an one or
46365 ** more index blocks.  
46366 **
46367 ** The wal-index header contains the total number of frames within the WAL
46368 ** in the the mxFrame field.  
46369 **
46370 ** Each index block except for the first contains information on 
46371 ** HASHTABLE_NPAGE frames. The first index block contains information on
46372 ** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and 
46373 ** HASHTABLE_NPAGE are selected so that together the wal-index header and
46374 ** first index block are the same size as all other index blocks in the
46375 ** wal-index.
46376 **
46377 ** Each index block contains two sections, a page-mapping that contains the
46378 ** database page number associated with each wal frame, and a hash-table 
46379 ** that allows readers to query an index block for a specific page number.
46380 ** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE
46381 ** for the first index block) 32-bit page numbers. The first entry in the 
46382 ** first index-block contains the database page number corresponding to the
46383 ** first frame in the WAL file. The first entry in the second index block
46384 ** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in
46385 ** the log, and so on.
46386 **
46387 ** The last index block in a wal-index usually contains less than the full
46388 ** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers,
46389 ** depending on the contents of the WAL file. This does not change the
46390 ** allocated size of the page-mapping array - the page-mapping array merely
46391 ** contains unused entries.
46392 **
46393 ** Even without using the hash table, the last frame for page P
46394 ** can be found by scanning the page-mapping sections of each index block
46395 ** starting with the last index block and moving toward the first, and
46396 ** within each index block, starting at the end and moving toward the
46397 ** beginning.  The first entry that equals P corresponds to the frame
46398 ** holding the content for that page.
46399 **
46400 ** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers.
46401 ** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the
46402 ** hash table for each page number in the mapping section, so the hash 
46403 ** table is never more than half full.  The expected number of collisions 
46404 ** prior to finding a match is 1.  Each entry of the hash table is an
46405 ** 1-based index of an entry in the mapping section of the same
46406 ** index block.   Let K be the 1-based index of the largest entry in
46407 ** the mapping section.  (For index blocks other than the last, K will
46408 ** always be exactly HASHTABLE_NPAGE (4096) and for the last index block
46409 ** K will be (mxFrame%HASHTABLE_NPAGE).)  Unused slots of the hash table
46410 ** contain a value of 0.
46411 **
46412 ** To look for page P in the hash table, first compute a hash iKey on
46413 ** P as follows:
46414 **
46415 **      iKey = (P * 383) % HASHTABLE_NSLOT
46416 **
46417 ** Then start scanning entries of the hash table, starting with iKey
46418 ** (wrapping around to the beginning when the end of the hash table is
46419 ** reached) until an unused hash slot is found. Let the first unused slot
46420 ** be at index iUnused.  (iUnused might be less than iKey if there was
46421 ** wrap-around.) Because the hash table is never more than half full,
46422 ** the search is guaranteed to eventually hit an unused entry.  Let 
46423 ** iMax be the value between iKey and iUnused, closest to iUnused,
46424 ** where aHash[iMax]==P.  If there is no iMax entry (if there exists
46425 ** no hash slot such that aHash[i]==p) then page P is not in the
46426 ** current index block.  Otherwise the iMax-th mapping entry of the
46427 ** current index block corresponds to the last entry that references 
46428 ** page P.
46429 **
46430 ** A hash search begins with the last index block and moves toward the
46431 ** first index block, looking for entries corresponding to page P.  On
46432 ** average, only two or three slots in each index block need to be
46433 ** examined in order to either find the last entry for page P, or to
46434 ** establish that no such entry exists in the block.  Each index block
46435 ** holds over 4000 entries.  So two or three index blocks are sufficient
46436 ** to cover a typical 10 megabyte WAL file, assuming 1K pages.  8 or 10
46437 ** comparisons (on average) suffice to either locate a frame in the
46438 ** WAL or to establish that the frame does not exist in the WAL.  This
46439 ** is much faster than scanning the entire 10MB WAL.
46440 **
46441 ** Note that entries are added in order of increasing K.  Hence, one
46442 ** reader might be using some value K0 and a second reader that started
46443 ** at a later time (after additional transactions were added to the WAL
46444 ** and to the wal-index) might be using a different value K1, where K1>K0.
46445 ** Both readers can use the same hash table and mapping section to get
46446 ** the correct result.  There may be entries in the hash table with
46447 ** K>K0 but to the first reader, those entries will appear to be unused
46448 ** slots in the hash table and so the first reader will get an answer as
46449 ** if no values greater than K0 had ever been inserted into the hash table
46450 ** in the first place - which is what reader one wants.  Meanwhile, the
46451 ** second reader using K1 will see additional values that were inserted
46452 ** later, which is exactly what reader two wants.  
46453 **
46454 ** When a rollback occurs, the value of K is decreased. Hash table entries
46455 ** that correspond to frames greater than the new K value are removed
46456 ** from the hash table at this point.
46457 */
46458 #ifndef SQLCIPHER_OMIT_WAL
46459
46460
46461 /*
46462 ** Trace output macros
46463 */
46464 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
46465 SQLCIPHER_PRIVATE int sqlcipher3WalTrace = 0;
46466 # define WALTRACE(X)  if(sqlcipher3WalTrace) sqlcipher3DebugPrintf X
46467 #else
46468 # define WALTRACE(X)
46469 #endif
46470
46471 /*
46472 ** The maximum (and only) versions of the wal and wal-index formats
46473 ** that may be interpreted by this version of SQLite.
46474 **
46475 ** If a client begins recovering a WAL file and finds that (a) the checksum
46476 ** values in the wal-header are correct and (b) the version field is not
46477 ** WAL_MAX_VERSION, recovery fails and SQLite returns SQLCIPHER_CANTOPEN.
46478 **
46479 ** Similarly, if a client successfully reads a wal-index header (i.e. the 
46480 ** checksum test is successful) and finds that the version field is not
46481 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
46482 ** returns SQLCIPHER_CANTOPEN.
46483 */
46484 #define WAL_MAX_VERSION      3007000
46485 #define WALINDEX_MAX_VERSION 3007000
46486
46487 /*
46488 ** Indices of various locking bytes.   WAL_NREADER is the number
46489 ** of available reader locks and should be at least 3.
46490 */
46491 #define WAL_WRITE_LOCK         0
46492 #define WAL_ALL_BUT_WRITE      1
46493 #define WAL_CKPT_LOCK          1
46494 #define WAL_RECOVER_LOCK       2
46495 #define WAL_READ_LOCK(I)       (3+(I))
46496 #define WAL_NREADER            (SQLCIPHER_SHM_NLOCK-3)
46497
46498
46499 /* Object declarations */
46500 typedef struct WalIndexHdr WalIndexHdr;
46501 typedef struct WalIterator WalIterator;
46502 typedef struct WalCkptInfo WalCkptInfo;
46503
46504
46505 /*
46506 ** The following object holds a copy of the wal-index header content.
46507 **
46508 ** The actual header in the wal-index consists of two copies of this
46509 ** object.
46510 **
46511 ** The szPage value can be any power of 2 between 512 and 32768, inclusive.
46512 ** Or it can be 1 to represent a 65536-byte page.  The latter case was
46513 ** added in 3.7.1 when support for 64K pages was added.  
46514 */
46515 struct WalIndexHdr {
46516   u32 iVersion;                   /* Wal-index version */
46517   u32 unused;                     /* Unused (padding) field */
46518   u32 iChange;                    /* Counter incremented each transaction */
46519   u8 isInit;                      /* 1 when initialized */
46520   u8 bigEndCksum;                 /* True if checksums in WAL are big-endian */
46521   u16 szPage;                     /* Database page size in bytes. 1==64K */
46522   u32 mxFrame;                    /* Index of last valid frame in the WAL */
46523   u32 nPage;                      /* Size of database in pages */
46524   u32 aFrameCksum[2];             /* Checksum of last frame in log */
46525   u32 aSalt[2];                   /* Two salt values copied from WAL header */
46526   u32 aCksum[2];                  /* Checksum over all prior fields */
46527 };
46528
46529 /*
46530 ** A copy of the following object occurs in the wal-index immediately
46531 ** following the second copy of the WalIndexHdr.  This object stores
46532 ** information used by checkpoint.
46533 **
46534 ** nBackfill is the number of frames in the WAL that have been written
46535 ** back into the database. (We call the act of moving content from WAL to
46536 ** database "backfilling".)  The nBackfill number is never greater than
46537 ** WalIndexHdr.mxFrame.  nBackfill can only be increased by threads
46538 ** holding the WAL_CKPT_LOCK lock (which includes a recovery thread).
46539 ** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from
46540 ** mxFrame back to zero when the WAL is reset.
46541 **
46542 ** There is one entry in aReadMark[] for each reader lock.  If a reader
46543 ** holds read-lock K, then the value in aReadMark[K] is no greater than
46544 ** the mxFrame for that reader.  The value READMARK_NOT_USED (0xffffffff)
46545 ** for any aReadMark[] means that entry is unused.  aReadMark[0] is 
46546 ** a special case; its value is never used and it exists as a place-holder
46547 ** to avoid having to offset aReadMark[] indexs by one.  Readers holding
46548 ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content
46549 ** directly from the database.
46550 **
46551 ** The value of aReadMark[K] may only be changed by a thread that
46552 ** is holding an exclusive lock on WAL_READ_LOCK(K).  Thus, the value of
46553 ** aReadMark[K] cannot changed while there is a reader is using that mark
46554 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
46555 **
46556 ** The checkpointer may only transfer frames from WAL to database where
46557 ** the frame numbers are less than or equal to every aReadMark[] that is
46558 ** in use (that is, every aReadMark[j] for which there is a corresponding
46559 ** WAL_READ_LOCK(j)).  New readers (usually) pick the aReadMark[] with the
46560 ** largest value and will increase an unused aReadMark[] to mxFrame if there
46561 ** is not already an aReadMark[] equal to mxFrame.  The exception to the
46562 ** previous sentence is when nBackfill equals mxFrame (meaning that everything
46563 ** in the WAL has been backfilled into the database) then new readers
46564 ** will choose aReadMark[0] which has value 0 and hence such reader will
46565 ** get all their all content directly from the database file and ignore 
46566 ** the WAL.
46567 **
46568 ** Writers normally append new frames to the end of the WAL.  However,
46569 ** if nBackfill equals mxFrame (meaning that all WAL content has been
46570 ** written back into the database) and if no readers are using the WAL
46571 ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then
46572 ** the writer will first "reset" the WAL back to the beginning and start
46573 ** writing new content beginning at frame 1.
46574 **
46575 ** We assume that 32-bit loads are atomic and so no locks are needed in
46576 ** order to read from any aReadMark[] entries.
46577 */
46578 struct WalCkptInfo {
46579   u32 nBackfill;                  /* Number of WAL frames backfilled into DB */
46580   u32 aReadMark[WAL_NREADER];     /* Reader marks */
46581 };
46582 #define READMARK_NOT_USED  0xffffffff
46583
46584
46585 /* A block of WALINDEX_LOCK_RESERVED bytes beginning at
46586 ** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems
46587 ** only support mandatory file-locks, we do not read or write data
46588 ** from the region of the file on which locks are applied.
46589 */
46590 #define WALINDEX_LOCK_OFFSET   (sizeof(WalIndexHdr)*2 + sizeof(WalCkptInfo))
46591 #define WALINDEX_LOCK_RESERVED 16
46592 #define WALINDEX_HDR_SIZE      (WALINDEX_LOCK_OFFSET+WALINDEX_LOCK_RESERVED)
46593
46594 /* Size of header before each frame in wal */
46595 #define WAL_FRAME_HDRSIZE 24
46596
46597 /* Size of write ahead log header, including checksum. */
46598 /* #define WAL_HDRSIZE 24 */
46599 #define WAL_HDRSIZE 32
46600
46601 /* WAL magic value. Either this value, or the same value with the least
46602 ** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit
46603 ** big-endian format in the first 4 bytes of a WAL file.
46604 **
46605 ** If the LSB is set, then the checksums for each frame within the WAL
46606 ** file are calculated by treating all data as an array of 32-bit 
46607 ** big-endian words. Otherwise, they are calculated by interpreting 
46608 ** all data as 32-bit little-endian words.
46609 */
46610 #define WAL_MAGIC 0x377f0682
46611
46612 /*
46613 ** Return the offset of frame iFrame in the write-ahead log file, 
46614 ** assuming a database page size of szPage bytes. The offset returned
46615 ** is to the start of the write-ahead log frame-header.
46616 */
46617 #define walFrameOffset(iFrame, szPage) (                               \
46618   WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE)         \
46619 )
46620
46621 /*
46622 ** An open write-ahead log file is represented by an instance of the
46623 ** following object.
46624 */
46625 struct Wal {
46626   sqlcipher3_vfs *pVfs;         /* The VFS used to create pDbFd */
46627   sqlcipher3_file *pDbFd;       /* File handle for the database file */
46628   sqlcipher3_file *pWalFd;      /* File handle for WAL file */
46629   u32 iCallback;             /* Value to pass to log callback (or 0) */
46630   i64 mxWalSize;             /* Truncate WAL to this size upon reset */
46631   int nWiData;               /* Size of array apWiData */
46632   volatile u32 **apWiData;   /* Pointer to wal-index content in memory */
46633   u32 szPage;                /* Database page size */
46634   i16 readLock;              /* Which read lock is being held.  -1 for none */
46635   u8 exclusiveMode;          /* Non-zero if connection is in exclusive mode */
46636   u8 writeLock;              /* True if in a write transaction */
46637   u8 ckptLock;               /* True if holding a checkpoint lock */
46638   u8 readOnly;               /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */
46639   WalIndexHdr hdr;           /* Wal-index header for current transaction */
46640   const char *zWalName;      /* Name of WAL file */
46641   u32 nCkpt;                 /* Checkpoint sequence counter in the wal-header */
46642 #ifdef SQLCIPHER_DEBUG
46643   u8 lockError;              /* True if a locking error has occurred */
46644 #endif
46645 };
46646
46647 /*
46648 ** Candidate values for Wal.exclusiveMode.
46649 */
46650 #define WAL_NORMAL_MODE     0
46651 #define WAL_EXCLUSIVE_MODE  1     
46652 #define WAL_HEAPMEMORY_MODE 2
46653
46654 /*
46655 ** Possible values for WAL.readOnly
46656 */
46657 #define WAL_RDWR        0    /* Normal read/write connection */
46658 #define WAL_RDONLY      1    /* The WAL file is readonly */
46659 #define WAL_SHM_RDONLY  2    /* The SHM file is readonly */
46660
46661 /*
46662 ** Each page of the wal-index mapping contains a hash-table made up of
46663 ** an array of HASHTABLE_NSLOT elements of the following type.
46664 */
46665 typedef u16 ht_slot;
46666
46667 /*
46668 ** This structure is used to implement an iterator that loops through
46669 ** all frames in the WAL in database page order. Where two or more frames
46670 ** correspond to the same database page, the iterator visits only the 
46671 ** frame most recently written to the WAL (in other words, the frame with
46672 ** the largest index).
46673 **
46674 ** The internals of this structure are only accessed by:
46675 **
46676 **   walIteratorInit() - Create a new iterator,
46677 **   walIteratorNext() - Step an iterator,
46678 **   walIteratorFree() - Free an iterator.
46679 **
46680 ** This functionality is used by the checkpoint code (see walCheckpoint()).
46681 */
46682 struct WalIterator {
46683   int iPrior;                     /* Last result returned from the iterator */
46684   int nSegment;                   /* Number of entries in aSegment[] */
46685   struct WalSegment {
46686     int iNext;                    /* Next slot in aIndex[] not yet returned */
46687     ht_slot *aIndex;              /* i0, i1, i2... such that aPgno[iN] ascend */
46688     u32 *aPgno;                   /* Array of page numbers. */
46689     int nEntry;                   /* Nr. of entries in aPgno[] and aIndex[] */
46690     int iZero;                    /* Frame number associated with aPgno[0] */
46691   } aSegment[1];                  /* One for every 32KB page in the wal-index */
46692 };
46693
46694 /*
46695 ** Define the parameters of the hash tables in the wal-index file. There
46696 ** is a hash-table following every HASHTABLE_NPAGE page numbers in the
46697 ** wal-index.
46698 **
46699 ** Changing any of these constants will alter the wal-index format and
46700 ** create incompatibilities.
46701 */
46702 #define HASHTABLE_NPAGE      4096                 /* Must be power of 2 */
46703 #define HASHTABLE_HASH_1     383                  /* Should be prime */
46704 #define HASHTABLE_NSLOT      (HASHTABLE_NPAGE*2)  /* Must be a power of 2 */
46705
46706 /* 
46707 ** The block of page numbers associated with the first hash-table in a
46708 ** wal-index is smaller than usual. This is so that there is a complete
46709 ** hash-table on each aligned 32KB page of the wal-index.
46710 */
46711 #define HASHTABLE_NPAGE_ONE  (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
46712
46713 /* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */
46714 #define WALINDEX_PGSZ   (                                         \
46715     sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
46716 )
46717
46718 /*
46719 ** Obtain a pointer to the iPage'th page of the wal-index. The wal-index
46720 ** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are
46721 ** numbered from zero.
46722 **
46723 ** If this call is successful, *ppPage is set to point to the wal-index
46724 ** page and SQLCIPHER_OK is returned. If an error (an OOM or VFS error) occurs,
46725 ** then an SQLite error code is returned and *ppPage is set to 0.
46726 */
46727 static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){
46728   int rc = SQLCIPHER_OK;
46729
46730   /* Enlarge the pWal->apWiData[] array if required */
46731   if( pWal->nWiData<=iPage ){
46732     int nByte = sizeof(u32*)*(iPage+1);
46733     volatile u32 **apNew;
46734     apNew = (volatile u32 **)sqlcipher3_realloc((void *)pWal->apWiData, nByte);
46735     if( !apNew ){
46736       *ppPage = 0;
46737       return SQLCIPHER_NOMEM;
46738     }
46739     memset((void*)&apNew[pWal->nWiData], 0,
46740            sizeof(u32*)*(iPage+1-pWal->nWiData));
46741     pWal->apWiData = apNew;
46742     pWal->nWiData = iPage+1;
46743   }
46744
46745   /* Request a pointer to the required page from the VFS */
46746   if( pWal->apWiData[iPage]==0 ){
46747     if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
46748       pWal->apWiData[iPage] = (u32 volatile *)sqlcipher3MallocZero(WALINDEX_PGSZ);
46749       if( !pWal->apWiData[iPage] ) rc = SQLCIPHER_NOMEM;
46750     }else{
46751       rc = sqlcipher3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, 
46752           pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
46753       );
46754       if( rc==SQLCIPHER_READONLY ){
46755         pWal->readOnly |= WAL_SHM_RDONLY;
46756         rc = SQLCIPHER_OK;
46757       }
46758     }
46759   }
46760
46761   *ppPage = pWal->apWiData[iPage];
46762   assert( iPage==0 || *ppPage || rc!=SQLCIPHER_OK );
46763   return rc;
46764 }
46765
46766 /*
46767 ** Return a pointer to the WalCkptInfo structure in the wal-index.
46768 */
46769 static volatile WalCkptInfo *walCkptInfo(Wal *pWal){
46770   assert( pWal->nWiData>0 && pWal->apWiData[0] );
46771   return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
46772 }
46773
46774 /*
46775 ** Return a pointer to the WalIndexHdr structure in the wal-index.
46776 */
46777 static volatile WalIndexHdr *walIndexHdr(Wal *pWal){
46778   assert( pWal->nWiData>0 && pWal->apWiData[0] );
46779   return (volatile WalIndexHdr*)pWal->apWiData[0];
46780 }
46781
46782 /*
46783 ** The argument to this macro must be of type u32. On a little-endian
46784 ** architecture, it returns the u32 value that results from interpreting
46785 ** the 4 bytes as a big-endian value. On a big-endian architecture, it
46786 ** returns the value that would be produced by intepreting the 4 bytes
46787 ** of the input value as a little-endian integer.
46788 */
46789 #define BYTESWAP32(x) ( \
46790     (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8)  \
46791   + (((x)&0x00FF0000)>>8)  + (((x)&0xFF000000)>>24) \
46792 )
46793
46794 /*
46795 ** Generate or extend an 8 byte checksum based on the data in 
46796 ** array aByte[] and the initial values of aIn[0] and aIn[1] (or
46797 ** initial values of 0 and 0 if aIn==NULL).
46798 **
46799 ** The checksum is written back into aOut[] before returning.
46800 **
46801 ** nByte must be a positive multiple of 8.
46802 */
46803 static void walChecksumBytes(
46804   int nativeCksum, /* True for native byte-order, false for non-native */
46805   u8 *a,           /* Content to be checksummed */
46806   int nByte,       /* Bytes of content in a[].  Must be a multiple of 8. */
46807   const u32 *aIn,  /* Initial checksum value input */
46808   u32 *aOut        /* OUT: Final checksum value output */
46809 ){
46810   u32 s1, s2;
46811   u32 *aData = (u32 *)a;
46812   u32 *aEnd = (u32 *)&a[nByte];
46813
46814   if( aIn ){
46815     s1 = aIn[0];
46816     s2 = aIn[1];
46817   }else{
46818     s1 = s2 = 0;
46819   }
46820
46821   assert( nByte>=8 );
46822   assert( (nByte&0x00000007)==0 );
46823
46824   if( nativeCksum ){
46825     do {
46826       s1 += *aData++ + s2;
46827       s2 += *aData++ + s1;
46828     }while( aData<aEnd );
46829   }else{
46830     do {
46831       s1 += BYTESWAP32(aData[0]) + s2;
46832       s2 += BYTESWAP32(aData[1]) + s1;
46833       aData += 2;
46834     }while( aData<aEnd );
46835   }
46836
46837   aOut[0] = s1;
46838   aOut[1] = s2;
46839 }
46840
46841 static void walShmBarrier(Wal *pWal){
46842   if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
46843     sqlcipher3OsShmBarrier(pWal->pDbFd);
46844   }
46845 }
46846
46847 /*
46848 ** Write the header information in pWal->hdr into the wal-index.
46849 **
46850 ** The checksum on pWal->hdr is updated before it is written.
46851 */
46852 static void walIndexWriteHdr(Wal *pWal){
46853   volatile WalIndexHdr *aHdr = walIndexHdr(pWal);
46854   const int nCksum = offsetof(WalIndexHdr, aCksum);
46855
46856   assert( pWal->writeLock );
46857   pWal->hdr.isInit = 1;
46858   pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
46859   walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
46860   memcpy((void *)&aHdr[1], (void *)&pWal->hdr, sizeof(WalIndexHdr));
46861   walShmBarrier(pWal);
46862   memcpy((void *)&aHdr[0], (void *)&pWal->hdr, sizeof(WalIndexHdr));
46863 }
46864
46865 /*
46866 ** This function encodes a single frame header and writes it to a buffer
46867 ** supplied by the caller. A frame-header is made up of a series of 
46868 ** 4-byte big-endian integers, as follows:
46869 **
46870 **     0: Page number.
46871 **     4: For commit records, the size of the database image in pages 
46872 **        after the commit. For all other records, zero.
46873 **     8: Salt-1 (copied from the wal-header)
46874 **    12: Salt-2 (copied from the wal-header)
46875 **    16: Checksum-1.
46876 **    20: Checksum-2.
46877 */
46878 static void walEncodeFrame(
46879   Wal *pWal,                      /* The write-ahead log */
46880   u32 iPage,                      /* Database page number for frame */
46881   u32 nTruncate,                  /* New db size (or 0 for non-commit frames) */
46882   u8 *aData,                      /* Pointer to page data */
46883   u8 *aFrame                      /* OUT: Write encoded frame here */
46884 ){
46885   int nativeCksum;                /* True for native byte-order checksums */
46886   u32 *aCksum = pWal->hdr.aFrameCksum;
46887   assert( WAL_FRAME_HDRSIZE==24 );
46888   sqlcipher3Put4byte(&aFrame[0], iPage);
46889   sqlcipher3Put4byte(&aFrame[4], nTruncate);
46890   memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
46891
46892   nativeCksum = (pWal->hdr.bigEndCksum==SQLCIPHER_BIGENDIAN);
46893   walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
46894   walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
46895
46896   sqlcipher3Put4byte(&aFrame[16], aCksum[0]);
46897   sqlcipher3Put4byte(&aFrame[20], aCksum[1]);
46898 }
46899
46900 /*
46901 ** Check to see if the frame with header in aFrame[] and content
46902 ** in aData[] is valid.  If it is a valid frame, fill *piPage and
46903 ** *pnTruncate and return true.  Return if the frame is not valid.
46904 */
46905 static int walDecodeFrame(
46906   Wal *pWal,                      /* The write-ahead log */
46907   u32 *piPage,                    /* OUT: Database page number for frame */
46908   u32 *pnTruncate,                /* OUT: New db size (or 0 if not commit) */
46909   u8 *aData,                      /* Pointer to page data (for checksum) */
46910   u8 *aFrame                      /* Frame data */
46911 ){
46912   int nativeCksum;                /* True for native byte-order checksums */
46913   u32 *aCksum = pWal->hdr.aFrameCksum;
46914   u32 pgno;                       /* Page number of the frame */
46915   assert( WAL_FRAME_HDRSIZE==24 );
46916
46917   /* A frame is only valid if the salt values in the frame-header
46918   ** match the salt values in the wal-header. 
46919   */
46920   if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
46921     return 0;
46922   }
46923
46924   /* A frame is only valid if the page number is creater than zero.
46925   */
46926   pgno = sqlcipher3Get4byte(&aFrame[0]);
46927   if( pgno==0 ){
46928     return 0;
46929   }
46930
46931   /* A frame is only valid if a checksum of the WAL header,
46932   ** all prior frams, the first 16 bytes of this frame-header, 
46933   ** and the frame-data matches the checksum in the last 8 
46934   ** bytes of this frame-header.
46935   */
46936   nativeCksum = (pWal->hdr.bigEndCksum==SQLCIPHER_BIGENDIAN);
46937   walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
46938   walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
46939   if( aCksum[0]!=sqlcipher3Get4byte(&aFrame[16]) 
46940    || aCksum[1]!=sqlcipher3Get4byte(&aFrame[20]) 
46941   ){
46942     /* Checksum failed. */
46943     return 0;
46944   }
46945
46946   /* If we reach this point, the frame is valid.  Return the page number
46947   ** and the new database size.
46948   */
46949   *piPage = pgno;
46950   *pnTruncate = sqlcipher3Get4byte(&aFrame[4]);
46951   return 1;
46952 }
46953
46954
46955 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
46956 /*
46957 ** Names of locks.  This routine is used to provide debugging output and is not
46958 ** a part of an ordinary build.
46959 */
46960 static const char *walLockName(int lockIdx){
46961   if( lockIdx==WAL_WRITE_LOCK ){
46962     return "WRITE-LOCK";
46963   }else if( lockIdx==WAL_CKPT_LOCK ){
46964     return "CKPT-LOCK";
46965   }else if( lockIdx==WAL_RECOVER_LOCK ){
46966     return "RECOVER-LOCK";
46967   }else{
46968     static char zName[15];
46969     sqlcipher3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
46970                      lockIdx-WAL_READ_LOCK(0));
46971     return zName;
46972   }
46973 }
46974 #endif /*defined(SQLCIPHER_TEST) || defined(SQLCIPHER_DEBUG) */
46975     
46976
46977 /*
46978 ** Set or release locks on the WAL.  Locks are either shared or exclusive.
46979 ** A lock cannot be moved directly between shared and exclusive - it must go
46980 ** through the unlocked state first.
46981 **
46982 ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
46983 */
46984 static int walLockShared(Wal *pWal, int lockIdx){
46985   int rc;
46986   if( pWal->exclusiveMode ) return SQLCIPHER_OK;
46987   rc = sqlcipher3OsShmLock(pWal->pDbFd, lockIdx, 1,
46988                         SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_SHARED);
46989   WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
46990             walLockName(lockIdx), rc ? "failed" : "ok"));
46991   VVA_ONLY( pWal->lockError = (u8)(rc!=SQLCIPHER_OK && rc!=SQLCIPHER_BUSY); )
46992   return rc;
46993 }
46994 static void walUnlockShared(Wal *pWal, int lockIdx){
46995   if( pWal->exclusiveMode ) return;
46996   (void)sqlcipher3OsShmLock(pWal->pDbFd, lockIdx, 1,
46997                          SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_SHARED);
46998   WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
46999 }
47000 static int walLockExclusive(Wal *pWal, int lockIdx, int n){
47001   int rc;
47002   if( pWal->exclusiveMode ) return SQLCIPHER_OK;
47003   rc = sqlcipher3OsShmLock(pWal->pDbFd, lockIdx, n,
47004                         SQLCIPHER_SHM_LOCK | SQLCIPHER_SHM_EXCLUSIVE);
47005   WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,
47006             walLockName(lockIdx), n, rc ? "failed" : "ok"));
47007   VVA_ONLY( pWal->lockError = (u8)(rc!=SQLCIPHER_OK && rc!=SQLCIPHER_BUSY); )
47008   return rc;
47009 }
47010 static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){
47011   if( pWal->exclusiveMode ) return;
47012   (void)sqlcipher3OsShmLock(pWal->pDbFd, lockIdx, n,
47013                          SQLCIPHER_SHM_UNLOCK | SQLCIPHER_SHM_EXCLUSIVE);
47014   WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,
47015              walLockName(lockIdx), n));
47016 }
47017
47018 /*
47019 ** Compute a hash on a page number.  The resulting hash value must land
47020 ** between 0 and (HASHTABLE_NSLOT-1).  The walHashNext() function advances
47021 ** the hash to the next value in the event of a collision.
47022 */
47023 static int walHash(u32 iPage){
47024   assert( iPage>0 );
47025   assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );
47026   return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1);
47027 }
47028 static int walNextHash(int iPriorHash){
47029   return (iPriorHash+1)&(HASHTABLE_NSLOT-1);
47030 }
47031
47032 /* 
47033 ** Return pointers to the hash table and page number array stored on
47034 ** page iHash of the wal-index. The wal-index is broken into 32KB pages
47035 ** numbered starting from 0.
47036 **
47037 ** Set output variable *paHash to point to the start of the hash table
47038 ** in the wal-index file. Set *piZero to one less than the frame 
47039 ** number of the first frame indexed by this hash table. If a
47040 ** slot in the hash table is set to N, it refers to frame number 
47041 ** (*piZero+N) in the log.
47042 **
47043 ** Finally, set *paPgno so that *paPgno[1] is the page number of the
47044 ** first frame indexed by the hash table, frame (*piZero+1).
47045 */
47046 static int walHashGet(
47047   Wal *pWal,                      /* WAL handle */
47048   int iHash,                      /* Find the iHash'th table */
47049   volatile ht_slot **paHash,      /* OUT: Pointer to hash index */
47050   volatile u32 **paPgno,          /* OUT: Pointer to page number array */
47051   u32 *piZero                     /* OUT: Frame associated with *paPgno[0] */
47052 ){
47053   int rc;                         /* Return code */
47054   volatile u32 *aPgno;
47055
47056   rc = walIndexPage(pWal, iHash, &aPgno);
47057   assert( rc==SQLCIPHER_OK || iHash>0 );
47058
47059   if( rc==SQLCIPHER_OK ){
47060     u32 iZero;
47061     volatile ht_slot *aHash;
47062
47063     aHash = (volatile ht_slot *)&aPgno[HASHTABLE_NPAGE];
47064     if( iHash==0 ){
47065       aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
47066       iZero = 0;
47067     }else{
47068       iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;
47069     }
47070   
47071     *paPgno = &aPgno[-1];
47072     *paHash = aHash;
47073     *piZero = iZero;
47074   }
47075   return rc;
47076 }
47077
47078 /*
47079 ** Return the number of the wal-index page that contains the hash-table
47080 ** and page-number array that contain entries corresponding to WAL frame
47081 ** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages 
47082 ** are numbered starting from 0.
47083 */
47084 static int walFramePage(u32 iFrame){
47085   int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE;
47086   assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)
47087        && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE)
47088        && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE))
47089        && (iHash>=2 || iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)
47090        && (iHash<=2 || iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE))
47091   );
47092   return iHash;
47093 }
47094
47095 /*
47096 ** Return the page number associated with frame iFrame in this WAL.
47097 */
47098 static u32 walFramePgno(Wal *pWal, u32 iFrame){
47099   int iHash = walFramePage(iFrame);
47100   if( iHash==0 ){
47101     return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
47102   }
47103   return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
47104 }
47105
47106 /*
47107 ** Remove entries from the hash table that point to WAL slots greater
47108 ** than pWal->hdr.mxFrame.
47109 **
47110 ** This function is called whenever pWal->hdr.mxFrame is decreased due
47111 ** to a rollback or savepoint.
47112 **
47113 ** At most only the hash table containing pWal->hdr.mxFrame needs to be
47114 ** updated.  Any later hash tables will be automatically cleared when
47115 ** pWal->hdr.mxFrame advances to the point where those hash tables are
47116 ** actually needed.
47117 */
47118 static void walCleanupHash(Wal *pWal){
47119   volatile ht_slot *aHash = 0;    /* Pointer to hash table to clear */
47120   volatile u32 *aPgno = 0;        /* Page number array for hash table */
47121   u32 iZero = 0;                  /* frame == (aHash[x]+iZero) */
47122   int iLimit = 0;                 /* Zero values greater than this */
47123   int nByte;                      /* Number of bytes to zero in aPgno[] */
47124   int i;                          /* Used to iterate through aHash[] */
47125
47126   assert( pWal->writeLock );
47127   testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
47128   testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
47129   testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
47130
47131   if( pWal->hdr.mxFrame==0 ) return;
47132
47133   /* Obtain pointers to the hash-table and page-number array containing 
47134   ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
47135   ** that the page said hash-table and array reside on is already mapped.
47136   */
47137   assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
47138   assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
47139   walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &aHash, &aPgno, &iZero);
47140
47141   /* Zero all hash-table entries that correspond to frame numbers greater
47142   ** than pWal->hdr.mxFrame.
47143   */
47144   iLimit = pWal->hdr.mxFrame - iZero;
47145   assert( iLimit>0 );
47146   for(i=0; i<HASHTABLE_NSLOT; i++){
47147     if( aHash[i]>iLimit ){
47148       aHash[i] = 0;
47149     }
47150   }
47151   
47152   /* Zero the entries in the aPgno array that correspond to frames with
47153   ** frame numbers greater than pWal->hdr.mxFrame. 
47154   */
47155   nByte = (int)((char *)aHash - (char *)&aPgno[iLimit+1]);
47156   memset((void *)&aPgno[iLimit+1], 0, nByte);
47157
47158 #ifdef SQLCIPHER_ENABLE_EXPENSIVE_ASSERT
47159   /* Verify that the every entry in the mapping region is still reachable
47160   ** via the hash table even after the cleanup.
47161   */
47162   if( iLimit ){
47163     int i;           /* Loop counter */
47164     int iKey;        /* Hash key */
47165     for(i=1; i<=iLimit; i++){
47166       for(iKey=walHash(aPgno[i]); aHash[iKey]; iKey=walNextHash(iKey)){
47167         if( aHash[iKey]==i ) break;
47168       }
47169       assert( aHash[iKey]==i );
47170     }
47171   }
47172 #endif /* SQLCIPHER_ENABLE_EXPENSIVE_ASSERT */
47173 }
47174
47175
47176 /*
47177 ** Set an entry in the wal-index that will map database page number
47178 ** pPage into WAL frame iFrame.
47179 */
47180 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
47181   int rc;                         /* Return code */
47182   u32 iZero = 0;                  /* One less than frame number of aPgno[1] */
47183   volatile u32 *aPgno = 0;        /* Page number array */
47184   volatile ht_slot *aHash = 0;    /* Hash table */
47185
47186   rc = walHashGet(pWal, walFramePage(iFrame), &aHash, &aPgno, &iZero);
47187
47188   /* Assuming the wal-index file was successfully mapped, populate the
47189   ** page number array and hash table entry.
47190   */
47191   if( rc==SQLCIPHER_OK ){
47192     int iKey;                     /* Hash table key */
47193     int idx;                      /* Value to write to hash-table slot */
47194     int nCollide;                 /* Number of hash collisions */
47195
47196     idx = iFrame - iZero;
47197     assert( idx <= HASHTABLE_NSLOT/2 + 1 );
47198     
47199     /* If this is the first entry to be added to this hash-table, zero the
47200     ** entire hash table and aPgno[] array before proceding. 
47201     */
47202     if( idx==1 ){
47203       int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]);
47204       memset((void*)&aPgno[1], 0, nByte);
47205     }
47206
47207     /* If the entry in aPgno[] is already set, then the previous writer
47208     ** must have exited unexpectedly in the middle of a transaction (after
47209     ** writing one or more dirty pages to the WAL to free up memory). 
47210     ** Remove the remnants of that writers uncommitted transaction from 
47211     ** the hash-table before writing any new entries.
47212     */
47213     if( aPgno[idx] ){
47214       walCleanupHash(pWal);
47215       assert( !aPgno[idx] );
47216     }
47217
47218     /* Write the aPgno[] array entry and the hash-table slot. */
47219     nCollide = idx;
47220     for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){
47221       if( (nCollide--)==0 ) return SQLCIPHER_CORRUPT_BKPT;
47222     }
47223     aPgno[idx] = iPage;
47224     aHash[iKey] = (ht_slot)idx;
47225
47226 #ifdef SQLCIPHER_ENABLE_EXPENSIVE_ASSERT
47227     /* Verify that the number of entries in the hash table exactly equals
47228     ** the number of entries in the mapping region.
47229     */
47230     {
47231       int i;           /* Loop counter */
47232       int nEntry = 0;  /* Number of entries in the hash table */
47233       for(i=0; i<HASHTABLE_NSLOT; i++){ if( aHash[i] ) nEntry++; }
47234       assert( nEntry==idx );
47235     }
47236
47237     /* Verify that the every entry in the mapping region is reachable
47238     ** via the hash table.  This turns out to be a really, really expensive
47239     ** thing to check, so only do this occasionally - not on every
47240     ** iteration.
47241     */
47242     if( (idx&0x3ff)==0 ){
47243       int i;           /* Loop counter */
47244       for(i=1; i<=idx; i++){
47245         for(iKey=walHash(aPgno[i]); aHash[iKey]; iKey=walNextHash(iKey)){
47246           if( aHash[iKey]==i ) break;
47247         }
47248         assert( aHash[iKey]==i );
47249       }
47250     }
47251 #endif /* SQLCIPHER_ENABLE_EXPENSIVE_ASSERT */
47252   }
47253
47254
47255   return rc;
47256 }
47257
47258
47259 /*
47260 ** Recover the wal-index by reading the write-ahead log file. 
47261 **
47262 ** This routine first tries to establish an exclusive lock on the
47263 ** wal-index to prevent other threads/processes from doing anything
47264 ** with the WAL or wal-index while recovery is running.  The
47265 ** WAL_RECOVER_LOCK is also held so that other threads will know
47266 ** that this thread is running recovery.  If unable to establish
47267 ** the necessary locks, this routine returns SQLCIPHER_BUSY.
47268 */
47269 static int walIndexRecover(Wal *pWal){
47270   int rc;                         /* Return Code */
47271   i64 nSize;                      /* Size of log file */
47272   u32 aFrameCksum[2] = {0, 0};
47273   int iLock;                      /* Lock offset to lock for checkpoint */
47274   int nLock;                      /* Number of locks to hold */
47275
47276   /* Obtain an exclusive lock on all byte in the locking range not already
47277   ** locked by the caller. The caller is guaranteed to have locked the
47278   ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.
47279   ** If successful, the same bytes that are locked here are unlocked before
47280   ** this function returns.
47281   */
47282   assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
47283   assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );
47284   assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );
47285   assert( pWal->writeLock );
47286   iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
47287   nLock = SQLCIPHER_SHM_NLOCK - iLock;
47288   rc = walLockExclusive(pWal, iLock, nLock);
47289   if( rc ){
47290     return rc;
47291   }
47292   WALTRACE(("WAL%p: recovery begin...\n", pWal));
47293
47294   memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
47295
47296   rc = sqlcipher3OsFileSize(pWal->pWalFd, &nSize);
47297   if( rc!=SQLCIPHER_OK ){
47298     goto recovery_error;
47299   }
47300
47301   if( nSize>WAL_HDRSIZE ){
47302     u8 aBuf[WAL_HDRSIZE];         /* Buffer to load WAL header into */
47303     u8 *aFrame = 0;               /* Malloc'd buffer to load entire frame */
47304     int szFrame;                  /* Number of bytes in buffer aFrame[] */
47305     u8 *aData;                    /* Pointer to data part of aFrame buffer */
47306     int iFrame;                   /* Index of last frame read */
47307     i64 iOffset;                  /* Next offset to read from log file */
47308     int szPage;                   /* Page size according to the log */
47309     u32 magic;                    /* Magic value read from WAL header */
47310     u32 version;                  /* Magic value read from WAL header */
47311
47312     /* Read in the WAL header. */
47313     rc = sqlcipher3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
47314     if( rc!=SQLCIPHER_OK ){
47315       goto recovery_error;
47316     }
47317
47318     /* If the database page size is not a power of two, or is greater than
47319     ** SQLCIPHER_MAX_PAGE_SIZE, conclude that the WAL file contains no valid 
47320     ** data. Similarly, if the 'magic' value is invalid, ignore the whole
47321     ** WAL file.
47322     */
47323     magic = sqlcipher3Get4byte(&aBuf[0]);
47324     szPage = sqlcipher3Get4byte(&aBuf[8]);
47325     if( (magic&0xFFFFFFFE)!=WAL_MAGIC 
47326      || szPage&(szPage-1) 
47327      || szPage>SQLCIPHER_MAX_PAGE_SIZE 
47328      || szPage<512 
47329     ){
47330       goto finished;
47331     }
47332     pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
47333     pWal->szPage = szPage;
47334     pWal->nCkpt = sqlcipher3Get4byte(&aBuf[12]);
47335     memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
47336
47337     /* Verify that the WAL header checksum is correct */
47338     walChecksumBytes(pWal->hdr.bigEndCksum==SQLCIPHER_BIGENDIAN, 
47339         aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
47340     );
47341     if( pWal->hdr.aFrameCksum[0]!=sqlcipher3Get4byte(&aBuf[24])
47342      || pWal->hdr.aFrameCksum[1]!=sqlcipher3Get4byte(&aBuf[28])
47343     ){
47344       goto finished;
47345     }
47346
47347     /* Verify that the version number on the WAL format is one that
47348     ** are able to understand */
47349     version = sqlcipher3Get4byte(&aBuf[4]);
47350     if( version!=WAL_MAX_VERSION ){
47351       rc = SQLCIPHER_CANTOPEN_BKPT;
47352       goto finished;
47353     }
47354
47355     /* Malloc a buffer to read frames into. */
47356     szFrame = szPage + WAL_FRAME_HDRSIZE;
47357     aFrame = (u8 *)sqlcipher3_malloc(szFrame);
47358     if( !aFrame ){
47359       rc = SQLCIPHER_NOMEM;
47360       goto recovery_error;
47361     }
47362     aData = &aFrame[WAL_FRAME_HDRSIZE];
47363
47364     /* Read all frames from the log file. */
47365     iFrame = 0;
47366     for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){
47367       u32 pgno;                   /* Database page number for frame */
47368       u32 nTruncate;              /* dbsize field from frame header */
47369       int isValid;                /* True if this frame is valid */
47370
47371       /* Read and decode the next log frame. */
47372       rc = sqlcipher3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
47373       if( rc!=SQLCIPHER_OK ) break;
47374       isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
47375       if( !isValid ) break;
47376       rc = walIndexAppend(pWal, ++iFrame, pgno);
47377       if( rc!=SQLCIPHER_OK ) break;
47378
47379       /* If nTruncate is non-zero, this is a commit record. */
47380       if( nTruncate ){
47381         pWal->hdr.mxFrame = iFrame;
47382         pWal->hdr.nPage = nTruncate;
47383         pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
47384         testcase( szPage<=32768 );
47385         testcase( szPage>=65536 );
47386         aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
47387         aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
47388       }
47389     }
47390
47391     sqlcipher3_free(aFrame);
47392   }
47393
47394 finished:
47395   if( rc==SQLCIPHER_OK ){
47396     volatile WalCkptInfo *pInfo;
47397     int i;
47398     pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
47399     pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
47400     walIndexWriteHdr(pWal);
47401
47402     /* Reset the checkpoint-header. This is safe because this thread is 
47403     ** currently holding locks that exclude all other readers, writers and
47404     ** checkpointers.
47405     */
47406     pInfo = walCkptInfo(pWal);
47407     pInfo->nBackfill = 0;
47408     pInfo->aReadMark[0] = 0;
47409     for(i=1; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
47410
47411     /* If more than one frame was recovered from the log file, report an
47412     ** event via sqlcipher3_log(). This is to help with identifying performance
47413     ** problems caused by applications routinely shutting down without
47414     ** checkpointing the log file.
47415     */
47416     if( pWal->hdr.nPage ){
47417       sqlcipher3_log(SQLCIPHER_OK, "Recovered %d frames from WAL file %s",
47418           pWal->hdr.nPage, pWal->zWalName
47419       );
47420     }
47421   }
47422
47423 recovery_error:
47424   WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));
47425   walUnlockExclusive(pWal, iLock, nLock);
47426   return rc;
47427 }
47428
47429 /*
47430 ** Close an open wal-index.
47431 */
47432 static void walIndexClose(Wal *pWal, int isDelete){
47433   if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
47434     int i;
47435     for(i=0; i<pWal->nWiData; i++){
47436       sqlcipher3_free((void *)pWal->apWiData[i]);
47437       pWal->apWiData[i] = 0;
47438     }
47439   }else{
47440     sqlcipher3OsShmUnmap(pWal->pDbFd, isDelete);
47441   }
47442 }
47443
47444 /* 
47445 ** Open a connection to the WAL file zWalName. The database file must 
47446 ** already be opened on connection pDbFd. The buffer that zWalName points
47447 ** to must remain valid for the lifetime of the returned Wal* handle.
47448 **
47449 ** A SHARED lock should be held on the database file when this function
47450 ** is called. The purpose of this SHARED lock is to prevent any other
47451 ** client from unlinking the WAL or wal-index file. If another process
47452 ** were to do this just after this client opened one of these files, the
47453 ** system would be badly broken.
47454 **
47455 ** If the log file is successfully opened, SQLCIPHER_OK is returned and 
47456 ** *ppWal is set to point to a new WAL handle. If an error occurs,
47457 ** an SQLite error code is returned and *ppWal is left unmodified.
47458 */
47459 SQLCIPHER_PRIVATE int sqlcipher3WalOpen(
47460   sqlcipher3_vfs *pVfs,              /* vfs module to open wal and wal-index */
47461   sqlcipher3_file *pDbFd,            /* The open database file */
47462   const char *zWalName,           /* Name of the WAL file */
47463   int bNoShm,                     /* True to run in heap-memory mode */
47464   i64 mxWalSize,                  /* Truncate WAL to this size on reset */
47465   Wal **ppWal                     /* OUT: Allocated Wal handle */
47466 ){
47467   int rc;                         /* Return Code */
47468   Wal *pRet;                      /* Object to allocate and return */
47469   int flags;                      /* Flags passed to OsOpen() */
47470
47471   assert( zWalName && zWalName[0] );
47472   assert( pDbFd );
47473
47474   /* In the amalgamation, the os_unix.c and os_win.c source files come before
47475   ** this source file.  Verify that the #defines of the locking byte offsets
47476   ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.
47477   */
47478 #ifdef WIN_SHM_BASE
47479   assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
47480 #endif
47481 #ifdef UNIX_SHM_BASE
47482   assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
47483 #endif
47484
47485
47486   /* Allocate an instance of struct Wal to return. */
47487   *ppWal = 0;
47488   pRet = (Wal*)sqlcipher3MallocZero(sizeof(Wal) + pVfs->szOsFile);
47489   if( !pRet ){
47490     return SQLCIPHER_NOMEM;
47491   }
47492
47493   pRet->pVfs = pVfs;
47494   pRet->pWalFd = (sqlcipher3_file *)&pRet[1];
47495   pRet->pDbFd = pDbFd;
47496   pRet->readLock = -1;
47497   pRet->mxWalSize = mxWalSize;
47498   pRet->zWalName = zWalName;
47499   pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);
47500
47501   /* Open file handle on the write-ahead log file. */
47502   flags = (SQLCIPHER_OPEN_READWRITE|SQLCIPHER_OPEN_CREATE|SQLCIPHER_OPEN_WAL);
47503   rc = sqlcipher3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
47504   if( rc==SQLCIPHER_OK && flags&SQLCIPHER_OPEN_READONLY ){
47505     pRet->readOnly = WAL_RDONLY;
47506   }
47507
47508   if( rc!=SQLCIPHER_OK ){
47509     walIndexClose(pRet, 0);
47510     sqlcipher3OsClose(pRet->pWalFd);
47511     sqlcipher3_free(pRet);
47512   }else{
47513     *ppWal = pRet;
47514     WALTRACE(("WAL%d: opened\n", pRet));
47515   }
47516   return rc;
47517 }
47518
47519 /*
47520 ** Change the size to which the WAL file is trucated on each reset.
47521 */
47522 SQLCIPHER_PRIVATE void sqlcipher3WalLimit(Wal *pWal, i64 iLimit){
47523   if( pWal ) pWal->mxWalSize = iLimit;
47524 }
47525
47526 /*
47527 ** Find the smallest page number out of all pages held in the WAL that
47528 ** has not been returned by any prior invocation of this method on the
47529 ** same WalIterator object.   Write into *piFrame the frame index where
47530 ** that page was last written into the WAL.  Write into *piPage the page
47531 ** number.
47532 **
47533 ** Return 0 on success.  If there are no pages in the WAL with a page
47534 ** number larger than *piPage, then return 1.
47535 */
47536 static int walIteratorNext(
47537   WalIterator *p,               /* Iterator */
47538   u32 *piPage,                  /* OUT: The page number of the next page */
47539   u32 *piFrame                  /* OUT: Wal frame index of next page */
47540 ){
47541   u32 iMin;                     /* Result pgno must be greater than iMin */
47542   u32 iRet = 0xFFFFFFFF;        /* 0xffffffff is never a valid page number */
47543   int i;                        /* For looping through segments */
47544
47545   iMin = p->iPrior;
47546   assert( iMin<0xffffffff );
47547   for(i=p->nSegment-1; i>=0; i--){
47548     struct WalSegment *pSegment = &p->aSegment[i];
47549     while( pSegment->iNext<pSegment->nEntry ){
47550       u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
47551       if( iPg>iMin ){
47552         if( iPg<iRet ){
47553           iRet = iPg;
47554           *piFrame = pSegment->iZero + pSegment->aIndex[pSegment->iNext];
47555         }
47556         break;
47557       }
47558       pSegment->iNext++;
47559     }
47560   }
47561
47562   *piPage = p->iPrior = iRet;
47563   return (iRet==0xFFFFFFFF);
47564 }
47565
47566 /*
47567 ** This function merges two sorted lists into a single sorted list.
47568 **
47569 ** aLeft[] and aRight[] are arrays of indices.  The sort key is
47570 ** aContent[aLeft[]] and aContent[aRight[]].  Upon entry, the following
47571 ** is guaranteed for all J<K:
47572 **
47573 **        aContent[aLeft[J]] < aContent[aLeft[K]]
47574 **        aContent[aRight[J]] < aContent[aRight[K]]
47575 **
47576 ** This routine overwrites aRight[] with a new (probably longer) sequence
47577 ** of indices such that the aRight[] contains every index that appears in
47578 ** either aLeft[] or the old aRight[] and such that the second condition
47579 ** above is still met.
47580 **
47581 ** The aContent[aLeft[X]] values will be unique for all X.  And the
47582 ** aContent[aRight[X]] values will be unique too.  But there might be
47583 ** one or more combinations of X and Y such that
47584 **
47585 **      aLeft[X]!=aRight[Y]  &&  aContent[aLeft[X]] == aContent[aRight[Y]]
47586 **
47587 ** When that happens, omit the aLeft[X] and use the aRight[Y] index.
47588 */
47589 static void walMerge(
47590   const u32 *aContent,            /* Pages in wal - keys for the sort */
47591   ht_slot *aLeft,                 /* IN: Left hand input list */
47592   int nLeft,                      /* IN: Elements in array *paLeft */
47593   ht_slot **paRight,              /* IN/OUT: Right hand input list */
47594   int *pnRight,                   /* IN/OUT: Elements in *paRight */
47595   ht_slot *aTmp                   /* Temporary buffer */
47596 ){
47597   int iLeft = 0;                  /* Current index in aLeft */
47598   int iRight = 0;                 /* Current index in aRight */
47599   int iOut = 0;                   /* Current index in output buffer */
47600   int nRight = *pnRight;
47601   ht_slot *aRight = *paRight;
47602
47603   assert( nLeft>0 && nRight>0 );
47604   while( iRight<nRight || iLeft<nLeft ){
47605     ht_slot logpage;
47606     Pgno dbpage;
47607
47608     if( (iLeft<nLeft) 
47609      && (iRight>=nRight || aContent[aLeft[iLeft]]<aContent[aRight[iRight]])
47610     ){
47611       logpage = aLeft[iLeft++];
47612     }else{
47613       logpage = aRight[iRight++];
47614     }
47615     dbpage = aContent[logpage];
47616
47617     aTmp[iOut++] = logpage;
47618     if( iLeft<nLeft && aContent[aLeft[iLeft]]==dbpage ) iLeft++;
47619
47620     assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );
47621     assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );
47622   }
47623
47624   *paRight = aLeft;
47625   *pnRight = iOut;
47626   memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut);
47627 }
47628
47629 /*
47630 ** Sort the elements in list aList using aContent[] as the sort key.
47631 ** Remove elements with duplicate keys, preferring to keep the
47632 ** larger aList[] values.
47633 **
47634 ** The aList[] entries are indices into aContent[].  The values in
47635 ** aList[] are to be sorted so that for all J<K:
47636 **
47637 **      aContent[aList[J]] < aContent[aList[K]]
47638 **
47639 ** For any X and Y such that
47640 **
47641 **      aContent[aList[X]] == aContent[aList[Y]]
47642 **
47643 ** Keep the larger of the two values aList[X] and aList[Y] and discard
47644 ** the smaller.
47645 */
47646 static void walMergesort(
47647   const u32 *aContent,            /* Pages in wal */
47648   ht_slot *aBuffer,               /* Buffer of at least *pnList items to use */
47649   ht_slot *aList,                 /* IN/OUT: List to sort */
47650   int *pnList                     /* IN/OUT: Number of elements in aList[] */
47651 ){
47652   struct Sublist {
47653     int nList;                    /* Number of elements in aList */
47654     ht_slot *aList;               /* Pointer to sub-list content */
47655   };
47656
47657   const int nList = *pnList;      /* Size of input list */
47658   int nMerge = 0;                 /* Number of elements in list aMerge */
47659   ht_slot *aMerge = 0;            /* List to be merged */
47660   int iList;                      /* Index into input list */
47661   int iSub = 0;                   /* Index into aSub array */
47662   struct Sublist aSub[13];        /* Array of sub-lists */
47663
47664   memset(aSub, 0, sizeof(aSub));
47665   assert( nList<=HASHTABLE_NPAGE && nList>0 );
47666   assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
47667
47668   for(iList=0; iList<nList; iList++){
47669     nMerge = 1;
47670     aMerge = &aList[iList];
47671     for(iSub=0; iList & (1<<iSub); iSub++){
47672       struct Sublist *p = &aSub[iSub];
47673       assert( p->aList && p->nList<=(1<<iSub) );
47674       assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
47675       walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
47676     }
47677     aSub[iSub].aList = aMerge;
47678     aSub[iSub].nList = nMerge;
47679   }
47680
47681   for(iSub++; iSub<ArraySize(aSub); iSub++){
47682     if( nList & (1<<iSub) ){
47683       struct Sublist *p = &aSub[iSub];
47684       assert( p->nList<=(1<<iSub) );
47685       assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
47686       walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
47687     }
47688   }
47689   assert( aMerge==aList );
47690   *pnList = nMerge;
47691
47692 #ifdef SQLCIPHER_DEBUG
47693   {
47694     int i;
47695     for(i=1; i<*pnList; i++){
47696       assert( aContent[aList[i]] > aContent[aList[i-1]] );
47697     }
47698   }
47699 #endif
47700 }
47701
47702 /* 
47703 ** Free an iterator allocated by walIteratorInit().
47704 */
47705 static void walIteratorFree(WalIterator *p){
47706   sqlcipher3ScratchFree(p);
47707 }
47708
47709 /*
47710 ** Construct a WalInterator object that can be used to loop over all 
47711 ** pages in the WAL in ascending order. The caller must hold the checkpoint
47712 ** lock.
47713 **
47714 ** On success, make *pp point to the newly allocated WalInterator object
47715 ** return SQLCIPHER_OK. Otherwise, return an error code. If this routine
47716 ** returns an error, the value of *pp is undefined.
47717 **
47718 ** The calling routine should invoke walIteratorFree() to destroy the
47719 ** WalIterator object when it has finished with it.
47720 */
47721 static int walIteratorInit(Wal *pWal, WalIterator **pp){
47722   WalIterator *p;                 /* Return value */
47723   int nSegment;                   /* Number of segments to merge */
47724   u32 iLast;                      /* Last frame in log */
47725   int nByte;                      /* Number of bytes to allocate */
47726   int i;                          /* Iterator variable */
47727   ht_slot *aTmp;                  /* Temp space used by merge-sort */
47728   int rc = SQLCIPHER_OK;             /* Return Code */
47729
47730   /* This routine only runs while holding the checkpoint lock. And
47731   ** it only runs if there is actually content in the log (mxFrame>0).
47732   */
47733   assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
47734   iLast = pWal->hdr.mxFrame;
47735
47736   /* Allocate space for the WalIterator object. */
47737   nSegment = walFramePage(iLast) + 1;
47738   nByte = sizeof(WalIterator) 
47739         + (nSegment-1)*sizeof(struct WalSegment)
47740         + iLast*sizeof(ht_slot);
47741   p = (WalIterator *)sqlcipher3ScratchMalloc(nByte);
47742   if( !p ){
47743     return SQLCIPHER_NOMEM;
47744   }
47745   memset(p, 0, nByte);
47746   p->nSegment = nSegment;
47747
47748   /* Allocate temporary space used by the merge-sort routine. This block
47749   ** of memory will be freed before this function returns.
47750   */
47751   aTmp = (ht_slot *)sqlcipher3ScratchMalloc(
47752       sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast)
47753   );
47754   if( !aTmp ){
47755     rc = SQLCIPHER_NOMEM;
47756   }
47757
47758   for(i=0; rc==SQLCIPHER_OK && i<nSegment; i++){
47759     volatile ht_slot *aHash;
47760     u32 iZero;
47761     volatile u32 *aPgno;
47762
47763     rc = walHashGet(pWal, i, &aHash, &aPgno, &iZero);
47764     if( rc==SQLCIPHER_OK ){
47765       int j;                      /* Counter variable */
47766       int nEntry;                 /* Number of entries in this segment */
47767       ht_slot *aIndex;            /* Sorted index for this segment */
47768
47769       aPgno++;
47770       if( (i+1)==nSegment ){
47771         nEntry = (int)(iLast - iZero);
47772       }else{
47773         nEntry = (int)((u32*)aHash - (u32*)aPgno);
47774       }
47775       aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
47776       iZero++;
47777   
47778       for(j=0; j<nEntry; j++){
47779         aIndex[j] = (ht_slot)j;
47780       }
47781       walMergesort((u32 *)aPgno, aTmp, aIndex, &nEntry);
47782       p->aSegment[i].iZero = iZero;
47783       p->aSegment[i].nEntry = nEntry;
47784       p->aSegment[i].aIndex = aIndex;
47785       p->aSegment[i].aPgno = (u32 *)aPgno;
47786     }
47787   }
47788   sqlcipher3ScratchFree(aTmp);
47789
47790   if( rc!=SQLCIPHER_OK ){
47791     walIteratorFree(p);
47792   }
47793   *pp = p;
47794   return rc;
47795 }
47796
47797 /*
47798 ** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and
47799 ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
47800 ** busy-handler function. Invoke it and retry the lock until either the
47801 ** lock is successfully obtained or the busy-handler returns 0.
47802 */
47803 static int walBusyLock(
47804   Wal *pWal,                      /* WAL connection */
47805   int (*xBusy)(void*),            /* Function to call when busy */
47806   void *pBusyArg,                 /* Context argument for xBusyHandler */
47807   int lockIdx,                    /* Offset of first byte to lock */
47808   int n                           /* Number of bytes to lock */
47809 ){
47810   int rc;
47811   do {
47812     rc = walLockExclusive(pWal, lockIdx, n);
47813   }while( xBusy && rc==SQLCIPHER_BUSY && xBusy(pBusyArg) );
47814   return rc;
47815 }
47816
47817 /*
47818 ** The cache of the wal-index header must be valid to call this function.
47819 ** Return the page-size in bytes used by the database.
47820 */
47821 static int walPagesize(Wal *pWal){
47822   return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
47823 }
47824
47825 /*
47826 ** Copy as much content as we can from the WAL back into the database file
47827 ** in response to an sqlcipher3_wal_checkpoint() request or the equivalent.
47828 **
47829 ** The amount of information copies from WAL to database might be limited
47830 ** by active readers.  This routine will never overwrite a database page
47831 ** that a concurrent reader might be using.
47832 **
47833 ** All I/O barrier operations (a.k.a fsyncs) occur in this routine when
47834 ** SQLite is in WAL-mode in synchronous=NORMAL.  That means that if 
47835 ** checkpoints are always run by a background thread or background 
47836 ** process, foreground threads will never block on a lengthy fsync call.
47837 **
47838 ** Fsync is called on the WAL before writing content out of the WAL and
47839 ** into the database.  This ensures that if the new content is persistent
47840 ** in the WAL and can be recovered following a power-loss or hard reset.
47841 **
47842 ** Fsync is also called on the database file if (and only if) the entire
47843 ** WAL content is copied into the database file.  This second fsync makes
47844 ** it safe to delete the WAL since the new content will persist in the
47845 ** database file.
47846 **
47847 ** This routine uses and updates the nBackfill field of the wal-index header.
47848 ** This is the only routine tha will increase the value of nBackfill.  
47849 ** (A WAL reset or recovery will revert nBackfill to zero, but not increase
47850 ** its value.)
47851 **
47852 ** The caller must be holding sufficient locks to ensure that no other
47853 ** checkpoint is running (in any other thread or process) at the same
47854 ** time.
47855 */
47856 static int walCheckpoint(
47857   Wal *pWal,                      /* Wal connection */
47858   int eMode,                      /* One of PASSIVE, FULL or RESTART */
47859   int (*xBusyCall)(void*),        /* Function to call when busy */
47860   void *pBusyArg,                 /* Context argument for xBusyHandler */
47861   int sync_flags,                 /* Flags for OsSync() (or 0) */
47862   u8 *zBuf                        /* Temporary buffer to use */
47863 ){
47864   int rc;                         /* Return code */
47865   int szPage;                     /* Database page-size */
47866   WalIterator *pIter = 0;         /* Wal iterator context */
47867   u32 iDbpage = 0;                /* Next database page to write */
47868   u32 iFrame = 0;                 /* Wal frame containing data for iDbpage */
47869   u32 mxSafeFrame;                /* Max frame that can be backfilled */
47870   u32 mxPage;                     /* Max database page to write */
47871   int i;                          /* Loop counter */
47872   volatile WalCkptInfo *pInfo;    /* The checkpoint status information */
47873   int (*xBusy)(void*) = 0;        /* Function to call when waiting for locks */
47874
47875   szPage = walPagesize(pWal);
47876   testcase( szPage<=32768 );
47877   testcase( szPage>=65536 );
47878   pInfo = walCkptInfo(pWal);
47879   if( pInfo->nBackfill>=pWal->hdr.mxFrame ) return SQLCIPHER_OK;
47880
47881   /* Allocate the iterator */
47882   rc = walIteratorInit(pWal, &pIter);
47883   if( rc!=SQLCIPHER_OK ){
47884     return rc;
47885   }
47886   assert( pIter );
47887
47888   if( eMode!=SQLCIPHER_CHECKPOINT_PASSIVE ) xBusy = xBusyCall;
47889
47890   /* Compute in mxSafeFrame the index of the last frame of the WAL that is
47891   ** safe to write into the database.  Frames beyond mxSafeFrame might
47892   ** overwrite database pages that are in use by active readers and thus
47893   ** cannot be backfilled from the WAL.
47894   */
47895   mxSafeFrame = pWal->hdr.mxFrame;
47896   mxPage = pWal->hdr.nPage;
47897   for(i=1; i<WAL_NREADER; i++){
47898     u32 y = pInfo->aReadMark[i];
47899     if( mxSafeFrame>y ){
47900       assert( y<=pWal->hdr.mxFrame );
47901       rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
47902       if( rc==SQLCIPHER_OK ){
47903         pInfo->aReadMark[i] = READMARK_NOT_USED;
47904         walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
47905       }else if( rc==SQLCIPHER_BUSY ){
47906         mxSafeFrame = y;
47907         xBusy = 0;
47908       }else{
47909         goto walcheckpoint_out;
47910       }
47911     }
47912   }
47913
47914   if( pInfo->nBackfill<mxSafeFrame
47915    && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0), 1))==SQLCIPHER_OK
47916   ){
47917     i64 nSize;                    /* Current size of database file */
47918     u32 nBackfill = pInfo->nBackfill;
47919
47920     /* Sync the WAL to disk */
47921     if( sync_flags ){
47922       rc = sqlcipher3OsSync(pWal->pWalFd, sync_flags);
47923     }
47924
47925     /* If the database file may grow as a result of this checkpoint, hint
47926     ** about the eventual size of the db file to the VFS layer. 
47927     */
47928     if( rc==SQLCIPHER_OK ){
47929       i64 nReq = ((i64)mxPage * szPage);
47930       rc = sqlcipher3OsFileSize(pWal->pDbFd, &nSize);
47931       if( rc==SQLCIPHER_OK && nSize<nReq ){
47932         sqlcipher3OsFileControl(pWal->pDbFd, SQLCIPHER_FCNTL_SIZE_HINT, &nReq);
47933       }
47934     }
47935
47936     /* Iterate through the contents of the WAL, copying data to the db file. */
47937     while( rc==SQLCIPHER_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
47938       i64 iOffset;
47939       assert( walFramePgno(pWal, iFrame)==iDbpage );
47940       if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ) continue;
47941       iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
47942       /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
47943       rc = sqlcipher3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
47944       if( rc!=SQLCIPHER_OK ) break;
47945       iOffset = (iDbpage-1)*(i64)szPage;
47946       testcase( IS_BIG_INT(iOffset) );
47947       rc = sqlcipher3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
47948       if( rc!=SQLCIPHER_OK ) break;
47949     }
47950
47951     /* If work was actually accomplished... */
47952     if( rc==SQLCIPHER_OK ){
47953       if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
47954         i64 szDb = pWal->hdr.nPage*(i64)szPage;
47955         testcase( IS_BIG_INT(szDb) );
47956         rc = sqlcipher3OsTruncate(pWal->pDbFd, szDb);
47957         if( rc==SQLCIPHER_OK && sync_flags ){
47958           rc = sqlcipher3OsSync(pWal->pDbFd, sync_flags);
47959         }
47960       }
47961       if( rc==SQLCIPHER_OK ){
47962         pInfo->nBackfill = mxSafeFrame;
47963       }
47964     }
47965
47966     /* Release the reader lock held while backfilling */
47967     walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
47968   }
47969
47970   if( rc==SQLCIPHER_BUSY ){
47971     /* Reset the return code so as not to report a checkpoint failure
47972     ** just because there are active readers.  */
47973     rc = SQLCIPHER_OK;
47974   }
47975
47976   /* If this is an SQLCIPHER_CHECKPOINT_RESTART operation, and the entire wal
47977   ** file has been copied into the database file, then block until all
47978   ** readers have finished using the wal file. This ensures that the next
47979   ** process to write to the database restarts the wal file.
47980   */
47981   if( rc==SQLCIPHER_OK && eMode!=SQLCIPHER_CHECKPOINT_PASSIVE ){
47982     assert( pWal->writeLock );
47983     if( pInfo->nBackfill<pWal->hdr.mxFrame ){
47984       rc = SQLCIPHER_BUSY;
47985     }else if( eMode==SQLCIPHER_CHECKPOINT_RESTART ){
47986       assert( mxSafeFrame==pWal->hdr.mxFrame );
47987       rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);
47988       if( rc==SQLCIPHER_OK ){
47989         walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
47990       }
47991     }
47992   }
47993
47994  walcheckpoint_out:
47995   walIteratorFree(pIter);
47996   return rc;
47997 }
47998
47999 /*
48000 ** Close a connection to a log file.
48001 */
48002 SQLCIPHER_PRIVATE int sqlcipher3WalClose(
48003   Wal *pWal,                      /* Wal to close */
48004   int sync_flags,                 /* Flags to pass to OsSync() (or 0) */
48005   int nBuf,
48006   u8 *zBuf                        /* Buffer of at least nBuf bytes */
48007 ){
48008   int rc = SQLCIPHER_OK;
48009   if( pWal ){
48010     int isDelete = 0;             /* True to unlink wal and wal-index files */
48011
48012     /* If an EXCLUSIVE lock can be obtained on the database file (using the
48013     ** ordinary, rollback-mode locking methods, this guarantees that the
48014     ** connection associated with this log file is the only connection to
48015     ** the database. In this case checkpoint the database and unlink both
48016     ** the wal and wal-index files.
48017     **
48018     ** The EXCLUSIVE lock is not released before returning.
48019     */
48020     rc = sqlcipher3OsLock(pWal->pDbFd, SQLCIPHER_LOCK_EXCLUSIVE);
48021     if( rc==SQLCIPHER_OK ){
48022       int bPersistWal = -1;
48023       if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
48024         pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
48025       }
48026       rc = sqlcipher3WalCheckpoint(
48027           pWal, SQLCIPHER_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0
48028       );
48029       sqlcipher3OsFileControl(pWal->pDbFd, SQLCIPHER_FCNTL_PERSIST_WAL, &bPersistWal);
48030       if( rc==SQLCIPHER_OK && bPersistWal!=1 ){
48031         isDelete = 1;
48032       }
48033     }
48034
48035     walIndexClose(pWal, isDelete);
48036     sqlcipher3OsClose(pWal->pWalFd);
48037     if( isDelete ){
48038       sqlcipher3OsDelete(pWal->pVfs, pWal->zWalName, 0);
48039     }
48040     WALTRACE(("WAL%p: closed\n", pWal));
48041     sqlcipher3_free((void *)pWal->apWiData);
48042     sqlcipher3_free(pWal);
48043   }
48044   return rc;
48045 }
48046
48047 /*
48048 ** Try to read the wal-index header.  Return 0 on success and 1 if
48049 ** there is a problem.
48050 **
48051 ** The wal-index is in shared memory.  Another thread or process might
48052 ** be writing the header at the same time this procedure is trying to
48053 ** read it, which might result in inconsistency.  A dirty read is detected
48054 ** by verifying that both copies of the header are the same and also by
48055 ** a checksum on the header.
48056 **
48057 ** If and only if the read is consistent and the header is different from
48058 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
48059 ** and *pChanged is set to 1.
48060 **
48061 ** If the checksum cannot be verified return non-zero. If the header
48062 ** is read successfully and the checksum verified, return zero.
48063 */
48064 static int walIndexTryHdr(Wal *pWal, int *pChanged){
48065   u32 aCksum[2];                  /* Checksum on the header content */
48066   WalIndexHdr h1, h2;             /* Two copies of the header content */
48067   WalIndexHdr volatile *aHdr;     /* Header in shared memory */
48068
48069   /* The first page of the wal-index must be mapped at this point. */
48070   assert( pWal->nWiData>0 && pWal->apWiData[0] );
48071
48072   /* Read the header. This might happen concurrently with a write to the
48073   ** same area of shared memory on a different CPU in a SMP,
48074   ** meaning it is possible that an inconsistent snapshot is read
48075   ** from the file. If this happens, return non-zero.
48076   **
48077   ** There are two copies of the header at the beginning of the wal-index.
48078   ** When reading, read [0] first then [1].  Writes are in the reverse order.
48079   ** Memory barriers are used to prevent the compiler or the hardware from
48080   ** reordering the reads and writes.
48081   */
48082   aHdr = walIndexHdr(pWal);
48083   memcpy(&h1, (void *)&aHdr[0], sizeof(h1));
48084   walShmBarrier(pWal);
48085   memcpy(&h2, (void *)&aHdr[1], sizeof(h2));
48086
48087   if( memcmp(&h1, &h2, sizeof(h1))!=0 ){
48088     return 1;   /* Dirty read */
48089   }  
48090   if( h1.isInit==0 ){
48091     return 1;   /* Malformed header - probably all zeros */
48092   }
48093   walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum);
48094   if( aCksum[0]!=h1.aCksum[0] || aCksum[1]!=h1.aCksum[1] ){
48095     return 1;   /* Checksum does not match */
48096   }
48097
48098   if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){
48099     *pChanged = 1;
48100     memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
48101     pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
48102     testcase( pWal->szPage<=32768 );
48103     testcase( pWal->szPage>=65536 );
48104   }
48105
48106   /* The header was successfully read. Return zero. */
48107   return 0;
48108 }
48109
48110 /*
48111 ** Read the wal-index header from the wal-index and into pWal->hdr.
48112 ** If the wal-header appears to be corrupt, try to reconstruct the
48113 ** wal-index from the WAL before returning.
48114 **
48115 ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is
48116 ** changed by this opertion.  If pWal->hdr is unchanged, set *pChanged
48117 ** to 0.
48118 **
48119 ** If the wal-index header is successfully read, return SQLCIPHER_OK. 
48120 ** Otherwise an SQLite error code.
48121 */
48122 static int walIndexReadHdr(Wal *pWal, int *pChanged){
48123   int rc;                         /* Return code */
48124   int badHdr;                     /* True if a header read failed */
48125   volatile u32 *page0;            /* Chunk of wal-index containing header */
48126
48127   /* Ensure that page 0 of the wal-index (the page that contains the 
48128   ** wal-index header) is mapped. Return early if an error occurs here.
48129   */
48130   assert( pChanged );
48131   rc = walIndexPage(pWal, 0, &page0);
48132   if( rc!=SQLCIPHER_OK ){
48133     return rc;
48134   };
48135   assert( page0 || pWal->writeLock==0 );
48136
48137   /* If the first page of the wal-index has been mapped, try to read the
48138   ** wal-index header immediately, without holding any lock. This usually
48139   ** works, but may fail if the wal-index header is corrupt or currently 
48140   ** being modified by another thread or process.
48141   */
48142   badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1);
48143
48144   /* If the first attempt failed, it might have been due to a race
48145   ** with a writer.  So get a WRITE lock and try again.
48146   */
48147   assert( badHdr==0 || pWal->writeLock==0 );
48148   if( badHdr ){
48149     if( pWal->readOnly & WAL_SHM_RDONLY ){
48150       if( SQLCIPHER_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
48151         walUnlockShared(pWal, WAL_WRITE_LOCK);
48152         rc = SQLCIPHER_READONLY_RECOVERY;
48153       }
48154     }else if( SQLCIPHER_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
48155       pWal->writeLock = 1;
48156       if( SQLCIPHER_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
48157         badHdr = walIndexTryHdr(pWal, pChanged);
48158         if( badHdr ){
48159           /* If the wal-index header is still malformed even while holding
48160           ** a WRITE lock, it can only mean that the header is corrupted and
48161           ** needs to be reconstructed.  So run recovery to do exactly that.
48162           */
48163           rc = walIndexRecover(pWal);
48164           *pChanged = 1;
48165         }
48166       }
48167       pWal->writeLock = 0;
48168       walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
48169     }
48170   }
48171
48172   /* If the header is read successfully, check the version number to make
48173   ** sure the wal-index was not constructed with some future format that
48174   ** this version of SQLite cannot understand.
48175   */
48176   if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
48177     rc = SQLCIPHER_CANTOPEN_BKPT;
48178   }
48179
48180   return rc;
48181 }
48182
48183 /*
48184 ** This is the value that walTryBeginRead returns when it needs to
48185 ** be retried.
48186 */
48187 #define WAL_RETRY  (-1)
48188
48189 /*
48190 ** Attempt to start a read transaction.  This might fail due to a race or
48191 ** other transient condition.  When that happens, it returns WAL_RETRY to
48192 ** indicate to the caller that it is safe to retry immediately.
48193 **
48194 ** On success return SQLCIPHER_OK.  On a permanent failure (such an
48195 ** I/O error or an SQLCIPHER_BUSY because another process is running
48196 ** recovery) return a positive error code.
48197 **
48198 ** The useWal parameter is true to force the use of the WAL and disable
48199 ** the case where the WAL is bypassed because it has been completely
48200 ** checkpointed.  If useWal==0 then this routine calls walIndexReadHdr() 
48201 ** to make a copy of the wal-index header into pWal->hdr.  If the 
48202 ** wal-index header has changed, *pChanged is set to 1 (as an indication 
48203 ** to the caller that the local paget cache is obsolete and needs to be 
48204 ** flushed.)  When useWal==1, the wal-index header is assumed to already
48205 ** be loaded and the pChanged parameter is unused.
48206 **
48207 ** The caller must set the cnt parameter to the number of prior calls to
48208 ** this routine during the current read attempt that returned WAL_RETRY.
48209 ** This routine will start taking more aggressive measures to clear the
48210 ** race conditions after multiple WAL_RETRY returns, and after an excessive
48211 ** number of errors will ultimately return SQLCIPHER_PROTOCOL.  The
48212 ** SQLCIPHER_PROTOCOL return indicates that some other process has gone rogue
48213 ** and is not honoring the locking protocol.  There is a vanishingly small
48214 ** chance that SQLCIPHER_PROTOCOL could be returned because of a run of really
48215 ** bad luck when there is lots of contention for the wal-index, but that
48216 ** possibility is so small that it can be safely neglected, we believe.
48217 **
48218 ** On success, this routine obtains a read lock on 
48219 ** WAL_READ_LOCK(pWal->readLock).  The pWal->readLock integer is
48220 ** in the range 0 <= pWal->readLock < WAL_NREADER.  If pWal->readLock==(-1)
48221 ** that means the Wal does not hold any read lock.  The reader must not
48222 ** access any database page that is modified by a WAL frame up to and
48223 ** including frame number aReadMark[pWal->readLock].  The reader will
48224 ** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0
48225 ** Or if pWal->readLock==0, then the reader will ignore the WAL
48226 ** completely and get all content directly from the database file.
48227 ** If the useWal parameter is 1 then the WAL will never be ignored and
48228 ** this routine will always set pWal->readLock>0 on success.
48229 ** When the read transaction is completed, the caller must release the
48230 ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.
48231 **
48232 ** This routine uses the nBackfill and aReadMark[] fields of the header
48233 ** to select a particular WAL_READ_LOCK() that strives to let the
48234 ** checkpoint process do as much work as possible.  This routine might
48235 ** update values of the aReadMark[] array in the header, but if it does
48236 ** so it takes care to hold an exclusive lock on the corresponding
48237 ** WAL_READ_LOCK() while changing values.
48238 */
48239 static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){
48240   volatile WalCkptInfo *pInfo;    /* Checkpoint information in wal-index */
48241   u32 mxReadMark;                 /* Largest aReadMark[] value */
48242   int mxI;                        /* Index of largest aReadMark[] value */
48243   int i;                          /* Loop counter */
48244   int rc = SQLCIPHER_OK;             /* Return code  */
48245
48246   assert( pWal->readLock<0 );     /* Not currently locked */
48247
48248   /* Take steps to avoid spinning forever if there is a protocol error.
48249   **
48250   ** Circumstances that cause a RETRY should only last for the briefest
48251   ** instances of time.  No I/O or other system calls are done while the
48252   ** locks are held, so the locks should not be held for very long. But 
48253   ** if we are unlucky, another process that is holding a lock might get
48254   ** paged out or take a page-fault that is time-consuming to resolve, 
48255   ** during the few nanoseconds that it is holding the lock.  In that case,
48256   ** it might take longer than normal for the lock to free.
48257   **
48258   ** After 5 RETRYs, we begin calling sqlcipher3OsSleep().  The first few
48259   ** calls to sqlcipher3OsSleep() have a delay of 1 microsecond.  Really this
48260   ** is more of a scheduler yield than an actual delay.  But on the 10th
48261   ** an subsequent retries, the delays start becoming longer and longer, 
48262   ** so that on the 100th (and last) RETRY we delay for 21 milliseconds.
48263   ** The total delay time before giving up is less than 1 second.
48264   */
48265   if( cnt>5 ){
48266     int nDelay = 1;                      /* Pause time in microseconds */
48267     if( cnt>100 ){
48268       VVA_ONLY( pWal->lockError = 1; )
48269       return SQLCIPHER_PROTOCOL;
48270     }
48271     if( cnt>=10 ) nDelay = (cnt-9)*238;  /* Max delay 21ms. Total delay 996ms */
48272     sqlcipher3OsSleep(pWal->pVfs, nDelay);
48273   }
48274
48275   if( !useWal ){
48276     rc = walIndexReadHdr(pWal, pChanged);
48277     if( rc==SQLCIPHER_BUSY ){
48278       /* If there is not a recovery running in another thread or process
48279       ** then convert BUSY errors to WAL_RETRY.  If recovery is known to
48280       ** be running, convert BUSY to BUSY_RECOVERY.  There is a race here
48281       ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
48282       ** would be technically correct.  But the race is benign since with
48283       ** WAL_RETRY this routine will be called again and will probably be
48284       ** right on the second iteration.
48285       */
48286       if( pWal->apWiData[0]==0 ){
48287         /* This branch is taken when the xShmMap() method returns SQLCIPHER_BUSY.
48288         ** We assume this is a transient condition, so return WAL_RETRY. The
48289         ** xShmMap() implementation used by the default unix and win32 VFS 
48290         ** modules may return SQLCIPHER_BUSY due to a race condition in the 
48291         ** code that determines whether or not the shared-memory region 
48292         ** must be zeroed before the requested page is returned.
48293         */
48294         rc = WAL_RETRY;
48295       }else if( SQLCIPHER_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
48296         walUnlockShared(pWal, WAL_RECOVER_LOCK);
48297         rc = WAL_RETRY;
48298       }else if( rc==SQLCIPHER_BUSY ){
48299         rc = SQLCIPHER_BUSY_RECOVERY;
48300       }
48301     }
48302     if( rc!=SQLCIPHER_OK ){
48303       return rc;
48304     }
48305   }
48306
48307   pInfo = walCkptInfo(pWal);
48308   if( !useWal && pInfo->nBackfill==pWal->hdr.mxFrame ){
48309     /* The WAL has been completely backfilled (or it is empty).
48310     ** and can be safely ignored.
48311     */
48312     rc = walLockShared(pWal, WAL_READ_LOCK(0));
48313     walShmBarrier(pWal);
48314     if( rc==SQLCIPHER_OK ){
48315       if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){
48316         /* It is not safe to allow the reader to continue here if frames
48317         ** may have been appended to the log before READ_LOCK(0) was obtained.
48318         ** When holding READ_LOCK(0), the reader ignores the entire log file,
48319         ** which implies that the database file contains a trustworthy
48320         ** snapshoT. Since holding READ_LOCK(0) prevents a checkpoint from
48321         ** happening, this is usually correct.
48322         **
48323         ** However, if frames have been appended to the log (or if the log 
48324         ** is wrapped and written for that matter) before the READ_LOCK(0)
48325         ** is obtained, that is not necessarily true. A checkpointer may
48326         ** have started to backfill the appended frames but crashed before
48327         ** it finished. Leaving a corrupt image in the database file.
48328         */
48329         walUnlockShared(pWal, WAL_READ_LOCK(0));
48330         return WAL_RETRY;
48331       }
48332       pWal->readLock = 0;
48333       return SQLCIPHER_OK;
48334     }else if( rc!=SQLCIPHER_BUSY ){
48335       return rc;
48336     }
48337   }
48338
48339   /* If we get this far, it means that the reader will want to use
48340   ** the WAL to get at content from recent commits.  The job now is
48341   ** to select one of the aReadMark[] entries that is closest to
48342   ** but not exceeding pWal->hdr.mxFrame and lock that entry.
48343   */
48344   mxReadMark = 0;
48345   mxI = 0;
48346   for(i=1; i<WAL_NREADER; i++){
48347     u32 thisMark = pInfo->aReadMark[i];
48348     if( mxReadMark<=thisMark && thisMark<=pWal->hdr.mxFrame ){
48349       assert( thisMark!=READMARK_NOT_USED );
48350       mxReadMark = thisMark;
48351       mxI = i;
48352     }
48353   }
48354   /* There was once an "if" here. The extra "{" is to preserve indentation. */
48355   {
48356     if( (pWal->readOnly & WAL_SHM_RDONLY)==0
48357      && (mxReadMark<pWal->hdr.mxFrame || mxI==0)
48358     ){
48359       for(i=1; i<WAL_NREADER; i++){
48360         rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
48361         if( rc==SQLCIPHER_OK ){
48362           mxReadMark = pInfo->aReadMark[i] = pWal->hdr.mxFrame;
48363           mxI = i;
48364           walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
48365           break;
48366         }else if( rc!=SQLCIPHER_BUSY ){
48367           return rc;
48368         }
48369       }
48370     }
48371     if( mxI==0 ){
48372       assert( rc==SQLCIPHER_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
48373       return rc==SQLCIPHER_BUSY ? WAL_RETRY : SQLCIPHER_READONLY_CANTLOCK;
48374     }
48375
48376     rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
48377     if( rc ){
48378       return rc==SQLCIPHER_BUSY ? WAL_RETRY : rc;
48379     }
48380     /* Now that the read-lock has been obtained, check that neither the
48381     ** value in the aReadMark[] array or the contents of the wal-index
48382     ** header have changed.
48383     **
48384     ** It is necessary to check that the wal-index header did not change
48385     ** between the time it was read and when the shared-lock was obtained
48386     ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility
48387     ** that the log file may have been wrapped by a writer, or that frames
48388     ** that occur later in the log than pWal->hdr.mxFrame may have been
48389     ** copied into the database by a checkpointer. If either of these things
48390     ** happened, then reading the database with the current value of
48391     ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry
48392     ** instead.
48393     **
48394     ** This does not guarantee that the copy of the wal-index header is up to
48395     ** date before proceeding. That would not be possible without somehow
48396     ** blocking writers. It only guarantees that a dangerous checkpoint or 
48397     ** log-wrap (either of which would require an exclusive lock on
48398     ** WAL_READ_LOCK(mxI)) has not occurred since the snapshot was valid.
48399     */
48400     walShmBarrier(pWal);
48401     if( pInfo->aReadMark[mxI]!=mxReadMark
48402      || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
48403     ){
48404       walUnlockShared(pWal, WAL_READ_LOCK(mxI));
48405       return WAL_RETRY;
48406     }else{
48407       assert( mxReadMark<=pWal->hdr.mxFrame );
48408       pWal->readLock = (i16)mxI;
48409     }
48410   }
48411   return rc;
48412 }
48413
48414 /*
48415 ** Begin a read transaction on the database.
48416 **
48417 ** This routine used to be called sqlcipher3OpenSnapshot() and with good reason:
48418 ** it takes a snapshot of the state of the WAL and wal-index for the current
48419 ** instant in time.  The current thread will continue to use this snapshot.
48420 ** Other threads might append new content to the WAL and wal-index but
48421 ** that extra content is ignored by the current thread.
48422 **
48423 ** If the database contents have changes since the previous read
48424 ** transaction, then *pChanged is set to 1 before returning.  The
48425 ** Pager layer will use this to know that is cache is stale and
48426 ** needs to be flushed.
48427 */
48428 SQLCIPHER_PRIVATE int sqlcipher3WalBeginReadTransaction(Wal *pWal, int *pChanged){
48429   int rc;                         /* Return code */
48430   int cnt = 0;                    /* Number of TryBeginRead attempts */
48431
48432   do{
48433     rc = walTryBeginRead(pWal, pChanged, 0, ++cnt);
48434   }while( rc==WAL_RETRY );
48435   testcase( (rc&0xff)==SQLCIPHER_BUSY );
48436   testcase( (rc&0xff)==SQLCIPHER_IOERR );
48437   testcase( rc==SQLCIPHER_PROTOCOL );
48438   testcase( rc==SQLCIPHER_OK );
48439   return rc;
48440 }
48441
48442 /*
48443 ** Finish with a read transaction.  All this does is release the
48444 ** read-lock.
48445 */
48446 SQLCIPHER_PRIVATE void sqlcipher3WalEndReadTransaction(Wal *pWal){
48447   sqlcipher3WalEndWriteTransaction(pWal);
48448   if( pWal->readLock>=0 ){
48449     walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
48450     pWal->readLock = -1;
48451   }
48452 }
48453
48454 /*
48455 ** Read a page from the WAL, if it is present in the WAL and if the 
48456 ** current read transaction is configured to use the WAL.  
48457 **
48458 ** The *pInWal is set to 1 if the requested page is in the WAL and
48459 ** has been loaded.  Or *pInWal is set to 0 if the page was not in 
48460 ** the WAL and needs to be read out of the database.
48461 */
48462 SQLCIPHER_PRIVATE int sqlcipher3WalRead(
48463   Wal *pWal,                      /* WAL handle */
48464   Pgno pgno,                      /* Database page number to read data for */
48465   int *pInWal,                    /* OUT: True if data is read from WAL */
48466   int nOut,                       /* Size of buffer pOut in bytes */
48467   u8 *pOut                        /* Buffer to write page data to */
48468 ){
48469   u32 iRead = 0;                  /* If !=0, WAL frame to return data from */
48470   u32 iLast = pWal->hdr.mxFrame;  /* Last page in WAL for this reader */
48471   int iHash;                      /* Used to loop through N hash tables */
48472
48473   /* This routine is only be called from within a read transaction. */
48474   assert( pWal->readLock>=0 || pWal->lockError );
48475
48476   /* If the "last page" field of the wal-index header snapshot is 0, then
48477   ** no data will be read from the wal under any circumstances. Return early
48478   ** in this case as an optimization.  Likewise, if pWal->readLock==0, 
48479   ** then the WAL is ignored by the reader so return early, as if the 
48480   ** WAL were empty.
48481   */
48482   if( iLast==0 || pWal->readLock==0 ){
48483     *pInWal = 0;
48484     return SQLCIPHER_OK;
48485   }
48486
48487   /* Search the hash table or tables for an entry matching page number
48488   ** pgno. Each iteration of the following for() loop searches one
48489   ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames).
48490   **
48491   ** This code might run concurrently to the code in walIndexAppend()
48492   ** that adds entries to the wal-index (and possibly to this hash 
48493   ** table). This means the value just read from the hash 
48494   ** slot (aHash[iKey]) may have been added before or after the 
48495   ** current read transaction was opened. Values added after the
48496   ** read transaction was opened may have been written incorrectly -
48497   ** i.e. these slots may contain garbage data. However, we assume
48498   ** that any slots written before the current read transaction was
48499   ** opened remain unmodified.
48500   **
48501   ** For the reasons above, the if(...) condition featured in the inner
48502   ** loop of the following block is more stringent that would be required 
48503   ** if we had exclusive access to the hash-table:
48504   **
48505   **   (aPgno[iFrame]==pgno): 
48506   **     This condition filters out normal hash-table collisions.
48507   **
48508   **   (iFrame<=iLast): 
48509   **     This condition filters out entries that were added to the hash
48510   **     table after the current read-transaction had started.
48511   */
48512   for(iHash=walFramePage(iLast); iHash>=0 && iRead==0; iHash--){
48513     volatile ht_slot *aHash;      /* Pointer to hash table */
48514     volatile u32 *aPgno;          /* Pointer to array of page numbers */
48515     u32 iZero;                    /* Frame number corresponding to aPgno[0] */
48516     int iKey;                     /* Hash slot index */
48517     int nCollide;                 /* Number of hash collisions remaining */
48518     int rc;                       /* Error code */
48519
48520     rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);
48521     if( rc!=SQLCIPHER_OK ){
48522       return rc;
48523     }
48524     nCollide = HASHTABLE_NSLOT;
48525     for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
48526       u32 iFrame = aHash[iKey] + iZero;
48527       if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
48528         assert( iFrame>iRead );
48529         iRead = iFrame;
48530       }
48531       if( (nCollide--)==0 ){
48532         return SQLCIPHER_CORRUPT_BKPT;
48533       }
48534     }
48535   }
48536
48537 #ifdef SQLCIPHER_ENABLE_EXPENSIVE_ASSERT
48538   /* If expensive assert() statements are available, do a linear search
48539   ** of the wal-index file content. Make sure the results agree with the
48540   ** result obtained using the hash indexes above.  */
48541   {
48542     u32 iRead2 = 0;
48543     u32 iTest;
48544     for(iTest=iLast; iTest>0; iTest--){
48545       if( walFramePgno(pWal, iTest)==pgno ){
48546         iRead2 = iTest;
48547         break;
48548       }
48549     }
48550     assert( iRead==iRead2 );
48551   }
48552 #endif
48553
48554   /* If iRead is non-zero, then it is the log frame number that contains the
48555   ** required page. Read and return data from the log file.
48556   */
48557   if( iRead ){
48558     int sz;
48559     i64 iOffset;
48560     sz = pWal->hdr.szPage;
48561     sz = (sz&0xfe00) + ((sz&0x0001)<<16);
48562     testcase( sz<=32768 );
48563     testcase( sz>=65536 );
48564     iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
48565     *pInWal = 1;
48566     /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
48567     return sqlcipher3OsRead(pWal->pWalFd, pOut, nOut, iOffset);
48568   }
48569
48570   *pInWal = 0;
48571   return SQLCIPHER_OK;
48572 }
48573
48574
48575 /* 
48576 ** Return the size of the database in pages (or zero, if unknown).
48577 */
48578 SQLCIPHER_PRIVATE Pgno sqlcipher3WalDbsize(Wal *pWal){
48579   if( pWal && ALWAYS(pWal->readLock>=0) ){
48580     return pWal->hdr.nPage;
48581   }
48582   return 0;
48583 }
48584
48585
48586 /* 
48587 ** This function starts a write transaction on the WAL.
48588 **
48589 ** A read transaction must have already been started by a prior call
48590 ** to sqlcipher3WalBeginReadTransaction().
48591 **
48592 ** If another thread or process has written into the database since
48593 ** the read transaction was started, then it is not possible for this
48594 ** thread to write as doing so would cause a fork.  So this routine
48595 ** returns SQLCIPHER_BUSY in that case and no write transaction is started.
48596 **
48597 ** There can only be a single writer active at a time.
48598 */
48599 SQLCIPHER_PRIVATE int sqlcipher3WalBeginWriteTransaction(Wal *pWal){
48600   int rc;
48601
48602   /* Cannot start a write transaction without first holding a read
48603   ** transaction. */
48604   assert( pWal->readLock>=0 );
48605
48606   if( pWal->readOnly ){
48607     return SQLCIPHER_READONLY;
48608   }
48609
48610   /* Only one writer allowed at a time.  Get the write lock.  Return
48611   ** SQLCIPHER_BUSY if unable.
48612   */
48613   rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
48614   if( rc ){
48615     return rc;
48616   }
48617   pWal->writeLock = 1;
48618
48619   /* If another connection has written to the database file since the
48620   ** time the read transaction on this connection was started, then
48621   ** the write is disallowed.
48622   */
48623   if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
48624     walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
48625     pWal->writeLock = 0;
48626     rc = SQLCIPHER_BUSY;
48627   }
48628
48629   return rc;
48630 }
48631
48632 /*
48633 ** End a write transaction.  The commit has already been done.  This
48634 ** routine merely releases the lock.
48635 */
48636 SQLCIPHER_PRIVATE int sqlcipher3WalEndWriteTransaction(Wal *pWal){
48637   if( pWal->writeLock ){
48638     walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
48639     pWal->writeLock = 0;
48640   }
48641   return SQLCIPHER_OK;
48642 }
48643
48644 /*
48645 ** If any data has been written (but not committed) to the log file, this
48646 ** function moves the write-pointer back to the start of the transaction.
48647 **
48648 ** Additionally, the callback function is invoked for each frame written
48649 ** to the WAL since the start of the transaction. If the callback returns
48650 ** other than SQLCIPHER_OK, it is not invoked again and the error code is
48651 ** returned to the caller.
48652 **
48653 ** Otherwise, if the callback function does not return an error, this
48654 ** function returns SQLCIPHER_OK.
48655 */
48656 SQLCIPHER_PRIVATE int sqlcipher3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
48657   int rc = SQLCIPHER_OK;
48658   if( ALWAYS(pWal->writeLock) ){
48659     Pgno iMax = pWal->hdr.mxFrame;
48660     Pgno iFrame;
48661   
48662     /* Restore the clients cache of the wal-index header to the state it
48663     ** was in before the client began writing to the database. 
48664     */
48665     memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
48666
48667     for(iFrame=pWal->hdr.mxFrame+1; 
48668         ALWAYS(rc==SQLCIPHER_OK) && iFrame<=iMax; 
48669         iFrame++
48670     ){
48671       /* This call cannot fail. Unless the page for which the page number
48672       ** is passed as the second argument is (a) in the cache and 
48673       ** (b) has an outstanding reference, then xUndo is either a no-op
48674       ** (if (a) is false) or simply expels the page from the cache (if (b)
48675       ** is false).
48676       **
48677       ** If the upper layer is doing a rollback, it is guaranteed that there
48678       ** are no outstanding references to any page other than page 1. And
48679       ** page 1 is never written to the log until the transaction is
48680       ** committed. As a result, the call to xUndo may not fail.
48681       */
48682       assert( walFramePgno(pWal, iFrame)!=1 );
48683       rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));
48684     }
48685     walCleanupHash(pWal);
48686   }
48687   assert( rc==SQLCIPHER_OK );
48688   return rc;
48689 }
48690
48691 /* 
48692 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32 
48693 ** values. This function populates the array with values required to 
48694 ** "rollback" the write position of the WAL handle back to the current 
48695 ** point in the event of a savepoint rollback (via WalSavepointUndo()).
48696 */
48697 SQLCIPHER_PRIVATE void sqlcipher3WalSavepoint(Wal *pWal, u32 *aWalData){
48698   assert( pWal->writeLock );
48699   aWalData[0] = pWal->hdr.mxFrame;
48700   aWalData[1] = pWal->hdr.aFrameCksum[0];
48701   aWalData[2] = pWal->hdr.aFrameCksum[1];
48702   aWalData[3] = pWal->nCkpt;
48703 }
48704
48705 /* 
48706 ** Move the write position of the WAL back to the point identified by
48707 ** the values in the aWalData[] array. aWalData must point to an array
48708 ** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated
48709 ** by a call to WalSavepoint().
48710 */
48711 SQLCIPHER_PRIVATE int sqlcipher3WalSavepointUndo(Wal *pWal, u32 *aWalData){
48712   int rc = SQLCIPHER_OK;
48713
48714   assert( pWal->writeLock );
48715   assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
48716
48717   if( aWalData[3]!=pWal->nCkpt ){
48718     /* This savepoint was opened immediately after the write-transaction
48719     ** was started. Right after that, the writer decided to wrap around
48720     ** to the start of the log. Update the savepoint values to match.
48721     */
48722     aWalData[0] = 0;
48723     aWalData[3] = pWal->nCkpt;
48724   }
48725
48726   if( aWalData[0]<pWal->hdr.mxFrame ){
48727     pWal->hdr.mxFrame = aWalData[0];
48728     pWal->hdr.aFrameCksum[0] = aWalData[1];
48729     pWal->hdr.aFrameCksum[1] = aWalData[2];
48730     walCleanupHash(pWal);
48731   }
48732
48733   return rc;
48734 }
48735
48736 /*
48737 ** This function is called just before writing a set of frames to the log
48738 ** file (see sqlcipher3WalFrames()). It checks to see if, instead of appending
48739 ** to the current log file, it is possible to overwrite the start of the
48740 ** existing log file with the new frames (i.e. "reset" the log). If so,
48741 ** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left
48742 ** unchanged.
48743 **
48744 ** SQLCIPHER_OK is returned if no error is encountered (regardless of whether
48745 ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
48746 ** if an error occurs.
48747 */
48748 static int walRestartLog(Wal *pWal){
48749   int rc = SQLCIPHER_OK;
48750   int cnt;
48751
48752   if( pWal->readLock==0 ){
48753     volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
48754     assert( pInfo->nBackfill==pWal->hdr.mxFrame );
48755     if( pInfo->nBackfill>0 ){
48756       u32 salt1;
48757       sqlcipher3_randomness(4, &salt1);
48758       rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
48759       if( rc==SQLCIPHER_OK ){
48760         /* If all readers are using WAL_READ_LOCK(0) (in other words if no
48761         ** readers are currently using the WAL), then the transactions
48762         ** frames will overwrite the start of the existing log. Update the
48763         ** wal-index header to reflect this.
48764         **
48765         ** In theory it would be Ok to update the cache of the header only
48766         ** at this point. But updating the actual wal-index header is also
48767         ** safe and means there is no special case for sqlcipher3WalUndo()
48768         ** to handle if this transaction is rolled back.
48769         */
48770         int i;                    /* Loop counter */
48771         u32 *aSalt = pWal->hdr.aSalt;       /* Big-endian salt values */
48772
48773         /* Limit the size of WAL file if the journal_size_limit PRAGMA is
48774         ** set to a non-negative value.  Log errors encountered
48775         ** during the truncation attempt. */
48776         if( pWal->mxWalSize>=0 ){
48777           i64 sz;
48778           int rx;
48779           sqlcipher3BeginBenignMalloc();
48780           rx = sqlcipher3OsFileSize(pWal->pWalFd, &sz);
48781           if( rx==SQLCIPHER_OK && (sz > pWal->mxWalSize) ){
48782             rx = sqlcipher3OsTruncate(pWal->pWalFd, pWal->mxWalSize);
48783           }
48784           sqlcipher3EndBenignMalloc();
48785           if( rx ){
48786             sqlcipher3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
48787           }
48788         }
48789
48790         pWal->nCkpt++;
48791         pWal->hdr.mxFrame = 0;
48792         sqlcipher3Put4byte((u8*)&aSalt[0], 1 + sqlcipher3Get4byte((u8*)&aSalt[0]));
48793         aSalt[1] = salt1;
48794         walIndexWriteHdr(pWal);
48795         pInfo->nBackfill = 0;
48796         for(i=1; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
48797         assert( pInfo->aReadMark[0]==0 );
48798         walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
48799       }else if( rc!=SQLCIPHER_BUSY ){
48800         return rc;
48801       }
48802     }
48803     walUnlockShared(pWal, WAL_READ_LOCK(0));
48804     pWal->readLock = -1;
48805     cnt = 0;
48806     do{
48807       int notUsed;
48808       rc = walTryBeginRead(pWal, &notUsed, 1, ++cnt);
48809     }while( rc==WAL_RETRY );
48810     assert( (rc&0xff)!=SQLCIPHER_BUSY ); /* BUSY not possible when useWal==1 */
48811     testcase( (rc&0xff)==SQLCIPHER_IOERR );
48812     testcase( rc==SQLCIPHER_PROTOCOL );
48813     testcase( rc==SQLCIPHER_OK );
48814   }
48815   return rc;
48816 }
48817
48818 /* 
48819 ** Write a set of frames to the log. The caller must hold the write-lock
48820 ** on the log file (obtained using sqlcipher3WalBeginWriteTransaction()).
48821 */
48822 SQLCIPHER_PRIVATE int sqlcipher3WalFrames(
48823   Wal *pWal,                      /* Wal handle to write to */
48824   int szPage,                     /* Database page-size in bytes */
48825   PgHdr *pList,                   /* List of dirty pages to write */
48826   Pgno nTruncate,                 /* Database size after this commit */
48827   int isCommit,                   /* True if this is a commit */
48828   int sync_flags                  /* Flags to pass to OsSync() (or 0) */
48829 ){
48830   int rc;                         /* Used to catch return codes */
48831   u32 iFrame;                     /* Next frame address */
48832   u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-header in */
48833   PgHdr *p;                       /* Iterator to run through pList with. */
48834   PgHdr *pLast = 0;               /* Last frame in list */
48835   int nLast = 0;                  /* Number of extra copies of last page */
48836
48837   assert( pList );
48838   assert( pWal->writeLock );
48839
48840 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
48841   { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
48842     WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n",
48843               pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
48844   }
48845 #endif
48846
48847   /* See if it is possible to write these frames into the start of the
48848   ** log file, instead of appending to it at pWal->hdr.mxFrame.
48849   */
48850   if( SQLCIPHER_OK!=(rc = walRestartLog(pWal)) ){
48851     return rc;
48852   }
48853
48854   /* If this is the first frame written into the log, write the WAL
48855   ** header to the start of the WAL file. See comments at the top of
48856   ** this source file for a description of the WAL header format.
48857   */
48858   iFrame = pWal->hdr.mxFrame;
48859   if( iFrame==0 ){
48860     u8 aWalHdr[WAL_HDRSIZE];      /* Buffer to assemble wal-header in */
48861     u32 aCksum[2];                /* Checksum for wal-header */
48862
48863     sqlcipher3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLCIPHER_BIGENDIAN));
48864     sqlcipher3Put4byte(&aWalHdr[4], WAL_MAX_VERSION);
48865     sqlcipher3Put4byte(&aWalHdr[8], szPage);
48866     sqlcipher3Put4byte(&aWalHdr[12], pWal->nCkpt);
48867     sqlcipher3_randomness(8, pWal->hdr.aSalt);
48868     memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
48869     walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum);
48870     sqlcipher3Put4byte(&aWalHdr[24], aCksum[0]);
48871     sqlcipher3Put4byte(&aWalHdr[28], aCksum[1]);
48872     
48873     pWal->szPage = szPage;
48874     pWal->hdr.bigEndCksum = SQLCIPHER_BIGENDIAN;
48875     pWal->hdr.aFrameCksum[0] = aCksum[0];
48876     pWal->hdr.aFrameCksum[1] = aCksum[1];
48877
48878     rc = sqlcipher3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
48879     WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
48880     if( rc!=SQLCIPHER_OK ){
48881       return rc;
48882     }
48883   }
48884   assert( (int)pWal->szPage==szPage );
48885
48886   /* Write the log file. */
48887   for(p=pList; p; p=p->pDirty){
48888     u32 nDbsize;                  /* Db-size field for frame header */
48889     i64 iOffset;                  /* Write offset in log file */
48890     void *pData;
48891    
48892     iOffset = walFrameOffset(++iFrame, szPage);
48893     /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
48894     
48895     /* Populate and write the frame header */
48896     nDbsize = (isCommit && p->pDirty==0) ? nTruncate : 0;
48897 #if defined(SQLCIPHER_HAS_CODEC)
48898     if( (pData = sqlcipher3PagerCodec(p))==0 ) return SQLCIPHER_NOMEM;
48899 #else
48900     pData = p->pData;
48901 #endif
48902     walEncodeFrame(pWal, p->pgno, nDbsize, pData, aFrame);
48903     rc = sqlcipher3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
48904     if( rc!=SQLCIPHER_OK ){
48905       return rc;
48906     }
48907
48908     /* Write the page data */
48909     rc = sqlcipher3OsWrite(pWal->pWalFd, pData, szPage, iOffset+sizeof(aFrame));
48910     if( rc!=SQLCIPHER_OK ){
48911       return rc;
48912     }
48913     pLast = p;
48914   }
48915
48916   /* Sync the log file if the 'isSync' flag was specified. */
48917   if( sync_flags ){
48918     i64 iSegment = sqlcipher3OsSectorSize(pWal->pWalFd);
48919     i64 iOffset = walFrameOffset(iFrame+1, szPage);
48920
48921     assert( isCommit );
48922     assert( iSegment>0 );
48923
48924     iSegment = (((iOffset+iSegment-1)/iSegment) * iSegment);
48925     while( iOffset<iSegment ){
48926       void *pData;
48927 #if defined(SQLCIPHER_HAS_CODEC)
48928       if( (pData = sqlcipher3PagerCodec(pLast))==0 ) return SQLCIPHER_NOMEM;
48929 #else
48930       pData = pLast->pData;
48931 #endif
48932       walEncodeFrame(pWal, pLast->pgno, nTruncate, pData, aFrame);
48933       /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
48934       rc = sqlcipher3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
48935       if( rc!=SQLCIPHER_OK ){
48936         return rc;
48937       }
48938       iOffset += WAL_FRAME_HDRSIZE;
48939       rc = sqlcipher3OsWrite(pWal->pWalFd, pData, szPage, iOffset); 
48940       if( rc!=SQLCIPHER_OK ){
48941         return rc;
48942       }
48943       nLast++;
48944       iOffset += szPage;
48945     }
48946
48947     rc = sqlcipher3OsSync(pWal->pWalFd, sync_flags);
48948   }
48949
48950   /* Append data to the wal-index. It is not necessary to lock the 
48951   ** wal-index to do this as the SQLCIPHER_SHM_WRITE lock held on the wal-index
48952   ** guarantees that there are no other writers, and no data that may
48953   ** be in use by existing readers is being overwritten.
48954   */
48955   iFrame = pWal->hdr.mxFrame;
48956   for(p=pList; p && rc==SQLCIPHER_OK; p=p->pDirty){
48957     iFrame++;
48958     rc = walIndexAppend(pWal, iFrame, p->pgno);
48959   }
48960   while( nLast>0 && rc==SQLCIPHER_OK ){
48961     iFrame++;
48962     nLast--;
48963     rc = walIndexAppend(pWal, iFrame, pLast->pgno);
48964   }
48965
48966   if( rc==SQLCIPHER_OK ){
48967     /* Update the private copy of the header. */
48968     pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
48969     testcase( szPage<=32768 );
48970     testcase( szPage>=65536 );
48971     pWal->hdr.mxFrame = iFrame;
48972     if( isCommit ){
48973       pWal->hdr.iChange++;
48974       pWal->hdr.nPage = nTruncate;
48975     }
48976     /* If this is a commit, update the wal-index header too. */
48977     if( isCommit ){
48978       walIndexWriteHdr(pWal);
48979       pWal->iCallback = iFrame;
48980     }
48981   }
48982
48983   WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok"));
48984   return rc;
48985 }
48986
48987 /* 
48988 ** This routine is called to implement sqlcipher3_wal_checkpoint() and
48989 ** related interfaces.
48990 **
48991 ** Obtain a CHECKPOINT lock and then backfill as much information as
48992 ** we can from WAL into the database.
48993 **
48994 ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
48995 ** callback. In this case this function runs a blocking checkpoint.
48996 */
48997 SQLCIPHER_PRIVATE int sqlcipher3WalCheckpoint(
48998   Wal *pWal,                      /* Wal connection */
48999   int eMode,                      /* PASSIVE, FULL or RESTART */
49000   int (*xBusy)(void*),            /* Function to call when busy */
49001   void *pBusyArg,                 /* Context argument for xBusyHandler */
49002   int sync_flags,                 /* Flags to sync db file with (or 0) */
49003   int nBuf,                       /* Size of temporary buffer */
49004   u8 *zBuf,                       /* Temporary buffer to use */
49005   int *pnLog,                     /* OUT: Number of frames in WAL */
49006   int *pnCkpt                     /* OUT: Number of backfilled frames in WAL */
49007 ){
49008   int rc;                         /* Return code */
49009   int isChanged = 0;              /* True if a new wal-index header is loaded */
49010   int eMode2 = eMode;             /* Mode to pass to walCheckpoint() */
49011
49012   assert( pWal->ckptLock==0 );
49013   assert( pWal->writeLock==0 );
49014
49015   if( pWal->readOnly ) return SQLCIPHER_READONLY;
49016   WALTRACE(("WAL%p: checkpoint begins\n", pWal));
49017   rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
49018   if( rc ){
49019     /* Usually this is SQLCIPHER_BUSY meaning that another thread or process
49020     ** is already running a checkpoint, or maybe a recovery.  But it might
49021     ** also be SQLCIPHER_IOERR. */
49022     return rc;
49023   }
49024   pWal->ckptLock = 1;
49025
49026   /* If this is a blocking-checkpoint, then obtain the write-lock as well
49027   ** to prevent any writers from running while the checkpoint is underway.
49028   ** This has to be done before the call to walIndexReadHdr() below.
49029   **
49030   ** If the writer lock cannot be obtained, then a passive checkpoint is
49031   ** run instead. Since the checkpointer is not holding the writer lock,
49032   ** there is no point in blocking waiting for any readers. Assuming no 
49033   ** other error occurs, this function will return SQLCIPHER_BUSY to the caller.
49034   */
49035   if( eMode!=SQLCIPHER_CHECKPOINT_PASSIVE ){
49036     rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_WRITE_LOCK, 1);
49037     if( rc==SQLCIPHER_OK ){
49038       pWal->writeLock = 1;
49039     }else if( rc==SQLCIPHER_BUSY ){
49040       eMode2 = SQLCIPHER_CHECKPOINT_PASSIVE;
49041       rc = SQLCIPHER_OK;
49042     }
49043   }
49044
49045   /* Read the wal-index header. */
49046   if( rc==SQLCIPHER_OK ){
49047     rc = walIndexReadHdr(pWal, &isChanged);
49048   }
49049
49050   /* Copy data from the log to the database file. */
49051   if( rc==SQLCIPHER_OK ){
49052     if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
49053       rc = SQLCIPHER_CORRUPT_BKPT;
49054     }else{
49055       rc = walCheckpoint(pWal, eMode2, xBusy, pBusyArg, sync_flags, zBuf);
49056     }
49057
49058     /* If no error occurred, set the output variables. */
49059     if( rc==SQLCIPHER_OK || rc==SQLCIPHER_BUSY ){
49060       if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
49061       if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
49062     }
49063   }
49064
49065   if( isChanged ){
49066     /* If a new wal-index header was loaded before the checkpoint was 
49067     ** performed, then the pager-cache associated with pWal is now
49068     ** out of date. So zero the cached wal-index header to ensure that
49069     ** next time the pager opens a snapshot on this database it knows that
49070     ** the cache needs to be reset.
49071     */
49072     memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
49073   }
49074
49075   /* Release the locks. */
49076   sqlcipher3WalEndWriteTransaction(pWal);
49077   walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
49078   pWal->ckptLock = 0;
49079   WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok"));
49080   return (rc==SQLCIPHER_OK && eMode!=eMode2 ? SQLCIPHER_BUSY : rc);
49081 }
49082
49083 /* Return the value to pass to a sqlcipher3_wal_hook callback, the
49084 ** number of frames in the WAL at the point of the last commit since
49085 ** sqlcipher3WalCallback() was called.  If no commits have occurred since
49086 ** the last call, then return 0.
49087 */
49088 SQLCIPHER_PRIVATE int sqlcipher3WalCallback(Wal *pWal){
49089   u32 ret = 0;
49090   if( pWal ){
49091     ret = pWal->iCallback;
49092     pWal->iCallback = 0;
49093   }
49094   return (int)ret;
49095 }
49096
49097 /*
49098 ** This function is called to change the WAL subsystem into or out
49099 ** of locking_mode=EXCLUSIVE.
49100 **
49101 ** If op is zero, then attempt to change from locking_mode=EXCLUSIVE
49102 ** into locking_mode=NORMAL.  This means that we must acquire a lock
49103 ** on the pWal->readLock byte.  If the WAL is already in locking_mode=NORMAL
49104 ** or if the acquisition of the lock fails, then return 0.  If the
49105 ** transition out of exclusive-mode is successful, return 1.  This
49106 ** operation must occur while the pager is still holding the exclusive
49107 ** lock on the main database file.
49108 **
49109 ** If op is one, then change from locking_mode=NORMAL into 
49110 ** locking_mode=EXCLUSIVE.  This means that the pWal->readLock must
49111 ** be released.  Return 1 if the transition is made and 0 if the
49112 ** WAL is already in exclusive-locking mode - meaning that this
49113 ** routine is a no-op.  The pager must already hold the exclusive lock
49114 ** on the main database file before invoking this operation.
49115 **
49116 ** If op is negative, then do a dry-run of the op==1 case but do
49117 ** not actually change anything. The pager uses this to see if it
49118 ** should acquire the database exclusive lock prior to invoking
49119 ** the op==1 case.
49120 */
49121 SQLCIPHER_PRIVATE int sqlcipher3WalExclusiveMode(Wal *pWal, int op){
49122   int rc;
49123   assert( pWal->writeLock==0 );
49124   assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
49125
49126   /* pWal->readLock is usually set, but might be -1 if there was a 
49127   ** prior error while attempting to acquire are read-lock. This cannot 
49128   ** happen if the connection is actually in exclusive mode (as no xShmLock
49129   ** locks are taken in this case). Nor should the pager attempt to
49130   ** upgrade to exclusive-mode following such an error.
49131   */
49132   assert( pWal->readLock>=0 || pWal->lockError );
49133   assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
49134
49135   if( op==0 ){
49136     if( pWal->exclusiveMode ){
49137       pWal->exclusiveMode = 0;
49138       if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLCIPHER_OK ){
49139         pWal->exclusiveMode = 1;
49140       }
49141       rc = pWal->exclusiveMode==0;
49142     }else{
49143       /* Already in locking_mode=NORMAL */
49144       rc = 0;
49145     }
49146   }else if( op>0 ){
49147     assert( pWal->exclusiveMode==0 );
49148     assert( pWal->readLock>=0 );
49149     walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
49150     pWal->exclusiveMode = 1;
49151     rc = 1;
49152   }else{
49153     rc = pWal->exclusiveMode==0;
49154   }
49155   return rc;
49156 }
49157
49158 /* 
49159 ** Return true if the argument is non-NULL and the WAL module is using
49160 ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
49161 ** WAL module is using shared-memory, return false. 
49162 */
49163 SQLCIPHER_PRIVATE int sqlcipher3WalHeapMemory(Wal *pWal){
49164   return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );
49165 }
49166
49167 #endif /* #ifndef SQLCIPHER_OMIT_WAL */
49168
49169 /************** End of wal.c *************************************************/
49170 /************** Begin file btmutex.c *****************************************/
49171 /*
49172 ** 2007 August 27
49173 **
49174 ** The author disclaims copyright to this source code.  In place of
49175 ** a legal notice, here is a blessing:
49176 **
49177 **    May you do good and not evil.
49178 **    May you find forgiveness for yourself and forgive others.
49179 **    May you share freely, never taking more than you give.
49180 **
49181 *************************************************************************
49182 **
49183 ** This file contains code used to implement mutexes on Btree objects.
49184 ** This code really belongs in btree.c.  But btree.c is getting too
49185 ** big and we want to break it down some.  This packaged seemed like
49186 ** a good breakout.
49187 */
49188 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
49189 #if SQLCIPHER_THREADSAFE
49190
49191 /*
49192 ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
49193 ** set BtShared.db to the database handle associated with p and the
49194 ** p->locked boolean to true.
49195 */
49196 static void lockBtreeMutex(Btree *p){
49197   assert( p->locked==0 );
49198   assert( sqlcipher3_mutex_notheld(p->pBt->mutex) );
49199   assert( sqlcipher3_mutex_held(p->db->mutex) );
49200
49201   sqlcipher3_mutex_enter(p->pBt->mutex);
49202   p->pBt->db = p->db;
49203   p->locked = 1;
49204 }
49205
49206 /*
49207 ** Release the BtShared mutex associated with B-Tree handle p and
49208 ** clear the p->locked boolean.
49209 */
49210 static void unlockBtreeMutex(Btree *p){
49211   BtShared *pBt = p->pBt;
49212   assert( p->locked==1 );
49213   assert( sqlcipher3_mutex_held(pBt->mutex) );
49214   assert( sqlcipher3_mutex_held(p->db->mutex) );
49215   assert( p->db==pBt->db );
49216
49217   sqlcipher3_mutex_leave(pBt->mutex);
49218   p->locked = 0;
49219 }
49220
49221 /*
49222 ** Enter a mutex on the given BTree object.
49223 **
49224 ** If the object is not sharable, then no mutex is ever required
49225 ** and this routine is a no-op.  The underlying mutex is non-recursive.
49226 ** But we keep a reference count in Btree.wantToLock so the behavior
49227 ** of this interface is recursive.
49228 **
49229 ** To avoid deadlocks, multiple Btrees are locked in the same order
49230 ** by all database connections.  The p->pNext is a list of other
49231 ** Btrees belonging to the same database connection as the p Btree
49232 ** which need to be locked after p.  If we cannot get a lock on
49233 ** p, then first unlock all of the others on p->pNext, then wait
49234 ** for the lock to become available on p, then relock all of the
49235 ** subsequent Btrees that desire a lock.
49236 */
49237 SQLCIPHER_PRIVATE void sqlcipher3BtreeEnter(Btree *p){
49238   Btree *pLater;
49239
49240   /* Some basic sanity checking on the Btree.  The list of Btrees
49241   ** connected by pNext and pPrev should be in sorted order by
49242   ** Btree.pBt value. All elements of the list should belong to
49243   ** the same connection. Only shared Btrees are on the list. */
49244   assert( p->pNext==0 || p->pNext->pBt>p->pBt );
49245   assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
49246   assert( p->pNext==0 || p->pNext->db==p->db );
49247   assert( p->pPrev==0 || p->pPrev->db==p->db );
49248   assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
49249
49250   /* Check for locking consistency */
49251   assert( !p->locked || p->wantToLock>0 );
49252   assert( p->sharable || p->wantToLock==0 );
49253
49254   /* We should already hold a lock on the database connection */
49255   assert( sqlcipher3_mutex_held(p->db->mutex) );
49256
49257   /* Unless the database is sharable and unlocked, then BtShared.db
49258   ** should already be set correctly. */
49259   assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
49260
49261   if( !p->sharable ) return;
49262   p->wantToLock++;
49263   if( p->locked ) return;
49264
49265   /* In most cases, we should be able to acquire the lock we
49266   ** want without having to go throught the ascending lock
49267   ** procedure that follows.  Just be sure not to block.
49268   */
49269   if( sqlcipher3_mutex_try(p->pBt->mutex)==SQLCIPHER_OK ){
49270     p->pBt->db = p->db;
49271     p->locked = 1;
49272     return;
49273   }
49274
49275   /* To avoid deadlock, first release all locks with a larger
49276   ** BtShared address.  Then acquire our lock.  Then reacquire
49277   ** the other BtShared locks that we used to hold in ascending
49278   ** order.
49279   */
49280   for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49281     assert( pLater->sharable );
49282     assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
49283     assert( !pLater->locked || pLater->wantToLock>0 );
49284     if( pLater->locked ){
49285       unlockBtreeMutex(pLater);
49286     }
49287   }
49288   lockBtreeMutex(p);
49289   for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49290     if( pLater->wantToLock ){
49291       lockBtreeMutex(pLater);
49292     }
49293   }
49294 }
49295
49296 /*
49297 ** Exit the recursive mutex on a Btree.
49298 */
49299 SQLCIPHER_PRIVATE void sqlcipher3BtreeLeave(Btree *p){
49300   if( p->sharable ){
49301     assert( p->wantToLock>0 );
49302     p->wantToLock--;
49303     if( p->wantToLock==0 ){
49304       unlockBtreeMutex(p);
49305     }
49306   }
49307 }
49308
49309 #ifndef NDEBUG
49310 /*
49311 ** Return true if the BtShared mutex is held on the btree, or if the
49312 ** B-Tree is not marked as sharable.
49313 **
49314 ** This routine is used only from within assert() statements.
49315 */
49316 SQLCIPHER_PRIVATE int sqlcipher3BtreeHoldsMutex(Btree *p){
49317   assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
49318   assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
49319   assert( p->sharable==0 || p->locked==0 || sqlcipher3_mutex_held(p->pBt->mutex) );
49320   assert( p->sharable==0 || p->locked==0 || sqlcipher3_mutex_held(p->db->mutex) );
49321
49322   return (p->sharable==0 || p->locked);
49323 }
49324 #endif
49325
49326
49327 #ifndef SQLCIPHER_OMIT_INCRBLOB
49328 /*
49329 ** Enter and leave a mutex on a Btree given a cursor owned by that
49330 ** Btree.  These entry points are used by incremental I/O and can be
49331 ** omitted if that module is not used.
49332 */
49333 SQLCIPHER_PRIVATE void sqlcipher3BtreeEnterCursor(BtCursor *pCur){
49334   sqlcipher3BtreeEnter(pCur->pBtree);
49335 }
49336 SQLCIPHER_PRIVATE void sqlcipher3BtreeLeaveCursor(BtCursor *pCur){
49337   sqlcipher3BtreeLeave(pCur->pBtree);
49338 }
49339 #endif /* SQLCIPHER_OMIT_INCRBLOB */
49340
49341
49342 /*
49343 ** Enter the mutex on every Btree associated with a database
49344 ** connection.  This is needed (for example) prior to parsing
49345 ** a statement since we will be comparing table and column names
49346 ** against all schemas and we do not want those schemas being
49347 ** reset out from under us.
49348 **
49349 ** There is a corresponding leave-all procedures.
49350 **
49351 ** Enter the mutexes in accending order by BtShared pointer address
49352 ** to avoid the possibility of deadlock when two threads with
49353 ** two or more btrees in common both try to lock all their btrees
49354 ** at the same instant.
49355 */
49356 SQLCIPHER_PRIVATE void sqlcipher3BtreeEnterAll(sqlcipher3 *db){
49357   int i;
49358   Btree *p;
49359   assert( sqlcipher3_mutex_held(db->mutex) );
49360   for(i=0; i<db->nDb; i++){
49361     p = db->aDb[i].pBt;
49362     if( p ) sqlcipher3BtreeEnter(p);
49363   }
49364 }
49365 SQLCIPHER_PRIVATE void sqlcipher3BtreeLeaveAll(sqlcipher3 *db){
49366   int i;
49367   Btree *p;
49368   assert( sqlcipher3_mutex_held(db->mutex) );
49369   for(i=0; i<db->nDb; i++){
49370     p = db->aDb[i].pBt;
49371     if( p ) sqlcipher3BtreeLeave(p);
49372   }
49373 }
49374
49375 /*
49376 ** Return true if a particular Btree requires a lock.  Return FALSE if
49377 ** no lock is ever required since it is not sharable.
49378 */
49379 SQLCIPHER_PRIVATE int sqlcipher3BtreeSharable(Btree *p){
49380   return p->sharable;
49381 }
49382
49383 #ifndef NDEBUG
49384 /*
49385 ** Return true if the current thread holds the database connection
49386 ** mutex and all required BtShared mutexes.
49387 **
49388 ** This routine is used inside assert() statements only.
49389 */
49390 SQLCIPHER_PRIVATE int sqlcipher3BtreeHoldsAllMutexes(sqlcipher3 *db){
49391   int i;
49392   if( !sqlcipher3_mutex_held(db->mutex) ){
49393     return 0;
49394   }
49395   for(i=0; i<db->nDb; i++){
49396     Btree *p;
49397     p = db->aDb[i].pBt;
49398     if( p && p->sharable &&
49399          (p->wantToLock==0 || !sqlcipher3_mutex_held(p->pBt->mutex)) ){
49400       return 0;
49401     }
49402   }
49403   return 1;
49404 }
49405 #endif /* NDEBUG */
49406
49407 #ifndef NDEBUG
49408 /*
49409 ** Return true if the correct mutexes are held for accessing the
49410 ** db->aDb[iDb].pSchema structure.  The mutexes required for schema
49411 ** access are:
49412 **
49413 **   (1) The mutex on db
49414 **   (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
49415 **
49416 ** If pSchema is not NULL, then iDb is computed from pSchema and
49417 ** db using sqlcipher3SchemaToIndex().
49418 */
49419 SQLCIPHER_PRIVATE int sqlcipher3SchemaMutexHeld(sqlcipher3 *db, int iDb, Schema *pSchema){
49420   Btree *p;
49421   assert( db!=0 );
49422   if( pSchema ) iDb = sqlcipher3SchemaToIndex(db, pSchema);
49423   assert( iDb>=0 && iDb<db->nDb );
49424   if( !sqlcipher3_mutex_held(db->mutex) ) return 0;
49425   if( iDb==1 ) return 1;
49426   p = db->aDb[iDb].pBt;
49427   assert( p!=0 );
49428   return p->sharable==0 || p->locked==1;
49429 }
49430 #endif /* NDEBUG */
49431
49432 #else /* SQLCIPHER_THREADSAFE>0 above.  SQLCIPHER_THREADSAFE==0 below */
49433 /*
49434 ** The following are special cases for mutex enter routines for use
49435 ** in single threaded applications that use shared cache.  Except for
49436 ** these two routines, all mutex operations are no-ops in that case and
49437 ** are null #defines in btree.h.
49438 **
49439 ** If shared cache is disabled, then all btree mutex routines, including
49440 ** the ones below, are no-ops and are null #defines in btree.h.
49441 */
49442
49443 SQLCIPHER_PRIVATE void sqlcipher3BtreeEnter(Btree *p){
49444   p->pBt->db = p->db;
49445 }
49446 SQLCIPHER_PRIVATE void sqlcipher3BtreeEnterAll(sqlcipher3 *db){
49447   int i;
49448   for(i=0; i<db->nDb; i++){
49449     Btree *p = db->aDb[i].pBt;
49450     if( p ){
49451       p->pBt->db = p->db;
49452     }
49453   }
49454 }
49455 #endif /* if SQLCIPHER_THREADSAFE */
49456 #endif /* ifndef SQLCIPHER_OMIT_SHARED_CACHE */
49457
49458 /************** End of btmutex.c *********************************************/
49459 /************** Begin file btree.c *******************************************/
49460 /*
49461 ** 2004 April 6
49462 **
49463 ** The author disclaims copyright to this source code.  In place of
49464 ** a legal notice, here is a blessing:
49465 **
49466 **    May you do good and not evil.
49467 **    May you find forgiveness for yourself and forgive others.
49468 **    May you share freely, never taking more than you give.
49469 **
49470 *************************************************************************
49471 ** This file implements a external (disk-based) database using BTrees.
49472 ** See the header comment on "btreeInt.h" for additional information.
49473 ** Including a description of file format and an overview of operation.
49474 */
49475
49476 /*
49477 ** The header string that appears at the beginning of every
49478 ** SQLite database.
49479 */
49480 static const char zMagicHeader[] = SQLCIPHER_FILE_HEADER;
49481
49482 /*
49483 ** Set this global variable to 1 to enable tracing using the TRACE
49484 ** macro.
49485 */
49486 #if 0
49487 int sqlcipher3BtreeTrace=1;  /* True to enable tracing */
49488 # define TRACE(X)  if(sqlcipher3BtreeTrace){printf X;fflush(stdout);}
49489 #else
49490 # define TRACE(X)
49491 #endif
49492
49493 /*
49494 ** Extract a 2-byte big-endian integer from an array of unsigned bytes.
49495 ** But if the value is zero, make it 65536.
49496 **
49497 ** This routine is used to extract the "offset to cell content area" value
49498 ** from the header of a btree page.  If the page size is 65536 and the page
49499 ** is empty, the offset should be 65536, but the 2-byte value stores zero.
49500 ** This routine makes the necessary adjustment to 65536.
49501 */
49502 #define get2byteNotZero(X)  (((((int)get2byte(X))-1)&0xffff)+1)
49503
49504 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
49505 /*
49506 ** A list of BtShared objects that are eligible for participation
49507 ** in shared cache.  This variable has file scope during normal builds,
49508 ** but the test harness needs to access it so we make it global for 
49509 ** test builds.
49510 **
49511 ** Access to this variable is protected by SQLCIPHER_MUTEX_STATIC_MASTER.
49512 */
49513 #ifdef SQLCIPHER_TEST
49514 SQLCIPHER_PRIVATE BtShared *SQLCIPHER_WSD sqlcipher3SharedCacheList = 0;
49515 #else
49516 static BtShared *SQLCIPHER_WSD sqlcipher3SharedCacheList = 0;
49517 #endif
49518 #endif /* SQLCIPHER_OMIT_SHARED_CACHE */
49519
49520 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
49521 /*
49522 ** Enable or disable the shared pager and schema features.
49523 **
49524 ** This routine has no effect on existing database connections.
49525 ** The shared cache setting effects only future calls to
49526 ** sqlcipher3_open(), sqlcipher3_open16(), or sqlcipher3_open_v2().
49527 */
49528 SQLCIPHER_API int sqlcipher3_enable_shared_cache(int enable){
49529   sqlcipher3GlobalConfig.sharedCacheEnabled = enable;
49530   return SQLCIPHER_OK;
49531 }
49532 #endif
49533
49534
49535
49536 #ifdef SQLCIPHER_OMIT_SHARED_CACHE
49537   /*
49538   ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(),
49539   ** and clearAllSharedCacheTableLocks()
49540   ** manipulate entries in the BtShared.pLock linked list used to store
49541   ** shared-cache table level locks. If the library is compiled with the
49542   ** shared-cache feature disabled, then there is only ever one user
49543   ** of each BtShared structure and so this locking is not necessary. 
49544   ** So define the lock related functions as no-ops.
49545   */
49546   #define querySharedCacheTableLock(a,b,c) SQLCIPHER_OK
49547   #define setSharedCacheTableLock(a,b,c) SQLCIPHER_OK
49548   #define clearAllSharedCacheTableLocks(a)
49549   #define downgradeAllSharedCacheTableLocks(a)
49550   #define hasSharedCacheTableLock(a,b,c,d) 1
49551   #define hasReadConflicts(a, b) 0
49552 #endif
49553
49554 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
49555
49556 #ifdef SQLCIPHER_DEBUG
49557 /*
49558 **** This function is only used as part of an assert() statement. ***
49559 **
49560 ** Check to see if pBtree holds the required locks to read or write to the 
49561 ** table with root page iRoot.   Return 1 if it does and 0 if not.
49562 **
49563 ** For example, when writing to a table with root-page iRoot via 
49564 ** Btree connection pBtree:
49565 **
49566 **    assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) );
49567 **
49568 ** When writing to an index that resides in a sharable database, the 
49569 ** caller should have first obtained a lock specifying the root page of
49570 ** the corresponding table. This makes things a bit more complicated,
49571 ** as this module treats each table as a separate structure. To determine
49572 ** the table corresponding to the index being written, this
49573 ** function has to search through the database schema.
49574 **
49575 ** Instead of a lock on the table/index rooted at page iRoot, the caller may
49576 ** hold a write-lock on the schema table (root page 1). This is also
49577 ** acceptable.
49578 */
49579 static int hasSharedCacheTableLock(
49580   Btree *pBtree,         /* Handle that must hold lock */
49581   Pgno iRoot,            /* Root page of b-tree */
49582   int isIndex,           /* True if iRoot is the root of an index b-tree */
49583   int eLockType          /* Required lock type (READ_LOCK or WRITE_LOCK) */
49584 ){
49585   Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
49586   Pgno iTab = 0;
49587   BtLock *pLock;
49588
49589   /* If this database is not shareable, or if the client is reading
49590   ** and has the read-uncommitted flag set, then no lock is required. 
49591   ** Return true immediately.
49592   */
49593   if( (pBtree->sharable==0)
49594    || (eLockType==READ_LOCK && (pBtree->db->flags & SQLCIPHER_ReadUncommitted))
49595   ){
49596     return 1;
49597   }
49598
49599   /* If the client is reading  or writing an index and the schema is
49600   ** not loaded, then it is too difficult to actually check to see if
49601   ** the correct locks are held.  So do not bother - just return true.
49602   ** This case does not come up very often anyhow.
49603   */
49604   if( isIndex && (!pSchema || (pSchema->flags&DB_SchemaLoaded)==0) ){
49605     return 1;
49606   }
49607
49608   /* Figure out the root-page that the lock should be held on. For table
49609   ** b-trees, this is just the root page of the b-tree being read or
49610   ** written. For index b-trees, it is the root page of the associated
49611   ** table.  */
49612   if( isIndex ){
49613     HashElem *p;
49614     for(p=sqlcipherHashFirst(&pSchema->idxHash); p; p=sqlcipherHashNext(p)){
49615       Index *pIdx = (Index *)sqlcipherHashData(p);
49616       if( pIdx->tnum==(int)iRoot ){
49617         iTab = pIdx->pTable->tnum;
49618       }
49619     }
49620   }else{
49621     iTab = iRoot;
49622   }
49623
49624   /* Search for the required lock. Either a write-lock on root-page iTab, a 
49625   ** write-lock on the schema table, or (if the client is reading) a
49626   ** read-lock on iTab will suffice. Return 1 if any of these are found.  */
49627   for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
49628     if( pLock->pBtree==pBtree 
49629      && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1))
49630      && pLock->eLock>=eLockType 
49631     ){
49632       return 1;
49633     }
49634   }
49635
49636   /* Failed to find the required lock. */
49637   return 0;
49638 }
49639 #endif /* SQLCIPHER_DEBUG */
49640
49641 #ifdef SQLCIPHER_DEBUG
49642 /*
49643 **** This function may be used as part of assert() statements only. ****
49644 **
49645 ** Return true if it would be illegal for pBtree to write into the
49646 ** table or index rooted at iRoot because other shared connections are
49647 ** simultaneously reading that same table or index.
49648 **
49649 ** It is illegal for pBtree to write if some other Btree object that
49650 ** shares the same BtShared object is currently reading or writing
49651 ** the iRoot table.  Except, if the other Btree object has the
49652 ** read-uncommitted flag set, then it is OK for the other object to
49653 ** have a read cursor.
49654 **
49655 ** For example, before writing to any part of the table or index
49656 ** rooted at page iRoot, one should call:
49657 **
49658 **    assert( !hasReadConflicts(pBtree, iRoot) );
49659 */
49660 static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
49661   BtCursor *p;
49662   for(p=pBtree->pBt->pCursor; p; p=p->pNext){
49663     if( p->pgnoRoot==iRoot 
49664      && p->pBtree!=pBtree
49665      && 0==(p->pBtree->db->flags & SQLCIPHER_ReadUncommitted)
49666     ){
49667       return 1;
49668     }
49669   }
49670   return 0;
49671 }
49672 #endif    /* #ifdef SQLCIPHER_DEBUG */
49673
49674 /*
49675 ** Query to see if Btree handle p may obtain a lock of type eLock 
49676 ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
49677 ** SQLCIPHER_OK if the lock may be obtained (by calling
49678 ** setSharedCacheTableLock()), or SQLCIPHER_LOCKED if not.
49679 */
49680 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
49681   BtShared *pBt = p->pBt;
49682   BtLock *pIter;
49683
49684   assert( sqlcipher3BtreeHoldsMutex(p) );
49685   assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
49686   assert( p->db!=0 );
49687   assert( !(p->db->flags&SQLCIPHER_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
49688   
49689   /* If requesting a write-lock, then the Btree must have an open write
49690   ** transaction on this file. And, obviously, for this to be so there 
49691   ** must be an open write transaction on the file itself.
49692   */
49693   assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
49694   assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
49695   
49696   /* This routine is a no-op if the shared-cache is not enabled */
49697   if( !p->sharable ){
49698     return SQLCIPHER_OK;
49699   }
49700
49701   /* If some other connection is holding an exclusive lock, the
49702   ** requested lock may not be obtained.
49703   */
49704   if( pBt->pWriter!=p && pBt->isExclusive ){
49705     sqlcipher3ConnectionBlocked(p->db, pBt->pWriter->db);
49706     return SQLCIPHER_LOCKED_SHAREDCACHE;
49707   }
49708
49709   for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49710     /* The condition (pIter->eLock!=eLock) in the following if(...) 
49711     ** statement is a simplification of:
49712     **
49713     **   (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
49714     **
49715     ** since we know that if eLock==WRITE_LOCK, then no other connection
49716     ** may hold a WRITE_LOCK on any table in this file (since there can
49717     ** only be a single writer).
49718     */
49719     assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
49720     assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
49721     if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
49722       sqlcipher3ConnectionBlocked(p->db, pIter->pBtree->db);
49723       if( eLock==WRITE_LOCK ){
49724         assert( p==pBt->pWriter );
49725         pBt->isPending = 1;
49726       }
49727       return SQLCIPHER_LOCKED_SHAREDCACHE;
49728     }
49729   }
49730   return SQLCIPHER_OK;
49731 }
49732 #endif /* !SQLCIPHER_OMIT_SHARED_CACHE */
49733
49734 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
49735 /*
49736 ** Add a lock on the table with root-page iTable to the shared-btree used
49737 ** by Btree handle p. Parameter eLock must be either READ_LOCK or 
49738 ** WRITE_LOCK.
49739 **
49740 ** This function assumes the following:
49741 **
49742 **   (a) The specified Btree object p is connected to a sharable
49743 **       database (one with the BtShared.sharable flag set), and
49744 **
49745 **   (b) No other Btree objects hold a lock that conflicts
49746 **       with the requested lock (i.e. querySharedCacheTableLock() has
49747 **       already been called and returned SQLCIPHER_OK).
49748 **
49749 ** SQLCIPHER_OK is returned if the lock is added successfully. SQLCIPHER_NOMEM 
49750 ** is returned if a malloc attempt fails.
49751 */
49752 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
49753   BtShared *pBt = p->pBt;
49754   BtLock *pLock = 0;
49755   BtLock *pIter;
49756
49757   assert( sqlcipher3BtreeHoldsMutex(p) );
49758   assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
49759   assert( p->db!=0 );
49760
49761   /* A connection with the read-uncommitted flag set will never try to
49762   ** obtain a read-lock using this function. The only read-lock obtained
49763   ** by a connection in read-uncommitted mode is on the sqlcipher_master 
49764   ** table, and that lock is obtained in BtreeBeginTrans().  */
49765   assert( 0==(p->db->flags&SQLCIPHER_ReadUncommitted) || eLock==WRITE_LOCK );
49766
49767   /* This function should only be called on a sharable b-tree after it 
49768   ** has been determined that no other b-tree holds a conflicting lock.  */
49769   assert( p->sharable );
49770   assert( SQLCIPHER_OK==querySharedCacheTableLock(p, iTable, eLock) );
49771
49772   /* First search the list for an existing lock on this table. */
49773   for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49774     if( pIter->iTable==iTable && pIter->pBtree==p ){
49775       pLock = pIter;
49776       break;
49777     }
49778   }
49779
49780   /* If the above search did not find a BtLock struct associating Btree p
49781   ** with table iTable, allocate one and link it into the list.
49782   */
49783   if( !pLock ){
49784     pLock = (BtLock *)sqlcipher3MallocZero(sizeof(BtLock));
49785     if( !pLock ){
49786       return SQLCIPHER_NOMEM;
49787     }
49788     pLock->iTable = iTable;
49789     pLock->pBtree = p;
49790     pLock->pNext = pBt->pLock;
49791     pBt->pLock = pLock;
49792   }
49793
49794   /* Set the BtLock.eLock variable to the maximum of the current lock
49795   ** and the requested lock. This means if a write-lock was already held
49796   ** and a read-lock requested, we don't incorrectly downgrade the lock.
49797   */
49798   assert( WRITE_LOCK>READ_LOCK );
49799   if( eLock>pLock->eLock ){
49800     pLock->eLock = eLock;
49801   }
49802
49803   return SQLCIPHER_OK;
49804 }
49805 #endif /* !SQLCIPHER_OMIT_SHARED_CACHE */
49806
49807 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
49808 /*
49809 ** Release all the table locks (locks obtained via calls to
49810 ** the setSharedCacheTableLock() procedure) held by Btree object p.
49811 **
49812 ** This function assumes that Btree p has an open read or write 
49813 ** transaction. If it does not, then the BtShared.isPending variable
49814 ** may be incorrectly cleared.
49815 */
49816 static void clearAllSharedCacheTableLocks(Btree *p){
49817   BtShared *pBt = p->pBt;
49818   BtLock **ppIter = &pBt->pLock;
49819
49820   assert( sqlcipher3BtreeHoldsMutex(p) );
49821   assert( p->sharable || 0==*ppIter );
49822   assert( p->inTrans>0 );
49823
49824   while( *ppIter ){
49825     BtLock *pLock = *ppIter;
49826     assert( pBt->isExclusive==0 || pBt->pWriter==pLock->pBtree );
49827     assert( pLock->pBtree->inTrans>=pLock->eLock );
49828     if( pLock->pBtree==p ){
49829       *ppIter = pLock->pNext;
49830       assert( pLock->iTable!=1 || pLock==&p->lock );
49831       if( pLock->iTable!=1 ){
49832         sqlcipher3_free(pLock);
49833       }
49834     }else{
49835       ppIter = &pLock->pNext;
49836     }
49837   }
49838
49839   assert( pBt->isPending==0 || pBt->pWriter );
49840   if( pBt->pWriter==p ){
49841     pBt->pWriter = 0;
49842     pBt->isExclusive = 0;
49843     pBt->isPending = 0;
49844   }else if( pBt->nTransaction==2 ){
49845     /* This function is called when Btree p is concluding its 
49846     ** transaction. If there currently exists a writer, and p is not
49847     ** that writer, then the number of locks held by connections other
49848     ** than the writer must be about to drop to zero. In this case
49849     ** set the isPending flag to 0.
49850     **
49851     ** If there is not currently a writer, then BtShared.isPending must
49852     ** be zero already. So this next line is harmless in that case.
49853     */
49854     pBt->isPending = 0;
49855   }
49856 }
49857
49858 /*
49859 ** This function changes all write-locks held by Btree p into read-locks.
49860 */
49861 static void downgradeAllSharedCacheTableLocks(Btree *p){
49862   BtShared *pBt = p->pBt;
49863   if( pBt->pWriter==p ){
49864     BtLock *pLock;
49865     pBt->pWriter = 0;
49866     pBt->isExclusive = 0;
49867     pBt->isPending = 0;
49868     for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
49869       assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
49870       pLock->eLock = READ_LOCK;
49871     }
49872   }
49873 }
49874
49875 #endif /* SQLCIPHER_OMIT_SHARED_CACHE */
49876
49877 static void releasePage(MemPage *pPage);  /* Forward reference */
49878
49879 /*
49880 ***** This routine is used inside of assert() only ****
49881 **
49882 ** Verify that the cursor holds the mutex on its BtShared
49883 */
49884 #ifdef SQLCIPHER_DEBUG
49885 static int cursorHoldsMutex(BtCursor *p){
49886   return sqlcipher3_mutex_held(p->pBt->mutex);
49887 }
49888 #endif
49889
49890
49891 #ifndef SQLCIPHER_OMIT_INCRBLOB
49892 /*
49893 ** Invalidate the overflow page-list cache for cursor pCur, if any.
49894 */
49895 static void invalidateOverflowCache(BtCursor *pCur){
49896   assert( cursorHoldsMutex(pCur) );
49897   sqlcipher3_free(pCur->aOverflow);
49898   pCur->aOverflow = 0;
49899 }
49900
49901 /*
49902 ** Invalidate the overflow page-list cache for all cursors opened
49903 ** on the shared btree structure pBt.
49904 */
49905 static void invalidateAllOverflowCache(BtShared *pBt){
49906   BtCursor *p;
49907   assert( sqlcipher3_mutex_held(pBt->mutex) );
49908   for(p=pBt->pCursor; p; p=p->pNext){
49909     invalidateOverflowCache(p);
49910   }
49911 }
49912
49913 /*
49914 ** This function is called before modifying the contents of a table
49915 ** to invalidate any incrblob cursors that are open on the
49916 ** row or one of the rows being modified.
49917 **
49918 ** If argument isClearTable is true, then the entire contents of the
49919 ** table is about to be deleted. In this case invalidate all incrblob
49920 ** cursors open on any row within the table with root-page pgnoRoot.
49921 **
49922 ** Otherwise, if argument isClearTable is false, then the row with
49923 ** rowid iRow is being replaced or deleted. In this case invalidate
49924 ** only those incrblob cursors open on that specific row.
49925 */
49926 static void invalidateIncrblobCursors(
49927   Btree *pBtree,          /* The database file to check */
49928   i64 iRow,               /* The rowid that might be changing */
49929   int isClearTable        /* True if all rows are being deleted */
49930 ){
49931   BtCursor *p;
49932   BtShared *pBt = pBtree->pBt;
49933   assert( sqlcipher3BtreeHoldsMutex(pBtree) );
49934   for(p=pBt->pCursor; p; p=p->pNext){
49935     if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
49936       p->eState = CURSOR_INVALID;
49937     }
49938   }
49939 }
49940
49941 #else
49942   /* Stub functions when INCRBLOB is omitted */
49943   #define invalidateOverflowCache(x)
49944   #define invalidateAllOverflowCache(x)
49945   #define invalidateIncrblobCursors(x,y,z)
49946 #endif /* SQLCIPHER_OMIT_INCRBLOB */
49947
49948 /*
49949 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called 
49950 ** when a page that previously contained data becomes a free-list leaf 
49951 ** page.
49952 **
49953 ** The BtShared.pHasContent bitvec exists to work around an obscure
49954 ** bug caused by the interaction of two useful IO optimizations surrounding
49955 ** free-list leaf pages:
49956 **
49957 **   1) When all data is deleted from a page and the page becomes
49958 **      a free-list leaf page, the page is not written to the database
49959 **      (as free-list leaf pages contain no meaningful data). Sometimes
49960 **      such a page is not even journalled (as it will not be modified,
49961 **      why bother journalling it?).
49962 **
49963 **   2) When a free-list leaf page is reused, its content is not read
49964 **      from the database or written to the journal file (why should it
49965 **      be, if it is not at all meaningful?).
49966 **
49967 ** By themselves, these optimizations work fine and provide a handy
49968 ** performance boost to bulk delete or insert operations. However, if
49969 ** a page is moved to the free-list and then reused within the same
49970 ** transaction, a problem comes up. If the page is not journalled when
49971 ** it is moved to the free-list and it is also not journalled when it
49972 ** is extracted from the free-list and reused, then the original data
49973 ** may be lost. In the event of a rollback, it may not be possible
49974 ** to restore the database to its original configuration.
49975 **
49976 ** The solution is the BtShared.pHasContent bitvec. Whenever a page is 
49977 ** moved to become a free-list leaf page, the corresponding bit is
49978 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
49979 ** optimization 2 above is omitted if the corresponding bit is already
49980 ** set in BtShared.pHasContent. The contents of the bitvec are cleared
49981 ** at the end of every transaction.
49982 */
49983 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
49984   int rc = SQLCIPHER_OK;
49985   if( !pBt->pHasContent ){
49986     assert( pgno<=pBt->nPage );
49987     pBt->pHasContent = sqlcipher3BitvecCreate(pBt->nPage);
49988     if( !pBt->pHasContent ){
49989       rc = SQLCIPHER_NOMEM;
49990     }
49991   }
49992   if( rc==SQLCIPHER_OK && pgno<=sqlcipher3BitvecSize(pBt->pHasContent) ){
49993     rc = sqlcipher3BitvecSet(pBt->pHasContent, pgno);
49994   }
49995   return rc;
49996 }
49997
49998 /*
49999 ** Query the BtShared.pHasContent vector.
50000 **
50001 ** This function is called when a free-list leaf page is removed from the
50002 ** free-list for reuse. It returns false if it is safe to retrieve the
50003 ** page from the pager layer with the 'no-content' flag set. True otherwise.
50004 */
50005 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
50006   Bitvec *p = pBt->pHasContent;
50007   return (p && (pgno>sqlcipher3BitvecSize(p) || sqlcipher3BitvecTest(p, pgno)));
50008 }
50009
50010 /*
50011 ** Clear (destroy) the BtShared.pHasContent bitvec. This should be
50012 ** invoked at the conclusion of each write-transaction.
50013 */
50014 static void btreeClearHasContent(BtShared *pBt){
50015   sqlcipher3BitvecDestroy(pBt->pHasContent);
50016   pBt->pHasContent = 0;
50017 }
50018
50019 /*
50020 ** Save the current cursor position in the variables BtCursor.nKey 
50021 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
50022 **
50023 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
50024 ** prior to calling this routine.  
50025 */
50026 static int saveCursorPosition(BtCursor *pCur){
50027   int rc;
50028
50029   assert( CURSOR_VALID==pCur->eState );
50030   assert( 0==pCur->pKey );
50031   assert( cursorHoldsMutex(pCur) );
50032
50033   rc = sqlcipher3BtreeKeySize(pCur, &pCur->nKey);
50034   assert( rc==SQLCIPHER_OK );  /* KeySize() cannot fail */
50035
50036   /* If this is an intKey table, then the above call to BtreeKeySize()
50037   ** stores the integer key in pCur->nKey. In this case this value is
50038   ** all that is required. Otherwise, if pCur is not open on an intKey
50039   ** table, then malloc space for and store the pCur->nKey bytes of key 
50040   ** data.
50041   */
50042   if( 0==pCur->apPage[0]->intKey ){
50043     void *pKey = sqlcipher3Malloc( (int)pCur->nKey );
50044     if( pKey ){
50045       rc = sqlcipher3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
50046       if( rc==SQLCIPHER_OK ){
50047         pCur->pKey = pKey;
50048       }else{
50049         sqlcipher3_free(pKey);
50050       }
50051     }else{
50052       rc = SQLCIPHER_NOMEM;
50053     }
50054   }
50055   assert( !pCur->apPage[0]->intKey || !pCur->pKey );
50056
50057   if( rc==SQLCIPHER_OK ){
50058     int i;
50059     for(i=0; i<=pCur->iPage; i++){
50060       releasePage(pCur->apPage[i]);
50061       pCur->apPage[i] = 0;
50062     }
50063     pCur->iPage = -1;
50064     pCur->eState = CURSOR_REQUIRESEEK;
50065   }
50066
50067   invalidateOverflowCache(pCur);
50068   return rc;
50069 }
50070
50071 /*
50072 ** Save the positions of all cursors (except pExcept) that are open on
50073 ** the table  with root-page iRoot. Usually, this is called just before cursor
50074 ** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()).
50075 */
50076 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
50077   BtCursor *p;
50078   assert( sqlcipher3_mutex_held(pBt->mutex) );
50079   assert( pExcept==0 || pExcept->pBt==pBt );
50080   for(p=pBt->pCursor; p; p=p->pNext){
50081     if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) && 
50082         p->eState==CURSOR_VALID ){
50083       int rc = saveCursorPosition(p);
50084       if( SQLCIPHER_OK!=rc ){
50085         return rc;
50086       }
50087     }
50088   }
50089   return SQLCIPHER_OK;
50090 }
50091
50092 /*
50093 ** Clear the current cursor position.
50094 */
50095 SQLCIPHER_PRIVATE void sqlcipher3BtreeClearCursor(BtCursor *pCur){
50096   assert( cursorHoldsMutex(pCur) );
50097   sqlcipher3_free(pCur->pKey);
50098   pCur->pKey = 0;
50099   pCur->eState = CURSOR_INVALID;
50100 }
50101
50102 /*
50103 ** In this version of BtreeMoveto, pKey is a packed index record
50104 ** such as is generated by the OP_MakeRecord opcode.  Unpack the
50105 ** record and then call BtreeMovetoUnpacked() to do the work.
50106 */
50107 static int btreeMoveto(
50108   BtCursor *pCur,     /* Cursor open on the btree to be searched */
50109   const void *pKey,   /* Packed key if the btree is an index */
50110   i64 nKey,           /* Integer key for tables.  Size of pKey for indices */
50111   int bias,           /* Bias search to the high end */
50112   int *pRes           /* Write search results here */
50113 ){
50114   int rc;                    /* Status code */
50115   UnpackedRecord *pIdxKey;   /* Unpacked index key */
50116   char aSpace[150];          /* Temp space for pIdxKey - to avoid a malloc */
50117   char *pFree = 0;
50118
50119   if( pKey ){
50120     assert( nKey==(i64)(int)nKey );
50121     pIdxKey = sqlcipher3VdbeAllocUnpackedRecord(
50122         pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
50123     );
50124     if( pIdxKey==0 ) return SQLCIPHER_NOMEM;
50125     sqlcipher3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
50126   }else{
50127     pIdxKey = 0;
50128   }
50129   rc = sqlcipher3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
50130   if( pFree ){
50131     sqlcipher3DbFree(pCur->pKeyInfo->db, pFree);
50132   }
50133   return rc;
50134 }
50135
50136 /*
50137 ** Restore the cursor to the position it was in (or as close to as possible)
50138 ** when saveCursorPosition() was called. Note that this call deletes the 
50139 ** saved position info stored by saveCursorPosition(), so there can be
50140 ** at most one effective restoreCursorPosition() call after each 
50141 ** saveCursorPosition().
50142 */
50143 static int btreeRestoreCursorPosition(BtCursor *pCur){
50144   int rc;
50145   assert( cursorHoldsMutex(pCur) );
50146   assert( pCur->eState>=CURSOR_REQUIRESEEK );
50147   if( pCur->eState==CURSOR_FAULT ){
50148     return pCur->skipNext;
50149   }
50150   pCur->eState = CURSOR_INVALID;
50151   rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
50152   if( rc==SQLCIPHER_OK ){
50153     sqlcipher3_free(pCur->pKey);
50154     pCur->pKey = 0;
50155     assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
50156   }
50157   return rc;
50158 }
50159
50160 #define restoreCursorPosition(p) \
50161   (p->eState>=CURSOR_REQUIRESEEK ? \
50162          btreeRestoreCursorPosition(p) : \
50163          SQLCIPHER_OK)
50164
50165 /*
50166 ** Determine whether or not a cursor has moved from the position it
50167 ** was last placed at.  Cursors can move when the row they are pointing
50168 ** at is deleted out from under them.
50169 **
50170 ** This routine returns an error code if something goes wrong.  The
50171 ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
50172 */
50173 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
50174   int rc;
50175
50176   rc = restoreCursorPosition(pCur);
50177   if( rc ){
50178     *pHasMoved = 1;
50179     return rc;
50180   }
50181   if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
50182     *pHasMoved = 1;
50183   }else{
50184     *pHasMoved = 0;
50185   }
50186   return SQLCIPHER_OK;
50187 }
50188
50189 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
50190 /*
50191 ** Given a page number of a regular database page, return the page
50192 ** number for the pointer-map page that contains the entry for the
50193 ** input page number.
50194 **
50195 ** Return 0 (not a valid page) for pgno==1 since there is
50196 ** no pointer map associated with page 1.  The integrity_check logic
50197 ** requires that ptrmapPageno(*,1)!=1.
50198 */
50199 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
50200   int nPagesPerMapPage;
50201   Pgno iPtrMap, ret;
50202   assert( sqlcipher3_mutex_held(pBt->mutex) );
50203   if( pgno<2 ) return 0;
50204   nPagesPerMapPage = (pBt->usableSize/5)+1;
50205   iPtrMap = (pgno-2)/nPagesPerMapPage;
50206   ret = (iPtrMap*nPagesPerMapPage) + 2; 
50207   if( ret==PENDING_BYTE_PAGE(pBt) ){
50208     ret++;
50209   }
50210   return ret;
50211 }
50212
50213 /*
50214 ** Write an entry into the pointer map.
50215 **
50216 ** This routine updates the pointer map entry for page number 'key'
50217 ** so that it maps to type 'eType' and parent page number 'pgno'.
50218 **
50219 ** If *pRC is initially non-zero (non-SQLCIPHER_OK) then this routine is
50220 ** a no-op.  If an error occurs, the appropriate error code is written
50221 ** into *pRC.
50222 */
50223 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
50224   DbPage *pDbPage;  /* The pointer map page */
50225   u8 *pPtrmap;      /* The pointer map data */
50226   Pgno iPtrmap;     /* The pointer map page number */
50227   int offset;       /* Offset in pointer map page */
50228   int rc;           /* Return code from subfunctions */
50229
50230   if( *pRC ) return;
50231
50232   assert( sqlcipher3_mutex_held(pBt->mutex) );
50233   /* The master-journal page number must never be used as a pointer map page */
50234   assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
50235
50236   assert( pBt->autoVacuum );
50237   if( key==0 ){
50238     *pRC = SQLCIPHER_CORRUPT_BKPT;
50239     return;
50240   }
50241   iPtrmap = PTRMAP_PAGENO(pBt, key);
50242   rc = sqlcipher3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
50243   if( rc!=SQLCIPHER_OK ){
50244     *pRC = rc;
50245     return;
50246   }
50247   offset = PTRMAP_PTROFFSET(iPtrmap, key);
50248   if( offset<0 ){
50249     *pRC = SQLCIPHER_CORRUPT_BKPT;
50250     goto ptrmap_exit;
50251   }
50252   assert( offset <= (int)pBt->usableSize-5 );
50253   pPtrmap = (u8 *)sqlcipher3PagerGetData(pDbPage);
50254
50255   if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
50256     TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
50257     *pRC= rc = sqlcipher3PagerWrite(pDbPage);
50258     if( rc==SQLCIPHER_OK ){
50259       pPtrmap[offset] = eType;
50260       put4byte(&pPtrmap[offset+1], parent);
50261     }
50262   }
50263
50264 ptrmap_exit:
50265   sqlcipher3PagerUnref(pDbPage);
50266 }
50267
50268 /*
50269 ** Read an entry from the pointer map.
50270 **
50271 ** This routine retrieves the pointer map entry for page 'key', writing
50272 ** the type and parent page number to *pEType and *pPgno respectively.
50273 ** An error code is returned if something goes wrong, otherwise SQLCIPHER_OK.
50274 */
50275 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
50276   DbPage *pDbPage;   /* The pointer map page */
50277   int iPtrmap;       /* Pointer map page index */
50278   u8 *pPtrmap;       /* Pointer map page data */
50279   int offset;        /* Offset of entry in pointer map */
50280   int rc;
50281
50282   assert( sqlcipher3_mutex_held(pBt->mutex) );
50283
50284   iPtrmap = PTRMAP_PAGENO(pBt, key);
50285   rc = sqlcipher3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
50286   if( rc!=0 ){
50287     return rc;
50288   }
50289   pPtrmap = (u8 *)sqlcipher3PagerGetData(pDbPage);
50290
50291   offset = PTRMAP_PTROFFSET(iPtrmap, key);
50292   if( offset<0 ){
50293     sqlcipher3PagerUnref(pDbPage);
50294     return SQLCIPHER_CORRUPT_BKPT;
50295   }
50296   assert( offset <= (int)pBt->usableSize-5 );
50297   assert( pEType!=0 );
50298   *pEType = pPtrmap[offset];
50299   if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
50300
50301   sqlcipher3PagerUnref(pDbPage);
50302   if( *pEType<1 || *pEType>5 ) return SQLCIPHER_CORRUPT_BKPT;
50303   return SQLCIPHER_OK;
50304 }
50305
50306 #else /* if defined SQLCIPHER_OMIT_AUTOVACUUM */
50307   #define ptrmapPut(w,x,y,z,rc)
50308   #define ptrmapGet(w,x,y,z) SQLCIPHER_OK
50309   #define ptrmapPutOvflPtr(x, y, rc)
50310 #endif
50311
50312 /*
50313 ** Given a btree page and a cell index (0 means the first cell on
50314 ** the page, 1 means the second cell, and so forth) return a pointer
50315 ** to the cell content.
50316 **
50317 ** This routine works only for pages that do not contain overflow cells.
50318 */
50319 #define findCell(P,I) \
50320   ((P)->aData + ((P)->maskPage & get2byte(&(P)->aData[(P)->cellOffset+2*(I)])))
50321 #define findCellv2(D,M,O,I) (D+(M&get2byte(D+(O+2*(I)))))
50322
50323
50324 /*
50325 ** This a more complex version of findCell() that works for
50326 ** pages that do contain overflow cells.
50327 */
50328 static u8 *findOverflowCell(MemPage *pPage, int iCell){
50329   int i;
50330   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50331   for(i=pPage->nOverflow-1; i>=0; i--){
50332     int k;
50333     struct _OvflCell *pOvfl;
50334     pOvfl = &pPage->aOvfl[i];
50335     k = pOvfl->idx;
50336     if( k<=iCell ){
50337       if( k==iCell ){
50338         return pOvfl->pCell;
50339       }
50340       iCell--;
50341     }
50342   }
50343   return findCell(pPage, iCell);
50344 }
50345
50346 /*
50347 ** Parse a cell content block and fill in the CellInfo structure.  There
50348 ** are two versions of this function.  btreeParseCell() takes a 
50349 ** cell index as the second argument and btreeParseCellPtr() 
50350 ** takes a pointer to the body of the cell as its second argument.
50351 **
50352 ** Within this file, the parseCell() macro can be called instead of
50353 ** btreeParseCellPtr(). Using some compilers, this will be faster.
50354 */
50355 static void btreeParseCellPtr(
50356   MemPage *pPage,         /* Page containing the cell */
50357   u8 *pCell,              /* Pointer to the cell text. */
50358   CellInfo *pInfo         /* Fill in this structure */
50359 ){
50360   u16 n;                  /* Number bytes in cell content header */
50361   u32 nPayload;           /* Number of bytes of cell payload */
50362
50363   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50364
50365   pInfo->pCell = pCell;
50366   assert( pPage->leaf==0 || pPage->leaf==1 );
50367   n = pPage->childPtrSize;
50368   assert( n==4-4*pPage->leaf );
50369   if( pPage->intKey ){
50370     if( pPage->hasData ){
50371       n += getVarint32(&pCell[n], nPayload);
50372     }else{
50373       nPayload = 0;
50374     }
50375     n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
50376     pInfo->nData = nPayload;
50377   }else{
50378     pInfo->nData = 0;
50379     n += getVarint32(&pCell[n], nPayload);
50380     pInfo->nKey = nPayload;
50381   }
50382   pInfo->nPayload = nPayload;
50383   pInfo->nHeader = n;
50384   testcase( nPayload==pPage->maxLocal );
50385   testcase( nPayload==pPage->maxLocal+1 );
50386   if( likely(nPayload<=pPage->maxLocal) ){
50387     /* This is the (easy) common case where the entire payload fits
50388     ** on the local page.  No overflow is required.
50389     */
50390     if( (pInfo->nSize = (u16)(n+nPayload))<4 ) pInfo->nSize = 4;
50391     pInfo->nLocal = (u16)nPayload;
50392     pInfo->iOverflow = 0;
50393   }else{
50394     /* If the payload will not fit completely on the local page, we have
50395     ** to decide how much to store locally and how much to spill onto
50396     ** overflow pages.  The strategy is to minimize the amount of unused
50397     ** space on overflow pages while keeping the amount of local storage
50398     ** in between minLocal and maxLocal.
50399     **
50400     ** Warning:  changing the way overflow payload is distributed in any
50401     ** way will result in an incompatible file format.
50402     */
50403     int minLocal;  /* Minimum amount of payload held locally */
50404     int maxLocal;  /* Maximum amount of payload held locally */
50405     int surplus;   /* Overflow payload available for local storage */
50406
50407     minLocal = pPage->minLocal;
50408     maxLocal = pPage->maxLocal;
50409     surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
50410     testcase( surplus==maxLocal );
50411     testcase( surplus==maxLocal+1 );
50412     if( surplus <= maxLocal ){
50413       pInfo->nLocal = (u16)surplus;
50414     }else{
50415       pInfo->nLocal = (u16)minLocal;
50416     }
50417     pInfo->iOverflow = (u16)(pInfo->nLocal + n);
50418     pInfo->nSize = pInfo->iOverflow + 4;
50419   }
50420 }
50421 #define parseCell(pPage, iCell, pInfo) \
50422   btreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo))
50423 static void btreeParseCell(
50424   MemPage *pPage,         /* Page containing the cell */
50425   int iCell,              /* The cell index.  First cell is 0 */
50426   CellInfo *pInfo         /* Fill in this structure */
50427 ){
50428   parseCell(pPage, iCell, pInfo);
50429 }
50430
50431 /*
50432 ** Compute the total number of bytes that a Cell needs in the cell
50433 ** data area of the btree-page.  The return number includes the cell
50434 ** data header and the local payload, but not any overflow page or
50435 ** the space used by the cell pointer.
50436 */
50437 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
50438   u8 *pIter = &pCell[pPage->childPtrSize];
50439   u32 nSize;
50440
50441 #ifdef SQLCIPHER_DEBUG
50442   /* The value returned by this function should always be the same as
50443   ** the (CellInfo.nSize) value found by doing a full parse of the
50444   ** cell. If SQLCIPHER_DEBUG is defined, an assert() at the bottom of
50445   ** this function verifies that this invariant is not violated. */
50446   CellInfo debuginfo;
50447   btreeParseCellPtr(pPage, pCell, &debuginfo);
50448 #endif
50449
50450   if( pPage->intKey ){
50451     u8 *pEnd;
50452     if( pPage->hasData ){
50453       pIter += getVarint32(pIter, nSize);
50454     }else{
50455       nSize = 0;
50456     }
50457
50458     /* pIter now points at the 64-bit integer key value, a variable length 
50459     ** integer. The following block moves pIter to point at the first byte
50460     ** past the end of the key value. */
50461     pEnd = &pIter[9];
50462     while( (*pIter++)&0x80 && pIter<pEnd );
50463   }else{
50464     pIter += getVarint32(pIter, nSize);
50465   }
50466
50467   testcase( nSize==pPage->maxLocal );
50468   testcase( nSize==pPage->maxLocal+1 );
50469   if( nSize>pPage->maxLocal ){
50470     int minLocal = pPage->minLocal;
50471     nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
50472     testcase( nSize==pPage->maxLocal );
50473     testcase( nSize==pPage->maxLocal+1 );
50474     if( nSize>pPage->maxLocal ){
50475       nSize = minLocal;
50476     }
50477     nSize += 4;
50478   }
50479   nSize += (u32)(pIter - pCell);
50480
50481   /* The minimum size of any cell is 4 bytes. */
50482   if( nSize<4 ){
50483     nSize = 4;
50484   }
50485
50486   assert( nSize==debuginfo.nSize );
50487   return (u16)nSize;
50488 }
50489
50490 #ifdef SQLCIPHER_DEBUG
50491 /* This variation on cellSizePtr() is used inside of assert() statements
50492 ** only. */
50493 static u16 cellSize(MemPage *pPage, int iCell){
50494   return cellSizePtr(pPage, findCell(pPage, iCell));
50495 }
50496 #endif
50497
50498 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
50499 /*
50500 ** If the cell pCell, part of page pPage contains a pointer
50501 ** to an overflow page, insert an entry into the pointer-map
50502 ** for the overflow page.
50503 */
50504 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
50505   CellInfo info;
50506   if( *pRC ) return;
50507   assert( pCell!=0 );
50508   btreeParseCellPtr(pPage, pCell, &info);
50509   assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
50510   if( info.iOverflow ){
50511     Pgno ovfl = get4byte(&pCell[info.iOverflow]);
50512     ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
50513   }
50514 }
50515 #endif
50516
50517
50518 /*
50519 ** Defragment the page given.  All Cells are moved to the
50520 ** end of the page and all free space is collected into one
50521 ** big FreeBlk that occurs in between the header and cell
50522 ** pointer array and the cell content area.
50523 */
50524 static int defragmentPage(MemPage *pPage){
50525   int i;                     /* Loop counter */
50526   int pc;                    /* Address of a i-th cell */
50527   int hdr;                   /* Offset to the page header */
50528   int size;                  /* Size of a cell */
50529   int usableSize;            /* Number of usable bytes on a page */
50530   int cellOffset;            /* Offset to the cell pointer array */
50531   int cbrk;                  /* Offset to the cell content area */
50532   int nCell;                 /* Number of cells on the page */
50533   unsigned char *data;       /* The page data */
50534   unsigned char *temp;       /* Temp area for cell content */
50535   int iCellFirst;            /* First allowable cell index */
50536   int iCellLast;             /* Last possible cell index */
50537
50538
50539   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
50540   assert( pPage->pBt!=0 );
50541   assert( pPage->pBt->usableSize <= SQLCIPHER_MAX_PAGE_SIZE );
50542   assert( pPage->nOverflow==0 );
50543   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50544   temp = sqlcipher3PagerTempSpace(pPage->pBt->pPager);
50545   data = pPage->aData;
50546   hdr = pPage->hdrOffset;
50547   cellOffset = pPage->cellOffset;
50548   nCell = pPage->nCell;
50549   assert( nCell==get2byte(&data[hdr+3]) );
50550   usableSize = pPage->pBt->usableSize;
50551   cbrk = get2byte(&data[hdr+5]);
50552   memcpy(&temp[cbrk], &data[cbrk], usableSize - cbrk);
50553   cbrk = usableSize;
50554   iCellFirst = cellOffset + 2*nCell;
50555   iCellLast = usableSize - 4;
50556   for(i=0; i<nCell; i++){
50557     u8 *pAddr;     /* The i-th cell pointer */
50558     pAddr = &data[cellOffset + i*2];
50559     pc = get2byte(pAddr);
50560     testcase( pc==iCellFirst );
50561     testcase( pc==iCellLast );
50562 #if !defined(SQLCIPHER_ENABLE_OVERSIZE_CELL_CHECK)
50563     /* These conditions have already been verified in btreeInitPage()
50564     ** if SQLCIPHER_ENABLE_OVERSIZE_CELL_CHECK is defined 
50565     */
50566     if( pc<iCellFirst || pc>iCellLast ){
50567       return SQLCIPHER_CORRUPT_BKPT;
50568     }
50569 #endif
50570     assert( pc>=iCellFirst && pc<=iCellLast );
50571     size = cellSizePtr(pPage, &temp[pc]);
50572     cbrk -= size;
50573 #if defined(SQLCIPHER_ENABLE_OVERSIZE_CELL_CHECK)
50574     if( cbrk<iCellFirst ){
50575       return SQLCIPHER_CORRUPT_BKPT;
50576     }
50577 #else
50578     if( cbrk<iCellFirst || pc+size>usableSize ){
50579       return SQLCIPHER_CORRUPT_BKPT;
50580     }
50581 #endif
50582     assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
50583     testcase( cbrk+size==usableSize );
50584     testcase( pc+size==usableSize );
50585     memcpy(&data[cbrk], &temp[pc], size);
50586     put2byte(pAddr, cbrk);
50587   }
50588   assert( cbrk>=iCellFirst );
50589   put2byte(&data[hdr+5], cbrk);
50590   data[hdr+1] = 0;
50591   data[hdr+2] = 0;
50592   data[hdr+7] = 0;
50593   memset(&data[iCellFirst], 0, cbrk-iCellFirst);
50594   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
50595   if( cbrk-iCellFirst!=pPage->nFree ){
50596     return SQLCIPHER_CORRUPT_BKPT;
50597   }
50598   return SQLCIPHER_OK;
50599 }
50600
50601 /*
50602 ** Allocate nByte bytes of space from within the B-Tree page passed
50603 ** as the first argument. Write into *pIdx the index into pPage->aData[]
50604 ** of the first byte of allocated space. Return either SQLCIPHER_OK or
50605 ** an error code (usually SQLCIPHER_CORRUPT).
50606 **
50607 ** The caller guarantees that there is sufficient space to make the
50608 ** allocation.  This routine might need to defragment in order to bring
50609 ** all the space together, however.  This routine will avoid using
50610 ** the first two bytes past the cell pointer area since presumably this
50611 ** allocation is being made in order to insert a new cell, so we will
50612 ** also end up needing a new cell pointer.
50613 */
50614 static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
50615   const int hdr = pPage->hdrOffset;    /* Local cache of pPage->hdrOffset */
50616   u8 * const data = pPage->aData;      /* Local cache of pPage->aData */
50617   int nFrag;                           /* Number of fragmented bytes on pPage */
50618   int top;                             /* First byte of cell content area */
50619   int gap;        /* First byte of gap between cell pointers and cell content */
50620   int rc;         /* Integer return code */
50621   int usableSize; /* Usable size of the page */
50622   
50623   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
50624   assert( pPage->pBt );
50625   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50626   assert( nByte>=0 );  /* Minimum cell size is 4 */
50627   assert( pPage->nFree>=nByte );
50628   assert( pPage->nOverflow==0 );
50629   usableSize = pPage->pBt->usableSize;
50630   assert( nByte < usableSize-8 );
50631
50632   nFrag = data[hdr+7];
50633   assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
50634   gap = pPage->cellOffset + 2*pPage->nCell;
50635   top = get2byteNotZero(&data[hdr+5]);
50636   if( gap>top ) return SQLCIPHER_CORRUPT_BKPT;
50637   testcase( gap+2==top );
50638   testcase( gap+1==top );
50639   testcase( gap==top );
50640
50641   if( nFrag>=60 ){
50642     /* Always defragment highly fragmented pages */
50643     rc = defragmentPage(pPage);
50644     if( rc ) return rc;
50645     top = get2byteNotZero(&data[hdr+5]);
50646   }else if( gap+2<=top ){
50647     /* Search the freelist looking for a free slot big enough to satisfy 
50648     ** the request. The allocation is made from the first free slot in 
50649     ** the list that is large enough to accomadate it.
50650     */
50651     int pc, addr;
50652     for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
50653       int size;            /* Size of the free slot */
50654       if( pc>usableSize-4 || pc<addr+4 ){
50655         return SQLCIPHER_CORRUPT_BKPT;
50656       }
50657       size = get2byte(&data[pc+2]);
50658       if( size>=nByte ){
50659         int x = size - nByte;
50660         testcase( x==4 );
50661         testcase( x==3 );
50662         if( x<4 ){
50663           /* Remove the slot from the free-list. Update the number of
50664           ** fragmented bytes within the page. */
50665           memcpy(&data[addr], &data[pc], 2);
50666           data[hdr+7] = (u8)(nFrag + x);
50667         }else if( size+pc > usableSize ){
50668           return SQLCIPHER_CORRUPT_BKPT;
50669         }else{
50670           /* The slot remains on the free-list. Reduce its size to account
50671           ** for the portion used by the new allocation. */
50672           put2byte(&data[pc+2], x);
50673         }
50674         *pIdx = pc + x;
50675         return SQLCIPHER_OK;
50676       }
50677     }
50678   }
50679
50680   /* Check to make sure there is enough space in the gap to satisfy
50681   ** the allocation.  If not, defragment.
50682   */
50683   testcase( gap+2+nByte==top );
50684   if( gap+2+nByte>top ){
50685     rc = defragmentPage(pPage);
50686     if( rc ) return rc;
50687     top = get2byteNotZero(&data[hdr+5]);
50688     assert( gap+nByte<=top );
50689   }
50690
50691
50692   /* Allocate memory from the gap in between the cell pointer array
50693   ** and the cell content area.  The btreeInitPage() call has already
50694   ** validated the freelist.  Given that the freelist is valid, there
50695   ** is no way that the allocation can extend off the end of the page.
50696   ** The assert() below verifies the previous sentence.
50697   */
50698   top -= nByte;
50699   put2byte(&data[hdr+5], top);
50700   assert( top+nByte <= (int)pPage->pBt->usableSize );
50701   *pIdx = top;
50702   return SQLCIPHER_OK;
50703 }
50704
50705 /*
50706 ** Return a section of the pPage->aData to the freelist.
50707 ** The first byte of the new free block is pPage->aDisk[start]
50708 ** and the size of the block is "size" bytes.
50709 **
50710 ** Most of the effort here is involved in coalesing adjacent
50711 ** free blocks into a single big free block.
50712 */
50713 static int freeSpace(MemPage *pPage, int start, int size){
50714   int addr, pbegin, hdr;
50715   int iLast;                        /* Largest possible freeblock offset */
50716   unsigned char *data = pPage->aData;
50717
50718   assert( pPage->pBt!=0 );
50719   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
50720   assert( start>=pPage->hdrOffset+6+pPage->childPtrSize );
50721   assert( (start + size) <= (int)pPage->pBt->usableSize );
50722   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50723   assert( size>=0 );   /* Minimum cell size is 4 */
50724
50725   if( pPage->pBt->secureDelete ){
50726     /* Overwrite deleted information with zeros when the secure_delete
50727     ** option is enabled */
50728     memset(&data[start], 0, size);
50729   }
50730
50731   /* Add the space back into the linked list of freeblocks.  Note that
50732   ** even though the freeblock list was checked by btreeInitPage(),
50733   ** btreeInitPage() did not detect overlapping cells or
50734   ** freeblocks that overlapped cells.   Nor does it detect when the
50735   ** cell content area exceeds the value in the page header.  If these
50736   ** situations arise, then subsequent insert operations might corrupt
50737   ** the freelist.  So we do need to check for corruption while scanning
50738   ** the freelist.
50739   */
50740   hdr = pPage->hdrOffset;
50741   addr = hdr + 1;
50742   iLast = pPage->pBt->usableSize - 4;
50743   assert( start<=iLast );
50744   while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){
50745     if( pbegin<addr+4 ){
50746       return SQLCIPHER_CORRUPT_BKPT;
50747     }
50748     addr = pbegin;
50749   }
50750   if( pbegin>iLast ){
50751     return SQLCIPHER_CORRUPT_BKPT;
50752   }
50753   assert( pbegin>addr || pbegin==0 );
50754   put2byte(&data[addr], start);
50755   put2byte(&data[start], pbegin);
50756   put2byte(&data[start+2], size);
50757   pPage->nFree = pPage->nFree + (u16)size;
50758
50759   /* Coalesce adjacent free blocks */
50760   addr = hdr + 1;
50761   while( (pbegin = get2byte(&data[addr]))>0 ){
50762     int pnext, psize, x;
50763     assert( pbegin>addr );
50764     assert( pbegin <= (int)pPage->pBt->usableSize-4 );
50765     pnext = get2byte(&data[pbegin]);
50766     psize = get2byte(&data[pbegin+2]);
50767     if( pbegin + psize + 3 >= pnext && pnext>0 ){
50768       int frag = pnext - (pbegin+psize);
50769       if( (frag<0) || (frag>(int)data[hdr+7]) ){
50770         return SQLCIPHER_CORRUPT_BKPT;
50771       }
50772       data[hdr+7] -= (u8)frag;
50773       x = get2byte(&data[pnext]);
50774       put2byte(&data[pbegin], x);
50775       x = pnext + get2byte(&data[pnext+2]) - pbegin;
50776       put2byte(&data[pbegin+2], x);
50777     }else{
50778       addr = pbegin;
50779     }
50780   }
50781
50782   /* If the cell content area begins with a freeblock, remove it. */
50783   if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
50784     int top;
50785     pbegin = get2byte(&data[hdr+1]);
50786     memcpy(&data[hdr+1], &data[pbegin], 2);
50787     top = get2byte(&data[hdr+5]) + get2byte(&data[pbegin+2]);
50788     put2byte(&data[hdr+5], top);
50789   }
50790   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
50791   return SQLCIPHER_OK;
50792 }
50793
50794 /*
50795 ** Decode the flags byte (the first byte of the header) for a page
50796 ** and initialize fields of the MemPage structure accordingly.
50797 **
50798 ** Only the following combinations are supported.  Anything different
50799 ** indicates a corrupt database files:
50800 **
50801 **         PTF_ZERODATA
50802 **         PTF_ZERODATA | PTF_LEAF
50803 **         PTF_LEAFDATA | PTF_INTKEY
50804 **         PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF
50805 */
50806 static int decodeFlags(MemPage *pPage, int flagByte){
50807   BtShared *pBt;     /* A copy of pPage->pBt */
50808
50809   assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
50810   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50811   pPage->leaf = (u8)(flagByte>>3);  assert( PTF_LEAF == 1<<3 );
50812   flagByte &= ~PTF_LEAF;
50813   pPage->childPtrSize = 4-4*pPage->leaf;
50814   pBt = pPage->pBt;
50815   if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){
50816     pPage->intKey = 1;
50817     pPage->hasData = pPage->leaf;
50818     pPage->maxLocal = pBt->maxLeaf;
50819     pPage->minLocal = pBt->minLeaf;
50820   }else if( flagByte==PTF_ZERODATA ){
50821     pPage->intKey = 0;
50822     pPage->hasData = 0;
50823     pPage->maxLocal = pBt->maxLocal;
50824     pPage->minLocal = pBt->minLocal;
50825   }else{
50826     return SQLCIPHER_CORRUPT_BKPT;
50827   }
50828   return SQLCIPHER_OK;
50829 }
50830
50831 /*
50832 ** Initialize the auxiliary information for a disk block.
50833 **
50834 ** Return SQLCIPHER_OK on success.  If we see that the page does
50835 ** not contain a well-formed database page, then return 
50836 ** SQLCIPHER_CORRUPT.  Note that a return of SQLCIPHER_OK does not
50837 ** guarantee that the page is well-formed.  It only shows that
50838 ** we failed to detect any corruption.
50839 */
50840 static int btreeInitPage(MemPage *pPage){
50841
50842   assert( pPage->pBt!=0 );
50843   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
50844   assert( pPage->pgno==sqlcipher3PagerPagenumber(pPage->pDbPage) );
50845   assert( pPage == sqlcipher3PagerGetExtra(pPage->pDbPage) );
50846   assert( pPage->aData == sqlcipher3PagerGetData(pPage->pDbPage) );
50847
50848   if( !pPage->isInit ){
50849     u16 pc;            /* Address of a freeblock within pPage->aData[] */
50850     u8 hdr;            /* Offset to beginning of page header */
50851     u8 *data;          /* Equal to pPage->aData */
50852     BtShared *pBt;        /* The main btree structure */
50853     int usableSize;    /* Amount of usable space on each page */
50854     u16 cellOffset;    /* Offset from start of page to first cell pointer */
50855     int nFree;         /* Number of unused bytes on the page */
50856     int top;           /* First byte of the cell content area */
50857     int iCellFirst;    /* First allowable cell or freeblock offset */
50858     int iCellLast;     /* Last possible cell or freeblock offset */
50859
50860     pBt = pPage->pBt;
50861
50862     hdr = pPage->hdrOffset;
50863     data = pPage->aData;
50864     if( decodeFlags(pPage, data[hdr]) ) return SQLCIPHER_CORRUPT_BKPT;
50865     assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
50866     pPage->maskPage = (u16)(pBt->pageSize - 1);
50867     pPage->nOverflow = 0;
50868     usableSize = pBt->usableSize;
50869     pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
50870     top = get2byteNotZero(&data[hdr+5]);
50871     pPage->nCell = get2byte(&data[hdr+3]);
50872     if( pPage->nCell>MX_CELL(pBt) ){
50873       /* To many cells for a single page.  The page must be corrupt */
50874       return SQLCIPHER_CORRUPT_BKPT;
50875     }
50876     testcase( pPage->nCell==MX_CELL(pBt) );
50877
50878     /* A malformed database page might cause us to read past the end
50879     ** of page when parsing a cell.  
50880     **
50881     ** The following block of code checks early to see if a cell extends
50882     ** past the end of a page boundary and causes SQLCIPHER_CORRUPT to be 
50883     ** returned if it does.
50884     */
50885     iCellFirst = cellOffset + 2*pPage->nCell;
50886     iCellLast = usableSize - 4;
50887 #if defined(SQLCIPHER_ENABLE_OVERSIZE_CELL_CHECK)
50888     {
50889       int i;            /* Index into the cell pointer array */
50890       int sz;           /* Size of a cell */
50891
50892       if( !pPage->leaf ) iCellLast--;
50893       for(i=0; i<pPage->nCell; i++){
50894         pc = get2byte(&data[cellOffset+i*2]);
50895         testcase( pc==iCellFirst );
50896         testcase( pc==iCellLast );
50897         if( pc<iCellFirst || pc>iCellLast ){
50898           return SQLCIPHER_CORRUPT_BKPT;
50899         }
50900         sz = cellSizePtr(pPage, &data[pc]);
50901         testcase( pc+sz==usableSize );
50902         if( pc+sz>usableSize ){
50903           return SQLCIPHER_CORRUPT_BKPT;
50904         }
50905       }
50906       if( !pPage->leaf ) iCellLast++;
50907     }  
50908 #endif
50909
50910     /* Compute the total free space on the page */
50911     pc = get2byte(&data[hdr+1]);
50912     nFree = data[hdr+7] + top;
50913     while( pc>0 ){
50914       u16 next, size;
50915       if( pc<iCellFirst || pc>iCellLast ){
50916         /* Start of free block is off the page */
50917         return SQLCIPHER_CORRUPT_BKPT; 
50918       }
50919       next = get2byte(&data[pc]);
50920       size = get2byte(&data[pc+2]);
50921       if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
50922         /* Free blocks must be in ascending order. And the last byte of
50923         ** the free-block must lie on the database page.  */
50924         return SQLCIPHER_CORRUPT_BKPT; 
50925       }
50926       nFree = nFree + size;
50927       pc = next;
50928     }
50929
50930     /* At this point, nFree contains the sum of the offset to the start
50931     ** of the cell-content area plus the number of free bytes within
50932     ** the cell-content area. If this is greater than the usable-size
50933     ** of the page, then the page must be corrupted. This check also
50934     ** serves to verify that the offset to the start of the cell-content
50935     ** area, according to the page header, lies within the page.
50936     */
50937     if( nFree>usableSize ){
50938       return SQLCIPHER_CORRUPT_BKPT; 
50939     }
50940     pPage->nFree = (u16)(nFree - iCellFirst);
50941     pPage->isInit = 1;
50942   }
50943   return SQLCIPHER_OK;
50944 }
50945
50946 /*
50947 ** Set up a raw page so that it looks like a database page holding
50948 ** no entries.
50949 */
50950 static void zeroPage(MemPage *pPage, int flags){
50951   unsigned char *data = pPage->aData;
50952   BtShared *pBt = pPage->pBt;
50953   u8 hdr = pPage->hdrOffset;
50954   u16 first;
50955
50956   assert( sqlcipher3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
50957   assert( sqlcipher3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
50958   assert( sqlcipher3PagerGetData(pPage->pDbPage) == data );
50959   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
50960   assert( sqlcipher3_mutex_held(pBt->mutex) );
50961   if( pBt->secureDelete ){
50962     memset(&data[hdr], 0, pBt->usableSize - hdr);
50963   }
50964   data[hdr] = (char)flags;
50965   first = hdr + 8 + 4*((flags&PTF_LEAF)==0 ?1:0);
50966   memset(&data[hdr+1], 0, 4);
50967   data[hdr+7] = 0;
50968   put2byte(&data[hdr+5], pBt->usableSize);
50969   pPage->nFree = (u16)(pBt->usableSize - first);
50970   decodeFlags(pPage, flags);
50971   pPage->hdrOffset = hdr;
50972   pPage->cellOffset = first;
50973   pPage->nOverflow = 0;
50974   assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
50975   pPage->maskPage = (u16)(pBt->pageSize - 1);
50976   pPage->nCell = 0;
50977   pPage->isInit = 1;
50978 }
50979
50980
50981 /*
50982 ** Convert a DbPage obtained from the pager into a MemPage used by
50983 ** the btree layer.
50984 */
50985 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
50986   MemPage *pPage = (MemPage*)sqlcipher3PagerGetExtra(pDbPage);
50987   pPage->aData = sqlcipher3PagerGetData(pDbPage);
50988   pPage->pDbPage = pDbPage;
50989   pPage->pBt = pBt;
50990   pPage->pgno = pgno;
50991   pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
50992   return pPage; 
50993 }
50994
50995 /*
50996 ** Get a page from the pager.  Initialize the MemPage.pBt and
50997 ** MemPage.aData elements if needed.
50998 **
50999 ** If the noContent flag is set, it means that we do not care about
51000 ** the content of the page at this time.  So do not go to the disk
51001 ** to fetch the content.  Just fill in the content with zeros for now.
51002 ** If in the future we call sqlcipher3PagerWrite() on this page, that
51003 ** means we have started to be concerned about content and the disk
51004 ** read should occur at that point.
51005 */
51006 static int btreeGetPage(
51007   BtShared *pBt,       /* The btree */
51008   Pgno pgno,           /* Number of the page to fetch */
51009   MemPage **ppPage,    /* Return the page in this parameter */
51010   int noContent        /* Do not load page content if true */
51011 ){
51012   int rc;
51013   DbPage *pDbPage;
51014
51015   assert( sqlcipher3_mutex_held(pBt->mutex) );
51016   rc = sqlcipher3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
51017   if( rc ) return rc;
51018   *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
51019   return SQLCIPHER_OK;
51020 }
51021
51022 /*
51023 ** Retrieve a page from the pager cache. If the requested page is not
51024 ** already in the pager cache return NULL. Initialize the MemPage.pBt and
51025 ** MemPage.aData elements if needed.
51026 */
51027 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
51028   DbPage *pDbPage;
51029   assert( sqlcipher3_mutex_held(pBt->mutex) );
51030   pDbPage = sqlcipher3PagerLookup(pBt->pPager, pgno);
51031   if( pDbPage ){
51032     return btreePageFromDbPage(pDbPage, pgno, pBt);
51033   }
51034   return 0;
51035 }
51036
51037 /*
51038 ** Return the size of the database file in pages. If there is any kind of
51039 ** error, return ((unsigned int)-1).
51040 */
51041 static Pgno btreePagecount(BtShared *pBt){
51042   return pBt->nPage;
51043 }
51044 SQLCIPHER_PRIVATE u32 sqlcipher3BtreeLastPage(Btree *p){
51045   assert( sqlcipher3BtreeHoldsMutex(p) );
51046   assert( ((p->pBt->nPage)&0x8000000)==0 );
51047   return (int)btreePagecount(p->pBt);
51048 }
51049
51050 /*
51051 ** Get a page from the pager and initialize it.  This routine is just a
51052 ** convenience wrapper around separate calls to btreeGetPage() and 
51053 ** btreeInitPage().
51054 **
51055 ** If an error occurs, then the value *ppPage is set to is undefined. It
51056 ** may remain unchanged, or it may be set to an invalid value.
51057 */
51058 static int getAndInitPage(
51059   BtShared *pBt,          /* The database file */
51060   Pgno pgno,           /* Number of the page to get */
51061   MemPage **ppPage     /* Write the page pointer here */
51062 ){
51063   int rc;
51064   assert( sqlcipher3_mutex_held(pBt->mutex) );
51065
51066   if( pgno>btreePagecount(pBt) ){
51067     rc = SQLCIPHER_CORRUPT_BKPT;
51068   }else{
51069     rc = btreeGetPage(pBt, pgno, ppPage, 0);
51070     if( rc==SQLCIPHER_OK ){
51071       rc = btreeInitPage(*ppPage);
51072       if( rc!=SQLCIPHER_OK ){
51073         releasePage(*ppPage);
51074       }
51075     }
51076   }
51077
51078   testcase( pgno==0 );
51079   assert( pgno!=0 || rc==SQLCIPHER_CORRUPT );
51080   return rc;
51081 }
51082
51083 /*
51084 ** Release a MemPage.  This should be called once for each prior
51085 ** call to btreeGetPage.
51086 */
51087 static void releasePage(MemPage *pPage){
51088   if( pPage ){
51089     assert( pPage->aData );
51090     assert( pPage->pBt );
51091     assert( sqlcipher3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
51092     assert( sqlcipher3PagerGetData(pPage->pDbPage)==pPage->aData );
51093     assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
51094     sqlcipher3PagerUnref(pPage->pDbPage);
51095   }
51096 }
51097
51098 /*
51099 ** During a rollback, when the pager reloads information into the cache
51100 ** so that the cache is restored to its original state at the start of
51101 ** the transaction, for each page restored this routine is called.
51102 **
51103 ** This routine needs to reset the extra data section at the end of the
51104 ** page to agree with the restored data.
51105 */
51106 static void pageReinit(DbPage *pData){
51107   MemPage *pPage;
51108   pPage = (MemPage *)sqlcipher3PagerGetExtra(pData);
51109   assert( sqlcipher3PagerPageRefcount(pData)>0 );
51110   if( pPage->isInit ){
51111     assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
51112     pPage->isInit = 0;
51113     if( sqlcipher3PagerPageRefcount(pData)>1 ){
51114       /* pPage might not be a btree page;  it might be an overflow page
51115       ** or ptrmap page or a free page.  In those cases, the following
51116       ** call to btreeInitPage() will likely return SQLCIPHER_CORRUPT.
51117       ** But no harm is done by this.  And it is very important that
51118       ** btreeInitPage() be called on every btree page so we make
51119       ** the call for every page that comes in for re-initing. */
51120       btreeInitPage(pPage);
51121     }
51122   }
51123 }
51124
51125 /*
51126 ** Invoke the busy handler for a btree.
51127 */
51128 static int btreeInvokeBusyHandler(void *pArg){
51129   BtShared *pBt = (BtShared*)pArg;
51130   assert( pBt->db );
51131   assert( sqlcipher3_mutex_held(pBt->db->mutex) );
51132   return sqlcipher3InvokeBusyHandler(&pBt->db->busyHandler);
51133 }
51134
51135 /*
51136 ** Open a database file.
51137 ** 
51138 ** zFilename is the name of the database file.  If zFilename is NULL
51139 ** then an ephemeral database is created.  The ephemeral database might
51140 ** be exclusively in memory, or it might use a disk-based memory cache.
51141 ** Either way, the ephemeral database will be automatically deleted 
51142 ** when sqlcipher3BtreeClose() is called.
51143 **
51144 ** If zFilename is ":memory:" then an in-memory database is created
51145 ** that is automatically destroyed when it is closed.
51146 **
51147 ** The "flags" parameter is a bitmask that might contain bits
51148 ** BTREE_OMIT_JOURNAL and/or BTREE_NO_READLOCK.  The BTREE_NO_READLOCK
51149 ** bit is also set if the SQLCIPHER_NoReadlock flags is set in db->flags.
51150 ** These flags are passed through into sqlcipher3PagerOpen() and must
51151 ** be the same values as PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK.
51152 **
51153 ** If the database is already opened in the same database connection
51154 ** and we are in shared cache mode, then the open will fail with an
51155 ** SQLCIPHER_CONSTRAINT error.  We cannot allow two or more BtShared
51156 ** objects in the same database connection since doing so will lead
51157 ** to problems with locking.
51158 */
51159 SQLCIPHER_PRIVATE int sqlcipher3BtreeOpen(
51160   sqlcipher3_vfs *pVfs,      /* VFS to use for this b-tree */
51161   const char *zFilename,  /* Name of the file containing the BTree database */
51162   sqlcipher3 *db,            /* Associated database handle */
51163   Btree **ppBtree,        /* Pointer to new Btree object written here */
51164   int flags,              /* Options */
51165   int vfsFlags            /* Flags passed through to sqlcipher3_vfs.xOpen() */
51166 ){
51167   BtShared *pBt = 0;             /* Shared part of btree structure */
51168   Btree *p;                      /* Handle to return */
51169   sqlcipher3_mutex *mutexOpen = 0;  /* Prevents a race condition. Ticket #3537 */
51170   int rc = SQLCIPHER_OK;            /* Result code from this function */
51171   u8 nReserve;                   /* Byte of unused space on each page */
51172   unsigned char zDbHeader[100];  /* Database header content */
51173
51174   /* True if opening an ephemeral, temporary database */
51175   const int isTempDb = zFilename==0 || zFilename[0]==0;
51176
51177   /* Set the variable isMemdb to true for an in-memory database, or 
51178   ** false for a file-based database.
51179   */
51180 #ifdef SQLCIPHER_OMIT_MEMORYDB
51181   const int isMemdb = 0;
51182 #else
51183   const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0)
51184                        || (isTempDb && sqlcipher3TempInMemory(db));
51185 #endif
51186
51187   assert( db!=0 );
51188   assert( pVfs!=0 );
51189   assert( sqlcipher3_mutex_held(db->mutex) );
51190   assert( (flags&0xff)==flags );   /* flags fit in 8 bits */
51191
51192   /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */
51193   assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
51194
51195   /* A BTREE_SINGLE database is always a temporary and/or ephemeral */
51196   assert( (flags & BTREE_SINGLE)==0 || isTempDb );
51197
51198   if( db->flags & SQLCIPHER_NoReadlock ){
51199     flags |= BTREE_NO_READLOCK;
51200   }
51201   if( isMemdb ){
51202     flags |= BTREE_MEMORY;
51203   }
51204   if( (vfsFlags & SQLCIPHER_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){
51205     vfsFlags = (vfsFlags & ~SQLCIPHER_OPEN_MAIN_DB) | SQLCIPHER_OPEN_TEMP_DB;
51206   }
51207   p = sqlcipher3MallocZero(sizeof(Btree));
51208   if( !p ){
51209     return SQLCIPHER_NOMEM;
51210   }
51211   p->inTrans = TRANS_NONE;
51212   p->db = db;
51213 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
51214   p->lock.pBtree = p;
51215   p->lock.iTable = 1;
51216 #endif
51217
51218 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && !defined(SQLCIPHER_OMIT_DISKIO)
51219   /*
51220   ** If this Btree is a candidate for shared cache, try to find an
51221   ** existing BtShared object that we can share with
51222   */
51223   if( isMemdb==0 && isTempDb==0 ){
51224     if( vfsFlags & SQLCIPHER_OPEN_SHAREDCACHE ){
51225       int nFullPathname = pVfs->mxPathname+1;
51226       char *zFullPathname = sqlcipher3Malloc(nFullPathname);
51227       MUTEX_LOGIC( sqlcipher3_mutex *mutexShared; )
51228       p->sharable = 1;
51229       if( !zFullPathname ){
51230         sqlcipher3_free(p);
51231         return SQLCIPHER_NOMEM;
51232       }
51233       sqlcipher3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname);
51234 #if SQLCIPHER_THREADSAFE
51235       mutexOpen = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_OPEN);
51236       sqlcipher3_mutex_enter(mutexOpen);
51237       mutexShared = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
51238       sqlcipher3_mutex_enter(mutexShared);
51239 #endif
51240       for(pBt=GLOBAL(BtShared*,sqlcipher3SharedCacheList); pBt; pBt=pBt->pNext){
51241         assert( pBt->nRef>0 );
51242         if( 0==strcmp(zFullPathname, sqlcipher3PagerFilename(pBt->pPager))
51243                  && sqlcipher3PagerVfs(pBt->pPager)==pVfs ){
51244           int iDb;
51245           for(iDb=db->nDb-1; iDb>=0; iDb--){
51246             Btree *pExisting = db->aDb[iDb].pBt;
51247             if( pExisting && pExisting->pBt==pBt ){
51248               sqlcipher3_mutex_leave(mutexShared);
51249               sqlcipher3_mutex_leave(mutexOpen);
51250               sqlcipher3_free(zFullPathname);
51251               sqlcipher3_free(p);
51252               return SQLCIPHER_CONSTRAINT;
51253             }
51254           }
51255           p->pBt = pBt;
51256           pBt->nRef++;
51257           break;
51258         }
51259       }
51260       sqlcipher3_mutex_leave(mutexShared);
51261       sqlcipher3_free(zFullPathname);
51262     }
51263 #ifdef SQLCIPHER_DEBUG
51264     else{
51265       /* In debug mode, we mark all persistent databases as sharable
51266       ** even when they are not.  This exercises the locking code and
51267       ** gives more opportunity for asserts(sqlcipher3_mutex_held())
51268       ** statements to find locking problems.
51269       */
51270       p->sharable = 1;
51271     }
51272 #endif
51273   }
51274 #endif
51275   if( pBt==0 ){
51276     /*
51277     ** The following asserts make sure that structures used by the btree are
51278     ** the right size.  This is to guard against size changes that result
51279     ** when compiling on a different architecture.
51280     */
51281     assert( sizeof(i64)==8 || sizeof(i64)==4 );
51282     assert( sizeof(u64)==8 || sizeof(u64)==4 );
51283     assert( sizeof(u32)==4 );
51284     assert( sizeof(u16)==2 );
51285     assert( sizeof(Pgno)==4 );
51286   
51287     pBt = sqlcipher3MallocZero( sizeof(*pBt) );
51288     if( pBt==0 ){
51289       rc = SQLCIPHER_NOMEM;
51290       goto btree_open_out;
51291     }
51292     rc = sqlcipher3PagerOpen(pVfs, &pBt->pPager, zFilename,
51293                           EXTRA_SIZE, flags, vfsFlags, pageReinit);
51294     if( rc==SQLCIPHER_OK ){
51295       rc = sqlcipher3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
51296     }
51297     if( rc!=SQLCIPHER_OK ){
51298       goto btree_open_out;
51299     }
51300     pBt->openFlags = (u8)flags;
51301     pBt->db = db;
51302     sqlcipher3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
51303     p->pBt = pBt;
51304   
51305     pBt->pCursor = 0;
51306     pBt->pPage1 = 0;
51307     pBt->readOnly = sqlcipher3PagerIsreadonly(pBt->pPager);
51308 #ifdef SQLCIPHER_SECURE_DELETE
51309     pBt->secureDelete = 1;
51310 #endif
51311     pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
51312     if( pBt->pageSize<512 || pBt->pageSize>SQLCIPHER_MAX_PAGE_SIZE
51313          || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
51314       pBt->pageSize = 0;
51315 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
51316       /* If the magic name ":memory:" will create an in-memory database, then
51317       ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
51318       ** SQLCIPHER_DEFAULT_AUTOVACUUM is true. On the other hand, if
51319       ** SQLCIPHER_OMIT_MEMORYDB has been defined, then ":memory:" is just a
51320       ** regular file-name. In this case the auto-vacuum applies as per normal.
51321       */
51322       if( zFilename && !isMemdb ){
51323         pBt->autoVacuum = (SQLCIPHER_DEFAULT_AUTOVACUUM ? 1 : 0);
51324         pBt->incrVacuum = (SQLCIPHER_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
51325       }
51326 #endif
51327       nReserve = 0;
51328     }else{
51329       nReserve = zDbHeader[20];
51330       pBt->pageSizeFixed = 1;
51331 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
51332       pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
51333       pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
51334 #endif
51335     }
51336     rc = sqlcipher3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
51337     if( rc ) goto btree_open_out;
51338     pBt->usableSize = pBt->pageSize - nReserve;
51339     assert( (pBt->pageSize & 7)==0 );  /* 8-byte alignment of pageSize */
51340    
51341 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && !defined(SQLCIPHER_OMIT_DISKIO)
51342     /* Add the new BtShared object to the linked list sharable BtShareds.
51343     */
51344     if( p->sharable ){
51345       MUTEX_LOGIC( sqlcipher3_mutex *mutexShared; )
51346       pBt->nRef = 1;
51347       MUTEX_LOGIC( mutexShared = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);)
51348       if( SQLCIPHER_THREADSAFE && sqlcipher3GlobalConfig.bCoreMutex ){
51349         pBt->mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_FAST);
51350         if( pBt->mutex==0 ){
51351           rc = SQLCIPHER_NOMEM;
51352           db->mallocFailed = 0;
51353           goto btree_open_out;
51354         }
51355       }
51356       sqlcipher3_mutex_enter(mutexShared);
51357       pBt->pNext = GLOBAL(BtShared*,sqlcipher3SharedCacheList);
51358       GLOBAL(BtShared*,sqlcipher3SharedCacheList) = pBt;
51359       sqlcipher3_mutex_leave(mutexShared);
51360     }
51361 #endif
51362   }
51363
51364 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && !defined(SQLCIPHER_OMIT_DISKIO)
51365   /* If the new Btree uses a sharable pBtShared, then link the new
51366   ** Btree into the list of all sharable Btrees for the same connection.
51367   ** The list is kept in ascending order by pBt address.
51368   */
51369   if( p->sharable ){
51370     int i;
51371     Btree *pSib;
51372     for(i=0; i<db->nDb; i++){
51373       if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
51374         while( pSib->pPrev ){ pSib = pSib->pPrev; }
51375         if( p->pBt<pSib->pBt ){
51376           p->pNext = pSib;
51377           p->pPrev = 0;
51378           pSib->pPrev = p;
51379         }else{
51380           while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
51381             pSib = pSib->pNext;
51382           }
51383           p->pNext = pSib->pNext;
51384           p->pPrev = pSib;
51385           if( p->pNext ){
51386             p->pNext->pPrev = p;
51387           }
51388           pSib->pNext = p;
51389         }
51390         break;
51391       }
51392     }
51393   }
51394 #endif
51395   *ppBtree = p;
51396
51397 btree_open_out:
51398   if( rc!=SQLCIPHER_OK ){
51399     if( pBt && pBt->pPager ){
51400       sqlcipher3PagerClose(pBt->pPager);
51401     }
51402     sqlcipher3_free(pBt);
51403     sqlcipher3_free(p);
51404     *ppBtree = 0;
51405   }else{
51406     /* If the B-Tree was successfully opened, set the pager-cache size to the
51407     ** default value. Except, when opening on an existing shared pager-cache,
51408     ** do not change the pager-cache size.
51409     */
51410     if( sqlcipher3BtreeSchema(p, 0, 0)==0 ){
51411       sqlcipher3PagerSetCachesize(p->pBt->pPager, SQLCIPHER_DEFAULT_CACHE_SIZE);
51412     }
51413   }
51414   if( mutexOpen ){
51415     assert( sqlcipher3_mutex_held(mutexOpen) );
51416     sqlcipher3_mutex_leave(mutexOpen);
51417   }
51418   return rc;
51419 }
51420
51421 /*
51422 ** Decrement the BtShared.nRef counter.  When it reaches zero,
51423 ** remove the BtShared structure from the sharing list.  Return
51424 ** true if the BtShared.nRef counter reaches zero and return
51425 ** false if it is still positive.
51426 */
51427 static int removeFromSharingList(BtShared *pBt){
51428 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
51429   MUTEX_LOGIC( sqlcipher3_mutex *pMaster; )
51430   BtShared *pList;
51431   int removed = 0;
51432
51433   assert( sqlcipher3_mutex_notheld(pBt->mutex) );
51434   MUTEX_LOGIC( pMaster = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER); )
51435   sqlcipher3_mutex_enter(pMaster);
51436   pBt->nRef--;
51437   if( pBt->nRef<=0 ){
51438     if( GLOBAL(BtShared*,sqlcipher3SharedCacheList)==pBt ){
51439       GLOBAL(BtShared*,sqlcipher3SharedCacheList) = pBt->pNext;
51440     }else{
51441       pList = GLOBAL(BtShared*,sqlcipher3SharedCacheList);
51442       while( ALWAYS(pList) && pList->pNext!=pBt ){
51443         pList=pList->pNext;
51444       }
51445       if( ALWAYS(pList) ){
51446         pList->pNext = pBt->pNext;
51447       }
51448     }
51449     if( SQLCIPHER_THREADSAFE ){
51450       sqlcipher3_mutex_free(pBt->mutex);
51451     }
51452     removed = 1;
51453   }
51454   sqlcipher3_mutex_leave(pMaster);
51455   return removed;
51456 #else
51457   return 1;
51458 #endif
51459 }
51460
51461 /*
51462 ** Make sure pBt->pTmpSpace points to an allocation of 
51463 ** MX_CELL_SIZE(pBt) bytes.
51464 */
51465 static void allocateTempSpace(BtShared *pBt){
51466   if( !pBt->pTmpSpace ){
51467     pBt->pTmpSpace = sqlcipher3PageMalloc( pBt->pageSize );
51468   }
51469 }
51470
51471 /*
51472 ** Free the pBt->pTmpSpace allocation
51473 */
51474 static void freeTempSpace(BtShared *pBt){
51475   sqlcipher3PageFree( pBt->pTmpSpace);
51476   pBt->pTmpSpace = 0;
51477 }
51478
51479 /*
51480 ** Close an open database and invalidate all cursors.
51481 */
51482 SQLCIPHER_PRIVATE int sqlcipher3BtreeClose(Btree *p){
51483   BtShared *pBt = p->pBt;
51484   BtCursor *pCur;
51485
51486   /* Close all cursors opened via this handle.  */
51487   assert( sqlcipher3_mutex_held(p->db->mutex) );
51488   sqlcipher3BtreeEnter(p);
51489   pCur = pBt->pCursor;
51490   while( pCur ){
51491     BtCursor *pTmp = pCur;
51492     pCur = pCur->pNext;
51493     if( pTmp->pBtree==p ){
51494       sqlcipher3BtreeCloseCursor(pTmp);
51495     }
51496   }
51497
51498   /* Rollback any active transaction and free the handle structure.
51499   ** The call to sqlcipher3BtreeRollback() drops any table-locks held by
51500   ** this handle.
51501   */
51502   sqlcipher3BtreeRollback(p);
51503   sqlcipher3BtreeLeave(p);
51504
51505   /* If there are still other outstanding references to the shared-btree
51506   ** structure, return now. The remainder of this procedure cleans 
51507   ** up the shared-btree.
51508   */
51509   assert( p->wantToLock==0 && p->locked==0 );
51510   if( !p->sharable || removeFromSharingList(pBt) ){
51511     /* The pBt is no longer on the sharing list, so we can access
51512     ** it without having to hold the mutex.
51513     **
51514     ** Clean out and delete the BtShared object.
51515     */
51516     assert( !pBt->pCursor );
51517     sqlcipher3PagerClose(pBt->pPager);
51518     if( pBt->xFreeSchema && pBt->pSchema ){
51519       pBt->xFreeSchema(pBt->pSchema);
51520     }
51521     sqlcipher3DbFree(0, pBt->pSchema);
51522     freeTempSpace(pBt);
51523     sqlcipher3_free(pBt);
51524   }
51525
51526 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
51527   assert( p->wantToLock==0 );
51528   assert( p->locked==0 );
51529   if( p->pPrev ) p->pPrev->pNext = p->pNext;
51530   if( p->pNext ) p->pNext->pPrev = p->pPrev;
51531 #endif
51532
51533   sqlcipher3_free(p);
51534   return SQLCIPHER_OK;
51535 }
51536
51537 /*
51538 ** Change the limit on the number of pages allowed in the cache.
51539 **
51540 ** The maximum number of cache pages is set to the absolute
51541 ** value of mxPage.  If mxPage is negative, the pager will
51542 ** operate asynchronously - it will not stop to do fsync()s
51543 ** to insure data is written to the disk surface before
51544 ** continuing.  Transactions still work if synchronous is off,
51545 ** and the database cannot be corrupted if this program
51546 ** crashes.  But if the operating system crashes or there is
51547 ** an abrupt power failure when synchronous is off, the database
51548 ** could be left in an inconsistent and unrecoverable state.
51549 ** Synchronous is on by default so database corruption is not
51550 ** normally a worry.
51551 */
51552 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetCacheSize(Btree *p, int mxPage){
51553   BtShared *pBt = p->pBt;
51554   assert( sqlcipher3_mutex_held(p->db->mutex) );
51555   sqlcipher3BtreeEnter(p);
51556   sqlcipher3PagerSetCachesize(pBt->pPager, mxPage);
51557   sqlcipher3BtreeLeave(p);
51558   return SQLCIPHER_OK;
51559 }
51560
51561 /*
51562 ** Change the way data is synced to disk in order to increase or decrease
51563 ** how well the database resists damage due to OS crashes and power
51564 ** failures.  Level 1 is the same as asynchronous (no syncs() occur and
51565 ** there is a high probability of damage)  Level 2 is the default.  There
51566 ** is a very low but non-zero probability of damage.  Level 3 reduces the
51567 ** probability of damage to near zero but with a write performance reduction.
51568 */
51569 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
51570 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetSafetyLevel(
51571   Btree *p,              /* The btree to set the safety level on */
51572   int level,             /* PRAGMA synchronous.  1=OFF, 2=NORMAL, 3=FULL */
51573   int fullSync,          /* PRAGMA fullfsync. */
51574   int ckptFullSync       /* PRAGMA checkpoint_fullfync */
51575 ){
51576   BtShared *pBt = p->pBt;
51577   assert( sqlcipher3_mutex_held(p->db->mutex) );
51578   assert( level>=1 && level<=3 );
51579   sqlcipher3BtreeEnter(p);
51580   sqlcipher3PagerSetSafetyLevel(pBt->pPager, level, fullSync, ckptFullSync);
51581   sqlcipher3BtreeLeave(p);
51582   return SQLCIPHER_OK;
51583 }
51584 #endif
51585
51586 /*
51587 ** Return TRUE if the given btree is set to safety level 1.  In other
51588 ** words, return TRUE if no sync() occurs on the disk files.
51589 */
51590 SQLCIPHER_PRIVATE int sqlcipher3BtreeSyncDisabled(Btree *p){
51591   BtShared *pBt = p->pBt;
51592   int rc;
51593   assert( sqlcipher3_mutex_held(p->db->mutex) );  
51594   sqlcipher3BtreeEnter(p);
51595   assert( pBt && pBt->pPager );
51596   rc = sqlcipher3PagerNosync(pBt->pPager);
51597   sqlcipher3BtreeLeave(p);
51598   return rc;
51599 }
51600
51601 /*
51602 ** Change the default pages size and the number of reserved bytes per page.
51603 ** Or, if the page size has already been fixed, return SQLCIPHER_READONLY 
51604 ** without changing anything.
51605 **
51606 ** The page size must be a power of 2 between 512 and 65536.  If the page
51607 ** size supplied does not meet this constraint then the page size is not
51608 ** changed.
51609 **
51610 ** Page sizes are constrained to be a power of two so that the region
51611 ** of the database file used for locking (beginning at PENDING_BYTE,
51612 ** the first byte past the 1GB boundary, 0x40000000) needs to occur
51613 ** at the beginning of a page.
51614 **
51615 ** If parameter nReserve is less than zero, then the number of reserved
51616 ** bytes per page is left unchanged.
51617 **
51618 ** If the iFix!=0 then the pageSizeFixed flag is set so that the page size
51619 ** and autovacuum mode can no longer be changed.
51620 */
51621 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
51622   int rc = SQLCIPHER_OK;
51623   BtShared *pBt = p->pBt;
51624   assert( nReserve>=-1 && nReserve<=255 );
51625   sqlcipher3BtreeEnter(p);
51626   if( pBt->pageSizeFixed ){
51627     sqlcipher3BtreeLeave(p);
51628     return SQLCIPHER_READONLY;
51629   }
51630   if( nReserve<0 ){
51631     nReserve = pBt->pageSize - pBt->usableSize;
51632   }
51633   assert( nReserve>=0 && nReserve<=255 );
51634   if( pageSize>=512 && pageSize<=SQLCIPHER_MAX_PAGE_SIZE &&
51635         ((pageSize-1)&pageSize)==0 ){
51636     assert( (pageSize & 7)==0 );
51637     assert( !pBt->pPage1 && !pBt->pCursor );
51638     pBt->pageSize = (u32)pageSize;
51639     freeTempSpace(pBt);
51640   }
51641   rc = sqlcipher3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
51642   pBt->usableSize = pBt->pageSize - (u16)nReserve;
51643   if( iFix ) pBt->pageSizeFixed = 1;
51644   sqlcipher3BtreeLeave(p);
51645   return rc;
51646 }
51647
51648 /*
51649 ** Return the currently defined page size
51650 */
51651 SQLCIPHER_PRIVATE int sqlcipher3BtreeGetPageSize(Btree *p){
51652   return p->pBt->pageSize;
51653 }
51654
51655 #if !defined(SQLCIPHER_OMIT_PAGER_PRAGMAS) || !defined(SQLCIPHER_OMIT_VACUUM)
51656 /*
51657 ** Return the number of bytes of space at the end of every page that
51658 ** are intentually left unused.  This is the "reserved" space that is
51659 ** sometimes used by extensions.
51660 */
51661 SQLCIPHER_PRIVATE int sqlcipher3BtreeGetReserve(Btree *p){
51662   int n;
51663   sqlcipher3BtreeEnter(p);
51664   n = p->pBt->pageSize - p->pBt->usableSize;
51665   sqlcipher3BtreeLeave(p);
51666   return n;
51667 }
51668
51669 /*
51670 ** Set the maximum page count for a database if mxPage is positive.
51671 ** No changes are made if mxPage is 0 or negative.
51672 ** Regardless of the value of mxPage, return the maximum page count.
51673 */
51674 SQLCIPHER_PRIVATE int sqlcipher3BtreeMaxPageCount(Btree *p, int mxPage){
51675   int n;
51676   sqlcipher3BtreeEnter(p);
51677   n = sqlcipher3PagerMaxPageCount(p->pBt->pPager, mxPage);
51678   sqlcipher3BtreeLeave(p);
51679   return n;
51680 }
51681
51682 /*
51683 ** Set the secureDelete flag if newFlag is 0 or 1.  If newFlag is -1,
51684 ** then make no changes.  Always return the value of the secureDelete
51685 ** setting after the change.
51686 */
51687 SQLCIPHER_PRIVATE int sqlcipher3BtreeSecureDelete(Btree *p, int newFlag){
51688   int b;
51689   if( p==0 ) return 0;
51690   sqlcipher3BtreeEnter(p);
51691   if( newFlag>=0 ){
51692     p->pBt->secureDelete = (newFlag!=0) ? 1 : 0;
51693   } 
51694   b = p->pBt->secureDelete;
51695   sqlcipher3BtreeLeave(p);
51696   return b;
51697 }
51698 #endif /* !defined(SQLCIPHER_OMIT_PAGER_PRAGMAS) || !defined(SQLCIPHER_OMIT_VACUUM) */
51699
51700 /*
51701 ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
51702 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
51703 ** is disabled. The default value for the auto-vacuum property is 
51704 ** determined by the SQLCIPHER_DEFAULT_AUTOVACUUM macro.
51705 */
51706 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
51707 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
51708   return SQLCIPHER_READONLY;
51709 #else
51710   BtShared *pBt = p->pBt;
51711   int rc = SQLCIPHER_OK;
51712   u8 av = (u8)autoVacuum;
51713
51714   sqlcipher3BtreeEnter(p);
51715   if( pBt->pageSizeFixed && (av ?1:0)!=pBt->autoVacuum ){
51716     rc = SQLCIPHER_READONLY;
51717   }else{
51718     pBt->autoVacuum = av ?1:0;
51719     pBt->incrVacuum = av==2 ?1:0;
51720   }
51721   sqlcipher3BtreeLeave(p);
51722   return rc;
51723 #endif
51724 }
51725
51726 /*
51727 ** Return the value of the 'auto-vacuum' property. If auto-vacuum is 
51728 ** enabled 1 is returned. Otherwise 0.
51729 */
51730 SQLCIPHER_PRIVATE int sqlcipher3BtreeGetAutoVacuum(Btree *p){
51731 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
51732   return BTREE_AUTOVACUUM_NONE;
51733 #else
51734   int rc;
51735   sqlcipher3BtreeEnter(p);
51736   rc = (
51737     (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
51738     (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
51739     BTREE_AUTOVACUUM_INCR
51740   );
51741   sqlcipher3BtreeLeave(p);
51742   return rc;
51743 #endif
51744 }
51745
51746
51747 /*
51748 ** Get a reference to pPage1 of the database file.  This will
51749 ** also acquire a readlock on that file.
51750 **
51751 ** SQLCIPHER_OK is returned on success.  If the file is not a
51752 ** well-formed database file, then SQLCIPHER_CORRUPT is returned.
51753 ** SQLCIPHER_BUSY is returned if the database is locked.  SQLCIPHER_NOMEM
51754 ** is returned if we run out of memory. 
51755 */
51756 static int lockBtree(BtShared *pBt){
51757   int rc;              /* Result code from subfunctions */
51758   MemPage *pPage1;     /* Page 1 of the database file */
51759   int nPage;           /* Number of pages in the database */
51760   int nPageFile = 0;   /* Number of pages in the database file */
51761   int nPageHeader;     /* Number of pages in the database according to hdr */
51762
51763   assert( sqlcipher3_mutex_held(pBt->mutex) );
51764   assert( pBt->pPage1==0 );
51765   rc = sqlcipher3PagerSharedLock(pBt->pPager);
51766   if( rc!=SQLCIPHER_OK ) return rc;
51767   rc = btreeGetPage(pBt, 1, &pPage1, 0);
51768   if( rc!=SQLCIPHER_OK ) return rc;
51769
51770   /* Do some checking to help insure the file we opened really is
51771   ** a valid database file. 
51772   */
51773   nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
51774   sqlcipher3PagerPagecount(pBt->pPager, &nPageFile);
51775   if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
51776     nPage = nPageFile;
51777   }
51778   if( nPage>0 ){
51779     u32 pageSize;
51780     u32 usableSize;
51781     u8 *page1 = pPage1->aData;
51782     rc = SQLCIPHER_NOTADB;
51783     if( memcmp(page1, zMagicHeader, 16)!=0 ){
51784       goto page1_init_failed;
51785     }
51786
51787 #ifdef SQLCIPHER_OMIT_WAL
51788     if( page1[18]>1 ){
51789       pBt->readOnly = 1;
51790     }
51791     if( page1[19]>1 ){
51792       goto page1_init_failed;
51793     }
51794 #else
51795     if( page1[18]>2 ){
51796       pBt->readOnly = 1;
51797     }
51798     if( page1[19]>2 ){
51799       goto page1_init_failed;
51800     }
51801
51802     /* If the write version is set to 2, this database should be accessed
51803     ** in WAL mode. If the log is not already open, open it now. Then 
51804     ** return SQLCIPHER_OK and return without populating BtShared.pPage1.
51805     ** The caller detects this and calls this function again. This is
51806     ** required as the version of page 1 currently in the page1 buffer
51807     ** may not be the latest version - there may be a newer one in the log
51808     ** file.
51809     */
51810     if( page1[19]==2 && pBt->doNotUseWAL==0 ){
51811       int isOpen = 0;
51812       rc = sqlcipher3PagerOpenWal(pBt->pPager, &isOpen);
51813       if( rc!=SQLCIPHER_OK ){
51814         goto page1_init_failed;
51815       }else if( isOpen==0 ){
51816         releasePage(pPage1);
51817         return SQLCIPHER_OK;
51818       }
51819       rc = SQLCIPHER_NOTADB;
51820     }
51821 #endif
51822
51823     /* The maximum embedded fraction must be exactly 25%.  And the minimum
51824     ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
51825     ** The original design allowed these amounts to vary, but as of
51826     ** version 3.6.0, we require them to be fixed.
51827     */
51828     if( memcmp(&page1[21], "\100\040\040",3)!=0 ){
51829       goto page1_init_failed;
51830     }
51831     pageSize = (page1[16]<<8) | (page1[17]<<16);
51832     if( ((pageSize-1)&pageSize)!=0
51833      || pageSize>SQLCIPHER_MAX_PAGE_SIZE 
51834      || pageSize<=256 
51835     ){
51836       goto page1_init_failed;
51837     }
51838     assert( (pageSize & 7)==0 );
51839     usableSize = pageSize - page1[20];
51840     if( (u32)pageSize!=pBt->pageSize ){
51841       /* After reading the first page of the database assuming a page size
51842       ** of BtShared.pageSize, we have discovered that the page-size is
51843       ** actually pageSize. Unlock the database, leave pBt->pPage1 at
51844       ** zero and return SQLCIPHER_OK. The caller will call this function
51845       ** again with the correct page-size.
51846       */
51847       releasePage(pPage1);
51848       pBt->usableSize = usableSize;
51849       pBt->pageSize = pageSize;
51850       freeTempSpace(pBt);
51851       rc = sqlcipher3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
51852                                    pageSize-usableSize);
51853       return rc;
51854     }
51855     if( (pBt->db->flags & SQLCIPHER_RecoveryMode)==0 && nPage>nPageFile ){
51856       rc = SQLCIPHER_CORRUPT_BKPT;
51857       goto page1_init_failed;
51858     }
51859     if( usableSize<480 ){
51860       goto page1_init_failed;
51861     }
51862     pBt->pageSize = pageSize;
51863     pBt->usableSize = usableSize;
51864 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
51865     pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
51866     pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
51867 #endif
51868   }
51869
51870   /* maxLocal is the maximum amount of payload to store locally for
51871   ** a cell.  Make sure it is small enough so that at least minFanout
51872   ** cells can will fit on one page.  We assume a 10-byte page header.
51873   ** Besides the payload, the cell must store:
51874   **     2-byte pointer to the cell
51875   **     4-byte child pointer
51876   **     9-byte nKey value
51877   **     4-byte nData value
51878   **     4-byte overflow page pointer
51879   ** So a cell consists of a 2-byte pointer, a header which is as much as
51880   ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
51881   ** page pointer.
51882   */
51883   pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
51884   pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
51885   pBt->maxLeaf = (u16)(pBt->usableSize - 35);
51886   pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
51887   assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
51888   pBt->pPage1 = pPage1;
51889   pBt->nPage = nPage;
51890   return SQLCIPHER_OK;
51891
51892 page1_init_failed:
51893   releasePage(pPage1);
51894   pBt->pPage1 = 0;
51895   return rc;
51896 }
51897
51898 /*
51899 ** If there are no outstanding cursors and we are not in the middle
51900 ** of a transaction but there is a read lock on the database, then
51901 ** this routine unrefs the first page of the database file which 
51902 ** has the effect of releasing the read lock.
51903 **
51904 ** If there is a transaction in progress, this routine is a no-op.
51905 */
51906 static void unlockBtreeIfUnused(BtShared *pBt){
51907   assert( sqlcipher3_mutex_held(pBt->mutex) );
51908   assert( pBt->pCursor==0 || pBt->inTransaction>TRANS_NONE );
51909   if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
51910     assert( pBt->pPage1->aData );
51911     assert( sqlcipher3PagerRefcount(pBt->pPager)==1 );
51912     assert( pBt->pPage1->aData );
51913     releasePage(pBt->pPage1);
51914     pBt->pPage1 = 0;
51915   }
51916 }
51917
51918 /*
51919 ** If pBt points to an empty file then convert that empty file
51920 ** into a new empty database by initializing the first page of
51921 ** the database.
51922 */
51923 static int newDatabase(BtShared *pBt){
51924   MemPage *pP1;
51925   unsigned char *data;
51926   int rc;
51927
51928   assert( sqlcipher3_mutex_held(pBt->mutex) );
51929   if( pBt->nPage>0 ){
51930     return SQLCIPHER_OK;
51931   }
51932   pP1 = pBt->pPage1;
51933   assert( pP1!=0 );
51934   data = pP1->aData;
51935   rc = sqlcipher3PagerWrite(pP1->pDbPage);
51936   if( rc ) return rc;
51937   memcpy(data, zMagicHeader, sizeof(zMagicHeader));
51938   assert( sizeof(zMagicHeader)==16 );
51939   data[16] = (u8)((pBt->pageSize>>8)&0xff);
51940   data[17] = (u8)((pBt->pageSize>>16)&0xff);
51941   data[18] = 1;
51942   data[19] = 1;
51943   assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
51944   data[20] = (u8)(pBt->pageSize - pBt->usableSize);
51945   data[21] = 64;
51946   data[22] = 32;
51947   data[23] = 32;
51948   memset(&data[24], 0, 100-24);
51949   zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA );
51950   pBt->pageSizeFixed = 1;
51951 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
51952   assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
51953   assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
51954   put4byte(&data[36 + 4*4], pBt->autoVacuum);
51955   put4byte(&data[36 + 7*4], pBt->incrVacuum);
51956 #endif
51957   pBt->nPage = 1;
51958   data[31] = 1;
51959   return SQLCIPHER_OK;
51960 }
51961
51962 /*
51963 ** Attempt to start a new transaction. A write-transaction
51964 ** is started if the second argument is nonzero, otherwise a read-
51965 ** transaction.  If the second argument is 2 or more and exclusive
51966 ** transaction is started, meaning that no other process is allowed
51967 ** to access the database.  A preexisting transaction may not be
51968 ** upgraded to exclusive by calling this routine a second time - the
51969 ** exclusivity flag only works for a new transaction.
51970 **
51971 ** A write-transaction must be started before attempting any 
51972 ** changes to the database.  None of the following routines 
51973 ** will work unless a transaction is started first:
51974 **
51975 **      sqlcipher3BtreeCreateTable()
51976 **      sqlcipher3BtreeCreateIndex()
51977 **      sqlcipher3BtreeClearTable()
51978 **      sqlcipher3BtreeDropTable()
51979 **      sqlcipher3BtreeInsert()
51980 **      sqlcipher3BtreeDelete()
51981 **      sqlcipher3BtreeUpdateMeta()
51982 **
51983 ** If an initial attempt to acquire the lock fails because of lock contention
51984 ** and the database was previously unlocked, then invoke the busy handler
51985 ** if there is one.  But if there was previously a read-lock, do not
51986 ** invoke the busy handler - just return SQLCIPHER_BUSY.  SQLCIPHER_BUSY is 
51987 ** returned when there is already a read-lock in order to avoid a deadlock.
51988 **
51989 ** Suppose there are two processes A and B.  A has a read lock and B has
51990 ** a reserved lock.  B tries to promote to exclusive but is blocked because
51991 ** of A's read lock.  A tries to promote to reserved but is blocked by B.
51992 ** One or the other of the two processes must give way or there can be
51993 ** no progress.  By returning SQLCIPHER_BUSY and not invoking the busy callback
51994 ** when A already has a read lock, we encourage A to give up and let B
51995 ** proceed.
51996 */
51997 SQLCIPHER_PRIVATE int sqlcipher3BtreeBeginTrans(Btree *p, int wrflag){
51998   sqlcipher3 *pBlock = 0;
51999   BtShared *pBt = p->pBt;
52000   int rc = SQLCIPHER_OK;
52001
52002   sqlcipher3BtreeEnter(p);
52003   btreeIntegrity(p);
52004
52005   /* If the btree is already in a write-transaction, or it
52006   ** is already in a read-transaction and a read-transaction
52007   ** is requested, this is a no-op.
52008   */
52009   if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
52010     goto trans_begun;
52011   }
52012
52013   /* Write transactions are not possible on a read-only database */
52014   if( pBt->readOnly && wrflag ){
52015     rc = SQLCIPHER_READONLY;
52016     goto trans_begun;
52017   }
52018
52019 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
52020   /* If another database handle has already opened a write transaction 
52021   ** on this shared-btree structure and a second write transaction is
52022   ** requested, return SQLCIPHER_LOCKED.
52023   */
52024   if( (wrflag && pBt->inTransaction==TRANS_WRITE) || pBt->isPending ){
52025     pBlock = pBt->pWriter->db;
52026   }else if( wrflag>1 ){
52027     BtLock *pIter;
52028     for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
52029       if( pIter->pBtree!=p ){
52030         pBlock = pIter->pBtree->db;
52031         break;
52032       }
52033     }
52034   }
52035   if( pBlock ){
52036     sqlcipher3ConnectionBlocked(p->db, pBlock);
52037     rc = SQLCIPHER_LOCKED_SHAREDCACHE;
52038     goto trans_begun;
52039   }
52040 #endif
52041
52042   /* Any read-only or read-write transaction implies a read-lock on 
52043   ** page 1. So if some other shared-cache client already has a write-lock 
52044   ** on page 1, the transaction cannot be opened. */
52045   rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
52046   if( SQLCIPHER_OK!=rc ) goto trans_begun;
52047
52048   pBt->initiallyEmpty = (u8)(pBt->nPage==0);
52049   do {
52050     /* Call lockBtree() until either pBt->pPage1 is populated or
52051     ** lockBtree() returns something other than SQLCIPHER_OK. lockBtree()
52052     ** may return SQLCIPHER_OK but leave pBt->pPage1 set to 0 if after
52053     ** reading page 1 it discovers that the page-size of the database 
52054     ** file is not pBt->pageSize. In this case lockBtree() will update
52055     ** pBt->pageSize to the page-size of the file on disk.
52056     */
52057     while( pBt->pPage1==0 && SQLCIPHER_OK==(rc = lockBtree(pBt)) );
52058
52059     if( rc==SQLCIPHER_OK && wrflag ){
52060       if( pBt->readOnly ){
52061         rc = SQLCIPHER_READONLY;
52062       }else{
52063         rc = sqlcipher3PagerBegin(pBt->pPager,wrflag>1,sqlcipher3TempInMemory(p->db));
52064         if( rc==SQLCIPHER_OK ){
52065           rc = newDatabase(pBt);
52066         }
52067       }
52068     }
52069   
52070     if( rc!=SQLCIPHER_OK ){
52071       unlockBtreeIfUnused(pBt);
52072     }
52073   }while( (rc&0xFF)==SQLCIPHER_BUSY && pBt->inTransaction==TRANS_NONE &&
52074           btreeInvokeBusyHandler(pBt) );
52075
52076   if( rc==SQLCIPHER_OK ){
52077     if( p->inTrans==TRANS_NONE ){
52078       pBt->nTransaction++;
52079 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
52080       if( p->sharable ){
52081         assert( p->lock.pBtree==p && p->lock.iTable==1 );
52082         p->lock.eLock = READ_LOCK;
52083         p->lock.pNext = pBt->pLock;
52084         pBt->pLock = &p->lock;
52085       }
52086 #endif
52087     }
52088     p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
52089     if( p->inTrans>pBt->inTransaction ){
52090       pBt->inTransaction = p->inTrans;
52091     }
52092     if( wrflag ){
52093       MemPage *pPage1 = pBt->pPage1;
52094 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
52095       assert( !pBt->pWriter );
52096       pBt->pWriter = p;
52097       pBt->isExclusive = (u8)(wrflag>1);
52098 #endif
52099
52100       /* If the db-size header field is incorrect (as it may be if an old
52101       ** client has been writing the database file), update it now. Doing
52102       ** this sooner rather than later means the database size can safely 
52103       ** re-read the database size from page 1 if a savepoint or transaction
52104       ** rollback occurs within the transaction.
52105       */
52106       if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
52107         rc = sqlcipher3PagerWrite(pPage1->pDbPage);
52108         if( rc==SQLCIPHER_OK ){
52109           put4byte(&pPage1->aData[28], pBt->nPage);
52110         }
52111       }
52112     }
52113   }
52114
52115
52116 trans_begun:
52117   if( rc==SQLCIPHER_OK && wrflag ){
52118     /* This call makes sure that the pager has the correct number of
52119     ** open savepoints. If the second parameter is greater than 0 and
52120     ** the sub-journal is not already open, then it will be opened here.
52121     */
52122     rc = sqlcipher3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
52123   }
52124
52125   btreeIntegrity(p);
52126   sqlcipher3BtreeLeave(p);
52127   return rc;
52128 }
52129
52130 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
52131
52132 /*
52133 ** Set the pointer-map entries for all children of page pPage. Also, if
52134 ** pPage contains cells that point to overflow pages, set the pointer
52135 ** map entries for the overflow pages as well.
52136 */
52137 static int setChildPtrmaps(MemPage *pPage){
52138   int i;                             /* Counter variable */
52139   int nCell;                         /* Number of cells in page pPage */
52140   int rc;                            /* Return code */
52141   BtShared *pBt = pPage->pBt;
52142   u8 isInitOrig = pPage->isInit;
52143   Pgno pgno = pPage->pgno;
52144
52145   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
52146   rc = btreeInitPage(pPage);
52147   if( rc!=SQLCIPHER_OK ){
52148     goto set_child_ptrmaps_out;
52149   }
52150   nCell = pPage->nCell;
52151
52152   for(i=0; i<nCell; i++){
52153     u8 *pCell = findCell(pPage, i);
52154
52155     ptrmapPutOvflPtr(pPage, pCell, &rc);
52156
52157     if( !pPage->leaf ){
52158       Pgno childPgno = get4byte(pCell);
52159       ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
52160     }
52161   }
52162
52163   if( !pPage->leaf ){
52164     Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
52165     ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
52166   }
52167
52168 set_child_ptrmaps_out:
52169   pPage->isInit = isInitOrig;
52170   return rc;
52171 }
52172
52173 /*
52174 ** Somewhere on pPage is a pointer to page iFrom.  Modify this pointer so
52175 ** that it points to iTo. Parameter eType describes the type of pointer to
52176 ** be modified, as  follows:
52177 **
52178 ** PTRMAP_BTREE:     pPage is a btree-page. The pointer points at a child 
52179 **                   page of pPage.
52180 **
52181 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
52182 **                   page pointed to by one of the cells on pPage.
52183 **
52184 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
52185 **                   overflow page in the list.
52186 */
52187 static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
52188   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
52189   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
52190   if( eType==PTRMAP_OVERFLOW2 ){
52191     /* The pointer is always the first 4 bytes of the page in this case.  */
52192     if( get4byte(pPage->aData)!=iFrom ){
52193       return SQLCIPHER_CORRUPT_BKPT;
52194     }
52195     put4byte(pPage->aData, iTo);
52196   }else{
52197     u8 isInitOrig = pPage->isInit;
52198     int i;
52199     int nCell;
52200
52201     btreeInitPage(pPage);
52202     nCell = pPage->nCell;
52203
52204     for(i=0; i<nCell; i++){
52205       u8 *pCell = findCell(pPage, i);
52206       if( eType==PTRMAP_OVERFLOW1 ){
52207         CellInfo info;
52208         btreeParseCellPtr(pPage, pCell, &info);
52209         if( info.iOverflow
52210          && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
52211          && iFrom==get4byte(&pCell[info.iOverflow])
52212         ){
52213           put4byte(&pCell[info.iOverflow], iTo);
52214           break;
52215         }
52216       }else{
52217         if( get4byte(pCell)==iFrom ){
52218           put4byte(pCell, iTo);
52219           break;
52220         }
52221       }
52222     }
52223   
52224     if( i==nCell ){
52225       if( eType!=PTRMAP_BTREE || 
52226           get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
52227         return SQLCIPHER_CORRUPT_BKPT;
52228       }
52229       put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
52230     }
52231
52232     pPage->isInit = isInitOrig;
52233   }
52234   return SQLCIPHER_OK;
52235 }
52236
52237
52238 /*
52239 ** Move the open database page pDbPage to location iFreePage in the 
52240 ** database. The pDbPage reference remains valid.
52241 **
52242 ** The isCommit flag indicates that there is no need to remember that
52243 ** the journal needs to be sync()ed before database page pDbPage->pgno 
52244 ** can be written to. The caller has already promised not to write to that
52245 ** page.
52246 */
52247 static int relocatePage(
52248   BtShared *pBt,           /* Btree */
52249   MemPage *pDbPage,        /* Open page to move */
52250   u8 eType,                /* Pointer map 'type' entry for pDbPage */
52251   Pgno iPtrPage,           /* Pointer map 'page-no' entry for pDbPage */
52252   Pgno iFreePage,          /* The location to move pDbPage to */
52253   int isCommit             /* isCommit flag passed to sqlcipher3PagerMovepage */
52254 ){
52255   MemPage *pPtrPage;   /* The page that contains a pointer to pDbPage */
52256   Pgno iDbPage = pDbPage->pgno;
52257   Pager *pPager = pBt->pPager;
52258   int rc;
52259
52260   assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || 
52261       eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
52262   assert( sqlcipher3_mutex_held(pBt->mutex) );
52263   assert( pDbPage->pBt==pBt );
52264
52265   /* Move page iDbPage from its current location to page number iFreePage */
52266   TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", 
52267       iDbPage, iFreePage, iPtrPage, eType));
52268   rc = sqlcipher3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
52269   if( rc!=SQLCIPHER_OK ){
52270     return rc;
52271   }
52272   pDbPage->pgno = iFreePage;
52273
52274   /* If pDbPage was a btree-page, then it may have child pages and/or cells
52275   ** that point to overflow pages. The pointer map entries for all these
52276   ** pages need to be changed.
52277   **
52278   ** If pDbPage is an overflow page, then the first 4 bytes may store a
52279   ** pointer to a subsequent overflow page. If this is the case, then
52280   ** the pointer map needs to be updated for the subsequent overflow page.
52281   */
52282   if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){
52283     rc = setChildPtrmaps(pDbPage);
52284     if( rc!=SQLCIPHER_OK ){
52285       return rc;
52286     }
52287   }else{
52288     Pgno nextOvfl = get4byte(pDbPage->aData);
52289     if( nextOvfl!=0 ){
52290       ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
52291       if( rc!=SQLCIPHER_OK ){
52292         return rc;
52293       }
52294     }
52295   }
52296
52297   /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
52298   ** that it points at iFreePage. Also fix the pointer map entry for
52299   ** iPtrPage.
52300   */
52301   if( eType!=PTRMAP_ROOTPAGE ){
52302     rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
52303     if( rc!=SQLCIPHER_OK ){
52304       return rc;
52305     }
52306     rc = sqlcipher3PagerWrite(pPtrPage->pDbPage);
52307     if( rc!=SQLCIPHER_OK ){
52308       releasePage(pPtrPage);
52309       return rc;
52310     }
52311     rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
52312     releasePage(pPtrPage);
52313     if( rc==SQLCIPHER_OK ){
52314       ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc);
52315     }
52316   }
52317   return rc;
52318 }
52319
52320 /* Forward declaration required by incrVacuumStep(). */
52321 static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
52322
52323 /*
52324 ** Perform a single step of an incremental-vacuum. If successful,
52325 ** return SQLCIPHER_OK. If there is no work to do (and therefore no
52326 ** point in calling this function again), return SQLCIPHER_DONE.
52327 **
52328 ** More specificly, this function attempts to re-organize the 
52329 ** database so that the last page of the file currently in use
52330 ** is no longer in use.
52331 **
52332 ** If the nFin parameter is non-zero, this function assumes
52333 ** that the caller will keep calling incrVacuumStep() until
52334 ** it returns SQLCIPHER_DONE or an error, and that nFin is the
52335 ** number of pages the database file will contain after this 
52336 ** process is complete.  If nFin is zero, it is assumed that
52337 ** incrVacuumStep() will be called a finite amount of times
52338 ** which may or may not empty the freelist.  A full autovacuum
52339 ** has nFin>0.  A "PRAGMA incremental_vacuum" has nFin==0.
52340 */
52341 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){
52342   Pgno nFreeList;           /* Number of pages still on the free-list */
52343   int rc;
52344
52345   assert( sqlcipher3_mutex_held(pBt->mutex) );
52346   assert( iLastPg>nFin );
52347
52348   if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
52349     u8 eType;
52350     Pgno iPtrPage;
52351
52352     nFreeList = get4byte(&pBt->pPage1->aData[36]);
52353     if( nFreeList==0 ){
52354       return SQLCIPHER_DONE;
52355     }
52356
52357     rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
52358     if( rc!=SQLCIPHER_OK ){
52359       return rc;
52360     }
52361     if( eType==PTRMAP_ROOTPAGE ){
52362       return SQLCIPHER_CORRUPT_BKPT;
52363     }
52364
52365     if( eType==PTRMAP_FREEPAGE ){
52366       if( nFin==0 ){
52367         /* Remove the page from the files free-list. This is not required
52368         ** if nFin is non-zero. In that case, the free-list will be
52369         ** truncated to zero after this function returns, so it doesn't 
52370         ** matter if it still contains some garbage entries.
52371         */
52372         Pgno iFreePg;
52373         MemPage *pFreePg;
52374         rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1);
52375         if( rc!=SQLCIPHER_OK ){
52376           return rc;
52377         }
52378         assert( iFreePg==iLastPg );
52379         releasePage(pFreePg);
52380       }
52381     } else {
52382       Pgno iFreePg;             /* Index of free page to move pLastPg to */
52383       MemPage *pLastPg;
52384
52385       rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
52386       if( rc!=SQLCIPHER_OK ){
52387         return rc;
52388       }
52389
52390       /* If nFin is zero, this loop runs exactly once and page pLastPg
52391       ** is swapped with the first free page pulled off the free list.
52392       **
52393       ** On the other hand, if nFin is greater than zero, then keep
52394       ** looping until a free-page located within the first nFin pages
52395       ** of the file is found.
52396       */
52397       do {
52398         MemPage *pFreePg;
52399         rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0);
52400         if( rc!=SQLCIPHER_OK ){
52401           releasePage(pLastPg);
52402           return rc;
52403         }
52404         releasePage(pFreePg);
52405       }while( nFin!=0 && iFreePg>nFin );
52406       assert( iFreePg<iLastPg );
52407       
52408       rc = sqlcipher3PagerWrite(pLastPg->pDbPage);
52409       if( rc==SQLCIPHER_OK ){
52410         rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, nFin!=0);
52411       }
52412       releasePage(pLastPg);
52413       if( rc!=SQLCIPHER_OK ){
52414         return rc;
52415       }
52416     }
52417   }
52418
52419   if( nFin==0 ){
52420     iLastPg--;
52421     while( iLastPg==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, iLastPg) ){
52422       if( PTRMAP_ISPAGE(pBt, iLastPg) ){
52423         MemPage *pPg;
52424         rc = btreeGetPage(pBt, iLastPg, &pPg, 0);
52425         if( rc!=SQLCIPHER_OK ){
52426           return rc;
52427         }
52428         rc = sqlcipher3PagerWrite(pPg->pDbPage);
52429         releasePage(pPg);
52430         if( rc!=SQLCIPHER_OK ){
52431           return rc;
52432         }
52433       }
52434       iLastPg--;
52435     }
52436     sqlcipher3PagerTruncateImage(pBt->pPager, iLastPg);
52437     pBt->nPage = iLastPg;
52438   }
52439   return SQLCIPHER_OK;
52440 }
52441
52442 /*
52443 ** A write-transaction must be opened before calling this function.
52444 ** It performs a single unit of work towards an incremental vacuum.
52445 **
52446 ** If the incremental vacuum is finished after this function has run,
52447 ** SQLCIPHER_DONE is returned. If it is not finished, but no error occurred,
52448 ** SQLCIPHER_OK is returned. Otherwise an SQLite error code. 
52449 */
52450 SQLCIPHER_PRIVATE int sqlcipher3BtreeIncrVacuum(Btree *p){
52451   int rc;
52452   BtShared *pBt = p->pBt;
52453
52454   sqlcipher3BtreeEnter(p);
52455   assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
52456   if( !pBt->autoVacuum ){
52457     rc = SQLCIPHER_DONE;
52458   }else{
52459     invalidateAllOverflowCache(pBt);
52460     rc = incrVacuumStep(pBt, 0, btreePagecount(pBt));
52461     if( rc==SQLCIPHER_OK ){
52462       rc = sqlcipher3PagerWrite(pBt->pPage1->pDbPage);
52463       put4byte(&pBt->pPage1->aData[28], pBt->nPage);
52464     }
52465   }
52466   sqlcipher3BtreeLeave(p);
52467   return rc;
52468 }
52469
52470 /*
52471 ** This routine is called prior to sqlcipher3PagerCommit when a transaction
52472 ** is commited for an auto-vacuum database.
52473 **
52474 ** If SQLCIPHER_OK is returned, then *pnTrunc is set to the number of pages
52475 ** the database file should be truncated to during the commit process. 
52476 ** i.e. the database has been reorganized so that only the first *pnTrunc
52477 ** pages are in use.
52478 */
52479 static int autoVacuumCommit(BtShared *pBt){
52480   int rc = SQLCIPHER_OK;
52481   Pager *pPager = pBt->pPager;
52482   VVA_ONLY( int nRef = sqlcipher3PagerRefcount(pPager) );
52483
52484   assert( sqlcipher3_mutex_held(pBt->mutex) );
52485   invalidateAllOverflowCache(pBt);
52486   assert(pBt->autoVacuum);
52487   if( !pBt->incrVacuum ){
52488     Pgno nFin;         /* Number of pages in database after autovacuuming */
52489     Pgno nFree;        /* Number of pages on the freelist initially */
52490     Pgno nPtrmap;      /* Number of PtrMap pages to be freed */
52491     Pgno iFree;        /* The next page to be freed */
52492     int nEntry;        /* Number of entries on one ptrmap page */
52493     Pgno nOrig;        /* Database size before freeing */
52494
52495     nOrig = btreePagecount(pBt);
52496     if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
52497       /* It is not possible to create a database for which the final page
52498       ** is either a pointer-map page or the pending-byte page. If one
52499       ** is encountered, this indicates corruption.
52500       */
52501       return SQLCIPHER_CORRUPT_BKPT;
52502     }
52503
52504     nFree = get4byte(&pBt->pPage1->aData[36]);
52505     nEntry = pBt->usableSize/5;
52506     nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
52507     nFin = nOrig - nFree - nPtrmap;
52508     if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
52509       nFin--;
52510     }
52511     while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
52512       nFin--;
52513     }
52514     if( nFin>nOrig ) return SQLCIPHER_CORRUPT_BKPT;
52515
52516     for(iFree=nOrig; iFree>nFin && rc==SQLCIPHER_OK; iFree--){
52517       rc = incrVacuumStep(pBt, nFin, iFree);
52518     }
52519     if( (rc==SQLCIPHER_DONE || rc==SQLCIPHER_OK) && nFree>0 ){
52520       rc = sqlcipher3PagerWrite(pBt->pPage1->pDbPage);
52521       put4byte(&pBt->pPage1->aData[32], 0);
52522       put4byte(&pBt->pPage1->aData[36], 0);
52523       put4byte(&pBt->pPage1->aData[28], nFin);
52524       sqlcipher3PagerTruncateImage(pBt->pPager, nFin);
52525       pBt->nPage = nFin;
52526     }
52527     if( rc!=SQLCIPHER_OK ){
52528       sqlcipher3PagerRollback(pPager);
52529     }
52530   }
52531
52532   assert( nRef==sqlcipher3PagerRefcount(pPager) );
52533   return rc;
52534 }
52535
52536 #else /* ifndef SQLCIPHER_OMIT_AUTOVACUUM */
52537 # define setChildPtrmaps(x) SQLCIPHER_OK
52538 #endif
52539
52540 /*
52541 ** This routine does the first phase of a two-phase commit.  This routine
52542 ** causes a rollback journal to be created (if it does not already exist)
52543 ** and populated with enough information so that if a power loss occurs
52544 ** the database can be restored to its original state by playing back
52545 ** the journal.  Then the contents of the journal are flushed out to
52546 ** the disk.  After the journal is safely on oxide, the changes to the
52547 ** database are written into the database file and flushed to oxide.
52548 ** At the end of this call, the rollback journal still exists on the
52549 ** disk and we are still holding all locks, so the transaction has not
52550 ** committed.  See sqlcipher3BtreeCommitPhaseTwo() for the second phase of the
52551 ** commit process.
52552 **
52553 ** This call is a no-op if no write-transaction is currently active on pBt.
52554 **
52555 ** Otherwise, sync the database file for the btree pBt. zMaster points to
52556 ** the name of a master journal file that should be written into the
52557 ** individual journal file, or is NULL, indicating no master journal file 
52558 ** (single database transaction).
52559 **
52560 ** When this is called, the master journal should already have been
52561 ** created, populated with this journal pointer and synced to disk.
52562 **
52563 ** Once this is routine has returned, the only thing required to commit
52564 ** the write-transaction for this database file is to delete the journal.
52565 */
52566 SQLCIPHER_PRIVATE int sqlcipher3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
52567   int rc = SQLCIPHER_OK;
52568   if( p->inTrans==TRANS_WRITE ){
52569     BtShared *pBt = p->pBt;
52570     sqlcipher3BtreeEnter(p);
52571 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
52572     if( pBt->autoVacuum ){
52573       rc = autoVacuumCommit(pBt);
52574       if( rc!=SQLCIPHER_OK ){
52575         sqlcipher3BtreeLeave(p);
52576         return rc;
52577       }
52578     }
52579 #endif
52580     rc = sqlcipher3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
52581     sqlcipher3BtreeLeave(p);
52582   }
52583   return rc;
52584 }
52585
52586 /*
52587 ** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
52588 ** at the conclusion of a transaction.
52589 */
52590 static void btreeEndTransaction(Btree *p){
52591   BtShared *pBt = p->pBt;
52592   assert( sqlcipher3BtreeHoldsMutex(p) );
52593
52594   btreeClearHasContent(pBt);
52595   if( p->inTrans>TRANS_NONE && p->db->activeVdbeCnt>1 ){
52596     /* If there are other active statements that belong to this database
52597     ** handle, downgrade to a read-only transaction. The other statements
52598     ** may still be reading from the database.  */
52599     downgradeAllSharedCacheTableLocks(p);
52600     p->inTrans = TRANS_READ;
52601   }else{
52602     /* If the handle had any kind of transaction open, decrement the 
52603     ** transaction count of the shared btree. If the transaction count 
52604     ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
52605     ** call below will unlock the pager.  */
52606     if( p->inTrans!=TRANS_NONE ){
52607       clearAllSharedCacheTableLocks(p);
52608       pBt->nTransaction--;
52609       if( 0==pBt->nTransaction ){
52610         pBt->inTransaction = TRANS_NONE;
52611       }
52612     }
52613
52614     /* Set the current transaction state to TRANS_NONE and unlock the 
52615     ** pager if this call closed the only read or write transaction.  */
52616     p->inTrans = TRANS_NONE;
52617     unlockBtreeIfUnused(pBt);
52618   }
52619
52620   btreeIntegrity(p);
52621 }
52622
52623 /*
52624 ** Commit the transaction currently in progress.
52625 **
52626 ** This routine implements the second phase of a 2-phase commit.  The
52627 ** sqlcipher3BtreeCommitPhaseOne() routine does the first phase and should
52628 ** be invoked prior to calling this routine.  The sqlcipher3BtreeCommitPhaseOne()
52629 ** routine did all the work of writing information out to disk and flushing the
52630 ** contents so that they are written onto the disk platter.  All this
52631 ** routine has to do is delete or truncate or zero the header in the
52632 ** the rollback journal (which causes the transaction to commit) and
52633 ** drop locks.
52634 **
52635 ** Normally, if an error occurs while the pager layer is attempting to 
52636 ** finalize the underlying journal file, this function returns an error and
52637 ** the upper layer will attempt a rollback. However, if the second argument
52638 ** is non-zero then this b-tree transaction is part of a multi-file 
52639 ** transaction. In this case, the transaction has already been committed 
52640 ** (by deleting a master journal file) and the caller will ignore this 
52641 ** functions return code. So, even if an error occurs in the pager layer,
52642 ** reset the b-tree objects internal state to indicate that the write
52643 ** transaction has been closed. This is quite safe, as the pager will have
52644 ** transitioned to the error state.
52645 **
52646 ** This will release the write lock on the database file.  If there
52647 ** are no active cursors, it also releases the read lock.
52648 */
52649 SQLCIPHER_PRIVATE int sqlcipher3BtreeCommitPhaseTwo(Btree *p, int bCleanup){
52650
52651   if( p->inTrans==TRANS_NONE ) return SQLCIPHER_OK;
52652   sqlcipher3BtreeEnter(p);
52653   btreeIntegrity(p);
52654
52655   /* If the handle has a write-transaction open, commit the shared-btrees 
52656   ** transaction and set the shared state to TRANS_READ.
52657   */
52658   if( p->inTrans==TRANS_WRITE ){
52659     int rc;
52660     BtShared *pBt = p->pBt;
52661     assert( pBt->inTransaction==TRANS_WRITE );
52662     assert( pBt->nTransaction>0 );
52663     rc = sqlcipher3PagerCommitPhaseTwo(pBt->pPager);
52664     if( rc!=SQLCIPHER_OK && bCleanup==0 ){
52665       sqlcipher3BtreeLeave(p);
52666       return rc;
52667     }
52668     pBt->inTransaction = TRANS_READ;
52669   }
52670
52671   btreeEndTransaction(p);
52672   sqlcipher3BtreeLeave(p);
52673   return SQLCIPHER_OK;
52674 }
52675
52676 /*
52677 ** Do both phases of a commit.
52678 */
52679 SQLCIPHER_PRIVATE int sqlcipher3BtreeCommit(Btree *p){
52680   int rc;
52681   sqlcipher3BtreeEnter(p);
52682   rc = sqlcipher3BtreeCommitPhaseOne(p, 0);
52683   if( rc==SQLCIPHER_OK ){
52684     rc = sqlcipher3BtreeCommitPhaseTwo(p, 0);
52685   }
52686   sqlcipher3BtreeLeave(p);
52687   return rc;
52688 }
52689
52690 #ifndef NDEBUG
52691 /*
52692 ** Return the number of write-cursors open on this handle. This is for use
52693 ** in assert() expressions, so it is only compiled if NDEBUG is not
52694 ** defined.
52695 **
52696 ** For the purposes of this routine, a write-cursor is any cursor that
52697 ** is capable of writing to the databse.  That means the cursor was
52698 ** originally opened for writing and the cursor has not be disabled
52699 ** by having its state changed to CURSOR_FAULT.
52700 */
52701 static int countWriteCursors(BtShared *pBt){
52702   BtCursor *pCur;
52703   int r = 0;
52704   for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
52705     if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++; 
52706   }
52707   return r;
52708 }
52709 #endif
52710
52711 /*
52712 ** This routine sets the state to CURSOR_FAULT and the error
52713 ** code to errCode for every cursor on BtShared that pBtree
52714 ** references.
52715 **
52716 ** Every cursor is tripped, including cursors that belong
52717 ** to other database connections that happen to be sharing
52718 ** the cache with pBtree.
52719 **
52720 ** This routine gets called when a rollback occurs.
52721 ** All cursors using the same cache must be tripped
52722 ** to prevent them from trying to use the btree after
52723 ** the rollback.  The rollback may have deleted tables
52724 ** or moved root pages, so it is not sufficient to
52725 ** save the state of the cursor.  The cursor must be
52726 ** invalidated.
52727 */
52728 SQLCIPHER_PRIVATE void sqlcipher3BtreeTripAllCursors(Btree *pBtree, int errCode){
52729   BtCursor *p;
52730   sqlcipher3BtreeEnter(pBtree);
52731   for(p=pBtree->pBt->pCursor; p; p=p->pNext){
52732     int i;
52733     sqlcipher3BtreeClearCursor(p);
52734     p->eState = CURSOR_FAULT;
52735     p->skipNext = errCode;
52736     for(i=0; i<=p->iPage; i++){
52737       releasePage(p->apPage[i]);
52738       p->apPage[i] = 0;
52739     }
52740   }
52741   sqlcipher3BtreeLeave(pBtree);
52742 }
52743
52744 /*
52745 ** Rollback the transaction in progress.  All cursors will be
52746 ** invalided by this operation.  Any attempt to use a cursor
52747 ** that was open at the beginning of this operation will result
52748 ** in an error.
52749 **
52750 ** This will release the write lock on the database file.  If there
52751 ** are no active cursors, it also releases the read lock.
52752 */
52753 SQLCIPHER_PRIVATE int sqlcipher3BtreeRollback(Btree *p){
52754   int rc;
52755   BtShared *pBt = p->pBt;
52756   MemPage *pPage1;
52757
52758   sqlcipher3BtreeEnter(p);
52759   rc = saveAllCursors(pBt, 0, 0);
52760 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
52761   if( rc!=SQLCIPHER_OK ){
52762     /* This is a horrible situation. An IO or malloc() error occurred whilst
52763     ** trying to save cursor positions. If this is an automatic rollback (as
52764     ** the result of a constraint, malloc() failure or IO error) then 
52765     ** the cache may be internally inconsistent (not contain valid trees) so
52766     ** we cannot simply return the error to the caller. Instead, abort 
52767     ** all queries that may be using any of the cursors that failed to save.
52768     */
52769     sqlcipher3BtreeTripAllCursors(p, rc);
52770   }
52771 #endif
52772   btreeIntegrity(p);
52773
52774   if( p->inTrans==TRANS_WRITE ){
52775     int rc2;
52776
52777     assert( TRANS_WRITE==pBt->inTransaction );
52778     rc2 = sqlcipher3PagerRollback(pBt->pPager);
52779     if( rc2!=SQLCIPHER_OK ){
52780       rc = rc2;
52781     }
52782
52783     /* The rollback may have destroyed the pPage1->aData value.  So
52784     ** call btreeGetPage() on page 1 again to make
52785     ** sure pPage1->aData is set correctly. */
52786     if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLCIPHER_OK ){
52787       int nPage = get4byte(28+(u8*)pPage1->aData);
52788       testcase( nPage==0 );
52789       if( nPage==0 ) sqlcipher3PagerPagecount(pBt->pPager, &nPage);
52790       testcase( pBt->nPage!=nPage );
52791       pBt->nPage = nPage;
52792       releasePage(pPage1);
52793     }
52794     assert( countWriteCursors(pBt)==0 );
52795     pBt->inTransaction = TRANS_READ;
52796   }
52797
52798   btreeEndTransaction(p);
52799   sqlcipher3BtreeLeave(p);
52800   return rc;
52801 }
52802
52803 /*
52804 ** Start a statement subtransaction. The subtransaction can can be rolled
52805 ** back independently of the main transaction. You must start a transaction 
52806 ** before starting a subtransaction. The subtransaction is ended automatically 
52807 ** if the main transaction commits or rolls back.
52808 **
52809 ** Statement subtransactions are used around individual SQL statements
52810 ** that are contained within a BEGIN...COMMIT block.  If a constraint
52811 ** error occurs within the statement, the effect of that one statement
52812 ** can be rolled back without having to rollback the entire transaction.
52813 **
52814 ** A statement sub-transaction is implemented as an anonymous savepoint. The
52815 ** value passed as the second parameter is the total number of savepoints,
52816 ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
52817 ** are no active savepoints and no other statement-transactions open,
52818 ** iStatement is 1. This anonymous savepoint can be released or rolled back
52819 ** using the sqlcipher3BtreeSavepoint() function.
52820 */
52821 SQLCIPHER_PRIVATE int sqlcipher3BtreeBeginStmt(Btree *p, int iStatement){
52822   int rc;
52823   BtShared *pBt = p->pBt;
52824   sqlcipher3BtreeEnter(p);
52825   assert( p->inTrans==TRANS_WRITE );
52826   assert( pBt->readOnly==0 );
52827   assert( iStatement>0 );
52828   assert( iStatement>p->db->nSavepoint );
52829   assert( pBt->inTransaction==TRANS_WRITE );
52830   /* At the pager level, a statement transaction is a savepoint with
52831   ** an index greater than all savepoints created explicitly using
52832   ** SQL statements. It is illegal to open, release or rollback any
52833   ** such savepoints while the statement transaction savepoint is active.
52834   */
52835   rc = sqlcipher3PagerOpenSavepoint(pBt->pPager, iStatement);
52836   sqlcipher3BtreeLeave(p);
52837   return rc;
52838 }
52839
52840 /*
52841 ** The second argument to this function, op, is always SAVEPOINT_ROLLBACK
52842 ** or SAVEPOINT_RELEASE. This function either releases or rolls back the
52843 ** savepoint identified by parameter iSavepoint, depending on the value 
52844 ** of op.
52845 **
52846 ** Normally, iSavepoint is greater than or equal to zero. However, if op is
52847 ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the 
52848 ** contents of the entire transaction are rolled back. This is different
52849 ** from a normal transaction rollback, as no locks are released and the
52850 ** transaction remains open.
52851 */
52852 SQLCIPHER_PRIVATE int sqlcipher3BtreeSavepoint(Btree *p, int op, int iSavepoint){
52853   int rc = SQLCIPHER_OK;
52854   if( p && p->inTrans==TRANS_WRITE ){
52855     BtShared *pBt = p->pBt;
52856     assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
52857     assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
52858     sqlcipher3BtreeEnter(p);
52859     rc = sqlcipher3PagerSavepoint(pBt->pPager, op, iSavepoint);
52860     if( rc==SQLCIPHER_OK ){
52861       if( iSavepoint<0 && pBt->initiallyEmpty ) pBt->nPage = 0;
52862       rc = newDatabase(pBt);
52863       pBt->nPage = get4byte(28 + pBt->pPage1->aData);
52864
52865       /* The database size was written into the offset 28 of the header
52866       ** when the transaction started, so we know that the value at offset
52867       ** 28 is nonzero. */
52868       assert( pBt->nPage>0 );
52869     }
52870     sqlcipher3BtreeLeave(p);
52871   }
52872   return rc;
52873 }
52874
52875 /*
52876 ** Create a new cursor for the BTree whose root is on the page
52877 ** iTable. If a read-only cursor is requested, it is assumed that
52878 ** the caller already has at least a read-only transaction open
52879 ** on the database already. If a write-cursor is requested, then
52880 ** the caller is assumed to have an open write transaction.
52881 **
52882 ** If wrFlag==0, then the cursor can only be used for reading.
52883 ** If wrFlag==1, then the cursor can be used for reading or for
52884 ** writing if other conditions for writing are also met.  These
52885 ** are the conditions that must be met in order for writing to
52886 ** be allowed:
52887 **
52888 ** 1:  The cursor must have been opened with wrFlag==1
52889 **
52890 ** 2:  Other database connections that share the same pager cache
52891 **     but which are not in the READ_UNCOMMITTED state may not have
52892 **     cursors open with wrFlag==0 on the same table.  Otherwise
52893 **     the changes made by this write cursor would be visible to
52894 **     the read cursors in the other database connection.
52895 **
52896 ** 3:  The database must be writable (not on read-only media)
52897 **
52898 ** 4:  There must be an active transaction.
52899 **
52900 ** No checking is done to make sure that page iTable really is the
52901 ** root page of a b-tree.  If it is not, then the cursor acquired
52902 ** will not work correctly.
52903 **
52904 ** It is assumed that the sqlcipher3BtreeCursorZero() has been called
52905 ** on pCur to initialize the memory space prior to invoking this routine.
52906 */
52907 static int btreeCursor(
52908   Btree *p,                              /* The btree */
52909   int iTable,                            /* Root page of table to open */
52910   int wrFlag,                            /* 1 to write. 0 read-only */
52911   struct KeyInfo *pKeyInfo,              /* First arg to comparison function */
52912   BtCursor *pCur                         /* Space for new cursor */
52913 ){
52914   BtShared *pBt = p->pBt;                /* Shared b-tree handle */
52915
52916   assert( sqlcipher3BtreeHoldsMutex(p) );
52917   assert( wrFlag==0 || wrFlag==1 );
52918
52919   /* The following assert statements verify that if this is a sharable 
52920   ** b-tree database, the connection is holding the required table locks, 
52921   ** and that no other connection has any open cursor that conflicts with 
52922   ** this lock.  */
52923   assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) );
52924   assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
52925
52926   /* Assert that the caller has opened the required transaction. */
52927   assert( p->inTrans>TRANS_NONE );
52928   assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
52929   assert( pBt->pPage1 && pBt->pPage1->aData );
52930
52931   if( NEVER(wrFlag && pBt->readOnly) ){
52932     return SQLCIPHER_READONLY;
52933   }
52934   if( iTable==1 && btreePagecount(pBt)==0 ){
52935     assert( wrFlag==0 );
52936     iTable = 0;
52937   }
52938
52939   /* Now that no other errors can occur, finish filling in the BtCursor
52940   ** variables and link the cursor into the BtShared list.  */
52941   pCur->pgnoRoot = (Pgno)iTable;
52942   pCur->iPage = -1;
52943   pCur->pKeyInfo = pKeyInfo;
52944   pCur->pBtree = p;
52945   pCur->pBt = pBt;
52946   pCur->wrFlag = (u8)wrFlag;
52947   pCur->pNext = pBt->pCursor;
52948   if( pCur->pNext ){
52949     pCur->pNext->pPrev = pCur;
52950   }
52951   pBt->pCursor = pCur;
52952   pCur->eState = CURSOR_INVALID;
52953   pCur->cachedRowid = 0;
52954   return SQLCIPHER_OK;
52955 }
52956 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursor(
52957   Btree *p,                                   /* The btree */
52958   int iTable,                                 /* Root page of table to open */
52959   int wrFlag,                                 /* 1 to write. 0 read-only */
52960   struct KeyInfo *pKeyInfo,                   /* First arg to xCompare() */
52961   BtCursor *pCur                              /* Write new cursor here */
52962 ){
52963   int rc;
52964   sqlcipher3BtreeEnter(p);
52965   rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
52966   sqlcipher3BtreeLeave(p);
52967   return rc;
52968 }
52969
52970 /*
52971 ** Return the size of a BtCursor object in bytes.
52972 **
52973 ** This interfaces is needed so that users of cursors can preallocate
52974 ** sufficient storage to hold a cursor.  The BtCursor object is opaque
52975 ** to users so they cannot do the sizeof() themselves - they must call
52976 ** this routine.
52977 */
52978 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorSize(void){
52979   return ROUND8(sizeof(BtCursor));
52980 }
52981
52982 /*
52983 ** Initialize memory that will be converted into a BtCursor object.
52984 **
52985 ** The simple approach here would be to memset() the entire object
52986 ** to zero.  But it turns out that the apPage[] and aiIdx[] arrays
52987 ** do not need to be zeroed and they are large, so we can save a lot
52988 ** of run-time by skipping the initialization of those elements.
52989 */
52990 SQLCIPHER_PRIVATE void sqlcipher3BtreeCursorZero(BtCursor *p){
52991   memset(p, 0, offsetof(BtCursor, iPage));
52992 }
52993
52994 /*
52995 ** Set the cached rowid value of every cursor in the same database file
52996 ** as pCur and having the same root page number as pCur.  The value is
52997 ** set to iRowid.
52998 **
52999 ** Only positive rowid values are considered valid for this cache.
53000 ** The cache is initialized to zero, indicating an invalid cache.
53001 ** A btree will work fine with zero or negative rowids.  We just cannot
53002 ** cache zero or negative rowids, which means tables that use zero or
53003 ** negative rowids might run a little slower.  But in practice, zero
53004 ** or negative rowids are very uncommon so this should not be a problem.
53005 */
53006 SQLCIPHER_PRIVATE void sqlcipher3BtreeSetCachedRowid(BtCursor *pCur, sqlcipher3_int64 iRowid){
53007   BtCursor *p;
53008   for(p=pCur->pBt->pCursor; p; p=p->pNext){
53009     if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
53010   }
53011   assert( pCur->cachedRowid==iRowid );
53012 }
53013
53014 /*
53015 ** Return the cached rowid for the given cursor.  A negative or zero
53016 ** return value indicates that the rowid cache is invalid and should be
53017 ** ignored.  If the rowid cache has never before been set, then a
53018 ** zero is returned.
53019 */
53020 SQLCIPHER_PRIVATE sqlcipher3_int64 sqlcipher3BtreeGetCachedRowid(BtCursor *pCur){
53021   return pCur->cachedRowid;
53022 }
53023
53024 /*
53025 ** Close a cursor.  The read lock on the database file is released
53026 ** when the last cursor is closed.
53027 */
53028 SQLCIPHER_PRIVATE int sqlcipher3BtreeCloseCursor(BtCursor *pCur){
53029   Btree *pBtree = pCur->pBtree;
53030   if( pBtree ){
53031     int i;
53032     BtShared *pBt = pCur->pBt;
53033     sqlcipher3BtreeEnter(pBtree);
53034     sqlcipher3BtreeClearCursor(pCur);
53035     if( pCur->pPrev ){
53036       pCur->pPrev->pNext = pCur->pNext;
53037     }else{
53038       pBt->pCursor = pCur->pNext;
53039     }
53040     if( pCur->pNext ){
53041       pCur->pNext->pPrev = pCur->pPrev;
53042     }
53043     for(i=0; i<=pCur->iPage; i++){
53044       releasePage(pCur->apPage[i]);
53045     }
53046     unlockBtreeIfUnused(pBt);
53047     invalidateOverflowCache(pCur);
53048     /* sqlcipher3_free(pCur); */
53049     sqlcipher3BtreeLeave(pBtree);
53050   }
53051   return SQLCIPHER_OK;
53052 }
53053
53054 /*
53055 ** Make sure the BtCursor* given in the argument has a valid
53056 ** BtCursor.info structure.  If it is not already valid, call
53057 ** btreeParseCell() to fill it in.
53058 **
53059 ** BtCursor.info is a cache of the information in the current cell.
53060 ** Using this cache reduces the number of calls to btreeParseCell().
53061 **
53062 ** 2007-06-25:  There is a bug in some versions of MSVC that cause the
53063 ** compiler to crash when getCellInfo() is implemented as a macro.
53064 ** But there is a measureable speed advantage to using the macro on gcc
53065 ** (when less compiler optimizations like -Os or -O0 are used and the
53066 ** compiler is not doing agressive inlining.)  So we use a real function
53067 ** for MSVC and a macro for everything else.  Ticket #2457.
53068 */
53069 #ifndef NDEBUG
53070   static void assertCellInfo(BtCursor *pCur){
53071     CellInfo info;
53072     int iPage = pCur->iPage;
53073     memset(&info, 0, sizeof(info));
53074     btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
53075     assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
53076   }
53077 #else
53078   #define assertCellInfo(x)
53079 #endif
53080 #ifdef _MSC_VER
53081   /* Use a real function in MSVC to work around bugs in that compiler. */
53082   static void getCellInfo(BtCursor *pCur){
53083     if( pCur->info.nSize==0 ){
53084       int iPage = pCur->iPage;
53085       btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
53086       pCur->validNKey = 1;
53087     }else{
53088       assertCellInfo(pCur);
53089     }
53090   }
53091 #else /* if not _MSC_VER */
53092   /* Use a macro in all other compilers so that the function is inlined */
53093 #define getCellInfo(pCur)                                                      \
53094   if( pCur->info.nSize==0 ){                                                   \
53095     int iPage = pCur->iPage;                                                   \
53096     btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
53097     pCur->validNKey = 1;                                                       \
53098   }else{                                                                       \
53099     assertCellInfo(pCur);                                                      \
53100   }
53101 #endif /* _MSC_VER */
53102
53103 #ifndef NDEBUG  /* The next routine used only within assert() statements */
53104 /*
53105 ** Return true if the given BtCursor is valid.  A valid cursor is one
53106 ** that is currently pointing to a row in a (non-empty) table.
53107 ** This is a verification routine is used only within assert() statements.
53108 */
53109 SQLCIPHER_PRIVATE int sqlcipher3BtreeCursorIsValid(BtCursor *pCur){
53110   return pCur && pCur->eState==CURSOR_VALID;
53111 }
53112 #endif /* NDEBUG */
53113
53114 /*
53115 ** Set *pSize to the size of the buffer needed to hold the value of
53116 ** the key for the current entry.  If the cursor is not pointing
53117 ** to a valid entry, *pSize is set to 0. 
53118 **
53119 ** For a table with the INTKEY flag set, this routine returns the key
53120 ** itself, not the number of bytes in the key.
53121 **
53122 ** The caller must position the cursor prior to invoking this routine.
53123 ** 
53124 ** This routine cannot fail.  It always returns SQLCIPHER_OK.  
53125 */
53126 SQLCIPHER_PRIVATE int sqlcipher3BtreeKeySize(BtCursor *pCur, i64 *pSize){
53127   assert( cursorHoldsMutex(pCur) );
53128   assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
53129   if( pCur->eState!=CURSOR_VALID ){
53130     *pSize = 0;
53131   }else{
53132     getCellInfo(pCur);
53133     *pSize = pCur->info.nKey;
53134   }
53135   return SQLCIPHER_OK;
53136 }
53137
53138 /*
53139 ** Set *pSize to the number of bytes of data in the entry the
53140 ** cursor currently points to.
53141 **
53142 ** The caller must guarantee that the cursor is pointing to a non-NULL
53143 ** valid entry.  In other words, the calling procedure must guarantee
53144 ** that the cursor has Cursor.eState==CURSOR_VALID.
53145 **
53146 ** Failure is not possible.  This function always returns SQLCIPHER_OK.
53147 ** It might just as well be a procedure (returning void) but we continue
53148 ** to return an integer result code for historical reasons.
53149 */
53150 SQLCIPHER_PRIVATE int sqlcipher3BtreeDataSize(BtCursor *pCur, u32 *pSize){
53151   assert( cursorHoldsMutex(pCur) );
53152   assert( pCur->eState==CURSOR_VALID );
53153   getCellInfo(pCur);
53154   *pSize = pCur->info.nData;
53155   return SQLCIPHER_OK;
53156 }
53157
53158 /*
53159 ** Given the page number of an overflow page in the database (parameter
53160 ** ovfl), this function finds the page number of the next page in the 
53161 ** linked list of overflow pages. If possible, it uses the auto-vacuum
53162 ** pointer-map data instead of reading the content of page ovfl to do so. 
53163 **
53164 ** If an error occurs an SQLite error code is returned. Otherwise:
53165 **
53166 ** The page number of the next overflow page in the linked list is 
53167 ** written to *pPgnoNext. If page ovfl is the last page in its linked 
53168 ** list, *pPgnoNext is set to zero. 
53169 **
53170 ** If ppPage is not NULL, and a reference to the MemPage object corresponding
53171 ** to page number pOvfl was obtained, then *ppPage is set to point to that
53172 ** reference. It is the responsibility of the caller to call releasePage()
53173 ** on *ppPage to free the reference. In no reference was obtained (because
53174 ** the pointer-map was used to obtain the value for *pPgnoNext), then
53175 ** *ppPage is set to zero.
53176 */
53177 static int getOverflowPage(
53178   BtShared *pBt,               /* The database file */
53179   Pgno ovfl,                   /* Current overflow page number */
53180   MemPage **ppPage,            /* OUT: MemPage handle (may be NULL) */
53181   Pgno *pPgnoNext              /* OUT: Next overflow page number */
53182 ){
53183   Pgno next = 0;
53184   MemPage *pPage = 0;
53185   int rc = SQLCIPHER_OK;
53186
53187   assert( sqlcipher3_mutex_held(pBt->mutex) );
53188   assert(pPgnoNext);
53189
53190 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
53191   /* Try to find the next page in the overflow list using the
53192   ** autovacuum pointer-map pages. Guess that the next page in 
53193   ** the overflow list is page number (ovfl+1). If that guess turns 
53194   ** out to be wrong, fall back to loading the data of page 
53195   ** number ovfl to determine the next page number.
53196   */
53197   if( pBt->autoVacuum ){
53198     Pgno pgno;
53199     Pgno iGuess = ovfl+1;
53200     u8 eType;
53201
53202     while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
53203       iGuess++;
53204     }
53205
53206     if( iGuess<=btreePagecount(pBt) ){
53207       rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
53208       if( rc==SQLCIPHER_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
53209         next = iGuess;
53210         rc = SQLCIPHER_DONE;
53211       }
53212     }
53213   }
53214 #endif
53215
53216   assert( next==0 || rc==SQLCIPHER_DONE );
53217   if( rc==SQLCIPHER_OK ){
53218     rc = btreeGetPage(pBt, ovfl, &pPage, 0);
53219     assert( rc==SQLCIPHER_OK || pPage==0 );
53220     if( rc==SQLCIPHER_OK ){
53221       next = get4byte(pPage->aData);
53222     }
53223   }
53224
53225   *pPgnoNext = next;
53226   if( ppPage ){
53227     *ppPage = pPage;
53228   }else{
53229     releasePage(pPage);
53230   }
53231   return (rc==SQLCIPHER_DONE ? SQLCIPHER_OK : rc);
53232 }
53233
53234 /*
53235 ** Copy data from a buffer to a page, or from a page to a buffer.
53236 **
53237 ** pPayload is a pointer to data stored on database page pDbPage.
53238 ** If argument eOp is false, then nByte bytes of data are copied
53239 ** from pPayload to the buffer pointed at by pBuf. If eOp is true,
53240 ** then sqlcipher3PagerWrite() is called on pDbPage and nByte bytes
53241 ** of data are copied from the buffer pBuf to pPayload.
53242 **
53243 ** SQLCIPHER_OK is returned on success, otherwise an error code.
53244 */
53245 static int copyPayload(
53246   void *pPayload,           /* Pointer to page data */
53247   void *pBuf,               /* Pointer to buffer */
53248   int nByte,                /* Number of bytes to copy */
53249   int eOp,                  /* 0 -> copy from page, 1 -> copy to page */
53250   DbPage *pDbPage           /* Page containing pPayload */
53251 ){
53252   if( eOp ){
53253     /* Copy data from buffer to page (a write operation) */
53254     int rc = sqlcipher3PagerWrite(pDbPage);
53255     if( rc!=SQLCIPHER_OK ){
53256       return rc;
53257     }
53258     memcpy(pPayload, pBuf, nByte);
53259   }else{
53260     /* Copy data from page to buffer (a read operation) */
53261     memcpy(pBuf, pPayload, nByte);
53262   }
53263   return SQLCIPHER_OK;
53264 }
53265
53266 /*
53267 ** This function is used to read or overwrite payload information
53268 ** for the entry that the pCur cursor is pointing to. If the eOp
53269 ** parameter is 0, this is a read operation (data copied into
53270 ** buffer pBuf). If it is non-zero, a write (data copied from
53271 ** buffer pBuf).
53272 **
53273 ** A total of "amt" bytes are read or written beginning at "offset".
53274 ** Data is read to or from the buffer pBuf.
53275 **
53276 ** The content being read or written might appear on the main page
53277 ** or be scattered out on multiple overflow pages.
53278 **
53279 ** If the BtCursor.isIncrblobHandle flag is set, and the current
53280 ** cursor entry uses one or more overflow pages, this function
53281 ** allocates space for and lazily popluates the overflow page-list 
53282 ** cache array (BtCursor.aOverflow). Subsequent calls use this
53283 ** cache to make seeking to the supplied offset more efficient.
53284 **
53285 ** Once an overflow page-list cache has been allocated, it may be
53286 ** invalidated if some other cursor writes to the same table, or if
53287 ** the cursor is moved to a different row. Additionally, in auto-vacuum
53288 ** mode, the following events may invalidate an overflow page-list cache.
53289 **
53290 **   * An incremental vacuum,
53291 **   * A commit in auto_vacuum="full" mode,
53292 **   * Creating a table (may require moving an overflow page).
53293 */
53294 static int accessPayload(
53295   BtCursor *pCur,      /* Cursor pointing to entry to read from */
53296   u32 offset,          /* Begin reading this far into payload */
53297   u32 amt,             /* Read this many bytes */
53298   unsigned char *pBuf, /* Write the bytes into this buffer */ 
53299   int eOp              /* zero to read. non-zero to write. */
53300 ){
53301   unsigned char *aPayload;
53302   int rc = SQLCIPHER_OK;
53303   u32 nKey;
53304   int iIdx = 0;
53305   MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
53306   BtShared *pBt = pCur->pBt;                  /* Btree this cursor belongs to */
53307
53308   assert( pPage );
53309   assert( pCur->eState==CURSOR_VALID );
53310   assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53311   assert( cursorHoldsMutex(pCur) );
53312
53313   getCellInfo(pCur);
53314   aPayload = pCur->info.pCell + pCur->info.nHeader;
53315   nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
53316
53317   if( NEVER(offset+amt > nKey+pCur->info.nData) 
53318    || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
53319   ){
53320     /* Trying to read or write past the end of the data is an error */
53321     return SQLCIPHER_CORRUPT_BKPT;
53322   }
53323
53324   /* Check if data must be read/written to/from the btree page itself. */
53325   if( offset<pCur->info.nLocal ){
53326     int a = amt;
53327     if( a+offset>pCur->info.nLocal ){
53328       a = pCur->info.nLocal - offset;
53329     }
53330     rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
53331     offset = 0;
53332     pBuf += a;
53333     amt -= a;
53334   }else{
53335     offset -= pCur->info.nLocal;
53336   }
53337
53338   if( rc==SQLCIPHER_OK && amt>0 ){
53339     const u32 ovflSize = pBt->usableSize - 4;  /* Bytes content per ovfl page */
53340     Pgno nextPage;
53341
53342     nextPage = get4byte(&aPayload[pCur->info.nLocal]);
53343
53344 #ifndef SQLCIPHER_OMIT_INCRBLOB
53345     /* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[]
53346     ** has not been allocated, allocate it now. The array is sized at
53347     ** one entry for each overflow page in the overflow chain. The
53348     ** page number of the first overflow page is stored in aOverflow[0],
53349     ** etc. A value of 0 in the aOverflow[] array means "not yet known"
53350     ** (the cache is lazily populated).
53351     */
53352     if( pCur->isIncrblobHandle && !pCur->aOverflow ){
53353       int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
53354       pCur->aOverflow = (Pgno *)sqlcipher3MallocZero(sizeof(Pgno)*nOvfl);
53355       /* nOvfl is always positive.  If it were zero, fetchPayload would have
53356       ** been used instead of this routine. */
53357       if( ALWAYS(nOvfl) && !pCur->aOverflow ){
53358         rc = SQLCIPHER_NOMEM;
53359       }
53360     }
53361
53362     /* If the overflow page-list cache has been allocated and the
53363     ** entry for the first required overflow page is valid, skip
53364     ** directly to it.
53365     */
53366     if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
53367       iIdx = (offset/ovflSize);
53368       nextPage = pCur->aOverflow[iIdx];
53369       offset = (offset%ovflSize);
53370     }
53371 #endif
53372
53373     for( ; rc==SQLCIPHER_OK && amt>0 && nextPage; iIdx++){
53374
53375 #ifndef SQLCIPHER_OMIT_INCRBLOB
53376       /* If required, populate the overflow page-list cache. */
53377       if( pCur->aOverflow ){
53378         assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
53379         pCur->aOverflow[iIdx] = nextPage;
53380       }
53381 #endif
53382
53383       if( offset>=ovflSize ){
53384         /* The only reason to read this page is to obtain the page
53385         ** number for the next page in the overflow chain. The page
53386         ** data is not required. So first try to lookup the overflow
53387         ** page-list cache, if any, then fall back to the getOverflowPage()
53388         ** function.
53389         */
53390 #ifndef SQLCIPHER_OMIT_INCRBLOB
53391         if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
53392           nextPage = pCur->aOverflow[iIdx+1];
53393         } else 
53394 #endif
53395           rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
53396         offset -= ovflSize;
53397       }else{
53398         /* Need to read this page properly. It contains some of the
53399         ** range of data that is being read (eOp==0) or written (eOp!=0).
53400         */
53401 #ifdef SQLCIPHER_DIRECT_OVERFLOW_READ
53402         sqlcipher3_file *fd;
53403 #endif
53404         int a = amt;
53405         if( a + offset > ovflSize ){
53406           a = ovflSize - offset;
53407         }
53408
53409 #ifdef SQLCIPHER_DIRECT_OVERFLOW_READ
53410         /* If all the following are true:
53411         **
53412         **   1) this is a read operation, and 
53413         **   2) data is required from the start of this overflow page, and
53414         **   3) the database is file-backed, and
53415         **   4) there is no open write-transaction, and
53416         **   5) the database is not a WAL database,
53417         **
53418         ** then data can be read directly from the database file into the
53419         ** output buffer, bypassing the page-cache altogether. This speeds
53420         ** up loading large records that span many overflow pages.
53421         */
53422         if( eOp==0                                             /* (1) */
53423          && offset==0                                          /* (2) */
53424          && pBt->inTransaction==TRANS_READ                     /* (4) */
53425          && (fd = sqlcipher3PagerFile(pBt->pPager))->pMethods     /* (3) */
53426          && pBt->pPage1->aData[19]==0x01                       /* (5) */
53427         ){
53428           u8 aSave[4];
53429           u8 *aWrite = &pBuf[-4];
53430           memcpy(aSave, aWrite, 4);
53431           rc = sqlcipher3OsRead(fd, aWrite, a+4, pBt->pageSize * (nextPage-1));
53432           nextPage = get4byte(aWrite);
53433           memcpy(aWrite, aSave, 4);
53434         }else
53435 #endif
53436
53437         {
53438           DbPage *pDbPage;
53439           rc = sqlcipher3PagerGet(pBt->pPager, nextPage, &pDbPage);
53440           if( rc==SQLCIPHER_OK ){
53441             aPayload = sqlcipher3PagerGetData(pDbPage);
53442             nextPage = get4byte(aPayload);
53443             rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
53444             sqlcipher3PagerUnref(pDbPage);
53445             offset = 0;
53446           }
53447         }
53448         amt -= a;
53449         pBuf += a;
53450       }
53451     }
53452   }
53453
53454   if( rc==SQLCIPHER_OK && amt>0 ){
53455     return SQLCIPHER_CORRUPT_BKPT;
53456   }
53457   return rc;
53458 }
53459
53460 /*
53461 ** Read part of the key associated with cursor pCur.  Exactly
53462 ** "amt" bytes will be transfered into pBuf[].  The transfer
53463 ** begins at "offset".
53464 **
53465 ** The caller must ensure that pCur is pointing to a valid row
53466 ** in the table.
53467 **
53468 ** Return SQLCIPHER_OK on success or an error code if anything goes
53469 ** wrong.  An error is returned if "offset+amt" is larger than
53470 ** the available payload.
53471 */
53472 SQLCIPHER_PRIVATE int sqlcipher3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
53473   assert( cursorHoldsMutex(pCur) );
53474   assert( pCur->eState==CURSOR_VALID );
53475   assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
53476   assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53477   return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
53478 }
53479
53480 /*
53481 ** Read part of the data associated with cursor pCur.  Exactly
53482 ** "amt" bytes will be transfered into pBuf[].  The transfer
53483 ** begins at "offset".
53484 **
53485 ** Return SQLCIPHER_OK on success or an error code if anything goes
53486 ** wrong.  An error is returned if "offset+amt" is larger than
53487 ** the available payload.
53488 */
53489 SQLCIPHER_PRIVATE int sqlcipher3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
53490   int rc;
53491
53492 #ifndef SQLCIPHER_OMIT_INCRBLOB
53493   if ( pCur->eState==CURSOR_INVALID ){
53494     return SQLCIPHER_ABORT;
53495   }
53496 #endif
53497
53498   assert( cursorHoldsMutex(pCur) );
53499   rc = restoreCursorPosition(pCur);
53500   if( rc==SQLCIPHER_OK ){
53501     assert( pCur->eState==CURSOR_VALID );
53502     assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
53503     assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53504     rc = accessPayload(pCur, offset, amt, pBuf, 0);
53505   }
53506   return rc;
53507 }
53508
53509 /*
53510 ** Return a pointer to payload information from the entry that the 
53511 ** pCur cursor is pointing to.  The pointer is to the beginning of
53512 ** the key if skipKey==0 and it points to the beginning of data if
53513 ** skipKey==1.  The number of bytes of available key/data is written
53514 ** into *pAmt.  If *pAmt==0, then the value returned will not be
53515 ** a valid pointer.
53516 **
53517 ** This routine is an optimization.  It is common for the entire key
53518 ** and data to fit on the local page and for there to be no overflow
53519 ** pages.  When that is so, this routine can be used to access the
53520 ** key and data without making a copy.  If the key and/or data spills
53521 ** onto overflow pages, then accessPayload() must be used to reassemble
53522 ** the key/data and copy it into a preallocated buffer.
53523 **
53524 ** The pointer returned by this routine looks directly into the cached
53525 ** page of the database.  The data might change or move the next time
53526 ** any btree routine is called.
53527 */
53528 static const unsigned char *fetchPayload(
53529   BtCursor *pCur,      /* Cursor pointing to entry to read from */
53530   int *pAmt,           /* Write the number of available bytes here */
53531   int skipKey          /* read beginning at data if this is true */
53532 ){
53533   unsigned char *aPayload;
53534   MemPage *pPage;
53535   u32 nKey;
53536   u32 nLocal;
53537
53538   assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
53539   assert( pCur->eState==CURSOR_VALID );
53540   assert( cursorHoldsMutex(pCur) );
53541   pPage = pCur->apPage[pCur->iPage];
53542   assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53543   if( NEVER(pCur->info.nSize==0) ){
53544     btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
53545                    &pCur->info);
53546   }
53547   aPayload = pCur->info.pCell;
53548   aPayload += pCur->info.nHeader;
53549   if( pPage->intKey ){
53550     nKey = 0;
53551   }else{
53552     nKey = (int)pCur->info.nKey;
53553   }
53554   if( skipKey ){
53555     aPayload += nKey;
53556     nLocal = pCur->info.nLocal - nKey;
53557   }else{
53558     nLocal = pCur->info.nLocal;
53559     assert( nLocal<=nKey );
53560   }
53561   *pAmt = nLocal;
53562   return aPayload;
53563 }
53564
53565
53566 /*
53567 ** For the entry that cursor pCur is point to, return as
53568 ** many bytes of the key or data as are available on the local
53569 ** b-tree page.  Write the number of available bytes into *pAmt.
53570 **
53571 ** The pointer returned is ephemeral.  The key/data may move
53572 ** or be destroyed on the next call to any Btree routine,
53573 ** including calls from other threads against the same cache.
53574 ** Hence, a mutex on the BtShared should be held prior to calling
53575 ** this routine.
53576 **
53577 ** These routines is used to get quick access to key and data
53578 ** in the common case where no overflow pages are used.
53579 */
53580 SQLCIPHER_PRIVATE const void *sqlcipher3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
53581   const void *p = 0;
53582   assert( sqlcipher3_mutex_held(pCur->pBtree->db->mutex) );
53583   assert( cursorHoldsMutex(pCur) );
53584   if( ALWAYS(pCur->eState==CURSOR_VALID) ){
53585     p = (const void*)fetchPayload(pCur, pAmt, 0);
53586   }
53587   return p;
53588 }
53589 SQLCIPHER_PRIVATE const void *sqlcipher3BtreeDataFetch(BtCursor *pCur, int *pAmt){
53590   const void *p = 0;
53591   assert( sqlcipher3_mutex_held(pCur->pBtree->db->mutex) );
53592   assert( cursorHoldsMutex(pCur) );
53593   if( ALWAYS(pCur->eState==CURSOR_VALID) ){
53594     p = (const void*)fetchPayload(pCur, pAmt, 1);
53595   }
53596   return p;
53597 }
53598
53599
53600 /*
53601 ** Move the cursor down to a new child page.  The newPgno argument is the
53602 ** page number of the child page to move to.
53603 **
53604 ** This function returns SQLCIPHER_CORRUPT if the page-header flags field of
53605 ** the new child page does not match the flags field of the parent (i.e.
53606 ** if an intkey page appears to be the parent of a non-intkey page, or
53607 ** vice-versa).
53608 */
53609 static int moveToChild(BtCursor *pCur, u32 newPgno){
53610   int rc;
53611   int i = pCur->iPage;
53612   MemPage *pNewPage;
53613   BtShared *pBt = pCur->pBt;
53614
53615   assert( cursorHoldsMutex(pCur) );
53616   assert( pCur->eState==CURSOR_VALID );
53617   assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
53618   if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
53619     return SQLCIPHER_CORRUPT_BKPT;
53620   }
53621   rc = getAndInitPage(pBt, newPgno, &pNewPage);
53622   if( rc ) return rc;
53623   pCur->apPage[i+1] = pNewPage;
53624   pCur->aiIdx[i+1] = 0;
53625   pCur->iPage++;
53626
53627   pCur->info.nSize = 0;
53628   pCur->validNKey = 0;
53629   if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
53630     return SQLCIPHER_CORRUPT_BKPT;
53631   }
53632   return SQLCIPHER_OK;
53633 }
53634
53635 #ifndef NDEBUG
53636 /*
53637 ** Page pParent is an internal (non-leaf) tree page. This function 
53638 ** asserts that page number iChild is the left-child if the iIdx'th
53639 ** cell in page pParent. Or, if iIdx is equal to the total number of
53640 ** cells in pParent, that page number iChild is the right-child of
53641 ** the page.
53642 */
53643 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
53644   assert( iIdx<=pParent->nCell );
53645   if( iIdx==pParent->nCell ){
53646     assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
53647   }else{
53648     assert( get4byte(findCell(pParent, iIdx))==iChild );
53649   }
53650 }
53651 #else
53652 #  define assertParentIndex(x,y,z) 
53653 #endif
53654
53655 /*
53656 ** Move the cursor up to the parent page.
53657 **
53658 ** pCur->idx is set to the cell index that contains the pointer
53659 ** to the page we are coming from.  If we are coming from the
53660 ** right-most child page then pCur->idx is set to one more than
53661 ** the largest cell index.
53662 */
53663 static void moveToParent(BtCursor *pCur){
53664   assert( cursorHoldsMutex(pCur) );
53665   assert( pCur->eState==CURSOR_VALID );
53666   assert( pCur->iPage>0 );
53667   assert( pCur->apPage[pCur->iPage] );
53668   assertParentIndex(
53669     pCur->apPage[pCur->iPage-1], 
53670     pCur->aiIdx[pCur->iPage-1], 
53671     pCur->apPage[pCur->iPage]->pgno
53672   );
53673   releasePage(pCur->apPage[pCur->iPage]);
53674   pCur->iPage--;
53675   pCur->info.nSize = 0;
53676   pCur->validNKey = 0;
53677 }
53678
53679 /*
53680 ** Move the cursor to point to the root page of its b-tree structure.
53681 **
53682 ** If the table has a virtual root page, then the cursor is moved to point
53683 ** to the virtual root page instead of the actual root page. A table has a
53684 ** virtual root page when the actual root page contains no cells and a 
53685 ** single child page. This can only happen with the table rooted at page 1.
53686 **
53687 ** If the b-tree structure is empty, the cursor state is set to 
53688 ** CURSOR_INVALID. Otherwise, the cursor is set to point to the first
53689 ** cell located on the root (or virtual root) page and the cursor state
53690 ** is set to CURSOR_VALID.
53691 **
53692 ** If this function returns successfully, it may be assumed that the
53693 ** page-header flags indicate that the [virtual] root-page is the expected 
53694 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
53695 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
53696 ** indicating a table b-tree, or if the caller did specify a KeyInfo 
53697 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
53698 ** b-tree).
53699 */
53700 static int moveToRoot(BtCursor *pCur){
53701   MemPage *pRoot;
53702   int rc = SQLCIPHER_OK;
53703   Btree *p = pCur->pBtree;
53704   BtShared *pBt = p->pBt;
53705
53706   assert( cursorHoldsMutex(pCur) );
53707   assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
53708   assert( CURSOR_VALID   < CURSOR_REQUIRESEEK );
53709   assert( CURSOR_FAULT   > CURSOR_REQUIRESEEK );
53710   if( pCur->eState>=CURSOR_REQUIRESEEK ){
53711     if( pCur->eState==CURSOR_FAULT ){
53712       assert( pCur->skipNext!=SQLCIPHER_OK );
53713       return pCur->skipNext;
53714     }
53715     sqlcipher3BtreeClearCursor(pCur);
53716   }
53717
53718   if( pCur->iPage>=0 ){
53719     int i;
53720     for(i=1; i<=pCur->iPage; i++){
53721       releasePage(pCur->apPage[i]);
53722     }
53723     pCur->iPage = 0;
53724   }else if( pCur->pgnoRoot==0 ){
53725     pCur->eState = CURSOR_INVALID;
53726     return SQLCIPHER_OK;
53727   }else{
53728     rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
53729     if( rc!=SQLCIPHER_OK ){
53730       pCur->eState = CURSOR_INVALID;
53731       return rc;
53732     }
53733     pCur->iPage = 0;
53734
53735     /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
53736     ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
53737     ** NULL, the caller expects a table b-tree. If this is not the case,
53738     ** return an SQLCIPHER_CORRUPT error.  */
53739     assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
53740     if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
53741       return SQLCIPHER_CORRUPT_BKPT;
53742     }
53743   }
53744
53745   /* Assert that the root page is of the correct type. This must be the
53746   ** case as the call to this function that loaded the root-page (either
53747   ** this call or a previous invocation) would have detected corruption 
53748   ** if the assumption were not true, and it is not possible for the flags 
53749   ** byte to have been modified while this cursor is holding a reference
53750   ** to the page.  */
53751   pRoot = pCur->apPage[0];
53752   assert( pRoot->pgno==pCur->pgnoRoot );
53753   assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
53754
53755   pCur->aiIdx[0] = 0;
53756   pCur->info.nSize = 0;
53757   pCur->atLast = 0;
53758   pCur->validNKey = 0;
53759
53760   if( pRoot->nCell==0 && !pRoot->leaf ){
53761     Pgno subpage;
53762     if( pRoot->pgno!=1 ) return SQLCIPHER_CORRUPT_BKPT;
53763     subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
53764     pCur->eState = CURSOR_VALID;
53765     rc = moveToChild(pCur, subpage);
53766   }else{
53767     pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
53768   }
53769   return rc;
53770 }
53771
53772 /*
53773 ** Move the cursor down to the left-most leaf entry beneath the
53774 ** entry to which it is currently pointing.
53775 **
53776 ** The left-most leaf is the one with the smallest key - the first
53777 ** in ascending order.
53778 */
53779 static int moveToLeftmost(BtCursor *pCur){
53780   Pgno pgno;
53781   int rc = SQLCIPHER_OK;
53782   MemPage *pPage;
53783
53784   assert( cursorHoldsMutex(pCur) );
53785   assert( pCur->eState==CURSOR_VALID );
53786   while( rc==SQLCIPHER_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53787     assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53788     pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
53789     rc = moveToChild(pCur, pgno);
53790   }
53791   return rc;
53792 }
53793
53794 /*
53795 ** Move the cursor down to the right-most leaf entry beneath the
53796 ** page to which it is currently pointing.  Notice the difference
53797 ** between moveToLeftmost() and moveToRightmost().  moveToLeftmost()
53798 ** finds the left-most entry beneath the *entry* whereas moveToRightmost()
53799 ** finds the right-most entry beneath the *page*.
53800 **
53801 ** The right-most entry is the one with the largest key - the last
53802 ** key in ascending order.
53803 */
53804 static int moveToRightmost(BtCursor *pCur){
53805   Pgno pgno;
53806   int rc = SQLCIPHER_OK;
53807   MemPage *pPage = 0;
53808
53809   assert( cursorHoldsMutex(pCur) );
53810   assert( pCur->eState==CURSOR_VALID );
53811   while( rc==SQLCIPHER_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53812     pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
53813     pCur->aiIdx[pCur->iPage] = pPage->nCell;
53814     rc = moveToChild(pCur, pgno);
53815   }
53816   if( rc==SQLCIPHER_OK ){
53817     pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
53818     pCur->info.nSize = 0;
53819     pCur->validNKey = 0;
53820   }
53821   return rc;
53822 }
53823
53824 /* Move the cursor to the first entry in the table.  Return SQLCIPHER_OK
53825 ** on success.  Set *pRes to 0 if the cursor actually points to something
53826 ** or set *pRes to 1 if the table is empty.
53827 */
53828 SQLCIPHER_PRIVATE int sqlcipher3BtreeFirst(BtCursor *pCur, int *pRes){
53829   int rc;
53830
53831   assert( cursorHoldsMutex(pCur) );
53832   assert( sqlcipher3_mutex_held(pCur->pBtree->db->mutex) );
53833   rc = moveToRoot(pCur);
53834   if( rc==SQLCIPHER_OK ){
53835     if( pCur->eState==CURSOR_INVALID ){
53836       assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53837       *pRes = 1;
53838     }else{
53839       assert( pCur->apPage[pCur->iPage]->nCell>0 );
53840       *pRes = 0;
53841       rc = moveToLeftmost(pCur);
53842     }
53843   }
53844   return rc;
53845 }
53846
53847 /* Move the cursor to the last entry in the table.  Return SQLCIPHER_OK
53848 ** on success.  Set *pRes to 0 if the cursor actually points to something
53849 ** or set *pRes to 1 if the table is empty.
53850 */
53851 SQLCIPHER_PRIVATE int sqlcipher3BtreeLast(BtCursor *pCur, int *pRes){
53852   int rc;
53853  
53854   assert( cursorHoldsMutex(pCur) );
53855   assert( sqlcipher3_mutex_held(pCur->pBtree->db->mutex) );
53856
53857   /* If the cursor already points to the last entry, this is a no-op. */
53858   if( CURSOR_VALID==pCur->eState && pCur->atLast ){
53859 #ifdef SQLCIPHER_DEBUG
53860     /* This block serves to assert() that the cursor really does point 
53861     ** to the last entry in the b-tree. */
53862     int ii;
53863     for(ii=0; ii<pCur->iPage; ii++){
53864       assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
53865     }
53866     assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
53867     assert( pCur->apPage[pCur->iPage]->leaf );
53868 #endif
53869     return SQLCIPHER_OK;
53870   }
53871
53872   rc = moveToRoot(pCur);
53873   if( rc==SQLCIPHER_OK ){
53874     if( CURSOR_INVALID==pCur->eState ){
53875       assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53876       *pRes = 1;
53877     }else{
53878       assert( pCur->eState==CURSOR_VALID );
53879       *pRes = 0;
53880       rc = moveToRightmost(pCur);
53881       pCur->atLast = rc==SQLCIPHER_OK ?1:0;
53882     }
53883   }
53884   return rc;
53885 }
53886
53887 /* Move the cursor so that it points to an entry near the key 
53888 ** specified by pIdxKey or intKey.   Return a success code.
53889 **
53890 ** For INTKEY tables, the intKey parameter is used.  pIdxKey 
53891 ** must be NULL.  For index tables, pIdxKey is used and intKey
53892 ** is ignored.
53893 **
53894 ** If an exact match is not found, then the cursor is always
53895 ** left pointing at a leaf page which would hold the entry if it
53896 ** were present.  The cursor might point to an entry that comes
53897 ** before or after the key.
53898 **
53899 ** An integer is written into *pRes which is the result of
53900 ** comparing the key with the entry to which the cursor is 
53901 ** pointing.  The meaning of the integer written into
53902 ** *pRes is as follows:
53903 **
53904 **     *pRes<0      The cursor is left pointing at an entry that
53905 **                  is smaller than intKey/pIdxKey or if the table is empty
53906 **                  and the cursor is therefore left point to nothing.
53907 **
53908 **     *pRes==0     The cursor is left pointing at an entry that
53909 **                  exactly matches intKey/pIdxKey.
53910 **
53911 **     *pRes>0      The cursor is left pointing at an entry that
53912 **                  is larger than intKey/pIdxKey.
53913 **
53914 */
53915 SQLCIPHER_PRIVATE int sqlcipher3BtreeMovetoUnpacked(
53916   BtCursor *pCur,          /* The cursor to be moved */
53917   UnpackedRecord *pIdxKey, /* Unpacked index key */
53918   i64 intKey,              /* The table key */
53919   int biasRight,           /* If true, bias the search to the high end */
53920   int *pRes                /* Write search results here */
53921 ){
53922   int rc;
53923
53924   assert( cursorHoldsMutex(pCur) );
53925   assert( sqlcipher3_mutex_held(pCur->pBtree->db->mutex) );
53926   assert( pRes );
53927   assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
53928
53929   /* If the cursor is already positioned at the point we are trying
53930   ** to move to, then just return without doing any work */
53931   if( pCur->eState==CURSOR_VALID && pCur->validNKey 
53932    && pCur->apPage[0]->intKey 
53933   ){
53934     if( pCur->info.nKey==intKey ){
53935       *pRes = 0;
53936       return SQLCIPHER_OK;
53937     }
53938     if( pCur->atLast && pCur->info.nKey<intKey ){
53939       *pRes = -1;
53940       return SQLCIPHER_OK;
53941     }
53942   }
53943
53944   rc = moveToRoot(pCur);
53945   if( rc ){
53946     return rc;
53947   }
53948   assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
53949   assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
53950   assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
53951   if( pCur->eState==CURSOR_INVALID ){
53952     *pRes = -1;
53953     assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53954     return SQLCIPHER_OK;
53955   }
53956   assert( pCur->apPage[0]->intKey || pIdxKey );
53957   for(;;){
53958     int lwr, upr, idx;
53959     Pgno chldPg;
53960     MemPage *pPage = pCur->apPage[pCur->iPage];
53961     int c;
53962
53963     /* pPage->nCell must be greater than zero. If this is the root-page
53964     ** the cursor would have been INVALID above and this for(;;) loop
53965     ** not run. If this is not the root-page, then the moveToChild() routine
53966     ** would have already detected db corruption. Similarly, pPage must
53967     ** be the right kind (index or table) of b-tree page. Otherwise
53968     ** a moveToChild() or moveToRoot() call would have detected corruption.  */
53969     assert( pPage->nCell>0 );
53970     assert( pPage->intKey==(pIdxKey==0) );
53971     lwr = 0;
53972     upr = pPage->nCell-1;
53973     if( biasRight ){
53974       pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
53975     }else{
53976       pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
53977     }
53978     for(;;){
53979       u8 *pCell;                          /* Pointer to current cell in pPage */
53980
53981       assert( idx==pCur->aiIdx[pCur->iPage] );
53982       pCur->info.nSize = 0;
53983       pCell = findCell(pPage, idx) + pPage->childPtrSize;
53984       if( pPage->intKey ){
53985         i64 nCellKey;
53986         if( pPage->hasData ){
53987           u32 dummy;
53988           pCell += getVarint32(pCell, dummy);
53989         }
53990         getVarint(pCell, (u64*)&nCellKey);
53991         if( nCellKey==intKey ){
53992           c = 0;
53993         }else if( nCellKey<intKey ){
53994           c = -1;
53995         }else{
53996           assert( nCellKey>intKey );
53997           c = +1;
53998         }
53999         pCur->validNKey = 1;
54000         pCur->info.nKey = nCellKey;
54001       }else{
54002         /* The maximum supported page-size is 65536 bytes. This means that
54003         ** the maximum number of record bytes stored on an index B-Tree
54004         ** page is less than 16384 bytes and may be stored as a 2-byte
54005         ** varint. This information is used to attempt to avoid parsing 
54006         ** the entire cell by checking for the cases where the record is 
54007         ** stored entirely within the b-tree page by inspecting the first 
54008         ** 2 bytes of the cell.
54009         */
54010         int nCell = pCell[0];
54011         if( !(nCell & 0x80) && nCell<=pPage->maxLocal ){
54012           /* This branch runs if the record-size field of the cell is a
54013           ** single byte varint and the record fits entirely on the main
54014           ** b-tree page.  */
54015           c = sqlcipher3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
54016         }else if( !(pCell[1] & 0x80) 
54017           && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
54018         ){
54019           /* The record-size field is a 2 byte varint and the record 
54020           ** fits entirely on the main b-tree page.  */
54021           c = sqlcipher3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
54022         }else{
54023           /* The record flows over onto one or more overflow pages. In
54024           ** this case the whole cell needs to be parsed, a buffer allocated
54025           ** and accessPayload() used to retrieve the record into the
54026           ** buffer before VdbeRecordCompare() can be called. */
54027           void *pCellKey;
54028           u8 * const pCellBody = pCell - pPage->childPtrSize;
54029           btreeParseCellPtr(pPage, pCellBody, &pCur->info);
54030           nCell = (int)pCur->info.nKey;
54031           pCellKey = sqlcipher3Malloc( nCell );
54032           if( pCellKey==0 ){
54033             rc = SQLCIPHER_NOMEM;
54034             goto moveto_finish;
54035           }
54036           rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
54037           if( rc ){
54038             sqlcipher3_free(pCellKey);
54039             goto moveto_finish;
54040           }
54041           c = sqlcipher3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
54042           sqlcipher3_free(pCellKey);
54043         }
54044       }
54045       if( c==0 ){
54046         if( pPage->intKey && !pPage->leaf ){
54047           lwr = idx;
54048           break;
54049         }else{
54050           *pRes = 0;
54051           rc = SQLCIPHER_OK;
54052           goto moveto_finish;
54053         }
54054       }
54055       if( c<0 ){
54056         lwr = idx+1;
54057       }else{
54058         upr = idx-1;
54059       }
54060       if( lwr>upr ){
54061         break;
54062       }
54063       pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
54064     }
54065     assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
54066     assert( pPage->isInit );
54067     if( pPage->leaf ){
54068       chldPg = 0;
54069     }else if( lwr>=pPage->nCell ){
54070       chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
54071     }else{
54072       chldPg = get4byte(findCell(pPage, lwr));
54073     }
54074     if( chldPg==0 ){
54075       assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
54076       *pRes = c;
54077       rc = SQLCIPHER_OK;
54078       goto moveto_finish;
54079     }
54080     pCur->aiIdx[pCur->iPage] = (u16)lwr;
54081     pCur->info.nSize = 0;
54082     pCur->validNKey = 0;
54083     rc = moveToChild(pCur, chldPg);
54084     if( rc ) goto moveto_finish;
54085   }
54086 moveto_finish:
54087   return rc;
54088 }
54089
54090
54091 /*
54092 ** Return TRUE if the cursor is not pointing at an entry of the table.
54093 **
54094 ** TRUE will be returned after a call to sqlcipher3BtreeNext() moves
54095 ** past the last entry in the table or sqlcipher3BtreePrev() moves past
54096 ** the first entry.  TRUE is also returned if the table is empty.
54097 */
54098 SQLCIPHER_PRIVATE int sqlcipher3BtreeEof(BtCursor *pCur){
54099   /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
54100   ** have been deleted? This API will need to change to return an error code
54101   ** as well as the boolean result value.
54102   */
54103   return (CURSOR_VALID!=pCur->eState);
54104 }
54105
54106 /*
54107 ** Advance the cursor to the next entry in the database.  If
54108 ** successful then set *pRes=0.  If the cursor
54109 ** was already pointing to the last entry in the database before
54110 ** this routine was called, then set *pRes=1.
54111 */
54112 SQLCIPHER_PRIVATE int sqlcipher3BtreeNext(BtCursor *pCur, int *pRes){
54113   int rc;
54114   int idx;
54115   MemPage *pPage;
54116
54117   assert( cursorHoldsMutex(pCur) );
54118   rc = restoreCursorPosition(pCur);
54119   if( rc!=SQLCIPHER_OK ){
54120     return rc;
54121   }
54122   assert( pRes!=0 );
54123   if( CURSOR_INVALID==pCur->eState ){
54124     *pRes = 1;
54125     return SQLCIPHER_OK;
54126   }
54127   if( pCur->skipNext>0 ){
54128     pCur->skipNext = 0;
54129     *pRes = 0;
54130     return SQLCIPHER_OK;
54131   }
54132   pCur->skipNext = 0;
54133
54134   pPage = pCur->apPage[pCur->iPage];
54135   idx = ++pCur->aiIdx[pCur->iPage];
54136   assert( pPage->isInit );
54137   assert( idx<=pPage->nCell );
54138
54139   pCur->info.nSize = 0;
54140   pCur->validNKey = 0;
54141   if( idx>=pPage->nCell ){
54142     if( !pPage->leaf ){
54143       rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
54144       if( rc ) return rc;
54145       rc = moveToLeftmost(pCur);
54146       *pRes = 0;
54147       return rc;
54148     }
54149     do{
54150       if( pCur->iPage==0 ){
54151         *pRes = 1;
54152         pCur->eState = CURSOR_INVALID;
54153         return SQLCIPHER_OK;
54154       }
54155       moveToParent(pCur);
54156       pPage = pCur->apPage[pCur->iPage];
54157     }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
54158     *pRes = 0;
54159     if( pPage->intKey ){
54160       rc = sqlcipher3BtreeNext(pCur, pRes);
54161     }else{
54162       rc = SQLCIPHER_OK;
54163     }
54164     return rc;
54165   }
54166   *pRes = 0;
54167   if( pPage->leaf ){
54168     return SQLCIPHER_OK;
54169   }
54170   rc = moveToLeftmost(pCur);
54171   return rc;
54172 }
54173
54174
54175 /*
54176 ** Step the cursor to the back to the previous entry in the database.  If
54177 ** successful then set *pRes=0.  If the cursor
54178 ** was already pointing to the first entry in the database before
54179 ** this routine was called, then set *pRes=1.
54180 */
54181 SQLCIPHER_PRIVATE int sqlcipher3BtreePrevious(BtCursor *pCur, int *pRes){
54182   int rc;
54183   MemPage *pPage;
54184
54185   assert( cursorHoldsMutex(pCur) );
54186   rc = restoreCursorPosition(pCur);
54187   if( rc!=SQLCIPHER_OK ){
54188     return rc;
54189   }
54190   pCur->atLast = 0;
54191   if( CURSOR_INVALID==pCur->eState ){
54192     *pRes = 1;
54193     return SQLCIPHER_OK;
54194   }
54195   if( pCur->skipNext<0 ){
54196     pCur->skipNext = 0;
54197     *pRes = 0;
54198     return SQLCIPHER_OK;
54199   }
54200   pCur->skipNext = 0;
54201
54202   pPage = pCur->apPage[pCur->iPage];
54203   assert( pPage->isInit );
54204   if( !pPage->leaf ){
54205     int idx = pCur->aiIdx[pCur->iPage];
54206     rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
54207     if( rc ){
54208       return rc;
54209     }
54210     rc = moveToRightmost(pCur);
54211   }else{
54212     while( pCur->aiIdx[pCur->iPage]==0 ){
54213       if( pCur->iPage==0 ){
54214         pCur->eState = CURSOR_INVALID;
54215         *pRes = 1;
54216         return SQLCIPHER_OK;
54217       }
54218       moveToParent(pCur);
54219     }
54220     pCur->info.nSize = 0;
54221     pCur->validNKey = 0;
54222
54223     pCur->aiIdx[pCur->iPage]--;
54224     pPage = pCur->apPage[pCur->iPage];
54225     if( pPage->intKey && !pPage->leaf ){
54226       rc = sqlcipher3BtreePrevious(pCur, pRes);
54227     }else{
54228       rc = SQLCIPHER_OK;
54229     }
54230   }
54231   *pRes = 0;
54232   return rc;
54233 }
54234
54235 /*
54236 ** Allocate a new page from the database file.
54237 **
54238 ** The new page is marked as dirty.  (In other words, sqlcipher3PagerWrite()
54239 ** has already been called on the new page.)  The new page has also
54240 ** been referenced and the calling routine is responsible for calling
54241 ** sqlcipher3PagerUnref() on the new page when it is done.
54242 **
54243 ** SQLCIPHER_OK is returned on success.  Any other return value indicates
54244 ** an error.  *ppPage and *pPgno are undefined in the event of an error.
54245 ** Do not invoke sqlcipher3PagerUnref() on *ppPage if an error is returned.
54246 **
54247 ** If the "nearby" parameter is not 0, then a (feeble) effort is made to 
54248 ** locate a page close to the page number "nearby".  This can be used in an
54249 ** attempt to keep related pages close to each other in the database file,
54250 ** which in turn can make database access faster.
54251 **
54252 ** If the "exact" parameter is not 0, and the page-number nearby exists 
54253 ** anywhere on the free-list, then it is guarenteed to be returned. This
54254 ** is only used by auto-vacuum databases when allocating a new table.
54255 */
54256 static int allocateBtreePage(
54257   BtShared *pBt, 
54258   MemPage **ppPage, 
54259   Pgno *pPgno, 
54260   Pgno nearby,
54261   u8 exact
54262 ){
54263   MemPage *pPage1;
54264   int rc;
54265   u32 n;     /* Number of pages on the freelist */
54266   u32 k;     /* Number of leaves on the trunk of the freelist */
54267   MemPage *pTrunk = 0;
54268   MemPage *pPrevTrunk = 0;
54269   Pgno mxPage;     /* Total size of the database file */
54270
54271   assert( sqlcipher3_mutex_held(pBt->mutex) );
54272   pPage1 = pBt->pPage1;
54273   mxPage = btreePagecount(pBt);
54274   n = get4byte(&pPage1->aData[36]);
54275   testcase( n==mxPage-1 );
54276   if( n>=mxPage ){
54277     return SQLCIPHER_CORRUPT_BKPT;
54278   }
54279   if( n>0 ){
54280     /* There are pages on the freelist.  Reuse one of those pages. */
54281     Pgno iTrunk;
54282     u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
54283     
54284     /* If the 'exact' parameter was true and a query of the pointer-map
54285     ** shows that the page 'nearby' is somewhere on the free-list, then
54286     ** the entire-list will be searched for that page.
54287     */
54288 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
54289     if( exact && nearby<=mxPage ){
54290       u8 eType;
54291       assert( nearby>0 );
54292       assert( pBt->autoVacuum );
54293       rc = ptrmapGet(pBt, nearby, &eType, 0);
54294       if( rc ) return rc;
54295       if( eType==PTRMAP_FREEPAGE ){
54296         searchList = 1;
54297       }
54298       *pPgno = nearby;
54299     }
54300 #endif
54301
54302     /* Decrement the free-list count by 1. Set iTrunk to the index of the
54303     ** first free-list trunk page. iPrevTrunk is initially 1.
54304     */
54305     rc = sqlcipher3PagerWrite(pPage1->pDbPage);
54306     if( rc ) return rc;
54307     put4byte(&pPage1->aData[36], n-1);
54308
54309     /* The code within this loop is run only once if the 'searchList' variable
54310     ** is not true. Otherwise, it runs once for each trunk-page on the
54311     ** free-list until the page 'nearby' is located.
54312     */
54313     do {
54314       pPrevTrunk = pTrunk;
54315       if( pPrevTrunk ){
54316         iTrunk = get4byte(&pPrevTrunk->aData[0]);
54317       }else{
54318         iTrunk = get4byte(&pPage1->aData[32]);
54319       }
54320       testcase( iTrunk==mxPage );
54321       if( iTrunk>mxPage ){
54322         rc = SQLCIPHER_CORRUPT_BKPT;
54323       }else{
54324         rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
54325       }
54326       if( rc ){
54327         pTrunk = 0;
54328         goto end_allocate_page;
54329       }
54330       assert( pTrunk!=0 );
54331       assert( pTrunk->aData!=0 );
54332
54333       k = get4byte(&pTrunk->aData[4]); /* # of leaves on this trunk page */
54334       if( k==0 && !searchList ){
54335         /* The trunk has no leaves and the list is not being searched. 
54336         ** So extract the trunk page itself and use it as the newly 
54337         ** allocated page */
54338         assert( pPrevTrunk==0 );
54339         rc = sqlcipher3PagerWrite(pTrunk->pDbPage);
54340         if( rc ){
54341           goto end_allocate_page;
54342         }
54343         *pPgno = iTrunk;
54344         memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
54345         *ppPage = pTrunk;
54346         pTrunk = 0;
54347         TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
54348       }else if( k>(u32)(pBt->usableSize/4 - 2) ){
54349         /* Value of k is out of range.  Database corruption */
54350         rc = SQLCIPHER_CORRUPT_BKPT;
54351         goto end_allocate_page;
54352 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
54353       }else if( searchList && nearby==iTrunk ){
54354         /* The list is being searched and this trunk page is the page
54355         ** to allocate, regardless of whether it has leaves.
54356         */
54357         assert( *pPgno==iTrunk );
54358         *ppPage = pTrunk;
54359         searchList = 0;
54360         rc = sqlcipher3PagerWrite(pTrunk->pDbPage);
54361         if( rc ){
54362           goto end_allocate_page;
54363         }
54364         if( k==0 ){
54365           if( !pPrevTrunk ){
54366             memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
54367           }else{
54368             rc = sqlcipher3PagerWrite(pPrevTrunk->pDbPage);
54369             if( rc!=SQLCIPHER_OK ){
54370               goto end_allocate_page;
54371             }
54372             memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
54373           }
54374         }else{
54375           /* The trunk page is required by the caller but it contains 
54376           ** pointers to free-list leaves. The first leaf becomes a trunk
54377           ** page in this case.
54378           */
54379           MemPage *pNewTrunk;
54380           Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
54381           if( iNewTrunk>mxPage ){ 
54382             rc = SQLCIPHER_CORRUPT_BKPT;
54383             goto end_allocate_page;
54384           }
54385           testcase( iNewTrunk==mxPage );
54386           rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
54387           if( rc!=SQLCIPHER_OK ){
54388             goto end_allocate_page;
54389           }
54390           rc = sqlcipher3PagerWrite(pNewTrunk->pDbPage);
54391           if( rc!=SQLCIPHER_OK ){
54392             releasePage(pNewTrunk);
54393             goto end_allocate_page;
54394           }
54395           memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
54396           put4byte(&pNewTrunk->aData[4], k-1);
54397           memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
54398           releasePage(pNewTrunk);
54399           if( !pPrevTrunk ){
54400             assert( sqlcipher3PagerIswriteable(pPage1->pDbPage) );
54401             put4byte(&pPage1->aData[32], iNewTrunk);
54402           }else{
54403             rc = sqlcipher3PagerWrite(pPrevTrunk->pDbPage);
54404             if( rc ){
54405               goto end_allocate_page;
54406             }
54407             put4byte(&pPrevTrunk->aData[0], iNewTrunk);
54408           }
54409         }
54410         pTrunk = 0;
54411         TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
54412 #endif
54413       }else if( k>0 ){
54414         /* Extract a leaf from the trunk */
54415         u32 closest;
54416         Pgno iPage;
54417         unsigned char *aData = pTrunk->aData;
54418         if( nearby>0 ){
54419           u32 i;
54420           int dist;
54421           closest = 0;
54422           dist = sqlcipher3AbsInt32(get4byte(&aData[8]) - nearby);
54423           for(i=1; i<k; i++){
54424             int d2 = sqlcipher3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
54425             if( d2<dist ){
54426               closest = i;
54427               dist = d2;
54428             }
54429           }
54430         }else{
54431           closest = 0;
54432         }
54433
54434         iPage = get4byte(&aData[8+closest*4]);
54435         testcase( iPage==mxPage );
54436         if( iPage>mxPage ){
54437           rc = SQLCIPHER_CORRUPT_BKPT;
54438           goto end_allocate_page;
54439         }
54440         testcase( iPage==mxPage );
54441         if( !searchList || iPage==nearby ){
54442           int noContent;
54443           *pPgno = iPage;
54444           TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
54445                  ": %d more free pages\n",
54446                  *pPgno, closest+1, k, pTrunk->pgno, n-1));
54447           rc = sqlcipher3PagerWrite(pTrunk->pDbPage);
54448           if( rc ) goto end_allocate_page;
54449           if( closest<k-1 ){
54450             memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
54451           }
54452           put4byte(&aData[4], k-1);
54453           noContent = !btreeGetHasContent(pBt, *pPgno);
54454           rc = btreeGetPage(pBt, *pPgno, ppPage, noContent);
54455           if( rc==SQLCIPHER_OK ){
54456             rc = sqlcipher3PagerWrite((*ppPage)->pDbPage);
54457             if( rc!=SQLCIPHER_OK ){
54458               releasePage(*ppPage);
54459             }
54460           }
54461           searchList = 0;
54462         }
54463       }
54464       releasePage(pPrevTrunk);
54465       pPrevTrunk = 0;
54466     }while( searchList );
54467   }else{
54468     /* There are no pages on the freelist, so create a new page at the
54469     ** end of the file */
54470     rc = sqlcipher3PagerWrite(pBt->pPage1->pDbPage);
54471     if( rc ) return rc;
54472     pBt->nPage++;
54473     if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
54474
54475 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
54476     if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
54477       /* If *pPgno refers to a pointer-map page, allocate two new pages
54478       ** at the end of the file instead of one. The first allocated page
54479       ** becomes a new pointer-map page, the second is used by the caller.
54480       */
54481       MemPage *pPg = 0;
54482       TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
54483       assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
54484       rc = btreeGetPage(pBt, pBt->nPage, &pPg, 1);
54485       if( rc==SQLCIPHER_OK ){
54486         rc = sqlcipher3PagerWrite(pPg->pDbPage);
54487         releasePage(pPg);
54488       }
54489       if( rc ) return rc;
54490       pBt->nPage++;
54491       if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
54492     }
54493 #endif
54494     put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
54495     *pPgno = pBt->nPage;
54496
54497     assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
54498     rc = btreeGetPage(pBt, *pPgno, ppPage, 1);
54499     if( rc ) return rc;
54500     rc = sqlcipher3PagerWrite((*ppPage)->pDbPage);
54501     if( rc!=SQLCIPHER_OK ){
54502       releasePage(*ppPage);
54503     }
54504     TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
54505   }
54506
54507   assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
54508
54509 end_allocate_page:
54510   releasePage(pTrunk);
54511   releasePage(pPrevTrunk);
54512   if( rc==SQLCIPHER_OK ){
54513     if( sqlcipher3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
54514       releasePage(*ppPage);
54515       return SQLCIPHER_CORRUPT_BKPT;
54516     }
54517     (*ppPage)->isInit = 0;
54518   }else{
54519     *ppPage = 0;
54520   }
54521   assert( rc!=SQLCIPHER_OK || sqlcipher3PagerIswriteable((*ppPage)->pDbPage) );
54522   return rc;
54523 }
54524
54525 /*
54526 ** This function is used to add page iPage to the database file free-list. 
54527 ** It is assumed that the page is not already a part of the free-list.
54528 **
54529 ** The value passed as the second argument to this function is optional.
54530 ** If the caller happens to have a pointer to the MemPage object 
54531 ** corresponding to page iPage handy, it may pass it as the second value. 
54532 ** Otherwise, it may pass NULL.
54533 **
54534 ** If a pointer to a MemPage object is passed as the second argument,
54535 ** its reference count is not altered by this function.
54536 */
54537 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
54538   MemPage *pTrunk = 0;                /* Free-list trunk page */
54539   Pgno iTrunk = 0;                    /* Page number of free-list trunk page */ 
54540   MemPage *pPage1 = pBt->pPage1;      /* Local reference to page 1 */
54541   MemPage *pPage;                     /* Page being freed. May be NULL. */
54542   int rc;                             /* Return Code */
54543   int nFree;                          /* Initial number of pages on free-list */
54544
54545   assert( sqlcipher3_mutex_held(pBt->mutex) );
54546   assert( iPage>1 );
54547   assert( !pMemPage || pMemPage->pgno==iPage );
54548
54549   if( pMemPage ){
54550     pPage = pMemPage;
54551     sqlcipher3PagerRef(pPage->pDbPage);
54552   }else{
54553     pPage = btreePageLookup(pBt, iPage);
54554   }
54555
54556   /* Increment the free page count on pPage1 */
54557   rc = sqlcipher3PagerWrite(pPage1->pDbPage);
54558   if( rc ) goto freepage_out;
54559   nFree = get4byte(&pPage1->aData[36]);
54560   put4byte(&pPage1->aData[36], nFree+1);
54561
54562   if( pBt->secureDelete ){
54563     /* If the secure_delete option is enabled, then
54564     ** always fully overwrite deleted information with zeros.
54565     */
54566     if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
54567      ||            ((rc = sqlcipher3PagerWrite(pPage->pDbPage))!=0)
54568     ){
54569       goto freepage_out;
54570     }
54571     memset(pPage->aData, 0, pPage->pBt->pageSize);
54572   }
54573
54574   /* If the database supports auto-vacuum, write an entry in the pointer-map
54575   ** to indicate that the page is free.
54576   */
54577   if( ISAUTOVACUUM ){
54578     ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
54579     if( rc ) goto freepage_out;
54580   }
54581
54582   /* Now manipulate the actual database free-list structure. There are two
54583   ** possibilities. If the free-list is currently empty, or if the first
54584   ** trunk page in the free-list is full, then this page will become a
54585   ** new free-list trunk page. Otherwise, it will become a leaf of the
54586   ** first trunk page in the current free-list. This block tests if it
54587   ** is possible to add the page as a new free-list leaf.
54588   */
54589   if( nFree!=0 ){
54590     u32 nLeaf;                /* Initial number of leaf cells on trunk page */
54591
54592     iTrunk = get4byte(&pPage1->aData[32]);
54593     rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
54594     if( rc!=SQLCIPHER_OK ){
54595       goto freepage_out;
54596     }
54597
54598     nLeaf = get4byte(&pTrunk->aData[4]);
54599     assert( pBt->usableSize>32 );
54600     if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
54601       rc = SQLCIPHER_CORRUPT_BKPT;
54602       goto freepage_out;
54603     }
54604     if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
54605       /* In this case there is room on the trunk page to insert the page
54606       ** being freed as a new leaf.
54607       **
54608       ** Note that the trunk page is not really full until it contains
54609       ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
54610       ** coded.  But due to a coding error in versions of SQLite prior to
54611       ** 3.6.0, databases with freelist trunk pages holding more than
54612       ** usableSize/4 - 8 entries will be reported as corrupt.  In order
54613       ** to maintain backwards compatibility with older versions of SQLite,
54614       ** we will continue to restrict the number of entries to usableSize/4 - 8
54615       ** for now.  At some point in the future (once everyone has upgraded
54616       ** to 3.6.0 or later) we should consider fixing the conditional above
54617       ** to read "usableSize/4-2" instead of "usableSize/4-8".
54618       */
54619       rc = sqlcipher3PagerWrite(pTrunk->pDbPage);
54620       if( rc==SQLCIPHER_OK ){
54621         put4byte(&pTrunk->aData[4], nLeaf+1);
54622         put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
54623         if( pPage && !pBt->secureDelete ){
54624           sqlcipher3PagerDontWrite(pPage->pDbPage);
54625         }
54626         rc = btreeSetHasContent(pBt, iPage);
54627       }
54628       TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
54629       goto freepage_out;
54630     }
54631   }
54632
54633   /* If control flows to this point, then it was not possible to add the
54634   ** the page being freed as a leaf page of the first trunk in the free-list.
54635   ** Possibly because the free-list is empty, or possibly because the 
54636   ** first trunk in the free-list is full. Either way, the page being freed
54637   ** will become the new first trunk page in the free-list.
54638   */
54639   if( pPage==0 && SQLCIPHER_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
54640     goto freepage_out;
54641   }
54642   rc = sqlcipher3PagerWrite(pPage->pDbPage);
54643   if( rc!=SQLCIPHER_OK ){
54644     goto freepage_out;
54645   }
54646   put4byte(pPage->aData, iTrunk);
54647   put4byte(&pPage->aData[4], 0);
54648   put4byte(&pPage1->aData[32], iPage);
54649   TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
54650
54651 freepage_out:
54652   if( pPage ){
54653     pPage->isInit = 0;
54654   }
54655   releasePage(pPage);
54656   releasePage(pTrunk);
54657   return rc;
54658 }
54659 static void freePage(MemPage *pPage, int *pRC){
54660   if( (*pRC)==SQLCIPHER_OK ){
54661     *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
54662   }
54663 }
54664
54665 /*
54666 ** Free any overflow pages associated with the given Cell.
54667 */
54668 static int clearCell(MemPage *pPage, unsigned char *pCell){
54669   BtShared *pBt = pPage->pBt;
54670   CellInfo info;
54671   Pgno ovflPgno;
54672   int rc;
54673   int nOvfl;
54674   u32 ovflPageSize;
54675
54676   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
54677   btreeParseCellPtr(pPage, pCell, &info);
54678   if( info.iOverflow==0 ){
54679     return SQLCIPHER_OK;  /* No overflow pages. Return without doing anything */
54680   }
54681   if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
54682     return SQLCIPHER_CORRUPT;  /* Cell extends past end of page */
54683   }
54684   ovflPgno = get4byte(&pCell[info.iOverflow]);
54685   assert( pBt->usableSize > 4 );
54686   ovflPageSize = pBt->usableSize - 4;
54687   nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize;
54688   assert( ovflPgno==0 || nOvfl>0 );
54689   while( nOvfl-- ){
54690     Pgno iNext = 0;
54691     MemPage *pOvfl = 0;
54692     if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
54693       /* 0 is not a legal page number and page 1 cannot be an 
54694       ** overflow page. Therefore if ovflPgno<2 or past the end of the 
54695       ** file the database must be corrupt. */
54696       return SQLCIPHER_CORRUPT_BKPT;
54697     }
54698     if( nOvfl ){
54699       rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
54700       if( rc ) return rc;
54701     }
54702
54703     if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
54704      && sqlcipher3PagerPageRefcount(pOvfl->pDbPage)!=1
54705     ){
54706       /* There is no reason any cursor should have an outstanding reference 
54707       ** to an overflow page belonging to a cell that is being deleted/updated.
54708       ** So if there exists more than one reference to this page, then it 
54709       ** must not really be an overflow page and the database must be corrupt. 
54710       ** It is helpful to detect this before calling freePage2(), as 
54711       ** freePage2() may zero the page contents if secure-delete mode is
54712       ** enabled. If this 'overflow' page happens to be a page that the
54713       ** caller is iterating through or using in some other way, this
54714       ** can be problematic.
54715       */
54716       rc = SQLCIPHER_CORRUPT_BKPT;
54717     }else{
54718       rc = freePage2(pBt, pOvfl, ovflPgno);
54719     }
54720
54721     if( pOvfl ){
54722       sqlcipher3PagerUnref(pOvfl->pDbPage);
54723     }
54724     if( rc ) return rc;
54725     ovflPgno = iNext;
54726   }
54727   return SQLCIPHER_OK;
54728 }
54729
54730 /*
54731 ** Create the byte sequence used to represent a cell on page pPage
54732 ** and write that byte sequence into pCell[].  Overflow pages are
54733 ** allocated and filled in as necessary.  The calling procedure
54734 ** is responsible for making sure sufficient space has been allocated
54735 ** for pCell[].
54736 **
54737 ** Note that pCell does not necessary need to point to the pPage->aData
54738 ** area.  pCell might point to some temporary storage.  The cell will
54739 ** be constructed in this temporary area then copied into pPage->aData
54740 ** later.
54741 */
54742 static int fillInCell(
54743   MemPage *pPage,                /* The page that contains the cell */
54744   unsigned char *pCell,          /* Complete text of the cell */
54745   const void *pKey, i64 nKey,    /* The key */
54746   const void *pData,int nData,   /* The data */
54747   int nZero,                     /* Extra zero bytes to append to pData */
54748   int *pnSize                    /* Write cell size here */
54749 ){
54750   int nPayload;
54751   const u8 *pSrc;
54752   int nSrc, n, rc;
54753   int spaceLeft;
54754   MemPage *pOvfl = 0;
54755   MemPage *pToRelease = 0;
54756   unsigned char *pPrior;
54757   unsigned char *pPayload;
54758   BtShared *pBt = pPage->pBt;
54759   Pgno pgnoOvfl = 0;
54760   int nHeader;
54761   CellInfo info;
54762
54763   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
54764
54765   /* pPage is not necessarily writeable since pCell might be auxiliary
54766   ** buffer space that is separate from the pPage buffer area */
54767   assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
54768             || sqlcipher3PagerIswriteable(pPage->pDbPage) );
54769
54770   /* Fill in the header. */
54771   nHeader = 0;
54772   if( !pPage->leaf ){
54773     nHeader += 4;
54774   }
54775   if( pPage->hasData ){
54776     nHeader += putVarint(&pCell[nHeader], nData+nZero);
54777   }else{
54778     nData = nZero = 0;
54779   }
54780   nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
54781   btreeParseCellPtr(pPage, pCell, &info);
54782   assert( info.nHeader==nHeader );
54783   assert( info.nKey==nKey );
54784   assert( info.nData==(u32)(nData+nZero) );
54785   
54786   /* Fill in the payload */
54787   nPayload = nData + nZero;
54788   if( pPage->intKey ){
54789     pSrc = pData;
54790     nSrc = nData;
54791     nData = 0;
54792   }else{ 
54793     if( NEVER(nKey>0x7fffffff || pKey==0) ){
54794       return SQLCIPHER_CORRUPT_BKPT;
54795     }
54796     nPayload += (int)nKey;
54797     pSrc = pKey;
54798     nSrc = (int)nKey;
54799   }
54800   *pnSize = info.nSize;
54801   spaceLeft = info.nLocal;
54802   pPayload = &pCell[nHeader];
54803   pPrior = &pCell[info.iOverflow];
54804
54805   while( nPayload>0 ){
54806     if( spaceLeft==0 ){
54807 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
54808       Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
54809       if( pBt->autoVacuum ){
54810         do{
54811           pgnoOvfl++;
54812         } while( 
54813           PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) 
54814         );
54815       }
54816 #endif
54817       rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
54818 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
54819       /* If the database supports auto-vacuum, and the second or subsequent
54820       ** overflow page is being allocated, add an entry to the pointer-map
54821       ** for that page now. 
54822       **
54823       ** If this is the first overflow page, then write a partial entry 
54824       ** to the pointer-map. If we write nothing to this pointer-map slot,
54825       ** then the optimistic overflow chain processing in clearCell()
54826       ** may misinterpret the uninitialised values and delete the
54827       ** wrong pages from the database.
54828       */
54829       if( pBt->autoVacuum && rc==SQLCIPHER_OK ){
54830         u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
54831         ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
54832         if( rc ){
54833           releasePage(pOvfl);
54834         }
54835       }
54836 #endif
54837       if( rc ){
54838         releasePage(pToRelease);
54839         return rc;
54840       }
54841
54842       /* If pToRelease is not zero than pPrior points into the data area
54843       ** of pToRelease.  Make sure pToRelease is still writeable. */
54844       assert( pToRelease==0 || sqlcipher3PagerIswriteable(pToRelease->pDbPage) );
54845
54846       /* If pPrior is part of the data area of pPage, then make sure pPage
54847       ** is still writeable */
54848       assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
54849             || sqlcipher3PagerIswriteable(pPage->pDbPage) );
54850
54851       put4byte(pPrior, pgnoOvfl);
54852       releasePage(pToRelease);
54853       pToRelease = pOvfl;
54854       pPrior = pOvfl->aData;
54855       put4byte(pPrior, 0);
54856       pPayload = &pOvfl->aData[4];
54857       spaceLeft = pBt->usableSize - 4;
54858     }
54859     n = nPayload;
54860     if( n>spaceLeft ) n = spaceLeft;
54861
54862     /* If pToRelease is not zero than pPayload points into the data area
54863     ** of pToRelease.  Make sure pToRelease is still writeable. */
54864     assert( pToRelease==0 || sqlcipher3PagerIswriteable(pToRelease->pDbPage) );
54865
54866     /* If pPayload is part of the data area of pPage, then make sure pPage
54867     ** is still writeable */
54868     assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
54869             || sqlcipher3PagerIswriteable(pPage->pDbPage) );
54870
54871     if( nSrc>0 ){
54872       if( n>nSrc ) n = nSrc;
54873       assert( pSrc );
54874       memcpy(pPayload, pSrc, n);
54875     }else{
54876       memset(pPayload, 0, n);
54877     }
54878     nPayload -= n;
54879     pPayload += n;
54880     pSrc += n;
54881     nSrc -= n;
54882     spaceLeft -= n;
54883     if( nSrc==0 ){
54884       nSrc = nData;
54885       pSrc = pData;
54886     }
54887   }
54888   releasePage(pToRelease);
54889   return SQLCIPHER_OK;
54890 }
54891
54892 /*
54893 ** Remove the i-th cell from pPage.  This routine effects pPage only.
54894 ** The cell content is not freed or deallocated.  It is assumed that
54895 ** the cell content has been copied someplace else.  This routine just
54896 ** removes the reference to the cell from pPage.
54897 **
54898 ** "sz" must be the number of bytes in the cell.
54899 */
54900 static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
54901   u32 pc;         /* Offset to cell content of cell being deleted */
54902   u8 *data;       /* pPage->aData */
54903   u8 *ptr;        /* Used to move bytes around within data[] */
54904   u8 *endPtr;     /* End of loop */
54905   int rc;         /* The return code */
54906   int hdr;        /* Beginning of the header.  0 most pages.  100 page 1 */
54907
54908   if( *pRC ) return;
54909
54910   assert( idx>=0 && idx<pPage->nCell );
54911   assert( sz==cellSize(pPage, idx) );
54912   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
54913   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
54914   data = pPage->aData;
54915   ptr = &data[pPage->cellOffset + 2*idx];
54916   pc = get2byte(ptr);
54917   hdr = pPage->hdrOffset;
54918   testcase( pc==get2byte(&data[hdr+5]) );
54919   testcase( pc+sz==pPage->pBt->usableSize );
54920   if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
54921     *pRC = SQLCIPHER_CORRUPT_BKPT;
54922     return;
54923   }
54924   rc = freeSpace(pPage, pc, sz);
54925   if( rc ){
54926     *pRC = rc;
54927     return;
54928   }
54929   endPtr = &data[pPage->cellOffset + 2*pPage->nCell - 2];
54930   assert( (SQLCIPHER_PTR_TO_INT(ptr)&1)==0 );  /* ptr is always 2-byte aligned */
54931   while( ptr<endPtr ){
54932     *(u16*)ptr = *(u16*)&ptr[2];
54933     ptr += 2;
54934   }
54935   pPage->nCell--;
54936   put2byte(&data[hdr+3], pPage->nCell);
54937   pPage->nFree += 2;
54938 }
54939
54940 /*
54941 ** Insert a new cell on pPage at cell index "i".  pCell points to the
54942 ** content of the cell.
54943 **
54944 ** If the cell content will fit on the page, then put it there.  If it
54945 ** will not fit, then make a copy of the cell content into pTemp if
54946 ** pTemp is not null.  Regardless of pTemp, allocate a new entry
54947 ** in pPage->aOvfl[] and make it point to the cell content (either
54948 ** in pTemp or the original pCell) and also record its index. 
54949 ** Allocating a new entry in pPage->aCell[] implies that 
54950 ** pPage->nOverflow is incremented.
54951 **
54952 ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
54953 ** cell. The caller will overwrite them after this function returns. If
54954 ** nSkip is non-zero, then pCell may not point to an invalid memory location 
54955 ** (but pCell+nSkip is always valid).
54956 */
54957 static void insertCell(
54958   MemPage *pPage,   /* Page into which we are copying */
54959   int i,            /* New cell becomes the i-th cell of the page */
54960   u8 *pCell,        /* Content of the new cell */
54961   int sz,           /* Bytes of content in pCell */
54962   u8 *pTemp,        /* Temp storage space for pCell, if needed */
54963   Pgno iChild,      /* If non-zero, replace first 4 bytes with this value */
54964   int *pRC          /* Read and write return code from here */
54965 ){
54966   int idx = 0;      /* Where to write new cell content in data[] */
54967   int j;            /* Loop counter */
54968   int end;          /* First byte past the last cell pointer in data[] */
54969   int ins;          /* Index in data[] where new cell pointer is inserted */
54970   int cellOffset;   /* Address of first cell pointer in data[] */
54971   u8 *data;         /* The content of the whole page */
54972   u8 *ptr;          /* Used for moving information around in data[] */
54973   u8 *endPtr;       /* End of the loop */
54974
54975   int nSkip = (iChild ? 4 : 0);
54976
54977   if( *pRC ) return;
54978
54979   assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
54980   assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
54981   assert( pPage->nOverflow<=ArraySize(pPage->aOvfl) );
54982   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
54983   /* The cell should normally be sized correctly.  However, when moving a
54984   ** malformed cell from a leaf page to an interior page, if the cell size
54985   ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
54986   ** might be less than 8 (leaf-size + pointer) on the interior node.  Hence
54987   ** the term after the || in the following assert(). */
54988   assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
54989   if( pPage->nOverflow || sz+2>pPage->nFree ){
54990     if( pTemp ){
54991       memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
54992       pCell = pTemp;
54993     }
54994     if( iChild ){
54995       put4byte(pCell, iChild);
54996     }
54997     j = pPage->nOverflow++;
54998     assert( j<(int)(sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0])) );
54999     pPage->aOvfl[j].pCell = pCell;
55000     pPage->aOvfl[j].idx = (u16)i;
55001   }else{
55002     int rc = sqlcipher3PagerWrite(pPage->pDbPage);
55003     if( rc!=SQLCIPHER_OK ){
55004       *pRC = rc;
55005       return;
55006     }
55007     assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
55008     data = pPage->aData;
55009     cellOffset = pPage->cellOffset;
55010     end = cellOffset + 2*pPage->nCell;
55011     ins = cellOffset + 2*i;
55012     rc = allocateSpace(pPage, sz, &idx);
55013     if( rc ){ *pRC = rc; return; }
55014     /* The allocateSpace() routine guarantees the following two properties
55015     ** if it returns success */
55016     assert( idx >= end+2 );
55017     assert( idx+sz <= (int)pPage->pBt->usableSize );
55018     pPage->nCell++;
55019     pPage->nFree -= (u16)(2 + sz);
55020     memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
55021     if( iChild ){
55022       put4byte(&data[idx], iChild);
55023     }
55024     ptr = &data[end];
55025     endPtr = &data[ins];
55026     assert( (SQLCIPHER_PTR_TO_INT(ptr)&1)==0 );  /* ptr is always 2-byte aligned */
55027     while( ptr>endPtr ){
55028       *(u16*)ptr = *(u16*)&ptr[-2];
55029       ptr -= 2;
55030     }
55031     put2byte(&data[ins], idx);
55032     put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
55033 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
55034     if( pPage->pBt->autoVacuum ){
55035       /* The cell may contain a pointer to an overflow page. If so, write
55036       ** the entry for the overflow page into the pointer map.
55037       */
55038       ptrmapPutOvflPtr(pPage, pCell, pRC);
55039     }
55040 #endif
55041   }
55042 }
55043
55044 /*
55045 ** Add a list of cells to a page.  The page should be initially empty.
55046 ** The cells are guaranteed to fit on the page.
55047 */
55048 static void assemblePage(
55049   MemPage *pPage,   /* The page to be assemblied */
55050   int nCell,        /* The number of cells to add to this page */
55051   u8 **apCell,      /* Pointers to cell bodies */
55052   u16 *aSize        /* Sizes of the cells */
55053 ){
55054   int i;            /* Loop counter */
55055   u8 *pCellptr;     /* Address of next cell pointer */
55056   int cellbody;     /* Address of next cell body */
55057   u8 * const data = pPage->aData;             /* Pointer to data for pPage */
55058   const int hdr = pPage->hdrOffset;           /* Offset of header on pPage */
55059   const int nUsable = pPage->pBt->usableSize; /* Usable size of page */
55060
55061   assert( pPage->nOverflow==0 );
55062   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
55063   assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
55064             && (int)MX_CELL(pPage->pBt)<=10921);
55065   assert( sqlcipher3PagerIswriteable(pPage->pDbPage) );
55066
55067   /* Check that the page has just been zeroed by zeroPage() */
55068   assert( pPage->nCell==0 );
55069   assert( get2byteNotZero(&data[hdr+5])==nUsable );
55070
55071   pCellptr = &data[pPage->cellOffset + nCell*2];
55072   cellbody = nUsable;
55073   for(i=nCell-1; i>=0; i--){
55074     u16 sz = aSize[i];
55075     pCellptr -= 2;
55076     cellbody -= sz;
55077     put2byte(pCellptr, cellbody);
55078     memcpy(&data[cellbody], apCell[i], sz);
55079   }
55080   put2byte(&data[hdr+3], nCell);
55081   put2byte(&data[hdr+5], cellbody);
55082   pPage->nFree -= (nCell*2 + nUsable - cellbody);
55083   pPage->nCell = (u16)nCell;
55084 }
55085
55086 /*
55087 ** The following parameters determine how many adjacent pages get involved
55088 ** in a balancing operation.  NN is the number of neighbors on either side
55089 ** of the page that participate in the balancing operation.  NB is the
55090 ** total number of pages that participate, including the target page and
55091 ** NN neighbors on either side.
55092 **
55093 ** The minimum value of NN is 1 (of course).  Increasing NN above 1
55094 ** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
55095 ** in exchange for a larger degradation in INSERT and UPDATE performance.
55096 ** The value of NN appears to give the best results overall.
55097 */
55098 #define NN 1             /* Number of neighbors on either side of pPage */
55099 #define NB (NN*2+1)      /* Total pages involved in the balance */
55100
55101
55102 #ifndef SQLCIPHER_OMIT_QUICKBALANCE
55103 /*
55104 ** This version of balance() handles the common special case where
55105 ** a new entry is being inserted on the extreme right-end of the
55106 ** tree, in other words, when the new entry will become the largest
55107 ** entry in the tree.
55108 **
55109 ** Instead of trying to balance the 3 right-most leaf pages, just add
55110 ** a new page to the right-hand side and put the one new entry in
55111 ** that page.  This leaves the right side of the tree somewhat
55112 ** unbalanced.  But odds are that we will be inserting new entries
55113 ** at the end soon afterwards so the nearly empty page will quickly
55114 ** fill up.  On average.
55115 **
55116 ** pPage is the leaf page which is the right-most page in the tree.
55117 ** pParent is its parent.  pPage must have a single overflow entry
55118 ** which is also the right-most entry on the page.
55119 **
55120 ** The pSpace buffer is used to store a temporary copy of the divider
55121 ** cell that will be inserted into pParent. Such a cell consists of a 4
55122 ** byte page number followed by a variable length integer. In other
55123 ** words, at most 13 bytes. Hence the pSpace buffer must be at
55124 ** least 13 bytes in size.
55125 */
55126 static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
55127   BtShared *const pBt = pPage->pBt;    /* B-Tree Database */
55128   MemPage *pNew;                       /* Newly allocated page */
55129   int rc;                              /* Return Code */
55130   Pgno pgnoNew;                        /* Page number of pNew */
55131
55132   assert( sqlcipher3_mutex_held(pPage->pBt->mutex) );
55133   assert( sqlcipher3PagerIswriteable(pParent->pDbPage) );
55134   assert( pPage->nOverflow==1 );
55135
55136   /* This error condition is now caught prior to reaching this function */
55137   if( pPage->nCell<=0 ) return SQLCIPHER_CORRUPT_BKPT;
55138
55139   /* Allocate a new page. This page will become the right-sibling of 
55140   ** pPage. Make the parent page writable, so that the new divider cell
55141   ** may be inserted. If both these operations are successful, proceed.
55142   */
55143   rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
55144
55145   if( rc==SQLCIPHER_OK ){
55146
55147     u8 *pOut = &pSpace[4];
55148     u8 *pCell = pPage->aOvfl[0].pCell;
55149     u16 szCell = cellSizePtr(pPage, pCell);
55150     u8 *pStop;
55151
55152     assert( sqlcipher3PagerIswriteable(pNew->pDbPage) );
55153     assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
55154     zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
55155     assemblePage(pNew, 1, &pCell, &szCell);
55156
55157     /* If this is an auto-vacuum database, update the pointer map
55158     ** with entries for the new page, and any pointer from the 
55159     ** cell on the page to an overflow page. If either of these
55160     ** operations fails, the return code is set, but the contents
55161     ** of the parent page are still manipulated by thh code below.
55162     ** That is Ok, at this point the parent page is guaranteed to
55163     ** be marked as dirty. Returning an error code will cause a
55164     ** rollback, undoing any changes made to the parent page.
55165     */
55166     if( ISAUTOVACUUM ){
55167       ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
55168       if( szCell>pNew->minLocal ){
55169         ptrmapPutOvflPtr(pNew, pCell, &rc);
55170       }
55171     }
55172   
55173     /* Create a divider cell to insert into pParent. The divider cell
55174     ** consists of a 4-byte page number (the page number of pPage) and
55175     ** a variable length key value (which must be the same value as the
55176     ** largest key on pPage).
55177     **
55178     ** To find the largest key value on pPage, first find the right-most 
55179     ** cell on pPage. The first two fields of this cell are the 
55180     ** record-length (a variable length integer at most 32-bits in size)
55181     ** and the key value (a variable length integer, may have any value).
55182     ** The first of the while(...) loops below skips over the record-length
55183     ** field. The second while(...) loop copies the key value from the
55184     ** cell on pPage into the pSpace buffer.
55185     */
55186     pCell = findCell(pPage, pPage->nCell-1);
55187     pStop = &pCell[9];
55188     while( (*(pCell++)&0x80) && pCell<pStop );
55189     pStop = &pCell[9];
55190     while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
55191
55192     /* Insert the new divider cell into pParent. */
55193     insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
55194                0, pPage->pgno, &rc);
55195
55196     /* Set the right-child pointer of pParent to point to the new page. */
55197     put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
55198   
55199     /* Release the reference to the new page. */
55200     releasePage(pNew);
55201   }
55202
55203   return rc;
55204 }
55205 #endif /* SQLCIPHER_OMIT_QUICKBALANCE */
55206
55207 #if 0
55208 /*
55209 ** This function does not contribute anything to the operation of SQLite.
55210 ** it is sometimes activated temporarily while debugging code responsible 
55211 ** for setting pointer-map entries.
55212 */
55213 static int ptrmapCheckPages(MemPage **apPage, int nPage){
55214   int i, j;
55215   for(i=0; i<nPage; i++){
55216     Pgno n;
55217     u8 e;
55218     MemPage *pPage = apPage[i];
55219     BtShared *pBt = pPage->pBt;
55220     assert( pPage->isInit );
55221
55222     for(j=0; j<pPage->nCell; j++){
55223       CellInfo info;
55224       u8 *z;
55225      
55226       z = findCell(pPage, j);
55227       btreeParseCellPtr(pPage, z, &info);
55228       if( info.iOverflow ){
55229         Pgno ovfl = get4byte(&z[info.iOverflow]);
55230         ptrmapGet(pBt, ovfl, &e, &n);
55231         assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
55232       }
55233       if( !pPage->leaf ){
55234         Pgno child = get4byte(z);
55235         ptrmapGet(pBt, child, &e, &n);
55236         assert( n==pPage->pgno && e==PTRMAP_BTREE );
55237       }
55238     }
55239     if( !pPage->leaf ){
55240       Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
55241       ptrmapGet(pBt, child, &e, &n);
55242       assert( n==pPage->pgno && e==PTRMAP_BTREE );
55243     }
55244   }
55245   return 1;
55246 }
55247 #endif
55248
55249 /*
55250 ** This function is used to copy the contents of the b-tree node stored 
55251 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
55252 ** the pointer-map entries for each child page are updated so that the
55253 ** parent page stored in the pointer map is page pTo. If pFrom contained
55254 ** any cells with overflow page pointers, then the corresponding pointer
55255 ** map entries are also updated so that the parent page is page pTo.
55256 **
55257 ** If pFrom is currently carrying any overflow cells (entries in the
55258 ** MemPage.aOvfl[] array), they are not copied to pTo. 
55259 **
55260 ** Before returning, page pTo is reinitialized using btreeInitPage().
55261 **
55262 ** The performance of this function is not critical. It is only used by 
55263 ** the balance_shallower() and balance_deeper() procedures, neither of
55264 ** which are called often under normal circumstances.
55265 */
55266 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
55267   if( (*pRC)==SQLCIPHER_OK ){
55268     BtShared * const pBt = pFrom->pBt;
55269     u8 * const aFrom = pFrom->aData;
55270     u8 * const aTo = pTo->aData;
55271     int const iFromHdr = pFrom->hdrOffset;
55272     int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
55273     int rc;
55274     int iData;
55275   
55276   
55277     assert( pFrom->isInit );
55278     assert( pFrom->nFree>=iToHdr );
55279     assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
55280   
55281     /* Copy the b-tree node content from page pFrom to page pTo. */
55282     iData = get2byte(&aFrom[iFromHdr+5]);
55283     memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
55284     memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
55285   
55286     /* Reinitialize page pTo so that the contents of the MemPage structure
55287     ** match the new data. The initialization of pTo can actually fail under
55288     ** fairly obscure circumstances, even though it is a copy of initialized 
55289     ** page pFrom.
55290     */
55291     pTo->isInit = 0;
55292     rc = btreeInitPage(pTo);
55293     if( rc!=SQLCIPHER_OK ){
55294       *pRC = rc;
55295       return;
55296     }
55297   
55298     /* If this is an auto-vacuum database, update the pointer-map entries
55299     ** for any b-tree or overflow pages that pTo now contains the pointers to.
55300     */
55301     if( ISAUTOVACUUM ){
55302       *pRC = setChildPtrmaps(pTo);
55303     }
55304   }
55305 }
55306
55307 /*
55308 ** This routine redistributes cells on the iParentIdx'th child of pParent
55309 ** (hereafter "the page") and up to 2 siblings so that all pages have about the
55310 ** same amount of free space. Usually a single sibling on either side of the
55311 ** page are used in the balancing, though both siblings might come from one
55312 ** side if the page is the first or last child of its parent. If the page 
55313 ** has fewer than 2 siblings (something which can only happen if the page
55314 ** is a root page or a child of a root page) then all available siblings
55315 ** participate in the balancing.
55316 **
55317 ** The number of siblings of the page might be increased or decreased by 
55318 ** one or two in an effort to keep pages nearly full but not over full. 
55319 **
55320 ** Note that when this routine is called, some of the cells on the page
55321 ** might not actually be stored in MemPage.aData[]. This can happen
55322 ** if the page is overfull. This routine ensures that all cells allocated
55323 ** to the page and its siblings fit into MemPage.aData[] before returning.
55324 **
55325 ** In the course of balancing the page and its siblings, cells may be
55326 ** inserted into or removed from the parent page (pParent). Doing so
55327 ** may cause the parent page to become overfull or underfull. If this
55328 ** happens, it is the responsibility of the caller to invoke the correct
55329 ** balancing routine to fix this problem (see the balance() routine). 
55330 **
55331 ** If this routine fails for any reason, it might leave the database
55332 ** in a corrupted state. So if this routine fails, the database should
55333 ** be rolled back.
55334 **
55335 ** The third argument to this function, aOvflSpace, is a pointer to a
55336 ** buffer big enough to hold one page. If while inserting cells into the parent
55337 ** page (pParent) the parent page becomes overfull, this buffer is
55338 ** used to store the parent's overflow cells. Because this function inserts
55339 ** a maximum of four divider cells into the parent page, and the maximum
55340 ** size of a cell stored within an internal node is always less than 1/4
55341 ** of the page-size, the aOvflSpace[] buffer is guaranteed to be large
55342 ** enough for all overflow cells.
55343 **
55344 ** If aOvflSpace is set to a null pointer, this function returns 
55345 ** SQLCIPHER_NOMEM.
55346 */
55347 static int balance_nonroot(
55348   MemPage *pParent,               /* Parent page of siblings being balanced */
55349   int iParentIdx,                 /* Index of "the page" in pParent */
55350   u8 *aOvflSpace,                 /* page-size bytes of space for parent ovfl */
55351   int isRoot                      /* True if pParent is a root-page */
55352 ){
55353   BtShared *pBt;               /* The whole database */
55354   int nCell = 0;               /* Number of cells in apCell[] */
55355   int nMaxCells = 0;           /* Allocated size of apCell, szCell, aFrom. */
55356   int nNew = 0;                /* Number of pages in apNew[] */
55357   int nOld;                    /* Number of pages in apOld[] */
55358   int i, j, k;                 /* Loop counters */
55359   int nxDiv;                   /* Next divider slot in pParent->aCell[] */
55360   int rc = SQLCIPHER_OK;          /* The return code */
55361   u16 leafCorrection;          /* 4 if pPage is a leaf.  0 if not */
55362   int leafData;                /* True if pPage is a leaf of a LEAFDATA tree */
55363   int usableSpace;             /* Bytes in pPage beyond the header */
55364   int pageFlags;               /* Value of pPage->aData[0] */
55365   int subtotal;                /* Subtotal of bytes in cells on one page */
55366   int iSpace1 = 0;             /* First unused byte of aSpace1[] */
55367   int iOvflSpace = 0;          /* First unused byte of aOvflSpace[] */
55368   int szScratch;               /* Size of scratch memory requested */
55369   MemPage *apOld[NB];          /* pPage and up to two siblings */
55370   MemPage *apCopy[NB];         /* Private copies of apOld[] pages */
55371   MemPage *apNew[NB+2];        /* pPage and up to NB siblings after balancing */
55372   u8 *pRight;                  /* Location in parent of right-sibling pointer */
55373   u8 *apDiv[NB-1];             /* Divider cells in pParent */
55374   int cntNew[NB+2];            /* Index in aCell[] of cell after i-th page */
55375   int szNew[NB+2];             /* Combined size of cells place on i-th page */
55376   u8 **apCell = 0;             /* All cells begin balanced */
55377   u16 *szCell;                 /* Local size of all cells in apCell[] */
55378   u8 *aSpace1;                 /* Space for copies of dividers cells */
55379   Pgno pgno;                   /* Temp var to store a page number in */
55380
55381   pBt = pParent->pBt;
55382   assert( sqlcipher3_mutex_held(pBt->mutex) );
55383   assert( sqlcipher3PagerIswriteable(pParent->pDbPage) );
55384
55385 #if 0
55386   TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
55387 #endif
55388
55389   /* At this point pParent may have at most one overflow cell. And if
55390   ** this overflow cell is present, it must be the cell with 
55391   ** index iParentIdx. This scenario comes about when this function
55392   ** is called (indirectly) from sqlcipher3BtreeDelete().
55393   */
55394   assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
55395   assert( pParent->nOverflow==0 || pParent->aOvfl[0].idx==iParentIdx );
55396
55397   if( !aOvflSpace ){
55398     return SQLCIPHER_NOMEM;
55399   }
55400
55401   /* Find the sibling pages to balance. Also locate the cells in pParent 
55402   ** that divide the siblings. An attempt is made to find NN siblings on 
55403   ** either side of pPage. More siblings are taken from one side, however, 
55404   ** if there are fewer than NN siblings on the other side. If pParent
55405   ** has NB or fewer children then all children of pParent are taken.  
55406   **
55407   ** This loop also drops the divider cells from the parent page. This
55408   ** way, the remainder of the function does not have to deal with any
55409   ** overflow cells in the parent page, since if any existed they will
55410   ** have already been removed.
55411   */
55412   i = pParent->nOverflow + pParent->nCell;
55413   if( i<2 ){
55414     nxDiv = 0;
55415     nOld = i+1;
55416   }else{
55417     nOld = 3;
55418     if( iParentIdx==0 ){                 
55419       nxDiv = 0;
55420     }else if( iParentIdx==i ){
55421       nxDiv = i-2;
55422     }else{
55423       nxDiv = iParentIdx-1;
55424     }
55425     i = 2;
55426   }
55427   if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
55428     pRight = &pParent->aData[pParent->hdrOffset+8];
55429   }else{
55430     pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
55431   }
55432   pgno = get4byte(pRight);
55433   while( 1 ){
55434     rc = getAndInitPage(pBt, pgno, &apOld[i]);
55435     if( rc ){
55436       memset(apOld, 0, (i+1)*sizeof(MemPage*));
55437       goto balance_cleanup;
55438     }
55439     nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
55440     if( (i--)==0 ) break;
55441
55442     if( i+nxDiv==pParent->aOvfl[0].idx && pParent->nOverflow ){
55443       apDiv[i] = pParent->aOvfl[0].pCell;
55444       pgno = get4byte(apDiv[i]);
55445       szNew[i] = cellSizePtr(pParent, apDiv[i]);
55446       pParent->nOverflow = 0;
55447     }else{
55448       apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow);
55449       pgno = get4byte(apDiv[i]);
55450       szNew[i] = cellSizePtr(pParent, apDiv[i]);
55451
55452       /* Drop the cell from the parent page. apDiv[i] still points to
55453       ** the cell within the parent, even though it has been dropped.
55454       ** This is safe because dropping a cell only overwrites the first
55455       ** four bytes of it, and this function does not need the first
55456       ** four bytes of the divider cell. So the pointer is safe to use
55457       ** later on.  
55458       **
55459       ** But not if we are in secure-delete mode. In secure-delete mode,
55460       ** the dropCell() routine will overwrite the entire cell with zeroes.
55461       ** In this case, temporarily copy the cell into the aOvflSpace[]
55462       ** buffer. It will be copied out again as soon as the aSpace[] buffer
55463       ** is allocated.  */
55464       if( pBt->secureDelete ){
55465         int iOff;
55466
55467         iOff = SQLCIPHER_PTR_TO_INT(apDiv[i]) - SQLCIPHER_PTR_TO_INT(pParent->aData);
55468         if( (iOff+szNew[i])>(int)pBt->usableSize ){
55469           rc = SQLCIPHER_CORRUPT_BKPT;
55470           memset(apOld, 0, (i+1)*sizeof(MemPage*));
55471           goto balance_cleanup;
55472         }else{
55473           memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]);
55474           apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
55475         }
55476       }
55477       dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc);
55478     }
55479   }
55480
55481   /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
55482   ** alignment */
55483   nMaxCells = (nMaxCells + 3)&~3;
55484
55485   /*
55486   ** Allocate space for memory structures
55487   */
55488   k = pBt->pageSize + ROUND8(sizeof(MemPage));
55489   szScratch =
55490        nMaxCells*sizeof(u8*)                       /* apCell */
55491      + nMaxCells*sizeof(u16)                       /* szCell */
55492      + pBt->pageSize                               /* aSpace1 */
55493      + k*nOld;                                     /* Page copies (apCopy) */
55494   apCell = sqlcipher3ScratchMalloc( szScratch ); 
55495   if( apCell==0 ){
55496     rc = SQLCIPHER_NOMEM;
55497     goto balance_cleanup;
55498   }
55499   szCell = (u16*)&apCell[nMaxCells];
55500   aSpace1 = (u8*)&szCell[nMaxCells];
55501   assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
55502
55503   /*
55504   ** Load pointers to all cells on sibling pages and the divider cells
55505   ** into the local apCell[] array.  Make copies of the divider cells
55506   ** into space obtained from aSpace1[] and remove the the divider Cells
55507   ** from pParent.
55508   **
55509   ** If the siblings are on leaf pages, then the child pointers of the
55510   ** divider cells are stripped from the cells before they are copied
55511   ** into aSpace1[].  In this way, all cells in apCell[] are without
55512   ** child pointers.  If siblings are not leaves, then all cell in
55513   ** apCell[] include child pointers.  Either way, all cells in apCell[]
55514   ** are alike.
55515   **
55516   ** leafCorrection:  4 if pPage is a leaf.  0 if pPage is not a leaf.
55517   **       leafData:  1 if pPage holds key+data and pParent holds only keys.
55518   */
55519   leafCorrection = apOld[0]->leaf*4;
55520   leafData = apOld[0]->hasData;
55521   for(i=0; i<nOld; i++){
55522     int limit;
55523     
55524     /* Before doing anything else, take a copy of the i'th original sibling
55525     ** The rest of this function will use data from the copies rather
55526     ** that the original pages since the original pages will be in the
55527     ** process of being overwritten.  */
55528     MemPage *pOld = apCopy[i] = (MemPage*)&aSpace1[pBt->pageSize + k*i];
55529     memcpy(pOld, apOld[i], sizeof(MemPage));
55530     pOld->aData = (void*)&pOld[1];
55531     memcpy(pOld->aData, apOld[i]->aData, pBt->pageSize);
55532
55533     limit = pOld->nCell+pOld->nOverflow;
55534     if( pOld->nOverflow>0 ){
55535       for(j=0; j<limit; j++){
55536         assert( nCell<nMaxCells );
55537         apCell[nCell] = findOverflowCell(pOld, j);
55538         szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
55539         nCell++;
55540       }
55541     }else{
55542       u8 *aData = pOld->aData;
55543       u16 maskPage = pOld->maskPage;
55544       u16 cellOffset = pOld->cellOffset;
55545       for(j=0; j<limit; j++){
55546         assert( nCell<nMaxCells );
55547         apCell[nCell] = findCellv2(aData, maskPage, cellOffset, j);
55548         szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
55549         nCell++;
55550       }
55551     }       
55552     if( i<nOld-1 && !leafData){
55553       u16 sz = (u16)szNew[i];
55554       u8 *pTemp;
55555       assert( nCell<nMaxCells );
55556       szCell[nCell] = sz;
55557       pTemp = &aSpace1[iSpace1];
55558       iSpace1 += sz;
55559       assert( sz<=pBt->maxLocal+23 );
55560       assert( iSpace1 <= (int)pBt->pageSize );
55561       memcpy(pTemp, apDiv[i], sz);
55562       apCell[nCell] = pTemp+leafCorrection;
55563       assert( leafCorrection==0 || leafCorrection==4 );
55564       szCell[nCell] = szCell[nCell] - leafCorrection;
55565       if( !pOld->leaf ){
55566         assert( leafCorrection==0 );
55567         assert( pOld->hdrOffset==0 );
55568         /* The right pointer of the child page pOld becomes the left
55569         ** pointer of the divider cell */
55570         memcpy(apCell[nCell], &pOld->aData[8], 4);
55571       }else{
55572         assert( leafCorrection==4 );
55573         if( szCell[nCell]<4 ){
55574           /* Do not allow any cells smaller than 4 bytes. */
55575           szCell[nCell] = 4;
55576         }
55577       }
55578       nCell++;
55579     }
55580   }
55581
55582   /*
55583   ** Figure out the number of pages needed to hold all nCell cells.
55584   ** Store this number in "k".  Also compute szNew[] which is the total
55585   ** size of all cells on the i-th page and cntNew[] which is the index
55586   ** in apCell[] of the cell that divides page i from page i+1.  
55587   ** cntNew[k] should equal nCell.
55588   **
55589   ** Values computed by this block:
55590   **
55591   **           k: The total number of sibling pages
55592   **    szNew[i]: Spaced used on the i-th sibling page.
55593   **   cntNew[i]: Index in apCell[] and szCell[] for the first cell to
55594   **              the right of the i-th sibling page.
55595   ** usableSpace: Number of bytes of space available on each sibling.
55596   ** 
55597   */
55598   usableSpace = pBt->usableSize - 12 + leafCorrection;
55599   for(subtotal=k=i=0; i<nCell; i++){
55600     assert( i<nMaxCells );
55601     subtotal += szCell[i] + 2;
55602     if( subtotal > usableSpace ){
55603       szNew[k] = subtotal - szCell[i];
55604       cntNew[k] = i;
55605       if( leafData ){ i--; }
55606       subtotal = 0;
55607       k++;
55608       if( k>NB+1 ){ rc = SQLCIPHER_CORRUPT_BKPT; goto balance_cleanup; }
55609     }
55610   }
55611   szNew[k] = subtotal;
55612   cntNew[k] = nCell;
55613   k++;
55614
55615   /*
55616   ** The packing computed by the previous block is biased toward the siblings
55617   ** on the left side.  The left siblings are always nearly full, while the
55618   ** right-most sibling might be nearly empty.  This block of code attempts
55619   ** to adjust the packing of siblings to get a better balance.
55620   **
55621   ** This adjustment is more than an optimization.  The packing above might
55622   ** be so out of balance as to be illegal.  For example, the right-most
55623   ** sibling might be completely empty.  This adjustment is not optional.
55624   */
55625   for(i=k-1; i>0; i--){
55626     int szRight = szNew[i];  /* Size of sibling on the right */
55627     int szLeft = szNew[i-1]; /* Size of sibling on the left */
55628     int r;              /* Index of right-most cell in left sibling */
55629     int d;              /* Index of first cell to the left of right sibling */
55630
55631     r = cntNew[i-1] - 1;
55632     d = r + 1 - leafData;
55633     assert( d<nMaxCells );
55634     assert( r<nMaxCells );
55635     while( szRight==0 || szRight+szCell[d]+2<=szLeft-(szCell[r]+2) ){
55636       szRight += szCell[d] + 2;
55637       szLeft -= szCell[r] + 2;
55638       cntNew[i-1]--;
55639       r = cntNew[i-1] - 1;
55640       d = r + 1 - leafData;
55641     }
55642     szNew[i] = szRight;
55643     szNew[i-1] = szLeft;
55644   }
55645
55646   /* Either we found one or more cells (cntnew[0])>0) or pPage is
55647   ** a virtual root page.  A virtual root page is when the real root
55648   ** page is page 1 and we are the only child of that page.
55649   */
55650   assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
55651
55652   TRACE(("BALANCE: old: %d %d %d  ",
55653     apOld[0]->pgno, 
55654     nOld>=2 ? apOld[1]->pgno : 0,
55655     nOld>=3 ? apOld[2]->pgno : 0
55656   ));
55657
55658   /*
55659   ** Allocate k new pages.  Reuse old pages where possible.
55660   */
55661   if( apOld[0]->pgno<=1 ){
55662     rc = SQLCIPHER_CORRUPT_BKPT;
55663     goto balance_cleanup;
55664   }
55665   pageFlags = apOld[0]->aData[0];
55666   for(i=0; i<k; i++){
55667     MemPage *pNew;
55668     if( i<nOld ){
55669       pNew = apNew[i] = apOld[i];
55670       apOld[i] = 0;
55671       rc = sqlcipher3PagerWrite(pNew->pDbPage);
55672       nNew++;
55673       if( rc ) goto balance_cleanup;
55674     }else{
55675       assert( i>0 );
55676       rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
55677       if( rc ) goto balance_cleanup;
55678       apNew[i] = pNew;
55679       nNew++;
55680
55681       /* Set the pointer-map entry for the new sibling page. */
55682       if( ISAUTOVACUUM ){
55683         ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
55684         if( rc!=SQLCIPHER_OK ){
55685           goto balance_cleanup;
55686         }
55687       }
55688     }
55689   }
55690
55691   /* Free any old pages that were not reused as new pages.
55692   */
55693   while( i<nOld ){
55694     freePage(apOld[i], &rc);
55695     if( rc ) goto balance_cleanup;
55696     releasePage(apOld[i]);
55697     apOld[i] = 0;
55698     i++;
55699   }
55700
55701   /*
55702   ** Put the new pages in accending order.  This helps to
55703   ** keep entries in the disk file in order so that a scan
55704   ** of the table is a linear scan through the file.  That
55705   ** in turn helps the operating system to deliver pages
55706   ** from the disk more rapidly.
55707   **
55708   ** An O(n^2) insertion sort algorithm is used, but since
55709   ** n is never more than NB (a small constant), that should
55710   ** not be a problem.
55711   **
55712   ** When NB==3, this one optimization makes the database
55713   ** about 25% faster for large insertions and deletions.
55714   */
55715   for(i=0; i<k-1; i++){
55716     int minV = apNew[i]->pgno;
55717     int minI = i;
55718     for(j=i+1; j<k; j++){
55719       if( apNew[j]->pgno<(unsigned)minV ){
55720         minI = j;
55721         minV = apNew[j]->pgno;
55722       }
55723     }
55724     if( minI>i ){
55725       MemPage *pT;
55726       pT = apNew[i];
55727       apNew[i] = apNew[minI];
55728       apNew[minI] = pT;
55729     }
55730   }
55731   TRACE(("new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n",
55732     apNew[0]->pgno, szNew[0],
55733     nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
55734     nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
55735     nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
55736     nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0));
55737
55738   assert( sqlcipher3PagerIswriteable(pParent->pDbPage) );
55739   put4byte(pRight, apNew[nNew-1]->pgno);
55740
55741   /*
55742   ** Evenly distribute the data in apCell[] across the new pages.
55743   ** Insert divider cells into pParent as necessary.
55744   */
55745   j = 0;
55746   for(i=0; i<nNew; i++){
55747     /* Assemble the new sibling page. */
55748     MemPage *pNew = apNew[i];
55749     assert( j<nMaxCells );
55750     zeroPage(pNew, pageFlags);
55751     assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
55752     assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
55753     assert( pNew->nOverflow==0 );
55754
55755     j = cntNew[i];
55756
55757     /* If the sibling page assembled above was not the right-most sibling,
55758     ** insert a divider cell into the parent page.
55759     */
55760     assert( i<nNew-1 || j==nCell );
55761     if( j<nCell ){
55762       u8 *pCell;
55763       u8 *pTemp;
55764       int sz;
55765
55766       assert( j<nMaxCells );
55767       pCell = apCell[j];
55768       sz = szCell[j] + leafCorrection;
55769       pTemp = &aOvflSpace[iOvflSpace];
55770       if( !pNew->leaf ){
55771         memcpy(&pNew->aData[8], pCell, 4);
55772       }else if( leafData ){
55773         /* If the tree is a leaf-data tree, and the siblings are leaves, 
55774         ** then there is no divider cell in apCell[]. Instead, the divider 
55775         ** cell consists of the integer key for the right-most cell of 
55776         ** the sibling-page assembled above only.
55777         */
55778         CellInfo info;
55779         j--;
55780         btreeParseCellPtr(pNew, apCell[j], &info);
55781         pCell = pTemp;
55782         sz = 4 + putVarint(&pCell[4], info.nKey);
55783         pTemp = 0;
55784       }else{
55785         pCell -= 4;
55786         /* Obscure case for non-leaf-data trees: If the cell at pCell was
55787         ** previously stored on a leaf node, and its reported size was 4
55788         ** bytes, then it may actually be smaller than this 
55789         ** (see btreeParseCellPtr(), 4 bytes is the minimum size of
55790         ** any cell). But it is important to pass the correct size to 
55791         ** insertCell(), so reparse the cell now.
55792         **
55793         ** Note that this can never happen in an SQLite data file, as all
55794         ** cells are at least 4 bytes. It only happens in b-trees used
55795         ** to evaluate "IN (SELECT ...)" and similar clauses.
55796         */
55797         if( szCell[j]==4 ){
55798           assert(leafCorrection==4);
55799           sz = cellSizePtr(pParent, pCell);
55800         }
55801       }
55802       iOvflSpace += sz;
55803       assert( sz<=pBt->maxLocal+23 );
55804       assert( iOvflSpace <= (int)pBt->pageSize );
55805       insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
55806       if( rc!=SQLCIPHER_OK ) goto balance_cleanup;
55807       assert( sqlcipher3PagerIswriteable(pParent->pDbPage) );
55808
55809       j++;
55810       nxDiv++;
55811     }
55812   }
55813   assert( j==nCell );
55814   assert( nOld>0 );
55815   assert( nNew>0 );
55816   if( (pageFlags & PTF_LEAF)==0 ){
55817     u8 *zChild = &apCopy[nOld-1]->aData[8];
55818     memcpy(&apNew[nNew-1]->aData[8], zChild, 4);
55819   }
55820
55821   if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
55822     /* The root page of the b-tree now contains no cells. The only sibling
55823     ** page is the right-child of the parent. Copy the contents of the
55824     ** child page into the parent, decreasing the overall height of the
55825     ** b-tree structure by one. This is described as the "balance-shallower"
55826     ** sub-algorithm in some documentation.
55827     **
55828     ** If this is an auto-vacuum database, the call to copyNodeContent() 
55829     ** sets all pointer-map entries corresponding to database image pages 
55830     ** for which the pointer is stored within the content being copied.
55831     **
55832     ** The second assert below verifies that the child page is defragmented
55833     ** (it must be, as it was just reconstructed using assemblePage()). This
55834     ** is important if the parent page happens to be page 1 of the database
55835     ** image.  */
55836     assert( nNew==1 );
55837     assert( apNew[0]->nFree == 
55838         (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2) 
55839     );
55840     copyNodeContent(apNew[0], pParent, &rc);
55841     freePage(apNew[0], &rc);
55842   }else if( ISAUTOVACUUM ){
55843     /* Fix the pointer-map entries for all the cells that were shifted around. 
55844     ** There are several different types of pointer-map entries that need to
55845     ** be dealt with by this routine. Some of these have been set already, but
55846     ** many have not. The following is a summary:
55847     **
55848     **   1) The entries associated with new sibling pages that were not
55849     **      siblings when this function was called. These have already
55850     **      been set. We don't need to worry about old siblings that were
55851     **      moved to the free-list - the freePage() code has taken care
55852     **      of those.
55853     **
55854     **   2) The pointer-map entries associated with the first overflow
55855     **      page in any overflow chains used by new divider cells. These 
55856     **      have also already been taken care of by the insertCell() code.
55857     **
55858     **   3) If the sibling pages are not leaves, then the child pages of
55859     **      cells stored on the sibling pages may need to be updated.
55860     **
55861     **   4) If the sibling pages are not internal intkey nodes, then any
55862     **      overflow pages used by these cells may need to be updated
55863     **      (internal intkey nodes never contain pointers to overflow pages).
55864     **
55865     **   5) If the sibling pages are not leaves, then the pointer-map
55866     **      entries for the right-child pages of each sibling may need
55867     **      to be updated.
55868     **
55869     ** Cases 1 and 2 are dealt with above by other code. The next
55870     ** block deals with cases 3 and 4 and the one after that, case 5. Since
55871     ** setting a pointer map entry is a relatively expensive operation, this
55872     ** code only sets pointer map entries for child or overflow pages that have
55873     ** actually moved between pages.  */
55874     MemPage *pNew = apNew[0];
55875     MemPage *pOld = apCopy[0];
55876     int nOverflow = pOld->nOverflow;
55877     int iNextOld = pOld->nCell + nOverflow;
55878     int iOverflow = (nOverflow ? pOld->aOvfl[0].idx : -1);
55879     j = 0;                             /* Current 'old' sibling page */
55880     k = 0;                             /* Current 'new' sibling page */
55881     for(i=0; i<nCell; i++){
55882       int isDivider = 0;
55883       while( i==iNextOld ){
55884         /* Cell i is the cell immediately following the last cell on old
55885         ** sibling page j. If the siblings are not leaf pages of an
55886         ** intkey b-tree, then cell i was a divider cell. */
55887         assert( j+1 < ArraySize(apCopy) );
55888         pOld = apCopy[++j];
55889         iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;
55890         if( pOld->nOverflow ){
55891           nOverflow = pOld->nOverflow;
55892           iOverflow = i + !leafData + pOld->aOvfl[0].idx;
55893         }
55894         isDivider = !leafData;  
55895       }
55896
55897       assert(nOverflow>0 || iOverflow<i );
55898       assert(nOverflow<2 || pOld->aOvfl[0].idx==pOld->aOvfl[1].idx-1);
55899       assert(nOverflow<3 || pOld->aOvfl[1].idx==pOld->aOvfl[2].idx-1);
55900       if( i==iOverflow ){
55901         isDivider = 1;
55902         if( (--nOverflow)>0 ){
55903           iOverflow++;
55904         }
55905       }
55906
55907       if( i==cntNew[k] ){
55908         /* Cell i is the cell immediately following the last cell on new
55909         ** sibling page k. If the siblings are not leaf pages of an
55910         ** intkey b-tree, then cell i is a divider cell.  */
55911         pNew = apNew[++k];
55912         if( !leafData ) continue;
55913       }
55914       assert( j<nOld );
55915       assert( k<nNew );
55916
55917       /* If the cell was originally divider cell (and is not now) or
55918       ** an overflow cell, or if the cell was located on a different sibling
55919       ** page before the balancing, then the pointer map entries associated
55920       ** with any child or overflow pages need to be updated.  */
55921       if( isDivider || pOld->pgno!=pNew->pgno ){
55922         if( !leafCorrection ){
55923           ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
55924         }
55925         if( szCell[i]>pNew->minLocal ){
55926           ptrmapPutOvflPtr(pNew, apCell[i], &rc);
55927         }
55928       }
55929     }
55930
55931     if( !leafCorrection ){
55932       for(i=0; i<nNew; i++){
55933         u32 key = get4byte(&apNew[i]->aData[8]);
55934         ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
55935       }
55936     }
55937
55938 #if 0
55939     /* The ptrmapCheckPages() contains assert() statements that verify that
55940     ** all pointer map pages are set correctly. This is helpful while 
55941     ** debugging. This is usually disabled because a corrupt database may
55942     ** cause an assert() statement to fail.  */
55943     ptrmapCheckPages(apNew, nNew);
55944     ptrmapCheckPages(&pParent, 1);
55945 #endif
55946   }
55947
55948   assert( pParent->isInit );
55949   TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
55950           nOld, nNew, nCell));
55951
55952   /*
55953   ** Cleanup before returning.
55954   */
55955 balance_cleanup:
55956   sqlcipher3ScratchFree(apCell);
55957   for(i=0; i<nOld; i++){
55958     releasePage(apOld[i]);
55959   }
55960   for(i=0; i<nNew; i++){
55961     releasePage(apNew[i]);
55962   }
55963
55964   return rc;
55965 }
55966
55967
55968 /*
55969 ** This function is called when the root page of a b-tree structure is
55970 ** overfull (has one or more overflow pages).
55971 **
55972 ** A new child page is allocated and the contents of the current root
55973 ** page, including overflow cells, are copied into the child. The root
55974 ** page is then overwritten to make it an empty page with the right-child 
55975 ** pointer pointing to the new page.
55976 **
55977 ** Before returning, all pointer-map entries corresponding to pages 
55978 ** that the new child-page now contains pointers to are updated. The
55979 ** entry corresponding to the new right-child pointer of the root
55980 ** page is also updated.
55981 **
55982 ** If successful, *ppChild is set to contain a reference to the child 
55983 ** page and SQLCIPHER_OK is returned. In this case the caller is required
55984 ** to call releasePage() on *ppChild exactly once. If an error occurs,
55985 ** an error code is returned and *ppChild is set to 0.
55986 */
55987 static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
55988   int rc;                        /* Return value from subprocedures */
55989   MemPage *pChild = 0;           /* Pointer to a new child page */
55990   Pgno pgnoChild = 0;            /* Page number of the new child page */
55991   BtShared *pBt = pRoot->pBt;    /* The BTree */
55992
55993   assert( pRoot->nOverflow>0 );
55994   assert( sqlcipher3_mutex_held(pBt->mutex) );
55995
55996   /* Make pRoot, the root page of the b-tree, writable. Allocate a new 
55997   ** page that will become the new right-child of pPage. Copy the contents
55998   ** of the node stored on pRoot into the new child page.
55999   */
56000   rc = sqlcipher3PagerWrite(pRoot->pDbPage);
56001   if( rc==SQLCIPHER_OK ){
56002     rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
56003     copyNodeContent(pRoot, pChild, &rc);
56004     if( ISAUTOVACUUM ){
56005       ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
56006     }
56007   }
56008   if( rc ){
56009     *ppChild = 0;
56010     releasePage(pChild);
56011     return rc;
56012   }
56013   assert( sqlcipher3PagerIswriteable(pChild->pDbPage) );
56014   assert( sqlcipher3PagerIswriteable(pRoot->pDbPage) );
56015   assert( pChild->nCell==pRoot->nCell );
56016
56017   TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
56018
56019   /* Copy the overflow cells from pRoot to pChild */
56020   memcpy(pChild->aOvfl, pRoot->aOvfl, pRoot->nOverflow*sizeof(pRoot->aOvfl[0]));
56021   pChild->nOverflow = pRoot->nOverflow;
56022
56023   /* Zero the contents of pRoot. Then install pChild as the right-child. */
56024   zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF);
56025   put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild);
56026
56027   *ppChild = pChild;
56028   return SQLCIPHER_OK;
56029 }
56030
56031 /*
56032 ** The page that pCur currently points to has just been modified in
56033 ** some way. This function figures out if this modification means the
56034 ** tree needs to be balanced, and if so calls the appropriate balancing 
56035 ** routine. Balancing routines are:
56036 **
56037 **   balance_quick()
56038 **   balance_deeper()
56039 **   balance_nonroot()
56040 */
56041 static int balance(BtCursor *pCur){
56042   int rc = SQLCIPHER_OK;
56043   const int nMin = pCur->pBt->usableSize * 2 / 3;
56044   u8 aBalanceQuickSpace[13];
56045   u8 *pFree = 0;
56046
56047   TESTONLY( int balance_quick_called = 0 );
56048   TESTONLY( int balance_deeper_called = 0 );
56049
56050   do {
56051     int iPage = pCur->iPage;
56052     MemPage *pPage = pCur->apPage[iPage];
56053
56054     if( iPage==0 ){
56055       if( pPage->nOverflow ){
56056         /* The root page of the b-tree is overfull. In this case call the
56057         ** balance_deeper() function to create a new child for the root-page
56058         ** and copy the current contents of the root-page to it. The
56059         ** next iteration of the do-loop will balance the child page.
56060         */ 
56061         assert( (balance_deeper_called++)==0 );
56062         rc = balance_deeper(pPage, &pCur->apPage[1]);
56063         if( rc==SQLCIPHER_OK ){
56064           pCur->iPage = 1;
56065           pCur->aiIdx[0] = 0;
56066           pCur->aiIdx[1] = 0;
56067           assert( pCur->apPage[1]->nOverflow );
56068         }
56069       }else{
56070         break;
56071       }
56072     }else if( pPage->nOverflow==0 && pPage->nFree<=nMin ){
56073       break;
56074     }else{
56075       MemPage * const pParent = pCur->apPage[iPage-1];
56076       int const iIdx = pCur->aiIdx[iPage-1];
56077
56078       rc = sqlcipher3PagerWrite(pParent->pDbPage);
56079       if( rc==SQLCIPHER_OK ){
56080 #ifndef SQLCIPHER_OMIT_QUICKBALANCE
56081         if( pPage->hasData
56082          && pPage->nOverflow==1
56083          && pPage->aOvfl[0].idx==pPage->nCell
56084          && pParent->pgno!=1
56085          && pParent->nCell==iIdx
56086         ){
56087           /* Call balance_quick() to create a new sibling of pPage on which
56088           ** to store the overflow cell. balance_quick() inserts a new cell
56089           ** into pParent, which may cause pParent overflow. If this
56090           ** happens, the next interation of the do-loop will balance pParent 
56091           ** use either balance_nonroot() or balance_deeper(). Until this
56092           ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
56093           ** buffer. 
56094           **
56095           ** The purpose of the following assert() is to check that only a
56096           ** single call to balance_quick() is made for each call to this
56097           ** function. If this were not verified, a subtle bug involving reuse
56098           ** of the aBalanceQuickSpace[] might sneak in.
56099           */
56100           assert( (balance_quick_called++)==0 );
56101           rc = balance_quick(pParent, pPage, aBalanceQuickSpace);
56102         }else
56103 #endif
56104         {
56105           /* In this case, call balance_nonroot() to redistribute cells
56106           ** between pPage and up to 2 of its sibling pages. This involves
56107           ** modifying the contents of pParent, which may cause pParent to
56108           ** become overfull or underfull. The next iteration of the do-loop
56109           ** will balance the parent page to correct this.
56110           ** 
56111           ** If the parent page becomes overfull, the overflow cell or cells
56112           ** are stored in the pSpace buffer allocated immediately below. 
56113           ** A subsequent iteration of the do-loop will deal with this by
56114           ** calling balance_nonroot() (balance_deeper() may be called first,
56115           ** but it doesn't deal with overflow cells - just moves them to a
56116           ** different page). Once this subsequent call to balance_nonroot() 
56117           ** has completed, it is safe to release the pSpace buffer used by
56118           ** the previous call, as the overflow cell data will have been 
56119           ** copied either into the body of a database page or into the new
56120           ** pSpace buffer passed to the latter call to balance_nonroot().
56121           */
56122           u8 *pSpace = sqlcipher3PageMalloc(pCur->pBt->pageSize);
56123           rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1);
56124           if( pFree ){
56125             /* If pFree is not NULL, it points to the pSpace buffer used 
56126             ** by a previous call to balance_nonroot(). Its contents are
56127             ** now stored either on real database pages or within the 
56128             ** new pSpace buffer, so it may be safely freed here. */
56129             sqlcipher3PageFree(pFree);
56130           }
56131
56132           /* The pSpace buffer will be freed after the next call to
56133           ** balance_nonroot(), or just before this function returns, whichever
56134           ** comes first. */
56135           pFree = pSpace;
56136         }
56137       }
56138
56139       pPage->nOverflow = 0;
56140
56141       /* The next iteration of the do-loop balances the parent page. */
56142       releasePage(pPage);
56143       pCur->iPage--;
56144     }
56145   }while( rc==SQLCIPHER_OK );
56146
56147   if( pFree ){
56148     sqlcipher3PageFree(pFree);
56149   }
56150   return rc;
56151 }
56152
56153
56154 /*
56155 ** Insert a new record into the BTree.  The key is given by (pKey,nKey)
56156 ** and the data is given by (pData,nData).  The cursor is used only to
56157 ** define what table the record should be inserted into.  The cursor
56158 ** is left pointing at a random location.
56159 **
56160 ** For an INTKEY table, only the nKey value of the key is used.  pKey is
56161 ** ignored.  For a ZERODATA table, the pData and nData are both ignored.
56162 **
56163 ** If the seekResult parameter is non-zero, then a successful call to
56164 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
56165 ** been performed. seekResult is the search result returned (a negative
56166 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
56167 ** a positive value if pCur points at an etry that is larger than 
56168 ** (pKey, nKey)). 
56169 **
56170 ** If the seekResult parameter is non-zero, then the caller guarantees that
56171 ** cursor pCur is pointing at the existing copy of a row that is to be
56172 ** overwritten.  If the seekResult parameter is 0, then cursor pCur may
56173 ** point to any entry or to no entry at all and so this function has to seek
56174 ** the cursor before the new key can be inserted.
56175 */
56176 SQLCIPHER_PRIVATE int sqlcipher3BtreeInsert(
56177   BtCursor *pCur,                /* Insert data into the table of this cursor */
56178   const void *pKey, i64 nKey,    /* The key of the new record */
56179   const void *pData, int nData,  /* The data of the new record */
56180   int nZero,                     /* Number of extra 0 bytes to append to data */
56181   int appendBias,                /* True if this is likely an append */
56182   int seekResult                 /* Result of prior MovetoUnpacked() call */
56183 ){
56184   int rc;
56185   int loc = seekResult;          /* -1: before desired location  +1: after */
56186   int szNew = 0;
56187   int idx;
56188   MemPage *pPage;
56189   Btree *p = pCur->pBtree;
56190   BtShared *pBt = p->pBt;
56191   unsigned char *oldCell;
56192   unsigned char *newCell = 0;
56193
56194   if( pCur->eState==CURSOR_FAULT ){
56195     assert( pCur->skipNext!=SQLCIPHER_OK );
56196     return pCur->skipNext;
56197   }
56198
56199   assert( cursorHoldsMutex(pCur) );
56200   assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE && !pBt->readOnly );
56201   assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
56202
56203   /* Assert that the caller has been consistent. If this cursor was opened
56204   ** expecting an index b-tree, then the caller should be inserting blob
56205   ** keys with no associated data. If the cursor was opened expecting an
56206   ** intkey table, the caller should be inserting integer keys with a
56207   ** blob of associated data.  */
56208   assert( (pKey==0)==(pCur->pKeyInfo==0) );
56209
56210   /* If this is an insert into a table b-tree, invalidate any incrblob 
56211   ** cursors open on the row being replaced (assuming this is a replace
56212   ** operation - if it is not, the following is a no-op).  */
56213   if( pCur->pKeyInfo==0 ){
56214     invalidateIncrblobCursors(p, nKey, 0);
56215   }
56216
56217   /* Save the positions of any other cursors open on this table.
56218   **
56219   ** In some cases, the call to btreeMoveto() below is a no-op. For
56220   ** example, when inserting data into a table with auto-generated integer
56221   ** keys, the VDBE layer invokes sqlcipher3BtreeLast() to figure out the 
56222   ** integer key to use. It then calls this function to actually insert the 
56223   ** data into the intkey B-Tree. In this case btreeMoveto() recognizes
56224   ** that the cursor is already where it needs to be and returns without
56225   ** doing any work. To avoid thwarting these optimizations, it is important
56226   ** not to clear the cursor here.
56227   */
56228   rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
56229   if( rc ) return rc;
56230   if( !loc ){
56231     rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
56232     if( rc ) return rc;
56233   }
56234   assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
56235
56236   pPage = pCur->apPage[pCur->iPage];
56237   assert( pPage->intKey || nKey>=0 );
56238   assert( pPage->leaf || !pPage->intKey );
56239
56240   TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
56241           pCur->pgnoRoot, nKey, nData, pPage->pgno,
56242           loc==0 ? "overwrite" : "new entry"));
56243   assert( pPage->isInit );
56244   allocateTempSpace(pBt);
56245   newCell = pBt->pTmpSpace;
56246   if( newCell==0 ) return SQLCIPHER_NOMEM;
56247   rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
56248   if( rc ) goto end_insert;
56249   assert( szNew==cellSizePtr(pPage, newCell) );
56250   assert( szNew <= MX_CELL_SIZE(pBt) );
56251   idx = pCur->aiIdx[pCur->iPage];
56252   if( loc==0 ){
56253     u16 szOld;
56254     assert( idx<pPage->nCell );
56255     rc = sqlcipher3PagerWrite(pPage->pDbPage);
56256     if( rc ){
56257       goto end_insert;
56258     }
56259     oldCell = findCell(pPage, idx);
56260     if( !pPage->leaf ){
56261       memcpy(newCell, oldCell, 4);
56262     }
56263     szOld = cellSizePtr(pPage, oldCell);
56264     rc = clearCell(pPage, oldCell);
56265     dropCell(pPage, idx, szOld, &rc);
56266     if( rc ) goto end_insert;
56267   }else if( loc<0 && pPage->nCell>0 ){
56268     assert( pPage->leaf );
56269     idx = ++pCur->aiIdx[pCur->iPage];
56270   }else{
56271     assert( pPage->leaf );
56272   }
56273   insertCell(pPage, idx, newCell, szNew, 0, 0, &rc);
56274   assert( rc!=SQLCIPHER_OK || pPage->nCell>0 || pPage->nOverflow>0 );
56275
56276   /* If no error has occured and pPage has an overflow cell, call balance() 
56277   ** to redistribute the cells within the tree. Since balance() may move
56278   ** the cursor, zero the BtCursor.info.nSize and BtCursor.validNKey
56279   ** variables.
56280   **
56281   ** Previous versions of SQLite called moveToRoot() to move the cursor
56282   ** back to the root page as balance() used to invalidate the contents
56283   ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that,
56284   ** set the cursor state to "invalid". This makes common insert operations
56285   ** slightly faster.
56286   **
56287   ** There is a subtle but important optimization here too. When inserting
56288   ** multiple records into an intkey b-tree using a single cursor (as can
56289   ** happen while processing an "INSERT INTO ... SELECT" statement), it
56290   ** is advantageous to leave the cursor pointing to the last entry in
56291   ** the b-tree if possible. If the cursor is left pointing to the last
56292   ** entry in the table, and the next row inserted has an integer key
56293   ** larger than the largest existing key, it is possible to insert the
56294   ** row without seeking the cursor. This can be a big performance boost.
56295   */
56296   pCur->info.nSize = 0;
56297   pCur->validNKey = 0;
56298   if( rc==SQLCIPHER_OK && pPage->nOverflow ){
56299     rc = balance(pCur);
56300
56301     /* Must make sure nOverflow is reset to zero even if the balance()
56302     ** fails. Internal data structure corruption will result otherwise. 
56303     ** Also, set the cursor state to invalid. This stops saveCursorPosition()
56304     ** from trying to save the current position of the cursor.  */
56305     pCur->apPage[pCur->iPage]->nOverflow = 0;
56306     pCur->eState = CURSOR_INVALID;
56307   }
56308   assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
56309
56310 end_insert:
56311   return rc;
56312 }
56313
56314 /*
56315 ** Delete the entry that the cursor is pointing to.  The cursor
56316 ** is left pointing at a arbitrary location.
56317 */
56318 SQLCIPHER_PRIVATE int sqlcipher3BtreeDelete(BtCursor *pCur){
56319   Btree *p = pCur->pBtree;
56320   BtShared *pBt = p->pBt;              
56321   int rc;                              /* Return code */
56322   MemPage *pPage;                      /* Page to delete cell from */
56323   unsigned char *pCell;                /* Pointer to cell to delete */
56324   int iCellIdx;                        /* Index of cell to delete */
56325   int iCellDepth;                      /* Depth of node containing pCell */ 
56326
56327   assert( cursorHoldsMutex(pCur) );
56328   assert( pBt->inTransaction==TRANS_WRITE );
56329   assert( !pBt->readOnly );
56330   assert( pCur->wrFlag );
56331   assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
56332   assert( !hasReadConflicts(p, pCur->pgnoRoot) );
56333
56334   if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell) 
56335    || NEVER(pCur->eState!=CURSOR_VALID)
56336   ){
56337     return SQLCIPHER_ERROR;  /* Something has gone awry. */
56338   }
56339
56340   /* If this is a delete operation to remove a row from a table b-tree,
56341   ** invalidate any incrblob cursors open on the row being deleted.  */
56342   if( pCur->pKeyInfo==0 ){
56343     invalidateIncrblobCursors(p, pCur->info.nKey, 0);
56344   }
56345
56346   iCellDepth = pCur->iPage;
56347   iCellIdx = pCur->aiIdx[iCellDepth];
56348   pPage = pCur->apPage[iCellDepth];
56349   pCell = findCell(pPage, iCellIdx);
56350
56351   /* If the page containing the entry to delete is not a leaf page, move
56352   ** the cursor to the largest entry in the tree that is smaller than
56353   ** the entry being deleted. This cell will replace the cell being deleted
56354   ** from the internal node. The 'previous' entry is used for this instead
56355   ** of the 'next' entry, as the previous entry is always a part of the
56356   ** sub-tree headed by the child page of the cell being deleted. This makes
56357   ** balancing the tree following the delete operation easier.  */
56358   if( !pPage->leaf ){
56359     int notUsed;
56360     rc = sqlcipher3BtreePrevious(pCur, &notUsed);
56361     if( rc ) return rc;
56362   }
56363
56364   /* Save the positions of any other cursors open on this table before
56365   ** making any modifications. Make the page containing the entry to be 
56366   ** deleted writable. Then free any overflow pages associated with the 
56367   ** entry and finally remove the cell itself from within the page.  
56368   */
56369   rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
56370   if( rc ) return rc;
56371   rc = sqlcipher3PagerWrite(pPage->pDbPage);
56372   if( rc ) return rc;
56373   rc = clearCell(pPage, pCell);
56374   dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
56375   if( rc ) return rc;
56376
56377   /* If the cell deleted was not located on a leaf page, then the cursor
56378   ** is currently pointing to the largest entry in the sub-tree headed
56379   ** by the child-page of the cell that was just deleted from an internal
56380   ** node. The cell from the leaf node needs to be moved to the internal
56381   ** node to replace the deleted cell.  */
56382   if( !pPage->leaf ){
56383     MemPage *pLeaf = pCur->apPage[pCur->iPage];
56384     int nCell;
56385     Pgno n = pCur->apPage[iCellDepth+1]->pgno;
56386     unsigned char *pTmp;
56387
56388     pCell = findCell(pLeaf, pLeaf->nCell-1);
56389     nCell = cellSizePtr(pLeaf, pCell);
56390     assert( MX_CELL_SIZE(pBt) >= nCell );
56391
56392     allocateTempSpace(pBt);
56393     pTmp = pBt->pTmpSpace;
56394
56395     rc = sqlcipher3PagerWrite(pLeaf->pDbPage);
56396     insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
56397     dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
56398     if( rc ) return rc;
56399   }
56400
56401   /* Balance the tree. If the entry deleted was located on a leaf page,
56402   ** then the cursor still points to that page. In this case the first
56403   ** call to balance() repairs the tree, and the if(...) condition is
56404   ** never true.
56405   **
56406   ** Otherwise, if the entry deleted was on an internal node page, then
56407   ** pCur is pointing to the leaf page from which a cell was removed to
56408   ** replace the cell deleted from the internal node. This is slightly
56409   ** tricky as the leaf node may be underfull, and the internal node may
56410   ** be either under or overfull. In this case run the balancing algorithm
56411   ** on the leaf node first. If the balance proceeds far enough up the
56412   ** tree that we can be sure that any problem in the internal node has
56413   ** been corrected, so be it. Otherwise, after balancing the leaf node,
56414   ** walk the cursor up the tree to the internal node and balance it as 
56415   ** well.  */
56416   rc = balance(pCur);
56417   if( rc==SQLCIPHER_OK && pCur->iPage>iCellDepth ){
56418     while( pCur->iPage>iCellDepth ){
56419       releasePage(pCur->apPage[pCur->iPage--]);
56420     }
56421     rc = balance(pCur);
56422   }
56423
56424   if( rc==SQLCIPHER_OK ){
56425     moveToRoot(pCur);
56426   }
56427   return rc;
56428 }
56429
56430 /*
56431 ** Create a new BTree table.  Write into *piTable the page
56432 ** number for the root page of the new table.
56433 **
56434 ** The type of type is determined by the flags parameter.  Only the
56435 ** following values of flags are currently in use.  Other values for
56436 ** flags might not work:
56437 **
56438 **     BTREE_INTKEY|BTREE_LEAFDATA     Used for SQL tables with rowid keys
56439 **     BTREE_ZERODATA                  Used for SQL indices
56440 */
56441 static int btreeCreateTable(Btree *p, int *piTable, int createTabFlags){
56442   BtShared *pBt = p->pBt;
56443   MemPage *pRoot;
56444   Pgno pgnoRoot;
56445   int rc;
56446   int ptfFlags;          /* Page-type flage for the root page of new table */
56447
56448   assert( sqlcipher3BtreeHoldsMutex(p) );
56449   assert( pBt->inTransaction==TRANS_WRITE );
56450   assert( !pBt->readOnly );
56451
56452 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
56453   rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
56454   if( rc ){
56455     return rc;
56456   }
56457 #else
56458   if( pBt->autoVacuum ){
56459     Pgno pgnoMove;      /* Move a page here to make room for the root-page */
56460     MemPage *pPageMove; /* The page to move to. */
56461
56462     /* Creating a new table may probably require moving an existing database
56463     ** to make room for the new tables root page. In case this page turns
56464     ** out to be an overflow page, delete all overflow page-map caches
56465     ** held by open cursors.
56466     */
56467     invalidateAllOverflowCache(pBt);
56468
56469     /* Read the value of meta[3] from the database to determine where the
56470     ** root page of the new table should go. meta[3] is the largest root-page
56471     ** created so far, so the new root-page is (meta[3]+1).
56472     */
56473     sqlcipher3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot);
56474     pgnoRoot++;
56475
56476     /* The new root-page may not be allocated on a pointer-map page, or the
56477     ** PENDING_BYTE page.
56478     */
56479     while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
56480         pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
56481       pgnoRoot++;
56482     }
56483     assert( pgnoRoot>=3 );
56484
56485     /* Allocate a page. The page that currently resides at pgnoRoot will
56486     ** be moved to the allocated page (unless the allocated page happens
56487     ** to reside at pgnoRoot).
56488     */
56489     rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
56490     if( rc!=SQLCIPHER_OK ){
56491       return rc;
56492     }
56493
56494     if( pgnoMove!=pgnoRoot ){
56495       /* pgnoRoot is the page that will be used for the root-page of
56496       ** the new table (assuming an error did not occur). But we were
56497       ** allocated pgnoMove. If required (i.e. if it was not allocated
56498       ** by extending the file), the current page at position pgnoMove
56499       ** is already journaled.
56500       */
56501       u8 eType = 0;
56502       Pgno iPtrPage = 0;
56503
56504       releasePage(pPageMove);
56505
56506       /* Move the page currently at pgnoRoot to pgnoMove. */
56507       rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
56508       if( rc!=SQLCIPHER_OK ){
56509         return rc;
56510       }
56511       rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
56512       if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
56513         rc = SQLCIPHER_CORRUPT_BKPT;
56514       }
56515       if( rc!=SQLCIPHER_OK ){
56516         releasePage(pRoot);
56517         return rc;
56518       }
56519       assert( eType!=PTRMAP_ROOTPAGE );
56520       assert( eType!=PTRMAP_FREEPAGE );
56521       rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
56522       releasePage(pRoot);
56523
56524       /* Obtain the page at pgnoRoot */
56525       if( rc!=SQLCIPHER_OK ){
56526         return rc;
56527       }
56528       rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
56529       if( rc!=SQLCIPHER_OK ){
56530         return rc;
56531       }
56532       rc = sqlcipher3PagerWrite(pRoot->pDbPage);
56533       if( rc!=SQLCIPHER_OK ){
56534         releasePage(pRoot);
56535         return rc;
56536       }
56537     }else{
56538       pRoot = pPageMove;
56539     } 
56540
56541     /* Update the pointer-map and meta-data with the new root-page number. */
56542     ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
56543     if( rc ){
56544       releasePage(pRoot);
56545       return rc;
56546     }
56547
56548     /* When the new root page was allocated, page 1 was made writable in
56549     ** order either to increase the database filesize, or to decrement the
56550     ** freelist count.  Hence, the sqlcipher3BtreeUpdateMeta() call cannot fail.
56551     */
56552     assert( sqlcipher3PagerIswriteable(pBt->pPage1->pDbPage) );
56553     rc = sqlcipher3BtreeUpdateMeta(p, 4, pgnoRoot);
56554     if( NEVER(rc) ){
56555       releasePage(pRoot);
56556       return rc;
56557     }
56558
56559   }else{
56560     rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
56561     if( rc ) return rc;
56562   }
56563 #endif
56564   assert( sqlcipher3PagerIswriteable(pRoot->pDbPage) );
56565   if( createTabFlags & BTREE_INTKEY ){
56566     ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF;
56567   }else{
56568     ptfFlags = PTF_ZERODATA | PTF_LEAF;
56569   }
56570   zeroPage(pRoot, ptfFlags);
56571   sqlcipher3PagerUnref(pRoot->pDbPage);
56572   assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
56573   *piTable = (int)pgnoRoot;
56574   return SQLCIPHER_OK;
56575 }
56576 SQLCIPHER_PRIVATE int sqlcipher3BtreeCreateTable(Btree *p, int *piTable, int flags){
56577   int rc;
56578   sqlcipher3BtreeEnter(p);
56579   rc = btreeCreateTable(p, piTable, flags);
56580   sqlcipher3BtreeLeave(p);
56581   return rc;
56582 }
56583
56584 /*
56585 ** Erase the given database page and all its children.  Return
56586 ** the page to the freelist.
56587 */
56588 static int clearDatabasePage(
56589   BtShared *pBt,           /* The BTree that contains the table */
56590   Pgno pgno,               /* Page number to clear */
56591   int freePageFlag,        /* Deallocate page if true */
56592   int *pnChange            /* Add number of Cells freed to this counter */
56593 ){
56594   MemPage *pPage;
56595   int rc;
56596   unsigned char *pCell;
56597   int i;
56598
56599   assert( sqlcipher3_mutex_held(pBt->mutex) );
56600   if( pgno>btreePagecount(pBt) ){
56601     return SQLCIPHER_CORRUPT_BKPT;
56602   }
56603
56604   rc = getAndInitPage(pBt, pgno, &pPage);
56605   if( rc ) return rc;
56606   for(i=0; i<pPage->nCell; i++){
56607     pCell = findCell(pPage, i);
56608     if( !pPage->leaf ){
56609       rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
56610       if( rc ) goto cleardatabasepage_out;
56611     }
56612     rc = clearCell(pPage, pCell);
56613     if( rc ) goto cleardatabasepage_out;
56614   }
56615   if( !pPage->leaf ){
56616     rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), 1, pnChange);
56617     if( rc ) goto cleardatabasepage_out;
56618   }else if( pnChange ){
56619     assert( pPage->intKey );
56620     *pnChange += pPage->nCell;
56621   }
56622   if( freePageFlag ){
56623     freePage(pPage, &rc);
56624   }else if( (rc = sqlcipher3PagerWrite(pPage->pDbPage))==0 ){
56625     zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
56626   }
56627
56628 cleardatabasepage_out:
56629   releasePage(pPage);
56630   return rc;
56631 }
56632
56633 /*
56634 ** Delete all information from a single table in the database.  iTable is
56635 ** the page number of the root of the table.  After this routine returns,
56636 ** the root page is empty, but still exists.
56637 **
56638 ** This routine will fail with SQLCIPHER_LOCKED if there are any open
56639 ** read cursors on the table.  Open write cursors are moved to the
56640 ** root of the table.
56641 **
56642 ** If pnChange is not NULL, then table iTable must be an intkey table. The
56643 ** integer value pointed to by pnChange is incremented by the number of
56644 ** entries in the table.
56645 */
56646 SQLCIPHER_PRIVATE int sqlcipher3BtreeClearTable(Btree *p, int iTable, int *pnChange){
56647   int rc;
56648   BtShared *pBt = p->pBt;
56649   sqlcipher3BtreeEnter(p);
56650   assert( p->inTrans==TRANS_WRITE );
56651
56652   /* Invalidate all incrblob cursors open on table iTable (assuming iTable
56653   ** is the root of a table b-tree - if it is not, the following call is
56654   ** a no-op).  */
56655   invalidateIncrblobCursors(p, 0, 1);
56656
56657   rc = saveAllCursors(pBt, (Pgno)iTable, 0);
56658   if( SQLCIPHER_OK==rc ){
56659     rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
56660   }
56661   sqlcipher3BtreeLeave(p);
56662   return rc;
56663 }
56664
56665 /*
56666 ** Erase all information in a table and add the root of the table to
56667 ** the freelist.  Except, the root of the principle table (the one on
56668 ** page 1) is never added to the freelist.
56669 **
56670 ** This routine will fail with SQLCIPHER_LOCKED if there are any open
56671 ** cursors on the table.
56672 **
56673 ** If AUTOVACUUM is enabled and the page at iTable is not the last
56674 ** root page in the database file, then the last root page 
56675 ** in the database file is moved into the slot formerly occupied by
56676 ** iTable and that last slot formerly occupied by the last root page
56677 ** is added to the freelist instead of iTable.  In this say, all
56678 ** root pages are kept at the beginning of the database file, which
56679 ** is necessary for AUTOVACUUM to work right.  *piMoved is set to the 
56680 ** page number that used to be the last root page in the file before
56681 ** the move.  If no page gets moved, *piMoved is set to 0.
56682 ** The last root page is recorded in meta[3] and the value of
56683 ** meta[3] is updated by this procedure.
56684 */
56685 static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
56686   int rc;
56687   MemPage *pPage = 0;
56688   BtShared *pBt = p->pBt;
56689
56690   assert( sqlcipher3BtreeHoldsMutex(p) );
56691   assert( p->inTrans==TRANS_WRITE );
56692
56693   /* It is illegal to drop a table if any cursors are open on the
56694   ** database. This is because in auto-vacuum mode the backend may
56695   ** need to move another root-page to fill a gap left by the deleted
56696   ** root page. If an open cursor was using this page a problem would 
56697   ** occur.
56698   **
56699   ** This error is caught long before control reaches this point.
56700   */
56701   if( NEVER(pBt->pCursor) ){
56702     sqlcipher3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
56703     return SQLCIPHER_LOCKED_SHAREDCACHE;
56704   }
56705
56706   rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
56707   if( rc ) return rc;
56708   rc = sqlcipher3BtreeClearTable(p, iTable, 0);
56709   if( rc ){
56710     releasePage(pPage);
56711     return rc;
56712   }
56713
56714   *piMoved = 0;
56715
56716   if( iTable>1 ){
56717 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
56718     freePage(pPage, &rc);
56719     releasePage(pPage);
56720 #else
56721     if( pBt->autoVacuum ){
56722       Pgno maxRootPgno;
56723       sqlcipher3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
56724
56725       if( iTable==maxRootPgno ){
56726         /* If the table being dropped is the table with the largest root-page
56727         ** number in the database, put the root page on the free list. 
56728         */
56729         freePage(pPage, &rc);
56730         releasePage(pPage);
56731         if( rc!=SQLCIPHER_OK ){
56732           return rc;
56733         }
56734       }else{
56735         /* The table being dropped does not have the largest root-page
56736         ** number in the database. So move the page that does into the 
56737         ** gap left by the deleted root-page.
56738         */
56739         MemPage *pMove;
56740         releasePage(pPage);
56741         rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
56742         if( rc!=SQLCIPHER_OK ){
56743           return rc;
56744         }
56745         rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
56746         releasePage(pMove);
56747         if( rc!=SQLCIPHER_OK ){
56748           return rc;
56749         }
56750         pMove = 0;
56751         rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
56752         freePage(pMove, &rc);
56753         releasePage(pMove);
56754         if( rc!=SQLCIPHER_OK ){
56755           return rc;
56756         }
56757         *piMoved = maxRootPgno;
56758       }
56759
56760       /* Set the new 'max-root-page' value in the database header. This
56761       ** is the old value less one, less one more if that happens to
56762       ** be a root-page number, less one again if that is the
56763       ** PENDING_BYTE_PAGE.
56764       */
56765       maxRootPgno--;
56766       while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
56767              || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
56768         maxRootPgno--;
56769       }
56770       assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
56771
56772       rc = sqlcipher3BtreeUpdateMeta(p, 4, maxRootPgno);
56773     }else{
56774       freePage(pPage, &rc);
56775       releasePage(pPage);
56776     }
56777 #endif
56778   }else{
56779     /* If sqlcipher3BtreeDropTable was called on page 1.
56780     ** This really never should happen except in a corrupt
56781     ** database. 
56782     */
56783     zeroPage(pPage, PTF_INTKEY|PTF_LEAF );
56784     releasePage(pPage);
56785   }
56786   return rc;  
56787 }
56788 SQLCIPHER_PRIVATE int sqlcipher3BtreeDropTable(Btree *p, int iTable, int *piMoved){
56789   int rc;
56790   sqlcipher3BtreeEnter(p);
56791   rc = btreeDropTable(p, iTable, piMoved);
56792   sqlcipher3BtreeLeave(p);
56793   return rc;
56794 }
56795
56796
56797 /*
56798 ** This function may only be called if the b-tree connection already
56799 ** has a read or write transaction open on the database.
56800 **
56801 ** Read the meta-information out of a database file.  Meta[0]
56802 ** is the number of free pages currently in the database.  Meta[1]
56803 ** through meta[15] are available for use by higher layers.  Meta[0]
56804 ** is read-only, the others are read/write.
56805 ** 
56806 ** The schema layer numbers meta values differently.  At the schema
56807 ** layer (and the SetCookie and ReadCookie opcodes) the number of
56808 ** free pages is not visible.  So Cookie[0] is the same as Meta[1].
56809 */
56810 SQLCIPHER_PRIVATE void sqlcipher3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
56811   BtShared *pBt = p->pBt;
56812
56813   sqlcipher3BtreeEnter(p);
56814   assert( p->inTrans>TRANS_NONE );
56815   assert( SQLCIPHER_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
56816   assert( pBt->pPage1 );
56817   assert( idx>=0 && idx<=15 );
56818
56819   *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
56820
56821   /* If auto-vacuum is disabled in this build and this is an auto-vacuum
56822   ** database, mark the database as read-only.  */
56823 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
56824   if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ) pBt->readOnly = 1;
56825 #endif
56826
56827   sqlcipher3BtreeLeave(p);
56828 }
56829
56830 /*
56831 ** Write meta-information back into the database.  Meta[0] is
56832 ** read-only and may not be written.
56833 */
56834 SQLCIPHER_PRIVATE int sqlcipher3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
56835   BtShared *pBt = p->pBt;
56836   unsigned char *pP1;
56837   int rc;
56838   assert( idx>=1 && idx<=15 );
56839   sqlcipher3BtreeEnter(p);
56840   assert( p->inTrans==TRANS_WRITE );
56841   assert( pBt->pPage1!=0 );
56842   pP1 = pBt->pPage1->aData;
56843   rc = sqlcipher3PagerWrite(pBt->pPage1->pDbPage);
56844   if( rc==SQLCIPHER_OK ){
56845     put4byte(&pP1[36 + idx*4], iMeta);
56846 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
56847     if( idx==BTREE_INCR_VACUUM ){
56848       assert( pBt->autoVacuum || iMeta==0 );
56849       assert( iMeta==0 || iMeta==1 );
56850       pBt->incrVacuum = (u8)iMeta;
56851     }
56852 #endif
56853   }
56854   sqlcipher3BtreeLeave(p);
56855   return rc;
56856 }
56857
56858 #ifndef SQLCIPHER_OMIT_BTREECOUNT
56859 /*
56860 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
56861 ** number of entries in the b-tree and write the result to *pnEntry.
56862 **
56863 ** SQLCIPHER_OK is returned if the operation is successfully executed. 
56864 ** Otherwise, if an error is encountered (i.e. an IO error or database
56865 ** corruption) an SQLite error code is returned.
56866 */
56867 SQLCIPHER_PRIVATE int sqlcipher3BtreeCount(BtCursor *pCur, i64 *pnEntry){
56868   i64 nEntry = 0;                      /* Value to return in *pnEntry */
56869   int rc;                              /* Return code */
56870
56871   if( pCur->pgnoRoot==0 ){
56872     *pnEntry = 0;
56873     return SQLCIPHER_OK;
56874   }
56875   rc = moveToRoot(pCur);
56876
56877   /* Unless an error occurs, the following loop runs one iteration for each
56878   ** page in the B-Tree structure (not including overflow pages). 
56879   */
56880   while( rc==SQLCIPHER_OK ){
56881     int iIdx;                          /* Index of child node in parent */
56882     MemPage *pPage;                    /* Current page of the b-tree */
56883
56884     /* If this is a leaf page or the tree is not an int-key tree, then 
56885     ** this page contains countable entries. Increment the entry counter
56886     ** accordingly.
56887     */
56888     pPage = pCur->apPage[pCur->iPage];
56889     if( pPage->leaf || !pPage->intKey ){
56890       nEntry += pPage->nCell;
56891     }
56892
56893     /* pPage is a leaf node. This loop navigates the cursor so that it 
56894     ** points to the first interior cell that it points to the parent of
56895     ** the next page in the tree that has not yet been visited. The
56896     ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
56897     ** of the page, or to the number of cells in the page if the next page
56898     ** to visit is the right-child of its parent.
56899     **
56900     ** If all pages in the tree have been visited, return SQLCIPHER_OK to the
56901     ** caller.
56902     */
56903     if( pPage->leaf ){
56904       do {
56905         if( pCur->iPage==0 ){
56906           /* All pages of the b-tree have been visited. Return successfully. */
56907           *pnEntry = nEntry;
56908           return SQLCIPHER_OK;
56909         }
56910         moveToParent(pCur);
56911       }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
56912
56913       pCur->aiIdx[pCur->iPage]++;
56914       pPage = pCur->apPage[pCur->iPage];
56915     }
56916
56917     /* Descend to the child node of the cell that the cursor currently 
56918     ** points at. This is the right-child if (iIdx==pPage->nCell).
56919     */
56920     iIdx = pCur->aiIdx[pCur->iPage];
56921     if( iIdx==pPage->nCell ){
56922       rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
56923     }else{
56924       rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
56925     }
56926   }
56927
56928   /* An error has occurred. Return an error code. */
56929   return rc;
56930 }
56931 #endif
56932
56933 /*
56934 ** Return the pager associated with a BTree.  This routine is used for
56935 ** testing and debugging only.
56936 */
56937 SQLCIPHER_PRIVATE Pager *sqlcipher3BtreePager(Btree *p){
56938   return p->pBt->pPager;
56939 }
56940
56941 #ifndef SQLCIPHER_OMIT_INTEGRITY_CHECK
56942 /*
56943 ** Append a message to the error message string.
56944 */
56945 static void checkAppendMsg(
56946   IntegrityCk *pCheck,
56947   char *zMsg1,
56948   const char *zFormat,
56949   ...
56950 ){
56951   va_list ap;
56952   if( !pCheck->mxErr ) return;
56953   pCheck->mxErr--;
56954   pCheck->nErr++;
56955   va_start(ap, zFormat);
56956   if( pCheck->errMsg.nChar ){
56957     sqlcipher3StrAccumAppend(&pCheck->errMsg, "\n", 1);
56958   }
56959   if( zMsg1 ){
56960     sqlcipher3StrAccumAppend(&pCheck->errMsg, zMsg1, -1);
56961   }
56962   sqlcipher3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
56963   va_end(ap);
56964   if( pCheck->errMsg.mallocFailed ){
56965     pCheck->mallocFailed = 1;
56966   }
56967 }
56968 #endif /* SQLCIPHER_OMIT_INTEGRITY_CHECK */
56969
56970 #ifndef SQLCIPHER_OMIT_INTEGRITY_CHECK
56971 /*
56972 ** Add 1 to the reference count for page iPage.  If this is the second
56973 ** reference to the page, add an error message to pCheck->zErrMsg.
56974 ** Return 1 if there are 2 ore more references to the page and 0 if
56975 ** if this is the first reference to the page.
56976 **
56977 ** Also check that the page number is in bounds.
56978 */
56979 static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
56980   if( iPage==0 ) return 1;
56981   if( iPage>pCheck->nPage ){
56982     checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
56983     return 1;
56984   }
56985   if( pCheck->anRef[iPage]==1 ){
56986     checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
56987     return 1;
56988   }
56989   return  (pCheck->anRef[iPage]++)>1;
56990 }
56991
56992 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
56993 /*
56994 ** Check that the entry in the pointer-map for page iChild maps to 
56995 ** page iParent, pointer type ptrType. If not, append an error message
56996 ** to pCheck.
56997 */
56998 static void checkPtrmap(
56999   IntegrityCk *pCheck,   /* Integrity check context */
57000   Pgno iChild,           /* Child page number */
57001   u8 eType,              /* Expected pointer map type */
57002   Pgno iParent,          /* Expected pointer map parent page number */
57003   char *zContext         /* Context description (used for error msg) */
57004 ){
57005   int rc;
57006   u8 ePtrmapType = 0;
57007   Pgno iPtrmapParent = 0;
57008
57009   rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
57010   if( rc!=SQLCIPHER_OK ){
57011     if( rc==SQLCIPHER_NOMEM || rc==SQLCIPHER_IOERR_NOMEM ) pCheck->mallocFailed = 1;
57012     checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
57013     return;
57014   }
57015
57016   if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
57017     checkAppendMsg(pCheck, zContext, 
57018       "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", 
57019       iChild, eType, iParent, ePtrmapType, iPtrmapParent);
57020   }
57021 }
57022 #endif
57023
57024 /*
57025 ** Check the integrity of the freelist or of an overflow page list.
57026 ** Verify that the number of pages on the list is N.
57027 */
57028 static void checkList(
57029   IntegrityCk *pCheck,  /* Integrity checking context */
57030   int isFreeList,       /* True for a freelist.  False for overflow page list */
57031   int iPage,            /* Page number for first page in the list */
57032   int N,                /* Expected number of pages in the list */
57033   char *zContext        /* Context for error messages */
57034 ){
57035   int i;
57036   int expected = N;
57037   int iFirst = iPage;
57038   while( N-- > 0 && pCheck->mxErr ){
57039     DbPage *pOvflPage;
57040     unsigned char *pOvflData;
57041     if( iPage<1 ){
57042       checkAppendMsg(pCheck, zContext,
57043          "%d of %d pages missing from overflow list starting at %d",
57044           N+1, expected, iFirst);
57045       break;
57046     }
57047     if( checkRef(pCheck, iPage, zContext) ) break;
57048     if( sqlcipher3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
57049       checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
57050       break;
57051     }
57052     pOvflData = (unsigned char *)sqlcipher3PagerGetData(pOvflPage);
57053     if( isFreeList ){
57054       int n = get4byte(&pOvflData[4]);
57055 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57056       if( pCheck->pBt->autoVacuum ){
57057         checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
57058       }
57059 #endif
57060       if( n>(int)pCheck->pBt->usableSize/4-2 ){
57061         checkAppendMsg(pCheck, zContext,
57062            "freelist leaf count too big on page %d", iPage);
57063         N--;
57064       }else{
57065         for(i=0; i<n; i++){
57066           Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
57067 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57068           if( pCheck->pBt->autoVacuum ){
57069             checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
57070           }
57071 #endif
57072           checkRef(pCheck, iFreePage, zContext);
57073         }
57074         N -= n;
57075       }
57076     }
57077 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57078     else{
57079       /* If this database supports auto-vacuum and iPage is not the last
57080       ** page in this overflow list, check that the pointer-map entry for
57081       ** the following page matches iPage.
57082       */
57083       if( pCheck->pBt->autoVacuum && N>0 ){
57084         i = get4byte(pOvflData);
57085         checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
57086       }
57087     }
57088 #endif
57089     iPage = get4byte(pOvflData);
57090     sqlcipher3PagerUnref(pOvflPage);
57091   }
57092 }
57093 #endif /* SQLCIPHER_OMIT_INTEGRITY_CHECK */
57094
57095 #ifndef SQLCIPHER_OMIT_INTEGRITY_CHECK
57096 /*
57097 ** Do various sanity checks on a single page of a tree.  Return
57098 ** the tree depth.  Root pages return 0.  Parents of root pages
57099 ** return 1, and so forth.
57100 ** 
57101 ** These checks are done:
57102 **
57103 **      1.  Make sure that cells and freeblocks do not overlap
57104 **          but combine to completely cover the page.
57105 **  NO  2.  Make sure cell keys are in order.
57106 **  NO  3.  Make sure no key is less than or equal to zLowerBound.
57107 **  NO  4.  Make sure no key is greater than or equal to zUpperBound.
57108 **      5.  Check the integrity of overflow pages.
57109 **      6.  Recursively call checkTreePage on all children.
57110 **      7.  Verify that the depth of all children is the same.
57111 **      8.  Make sure this page is at least 33% full or else it is
57112 **          the root of the tree.
57113 */
57114 static int checkTreePage(
57115   IntegrityCk *pCheck,  /* Context for the sanity check */
57116   int iPage,            /* Page number of the page to check */
57117   char *zParentContext, /* Parent context */
57118   i64 *pnParentMinKey, 
57119   i64 *pnParentMaxKey
57120 ){
57121   MemPage *pPage;
57122   int i, rc, depth, d2, pgno, cnt;
57123   int hdr, cellStart;
57124   int nCell;
57125   u8 *data;
57126   BtShared *pBt;
57127   int usableSize;
57128   char zContext[100];
57129   char *hit = 0;
57130   i64 nMinKey = 0;
57131   i64 nMaxKey = 0;
57132
57133   sqlcipher3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
57134
57135   /* Check that the page exists
57136   */
57137   pBt = pCheck->pBt;
57138   usableSize = pBt->usableSize;
57139   if( iPage==0 ) return 0;
57140   if( checkRef(pCheck, iPage, zParentContext) ) return 0;
57141   if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
57142     checkAppendMsg(pCheck, zContext,
57143        "unable to get the page. error code=%d", rc);
57144     return 0;
57145   }
57146
57147   /* Clear MemPage.isInit to make sure the corruption detection code in
57148   ** btreeInitPage() is executed.  */
57149   pPage->isInit = 0;
57150   if( (rc = btreeInitPage(pPage))!=0 ){
57151     assert( rc==SQLCIPHER_CORRUPT );  /* The only possible error from InitPage */
57152     checkAppendMsg(pCheck, zContext, 
57153                    "btreeInitPage() returns error code %d", rc);
57154     releasePage(pPage);
57155     return 0;
57156   }
57157
57158   /* Check out all the cells.
57159   */
57160   depth = 0;
57161   for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
57162     u8 *pCell;
57163     u32 sz;
57164     CellInfo info;
57165
57166     /* Check payload overflow pages
57167     */
57168     sqlcipher3_snprintf(sizeof(zContext), zContext,
57169              "On tree page %d cell %d: ", iPage, i);
57170     pCell = findCell(pPage,i);
57171     btreeParseCellPtr(pPage, pCell, &info);
57172     sz = info.nData;
57173     if( !pPage->intKey ) sz += (int)info.nKey;
57174     /* For intKey pages, check that the keys are in order.
57175     */
57176     else if( i==0 ) nMinKey = nMaxKey = info.nKey;
57177     else{
57178       if( info.nKey <= nMaxKey ){
57179         checkAppendMsg(pCheck, zContext, 
57180             "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
57181       }
57182       nMaxKey = info.nKey;
57183     }
57184     assert( sz==info.nPayload );
57185     if( (sz>info.nLocal) 
57186      && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
57187     ){
57188       int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
57189       Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
57190 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57191       if( pBt->autoVacuum ){
57192         checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
57193       }
57194 #endif
57195       checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
57196     }
57197
57198     /* Check sanity of left child page.
57199     */
57200     if( !pPage->leaf ){
57201       pgno = get4byte(pCell);
57202 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57203       if( pBt->autoVacuum ){
57204         checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
57205       }
57206 #endif
57207       d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey);
57208       if( i>0 && d2!=depth ){
57209         checkAppendMsg(pCheck, zContext, "Child page depth differs");
57210       }
57211       depth = d2;
57212     }
57213   }
57214
57215   if( !pPage->leaf ){
57216     pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
57217     sqlcipher3_snprintf(sizeof(zContext), zContext, 
57218                      "On page %d at right child: ", iPage);
57219 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57220     if( pBt->autoVacuum ){
57221       checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
57222     }
57223 #endif
57224     checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
57225   }
57226  
57227   /* For intKey leaf pages, check that the min/max keys are in order
57228   ** with any left/parent/right pages.
57229   */
57230   if( pPage->leaf && pPage->intKey ){
57231     /* if we are a left child page */
57232     if( pnParentMinKey ){
57233       /* if we are the left most child page */
57234       if( !pnParentMaxKey ){
57235         if( nMaxKey > *pnParentMinKey ){
57236           checkAppendMsg(pCheck, zContext, 
57237               "Rowid %lld out of order (max larger than parent min of %lld)",
57238               nMaxKey, *pnParentMinKey);
57239         }
57240       }else{
57241         if( nMinKey <= *pnParentMinKey ){
57242           checkAppendMsg(pCheck, zContext, 
57243               "Rowid %lld out of order (min less than parent min of %lld)",
57244               nMinKey, *pnParentMinKey);
57245         }
57246         if( nMaxKey > *pnParentMaxKey ){
57247           checkAppendMsg(pCheck, zContext, 
57248               "Rowid %lld out of order (max larger than parent max of %lld)",
57249               nMaxKey, *pnParentMaxKey);
57250         }
57251         *pnParentMinKey = nMaxKey;
57252       }
57253     /* else if we're a right child page */
57254     } else if( pnParentMaxKey ){
57255       if( nMinKey <= *pnParentMaxKey ){
57256         checkAppendMsg(pCheck, zContext, 
57257             "Rowid %lld out of order (min less than parent max of %lld)",
57258             nMinKey, *pnParentMaxKey);
57259       }
57260     }
57261   }
57262
57263   /* Check for complete coverage of the page
57264   */
57265   data = pPage->aData;
57266   hdr = pPage->hdrOffset;
57267   hit = sqlcipher3PageMalloc( pBt->pageSize );
57268   if( hit==0 ){
57269     pCheck->mallocFailed = 1;
57270   }else{
57271     int contentOffset = get2byteNotZero(&data[hdr+5]);
57272     assert( contentOffset<=usableSize );  /* Enforced by btreeInitPage() */
57273     memset(hit+contentOffset, 0, usableSize-contentOffset);
57274     memset(hit, 1, contentOffset);
57275     nCell = get2byte(&data[hdr+3]);
57276     cellStart = hdr + 12 - 4*pPage->leaf;
57277     for(i=0; i<nCell; i++){
57278       int pc = get2byte(&data[cellStart+i*2]);
57279       u32 size = 65536;
57280       int j;
57281       if( pc<=usableSize-4 ){
57282         size = cellSizePtr(pPage, &data[pc]);
57283       }
57284       if( (int)(pc+size-1)>=usableSize ){
57285         checkAppendMsg(pCheck, 0, 
57286             "Corruption detected in cell %d on page %d",i,iPage);
57287       }else{
57288         for(j=pc+size-1; j>=pc; j--) hit[j]++;
57289       }
57290     }
57291     i = get2byte(&data[hdr+1]);
57292     while( i>0 ){
57293       int size, j;
57294       assert( i<=usableSize-4 );     /* Enforced by btreeInitPage() */
57295       size = get2byte(&data[i+2]);
57296       assert( i+size<=usableSize );  /* Enforced by btreeInitPage() */
57297       for(j=i+size-1; j>=i; j--) hit[j]++;
57298       j = get2byte(&data[i]);
57299       assert( j==0 || j>i+size );  /* Enforced by btreeInitPage() */
57300       assert( j<=usableSize-4 );   /* Enforced by btreeInitPage() */
57301       i = j;
57302     }
57303     for(i=cnt=0; i<usableSize; i++){
57304       if( hit[i]==0 ){
57305         cnt++;
57306       }else if( hit[i]>1 ){
57307         checkAppendMsg(pCheck, 0,
57308           "Multiple uses for byte %d of page %d", i, iPage);
57309         break;
57310       }
57311     }
57312     if( cnt!=data[hdr+7] ){
57313       checkAppendMsg(pCheck, 0, 
57314           "Fragmentation of %d bytes reported as %d on page %d",
57315           cnt, data[hdr+7], iPage);
57316     }
57317   }
57318   sqlcipher3PageFree(hit);
57319   releasePage(pPage);
57320   return depth+1;
57321 }
57322 #endif /* SQLCIPHER_OMIT_INTEGRITY_CHECK */
57323
57324 #ifndef SQLCIPHER_OMIT_INTEGRITY_CHECK
57325 /*
57326 ** This routine does a complete check of the given BTree file.  aRoot[] is
57327 ** an array of pages numbers were each page number is the root page of
57328 ** a table.  nRoot is the number of entries in aRoot.
57329 **
57330 ** A read-only or read-write transaction must be opened before calling
57331 ** this function.
57332 **
57333 ** Write the number of error seen in *pnErr.  Except for some memory
57334 ** allocation errors,  an error message held in memory obtained from
57335 ** malloc is returned if *pnErr is non-zero.  If *pnErr==0 then NULL is
57336 ** returned.  If a memory allocation error occurs, NULL is returned.
57337 */
57338 SQLCIPHER_PRIVATE char *sqlcipher3BtreeIntegrityCheck(
57339   Btree *p,     /* The btree to be checked */
57340   int *aRoot,   /* An array of root pages numbers for individual trees */
57341   int nRoot,    /* Number of entries in aRoot[] */
57342   int mxErr,    /* Stop reporting errors after this many */
57343   int *pnErr    /* Write number of errors seen to this variable */
57344 ){
57345   Pgno i;
57346   int nRef;
57347   IntegrityCk sCheck;
57348   BtShared *pBt = p->pBt;
57349   char zErr[100];
57350
57351   sqlcipher3BtreeEnter(p);
57352   assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
57353   nRef = sqlcipher3PagerRefcount(pBt->pPager);
57354   sCheck.pBt = pBt;
57355   sCheck.pPager = pBt->pPager;
57356   sCheck.nPage = btreePagecount(sCheck.pBt);
57357   sCheck.mxErr = mxErr;
57358   sCheck.nErr = 0;
57359   sCheck.mallocFailed = 0;
57360   *pnErr = 0;
57361   if( sCheck.nPage==0 ){
57362     sqlcipher3BtreeLeave(p);
57363     return 0;
57364   }
57365   sCheck.anRef = sqlcipher3Malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
57366   if( !sCheck.anRef ){
57367     *pnErr = 1;
57368     sqlcipher3BtreeLeave(p);
57369     return 0;
57370   }
57371   for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
57372   i = PENDING_BYTE_PAGE(pBt);
57373   if( i<=sCheck.nPage ){
57374     sCheck.anRef[i] = 1;
57375   }
57376   sqlcipher3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000);
57377   sCheck.errMsg.useMalloc = 2;
57378
57379   /* Check the integrity of the freelist
57380   */
57381   checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
57382             get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
57383
57384   /* Check all the tables.
57385   */
57386   for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
57387     if( aRoot[i]==0 ) continue;
57388 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
57389     if( pBt->autoVacuum && aRoot[i]>1 ){
57390       checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
57391     }
57392 #endif
57393     checkTreePage(&sCheck, aRoot[i], "List of tree roots: ", NULL, NULL);
57394   }
57395
57396   /* Make sure every page in the file is referenced
57397   */
57398   for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
57399 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
57400     if( sCheck.anRef[i]==0 ){
57401       checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
57402     }
57403 #else
57404     /* If the database supports auto-vacuum, make sure no tables contain
57405     ** references to pointer-map pages.
57406     */
57407     if( sCheck.anRef[i]==0 && 
57408        (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
57409       checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
57410     }
57411     if( sCheck.anRef[i]!=0 && 
57412        (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
57413       checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
57414     }
57415 #endif
57416   }
57417
57418   /* Make sure this analysis did not leave any unref() pages.
57419   ** This is an internal consistency check; an integrity check
57420   ** of the integrity check.
57421   */
57422   if( NEVER(nRef != sqlcipher3PagerRefcount(pBt->pPager)) ){
57423     checkAppendMsg(&sCheck, 0, 
57424       "Outstanding page count goes from %d to %d during this analysis",
57425       nRef, sqlcipher3PagerRefcount(pBt->pPager)
57426     );
57427   }
57428
57429   /* Clean  up and report errors.
57430   */
57431   sqlcipher3BtreeLeave(p);
57432   sqlcipher3_free(sCheck.anRef);
57433   if( sCheck.mallocFailed ){
57434     sqlcipher3StrAccumReset(&sCheck.errMsg);
57435     *pnErr = sCheck.nErr+1;
57436     return 0;
57437   }
57438   *pnErr = sCheck.nErr;
57439   if( sCheck.nErr==0 ) sqlcipher3StrAccumReset(&sCheck.errMsg);
57440   return sqlcipher3StrAccumFinish(&sCheck.errMsg);
57441 }
57442 #endif /* SQLCIPHER_OMIT_INTEGRITY_CHECK */
57443
57444 /*
57445 ** Return the full pathname of the underlying database file.
57446 **
57447 ** The pager filename is invariant as long as the pager is
57448 ** open so it is safe to access without the BtShared mutex.
57449 */
57450 SQLCIPHER_PRIVATE const char *sqlcipher3BtreeGetFilename(Btree *p){
57451   assert( p->pBt->pPager!=0 );
57452   return sqlcipher3PagerFilename(p->pBt->pPager);
57453 }
57454
57455 /*
57456 ** Return the pathname of the journal file for this database. The return
57457 ** value of this routine is the same regardless of whether the journal file
57458 ** has been created or not.
57459 **
57460 ** The pager journal filename is invariant as long as the pager is
57461 ** open so it is safe to access without the BtShared mutex.
57462 */
57463 SQLCIPHER_PRIVATE const char *sqlcipher3BtreeGetJournalname(Btree *p){
57464   assert( p->pBt->pPager!=0 );
57465   return sqlcipher3PagerJournalname(p->pBt->pPager);
57466 }
57467
57468 /*
57469 ** Return non-zero if a transaction is active.
57470 */
57471 SQLCIPHER_PRIVATE int sqlcipher3BtreeIsInTrans(Btree *p){
57472   assert( p==0 || sqlcipher3_mutex_held(p->db->mutex) );
57473   return (p && (p->inTrans==TRANS_WRITE));
57474 }
57475
57476 #ifndef SQLCIPHER_OMIT_WAL
57477 /*
57478 ** Run a checkpoint on the Btree passed as the first argument.
57479 **
57480 ** Return SQLCIPHER_LOCKED if this or any other connection has an open 
57481 ** transaction on the shared-cache the argument Btree is connected to.
57482 **
57483 ** Parameter eMode is one of SQLCIPHER_CHECKPOINT_PASSIVE, FULL or RESTART.
57484 */
57485 SQLCIPHER_PRIVATE int sqlcipher3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){
57486   int rc = SQLCIPHER_OK;
57487   if( p ){
57488     BtShared *pBt = p->pBt;
57489     sqlcipher3BtreeEnter(p);
57490     if( pBt->inTransaction!=TRANS_NONE ){
57491       rc = SQLCIPHER_LOCKED;
57492     }else{
57493       rc = sqlcipher3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
57494     }
57495     sqlcipher3BtreeLeave(p);
57496   }
57497   return rc;
57498 }
57499 #endif
57500
57501 /*
57502 ** Return non-zero if a read (or write) transaction is active.
57503 */
57504 SQLCIPHER_PRIVATE int sqlcipher3BtreeIsInReadTrans(Btree *p){
57505   assert( p );
57506   assert( sqlcipher3_mutex_held(p->db->mutex) );
57507   return p->inTrans!=TRANS_NONE;
57508 }
57509
57510 SQLCIPHER_PRIVATE int sqlcipher3BtreeIsInBackup(Btree *p){
57511   assert( p );
57512   assert( sqlcipher3_mutex_held(p->db->mutex) );
57513   return p->nBackup!=0;
57514 }
57515
57516 /*
57517 ** This function returns a pointer to a blob of memory associated with
57518 ** a single shared-btree. The memory is used by client code for its own
57519 ** purposes (for example, to store a high-level schema associated with 
57520 ** the shared-btree). The btree layer manages reference counting issues.
57521 **
57522 ** The first time this is called on a shared-btree, nBytes bytes of memory
57523 ** are allocated, zeroed, and returned to the caller. For each subsequent 
57524 ** call the nBytes parameter is ignored and a pointer to the same blob
57525 ** of memory returned. 
57526 **
57527 ** If the nBytes parameter is 0 and the blob of memory has not yet been
57528 ** allocated, a null pointer is returned. If the blob has already been
57529 ** allocated, it is returned as normal.
57530 **
57531 ** Just before the shared-btree is closed, the function passed as the 
57532 ** xFree argument when the memory allocation was made is invoked on the 
57533 ** blob of allocated memory. The xFree function should not call sqlcipher3_free()
57534 ** on the memory, the btree layer does that.
57535 */
57536 SQLCIPHER_PRIVATE void *sqlcipher3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
57537   BtShared *pBt = p->pBt;
57538   sqlcipher3BtreeEnter(p);
57539   if( !pBt->pSchema && nBytes ){
57540     pBt->pSchema = sqlcipher3DbMallocZero(0, nBytes);
57541     pBt->xFreeSchema = xFree;
57542   }
57543   sqlcipher3BtreeLeave(p);
57544   return pBt->pSchema;
57545 }
57546
57547 /*
57548 ** Return SQLCIPHER_LOCKED_SHAREDCACHE if another user of the same shared 
57549 ** btree as the argument handle holds an exclusive lock on the 
57550 ** sqlcipher_master table. Otherwise SQLCIPHER_OK.
57551 */
57552 SQLCIPHER_PRIVATE int sqlcipher3BtreeSchemaLocked(Btree *p){
57553   int rc;
57554   assert( sqlcipher3_mutex_held(p->db->mutex) );
57555   sqlcipher3BtreeEnter(p);
57556   rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
57557   assert( rc==SQLCIPHER_OK || rc==SQLCIPHER_LOCKED_SHAREDCACHE );
57558   sqlcipher3BtreeLeave(p);
57559   return rc;
57560 }
57561
57562
57563 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
57564 /*
57565 ** Obtain a lock on the table whose root page is iTab.  The
57566 ** lock is a write lock if isWritelock is true or a read lock
57567 ** if it is false.
57568 */
57569 SQLCIPHER_PRIVATE int sqlcipher3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
57570   int rc = SQLCIPHER_OK;
57571   assert( p->inTrans!=TRANS_NONE );
57572   if( p->sharable ){
57573     u8 lockType = READ_LOCK + isWriteLock;
57574     assert( READ_LOCK+1==WRITE_LOCK );
57575     assert( isWriteLock==0 || isWriteLock==1 );
57576
57577     sqlcipher3BtreeEnter(p);
57578     rc = querySharedCacheTableLock(p, iTab, lockType);
57579     if( rc==SQLCIPHER_OK ){
57580       rc = setSharedCacheTableLock(p, iTab, lockType);
57581     }
57582     sqlcipher3BtreeLeave(p);
57583   }
57584   return rc;
57585 }
57586 #endif
57587
57588 #ifndef SQLCIPHER_OMIT_INCRBLOB
57589 /*
57590 ** Argument pCsr must be a cursor opened for writing on an 
57591 ** INTKEY table currently pointing at a valid table entry. 
57592 ** This function modifies the data stored as part of that entry.
57593 **
57594 ** Only the data content may only be modified, it is not possible to 
57595 ** change the length of the data stored. If this function is called with
57596 ** parameters that attempt to write past the end of the existing data,
57597 ** no modifications are made and SQLCIPHER_CORRUPT is returned.
57598 */
57599 SQLCIPHER_PRIVATE int sqlcipher3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
57600   int rc;
57601   assert( cursorHoldsMutex(pCsr) );
57602   assert( sqlcipher3_mutex_held(pCsr->pBtree->db->mutex) );
57603   assert( pCsr->isIncrblobHandle );
57604
57605   rc = restoreCursorPosition(pCsr);
57606   if( rc!=SQLCIPHER_OK ){
57607     return rc;
57608   }
57609   assert( pCsr->eState!=CURSOR_REQUIRESEEK );
57610   if( pCsr->eState!=CURSOR_VALID ){
57611     return SQLCIPHER_ABORT;
57612   }
57613
57614   /* Check some assumptions: 
57615   **   (a) the cursor is open for writing,
57616   **   (b) there is a read/write transaction open,
57617   **   (c) the connection holds a write-lock on the table (if required),
57618   **   (d) there are no conflicting read-locks, and
57619   **   (e) the cursor points at a valid row of an intKey table.
57620   */
57621   if( !pCsr->wrFlag ){
57622     return SQLCIPHER_READONLY;
57623   }
57624   assert( !pCsr->pBt->readOnly && pCsr->pBt->inTransaction==TRANS_WRITE );
57625   assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
57626   assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
57627   assert( pCsr->apPage[pCsr->iPage]->intKey );
57628
57629   return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
57630 }
57631
57632 /* 
57633 ** Set a flag on this cursor to cache the locations of pages from the 
57634 ** overflow list for the current row. This is used by cursors opened
57635 ** for incremental blob IO only.
57636 **
57637 ** This function sets a flag only. The actual page location cache
57638 ** (stored in BtCursor.aOverflow[]) is allocated and used by function
57639 ** accessPayload() (the worker function for sqlcipher3BtreeData() and
57640 ** sqlcipher3BtreePutData()).
57641 */
57642 SQLCIPHER_PRIVATE void sqlcipher3BtreeCacheOverflow(BtCursor *pCur){
57643   assert( cursorHoldsMutex(pCur) );
57644   assert( sqlcipher3_mutex_held(pCur->pBtree->db->mutex) );
57645   invalidateOverflowCache(pCur);
57646   pCur->isIncrblobHandle = 1;
57647 }
57648 #endif
57649
57650 /*
57651 ** Set both the "read version" (single byte at byte offset 18) and 
57652 ** "write version" (single byte at byte offset 19) fields in the database
57653 ** header to iVersion.
57654 */
57655 SQLCIPHER_PRIVATE int sqlcipher3BtreeSetVersion(Btree *pBtree, int iVersion){
57656   BtShared *pBt = pBtree->pBt;
57657   int rc;                         /* Return code */
57658  
57659   assert( iVersion==1 || iVersion==2 );
57660
57661   /* If setting the version fields to 1, do not automatically open the
57662   ** WAL connection, even if the version fields are currently set to 2.
57663   */
57664   pBt->doNotUseWAL = (u8)(iVersion==1);
57665
57666   rc = sqlcipher3BtreeBeginTrans(pBtree, 0);
57667   if( rc==SQLCIPHER_OK ){
57668     u8 *aData = pBt->pPage1->aData;
57669     if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
57670       rc = sqlcipher3BtreeBeginTrans(pBtree, 2);
57671       if( rc==SQLCIPHER_OK ){
57672         rc = sqlcipher3PagerWrite(pBt->pPage1->pDbPage);
57673         if( rc==SQLCIPHER_OK ){
57674           aData[18] = (u8)iVersion;
57675           aData[19] = (u8)iVersion;
57676         }
57677       }
57678     }
57679   }
57680
57681   pBt->doNotUseWAL = 0;
57682   return rc;
57683 }
57684
57685 /************** End of btree.c ***********************************************/
57686 /************** Begin file backup.c ******************************************/
57687 /*
57688 ** 2009 January 28
57689 **
57690 ** The author disclaims copyright to this source code.  In place of
57691 ** a legal notice, here is a blessing:
57692 **
57693 **    May you do good and not evil.
57694 **    May you find forgiveness for yourself and forgive others.
57695 **    May you share freely, never taking more than you give.
57696 **
57697 *************************************************************************
57698 ** This file contains the implementation of the sqlcipher3_backup_XXX() 
57699 ** API functions and the related features.
57700 */
57701
57702 /* Macro to find the minimum of two numeric values.
57703 */
57704 #ifndef MIN
57705 # define MIN(x,y) ((x)<(y)?(x):(y))
57706 #endif
57707
57708 /*
57709 ** Structure allocated for each backup operation.
57710 */
57711 struct sqlcipher3_backup {
57712   sqlcipher3* pDestDb;        /* Destination database handle */
57713   Btree *pDest;            /* Destination b-tree file */
57714   u32 iDestSchema;         /* Original schema cookie in destination */
57715   int bDestLocked;         /* True once a write-transaction is open on pDest */
57716
57717   Pgno iNext;              /* Page number of the next source page to copy */
57718   sqlcipher3* pSrcDb;         /* Source database handle */
57719   Btree *pSrc;             /* Source b-tree file */
57720
57721   int rc;                  /* Backup process error code */
57722
57723   /* These two variables are set by every call to backup_step(). They are
57724   ** read by calls to backup_remaining() and backup_pagecount().
57725   */
57726   Pgno nRemaining;         /* Number of pages left to copy */
57727   Pgno nPagecount;         /* Total number of pages to copy */
57728
57729   int isAttached;          /* True once backup has been registered with pager */
57730   sqlcipher3_backup *pNext;   /* Next backup associated with source pager */
57731 };
57732
57733 /*
57734 ** THREAD SAFETY NOTES:
57735 **
57736 **   Once it has been created using backup_init(), a single sqlcipher3_backup
57737 **   structure may be accessed via two groups of thread-safe entry points:
57738 **
57739 **     * Via the sqlcipher3_backup_XXX() API function backup_step() and 
57740 **       backup_finish(). Both these functions obtain the source database
57741 **       handle mutex and the mutex associated with the source BtShared 
57742 **       structure, in that order.
57743 **
57744 **     * Via the BackupUpdate() and BackupRestart() functions, which are
57745 **       invoked by the pager layer to report various state changes in
57746 **       the page cache associated with the source database. The mutex
57747 **       associated with the source database BtShared structure will always 
57748 **       be held when either of these functions are invoked.
57749 **
57750 **   The other sqlcipher3_backup_XXX() API functions, backup_remaining() and
57751 **   backup_pagecount() are not thread-safe functions. If they are called
57752 **   while some other thread is calling backup_step() or backup_finish(),
57753 **   the values returned may be invalid. There is no way for a call to
57754 **   BackupUpdate() or BackupRestart() to interfere with backup_remaining()
57755 **   or backup_pagecount().
57756 **
57757 **   Depending on the SQLite configuration, the database handles and/or
57758 **   the Btree objects may have their own mutexes that require locking.
57759 **   Non-sharable Btrees (in-memory databases for example), do not have
57760 **   associated mutexes.
57761 */
57762
57763 /*
57764 ** Return a pointer corresponding to database zDb (i.e. "main", "temp")
57765 ** in connection handle pDb. If such a database cannot be found, return
57766 ** a NULL pointer and write an error message to pErrorDb.
57767 **
57768 ** If the "temp" database is requested, it may need to be opened by this 
57769 ** function. If an error occurs while doing so, return 0 and write an 
57770 ** error message to pErrorDb.
57771 */
57772 static Btree *findBtree(sqlcipher3 *pErrorDb, sqlcipher3 *pDb, const char *zDb){
57773   int i = sqlcipher3FindDbName(pDb, zDb);
57774
57775   if( i==1 ){
57776     Parse *pParse;
57777     int rc = 0;
57778     pParse = sqlcipher3StackAllocZero(pErrorDb, sizeof(*pParse));
57779     if( pParse==0 ){
57780       sqlcipher3Error(pErrorDb, SQLCIPHER_NOMEM, "out of memory");
57781       rc = SQLCIPHER_NOMEM;
57782     }else{
57783       pParse->db = pDb;
57784       if( sqlcipher3OpenTempDatabase(pParse) ){
57785         sqlcipher3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
57786         rc = SQLCIPHER_ERROR;
57787       }
57788       sqlcipher3DbFree(pErrorDb, pParse->zErrMsg);
57789       sqlcipher3StackFree(pErrorDb, pParse);
57790     }
57791     if( rc ){
57792       return 0;
57793     }
57794   }
57795
57796   if( i<0 ){
57797     sqlcipher3Error(pErrorDb, SQLCIPHER_ERROR, "unknown database %s", zDb);
57798     return 0;
57799   }
57800
57801   return pDb->aDb[i].pBt;
57802 }
57803
57804 /*
57805 ** Attempt to set the page size of the destination to match the page size
57806 ** of the source.
57807 */
57808 static int setDestPgsz(sqlcipher3_backup *p){
57809   int rc;
57810   rc = sqlcipher3BtreeSetPageSize(p->pDest,sqlcipher3BtreeGetPageSize(p->pSrc),-1,0);
57811   return rc;
57812 }
57813
57814 /*
57815 ** Create an sqlcipher3_backup process to copy the contents of zSrcDb from
57816 ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
57817 ** a pointer to the new sqlcipher3_backup object.
57818 **
57819 ** If an error occurs, NULL is returned and an error code and error message
57820 ** stored in database handle pDestDb.
57821 */
57822 SQLCIPHER_API sqlcipher3_backup *sqlcipher3_backup_init(
57823   sqlcipher3* pDestDb,                     /* Database to write to */
57824   const char *zDestDb,                  /* Name of database within pDestDb */
57825   sqlcipher3* pSrcDb,                      /* Database connection to read from */
57826   const char *zSrcDb                    /* Name of database within pSrcDb */
57827 ){
57828   sqlcipher3_backup *p;                    /* Value to return */
57829
57830   /* Lock the source database handle. The destination database
57831   ** handle is not locked in this routine, but it is locked in
57832   ** sqlcipher3_backup_step(). The user is required to ensure that no
57833   ** other thread accesses the destination handle for the duration
57834   ** of the backup operation.  Any attempt to use the destination
57835   ** database connection while a backup is in progress may cause
57836   ** a malfunction or a deadlock.
57837   */
57838   sqlcipher3_mutex_enter(pSrcDb->mutex);
57839   sqlcipher3_mutex_enter(pDestDb->mutex);
57840
57841   if( pSrcDb==pDestDb ){
57842     sqlcipher3Error(
57843         pDestDb, SQLCIPHER_ERROR, "source and destination must be distinct"
57844     );
57845     p = 0;
57846   }else {
57847     /* Allocate space for a new sqlcipher3_backup object...
57848     ** EVIDENCE-OF: R-64852-21591 The sqlcipher3_backup object is created by a
57849     ** call to sqlcipher3_backup_init() and is destroyed by a call to
57850     ** sqlcipher3_backup_finish(). */
57851     p = (sqlcipher3_backup *)sqlcipher3_malloc(sizeof(sqlcipher3_backup));
57852     if( !p ){
57853       sqlcipher3Error(pDestDb, SQLCIPHER_NOMEM, 0);
57854     }
57855   }
57856
57857   /* If the allocation succeeded, populate the new object. */
57858   if( p ){
57859     memset(p, 0, sizeof(sqlcipher3_backup));
57860     p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
57861     p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
57862     p->pDestDb = pDestDb;
57863     p->pSrcDb = pSrcDb;
57864     p->iNext = 1;
57865     p->isAttached = 0;
57866
57867     if( 0==p->pSrc || 0==p->pDest || setDestPgsz(p)==SQLCIPHER_NOMEM ){
57868       /* One (or both) of the named databases did not exist or an OOM
57869       ** error was hit.  The error has already been written into the
57870       ** pDestDb handle.  All that is left to do here is free the
57871       ** sqlcipher3_backup structure.
57872       */
57873       sqlcipher3_free(p);
57874       p = 0;
57875     }
57876   }
57877   if( p ){
57878     p->pSrc->nBackup++;
57879   }
57880
57881   sqlcipher3_mutex_leave(pDestDb->mutex);
57882   sqlcipher3_mutex_leave(pSrcDb->mutex);
57883   return p;
57884 }
57885
57886 /*
57887 ** Argument rc is an SQLite error code. Return true if this error is 
57888 ** considered fatal if encountered during a backup operation. All errors
57889 ** are considered fatal except for SQLCIPHER_BUSY and SQLCIPHER_LOCKED.
57890 */
57891 static int isFatalError(int rc){
57892   return (rc!=SQLCIPHER_OK && rc!=SQLCIPHER_BUSY && ALWAYS(rc!=SQLCIPHER_LOCKED));
57893 }
57894
57895 /*
57896 ** Parameter zSrcData points to a buffer containing the data for 
57897 ** page iSrcPg from the source database. Copy this data into the 
57898 ** destination database.
57899 */
57900 static int backupOnePage(sqlcipher3_backup *p, Pgno iSrcPg, const u8 *zSrcData){
57901   Pager * const pDestPager = sqlcipher3BtreePager(p->pDest);
57902   const int nSrcPgsz = sqlcipher3BtreeGetPageSize(p->pSrc);
57903   int nDestPgsz = sqlcipher3BtreeGetPageSize(p->pDest);
57904   const int nCopy = MIN(nSrcPgsz, nDestPgsz);
57905   const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz;
57906 #ifdef SQLCIPHER_HAS_CODEC
57907   int nSrcReserve = sqlcipher3BtreeGetReserve(p->pSrc);
57908   int nDestReserve = sqlcipher3BtreeGetReserve(p->pDest);
57909 #endif
57910
57911   int rc = SQLCIPHER_OK;
57912   i64 iOff;
57913
57914   assert( p->bDestLocked );
57915   assert( !isFatalError(p->rc) );
57916   assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
57917   assert( zSrcData );
57918
57919   /* Catch the case where the destination is an in-memory database and the
57920   ** page sizes of the source and destination differ. 
57921   */
57922   if( nSrcPgsz!=nDestPgsz && sqlcipher3PagerIsMemdb(pDestPager) ){
57923     rc = SQLCIPHER_READONLY;
57924   }
57925
57926 #ifdef SQLCIPHER_HAS_CODEC
57927   /* Backup is not possible if the page size of the destination is changing
57928   ** and a codec is in use.
57929   */
57930   if( nSrcPgsz!=nDestPgsz && sqlcipher3PagerGetCodec(pDestPager)!=0 ){
57931     rc = SQLCIPHER_READONLY;
57932   }
57933
57934   /* Backup is not possible if the number of bytes of reserve space differ
57935   ** between source and destination.  If there is a difference, try to
57936   ** fix the destination to agree with the source.  If that is not possible,
57937   ** then the backup cannot proceed.
57938   */
57939   if( nSrcReserve!=nDestReserve ){
57940     u32 newPgsz = nSrcPgsz;
57941     rc = sqlcipher3PagerSetPagesize(pDestPager, &newPgsz, nSrcReserve);
57942     if( rc==SQLCIPHER_OK && newPgsz!=nSrcPgsz ) rc = SQLCIPHER_READONLY;
57943   }
57944 #endif
57945
57946   /* This loop runs once for each destination page spanned by the source 
57947   ** page. For each iteration, variable iOff is set to the byte offset
57948   ** of the destination page.
57949   */
57950   for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLCIPHER_OK && iOff<iEnd; iOff+=nDestPgsz){
57951     DbPage *pDestPg = 0;
57952     Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
57953     if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
57954     if( SQLCIPHER_OK==(rc = sqlcipher3PagerGet(pDestPager, iDest, &pDestPg))
57955      && SQLCIPHER_OK==(rc = sqlcipher3PagerWrite(pDestPg))
57956     ){
57957       const u8 *zIn = &zSrcData[iOff%nSrcPgsz];
57958       u8 *zDestData = sqlcipher3PagerGetData(pDestPg);
57959       u8 *zOut = &zDestData[iOff%nDestPgsz];
57960
57961       /* Copy the data from the source page into the destination page.
57962       ** Then clear the Btree layer MemPage.isInit flag. Both this module
57963       ** and the pager code use this trick (clearing the first byte
57964       ** of the page 'extra' space to invalidate the Btree layers
57965       ** cached parse of the page). MemPage.isInit is marked 
57966       ** "MUST BE FIRST" for this purpose.
57967       */
57968       memcpy(zOut, zIn, nCopy);
57969       ((u8 *)sqlcipher3PagerGetExtra(pDestPg))[0] = 0;
57970     }
57971     sqlcipher3PagerUnref(pDestPg);
57972   }
57973
57974   return rc;
57975 }
57976
57977 /*
57978 ** If pFile is currently larger than iSize bytes, then truncate it to
57979 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
57980 ** this function is a no-op.
57981 **
57982 ** Return SQLCIPHER_OK if everything is successful, or an SQLite error 
57983 ** code if an error occurs.
57984 */
57985 static int backupTruncateFile(sqlcipher3_file *pFile, i64 iSize){
57986   i64 iCurrent;
57987   int rc = sqlcipher3OsFileSize(pFile, &iCurrent);
57988   if( rc==SQLCIPHER_OK && iCurrent>iSize ){
57989     rc = sqlcipher3OsTruncate(pFile, iSize);
57990   }
57991   return rc;
57992 }
57993
57994 /*
57995 ** Register this backup object with the associated source pager for
57996 ** callbacks when pages are changed or the cache invalidated.
57997 */
57998 static void attachBackupObject(sqlcipher3_backup *p){
57999   sqlcipher3_backup **pp;
58000   assert( sqlcipher3BtreeHoldsMutex(p->pSrc) );
58001   pp = sqlcipher3PagerBackupPtr(sqlcipher3BtreePager(p->pSrc));
58002   p->pNext = *pp;
58003   *pp = p;
58004   p->isAttached = 1;
58005 }
58006
58007 /*
58008 ** Copy nPage pages from the source b-tree to the destination.
58009 */
58010 SQLCIPHER_API int sqlcipher3_backup_step(sqlcipher3_backup *p, int nPage){
58011   int rc;
58012   int destMode;       /* Destination journal mode */
58013   int pgszSrc = 0;    /* Source page size */
58014   int pgszDest = 0;   /* Destination page size */
58015
58016   sqlcipher3_mutex_enter(p->pSrcDb->mutex);
58017   sqlcipher3BtreeEnter(p->pSrc);
58018   if( p->pDestDb ){
58019     sqlcipher3_mutex_enter(p->pDestDb->mutex);
58020   }
58021
58022   rc = p->rc;
58023   if( !isFatalError(rc) ){
58024     Pager * const pSrcPager = sqlcipher3BtreePager(p->pSrc);     /* Source pager */
58025     Pager * const pDestPager = sqlcipher3BtreePager(p->pDest);   /* Dest pager */
58026     int ii;                            /* Iterator variable */
58027     int nSrcPage = -1;                 /* Size of source db in pages */
58028     int bCloseTrans = 0;               /* True if src db requires unlocking */
58029
58030     /* If the source pager is currently in a write-transaction, return
58031     ** SQLCIPHER_BUSY immediately.
58032     */
58033     if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
58034       rc = SQLCIPHER_BUSY;
58035     }else{
58036       rc = SQLCIPHER_OK;
58037     }
58038
58039     /* Lock the destination database, if it is not locked already. */
58040     if( SQLCIPHER_OK==rc && p->bDestLocked==0
58041      && SQLCIPHER_OK==(rc = sqlcipher3BtreeBeginTrans(p->pDest, 2)) 
58042     ){
58043       p->bDestLocked = 1;
58044       sqlcipher3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema);
58045     }
58046
58047     /* If there is no open read-transaction on the source database, open
58048     ** one now. If a transaction is opened here, then it will be closed
58049     ** before this function exits.
58050     */
58051     if( rc==SQLCIPHER_OK && 0==sqlcipher3BtreeIsInReadTrans(p->pSrc) ){
58052       rc = sqlcipher3BtreeBeginTrans(p->pSrc, 0);
58053       bCloseTrans = 1;
58054     }
58055
58056     /* Do not allow backup if the destination database is in WAL mode
58057     ** and the page sizes are different between source and destination */
58058     pgszSrc = sqlcipher3BtreeGetPageSize(p->pSrc);
58059     pgszDest = sqlcipher3BtreeGetPageSize(p->pDest);
58060     destMode = sqlcipher3PagerGetJournalMode(sqlcipher3BtreePager(p->pDest));
58061     if( SQLCIPHER_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
58062       rc = SQLCIPHER_READONLY;
58063     }
58064   
58065     /* Now that there is a read-lock on the source database, query the
58066     ** source pager for the number of pages in the database.
58067     */
58068     nSrcPage = (int)sqlcipher3BtreeLastPage(p->pSrc);
58069     assert( nSrcPage>=0 );
58070     for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
58071       const Pgno iSrcPg = p->iNext;                 /* Source page number */
58072       if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
58073         DbPage *pSrcPg;                             /* Source page object */
58074         rc = sqlcipher3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
58075         if( rc==SQLCIPHER_OK ){
58076           rc = backupOnePage(p, iSrcPg, sqlcipher3PagerGetData(pSrcPg));
58077           sqlcipher3PagerUnref(pSrcPg);
58078         }
58079       }
58080       p->iNext++;
58081     }
58082     if( rc==SQLCIPHER_OK ){
58083       p->nPagecount = nSrcPage;
58084       p->nRemaining = nSrcPage+1-p->iNext;
58085       if( p->iNext>(Pgno)nSrcPage ){
58086         rc = SQLCIPHER_DONE;
58087       }else if( !p->isAttached ){
58088         attachBackupObject(p);
58089       }
58090     }
58091   
58092     /* Update the schema version field in the destination database. This
58093     ** is to make sure that the schema-version really does change in
58094     ** the case where the source and destination databases have the
58095     ** same schema version.
58096     */
58097     if( rc==SQLCIPHER_DONE ){
58098       rc = sqlcipher3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
58099       if( rc==SQLCIPHER_OK ){
58100         if( p->pDestDb ){
58101           sqlcipher3ResetInternalSchema(p->pDestDb, -1);
58102         }
58103         if( destMode==PAGER_JOURNALMODE_WAL ){
58104           rc = sqlcipher3BtreeSetVersion(p->pDest, 2);
58105         }
58106       }
58107       if( rc==SQLCIPHER_OK ){
58108         int nDestTruncate;
58109         /* Set nDestTruncate to the final number of pages in the destination
58110         ** database. The complication here is that the destination page
58111         ** size may be different to the source page size. 
58112         **
58113         ** If the source page size is smaller than the destination page size, 
58114         ** round up. In this case the call to sqlcipher3OsTruncate() below will
58115         ** fix the size of the file. However it is important to call
58116         ** sqlcipher3PagerTruncateImage() here so that any pages in the 
58117         ** destination file that lie beyond the nDestTruncate page mark are
58118         ** journalled by PagerCommitPhaseOne() before they are destroyed
58119         ** by the file truncation.
58120         */
58121         assert( pgszSrc==sqlcipher3BtreeGetPageSize(p->pSrc) );
58122         assert( pgszDest==sqlcipher3BtreeGetPageSize(p->pDest) );
58123         if( pgszSrc<pgszDest ){
58124           int ratio = pgszDest/pgszSrc;
58125           nDestTruncate = (nSrcPage+ratio-1)/ratio;
58126           if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
58127             nDestTruncate--;
58128           }
58129         }else{
58130           nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
58131         }
58132         sqlcipher3PagerTruncateImage(pDestPager, nDestTruncate);
58133
58134         if( pgszSrc<pgszDest ){
58135           /* If the source page-size is smaller than the destination page-size,
58136           ** two extra things may need to happen:
58137           **
58138           **   * The destination may need to be truncated, and
58139           **
58140           **   * Data stored on the pages immediately following the 
58141           **     pending-byte page in the source database may need to be
58142           **     copied into the destination database.
58143           */
58144           const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
58145           sqlcipher3_file * const pFile = sqlcipher3PagerFile(pDestPager);
58146           i64 iOff;
58147           i64 iEnd;
58148
58149           assert( pFile );
58150           assert( (i64)nDestTruncate*(i64)pgszDest >= iSize || (
58151                 nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
58152              && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
58153           ));
58154
58155           /* This call ensures that all data required to recreate the original
58156           ** database has been stored in the journal for pDestPager and the
58157           ** journal synced to disk. So at this point we may safely modify
58158           ** the database file in any way, knowing that if a power failure
58159           ** occurs, the original database will be reconstructed from the 
58160           ** journal file.  */
58161           rc = sqlcipher3PagerCommitPhaseOne(pDestPager, 0, 1);
58162
58163           /* Write the extra pages and truncate the database file as required */
58164           iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
58165           for(
58166             iOff=PENDING_BYTE+pgszSrc; 
58167             rc==SQLCIPHER_OK && iOff<iEnd; 
58168             iOff+=pgszSrc
58169           ){
58170             PgHdr *pSrcPg = 0;
58171             const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
58172             rc = sqlcipher3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
58173             if( rc==SQLCIPHER_OK ){
58174               u8 *zData = sqlcipher3PagerGetData(pSrcPg);
58175               rc = sqlcipher3OsWrite(pFile, zData, pgszSrc, iOff);
58176             }
58177             sqlcipher3PagerUnref(pSrcPg);
58178           }
58179           if( rc==SQLCIPHER_OK ){
58180             rc = backupTruncateFile(pFile, iSize);
58181           }
58182
58183           /* Sync the database file to disk. */
58184           if( rc==SQLCIPHER_OK ){
58185             rc = sqlcipher3PagerSync(pDestPager);
58186           }
58187         }else{
58188           rc = sqlcipher3PagerCommitPhaseOne(pDestPager, 0, 0);
58189         }
58190     
58191         /* Finish committing the transaction to the destination database. */
58192         if( SQLCIPHER_OK==rc
58193          && SQLCIPHER_OK==(rc = sqlcipher3BtreeCommitPhaseTwo(p->pDest, 0))
58194         ){
58195           rc = SQLCIPHER_DONE;
58196         }
58197       }
58198     }
58199   
58200     /* If bCloseTrans is true, then this function opened a read transaction
58201     ** on the source database. Close the read transaction here. There is
58202     ** no need to check the return values of the btree methods here, as
58203     ** "committing" a read-only transaction cannot fail.
58204     */
58205     if( bCloseTrans ){
58206       TESTONLY( int rc2 );
58207       TESTONLY( rc2  = ) sqlcipher3BtreeCommitPhaseOne(p->pSrc, 0);
58208       TESTONLY( rc2 |= ) sqlcipher3BtreeCommitPhaseTwo(p->pSrc, 0);
58209       assert( rc2==SQLCIPHER_OK );
58210     }
58211   
58212     if( rc==SQLCIPHER_IOERR_NOMEM ){
58213       rc = SQLCIPHER_NOMEM;
58214     }
58215     p->rc = rc;
58216   }
58217   if( p->pDestDb ){
58218     sqlcipher3_mutex_leave(p->pDestDb->mutex);
58219   }
58220   sqlcipher3BtreeLeave(p->pSrc);
58221   sqlcipher3_mutex_leave(p->pSrcDb->mutex);
58222   return rc;
58223 }
58224
58225 /*
58226 ** Release all resources associated with an sqlcipher3_backup* handle.
58227 */
58228 SQLCIPHER_API int sqlcipher3_backup_finish(sqlcipher3_backup *p){
58229   sqlcipher3_backup **pp;                 /* Ptr to head of pagers backup list */
58230   MUTEX_LOGIC( sqlcipher3_mutex *mutex; ) /* Mutex to protect source database */
58231   int rc;                              /* Value to return */
58232
58233   /* Enter the mutexes */
58234   if( p==0 ) return SQLCIPHER_OK;
58235   sqlcipher3_mutex_enter(p->pSrcDb->mutex);
58236   sqlcipher3BtreeEnter(p->pSrc);
58237   MUTEX_LOGIC( mutex = p->pSrcDb->mutex; )
58238   if( p->pDestDb ){
58239     sqlcipher3_mutex_enter(p->pDestDb->mutex);
58240   }
58241
58242   /* Detach this backup from the source pager. */
58243   if( p->pDestDb ){
58244     p->pSrc->nBackup--;
58245   }
58246   if( p->isAttached ){
58247     pp = sqlcipher3PagerBackupPtr(sqlcipher3BtreePager(p->pSrc));
58248     while( *pp!=p ){
58249       pp = &(*pp)->pNext;
58250     }
58251     *pp = p->pNext;
58252   }
58253
58254   /* If a transaction is still open on the Btree, roll it back. */
58255   sqlcipher3BtreeRollback(p->pDest);
58256
58257   /* Set the error code of the destination database handle. */
58258   rc = (p->rc==SQLCIPHER_DONE) ? SQLCIPHER_OK : p->rc;
58259   sqlcipher3Error(p->pDestDb, rc, 0);
58260
58261   /* Exit the mutexes and free the backup context structure. */
58262   if( p->pDestDb ){
58263     sqlcipher3_mutex_leave(p->pDestDb->mutex);
58264   }
58265   sqlcipher3BtreeLeave(p->pSrc);
58266   if( p->pDestDb ){
58267     /* EVIDENCE-OF: R-64852-21591 The sqlcipher3_backup object is created by a
58268     ** call to sqlcipher3_backup_init() and is destroyed by a call to
58269     ** sqlcipher3_backup_finish(). */
58270     sqlcipher3_free(p);
58271   }
58272   sqlcipher3_mutex_leave(mutex);
58273   return rc;
58274 }
58275
58276 /*
58277 ** Return the number of pages still to be backed up as of the most recent
58278 ** call to sqlcipher3_backup_step().
58279 */
58280 SQLCIPHER_API int sqlcipher3_backup_remaining(sqlcipher3_backup *p){
58281   return p->nRemaining;
58282 }
58283
58284 /*
58285 ** Return the total number of pages in the source database as of the most 
58286 ** recent call to sqlcipher3_backup_step().
58287 */
58288 SQLCIPHER_API int sqlcipher3_backup_pagecount(sqlcipher3_backup *p){
58289   return p->nPagecount;
58290 }
58291
58292 /*
58293 ** This function is called after the contents of page iPage of the
58294 ** source database have been modified. If page iPage has already been 
58295 ** copied into the destination database, then the data written to the
58296 ** destination is now invalidated. The destination copy of iPage needs
58297 ** to be updated with the new data before the backup operation is
58298 ** complete.
58299 **
58300 ** It is assumed that the mutex associated with the BtShared object
58301 ** corresponding to the source database is held when this function is
58302 ** called.
58303 */
58304 SQLCIPHER_PRIVATE void sqlcipher3BackupUpdate(sqlcipher3_backup *pBackup, Pgno iPage, const u8 *aData){
58305   sqlcipher3_backup *p;                   /* Iterator variable */
58306   for(p=pBackup; p; p=p->pNext){
58307     assert( sqlcipher3_mutex_held(p->pSrc->pBt->mutex) );
58308     if( !isFatalError(p->rc) && iPage<p->iNext ){
58309       /* The backup process p has already copied page iPage. But now it
58310       ** has been modified by a transaction on the source pager. Copy
58311       ** the new data into the backup.
58312       */
58313       int rc;
58314       assert( p->pDestDb );
58315       sqlcipher3_mutex_enter(p->pDestDb->mutex);
58316       rc = backupOnePage(p, iPage, aData);
58317       sqlcipher3_mutex_leave(p->pDestDb->mutex);
58318       assert( rc!=SQLCIPHER_BUSY && rc!=SQLCIPHER_LOCKED );
58319       if( rc!=SQLCIPHER_OK ){
58320         p->rc = rc;
58321       }
58322     }
58323   }
58324 }
58325
58326 /*
58327 ** Restart the backup process. This is called when the pager layer
58328 ** detects that the database has been modified by an external database
58329 ** connection. In this case there is no way of knowing which of the
58330 ** pages that have been copied into the destination database are still 
58331 ** valid and which are not, so the entire process needs to be restarted.
58332 **
58333 ** It is assumed that the mutex associated with the BtShared object
58334 ** corresponding to the source database is held when this function is
58335 ** called.
58336 */
58337 SQLCIPHER_PRIVATE void sqlcipher3BackupRestart(sqlcipher3_backup *pBackup){
58338   sqlcipher3_backup *p;                   /* Iterator variable */
58339   for(p=pBackup; p; p=p->pNext){
58340     assert( sqlcipher3_mutex_held(p->pSrc->pBt->mutex) );
58341     p->iNext = 1;
58342   }
58343 }
58344
58345 #ifndef SQLCIPHER_OMIT_VACUUM
58346 /*
58347 ** Copy the complete content of pBtFrom into pBtTo.  A transaction
58348 ** must be active for both files.
58349 **
58350 ** The size of file pTo may be reduced by this operation. If anything 
58351 ** goes wrong, the transaction on pTo is rolled back. If successful, the 
58352 ** transaction is committed before returning.
58353 */
58354 SQLCIPHER_PRIVATE int sqlcipher3BtreeCopyFile(Btree *pTo, Btree *pFrom){
58355   int rc;
58356   sqlcipher3_file *pFd;              /* File descriptor for database pTo */
58357   sqlcipher3_backup b;
58358   sqlcipher3BtreeEnter(pTo);
58359   sqlcipher3BtreeEnter(pFrom);
58360
58361   assert( sqlcipher3BtreeIsInTrans(pTo) );
58362   pFd = sqlcipher3PagerFile(sqlcipher3BtreePager(pTo));
58363   if( pFd->pMethods ){
58364     i64 nByte = sqlcipher3BtreeGetPageSize(pFrom)*(i64)sqlcipher3BtreeLastPage(pFrom);
58365     sqlcipher3OsFileControl(pFd, SQLCIPHER_FCNTL_OVERWRITE, &nByte);
58366   }
58367
58368   /* Set up an sqlcipher3_backup object. sqlcipher3_backup.pDestDb must be set
58369   ** to 0. This is used by the implementations of sqlcipher3_backup_step()
58370   ** and sqlcipher3_backup_finish() to detect that they are being called
58371   ** from this function, not directly by the user.
58372   */
58373   memset(&b, 0, sizeof(b));
58374   b.pSrcDb = pFrom->db;
58375   b.pSrc = pFrom;
58376   b.pDest = pTo;
58377   b.iNext = 1;
58378
58379   /* 0x7FFFFFFF is the hard limit for the number of pages in a database
58380   ** file. By passing this as the number of pages to copy to
58381   ** sqlcipher3_backup_step(), we can guarantee that the copy finishes 
58382   ** within a single call (unless an error occurs). The assert() statement
58383   ** checks this assumption - (p->rc) should be set to either SQLCIPHER_DONE 
58384   ** or an error code.
58385   */
58386   sqlcipher3_backup_step(&b, 0x7FFFFFFF);
58387   assert( b.rc!=SQLCIPHER_OK );
58388   rc = sqlcipher3_backup_finish(&b);
58389   if( rc==SQLCIPHER_OK ){
58390     pTo->pBt->pageSizeFixed = 0;
58391   }else{
58392     sqlcipher3PagerClearCache(sqlcipher3BtreePager(b.pDest));
58393   }
58394
58395   assert( sqlcipher3BtreeIsInTrans(pTo)==0 );
58396   sqlcipher3BtreeLeave(pFrom);
58397   sqlcipher3BtreeLeave(pTo);
58398   return rc;
58399 }
58400 #endif /* SQLCIPHER_OMIT_VACUUM */
58401
58402 /************** End of backup.c **********************************************/
58403 /************** Begin file vdbemem.c *****************************************/
58404 /*
58405 ** 2004 May 26
58406 **
58407 ** The author disclaims copyright to this source code.  In place of
58408 ** a legal notice, here is a blessing:
58409 **
58410 **    May you do good and not evil.
58411 **    May you find forgiveness for yourself and forgive others.
58412 **    May you share freely, never taking more than you give.
58413 **
58414 *************************************************************************
58415 **
58416 ** This file contains code use to manipulate "Mem" structure.  A "Mem"
58417 ** stores a single value in the VDBE.  Mem is an opaque structure visible
58418 ** only within the VDBE.  Interface routines refer to a Mem using the
58419 ** name sqlcipher_value
58420 */
58421
58422 /*
58423 ** Call sqlcipher3VdbeMemExpandBlob() on the supplied value (type Mem*)
58424 ** P if required.
58425 */
58426 #define expandBlob(P) (((P)->flags&MEM_Zero)?sqlcipher3VdbeMemExpandBlob(P):0)
58427
58428 /*
58429 ** If pMem is an object with a valid string representation, this routine
58430 ** ensures the internal encoding for the string representation is
58431 ** 'desiredEnc', one of SQLCIPHER_UTF8, SQLCIPHER_UTF16LE or SQLCIPHER_UTF16BE.
58432 **
58433 ** If pMem is not a string object, or the encoding of the string
58434 ** representation is already stored using the requested encoding, then this
58435 ** routine is a no-op.
58436 **
58437 ** SQLCIPHER_OK is returned if the conversion is successful (or not required).
58438 ** SQLCIPHER_NOMEM may be returned if a malloc() fails during conversion
58439 ** between formats.
58440 */
58441 SQLCIPHER_PRIVATE int sqlcipher3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
58442   int rc;
58443   assert( (pMem->flags&MEM_RowSet)==0 );
58444   assert( desiredEnc==SQLCIPHER_UTF8 || desiredEnc==SQLCIPHER_UTF16LE
58445            || desiredEnc==SQLCIPHER_UTF16BE );
58446   if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
58447     return SQLCIPHER_OK;
58448   }
58449   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58450 #ifdef SQLCIPHER_OMIT_UTF16
58451   return SQLCIPHER_ERROR;
58452 #else
58453
58454   /* MemTranslate() may return SQLCIPHER_OK or SQLCIPHER_NOMEM. If NOMEM is returned,
58455   ** then the encoding of the value may not have changed.
58456   */
58457   rc = sqlcipher3VdbeMemTranslate(pMem, (u8)desiredEnc);
58458   assert(rc==SQLCIPHER_OK    || rc==SQLCIPHER_NOMEM);
58459   assert(rc==SQLCIPHER_OK    || pMem->enc!=desiredEnc);
58460   assert(rc==SQLCIPHER_NOMEM || pMem->enc==desiredEnc);
58461   return rc;
58462 #endif
58463 }
58464
58465 /*
58466 ** Make sure pMem->z points to a writable allocation of at least 
58467 ** n bytes.
58468 **
58469 ** If the memory cell currently contains string or blob data
58470 ** and the third argument passed to this function is true, the 
58471 ** current content of the cell is preserved. Otherwise, it may
58472 ** be discarded.  
58473 **
58474 ** This function sets the MEM_Dyn flag and clears any xDel callback.
58475 ** It also clears MEM_Ephem and MEM_Static. If the preserve flag is 
58476 ** not set, Mem.n is zeroed.
58477 */
58478 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemGrow(Mem *pMem, int n, int preserve){
58479   assert( 1 >=
58480     ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
58481     (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) + 
58482     ((pMem->flags&MEM_Ephem) ? 1 : 0) + 
58483     ((pMem->flags&MEM_Static) ? 1 : 0)
58484   );
58485   assert( (pMem->flags&MEM_RowSet)==0 );
58486
58487   if( n<32 ) n = 32;
58488   if( sqlcipher3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
58489     if( preserve && pMem->z==pMem->zMalloc ){
58490       pMem->z = pMem->zMalloc = sqlcipher3DbReallocOrFree(pMem->db, pMem->z, n);
58491       preserve = 0;
58492     }else{
58493       sqlcipher3DbFree(pMem->db, pMem->zMalloc);
58494       pMem->zMalloc = sqlcipher3DbMallocRaw(pMem->db, n);
58495     }
58496   }
58497
58498   if( pMem->z && preserve && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
58499     memcpy(pMem->zMalloc, pMem->z, pMem->n);
58500   }
58501   if( pMem->flags&MEM_Dyn && pMem->xDel ){
58502     pMem->xDel((void *)(pMem->z));
58503   }
58504
58505   pMem->z = pMem->zMalloc;
58506   if( pMem->z==0 ){
58507     pMem->flags = MEM_Null;
58508   }else{
58509     pMem->flags &= ~(MEM_Ephem|MEM_Static);
58510   }
58511   pMem->xDel = 0;
58512   return (pMem->z ? SQLCIPHER_OK : SQLCIPHER_NOMEM);
58513 }
58514
58515 /*
58516 ** Make the given Mem object MEM_Dyn.  In other words, make it so
58517 ** that any TEXT or BLOB content is stored in memory obtained from
58518 ** malloc().  In this way, we know that the memory is safe to be
58519 ** overwritten or altered.
58520 **
58521 ** Return SQLCIPHER_OK on success or SQLCIPHER_NOMEM if malloc fails.
58522 */
58523 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemMakeWriteable(Mem *pMem){
58524   int f;
58525   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58526   assert( (pMem->flags&MEM_RowSet)==0 );
58527   expandBlob(pMem);
58528   f = pMem->flags;
58529   if( (f&(MEM_Str|MEM_Blob)) && pMem->z!=pMem->zMalloc ){
58530     if( sqlcipher3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
58531       return SQLCIPHER_NOMEM;
58532     }
58533     pMem->z[pMem->n] = 0;
58534     pMem->z[pMem->n+1] = 0;
58535     pMem->flags |= MEM_Term;
58536 #ifdef SQLCIPHER_DEBUG
58537     pMem->pScopyFrom = 0;
58538 #endif
58539   }
58540
58541   return SQLCIPHER_OK;
58542 }
58543
58544 /*
58545 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
58546 ** blob stored in dynamically allocated space.
58547 */
58548 #ifndef SQLCIPHER_OMIT_INCRBLOB
58549 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemExpandBlob(Mem *pMem){
58550   if( pMem->flags & MEM_Zero ){
58551     int nByte;
58552     assert( pMem->flags&MEM_Blob );
58553     assert( (pMem->flags&MEM_RowSet)==0 );
58554     assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58555
58556     /* Set nByte to the number of bytes required to store the expanded blob. */
58557     nByte = pMem->n + pMem->u.nZero;
58558     if( nByte<=0 ){
58559       nByte = 1;
58560     }
58561     if( sqlcipher3VdbeMemGrow(pMem, nByte, 1) ){
58562       return SQLCIPHER_NOMEM;
58563     }
58564
58565     memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
58566     pMem->n += pMem->u.nZero;
58567     pMem->flags &= ~(MEM_Zero|MEM_Term);
58568   }
58569   return SQLCIPHER_OK;
58570 }
58571 #endif
58572
58573
58574 /*
58575 ** Make sure the given Mem is \u0000 terminated.
58576 */
58577 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemNulTerminate(Mem *pMem){
58578   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58579   if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
58580     return SQLCIPHER_OK;   /* Nothing to do */
58581   }
58582   if( sqlcipher3VdbeMemGrow(pMem, pMem->n+2, 1) ){
58583     return SQLCIPHER_NOMEM;
58584   }
58585   pMem->z[pMem->n] = 0;
58586   pMem->z[pMem->n+1] = 0;
58587   pMem->flags |= MEM_Term;
58588   return SQLCIPHER_OK;
58589 }
58590
58591 /*
58592 ** Add MEM_Str to the set of representations for the given Mem.  Numbers
58593 ** are converted using sqlcipher3_snprintf().  Converting a BLOB to a string
58594 ** is a no-op.
58595 **
58596 ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
58597 **
58598 ** A MEM_Null value will never be passed to this function. This function is
58599 ** used for converting values to text for returning to the user (i.e. via
58600 ** sqlcipher3_value_text()), or for ensuring that values to be used as btree
58601 ** keys are strings. In the former case a NULL pointer is returned the
58602 ** user and the later is an internal programming error.
58603 */
58604 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemStringify(Mem *pMem, int enc){
58605   int rc = SQLCIPHER_OK;
58606   int fg = pMem->flags;
58607   const int nByte = 32;
58608
58609   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58610   assert( !(fg&MEM_Zero) );
58611   assert( !(fg&(MEM_Str|MEM_Blob)) );
58612   assert( fg&(MEM_Int|MEM_Real) );
58613   assert( (pMem->flags&MEM_RowSet)==0 );
58614   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58615
58616
58617   if( sqlcipher3VdbeMemGrow(pMem, nByte, 0) ){
58618     return SQLCIPHER_NOMEM;
58619   }
58620
58621   /* For a Real or Integer, use sqlcipher3_mprintf() to produce the UTF-8
58622   ** string representation of the value. Then, if the required encoding
58623   ** is UTF-16le or UTF-16be do a translation.
58624   ** 
58625   ** FIX ME: It would be better if sqlcipher3_snprintf() could do UTF-16.
58626   */
58627   if( fg & MEM_Int ){
58628     sqlcipher3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
58629   }else{
58630     assert( fg & MEM_Real );
58631     sqlcipher3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
58632   }
58633   pMem->n = sqlcipher3Strlen30(pMem->z);
58634   pMem->enc = SQLCIPHER_UTF8;
58635   pMem->flags |= MEM_Str|MEM_Term;
58636   sqlcipher3VdbeChangeEncoding(pMem, enc);
58637   return rc;
58638 }
58639
58640 /*
58641 ** Memory cell pMem contains the context of an aggregate function.
58642 ** This routine calls the finalize method for that function.  The
58643 ** result of the aggregate is stored back into pMem.
58644 **
58645 ** Return SQLCIPHER_ERROR if the finalizer reports an error.  SQLCIPHER_OK
58646 ** otherwise.
58647 */
58648 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
58649   int rc = SQLCIPHER_OK;
58650   if( ALWAYS(pFunc && pFunc->xFinalize) ){
58651     sqlcipher3_context ctx;
58652     assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
58653     assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58654     memset(&ctx, 0, sizeof(ctx));
58655     ctx.s.flags = MEM_Null;
58656     ctx.s.db = pMem->db;
58657     ctx.pMem = pMem;
58658     ctx.pFunc = pFunc;
58659     pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
58660     assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
58661     sqlcipher3DbFree(pMem->db, pMem->zMalloc);
58662     memcpy(pMem, &ctx.s, sizeof(ctx.s));
58663     rc = ctx.isError;
58664   }
58665   return rc;
58666 }
58667
58668 /*
58669 ** If the memory cell contains a string value that must be freed by
58670 ** invoking an external callback, free it now. Calling this function
58671 ** does not free any Mem.zMalloc buffer.
58672 */
58673 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemReleaseExternal(Mem *p){
58674   assert( p->db==0 || sqlcipher3_mutex_held(p->db->mutex) );
58675   if( p->flags&MEM_Agg ){
58676     sqlcipher3VdbeMemFinalize(p, p->u.pDef);
58677     assert( (p->flags & MEM_Agg)==0 );
58678     sqlcipher3VdbeMemRelease(p);
58679   }else if( p->flags&MEM_Dyn && p->xDel ){
58680     assert( (p->flags&MEM_RowSet)==0 );
58681     p->xDel((void *)p->z);
58682     p->xDel = 0;
58683   }else if( p->flags&MEM_RowSet ){
58684     sqlcipher3RowSetClear(p->u.pRowSet);
58685   }else if( p->flags&MEM_Frame ){
58686     sqlcipher3VdbeMemSetNull(p);
58687   }
58688 }
58689
58690 /*
58691 ** Release any memory held by the Mem. This may leave the Mem in an
58692 ** inconsistent state, for example with (Mem.z==0) and
58693 ** (Mem.type==SQLCIPHER_TEXT).
58694 */
58695 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemRelease(Mem *p){
58696   MemReleaseExt(p);
58697   sqlcipher3DbFree(p->db, p->zMalloc);
58698   p->z = 0;
58699   p->zMalloc = 0;
58700   p->xDel = 0;
58701 }
58702
58703 /*
58704 ** Convert a 64-bit IEEE double into a 64-bit signed integer.
58705 ** If the double is too large, return 0x8000000000000000.
58706 **
58707 ** Most systems appear to do this simply by assigning
58708 ** variables and without the extra range tests.  But
58709 ** there are reports that windows throws an expection
58710 ** if the floating point value is out of range. (See ticket #2880.)
58711 ** Because we do not completely understand the problem, we will
58712 ** take the conservative approach and always do range tests
58713 ** before attempting the conversion.
58714 */
58715 static i64 doubleToInt64(double r){
58716 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
58717   /* When floating-point is omitted, double and int64 are the same thing */
58718   return r;
58719 #else
58720   /*
58721   ** Many compilers we encounter do not define constants for the
58722   ** minimum and maximum 64-bit integers, or they define them
58723   ** inconsistently.  And many do not understand the "LL" notation.
58724   ** So we define our own static constants here using nothing
58725   ** larger than a 32-bit integer constant.
58726   */
58727   static const i64 maxInt = LARGEST_INT64;
58728   static const i64 minInt = SMALLEST_INT64;
58729
58730   if( r<(double)minInt ){
58731     return minInt;
58732   }else if( r>(double)maxInt ){
58733     /* minInt is correct here - not maxInt.  It turns out that assigning
58734     ** a very large positive number to an integer results in a very large
58735     ** negative integer.  This makes no sense, but it is what x86 hardware
58736     ** does so for compatibility we will do the same in software. */
58737     return minInt;
58738   }else{
58739     return (i64)r;
58740   }
58741 #endif
58742 }
58743
58744 /*
58745 ** Return some kind of integer value which is the best we can do
58746 ** at representing the value that *pMem describes as an integer.
58747 ** If pMem is an integer, then the value is exact.  If pMem is
58748 ** a floating-point then the value returned is the integer part.
58749 ** If pMem is a string or blob, then we make an attempt to convert
58750 ** it into a integer and return that.  If pMem represents an
58751 ** an SQL-NULL value, return 0.
58752 **
58753 ** If pMem represents a string value, its encoding might be changed.
58754 */
58755 SQLCIPHER_PRIVATE i64 sqlcipher3VdbeIntValue(Mem *pMem){
58756   int flags;
58757   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58758   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58759   flags = pMem->flags;
58760   if( flags & MEM_Int ){
58761     return pMem->u.i;
58762   }else if( flags & MEM_Real ){
58763     return doubleToInt64(pMem->r);
58764   }else if( flags & (MEM_Str|MEM_Blob) ){
58765     i64 value = 0;
58766     assert( pMem->z || pMem->n==0 );
58767     testcase( pMem->z==0 );
58768     sqlcipher3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
58769     return value;
58770   }else{
58771     return 0;
58772   }
58773 }
58774
58775 /*
58776 ** Return the best representation of pMem that we can get into a
58777 ** double.  If pMem is already a double or an integer, return its
58778 ** value.  If it is a string or blob, try to convert it to a double.
58779 ** If it is a NULL, return 0.0.
58780 */
58781 SQLCIPHER_PRIVATE double sqlcipher3VdbeRealValue(Mem *pMem){
58782   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58783   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58784   if( pMem->flags & MEM_Real ){
58785     return pMem->r;
58786   }else if( pMem->flags & MEM_Int ){
58787     return (double)pMem->u.i;
58788   }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
58789     /* (double)0 In case of SQLCIPHER_OMIT_FLOATING_POINT... */
58790     double val = (double)0;
58791     sqlcipher3AtoF(pMem->z, &val, pMem->n, pMem->enc);
58792     return val;
58793   }else{
58794     /* (double)0 In case of SQLCIPHER_OMIT_FLOATING_POINT... */
58795     return (double)0;
58796   }
58797 }
58798
58799 /*
58800 ** The MEM structure is already a MEM_Real.  Try to also make it a
58801 ** MEM_Int if we can.
58802 */
58803 SQLCIPHER_PRIVATE void sqlcipher3VdbeIntegerAffinity(Mem *pMem){
58804   assert( pMem->flags & MEM_Real );
58805   assert( (pMem->flags & MEM_RowSet)==0 );
58806   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58807   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58808
58809   pMem->u.i = doubleToInt64(pMem->r);
58810
58811   /* Only mark the value as an integer if
58812   **
58813   **    (1) the round-trip conversion real->int->real is a no-op, and
58814   **    (2) The integer is neither the largest nor the smallest
58815   **        possible integer (ticket #3922)
58816   **
58817   ** The second and third terms in the following conditional enforces
58818   ** the second condition under the assumption that addition overflow causes
58819   ** values to wrap around.  On x86 hardware, the third term is always
58820   ** true and could be omitted.  But we leave it in because other
58821   ** architectures might behave differently.
58822   */
58823   if( pMem->r==(double)pMem->u.i && pMem->u.i>SMALLEST_INT64
58824       && ALWAYS(pMem->u.i<LARGEST_INT64) ){
58825     pMem->flags |= MEM_Int;
58826   }
58827 }
58828
58829 /*
58830 ** Convert pMem to type integer.  Invalidate any prior representations.
58831 */
58832 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemIntegerify(Mem *pMem){
58833   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58834   assert( (pMem->flags & MEM_RowSet)==0 );
58835   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58836
58837   pMem->u.i = sqlcipher3VdbeIntValue(pMem);
58838   MemSetTypeFlag(pMem, MEM_Int);
58839   return SQLCIPHER_OK;
58840 }
58841
58842 /*
58843 ** Convert pMem so that it is of type MEM_Real.
58844 ** Invalidate any prior representations.
58845 */
58846 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemRealify(Mem *pMem){
58847   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58848   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58849
58850   pMem->r = sqlcipher3VdbeRealValue(pMem);
58851   MemSetTypeFlag(pMem, MEM_Real);
58852   return SQLCIPHER_OK;
58853 }
58854
58855 /*
58856 ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
58857 ** Invalidate any prior representations.
58858 **
58859 ** Every effort is made to force the conversion, even if the input
58860 ** is a string that does not look completely like a number.  Convert
58861 ** as much of the string as we can and ignore the rest.
58862 */
58863 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemNumerify(Mem *pMem){
58864   if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
58865     assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
58866     assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
58867     if( 0==sqlcipher3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){
58868       MemSetTypeFlag(pMem, MEM_Int);
58869     }else{
58870       pMem->r = sqlcipher3VdbeRealValue(pMem);
58871       MemSetTypeFlag(pMem, MEM_Real);
58872       sqlcipher3VdbeIntegerAffinity(pMem);
58873     }
58874   }
58875   assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
58876   pMem->flags &= ~(MEM_Str|MEM_Blob);
58877   return SQLCIPHER_OK;
58878 }
58879
58880 /*
58881 ** Delete any previous value and set the value stored in *pMem to NULL.
58882 */
58883 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetNull(Mem *pMem){
58884   if( pMem->flags & MEM_Frame ){
58885     VdbeFrame *pFrame = pMem->u.pFrame;
58886     pFrame->pParent = pFrame->v->pDelFrame;
58887     pFrame->v->pDelFrame = pFrame;
58888   }
58889   if( pMem->flags & MEM_RowSet ){
58890     sqlcipher3RowSetClear(pMem->u.pRowSet);
58891   }
58892   MemSetTypeFlag(pMem, MEM_Null);
58893   pMem->type = SQLCIPHER_NULL;
58894 }
58895
58896 /*
58897 ** Delete any previous value and set the value to be a BLOB of length
58898 ** n containing all zeros.
58899 */
58900 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetZeroBlob(Mem *pMem, int n){
58901   sqlcipher3VdbeMemRelease(pMem);
58902   pMem->flags = MEM_Blob|MEM_Zero;
58903   pMem->type = SQLCIPHER_BLOB;
58904   pMem->n = 0;
58905   if( n<0 ) n = 0;
58906   pMem->u.nZero = n;
58907   pMem->enc = SQLCIPHER_UTF8;
58908
58909 #ifdef SQLCIPHER_OMIT_INCRBLOB
58910   sqlcipher3VdbeMemGrow(pMem, n, 0);
58911   if( pMem->z ){
58912     pMem->n = n;
58913     memset(pMem->z, 0, n);
58914   }
58915 #endif
58916 }
58917
58918 /*
58919 ** Delete any previous value and set the value stored in *pMem to val,
58920 ** manifest type INTEGER.
58921 */
58922 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetInt64(Mem *pMem, i64 val){
58923   sqlcipher3VdbeMemRelease(pMem);
58924   pMem->u.i = val;
58925   pMem->flags = MEM_Int;
58926   pMem->type = SQLCIPHER_INTEGER;
58927 }
58928
58929 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
58930 /*
58931 ** Delete any previous value and set the value stored in *pMem to val,
58932 ** manifest type REAL.
58933 */
58934 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetDouble(Mem *pMem, double val){
58935   if( sqlcipher3IsNaN(val) ){
58936     sqlcipher3VdbeMemSetNull(pMem);
58937   }else{
58938     sqlcipher3VdbeMemRelease(pMem);
58939     pMem->r = val;
58940     pMem->flags = MEM_Real;
58941     pMem->type = SQLCIPHER_FLOAT;
58942   }
58943 }
58944 #endif
58945
58946 /*
58947 ** Delete any previous value and set the value of pMem to be an
58948 ** empty boolean index.
58949 */
58950 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemSetRowSet(Mem *pMem){
58951   sqlcipher3 *db = pMem->db;
58952   assert( db!=0 );
58953   assert( (pMem->flags & MEM_RowSet)==0 );
58954   sqlcipher3VdbeMemRelease(pMem);
58955   pMem->zMalloc = sqlcipher3DbMallocRaw(db, 64);
58956   if( db->mallocFailed ){
58957     pMem->flags = MEM_Null;
58958   }else{
58959     assert( pMem->zMalloc );
58960     pMem->u.pRowSet = sqlcipher3RowSetInit(db, pMem->zMalloc, 
58961                                        sqlcipher3DbMallocSize(db, pMem->zMalloc));
58962     assert( pMem->u.pRowSet!=0 );
58963     pMem->flags = MEM_RowSet;
58964   }
58965 }
58966
58967 /*
58968 ** Return true if the Mem object contains a TEXT or BLOB that is
58969 ** too large - whose size exceeds SQLCIPHER_MAX_LENGTH.
58970 */
58971 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemTooBig(Mem *p){
58972   assert( p->db!=0 );
58973   if( p->flags & (MEM_Str|MEM_Blob) ){
58974     int n = p->n;
58975     if( p->flags & MEM_Zero ){
58976       n += p->u.nZero;
58977     }
58978     return n>p->db->aLimit[SQLCIPHER_LIMIT_LENGTH];
58979   }
58980   return 0; 
58981 }
58982
58983 #ifdef SQLCIPHER_DEBUG
58984 /*
58985 ** This routine prepares a memory cell for modication by breaking
58986 ** its link to a shallow copy and by marking any current shallow
58987 ** copies of this cell as invalid.
58988 **
58989 ** This is used for testing and debugging only - to make sure shallow
58990 ** copies are not misused.
58991 */
58992 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemPrepareToChange(Vdbe *pVdbe, Mem *pMem){
58993   int i;
58994   Mem *pX;
58995   for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
58996     if( pX->pScopyFrom==pMem ){
58997       pX->flags |= MEM_Invalid;
58998       pX->pScopyFrom = 0;
58999     }
59000   }
59001   pMem->pScopyFrom = 0;
59002 }
59003 #endif /* SQLCIPHER_DEBUG */
59004
59005 /*
59006 ** Size of struct Mem not including the Mem.zMalloc member.
59007 */
59008 #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
59009
59010 /*
59011 ** Make an shallow copy of pFrom into pTo.  Prior contents of
59012 ** pTo are freed.  The pFrom->z field is not duplicated.  If
59013 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
59014 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
59015 */
59016 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
59017   assert( (pFrom->flags & MEM_RowSet)==0 );
59018   MemReleaseExt(pTo);
59019   memcpy(pTo, pFrom, MEMCELLSIZE);
59020   pTo->xDel = 0;
59021   if( (pFrom->flags&MEM_Static)==0 ){
59022     pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
59023     assert( srcType==MEM_Ephem || srcType==MEM_Static );
59024     pTo->flags |= srcType;
59025   }
59026 }
59027
59028 /*
59029 ** Make a full copy of pFrom into pTo.  Prior contents of pTo are
59030 ** freed before the copy is made.
59031 */
59032 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
59033   int rc = SQLCIPHER_OK;
59034
59035   assert( (pFrom->flags & MEM_RowSet)==0 );
59036   MemReleaseExt(pTo);
59037   memcpy(pTo, pFrom, MEMCELLSIZE);
59038   pTo->flags &= ~MEM_Dyn;
59039
59040   if( pTo->flags&(MEM_Str|MEM_Blob) ){
59041     if( 0==(pFrom->flags&MEM_Static) ){
59042       pTo->flags |= MEM_Ephem;
59043       rc = sqlcipher3VdbeMemMakeWriteable(pTo);
59044     }
59045   }
59046
59047   return rc;
59048 }
59049
59050 /*
59051 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
59052 ** freed. If pFrom contains ephemeral data, a copy is made.
59053 **
59054 ** pFrom contains an SQL NULL when this routine returns.
59055 */
59056 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemMove(Mem *pTo, Mem *pFrom){
59057   assert( pFrom->db==0 || sqlcipher3_mutex_held(pFrom->db->mutex) );
59058   assert( pTo->db==0 || sqlcipher3_mutex_held(pTo->db->mutex) );
59059   assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
59060
59061   sqlcipher3VdbeMemRelease(pTo);
59062   memcpy(pTo, pFrom, sizeof(Mem));
59063   pFrom->flags = MEM_Null;
59064   pFrom->xDel = 0;
59065   pFrom->zMalloc = 0;
59066 }
59067
59068 /*
59069 ** Change the value of a Mem to be a string or a BLOB.
59070 **
59071 ** The memory management strategy depends on the value of the xDel
59072 ** parameter. If the value passed is SQLCIPHER_TRANSIENT, then the 
59073 ** string is copied into a (possibly existing) buffer managed by the 
59074 ** Mem structure. Otherwise, any existing buffer is freed and the
59075 ** pointer copied.
59076 **
59077 ** If the string is too large (if it exceeds the SQLCIPHER_LIMIT_LENGTH
59078 ** size limit) then no memory allocation occurs.  If the string can be
59079 ** stored without allocating memory, then it is.  If a memory allocation
59080 ** is required to store the string, then value of pMem is unchanged.  In
59081 ** either case, SQLCIPHER_TOOBIG is returned.
59082 */
59083 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemSetStr(
59084   Mem *pMem,          /* Memory cell to set to string value */
59085   const char *z,      /* String pointer */
59086   int n,              /* Bytes in string, or negative */
59087   u8 enc,             /* Encoding of z.  0 for BLOBs */
59088   void (*xDel)(void*) /* Destructor function */
59089 ){
59090   int nByte = n;      /* New value for pMem->n */
59091   int iLimit;         /* Maximum allowed string or blob size */
59092   u16 flags = 0;      /* New value for pMem->flags */
59093
59094   assert( pMem->db==0 || sqlcipher3_mutex_held(pMem->db->mutex) );
59095   assert( (pMem->flags & MEM_RowSet)==0 );
59096
59097   /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
59098   if( !z ){
59099     sqlcipher3VdbeMemSetNull(pMem);
59100     return SQLCIPHER_OK;
59101   }
59102
59103   if( pMem->db ){
59104     iLimit = pMem->db->aLimit[SQLCIPHER_LIMIT_LENGTH];
59105   }else{
59106     iLimit = SQLCIPHER_MAX_LENGTH;
59107   }
59108   flags = (enc==0?MEM_Blob:MEM_Str);
59109   if( nByte<0 ){
59110     assert( enc!=0 );
59111     if( enc==SQLCIPHER_UTF8 ){
59112       for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
59113     }else{
59114       for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
59115     }
59116     flags |= MEM_Term;
59117   }
59118
59119   /* The following block sets the new values of Mem.z and Mem.xDel. It
59120   ** also sets a flag in local variable "flags" to indicate the memory
59121   ** management (one of MEM_Dyn or MEM_Static).
59122   */
59123   if( xDel==SQLCIPHER_TRANSIENT ){
59124     int nAlloc = nByte;
59125     if( flags&MEM_Term ){
59126       nAlloc += (enc==SQLCIPHER_UTF8?1:2);
59127     }
59128     if( nByte>iLimit ){
59129       return SQLCIPHER_TOOBIG;
59130     }
59131     if( sqlcipher3VdbeMemGrow(pMem, nAlloc, 0) ){
59132       return SQLCIPHER_NOMEM;
59133     }
59134     memcpy(pMem->z, z, nAlloc);
59135   }else if( xDel==SQLCIPHER_DYNAMIC ){
59136     sqlcipher3VdbeMemRelease(pMem);
59137     pMem->zMalloc = pMem->z = (char *)z;
59138     pMem->xDel = 0;
59139   }else{
59140     sqlcipher3VdbeMemRelease(pMem);
59141     pMem->z = (char *)z;
59142     pMem->xDel = xDel;
59143     flags |= ((xDel==SQLCIPHER_STATIC)?MEM_Static:MEM_Dyn);
59144   }
59145
59146   pMem->n = nByte;
59147   pMem->flags = flags;
59148   pMem->enc = (enc==0 ? SQLCIPHER_UTF8 : enc);
59149   pMem->type = (enc==0 ? SQLCIPHER_BLOB : SQLCIPHER_TEXT);
59150
59151 #ifndef SQLCIPHER_OMIT_UTF16
59152   if( pMem->enc!=SQLCIPHER_UTF8 && sqlcipher3VdbeMemHandleBom(pMem) ){
59153     return SQLCIPHER_NOMEM;
59154   }
59155 #endif
59156
59157   if( nByte>iLimit ){
59158     return SQLCIPHER_TOOBIG;
59159   }
59160
59161   return SQLCIPHER_OK;
59162 }
59163
59164 /*
59165 ** Compare the values contained by the two memory cells, returning
59166 ** negative, zero or positive if pMem1 is less than, equal to, or greater
59167 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
59168 ** and reals) sorted numerically, followed by text ordered by the collating
59169 ** sequence pColl and finally blob's ordered by memcmp().
59170 **
59171 ** Two NULL values are considered equal by this function.
59172 */
59173 SQLCIPHER_PRIVATE int sqlcipher3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
59174   int rc;
59175   int f1, f2;
59176   int combined_flags;
59177
59178   f1 = pMem1->flags;
59179   f2 = pMem2->flags;
59180   combined_flags = f1|f2;
59181   assert( (combined_flags & MEM_RowSet)==0 );
59182  
59183   /* If one value is NULL, it is less than the other. If both values
59184   ** are NULL, return 0.
59185   */
59186   if( combined_flags&MEM_Null ){
59187     return (f2&MEM_Null) - (f1&MEM_Null);
59188   }
59189
59190   /* If one value is a number and the other is not, the number is less.
59191   ** If both are numbers, compare as reals if one is a real, or as integers
59192   ** if both values are integers.
59193   */
59194   if( combined_flags&(MEM_Int|MEM_Real) ){
59195     if( !(f1&(MEM_Int|MEM_Real)) ){
59196       return 1;
59197     }
59198     if( !(f2&(MEM_Int|MEM_Real)) ){
59199       return -1;
59200     }
59201     if( (f1 & f2 & MEM_Int)==0 ){
59202       double r1, r2;
59203       if( (f1&MEM_Real)==0 ){
59204         r1 = (double)pMem1->u.i;
59205       }else{
59206         r1 = pMem1->r;
59207       }
59208       if( (f2&MEM_Real)==0 ){
59209         r2 = (double)pMem2->u.i;
59210       }else{
59211         r2 = pMem2->r;
59212       }
59213       if( r1<r2 ) return -1;
59214       if( r1>r2 ) return 1;
59215       return 0;
59216     }else{
59217       assert( f1&MEM_Int );
59218       assert( f2&MEM_Int );
59219       if( pMem1->u.i < pMem2->u.i ) return -1;
59220       if( pMem1->u.i > pMem2->u.i ) return 1;
59221       return 0;
59222     }
59223   }
59224
59225   /* If one value is a string and the other is a blob, the string is less.
59226   ** If both are strings, compare using the collating functions.
59227   */
59228   if( combined_flags&MEM_Str ){
59229     if( (f1 & MEM_Str)==0 ){
59230       return 1;
59231     }
59232     if( (f2 & MEM_Str)==0 ){
59233       return -1;
59234     }
59235
59236     assert( pMem1->enc==pMem2->enc );
59237     assert( pMem1->enc==SQLCIPHER_UTF8 || 
59238             pMem1->enc==SQLCIPHER_UTF16LE || pMem1->enc==SQLCIPHER_UTF16BE );
59239
59240     /* The collation sequence must be defined at this point, even if
59241     ** the user deletes the collation sequence after the vdbe program is
59242     ** compiled (this was not always the case).
59243     */
59244     assert( !pColl || pColl->xCmp );
59245
59246     if( pColl ){
59247       if( pMem1->enc==pColl->enc ){
59248         /* The strings are already in the correct encoding.  Call the
59249         ** comparison function directly */
59250         return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
59251       }else{
59252         const void *v1, *v2;
59253         int n1, n2;
59254         Mem c1;
59255         Mem c2;
59256         memset(&c1, 0, sizeof(c1));
59257         memset(&c2, 0, sizeof(c2));
59258         sqlcipher3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
59259         sqlcipher3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
59260         v1 = sqlcipher3ValueText((sqlcipher3_value*)&c1, pColl->enc);
59261         n1 = v1==0 ? 0 : c1.n;
59262         v2 = sqlcipher3ValueText((sqlcipher3_value*)&c2, pColl->enc);
59263         n2 = v2==0 ? 0 : c2.n;
59264         rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
59265         sqlcipher3VdbeMemRelease(&c1);
59266         sqlcipher3VdbeMemRelease(&c2);
59267         return rc;
59268       }
59269     }
59270     /* If a NULL pointer was passed as the collate function, fall through
59271     ** to the blob case and use memcmp().  */
59272   }
59273  
59274   /* Both values must be blobs.  Compare using memcmp().  */
59275   rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
59276   if( rc==0 ){
59277     rc = pMem1->n - pMem2->n;
59278   }
59279   return rc;
59280 }
59281
59282 /*
59283 ** Move data out of a btree key or data field and into a Mem structure.
59284 ** The data or key is taken from the entry that pCur is currently pointing
59285 ** to.  offset and amt determine what portion of the data or key to retrieve.
59286 ** key is true to get the key or false to get data.  The result is written
59287 ** into the pMem element.
59288 **
59289 ** The pMem structure is assumed to be uninitialized.  Any prior content
59290 ** is overwritten without being freed.
59291 **
59292 ** If this routine fails for any reason (malloc returns NULL or unable
59293 ** to read from the disk) then the pMem is left in an inconsistent state.
59294 */
59295 SQLCIPHER_PRIVATE int sqlcipher3VdbeMemFromBtree(
59296   BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
59297   int offset,       /* Offset from the start of data to return bytes from. */
59298   int amt,          /* Number of bytes to return. */
59299   int key,          /* If true, retrieve from the btree key, not data. */
59300   Mem *pMem         /* OUT: Return data in this Mem structure. */
59301 ){
59302   char *zData;        /* Data from the btree layer */
59303   int available = 0;  /* Number of bytes available on the local btree page */
59304   int rc = SQLCIPHER_OK; /* Return code */
59305
59306   assert( sqlcipher3BtreeCursorIsValid(pCur) );
59307
59308   /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert() 
59309   ** that both the BtShared and database handle mutexes are held. */
59310   assert( (pMem->flags & MEM_RowSet)==0 );
59311   if( key ){
59312     zData = (char *)sqlcipher3BtreeKeyFetch(pCur, &available);
59313   }else{
59314     zData = (char *)sqlcipher3BtreeDataFetch(pCur, &available);
59315   }
59316   assert( zData!=0 );
59317
59318   if( offset+amt<=available && (pMem->flags&MEM_Dyn)==0 ){
59319     sqlcipher3VdbeMemRelease(pMem);
59320     pMem->z = &zData[offset];
59321     pMem->flags = MEM_Blob|MEM_Ephem;
59322   }else if( SQLCIPHER_OK==(rc = sqlcipher3VdbeMemGrow(pMem, amt+2, 0)) ){
59323     pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
59324     pMem->enc = 0;
59325     pMem->type = SQLCIPHER_BLOB;
59326     if( key ){
59327       rc = sqlcipher3BtreeKey(pCur, offset, amt, pMem->z);
59328     }else{
59329       rc = sqlcipher3BtreeData(pCur, offset, amt, pMem->z);
59330     }
59331     pMem->z[amt] = 0;
59332     pMem->z[amt+1] = 0;
59333     if( rc!=SQLCIPHER_OK ){
59334       sqlcipher3VdbeMemRelease(pMem);
59335     }
59336   }
59337   pMem->n = amt;
59338
59339   return rc;
59340 }
59341
59342 /* This function is only available internally, it is not part of the
59343 ** external API. It works in a similar way to sqlcipher3_value_text(),
59344 ** except the data returned is in the encoding specified by the second
59345 ** parameter, which must be one of SQLCIPHER_UTF16BE, SQLCIPHER_UTF16LE or
59346 ** SQLCIPHER_UTF8.
59347 **
59348 ** (2006-02-16:)  The enc value can be or-ed with SQLCIPHER_UTF16_ALIGNED.
59349 ** If that is the case, then the result must be aligned on an even byte
59350 ** boundary.
59351 */
59352 SQLCIPHER_PRIVATE const void *sqlcipher3ValueText(sqlcipher3_value* pVal, u8 enc){
59353   if( !pVal ) return 0;
59354
59355   assert( pVal->db==0 || sqlcipher3_mutex_held(pVal->db->mutex) );
59356   assert( (enc&3)==(enc&~SQLCIPHER_UTF16_ALIGNED) );
59357   assert( (pVal->flags & MEM_RowSet)==0 );
59358
59359   if( pVal->flags&MEM_Null ){
59360     return 0;
59361   }
59362   assert( (MEM_Blob>>3) == MEM_Str );
59363   pVal->flags |= (pVal->flags & MEM_Blob)>>3;
59364   expandBlob(pVal);
59365   if( pVal->flags&MEM_Str ){
59366     sqlcipher3VdbeChangeEncoding(pVal, enc & ~SQLCIPHER_UTF16_ALIGNED);
59367     if( (enc & SQLCIPHER_UTF16_ALIGNED)!=0 && 1==(1&SQLCIPHER_PTR_TO_INT(pVal->z)) ){
59368       assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
59369       if( sqlcipher3VdbeMemMakeWriteable(pVal)!=SQLCIPHER_OK ){
59370         return 0;
59371       }
59372     }
59373     sqlcipher3VdbeMemNulTerminate(pVal); /* IMP: R-59893-45467 */
59374   }else{
59375     assert( (pVal->flags&MEM_Blob)==0 );
59376     sqlcipher3VdbeMemStringify(pVal, enc);
59377     assert( 0==(1&SQLCIPHER_PTR_TO_INT(pVal->z)) );
59378   }
59379   assert(pVal->enc==(enc & ~SQLCIPHER_UTF16_ALIGNED) || pVal->db==0
59380               || pVal->db->mallocFailed );
59381   if( pVal->enc==(enc & ~SQLCIPHER_UTF16_ALIGNED) ){
59382     return pVal->z;
59383   }else{
59384     return 0;
59385   }
59386 }
59387
59388 /*
59389 ** Create a new sqlcipher3_value object.
59390 */
59391 SQLCIPHER_PRIVATE sqlcipher3_value *sqlcipher3ValueNew(sqlcipher3 *db){
59392   Mem *p = sqlcipher3DbMallocZero(db, sizeof(*p));
59393   if( p ){
59394     p->flags = MEM_Null;
59395     p->type = SQLCIPHER_NULL;
59396     p->db = db;
59397   }
59398   return p;
59399 }
59400
59401 /*
59402 ** Create a new sqlcipher3_value object, containing the value of pExpr.
59403 **
59404 ** This only works for very simple expressions that consist of one constant
59405 ** token (i.e. "5", "5.1", "'a string'"). If the expression can
59406 ** be converted directly into a value, then the value is allocated and
59407 ** a pointer written to *ppVal. The caller is responsible for deallocating
59408 ** the value by passing it to sqlcipher3ValueFree() later on. If the expression
59409 ** cannot be converted to a value, then *ppVal is set to NULL.
59410 */
59411 SQLCIPHER_PRIVATE int sqlcipher3ValueFromExpr(
59412   sqlcipher3 *db,              /* The database connection */
59413   Expr *pExpr,              /* The expression to evaluate */
59414   u8 enc,                   /* Encoding to use */
59415   u8 affinity,              /* Affinity to use */
59416   sqlcipher3_value **ppVal     /* Write the new value here */
59417 ){
59418   int op;
59419   char *zVal = 0;
59420   sqlcipher3_value *pVal = 0;
59421   int negInt = 1;
59422   const char *zNeg = "";
59423
59424   if( !pExpr ){
59425     *ppVal = 0;
59426     return SQLCIPHER_OK;
59427   }
59428   op = pExpr->op;
59429
59430   /* op can only be TK_REGISTER if we have compiled with SQLCIPHER_ENABLE_STAT3.
59431   ** The ifdef here is to enable us to achieve 100% branch test coverage even
59432   ** when SQLCIPHER_ENABLE_STAT3 is omitted.
59433   */
59434 #ifdef SQLCIPHER_ENABLE_STAT3
59435   if( op==TK_REGISTER ) op = pExpr->op2;
59436 #else
59437   if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
59438 #endif
59439
59440   /* Handle negative integers in a single step.  This is needed in the
59441   ** case when the value is -9223372036854775808.
59442   */
59443   if( op==TK_UMINUS
59444    && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
59445     pExpr = pExpr->pLeft;
59446     op = pExpr->op;
59447     negInt = -1;
59448     zNeg = "-";
59449   }
59450
59451   if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
59452     pVal = sqlcipher3ValueNew(db);
59453     if( pVal==0 ) goto no_mem;
59454     if( ExprHasProperty(pExpr, EP_IntValue) ){
59455       sqlcipher3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
59456     }else{
59457       zVal = sqlcipher3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
59458       if( zVal==0 ) goto no_mem;
59459       sqlcipher3ValueSetStr(pVal, -1, zVal, SQLCIPHER_UTF8, SQLCIPHER_DYNAMIC);
59460       if( op==TK_FLOAT ) pVal->type = SQLCIPHER_FLOAT;
59461     }
59462     if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLCIPHER_AFF_NONE ){
59463       sqlcipher3ValueApplyAffinity(pVal, SQLCIPHER_AFF_NUMERIC, SQLCIPHER_UTF8);
59464     }else{
59465       sqlcipher3ValueApplyAffinity(pVal, affinity, SQLCIPHER_UTF8);
59466     }
59467     if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
59468     if( enc!=SQLCIPHER_UTF8 ){
59469       sqlcipher3VdbeChangeEncoding(pVal, enc);
59470     }
59471   }else if( op==TK_UMINUS ) {
59472     /* This branch happens for multiple negative signs.  Ex: -(-5) */
59473     if( SQLCIPHER_OK==sqlcipher3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
59474       sqlcipher3VdbeMemNumerify(pVal);
59475       if( pVal->u.i==SMALLEST_INT64 ){
59476         pVal->flags &= MEM_Int;
59477         pVal->flags |= MEM_Real;
59478         pVal->r = (double)LARGEST_INT64;
59479       }else{
59480         pVal->u.i = -pVal->u.i;
59481       }
59482       pVal->r = -pVal->r;
59483       sqlcipher3ValueApplyAffinity(pVal, affinity, enc);
59484     }
59485   }else if( op==TK_NULL ){
59486     pVal = sqlcipher3ValueNew(db);
59487     if( pVal==0 ) goto no_mem;
59488   }
59489 #ifndef SQLCIPHER_OMIT_BLOB_LITERAL
59490   else if( op==TK_BLOB ){
59491     int nVal;
59492     assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
59493     assert( pExpr->u.zToken[1]=='\'' );
59494     pVal = sqlcipher3ValueNew(db);
59495     if( !pVal ) goto no_mem;
59496     zVal = &pExpr->u.zToken[2];
59497     nVal = sqlcipher3Strlen30(zVal)-1;
59498     assert( zVal[nVal]=='\'' );
59499     sqlcipher3VdbeMemSetStr(pVal, sqlcipher3HexToBlob(db, zVal, nVal), nVal/2,
59500                          0, SQLCIPHER_DYNAMIC);
59501   }
59502 #endif
59503
59504   if( pVal ){
59505     sqlcipher3VdbeMemStoreType(pVal);
59506   }
59507   *ppVal = pVal;
59508   return SQLCIPHER_OK;
59509
59510 no_mem:
59511   db->mallocFailed = 1;
59512   sqlcipher3DbFree(db, zVal);
59513   sqlcipher3ValueFree(pVal);
59514   *ppVal = 0;
59515   return SQLCIPHER_NOMEM;
59516 }
59517
59518 /*
59519 ** Change the string value of an sqlcipher3_value object
59520 */
59521 SQLCIPHER_PRIVATE void sqlcipher3ValueSetStr(
59522   sqlcipher3_value *v,     /* Value to be set */
59523   int n,                /* Length of string z */
59524   const void *z,        /* Text of the new string */
59525   u8 enc,               /* Encoding to use */
59526   void (*xDel)(void*)   /* Destructor for the string */
59527 ){
59528   if( v ) sqlcipher3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
59529 }
59530
59531 /*
59532 ** Free an sqlcipher3_value object
59533 */
59534 SQLCIPHER_PRIVATE void sqlcipher3ValueFree(sqlcipher3_value *v){
59535   if( !v ) return;
59536   sqlcipher3VdbeMemRelease((Mem *)v);
59537   sqlcipher3DbFree(((Mem*)v)->db, v);
59538 }
59539
59540 /*
59541 ** Return the number of bytes in the sqlcipher3_value object assuming
59542 ** that it uses the encoding "enc"
59543 */
59544 SQLCIPHER_PRIVATE int sqlcipher3ValueBytes(sqlcipher3_value *pVal, u8 enc){
59545   Mem *p = (Mem*)pVal;
59546   if( (p->flags & MEM_Blob)!=0 || sqlcipher3ValueText(pVal, enc) ){
59547     if( p->flags & MEM_Zero ){
59548       return p->n + p->u.nZero;
59549     }else{
59550       return p->n;
59551     }
59552   }
59553   return 0;
59554 }
59555
59556 /************** End of vdbemem.c *********************************************/
59557 /************** Begin file vdbeaux.c *****************************************/
59558 /*
59559 ** 2003 September 6
59560 **
59561 ** The author disclaims copyright to this source code.  In place of
59562 ** a legal notice, here is a blessing:
59563 **
59564 **    May you do good and not evil.
59565 **    May you find forgiveness for yourself and forgive others.
59566 **    May you share freely, never taking more than you give.
59567 **
59568 *************************************************************************
59569 ** This file contains code used for creating, destroying, and populating
59570 ** a VDBE (or an "sqlcipher3_stmt" as it is known to the outside world.)  Prior
59571 ** to version 2.8.7, all this code was combined into the vdbe.c source file.
59572 ** But that file was getting too big so this subroutines were split out.
59573 */
59574
59575
59576
59577 /*
59578 ** When debugging the code generator in a symbolic debugger, one can
59579 ** set the sqlcipher3VdbeAddopTrace to 1 and all opcodes will be printed
59580 ** as they are added to the instruction stream.
59581 */
59582 #ifdef SQLCIPHER_DEBUG
59583 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddopTrace = 0;
59584 #endif
59585
59586
59587 /*
59588 ** Create a new virtual database engine.
59589 */
59590 SQLCIPHER_PRIVATE Vdbe *sqlcipher3VdbeCreate(sqlcipher3 *db){
59591   Vdbe *p;
59592   p = sqlcipher3DbMallocZero(db, sizeof(Vdbe) );
59593   if( p==0 ) return 0;
59594   p->db = db;
59595   if( db->pVdbe ){
59596     db->pVdbe->pPrev = p;
59597   }
59598   p->pNext = db->pVdbe;
59599   p->pPrev = 0;
59600   db->pVdbe = p;
59601   p->magic = VDBE_MAGIC_INIT;
59602   return p;
59603 }
59604
59605 /*
59606 ** Remember the SQL string for a prepared statement.
59607 */
59608 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
59609   assert( isPrepareV2==1 || isPrepareV2==0 );
59610   if( p==0 ) return;
59611 #ifdef SQLCIPHER_OMIT_TRACE
59612   if( !isPrepareV2 ) return;
59613 #endif
59614   assert( p->zSql==0 );
59615   p->zSql = sqlcipher3DbStrNDup(p->db, z, n);
59616   p->isPrepareV2 = (u8)isPrepareV2;
59617 }
59618
59619 /*
59620 ** Return the SQL associated with a prepared statement
59621 */
59622 SQLCIPHER_API const char *sqlcipher3_sql(sqlcipher3_stmt *pStmt){
59623   Vdbe *p = (Vdbe *)pStmt;
59624   return (p && p->isPrepareV2) ? p->zSql : 0;
59625 }
59626
59627 /*
59628 ** Swap all content between two VDBE structures.
59629 */
59630 SQLCIPHER_PRIVATE void sqlcipher3VdbeSwap(Vdbe *pA, Vdbe *pB){
59631   Vdbe tmp, *pTmp;
59632   char *zTmp;
59633   tmp = *pA;
59634   *pA = *pB;
59635   *pB = tmp;
59636   pTmp = pA->pNext;
59637   pA->pNext = pB->pNext;
59638   pB->pNext = pTmp;
59639   pTmp = pA->pPrev;
59640   pA->pPrev = pB->pPrev;
59641   pB->pPrev = pTmp;
59642   zTmp = pA->zSql;
59643   pA->zSql = pB->zSql;
59644   pB->zSql = zTmp;
59645   pB->isPrepareV2 = pA->isPrepareV2;
59646 }
59647
59648 #ifdef SQLCIPHER_DEBUG
59649 /*
59650 ** Turn tracing on or off
59651 */
59652 SQLCIPHER_PRIVATE void sqlcipher3VdbeTrace(Vdbe *p, FILE *trace){
59653   p->trace = trace;
59654 }
59655 #endif
59656
59657 /*
59658 ** Resize the Vdbe.aOp array so that it is at least one op larger than 
59659 ** it was.
59660 **
59661 ** If an out-of-memory error occurs while resizing the array, return
59662 ** SQLCIPHER_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain 
59663 ** unchanged (this is so that any opcodes already allocated can be 
59664 ** correctly deallocated along with the rest of the Vdbe).
59665 */
59666 static int growOpArray(Vdbe *p){
59667   VdbeOp *pNew;
59668   int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
59669   pNew = sqlcipher3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
59670   if( pNew ){
59671     p->nOpAlloc = sqlcipher3DbMallocSize(p->db, pNew)/sizeof(Op);
59672     p->aOp = pNew;
59673   }
59674   return (pNew ? SQLCIPHER_OK : SQLCIPHER_NOMEM);
59675 }
59676
59677 /*
59678 ** Add a new instruction to the list of instructions current in the
59679 ** VDBE.  Return the address of the new instruction.
59680 **
59681 ** Parameters:
59682 **
59683 **    p               Pointer to the VDBE
59684 **
59685 **    op              The opcode for this instruction
59686 **
59687 **    p1, p2, p3      Operands
59688 **
59689 ** Use the sqlcipher3VdbeResolveLabel() function to fix an address and
59690 ** the sqlcipher3VdbeChangeP4() function to change the value of the P4
59691 ** operand.
59692 */
59693 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
59694   int i;
59695   VdbeOp *pOp;
59696
59697   i = p->nOp;
59698   assert( p->magic==VDBE_MAGIC_INIT );
59699   assert( op>0 && op<0xff );
59700   if( p->nOpAlloc<=i ){
59701     if( growOpArray(p) ){
59702       return 1;
59703     }
59704   }
59705   p->nOp++;
59706   pOp = &p->aOp[i];
59707   pOp->opcode = (u8)op;
59708   pOp->p5 = 0;
59709   pOp->p1 = p1;
59710   pOp->p2 = p2;
59711   pOp->p3 = p3;
59712   pOp->p4.p = 0;
59713   pOp->p4type = P4_NOTUSED;
59714 #ifdef SQLCIPHER_DEBUG
59715   pOp->zComment = 0;
59716   if( sqlcipher3VdbeAddopTrace ) sqlcipher3VdbePrintOp(0, i, &p->aOp[i]);
59717 #endif
59718 #ifdef VDBE_PROFILE
59719   pOp->cycles = 0;
59720   pOp->cnt = 0;
59721 #endif
59722   return i;
59723 }
59724 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp0(Vdbe *p, int op){
59725   return sqlcipher3VdbeAddOp3(p, op, 0, 0, 0);
59726 }
59727 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp1(Vdbe *p, int op, int p1){
59728   return sqlcipher3VdbeAddOp3(p, op, p1, 0, 0);
59729 }
59730 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
59731   return sqlcipher3VdbeAddOp3(p, op, p1, p2, 0);
59732 }
59733
59734
59735 /*
59736 ** Add an opcode that includes the p4 value as a pointer.
59737 */
59738 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp4(
59739   Vdbe *p,            /* Add the opcode to this VM */
59740   int op,             /* The new opcode */
59741   int p1,             /* The P1 operand */
59742   int p2,             /* The P2 operand */
59743   int p3,             /* The P3 operand */
59744   const char *zP4,    /* The P4 operand */
59745   int p4type          /* P4 operand type */
59746 ){
59747   int addr = sqlcipher3VdbeAddOp3(p, op, p1, p2, p3);
59748   sqlcipher3VdbeChangeP4(p, addr, zP4, p4type);
59749   return addr;
59750 }
59751
59752 /*
59753 ** Add an OP_ParseSchema opcode.  This routine is broken out from
59754 ** sqlcipher3VdbeAddOp4() since it needs to also local all btrees.
59755 **
59756 ** The zWhere string must have been obtained from sqlcipher3_malloc().
59757 ** This routine will take ownership of the allocated memory.
59758 */
59759 SQLCIPHER_PRIVATE void sqlcipher3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
59760   int j;
59761   int addr = sqlcipher3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0);
59762   sqlcipher3VdbeChangeP4(p, addr, zWhere, P4_DYNAMIC);
59763   for(j=0; j<p->db->nDb; j++) sqlcipher3VdbeUsesBtree(p, j);
59764 }
59765
59766 /*
59767 ** Add an opcode that includes the p4 value as an integer.
59768 */
59769 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOp4Int(
59770   Vdbe *p,            /* Add the opcode to this VM */
59771   int op,             /* The new opcode */
59772   int p1,             /* The P1 operand */
59773   int p2,             /* The P2 operand */
59774   int p3,             /* The P3 operand */
59775   int p4              /* The P4 operand as an integer */
59776 ){
59777   int addr = sqlcipher3VdbeAddOp3(p, op, p1, p2, p3);
59778   sqlcipher3VdbeChangeP4(p, addr, SQLCIPHER_INT_TO_PTR(p4), P4_INT32);
59779   return addr;
59780 }
59781
59782 /*
59783 ** Create a new symbolic label for an instruction that has yet to be
59784 ** coded.  The symbolic label is really just a negative number.  The
59785 ** label can be used as the P2 value of an operation.  Later, when
59786 ** the label is resolved to a specific address, the VDBE will scan
59787 ** through its operation list and change all values of P2 which match
59788 ** the label into the resolved address.
59789 **
59790 ** The VDBE knows that a P2 value is a label because labels are
59791 ** always negative and P2 values are suppose to be non-negative.
59792 ** Hence, a negative P2 value is a label that has yet to be resolved.
59793 **
59794 ** Zero is returned if a malloc() fails.
59795 */
59796 SQLCIPHER_PRIVATE int sqlcipher3VdbeMakeLabel(Vdbe *p){
59797   int i;
59798   i = p->nLabel++;
59799   assert( p->magic==VDBE_MAGIC_INIT );
59800   if( i>=p->nLabelAlloc ){
59801     int n = p->nLabelAlloc*2 + 5;
59802     p->aLabel = sqlcipher3DbReallocOrFree(p->db, p->aLabel,
59803                                        n*sizeof(p->aLabel[0]));
59804     p->nLabelAlloc = sqlcipher3DbMallocSize(p->db, p->aLabel)/sizeof(p->aLabel[0]);
59805   }
59806   if( p->aLabel ){
59807     p->aLabel[i] = -1;
59808   }
59809   return -1-i;
59810 }
59811
59812 /*
59813 ** Resolve label "x" to be the address of the next instruction to
59814 ** be inserted.  The parameter "x" must have been obtained from
59815 ** a prior call to sqlcipher3VdbeMakeLabel().
59816 */
59817 SQLCIPHER_PRIVATE void sqlcipher3VdbeResolveLabel(Vdbe *p, int x){
59818   int j = -1-x;
59819   assert( p->magic==VDBE_MAGIC_INIT );
59820   assert( j>=0 && j<p->nLabel );
59821   if( p->aLabel ){
59822     p->aLabel[j] = p->nOp;
59823   }
59824 }
59825
59826 /*
59827 ** Mark the VDBE as one that can only be run one time.
59828 */
59829 SQLCIPHER_PRIVATE void sqlcipher3VdbeRunOnlyOnce(Vdbe *p){
59830   p->runOnlyOnce = 1;
59831 }
59832
59833 #ifdef SQLCIPHER_DEBUG /* sqlcipher3AssertMayAbort() logic */
59834
59835 /*
59836 ** The following type and function are used to iterate through all opcodes
59837 ** in a Vdbe main program and each of the sub-programs (triggers) it may 
59838 ** invoke directly or indirectly. It should be used as follows:
59839 **
59840 **   Op *pOp;
59841 **   VdbeOpIter sIter;
59842 **
59843 **   memset(&sIter, 0, sizeof(sIter));
59844 **   sIter.v = v;                            // v is of type Vdbe* 
59845 **   while( (pOp = opIterNext(&sIter)) ){
59846 **     // Do something with pOp
59847 **   }
59848 **   sqlcipher3DbFree(v->db, sIter.apSub);
59849 ** 
59850 */
59851 typedef struct VdbeOpIter VdbeOpIter;
59852 struct VdbeOpIter {
59853   Vdbe *v;                   /* Vdbe to iterate through the opcodes of */
59854   SubProgram **apSub;        /* Array of subprograms */
59855   int nSub;                  /* Number of entries in apSub */
59856   int iAddr;                 /* Address of next instruction to return */
59857   int iSub;                  /* 0 = main program, 1 = first sub-program etc. */
59858 };
59859 static Op *opIterNext(VdbeOpIter *p){
59860   Vdbe *v = p->v;
59861   Op *pRet = 0;
59862   Op *aOp;
59863   int nOp;
59864
59865   if( p->iSub<=p->nSub ){
59866
59867     if( p->iSub==0 ){
59868       aOp = v->aOp;
59869       nOp = v->nOp;
59870     }else{
59871       aOp = p->apSub[p->iSub-1]->aOp;
59872       nOp = p->apSub[p->iSub-1]->nOp;
59873     }
59874     assert( p->iAddr<nOp );
59875
59876     pRet = &aOp[p->iAddr];
59877     p->iAddr++;
59878     if( p->iAddr==nOp ){
59879       p->iSub++;
59880       p->iAddr = 0;
59881     }
59882   
59883     if( pRet->p4type==P4_SUBPROGRAM ){
59884       int nByte = (p->nSub+1)*sizeof(SubProgram*);
59885       int j;
59886       for(j=0; j<p->nSub; j++){
59887         if( p->apSub[j]==pRet->p4.pProgram ) break;
59888       }
59889       if( j==p->nSub ){
59890         p->apSub = sqlcipher3DbReallocOrFree(v->db, p->apSub, nByte);
59891         if( !p->apSub ){
59892           pRet = 0;
59893         }else{
59894           p->apSub[p->nSub++] = pRet->p4.pProgram;
59895         }
59896       }
59897     }
59898   }
59899
59900   return pRet;
59901 }
59902
59903 /*
59904 ** Check if the program stored in the VM associated with pParse may
59905 ** throw an ABORT exception (causing the statement, but not entire transaction
59906 ** to be rolled back). This condition is true if the main program or any
59907 ** sub-programs contains any of the following:
59908 **
59909 **   *  OP_Halt with P1=SQLCIPHER_CONSTRAINT and P2=OE_Abort.
59910 **   *  OP_HaltIfNull with P1=SQLCIPHER_CONSTRAINT and P2=OE_Abort.
59911 **   *  OP_Destroy
59912 **   *  OP_VUpdate
59913 **   *  OP_VRename
59914 **   *  OP_FkCounter with P2==0 (immediate foreign key constraint)
59915 **
59916 ** Then check that the value of Parse.mayAbort is true if an
59917 ** ABORT may be thrown, or false otherwise. Return true if it does
59918 ** match, or false otherwise. This function is intended to be used as
59919 ** part of an assert statement in the compiler. Similar to:
59920 **
59921 **   assert( sqlcipher3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
59922 */
59923 SQLCIPHER_PRIVATE int sqlcipher3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
59924   int hasAbort = 0;
59925   Op *pOp;
59926   VdbeOpIter sIter;
59927   memset(&sIter, 0, sizeof(sIter));
59928   sIter.v = v;
59929
59930   while( (pOp = opIterNext(&sIter))!=0 ){
59931     int opcode = pOp->opcode;
59932     if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename 
59933 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
59934      || (opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1) 
59935 #endif
59936      || ((opcode==OP_Halt || opcode==OP_HaltIfNull) 
59937       && (pOp->p1==SQLCIPHER_CONSTRAINT && pOp->p2==OE_Abort))
59938     ){
59939       hasAbort = 1;
59940       break;
59941     }
59942   }
59943   sqlcipher3DbFree(v->db, sIter.apSub);
59944
59945   /* Return true if hasAbort==mayAbort. Or if a malloc failure occured.
59946   ** If malloc failed, then the while() loop above may not have iterated
59947   ** through all opcodes and hasAbort may be set incorrectly. Return
59948   ** true for this case to prevent the assert() in the callers frame
59949   ** from failing.  */
59950   return ( v->db->mallocFailed || hasAbort==mayAbort );
59951 }
59952 #endif /* SQLCIPHER_DEBUG - the sqlcipher3AssertMayAbort() function */
59953
59954 /*
59955 ** Loop through the program looking for P2 values that are negative
59956 ** on jump instructions.  Each such value is a label.  Resolve the
59957 ** label by setting the P2 value to its correct non-zero value.
59958 **
59959 ** This routine is called once after all opcodes have been inserted.
59960 **
59961 ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument 
59962 ** to an OP_Function, OP_AggStep or OP_VFilter opcode. This is used by 
59963 ** sqlcipher3VdbeMakeReady() to size the Vdbe.apArg[] array.
59964 **
59965 ** The Op.opflags field is set on all opcodes.
59966 */
59967 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
59968   int i;
59969   int nMaxArgs = *pMaxFuncArgs;
59970   Op *pOp;
59971   int *aLabel = p->aLabel;
59972   p->readOnly = 1;
59973   for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
59974     u8 opcode = pOp->opcode;
59975
59976     pOp->opflags = sqlcipher3OpcodeProperty[opcode];
59977     if( opcode==OP_Function || opcode==OP_AggStep ){
59978       if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5;
59979     }else if( (opcode==OP_Transaction && pOp->p2!=0) || opcode==OP_Vacuum ){
59980       p->readOnly = 0;
59981 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
59982     }else if( opcode==OP_VUpdate ){
59983       if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
59984     }else if( opcode==OP_VFilter ){
59985       int n;
59986       assert( p->nOp - i >= 3 );
59987       assert( pOp[-1].opcode==OP_Integer );
59988       n = pOp[-1].p1;
59989       if( n>nMaxArgs ) nMaxArgs = n;
59990 #endif
59991     }else if( opcode==OP_Next || opcode==OP_SorterNext ){
59992       pOp->p4.xAdvance = sqlcipher3BtreeNext;
59993       pOp->p4type = P4_ADVANCE;
59994     }else if( opcode==OP_Prev ){
59995       pOp->p4.xAdvance = sqlcipher3BtreePrevious;
59996       pOp->p4type = P4_ADVANCE;
59997     }
59998
59999     if( (pOp->opflags & OPFLG_JUMP)!=0 && pOp->p2<0 ){
60000       assert( -1-pOp->p2<p->nLabel );
60001       pOp->p2 = aLabel[-1-pOp->p2];
60002     }
60003   }
60004   sqlcipher3DbFree(p->db, p->aLabel);
60005   p->aLabel = 0;
60006
60007   *pMaxFuncArgs = nMaxArgs;
60008 }
60009
60010 /*
60011 ** Return the address of the next instruction to be inserted.
60012 */
60013 SQLCIPHER_PRIVATE int sqlcipher3VdbeCurrentAddr(Vdbe *p){
60014   assert( p->magic==VDBE_MAGIC_INIT );
60015   return p->nOp;
60016 }
60017
60018 /*
60019 ** This function returns a pointer to the array of opcodes associated with
60020 ** the Vdbe passed as the first argument. It is the callers responsibility
60021 ** to arrange for the returned array to be eventually freed using the 
60022 ** vdbeFreeOpArray() function.
60023 **
60024 ** Before returning, *pnOp is set to the number of entries in the returned
60025 ** array. Also, *pnMaxArg is set to the larger of its current value and 
60026 ** the number of entries in the Vdbe.apArg[] array required to execute the 
60027 ** returned program.
60028 */
60029 SQLCIPHER_PRIVATE VdbeOp *sqlcipher3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){
60030   VdbeOp *aOp = p->aOp;
60031   assert( aOp && !p->db->mallocFailed );
60032
60033   /* Check that sqlcipher3VdbeUsesBtree() was not called on this VM */
60034   assert( p->btreeMask==0 );
60035
60036   resolveP2Values(p, pnMaxArg);
60037   *pnOp = p->nOp;
60038   p->aOp = 0;
60039   return aOp;
60040 }
60041
60042 /*
60043 ** Add a whole list of operations to the operation stack.  Return the
60044 ** address of the first operation added.
60045 */
60046 SQLCIPHER_PRIVATE int sqlcipher3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
60047   int addr;
60048   assert( p->magic==VDBE_MAGIC_INIT );
60049   if( p->nOp + nOp > p->nOpAlloc && growOpArray(p) ){
60050     return 0;
60051   }
60052   addr = p->nOp;
60053   if( ALWAYS(nOp>0) ){
60054     int i;
60055     VdbeOpList const *pIn = aOp;
60056     for(i=0; i<nOp; i++, pIn++){
60057       int p2 = pIn->p2;
60058       VdbeOp *pOut = &p->aOp[i+addr];
60059       pOut->opcode = pIn->opcode;
60060       pOut->p1 = pIn->p1;
60061       if( p2<0 && (sqlcipher3OpcodeProperty[pOut->opcode] & OPFLG_JUMP)!=0 ){
60062         pOut->p2 = addr + ADDR(p2);
60063       }else{
60064         pOut->p2 = p2;
60065       }
60066       pOut->p3 = pIn->p3;
60067       pOut->p4type = P4_NOTUSED;
60068       pOut->p4.p = 0;
60069       pOut->p5 = 0;
60070 #ifdef SQLCIPHER_DEBUG
60071       pOut->zComment = 0;
60072       if( sqlcipher3VdbeAddopTrace ){
60073         sqlcipher3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
60074       }
60075 #endif
60076     }
60077     p->nOp += nOp;
60078   }
60079   return addr;
60080 }
60081
60082 /*
60083 ** Change the value of the P1 operand for a specific instruction.
60084 ** This routine is useful when a large program is loaded from a
60085 ** static array using sqlcipher3VdbeAddOpList but we want to make a
60086 ** few minor changes to the program.
60087 */
60088 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP1(Vdbe *p, u32 addr, int val){
60089   assert( p!=0 );
60090   if( ((u32)p->nOp)>addr ){
60091     p->aOp[addr].p1 = val;
60092   }
60093 }
60094
60095 /*
60096 ** Change the value of the P2 operand for a specific instruction.
60097 ** This routine is useful for setting a jump destination.
60098 */
60099 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP2(Vdbe *p, u32 addr, int val){
60100   assert( p!=0 );
60101   if( ((u32)p->nOp)>addr ){
60102     p->aOp[addr].p2 = val;
60103   }
60104 }
60105
60106 /*
60107 ** Change the value of the P3 operand for a specific instruction.
60108 */
60109 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP3(Vdbe *p, u32 addr, int val){
60110   assert( p!=0 );
60111   if( ((u32)p->nOp)>addr ){
60112     p->aOp[addr].p3 = val;
60113   }
60114 }
60115
60116 /*
60117 ** Change the value of the P5 operand for the most recently
60118 ** added operation.
60119 */
60120 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP5(Vdbe *p, u8 val){
60121   assert( p!=0 );
60122   if( p->aOp ){
60123     assert( p->nOp>0 );
60124     p->aOp[p->nOp-1].p5 = val;
60125   }
60126 }
60127
60128 /*
60129 ** Change the P2 operand of instruction addr so that it points to
60130 ** the address of the next instruction to be coded.
60131 */
60132 SQLCIPHER_PRIVATE void sqlcipher3VdbeJumpHere(Vdbe *p, int addr){
60133   assert( addr>=0 || p->db->mallocFailed );
60134   if( addr>=0 ) sqlcipher3VdbeChangeP2(p, addr, p->nOp);
60135 }
60136
60137
60138 /*
60139 ** If the input FuncDef structure is ephemeral, then free it.  If
60140 ** the FuncDef is not ephermal, then do nothing.
60141 */
60142 static void freeEphemeralFunction(sqlcipher3 *db, FuncDef *pDef){
60143   if( ALWAYS(pDef) && (pDef->flags & SQLCIPHER_FUNC_EPHEM)!=0 ){
60144     sqlcipher3DbFree(db, pDef);
60145   }
60146 }
60147
60148 static void vdbeFreeOpArray(sqlcipher3 *, Op *, int);
60149
60150 /*
60151 ** Delete a P4 value if necessary.
60152 */
60153 static void freeP4(sqlcipher3 *db, int p4type, void *p4){
60154   if( p4 ){
60155     assert( db );
60156     switch( p4type ){
60157       case P4_REAL:
60158       case P4_INT64:
60159       case P4_DYNAMIC:
60160       case P4_KEYINFO:
60161       case P4_INTARRAY:
60162       case P4_KEYINFO_HANDOFF: {
60163         sqlcipher3DbFree(db, p4);
60164         break;
60165       }
60166       case P4_MPRINTF: {
60167         if( db->pnBytesFreed==0 ) sqlcipher3_free(p4);
60168         break;
60169       }
60170       case P4_VDBEFUNC: {
60171         VdbeFunc *pVdbeFunc = (VdbeFunc *)p4;
60172         freeEphemeralFunction(db, pVdbeFunc->pFunc);
60173         if( db->pnBytesFreed==0 ) sqlcipher3VdbeDeleteAuxData(pVdbeFunc, 0);
60174         sqlcipher3DbFree(db, pVdbeFunc);
60175         break;
60176       }
60177       case P4_FUNCDEF: {
60178         freeEphemeralFunction(db, (FuncDef*)p4);
60179         break;
60180       }
60181       case P4_MEM: {
60182         if( db->pnBytesFreed==0 ){
60183           sqlcipher3ValueFree((sqlcipher3_value*)p4);
60184         }else{
60185           Mem *p = (Mem*)p4;
60186           sqlcipher3DbFree(db, p->zMalloc);
60187           sqlcipher3DbFree(db, p);
60188         }
60189         break;
60190       }
60191       case P4_VTAB : {
60192         if( db->pnBytesFreed==0 ) sqlcipher3VtabUnlock((VTable *)p4);
60193         break;
60194       }
60195     }
60196   }
60197 }
60198
60199 /*
60200 ** Free the space allocated for aOp and any p4 values allocated for the
60201 ** opcodes contained within. If aOp is not NULL it is assumed to contain 
60202 ** nOp entries. 
60203 */
60204 static void vdbeFreeOpArray(sqlcipher3 *db, Op *aOp, int nOp){
60205   if( aOp ){
60206     Op *pOp;
60207     for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
60208       freeP4(db, pOp->p4type, pOp->p4.p);
60209 #ifdef SQLCIPHER_DEBUG
60210       sqlcipher3DbFree(db, pOp->zComment);
60211 #endif     
60212     }
60213   }
60214   sqlcipher3DbFree(db, aOp);
60215 }
60216
60217 /*
60218 ** Link the SubProgram object passed as the second argument into the linked
60219 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
60220 ** objects when the VM is no longer required.
60221 */
60222 SQLCIPHER_PRIVATE void sqlcipher3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
60223   p->pNext = pVdbe->pProgram;
60224   pVdbe->pProgram = p;
60225 }
60226
60227 /*
60228 ** Change the opcode at addr into OP_Noop
60229 */
60230 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeToNoop(Vdbe *p, int addr){
60231   if( p->aOp ){
60232     VdbeOp *pOp = &p->aOp[addr];
60233     sqlcipher3 *db = p->db;
60234     freeP4(db, pOp->p4type, pOp->p4.p);
60235     memset(pOp, 0, sizeof(pOp[0]));
60236     pOp->opcode = OP_Noop;
60237   }
60238 }
60239
60240 /*
60241 ** Change the value of the P4 operand for a specific instruction.
60242 ** This routine is useful when a large program is loaded from a
60243 ** static array using sqlcipher3VdbeAddOpList but we want to make a
60244 ** few minor changes to the program.
60245 **
60246 ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
60247 ** the string is made into memory obtained from sqlcipher3_malloc().
60248 ** A value of n==0 means copy bytes of zP4 up to and including the
60249 ** first null byte.  If n>0 then copy n+1 bytes of zP4.
60250 **
60251 ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
60252 ** A copy is made of the KeyInfo structure into memory obtained from
60253 ** sqlcipher3_malloc, to be freed when the Vdbe is finalized.
60254 ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
60255 ** stored in memory that the caller has obtained from sqlcipher3_malloc. The 
60256 ** caller should not free the allocation, it will be freed when the Vdbe is
60257 ** finalized.
60258 ** 
60259 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
60260 ** to a string or structure that is guaranteed to exist for the lifetime of
60261 ** the Vdbe. In these cases we can just copy the pointer.
60262 **
60263 ** If addr<0 then change P4 on the most recently inserted instruction.
60264 */
60265 SQLCIPHER_PRIVATE void sqlcipher3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
60266   Op *pOp;
60267   sqlcipher3 *db;
60268   assert( p!=0 );
60269   db = p->db;
60270   assert( p->magic==VDBE_MAGIC_INIT );
60271   if( p->aOp==0 || db->mallocFailed ){
60272     if ( n!=P4_KEYINFO && n!=P4_VTAB ) {
60273       freeP4(db, n, (void*)*(char**)&zP4);
60274     }
60275     return;
60276   }
60277   assert( p->nOp>0 );
60278   assert( addr<p->nOp );
60279   if( addr<0 ){
60280     addr = p->nOp - 1;
60281   }
60282   pOp = &p->aOp[addr];
60283   freeP4(db, pOp->p4type, pOp->p4.p);
60284   pOp->p4.p = 0;
60285   if( n==P4_INT32 ){
60286     /* Note: this cast is safe, because the origin data point was an int
60287     ** that was cast to a (const char *). */
60288     pOp->p4.i = SQLCIPHER_PTR_TO_INT(zP4);
60289     pOp->p4type = P4_INT32;
60290   }else if( zP4==0 ){
60291     pOp->p4.p = 0;
60292     pOp->p4type = P4_NOTUSED;
60293   }else if( n==P4_KEYINFO ){
60294     KeyInfo *pKeyInfo;
60295     int nField, nByte;
60296
60297     nField = ((KeyInfo*)zP4)->nField;
60298     nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
60299     pKeyInfo = sqlcipher3DbMallocRaw(0, nByte);
60300     pOp->p4.pKeyInfo = pKeyInfo;
60301     if( pKeyInfo ){
60302       u8 *aSortOrder;
60303       memcpy((char*)pKeyInfo, zP4, nByte - nField);
60304       aSortOrder = pKeyInfo->aSortOrder;
60305       if( aSortOrder ){
60306         pKeyInfo->aSortOrder = (unsigned char*)&pKeyInfo->aColl[nField];
60307         memcpy(pKeyInfo->aSortOrder, aSortOrder, nField);
60308       }
60309       pOp->p4type = P4_KEYINFO;
60310     }else{
60311       p->db->mallocFailed = 1;
60312       pOp->p4type = P4_NOTUSED;
60313     }
60314   }else if( n==P4_KEYINFO_HANDOFF ){
60315     pOp->p4.p = (void*)zP4;
60316     pOp->p4type = P4_KEYINFO;
60317   }else if( n==P4_VTAB ){
60318     pOp->p4.p = (void*)zP4;
60319     pOp->p4type = P4_VTAB;
60320     sqlcipher3VtabLock((VTable *)zP4);
60321     assert( ((VTable *)zP4)->db==p->db );
60322   }else if( n<0 ){
60323     pOp->p4.p = (void*)zP4;
60324     pOp->p4type = (signed char)n;
60325   }else{
60326     if( n==0 ) n = sqlcipher3Strlen30(zP4);
60327     pOp->p4.z = sqlcipher3DbStrNDup(p->db, zP4, n);
60328     pOp->p4type = P4_DYNAMIC;
60329   }
60330 }
60331
60332 #ifndef NDEBUG
60333 /*
60334 ** Change the comment on the the most recently coded instruction.  Or
60335 ** insert a No-op and add the comment to that new instruction.  This
60336 ** makes the code easier to read during debugging.  None of this happens
60337 ** in a production build.
60338 */
60339 static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){
60340   assert( p->nOp>0 || p->aOp==0 );
60341   assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
60342   if( p->nOp ){
60343     assert( p->aOp );
60344     sqlcipher3DbFree(p->db, p->aOp[p->nOp-1].zComment);
60345     p->aOp[p->nOp-1].zComment = sqlcipher3VMPrintf(p->db, zFormat, ap);
60346   }
60347 }
60348 SQLCIPHER_PRIVATE void sqlcipher3VdbeComment(Vdbe *p, const char *zFormat, ...){
60349   va_list ap;
60350   if( p ){
60351     va_start(ap, zFormat);
60352     vdbeVComment(p, zFormat, ap);
60353     va_end(ap);
60354   }
60355 }
60356 SQLCIPHER_PRIVATE void sqlcipher3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
60357   va_list ap;
60358   if( p ){
60359     sqlcipher3VdbeAddOp0(p, OP_Noop);
60360     va_start(ap, zFormat);
60361     vdbeVComment(p, zFormat, ap);
60362     va_end(ap);
60363   }
60364 }
60365 #endif  /* NDEBUG */
60366
60367 /*
60368 ** Return the opcode for a given address.  If the address is -1, then
60369 ** return the most recently inserted opcode.
60370 **
60371 ** If a memory allocation error has occurred prior to the calling of this
60372 ** routine, then a pointer to a dummy VdbeOp will be returned.  That opcode
60373 ** is readable but not writable, though it is cast to a writable value.
60374 ** The return of a dummy opcode allows the call to continue functioning
60375 ** after a OOM fault without having to check to see if the return from 
60376 ** this routine is a valid pointer.  But because the dummy.opcode is 0,
60377 ** dummy will never be written to.  This is verified by code inspection and
60378 ** by running with Valgrind.
60379 **
60380 ** About the #ifdef SQLCIPHER_OMIT_TRACE:  Normally, this routine is never called
60381 ** unless p->nOp>0.  This is because in the absense of SQLCIPHER_OMIT_TRACE,
60382 ** an OP_Trace instruction is always inserted by sqlcipher3VdbeGet() as soon as
60383 ** a new VDBE is created.  So we are free to set addr to p->nOp-1 without
60384 ** having to double-check to make sure that the result is non-negative. But
60385 ** if SQLCIPHER_OMIT_TRACE is defined, the OP_Trace is omitted and we do need to
60386 ** check the value of p->nOp-1 before continuing.
60387 */
60388 SQLCIPHER_PRIVATE VdbeOp *sqlcipher3VdbeGetOp(Vdbe *p, int addr){
60389   /* C89 specifies that the constant "dummy" will be initialized to all
60390   ** zeros, which is correct.  MSVC generates a warning, nevertheless. */
60391   static VdbeOp dummy;  /* Ignore the MSVC warning about no initializer */
60392   assert( p->magic==VDBE_MAGIC_INIT );
60393   if( addr<0 ){
60394 #ifdef SQLCIPHER_OMIT_TRACE
60395     if( p->nOp==0 ) return (VdbeOp*)&dummy;
60396 #endif
60397     addr = p->nOp - 1;
60398   }
60399   assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
60400   if( p->db->mallocFailed ){
60401     return (VdbeOp*)&dummy;
60402   }else{
60403     return &p->aOp[addr];
60404   }
60405 }
60406
60407 #if !defined(SQLCIPHER_OMIT_EXPLAIN) || !defined(NDEBUG) \
60408      || defined(VDBE_PROFILE) || defined(SQLCIPHER_DEBUG)
60409 /*
60410 ** Compute a string that describes the P4 parameter for an opcode.
60411 ** Use zTemp for any required temporary buffer space.
60412 */
60413 static char *displayP4(Op *pOp, char *zTemp, int nTemp){
60414   char *zP4 = zTemp;
60415   assert( nTemp>=20 );
60416   switch( pOp->p4type ){
60417     case P4_KEYINFO_STATIC:
60418     case P4_KEYINFO: {
60419       int i, j;
60420       KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
60421       sqlcipher3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField);
60422       i = sqlcipher3Strlen30(zTemp);
60423       for(j=0; j<pKeyInfo->nField; j++){
60424         CollSeq *pColl = pKeyInfo->aColl[j];
60425         if( pColl ){
60426           int n = sqlcipher3Strlen30(pColl->zName);
60427           if( i+n>nTemp-6 ){
60428             memcpy(&zTemp[i],",...",4);
60429             break;
60430           }
60431           zTemp[i++] = ',';
60432           if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){
60433             zTemp[i++] = '-';
60434           }
60435           memcpy(&zTemp[i], pColl->zName,n+1);
60436           i += n;
60437         }else if( i+4<nTemp-6 ){
60438           memcpy(&zTemp[i],",nil",4);
60439           i += 4;
60440         }
60441       }
60442       zTemp[i++] = ')';
60443       zTemp[i] = 0;
60444       assert( i<nTemp );
60445       break;
60446     }
60447     case P4_COLLSEQ: {
60448       CollSeq *pColl = pOp->p4.pColl;
60449       sqlcipher3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
60450       break;
60451     }
60452     case P4_FUNCDEF: {
60453       FuncDef *pDef = pOp->p4.pFunc;
60454       sqlcipher3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
60455       break;
60456     }
60457     case P4_INT64: {
60458       sqlcipher3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64);
60459       break;
60460     }
60461     case P4_INT32: {
60462       sqlcipher3_snprintf(nTemp, zTemp, "%d", pOp->p4.i);
60463       break;
60464     }
60465     case P4_REAL: {
60466       sqlcipher3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal);
60467       break;
60468     }
60469     case P4_MEM: {
60470       Mem *pMem = pOp->p4.pMem;
60471       assert( (pMem->flags & MEM_Null)==0 );
60472       if( pMem->flags & MEM_Str ){
60473         zP4 = pMem->z;
60474       }else if( pMem->flags & MEM_Int ){
60475         sqlcipher3_snprintf(nTemp, zTemp, "%lld", pMem->u.i);
60476       }else if( pMem->flags & MEM_Real ){
60477         sqlcipher3_snprintf(nTemp, zTemp, "%.16g", pMem->r);
60478       }else{
60479         assert( pMem->flags & MEM_Blob );
60480         zP4 = "(blob)";
60481       }
60482       break;
60483     }
60484 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
60485     case P4_VTAB: {
60486       sqlcipher3_vtab *pVtab = pOp->p4.pVtab->pVtab;
60487       sqlcipher3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule);
60488       break;
60489     }
60490 #endif
60491     case P4_INTARRAY: {
60492       sqlcipher3_snprintf(nTemp, zTemp, "intarray");
60493       break;
60494     }
60495     case P4_SUBPROGRAM: {
60496       sqlcipher3_snprintf(nTemp, zTemp, "program");
60497       break;
60498     }
60499     case P4_ADVANCE: {
60500       zTemp[0] = 0;
60501       break;
60502     }
60503     default: {
60504       zP4 = pOp->p4.z;
60505       if( zP4==0 ){
60506         zP4 = zTemp;
60507         zTemp[0] = 0;
60508       }
60509     }
60510   }
60511   assert( zP4!=0 );
60512   return zP4;
60513 }
60514 #endif
60515
60516 /*
60517 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
60518 **
60519 ** The prepared statements need to know in advance the complete set of
60520 ** attached databases that they will be using.  A mask of these databases
60521 ** is maintained in p->btreeMask and is used for locking and other purposes.
60522 */
60523 SQLCIPHER_PRIVATE void sqlcipher3VdbeUsesBtree(Vdbe *p, int i){
60524   assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
60525   assert( i<(int)sizeof(p->btreeMask)*8 );
60526   p->btreeMask |= ((yDbMask)1)<<i;
60527   if( i!=1 && sqlcipher3BtreeSharable(p->db->aDb[i].pBt) ){
60528     p->lockMask |= ((yDbMask)1)<<i;
60529   }
60530 }
60531
60532 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && SQLCIPHER_THREADSAFE>0
60533 /*
60534 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
60535 ** this routine obtains the mutex associated with each BtShared structure
60536 ** that may be accessed by the VM passed as an argument. In doing so it also
60537 ** sets the BtShared.db member of each of the BtShared structures, ensuring
60538 ** that the correct busy-handler callback is invoked if required.
60539 **
60540 ** If SQLite is not threadsafe but does support shared-cache mode, then
60541 ** sqlcipher3BtreeEnter() is invoked to set the BtShared.db variables
60542 ** of all of BtShared structures accessible via the database handle 
60543 ** associated with the VM.
60544 **
60545 ** If SQLite is not threadsafe and does not support shared-cache mode, this
60546 ** function is a no-op.
60547 **
60548 ** The p->btreeMask field is a bitmask of all btrees that the prepared 
60549 ** statement p will ever use.  Let N be the number of bits in p->btreeMask
60550 ** corresponding to btrees that use shared cache.  Then the runtime of
60551 ** this routine is N*N.  But as N is rarely more than 1, this should not
60552 ** be a problem.
60553 */
60554 SQLCIPHER_PRIVATE void sqlcipher3VdbeEnter(Vdbe *p){
60555   int i;
60556   yDbMask mask;
60557   sqlcipher3 *db;
60558   Db *aDb;
60559   int nDb;
60560   if( p->lockMask==0 ) return;  /* The common case */
60561   db = p->db;
60562   aDb = db->aDb;
60563   nDb = db->nDb;
60564   for(i=0, mask=1; i<nDb; i++, mask += mask){
60565     if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
60566       sqlcipher3BtreeEnter(aDb[i].pBt);
60567     }
60568   }
60569 }
60570 #endif
60571
60572 #if !defined(SQLCIPHER_OMIT_SHARED_CACHE) && SQLCIPHER_THREADSAFE>0
60573 /*
60574 ** Unlock all of the btrees previously locked by a call to sqlcipher3VdbeEnter().
60575 */
60576 SQLCIPHER_PRIVATE void sqlcipher3VdbeLeave(Vdbe *p){
60577   int i;
60578   yDbMask mask;
60579   sqlcipher3 *db;
60580   Db *aDb;
60581   int nDb;
60582   if( p->lockMask==0 ) return;  /* The common case */
60583   db = p->db;
60584   aDb = db->aDb;
60585   nDb = db->nDb;
60586   for(i=0, mask=1; i<nDb; i++, mask += mask){
60587     if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
60588       sqlcipher3BtreeLeave(aDb[i].pBt);
60589     }
60590   }
60591 }
60592 #endif
60593
60594 #if defined(VDBE_PROFILE) || defined(SQLCIPHER_DEBUG)
60595 /*
60596 ** Print a single opcode.  This routine is used for debugging only.
60597 */
60598 SQLCIPHER_PRIVATE void sqlcipher3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
60599   char *zP4;
60600   char zPtr[50];
60601   static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-4s %.2X %s\n";
60602   if( pOut==0 ) pOut = stdout;
60603   zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
60604   fprintf(pOut, zFormat1, pc, 
60605       sqlcipher3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
60606 #ifdef SQLCIPHER_DEBUG
60607       pOp->zComment ? pOp->zComment : ""
60608 #else
60609       ""
60610 #endif
60611   );
60612   fflush(pOut);
60613 }
60614 #endif
60615
60616 /*
60617 ** Release an array of N Mem elements
60618 */
60619 static void releaseMemArray(Mem *p, int N){
60620   if( p && N ){
60621     Mem *pEnd;
60622     sqlcipher3 *db = p->db;
60623     u8 malloc_failed = db->mallocFailed;
60624     if( db->pnBytesFreed ){
60625       for(pEnd=&p[N]; p<pEnd; p++){
60626         sqlcipher3DbFree(db, p->zMalloc);
60627       }
60628       return;
60629     }
60630     for(pEnd=&p[N]; p<pEnd; p++){
60631       assert( (&p[1])==pEnd || p[0].db==p[1].db );
60632
60633       /* This block is really an inlined version of sqlcipher3VdbeMemRelease()
60634       ** that takes advantage of the fact that the memory cell value is 
60635       ** being set to NULL after releasing any dynamic resources.
60636       **
60637       ** The justification for duplicating code is that according to 
60638       ** callgrind, this causes a certain test case to hit the CPU 4.7 
60639       ** percent less (x86 linux, gcc version 4.1.2, -O6) than if 
60640       ** sqlcipher3MemRelease() were called from here. With -O2, this jumps
60641       ** to 6.6 percent. The test case is inserting 1000 rows into a table 
60642       ** with no indexes using a single prepared INSERT statement, bind() 
60643       ** and reset(). Inserts are grouped into a transaction.
60644       */
60645       if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){
60646         sqlcipher3VdbeMemRelease(p);
60647       }else if( p->zMalloc ){
60648         sqlcipher3DbFree(db, p->zMalloc);
60649         p->zMalloc = 0;
60650       }
60651
60652       p->flags = MEM_Null;
60653     }
60654     db->mallocFailed = malloc_failed;
60655   }
60656 }
60657
60658 /*
60659 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
60660 ** allocated by the OP_Program opcode in sqlcipher3VdbeExec().
60661 */
60662 SQLCIPHER_PRIVATE void sqlcipher3VdbeFrameDelete(VdbeFrame *p){
60663   int i;
60664   Mem *aMem = VdbeFrameMem(p);
60665   VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
60666   for(i=0; i<p->nChildCsr; i++){
60667     sqlcipher3VdbeFreeCursor(p->v, apCsr[i]);
60668   }
60669   releaseMemArray(aMem, p->nChildMem);
60670   sqlcipher3DbFree(p->v->db, p);
60671 }
60672
60673 #ifndef SQLCIPHER_OMIT_EXPLAIN
60674 /*
60675 ** Give a listing of the program in the virtual machine.
60676 **
60677 ** The interface is the same as sqlcipher3VdbeExec().  But instead of
60678 ** running the code, it invokes the callback once for each instruction.
60679 ** This feature is used to implement "EXPLAIN".
60680 **
60681 ** When p->explain==1, each instruction is listed.  When
60682 ** p->explain==2, only OP_Explain instructions are listed and these
60683 ** are shown in a different format.  p->explain==2 is used to implement
60684 ** EXPLAIN QUERY PLAN.
60685 **
60686 ** When p->explain==1, first the main program is listed, then each of
60687 ** the trigger subprograms are listed one by one.
60688 */
60689 SQLCIPHER_PRIVATE int sqlcipher3VdbeList(
60690   Vdbe *p                   /* The VDBE */
60691 ){
60692   int nRow;                            /* Stop when row count reaches this */
60693   int nSub = 0;                        /* Number of sub-vdbes seen so far */
60694   SubProgram **apSub = 0;              /* Array of sub-vdbes */
60695   Mem *pSub = 0;                       /* Memory cell hold array of subprogs */
60696   sqlcipher3 *db = p->db;                 /* The database connection */
60697   int i;                               /* Loop counter */
60698   int rc = SQLCIPHER_OK;                  /* Return code */
60699   Mem *pMem = &p->aMem[1];             /* First Mem of result set */
60700
60701   assert( p->explain );
60702   assert( p->magic==VDBE_MAGIC_RUN );
60703   assert( p->rc==SQLCIPHER_OK || p->rc==SQLCIPHER_BUSY || p->rc==SQLCIPHER_NOMEM );
60704
60705   /* Even though this opcode does not use dynamic strings for
60706   ** the result, result columns may become dynamic if the user calls
60707   ** sqlcipher3_column_text16(), causing a translation to UTF-16 encoding.
60708   */
60709   releaseMemArray(pMem, 8);
60710   p->pResultSet = 0;
60711
60712   if( p->rc==SQLCIPHER_NOMEM ){
60713     /* This happens if a malloc() inside a call to sqlcipher3_column_text() or
60714     ** sqlcipher3_column_text16() failed.  */
60715     db->mallocFailed = 1;
60716     return SQLCIPHER_ERROR;
60717   }
60718
60719   /* When the number of output rows reaches nRow, that means the
60720   ** listing has finished and sqlcipher3_step() should return SQLCIPHER_DONE.
60721   ** nRow is the sum of the number of rows in the main program, plus
60722   ** the sum of the number of rows in all trigger subprograms encountered
60723   ** so far.  The nRow value will increase as new trigger subprograms are
60724   ** encountered, but p->pc will eventually catch up to nRow.
60725   */
60726   nRow = p->nOp;
60727   if( p->explain==1 ){
60728     /* The first 8 memory cells are used for the result set.  So we will
60729     ** commandeer the 9th cell to use as storage for an array of pointers
60730     ** to trigger subprograms.  The VDBE is guaranteed to have at least 9
60731     ** cells.  */
60732     assert( p->nMem>9 );
60733     pSub = &p->aMem[9];
60734     if( pSub->flags&MEM_Blob ){
60735       /* On the first call to sqlcipher3_step(), pSub will hold a NULL.  It is
60736       ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */
60737       nSub = pSub->n/sizeof(Vdbe*);
60738       apSub = (SubProgram **)pSub->z;
60739     }
60740     for(i=0; i<nSub; i++){
60741       nRow += apSub[i]->nOp;
60742     }
60743   }
60744
60745   do{
60746     i = p->pc++;
60747   }while( i<nRow && p->explain==2 && p->aOp[i].opcode!=OP_Explain );
60748   if( i>=nRow ){
60749     p->rc = SQLCIPHER_OK;
60750     rc = SQLCIPHER_DONE;
60751   }else if( db->u1.isInterrupted ){
60752     p->rc = SQLCIPHER_INTERRUPT;
60753     rc = SQLCIPHER_ERROR;
60754     sqlcipher3SetString(&p->zErrMsg, db, "%s", sqlcipher3ErrStr(p->rc));
60755   }else{
60756     char *z;
60757     Op *pOp;
60758     if( i<p->nOp ){
60759       /* The output line number is small enough that we are still in the
60760       ** main program. */
60761       pOp = &p->aOp[i];
60762     }else{
60763       /* We are currently listing subprograms.  Figure out which one and
60764       ** pick up the appropriate opcode. */
60765       int j;
60766       i -= p->nOp;
60767       for(j=0; i>=apSub[j]->nOp; j++){
60768         i -= apSub[j]->nOp;
60769       }
60770       pOp = &apSub[j]->aOp[i];
60771     }
60772     if( p->explain==1 ){
60773       pMem->flags = MEM_Int;
60774       pMem->type = SQLCIPHER_INTEGER;
60775       pMem->u.i = i;                                /* Program counter */
60776       pMem++;
60777   
60778       pMem->flags = MEM_Static|MEM_Str|MEM_Term;
60779       pMem->z = (char*)sqlcipher3OpcodeName(pOp->opcode);  /* Opcode */
60780       assert( pMem->z!=0 );
60781       pMem->n = sqlcipher3Strlen30(pMem->z);
60782       pMem->type = SQLCIPHER_TEXT;
60783       pMem->enc = SQLCIPHER_UTF8;
60784       pMem++;
60785
60786       /* When an OP_Program opcode is encounter (the only opcode that has
60787       ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
60788       ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
60789       ** has not already been seen.
60790       */
60791       if( pOp->p4type==P4_SUBPROGRAM ){
60792         int nByte = (nSub+1)*sizeof(SubProgram*);
60793         int j;
60794         for(j=0; j<nSub; j++){
60795           if( apSub[j]==pOp->p4.pProgram ) break;
60796         }
60797         if( j==nSub && SQLCIPHER_OK==sqlcipher3VdbeMemGrow(pSub, nByte, 1) ){
60798           apSub = (SubProgram **)pSub->z;
60799           apSub[nSub++] = pOp->p4.pProgram;
60800           pSub->flags |= MEM_Blob;
60801           pSub->n = nSub*sizeof(SubProgram*);
60802         }
60803       }
60804     }
60805
60806     pMem->flags = MEM_Int;
60807     pMem->u.i = pOp->p1;                          /* P1 */
60808     pMem->type = SQLCIPHER_INTEGER;
60809     pMem++;
60810
60811     pMem->flags = MEM_Int;
60812     pMem->u.i = pOp->p2;                          /* P2 */
60813     pMem->type = SQLCIPHER_INTEGER;
60814     pMem++;
60815
60816     pMem->flags = MEM_Int;
60817     pMem->u.i = pOp->p3;                          /* P3 */
60818     pMem->type = SQLCIPHER_INTEGER;
60819     pMem++;
60820
60821     if( sqlcipher3VdbeMemGrow(pMem, 32, 0) ){            /* P4 */
60822       assert( p->db->mallocFailed );
60823       return SQLCIPHER_ERROR;
60824     }
60825     pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
60826     z = displayP4(pOp, pMem->z, 32);
60827     if( z!=pMem->z ){
60828       sqlcipher3VdbeMemSetStr(pMem, z, -1, SQLCIPHER_UTF8, 0);
60829     }else{
60830       assert( pMem->z!=0 );
60831       pMem->n = sqlcipher3Strlen30(pMem->z);
60832       pMem->enc = SQLCIPHER_UTF8;
60833     }
60834     pMem->type = SQLCIPHER_TEXT;
60835     pMem++;
60836
60837     if( p->explain==1 ){
60838       if( sqlcipher3VdbeMemGrow(pMem, 4, 0) ){
60839         assert( p->db->mallocFailed );
60840         return SQLCIPHER_ERROR;
60841       }
60842       pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
60843       pMem->n = 2;
60844       sqlcipher3_snprintf(3, pMem->z, "%.2x", pOp->p5);   /* P5 */
60845       pMem->type = SQLCIPHER_TEXT;
60846       pMem->enc = SQLCIPHER_UTF8;
60847       pMem++;
60848   
60849 #ifdef SQLCIPHER_DEBUG
60850       if( pOp->zComment ){
60851         pMem->flags = MEM_Str|MEM_Term;
60852         pMem->z = pOp->zComment;
60853         pMem->n = sqlcipher3Strlen30(pMem->z);
60854         pMem->enc = SQLCIPHER_UTF8;
60855         pMem->type = SQLCIPHER_TEXT;
60856       }else
60857 #endif
60858       {
60859         pMem->flags = MEM_Null;                       /* Comment */
60860         pMem->type = SQLCIPHER_NULL;
60861       }
60862     }
60863
60864     p->nResColumn = 8 - 4*(p->explain-1);
60865     p->pResultSet = &p->aMem[1];
60866     p->rc = SQLCIPHER_OK;
60867     rc = SQLCIPHER_ROW;
60868   }
60869   return rc;
60870 }
60871 #endif /* SQLCIPHER_OMIT_EXPLAIN */
60872
60873 #ifdef SQLCIPHER_DEBUG
60874 /*
60875 ** Print the SQL that was used to generate a VDBE program.
60876 */
60877 SQLCIPHER_PRIVATE void sqlcipher3VdbePrintSql(Vdbe *p){
60878   int nOp = p->nOp;
60879   VdbeOp *pOp;
60880   if( nOp<1 ) return;
60881   pOp = &p->aOp[0];
60882   if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
60883     const char *z = pOp->p4.z;
60884     while( sqlcipher3Isspace(*z) ) z++;
60885     printf("SQL: [%s]\n", z);
60886   }
60887 }
60888 #endif
60889
60890 #if !defined(SQLCIPHER_OMIT_TRACE) && defined(SQLCIPHER_ENABLE_IOTRACE)
60891 /*
60892 ** Print an IOTRACE message showing SQL content.
60893 */
60894 SQLCIPHER_PRIVATE void sqlcipher3VdbeIOTraceSql(Vdbe *p){
60895   int nOp = p->nOp;
60896   VdbeOp *pOp;
60897   if( sqlcipher3IoTrace==0 ) return;
60898   if( nOp<1 ) return;
60899   pOp = &p->aOp[0];
60900   if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
60901     int i, j;
60902     char z[1000];
60903     sqlcipher3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
60904     for(i=0; sqlcipher3Isspace(z[i]); i++){}
60905     for(j=0; z[i]; i++){
60906       if( sqlcipher3Isspace(z[i]) ){
60907         if( z[i-1]!=' ' ){
60908           z[j++] = ' ';
60909         }
60910       }else{
60911         z[j++] = z[i];
60912       }
60913     }
60914     z[j] = 0;
60915     sqlcipher3IoTrace("SQL %s\n", z);
60916   }
60917 }
60918 #endif /* !SQLCIPHER_OMIT_TRACE && SQLCIPHER_ENABLE_IOTRACE */
60919
60920 /*
60921 ** Allocate space from a fixed size buffer and return a pointer to
60922 ** that space.  If insufficient space is available, return NULL.
60923 **
60924 ** The pBuf parameter is the initial value of a pointer which will
60925 ** receive the new memory.  pBuf is normally NULL.  If pBuf is not
60926 ** NULL, it means that memory space has already been allocated and that
60927 ** this routine should not allocate any new memory.  When pBuf is not
60928 ** NULL simply return pBuf.  Only allocate new memory space when pBuf
60929 ** is NULL.
60930 **
60931 ** nByte is the number of bytes of space needed.
60932 **
60933 ** *ppFrom points to available space and pEnd points to the end of the
60934 ** available space.  When space is allocated, *ppFrom is advanced past
60935 ** the end of the allocated space.
60936 **
60937 ** *pnByte is a counter of the number of bytes of space that have failed
60938 ** to allocate.  If there is insufficient space in *ppFrom to satisfy the
60939 ** request, then increment *pnByte by the amount of the request.
60940 */
60941 static void *allocSpace(
60942   void *pBuf,          /* Where return pointer will be stored */
60943   int nByte,           /* Number of bytes to allocate */
60944   u8 **ppFrom,         /* IN/OUT: Allocate from *ppFrom */
60945   u8 *pEnd,            /* Pointer to 1 byte past the end of *ppFrom buffer */
60946   int *pnByte          /* If allocation cannot be made, increment *pnByte */
60947 ){
60948   assert( EIGHT_BYTE_ALIGNMENT(*ppFrom) );
60949   if( pBuf ) return pBuf;
60950   nByte = ROUND8(nByte);
60951   if( &(*ppFrom)[nByte] <= pEnd ){
60952     pBuf = (void*)*ppFrom;
60953     *ppFrom += nByte;
60954   }else{
60955     *pnByte += nByte;
60956   }
60957   return pBuf;
60958 }
60959
60960 /*
60961 ** Rewind the VDBE back to the beginning in preparation for
60962 ** running it.
60963 */
60964 SQLCIPHER_PRIVATE void sqlcipher3VdbeRewind(Vdbe *p){
60965 #if defined(SQLCIPHER_DEBUG) || defined(VDBE_PROFILE)
60966   int i;
60967 #endif
60968   assert( p!=0 );
60969   assert( p->magic==VDBE_MAGIC_INIT );
60970
60971   /* There should be at least one opcode.
60972   */
60973   assert( p->nOp>0 );
60974
60975   /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
60976   p->magic = VDBE_MAGIC_RUN;
60977
60978 #ifdef SQLCIPHER_DEBUG
60979   for(i=1; i<p->nMem; i++){
60980     assert( p->aMem[i].db==p->db );
60981   }
60982 #endif
60983   p->pc = -1;
60984   p->rc = SQLCIPHER_OK;
60985   p->errorAction = OE_Abort;
60986   p->magic = VDBE_MAGIC_RUN;
60987   p->nChange = 0;
60988   p->cacheCtr = 1;
60989   p->minWriteFileFormat = 255;
60990   p->iStatement = 0;
60991   p->nFkConstraint = 0;
60992 #ifdef VDBE_PROFILE
60993   for(i=0; i<p->nOp; i++){
60994     p->aOp[i].cnt = 0;
60995     p->aOp[i].cycles = 0;
60996   }
60997 #endif
60998 }
60999
61000 /*
61001 ** Prepare a virtual machine for execution for the first time after
61002 ** creating the virtual machine.  This involves things such
61003 ** as allocating stack space and initializing the program counter.
61004 ** After the VDBE has be prepped, it can be executed by one or more
61005 ** calls to sqlcipher3VdbeExec().  
61006 **
61007 ** This function may be called exact once on a each virtual machine.
61008 ** After this routine is called the VM has been "packaged" and is ready
61009 ** to run.  After this routine is called, futher calls to 
61010 ** sqlcipher3VdbeAddOp() functions are prohibited.  This routine disconnects
61011 ** the Vdbe from the Parse object that helped generate it so that the
61012 ** the Vdbe becomes an independent entity and the Parse object can be
61013 ** destroyed.
61014 **
61015 ** Use the sqlcipher3VdbeRewind() procedure to restore a virtual machine back
61016 ** to its initial state after it has been run.
61017 */
61018 SQLCIPHER_PRIVATE void sqlcipher3VdbeMakeReady(
61019   Vdbe *p,                       /* The VDBE */
61020   Parse *pParse                  /* Parsing context */
61021 ){
61022   sqlcipher3 *db;                   /* The database connection */
61023   int nVar;                      /* Number of parameters */
61024   int nMem;                      /* Number of VM memory registers */
61025   int nCursor;                   /* Number of cursors required */
61026   int nArg;                      /* Number of arguments in subprograms */
61027   int n;                         /* Loop counter */
61028   u8 *zCsr;                      /* Memory available for allocation */
61029   u8 *zEnd;                      /* First byte past allocated memory */
61030   int nByte;                     /* How much extra memory is needed */
61031
61032   assert( p!=0 );
61033   assert( p->nOp>0 );
61034   assert( pParse!=0 );
61035   assert( p->magic==VDBE_MAGIC_INIT );
61036   db = p->db;
61037   assert( db->mallocFailed==0 );
61038   nVar = pParse->nVar;
61039   nMem = pParse->nMem;
61040   nCursor = pParse->nTab;
61041   nArg = pParse->nMaxArg;
61042   
61043   /* For each cursor required, also allocate a memory cell. Memory
61044   ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
61045   ** the vdbe program. Instead they are used to allocate space for
61046   ** VdbeCursor/BtCursor structures. The blob of memory associated with 
61047   ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1)
61048   ** stores the blob of memory associated with cursor 1, etc.
61049   **
61050   ** See also: allocateCursor().
61051   */
61052   nMem += nCursor;
61053
61054   /* Allocate space for memory registers, SQL variables, VDBE cursors and 
61055   ** an array to marshal SQL function arguments in.
61056   */
61057   zCsr = (u8*)&p->aOp[p->nOp];       /* Memory avaliable for allocation */
61058   zEnd = (u8*)&p->aOp[p->nOpAlloc];  /* First byte past end of zCsr[] */
61059
61060   resolveP2Values(p, &nArg);
61061   p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
61062   if( pParse->explain && nMem<10 ){
61063     nMem = 10;
61064   }
61065   memset(zCsr, 0, zEnd-zCsr);
61066   zCsr += (zCsr - (u8*)0)&7;
61067   assert( EIGHT_BYTE_ALIGNMENT(zCsr) );
61068   p->expired = 0;
61069
61070   /* Memory for registers, parameters, cursor, etc, is allocated in two
61071   ** passes.  On the first pass, we try to reuse unused space at the 
61072   ** end of the opcode array.  If we are unable to satisfy all memory
61073   ** requirements by reusing the opcode array tail, then the second
61074   ** pass will fill in the rest using a fresh allocation.  
61075   **
61076   ** This two-pass approach that reuses as much memory as possible from
61077   ** the leftover space at the end of the opcode array can significantly
61078   ** reduce the amount of memory held by a prepared statement.
61079   */
61080   do {
61081     nByte = 0;
61082     p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
61083     p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
61084     p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
61085     p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
61086     p->apCsr = allocSpace(p->apCsr, nCursor*sizeof(VdbeCursor*),
61087                           &zCsr, zEnd, &nByte);
61088     if( nByte ){
61089       p->pFree = sqlcipher3DbMallocZero(db, nByte);
61090     }
61091     zCsr = p->pFree;
61092     zEnd = &zCsr[nByte];
61093   }while( nByte && !db->mallocFailed );
61094
61095   p->nCursor = (u16)nCursor;
61096   if( p->aVar ){
61097     p->nVar = (ynVar)nVar;
61098     for(n=0; n<nVar; n++){
61099       p->aVar[n].flags = MEM_Null;
61100       p->aVar[n].db = db;
61101     }
61102   }
61103   if( p->azVar ){
61104     p->nzVar = pParse->nzVar;
61105     memcpy(p->azVar, pParse->azVar, p->nzVar*sizeof(p->azVar[0]));
61106     memset(pParse->azVar, 0, pParse->nzVar*sizeof(pParse->azVar[0]));
61107   }
61108   if( p->aMem ){
61109     p->aMem--;                      /* aMem[] goes from 1..nMem */
61110     p->nMem = nMem;                 /*       not from 0..nMem-1 */
61111     for(n=1; n<=nMem; n++){
61112       p->aMem[n].flags = MEM_Null;
61113       p->aMem[n].db = db;
61114     }
61115   }
61116   p->explain = pParse->explain;
61117   sqlcipher3VdbeRewind(p);
61118 }
61119
61120 /*
61121 ** Close a VDBE cursor and release all the resources that cursor 
61122 ** happens to hold.
61123 */
61124 SQLCIPHER_PRIVATE void sqlcipher3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
61125   if( pCx==0 ){
61126     return;
61127   }
61128   sqlcipher3VdbeSorterClose(p->db, pCx);
61129   if( pCx->pBt ){
61130     sqlcipher3BtreeClose(pCx->pBt);
61131     /* The pCx->pCursor will be close automatically, if it exists, by
61132     ** the call above. */
61133   }else if( pCx->pCursor ){
61134     sqlcipher3BtreeCloseCursor(pCx->pCursor);
61135   }
61136 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
61137   if( pCx->pVtabCursor ){
61138     sqlcipher3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
61139     const sqlcipher3_module *pModule = pCx->pModule;
61140     p->inVtabMethod = 1;
61141     pModule->xClose(pVtabCursor);
61142     p->inVtabMethod = 0;
61143   }
61144 #endif
61145 }
61146
61147 /*
61148 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
61149 ** is used, for example, when a trigger sub-program is halted to restore
61150 ** control to the main program.
61151 */
61152 SQLCIPHER_PRIVATE int sqlcipher3VdbeFrameRestore(VdbeFrame *pFrame){
61153   Vdbe *v = pFrame->v;
61154   v->aOp = pFrame->aOp;
61155   v->nOp = pFrame->nOp;
61156   v->aMem = pFrame->aMem;
61157   v->nMem = pFrame->nMem;
61158   v->apCsr = pFrame->apCsr;
61159   v->nCursor = pFrame->nCursor;
61160   v->db->lastRowid = pFrame->lastRowid;
61161   v->nChange = pFrame->nChange;
61162   return pFrame->pc;
61163 }
61164
61165 /*
61166 ** Close all cursors.
61167 **
61168 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory 
61169 ** cell array. This is necessary as the memory cell array may contain
61170 ** pointers to VdbeFrame objects, which may in turn contain pointers to
61171 ** open cursors.
61172 */
61173 static void closeAllCursors(Vdbe *p){
61174   if( p->pFrame ){
61175     VdbeFrame *pFrame;
61176     for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
61177     sqlcipher3VdbeFrameRestore(pFrame);
61178   }
61179   p->pFrame = 0;
61180   p->nFrame = 0;
61181
61182   if( p->apCsr ){
61183     int i;
61184     for(i=0; i<p->nCursor; i++){
61185       VdbeCursor *pC = p->apCsr[i];
61186       if( pC ){
61187         sqlcipher3VdbeFreeCursor(p, pC);
61188         p->apCsr[i] = 0;
61189       }
61190     }
61191   }
61192   if( p->aMem ){
61193     releaseMemArray(&p->aMem[1], p->nMem);
61194   }
61195   while( p->pDelFrame ){
61196     VdbeFrame *pDel = p->pDelFrame;
61197     p->pDelFrame = pDel->pParent;
61198     sqlcipher3VdbeFrameDelete(pDel);
61199   }
61200 }
61201
61202 /*
61203 ** Clean up the VM after execution.
61204 **
61205 ** This routine will automatically close any cursors, lists, and/or
61206 ** sorters that were left open.  It also deletes the values of
61207 ** variables in the aVar[] array.
61208 */
61209 static void Cleanup(Vdbe *p){
61210   sqlcipher3 *db = p->db;
61211
61212 #ifdef SQLCIPHER_DEBUG
61213   /* Execute assert() statements to ensure that the Vdbe.apCsr[] and 
61214   ** Vdbe.aMem[] arrays have already been cleaned up.  */
61215   int i;
61216   for(i=0; i<p->nCursor; i++) assert( p->apCsr==0 || p->apCsr[i]==0 );
61217   for(i=1; i<=p->nMem; i++) assert( p->aMem==0 || p->aMem[i].flags==MEM_Null );
61218 #endif
61219
61220   sqlcipher3DbFree(db, p->zErrMsg);
61221   p->zErrMsg = 0;
61222   p->pResultSet = 0;
61223 }
61224
61225 /*
61226 ** Set the number of result columns that will be returned by this SQL
61227 ** statement. This is now set at compile time, rather than during
61228 ** execution of the vdbe program so that sqlcipher3_column_count() can
61229 ** be called on an SQL statement before sqlcipher3_step().
61230 */
61231 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetNumCols(Vdbe *p, int nResColumn){
61232   Mem *pColName;
61233   int n;
61234   sqlcipher3 *db = p->db;
61235
61236   releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
61237   sqlcipher3DbFree(db, p->aColName);
61238   n = nResColumn*COLNAME_N;
61239   p->nResColumn = (u16)nResColumn;
61240   p->aColName = pColName = (Mem*)sqlcipher3DbMallocZero(db, sizeof(Mem)*n );
61241   if( p->aColName==0 ) return;
61242   while( n-- > 0 ){
61243     pColName->flags = MEM_Null;
61244     pColName->db = p->db;
61245     pColName++;
61246   }
61247 }
61248
61249 /*
61250 ** Set the name of the idx'th column to be returned by the SQL statement.
61251 ** zName must be a pointer to a nul terminated string.
61252 **
61253 ** This call must be made after a call to sqlcipher3VdbeSetNumCols().
61254 **
61255 ** The final parameter, xDel, must be one of SQLCIPHER_DYNAMIC, SQLCIPHER_STATIC
61256 ** or SQLCIPHER_TRANSIENT. If it is SQLCIPHER_DYNAMIC, then the buffer pointed
61257 ** to by zName will be freed by sqlcipher3DbFree() when the vdbe is destroyed.
61258 */
61259 SQLCIPHER_PRIVATE int sqlcipher3VdbeSetColName(
61260   Vdbe *p,                         /* Vdbe being configured */
61261   int idx,                         /* Index of column zName applies to */
61262   int var,                         /* One of the COLNAME_* constants */
61263   const char *zName,               /* Pointer to buffer containing name */
61264   void (*xDel)(void*)              /* Memory management strategy for zName */
61265 ){
61266   int rc;
61267   Mem *pColName;
61268   assert( idx<p->nResColumn );
61269   assert( var<COLNAME_N );
61270   if( p->db->mallocFailed ){
61271     assert( !zName || xDel!=SQLCIPHER_DYNAMIC );
61272     return SQLCIPHER_NOMEM;
61273   }
61274   assert( p->aColName!=0 );
61275   pColName = &(p->aColName[idx+var*p->nResColumn]);
61276   rc = sqlcipher3VdbeMemSetStr(pColName, zName, -1, SQLCIPHER_UTF8, xDel);
61277   assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
61278   return rc;
61279 }
61280
61281 /*
61282 ** A read or write transaction may or may not be active on database handle
61283 ** db. If a transaction is active, commit it. If there is a
61284 ** write-transaction spanning more than one database file, this routine
61285 ** takes care of the master journal trickery.
61286 */
61287 static int vdbeCommit(sqlcipher3 *db, Vdbe *p){
61288   int i;
61289   int nTrans = 0;  /* Number of databases with an active write-transaction */
61290   int rc = SQLCIPHER_OK;
61291   int needXcommit = 0;
61292
61293 #ifdef SQLCIPHER_OMIT_VIRTUALTABLE
61294   /* With this option, sqlcipher3VtabSync() is defined to be simply 
61295   ** SQLCIPHER_OK so p is not used. 
61296   */
61297   UNUSED_PARAMETER(p);
61298 #endif
61299
61300   /* Before doing anything else, call the xSync() callback for any
61301   ** virtual module tables written in this transaction. This has to
61302   ** be done before determining whether a master journal file is 
61303   ** required, as an xSync() callback may add an attached database
61304   ** to the transaction.
61305   */
61306   rc = sqlcipher3VtabSync(db, &p->zErrMsg);
61307
61308   /* This loop determines (a) if the commit hook should be invoked and
61309   ** (b) how many database files have open write transactions, not 
61310   ** including the temp database. (b) is important because if more than 
61311   ** one database file has an open write transaction, a master journal
61312   ** file is required for an atomic commit.
61313   */ 
61314   for(i=0; rc==SQLCIPHER_OK && i<db->nDb; i++){ 
61315     Btree *pBt = db->aDb[i].pBt;
61316     if( sqlcipher3BtreeIsInTrans(pBt) ){
61317       needXcommit = 1;
61318       if( i!=1 ) nTrans++;
61319       rc = sqlcipher3PagerExclusiveLock(sqlcipher3BtreePager(pBt));
61320     }
61321   }
61322   if( rc!=SQLCIPHER_OK ){
61323     return rc;
61324   }
61325
61326   /* If there are any write-transactions at all, invoke the commit hook */
61327   if( needXcommit && db->xCommitCallback ){
61328     rc = db->xCommitCallback(db->pCommitArg);
61329     if( rc ){
61330       return SQLCIPHER_CONSTRAINT;
61331     }
61332   }
61333
61334   /* The simple case - no more than one database file (not counting the
61335   ** TEMP database) has a transaction active.   There is no need for the
61336   ** master-journal.
61337   **
61338   ** If the return value of sqlcipher3BtreeGetFilename() is a zero length
61339   ** string, it means the main database is :memory: or a temp file.  In 
61340   ** that case we do not support atomic multi-file commits, so use the 
61341   ** simple case then too.
61342   */
61343   if( 0==sqlcipher3Strlen30(sqlcipher3BtreeGetFilename(db->aDb[0].pBt))
61344    || nTrans<=1
61345   ){
61346     for(i=0; rc==SQLCIPHER_OK && i<db->nDb; i++){
61347       Btree *pBt = db->aDb[i].pBt;
61348       if( pBt ){
61349         rc = sqlcipher3BtreeCommitPhaseOne(pBt, 0);
61350       }
61351     }
61352
61353     /* Do the commit only if all databases successfully complete phase 1. 
61354     ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
61355     ** IO error while deleting or truncating a journal file. It is unlikely,
61356     ** but could happen. In this case abandon processing and return the error.
61357     */
61358     for(i=0; rc==SQLCIPHER_OK && i<db->nDb; i++){
61359       Btree *pBt = db->aDb[i].pBt;
61360       if( pBt ){
61361         rc = sqlcipher3BtreeCommitPhaseTwo(pBt, 0);
61362       }
61363     }
61364     if( rc==SQLCIPHER_OK ){
61365       sqlcipher3VtabCommit(db);
61366     }
61367   }
61368
61369   /* The complex case - There is a multi-file write-transaction active.
61370   ** This requires a master journal file to ensure the transaction is
61371   ** committed atomicly.
61372   */
61373 #ifndef SQLCIPHER_OMIT_DISKIO
61374   else{
61375     sqlcipher3_vfs *pVfs = db->pVfs;
61376     int needSync = 0;
61377     char *zMaster = 0;   /* File-name for the master journal */
61378     char const *zMainFile = sqlcipher3BtreeGetFilename(db->aDb[0].pBt);
61379     sqlcipher3_file *pMaster = 0;
61380     i64 offset = 0;
61381     int res;
61382
61383     /* Select a master journal file name */
61384     do {
61385       u32 iRandom;
61386       sqlcipher3DbFree(db, zMaster);
61387       sqlcipher3_randomness(sizeof(iRandom), &iRandom);
61388       zMaster = sqlcipher3MPrintf(db, "%s-mj%08X", zMainFile, iRandom&0x7fffffff);
61389       if( !zMaster ){
61390         return SQLCIPHER_NOMEM;
61391       }
61392       sqlcipher3FileSuffix3(zMainFile, zMaster);
61393       rc = sqlcipher3OsAccess(pVfs, zMaster, SQLCIPHER_ACCESS_EXISTS, &res);
61394     }while( rc==SQLCIPHER_OK && res );
61395     if( rc==SQLCIPHER_OK ){
61396       /* Open the master journal. */
61397       rc = sqlcipher3OsOpenMalloc(pVfs, zMaster, &pMaster, 
61398           SQLCIPHER_OPEN_READWRITE|SQLCIPHER_OPEN_CREATE|
61399           SQLCIPHER_OPEN_EXCLUSIVE|SQLCIPHER_OPEN_MASTER_JOURNAL, 0
61400       );
61401     }
61402     if( rc!=SQLCIPHER_OK ){
61403       sqlcipher3DbFree(db, zMaster);
61404       return rc;
61405     }
61406  
61407     /* Write the name of each database file in the transaction into the new
61408     ** master journal file. If an error occurs at this point close
61409     ** and delete the master journal file. All the individual journal files
61410     ** still have 'null' as the master journal pointer, so they will roll
61411     ** back independently if a failure occurs.
61412     */
61413     for(i=0; i<db->nDb; i++){
61414       Btree *pBt = db->aDb[i].pBt;
61415       if( sqlcipher3BtreeIsInTrans(pBt) ){
61416         char const *zFile = sqlcipher3BtreeGetJournalname(pBt);
61417         if( zFile==0 ){
61418           continue;  /* Ignore TEMP and :memory: databases */
61419         }
61420         assert( zFile[0]!=0 );
61421         if( !needSync && !sqlcipher3BtreeSyncDisabled(pBt) ){
61422           needSync = 1;
61423         }
61424         rc = sqlcipher3OsWrite(pMaster, zFile, sqlcipher3Strlen30(zFile)+1, offset);
61425         offset += sqlcipher3Strlen30(zFile)+1;
61426         if( rc!=SQLCIPHER_OK ){
61427           sqlcipher3OsCloseFree(pMaster);
61428           sqlcipher3OsDelete(pVfs, zMaster, 0);
61429           sqlcipher3DbFree(db, zMaster);
61430           return rc;
61431         }
61432       }
61433     }
61434
61435     /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
61436     ** flag is set this is not required.
61437     */
61438     if( needSync 
61439      && 0==(sqlcipher3OsDeviceCharacteristics(pMaster)&SQLCIPHER_IOCAP_SEQUENTIAL)
61440      && SQLCIPHER_OK!=(rc = sqlcipher3OsSync(pMaster, SQLCIPHER_SYNC_NORMAL))
61441     ){
61442       sqlcipher3OsCloseFree(pMaster);
61443       sqlcipher3OsDelete(pVfs, zMaster, 0);
61444       sqlcipher3DbFree(db, zMaster);
61445       return rc;
61446     }
61447
61448     /* Sync all the db files involved in the transaction. The same call
61449     ** sets the master journal pointer in each individual journal. If
61450     ** an error occurs here, do not delete the master journal file.
61451     **
61452     ** If the error occurs during the first call to
61453     ** sqlcipher3BtreeCommitPhaseOne(), then there is a chance that the
61454     ** master journal file will be orphaned. But we cannot delete it,
61455     ** in case the master journal file name was written into the journal
61456     ** file before the failure occurred.
61457     */
61458     for(i=0; rc==SQLCIPHER_OK && i<db->nDb; i++){ 
61459       Btree *pBt = db->aDb[i].pBt;
61460       if( pBt ){
61461         rc = sqlcipher3BtreeCommitPhaseOne(pBt, zMaster);
61462       }
61463     }
61464     sqlcipher3OsCloseFree(pMaster);
61465     assert( rc!=SQLCIPHER_BUSY );
61466     if( rc!=SQLCIPHER_OK ){
61467       sqlcipher3DbFree(db, zMaster);
61468       return rc;
61469     }
61470
61471     /* Delete the master journal file. This commits the transaction. After
61472     ** doing this the directory is synced again before any individual
61473     ** transaction files are deleted.
61474     */
61475     rc = sqlcipher3OsDelete(pVfs, zMaster, 1);
61476     sqlcipher3DbFree(db, zMaster);
61477     zMaster = 0;
61478     if( rc ){
61479       return rc;
61480     }
61481
61482     /* All files and directories have already been synced, so the following
61483     ** calls to sqlcipher3BtreeCommitPhaseTwo() are only closing files and
61484     ** deleting or truncating journals. If something goes wrong while
61485     ** this is happening we don't really care. The integrity of the
61486     ** transaction is already guaranteed, but some stray 'cold' journals
61487     ** may be lying around. Returning an error code won't help matters.
61488     */
61489     disable_simulated_io_errors();
61490     sqlcipher3BeginBenignMalloc();
61491     for(i=0; i<db->nDb; i++){ 
61492       Btree *pBt = db->aDb[i].pBt;
61493       if( pBt ){
61494         sqlcipher3BtreeCommitPhaseTwo(pBt, 1);
61495       }
61496     }
61497     sqlcipher3EndBenignMalloc();
61498     enable_simulated_io_errors();
61499
61500     sqlcipher3VtabCommit(db);
61501   }
61502 #endif
61503
61504   return rc;
61505 }
61506
61507 /* 
61508 ** This routine checks that the sqlcipher3.activeVdbeCnt count variable
61509 ** matches the number of vdbe's in the list sqlcipher3.pVdbe that are
61510 ** currently active. An assertion fails if the two counts do not match.
61511 ** This is an internal self-check only - it is not an essential processing
61512 ** step.
61513 **
61514 ** This is a no-op if NDEBUG is defined.
61515 */
61516 #ifndef NDEBUG
61517 static void checkActiveVdbeCnt(sqlcipher3 *db){
61518   Vdbe *p;
61519   int cnt = 0;
61520   int nWrite = 0;
61521   p = db->pVdbe;
61522   while( p ){
61523     if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61524       cnt++;
61525       if( p->readOnly==0 ) nWrite++;
61526     }
61527     p = p->pNext;
61528   }
61529   assert( cnt==db->activeVdbeCnt );
61530   assert( nWrite==db->writeVdbeCnt );
61531 }
61532 #else
61533 #define checkActiveVdbeCnt(x)
61534 #endif
61535
61536 /*
61537 ** For every Btree that in database connection db which 
61538 ** has been modified, "trip" or invalidate each cursor in
61539 ** that Btree might have been modified so that the cursor
61540 ** can never be used again.  This happens when a rollback
61541 *** occurs.  We have to trip all the other cursors, even
61542 ** cursor from other VMs in different database connections,
61543 ** so that none of them try to use the data at which they
61544 ** were pointing and which now may have been changed due
61545 ** to the rollback.
61546 **
61547 ** Remember that a rollback can delete tables complete and
61548 ** reorder rootpages.  So it is not sufficient just to save
61549 ** the state of the cursor.  We have to invalidate the cursor
61550 ** so that it is never used again.
61551 */
61552 static void invalidateCursorsOnModifiedBtrees(sqlcipher3 *db){
61553   int i;
61554   for(i=0; i<db->nDb; i++){
61555     Btree *p = db->aDb[i].pBt;
61556     if( p && sqlcipher3BtreeIsInTrans(p) ){
61557       sqlcipher3BtreeTripAllCursors(p, SQLCIPHER_ABORT);
61558     }
61559   }
61560 }
61561
61562 /*
61563 ** If the Vdbe passed as the first argument opened a statement-transaction,
61564 ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
61565 ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
61566 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the 
61567 ** statement transaction is commtted.
61568 **
61569 ** If an IO error occurs, an SQLCIPHER_IOERR_XXX error code is returned. 
61570 ** Otherwise SQLCIPHER_OK.
61571 */
61572 SQLCIPHER_PRIVATE int sqlcipher3VdbeCloseStatement(Vdbe *p, int eOp){
61573   sqlcipher3 *const db = p->db;
61574   int rc = SQLCIPHER_OK;
61575
61576   /* If p->iStatement is greater than zero, then this Vdbe opened a 
61577   ** statement transaction that should be closed here. The only exception
61578   ** is that an IO error may have occured, causing an emergency rollback.
61579   ** In this case (db->nStatement==0), and there is nothing to do.
61580   */
61581   if( db->nStatement && p->iStatement ){
61582     int i;
61583     const int iSavepoint = p->iStatement-1;
61584
61585     assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
61586     assert( db->nStatement>0 );
61587     assert( p->iStatement==(db->nStatement+db->nSavepoint) );
61588
61589     for(i=0; i<db->nDb; i++){ 
61590       int rc2 = SQLCIPHER_OK;
61591       Btree *pBt = db->aDb[i].pBt;
61592       if( pBt ){
61593         if( eOp==SAVEPOINT_ROLLBACK ){
61594           rc2 = sqlcipher3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
61595         }
61596         if( rc2==SQLCIPHER_OK ){
61597           rc2 = sqlcipher3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
61598         }
61599         if( rc==SQLCIPHER_OK ){
61600           rc = rc2;
61601         }
61602       }
61603     }
61604     db->nStatement--;
61605     p->iStatement = 0;
61606
61607     if( rc==SQLCIPHER_OK ){
61608       if( eOp==SAVEPOINT_ROLLBACK ){
61609         rc = sqlcipher3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
61610       }
61611       if( rc==SQLCIPHER_OK ){
61612         rc = sqlcipher3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
61613       }
61614     }
61615
61616     /* If the statement transaction is being rolled back, also restore the 
61617     ** database handles deferred constraint counter to the value it had when 
61618     ** the statement transaction was opened.  */
61619     if( eOp==SAVEPOINT_ROLLBACK ){
61620       db->nDeferredCons = p->nStmtDefCons;
61621     }
61622   }
61623   return rc;
61624 }
61625
61626 /*
61627 ** This function is called when a transaction opened by the database 
61628 ** handle associated with the VM passed as an argument is about to be 
61629 ** committed. If there are outstanding deferred foreign key constraint
61630 ** violations, return SQLCIPHER_ERROR. Otherwise, SQLCIPHER_OK.
61631 **
61632 ** If there are outstanding FK violations and this function returns 
61633 ** SQLCIPHER_ERROR, set the result of the VM to SQLCIPHER_CONSTRAINT and write
61634 ** an error message to it. Then return SQLCIPHER_ERROR.
61635 */
61636 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
61637 SQLCIPHER_PRIVATE int sqlcipher3VdbeCheckFk(Vdbe *p, int deferred){
61638   sqlcipher3 *db = p->db;
61639   if( (deferred && db->nDeferredCons>0) || (!deferred && p->nFkConstraint>0) ){
61640     p->rc = SQLCIPHER_CONSTRAINT;
61641     p->errorAction = OE_Abort;
61642     sqlcipher3SetString(&p->zErrMsg, db, "foreign key constraint failed");
61643     return SQLCIPHER_ERROR;
61644   }
61645   return SQLCIPHER_OK;
61646 }
61647 #endif
61648
61649 /*
61650 ** This routine is called the when a VDBE tries to halt.  If the VDBE
61651 ** has made changes and is in autocommit mode, then commit those
61652 ** changes.  If a rollback is needed, then do the rollback.
61653 **
61654 ** This routine is the only way to move the state of a VM from
61655 ** SQLCIPHER_MAGIC_RUN to SQLCIPHER_MAGIC_HALT.  It is harmless to
61656 ** call this on a VM that is in the SQLCIPHER_MAGIC_HALT state.
61657 **
61658 ** Return an error code.  If the commit could not complete because of
61659 ** lock contention, return SQLCIPHER_BUSY.  If SQLCIPHER_BUSY is returned, it
61660 ** means the close did not happen and needs to be repeated.
61661 */
61662 SQLCIPHER_PRIVATE int sqlcipher3VdbeHalt(Vdbe *p){
61663   int rc;                         /* Used to store transient return codes */
61664   sqlcipher3 *db = p->db;
61665
61666   /* This function contains the logic that determines if a statement or
61667   ** transaction will be committed or rolled back as a result of the
61668   ** execution of this virtual machine. 
61669   **
61670   ** If any of the following errors occur:
61671   **
61672   **     SQLCIPHER_NOMEM
61673   **     SQLCIPHER_IOERR
61674   **     SQLCIPHER_FULL
61675   **     SQLCIPHER_INTERRUPT
61676   **
61677   ** Then the internal cache might have been left in an inconsistent
61678   ** state.  We need to rollback the statement transaction, if there is
61679   ** one, or the complete transaction if there is no statement transaction.
61680   */
61681
61682   if( p->db->mallocFailed ){
61683     p->rc = SQLCIPHER_NOMEM;
61684   }
61685   closeAllCursors(p);
61686   if( p->magic!=VDBE_MAGIC_RUN ){
61687     return SQLCIPHER_OK;
61688   }
61689   checkActiveVdbeCnt(db);
61690
61691   /* No commit or rollback needed if the program never started */
61692   if( p->pc>=0 ){
61693     int mrc;   /* Primary error code from p->rc */
61694     int eStatementOp = 0;
61695     int isSpecialError;            /* Set to true if a 'special' error */
61696
61697     /* Lock all btrees used by the statement */
61698     sqlcipher3VdbeEnter(p);
61699
61700     /* Check for one of the special errors */
61701     mrc = p->rc & 0xff;
61702     assert( p->rc!=SQLCIPHER_IOERR_BLOCKED );  /* This error no longer exists */
61703     isSpecialError = mrc==SQLCIPHER_NOMEM || mrc==SQLCIPHER_IOERR
61704                      || mrc==SQLCIPHER_INTERRUPT || mrc==SQLCIPHER_FULL;
61705     if( isSpecialError ){
61706       /* If the query was read-only and the error code is SQLCIPHER_INTERRUPT, 
61707       ** no rollback is necessary. Otherwise, at least a savepoint 
61708       ** transaction must be rolled back to restore the database to a 
61709       ** consistent state.
61710       **
61711       ** Even if the statement is read-only, it is important to perform
61712       ** a statement or transaction rollback operation. If the error 
61713       ** occured while writing to the journal, sub-journal or database
61714       ** file as part of an effort to free up cache space (see function
61715       ** pagerStress() in pager.c), the rollback is required to restore 
61716       ** the pager to a consistent state.
61717       */
61718       if( !p->readOnly || mrc!=SQLCIPHER_INTERRUPT ){
61719         if( (mrc==SQLCIPHER_NOMEM || mrc==SQLCIPHER_FULL) && p->usesStmtJournal ){
61720           eStatementOp = SAVEPOINT_ROLLBACK;
61721         }else{
61722           /* We are forced to roll back the active transaction. Before doing
61723           ** so, abort any other statements this handle currently has active.
61724           */
61725           invalidateCursorsOnModifiedBtrees(db);
61726           sqlcipher3RollbackAll(db);
61727           sqlcipher3CloseSavepoints(db);
61728           db->autoCommit = 1;
61729         }
61730       }
61731     }
61732
61733     /* Check for immediate foreign key violations. */
61734     if( p->rc==SQLCIPHER_OK ){
61735       sqlcipher3VdbeCheckFk(p, 0);
61736     }
61737   
61738     /* If the auto-commit flag is set and this is the only active writer 
61739     ** VM, then we do either a commit or rollback of the current transaction. 
61740     **
61741     ** Note: This block also runs if one of the special errors handled 
61742     ** above has occurred. 
61743     */
61744     if( !sqlcipher3VtabInSync(db) 
61745      && db->autoCommit 
61746      && db->writeVdbeCnt==(p->readOnly==0) 
61747     ){
61748       if( p->rc==SQLCIPHER_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
61749         rc = sqlcipher3VdbeCheckFk(p, 1);
61750         if( rc!=SQLCIPHER_OK ){
61751           if( NEVER(p->readOnly) ){
61752             sqlcipher3VdbeLeave(p);
61753             return SQLCIPHER_ERROR;
61754           }
61755           rc = SQLCIPHER_CONSTRAINT;
61756         }else{ 
61757           /* The auto-commit flag is true, the vdbe program was successful 
61758           ** or hit an 'OR FAIL' constraint and there are no deferred foreign
61759           ** key constraints to hold up the transaction. This means a commit 
61760           ** is required. */
61761           rc = vdbeCommit(db, p);
61762         }
61763         if( rc==SQLCIPHER_BUSY && p->readOnly ){
61764           sqlcipher3VdbeLeave(p);
61765           return SQLCIPHER_BUSY;
61766         }else if( rc!=SQLCIPHER_OK ){
61767           p->rc = rc;
61768           sqlcipher3RollbackAll(db);
61769         }else{
61770           db->nDeferredCons = 0;
61771           sqlcipher3CommitInternalChanges(db);
61772         }
61773       }else{
61774         sqlcipher3RollbackAll(db);
61775       }
61776       db->nStatement = 0;
61777     }else if( eStatementOp==0 ){
61778       if( p->rc==SQLCIPHER_OK || p->errorAction==OE_Fail ){
61779         eStatementOp = SAVEPOINT_RELEASE;
61780       }else if( p->errorAction==OE_Abort ){
61781         eStatementOp = SAVEPOINT_ROLLBACK;
61782       }else{
61783         invalidateCursorsOnModifiedBtrees(db);
61784         sqlcipher3RollbackAll(db);
61785         sqlcipher3CloseSavepoints(db);
61786         db->autoCommit = 1;
61787       }
61788     }
61789   
61790     /* If eStatementOp is non-zero, then a statement transaction needs to
61791     ** be committed or rolled back. Call sqlcipher3VdbeCloseStatement() to
61792     ** do so. If this operation returns an error, and the current statement
61793     ** error code is SQLCIPHER_OK or SQLCIPHER_CONSTRAINT, then promote the
61794     ** current statement error code.
61795     */
61796     if( eStatementOp ){
61797       rc = sqlcipher3VdbeCloseStatement(p, eStatementOp);
61798       if( rc ){
61799         if( p->rc==SQLCIPHER_OK || p->rc==SQLCIPHER_CONSTRAINT ){
61800           p->rc = rc;
61801           sqlcipher3DbFree(db, p->zErrMsg);
61802           p->zErrMsg = 0;
61803         }
61804         invalidateCursorsOnModifiedBtrees(db);
61805         sqlcipher3RollbackAll(db);
61806         sqlcipher3CloseSavepoints(db);
61807         db->autoCommit = 1;
61808       }
61809     }
61810   
61811     /* If this was an INSERT, UPDATE or DELETE and no statement transaction
61812     ** has been rolled back, update the database connection change-counter. 
61813     */
61814     if( p->changeCntOn ){
61815       if( eStatementOp!=SAVEPOINT_ROLLBACK ){
61816         sqlcipher3VdbeSetChanges(db, p->nChange);
61817       }else{
61818         sqlcipher3VdbeSetChanges(db, 0);
61819       }
61820       p->nChange = 0;
61821     }
61822   
61823     /* Rollback or commit any schema changes that occurred. */
61824     if( p->rc!=SQLCIPHER_OK && db->flags&SQLCIPHER_InternChanges ){
61825       sqlcipher3ResetInternalSchema(db, -1);
61826       db->flags = (db->flags | SQLCIPHER_InternChanges);
61827     }
61828
61829     /* Release the locks */
61830     sqlcipher3VdbeLeave(p);
61831   }
61832
61833   /* We have successfully halted and closed the VM.  Record this fact. */
61834   if( p->pc>=0 ){
61835     db->activeVdbeCnt--;
61836     if( !p->readOnly ){
61837       db->writeVdbeCnt--;
61838     }
61839     assert( db->activeVdbeCnt>=db->writeVdbeCnt );
61840   }
61841   p->magic = VDBE_MAGIC_HALT;
61842   checkActiveVdbeCnt(db);
61843   if( p->db->mallocFailed ){
61844     p->rc = SQLCIPHER_NOMEM;
61845   }
61846
61847   /* If the auto-commit flag is set to true, then any locks that were held
61848   ** by connection db have now been released. Call sqlcipher3ConnectionUnlocked() 
61849   ** to invoke any required unlock-notify callbacks.
61850   */
61851   if( db->autoCommit ){
61852     sqlcipher3ConnectionUnlocked(db);
61853   }
61854
61855   assert( db->activeVdbeCnt>0 || db->autoCommit==0 || db->nStatement==0 );
61856   return (p->rc==SQLCIPHER_BUSY ? SQLCIPHER_BUSY : SQLCIPHER_OK);
61857 }
61858
61859
61860 /*
61861 ** Each VDBE holds the result of the most recent sqlcipher3_step() call
61862 ** in p->rc.  This routine sets that result back to SQLCIPHER_OK.
61863 */
61864 SQLCIPHER_PRIVATE void sqlcipher3VdbeResetStepResult(Vdbe *p){
61865   p->rc = SQLCIPHER_OK;
61866 }
61867
61868 /*
61869 ** Copy the error code and error message belonging to the VDBE passed
61870 ** as the first argument to its database handle (so that they will be 
61871 ** returned by calls to sqlcipher3_errcode() and sqlcipher3_errmsg()).
61872 **
61873 ** This function does not clear the VDBE error code or message, just
61874 ** copies them to the database handle.
61875 */
61876 SQLCIPHER_PRIVATE int sqlcipher3VdbeTransferError(Vdbe *p){
61877   sqlcipher3 *db = p->db;
61878   int rc = p->rc;
61879   if( p->zErrMsg ){
61880     u8 mallocFailed = db->mallocFailed;
61881     sqlcipher3BeginBenignMalloc();
61882     sqlcipher3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLCIPHER_UTF8, SQLCIPHER_TRANSIENT);
61883     sqlcipher3EndBenignMalloc();
61884     db->mallocFailed = mallocFailed;
61885     db->errCode = rc;
61886   }else{
61887     sqlcipher3Error(db, rc, 0);
61888   }
61889   return rc;
61890 }
61891
61892 /*
61893 ** Clean up a VDBE after execution but do not delete the VDBE just yet.
61894 ** Write any error messages into *pzErrMsg.  Return the result code.
61895 **
61896 ** After this routine is run, the VDBE should be ready to be executed
61897 ** again.
61898 **
61899 ** To look at it another way, this routine resets the state of the
61900 ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
61901 ** VDBE_MAGIC_INIT.
61902 */
61903 SQLCIPHER_PRIVATE int sqlcipher3VdbeReset(Vdbe *p){
61904   sqlcipher3 *db;
61905   db = p->db;
61906
61907   /* If the VM did not run to completion or if it encountered an
61908   ** error, then it might not have been halted properly.  So halt
61909   ** it now.
61910   */
61911   sqlcipher3VdbeHalt(p);
61912
61913   /* If the VDBE has be run even partially, then transfer the error code
61914   ** and error message from the VDBE into the main database structure.  But
61915   ** if the VDBE has just been set to run but has not actually executed any
61916   ** instructions yet, leave the main database error information unchanged.
61917   */
61918   if( p->pc>=0 ){
61919     sqlcipher3VdbeTransferError(p);
61920     sqlcipher3DbFree(db, p->zErrMsg);
61921     p->zErrMsg = 0;
61922     if( p->runOnlyOnce ) p->expired = 1;
61923   }else if( p->rc && p->expired ){
61924     /* The expired flag was set on the VDBE before the first call
61925     ** to sqlcipher3_step(). For consistency (since sqlcipher3_step() was
61926     ** called), set the database error in this case as well.
61927     */
61928     sqlcipher3Error(db, p->rc, 0);
61929     sqlcipher3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLCIPHER_UTF8, SQLCIPHER_TRANSIENT);
61930     sqlcipher3DbFree(db, p->zErrMsg);
61931     p->zErrMsg = 0;
61932   }
61933
61934   /* Reclaim all memory used by the VDBE
61935   */
61936   Cleanup(p);
61937
61938   /* Save profiling information from this VDBE run.
61939   */
61940 #ifdef VDBE_PROFILE
61941   {
61942     FILE *out = fopen("vdbe_profile.out", "a");
61943     if( out ){
61944       int i;
61945       fprintf(out, "---- ");
61946       for(i=0; i<p->nOp; i++){
61947         fprintf(out, "%02x", p->aOp[i].opcode);
61948       }
61949       fprintf(out, "\n");
61950       for(i=0; i<p->nOp; i++){
61951         fprintf(out, "%6d %10lld %8lld ",
61952            p->aOp[i].cnt,
61953            p->aOp[i].cycles,
61954            p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
61955         );
61956         sqlcipher3VdbePrintOp(out, i, &p->aOp[i]);
61957       }
61958       fclose(out);
61959     }
61960   }
61961 #endif
61962   p->magic = VDBE_MAGIC_INIT;
61963   return p->rc & db->errMask;
61964 }
61965  
61966 /*
61967 ** Clean up and delete a VDBE after execution.  Return an integer which is
61968 ** the result code.  Write any error message text into *pzErrMsg.
61969 */
61970 SQLCIPHER_PRIVATE int sqlcipher3VdbeFinalize(Vdbe *p){
61971   int rc = SQLCIPHER_OK;
61972   if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
61973     rc = sqlcipher3VdbeReset(p);
61974     assert( (rc & p->db->errMask)==rc );
61975   }
61976   sqlcipher3VdbeDelete(p);
61977   return rc;
61978 }
61979
61980 /*
61981 ** Call the destructor for each auxdata entry in pVdbeFunc for which
61982 ** the corresponding bit in mask is clear.  Auxdata entries beyond 31
61983 ** are always destroyed.  To destroy all auxdata entries, call this
61984 ** routine with mask==0.
61985 */
61986 SQLCIPHER_PRIVATE void sqlcipher3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){
61987   int i;
61988   for(i=0; i<pVdbeFunc->nAux; i++){
61989     struct AuxData *pAux = &pVdbeFunc->apAux[i];
61990     if( (i>31 || !(mask&(((u32)1)<<i))) && pAux->pAux ){
61991       if( pAux->xDelete ){
61992         pAux->xDelete(pAux->pAux);
61993       }
61994       pAux->pAux = 0;
61995     }
61996   }
61997 }
61998
61999 /*
62000 ** Free all memory associated with the Vdbe passed as the second argument.
62001 ** The difference between this function and sqlcipher3VdbeDelete() is that
62002 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
62003 ** the database connection.
62004 */
62005 SQLCIPHER_PRIVATE void sqlcipher3VdbeDeleteObject(sqlcipher3 *db, Vdbe *p){
62006   SubProgram *pSub, *pNext;
62007   int i;
62008   assert( p->db==0 || p->db==db );
62009   releaseMemArray(p->aVar, p->nVar);
62010   releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
62011   for(pSub=p->pProgram; pSub; pSub=pNext){
62012     pNext = pSub->pNext;
62013     vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
62014     sqlcipher3DbFree(db, pSub);
62015   }
62016   for(i=p->nzVar-1; i>=0; i--) sqlcipher3DbFree(db, p->azVar[i]);
62017   vdbeFreeOpArray(db, p->aOp, p->nOp);
62018   sqlcipher3DbFree(db, p->aLabel);
62019   sqlcipher3DbFree(db, p->aColName);
62020   sqlcipher3DbFree(db, p->zSql);
62021   sqlcipher3DbFree(db, p->pFree);
62022   sqlcipher3DbFree(db, p);
62023 }
62024
62025 /*
62026 ** Delete an entire VDBE.
62027 */
62028 SQLCIPHER_PRIVATE void sqlcipher3VdbeDelete(Vdbe *p){
62029   sqlcipher3 *db;
62030
62031   if( NEVER(p==0) ) return;
62032   db = p->db;
62033   if( p->pPrev ){
62034     p->pPrev->pNext = p->pNext;
62035   }else{
62036     assert( db->pVdbe==p );
62037     db->pVdbe = p->pNext;
62038   }
62039   if( p->pNext ){
62040     p->pNext->pPrev = p->pPrev;
62041   }
62042   p->magic = VDBE_MAGIC_DEAD;
62043   p->db = 0;
62044   sqlcipher3VdbeDeleteObject(db, p);
62045 }
62046
62047 /*
62048 ** Make sure the cursor p is ready to read or write the row to which it
62049 ** was last positioned.  Return an error code if an OOM fault or I/O error
62050 ** prevents us from positioning the cursor to its correct position.
62051 **
62052 ** If a MoveTo operation is pending on the given cursor, then do that
62053 ** MoveTo now.  If no move is pending, check to see if the row has been
62054 ** deleted out from under the cursor and if it has, mark the row as
62055 ** a NULL row.
62056 **
62057 ** If the cursor is already pointing to the correct row and that row has
62058 ** not been deleted out from under the cursor, then this routine is a no-op.
62059 */
62060 SQLCIPHER_PRIVATE int sqlcipher3VdbeCursorMoveto(VdbeCursor *p){
62061   if( p->deferredMoveto ){
62062     int res, rc;
62063 #ifdef SQLCIPHER_TEST
62064     extern int sqlcipher3_search_count;
62065 #endif
62066     assert( p->isTable );
62067     rc = sqlcipher3BtreeMovetoUnpacked(p->pCursor, 0, p->movetoTarget, 0, &res);
62068     if( rc ) return rc;
62069     p->lastRowid = p->movetoTarget;
62070     if( res!=0 ) return SQLCIPHER_CORRUPT_BKPT;
62071     p->rowidIsValid = 1;
62072 #ifdef SQLCIPHER_TEST
62073     sqlcipher3_search_count++;
62074 #endif
62075     p->deferredMoveto = 0;
62076     p->cacheStatus = CACHE_STALE;
62077   }else if( ALWAYS(p->pCursor) ){
62078     int hasMoved;
62079     int rc = sqlcipher3BtreeCursorHasMoved(p->pCursor, &hasMoved);
62080     if( rc ) return rc;
62081     if( hasMoved ){
62082       p->cacheStatus = CACHE_STALE;
62083       p->nullRow = 1;
62084     }
62085   }
62086   return SQLCIPHER_OK;
62087 }
62088
62089 /*
62090 ** The following functions:
62091 **
62092 ** sqlcipher3VdbeSerialType()
62093 ** sqlcipher3VdbeSerialTypeLen()
62094 ** sqlcipher3VdbeSerialLen()
62095 ** sqlcipher3VdbeSerialPut()
62096 ** sqlcipher3VdbeSerialGet()
62097 **
62098 ** encapsulate the code that serializes values for storage in SQLite
62099 ** data and index records. Each serialized value consists of a
62100 ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
62101 ** integer, stored as a varint.
62102 **
62103 ** In an SQLite index record, the serial type is stored directly before
62104 ** the blob of data that it corresponds to. In a table record, all serial
62105 ** types are stored at the start of the record, and the blobs of data at
62106 ** the end. Hence these functions allow the caller to handle the
62107 ** serial-type and data blob seperately.
62108 **
62109 ** The following table describes the various storage classes for data:
62110 **
62111 **   serial type        bytes of data      type
62112 **   --------------     ---------------    ---------------
62113 **      0                     0            NULL
62114 **      1                     1            signed integer
62115 **      2                     2            signed integer
62116 **      3                     3            signed integer
62117 **      4                     4            signed integer
62118 **      5                     6            signed integer
62119 **      6                     8            signed integer
62120 **      7                     8            IEEE float
62121 **      8                     0            Integer constant 0
62122 **      9                     0            Integer constant 1
62123 **     10,11                               reserved for expansion
62124 **    N>=12 and even       (N-12)/2        BLOB
62125 **    N>=13 and odd        (N-13)/2        text
62126 **
62127 ** The 8 and 9 types were added in 3.3.0, file format 4.  Prior versions
62128 ** of SQLite will not understand those serial types.
62129 */
62130
62131 /*
62132 ** Return the serial-type for the value stored in pMem.
62133 */
62134 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialType(Mem *pMem, int file_format){
62135   int flags = pMem->flags;
62136   int n;
62137
62138   if( flags&MEM_Null ){
62139     return 0;
62140   }
62141   if( flags&MEM_Int ){
62142     /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
62143 #   define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
62144     i64 i = pMem->u.i;
62145     u64 u;
62146     if( file_format>=4 && (i&1)==i ){
62147       return 8+(u32)i;
62148     }
62149     if( i<0 ){
62150       if( i<(-MAX_6BYTE) ) return 6;
62151       /* Previous test prevents:  u = -(-9223372036854775808) */
62152       u = -i;
62153     }else{
62154       u = i;
62155     }
62156     if( u<=127 ) return 1;
62157     if( u<=32767 ) return 2;
62158     if( u<=8388607 ) return 3;
62159     if( u<=2147483647 ) return 4;
62160     if( u<=MAX_6BYTE ) return 5;
62161     return 6;
62162   }
62163   if( flags&MEM_Real ){
62164     return 7;
62165   }
62166   assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
62167   n = pMem->n;
62168   if( flags & MEM_Zero ){
62169     n += pMem->u.nZero;
62170   }
62171   assert( n>=0 );
62172   return ((n*2) + 12 + ((flags&MEM_Str)!=0));
62173 }
62174
62175 /*
62176 ** Return the length of the data corresponding to the supplied serial-type.
62177 */
62178 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialTypeLen(u32 serial_type){
62179   if( serial_type>=12 ){
62180     return (serial_type-12)/2;
62181   }else{
62182     static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 };
62183     return aSize[serial_type];
62184   }
62185 }
62186
62187 /*
62188 ** If we are on an architecture with mixed-endian floating 
62189 ** points (ex: ARM7) then swap the lower 4 bytes with the 
62190 ** upper 4 bytes.  Return the result.
62191 **
62192 ** For most architectures, this is a no-op.
62193 **
62194 ** (later):  It is reported to me that the mixed-endian problem
62195 ** on ARM7 is an issue with GCC, not with the ARM7 chip.  It seems
62196 ** that early versions of GCC stored the two words of a 64-bit
62197 ** float in the wrong order.  And that error has been propagated
62198 ** ever since.  The blame is not necessarily with GCC, though.
62199 ** GCC might have just copying the problem from a prior compiler.
62200 ** I am also told that newer versions of GCC that follow a different
62201 ** ABI get the byte order right.
62202 **
62203 ** Developers using SQLite on an ARM7 should compile and run their
62204 ** application using -DSQLCIPHER_DEBUG=1 at least once.  With DEBUG
62205 ** enabled, some asserts below will ensure that the byte order of
62206 ** floating point values is correct.
62207 **
62208 ** (2007-08-30)  Frank van Vugt has studied this problem closely
62209 ** and has send his findings to the SQLite developers.  Frank
62210 ** writes that some Linux kernels offer floating point hardware
62211 ** emulation that uses only 32-bit mantissas instead of a full 
62212 ** 48-bits as required by the IEEE standard.  (This is the
62213 ** CONFIG_FPE_FASTFPE option.)  On such systems, floating point
62214 ** byte swapping becomes very complicated.  To avoid problems,
62215 ** the necessary byte swapping is carried out using a 64-bit integer
62216 ** rather than a 64-bit float.  Frank assures us that the code here
62217 ** works for him.  We, the developers, have no way to independently
62218 ** verify this, but Frank seems to know what he is talking about
62219 ** so we trust him.
62220 */
62221 #ifdef SQLCIPHER_MIXED_ENDIAN_64BIT_FLOAT
62222 static u64 floatSwap(u64 in){
62223   union {
62224     u64 r;
62225     u32 i[2];
62226   } u;
62227   u32 t;
62228
62229   u.r = in;
62230   t = u.i[0];
62231   u.i[0] = u.i[1];
62232   u.i[1] = t;
62233   return u.r;
62234 }
62235 # define swapMixedEndianFloat(X)  X = floatSwap(X)
62236 #else
62237 # define swapMixedEndianFloat(X)
62238 #endif
62239
62240 /*
62241 ** Write the serialized data blob for the value stored in pMem into 
62242 ** buf. It is assumed that the caller has allocated sufficient space.
62243 ** Return the number of bytes written.
62244 **
62245 ** nBuf is the amount of space left in buf[].  nBuf must always be
62246 ** large enough to hold the entire field.  Except, if the field is
62247 ** a blob with a zero-filled tail, then buf[] might be just the right
62248 ** size to hold everything except for the zero-filled tail.  If buf[]
62249 ** is only big enough to hold the non-zero prefix, then only write that
62250 ** prefix into buf[].  But if buf[] is large enough to hold both the
62251 ** prefix and the tail then write the prefix and set the tail to all
62252 ** zeros.
62253 **
62254 ** Return the number of bytes actually written into buf[].  The number
62255 ** of bytes in the zero-filled tail is included in the return value only
62256 ** if those bytes were zeroed in buf[].
62257 */ 
62258 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
62259   u32 serial_type = sqlcipher3VdbeSerialType(pMem, file_format);
62260   u32 len;
62261
62262   /* Integer and Real */
62263   if( serial_type<=7 && serial_type>0 ){
62264     u64 v;
62265     u32 i;
62266     if( serial_type==7 ){
62267       assert( sizeof(v)==sizeof(pMem->r) );
62268       memcpy(&v, &pMem->r, sizeof(v));
62269       swapMixedEndianFloat(v);
62270     }else{
62271       v = pMem->u.i;
62272     }
62273     len = i = sqlcipher3VdbeSerialTypeLen(serial_type);
62274     assert( len<=(u32)nBuf );
62275     while( i-- ){
62276       buf[i] = (u8)(v&0xFF);
62277       v >>= 8;
62278     }
62279     return len;
62280   }
62281
62282   /* String or blob */
62283   if( serial_type>=12 ){
62284     assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
62285              == (int)sqlcipher3VdbeSerialTypeLen(serial_type) );
62286     assert( pMem->n<=nBuf );
62287     len = pMem->n;
62288     memcpy(buf, pMem->z, len);
62289     if( pMem->flags & MEM_Zero ){
62290       len += pMem->u.nZero;
62291       assert( nBuf>=0 );
62292       if( len > (u32)nBuf ){
62293         len = (u32)nBuf;
62294       }
62295       memset(&buf[pMem->n], 0, len-pMem->n);
62296     }
62297     return len;
62298   }
62299
62300   /* NULL or constants 0 or 1 */
62301   return 0;
62302 }
62303
62304 /*
62305 ** Deserialize the data blob pointed to by buf as serial type serial_type
62306 ** and store the result in pMem.  Return the number of bytes read.
62307 */ 
62308 SQLCIPHER_PRIVATE u32 sqlcipher3VdbeSerialGet(
62309   const unsigned char *buf,     /* Buffer to deserialize from */
62310   u32 serial_type,              /* Serial type to deserialize */
62311   Mem *pMem                     /* Memory cell to write value into */
62312 ){
62313   switch( serial_type ){
62314     case 10:   /* Reserved for future use */
62315     case 11:   /* Reserved for future use */
62316     case 0: {  /* NULL */
62317       pMem->flags = MEM_Null;
62318       break;
62319     }
62320     case 1: { /* 1-byte signed integer */
62321       pMem->u.i = (signed char)buf[0];
62322       pMem->flags = MEM_Int;
62323       return 1;
62324     }
62325     case 2: { /* 2-byte signed integer */
62326       pMem->u.i = (((signed char)buf[0])<<8) | buf[1];
62327       pMem->flags = MEM_Int;
62328       return 2;
62329     }
62330     case 3: { /* 3-byte signed integer */
62331       pMem->u.i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2];
62332       pMem->flags = MEM_Int;
62333       return 3;
62334     }
62335     case 4: { /* 4-byte signed integer */
62336       pMem->u.i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
62337       pMem->flags = MEM_Int;
62338       return 4;
62339     }
62340     case 5: { /* 6-byte signed integer */
62341       u64 x = (((signed char)buf[0])<<8) | buf[1];
62342       u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5];
62343       x = (x<<32) | y;
62344       pMem->u.i = *(i64*)&x;
62345       pMem->flags = MEM_Int;
62346       return 6;
62347     }
62348     case 6:   /* 8-byte signed integer */
62349     case 7: { /* IEEE floating point */
62350       u64 x;
62351       u32 y;
62352 #if !defined(NDEBUG) && !defined(SQLCIPHER_OMIT_FLOATING_POINT)
62353       /* Verify that integers and floating point values use the same
62354       ** byte order.  Or, that if SQLCIPHER_MIXED_ENDIAN_64BIT_FLOAT is
62355       ** defined that 64-bit floating point values really are mixed
62356       ** endian.
62357       */
62358       static const u64 t1 = ((u64)0x3ff00000)<<32;
62359       static const double r1 = 1.0;
62360       u64 t2 = t1;
62361       swapMixedEndianFloat(t2);
62362       assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
62363 #endif
62364
62365       x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
62366       y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7];
62367       x = (x<<32) | y;
62368       if( serial_type==6 ){
62369         pMem->u.i = *(i64*)&x;
62370         pMem->flags = MEM_Int;
62371       }else{
62372         assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
62373         swapMixedEndianFloat(x);
62374         memcpy(&pMem->r, &x, sizeof(x));
62375         pMem->flags = sqlcipher3IsNaN(pMem->r) ? MEM_Null : MEM_Real;
62376       }
62377       return 8;
62378     }
62379     case 8:    /* Integer 0 */
62380     case 9: {  /* Integer 1 */
62381       pMem->u.i = serial_type-8;
62382       pMem->flags = MEM_Int;
62383       return 0;
62384     }
62385     default: {
62386       u32 len = (serial_type-12)/2;
62387       pMem->z = (char *)buf;
62388       pMem->n = len;
62389       pMem->xDel = 0;
62390       if( serial_type&0x01 ){
62391         pMem->flags = MEM_Str | MEM_Ephem;
62392       }else{
62393         pMem->flags = MEM_Blob | MEM_Ephem;
62394       }
62395       return len;
62396     }
62397   }
62398   return 0;
62399 }
62400
62401 /*
62402 ** This routine is used to allocate sufficient space for an UnpackedRecord
62403 ** structure large enough to be used with sqlcipher3VdbeRecordUnpack() if
62404 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
62405 **
62406 ** The space is either allocated using sqlcipher3DbMallocRaw() or from within
62407 ** the unaligned buffer passed via the second and third arguments (presumably
62408 ** stack space). If the former, then *ppFree is set to a pointer that should
62409 ** be eventually freed by the caller using sqlcipher3DbFree(). Or, if the 
62410 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
62411 ** before returning.
62412 **
62413 ** If an OOM error occurs, NULL is returned.
62414 */
62415 SQLCIPHER_PRIVATE UnpackedRecord *sqlcipher3VdbeAllocUnpackedRecord(
62416   KeyInfo *pKeyInfo,              /* Description of the record */
62417   char *pSpace,                   /* Unaligned space available */
62418   int szSpace,                    /* Size of pSpace[] in bytes */
62419   char **ppFree                   /* OUT: Caller should free this pointer */
62420 ){
62421   UnpackedRecord *p;              /* Unpacked record to return */
62422   int nOff;                       /* Increment pSpace by nOff to align it */
62423   int nByte;                      /* Number of bytes required for *p */
62424
62425   /* We want to shift the pointer pSpace up such that it is 8-byte aligned.
62426   ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift 
62427   ** it by.  If pSpace is already 8-byte aligned, nOff should be zero.
62428   */
62429   nOff = (8 - (SQLCIPHER_PTR_TO_INT(pSpace) & 7)) & 7;
62430   nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
62431   if( nByte>szSpace+nOff ){
62432     p = (UnpackedRecord *)sqlcipher3DbMallocRaw(pKeyInfo->db, nByte);
62433     *ppFree = (char *)p;
62434     if( !p ) return 0;
62435   }else{
62436     p = (UnpackedRecord*)&pSpace[nOff];
62437     *ppFree = 0;
62438   }
62439
62440   p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
62441   p->pKeyInfo = pKeyInfo;
62442   p->nField = pKeyInfo->nField + 1;
62443   return p;
62444 }
62445
62446 /*
62447 ** Given the nKey-byte encoding of a record in pKey[], populate the 
62448 ** UnpackedRecord structure indicated by the fourth argument with the
62449 ** contents of the decoded record.
62450 */ 
62451 SQLCIPHER_PRIVATE void sqlcipher3VdbeRecordUnpack(
62452   KeyInfo *pKeyInfo,     /* Information about the record format */
62453   int nKey,              /* Size of the binary record */
62454   const void *pKey,      /* The binary record */
62455   UnpackedRecord *p      /* Populate this structure before returning. */
62456 ){
62457   const unsigned char *aKey = (const unsigned char *)pKey;
62458   int d; 
62459   u32 idx;                        /* Offset in aKey[] to read from */
62460   u16 u;                          /* Unsigned loop counter */
62461   u32 szHdr;
62462   Mem *pMem = p->aMem;
62463
62464   p->flags = 0;
62465   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
62466   idx = getVarint32(aKey, szHdr);
62467   d = szHdr;
62468   u = 0;
62469   while( idx<szHdr && u<p->nField && d<=nKey ){
62470     u32 serial_type;
62471
62472     idx += getVarint32(&aKey[idx], serial_type);
62473     pMem->enc = pKeyInfo->enc;
62474     pMem->db = pKeyInfo->db;
62475     /* pMem->flags = 0; // sqlcipher3VdbeSerialGet() will set this for us */
62476     pMem->zMalloc = 0;
62477     d += sqlcipher3VdbeSerialGet(&aKey[d], serial_type, pMem);
62478     pMem++;
62479     u++;
62480   }
62481   assert( u<=pKeyInfo->nField + 1 );
62482   p->nField = u;
62483 }
62484
62485 /*
62486 ** This function compares the two table rows or index records
62487 ** specified by {nKey1, pKey1} and pPKey2.  It returns a negative, zero
62488 ** or positive integer if key1 is less than, equal to or 
62489 ** greater than key2.  The {nKey1, pKey1} key must be a blob
62490 ** created by th OP_MakeRecord opcode of the VDBE.  The pPKey2
62491 ** key must be a parsed key such as obtained from
62492 ** sqlcipher3VdbeParseRecord.
62493 **
62494 ** Key1 and Key2 do not have to contain the same number of fields.
62495 ** The key with fewer fields is usually compares less than the 
62496 ** longer key.  However if the UNPACKED_INCRKEY flags in pPKey2 is set
62497 ** and the common prefixes are equal, then key1 is less than key2.
62498 ** Or if the UNPACKED_MATCH_PREFIX flag is set and the prefixes are
62499 ** equal, then the keys are considered to be equal and
62500 ** the parts beyond the common prefix are ignored.
62501 **
62502 ** If the UNPACKED_IGNORE_ROWID flag is set, then the last byte of
62503 ** the header of pKey1 is ignored.  It is assumed that pKey1 is
62504 ** an index key, and thus ends with a rowid value.  The last byte
62505 ** of the header will therefore be the serial type of the rowid:
62506 ** one of 1, 2, 3, 4, 5, 6, 8, or 9 - the integer serial types.
62507 ** The serial type of the final rowid will always be a single byte.
62508 ** By ignoring this last byte of the header, we force the comparison
62509 ** to ignore the rowid at the end of key1.
62510 */
62511 SQLCIPHER_PRIVATE int sqlcipher3VdbeRecordCompare(
62512   int nKey1, const void *pKey1, /* Left key */
62513   UnpackedRecord *pPKey2        /* Right key */
62514 ){
62515   int d1;            /* Offset into aKey[] of next data element */
62516   u32 idx1;          /* Offset into aKey[] of next header element */
62517   u32 szHdr1;        /* Number of bytes in header */
62518   int i = 0;
62519   int nField;
62520   int rc = 0;
62521   const unsigned char *aKey1 = (const unsigned char *)pKey1;
62522   KeyInfo *pKeyInfo;
62523   Mem mem1;
62524
62525   pKeyInfo = pPKey2->pKeyInfo;
62526   mem1.enc = pKeyInfo->enc;
62527   mem1.db = pKeyInfo->db;
62528   /* mem1.flags = 0;  // Will be initialized by sqlcipher3VdbeSerialGet() */
62529   VVA_ONLY( mem1.zMalloc = 0; ) /* Only needed by assert() statements */
62530
62531   /* Compilers may complain that mem1.u.i is potentially uninitialized.
62532   ** We could initialize it, as shown here, to silence those complaints.
62533   ** But in fact, mem1.u.i will never actually be used uninitialized, and doing 
62534   ** the unnecessary initialization has a measurable negative performance
62535   ** impact, since this routine is a very high runner.  And so, we choose
62536   ** to ignore the compiler warnings and leave this variable uninitialized.
62537   */
62538   /*  mem1.u.i = 0;  // not needed, here to silence compiler warning */
62539   
62540   idx1 = getVarint32(aKey1, szHdr1);
62541   d1 = szHdr1;
62542   if( pPKey2->flags & UNPACKED_IGNORE_ROWID ){
62543     szHdr1--;
62544   }
62545   nField = pKeyInfo->nField;
62546   while( idx1<szHdr1 && i<pPKey2->nField ){
62547     u32 serial_type1;
62548
62549     /* Read the serial types for the next element in each key. */
62550     idx1 += getVarint32( aKey1+idx1, serial_type1 );
62551     if( d1>=nKey1 && sqlcipher3VdbeSerialTypeLen(serial_type1)>0 ) break;
62552
62553     /* Extract the values to be compared.
62554     */
62555     d1 += sqlcipher3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1);
62556
62557     /* Do the comparison
62558     */
62559     rc = sqlcipher3MemCompare(&mem1, &pPKey2->aMem[i],
62560                            i<nField ? pKeyInfo->aColl[i] : 0);
62561     if( rc!=0 ){
62562       assert( mem1.zMalloc==0 );  /* See comment below */
62563
62564       /* Invert the result if we are using DESC sort order. */
62565       if( pKeyInfo->aSortOrder && i<nField && pKeyInfo->aSortOrder[i] ){
62566         rc = -rc;
62567       }
62568     
62569       /* If the PREFIX_SEARCH flag is set and all fields except the final
62570       ** rowid field were equal, then clear the PREFIX_SEARCH flag and set 
62571       ** pPKey2->rowid to the value of the rowid field in (pKey1, nKey1).
62572       ** This is used by the OP_IsUnique opcode.
62573       */
62574       if( (pPKey2->flags & UNPACKED_PREFIX_SEARCH) && i==(pPKey2->nField-1) ){
62575         assert( idx1==szHdr1 && rc );
62576         assert( mem1.flags & MEM_Int );
62577         pPKey2->flags &= ~UNPACKED_PREFIX_SEARCH;
62578         pPKey2->rowid = mem1.u.i;
62579       }
62580     
62581       return rc;
62582     }
62583     i++;
62584   }
62585
62586   /* No memory allocation is ever used on mem1.  Prove this using
62587   ** the following assert().  If the assert() fails, it indicates a
62588   ** memory leak and a need to call sqlcipher3VdbeMemRelease(&mem1).
62589   */
62590   assert( mem1.zMalloc==0 );
62591
62592   /* rc==0 here means that one of the keys ran out of fields and
62593   ** all the fields up to that point were equal. If the UNPACKED_INCRKEY
62594   ** flag is set, then break the tie by treating key2 as larger.
62595   ** If the UPACKED_PREFIX_MATCH flag is set, then keys with common prefixes
62596   ** are considered to be equal.  Otherwise, the longer key is the 
62597   ** larger.  As it happens, the pPKey2 will always be the longer
62598   ** if there is a difference.
62599   */
62600   assert( rc==0 );
62601   if( pPKey2->flags & UNPACKED_INCRKEY ){
62602     rc = -1;
62603   }else if( pPKey2->flags & UNPACKED_PREFIX_MATCH ){
62604     /* Leave rc==0 */
62605   }else if( idx1<szHdr1 ){
62606     rc = 1;
62607   }
62608   return rc;
62609 }
62610  
62611
62612 /*
62613 ** pCur points at an index entry created using the OP_MakeRecord opcode.
62614 ** Read the rowid (the last field in the record) and store it in *rowid.
62615 ** Return SQLCIPHER_OK if everything works, or an error code otherwise.
62616 **
62617 ** pCur might be pointing to text obtained from a corrupt database file.
62618 ** So the content cannot be trusted.  Do appropriate checks on the content.
62619 */
62620 SQLCIPHER_PRIVATE int sqlcipher3VdbeIdxRowid(sqlcipher3 *db, BtCursor *pCur, i64 *rowid){
62621   i64 nCellKey = 0;
62622   int rc;
62623   u32 szHdr;        /* Size of the header */
62624   u32 typeRowid;    /* Serial type of the rowid */
62625   u32 lenRowid;     /* Size of the rowid */
62626   Mem m, v;
62627
62628   UNUSED_PARAMETER(db);
62629
62630   /* Get the size of the index entry.  Only indices entries of less
62631   ** than 2GiB are support - anything large must be database corruption.
62632   ** Any corruption is detected in sqlcipher3BtreeParseCellPtr(), though, so
62633   ** this code can safely assume that nCellKey is 32-bits  
62634   */
62635   assert( sqlcipher3BtreeCursorIsValid(pCur) );
62636   VVA_ONLY(rc =) sqlcipher3BtreeKeySize(pCur, &nCellKey);
62637   assert( rc==SQLCIPHER_OK );     /* pCur is always valid so KeySize cannot fail */
62638   assert( (nCellKey & SQLCIPHER_MAX_U32)==(u64)nCellKey );
62639
62640   /* Read in the complete content of the index entry */
62641   memset(&m, 0, sizeof(m));
62642   rc = sqlcipher3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
62643   if( rc ){
62644     return rc;
62645   }
62646
62647   /* The index entry must begin with a header size */
62648   (void)getVarint32((u8*)m.z, szHdr);
62649   testcase( szHdr==3 );
62650   testcase( szHdr==m.n );
62651   if( unlikely(szHdr<3 || (int)szHdr>m.n) ){
62652     goto idx_rowid_corruption;
62653   }
62654
62655   /* The last field of the index should be an integer - the ROWID.
62656   ** Verify that the last entry really is an integer. */
62657   (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
62658   testcase( typeRowid==1 );
62659   testcase( typeRowid==2 );
62660   testcase( typeRowid==3 );
62661   testcase( typeRowid==4 );
62662   testcase( typeRowid==5 );
62663   testcase( typeRowid==6 );
62664   testcase( typeRowid==8 );
62665   testcase( typeRowid==9 );
62666   if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){
62667     goto idx_rowid_corruption;
62668   }
62669   lenRowid = sqlcipher3VdbeSerialTypeLen(typeRowid);
62670   testcase( (u32)m.n==szHdr+lenRowid );
62671   if( unlikely((u32)m.n<szHdr+lenRowid) ){
62672     goto idx_rowid_corruption;
62673   }
62674
62675   /* Fetch the integer off the end of the index record */
62676   sqlcipher3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
62677   *rowid = v.u.i;
62678   sqlcipher3VdbeMemRelease(&m);
62679   return SQLCIPHER_OK;
62680
62681   /* Jump here if database corruption is detected after m has been
62682   ** allocated.  Free the m object and return SQLCIPHER_CORRUPT. */
62683 idx_rowid_corruption:
62684   testcase( m.zMalloc!=0 );
62685   sqlcipher3VdbeMemRelease(&m);
62686   return SQLCIPHER_CORRUPT_BKPT;
62687 }
62688
62689 /*
62690 ** Compare the key of the index entry that cursor pC is pointing to against
62691 ** the key string in pUnpacked.  Write into *pRes a number
62692 ** that is negative, zero, or positive if pC is less than, equal to,
62693 ** or greater than pUnpacked.  Return SQLCIPHER_OK on success.
62694 **
62695 ** pUnpacked is either created without a rowid or is truncated so that it
62696 ** omits the rowid at the end.  The rowid at the end of the index entry
62697 ** is ignored as well.  Hence, this routine only compares the prefixes 
62698 ** of the keys prior to the final rowid, not the entire key.
62699 */
62700 SQLCIPHER_PRIVATE int sqlcipher3VdbeIdxKeyCompare(
62701   VdbeCursor *pC,             /* The cursor to compare against */
62702   UnpackedRecord *pUnpacked,  /* Unpacked version of key to compare against */
62703   int *res                    /* Write the comparison result here */
62704 ){
62705   i64 nCellKey = 0;
62706   int rc;
62707   BtCursor *pCur = pC->pCursor;
62708   Mem m;
62709
62710   assert( sqlcipher3BtreeCursorIsValid(pCur) );
62711   VVA_ONLY(rc =) sqlcipher3BtreeKeySize(pCur, &nCellKey);
62712   assert( rc==SQLCIPHER_OK );    /* pCur is always valid so KeySize cannot fail */
62713   /* nCellKey will always be between 0 and 0xffffffff because of the say
62714   ** that btreeParseCellPtr() and sqlcipher3GetVarint32() are implemented */
62715   if( nCellKey<=0 || nCellKey>0x7fffffff ){
62716     *res = 0;
62717     return SQLCIPHER_CORRUPT_BKPT;
62718   }
62719   memset(&m, 0, sizeof(m));
62720   rc = sqlcipher3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
62721   if( rc ){
62722     return rc;
62723   }
62724   assert( pUnpacked->flags & UNPACKED_IGNORE_ROWID );
62725   *res = sqlcipher3VdbeRecordCompare(m.n, m.z, pUnpacked);
62726   sqlcipher3VdbeMemRelease(&m);
62727   return SQLCIPHER_OK;
62728 }
62729
62730 /*
62731 ** This routine sets the value to be returned by subsequent calls to
62732 ** sqlcipher3_changes() on the database handle 'db'. 
62733 */
62734 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetChanges(sqlcipher3 *db, int nChange){
62735   assert( sqlcipher3_mutex_held(db->mutex) );
62736   db->nChange = nChange;
62737   db->nTotalChange += nChange;
62738 }
62739
62740 /*
62741 ** Set a flag in the vdbe to update the change counter when it is finalised
62742 ** or reset.
62743 */
62744 SQLCIPHER_PRIVATE void sqlcipher3VdbeCountChanges(Vdbe *v){
62745   v->changeCntOn = 1;
62746 }
62747
62748 /*
62749 ** Mark every prepared statement associated with a database connection
62750 ** as expired.
62751 **
62752 ** An expired statement means that recompilation of the statement is
62753 ** recommend.  Statements expire when things happen that make their
62754 ** programs obsolete.  Removing user-defined functions or collating
62755 ** sequences, or changing an authorization function are the types of
62756 ** things that make prepared statements obsolete.
62757 */
62758 SQLCIPHER_PRIVATE void sqlcipher3ExpirePreparedStatements(sqlcipher3 *db){
62759   Vdbe *p;
62760   for(p = db->pVdbe; p; p=p->pNext){
62761     p->expired = 1;
62762   }
62763 }
62764
62765 /*
62766 ** Return the database associated with the Vdbe.
62767 */
62768 SQLCIPHER_PRIVATE sqlcipher3 *sqlcipher3VdbeDb(Vdbe *v){
62769   return v->db;
62770 }
62771
62772 /*
62773 ** Return a pointer to an sqlcipher3_value structure containing the value bound
62774 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return 
62775 ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLCIPHER_AFF_*
62776 ** constants) to the value before returning it.
62777 **
62778 ** The returned value must be freed by the caller using sqlcipher3ValueFree().
62779 */
62780 SQLCIPHER_PRIVATE sqlcipher3_value *sqlcipher3VdbeGetValue(Vdbe *v, int iVar, u8 aff){
62781   assert( iVar>0 );
62782   if( v ){
62783     Mem *pMem = &v->aVar[iVar-1];
62784     if( 0==(pMem->flags & MEM_Null) ){
62785       sqlcipher3_value *pRet = sqlcipher3ValueNew(v->db);
62786       if( pRet ){
62787         sqlcipher3VdbeMemCopy((Mem *)pRet, pMem);
62788         sqlcipher3ValueApplyAffinity(pRet, aff, SQLCIPHER_UTF8);
62789         sqlcipher3VdbeMemStoreType((Mem *)pRet);
62790       }
62791       return pRet;
62792     }
62793   }
62794   return 0;
62795 }
62796
62797 /*
62798 ** Configure SQL variable iVar so that binding a new value to it signals
62799 ** to sqlcipher3_reoptimize() that re-preparing the statement may result
62800 ** in a better query plan.
62801 */
62802 SQLCIPHER_PRIVATE void sqlcipher3VdbeSetVarmask(Vdbe *v, int iVar){
62803   assert( iVar>0 );
62804   if( iVar>32 ){
62805     v->expmask = 0xffffffff;
62806   }else{
62807     v->expmask |= ((u32)1 << (iVar-1));
62808   }
62809 }
62810
62811 /************** End of vdbeaux.c *********************************************/
62812 /************** Begin file vdbeapi.c *****************************************/
62813 /*
62814 ** 2004 May 26
62815 **
62816 ** The author disclaims copyright to this source code.  In place of
62817 ** a legal notice, here is a blessing:
62818 **
62819 **    May you do good and not evil.
62820 **    May you find forgiveness for yourself and forgive others.
62821 **    May you share freely, never taking more than you give.
62822 **
62823 *************************************************************************
62824 **
62825 ** This file contains code use to implement APIs that are part of the
62826 ** VDBE.
62827 */
62828
62829 #ifndef SQLCIPHER_OMIT_DEPRECATED
62830 /*
62831 ** Return TRUE (non-zero) of the statement supplied as an argument needs
62832 ** to be recompiled.  A statement needs to be recompiled whenever the
62833 ** execution environment changes in a way that would alter the program
62834 ** that sqlcipher3_prepare() generates.  For example, if new functions or
62835 ** collating sequences are registered or if an authorizer function is
62836 ** added or changed.
62837 */
62838 SQLCIPHER_API int sqlcipher3_expired(sqlcipher3_stmt *pStmt){
62839   Vdbe *p = (Vdbe*)pStmt;
62840   return p==0 || p->expired;
62841 }
62842 #endif
62843
62844 /*
62845 ** Check on a Vdbe to make sure it has not been finalized.  Log
62846 ** an error and return true if it has been finalized (or is otherwise
62847 ** invalid).  Return false if it is ok.
62848 */
62849 static int vdbeSafety(Vdbe *p){
62850   if( p->db==0 ){
62851     sqlcipher3_log(SQLCIPHER_MISUSE, "API called with finalized prepared statement");
62852     return 1;
62853   }else{
62854     return 0;
62855   }
62856 }
62857 static int vdbeSafetyNotNull(Vdbe *p){
62858   if( p==0 ){
62859     sqlcipher3_log(SQLCIPHER_MISUSE, "API called with NULL prepared statement");
62860     return 1;
62861   }else{
62862     return vdbeSafety(p);
62863   }
62864 }
62865
62866 /*
62867 ** The following routine destroys a virtual machine that is created by
62868 ** the sqlcipher3_compile() routine. The integer returned is an SQLCIPHER_
62869 ** success/failure code that describes the result of executing the virtual
62870 ** machine.
62871 **
62872 ** This routine sets the error code and string returned by
62873 ** sqlcipher3_errcode(), sqlcipher3_errmsg() and sqlcipher3_errmsg16().
62874 */
62875 SQLCIPHER_API int sqlcipher3_finalize(sqlcipher3_stmt *pStmt){
62876   int rc;
62877   if( pStmt==0 ){
62878     /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlcipher3_finalize() on a NULL
62879     ** pointer is a harmless no-op. */
62880     rc = SQLCIPHER_OK;
62881   }else{
62882     Vdbe *v = (Vdbe*)pStmt;
62883     sqlcipher3 *db = v->db;
62884 #if SQLCIPHER_THREADSAFE
62885     sqlcipher3_mutex *mutex;
62886 #endif
62887     if( vdbeSafety(v) ) return SQLCIPHER_MISUSE_BKPT;
62888 #if SQLCIPHER_THREADSAFE
62889     mutex = v->db->mutex;
62890 #endif
62891     sqlcipher3_mutex_enter(mutex);
62892     rc = sqlcipher3VdbeFinalize(v);
62893     rc = sqlcipher3ApiExit(db, rc);
62894     sqlcipher3_mutex_leave(mutex);
62895   }
62896   return rc;
62897 }
62898
62899 /*
62900 ** Terminate the current execution of an SQL statement and reset it
62901 ** back to its starting state so that it can be reused. A success code from
62902 ** the prior execution is returned.
62903 **
62904 ** This routine sets the error code and string returned by
62905 ** sqlcipher3_errcode(), sqlcipher3_errmsg() and sqlcipher3_errmsg16().
62906 */
62907 SQLCIPHER_API int sqlcipher3_reset(sqlcipher3_stmt *pStmt){
62908   int rc;
62909   if( pStmt==0 ){
62910     rc = SQLCIPHER_OK;
62911   }else{
62912     Vdbe *v = (Vdbe*)pStmt;
62913     sqlcipher3_mutex_enter(v->db->mutex);
62914     rc = sqlcipher3VdbeReset(v);
62915     sqlcipher3VdbeRewind(v);
62916     assert( (rc & (v->db->errMask))==rc );
62917     rc = sqlcipher3ApiExit(v->db, rc);
62918     sqlcipher3_mutex_leave(v->db->mutex);
62919   }
62920   return rc;
62921 }
62922
62923 /*
62924 ** Set all the parameters in the compiled SQL statement to NULL.
62925 */
62926 SQLCIPHER_API int sqlcipher3_clear_bindings(sqlcipher3_stmt *pStmt){
62927   int i;
62928   int rc = SQLCIPHER_OK;
62929   Vdbe *p = (Vdbe*)pStmt;
62930 #if SQLCIPHER_THREADSAFE
62931   sqlcipher3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
62932 #endif
62933   sqlcipher3_mutex_enter(mutex);
62934   for(i=0; i<p->nVar; i++){
62935     sqlcipher3VdbeMemRelease(&p->aVar[i]);
62936     p->aVar[i].flags = MEM_Null;
62937   }
62938   if( p->isPrepareV2 && p->expmask ){
62939     p->expired = 1;
62940   }
62941   sqlcipher3_mutex_leave(mutex);
62942   return rc;
62943 }
62944
62945
62946 /**************************** sqlcipher3_value_  *******************************
62947 ** The following routines extract information from a Mem or sqlcipher3_value
62948 ** structure.
62949 */
62950 SQLCIPHER_API const void *sqlcipher3_value_blob(sqlcipher3_value *pVal){
62951   Mem *p = (Mem*)pVal;
62952   if( p->flags & (MEM_Blob|MEM_Str) ){
62953     sqlcipher3VdbeMemExpandBlob(p);
62954     p->flags &= ~MEM_Str;
62955     p->flags |= MEM_Blob;
62956     return p->n ? p->z : 0;
62957   }else{
62958     return sqlcipher3_value_text(pVal);
62959   }
62960 }
62961 SQLCIPHER_API int sqlcipher3_value_bytes(sqlcipher3_value *pVal){
62962   return sqlcipher3ValueBytes(pVal, SQLCIPHER_UTF8);
62963 }
62964 SQLCIPHER_API int sqlcipher3_value_bytes16(sqlcipher3_value *pVal){
62965   return sqlcipher3ValueBytes(pVal, SQLCIPHER_UTF16NATIVE);
62966 }
62967 SQLCIPHER_API double sqlcipher3_value_double(sqlcipher3_value *pVal){
62968   return sqlcipher3VdbeRealValue((Mem*)pVal);
62969 }
62970 SQLCIPHER_API int sqlcipher3_value_int(sqlcipher3_value *pVal){
62971   return (int)sqlcipher3VdbeIntValue((Mem*)pVal);
62972 }
62973 SQLCIPHER_API sqlcipher_int64 sqlcipher3_value_int64(sqlcipher3_value *pVal){
62974   return sqlcipher3VdbeIntValue((Mem*)pVal);
62975 }
62976 SQLCIPHER_API const unsigned char *sqlcipher3_value_text(sqlcipher3_value *pVal){
62977   return (const unsigned char *)sqlcipher3ValueText(pVal, SQLCIPHER_UTF8);
62978 }
62979 #ifndef SQLCIPHER_OMIT_UTF16
62980 SQLCIPHER_API const void *sqlcipher3_value_text16(sqlcipher3_value* pVal){
62981   return sqlcipher3ValueText(pVal, SQLCIPHER_UTF16NATIVE);
62982 }
62983 SQLCIPHER_API const void *sqlcipher3_value_text16be(sqlcipher3_value *pVal){
62984   return sqlcipher3ValueText(pVal, SQLCIPHER_UTF16BE);
62985 }
62986 SQLCIPHER_API const void *sqlcipher3_value_text16le(sqlcipher3_value *pVal){
62987   return sqlcipher3ValueText(pVal, SQLCIPHER_UTF16LE);
62988 }
62989 #endif /* SQLCIPHER_OMIT_UTF16 */
62990 SQLCIPHER_API int sqlcipher3_value_type(sqlcipher3_value* pVal){
62991   return pVal->type;
62992 }
62993
62994 /**************************** sqlcipher3_result_  *******************************
62995 ** The following routines are used by user-defined functions to specify
62996 ** the function result.
62997 **
62998 ** The setStrOrError() funtion calls sqlcipher3VdbeMemSetStr() to store the
62999 ** result as a string or blob but if the string or blob is too large, it
63000 ** then sets the error code to SQLCIPHER_TOOBIG
63001 */
63002 static void setResultStrOrError(
63003   sqlcipher3_context *pCtx,  /* Function context */
63004   const char *z,          /* String pointer */
63005   int n,                  /* Bytes in string, or negative */
63006   u8 enc,                 /* Encoding of z.  0 for BLOBs */
63007   void (*xDel)(void*)     /* Destructor function */
63008 ){
63009   if( sqlcipher3VdbeMemSetStr(&pCtx->s, z, n, enc, xDel)==SQLCIPHER_TOOBIG ){
63010     sqlcipher3_result_error_toobig(pCtx);
63011   }
63012 }
63013 SQLCIPHER_API void sqlcipher3_result_blob(
63014   sqlcipher3_context *pCtx, 
63015   const void *z, 
63016   int n, 
63017   void (*xDel)(void *)
63018 ){
63019   assert( n>=0 );
63020   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63021   setResultStrOrError(pCtx, z, n, 0, xDel);
63022 }
63023 SQLCIPHER_API void sqlcipher3_result_double(sqlcipher3_context *pCtx, double rVal){
63024   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63025   sqlcipher3VdbeMemSetDouble(&pCtx->s, rVal);
63026 }
63027 SQLCIPHER_API void sqlcipher3_result_error(sqlcipher3_context *pCtx, const char *z, int n){
63028   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63029   pCtx->isError = SQLCIPHER_ERROR;
63030   sqlcipher3VdbeMemSetStr(&pCtx->s, z, n, SQLCIPHER_UTF8, SQLCIPHER_TRANSIENT);
63031 }
63032 #ifndef SQLCIPHER_OMIT_UTF16
63033 SQLCIPHER_API void sqlcipher3_result_error16(sqlcipher3_context *pCtx, const void *z, int n){
63034   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63035   pCtx->isError = SQLCIPHER_ERROR;
63036   sqlcipher3VdbeMemSetStr(&pCtx->s, z, n, SQLCIPHER_UTF16NATIVE, SQLCIPHER_TRANSIENT);
63037 }
63038 #endif
63039 SQLCIPHER_API void sqlcipher3_result_int(sqlcipher3_context *pCtx, int iVal){
63040   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63041   sqlcipher3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
63042 }
63043 SQLCIPHER_API void sqlcipher3_result_int64(sqlcipher3_context *pCtx, i64 iVal){
63044   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63045   sqlcipher3VdbeMemSetInt64(&pCtx->s, iVal);
63046 }
63047 SQLCIPHER_API void sqlcipher3_result_null(sqlcipher3_context *pCtx){
63048   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63049   sqlcipher3VdbeMemSetNull(&pCtx->s);
63050 }
63051 SQLCIPHER_API void sqlcipher3_result_text(
63052   sqlcipher3_context *pCtx, 
63053   const char *z, 
63054   int n,
63055   void (*xDel)(void *)
63056 ){
63057   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63058   setResultStrOrError(pCtx, z, n, SQLCIPHER_UTF8, xDel);
63059 }
63060 #ifndef SQLCIPHER_OMIT_UTF16
63061 SQLCIPHER_API void sqlcipher3_result_text16(
63062   sqlcipher3_context *pCtx, 
63063   const void *z, 
63064   int n, 
63065   void (*xDel)(void *)
63066 ){
63067   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63068   setResultStrOrError(pCtx, z, n, SQLCIPHER_UTF16NATIVE, xDel);
63069 }
63070 SQLCIPHER_API void sqlcipher3_result_text16be(
63071   sqlcipher3_context *pCtx, 
63072   const void *z, 
63073   int n, 
63074   void (*xDel)(void *)
63075 ){
63076   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63077   setResultStrOrError(pCtx, z, n, SQLCIPHER_UTF16BE, xDel);
63078 }
63079 SQLCIPHER_API void sqlcipher3_result_text16le(
63080   sqlcipher3_context *pCtx, 
63081   const void *z, 
63082   int n, 
63083   void (*xDel)(void *)
63084 ){
63085   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63086   setResultStrOrError(pCtx, z, n, SQLCIPHER_UTF16LE, xDel);
63087 }
63088 #endif /* SQLCIPHER_OMIT_UTF16 */
63089 SQLCIPHER_API void sqlcipher3_result_value(sqlcipher3_context *pCtx, sqlcipher3_value *pValue){
63090   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63091   sqlcipher3VdbeMemCopy(&pCtx->s, pValue);
63092 }
63093 SQLCIPHER_API void sqlcipher3_result_zeroblob(sqlcipher3_context *pCtx, int n){
63094   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63095   sqlcipher3VdbeMemSetZeroBlob(&pCtx->s, n);
63096 }
63097 SQLCIPHER_API void sqlcipher3_result_error_code(sqlcipher3_context *pCtx, int errCode){
63098   pCtx->isError = errCode;
63099   if( pCtx->s.flags & MEM_Null ){
63100     sqlcipher3VdbeMemSetStr(&pCtx->s, sqlcipher3ErrStr(errCode), -1, 
63101                          SQLCIPHER_UTF8, SQLCIPHER_STATIC);
63102   }
63103 }
63104
63105 /* Force an SQLCIPHER_TOOBIG error. */
63106 SQLCIPHER_API void sqlcipher3_result_error_toobig(sqlcipher3_context *pCtx){
63107   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63108   pCtx->isError = SQLCIPHER_TOOBIG;
63109   sqlcipher3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1, 
63110                        SQLCIPHER_UTF8, SQLCIPHER_STATIC);
63111 }
63112
63113 /* An SQLCIPHER_NOMEM error. */
63114 SQLCIPHER_API void sqlcipher3_result_error_nomem(sqlcipher3_context *pCtx){
63115   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63116   sqlcipher3VdbeMemSetNull(&pCtx->s);
63117   pCtx->isError = SQLCIPHER_NOMEM;
63118   pCtx->s.db->mallocFailed = 1;
63119 }
63120
63121 /*
63122 ** This function is called after a transaction has been committed. It 
63123 ** invokes callbacks registered with sqlcipher3_wal_hook() as required.
63124 */
63125 static int doWalCallbacks(sqlcipher3 *db){
63126   int rc = SQLCIPHER_OK;
63127 #ifndef SQLCIPHER_OMIT_WAL
63128   int i;
63129   for(i=0; i<db->nDb; i++){
63130     Btree *pBt = db->aDb[i].pBt;
63131     if( pBt ){
63132       int nEntry = sqlcipher3PagerWalCallback(sqlcipher3BtreePager(pBt));
63133       if( db->xWalCallback && nEntry>0 && rc==SQLCIPHER_OK ){
63134         rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
63135       }
63136     }
63137   }
63138 #endif
63139   return rc;
63140 }
63141
63142 /*
63143 ** Execute the statement pStmt, either until a row of data is ready, the
63144 ** statement is completely executed or an error occurs.
63145 **
63146 ** This routine implements the bulk of the logic behind the sqlcipher_step()
63147 ** API.  The only thing omitted is the automatic recompile if a 
63148 ** schema change has occurred.  That detail is handled by the
63149 ** outer sqlcipher3_step() wrapper procedure.
63150 */
63151 static int sqlcipher3Step(Vdbe *p){
63152   sqlcipher3 *db;
63153   int rc;
63154
63155   assert(p);
63156   if( p->magic!=VDBE_MAGIC_RUN ){
63157     /* We used to require that sqlcipher3_reset() be called before retrying
63158     ** sqlcipher3_step() after any error or after SQLCIPHER_DONE.  But beginning
63159     ** with version 3.7.0, we changed this so that sqlcipher3_reset() would
63160     ** be called automatically instead of throwing the SQLCIPHER_MISUSE error.
63161     ** This "automatic-reset" change is not technically an incompatibility, 
63162     ** since any application that receives an SQLCIPHER_MISUSE is broken by
63163     ** definition.
63164     **
63165     ** Nevertheless, some published applications that were originally written
63166     ** for version 3.6.23 or earlier do in fact depend on SQLCIPHER_MISUSE 
63167     ** returns, and the so were broken by the automatic-reset change.  As a
63168     ** a work-around, the SQLCIPHER_OMIT_AUTORESET compile-time restores the
63169     ** legacy behavior of returning SQLCIPHER_MISUSE for cases where the 
63170     ** previous sqlcipher3_step() returned something other than a SQLCIPHER_LOCKED
63171     ** or SQLCIPHER_BUSY error.
63172     */
63173 #ifdef SQLCIPHER_OMIT_AUTORESET
63174     if( p->rc==SQLCIPHER_BUSY || p->rc==SQLCIPHER_LOCKED ){
63175       sqlcipher3_reset((sqlcipher3_stmt*)p);
63176     }else{
63177       return SQLCIPHER_MISUSE_BKPT;
63178     }
63179 #else
63180     sqlcipher3_reset((sqlcipher3_stmt*)p);
63181 #endif
63182   }
63183
63184   /* Check that malloc() has not failed. If it has, return early. */
63185   db = p->db;
63186   if( db->mallocFailed ){
63187     p->rc = SQLCIPHER_NOMEM;
63188     return SQLCIPHER_NOMEM;
63189   }
63190
63191   if( p->pc<=0 && p->expired ){
63192     p->rc = SQLCIPHER_SCHEMA;
63193     rc = SQLCIPHER_ERROR;
63194     goto end_of_step;
63195   }
63196   if( p->pc<0 ){
63197     /* If there are no other statements currently running, then
63198     ** reset the interrupt flag.  This prevents a call to sqlcipher3_interrupt
63199     ** from interrupting a statement that has not yet started.
63200     */
63201     if( db->activeVdbeCnt==0 ){
63202       db->u1.isInterrupted = 0;
63203     }
63204
63205     assert( db->writeVdbeCnt>0 || db->autoCommit==0 || db->nDeferredCons==0 );
63206
63207 #ifndef SQLCIPHER_OMIT_TRACE
63208     if( db->xProfile && !db->init.busy ){
63209       sqlcipher3OsCurrentTimeInt64(db->pVfs, &p->startTime);
63210     }
63211 #endif
63212
63213     db->activeVdbeCnt++;
63214     if( p->readOnly==0 ) db->writeVdbeCnt++;
63215     p->pc = 0;
63216   }
63217 #ifndef SQLCIPHER_OMIT_EXPLAIN
63218   if( p->explain ){
63219     rc = sqlcipher3VdbeList(p);
63220   }else
63221 #endif /* SQLCIPHER_OMIT_EXPLAIN */
63222   {
63223     db->vdbeExecCnt++;
63224     rc = sqlcipher3VdbeExec(p);
63225     db->vdbeExecCnt--;
63226   }
63227
63228 #ifndef SQLCIPHER_OMIT_TRACE
63229   /* Invoke the profile callback if there is one
63230   */
63231   if( rc!=SQLCIPHER_ROW && db->xProfile && !db->init.busy && p->zSql ){
63232     sqlcipher3_int64 iNow;
63233     sqlcipher3OsCurrentTimeInt64(db->pVfs, &iNow);
63234     db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);
63235   }
63236 #endif
63237
63238   if( rc==SQLCIPHER_DONE ){
63239     assert( p->rc==SQLCIPHER_OK );
63240     p->rc = doWalCallbacks(db);
63241     if( p->rc!=SQLCIPHER_OK ){
63242       rc = SQLCIPHER_ERROR;
63243     }
63244   }
63245
63246   db->errCode = rc;
63247   if( SQLCIPHER_NOMEM==sqlcipher3ApiExit(p->db, p->rc) ){
63248     p->rc = SQLCIPHER_NOMEM;
63249   }
63250 end_of_step:
63251   /* At this point local variable rc holds the value that should be 
63252   ** returned if this statement was compiled using the legacy 
63253   ** sqlcipher3_prepare() interface. According to the docs, this can only
63254   ** be one of the values in the first assert() below. Variable p->rc 
63255   ** contains the value that would be returned if sqlcipher3_finalize() 
63256   ** were called on statement p.
63257   */
63258   assert( rc==SQLCIPHER_ROW  || rc==SQLCIPHER_DONE   || rc==SQLCIPHER_ERROR 
63259        || rc==SQLCIPHER_BUSY || rc==SQLCIPHER_MISUSE
63260   );
63261   assert( p->rc!=SQLCIPHER_ROW && p->rc!=SQLCIPHER_DONE );
63262   if( p->isPrepareV2 && rc!=SQLCIPHER_ROW && rc!=SQLCIPHER_DONE ){
63263     /* If this statement was prepared using sqlcipher3_prepare_v2(), and an
63264     ** error has occured, then return the error code in p->rc to the
63265     ** caller. Set the error code in the database handle to the same value.
63266     */ 
63267     rc = sqlcipher3VdbeTransferError(p);
63268   }
63269   return (rc&db->errMask);
63270 }
63271
63272 /*
63273 ** The maximum number of times that a statement will try to reparse
63274 ** itself before giving up and returning SQLCIPHER_SCHEMA.
63275 */
63276 #ifndef SQLCIPHER_MAX_SCHEMA_RETRY
63277 # define SQLCIPHER_MAX_SCHEMA_RETRY 5
63278 #endif
63279
63280 /*
63281 ** This is the top-level implementation of sqlcipher3_step().  Call
63282 ** sqlcipher3Step() to do most of the work.  If a schema error occurs,
63283 ** call sqlcipher3Reprepare() and try again.
63284 */
63285 SQLCIPHER_API int sqlcipher3_step(sqlcipher3_stmt *pStmt){
63286   int rc = SQLCIPHER_OK;      /* Result from sqlcipher3Step() */
63287   int rc2 = SQLCIPHER_OK;     /* Result from sqlcipher3Reprepare() */
63288   Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
63289   int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
63290   sqlcipher3 *db;             /* The database connection */
63291
63292   if( vdbeSafetyNotNull(v) ){
63293     return SQLCIPHER_MISUSE_BKPT;
63294   }
63295   db = v->db;
63296   sqlcipher3_mutex_enter(db->mutex);
63297   while( (rc = sqlcipher3Step(v))==SQLCIPHER_SCHEMA
63298          && cnt++ < SQLCIPHER_MAX_SCHEMA_RETRY
63299          && (rc2 = rc = sqlcipher3Reprepare(v))==SQLCIPHER_OK ){
63300     sqlcipher3_reset(pStmt);
63301     assert( v->expired==0 );
63302   }
63303   if( rc2!=SQLCIPHER_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
63304     /* This case occurs after failing to recompile an sql statement. 
63305     ** The error message from the SQL compiler has already been loaded 
63306     ** into the database handle. This block copies the error message 
63307     ** from the database handle into the statement and sets the statement
63308     ** program counter to 0 to ensure that when the statement is 
63309     ** finalized or reset the parser error message is available via
63310     ** sqlcipher3_errmsg() and sqlcipher3_errcode().
63311     */
63312     const char *zErr = (const char *)sqlcipher3_value_text(db->pErr); 
63313     sqlcipher3DbFree(db, v->zErrMsg);
63314     if( !db->mallocFailed ){
63315       v->zErrMsg = sqlcipher3DbStrDup(db, zErr);
63316       v->rc = rc2;
63317     } else {
63318       v->zErrMsg = 0;
63319       v->rc = rc = SQLCIPHER_NOMEM;
63320     }
63321   }
63322   rc = sqlcipher3ApiExit(db, rc);
63323   sqlcipher3_mutex_leave(db->mutex);
63324   return rc;
63325 }
63326
63327 /*
63328 ** Extract the user data from a sqlcipher3_context structure and return a
63329 ** pointer to it.
63330 */
63331 SQLCIPHER_API void *sqlcipher3_user_data(sqlcipher3_context *p){
63332   assert( p && p->pFunc );
63333   return p->pFunc->pUserData;
63334 }
63335
63336 /*
63337 ** Extract the user data from a sqlcipher3_context structure and return a
63338 ** pointer to it.
63339 **
63340 ** IMPLEMENTATION-OF: R-46798-50301 The sqlcipher3_context_db_handle() interface
63341 ** returns a copy of the pointer to the database connection (the 1st
63342 ** parameter) of the sqlcipher3_create_function() and
63343 ** sqlcipher3_create_function16() routines that originally registered the
63344 ** application defined function.
63345 */
63346 SQLCIPHER_API sqlcipher3 *sqlcipher3_context_db_handle(sqlcipher3_context *p){
63347   assert( p && p->pFunc );
63348   return p->s.db;
63349 }
63350
63351 /*
63352 ** The following is the implementation of an SQL function that always
63353 ** fails with an error message stating that the function is used in the
63354 ** wrong context.  The sqlcipher3_overload_function() API might construct
63355 ** SQL function that use this routine so that the functions will exist
63356 ** for name resolution but are actually overloaded by the xFindFunction
63357 ** method of virtual tables.
63358 */
63359 SQLCIPHER_PRIVATE void sqlcipher3InvalidFunction(
63360   sqlcipher3_context *context,  /* The function calling context */
63361   int NotUsed,               /* Number of arguments to the function */
63362   sqlcipher3_value **NotUsed2   /* Value of each argument */
63363 ){
63364   const char *zName = context->pFunc->zName;
63365   char *zErr;
63366   UNUSED_PARAMETER2(NotUsed, NotUsed2);
63367   zErr = sqlcipher3_mprintf(
63368       "unable to use function %s in the requested context", zName);
63369   sqlcipher3_result_error(context, zErr, -1);
63370   sqlcipher3_free(zErr);
63371 }
63372
63373 /*
63374 ** Allocate or return the aggregate context for a user function.  A new
63375 ** context is allocated on the first call.  Subsequent calls return the
63376 ** same context that was returned on prior calls.
63377 */
63378 SQLCIPHER_API void *sqlcipher3_aggregate_context(sqlcipher3_context *p, int nByte){
63379   Mem *pMem;
63380   assert( p && p->pFunc && p->pFunc->xStep );
63381   assert( sqlcipher3_mutex_held(p->s.db->mutex) );
63382   pMem = p->pMem;
63383   testcase( nByte<0 );
63384   if( (pMem->flags & MEM_Agg)==0 ){
63385     if( nByte<=0 ){
63386       sqlcipher3VdbeMemReleaseExternal(pMem);
63387       pMem->flags = MEM_Null;
63388       pMem->z = 0;
63389     }else{
63390       sqlcipher3VdbeMemGrow(pMem, nByte, 0);
63391       pMem->flags = MEM_Agg;
63392       pMem->u.pDef = p->pFunc;
63393       if( pMem->z ){
63394         memset(pMem->z, 0, nByte);
63395       }
63396     }
63397   }
63398   return (void*)pMem->z;
63399 }
63400
63401 /*
63402 ** Return the auxilary data pointer, if any, for the iArg'th argument to
63403 ** the user-function defined by pCtx.
63404 */
63405 SQLCIPHER_API void *sqlcipher3_get_auxdata(sqlcipher3_context *pCtx, int iArg){
63406   VdbeFunc *pVdbeFunc;
63407
63408   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63409   pVdbeFunc = pCtx->pVdbeFunc;
63410   if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
63411     return 0;
63412   }
63413   return pVdbeFunc->apAux[iArg].pAux;
63414 }
63415
63416 /*
63417 ** Set the auxilary data pointer and delete function, for the iArg'th
63418 ** argument to the user-function defined by pCtx. Any previous value is
63419 ** deleted by calling the delete function specified when it was set.
63420 */
63421 SQLCIPHER_API void sqlcipher3_set_auxdata(
63422   sqlcipher3_context *pCtx, 
63423   int iArg, 
63424   void *pAux, 
63425   void (*xDelete)(void*)
63426 ){
63427   struct AuxData *pAuxData;
63428   VdbeFunc *pVdbeFunc;
63429   if( iArg<0 ) goto failed;
63430
63431   assert( sqlcipher3_mutex_held(pCtx->s.db->mutex) );
63432   pVdbeFunc = pCtx->pVdbeFunc;
63433   if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
63434     int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
63435     int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
63436     pVdbeFunc = sqlcipher3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
63437     if( !pVdbeFunc ){
63438       goto failed;
63439     }
63440     pCtx->pVdbeFunc = pVdbeFunc;
63441     memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
63442     pVdbeFunc->nAux = iArg+1;
63443     pVdbeFunc->pFunc = pCtx->pFunc;
63444   }
63445
63446   pAuxData = &pVdbeFunc->apAux[iArg];
63447   if( pAuxData->pAux && pAuxData->xDelete ){
63448     pAuxData->xDelete(pAuxData->pAux);
63449   }
63450   pAuxData->pAux = pAux;
63451   pAuxData->xDelete = xDelete;
63452   return;
63453
63454 failed:
63455   if( xDelete ){
63456     xDelete(pAux);
63457   }
63458 }
63459
63460 #ifndef SQLCIPHER_OMIT_DEPRECATED
63461 /*
63462 ** Return the number of times the Step function of a aggregate has been 
63463 ** called.
63464 **
63465 ** This function is deprecated.  Do not use it for new code.  It is
63466 ** provide only to avoid breaking legacy code.  New aggregate function
63467 ** implementations should keep their own counts within their aggregate
63468 ** context.
63469 */
63470 SQLCIPHER_API int sqlcipher3_aggregate_count(sqlcipher3_context *p){
63471   assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
63472   return p->pMem->n;
63473 }
63474 #endif
63475
63476 /*
63477 ** Return the number of columns in the result set for the statement pStmt.
63478 */
63479 SQLCIPHER_API int sqlcipher3_column_count(sqlcipher3_stmt *pStmt){
63480   Vdbe *pVm = (Vdbe *)pStmt;
63481   return pVm ? pVm->nResColumn : 0;
63482 }
63483
63484 /*
63485 ** Return the number of values available from the current row of the
63486 ** currently executing statement pStmt.
63487 */
63488 SQLCIPHER_API int sqlcipher3_data_count(sqlcipher3_stmt *pStmt){
63489   Vdbe *pVm = (Vdbe *)pStmt;
63490   if( pVm==0 || pVm->pResultSet==0 ) return 0;
63491   return pVm->nResColumn;
63492 }
63493
63494
63495 /*
63496 ** Check to see if column iCol of the given statement is valid.  If
63497 ** it is, return a pointer to the Mem for the value of that column.
63498 ** If iCol is not valid, return a pointer to a Mem which has a value
63499 ** of NULL.
63500 */
63501 static Mem *columnMem(sqlcipher3_stmt *pStmt, int i){
63502   Vdbe *pVm;
63503   Mem *pOut;
63504
63505   pVm = (Vdbe *)pStmt;
63506   if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
63507     sqlcipher3_mutex_enter(pVm->db->mutex);
63508     pOut = &pVm->pResultSet[i];
63509   }else{
63510     /* If the value passed as the second argument is out of range, return
63511     ** a pointer to the following static Mem object which contains the
63512     ** value SQL NULL. Even though the Mem structure contains an element
63513     ** of type i64, on certain architecture (x86) with certain compiler
63514     ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
63515     ** instead of an 8-byte one. This all works fine, except that when
63516     ** running with SQLCIPHER_DEBUG defined the SQLite code sometimes assert()s
63517     ** that a Mem structure is located on an 8-byte boundary. To prevent
63518     ** this assert() from failing, when building with SQLCIPHER_DEBUG defined
63519     ** using gcc, force nullMem to be 8-byte aligned using the magical
63520     ** __attribute__((aligned(8))) macro.  */
63521     static const Mem nullMem 
63522 #if defined(SQLCIPHER_DEBUG) && defined(__GNUC__)
63523       __attribute__((aligned(8))) 
63524 #endif
63525       = {0, "", (double)0, {0}, 0, MEM_Null, SQLCIPHER_NULL, 0,
63526 #ifdef SQLCIPHER_DEBUG
63527          0, 0,  /* pScopyFrom, pFiller */
63528 #endif
63529          0, 0 };
63530
63531     if( pVm && ALWAYS(pVm->db) ){
63532       sqlcipher3_mutex_enter(pVm->db->mutex);
63533       sqlcipher3Error(pVm->db, SQLCIPHER_RANGE, 0);
63534     }
63535     pOut = (Mem*)&nullMem;
63536   }
63537   return pOut;
63538 }
63539
63540 /*
63541 ** This function is called after invoking an sqlcipher3_value_XXX function on a 
63542 ** column value (i.e. a value returned by evaluating an SQL expression in the
63543 ** select list of a SELECT statement) that may cause a malloc() failure. If 
63544 ** malloc() has failed, the threads mallocFailed flag is cleared and the result
63545 ** code of statement pStmt set to SQLCIPHER_NOMEM.
63546 **
63547 ** Specifically, this is called from within:
63548 **
63549 **     sqlcipher3_column_int()
63550 **     sqlcipher3_column_int64()
63551 **     sqlcipher3_column_text()
63552 **     sqlcipher3_column_text16()
63553 **     sqlcipher3_column_real()
63554 **     sqlcipher3_column_bytes()
63555 **     sqlcipher3_column_bytes16()
63556 **     sqiite3_column_blob()
63557 */
63558 static void columnMallocFailure(sqlcipher3_stmt *pStmt)
63559 {
63560   /* If malloc() failed during an encoding conversion within an
63561   ** sqlcipher3_column_XXX API, then set the return code of the statement to
63562   ** SQLCIPHER_NOMEM. The next call to _step() (if any) will return SQLCIPHER_ERROR
63563   ** and _finalize() will return NOMEM.
63564   */
63565   Vdbe *p = (Vdbe *)pStmt;
63566   if( p ){
63567     p->rc = sqlcipher3ApiExit(p->db, p->rc);
63568     sqlcipher3_mutex_leave(p->db->mutex);
63569   }
63570 }
63571
63572 /**************************** sqlcipher3_column_  *******************************
63573 ** The following routines are used to access elements of the current row
63574 ** in the result set.
63575 */
63576 SQLCIPHER_API const void *sqlcipher3_column_blob(sqlcipher3_stmt *pStmt, int i){
63577   const void *val;
63578   val = sqlcipher3_value_blob( columnMem(pStmt,i) );
63579   /* Even though there is no encoding conversion, value_blob() might
63580   ** need to call malloc() to expand the result of a zeroblob() 
63581   ** expression. 
63582   */
63583   columnMallocFailure(pStmt);
63584   return val;
63585 }
63586 SQLCIPHER_API int sqlcipher3_column_bytes(sqlcipher3_stmt *pStmt, int i){
63587   int val = sqlcipher3_value_bytes( columnMem(pStmt,i) );
63588   columnMallocFailure(pStmt);
63589   return val;
63590 }
63591 SQLCIPHER_API int sqlcipher3_column_bytes16(sqlcipher3_stmt *pStmt, int i){
63592   int val = sqlcipher3_value_bytes16( columnMem(pStmt,i) );
63593   columnMallocFailure(pStmt);
63594   return val;
63595 }
63596 SQLCIPHER_API double sqlcipher3_column_double(sqlcipher3_stmt *pStmt, int i){
63597   double val = sqlcipher3_value_double( columnMem(pStmt,i) );
63598   columnMallocFailure(pStmt);
63599   return val;
63600 }
63601 SQLCIPHER_API int sqlcipher3_column_int(sqlcipher3_stmt *pStmt, int i){
63602   int val = sqlcipher3_value_int( columnMem(pStmt,i) );
63603   columnMallocFailure(pStmt);
63604   return val;
63605 }
63606 SQLCIPHER_API sqlcipher_int64 sqlcipher3_column_int64(sqlcipher3_stmt *pStmt, int i){
63607   sqlcipher_int64 val = sqlcipher3_value_int64( columnMem(pStmt,i) );
63608   columnMallocFailure(pStmt);
63609   return val;
63610 }
63611 SQLCIPHER_API const unsigned char *sqlcipher3_column_text(sqlcipher3_stmt *pStmt, int i){
63612   const unsigned char *val = sqlcipher3_value_text( columnMem(pStmt,i) );
63613   columnMallocFailure(pStmt);
63614   return val;
63615 }
63616 SQLCIPHER_API sqlcipher3_value *sqlcipher3_column_value(sqlcipher3_stmt *pStmt, int i){
63617   Mem *pOut = columnMem(pStmt, i);
63618   if( pOut->flags&MEM_Static ){
63619     pOut->flags &= ~MEM_Static;
63620     pOut->flags |= MEM_Ephem;
63621   }
63622   columnMallocFailure(pStmt);
63623   return (sqlcipher3_value *)pOut;
63624 }
63625 #ifndef SQLCIPHER_OMIT_UTF16
63626 SQLCIPHER_API const void *sqlcipher3_column_text16(sqlcipher3_stmt *pStmt, int i){
63627   const void *val = sqlcipher3_value_text16( columnMem(pStmt,i) );
63628   columnMallocFailure(pStmt);
63629   return val;
63630 }
63631 #endif /* SQLCIPHER_OMIT_UTF16 */
63632 SQLCIPHER_API int sqlcipher3_column_type(sqlcipher3_stmt *pStmt, int i){
63633   int iType = sqlcipher3_value_type( columnMem(pStmt,i) );
63634   columnMallocFailure(pStmt);
63635   return iType;
63636 }
63637
63638 /* The following function is experimental and subject to change or
63639 ** removal */
63640 /*int sqlcipher3_column_numeric_type(sqlcipher3_stmt *pStmt, int i){
63641 **  return sqlcipher3_value_numeric_type( columnMem(pStmt,i) );
63642 **}
63643 */
63644
63645 /*
63646 ** Convert the N-th element of pStmt->pColName[] into a string using
63647 ** xFunc() then return that string.  If N is out of range, return 0.
63648 **
63649 ** There are up to 5 names for each column.  useType determines which
63650 ** name is returned.  Here are the names:
63651 **
63652 **    0      The column name as it should be displayed for output
63653 **    1      The datatype name for the column
63654 **    2      The name of the database that the column derives from
63655 **    3      The name of the table that the column derives from
63656 **    4      The name of the table column that the result column derives from
63657 **
63658 ** If the result is not a simple column reference (if it is an expression
63659 ** or a constant) then useTypes 2, 3, and 4 return NULL.
63660 */
63661 static const void *columnName(
63662   sqlcipher3_stmt *pStmt,
63663   int N,
63664   const void *(*xFunc)(Mem*),
63665   int useType
63666 ){
63667   const void *ret = 0;
63668   Vdbe *p = (Vdbe *)pStmt;
63669   int n;
63670   sqlcipher3 *db = p->db;
63671   
63672   assert( db!=0 );
63673   n = sqlcipher3_column_count(pStmt);
63674   if( N<n && N>=0 ){
63675     N += useType*n;
63676     sqlcipher3_mutex_enter(db->mutex);
63677     assert( db->mallocFailed==0 );
63678     ret = xFunc(&p->aColName[N]);
63679      /* A malloc may have failed inside of the xFunc() call. If this
63680     ** is the case, clear the mallocFailed flag and return NULL.
63681     */
63682     if( db->mallocFailed ){
63683       db->mallocFailed = 0;
63684       ret = 0;
63685     }
63686     sqlcipher3_mutex_leave(db->mutex);
63687   }
63688   return ret;
63689 }
63690
63691 /*
63692 ** Return the name of the Nth column of the result set returned by SQL
63693 ** statement pStmt.
63694 */
63695 SQLCIPHER_API const char *sqlcipher3_column_name(sqlcipher3_stmt *pStmt, int N){
63696   return columnName(
63697       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text, COLNAME_NAME);
63698 }
63699 #ifndef SQLCIPHER_OMIT_UTF16
63700 SQLCIPHER_API const void *sqlcipher3_column_name16(sqlcipher3_stmt *pStmt, int N){
63701   return columnName(
63702       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text16, COLNAME_NAME);
63703 }
63704 #endif
63705
63706 /*
63707 ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must
63708 ** not define OMIT_DECLTYPE.
63709 */
63710 #if defined(SQLCIPHER_OMIT_DECLTYPE) && defined(SQLCIPHER_ENABLE_COLUMN_METADATA)
63711 # error "Must not define both SQLCIPHER_OMIT_DECLTYPE \
63712          and SQLCIPHER_ENABLE_COLUMN_METADATA"
63713 #endif
63714
63715 #ifndef SQLCIPHER_OMIT_DECLTYPE
63716 /*
63717 ** Return the column declaration type (if applicable) of the 'i'th column
63718 ** of the result set of SQL statement pStmt.
63719 */
63720 SQLCIPHER_API const char *sqlcipher3_column_decltype(sqlcipher3_stmt *pStmt, int N){
63721   return columnName(
63722       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text, COLNAME_DECLTYPE);
63723 }
63724 #ifndef SQLCIPHER_OMIT_UTF16
63725 SQLCIPHER_API const void *sqlcipher3_column_decltype16(sqlcipher3_stmt *pStmt, int N){
63726   return columnName(
63727       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text16, COLNAME_DECLTYPE);
63728 }
63729 #endif /* SQLCIPHER_OMIT_UTF16 */
63730 #endif /* SQLCIPHER_OMIT_DECLTYPE */
63731
63732 #ifdef SQLCIPHER_ENABLE_COLUMN_METADATA
63733 /*
63734 ** Return the name of the database from which a result column derives.
63735 ** NULL is returned if the result column is an expression or constant or
63736 ** anything else which is not an unabiguous reference to a database column.
63737 */
63738 SQLCIPHER_API const char *sqlcipher3_column_database_name(sqlcipher3_stmt *pStmt, int N){
63739   return columnName(
63740       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text, COLNAME_DATABASE);
63741 }
63742 #ifndef SQLCIPHER_OMIT_UTF16
63743 SQLCIPHER_API const void *sqlcipher3_column_database_name16(sqlcipher3_stmt *pStmt, int N){
63744   return columnName(
63745       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text16, COLNAME_DATABASE);
63746 }
63747 #endif /* SQLCIPHER_OMIT_UTF16 */
63748
63749 /*
63750 ** Return the name of the table from which a result column derives.
63751 ** NULL is returned if the result column is an expression or constant or
63752 ** anything else which is not an unabiguous reference to a database column.
63753 */
63754 SQLCIPHER_API const char *sqlcipher3_column_table_name(sqlcipher3_stmt *pStmt, int N){
63755   return columnName(
63756       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text, COLNAME_TABLE);
63757 }
63758 #ifndef SQLCIPHER_OMIT_UTF16
63759 SQLCIPHER_API const void *sqlcipher3_column_table_name16(sqlcipher3_stmt *pStmt, int N){
63760   return columnName(
63761       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text16, COLNAME_TABLE);
63762 }
63763 #endif /* SQLCIPHER_OMIT_UTF16 */
63764
63765 /*
63766 ** Return the name of the table column from which a result column derives.
63767 ** NULL is returned if the result column is an expression or constant or
63768 ** anything else which is not an unabiguous reference to a database column.
63769 */
63770 SQLCIPHER_API const char *sqlcipher3_column_origin_name(sqlcipher3_stmt *pStmt, int N){
63771   return columnName(
63772       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text, COLNAME_COLUMN);
63773 }
63774 #ifndef SQLCIPHER_OMIT_UTF16
63775 SQLCIPHER_API const void *sqlcipher3_column_origin_name16(sqlcipher3_stmt *pStmt, int N){
63776   return columnName(
63777       pStmt, N, (const void*(*)(Mem*))sqlcipher3_value_text16, COLNAME_COLUMN);
63778 }
63779 #endif /* SQLCIPHER_OMIT_UTF16 */
63780 #endif /* SQLCIPHER_ENABLE_COLUMN_METADATA */
63781
63782
63783 /******************************* sqlcipher3_bind_  ***************************
63784 ** 
63785 ** Routines used to attach values to wildcards in a compiled SQL statement.
63786 */
63787 /*
63788 ** Unbind the value bound to variable i in virtual machine p. This is the 
63789 ** the same as binding a NULL value to the column. If the "i" parameter is
63790 ** out of range, then SQLCIPHER_RANGE is returned. Othewise SQLCIPHER_OK.
63791 **
63792 ** A successful evaluation of this routine acquires the mutex on p.
63793 ** the mutex is released if any kind of error occurs.
63794 **
63795 ** The error code stored in database p->db is overwritten with the return
63796 ** value in any case.
63797 */
63798 static int vdbeUnbind(Vdbe *p, int i){
63799   Mem *pVar;
63800   if( vdbeSafetyNotNull(p) ){
63801     return SQLCIPHER_MISUSE_BKPT;
63802   }
63803   sqlcipher3_mutex_enter(p->db->mutex);
63804   if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
63805     sqlcipher3Error(p->db, SQLCIPHER_MISUSE, 0);
63806     sqlcipher3_mutex_leave(p->db->mutex);
63807     sqlcipher3_log(SQLCIPHER_MISUSE, 
63808         "bind on a busy prepared statement: [%s]", p->zSql);
63809     return SQLCIPHER_MISUSE_BKPT;
63810   }
63811   if( i<1 || i>p->nVar ){
63812     sqlcipher3Error(p->db, SQLCIPHER_RANGE, 0);
63813     sqlcipher3_mutex_leave(p->db->mutex);
63814     return SQLCIPHER_RANGE;
63815   }
63816   i--;
63817   pVar = &p->aVar[i];
63818   sqlcipher3VdbeMemRelease(pVar);
63819   pVar->flags = MEM_Null;
63820   sqlcipher3Error(p->db, SQLCIPHER_OK, 0);
63821
63822   /* If the bit corresponding to this variable in Vdbe.expmask is set, then 
63823   ** binding a new value to this variable invalidates the current query plan.
63824   **
63825   ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host
63826   ** parameter in the WHERE clause might influence the choice of query plan
63827   ** for a statement, then the statement will be automatically recompiled,
63828   ** as if there had been a schema change, on the first sqlcipher3_step() call
63829   ** following any change to the bindings of that parameter.
63830   */
63831   if( p->isPrepareV2 &&
63832      ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
63833   ){
63834     p->expired = 1;
63835   }
63836   return SQLCIPHER_OK;
63837 }
63838
63839 /*
63840 ** Bind a text or BLOB value.
63841 */
63842 static int bindText(
63843   sqlcipher3_stmt *pStmt,   /* The statement to bind against */
63844   int i,                 /* Index of the parameter to bind */
63845   const void *zData,     /* Pointer to the data to be bound */
63846   int nData,             /* Number of bytes of data to be bound */
63847   void (*xDel)(void*),   /* Destructor for the data */
63848   u8 encoding            /* Encoding for the data */
63849 ){
63850   Vdbe *p = (Vdbe *)pStmt;
63851   Mem *pVar;
63852   int rc;
63853
63854   rc = vdbeUnbind(p, i);
63855   if( rc==SQLCIPHER_OK ){
63856     if( zData!=0 ){
63857       pVar = &p->aVar[i-1];
63858       rc = sqlcipher3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
63859       if( rc==SQLCIPHER_OK && encoding!=0 ){
63860         rc = sqlcipher3VdbeChangeEncoding(pVar, ENC(p->db));
63861       }
63862       sqlcipher3Error(p->db, rc, 0);
63863       rc = sqlcipher3ApiExit(p->db, rc);
63864     }
63865     sqlcipher3_mutex_leave(p->db->mutex);
63866   }else if( xDel!=SQLCIPHER_STATIC && xDel!=SQLCIPHER_TRANSIENT ){
63867     xDel((void*)zData);
63868   }
63869   return rc;
63870 }
63871
63872
63873 /*
63874 ** Bind a blob value to an SQL statement variable.
63875 */
63876 SQLCIPHER_API int sqlcipher3_bind_blob(
63877   sqlcipher3_stmt *pStmt, 
63878   int i, 
63879   const void *zData, 
63880   int nData, 
63881   void (*xDel)(void*)
63882 ){
63883   return bindText(pStmt, i, zData, nData, xDel, 0);
63884 }
63885 SQLCIPHER_API int sqlcipher3_bind_double(sqlcipher3_stmt *pStmt, int i, double rValue){
63886   int rc;
63887   Vdbe *p = (Vdbe *)pStmt;
63888   rc = vdbeUnbind(p, i);
63889   if( rc==SQLCIPHER_OK ){
63890     sqlcipher3VdbeMemSetDouble(&p->aVar[i-1], rValue);
63891     sqlcipher3_mutex_leave(p->db->mutex);
63892   }
63893   return rc;
63894 }
63895 SQLCIPHER_API int sqlcipher3_bind_int(sqlcipher3_stmt *p, int i, int iValue){
63896   return sqlcipher3_bind_int64(p, i, (i64)iValue);
63897 }
63898 SQLCIPHER_API int sqlcipher3_bind_int64(sqlcipher3_stmt *pStmt, int i, sqlcipher_int64 iValue){
63899   int rc;
63900   Vdbe *p = (Vdbe *)pStmt;
63901   rc = vdbeUnbind(p, i);
63902   if( rc==SQLCIPHER_OK ){
63903     sqlcipher3VdbeMemSetInt64(&p->aVar[i-1], iValue);
63904     sqlcipher3_mutex_leave(p->db->mutex);
63905   }
63906   return rc;
63907 }
63908 SQLCIPHER_API int sqlcipher3_bind_null(sqlcipher3_stmt *pStmt, int i){
63909   int rc;
63910   Vdbe *p = (Vdbe*)pStmt;
63911   rc = vdbeUnbind(p, i);
63912   if( rc==SQLCIPHER_OK ){
63913     sqlcipher3_mutex_leave(p->db->mutex);
63914   }
63915   return rc;
63916 }
63917 SQLCIPHER_API int sqlcipher3_bind_text( 
63918   sqlcipher3_stmt *pStmt, 
63919   int i, 
63920   const char *zData, 
63921   int nData, 
63922   void (*xDel)(void*)
63923 ){
63924   return bindText(pStmt, i, zData, nData, xDel, SQLCIPHER_UTF8);
63925 }
63926 #ifndef SQLCIPHER_OMIT_UTF16
63927 SQLCIPHER_API int sqlcipher3_bind_text16(
63928   sqlcipher3_stmt *pStmt, 
63929   int i, 
63930   const void *zData, 
63931   int nData, 
63932   void (*xDel)(void*)
63933 ){
63934   return bindText(pStmt, i, zData, nData, xDel, SQLCIPHER_UTF16NATIVE);
63935 }
63936 #endif /* SQLCIPHER_OMIT_UTF16 */
63937 SQLCIPHER_API int sqlcipher3_bind_value(sqlcipher3_stmt *pStmt, int i, const sqlcipher3_value *pValue){
63938   int rc;
63939   switch( pValue->type ){
63940     case SQLCIPHER_INTEGER: {
63941       rc = sqlcipher3_bind_int64(pStmt, i, pValue->u.i);
63942       break;
63943     }
63944     case SQLCIPHER_FLOAT: {
63945       rc = sqlcipher3_bind_double(pStmt, i, pValue->r);
63946       break;
63947     }
63948     case SQLCIPHER_BLOB: {
63949       if( pValue->flags & MEM_Zero ){
63950         rc = sqlcipher3_bind_zeroblob(pStmt, i, pValue->u.nZero);
63951       }else{
63952         rc = sqlcipher3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLCIPHER_TRANSIENT);
63953       }
63954       break;
63955     }
63956     case SQLCIPHER_TEXT: {
63957       rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLCIPHER_TRANSIENT,
63958                               pValue->enc);
63959       break;
63960     }
63961     default: {
63962       rc = sqlcipher3_bind_null(pStmt, i);
63963       break;
63964     }
63965   }
63966   return rc;
63967 }
63968 SQLCIPHER_API int sqlcipher3_bind_zeroblob(sqlcipher3_stmt *pStmt, int i, int n){
63969   int rc;
63970   Vdbe *p = (Vdbe *)pStmt;
63971   rc = vdbeUnbind(p, i);
63972   if( rc==SQLCIPHER_OK ){
63973     sqlcipher3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
63974     sqlcipher3_mutex_leave(p->db->mutex);
63975   }
63976   return rc;
63977 }
63978
63979 /*
63980 ** Return the number of wildcards that can be potentially bound to.
63981 ** This routine is added to support DBD::SQLite.  
63982 */
63983 SQLCIPHER_API int sqlcipher3_bind_parameter_count(sqlcipher3_stmt *pStmt){
63984   Vdbe *p = (Vdbe*)pStmt;
63985   return p ? p->nVar : 0;
63986 }
63987
63988 /*
63989 ** Return the name of a wildcard parameter.  Return NULL if the index
63990 ** is out of range or if the wildcard is unnamed.
63991 **
63992 ** The result is always UTF-8.
63993 */
63994 SQLCIPHER_API const char *sqlcipher3_bind_parameter_name(sqlcipher3_stmt *pStmt, int i){
63995   Vdbe *p = (Vdbe*)pStmt;
63996   if( p==0 || i<1 || i>p->nzVar ){
63997     return 0;
63998   }
63999   return p->azVar[i-1];
64000 }
64001
64002 /*
64003 ** Given a wildcard parameter name, return the index of the variable
64004 ** with that name.  If there is no variable with the given name,
64005 ** return 0.
64006 */
64007 SQLCIPHER_PRIVATE int sqlcipher3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
64008   int i;
64009   if( p==0 ){
64010     return 0;
64011   }
64012   if( zName ){
64013     for(i=0; i<p->nzVar; i++){
64014       const char *z = p->azVar[i];
64015       if( z && memcmp(z,zName,nName)==0 && z[nName]==0 ){
64016         return i+1;
64017       }
64018     }
64019   }
64020   return 0;
64021 }
64022 SQLCIPHER_API int sqlcipher3_bind_parameter_index(sqlcipher3_stmt *pStmt, const char *zName){
64023   return sqlcipher3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlcipher3Strlen30(zName));
64024 }
64025
64026 /*
64027 ** Transfer all bindings from the first statement over to the second.
64028 */
64029 SQLCIPHER_PRIVATE int sqlcipher3TransferBindings(sqlcipher3_stmt *pFromStmt, sqlcipher3_stmt *pToStmt){
64030   Vdbe *pFrom = (Vdbe*)pFromStmt;
64031   Vdbe *pTo = (Vdbe*)pToStmt;
64032   int i;
64033   assert( pTo->db==pFrom->db );
64034   assert( pTo->nVar==pFrom->nVar );
64035   sqlcipher3_mutex_enter(pTo->db->mutex);
64036   for(i=0; i<pFrom->nVar; i++){
64037     sqlcipher3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
64038   }
64039   sqlcipher3_mutex_leave(pTo->db->mutex);
64040   return SQLCIPHER_OK;
64041 }
64042
64043 #ifndef SQLCIPHER_OMIT_DEPRECATED
64044 /*
64045 ** Deprecated external interface.  Internal/core SQLite code
64046 ** should call sqlcipher3TransferBindings.
64047 **
64048 ** Is is misuse to call this routine with statements from different
64049 ** database connections.  But as this is a deprecated interface, we
64050 ** will not bother to check for that condition.
64051 **
64052 ** If the two statements contain a different number of bindings, then
64053 ** an SQLCIPHER_ERROR is returned.  Nothing else can go wrong, so otherwise
64054 ** SQLCIPHER_OK is returned.
64055 */
64056 SQLCIPHER_API int sqlcipher3_transfer_bindings(sqlcipher3_stmt *pFromStmt, sqlcipher3_stmt *pToStmt){
64057   Vdbe *pFrom = (Vdbe*)pFromStmt;
64058   Vdbe *pTo = (Vdbe*)pToStmt;
64059   if( pFrom->nVar!=pTo->nVar ){
64060     return SQLCIPHER_ERROR;
64061   }
64062   if( pTo->isPrepareV2 && pTo->expmask ){
64063     pTo->expired = 1;
64064   }
64065   if( pFrom->isPrepareV2 && pFrom->expmask ){
64066     pFrom->expired = 1;
64067   }
64068   return sqlcipher3TransferBindings(pFromStmt, pToStmt);
64069 }
64070 #endif
64071
64072 /*
64073 ** Return the sqlcipher3* database handle to which the prepared statement given
64074 ** in the argument belongs.  This is the same database handle that was
64075 ** the first argument to the sqlcipher3_prepare() that was used to create
64076 ** the statement in the first place.
64077 */
64078 SQLCIPHER_API sqlcipher3 *sqlcipher3_db_handle(sqlcipher3_stmt *pStmt){
64079   return pStmt ? ((Vdbe*)pStmt)->db : 0;
64080 }
64081
64082 /*
64083 ** Return true if the prepared statement is guaranteed to not modify the
64084 ** database.
64085 */
64086 SQLCIPHER_API int sqlcipher3_stmt_readonly(sqlcipher3_stmt *pStmt){
64087   return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
64088 }
64089
64090 /*
64091 ** Return a pointer to the next prepared statement after pStmt associated
64092 ** with database connection pDb.  If pStmt is NULL, return the first
64093 ** prepared statement for the database connection.  Return NULL if there
64094 ** are no more.
64095 */
64096 SQLCIPHER_API sqlcipher3_stmt *sqlcipher3_next_stmt(sqlcipher3 *pDb, sqlcipher3_stmt *pStmt){
64097   sqlcipher3_stmt *pNext;
64098   sqlcipher3_mutex_enter(pDb->mutex);
64099   if( pStmt==0 ){
64100     pNext = (sqlcipher3_stmt*)pDb->pVdbe;
64101   }else{
64102     pNext = (sqlcipher3_stmt*)((Vdbe*)pStmt)->pNext;
64103   }
64104   sqlcipher3_mutex_leave(pDb->mutex);
64105   return pNext;
64106 }
64107
64108 /*
64109 ** Return the value of a status counter for a prepared statement
64110 */
64111 SQLCIPHER_API int sqlcipher3_stmt_status(sqlcipher3_stmt *pStmt, int op, int resetFlag){
64112   Vdbe *pVdbe = (Vdbe*)pStmt;
64113   int v = pVdbe->aCounter[op-1];
64114   if( resetFlag ) pVdbe->aCounter[op-1] = 0;
64115   return v;
64116 }
64117
64118 /************** End of vdbeapi.c *********************************************/
64119 /************** Begin file vdbetrace.c ***************************************/
64120 /*
64121 ** 2009 November 25
64122 **
64123 ** The author disclaims copyright to this source code.  In place of
64124 ** a legal notice, here is a blessing:
64125 **
64126 **    May you do good and not evil.
64127 **    May you find forgiveness for yourself and forgive others.
64128 **    May you share freely, never taking more than you give.
64129 **
64130 *************************************************************************
64131 **
64132 ** This file contains code used to insert the values of host parameters
64133 ** (aka "wildcards") into the SQL text output by sqlcipher3_trace().
64134 */
64135
64136 #ifndef SQLCIPHER_OMIT_TRACE
64137
64138 /*
64139 ** zSql is a zero-terminated string of UTF-8 SQL text.  Return the number of
64140 ** bytes in this text up to but excluding the first character in
64141 ** a host parameter.  If the text contains no host parameters, return
64142 ** the total number of bytes in the text.
64143 */
64144 static int findNextHostParameter(const char *zSql, int *pnToken){
64145   int tokenType;
64146   int nTotal = 0;
64147   int n;
64148
64149   *pnToken = 0;
64150   while( zSql[0] ){
64151     n = sqlcipher3GetToken((u8*)zSql, &tokenType);
64152     assert( n>0 && tokenType!=TK_ILLEGAL );
64153     if( tokenType==TK_VARIABLE ){
64154       *pnToken = n;
64155       break;
64156     }
64157     nTotal += n;
64158     zSql += n;
64159   }
64160   return nTotal;
64161 }
64162
64163 /*
64164 ** This function returns a pointer to a nul-terminated string in memory
64165 ** obtained from sqlcipher3DbMalloc(). If sqlcipher3.vdbeExecCnt is 1, then the
64166 ** string contains a copy of zRawSql but with host parameters expanded to 
64167 ** their current bindings. Or, if sqlcipher3.vdbeExecCnt is greater than 1, 
64168 ** then the returned string holds a copy of zRawSql with "-- " prepended
64169 ** to each line of text.
64170 **
64171 ** The calling function is responsible for making sure the memory returned
64172 ** is eventually freed.
64173 **
64174 ** ALGORITHM:  Scan the input string looking for host parameters in any of
64175 ** these forms:  ?, ?N, $A, @A, :A.  Take care to avoid text within
64176 ** string literals, quoted identifier names, and comments.  For text forms,
64177 ** the host parameter index is found by scanning the perpared
64178 ** statement for the corresponding OP_Variable opcode.  Once the host
64179 ** parameter index is known, locate the value in p->aVar[].  Then render
64180 ** the value as a literal in place of the host parameter name.
64181 */
64182 SQLCIPHER_PRIVATE char *sqlcipher3VdbeExpandSql(
64183   Vdbe *p,                 /* The prepared statement being evaluated */
64184   const char *zRawSql      /* Raw text of the SQL statement */
64185 ){
64186   sqlcipher3 *db;             /* The database connection */
64187   int idx = 0;             /* Index of a host parameter */
64188   int nextIndex = 1;       /* Index of next ? host parameter */
64189   int n;                   /* Length of a token prefix */
64190   int nToken;              /* Length of the parameter token */
64191   int i;                   /* Loop counter */
64192   Mem *pVar;               /* Value of a host parameter */
64193   StrAccum out;            /* Accumulate the output here */
64194   char zBase[100];         /* Initial working space */
64195
64196   db = p->db;
64197   sqlcipher3StrAccumInit(&out, zBase, sizeof(zBase), 
64198                       db->aLimit[SQLCIPHER_LIMIT_LENGTH]);
64199   out.db = db;
64200   if( db->vdbeExecCnt>1 ){
64201     while( *zRawSql ){
64202       const char *zStart = zRawSql;
64203       while( *(zRawSql++)!='\n' && *zRawSql );
64204       sqlcipher3StrAccumAppend(&out, "-- ", 3);
64205       sqlcipher3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
64206     }
64207   }else{
64208     while( zRawSql[0] ){
64209       n = findNextHostParameter(zRawSql, &nToken);
64210       assert( n>0 );
64211       sqlcipher3StrAccumAppend(&out, zRawSql, n);
64212       zRawSql += n;
64213       assert( zRawSql[0] || nToken==0 );
64214       if( nToken==0 ) break;
64215       if( zRawSql[0]=='?' ){
64216         if( nToken>1 ){
64217           assert( sqlcipher3Isdigit(zRawSql[1]) );
64218           sqlcipher3GetInt32(&zRawSql[1], &idx);
64219         }else{
64220           idx = nextIndex;
64221         }
64222       }else{
64223         assert( zRawSql[0]==':' || zRawSql[0]=='$' || zRawSql[0]=='@' );
64224         testcase( zRawSql[0]==':' );
64225         testcase( zRawSql[0]=='$' );
64226         testcase( zRawSql[0]=='@' );
64227         idx = sqlcipher3VdbeParameterIndex(p, zRawSql, nToken);
64228         assert( idx>0 );
64229       }
64230       zRawSql += nToken;
64231       nextIndex = idx + 1;
64232       assert( idx>0 && idx<=p->nVar );
64233       pVar = &p->aVar[idx-1];
64234       if( pVar->flags & MEM_Null ){
64235         sqlcipher3StrAccumAppend(&out, "NULL", 4);
64236       }else if( pVar->flags & MEM_Int ){
64237         sqlcipher3XPrintf(&out, "%lld", pVar->u.i);
64238       }else if( pVar->flags & MEM_Real ){
64239         sqlcipher3XPrintf(&out, "%!.15g", pVar->r);
64240       }else if( pVar->flags & MEM_Str ){
64241 #ifndef SQLCIPHER_OMIT_UTF16
64242         u8 enc = ENC(db);
64243         if( enc!=SQLCIPHER_UTF8 ){
64244           Mem utf8;
64245           memset(&utf8, 0, sizeof(utf8));
64246           utf8.db = db;
64247           sqlcipher3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLCIPHER_STATIC);
64248           sqlcipher3VdbeChangeEncoding(&utf8, SQLCIPHER_UTF8);
64249           sqlcipher3XPrintf(&out, "'%.*q'", utf8.n, utf8.z);
64250           sqlcipher3VdbeMemRelease(&utf8);
64251         }else
64252 #endif
64253         {
64254           sqlcipher3XPrintf(&out, "'%.*q'", pVar->n, pVar->z);
64255         }
64256       }else if( pVar->flags & MEM_Zero ){
64257         sqlcipher3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
64258       }else{
64259         assert( pVar->flags & MEM_Blob );
64260         sqlcipher3StrAccumAppend(&out, "x'", 2);
64261         for(i=0; i<pVar->n; i++){
64262           sqlcipher3XPrintf(&out, "%02x", pVar->z[i]&0xff);
64263         }
64264         sqlcipher3StrAccumAppend(&out, "'", 1);
64265       }
64266     }
64267   }
64268   return sqlcipher3StrAccumFinish(&out);
64269 }
64270
64271 #endif /* #ifndef SQLCIPHER_OMIT_TRACE */
64272
64273 /************** End of vdbetrace.c *******************************************/
64274 /************** Begin file vdbe.c ********************************************/
64275 /*
64276 ** 2001 September 15
64277 **
64278 ** The author disclaims copyright to this source code.  In place of
64279 ** a legal notice, here is a blessing:
64280 **
64281 **    May you do good and not evil.
64282 **    May you find forgiveness for yourself and forgive others.
64283 **    May you share freely, never taking more than you give.
64284 **
64285 *************************************************************************
64286 ** The code in this file implements execution method of the 
64287 ** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")
64288 ** handles housekeeping details such as creating and deleting
64289 ** VDBE instances.  This file is solely interested in executing
64290 ** the VDBE program.
64291 **
64292 ** In the external interface, an "sqlcipher3_stmt*" is an opaque pointer
64293 ** to a VDBE.
64294 **
64295 ** The SQL parser generates a program which is then executed by
64296 ** the VDBE to do the work of the SQL statement.  VDBE programs are 
64297 ** similar in form to assembly language.  The program consists of
64298 ** a linear sequence of operations.  Each operation has an opcode 
64299 ** and 5 operands.  Operands P1, P2, and P3 are integers.  Operand P4 
64300 ** is a null-terminated string.  Operand P5 is an unsigned character.
64301 ** Few opcodes use all 5 operands.
64302 **
64303 ** Computation results are stored on a set of registers numbered beginning
64304 ** with 1 and going up to Vdbe.nMem.  Each register can store
64305 ** either an integer, a null-terminated string, a floating point
64306 ** number, or the SQL "NULL" value.  An implicit conversion from one
64307 ** type to the other occurs as necessary.
64308 ** 
64309 ** Most of the code in this file is taken up by the sqlcipher3VdbeExec()
64310 ** function which does the work of interpreting a VDBE program.
64311 ** But other routines are also provided to help in building up
64312 ** a program instruction by instruction.
64313 **
64314 ** Various scripts scan this source file in order to generate HTML
64315 ** documentation, headers files, or other derived files.  The formatting
64316 ** of the code in this file is, therefore, important.  See other comments
64317 ** in this file for details.  If in doubt, do not deviate from existing
64318 ** commenting and indentation practices when changing or adding code.
64319 */
64320
64321 /*
64322 ** Invoke this macro on memory cells just prior to changing the
64323 ** value of the cell.  This macro verifies that shallow copies are
64324 ** not misused.
64325 */
64326 #ifdef SQLCIPHER_DEBUG
64327 # define memAboutToChange(P,M) sqlcipher3VdbeMemPrepareToChange(P,M)
64328 #else
64329 # define memAboutToChange(P,M)
64330 #endif
64331
64332 /*
64333 ** The following global variable is incremented every time a cursor
64334 ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes.  The test
64335 ** procedures use this information to make sure that indices are
64336 ** working correctly.  This variable has no function other than to
64337 ** help verify the correct operation of the library.
64338 */
64339 #ifdef SQLCIPHER_TEST
64340 SQLCIPHER_API int sqlcipher3_search_count = 0;
64341 #endif
64342
64343 /*
64344 ** When this global variable is positive, it gets decremented once before
64345 ** each instruction in the VDBE.  When reaches zero, the u1.isInterrupted
64346 ** field of the sqlcipher3 structure is set in order to simulate and interrupt.
64347 **
64348 ** This facility is used for testing purposes only.  It does not function
64349 ** in an ordinary build.
64350 */
64351 #ifdef SQLCIPHER_TEST
64352 SQLCIPHER_API int sqlcipher3_interrupt_count = 0;
64353 #endif
64354
64355 /*
64356 ** The next global variable is incremented each type the OP_Sort opcode
64357 ** is executed.  The test procedures use this information to make sure that
64358 ** sorting is occurring or not occurring at appropriate times.   This variable
64359 ** has no function other than to help verify the correct operation of the
64360 ** library.
64361 */
64362 #ifdef SQLCIPHER_TEST
64363 SQLCIPHER_API int sqlcipher3_sort_count = 0;
64364 #endif
64365
64366 /*
64367 ** The next global variable records the size of the largest MEM_Blob
64368 ** or MEM_Str that has been used by a VDBE opcode.  The test procedures
64369 ** use this information to make sure that the zero-blob functionality
64370 ** is working correctly.   This variable has no function other than to
64371 ** help verify the correct operation of the library.
64372 */
64373 #ifdef SQLCIPHER_TEST
64374 SQLCIPHER_API int sqlcipher3_max_blobsize = 0;
64375 static void updateMaxBlobsize(Mem *p){
64376   if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlcipher3_max_blobsize ){
64377     sqlcipher3_max_blobsize = p->n;
64378   }
64379 }
64380 #endif
64381
64382 /*
64383 ** The next global variable is incremented each type the OP_Found opcode
64384 ** is executed. This is used to test whether or not the foreign key
64385 ** operation implemented using OP_FkIsZero is working. This variable
64386 ** has no function other than to help verify the correct operation of the
64387 ** library.
64388 */
64389 #ifdef SQLCIPHER_TEST
64390 SQLCIPHER_API int sqlcipher3_found_count = 0;
64391 #endif
64392
64393 /*
64394 ** Test a register to see if it exceeds the current maximum blob size.
64395 ** If it does, record the new maximum blob size.
64396 */
64397 #if defined(SQLCIPHER_TEST) && !defined(SQLCIPHER_OMIT_BUILTIN_TEST)
64398 # define UPDATE_MAX_BLOBSIZE(P)  updateMaxBlobsize(P)
64399 #else
64400 # define UPDATE_MAX_BLOBSIZE(P)
64401 #endif
64402
64403 /*
64404 ** Convert the given register into a string if it isn't one
64405 ** already. Return non-zero if a malloc() fails.
64406 */
64407 #define Stringify(P, enc) \
64408    if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlcipher3VdbeMemStringify(P,enc)) \
64409      { goto no_mem; }
64410
64411 /*
64412 ** An ephemeral string value (signified by the MEM_Ephem flag) contains
64413 ** a pointer to a dynamically allocated string where some other entity
64414 ** is responsible for deallocating that string.  Because the register
64415 ** does not control the string, it might be deleted without the register
64416 ** knowing it.
64417 **
64418 ** This routine converts an ephemeral string into a dynamically allocated
64419 ** string that the register itself controls.  In other words, it
64420 ** converts an MEM_Ephem string into an MEM_Dyn string.
64421 */
64422 #define Deephemeralize(P) \
64423    if( ((P)->flags&MEM_Ephem)!=0 \
64424        && sqlcipher3VdbeMemMakeWriteable(P) ){ goto no_mem;}
64425
64426 /*
64427 ** Call sqlcipher3VdbeMemExpandBlob() on the supplied value (type Mem*)
64428 ** P if required.
64429 */
64430 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlcipher3VdbeMemExpandBlob(P):0)
64431
64432 /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
64433 #ifdef SQLCIPHER_OMIT_MERGE_SORT
64434 # define isSorter(x) 0
64435 #else
64436 # define isSorter(x) ((x)->pSorter!=0)
64437 #endif
64438
64439 /*
64440 ** Argument pMem points at a register that will be passed to a
64441 ** user-defined function or returned to the user as the result of a query.
64442 ** This routine sets the pMem->type variable used by the sqlcipher3_value_*() 
64443 ** routines.
64444 */
64445 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemStoreType(Mem *pMem){
64446   int flags = pMem->flags;
64447   if( flags & MEM_Null ){
64448     pMem->type = SQLCIPHER_NULL;
64449   }
64450   else if( flags & MEM_Int ){
64451     pMem->type = SQLCIPHER_INTEGER;
64452   }
64453   else if( flags & MEM_Real ){
64454     pMem->type = SQLCIPHER_FLOAT;
64455   }
64456   else if( flags & MEM_Str ){
64457     pMem->type = SQLCIPHER_TEXT;
64458   }else{
64459     pMem->type = SQLCIPHER_BLOB;
64460   }
64461 }
64462
64463 /*
64464 ** Allocate VdbeCursor number iCur.  Return a pointer to it.  Return NULL
64465 ** if we run out of memory.
64466 */
64467 static VdbeCursor *allocateCursor(
64468   Vdbe *p,              /* The virtual machine */
64469   int iCur,             /* Index of the new VdbeCursor */
64470   int nField,           /* Number of fields in the table or index */
64471   int iDb,              /* When database the cursor belongs to, or -1 */
64472   int isBtreeCursor     /* True for B-Tree.  False for pseudo-table or vtab */
64473 ){
64474   /* Find the memory cell that will be used to store the blob of memory
64475   ** required for this VdbeCursor structure. It is convenient to use a 
64476   ** vdbe memory cell to manage the memory allocation required for a
64477   ** VdbeCursor structure for the following reasons:
64478   **
64479   **   * Sometimes cursor numbers are used for a couple of different
64480   **     purposes in a vdbe program. The different uses might require
64481   **     different sized allocations. Memory cells provide growable
64482   **     allocations.
64483   **
64484   **   * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
64485   **     be freed lazily via the sqlcipher3_release_memory() API. This
64486   **     minimizes the number of malloc calls made by the system.
64487   **
64488   ** Memory cells for cursors are allocated at the top of the address
64489   ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
64490   ** cursor 1 is managed by memory cell (p->nMem-1), etc.
64491   */
64492   Mem *pMem = &p->aMem[p->nMem-iCur];
64493
64494   int nByte;
64495   VdbeCursor *pCx = 0;
64496   nByte = 
64497       ROUND8(sizeof(VdbeCursor)) + 
64498       (isBtreeCursor?sqlcipher3BtreeCursorSize():0) + 
64499       2*nField*sizeof(u32);
64500
64501   assert( iCur<p->nCursor );
64502   if( p->apCsr[iCur] ){
64503     sqlcipher3VdbeFreeCursor(p, p->apCsr[iCur]);
64504     p->apCsr[iCur] = 0;
64505   }
64506   if( SQLCIPHER_OK==sqlcipher3VdbeMemGrow(pMem, nByte, 0) ){
64507     p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
64508     memset(pCx, 0, sizeof(VdbeCursor));
64509     pCx->iDb = iDb;
64510     pCx->nField = nField;
64511     if( nField ){
64512       pCx->aType = (u32 *)&pMem->z[ROUND8(sizeof(VdbeCursor))];
64513     }
64514     if( isBtreeCursor ){
64515       pCx->pCursor = (BtCursor*)
64516           &pMem->z[ROUND8(sizeof(VdbeCursor))+2*nField*sizeof(u32)];
64517       sqlcipher3BtreeCursorZero(pCx->pCursor);
64518     }
64519   }
64520   return pCx;
64521 }
64522
64523 /*
64524 ** Try to convert a value into a numeric representation if we can
64525 ** do so without loss of information.  In other words, if the string
64526 ** looks like a number, convert it into a number.  If it does not
64527 ** look like a number, leave it alone.
64528 */
64529 static void applyNumericAffinity(Mem *pRec){
64530   if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){
64531     double rValue;
64532     i64 iValue;
64533     u8 enc = pRec->enc;
64534     if( (pRec->flags&MEM_Str)==0 ) return;
64535     if( sqlcipher3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
64536     if( 0==sqlcipher3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
64537       pRec->u.i = iValue;
64538       pRec->flags |= MEM_Int;
64539     }else{
64540       pRec->r = rValue;
64541       pRec->flags |= MEM_Real;
64542     }
64543   }
64544 }
64545
64546 /*
64547 ** Processing is determine by the affinity parameter:
64548 **
64549 ** SQLCIPHER_AFF_INTEGER:
64550 ** SQLCIPHER_AFF_REAL:
64551 ** SQLCIPHER_AFF_NUMERIC:
64552 **    Try to convert pRec to an integer representation or a 
64553 **    floating-point representation if an integer representation
64554 **    is not possible.  Note that the integer representation is
64555 **    always preferred, even if the affinity is REAL, because
64556 **    an integer representation is more space efficient on disk.
64557 **
64558 ** SQLCIPHER_AFF_TEXT:
64559 **    Convert pRec to a text representation.
64560 **
64561 ** SQLCIPHER_AFF_NONE:
64562 **    No-op.  pRec is unchanged.
64563 */
64564 static void applyAffinity(
64565   Mem *pRec,          /* The value to apply affinity to */
64566   char affinity,      /* The affinity to be applied */
64567   u8 enc              /* Use this text encoding */
64568 ){
64569   if( affinity==SQLCIPHER_AFF_TEXT ){
64570     /* Only attempt the conversion to TEXT if there is an integer or real
64571     ** representation (blob and NULL do not get converted) but no string
64572     ** representation.
64573     */
64574     if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){
64575       sqlcipher3VdbeMemStringify(pRec, enc);
64576     }
64577     pRec->flags &= ~(MEM_Real|MEM_Int);
64578   }else if( affinity!=SQLCIPHER_AFF_NONE ){
64579     assert( affinity==SQLCIPHER_AFF_INTEGER || affinity==SQLCIPHER_AFF_REAL
64580              || affinity==SQLCIPHER_AFF_NUMERIC );
64581     applyNumericAffinity(pRec);
64582     if( pRec->flags & MEM_Real ){
64583       sqlcipher3VdbeIntegerAffinity(pRec);
64584     }
64585   }
64586 }
64587
64588 /*
64589 ** Try to convert the type of a function argument or a result column
64590 ** into a numeric representation.  Use either INTEGER or REAL whichever
64591 ** is appropriate.  But only do the conversion if it is possible without
64592 ** loss of information and return the revised type of the argument.
64593 */
64594 SQLCIPHER_API int sqlcipher3_value_numeric_type(sqlcipher3_value *pVal){
64595   Mem *pMem = (Mem*)pVal;
64596   if( pMem->type==SQLCIPHER_TEXT ){
64597     applyNumericAffinity(pMem);
64598     sqlcipher3VdbeMemStoreType(pMem);
64599   }
64600   return pMem->type;
64601 }
64602
64603 /*
64604 ** Exported version of applyAffinity(). This one works on sqlcipher3_value*, 
64605 ** not the internal Mem* type.
64606 */
64607 SQLCIPHER_PRIVATE void sqlcipher3ValueApplyAffinity(
64608   sqlcipher3_value *pVal, 
64609   u8 affinity, 
64610   u8 enc
64611 ){
64612   applyAffinity((Mem *)pVal, affinity, enc);
64613 }
64614
64615 #ifdef SQLCIPHER_DEBUG
64616 /*
64617 ** Write a nice string representation of the contents of cell pMem
64618 ** into buffer zBuf, length nBuf.
64619 */
64620 SQLCIPHER_PRIVATE void sqlcipher3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
64621   char *zCsr = zBuf;
64622   int f = pMem->flags;
64623
64624   static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
64625
64626   if( f&MEM_Blob ){
64627     int i;
64628     char c;
64629     if( f & MEM_Dyn ){
64630       c = 'z';
64631       assert( (f & (MEM_Static|MEM_Ephem))==0 );
64632     }else if( f & MEM_Static ){
64633       c = 't';
64634       assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
64635     }else if( f & MEM_Ephem ){
64636       c = 'e';
64637       assert( (f & (MEM_Static|MEM_Dyn))==0 );
64638     }else{
64639       c = 's';
64640     }
64641
64642     sqlcipher3_snprintf(100, zCsr, "%c", c);
64643     zCsr += sqlcipher3Strlen30(zCsr);
64644     sqlcipher3_snprintf(100, zCsr, "%d[", pMem->n);
64645     zCsr += sqlcipher3Strlen30(zCsr);
64646     for(i=0; i<16 && i<pMem->n; i++){
64647       sqlcipher3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
64648       zCsr += sqlcipher3Strlen30(zCsr);
64649     }
64650     for(i=0; i<16 && i<pMem->n; i++){
64651       char z = pMem->z[i];
64652       if( z<32 || z>126 ) *zCsr++ = '.';
64653       else *zCsr++ = z;
64654     }
64655
64656     sqlcipher3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
64657     zCsr += sqlcipher3Strlen30(zCsr);
64658     if( f & MEM_Zero ){
64659       sqlcipher3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
64660       zCsr += sqlcipher3Strlen30(zCsr);
64661     }
64662     *zCsr = '\0';
64663   }else if( f & MEM_Str ){
64664     int j, k;
64665     zBuf[0] = ' ';
64666     if( f & MEM_Dyn ){
64667       zBuf[1] = 'z';
64668       assert( (f & (MEM_Static|MEM_Ephem))==0 );
64669     }else if( f & MEM_Static ){
64670       zBuf[1] = 't';
64671       assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
64672     }else if( f & MEM_Ephem ){
64673       zBuf[1] = 'e';
64674       assert( (f & (MEM_Static|MEM_Dyn))==0 );
64675     }else{
64676       zBuf[1] = 's';
64677     }
64678     k = 2;
64679     sqlcipher3_snprintf(100, &zBuf[k], "%d", pMem->n);
64680     k += sqlcipher3Strlen30(&zBuf[k]);
64681     zBuf[k++] = '[';
64682     for(j=0; j<15 && j<pMem->n; j++){
64683       u8 c = pMem->z[j];
64684       if( c>=0x20 && c<0x7f ){
64685         zBuf[k++] = c;
64686       }else{
64687         zBuf[k++] = '.';
64688       }
64689     }
64690     zBuf[k++] = ']';
64691     sqlcipher3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
64692     k += sqlcipher3Strlen30(&zBuf[k]);
64693     zBuf[k++] = 0;
64694   }
64695 }
64696 #endif
64697
64698 #ifdef SQLCIPHER_DEBUG
64699 /*
64700 ** Print the value of a register for tracing purposes:
64701 */
64702 static void memTracePrint(FILE *out, Mem *p){
64703   if( p->flags & MEM_Null ){
64704     fprintf(out, " NULL");
64705   }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
64706     fprintf(out, " si:%lld", p->u.i);
64707   }else if( p->flags & MEM_Int ){
64708     fprintf(out, " i:%lld", p->u.i);
64709 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
64710   }else if( p->flags & MEM_Real ){
64711     fprintf(out, " r:%g", p->r);
64712 #endif
64713   }else if( p->flags & MEM_RowSet ){
64714     fprintf(out, " (rowset)");
64715   }else{
64716     char zBuf[200];
64717     sqlcipher3VdbeMemPrettyPrint(p, zBuf);
64718     fprintf(out, " ");
64719     fprintf(out, "%s", zBuf);
64720   }
64721 }
64722 static void registerTrace(FILE *out, int iReg, Mem *p){
64723   fprintf(out, "REG[%d] = ", iReg);
64724   memTracePrint(out, p);
64725   fprintf(out, "\n");
64726 }
64727 #endif
64728
64729 #ifdef SQLCIPHER_DEBUG
64730 #  define REGISTER_TRACE(R,M) if(p->trace)registerTrace(p->trace,R,M)
64731 #else
64732 #  define REGISTER_TRACE(R,M)
64733 #endif
64734
64735
64736 #ifdef VDBE_PROFILE
64737
64738 /* 
64739 ** hwtime.h contains inline assembler code for implementing 
64740 ** high-performance timing routines.
64741 */
64742 /************** Include hwtime.h in the middle of vdbe.c *********************/
64743 /************** Begin file hwtime.h ******************************************/
64744 /*
64745 ** 2008 May 27
64746 **
64747 ** The author disclaims copyright to this source code.  In place of
64748 ** a legal notice, here is a blessing:
64749 **
64750 **    May you do good and not evil.
64751 **    May you find forgiveness for yourself and forgive others.
64752 **    May you share freely, never taking more than you give.
64753 **
64754 ******************************************************************************
64755 **
64756 ** This file contains inline asm code for retrieving "high-performance"
64757 ** counters for x86 class CPUs.
64758 */
64759 #ifndef _HWTIME_H_
64760 #define _HWTIME_H_
64761
64762 /*
64763 ** The following routine only works on pentium-class (or newer) processors.
64764 ** It uses the RDTSC opcode to read the cycle count value out of the
64765 ** processor and returns that value.  This can be used for high-res
64766 ** profiling.
64767 */
64768 #if (defined(__GNUC__) || defined(_MSC_VER)) && \
64769       (defined(i386) || defined(__i386__) || defined(_M_IX86))
64770
64771   #if defined(__GNUC__)
64772
64773   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
64774      unsigned int lo, hi;
64775      __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
64776      return (sqlcipher_uint64)hi << 32 | lo;
64777   }
64778
64779   #elif defined(_MSC_VER)
64780
64781   __declspec(naked) __inline sqlcipher_uint64 __cdecl sqlcipher3Hwtime(void){
64782      __asm {
64783         rdtsc
64784         ret       ; return value at EDX:EAX
64785      }
64786   }
64787
64788   #endif
64789
64790 #elif (defined(__GNUC__) && defined(__x86_64__))
64791
64792   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
64793       unsigned long val;
64794       __asm__ __volatile__ ("rdtsc" : "=A" (val));
64795       return val;
64796   }
64797  
64798 #elif (defined(__GNUC__) && defined(__ppc__))
64799
64800   __inline__ sqlcipher_uint64 sqlcipher3Hwtime(void){
64801       unsigned long long retval;
64802       unsigned long junk;
64803       __asm__ __volatile__ ("\n\
64804           1:      mftbu   %1\n\
64805                   mftb    %L0\n\
64806                   mftbu   %0\n\
64807                   cmpw    %0,%1\n\
64808                   bne     1b"
64809                   : "=r" (retval), "=r" (junk));
64810       return retval;
64811   }
64812
64813 #else
64814
64815   #error Need implementation of sqlcipher3Hwtime() for your platform.
64816
64817   /*
64818   ** To compile without implementing sqlcipher3Hwtime() for your platform,
64819   ** you can remove the above #error and use the following
64820   ** stub function.  You will lose timing support for many
64821   ** of the debugging and testing utilities, but it should at
64822   ** least compile and run.
64823   */
64824 SQLCIPHER_PRIVATE   sqlcipher_uint64 sqlcipher3Hwtime(void){ return ((sqlcipher_uint64)0); }
64825
64826 #endif
64827
64828 #endif /* !defined(_HWTIME_H_) */
64829
64830 /************** End of hwtime.h **********************************************/
64831 /************** Continuing where we left off in vdbe.c ***********************/
64832
64833 #endif
64834
64835 /*
64836 ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
64837 ** sqlcipher3_interrupt() routine has been called.  If it has been, then
64838 ** processing of the VDBE program is interrupted.
64839 **
64840 ** This macro added to every instruction that does a jump in order to
64841 ** implement a loop.  This test used to be on every single instruction,
64842 ** but that meant we more testing that we needed.  By only testing the
64843 ** flag on jump instructions, we get a (small) speed improvement.
64844 */
64845 #define CHECK_FOR_INTERRUPT \
64846    if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
64847
64848
64849 #ifndef NDEBUG
64850 /*
64851 ** This function is only called from within an assert() expression. It
64852 ** checks that the sqlcipher3.nTransaction variable is correctly set to
64853 ** the number of non-transaction savepoints currently in the 
64854 ** linked list starting at sqlcipher3.pSavepoint.
64855 ** 
64856 ** Usage:
64857 **
64858 **     assert( checkSavepointCount(db) );
64859 */
64860 static int checkSavepointCount(sqlcipher3 *db){
64861   int n = 0;
64862   Savepoint *p;
64863   for(p=db->pSavepoint; p; p=p->pNext) n++;
64864   assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
64865   return 1;
64866 }
64867 #endif
64868
64869 /*
64870 ** Transfer error message text from an sqlcipher3_vtab.zErrMsg (text stored
64871 ** in memory obtained from sqlcipher3_malloc) into a Vdbe.zErrMsg (text stored
64872 ** in memory obtained from sqlcipher3DbMalloc).
64873 */
64874 static void importVtabErrMsg(Vdbe *p, sqlcipher3_vtab *pVtab){
64875   sqlcipher3 *db = p->db;
64876   sqlcipher3DbFree(db, p->zErrMsg);
64877   p->zErrMsg = sqlcipher3DbStrDup(db, pVtab->zErrMsg);
64878   sqlcipher3_free(pVtab->zErrMsg);
64879   pVtab->zErrMsg = 0;
64880 }
64881
64882
64883 /*
64884 ** Execute as much of a VDBE program as we can then return.
64885 **
64886 ** sqlcipher3VdbeMakeReady() must be called before this routine in order to
64887 ** close the program with a final OP_Halt and to set up the callbacks
64888 ** and the error message pointer.
64889 **
64890 ** Whenever a row or result data is available, this routine will either
64891 ** invoke the result callback (if there is one) or return with
64892 ** SQLCIPHER_ROW.
64893 **
64894 ** If an attempt is made to open a locked database, then this routine
64895 ** will either invoke the busy callback (if there is one) or it will
64896 ** return SQLCIPHER_BUSY.
64897 **
64898 ** If an error occurs, an error message is written to memory obtained
64899 ** from sqlcipher3_malloc() and p->zErrMsg is made to point to that memory.
64900 ** The error code is stored in p->rc and this routine returns SQLCIPHER_ERROR.
64901 **
64902 ** If the callback ever returns non-zero, then the program exits
64903 ** immediately.  There will be no error message but the p->rc field is
64904 ** set to SQLCIPHER_ABORT and this routine will return SQLCIPHER_ERROR.
64905 **
64906 ** A memory allocation error causes p->rc to be set to SQLCIPHER_NOMEM and this
64907 ** routine to return SQLCIPHER_ERROR.
64908 **
64909 ** Other fatal errors return SQLCIPHER_ERROR.
64910 **
64911 ** After this routine has finished, sqlcipher3VdbeFinalize() should be
64912 ** used to clean up the mess that was left behind.
64913 */
64914 SQLCIPHER_PRIVATE int sqlcipher3VdbeExec(
64915   Vdbe *p                    /* The VDBE */
64916 ){
64917   int pc=0;                  /* The program counter */
64918   Op *aOp = p->aOp;          /* Copy of p->aOp */
64919   Op *pOp;                   /* Current operation */
64920   int rc = SQLCIPHER_OK;        /* Value to return */
64921   sqlcipher3 *db = p->db;       /* The database */
64922   u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
64923   u8 encoding = ENC(db);     /* The database encoding */
64924 #ifndef SQLCIPHER_OMIT_PROGRESS_CALLBACK
64925   int checkProgress;         /* True if progress callbacks are enabled */
64926   int nProgressOps = 0;      /* Opcodes executed since progress callback. */
64927 #endif
64928   Mem *aMem = p->aMem;       /* Copy of p->aMem */
64929   Mem *pIn1 = 0;             /* 1st input operand */
64930   Mem *pIn2 = 0;             /* 2nd input operand */
64931   Mem *pIn3 = 0;             /* 3rd input operand */
64932   Mem *pOut = 0;             /* Output operand */
64933   int iCompare = 0;          /* Result of last OP_Compare operation */
64934   int *aPermute = 0;         /* Permutation of columns for OP_Compare */
64935   i64 lastRowid = db->lastRowid;  /* Saved value of the last insert ROWID */
64936 #ifdef VDBE_PROFILE
64937   u64 start;                 /* CPU clock count at start of opcode */
64938   int origPc;                /* Program counter at start of opcode */
64939 #endif
64940   /********************************************************************
64941   ** Automatically generated code
64942   **
64943   ** The following union is automatically generated by the
64944   ** vdbe-compress.tcl script.  The purpose of this union is to
64945   ** reduce the amount of stack space required by this function.
64946   ** See comments in the vdbe-compress.tcl script for details.
64947   */
64948   union vdbeExecUnion {
64949     struct OP_Yield_stack_vars {
64950       int pcDest;
64951     } aa;
64952     struct OP_Variable_stack_vars {
64953       Mem *pVar;       /* Value being transferred */
64954     } ab;
64955     struct OP_Move_stack_vars {
64956       char *zMalloc;   /* Holding variable for allocated memory */
64957       int n;           /* Number of registers left to copy */
64958       int p1;          /* Register to copy from */
64959       int p2;          /* Register to copy to */
64960     } ac;
64961     struct OP_ResultRow_stack_vars {
64962       Mem *pMem;
64963       int i;
64964     } ad;
64965     struct OP_Concat_stack_vars {
64966       i64 nByte;
64967     } ae;
64968     struct OP_Remainder_stack_vars {
64969       int flags;      /* Combined MEM_* flags from both inputs */
64970       i64 iA;         /* Integer value of left operand */
64971       i64 iB;         /* Integer value of right operand */
64972       double rA;      /* Real value of left operand */
64973       double rB;      /* Real value of right operand */
64974     } af;
64975     struct OP_Function_stack_vars {
64976       int i;
64977       Mem *pArg;
64978       sqlcipher3_context ctx;
64979       sqlcipher3_value **apVal;
64980       int n;
64981     } ag;
64982     struct OP_ShiftRight_stack_vars {
64983       i64 iA;
64984       u64 uA;
64985       i64 iB;
64986       u8 op;
64987     } ah;
64988     struct OP_Ge_stack_vars {
64989       int res;            /* Result of the comparison of pIn1 against pIn3 */
64990       char affinity;      /* Affinity to use for comparison */
64991       u16 flags1;         /* Copy of initial value of pIn1->flags */
64992       u16 flags3;         /* Copy of initial value of pIn3->flags */
64993     } ai;
64994     struct OP_Compare_stack_vars {
64995       int n;
64996       int i;
64997       int p1;
64998       int p2;
64999       const KeyInfo *pKeyInfo;
65000       int idx;
65001       CollSeq *pColl;    /* Collating sequence to use on this term */
65002       int bRev;          /* True for DESCENDING sort order */
65003     } aj;
65004     struct OP_Or_stack_vars {
65005       int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
65006       int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
65007     } ak;
65008     struct OP_IfNot_stack_vars {
65009       int c;
65010     } al;
65011     struct OP_Column_stack_vars {
65012       u32 payloadSize;   /* Number of bytes in the record */
65013       i64 payloadSize64; /* Number of bytes in the record */
65014       int p1;            /* P1 value of the opcode */
65015       int p2;            /* column number to retrieve */
65016       VdbeCursor *pC;    /* The VDBE cursor */
65017       char *zRec;        /* Pointer to complete record-data */
65018       BtCursor *pCrsr;   /* The BTree cursor */
65019       u32 *aType;        /* aType[i] holds the numeric type of the i-th column */
65020       u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
65021       int nField;        /* number of fields in the record */
65022       int len;           /* The length of the serialized data for the column */
65023       int i;             /* Loop counter */
65024       char *zData;       /* Part of the record being decoded */
65025       Mem *pDest;        /* Where to write the extracted value */
65026       Mem sMem;          /* For storing the record being decoded */
65027       u8 *zIdx;          /* Index into header */
65028       u8 *zEndHdr;       /* Pointer to first byte after the header */
65029       u32 offset;        /* Offset into the data */
65030       u32 szField;       /* Number of bytes in the content of a field */
65031       int szHdr;         /* Size of the header size field at start of record */
65032       int avail;         /* Number of bytes of available data */
65033       u32 t;             /* A type code from the record header */
65034       Mem *pReg;         /* PseudoTable input register */
65035     } am;
65036     struct OP_Affinity_stack_vars {
65037       const char *zAffinity;   /* The affinity to be applied */
65038       char cAff;               /* A single character of affinity */
65039     } an;
65040     struct OP_MakeRecord_stack_vars {
65041       u8 *zNewRecord;        /* A buffer to hold the data for the new record */
65042       Mem *pRec;             /* The new record */
65043       u64 nData;             /* Number of bytes of data space */
65044       int nHdr;              /* Number of bytes of header space */
65045       i64 nByte;             /* Data space required for this record */
65046       int nZero;             /* Number of zero bytes at the end of the record */
65047       int nVarint;           /* Number of bytes in a varint */
65048       u32 serial_type;       /* Type field */
65049       Mem *pData0;           /* First field to be combined into the record */
65050       Mem *pLast;            /* Last field of the record */
65051       int nField;            /* Number of fields in the record */
65052       char *zAffinity;       /* The affinity string for the record */
65053       int file_format;       /* File format to use for encoding */
65054       int i;                 /* Space used in zNewRecord[] */
65055       int len;               /* Length of a field */
65056     } ao;
65057     struct OP_Count_stack_vars {
65058       i64 nEntry;
65059       BtCursor *pCrsr;
65060     } ap;
65061     struct OP_Savepoint_stack_vars {
65062       int p1;                         /* Value of P1 operand */
65063       char *zName;                    /* Name of savepoint */
65064       int nName;
65065       Savepoint *pNew;
65066       Savepoint *pSavepoint;
65067       Savepoint *pTmp;
65068       int iSavepoint;
65069       int ii;
65070     } aq;
65071     struct OP_AutoCommit_stack_vars {
65072       int desiredAutoCommit;
65073       int iRollback;
65074       int turnOnAC;
65075     } ar;
65076     struct OP_Transaction_stack_vars {
65077       Btree *pBt;
65078     } as;
65079     struct OP_ReadCookie_stack_vars {
65080       int iMeta;
65081       int iDb;
65082       int iCookie;
65083     } at;
65084     struct OP_SetCookie_stack_vars {
65085       Db *pDb;
65086     } au;
65087     struct OP_VerifyCookie_stack_vars {
65088       int iMeta;
65089       int iGen;
65090       Btree *pBt;
65091     } av;
65092     struct OP_OpenWrite_stack_vars {
65093       int nField;
65094       KeyInfo *pKeyInfo;
65095       int p2;
65096       int iDb;
65097       int wrFlag;
65098       Btree *pX;
65099       VdbeCursor *pCur;
65100       Db *pDb;
65101     } aw;
65102     struct OP_OpenEphemeral_stack_vars {
65103       VdbeCursor *pCx;
65104     } ax;
65105     struct OP_SorterOpen_stack_vars {
65106       VdbeCursor *pCx;
65107     } ay;
65108     struct OP_OpenPseudo_stack_vars {
65109       VdbeCursor *pCx;
65110     } az;
65111     struct OP_SeekGt_stack_vars {
65112       int res;
65113       int oc;
65114       VdbeCursor *pC;
65115       UnpackedRecord r;
65116       int nField;
65117       i64 iKey;      /* The rowid we are to seek to */
65118     } ba;
65119     struct OP_Seek_stack_vars {
65120       VdbeCursor *pC;
65121     } bb;
65122     struct OP_Found_stack_vars {
65123       int alreadyExists;
65124       VdbeCursor *pC;
65125       int res;
65126       char *pFree;
65127       UnpackedRecord *pIdxKey;
65128       UnpackedRecord r;
65129       char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
65130     } bc;
65131     struct OP_IsUnique_stack_vars {
65132       u16 ii;
65133       VdbeCursor *pCx;
65134       BtCursor *pCrsr;
65135       u16 nField;
65136       Mem *aMx;
65137       UnpackedRecord r;                  /* B-Tree index search key */
65138       i64 R;                             /* Rowid stored in register P3 */
65139     } bd;
65140     struct OP_NotExists_stack_vars {
65141       VdbeCursor *pC;
65142       BtCursor *pCrsr;
65143       int res;
65144       u64 iKey;
65145     } be;
65146     struct OP_NewRowid_stack_vars {
65147       i64 v;                 /* The new rowid */
65148       VdbeCursor *pC;        /* Cursor of table to get the new rowid */
65149       int res;               /* Result of an sqlcipher3BtreeLast() */
65150       int cnt;               /* Counter to limit the number of searches */
65151       Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
65152       VdbeFrame *pFrame;     /* Root frame of VDBE */
65153     } bf;
65154     struct OP_InsertInt_stack_vars {
65155       Mem *pData;       /* MEM cell holding data for the record to be inserted */
65156       Mem *pKey;        /* MEM cell holding key  for the record */
65157       i64 iKey;         /* The integer ROWID or key for the record to be inserted */
65158       VdbeCursor *pC;   /* Cursor to table into which insert is written */
65159       int nZero;        /* Number of zero-bytes to append */
65160       int seekResult;   /* Result of prior seek or 0 if no USESEEKRESULT flag */
65161       const char *zDb;  /* database name - used by the update hook */
65162       const char *zTbl; /* Table name - used by the opdate hook */
65163       int op;           /* Opcode for update hook: SQLCIPHER_UPDATE or SQLCIPHER_INSERT */
65164     } bg;
65165     struct OP_Delete_stack_vars {
65166       i64 iKey;
65167       VdbeCursor *pC;
65168     } bh;
65169     struct OP_SorterCompare_stack_vars {
65170       VdbeCursor *pC;
65171       int res;
65172     } bi;
65173     struct OP_SorterData_stack_vars {
65174       VdbeCursor *pC;
65175     } bj;
65176     struct OP_RowData_stack_vars {
65177       VdbeCursor *pC;
65178       BtCursor *pCrsr;
65179       u32 n;
65180       i64 n64;
65181     } bk;
65182     struct OP_Rowid_stack_vars {
65183       VdbeCursor *pC;
65184       i64 v;
65185       sqlcipher3_vtab *pVtab;
65186       const sqlcipher3_module *pModule;
65187     } bl;
65188     struct OP_NullRow_stack_vars {
65189       VdbeCursor *pC;
65190     } bm;
65191     struct OP_Last_stack_vars {
65192       VdbeCursor *pC;
65193       BtCursor *pCrsr;
65194       int res;
65195     } bn;
65196     struct OP_Rewind_stack_vars {
65197       VdbeCursor *pC;
65198       BtCursor *pCrsr;
65199       int res;
65200     } bo;
65201     struct OP_Next_stack_vars {
65202       VdbeCursor *pC;
65203       int res;
65204     } bp;
65205     struct OP_IdxInsert_stack_vars {
65206       VdbeCursor *pC;
65207       BtCursor *pCrsr;
65208       int nKey;
65209       const char *zKey;
65210     } bq;
65211     struct OP_IdxDelete_stack_vars {
65212       VdbeCursor *pC;
65213       BtCursor *pCrsr;
65214       int res;
65215       UnpackedRecord r;
65216     } br;
65217     struct OP_IdxRowid_stack_vars {
65218       BtCursor *pCrsr;
65219       VdbeCursor *pC;
65220       i64 rowid;
65221     } bs;
65222     struct OP_IdxGE_stack_vars {
65223       VdbeCursor *pC;
65224       int res;
65225       UnpackedRecord r;
65226     } bt;
65227     struct OP_Destroy_stack_vars {
65228       int iMoved;
65229       int iCnt;
65230       Vdbe *pVdbe;
65231       int iDb;
65232     } bu;
65233     struct OP_Clear_stack_vars {
65234       int nChange;
65235     } bv;
65236     struct OP_CreateTable_stack_vars {
65237       int pgno;
65238       int flags;
65239       Db *pDb;
65240     } bw;
65241     struct OP_ParseSchema_stack_vars {
65242       int iDb;
65243       const char *zMaster;
65244       char *zSql;
65245       InitData initData;
65246     } bx;
65247     struct OP_IntegrityCk_stack_vars {
65248       int nRoot;      /* Number of tables to check.  (Number of root pages.) */
65249       int *aRoot;     /* Array of rootpage numbers for tables to be checked */
65250       int j;          /* Loop counter */
65251       int nErr;       /* Number of errors reported */
65252       char *z;        /* Text of the error report */
65253       Mem *pnErr;     /* Register keeping track of errors remaining */
65254     } by;
65255     struct OP_RowSetRead_stack_vars {
65256       i64 val;
65257     } bz;
65258     struct OP_RowSetTest_stack_vars {
65259       int iSet;
65260       int exists;
65261     } ca;
65262     struct OP_Program_stack_vars {
65263       int nMem;               /* Number of memory registers for sub-program */
65264       int nByte;              /* Bytes of runtime space required for sub-program */
65265       Mem *pRt;               /* Register to allocate runtime space */
65266       Mem *pMem;              /* Used to iterate through memory cells */
65267       Mem *pEnd;              /* Last memory cell in new array */
65268       VdbeFrame *pFrame;      /* New vdbe frame to execute in */
65269       SubProgram *pProgram;   /* Sub-program to execute */
65270       void *t;                /* Token identifying trigger */
65271     } cb;
65272     struct OP_Param_stack_vars {
65273       VdbeFrame *pFrame;
65274       Mem *pIn;
65275     } cc;
65276     struct OP_MemMax_stack_vars {
65277       Mem *pIn1;
65278       VdbeFrame *pFrame;
65279     } cd;
65280     struct OP_AggStep_stack_vars {
65281       int n;
65282       int i;
65283       Mem *pMem;
65284       Mem *pRec;
65285       sqlcipher3_context ctx;
65286       sqlcipher3_value **apVal;
65287     } ce;
65288     struct OP_AggFinal_stack_vars {
65289       Mem *pMem;
65290     } cf;
65291     struct OP_Checkpoint_stack_vars {
65292       int i;                          /* Loop counter */
65293       int aRes[3];                    /* Results */
65294       Mem *pMem;                      /* Write results here */
65295     } cg;
65296     struct OP_JournalMode_stack_vars {
65297       Btree *pBt;                     /* Btree to change journal mode of */
65298       Pager *pPager;                  /* Pager associated with pBt */
65299       int eNew;                       /* New journal mode */
65300       int eOld;                       /* The old journal mode */
65301       const char *zFilename;          /* Name of database file for pPager */
65302     } ch;
65303     struct OP_IncrVacuum_stack_vars {
65304       Btree *pBt;
65305     } ci;
65306     struct OP_VBegin_stack_vars {
65307       VTable *pVTab;
65308     } cj;
65309     struct OP_VOpen_stack_vars {
65310       VdbeCursor *pCur;
65311       sqlcipher3_vtab_cursor *pVtabCursor;
65312       sqlcipher3_vtab *pVtab;
65313       sqlcipher3_module *pModule;
65314     } ck;
65315     struct OP_VFilter_stack_vars {
65316       int nArg;
65317       int iQuery;
65318       const sqlcipher3_module *pModule;
65319       Mem *pQuery;
65320       Mem *pArgc;
65321       sqlcipher3_vtab_cursor *pVtabCursor;
65322       sqlcipher3_vtab *pVtab;
65323       VdbeCursor *pCur;
65324       int res;
65325       int i;
65326       Mem **apArg;
65327     } cl;
65328     struct OP_VColumn_stack_vars {
65329       sqlcipher3_vtab *pVtab;
65330       const sqlcipher3_module *pModule;
65331       Mem *pDest;
65332       sqlcipher3_context sContext;
65333     } cm;
65334     struct OP_VNext_stack_vars {
65335       sqlcipher3_vtab *pVtab;
65336       const sqlcipher3_module *pModule;
65337       int res;
65338       VdbeCursor *pCur;
65339     } cn;
65340     struct OP_VRename_stack_vars {
65341       sqlcipher3_vtab *pVtab;
65342       Mem *pName;
65343     } co;
65344     struct OP_VUpdate_stack_vars {
65345       sqlcipher3_vtab *pVtab;
65346       sqlcipher3_module *pModule;
65347       int nArg;
65348       int i;
65349       sqlcipher_int64 rowid;
65350       Mem **apArg;
65351       Mem *pX;
65352     } cp;
65353     struct OP_Trace_stack_vars {
65354       char *zTrace;
65355       char *z;
65356     } cq;
65357   } u;
65358   /* End automatically generated code
65359   ********************************************************************/
65360
65361   assert( p->magic==VDBE_MAGIC_RUN );  /* sqlcipher3_step() verifies this */
65362   sqlcipher3VdbeEnter(p);
65363   if( p->rc==SQLCIPHER_NOMEM ){
65364     /* This happens if a malloc() inside a call to sqlcipher3_column_text() or
65365     ** sqlcipher3_column_text16() failed.  */
65366     goto no_mem;
65367   }
65368   assert( p->rc==SQLCIPHER_OK || p->rc==SQLCIPHER_BUSY );
65369   p->rc = SQLCIPHER_OK;
65370   assert( p->explain==0 );
65371   p->pResultSet = 0;
65372   db->busyHandler.nBusy = 0;
65373   CHECK_FOR_INTERRUPT;
65374   sqlcipher3VdbeIOTraceSql(p);
65375 #ifndef SQLCIPHER_OMIT_PROGRESS_CALLBACK
65376   checkProgress = db->xProgress!=0;
65377 #endif
65378 #ifdef SQLCIPHER_DEBUG
65379   sqlcipher3BeginBenignMalloc();
65380   if( p->pc==0  && (p->db->flags & SQLCIPHER_VdbeListing)!=0 ){
65381     int i;
65382     printf("VDBE Program Listing:\n");
65383     sqlcipher3VdbePrintSql(p);
65384     for(i=0; i<p->nOp; i++){
65385       sqlcipher3VdbePrintOp(stdout, i, &aOp[i]);
65386     }
65387   }
65388   sqlcipher3EndBenignMalloc();
65389 #endif
65390   for(pc=p->pc; rc==SQLCIPHER_OK; pc++){
65391     assert( pc>=0 && pc<p->nOp );
65392     if( db->mallocFailed ) goto no_mem;
65393 #ifdef VDBE_PROFILE
65394     origPc = pc;
65395     start = sqlcipher3Hwtime();
65396 #endif
65397     pOp = &aOp[pc];
65398
65399     /* Only allow tracing if SQLCIPHER_DEBUG is defined.
65400     */
65401 #ifdef SQLCIPHER_DEBUG
65402     if( p->trace ){
65403       if( pc==0 ){
65404         printf("VDBE Execution Trace:\n");
65405         sqlcipher3VdbePrintSql(p);
65406       }
65407       sqlcipher3VdbePrintOp(p->trace, pc, pOp);
65408     }
65409 #endif
65410       
65411
65412     /* Check to see if we need to simulate an interrupt.  This only happens
65413     ** if we have a special test build.
65414     */
65415 #ifdef SQLCIPHER_TEST
65416     if( sqlcipher3_interrupt_count>0 ){
65417       sqlcipher3_interrupt_count--;
65418       if( sqlcipher3_interrupt_count==0 ){
65419         sqlcipher3_interrupt(db);
65420       }
65421     }
65422 #endif
65423
65424 #ifndef SQLCIPHER_OMIT_PROGRESS_CALLBACK
65425     /* Call the progress callback if it is configured and the required number
65426     ** of VDBE ops have been executed (either since this invocation of
65427     ** sqlcipher3VdbeExec() or since last time the progress callback was called).
65428     ** If the progress callback returns non-zero, exit the virtual machine with
65429     ** a return code SQLCIPHER_ABORT.
65430     */
65431     if( checkProgress ){
65432       if( db->nProgressOps==nProgressOps ){
65433         int prc;
65434         prc = db->xProgress(db->pProgressArg);
65435         if( prc!=0 ){
65436           rc = SQLCIPHER_INTERRUPT;
65437           goto vdbe_error_halt;
65438         }
65439         nProgressOps = 0;
65440       }
65441       nProgressOps++;
65442     }
65443 #endif
65444
65445     /* On any opcode with the "out2-prerelase" tag, free any
65446     ** external allocations out of mem[p2] and set mem[p2] to be
65447     ** an undefined integer.  Opcodes will either fill in the integer
65448     ** value or convert mem[p2] to a different type.
65449     */
65450     assert( pOp->opflags==sqlcipher3OpcodeProperty[pOp->opcode] );
65451     if( pOp->opflags & OPFLG_OUT2_PRERELEASE ){
65452       assert( pOp->p2>0 );
65453       assert( pOp->p2<=p->nMem );
65454       pOut = &aMem[pOp->p2];
65455       memAboutToChange(p, pOut);
65456       MemReleaseExt(pOut);
65457       pOut->flags = MEM_Int;
65458     }
65459
65460     /* Sanity checking on other operands */
65461 #ifdef SQLCIPHER_DEBUG
65462     if( (pOp->opflags & OPFLG_IN1)!=0 ){
65463       assert( pOp->p1>0 );
65464       assert( pOp->p1<=p->nMem );
65465       assert( memIsValid(&aMem[pOp->p1]) );
65466       REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
65467     }
65468     if( (pOp->opflags & OPFLG_IN2)!=0 ){
65469       assert( pOp->p2>0 );
65470       assert( pOp->p2<=p->nMem );
65471       assert( memIsValid(&aMem[pOp->p2]) );
65472       REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
65473     }
65474     if( (pOp->opflags & OPFLG_IN3)!=0 ){
65475       assert( pOp->p3>0 );
65476       assert( pOp->p3<=p->nMem );
65477       assert( memIsValid(&aMem[pOp->p3]) );
65478       REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
65479     }
65480     if( (pOp->opflags & OPFLG_OUT2)!=0 ){
65481       assert( pOp->p2>0 );
65482       assert( pOp->p2<=p->nMem );
65483       memAboutToChange(p, &aMem[pOp->p2]);
65484     }
65485     if( (pOp->opflags & OPFLG_OUT3)!=0 ){
65486       assert( pOp->p3>0 );
65487       assert( pOp->p3<=p->nMem );
65488       memAboutToChange(p, &aMem[pOp->p3]);
65489     }
65490 #endif
65491   
65492     switch( pOp->opcode ){
65493
65494 /*****************************************************************************
65495 ** What follows is a massive switch statement where each case implements a
65496 ** separate instruction in the virtual machine.  If we follow the usual
65497 ** indentation conventions, each case should be indented by 6 spaces.  But
65498 ** that is a lot of wasted space on the left margin.  So the code within
65499 ** the switch statement will break with convention and be flush-left. Another
65500 ** big comment (similar to this one) will mark the point in the code where
65501 ** we transition back to normal indentation.
65502 **
65503 ** The formatting of each case is important.  The makefile for SQLite
65504 ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
65505 ** file looking for lines that begin with "case OP_".  The opcodes.h files
65506 ** will be filled with #defines that give unique integer values to each
65507 ** opcode and the opcodes.c file is filled with an array of strings where
65508 ** each string is the symbolic name for the corresponding opcode.  If the
65509 ** case statement is followed by a comment of the form "/# same as ... #/"
65510 ** that comment is used to determine the particular value of the opcode.
65511 **
65512 ** Other keywords in the comment that follows each case are used to
65513 ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
65514 ** Keywords include: in1, in2, in3, out2_prerelease, out2, out3.  See
65515 ** the mkopcodeh.awk script for additional information.
65516 **
65517 ** Documentation about VDBE opcodes is generated by scanning this file
65518 ** for lines of that contain "Opcode:".  That line and all subsequent
65519 ** comment lines are used in the generation of the opcode.html documentation
65520 ** file.
65521 **
65522 ** SUMMARY:
65523 **
65524 **     Formatting is important to scripts that scan this file.
65525 **     Do not deviate from the formatting style currently in use.
65526 **
65527 *****************************************************************************/
65528
65529 /* Opcode:  Goto * P2 * * *
65530 **
65531 ** An unconditional jump to address P2.
65532 ** The next instruction executed will be 
65533 ** the one at index P2 from the beginning of
65534 ** the program.
65535 */
65536 case OP_Goto: {             /* jump */
65537   CHECK_FOR_INTERRUPT;
65538   pc = pOp->p2 - 1;
65539   break;
65540 }
65541
65542 /* Opcode:  Gosub P1 P2 * * *
65543 **
65544 ** Write the current address onto register P1
65545 ** and then jump to address P2.
65546 */
65547 case OP_Gosub: {            /* jump, in1 */
65548   pIn1 = &aMem[pOp->p1];
65549   assert( (pIn1->flags & MEM_Dyn)==0 );
65550   memAboutToChange(p, pIn1);
65551   pIn1->flags = MEM_Int;
65552   pIn1->u.i = pc;
65553   REGISTER_TRACE(pOp->p1, pIn1);
65554   pc = pOp->p2 - 1;
65555   break;
65556 }
65557
65558 /* Opcode:  Return P1 * * * *
65559 **
65560 ** Jump to the next instruction after the address in register P1.
65561 */
65562 case OP_Return: {           /* in1 */
65563   pIn1 = &aMem[pOp->p1];
65564   assert( pIn1->flags & MEM_Int );
65565   pc = (int)pIn1->u.i;
65566   break;
65567 }
65568
65569 /* Opcode:  Yield P1 * * * *
65570 **
65571 ** Swap the program counter with the value in register P1.
65572 */
65573 case OP_Yield: {            /* in1 */
65574 #if 0  /* local variables moved into u.aa */
65575   int pcDest;
65576 #endif /* local variables moved into u.aa */
65577   pIn1 = &aMem[pOp->p1];
65578   assert( (pIn1->flags & MEM_Dyn)==0 );
65579   pIn1->flags = MEM_Int;
65580   u.aa.pcDest = (int)pIn1->u.i;
65581   pIn1->u.i = pc;
65582   REGISTER_TRACE(pOp->p1, pIn1);
65583   pc = u.aa.pcDest;
65584   break;
65585 }
65586
65587 /* Opcode:  HaltIfNull  P1 P2 P3 P4 *
65588 **
65589 ** Check the value in register P3.  If it is NULL then Halt using
65590 ** parameter P1, P2, and P4 as if this were a Halt instruction.  If the
65591 ** value in register P3 is not NULL, then this routine is a no-op.
65592 */
65593 case OP_HaltIfNull: {      /* in3 */
65594   pIn3 = &aMem[pOp->p3];
65595   if( (pIn3->flags & MEM_Null)==0 ) break;
65596   /* Fall through into OP_Halt */
65597 }
65598
65599 /* Opcode:  Halt P1 P2 * P4 *
65600 **
65601 ** Exit immediately.  All open cursors, etc are closed
65602 ** automatically.
65603 **
65604 ** P1 is the result code returned by sqlcipher3_exec(), sqlcipher3_reset(),
65605 ** or sqlcipher3_finalize().  For a normal halt, this should be SQLCIPHER_OK (0).
65606 ** For errors, it can be some other value.  If P1!=0 then P2 will determine
65607 ** whether or not to rollback the current transaction.  Do not rollback
65608 ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,
65609 ** then back out all changes that have occurred during this execution of the
65610 ** VDBE, but do not rollback the transaction. 
65611 **
65612 ** If P4 is not null then it is an error message string.
65613 **
65614 ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
65615 ** every program.  So a jump past the last instruction of the program
65616 ** is the same as executing Halt.
65617 */
65618 case OP_Halt: {
65619   if( pOp->p1==SQLCIPHER_OK && p->pFrame ){
65620     /* Halt the sub-program. Return control to the parent frame. */
65621     VdbeFrame *pFrame = p->pFrame;
65622     p->pFrame = pFrame->pParent;
65623     p->nFrame--;
65624     sqlcipher3VdbeSetChanges(db, p->nChange);
65625     pc = sqlcipher3VdbeFrameRestore(pFrame);
65626     lastRowid = db->lastRowid;
65627     if( pOp->p2==OE_Ignore ){
65628       /* Instruction pc is the OP_Program that invoked the sub-program 
65629       ** currently being halted. If the p2 instruction of this OP_Halt
65630       ** instruction is set to OE_Ignore, then the sub-program is throwing
65631       ** an IGNORE exception. In this case jump to the address specified
65632       ** as the p2 of the calling OP_Program.  */
65633       pc = p->aOp[pc].p2-1;
65634     }
65635     aOp = p->aOp;
65636     aMem = p->aMem;
65637     break;
65638   }
65639
65640   p->rc = pOp->p1;
65641   p->errorAction = (u8)pOp->p2;
65642   p->pc = pc;
65643   if( pOp->p4.z ){
65644     assert( p->rc!=SQLCIPHER_OK );
65645     sqlcipher3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
65646     testcase( sqlcipher3GlobalConfig.xLog!=0 );
65647     sqlcipher3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
65648   }else if( p->rc ){
65649     testcase( sqlcipher3GlobalConfig.xLog!=0 );
65650     sqlcipher3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
65651   }
65652   rc = sqlcipher3VdbeHalt(p);
65653   assert( rc==SQLCIPHER_BUSY || rc==SQLCIPHER_OK || rc==SQLCIPHER_ERROR );
65654   if( rc==SQLCIPHER_BUSY ){
65655     p->rc = rc = SQLCIPHER_BUSY;
65656   }else{
65657     assert( rc==SQLCIPHER_OK || p->rc==SQLCIPHER_CONSTRAINT );
65658     assert( rc==SQLCIPHER_OK || db->nDeferredCons>0 );
65659     rc = p->rc ? SQLCIPHER_ERROR : SQLCIPHER_DONE;
65660   }
65661   goto vdbe_return;
65662 }
65663
65664 /* Opcode: Integer P1 P2 * * *
65665 **
65666 ** The 32-bit integer value P1 is written into register P2.
65667 */
65668 case OP_Integer: {         /* out2-prerelease */
65669   pOut->u.i = pOp->p1;
65670   break;
65671 }
65672
65673 /* Opcode: Int64 * P2 * P4 *
65674 **
65675 ** P4 is a pointer to a 64-bit integer value.
65676 ** Write that value into register P2.
65677 */
65678 case OP_Int64: {           /* out2-prerelease */
65679   assert( pOp->p4.pI64!=0 );
65680   pOut->u.i = *pOp->p4.pI64;
65681   break;
65682 }
65683
65684 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
65685 /* Opcode: Real * P2 * P4 *
65686 **
65687 ** P4 is a pointer to a 64-bit floating point value.
65688 ** Write that value into register P2.
65689 */
65690 case OP_Real: {            /* same as TK_FLOAT, out2-prerelease */
65691   pOut->flags = MEM_Real;
65692   assert( !sqlcipher3IsNaN(*pOp->p4.pReal) );
65693   pOut->r = *pOp->p4.pReal;
65694   break;
65695 }
65696 #endif
65697
65698 /* Opcode: String8 * P2 * P4 *
65699 **
65700 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed 
65701 ** into an OP_String before it is executed for the first time.
65702 */
65703 case OP_String8: {         /* same as TK_STRING, out2-prerelease */
65704   assert( pOp->p4.z!=0 );
65705   pOp->opcode = OP_String;
65706   pOp->p1 = sqlcipher3Strlen30(pOp->p4.z);
65707
65708 #ifndef SQLCIPHER_OMIT_UTF16
65709   if( encoding!=SQLCIPHER_UTF8 ){
65710     rc = sqlcipher3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLCIPHER_UTF8, SQLCIPHER_STATIC);
65711     if( rc==SQLCIPHER_TOOBIG ) goto too_big;
65712     if( SQLCIPHER_OK!=sqlcipher3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
65713     assert( pOut->zMalloc==pOut->z );
65714     assert( pOut->flags & MEM_Dyn );
65715     pOut->zMalloc = 0;
65716     pOut->flags |= MEM_Static;
65717     pOut->flags &= ~MEM_Dyn;
65718     if( pOp->p4type==P4_DYNAMIC ){
65719       sqlcipher3DbFree(db, pOp->p4.z);
65720     }
65721     pOp->p4type = P4_DYNAMIC;
65722     pOp->p4.z = pOut->z;
65723     pOp->p1 = pOut->n;
65724   }
65725 #endif
65726   if( pOp->p1>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
65727     goto too_big;
65728   }
65729   /* Fall through to the next case, OP_String */
65730 }
65731   
65732 /* Opcode: String P1 P2 * P4 *
65733 **
65734 ** The string value P4 of length P1 (bytes) is stored in register P2.
65735 */
65736 case OP_String: {          /* out2-prerelease */
65737   assert( pOp->p4.z!=0 );
65738   pOut->flags = MEM_Str|MEM_Static|MEM_Term;
65739   pOut->z = pOp->p4.z;
65740   pOut->n = pOp->p1;
65741   pOut->enc = encoding;
65742   UPDATE_MAX_BLOBSIZE(pOut);
65743   break;
65744 }
65745
65746 /* Opcode: Null * P2 * * *
65747 **
65748 ** Write a NULL into register P2.
65749 */
65750 case OP_Null: {           /* out2-prerelease */
65751   pOut->flags = MEM_Null;
65752   break;
65753 }
65754
65755
65756 /* Opcode: Blob P1 P2 * P4
65757 **
65758 ** P4 points to a blob of data P1 bytes long.  Store this
65759 ** blob in register P2.
65760 */
65761 case OP_Blob: {                /* out2-prerelease */
65762   assert( pOp->p1 <= SQLCIPHER_MAX_LENGTH );
65763   sqlcipher3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
65764   pOut->enc = encoding;
65765   UPDATE_MAX_BLOBSIZE(pOut);
65766   break;
65767 }
65768
65769 /* Opcode: Variable P1 P2 * P4 *
65770 **
65771 ** Transfer the values of bound parameter P1 into register P2
65772 **
65773 ** If the parameter is named, then its name appears in P4 and P3==1.
65774 ** The P4 value is used by sqlcipher3_bind_parameter_name().
65775 */
65776 case OP_Variable: {            /* out2-prerelease */
65777 #if 0  /* local variables moved into u.ab */
65778   Mem *pVar;       /* Value being transferred */
65779 #endif /* local variables moved into u.ab */
65780
65781   assert( pOp->p1>0 && pOp->p1<=p->nVar );
65782   assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
65783   u.ab.pVar = &p->aVar[pOp->p1 - 1];
65784   if( sqlcipher3VdbeMemTooBig(u.ab.pVar) ){
65785     goto too_big;
65786   }
65787   sqlcipher3VdbeMemShallowCopy(pOut, u.ab.pVar, MEM_Static);
65788   UPDATE_MAX_BLOBSIZE(pOut);
65789   break;
65790 }
65791
65792 /* Opcode: Move P1 P2 P3 * *
65793 **
65794 ** Move the values in register P1..P1+P3-1 over into
65795 ** registers P2..P2+P3-1.  Registers P1..P1+P1-1 are
65796 ** left holding a NULL.  It is an error for register ranges
65797 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
65798 */
65799 case OP_Move: {
65800 #if 0  /* local variables moved into u.ac */
65801   char *zMalloc;   /* Holding variable for allocated memory */
65802   int n;           /* Number of registers left to copy */
65803   int p1;          /* Register to copy from */
65804   int p2;          /* Register to copy to */
65805 #endif /* local variables moved into u.ac */
65806
65807   u.ac.n = pOp->p3;
65808   u.ac.p1 = pOp->p1;
65809   u.ac.p2 = pOp->p2;
65810   assert( u.ac.n>0 && u.ac.p1>0 && u.ac.p2>0 );
65811   assert( u.ac.p1+u.ac.n<=u.ac.p2 || u.ac.p2+u.ac.n<=u.ac.p1 );
65812
65813   pIn1 = &aMem[u.ac.p1];
65814   pOut = &aMem[u.ac.p2];
65815   while( u.ac.n-- ){
65816     assert( pOut<=&aMem[p->nMem] );
65817     assert( pIn1<=&aMem[p->nMem] );
65818     assert( memIsValid(pIn1) );
65819     memAboutToChange(p, pOut);
65820     u.ac.zMalloc = pOut->zMalloc;
65821     pOut->zMalloc = 0;
65822     sqlcipher3VdbeMemMove(pOut, pIn1);
65823 #ifdef SQLCIPHER_DEBUG
65824     if( pOut->pScopyFrom>=&aMem[u.ac.p1] && pOut->pScopyFrom<&aMem[u.ac.p1+pOp->p3] ){
65825       pOut->pScopyFrom += u.ac.p1 - pOp->p2;
65826     }
65827 #endif
65828     pIn1->zMalloc = u.ac.zMalloc;
65829     REGISTER_TRACE(u.ac.p2++, pOut);
65830     pIn1++;
65831     pOut++;
65832   }
65833   break;
65834 }
65835
65836 /* Opcode: Copy P1 P2 * * *
65837 **
65838 ** Make a copy of register P1 into register P2.
65839 **
65840 ** This instruction makes a deep copy of the value.  A duplicate
65841 ** is made of any string or blob constant.  See also OP_SCopy.
65842 */
65843 case OP_Copy: {             /* in1, out2 */
65844   pIn1 = &aMem[pOp->p1];
65845   pOut = &aMem[pOp->p2];
65846   assert( pOut!=pIn1 );
65847   sqlcipher3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
65848   Deephemeralize(pOut);
65849   REGISTER_TRACE(pOp->p2, pOut);
65850   break;
65851 }
65852
65853 /* Opcode: SCopy P1 P2 * * *
65854 **
65855 ** Make a shallow copy of register P1 into register P2.
65856 **
65857 ** This instruction makes a shallow copy of the value.  If the value
65858 ** is a string or blob, then the copy is only a pointer to the
65859 ** original and hence if the original changes so will the copy.
65860 ** Worse, if the original is deallocated, the copy becomes invalid.
65861 ** Thus the program must guarantee that the original will not change
65862 ** during the lifetime of the copy.  Use OP_Copy to make a complete
65863 ** copy.
65864 */
65865 case OP_SCopy: {            /* in1, out2 */
65866   pIn1 = &aMem[pOp->p1];
65867   pOut = &aMem[pOp->p2];
65868   assert( pOut!=pIn1 );
65869   sqlcipher3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
65870 #ifdef SQLCIPHER_DEBUG
65871   if( pOut->pScopyFrom==0 ) pOut->pScopyFrom = pIn1;
65872 #endif
65873   REGISTER_TRACE(pOp->p2, pOut);
65874   break;
65875 }
65876
65877 /* Opcode: ResultRow P1 P2 * * *
65878 **
65879 ** The registers P1 through P1+P2-1 contain a single row of
65880 ** results. This opcode causes the sqlcipher3_step() call to terminate
65881 ** with an SQLCIPHER_ROW return code and it sets up the sqlcipher3_stmt
65882 ** structure to provide access to the top P1 values as the result
65883 ** row.
65884 */
65885 case OP_ResultRow: {
65886 #if 0  /* local variables moved into u.ad */
65887   Mem *pMem;
65888   int i;
65889 #endif /* local variables moved into u.ad */
65890   assert( p->nResColumn==pOp->p2 );
65891   assert( pOp->p1>0 );
65892   assert( pOp->p1+pOp->p2<=p->nMem+1 );
65893
65894   /* If this statement has violated immediate foreign key constraints, do
65895   ** not return the number of rows modified. And do not RELEASE the statement
65896   ** transaction. It needs to be rolled back.  */
65897   if( SQLCIPHER_OK!=(rc = sqlcipher3VdbeCheckFk(p, 0)) ){
65898     assert( db->flags&SQLCIPHER_CountRows );
65899     assert( p->usesStmtJournal );
65900     break;
65901   }
65902
65903   /* If the SQLCIPHER_CountRows flag is set in sqlcipher3.flags mask, then
65904   ** DML statements invoke this opcode to return the number of rows
65905   ** modified to the user. This is the only way that a VM that
65906   ** opens a statement transaction may invoke this opcode.
65907   **
65908   ** In case this is such a statement, close any statement transaction
65909   ** opened by this VM before returning control to the user. This is to
65910   ** ensure that statement-transactions are always nested, not overlapping.
65911   ** If the open statement-transaction is not closed here, then the user
65912   ** may step another VM that opens its own statement transaction. This
65913   ** may lead to overlapping statement transactions.
65914   **
65915   ** The statement transaction is never a top-level transaction.  Hence
65916   ** the RELEASE call below can never fail.
65917   */
65918   assert( p->iStatement==0 || db->flags&SQLCIPHER_CountRows );
65919   rc = sqlcipher3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
65920   if( NEVER(rc!=SQLCIPHER_OK) ){
65921     break;
65922   }
65923
65924   /* Invalidate all ephemeral cursor row caches */
65925   p->cacheCtr = (p->cacheCtr + 2)|1;
65926
65927   /* Make sure the results of the current row are \000 terminated
65928   ** and have an assigned type.  The results are de-ephemeralized as
65929   ** as side effect.
65930   */
65931   u.ad.pMem = p->pResultSet = &aMem[pOp->p1];
65932   for(u.ad.i=0; u.ad.i<pOp->p2; u.ad.i++){
65933     assert( memIsValid(&u.ad.pMem[u.ad.i]) );
65934     Deephemeralize(&u.ad.pMem[u.ad.i]);
65935     assert( (u.ad.pMem[u.ad.i].flags & MEM_Ephem)==0
65936             || (u.ad.pMem[u.ad.i].flags & (MEM_Str|MEM_Blob))==0 );
65937     sqlcipher3VdbeMemNulTerminate(&u.ad.pMem[u.ad.i]);
65938     sqlcipher3VdbeMemStoreType(&u.ad.pMem[u.ad.i]);
65939     REGISTER_TRACE(pOp->p1+u.ad.i, &u.ad.pMem[u.ad.i]);
65940   }
65941   if( db->mallocFailed ) goto no_mem;
65942
65943   /* Return SQLCIPHER_ROW
65944   */
65945   p->pc = pc + 1;
65946   rc = SQLCIPHER_ROW;
65947   goto vdbe_return;
65948 }
65949
65950 /* Opcode: Concat P1 P2 P3 * *
65951 **
65952 ** Add the text in register P1 onto the end of the text in
65953 ** register P2 and store the result in register P3.
65954 ** If either the P1 or P2 text are NULL then store NULL in P3.
65955 **
65956 **   P3 = P2 || P1
65957 **
65958 ** It is illegal for P1 and P3 to be the same register. Sometimes,
65959 ** if P3 is the same register as P2, the implementation is able
65960 ** to avoid a memcpy().
65961 */
65962 case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
65963 #if 0  /* local variables moved into u.ae */
65964   i64 nByte;
65965 #endif /* local variables moved into u.ae */
65966
65967   pIn1 = &aMem[pOp->p1];
65968   pIn2 = &aMem[pOp->p2];
65969   pOut = &aMem[pOp->p3];
65970   assert( pIn1!=pOut );
65971   if( (pIn1->flags | pIn2->flags) & MEM_Null ){
65972     sqlcipher3VdbeMemSetNull(pOut);
65973     break;
65974   }
65975   if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem;
65976   Stringify(pIn1, encoding);
65977   Stringify(pIn2, encoding);
65978   u.ae.nByte = pIn1->n + pIn2->n;
65979   if( u.ae.nByte>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
65980     goto too_big;
65981   }
65982   MemSetTypeFlag(pOut, MEM_Str);
65983   if( sqlcipher3VdbeMemGrow(pOut, (int)u.ae.nByte+2, pOut==pIn2) ){
65984     goto no_mem;
65985   }
65986   if( pOut!=pIn2 ){
65987     memcpy(pOut->z, pIn2->z, pIn2->n);
65988   }
65989   memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
65990   pOut->z[u.ae.nByte] = 0;
65991   pOut->z[u.ae.nByte+1] = 0;
65992   pOut->flags |= MEM_Term;
65993   pOut->n = (int)u.ae.nByte;
65994   pOut->enc = encoding;
65995   UPDATE_MAX_BLOBSIZE(pOut);
65996   break;
65997 }
65998
65999 /* Opcode: Add P1 P2 P3 * *
66000 **
66001 ** Add the value in register P1 to the value in register P2
66002 ** and store the result in register P3.
66003 ** If either input is NULL, the result is NULL.
66004 */
66005 /* Opcode: Multiply P1 P2 P3 * *
66006 **
66007 **
66008 ** Multiply the value in register P1 by the value in register P2
66009 ** and store the result in register P3.
66010 ** If either input is NULL, the result is NULL.
66011 */
66012 /* Opcode: Subtract P1 P2 P3 * *
66013 **
66014 ** Subtract the value in register P1 from the value in register P2
66015 ** and store the result in register P3.
66016 ** If either input is NULL, the result is NULL.
66017 */
66018 /* Opcode: Divide P1 P2 P3 * *
66019 **
66020 ** Divide the value in register P1 by the value in register P2
66021 ** and store the result in register P3 (P3=P2/P1). If the value in 
66022 ** register P1 is zero, then the result is NULL. If either input is 
66023 ** NULL, the result is NULL.
66024 */
66025 /* Opcode: Remainder P1 P2 P3 * *
66026 **
66027 ** Compute the remainder after integer division of the value in
66028 ** register P1 by the value in register P2 and store the result in P3. 
66029 ** If the value in register P2 is zero the result is NULL.
66030 ** If either operand is NULL, the result is NULL.
66031 */
66032 case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */
66033 case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */
66034 case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
66035 case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
66036 case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
66037 #if 0  /* local variables moved into u.af */
66038   int flags;      /* Combined MEM_* flags from both inputs */
66039   i64 iA;         /* Integer value of left operand */
66040   i64 iB;         /* Integer value of right operand */
66041   double rA;      /* Real value of left operand */
66042   double rB;      /* Real value of right operand */
66043 #endif /* local variables moved into u.af */
66044
66045   pIn1 = &aMem[pOp->p1];
66046   applyNumericAffinity(pIn1);
66047   pIn2 = &aMem[pOp->p2];
66048   applyNumericAffinity(pIn2);
66049   pOut = &aMem[pOp->p3];
66050   u.af.flags = pIn1->flags | pIn2->flags;
66051   if( (u.af.flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
66052   if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){
66053     u.af.iA = pIn1->u.i;
66054     u.af.iB = pIn2->u.i;
66055     switch( pOp->opcode ){
66056       case OP_Add:       if( sqlcipher3AddInt64(&u.af.iB,u.af.iA) ) goto fp_math;  break;
66057       case OP_Subtract:  if( sqlcipher3SubInt64(&u.af.iB,u.af.iA) ) goto fp_math;  break;
66058       case OP_Multiply:  if( sqlcipher3MulInt64(&u.af.iB,u.af.iA) ) goto fp_math;  break;
66059       case OP_Divide: {
66060         if( u.af.iA==0 ) goto arithmetic_result_is_null;
66061         if( u.af.iA==-1 && u.af.iB==SMALLEST_INT64 ) goto fp_math;
66062         u.af.iB /= u.af.iA;
66063         break;
66064       }
66065       default: {
66066         if( u.af.iA==0 ) goto arithmetic_result_is_null;
66067         if( u.af.iA==-1 ) u.af.iA = 1;
66068         u.af.iB %= u.af.iA;
66069         break;
66070       }
66071     }
66072     pOut->u.i = u.af.iB;
66073     MemSetTypeFlag(pOut, MEM_Int);
66074   }else{
66075 fp_math:
66076     u.af.rA = sqlcipher3VdbeRealValue(pIn1);
66077     u.af.rB = sqlcipher3VdbeRealValue(pIn2);
66078     switch( pOp->opcode ){
66079       case OP_Add:         u.af.rB += u.af.rA;       break;
66080       case OP_Subtract:    u.af.rB -= u.af.rA;       break;
66081       case OP_Multiply:    u.af.rB *= u.af.rA;       break;
66082       case OP_Divide: {
66083         /* (double)0 In case of SQLCIPHER_OMIT_FLOATING_POINT... */
66084         if( u.af.rA==(double)0 ) goto arithmetic_result_is_null;
66085         u.af.rB /= u.af.rA;
66086         break;
66087       }
66088       default: {
66089         u.af.iA = (i64)u.af.rA;
66090         u.af.iB = (i64)u.af.rB;
66091         if( u.af.iA==0 ) goto arithmetic_result_is_null;
66092         if( u.af.iA==-1 ) u.af.iA = 1;
66093         u.af.rB = (double)(u.af.iB % u.af.iA);
66094         break;
66095       }
66096     }
66097 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
66098     pOut->u.i = u.af.rB;
66099     MemSetTypeFlag(pOut, MEM_Int);
66100 #else
66101     if( sqlcipher3IsNaN(u.af.rB) ){
66102       goto arithmetic_result_is_null;
66103     }
66104     pOut->r = u.af.rB;
66105     MemSetTypeFlag(pOut, MEM_Real);
66106     if( (u.af.flags & MEM_Real)==0 ){
66107       sqlcipher3VdbeIntegerAffinity(pOut);
66108     }
66109 #endif
66110   }
66111   break;
66112
66113 arithmetic_result_is_null:
66114   sqlcipher3VdbeMemSetNull(pOut);
66115   break;
66116 }
66117
66118 /* Opcode: CollSeq * * P4
66119 **
66120 ** P4 is a pointer to a CollSeq struct. If the next call to a user function
66121 ** or aggregate calls sqlcipher3GetFuncCollSeq(), this collation sequence will
66122 ** be returned. This is used by the built-in min(), max() and nullif()
66123 ** functions.
66124 **
66125 ** The interface used by the implementation of the aforementioned functions
66126 ** to retrieve the collation sequence set by this opcode is not available
66127 ** publicly, only to user functions defined in func.c.
66128 */
66129 case OP_CollSeq: {
66130   assert( pOp->p4type==P4_COLLSEQ );
66131   break;
66132 }
66133
66134 /* Opcode: Function P1 P2 P3 P4 P5
66135 **
66136 ** Invoke a user function (P4 is a pointer to a Function structure that
66137 ** defines the function) with P5 arguments taken from register P2 and
66138 ** successors.  The result of the function is stored in register P3.
66139 ** Register P3 must not be one of the function inputs.
66140 **
66141 ** P1 is a 32-bit bitmask indicating whether or not each argument to the 
66142 ** function was determined to be constant at compile time. If the first
66143 ** argument was constant then bit 0 of P1 is set. This is used to determine
66144 ** whether meta data associated with a user function argument using the
66145 ** sqlcipher3_set_auxdata() API may be safely retained until the next
66146 ** invocation of this opcode.
66147 **
66148 ** See also: AggStep and AggFinal
66149 */
66150 case OP_Function: {
66151 #if 0  /* local variables moved into u.ag */
66152   int i;
66153   Mem *pArg;
66154   sqlcipher3_context ctx;
66155   sqlcipher3_value **apVal;
66156   int n;
66157 #endif /* local variables moved into u.ag */
66158
66159   u.ag.n = pOp->p5;
66160   u.ag.apVal = p->apArg;
66161   assert( u.ag.apVal || u.ag.n==0 );
66162   assert( pOp->p3>0 && pOp->p3<=p->nMem );
66163   pOut = &aMem[pOp->p3];
66164   memAboutToChange(p, pOut);
66165
66166   assert( u.ag.n==0 || (pOp->p2>0 && pOp->p2+u.ag.n<=p->nMem+1) );
66167   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+u.ag.n );
66168   u.ag.pArg = &aMem[pOp->p2];
66169   for(u.ag.i=0; u.ag.i<u.ag.n; u.ag.i++, u.ag.pArg++){
66170     assert( memIsValid(u.ag.pArg) );
66171     u.ag.apVal[u.ag.i] = u.ag.pArg;
66172     Deephemeralize(u.ag.pArg);
66173     sqlcipher3VdbeMemStoreType(u.ag.pArg);
66174     REGISTER_TRACE(pOp->p2+u.ag.i, u.ag.pArg);
66175   }
66176
66177   assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );
66178   if( pOp->p4type==P4_FUNCDEF ){
66179     u.ag.ctx.pFunc = pOp->p4.pFunc;
66180     u.ag.ctx.pVdbeFunc = 0;
66181   }else{
66182     u.ag.ctx.pVdbeFunc = (VdbeFunc*)pOp->p4.pVdbeFunc;
66183     u.ag.ctx.pFunc = u.ag.ctx.pVdbeFunc->pFunc;
66184   }
66185
66186   u.ag.ctx.s.flags = MEM_Null;
66187   u.ag.ctx.s.db = db;
66188   u.ag.ctx.s.xDel = 0;
66189   u.ag.ctx.s.zMalloc = 0;
66190
66191   /* The output cell may already have a buffer allocated. Move
66192   ** the pointer to u.ag.ctx.s so in case the user-function can use
66193   ** the already allocated buffer instead of allocating a new one.
66194   */
66195   sqlcipher3VdbeMemMove(&u.ag.ctx.s, pOut);
66196   MemSetTypeFlag(&u.ag.ctx.s, MEM_Null);
66197
66198   u.ag.ctx.isError = 0;
66199   if( u.ag.ctx.pFunc->flags & SQLCIPHER_FUNC_NEEDCOLL ){
66200     assert( pOp>aOp );
66201     assert( pOp[-1].p4type==P4_COLLSEQ );
66202     assert( pOp[-1].opcode==OP_CollSeq );
66203     u.ag.ctx.pColl = pOp[-1].p4.pColl;
66204   }
66205   db->lastRowid = lastRowid;
66206   (*u.ag.ctx.pFunc->xFunc)(&u.ag.ctx, u.ag.n, u.ag.apVal); /* IMP: R-24505-23230 */
66207   lastRowid = db->lastRowid;
66208
66209   /* If any auxiliary data functions have been called by this user function,
66210   ** immediately call the destructor for any non-static values.
66211   */
66212   if( u.ag.ctx.pVdbeFunc ){
66213     sqlcipher3VdbeDeleteAuxData(u.ag.ctx.pVdbeFunc, pOp->p1);
66214     pOp->p4.pVdbeFunc = u.ag.ctx.pVdbeFunc;
66215     pOp->p4type = P4_VDBEFUNC;
66216   }
66217
66218   if( db->mallocFailed ){
66219     /* Even though a malloc() has failed, the implementation of the
66220     ** user function may have called an sqlcipher3_result_XXX() function
66221     ** to return a value. The following call releases any resources
66222     ** associated with such a value.
66223     */
66224     sqlcipher3VdbeMemRelease(&u.ag.ctx.s);
66225     goto no_mem;
66226   }
66227
66228   /* If the function returned an error, throw an exception */
66229   if( u.ag.ctx.isError ){
66230     sqlcipher3SetString(&p->zErrMsg, db, "%s", sqlcipher3_value_text(&u.ag.ctx.s));
66231     rc = u.ag.ctx.isError;
66232   }
66233
66234   /* Copy the result of the function into register P3 */
66235   sqlcipher3VdbeChangeEncoding(&u.ag.ctx.s, encoding);
66236   sqlcipher3VdbeMemMove(pOut, &u.ag.ctx.s);
66237   if( sqlcipher3VdbeMemTooBig(pOut) ){
66238     goto too_big;
66239   }
66240
66241 #if 0
66242   /* The app-defined function has done something that as caused this
66243   ** statement to expire.  (Perhaps the function called sqlcipher3_exec()
66244   ** with a CREATE TABLE statement.)
66245   */
66246   if( p->expired ) rc = SQLCIPHER_ABORT;
66247 #endif
66248
66249   REGISTER_TRACE(pOp->p3, pOut);
66250   UPDATE_MAX_BLOBSIZE(pOut);
66251   break;
66252 }
66253
66254 /* Opcode: BitAnd P1 P2 P3 * *
66255 **
66256 ** Take the bit-wise AND of the values in register P1 and P2 and
66257 ** store the result in register P3.
66258 ** If either input is NULL, the result is NULL.
66259 */
66260 /* Opcode: BitOr P1 P2 P3 * *
66261 **
66262 ** Take the bit-wise OR of the values in register P1 and P2 and
66263 ** store the result in register P3.
66264 ** If either input is NULL, the result is NULL.
66265 */
66266 /* Opcode: ShiftLeft P1 P2 P3 * *
66267 **
66268 ** Shift the integer value in register P2 to the left by the
66269 ** number of bits specified by the integer in register P1.
66270 ** Store the result in register P3.
66271 ** If either input is NULL, the result is NULL.
66272 */
66273 /* Opcode: ShiftRight P1 P2 P3 * *
66274 **
66275 ** Shift the integer value in register P2 to the right by the
66276 ** number of bits specified by the integer in register P1.
66277 ** Store the result in register P3.
66278 ** If either input is NULL, the result is NULL.
66279 */
66280 case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */
66281 case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
66282 case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
66283 case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
66284 #if 0  /* local variables moved into u.ah */
66285   i64 iA;
66286   u64 uA;
66287   i64 iB;
66288   u8 op;
66289 #endif /* local variables moved into u.ah */
66290
66291   pIn1 = &aMem[pOp->p1];
66292   pIn2 = &aMem[pOp->p2];
66293   pOut = &aMem[pOp->p3];
66294   if( (pIn1->flags | pIn2->flags) & MEM_Null ){
66295     sqlcipher3VdbeMemSetNull(pOut);
66296     break;
66297   }
66298   u.ah.iA = sqlcipher3VdbeIntValue(pIn2);
66299   u.ah.iB = sqlcipher3VdbeIntValue(pIn1);
66300   u.ah.op = pOp->opcode;
66301   if( u.ah.op==OP_BitAnd ){
66302     u.ah.iA &= u.ah.iB;
66303   }else if( u.ah.op==OP_BitOr ){
66304     u.ah.iA |= u.ah.iB;
66305   }else if( u.ah.iB!=0 ){
66306     assert( u.ah.op==OP_ShiftRight || u.ah.op==OP_ShiftLeft );
66307
66308     /* If shifting by a negative amount, shift in the other direction */
66309     if( u.ah.iB<0 ){
66310       assert( OP_ShiftRight==OP_ShiftLeft+1 );
66311       u.ah.op = 2*OP_ShiftLeft + 1 - u.ah.op;
66312       u.ah.iB = u.ah.iB>(-64) ? -u.ah.iB : 64;
66313     }
66314
66315     if( u.ah.iB>=64 ){
66316       u.ah.iA = (u.ah.iA>=0 || u.ah.op==OP_ShiftLeft) ? 0 : -1;
66317     }else{
66318       memcpy(&u.ah.uA, &u.ah.iA, sizeof(u.ah.uA));
66319       if( u.ah.op==OP_ShiftLeft ){
66320         u.ah.uA <<= u.ah.iB;
66321       }else{
66322         u.ah.uA >>= u.ah.iB;
66323         /* Sign-extend on a right shift of a negative number */
66324         if( u.ah.iA<0 ) u.ah.uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-u.ah.iB);
66325       }
66326       memcpy(&u.ah.iA, &u.ah.uA, sizeof(u.ah.iA));
66327     }
66328   }
66329   pOut->u.i = u.ah.iA;
66330   MemSetTypeFlag(pOut, MEM_Int);
66331   break;
66332 }
66333
66334 /* Opcode: AddImm  P1 P2 * * *
66335 ** 
66336 ** Add the constant P2 to the value in register P1.
66337 ** The result is always an integer.
66338 **
66339 ** To force any register to be an integer, just add 0.
66340 */
66341 case OP_AddImm: {            /* in1 */
66342   pIn1 = &aMem[pOp->p1];
66343   memAboutToChange(p, pIn1);
66344   sqlcipher3VdbeMemIntegerify(pIn1);
66345   pIn1->u.i += pOp->p2;
66346   break;
66347 }
66348
66349 /* Opcode: MustBeInt P1 P2 * * *
66350 ** 
66351 ** Force the value in register P1 to be an integer.  If the value
66352 ** in P1 is not an integer and cannot be converted into an integer
66353 ** without data loss, then jump immediately to P2, or if P2==0
66354 ** raise an SQLCIPHER_MISMATCH exception.
66355 */
66356 case OP_MustBeInt: {            /* jump, in1 */
66357   pIn1 = &aMem[pOp->p1];
66358   applyAffinity(pIn1, SQLCIPHER_AFF_NUMERIC, encoding);
66359   if( (pIn1->flags & MEM_Int)==0 ){
66360     if( pOp->p2==0 ){
66361       rc = SQLCIPHER_MISMATCH;
66362       goto abort_due_to_error;
66363     }else{
66364       pc = pOp->p2 - 1;
66365     }
66366   }else{
66367     MemSetTypeFlag(pIn1, MEM_Int);
66368   }
66369   break;
66370 }
66371
66372 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
66373 /* Opcode: RealAffinity P1 * * * *
66374 **
66375 ** If register P1 holds an integer convert it to a real value.
66376 **
66377 ** This opcode is used when extracting information from a column that
66378 ** has REAL affinity.  Such column values may still be stored as
66379 ** integers, for space efficiency, but after extraction we want them
66380 ** to have only a real value.
66381 */
66382 case OP_RealAffinity: {                  /* in1 */
66383   pIn1 = &aMem[pOp->p1];
66384   if( pIn1->flags & MEM_Int ){
66385     sqlcipher3VdbeMemRealify(pIn1);
66386   }
66387   break;
66388 }
66389 #endif
66390
66391 #ifndef SQLCIPHER_OMIT_CAST
66392 /* Opcode: ToText P1 * * * *
66393 **
66394 ** Force the value in register P1 to be text.
66395 ** If the value is numeric, convert it to a string using the
66396 ** equivalent of printf().  Blob values are unchanged and
66397 ** are afterwards simply interpreted as text.
66398 **
66399 ** A NULL value is not changed by this routine.  It remains NULL.
66400 */
66401 case OP_ToText: {                  /* same as TK_TO_TEXT, in1 */
66402   pIn1 = &aMem[pOp->p1];
66403   memAboutToChange(p, pIn1);
66404   if( pIn1->flags & MEM_Null ) break;
66405   assert( MEM_Str==(MEM_Blob>>3) );
66406   pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;
66407   applyAffinity(pIn1, SQLCIPHER_AFF_TEXT, encoding);
66408   rc = ExpandBlob(pIn1);
66409   assert( pIn1->flags & MEM_Str || db->mallocFailed );
66410   pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero);
66411   UPDATE_MAX_BLOBSIZE(pIn1);
66412   break;
66413 }
66414
66415 /* Opcode: ToBlob P1 * * * *
66416 **
66417 ** Force the value in register P1 to be a BLOB.
66418 ** If the value is numeric, convert it to a string first.
66419 ** Strings are simply reinterpreted as blobs with no change
66420 ** to the underlying data.
66421 **
66422 ** A NULL value is not changed by this routine.  It remains NULL.
66423 */
66424 case OP_ToBlob: {                  /* same as TK_TO_BLOB, in1 */
66425   pIn1 = &aMem[pOp->p1];
66426   if( pIn1->flags & MEM_Null ) break;
66427   if( (pIn1->flags & MEM_Blob)==0 ){
66428     applyAffinity(pIn1, SQLCIPHER_AFF_TEXT, encoding);
66429     assert( pIn1->flags & MEM_Str || db->mallocFailed );
66430     MemSetTypeFlag(pIn1, MEM_Blob);
66431   }else{
66432     pIn1->flags &= ~(MEM_TypeMask&~MEM_Blob);
66433   }
66434   UPDATE_MAX_BLOBSIZE(pIn1);
66435   break;
66436 }
66437
66438 /* Opcode: ToNumeric P1 * * * *
66439 **
66440 ** Force the value in register P1 to be numeric (either an
66441 ** integer or a floating-point number.)
66442 ** If the value is text or blob, try to convert it to an using the
66443 ** equivalent of atoi() or atof() and store 0 if no such conversion 
66444 ** is possible.
66445 **
66446 ** A NULL value is not changed by this routine.  It remains NULL.
66447 */
66448 case OP_ToNumeric: {                  /* same as TK_TO_NUMERIC, in1 */
66449   pIn1 = &aMem[pOp->p1];
66450   sqlcipher3VdbeMemNumerify(pIn1);
66451   break;
66452 }
66453 #endif /* SQLCIPHER_OMIT_CAST */
66454
66455 /* Opcode: ToInt P1 * * * *
66456 **
66457 ** Force the value in register P1 to be an integer.  If
66458 ** The value is currently a real number, drop its fractional part.
66459 ** If the value is text or blob, try to convert it to an integer using the
66460 ** equivalent of atoi() and store 0 if no such conversion is possible.
66461 **
66462 ** A NULL value is not changed by this routine.  It remains NULL.
66463 */
66464 case OP_ToInt: {                  /* same as TK_TO_INT, in1 */
66465   pIn1 = &aMem[pOp->p1];
66466   if( (pIn1->flags & MEM_Null)==0 ){
66467     sqlcipher3VdbeMemIntegerify(pIn1);
66468   }
66469   break;
66470 }
66471
66472 #if !defined(SQLCIPHER_OMIT_CAST) && !defined(SQLCIPHER_OMIT_FLOATING_POINT)
66473 /* Opcode: ToReal P1 * * * *
66474 **
66475 ** Force the value in register P1 to be a floating point number.
66476 ** If The value is currently an integer, convert it.
66477 ** If the value is text or blob, try to convert it to an integer using the
66478 ** equivalent of atoi() and store 0.0 if no such conversion is possible.
66479 **
66480 ** A NULL value is not changed by this routine.  It remains NULL.
66481 */
66482 case OP_ToReal: {                  /* same as TK_TO_REAL, in1 */
66483   pIn1 = &aMem[pOp->p1];
66484   memAboutToChange(p, pIn1);
66485   if( (pIn1->flags & MEM_Null)==0 ){
66486     sqlcipher3VdbeMemRealify(pIn1);
66487   }
66488   break;
66489 }
66490 #endif /* !defined(SQLCIPHER_OMIT_CAST) && !defined(SQLCIPHER_OMIT_FLOATING_POINT) */
66491
66492 /* Opcode: Lt P1 P2 P3 P4 P5
66493 **
66494 ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
66495 ** jump to address P2.  
66496 **
66497 ** If the SQLCIPHER_JUMPIFNULL bit of P5 is set and either reg(P1) or
66498 ** reg(P3) is NULL then take the jump.  If the SQLCIPHER_JUMPIFNULL 
66499 ** bit is clear then fall through if either operand is NULL.
66500 **
66501 ** The SQLCIPHER_AFF_MASK portion of P5 must be an affinity character -
66502 ** SQLCIPHER_AFF_TEXT, SQLCIPHER_AFF_INTEGER, and so forth. An attempt is made 
66503 ** to coerce both inputs according to this affinity before the
66504 ** comparison is made. If the SQLCIPHER_AFF_MASK is 0x00, then numeric
66505 ** affinity is used. Note that the affinity conversions are stored
66506 ** back into the input registers P1 and P3.  So this opcode can cause
66507 ** persistent changes to registers P1 and P3.
66508 **
66509 ** Once any conversions have taken place, and neither value is NULL, 
66510 ** the values are compared. If both values are blobs then memcmp() is
66511 ** used to determine the results of the comparison.  If both values
66512 ** are text, then the appropriate collating function specified in
66513 ** P4 is  used to do the comparison.  If P4 is not specified then
66514 ** memcmp() is used to compare text string.  If both values are
66515 ** numeric, then a numeric comparison is used. If the two values
66516 ** are of different types, then numbers are considered less than
66517 ** strings and strings are considered less than blobs.
66518 **
66519 ** If the SQLCIPHER_STOREP2 bit of P5 is set, then do not jump.  Instead,
66520 ** store a boolean result (either 0, or 1, or NULL) in register P2.
66521 */
66522 /* Opcode: Ne P1 P2 P3 P4 P5
66523 **
66524 ** This works just like the Lt opcode except that the jump is taken if
66525 ** the operands in registers P1 and P3 are not equal.  See the Lt opcode for
66526 ** additional information.
66527 **
66528 ** If SQLCIPHER_NULLEQ is set in P5 then the result of comparison is always either
66529 ** true or false and is never NULL.  If both operands are NULL then the result
66530 ** of comparison is false.  If either operand is NULL then the result is true.
66531 ** If neither operand is NULL the result is the same as it would be if
66532 ** the SQLCIPHER_NULLEQ flag were omitted from P5.
66533 */
66534 /* Opcode: Eq P1 P2 P3 P4 P5
66535 **
66536 ** This works just like the Lt opcode except that the jump is taken if
66537 ** the operands in registers P1 and P3 are equal.
66538 ** See the Lt opcode for additional information.
66539 **
66540 ** If SQLCIPHER_NULLEQ is set in P5 then the result of comparison is always either
66541 ** true or false and is never NULL.  If both operands are NULL then the result
66542 ** of comparison is true.  If either operand is NULL then the result is false.
66543 ** If neither operand is NULL the result is the same as it would be if
66544 ** the SQLCIPHER_NULLEQ flag were omitted from P5.
66545 */
66546 /* Opcode: Le P1 P2 P3 P4 P5
66547 **
66548 ** This works just like the Lt opcode except that the jump is taken if
66549 ** the content of register P3 is less than or equal to the content of
66550 ** register P1.  See the Lt opcode for additional information.
66551 */
66552 /* Opcode: Gt P1 P2 P3 P4 P5
66553 **
66554 ** This works just like the Lt opcode except that the jump is taken if
66555 ** the content of register P3 is greater than the content of
66556 ** register P1.  See the Lt opcode for additional information.
66557 */
66558 /* Opcode: Ge P1 P2 P3 P4 P5
66559 **
66560 ** This works just like the Lt opcode except that the jump is taken if
66561 ** the content of register P3 is greater than or equal to the content of
66562 ** register P1.  See the Lt opcode for additional information.
66563 */
66564 case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */
66565 case OP_Ne:               /* same as TK_NE, jump, in1, in3 */
66566 case OP_Lt:               /* same as TK_LT, jump, in1, in3 */
66567 case OP_Le:               /* same as TK_LE, jump, in1, in3 */
66568 case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
66569 case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
66570 #if 0  /* local variables moved into u.ai */
66571   int res;            /* Result of the comparison of pIn1 against pIn3 */
66572   char affinity;      /* Affinity to use for comparison */
66573   u16 flags1;         /* Copy of initial value of pIn1->flags */
66574   u16 flags3;         /* Copy of initial value of pIn3->flags */
66575 #endif /* local variables moved into u.ai */
66576
66577   pIn1 = &aMem[pOp->p1];
66578   pIn3 = &aMem[pOp->p3];
66579   u.ai.flags1 = pIn1->flags;
66580   u.ai.flags3 = pIn3->flags;
66581   if( (u.ai.flags1 | u.ai.flags3)&MEM_Null ){
66582     /* One or both operands are NULL */
66583     if( pOp->p5 & SQLCIPHER_NULLEQ ){
66584       /* If SQLCIPHER_NULLEQ is set (which will only happen if the operator is
66585       ** OP_Eq or OP_Ne) then take the jump or not depending on whether
66586       ** or not both operands are null.
66587       */
66588       assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
66589       u.ai.res = (u.ai.flags1 & u.ai.flags3 & MEM_Null)==0;
66590     }else{
66591       /* SQLCIPHER_NULLEQ is clear and at least one operand is NULL,
66592       ** then the result is always NULL.
66593       ** The jump is taken if the SQLCIPHER_JUMPIFNULL bit is set.
66594       */
66595       if( pOp->p5 & SQLCIPHER_STOREP2 ){
66596         pOut = &aMem[pOp->p2];
66597         MemSetTypeFlag(pOut, MEM_Null);
66598         REGISTER_TRACE(pOp->p2, pOut);
66599       }else if( pOp->p5 & SQLCIPHER_JUMPIFNULL ){
66600         pc = pOp->p2-1;
66601       }
66602       break;
66603     }
66604   }else{
66605     /* Neither operand is NULL.  Do a comparison. */
66606     u.ai.affinity = pOp->p5 & SQLCIPHER_AFF_MASK;
66607     if( u.ai.affinity ){
66608       applyAffinity(pIn1, u.ai.affinity, encoding);
66609       applyAffinity(pIn3, u.ai.affinity, encoding);
66610       if( db->mallocFailed ) goto no_mem;
66611     }
66612
66613     assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
66614     ExpandBlob(pIn1);
66615     ExpandBlob(pIn3);
66616     u.ai.res = sqlcipher3MemCompare(pIn3, pIn1, pOp->p4.pColl);
66617   }
66618   switch( pOp->opcode ){
66619     case OP_Eq:    u.ai.res = u.ai.res==0;     break;
66620     case OP_Ne:    u.ai.res = u.ai.res!=0;     break;
66621     case OP_Lt:    u.ai.res = u.ai.res<0;      break;
66622     case OP_Le:    u.ai.res = u.ai.res<=0;     break;
66623     case OP_Gt:    u.ai.res = u.ai.res>0;      break;
66624     default:       u.ai.res = u.ai.res>=0;     break;
66625   }
66626
66627   if( pOp->p5 & SQLCIPHER_STOREP2 ){
66628     pOut = &aMem[pOp->p2];
66629     memAboutToChange(p, pOut);
66630     MemSetTypeFlag(pOut, MEM_Int);
66631     pOut->u.i = u.ai.res;
66632     REGISTER_TRACE(pOp->p2, pOut);
66633   }else if( u.ai.res ){
66634     pc = pOp->p2-1;
66635   }
66636
66637   /* Undo any changes made by applyAffinity() to the input registers. */
66638   pIn1->flags = (pIn1->flags&~MEM_TypeMask) | (u.ai.flags1&MEM_TypeMask);
66639   pIn3->flags = (pIn3->flags&~MEM_TypeMask) | (u.ai.flags3&MEM_TypeMask);
66640   break;
66641 }
66642
66643 /* Opcode: Permutation * * * P4 *
66644 **
66645 ** Set the permutation used by the OP_Compare operator to be the array
66646 ** of integers in P4.
66647 **
66648 ** The permutation is only valid until the next OP_Permutation, OP_Compare,
66649 ** OP_Halt, or OP_ResultRow.  Typically the OP_Permutation should occur
66650 ** immediately prior to the OP_Compare.
66651 */
66652 case OP_Permutation: {
66653   assert( pOp->p4type==P4_INTARRAY );
66654   assert( pOp->p4.ai );
66655   aPermute = pOp->p4.ai;
66656   break;
66657 }
66658
66659 /* Opcode: Compare P1 P2 P3 P4 *
66660 **
66661 ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
66662 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B").  Save the result of
66663 ** the comparison for use by the next OP_Jump instruct.
66664 **
66665 ** P4 is a KeyInfo structure that defines collating sequences and sort
66666 ** orders for the comparison.  The permutation applies to registers
66667 ** only.  The KeyInfo elements are used sequentially.
66668 **
66669 ** The comparison is a sort comparison, so NULLs compare equal,
66670 ** NULLs are less than numbers, numbers are less than strings,
66671 ** and strings are less than blobs.
66672 */
66673 case OP_Compare: {
66674 #if 0  /* local variables moved into u.aj */
66675   int n;
66676   int i;
66677   int p1;
66678   int p2;
66679   const KeyInfo *pKeyInfo;
66680   int idx;
66681   CollSeq *pColl;    /* Collating sequence to use on this term */
66682   int bRev;          /* True for DESCENDING sort order */
66683 #endif /* local variables moved into u.aj */
66684
66685   u.aj.n = pOp->p3;
66686   u.aj.pKeyInfo = pOp->p4.pKeyInfo;
66687   assert( u.aj.n>0 );
66688   assert( u.aj.pKeyInfo!=0 );
66689   u.aj.p1 = pOp->p1;
66690   u.aj.p2 = pOp->p2;
66691 #if SQLCIPHER_DEBUG
66692   if( aPermute ){
66693     int k, mx = 0;
66694     for(k=0; k<u.aj.n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
66695     assert( u.aj.p1>0 && u.aj.p1+mx<=p->nMem+1 );
66696     assert( u.aj.p2>0 && u.aj.p2+mx<=p->nMem+1 );
66697   }else{
66698     assert( u.aj.p1>0 && u.aj.p1+u.aj.n<=p->nMem+1 );
66699     assert( u.aj.p2>0 && u.aj.p2+u.aj.n<=p->nMem+1 );
66700   }
66701 #endif /* SQLCIPHER_DEBUG */
66702   for(u.aj.i=0; u.aj.i<u.aj.n; u.aj.i++){
66703     u.aj.idx = aPermute ? aPermute[u.aj.i] : u.aj.i;
66704     assert( memIsValid(&aMem[u.aj.p1+u.aj.idx]) );
66705     assert( memIsValid(&aMem[u.aj.p2+u.aj.idx]) );
66706     REGISTER_TRACE(u.aj.p1+u.aj.idx, &aMem[u.aj.p1+u.aj.idx]);
66707     REGISTER_TRACE(u.aj.p2+u.aj.idx, &aMem[u.aj.p2+u.aj.idx]);
66708     assert( u.aj.i<u.aj.pKeyInfo->nField );
66709     u.aj.pColl = u.aj.pKeyInfo->aColl[u.aj.i];
66710     u.aj.bRev = u.aj.pKeyInfo->aSortOrder[u.aj.i];
66711     iCompare = sqlcipher3MemCompare(&aMem[u.aj.p1+u.aj.idx], &aMem[u.aj.p2+u.aj.idx], u.aj.pColl);
66712     if( iCompare ){
66713       if( u.aj.bRev ) iCompare = -iCompare;
66714       break;
66715     }
66716   }
66717   aPermute = 0;
66718   break;
66719 }
66720
66721 /* Opcode: Jump P1 P2 P3 * *
66722 **
66723 ** Jump to the instruction at address P1, P2, or P3 depending on whether
66724 ** in the most recent OP_Compare instruction the P1 vector was less than
66725 ** equal to, or greater than the P2 vector, respectively.
66726 */
66727 case OP_Jump: {             /* jump */
66728   if( iCompare<0 ){
66729     pc = pOp->p1 - 1;
66730   }else if( iCompare==0 ){
66731     pc = pOp->p2 - 1;
66732   }else{
66733     pc = pOp->p3 - 1;
66734   }
66735   break;
66736 }
66737
66738 /* Opcode: And P1 P2 P3 * *
66739 **
66740 ** Take the logical AND of the values in registers P1 and P2 and
66741 ** write the result into register P3.
66742 **
66743 ** If either P1 or P2 is 0 (false) then the result is 0 even if
66744 ** the other input is NULL.  A NULL and true or two NULLs give
66745 ** a NULL output.
66746 */
66747 /* Opcode: Or P1 P2 P3 * *
66748 **
66749 ** Take the logical OR of the values in register P1 and P2 and
66750 ** store the answer in register P3.
66751 **
66752 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
66753 ** even if the other input is NULL.  A NULL and false or two NULLs
66754 ** give a NULL output.
66755 */
66756 case OP_And:              /* same as TK_AND, in1, in2, out3 */
66757 case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
66758 #if 0  /* local variables moved into u.ak */
66759   int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
66760   int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
66761 #endif /* local variables moved into u.ak */
66762
66763   pIn1 = &aMem[pOp->p1];
66764   if( pIn1->flags & MEM_Null ){
66765     u.ak.v1 = 2;
66766   }else{
66767     u.ak.v1 = sqlcipher3VdbeIntValue(pIn1)!=0;
66768   }
66769   pIn2 = &aMem[pOp->p2];
66770   if( pIn2->flags & MEM_Null ){
66771     u.ak.v2 = 2;
66772   }else{
66773     u.ak.v2 = sqlcipher3VdbeIntValue(pIn2)!=0;
66774   }
66775   if( pOp->opcode==OP_And ){
66776     static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
66777     u.ak.v1 = and_logic[u.ak.v1*3+u.ak.v2];
66778   }else{
66779     static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
66780     u.ak.v1 = or_logic[u.ak.v1*3+u.ak.v2];
66781   }
66782   pOut = &aMem[pOp->p3];
66783   if( u.ak.v1==2 ){
66784     MemSetTypeFlag(pOut, MEM_Null);
66785   }else{
66786     pOut->u.i = u.ak.v1;
66787     MemSetTypeFlag(pOut, MEM_Int);
66788   }
66789   break;
66790 }
66791
66792 /* Opcode: Not P1 P2 * * *
66793 **
66794 ** Interpret the value in register P1 as a boolean value.  Store the
66795 ** boolean complement in register P2.  If the value in register P1 is 
66796 ** NULL, then a NULL is stored in P2.
66797 */
66798 case OP_Not: {                /* same as TK_NOT, in1, out2 */
66799   pIn1 = &aMem[pOp->p1];
66800   pOut = &aMem[pOp->p2];
66801   if( pIn1->flags & MEM_Null ){
66802     sqlcipher3VdbeMemSetNull(pOut);
66803   }else{
66804     sqlcipher3VdbeMemSetInt64(pOut, !sqlcipher3VdbeIntValue(pIn1));
66805   }
66806   break;
66807 }
66808
66809 /* Opcode: BitNot P1 P2 * * *
66810 **
66811 ** Interpret the content of register P1 as an integer.  Store the
66812 ** ones-complement of the P1 value into register P2.  If P1 holds
66813 ** a NULL then store a NULL in P2.
66814 */
66815 case OP_BitNot: {             /* same as TK_BITNOT, in1, out2 */
66816   pIn1 = &aMem[pOp->p1];
66817   pOut = &aMem[pOp->p2];
66818   if( pIn1->flags & MEM_Null ){
66819     sqlcipher3VdbeMemSetNull(pOut);
66820   }else{
66821     sqlcipher3VdbeMemSetInt64(pOut, ~sqlcipher3VdbeIntValue(pIn1));
66822   }
66823   break;
66824 }
66825
66826 /* Opcode: Once P1 P2 * * *
66827 **
66828 ** Jump to P2 if the value in register P1 is a not null or zero.  If
66829 ** the value is NULL or zero, fall through and change the P1 register
66830 ** to an integer 1.
66831 **
66832 ** When P1 is not used otherwise in a program, this opcode falls through
66833 ** once and jumps on all subsequent invocations.  It is the equivalent
66834 ** of "OP_If P1 P2", followed by "OP_Integer 1 P1".
66835 */
66836 /* Opcode: If P1 P2 P3 * *
66837 **
66838 ** Jump to P2 if the value in register P1 is true.  The value
66839 ** is considered true if it is numeric and non-zero.  If the value
66840 ** in P1 is NULL then take the jump if P3 is true.
66841 */
66842 /* Opcode: IfNot P1 P2 P3 * *
66843 **
66844 ** Jump to P2 if the value in register P1 is False.  The value
66845 ** is considered true if it has a numeric value of zero.  If the value
66846 ** in P1 is NULL then take the jump if P3 is true.
66847 */
66848 case OP_Once:               /* jump, in1 */
66849 case OP_If:                 /* jump, in1 */
66850 case OP_IfNot: {            /* jump, in1 */
66851 #if 0  /* local variables moved into u.al */
66852   int c;
66853 #endif /* local variables moved into u.al */
66854   pIn1 = &aMem[pOp->p1];
66855   if( pIn1->flags & MEM_Null ){
66856     u.al.c = pOp->p3;
66857   }else{
66858 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
66859     u.al.c = sqlcipher3VdbeIntValue(pIn1)!=0;
66860 #else
66861     u.al.c = sqlcipher3VdbeRealValue(pIn1)!=0.0;
66862 #endif
66863     if( pOp->opcode==OP_IfNot ) u.al.c = !u.al.c;
66864   }
66865   if( u.al.c ){
66866     pc = pOp->p2-1;
66867   }else if( pOp->opcode==OP_Once ){
66868     assert( (pIn1->flags & (MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))==0 );
66869     memAboutToChange(p, pIn1);
66870     pIn1->flags = MEM_Int;
66871     pIn1->u.i = 1;
66872     REGISTER_TRACE(pOp->p1, pIn1);
66873   }
66874   break;
66875 }
66876
66877 /* Opcode: IsNull P1 P2 * * *
66878 **
66879 ** Jump to P2 if the value in register P1 is NULL.
66880 */
66881 case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
66882   pIn1 = &aMem[pOp->p1];
66883   if( (pIn1->flags & MEM_Null)!=0 ){
66884     pc = pOp->p2 - 1;
66885   }
66886   break;
66887 }
66888
66889 /* Opcode: NotNull P1 P2 * * *
66890 **
66891 ** Jump to P2 if the value in register P1 is not NULL.  
66892 */
66893 case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
66894   pIn1 = &aMem[pOp->p1];
66895   if( (pIn1->flags & MEM_Null)==0 ){
66896     pc = pOp->p2 - 1;
66897   }
66898   break;
66899 }
66900
66901 /* Opcode: Column P1 P2 P3 P4 P5
66902 **
66903 ** Interpret the data that cursor P1 points to as a structure built using
66904 ** the MakeRecord instruction.  (See the MakeRecord opcode for additional
66905 ** information about the format of the data.)  Extract the P2-th column
66906 ** from this record.  If there are less that (P2+1) 
66907 ** values in the record, extract a NULL.
66908 **
66909 ** The value extracted is stored in register P3.
66910 **
66911 ** If the column contains fewer than P2 fields, then extract a NULL.  Or,
66912 ** if the P4 argument is a P4_MEM use the value of the P4 argument as
66913 ** the result.
66914 **
66915 ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
66916 ** then the cache of the cursor is reset prior to extracting the column.
66917 ** The first OP_Column against a pseudo-table after the value of the content
66918 ** register has changed should have this bit set.
66919 */
66920 case OP_Column: {
66921 #if 0  /* local variables moved into u.am */
66922   u32 payloadSize;   /* Number of bytes in the record */
66923   i64 payloadSize64; /* Number of bytes in the record */
66924   int p1;            /* P1 value of the opcode */
66925   int p2;            /* column number to retrieve */
66926   VdbeCursor *pC;    /* The VDBE cursor */
66927   char *zRec;        /* Pointer to complete record-data */
66928   BtCursor *pCrsr;   /* The BTree cursor */
66929   u32 *aType;        /* aType[i] holds the numeric type of the i-th column */
66930   u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
66931   int nField;        /* number of fields in the record */
66932   int len;           /* The length of the serialized data for the column */
66933   int i;             /* Loop counter */
66934   char *zData;       /* Part of the record being decoded */
66935   Mem *pDest;        /* Where to write the extracted value */
66936   Mem sMem;          /* For storing the record being decoded */
66937   u8 *zIdx;          /* Index into header */
66938   u8 *zEndHdr;       /* Pointer to first byte after the header */
66939   u32 offset;        /* Offset into the data */
66940   u32 szField;       /* Number of bytes in the content of a field */
66941   int szHdr;         /* Size of the header size field at start of record */
66942   int avail;         /* Number of bytes of available data */
66943   u32 t;             /* A type code from the record header */
66944   Mem *pReg;         /* PseudoTable input register */
66945 #endif /* local variables moved into u.am */
66946
66947
66948   u.am.p1 = pOp->p1;
66949   u.am.p2 = pOp->p2;
66950   u.am.pC = 0;
66951   memset(&u.am.sMem, 0, sizeof(u.am.sMem));
66952   assert( u.am.p1<p->nCursor );
66953   assert( pOp->p3>0 && pOp->p3<=p->nMem );
66954   u.am.pDest = &aMem[pOp->p3];
66955   memAboutToChange(p, u.am.pDest);
66956   u.am.zRec = 0;
66957
66958   /* This block sets the variable u.am.payloadSize to be the total number of
66959   ** bytes in the record.
66960   **
66961   ** u.am.zRec is set to be the complete text of the record if it is available.
66962   ** The complete record text is always available for pseudo-tables
66963   ** If the record is stored in a cursor, the complete record text
66964   ** might be available in the  u.am.pC->aRow cache.  Or it might not be.
66965   ** If the data is unavailable,  u.am.zRec is set to NULL.
66966   **
66967   ** We also compute the number of columns in the record.  For cursors,
66968   ** the number of columns is stored in the VdbeCursor.nField element.
66969   */
66970   u.am.pC = p->apCsr[u.am.p1];
66971   assert( u.am.pC!=0 );
66972 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
66973   assert( u.am.pC->pVtabCursor==0 );
66974 #endif
66975   u.am.pCrsr = u.am.pC->pCursor;
66976   if( u.am.pCrsr!=0 ){
66977     /* The record is stored in a B-Tree */
66978     rc = sqlcipher3VdbeCursorMoveto(u.am.pC);
66979     if( rc ) goto abort_due_to_error;
66980     if( u.am.pC->nullRow ){
66981       u.am.payloadSize = 0;
66982     }else if( u.am.pC->cacheStatus==p->cacheCtr ){
66983       u.am.payloadSize = u.am.pC->payloadSize;
66984       u.am.zRec = (char*)u.am.pC->aRow;
66985     }else if( u.am.pC->isIndex ){
66986       assert( sqlcipher3BtreeCursorIsValid(u.am.pCrsr) );
66987       VVA_ONLY(rc =) sqlcipher3BtreeKeySize(u.am.pCrsr, &u.am.payloadSize64);
66988       assert( rc==SQLCIPHER_OK );   /* True because of CursorMoveto() call above */
66989       /* sqlcipher3BtreeParseCellPtr() uses getVarint32() to extract the
66990       ** payload size, so it is impossible for u.am.payloadSize64 to be
66991       ** larger than 32 bits. */
66992       assert( (u.am.payloadSize64 & SQLCIPHER_MAX_U32)==(u64)u.am.payloadSize64 );
66993       u.am.payloadSize = (u32)u.am.payloadSize64;
66994     }else{
66995       assert( sqlcipher3BtreeCursorIsValid(u.am.pCrsr) );
66996       VVA_ONLY(rc =) sqlcipher3BtreeDataSize(u.am.pCrsr, &u.am.payloadSize);
66997       assert( rc==SQLCIPHER_OK );   /* DataSize() cannot fail */
66998     }
66999   }else if( ALWAYS(u.am.pC->pseudoTableReg>0) ){
67000     u.am.pReg = &aMem[u.am.pC->pseudoTableReg];
67001     assert( u.am.pReg->flags & MEM_Blob );
67002     assert( memIsValid(u.am.pReg) );
67003     u.am.payloadSize = u.am.pReg->n;
67004     u.am.zRec = u.am.pReg->z;
67005     u.am.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
67006     assert( u.am.payloadSize==0 || u.am.zRec!=0 );
67007   }else{
67008     /* Consider the row to be NULL */
67009     u.am.payloadSize = 0;
67010   }
67011
67012   /* If u.am.payloadSize is 0, then just store a NULL.  This can happen because of
67013   ** nullRow or because of a corrupt database. */
67014   if( u.am.payloadSize==0 ){
67015     MemSetTypeFlag(u.am.pDest, MEM_Null);
67016     goto op_column_out;
67017   }
67018   assert( db->aLimit[SQLCIPHER_LIMIT_LENGTH]>=0 );
67019   if( u.am.payloadSize > (u32)db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
67020     goto too_big;
67021   }
67022
67023   u.am.nField = u.am.pC->nField;
67024   assert( u.am.p2<u.am.nField );
67025
67026   /* Read and parse the table header.  Store the results of the parse
67027   ** into the record header cache fields of the cursor.
67028   */
67029   u.am.aType = u.am.pC->aType;
67030   if( u.am.pC->cacheStatus==p->cacheCtr ){
67031     u.am.aOffset = u.am.pC->aOffset;
67032   }else{
67033     assert(u.am.aType);
67034     u.am.avail = 0;
67035     u.am.pC->aOffset = u.am.aOffset = &u.am.aType[u.am.nField];
67036     u.am.pC->payloadSize = u.am.payloadSize;
67037     u.am.pC->cacheStatus = p->cacheCtr;
67038
67039     /* Figure out how many bytes are in the header */
67040     if( u.am.zRec ){
67041       u.am.zData = u.am.zRec;
67042     }else{
67043       if( u.am.pC->isIndex ){
67044         u.am.zData = (char*)sqlcipher3BtreeKeyFetch(u.am.pCrsr, &u.am.avail);
67045       }else{
67046         u.am.zData = (char*)sqlcipher3BtreeDataFetch(u.am.pCrsr, &u.am.avail);
67047       }
67048       /* If KeyFetch()/DataFetch() managed to get the entire payload,
67049       ** save the payload in the u.am.pC->aRow cache.  That will save us from
67050       ** having to make additional calls to fetch the content portion of
67051       ** the record.
67052       */
67053       assert( u.am.avail>=0 );
67054       if( u.am.payloadSize <= (u32)u.am.avail ){
67055         u.am.zRec = u.am.zData;
67056         u.am.pC->aRow = (u8*)u.am.zData;
67057       }else{
67058         u.am.pC->aRow = 0;
67059       }
67060     }
67061     /* The following assert is true in all cases accept when
67062     ** the database file has been corrupted externally.
67063     **    assert( u.am.zRec!=0 || u.am.avail>=u.am.payloadSize || u.am.avail>=9 ); */
67064     u.am.szHdr = getVarint32((u8*)u.am.zData, u.am.offset);
67065
67066     /* Make sure a corrupt database has not given us an oversize header.
67067     ** Do this now to avoid an oversize memory allocation.
67068     **
67069     ** Type entries can be between 1 and 5 bytes each.  But 4 and 5 byte
67070     ** types use so much data space that there can only be 4096 and 32 of
67071     ** them, respectively.  So the maximum header length results from a
67072     ** 3-byte type for each of the maximum of 32768 columns plus three
67073     ** extra bytes for the header length itself.  32768*3 + 3 = 98307.
67074     */
67075     if( u.am.offset > 98307 ){
67076       rc = SQLCIPHER_CORRUPT_BKPT;
67077       goto op_column_out;
67078     }
67079
67080     /* Compute in u.am.len the number of bytes of data we need to read in order
67081     ** to get u.am.nField type values.  u.am.offset is an upper bound on this.  But
67082     ** u.am.nField might be significantly less than the true number of columns
67083     ** in the table, and in that case, 5*u.am.nField+3 might be smaller than u.am.offset.
67084     ** We want to minimize u.am.len in order to limit the size of the memory
67085     ** allocation, especially if a corrupt database file has caused u.am.offset
67086     ** to be oversized. Offset is limited to 98307 above.  But 98307 might
67087     ** still exceed Robson memory allocation limits on some configurations.
67088     ** On systems that cannot tolerate large memory allocations, u.am.nField*5+3
67089     ** will likely be much smaller since u.am.nField will likely be less than
67090     ** 20 or so.  This insures that Robson memory allocation limits are
67091     ** not exceeded even for corrupt database files.
67092     */
67093     u.am.len = u.am.nField*5 + 3;
67094     if( u.am.len > (int)u.am.offset ) u.am.len = (int)u.am.offset;
67095
67096     /* The KeyFetch() or DataFetch() above are fast and will get the entire
67097     ** record header in most cases.  But they will fail to get the complete
67098     ** record header if the record header does not fit on a single page
67099     ** in the B-Tree.  When that happens, use sqlcipher3VdbeMemFromBtree() to
67100     ** acquire the complete header text.
67101     */
67102     if( !u.am.zRec && u.am.avail<u.am.len ){
67103       u.am.sMem.flags = 0;
67104       u.am.sMem.db = 0;
67105       rc = sqlcipher3VdbeMemFromBtree(u.am.pCrsr, 0, u.am.len, u.am.pC->isIndex, &u.am.sMem);
67106       if( rc!=SQLCIPHER_OK ){
67107         goto op_column_out;
67108       }
67109       u.am.zData = u.am.sMem.z;
67110     }
67111     u.am.zEndHdr = (u8 *)&u.am.zData[u.am.len];
67112     u.am.zIdx = (u8 *)&u.am.zData[u.am.szHdr];
67113
67114     /* Scan the header and use it to fill in the u.am.aType[] and u.am.aOffset[]
67115     ** arrays.  u.am.aType[u.am.i] will contain the type integer for the u.am.i-th
67116     ** column and u.am.aOffset[u.am.i] will contain the u.am.offset from the beginning
67117     ** of the record to the start of the data for the u.am.i-th column
67118     */
67119     for(u.am.i=0; u.am.i<u.am.nField; u.am.i++){
67120       if( u.am.zIdx<u.am.zEndHdr ){
67121         u.am.aOffset[u.am.i] = u.am.offset;
67122         if( u.am.zIdx[0]<0x80 ){
67123           u.am.t = u.am.zIdx[0];
67124           u.am.zIdx++;
67125         }else{
67126           u.am.zIdx += sqlcipher3GetVarint32(u.am.zIdx, &u.am.t);
67127         }
67128         u.am.aType[u.am.i] = u.am.t;
67129         u.am.szField = sqlcipher3VdbeSerialTypeLen(u.am.t);
67130         u.am.offset += u.am.szField;
67131         if( u.am.offset<u.am.szField ){  /* True if u.am.offset overflows */
67132           u.am.zIdx = &u.am.zEndHdr[1];  /* Forces SQLCIPHER_CORRUPT return below */
67133           break;
67134         }
67135       }else{
67136         /* If u.am.i is less that u.am.nField, then there are less fields in this
67137         ** record than SetNumColumns indicated there are columns in the
67138         ** table. Set the u.am.offset for any extra columns not present in
67139         ** the record to 0. This tells code below to store a NULL
67140         ** instead of deserializing a value from the record.
67141         */
67142         u.am.aOffset[u.am.i] = 0;
67143       }
67144     }
67145     sqlcipher3VdbeMemRelease(&u.am.sMem);
67146     u.am.sMem.flags = MEM_Null;
67147
67148     /* If we have read more header data than was contained in the header,
67149     ** or if the end of the last field appears to be past the end of the
67150     ** record, or if the end of the last field appears to be before the end
67151     ** of the record (when all fields present), then we must be dealing
67152     ** with a corrupt database.
67153     */
67154     if( (u.am.zIdx > u.am.zEndHdr) || (u.am.offset > u.am.payloadSize)
67155          || (u.am.zIdx==u.am.zEndHdr && u.am.offset!=u.am.payloadSize) ){
67156       rc = SQLCIPHER_CORRUPT_BKPT;
67157       goto op_column_out;
67158     }
67159   }
67160
67161   /* Get the column information. If u.am.aOffset[u.am.p2] is non-zero, then
67162   ** deserialize the value from the record. If u.am.aOffset[u.am.p2] is zero,
67163   ** then there are not enough fields in the record to satisfy the
67164   ** request.  In this case, set the value NULL or to P4 if P4 is
67165   ** a pointer to a Mem object.
67166   */
67167   if( u.am.aOffset[u.am.p2] ){
67168     assert( rc==SQLCIPHER_OK );
67169     if( u.am.zRec ){
67170       MemReleaseExt(u.am.pDest);
67171       sqlcipher3VdbeSerialGet((u8 *)&u.am.zRec[u.am.aOffset[u.am.p2]], u.am.aType[u.am.p2], u.am.pDest);
67172     }else{
67173       u.am.len = sqlcipher3VdbeSerialTypeLen(u.am.aType[u.am.p2]);
67174       sqlcipher3VdbeMemMove(&u.am.sMem, u.am.pDest);
67175       rc = sqlcipher3VdbeMemFromBtree(u.am.pCrsr, u.am.aOffset[u.am.p2], u.am.len, u.am.pC->isIndex, &u.am.sMem);
67176       if( rc!=SQLCIPHER_OK ){
67177         goto op_column_out;
67178       }
67179       u.am.zData = u.am.sMem.z;
67180       sqlcipher3VdbeSerialGet((u8*)u.am.zData, u.am.aType[u.am.p2], u.am.pDest);
67181     }
67182     u.am.pDest->enc = encoding;
67183   }else{
67184     if( pOp->p4type==P4_MEM ){
67185       sqlcipher3VdbeMemShallowCopy(u.am.pDest, pOp->p4.pMem, MEM_Static);
67186     }else{
67187       MemSetTypeFlag(u.am.pDest, MEM_Null);
67188     }
67189   }
67190
67191   /* If we dynamically allocated space to hold the data (in the
67192   ** sqlcipher3VdbeMemFromBtree() call above) then transfer control of that
67193   ** dynamically allocated space over to the u.am.pDest structure.
67194   ** This prevents a memory copy.
67195   */
67196   if( u.am.sMem.zMalloc ){
67197     assert( u.am.sMem.z==u.am.sMem.zMalloc );
67198     assert( !(u.am.pDest->flags & MEM_Dyn) );
67199     assert( !(u.am.pDest->flags & (MEM_Blob|MEM_Str)) || u.am.pDest->z==u.am.sMem.z );
67200     u.am.pDest->flags &= ~(MEM_Ephem|MEM_Static);
67201     u.am.pDest->flags |= MEM_Term;
67202     u.am.pDest->z = u.am.sMem.z;
67203     u.am.pDest->zMalloc = u.am.sMem.zMalloc;
67204   }
67205
67206   rc = sqlcipher3VdbeMemMakeWriteable(u.am.pDest);
67207
67208 op_column_out:
67209   UPDATE_MAX_BLOBSIZE(u.am.pDest);
67210   REGISTER_TRACE(pOp->p3, u.am.pDest);
67211   break;
67212 }
67213
67214 /* Opcode: Affinity P1 P2 * P4 *
67215 **
67216 ** Apply affinities to a range of P2 registers starting with P1.
67217 **
67218 ** P4 is a string that is P2 characters long. The nth character of the
67219 ** string indicates the column affinity that should be used for the nth
67220 ** memory cell in the range.
67221 */
67222 case OP_Affinity: {
67223 #if 0  /* local variables moved into u.an */
67224   const char *zAffinity;   /* The affinity to be applied */
67225   char cAff;               /* A single character of affinity */
67226 #endif /* local variables moved into u.an */
67227
67228   u.an.zAffinity = pOp->p4.z;
67229   assert( u.an.zAffinity!=0 );
67230   assert( u.an.zAffinity[pOp->p2]==0 );
67231   pIn1 = &aMem[pOp->p1];
67232   while( (u.an.cAff = *(u.an.zAffinity++))!=0 ){
67233     assert( pIn1 <= &p->aMem[p->nMem] );
67234     assert( memIsValid(pIn1) );
67235     ExpandBlob(pIn1);
67236     applyAffinity(pIn1, u.an.cAff, encoding);
67237     pIn1++;
67238   }
67239   break;
67240 }
67241
67242 /* Opcode: MakeRecord P1 P2 P3 P4 *
67243 **
67244 ** Convert P2 registers beginning with P1 into the [record format]
67245 ** use as a data record in a database table or as a key
67246 ** in an index.  The OP_Column opcode can decode the record later.
67247 **
67248 ** P4 may be a string that is P2 characters long.  The nth character of the
67249 ** string indicates the column affinity that should be used for the nth
67250 ** field of the index key.
67251 **
67252 ** The mapping from character to affinity is given by the SQLCIPHER_AFF_
67253 ** macros defined in sqlcipherInt.h.
67254 **
67255 ** If P4 is NULL then all index fields have the affinity NONE.
67256 */
67257 case OP_MakeRecord: {
67258 #if 0  /* local variables moved into u.ao */
67259   u8 *zNewRecord;        /* A buffer to hold the data for the new record */
67260   Mem *pRec;             /* The new record */
67261   u64 nData;             /* Number of bytes of data space */
67262   int nHdr;              /* Number of bytes of header space */
67263   i64 nByte;             /* Data space required for this record */
67264   int nZero;             /* Number of zero bytes at the end of the record */
67265   int nVarint;           /* Number of bytes in a varint */
67266   u32 serial_type;       /* Type field */
67267   Mem *pData0;           /* First field to be combined into the record */
67268   Mem *pLast;            /* Last field of the record */
67269   int nField;            /* Number of fields in the record */
67270   char *zAffinity;       /* The affinity string for the record */
67271   int file_format;       /* File format to use for encoding */
67272   int i;                 /* Space used in zNewRecord[] */
67273   int len;               /* Length of a field */
67274 #endif /* local variables moved into u.ao */
67275
67276   /* Assuming the record contains N fields, the record format looks
67277   ** like this:
67278   **
67279   ** ------------------------------------------------------------------------
67280   ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
67281   ** ------------------------------------------------------------------------
67282   **
67283   ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
67284   ** and so froth.
67285   **
67286   ** Each type field is a varint representing the serial type of the
67287   ** corresponding data element (see sqlcipher3VdbeSerialType()). The
67288   ** hdr-size field is also a varint which is the offset from the beginning
67289   ** of the record to data0.
67290   */
67291   u.ao.nData = 0;         /* Number of bytes of data space */
67292   u.ao.nHdr = 0;          /* Number of bytes of header space */
67293   u.ao.nZero = 0;         /* Number of zero bytes at the end of the record */
67294   u.ao.nField = pOp->p1;
67295   u.ao.zAffinity = pOp->p4.z;
67296   assert( u.ao.nField>0 && pOp->p2>0 && pOp->p2+u.ao.nField<=p->nMem+1 );
67297   u.ao.pData0 = &aMem[u.ao.nField];
67298   u.ao.nField = pOp->p2;
67299   u.ao.pLast = &u.ao.pData0[u.ao.nField-1];
67300   u.ao.file_format = p->minWriteFileFormat;
67301
67302   /* Identify the output register */
67303   assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
67304   pOut = &aMem[pOp->p3];
67305   memAboutToChange(p, pOut);
67306
67307   /* Loop through the elements that will make up the record to figure
67308   ** out how much space is required for the new record.
67309   */
67310   for(u.ao.pRec=u.ao.pData0; u.ao.pRec<=u.ao.pLast; u.ao.pRec++){
67311     assert( memIsValid(u.ao.pRec) );
67312     if( u.ao.zAffinity ){
67313       applyAffinity(u.ao.pRec, u.ao.zAffinity[u.ao.pRec-u.ao.pData0], encoding);
67314     }
67315     if( u.ao.pRec->flags&MEM_Zero && u.ao.pRec->n>0 ){
67316       sqlcipher3VdbeMemExpandBlob(u.ao.pRec);
67317     }
67318     u.ao.serial_type = sqlcipher3VdbeSerialType(u.ao.pRec, u.ao.file_format);
67319     u.ao.len = sqlcipher3VdbeSerialTypeLen(u.ao.serial_type);
67320     u.ao.nData += u.ao.len;
67321     u.ao.nHdr += sqlcipher3VarintLen(u.ao.serial_type);
67322     if( u.ao.pRec->flags & MEM_Zero ){
67323       /* Only pure zero-filled BLOBs can be input to this Opcode.
67324       ** We do not allow blobs with a prefix and a zero-filled tail. */
67325       u.ao.nZero += u.ao.pRec->u.nZero;
67326     }else if( u.ao.len ){
67327       u.ao.nZero = 0;
67328     }
67329   }
67330
67331   /* Add the initial header varint and total the size */
67332   u.ao.nHdr += u.ao.nVarint = sqlcipher3VarintLen(u.ao.nHdr);
67333   if( u.ao.nVarint<sqlcipher3VarintLen(u.ao.nHdr) ){
67334     u.ao.nHdr++;
67335   }
67336   u.ao.nByte = u.ao.nHdr+u.ao.nData-u.ao.nZero;
67337   if( u.ao.nByte>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
67338     goto too_big;
67339   }
67340
67341   /* Make sure the output register has a buffer large enough to store
67342   ** the new record. The output register (pOp->p3) is not allowed to
67343   ** be one of the input registers (because the following call to
67344   ** sqlcipher3VdbeMemGrow() could clobber the value before it is used).
67345   */
67346   if( sqlcipher3VdbeMemGrow(pOut, (int)u.ao.nByte, 0) ){
67347     goto no_mem;
67348   }
67349   u.ao.zNewRecord = (u8 *)pOut->z;
67350
67351   /* Write the record */
67352   u.ao.i = putVarint32(u.ao.zNewRecord, u.ao.nHdr);
67353   for(u.ao.pRec=u.ao.pData0; u.ao.pRec<=u.ao.pLast; u.ao.pRec++){
67354     u.ao.serial_type = sqlcipher3VdbeSerialType(u.ao.pRec, u.ao.file_format);
67355     u.ao.i += putVarint32(&u.ao.zNewRecord[u.ao.i], u.ao.serial_type);      /* serial type */
67356   }
67357   for(u.ao.pRec=u.ao.pData0; u.ao.pRec<=u.ao.pLast; u.ao.pRec++){  /* serial data */
67358     u.ao.i += sqlcipher3VdbeSerialPut(&u.ao.zNewRecord[u.ao.i], (int)(u.ao.nByte-u.ao.i), u.ao.pRec,u.ao.file_format);
67359   }
67360   assert( u.ao.i==u.ao.nByte );
67361
67362   assert( pOp->p3>0 && pOp->p3<=p->nMem );
67363   pOut->n = (int)u.ao.nByte;
67364   pOut->flags = MEM_Blob | MEM_Dyn;
67365   pOut->xDel = 0;
67366   if( u.ao.nZero ){
67367     pOut->u.nZero = u.ao.nZero;
67368     pOut->flags |= MEM_Zero;
67369   }
67370   pOut->enc = SQLCIPHER_UTF8;  /* In case the blob is ever converted to text */
67371   REGISTER_TRACE(pOp->p3, pOut);
67372   UPDATE_MAX_BLOBSIZE(pOut);
67373   break;
67374 }
67375
67376 /* Opcode: Count P1 P2 * * *
67377 **
67378 ** Store the number of entries (an integer value) in the table or index 
67379 ** opened by cursor P1 in register P2
67380 */
67381 #ifndef SQLCIPHER_OMIT_BTREECOUNT
67382 case OP_Count: {         /* out2-prerelease */
67383 #if 0  /* local variables moved into u.ap */
67384   i64 nEntry;
67385   BtCursor *pCrsr;
67386 #endif /* local variables moved into u.ap */
67387
67388   u.ap.pCrsr = p->apCsr[pOp->p1]->pCursor;
67389   if( ALWAYS(u.ap.pCrsr) ){
67390     rc = sqlcipher3BtreeCount(u.ap.pCrsr, &u.ap.nEntry);
67391   }else{
67392     u.ap.nEntry = 0;
67393   }
67394   pOut->u.i = u.ap.nEntry;
67395   break;
67396 }
67397 #endif
67398
67399 /* Opcode: Savepoint P1 * * P4 *
67400 **
67401 ** Open, release or rollback the savepoint named by parameter P4, depending
67402 ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an
67403 ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
67404 */
67405 case OP_Savepoint: {
67406 #if 0  /* local variables moved into u.aq */
67407   int p1;                         /* Value of P1 operand */
67408   char *zName;                    /* Name of savepoint */
67409   int nName;
67410   Savepoint *pNew;
67411   Savepoint *pSavepoint;
67412   Savepoint *pTmp;
67413   int iSavepoint;
67414   int ii;
67415 #endif /* local variables moved into u.aq */
67416
67417   u.aq.p1 = pOp->p1;
67418   u.aq.zName = pOp->p4.z;
67419
67420   /* Assert that the u.aq.p1 parameter is valid. Also that if there is no open
67421   ** transaction, then there cannot be any savepoints.
67422   */
67423   assert( db->pSavepoint==0 || db->autoCommit==0 );
67424   assert( u.aq.p1==SAVEPOINT_BEGIN||u.aq.p1==SAVEPOINT_RELEASE||u.aq.p1==SAVEPOINT_ROLLBACK );
67425   assert( db->pSavepoint || db->isTransactionSavepoint==0 );
67426   assert( checkSavepointCount(db) );
67427
67428   if( u.aq.p1==SAVEPOINT_BEGIN ){
67429     if( db->writeVdbeCnt>0 ){
67430       /* A new savepoint cannot be created if there are active write
67431       ** statements (i.e. open read/write incremental blob handles).
67432       */
67433       sqlcipher3SetString(&p->zErrMsg, db, "cannot open savepoint - "
67434         "SQL statements in progress");
67435       rc = SQLCIPHER_BUSY;
67436     }else{
67437       u.aq.nName = sqlcipher3Strlen30(u.aq.zName);
67438
67439 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
67440       /* This call is Ok even if this savepoint is actually a transaction
67441       ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
67442       ** If this is a transaction savepoint being opened, it is guaranteed
67443       ** that the db->aVTrans[] array is empty.  */
67444       assert( db->autoCommit==0 || db->nVTrans==0 );
67445       rc = sqlcipher3VtabSavepoint(db, SAVEPOINT_BEGIN,
67446                                 db->nStatement+db->nSavepoint);
67447       if( rc!=SQLCIPHER_OK ) goto abort_due_to_error;
67448 #endif
67449
67450       /* Create a new savepoint structure. */
67451       u.aq.pNew = sqlcipher3DbMallocRaw(db, sizeof(Savepoint)+u.aq.nName+1);
67452       if( u.aq.pNew ){
67453         u.aq.pNew->zName = (char *)&u.aq.pNew[1];
67454         memcpy(u.aq.pNew->zName, u.aq.zName, u.aq.nName+1);
67455
67456         /* If there is no open transaction, then mark this as a special
67457         ** "transaction savepoint". */
67458         if( db->autoCommit ){
67459           db->autoCommit = 0;
67460           db->isTransactionSavepoint = 1;
67461         }else{
67462           db->nSavepoint++;
67463         }
67464
67465         /* Link the new savepoint into the database handle's list. */
67466         u.aq.pNew->pNext = db->pSavepoint;
67467         db->pSavepoint = u.aq.pNew;
67468         u.aq.pNew->nDeferredCons = db->nDeferredCons;
67469       }
67470     }
67471   }else{
67472     u.aq.iSavepoint = 0;
67473
67474     /* Find the named savepoint. If there is no such savepoint, then an
67475     ** an error is returned to the user.  */
67476     for(
67477       u.aq.pSavepoint = db->pSavepoint;
67478       u.aq.pSavepoint && sqlcipher3StrICmp(u.aq.pSavepoint->zName, u.aq.zName);
67479       u.aq.pSavepoint = u.aq.pSavepoint->pNext
67480     ){
67481       u.aq.iSavepoint++;
67482     }
67483     if( !u.aq.pSavepoint ){
67484       sqlcipher3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.aq.zName);
67485       rc = SQLCIPHER_ERROR;
67486     }else if(
67487         db->writeVdbeCnt>0 || (u.aq.p1==SAVEPOINT_ROLLBACK && db->activeVdbeCnt>1)
67488     ){
67489       /* It is not possible to release (commit) a savepoint if there are
67490       ** active write statements. It is not possible to rollback a savepoint
67491       ** if there are any active statements at all.
67492       */
67493       sqlcipher3SetString(&p->zErrMsg, db,
67494         "cannot %s savepoint - SQL statements in progress",
67495         (u.aq.p1==SAVEPOINT_ROLLBACK ? "rollback": "release")
67496       );
67497       rc = SQLCIPHER_BUSY;
67498     }else{
67499
67500       /* Determine whether or not this is a transaction savepoint. If so,
67501       ** and this is a RELEASE command, then the current transaction
67502       ** is committed.
67503       */
67504       int isTransaction = u.aq.pSavepoint->pNext==0 && db->isTransactionSavepoint;
67505       if( isTransaction && u.aq.p1==SAVEPOINT_RELEASE ){
67506         if( (rc = sqlcipher3VdbeCheckFk(p, 1))!=SQLCIPHER_OK ){
67507           goto vdbe_return;
67508         }
67509         db->autoCommit = 1;
67510         if( sqlcipher3VdbeHalt(p)==SQLCIPHER_BUSY ){
67511           p->pc = pc;
67512           db->autoCommit = 0;
67513           p->rc = rc = SQLCIPHER_BUSY;
67514           goto vdbe_return;
67515         }
67516         db->isTransactionSavepoint = 0;
67517         rc = p->rc;
67518       }else{
67519         u.aq.iSavepoint = db->nSavepoint - u.aq.iSavepoint - 1;
67520         for(u.aq.ii=0; u.aq.ii<db->nDb; u.aq.ii++){
67521           rc = sqlcipher3BtreeSavepoint(db->aDb[u.aq.ii].pBt, u.aq.p1, u.aq.iSavepoint);
67522           if( rc!=SQLCIPHER_OK ){
67523             goto abort_due_to_error;
67524           }
67525         }
67526         if( u.aq.p1==SAVEPOINT_ROLLBACK && (db->flags&SQLCIPHER_InternChanges)!=0 ){
67527           sqlcipher3ExpirePreparedStatements(db);
67528           sqlcipher3ResetInternalSchema(db, -1);
67529           db->flags = (db->flags | SQLCIPHER_InternChanges);
67530         }
67531       }
67532
67533       /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
67534       ** savepoints nested inside of the savepoint being operated on. */
67535       while( db->pSavepoint!=u.aq.pSavepoint ){
67536         u.aq.pTmp = db->pSavepoint;
67537         db->pSavepoint = u.aq.pTmp->pNext;
67538         sqlcipher3DbFree(db, u.aq.pTmp);
67539         db->nSavepoint--;
67540       }
67541
67542       /* If it is a RELEASE, then destroy the savepoint being operated on
67543       ** too. If it is a ROLLBACK TO, then set the number of deferred
67544       ** constraint violations present in the database to the value stored
67545       ** when the savepoint was created.  */
67546       if( u.aq.p1==SAVEPOINT_RELEASE ){
67547         assert( u.aq.pSavepoint==db->pSavepoint );
67548         db->pSavepoint = u.aq.pSavepoint->pNext;
67549         sqlcipher3DbFree(db, u.aq.pSavepoint);
67550         if( !isTransaction ){
67551           db->nSavepoint--;
67552         }
67553       }else{
67554         db->nDeferredCons = u.aq.pSavepoint->nDeferredCons;
67555       }
67556
67557       if( !isTransaction ){
67558         rc = sqlcipher3VtabSavepoint(db, u.aq.p1, u.aq.iSavepoint);
67559         if( rc!=SQLCIPHER_OK ) goto abort_due_to_error;
67560       }
67561     }
67562   }
67563
67564   break;
67565 }
67566
67567 /* Opcode: AutoCommit P1 P2 * * *
67568 **
67569 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
67570 ** back any currently active btree transactions. If there are any active
67571 ** VMs (apart from this one), then a ROLLBACK fails.  A COMMIT fails if
67572 ** there are active writing VMs or active VMs that use shared cache.
67573 **
67574 ** This instruction causes the VM to halt.
67575 */
67576 case OP_AutoCommit: {
67577 #if 0  /* local variables moved into u.ar */
67578   int desiredAutoCommit;
67579   int iRollback;
67580   int turnOnAC;
67581 #endif /* local variables moved into u.ar */
67582
67583   u.ar.desiredAutoCommit = pOp->p1;
67584   u.ar.iRollback = pOp->p2;
67585   u.ar.turnOnAC = u.ar.desiredAutoCommit && !db->autoCommit;
67586   assert( u.ar.desiredAutoCommit==1 || u.ar.desiredAutoCommit==0 );
67587   assert( u.ar.desiredAutoCommit==1 || u.ar.iRollback==0 );
67588   assert( db->activeVdbeCnt>0 );  /* At least this one VM is active */
67589
67590   if( u.ar.turnOnAC && u.ar.iRollback && db->activeVdbeCnt>1 ){
67591     /* If this instruction implements a ROLLBACK and other VMs are
67592     ** still running, and a transaction is active, return an error indicating
67593     ** that the other VMs must complete first.
67594     */
67595     sqlcipher3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
67596         "SQL statements in progress");
67597     rc = SQLCIPHER_BUSY;
67598   }else if( u.ar.turnOnAC && !u.ar.iRollback && db->writeVdbeCnt>0 ){
67599     /* If this instruction implements a COMMIT and other VMs are writing
67600     ** return an error indicating that the other VMs must complete first.
67601     */
67602     sqlcipher3SetString(&p->zErrMsg, db, "cannot commit transaction - "
67603         "SQL statements in progress");
67604     rc = SQLCIPHER_BUSY;
67605   }else if( u.ar.desiredAutoCommit!=db->autoCommit ){
67606     if( u.ar.iRollback ){
67607       assert( u.ar.desiredAutoCommit==1 );
67608       sqlcipher3RollbackAll(db);
67609       db->autoCommit = 1;
67610     }else if( (rc = sqlcipher3VdbeCheckFk(p, 1))!=SQLCIPHER_OK ){
67611       goto vdbe_return;
67612     }else{
67613       db->autoCommit = (u8)u.ar.desiredAutoCommit;
67614       if( sqlcipher3VdbeHalt(p)==SQLCIPHER_BUSY ){
67615         p->pc = pc;
67616         db->autoCommit = (u8)(1-u.ar.desiredAutoCommit);
67617         p->rc = rc = SQLCIPHER_BUSY;
67618         goto vdbe_return;
67619       }
67620     }
67621     assert( db->nStatement==0 );
67622     sqlcipher3CloseSavepoints(db);
67623     if( p->rc==SQLCIPHER_OK ){
67624       rc = SQLCIPHER_DONE;
67625     }else{
67626       rc = SQLCIPHER_ERROR;
67627     }
67628     goto vdbe_return;
67629   }else{
67630     sqlcipher3SetString(&p->zErrMsg, db,
67631         (!u.ar.desiredAutoCommit)?"cannot start a transaction within a transaction":(
67632         (u.ar.iRollback)?"cannot rollback - no transaction is active":
67633                    "cannot commit - no transaction is active"));
67634
67635     rc = SQLCIPHER_ERROR;
67636   }
67637   break;
67638 }
67639
67640 /* Opcode: Transaction P1 P2 * * *
67641 **
67642 ** Begin a transaction.  The transaction ends when a Commit or Rollback
67643 ** opcode is encountered.  Depending on the ON CONFLICT setting, the
67644 ** transaction might also be rolled back if an error is encountered.
67645 **
67646 ** P1 is the index of the database file on which the transaction is
67647 ** started.  Index 0 is the main database file and index 1 is the
67648 ** file used for temporary tables.  Indices of 2 or more are used for
67649 ** attached databases.
67650 **
67651 ** If P2 is non-zero, then a write-transaction is started.  A RESERVED lock is
67652 ** obtained on the database file when a write-transaction is started.  No
67653 ** other process can start another write transaction while this transaction is
67654 ** underway.  Starting a write transaction also creates a rollback journal. A
67655 ** write transaction must be started before any changes can be made to the
67656 ** database.  If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
67657 ** on the file.
67658 **
67659 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
67660 ** true (this flag is set if the Vdbe may modify more than one row and may
67661 ** throw an ABORT exception), a statement transaction may also be opened.
67662 ** More specifically, a statement transaction is opened iff the database
67663 ** connection is currently not in autocommit mode, or if there are other
67664 ** active statements. A statement transaction allows the affects of this
67665 ** VDBE to be rolled back after an error without having to roll back the
67666 ** entire transaction. If no error is encountered, the statement transaction
67667 ** will automatically commit when the VDBE halts.
67668 **
67669 ** If P2 is zero, then a read-lock is obtained on the database file.
67670 */
67671 case OP_Transaction: {
67672 #if 0  /* local variables moved into u.as */
67673   Btree *pBt;
67674 #endif /* local variables moved into u.as */
67675
67676   assert( pOp->p1>=0 && pOp->p1<db->nDb );
67677   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
67678   u.as.pBt = db->aDb[pOp->p1].pBt;
67679
67680   if( u.as.pBt ){
67681     rc = sqlcipher3BtreeBeginTrans(u.as.pBt, pOp->p2);
67682     if( rc==SQLCIPHER_BUSY ){
67683       p->pc = pc;
67684       p->rc = rc = SQLCIPHER_BUSY;
67685       goto vdbe_return;
67686     }
67687     if( rc!=SQLCIPHER_OK ){
67688       goto abort_due_to_error;
67689     }
67690
67691     if( pOp->p2 && p->usesStmtJournal
67692      && (db->autoCommit==0 || db->activeVdbeCnt>1)
67693     ){
67694       assert( sqlcipher3BtreeIsInTrans(u.as.pBt) );
67695       if( p->iStatement==0 ){
67696         assert( db->nStatement>=0 && db->nSavepoint>=0 );
67697         db->nStatement++;
67698         p->iStatement = db->nSavepoint + db->nStatement;
67699       }
67700
67701       rc = sqlcipher3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
67702       if( rc==SQLCIPHER_OK ){
67703         rc = sqlcipher3BtreeBeginStmt(u.as.pBt, p->iStatement);
67704       }
67705
67706       /* Store the current value of the database handles deferred constraint
67707       ** counter. If the statement transaction needs to be rolled back,
67708       ** the value of this counter needs to be restored too.  */
67709       p->nStmtDefCons = db->nDeferredCons;
67710     }
67711   }
67712   break;
67713 }
67714
67715 /* Opcode: ReadCookie P1 P2 P3 * *
67716 **
67717 ** Read cookie number P3 from database P1 and write it into register P2.
67718 ** P3==1 is the schema version.  P3==2 is the database format.
67719 ** P3==3 is the recommended pager cache size, and so forth.  P1==0 is
67720 ** the main database file and P1==1 is the database file used to store
67721 ** temporary tables.
67722 **
67723 ** There must be a read-lock on the database (either a transaction
67724 ** must be started or there must be an open cursor) before
67725 ** executing this instruction.
67726 */
67727 case OP_ReadCookie: {               /* out2-prerelease */
67728 #if 0  /* local variables moved into u.at */
67729   int iMeta;
67730   int iDb;
67731   int iCookie;
67732 #endif /* local variables moved into u.at */
67733
67734   u.at.iDb = pOp->p1;
67735   u.at.iCookie = pOp->p3;
67736   assert( pOp->p3<SQLCIPHER_N_BTREE_META );
67737   assert( u.at.iDb>=0 && u.at.iDb<db->nDb );
67738   assert( db->aDb[u.at.iDb].pBt!=0 );
67739   assert( (p->btreeMask & (((yDbMask)1)<<u.at.iDb))!=0 );
67740
67741   sqlcipher3BtreeGetMeta(db->aDb[u.at.iDb].pBt, u.at.iCookie, (u32 *)&u.at.iMeta);
67742   pOut->u.i = u.at.iMeta;
67743   break;
67744 }
67745
67746 /* Opcode: SetCookie P1 P2 P3 * *
67747 **
67748 ** Write the content of register P3 (interpreted as an integer)
67749 ** into cookie number P2 of database P1.  P2==1 is the schema version.  
67750 ** P2==2 is the database format. P2==3 is the recommended pager cache 
67751 ** size, and so forth.  P1==0 is the main database file and P1==1 is the 
67752 ** database file used to store temporary tables.
67753 **
67754 ** A transaction must be started before executing this opcode.
67755 */
67756 case OP_SetCookie: {       /* in3 */
67757 #if 0  /* local variables moved into u.au */
67758   Db *pDb;
67759 #endif /* local variables moved into u.au */
67760   assert( pOp->p2<SQLCIPHER_N_BTREE_META );
67761   assert( pOp->p1>=0 && pOp->p1<db->nDb );
67762   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
67763   u.au.pDb = &db->aDb[pOp->p1];
67764   assert( u.au.pDb->pBt!=0 );
67765   assert( sqlcipher3SchemaMutexHeld(db, pOp->p1, 0) );
67766   pIn3 = &aMem[pOp->p3];
67767   sqlcipher3VdbeMemIntegerify(pIn3);
67768   /* See note about index shifting on OP_ReadCookie */
67769   rc = sqlcipher3BtreeUpdateMeta(u.au.pDb->pBt, pOp->p2, (int)pIn3->u.i);
67770   if( pOp->p2==BTREE_SCHEMA_VERSION ){
67771     /* When the schema cookie changes, record the new cookie internally */
67772     u.au.pDb->pSchema->schema_cookie = (int)pIn3->u.i;
67773     db->flags |= SQLCIPHER_InternChanges;
67774   }else if( pOp->p2==BTREE_FILE_FORMAT ){
67775     /* Record changes in the file format */
67776     u.au.pDb->pSchema->file_format = (u8)pIn3->u.i;
67777   }
67778   if( pOp->p1==1 ){
67779     /* Invalidate all prepared statements whenever the TEMP database
67780     ** schema is changed.  Ticket #1644 */
67781     sqlcipher3ExpirePreparedStatements(db);
67782     p->expired = 0;
67783   }
67784   break;
67785 }
67786
67787 /* Opcode: VerifyCookie P1 P2 P3 * *
67788 **
67789 ** Check the value of global database parameter number 0 (the
67790 ** schema version) and make sure it is equal to P2 and that the
67791 ** generation counter on the local schema parse equals P3.
67792 **
67793 ** P1 is the database number which is 0 for the main database file
67794 ** and 1 for the file holding temporary tables and some higher number
67795 ** for auxiliary databases.
67796 **
67797 ** The cookie changes its value whenever the database schema changes.
67798 ** This operation is used to detect when that the cookie has changed
67799 ** and that the current process needs to reread the schema.
67800 **
67801 ** Either a transaction needs to have been started or an OP_Open needs
67802 ** to be executed (to establish a read lock) before this opcode is
67803 ** invoked.
67804 */
67805 case OP_VerifyCookie: {
67806 #if 0  /* local variables moved into u.av */
67807   int iMeta;
67808   int iGen;
67809   Btree *pBt;
67810 #endif /* local variables moved into u.av */
67811
67812   assert( pOp->p1>=0 && pOp->p1<db->nDb );
67813   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
67814   assert( sqlcipher3SchemaMutexHeld(db, pOp->p1, 0) );
67815   u.av.pBt = db->aDb[pOp->p1].pBt;
67816   if( u.av.pBt ){
67817     sqlcipher3BtreeGetMeta(u.av.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.av.iMeta);
67818     u.av.iGen = db->aDb[pOp->p1].pSchema->iGeneration;
67819   }else{
67820     u.av.iGen = u.av.iMeta = 0;
67821   }
67822   if( u.av.iMeta!=pOp->p2 || u.av.iGen!=pOp->p3 ){
67823     sqlcipher3DbFree(db, p->zErrMsg);
67824     p->zErrMsg = sqlcipher3DbStrDup(db, "database schema has changed");
67825     /* If the schema-cookie from the database file matches the cookie
67826     ** stored with the in-memory representation of the schema, do
67827     ** not reload the schema from the database file.
67828     **
67829     ** If virtual-tables are in use, this is not just an optimization.
67830     ** Often, v-tables store their data in other SQLite tables, which
67831     ** are queried from within xNext() and other v-table methods using
67832     ** prepared queries. If such a query is out-of-date, we do not want to
67833     ** discard the database schema, as the user code implementing the
67834     ** v-table would have to be ready for the sqlcipher3_vtab structure itself
67835     ** to be invalidated whenever sqlcipher3_step() is called from within
67836     ** a v-table method.
67837     */
67838     if( db->aDb[pOp->p1].pSchema->schema_cookie!=u.av.iMeta ){
67839       sqlcipher3ResetInternalSchema(db, pOp->p1);
67840     }
67841
67842     p->expired = 1;
67843     rc = SQLCIPHER_SCHEMA;
67844   }
67845   break;
67846 }
67847
67848 /* Opcode: OpenRead P1 P2 P3 P4 P5
67849 **
67850 ** Open a read-only cursor for the database table whose root page is
67851 ** P2 in a database file.  The database file is determined by P3. 
67852 ** P3==0 means the main database, P3==1 means the database used for 
67853 ** temporary tables, and P3>1 means used the corresponding attached
67854 ** database.  Give the new cursor an identifier of P1.  The P1
67855 ** values need not be contiguous but all P1 values should be small integers.
67856 ** It is an error for P1 to be negative.
67857 **
67858 ** If P5!=0 then use the content of register P2 as the root page, not
67859 ** the value of P2 itself.
67860 **
67861 ** There will be a read lock on the database whenever there is an
67862 ** open cursor.  If the database was unlocked prior to this instruction
67863 ** then a read lock is acquired as part of this instruction.  A read
67864 ** lock allows other processes to read the database but prohibits
67865 ** any other process from modifying the database.  The read lock is
67866 ** released when all cursors are closed.  If this instruction attempts
67867 ** to get a read lock but fails, the script terminates with an
67868 ** SQLCIPHER_BUSY error code.
67869 **
67870 ** The P4 value may be either an integer (P4_INT32) or a pointer to
67871 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo 
67872 ** structure, then said structure defines the content and collating 
67873 ** sequence of the index being opened. Otherwise, if P4 is an integer 
67874 ** value, it is set to the number of columns in the table.
67875 **
67876 ** See also OpenWrite.
67877 */
67878 /* Opcode: OpenWrite P1 P2 P3 P4 P5
67879 **
67880 ** Open a read/write cursor named P1 on the table or index whose root
67881 ** page is P2.  Or if P5!=0 use the content of register P2 to find the
67882 ** root page.
67883 **
67884 ** The P4 value may be either an integer (P4_INT32) or a pointer to
67885 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo 
67886 ** structure, then said structure defines the content and collating 
67887 ** sequence of the index being opened. Otherwise, if P4 is an integer 
67888 ** value, it is set to the number of columns in the table, or to the
67889 ** largest index of any column of the table that is actually used.
67890 **
67891 ** This instruction works just like OpenRead except that it opens the cursor
67892 ** in read/write mode.  For a given table, there can be one or more read-only
67893 ** cursors or a single read/write cursor but not both.
67894 **
67895 ** See also OpenRead.
67896 */
67897 case OP_OpenRead:
67898 case OP_OpenWrite: {
67899 #if 0  /* local variables moved into u.aw */
67900   int nField;
67901   KeyInfo *pKeyInfo;
67902   int p2;
67903   int iDb;
67904   int wrFlag;
67905   Btree *pX;
67906   VdbeCursor *pCur;
67907   Db *pDb;
67908 #endif /* local variables moved into u.aw */
67909
67910   if( p->expired ){
67911     rc = SQLCIPHER_ABORT;
67912     break;
67913   }
67914
67915   u.aw.nField = 0;
67916   u.aw.pKeyInfo = 0;
67917   u.aw.p2 = pOp->p2;
67918   u.aw.iDb = pOp->p3;
67919   assert( u.aw.iDb>=0 && u.aw.iDb<db->nDb );
67920   assert( (p->btreeMask & (((yDbMask)1)<<u.aw.iDb))!=0 );
67921   u.aw.pDb = &db->aDb[u.aw.iDb];
67922   u.aw.pX = u.aw.pDb->pBt;
67923   assert( u.aw.pX!=0 );
67924   if( pOp->opcode==OP_OpenWrite ){
67925     u.aw.wrFlag = 1;
67926     assert( sqlcipher3SchemaMutexHeld(db, u.aw.iDb, 0) );
67927     if( u.aw.pDb->pSchema->file_format < p->minWriteFileFormat ){
67928       p->minWriteFileFormat = u.aw.pDb->pSchema->file_format;
67929     }
67930   }else{
67931     u.aw.wrFlag = 0;
67932   }
67933   if( pOp->p5 ){
67934     assert( u.aw.p2>0 );
67935     assert( u.aw.p2<=p->nMem );
67936     pIn2 = &aMem[u.aw.p2];
67937     assert( memIsValid(pIn2) );
67938     assert( (pIn2->flags & MEM_Int)!=0 );
67939     sqlcipher3VdbeMemIntegerify(pIn2);
67940     u.aw.p2 = (int)pIn2->u.i;
67941     /* The u.aw.p2 value always comes from a prior OP_CreateTable opcode and
67942     ** that opcode will always set the u.aw.p2 value to 2 or more or else fail.
67943     ** If there were a failure, the prepared statement would have halted
67944     ** before reaching this instruction. */
67945     if( NEVER(u.aw.p2<2) ) {
67946       rc = SQLCIPHER_CORRUPT_BKPT;
67947       goto abort_due_to_error;
67948     }
67949   }
67950   if( pOp->p4type==P4_KEYINFO ){
67951     u.aw.pKeyInfo = pOp->p4.pKeyInfo;
67952     u.aw.pKeyInfo->enc = ENC(p->db);
67953     u.aw.nField = u.aw.pKeyInfo->nField+1;
67954   }else if( pOp->p4type==P4_INT32 ){
67955     u.aw.nField = pOp->p4.i;
67956   }
67957   assert( pOp->p1>=0 );
67958   u.aw.pCur = allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
67959   if( u.aw.pCur==0 ) goto no_mem;
67960   u.aw.pCur->nullRow = 1;
67961   u.aw.pCur->isOrdered = 1;
67962   rc = sqlcipher3BtreeCursor(u.aw.pX, u.aw.p2, u.aw.wrFlag, u.aw.pKeyInfo, u.aw.pCur->pCursor);
67963   u.aw.pCur->pKeyInfo = u.aw.pKeyInfo;
67964
67965   /* Since it performs no memory allocation or IO, the only value that
67966   ** sqlcipher3BtreeCursor() may return is SQLCIPHER_OK. */
67967   assert( rc==SQLCIPHER_OK );
67968
67969   /* Set the VdbeCursor.isTable and isIndex variables. Previous versions of
67970   ** SQLite used to check if the root-page flags were sane at this point
67971   ** and report database corruption if they were not, but this check has
67972   ** since moved into the btree layer.  */
67973   u.aw.pCur->isTable = pOp->p4type!=P4_KEYINFO;
67974   u.aw.pCur->isIndex = !u.aw.pCur->isTable;
67975   break;
67976 }
67977
67978 /* Opcode: OpenEphemeral P1 P2 * P4 P5
67979 **
67980 ** Open a new cursor P1 to a transient table.
67981 ** The cursor is always opened read/write even if 
67982 ** the main database is read-only.  The ephemeral
67983 ** table is deleted automatically when the cursor is closed.
67984 **
67985 ** P2 is the number of columns in the ephemeral table.
67986 ** The cursor points to a BTree table if P4==0 and to a BTree index
67987 ** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
67988 ** that defines the format of keys in the index.
67989 **
67990 ** This opcode was once called OpenTemp.  But that created
67991 ** confusion because the term "temp table", might refer either
67992 ** to a TEMP table at the SQL level, or to a table opened by
67993 ** this opcode.  Then this opcode was call OpenVirtual.  But
67994 ** that created confusion with the whole virtual-table idea.
67995 **
67996 ** The P5 parameter can be a mask of the BTREE_* flags defined
67997 ** in btree.h.  These flags control aspects of the operation of
67998 ** the btree.  The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
67999 ** added automatically.
68000 */
68001 /* Opcode: OpenAutoindex P1 P2 * P4 *
68002 **
68003 ** This opcode works the same as OP_OpenEphemeral.  It has a
68004 ** different name to distinguish its use.  Tables created using
68005 ** by this opcode will be used for automatically created transient
68006 ** indices in joins.
68007 */
68008 case OP_OpenAutoindex: 
68009 case OP_OpenEphemeral: {
68010 #if 0  /* local variables moved into u.ax */
68011   VdbeCursor *pCx;
68012 #endif /* local variables moved into u.ax */
68013   static const int vfsFlags =
68014       SQLCIPHER_OPEN_READWRITE |
68015       SQLCIPHER_OPEN_CREATE |
68016       SQLCIPHER_OPEN_EXCLUSIVE |
68017       SQLCIPHER_OPEN_DELETEONCLOSE |
68018       SQLCIPHER_OPEN_TRANSIENT_DB;
68019
68020   assert( pOp->p1>=0 );
68021   u.ax.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68022   if( u.ax.pCx==0 ) goto no_mem;
68023   u.ax.pCx->nullRow = 1;
68024   rc = sqlcipher3BtreeOpen(db->pVfs, 0, db, &u.ax.pCx->pBt,
68025                         BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, vfsFlags);
68026   if( rc==SQLCIPHER_OK ){
68027     rc = sqlcipher3BtreeBeginTrans(u.ax.pCx->pBt, 1);
68028   }
68029   if( rc==SQLCIPHER_OK ){
68030     /* If a transient index is required, create it by calling
68031     ** sqlcipher3BtreeCreateTable() with the BTREE_BLOBKEY flag before
68032     ** opening it. If a transient table is required, just use the
68033     ** automatically created table with root-page 1 (an BLOB_INTKEY table).
68034     */
68035     if( pOp->p4.pKeyInfo ){
68036       int pgno;
68037       assert( pOp->p4type==P4_KEYINFO );
68038       rc = sqlcipher3BtreeCreateTable(u.ax.pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
68039       if( rc==SQLCIPHER_OK ){
68040         assert( pgno==MASTER_ROOT+1 );
68041         rc = sqlcipher3BtreeCursor(u.ax.pCx->pBt, pgno, 1,
68042                                 (KeyInfo*)pOp->p4.z, u.ax.pCx->pCursor);
68043         u.ax.pCx->pKeyInfo = pOp->p4.pKeyInfo;
68044         u.ax.pCx->pKeyInfo->enc = ENC(p->db);
68045       }
68046       u.ax.pCx->isTable = 0;
68047     }else{
68048       rc = sqlcipher3BtreeCursor(u.ax.pCx->pBt, MASTER_ROOT, 1, 0, u.ax.pCx->pCursor);
68049       u.ax.pCx->isTable = 1;
68050     }
68051   }
68052   u.ax.pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
68053   u.ax.pCx->isIndex = !u.ax.pCx->isTable;
68054   break;
68055 }
68056
68057 /* Opcode: OpenSorter P1 P2 * P4 *
68058 **
68059 ** This opcode works like OP_OpenEphemeral except that it opens
68060 ** a transient index that is specifically designed to sort large
68061 ** tables using an external merge-sort algorithm.
68062 */
68063 case OP_SorterOpen: {
68064 #if 0  /* local variables moved into u.ay */
68065   VdbeCursor *pCx;
68066 #endif /* local variables moved into u.ay */
68067 #ifndef SQLCIPHER_OMIT_MERGE_SORT
68068   u.ay.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68069   if( u.ay.pCx==0 ) goto no_mem;
68070   u.ay.pCx->pKeyInfo = pOp->p4.pKeyInfo;
68071   u.ay.pCx->pKeyInfo->enc = ENC(p->db);
68072   u.ay.pCx->isSorter = 1;
68073   rc = sqlcipher3VdbeSorterInit(db, u.ay.pCx);
68074 #else
68075   pOp->opcode = OP_OpenEphemeral;
68076   pc--;
68077 #endif
68078   break;
68079 }
68080
68081 /* Opcode: OpenPseudo P1 P2 P3 * *
68082 **
68083 ** Open a new cursor that points to a fake table that contains a single
68084 ** row of data.  The content of that one row in the content of memory
68085 ** register P2.  In other words, cursor P1 becomes an alias for the 
68086 ** MEM_Blob content contained in register P2.
68087 **
68088 ** A pseudo-table created by this opcode is used to hold a single
68089 ** row output from the sorter so that the row can be decomposed into
68090 ** individual columns using the OP_Column opcode.  The OP_Column opcode
68091 ** is the only cursor opcode that works with a pseudo-table.
68092 **
68093 ** P3 is the number of fields in the records that will be stored by
68094 ** the pseudo-table.
68095 */
68096 case OP_OpenPseudo: {
68097 #if 0  /* local variables moved into u.az */
68098   VdbeCursor *pCx;
68099 #endif /* local variables moved into u.az */
68100
68101   assert( pOp->p1>=0 );
68102   u.az.pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0);
68103   if( u.az.pCx==0 ) goto no_mem;
68104   u.az.pCx->nullRow = 1;
68105   u.az.pCx->pseudoTableReg = pOp->p2;
68106   u.az.pCx->isTable = 1;
68107   u.az.pCx->isIndex = 0;
68108   break;
68109 }
68110
68111 /* Opcode: Close P1 * * * *
68112 **
68113 ** Close a cursor previously opened as P1.  If P1 is not
68114 ** currently open, this instruction is a no-op.
68115 */
68116 case OP_Close: {
68117   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68118   sqlcipher3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
68119   p->apCsr[pOp->p1] = 0;
68120   break;
68121 }
68122
68123 /* Opcode: SeekGe P1 P2 P3 P4 *
68124 **
68125 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
68126 ** use the value in register P3 as the key.  If cursor P1 refers 
68127 ** to an SQL index, then P3 is the first in an array of P4 registers 
68128 ** that are used as an unpacked index key. 
68129 **
68130 ** Reposition cursor P1 so that  it points to the smallest entry that 
68131 ** is greater than or equal to the key value. If there are no records 
68132 ** greater than or equal to the key and P2 is not zero, then jump to P2.
68133 **
68134 ** See also: Found, NotFound, Distinct, SeekLt, SeekGt, SeekLe
68135 */
68136 /* Opcode: SeekGt P1 P2 P3 P4 *
68137 **
68138 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
68139 ** use the value in register P3 as a key. If cursor P1 refers 
68140 ** to an SQL index, then P3 is the first in an array of P4 registers 
68141 ** that are used as an unpacked index key. 
68142 **
68143 ** Reposition cursor P1 so that  it points to the smallest entry that 
68144 ** is greater than the key value. If there are no records greater than 
68145 ** the key and P2 is not zero, then jump to P2.
68146 **
68147 ** See also: Found, NotFound, Distinct, SeekLt, SeekGe, SeekLe
68148 */
68149 /* Opcode: SeekLt P1 P2 P3 P4 * 
68150 **
68151 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
68152 ** use the value in register P3 as a key. If cursor P1 refers 
68153 ** to an SQL index, then P3 is the first in an array of P4 registers 
68154 ** that are used as an unpacked index key. 
68155 **
68156 ** Reposition cursor P1 so that  it points to the largest entry that 
68157 ** is less than the key value. If there are no records less than 
68158 ** the key and P2 is not zero, then jump to P2.
68159 **
68160 ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLe
68161 */
68162 /* Opcode: SeekLe P1 P2 P3 P4 *
68163 **
68164 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
68165 ** use the value in register P3 as a key. If cursor P1 refers 
68166 ** to an SQL index, then P3 is the first in an array of P4 registers 
68167 ** that are used as an unpacked index key. 
68168 **
68169 ** Reposition cursor P1 so that it points to the largest entry that 
68170 ** is less than or equal to the key value. If there are no records 
68171 ** less than or equal to the key and P2 is not zero, then jump to P2.
68172 **
68173 ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLt
68174 */
68175 case OP_SeekLt:         /* jump, in3 */
68176 case OP_SeekLe:         /* jump, in3 */
68177 case OP_SeekGe:         /* jump, in3 */
68178 case OP_SeekGt: {       /* jump, in3 */
68179 #if 0  /* local variables moved into u.ba */
68180   int res;
68181   int oc;
68182   VdbeCursor *pC;
68183   UnpackedRecord r;
68184   int nField;
68185   i64 iKey;      /* The rowid we are to seek to */
68186 #endif /* local variables moved into u.ba */
68187
68188   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68189   assert( pOp->p2!=0 );
68190   u.ba.pC = p->apCsr[pOp->p1];
68191   assert( u.ba.pC!=0 );
68192   assert( u.ba.pC->pseudoTableReg==0 );
68193   assert( OP_SeekLe == OP_SeekLt+1 );
68194   assert( OP_SeekGe == OP_SeekLt+2 );
68195   assert( OP_SeekGt == OP_SeekLt+3 );
68196   assert( u.ba.pC->isOrdered );
68197   if( ALWAYS(u.ba.pC->pCursor!=0) ){
68198     u.ba.oc = pOp->opcode;
68199     u.ba.pC->nullRow = 0;
68200     if( u.ba.pC->isTable ){
68201       /* The input value in P3 might be of any type: integer, real, string,
68202       ** blob, or NULL.  But it needs to be an integer before we can do
68203       ** the seek, so covert it. */
68204       pIn3 = &aMem[pOp->p3];
68205       applyNumericAffinity(pIn3);
68206       u.ba.iKey = sqlcipher3VdbeIntValue(pIn3);
68207       u.ba.pC->rowidIsValid = 0;
68208
68209       /* If the P3 value could not be converted into an integer without
68210       ** loss of information, then special processing is required... */
68211       if( (pIn3->flags & MEM_Int)==0 ){
68212         if( (pIn3->flags & MEM_Real)==0 ){
68213           /* If the P3 value cannot be converted into any kind of a number,
68214           ** then the seek is not possible, so jump to P2 */
68215           pc = pOp->p2 - 1;
68216           break;
68217         }
68218         /* If we reach this point, then the P3 value must be a floating
68219         ** point number. */
68220         assert( (pIn3->flags & MEM_Real)!=0 );
68221
68222         if( u.ba.iKey==SMALLEST_INT64 && (pIn3->r<(double)u.ba.iKey || pIn3->r>0) ){
68223           /* The P3 value is too large in magnitude to be expressed as an
68224           ** integer. */
68225           u.ba.res = 1;
68226           if( pIn3->r<0 ){
68227             if( u.ba.oc>=OP_SeekGe ){  assert( u.ba.oc==OP_SeekGe || u.ba.oc==OP_SeekGt );
68228               rc = sqlcipher3BtreeFirst(u.ba.pC->pCursor, &u.ba.res);
68229               if( rc!=SQLCIPHER_OK ) goto abort_due_to_error;
68230             }
68231           }else{
68232             if( u.ba.oc<=OP_SeekLe ){  assert( u.ba.oc==OP_SeekLt || u.ba.oc==OP_SeekLe );
68233               rc = sqlcipher3BtreeLast(u.ba.pC->pCursor, &u.ba.res);
68234               if( rc!=SQLCIPHER_OK ) goto abort_due_to_error;
68235             }
68236           }
68237           if( u.ba.res ){
68238             pc = pOp->p2 - 1;
68239           }
68240           break;
68241         }else if( u.ba.oc==OP_SeekLt || u.ba.oc==OP_SeekGe ){
68242           /* Use the ceiling() function to convert real->int */
68243           if( pIn3->r > (double)u.ba.iKey ) u.ba.iKey++;
68244         }else{
68245           /* Use the floor() function to convert real->int */
68246           assert( u.ba.oc==OP_SeekLe || u.ba.oc==OP_SeekGt );
68247           if( pIn3->r < (double)u.ba.iKey ) u.ba.iKey--;
68248         }
68249       }
68250       rc = sqlcipher3BtreeMovetoUnpacked(u.ba.pC->pCursor, 0, (u64)u.ba.iKey, 0, &u.ba.res);
68251       if( rc!=SQLCIPHER_OK ){
68252         goto abort_due_to_error;
68253       }
68254       if( u.ba.res==0 ){
68255         u.ba.pC->rowidIsValid = 1;
68256         u.ba.pC->lastRowid = u.ba.iKey;
68257       }
68258     }else{
68259       u.ba.nField = pOp->p4.i;
68260       assert( pOp->p4type==P4_INT32 );
68261       assert( u.ba.nField>0 );
68262       u.ba.r.pKeyInfo = u.ba.pC->pKeyInfo;
68263       u.ba.r.nField = (u16)u.ba.nField;
68264
68265       /* The next line of code computes as follows, only faster:
68266       **   if( u.ba.oc==OP_SeekGt || u.ba.oc==OP_SeekLe ){
68267       **     u.ba.r.flags = UNPACKED_INCRKEY;
68268       **   }else{
68269       **     u.ba.r.flags = 0;
68270       **   }
68271       */
68272       u.ba.r.flags = (u16)(UNPACKED_INCRKEY * (1 & (u.ba.oc - OP_SeekLt)));
68273       assert( u.ba.oc!=OP_SeekGt || u.ba.r.flags==UNPACKED_INCRKEY );
68274       assert( u.ba.oc!=OP_SeekLe || u.ba.r.flags==UNPACKED_INCRKEY );
68275       assert( u.ba.oc!=OP_SeekGe || u.ba.r.flags==0 );
68276       assert( u.ba.oc!=OP_SeekLt || u.ba.r.flags==0 );
68277
68278       u.ba.r.aMem = &aMem[pOp->p3];
68279 #ifdef SQLCIPHER_DEBUG
68280       { int i; for(i=0; i<u.ba.r.nField; i++) assert( memIsValid(&u.ba.r.aMem[i]) ); }
68281 #endif
68282       ExpandBlob(u.ba.r.aMem);
68283       rc = sqlcipher3BtreeMovetoUnpacked(u.ba.pC->pCursor, &u.ba.r, 0, 0, &u.ba.res);
68284       if( rc!=SQLCIPHER_OK ){
68285         goto abort_due_to_error;
68286       }
68287       u.ba.pC->rowidIsValid = 0;
68288     }
68289     u.ba.pC->deferredMoveto = 0;
68290     u.ba.pC->cacheStatus = CACHE_STALE;
68291 #ifdef SQLCIPHER_TEST
68292     sqlcipher3_search_count++;
68293 #endif
68294     if( u.ba.oc>=OP_SeekGe ){  assert( u.ba.oc==OP_SeekGe || u.ba.oc==OP_SeekGt );
68295       if( u.ba.res<0 || (u.ba.res==0 && u.ba.oc==OP_SeekGt) ){
68296         rc = sqlcipher3BtreeNext(u.ba.pC->pCursor, &u.ba.res);
68297         if( rc!=SQLCIPHER_OK ) goto abort_due_to_error;
68298         u.ba.pC->rowidIsValid = 0;
68299       }else{
68300         u.ba.res = 0;
68301       }
68302     }else{
68303       assert( u.ba.oc==OP_SeekLt || u.ba.oc==OP_SeekLe );
68304       if( u.ba.res>0 || (u.ba.res==0 && u.ba.oc==OP_SeekLt) ){
68305         rc = sqlcipher3BtreePrevious(u.ba.pC->pCursor, &u.ba.res);
68306         if( rc!=SQLCIPHER_OK ) goto abort_due_to_error;
68307         u.ba.pC->rowidIsValid = 0;
68308       }else{
68309         /* u.ba.res might be negative because the table is empty.  Check to
68310         ** see if this is the case.
68311         */
68312         u.ba.res = sqlcipher3BtreeEof(u.ba.pC->pCursor);
68313       }
68314     }
68315     assert( pOp->p2>0 );
68316     if( u.ba.res ){
68317       pc = pOp->p2 - 1;
68318     }
68319   }else{
68320     /* This happens when attempting to open the sqlcipher3_master table
68321     ** for read access returns SQLCIPHER_EMPTY. In this case always
68322     ** take the jump (since there are no records in the table).
68323     */
68324     pc = pOp->p2 - 1;
68325   }
68326   break;
68327 }
68328
68329 /* Opcode: Seek P1 P2 * * *
68330 **
68331 ** P1 is an open table cursor and P2 is a rowid integer.  Arrange
68332 ** for P1 to move so that it points to the rowid given by P2.
68333 **
68334 ** This is actually a deferred seek.  Nothing actually happens until
68335 ** the cursor is used to read a record.  That way, if no reads
68336 ** occur, no unnecessary I/O happens.
68337 */
68338 case OP_Seek: {    /* in2 */
68339 #if 0  /* local variables moved into u.bb */
68340   VdbeCursor *pC;
68341 #endif /* local variables moved into u.bb */
68342
68343   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68344   u.bb.pC = p->apCsr[pOp->p1];
68345   assert( u.bb.pC!=0 );
68346   if( ALWAYS(u.bb.pC->pCursor!=0) ){
68347     assert( u.bb.pC->isTable );
68348     u.bb.pC->nullRow = 0;
68349     pIn2 = &aMem[pOp->p2];
68350     u.bb.pC->movetoTarget = sqlcipher3VdbeIntValue(pIn2);
68351     u.bb.pC->rowidIsValid = 0;
68352     u.bb.pC->deferredMoveto = 1;
68353   }
68354   break;
68355 }
68356   
68357
68358 /* Opcode: Found P1 P2 P3 P4 *
68359 **
68360 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
68361 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
68362 ** record.
68363 **
68364 ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
68365 ** is a prefix of any entry in P1 then a jump is made to P2 and
68366 ** P1 is left pointing at the matching entry.
68367 */
68368 /* Opcode: NotFound P1 P2 P3 P4 *
68369 **
68370 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
68371 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
68372 ** record.
68373 ** 
68374 ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
68375 ** is not the prefix of any entry in P1 then a jump is made to P2.  If P1 
68376 ** does contain an entry whose prefix matches the P3/P4 record then control
68377 ** falls through to the next instruction and P1 is left pointing at the
68378 ** matching entry.
68379 **
68380 ** See also: Found, NotExists, IsUnique
68381 */
68382 case OP_NotFound:       /* jump, in3 */
68383 case OP_Found: {        /* jump, in3 */
68384 #if 0  /* local variables moved into u.bc */
68385   int alreadyExists;
68386   VdbeCursor *pC;
68387   int res;
68388   char *pFree;
68389   UnpackedRecord *pIdxKey;
68390   UnpackedRecord r;
68391   char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
68392 #endif /* local variables moved into u.bc */
68393
68394 #ifdef SQLCIPHER_TEST
68395   sqlcipher3_found_count++;
68396 #endif
68397
68398   u.bc.alreadyExists = 0;
68399   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68400   assert( pOp->p4type==P4_INT32 );
68401   u.bc.pC = p->apCsr[pOp->p1];
68402   assert( u.bc.pC!=0 );
68403   pIn3 = &aMem[pOp->p3];
68404   if( ALWAYS(u.bc.pC->pCursor!=0) ){
68405
68406     assert( u.bc.pC->isTable==0 );
68407     if( pOp->p4.i>0 ){
68408       u.bc.r.pKeyInfo = u.bc.pC->pKeyInfo;
68409       u.bc.r.nField = (u16)pOp->p4.i;
68410       u.bc.r.aMem = pIn3;
68411 #ifdef SQLCIPHER_DEBUG
68412       { int i; for(i=0; i<u.bc.r.nField; i++) assert( memIsValid(&u.bc.r.aMem[i]) ); }
68413 #endif
68414       u.bc.r.flags = UNPACKED_PREFIX_MATCH;
68415       u.bc.pIdxKey = &u.bc.r;
68416     }else{
68417       u.bc.pIdxKey = sqlcipher3VdbeAllocUnpackedRecord(
68418           u.bc.pC->pKeyInfo, u.bc.aTempRec, sizeof(u.bc.aTempRec), &u.bc.pFree
68419       );
68420       if( u.bc.pIdxKey==0 ) goto no_mem;
68421       assert( pIn3->flags & MEM_Blob );
68422       assert( (pIn3->flags & MEM_Zero)==0 );  /* zeroblobs already expanded */
68423       sqlcipher3VdbeRecordUnpack(u.bc.pC->pKeyInfo, pIn3->n, pIn3->z, u.bc.pIdxKey);
68424       u.bc.pIdxKey->flags |= UNPACKED_PREFIX_MATCH;
68425     }
68426     rc = sqlcipher3BtreeMovetoUnpacked(u.bc.pC->pCursor, u.bc.pIdxKey, 0, 0, &u.bc.res);
68427     if( pOp->p4.i==0 ){
68428       sqlcipher3DbFree(db, u.bc.pFree);
68429     }
68430     if( rc!=SQLCIPHER_OK ){
68431       break;
68432     }
68433     u.bc.alreadyExists = (u.bc.res==0);
68434     u.bc.pC->deferredMoveto = 0;
68435     u.bc.pC->cacheStatus = CACHE_STALE;
68436   }
68437   if( pOp->opcode==OP_Found ){
68438     if( u.bc.alreadyExists ) pc = pOp->p2 - 1;
68439   }else{
68440     if( !u.bc.alreadyExists ) pc = pOp->p2 - 1;
68441   }
68442   break;
68443 }
68444
68445 /* Opcode: IsUnique P1 P2 P3 P4 *
68446 **
68447 ** Cursor P1 is open on an index b-tree - that is to say, a btree which
68448 ** no data and where the key are records generated by OP_MakeRecord with
68449 ** the list field being the integer ROWID of the entry that the index
68450 ** entry refers to.
68451 **
68452 ** The P3 register contains an integer record number. Call this record 
68453 ** number R. Register P4 is the first in a set of N contiguous registers
68454 ** that make up an unpacked index key that can be used with cursor P1.
68455 ** The value of N can be inferred from the cursor. N includes the rowid
68456 ** value appended to the end of the index record. This rowid value may
68457 ** or may not be the same as R.
68458 **
68459 ** If any of the N registers beginning with register P4 contains a NULL
68460 ** value, jump immediately to P2.
68461 **
68462 ** Otherwise, this instruction checks if cursor P1 contains an entry
68463 ** where the first (N-1) fields match but the rowid value at the end
68464 ** of the index entry is not R. If there is no such entry, control jumps
68465 ** to instruction P2. Otherwise, the rowid of the conflicting index
68466 ** entry is copied to register P3 and control falls through to the next
68467 ** instruction.
68468 **
68469 ** See also: NotFound, NotExists, Found
68470 */
68471 case OP_IsUnique: {        /* jump, in3 */
68472 #if 0  /* local variables moved into u.bd */
68473   u16 ii;
68474   VdbeCursor *pCx;
68475   BtCursor *pCrsr;
68476   u16 nField;
68477   Mem *aMx;
68478   UnpackedRecord r;                  /* B-Tree index search key */
68479   i64 R;                             /* Rowid stored in register P3 */
68480 #endif /* local variables moved into u.bd */
68481
68482   pIn3 = &aMem[pOp->p3];
68483   u.bd.aMx = &aMem[pOp->p4.i];
68484   /* Assert that the values of parameters P1 and P4 are in range. */
68485   assert( pOp->p4type==P4_INT32 );
68486   assert( pOp->p4.i>0 && pOp->p4.i<=p->nMem );
68487   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68488
68489   /* Find the index cursor. */
68490   u.bd.pCx = p->apCsr[pOp->p1];
68491   assert( u.bd.pCx->deferredMoveto==0 );
68492   u.bd.pCx->seekResult = 0;
68493   u.bd.pCx->cacheStatus = CACHE_STALE;
68494   u.bd.pCrsr = u.bd.pCx->pCursor;
68495
68496   /* If any of the values are NULL, take the jump. */
68497   u.bd.nField = u.bd.pCx->pKeyInfo->nField;
68498   for(u.bd.ii=0; u.bd.ii<u.bd.nField; u.bd.ii++){
68499     if( u.bd.aMx[u.bd.ii].flags & MEM_Null ){
68500       pc = pOp->p2 - 1;
68501       u.bd.pCrsr = 0;
68502       break;
68503     }
68504   }
68505   assert( (u.bd.aMx[u.bd.nField].flags & MEM_Null)==0 );
68506
68507   if( u.bd.pCrsr!=0 ){
68508     /* Populate the index search key. */
68509     u.bd.r.pKeyInfo = u.bd.pCx->pKeyInfo;
68510     u.bd.r.nField = u.bd.nField + 1;
68511     u.bd.r.flags = UNPACKED_PREFIX_SEARCH;
68512     u.bd.r.aMem = u.bd.aMx;
68513 #ifdef SQLCIPHER_DEBUG
68514     { int i; for(i=0; i<u.bd.r.nField; i++) assert( memIsValid(&u.bd.r.aMem[i]) ); }
68515 #endif
68516
68517     /* Extract the value of u.bd.R from register P3. */
68518     sqlcipher3VdbeMemIntegerify(pIn3);
68519     u.bd.R = pIn3->u.i;
68520
68521     /* Search the B-Tree index. If no conflicting record is found, jump
68522     ** to P2. Otherwise, copy the rowid of the conflicting record to
68523     ** register P3 and fall through to the next instruction.  */
68524     rc = sqlcipher3BtreeMovetoUnpacked(u.bd.pCrsr, &u.bd.r, 0, 0, &u.bd.pCx->seekResult);
68525     if( (u.bd.r.flags & UNPACKED_PREFIX_SEARCH) || u.bd.r.rowid==u.bd.R ){
68526       pc = pOp->p2 - 1;
68527     }else{
68528       pIn3->u.i = u.bd.r.rowid;
68529     }
68530   }
68531   break;
68532 }
68533
68534 /* Opcode: NotExists P1 P2 P3 * *
68535 **
68536 ** Use the content of register P3 as an integer key.  If a record 
68537 ** with that key does not exist in table of P1, then jump to P2. 
68538 ** If the record does exist, then fall through.  The cursor is left 
68539 ** pointing to the record if it exists.
68540 **
68541 ** The difference between this operation and NotFound is that this
68542 ** operation assumes the key is an integer and that P1 is a table whereas
68543 ** NotFound assumes key is a blob constructed from MakeRecord and
68544 ** P1 is an index.
68545 **
68546 ** See also: Found, NotFound, IsUnique
68547 */
68548 case OP_NotExists: {        /* jump, in3 */
68549 #if 0  /* local variables moved into u.be */
68550   VdbeCursor *pC;
68551   BtCursor *pCrsr;
68552   int res;
68553   u64 iKey;
68554 #endif /* local variables moved into u.be */
68555
68556   pIn3 = &aMem[pOp->p3];
68557   assert( pIn3->flags & MEM_Int );
68558   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68559   u.be.pC = p->apCsr[pOp->p1];
68560   assert( u.be.pC!=0 );
68561   assert( u.be.pC->isTable );
68562   assert( u.be.pC->pseudoTableReg==0 );
68563   u.be.pCrsr = u.be.pC->pCursor;
68564   if( ALWAYS(u.be.pCrsr!=0) ){
68565     u.be.res = 0;
68566     u.be.iKey = pIn3->u.i;
68567     rc = sqlcipher3BtreeMovetoUnpacked(u.be.pCrsr, 0, u.be.iKey, 0, &u.be.res);
68568     u.be.pC->lastRowid = pIn3->u.i;
68569     u.be.pC->rowidIsValid = u.be.res==0 ?1:0;
68570     u.be.pC->nullRow = 0;
68571     u.be.pC->cacheStatus = CACHE_STALE;
68572     u.be.pC->deferredMoveto = 0;
68573     if( u.be.res!=0 ){
68574       pc = pOp->p2 - 1;
68575       assert( u.be.pC->rowidIsValid==0 );
68576     }
68577     u.be.pC->seekResult = u.be.res;
68578   }else{
68579     /* This happens when an attempt to open a read cursor on the
68580     ** sqlcipher_master table returns SQLCIPHER_EMPTY.
68581     */
68582     pc = pOp->p2 - 1;
68583     assert( u.be.pC->rowidIsValid==0 );
68584     u.be.pC->seekResult = 0;
68585   }
68586   break;
68587 }
68588
68589 /* Opcode: Sequence P1 P2 * * *
68590 **
68591 ** Find the next available sequence number for cursor P1.
68592 ** Write the sequence number into register P2.
68593 ** The sequence number on the cursor is incremented after this
68594 ** instruction.  
68595 */
68596 case OP_Sequence: {           /* out2-prerelease */
68597   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68598   assert( p->apCsr[pOp->p1]!=0 );
68599   pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
68600   break;
68601 }
68602
68603
68604 /* Opcode: NewRowid P1 P2 P3 * *
68605 **
68606 ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
68607 ** The record number is not previously used as a key in the database
68608 ** table that cursor P1 points to.  The new record number is written
68609 ** written to register P2.
68610 **
68611 ** If P3>0 then P3 is a register in the root frame of this VDBE that holds 
68612 ** the largest previously generated record number. No new record numbers are
68613 ** allowed to be less than this value. When this value reaches its maximum, 
68614 ** an SQLCIPHER_FULL error is generated. The P3 register is updated with the '
68615 ** generated record number. This P3 mechanism is used to help implement the
68616 ** AUTOINCREMENT feature.
68617 */
68618 case OP_NewRowid: {           /* out2-prerelease */
68619 #if 0  /* local variables moved into u.bf */
68620   i64 v;                 /* The new rowid */
68621   VdbeCursor *pC;        /* Cursor of table to get the new rowid */
68622   int res;               /* Result of an sqlcipher3BtreeLast() */
68623   int cnt;               /* Counter to limit the number of searches */
68624   Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
68625   VdbeFrame *pFrame;     /* Root frame of VDBE */
68626 #endif /* local variables moved into u.bf */
68627
68628   u.bf.v = 0;
68629   u.bf.res = 0;
68630   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68631   u.bf.pC = p->apCsr[pOp->p1];
68632   assert( u.bf.pC!=0 );
68633   if( NEVER(u.bf.pC->pCursor==0) ){
68634     /* The zero initialization above is all that is needed */
68635   }else{
68636     /* The next rowid or record number (different terms for the same
68637     ** thing) is obtained in a two-step algorithm.
68638     **
68639     ** First we attempt to find the largest existing rowid and add one
68640     ** to that.  But if the largest existing rowid is already the maximum
68641     ** positive integer, we have to fall through to the second
68642     ** probabilistic algorithm
68643     **
68644     ** The second algorithm is to select a rowid at random and see if
68645     ** it already exists in the table.  If it does not exist, we have
68646     ** succeeded.  If the random rowid does exist, we select a new one
68647     ** and try again, up to 100 times.
68648     */
68649     assert( u.bf.pC->isTable );
68650
68651 #ifdef SQLCIPHER_32BIT_ROWID
68652 #   define MAX_ROWID 0x7fffffff
68653 #else
68654     /* Some compilers complain about constants of the form 0x7fffffffffffffff.
68655     ** Others complain about 0x7ffffffffffffffffLL.  The following macro seems
68656     ** to provide the constant while making all compilers happy.
68657     */
68658 #   define MAX_ROWID  (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
68659 #endif
68660
68661     if( !u.bf.pC->useRandomRowid ){
68662       u.bf.v = sqlcipher3BtreeGetCachedRowid(u.bf.pC->pCursor);
68663       if( u.bf.v==0 ){
68664         rc = sqlcipher3BtreeLast(u.bf.pC->pCursor, &u.bf.res);
68665         if( rc!=SQLCIPHER_OK ){
68666           goto abort_due_to_error;
68667         }
68668         if( u.bf.res ){
68669           u.bf.v = 1;   /* IMP: R-61914-48074 */
68670         }else{
68671           assert( sqlcipher3BtreeCursorIsValid(u.bf.pC->pCursor) );
68672           rc = sqlcipher3BtreeKeySize(u.bf.pC->pCursor, &u.bf.v);
68673           assert( rc==SQLCIPHER_OK );   /* Cannot fail following BtreeLast() */
68674           if( u.bf.v==MAX_ROWID ){
68675             u.bf.pC->useRandomRowid = 1;
68676           }else{
68677             u.bf.v++;   /* IMP: R-29538-34987 */
68678           }
68679         }
68680       }
68681
68682 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
68683       if( pOp->p3 ){
68684         /* Assert that P3 is a valid memory cell. */
68685         assert( pOp->p3>0 );
68686         if( p->pFrame ){
68687           for(u.bf.pFrame=p->pFrame; u.bf.pFrame->pParent; u.bf.pFrame=u.bf.pFrame->pParent);
68688           /* Assert that P3 is a valid memory cell. */
68689           assert( pOp->p3<=u.bf.pFrame->nMem );
68690           u.bf.pMem = &u.bf.pFrame->aMem[pOp->p3];
68691         }else{
68692           /* Assert that P3 is a valid memory cell. */
68693           assert( pOp->p3<=p->nMem );
68694           u.bf.pMem = &aMem[pOp->p3];
68695           memAboutToChange(p, u.bf.pMem);
68696         }
68697         assert( memIsValid(u.bf.pMem) );
68698
68699         REGISTER_TRACE(pOp->p3, u.bf.pMem);
68700         sqlcipher3VdbeMemIntegerify(u.bf.pMem);
68701         assert( (u.bf.pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
68702         if( u.bf.pMem->u.i==MAX_ROWID || u.bf.pC->useRandomRowid ){
68703           rc = SQLCIPHER_FULL;   /* IMP: R-12275-61338 */
68704           goto abort_due_to_error;
68705         }
68706         if( u.bf.v<u.bf.pMem->u.i+1 ){
68707           u.bf.v = u.bf.pMem->u.i + 1;
68708         }
68709         u.bf.pMem->u.i = u.bf.v;
68710       }
68711 #endif
68712
68713       sqlcipher3BtreeSetCachedRowid(u.bf.pC->pCursor, u.bf.v<MAX_ROWID ? u.bf.v+1 : 0);
68714     }
68715     if( u.bf.pC->useRandomRowid ){
68716       /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
68717       ** largest possible integer (9223372036854775807) then the database
68718       ** engine starts picking positive candidate ROWIDs at random until
68719       ** it finds one that is not previously used. */
68720       assert( pOp->p3==0 );  /* We cannot be in random rowid mode if this is
68721                              ** an AUTOINCREMENT table. */
68722       /* on the first attempt, simply do one more than previous */
68723       u.bf.v = lastRowid;
68724       u.bf.v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
68725       u.bf.v++; /* ensure non-zero */
68726       u.bf.cnt = 0;
68727       while(   ((rc = sqlcipher3BtreeMovetoUnpacked(u.bf.pC->pCursor, 0, (u64)u.bf.v,
68728                                                  0, &u.bf.res))==SQLCIPHER_OK)
68729             && (u.bf.res==0)
68730             && (++u.bf.cnt<100)){
68731         /* collision - try another random rowid */
68732         sqlcipher3_randomness(sizeof(u.bf.v), &u.bf.v);
68733         if( u.bf.cnt<5 ){
68734           /* try "small" random rowids for the initial attempts */
68735           u.bf.v &= 0xffffff;
68736         }else{
68737           u.bf.v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
68738         }
68739         u.bf.v++; /* ensure non-zero */
68740       }
68741       if( rc==SQLCIPHER_OK && u.bf.res==0 ){
68742         rc = SQLCIPHER_FULL;   /* IMP: R-38219-53002 */
68743         goto abort_due_to_error;
68744       }
68745       assert( u.bf.v>0 );  /* EV: R-40812-03570 */
68746     }
68747     u.bf.pC->rowidIsValid = 0;
68748     u.bf.pC->deferredMoveto = 0;
68749     u.bf.pC->cacheStatus = CACHE_STALE;
68750   }
68751   pOut->u.i = u.bf.v;
68752   break;
68753 }
68754
68755 /* Opcode: Insert P1 P2 P3 P4 P5
68756 **
68757 ** Write an entry into the table of cursor P1.  A new entry is
68758 ** created if it doesn't already exist or the data for an existing
68759 ** entry is overwritten.  The data is the value MEM_Blob stored in register
68760 ** number P2. The key is stored in register P3. The key must
68761 ** be a MEM_Int.
68762 **
68763 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
68764 ** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
68765 ** then rowid is stored for subsequent return by the
68766 ** sqlcipher3_last_insert_rowid() function (otherwise it is unmodified).
68767 **
68768 ** If the OPFLAG_USESEEKRESULT flag of P5 is set and if the result of
68769 ** the last seek operation (OP_NotExists) was a success, then this
68770 ** operation will not attempt to find the appropriate row before doing
68771 ** the insert but will instead overwrite the row that the cursor is
68772 ** currently pointing to.  Presumably, the prior OP_NotExists opcode
68773 ** has already positioned the cursor correctly.  This is an optimization
68774 ** that boosts performance by avoiding redundant seeks.
68775 **
68776 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
68777 ** UPDATE operation.  Otherwise (if the flag is clear) then this opcode
68778 ** is part of an INSERT operation.  The difference is only important to
68779 ** the update hook.
68780 **
68781 ** Parameter P4 may point to a string containing the table-name, or
68782 ** may be NULL. If it is not NULL, then the update-hook 
68783 ** (sqlcipher3.xUpdateCallback) is invoked following a successful insert.
68784 **
68785 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
68786 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
68787 ** and register P2 becomes ephemeral.  If the cursor is changed, the
68788 ** value of register P2 will then change.  Make sure this does not
68789 ** cause any problems.)
68790 **
68791 ** This instruction only works on tables.  The equivalent instruction
68792 ** for indices is OP_IdxInsert.
68793 */
68794 /* Opcode: InsertInt P1 P2 P3 P4 P5
68795 **
68796 ** This works exactly like OP_Insert except that the key is the
68797 ** integer value P3, not the value of the integer stored in register P3.
68798 */
68799 case OP_Insert: 
68800 case OP_InsertInt: {
68801 #if 0  /* local variables moved into u.bg */
68802   Mem *pData;       /* MEM cell holding data for the record to be inserted */
68803   Mem *pKey;        /* MEM cell holding key  for the record */
68804   i64 iKey;         /* The integer ROWID or key for the record to be inserted */
68805   VdbeCursor *pC;   /* Cursor to table into which insert is written */
68806   int nZero;        /* Number of zero-bytes to append */
68807   int seekResult;   /* Result of prior seek or 0 if no USESEEKRESULT flag */
68808   const char *zDb;  /* database name - used by the update hook */
68809   const char *zTbl; /* Table name - used by the opdate hook */
68810   int op;           /* Opcode for update hook: SQLCIPHER_UPDATE or SQLCIPHER_INSERT */
68811 #endif /* local variables moved into u.bg */
68812
68813   u.bg.pData = &aMem[pOp->p2];
68814   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68815   assert( memIsValid(u.bg.pData) );
68816   u.bg.pC = p->apCsr[pOp->p1];
68817   assert( u.bg.pC!=0 );
68818   assert( u.bg.pC->pCursor!=0 );
68819   assert( u.bg.pC->pseudoTableReg==0 );
68820   assert( u.bg.pC->isTable );
68821   REGISTER_TRACE(pOp->p2, u.bg.pData);
68822
68823   if( pOp->opcode==OP_Insert ){
68824     u.bg.pKey = &aMem[pOp->p3];
68825     assert( u.bg.pKey->flags & MEM_Int );
68826     assert( memIsValid(u.bg.pKey) );
68827     REGISTER_TRACE(pOp->p3, u.bg.pKey);
68828     u.bg.iKey = u.bg.pKey->u.i;
68829   }else{
68830     assert( pOp->opcode==OP_InsertInt );
68831     u.bg.iKey = pOp->p3;
68832   }
68833
68834   if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
68835   if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = u.bg.iKey;
68836   if( u.bg.pData->flags & MEM_Null ){
68837     u.bg.pData->z = 0;
68838     u.bg.pData->n = 0;
68839   }else{
68840     assert( u.bg.pData->flags & (MEM_Blob|MEM_Str) );
68841   }
68842   u.bg.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bg.pC->seekResult : 0);
68843   if( u.bg.pData->flags & MEM_Zero ){
68844     u.bg.nZero = u.bg.pData->u.nZero;
68845   }else{
68846     u.bg.nZero = 0;
68847   }
68848   sqlcipher3BtreeSetCachedRowid(u.bg.pC->pCursor, 0);
68849   rc = sqlcipher3BtreeInsert(u.bg.pC->pCursor, 0, u.bg.iKey,
68850                           u.bg.pData->z, u.bg.pData->n, u.bg.nZero,
68851                           pOp->p5 & OPFLAG_APPEND, u.bg.seekResult
68852   );
68853   u.bg.pC->rowidIsValid = 0;
68854   u.bg.pC->deferredMoveto = 0;
68855   u.bg.pC->cacheStatus = CACHE_STALE;
68856
68857   /* Invoke the update-hook if required. */
68858   if( rc==SQLCIPHER_OK && db->xUpdateCallback && pOp->p4.z ){
68859     u.bg.zDb = db->aDb[u.bg.pC->iDb].zName;
68860     u.bg.zTbl = pOp->p4.z;
68861     u.bg.op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLCIPHER_UPDATE : SQLCIPHER_INSERT);
68862     assert( u.bg.pC->isTable );
68863     db->xUpdateCallback(db->pUpdateArg, u.bg.op, u.bg.zDb, u.bg.zTbl, u.bg.iKey);
68864     assert( u.bg.pC->iDb>=0 );
68865   }
68866   break;
68867 }
68868
68869 /* Opcode: Delete P1 P2 * P4 *
68870 **
68871 ** Delete the record at which the P1 cursor is currently pointing.
68872 **
68873 ** The cursor will be left pointing at either the next or the previous
68874 ** record in the table. If it is left pointing at the next record, then
68875 ** the next Next instruction will be a no-op.  Hence it is OK to delete
68876 ** a record from within an Next loop.
68877 **
68878 ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
68879 ** incremented (otherwise not).
68880 **
68881 ** P1 must not be pseudo-table.  It has to be a real table with
68882 ** multiple rows.
68883 **
68884 ** If P4 is not NULL, then it is the name of the table that P1 is
68885 ** pointing to.  The update hook will be invoked, if it exists.
68886 ** If P4 is not NULL then the P1 cursor must have been positioned
68887 ** using OP_NotFound prior to invoking this opcode.
68888 */
68889 case OP_Delete: {
68890 #if 0  /* local variables moved into u.bh */
68891   i64 iKey;
68892   VdbeCursor *pC;
68893 #endif /* local variables moved into u.bh */
68894
68895   u.bh.iKey = 0;
68896   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68897   u.bh.pC = p->apCsr[pOp->p1];
68898   assert( u.bh.pC!=0 );
68899   assert( u.bh.pC->pCursor!=0 );  /* Only valid for real tables, no pseudotables */
68900
68901   /* If the update-hook will be invoked, set u.bh.iKey to the rowid of the
68902   ** row being deleted.
68903   */
68904   if( db->xUpdateCallback && pOp->p4.z ){
68905     assert( u.bh.pC->isTable );
68906     assert( u.bh.pC->rowidIsValid );  /* lastRowid set by previous OP_NotFound */
68907     u.bh.iKey = u.bh.pC->lastRowid;
68908   }
68909
68910   /* The OP_Delete opcode always follows an OP_NotExists or OP_Last or
68911   ** OP_Column on the same table without any intervening operations that
68912   ** might move or invalidate the cursor.  Hence cursor u.bh.pC is always pointing
68913   ** to the row to be deleted and the sqlcipher3VdbeCursorMoveto() operation
68914   ** below is always a no-op and cannot fail.  We will run it anyhow, though,
68915   ** to guard against future changes to the code generator.
68916   **/
68917   assert( u.bh.pC->deferredMoveto==0 );
68918   rc = sqlcipher3VdbeCursorMoveto(u.bh.pC);
68919   if( NEVER(rc!=SQLCIPHER_OK) ) goto abort_due_to_error;
68920
68921   sqlcipher3BtreeSetCachedRowid(u.bh.pC->pCursor, 0);
68922   rc = sqlcipher3BtreeDelete(u.bh.pC->pCursor);
68923   u.bh.pC->cacheStatus = CACHE_STALE;
68924
68925   /* Invoke the update-hook if required. */
68926   if( rc==SQLCIPHER_OK && db->xUpdateCallback && pOp->p4.z ){
68927     const char *zDb = db->aDb[u.bh.pC->iDb].zName;
68928     const char *zTbl = pOp->p4.z;
68929     db->xUpdateCallback(db->pUpdateArg, SQLCIPHER_DELETE, zDb, zTbl, u.bh.iKey);
68930     assert( u.bh.pC->iDb>=0 );
68931   }
68932   if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
68933   break;
68934 }
68935 /* Opcode: ResetCount * * * * *
68936 **
68937 ** The value of the change counter is copied to the database handle
68938 ** change counter (returned by subsequent calls to sqlcipher3_changes()).
68939 ** Then the VMs internal change counter resets to 0.
68940 ** This is used by trigger programs.
68941 */
68942 case OP_ResetCount: {
68943   sqlcipher3VdbeSetChanges(db, p->nChange);
68944   p->nChange = 0;
68945   break;
68946 }
68947
68948 /* Opcode: SorterCompare P1 P2 P3
68949 **
68950 ** P1 is a sorter cursor. This instruction compares the record blob in 
68951 ** register P3 with the entry that the sorter cursor currently points to.
68952 ** If, excluding the rowid fields at the end, the two records are a match,
68953 ** fall through to the next instruction. Otherwise, jump to instruction P2.
68954 */
68955 case OP_SorterCompare: {
68956 #if 0  /* local variables moved into u.bi */
68957   VdbeCursor *pC;
68958   int res;
68959 #endif /* local variables moved into u.bi */
68960
68961   u.bi.pC = p->apCsr[pOp->p1];
68962   assert( isSorter(u.bi.pC) );
68963   pIn3 = &aMem[pOp->p3];
68964   rc = sqlcipher3VdbeSorterCompare(u.bi.pC, pIn3, &u.bi.res);
68965   if( u.bi.res ){
68966     pc = pOp->p2-1;
68967   }
68968   break;
68969 };
68970
68971 /* Opcode: SorterData P1 P2 * * *
68972 **
68973 ** Write into register P2 the current sorter data for sorter cursor P1.
68974 */
68975 case OP_SorterData: {
68976 #if 0  /* local variables moved into u.bj */
68977   VdbeCursor *pC;
68978 #endif /* local variables moved into u.bj */
68979 #ifndef SQLCIPHER_OMIT_MERGE_SORT
68980   pOut = &aMem[pOp->p2];
68981   u.bj.pC = p->apCsr[pOp->p1];
68982   assert( u.bj.pC->isSorter );
68983   rc = sqlcipher3VdbeSorterRowkey(u.bj.pC, pOut);
68984 #else
68985   pOp->opcode = OP_RowKey;
68986   pc--;
68987 #endif
68988   break;
68989 }
68990
68991 /* Opcode: RowData P1 P2 * * *
68992 **
68993 ** Write into register P2 the complete row data for cursor P1.
68994 ** There is no interpretation of the data.  
68995 ** It is just copied onto the P2 register exactly as 
68996 ** it is found in the database file.
68997 **
68998 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
68999 ** of a real table, not a pseudo-table.
69000 */
69001 /* Opcode: RowKey P1 P2 * * *
69002 **
69003 ** Write into register P2 the complete row key for cursor P1.
69004 ** There is no interpretation of the data.  
69005 ** The key is copied onto the P3 register exactly as 
69006 ** it is found in the database file.
69007 **
69008 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
69009 ** of a real table, not a pseudo-table.
69010 */
69011 case OP_RowKey:
69012 case OP_RowData: {
69013 #if 0  /* local variables moved into u.bk */
69014   VdbeCursor *pC;
69015   BtCursor *pCrsr;
69016   u32 n;
69017   i64 n64;
69018 #endif /* local variables moved into u.bk */
69019
69020   pOut = &aMem[pOp->p2];
69021   memAboutToChange(p, pOut);
69022
69023   /* Note that RowKey and RowData are really exactly the same instruction */
69024   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69025   u.bk.pC = p->apCsr[pOp->p1];
69026   assert( u.bk.pC->isSorter==0 );
69027   assert( u.bk.pC->isTable || pOp->opcode!=OP_RowData );
69028   assert( u.bk.pC->isIndex || pOp->opcode==OP_RowData );
69029   assert( u.bk.pC!=0 );
69030   assert( u.bk.pC->nullRow==0 );
69031   assert( u.bk.pC->pseudoTableReg==0 );
69032   assert( !u.bk.pC->isSorter );
69033   assert( u.bk.pC->pCursor!=0 );
69034   u.bk.pCrsr = u.bk.pC->pCursor;
69035   assert( sqlcipher3BtreeCursorIsValid(u.bk.pCrsr) );
69036
69037   /* The OP_RowKey and OP_RowData opcodes always follow OP_NotExists or
69038   ** OP_Rewind/Op_Next with no intervening instructions that might invalidate
69039   ** the cursor.  Hence the following sqlcipher3VdbeCursorMoveto() call is always
69040   ** a no-op and can never fail.  But we leave it in place as a safety.
69041   */
69042   assert( u.bk.pC->deferredMoveto==0 );
69043   rc = sqlcipher3VdbeCursorMoveto(u.bk.pC);
69044   if( NEVER(rc!=SQLCIPHER_OK) ) goto abort_due_to_error;
69045
69046   if( u.bk.pC->isIndex ){
69047     assert( !u.bk.pC->isTable );
69048     VVA_ONLY(rc =) sqlcipher3BtreeKeySize(u.bk.pCrsr, &u.bk.n64);
69049     assert( rc==SQLCIPHER_OK );    /* True because of CursorMoveto() call above */
69050     if( u.bk.n64>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
69051       goto too_big;
69052     }
69053     u.bk.n = (u32)u.bk.n64;
69054   }else{
69055     VVA_ONLY(rc =) sqlcipher3BtreeDataSize(u.bk.pCrsr, &u.bk.n);
69056     assert( rc==SQLCIPHER_OK );    /* DataSize() cannot fail */
69057     if( u.bk.n>(u32)db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
69058       goto too_big;
69059     }
69060   }
69061   if( sqlcipher3VdbeMemGrow(pOut, u.bk.n, 0) ){
69062     goto no_mem;
69063   }
69064   pOut->n = u.bk.n;
69065   MemSetTypeFlag(pOut, MEM_Blob);
69066   if( u.bk.pC->isIndex ){
69067     rc = sqlcipher3BtreeKey(u.bk.pCrsr, 0, u.bk.n, pOut->z);
69068   }else{
69069     rc = sqlcipher3BtreeData(u.bk.pCrsr, 0, u.bk.n, pOut->z);
69070   }
69071   pOut->enc = SQLCIPHER_UTF8;  /* In case the blob is ever cast to text */
69072   UPDATE_MAX_BLOBSIZE(pOut);
69073   break;
69074 }
69075
69076 /* Opcode: Rowid P1 P2 * * *
69077 **
69078 ** Store in register P2 an integer which is the key of the table entry that
69079 ** P1 is currently point to.
69080 **
69081 ** P1 can be either an ordinary table or a virtual table.  There used to
69082 ** be a separate OP_VRowid opcode for use with virtual tables, but this
69083 ** one opcode now works for both table types.
69084 */
69085 case OP_Rowid: {                 /* out2-prerelease */
69086 #if 0  /* local variables moved into u.bl */
69087   VdbeCursor *pC;
69088   i64 v;
69089   sqlcipher3_vtab *pVtab;
69090   const sqlcipher3_module *pModule;
69091 #endif /* local variables moved into u.bl */
69092
69093   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69094   u.bl.pC = p->apCsr[pOp->p1];
69095   assert( u.bl.pC!=0 );
69096   assert( u.bl.pC->pseudoTableReg==0 );
69097   if( u.bl.pC->nullRow ){
69098     pOut->flags = MEM_Null;
69099     break;
69100   }else if( u.bl.pC->deferredMoveto ){
69101     u.bl.v = u.bl.pC->movetoTarget;
69102 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
69103   }else if( u.bl.pC->pVtabCursor ){
69104     u.bl.pVtab = u.bl.pC->pVtabCursor->pVtab;
69105     u.bl.pModule = u.bl.pVtab->pModule;
69106     assert( u.bl.pModule->xRowid );
69107     rc = u.bl.pModule->xRowid(u.bl.pC->pVtabCursor, &u.bl.v);
69108     importVtabErrMsg(p, u.bl.pVtab);
69109 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
69110   }else{
69111     assert( u.bl.pC->pCursor!=0 );
69112     rc = sqlcipher3VdbeCursorMoveto(u.bl.pC);
69113     if( rc ) goto abort_due_to_error;
69114     if( u.bl.pC->rowidIsValid ){
69115       u.bl.v = u.bl.pC->lastRowid;
69116     }else{
69117       rc = sqlcipher3BtreeKeySize(u.bl.pC->pCursor, &u.bl.v);
69118       assert( rc==SQLCIPHER_OK );  /* Always so because of CursorMoveto() above */
69119     }
69120   }
69121   pOut->u.i = u.bl.v;
69122   break;
69123 }
69124
69125 /* Opcode: NullRow P1 * * * *
69126 **
69127 ** Move the cursor P1 to a null row.  Any OP_Column operations
69128 ** that occur while the cursor is on the null row will always
69129 ** write a NULL.
69130 */
69131 case OP_NullRow: {
69132 #if 0  /* local variables moved into u.bm */
69133   VdbeCursor *pC;
69134 #endif /* local variables moved into u.bm */
69135
69136   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69137   u.bm.pC = p->apCsr[pOp->p1];
69138   assert( u.bm.pC!=0 );
69139   u.bm.pC->nullRow = 1;
69140   u.bm.pC->rowidIsValid = 0;
69141   assert( u.bm.pC->pCursor || u.bm.pC->pVtabCursor );
69142   if( u.bm.pC->pCursor ){
69143     sqlcipher3BtreeClearCursor(u.bm.pC->pCursor);
69144   }
69145   break;
69146 }
69147
69148 /* Opcode: Last P1 P2 * * *
69149 **
69150 ** The next use of the Rowid or Column or Next instruction for P1 
69151 ** will refer to the last entry in the database table or index.
69152 ** If the table or index is empty and P2>0, then jump immediately to P2.
69153 ** If P2 is 0 or if the table or index is not empty, fall through
69154 ** to the following instruction.
69155 */
69156 case OP_Last: {        /* jump */
69157 #if 0  /* local variables moved into u.bn */
69158   VdbeCursor *pC;
69159   BtCursor *pCrsr;
69160   int res;
69161 #endif /* local variables moved into u.bn */
69162
69163   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69164   u.bn.pC = p->apCsr[pOp->p1];
69165   assert( u.bn.pC!=0 );
69166   u.bn.pCrsr = u.bn.pC->pCursor;
69167   u.bn.res = 0;
69168   if( ALWAYS(u.bn.pCrsr!=0) ){
69169     rc = sqlcipher3BtreeLast(u.bn.pCrsr, &u.bn.res);
69170   }
69171   u.bn.pC->nullRow = (u8)u.bn.res;
69172   u.bn.pC->deferredMoveto = 0;
69173   u.bn.pC->rowidIsValid = 0;
69174   u.bn.pC->cacheStatus = CACHE_STALE;
69175   if( pOp->p2>0 && u.bn.res ){
69176     pc = pOp->p2 - 1;
69177   }
69178   break;
69179 }
69180
69181
69182 /* Opcode: Sort P1 P2 * * *
69183 **
69184 ** This opcode does exactly the same thing as OP_Rewind except that
69185 ** it increments an undocumented global variable used for testing.
69186 **
69187 ** Sorting is accomplished by writing records into a sorting index,
69188 ** then rewinding that index and playing it back from beginning to
69189 ** end.  We use the OP_Sort opcode instead of OP_Rewind to do the
69190 ** rewinding so that the global variable will be incremented and
69191 ** regression tests can determine whether or not the optimizer is
69192 ** correctly optimizing out sorts.
69193 */
69194 case OP_SorterSort:    /* jump */
69195 #ifdef SQLCIPHER_OMIT_MERGE_SORT
69196   pOp->opcode = OP_Sort;
69197 #endif
69198 case OP_Sort: {        /* jump */
69199 #ifdef SQLCIPHER_TEST
69200   sqlcipher3_sort_count++;
69201   sqlcipher3_search_count--;
69202 #endif
69203   p->aCounter[SQLCIPHER_STMTSTATUS_SORT-1]++;
69204   /* Fall through into OP_Rewind */
69205 }
69206 /* Opcode: Rewind P1 P2 * * *
69207 **
69208 ** The next use of the Rowid or Column or Next instruction for P1 
69209 ** will refer to the first entry in the database table or index.
69210 ** If the table or index is empty and P2>0, then jump immediately to P2.
69211 ** If P2 is 0 or if the table or index is not empty, fall through
69212 ** to the following instruction.
69213 */
69214 case OP_Rewind: {        /* jump */
69215 #if 0  /* local variables moved into u.bo */
69216   VdbeCursor *pC;
69217   BtCursor *pCrsr;
69218   int res;
69219 #endif /* local variables moved into u.bo */
69220
69221   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69222   u.bo.pC = p->apCsr[pOp->p1];
69223   assert( u.bo.pC!=0 );
69224   assert( u.bo.pC->isSorter==(pOp->opcode==OP_SorterSort) );
69225   u.bo.res = 1;
69226   if( isSorter(u.bo.pC) ){
69227     rc = sqlcipher3VdbeSorterRewind(db, u.bo.pC, &u.bo.res);
69228   }else{
69229     u.bo.pCrsr = u.bo.pC->pCursor;
69230     assert( u.bo.pCrsr );
69231     rc = sqlcipher3BtreeFirst(u.bo.pCrsr, &u.bo.res);
69232     u.bo.pC->atFirst = u.bo.res==0 ?1:0;
69233     u.bo.pC->deferredMoveto = 0;
69234     u.bo.pC->cacheStatus = CACHE_STALE;
69235     u.bo.pC->rowidIsValid = 0;
69236   }
69237   u.bo.pC->nullRow = (u8)u.bo.res;
69238   assert( pOp->p2>0 && pOp->p2<p->nOp );
69239   if( u.bo.res ){
69240     pc = pOp->p2 - 1;
69241   }
69242   break;
69243 }
69244
69245 /* Opcode: Next P1 P2 * P4 P5
69246 **
69247 ** Advance cursor P1 so that it points to the next key/data pair in its
69248 ** table or index.  If there are no more key/value pairs then fall through
69249 ** to the following instruction.  But if the cursor advance was successful,
69250 ** jump immediately to P2.
69251 **
69252 ** The P1 cursor must be for a real table, not a pseudo-table.
69253 **
69254 ** P4 is always of type P4_ADVANCE. The function pointer points to
69255 ** sqlcipher3BtreeNext().
69256 **
69257 ** If P5 is positive and the jump is taken, then event counter
69258 ** number P5-1 in the prepared statement is incremented.
69259 **
69260 ** See also: Prev
69261 */
69262 /* Opcode: Prev P1 P2 * * P5
69263 **
69264 ** Back up cursor P1 so that it points to the previous key/data pair in its
69265 ** table or index.  If there is no previous key/value pairs then fall through
69266 ** to the following instruction.  But if the cursor backup was successful,
69267 ** jump immediately to P2.
69268 **
69269 ** The P1 cursor must be for a real table, not a pseudo-table.
69270 **
69271 ** P4 is always of type P4_ADVANCE. The function pointer points to
69272 ** sqlcipher3BtreePrevious().
69273 **
69274 ** If P5 is positive and the jump is taken, then event counter
69275 ** number P5-1 in the prepared statement is incremented.
69276 */
69277 case OP_SorterNext:    /* jump */
69278 #ifdef SQLCIPHER_OMIT_MERGE_SORT
69279   pOp->opcode = OP_Next;
69280 #endif
69281 case OP_Prev:          /* jump */
69282 case OP_Next: {        /* jump */
69283 #if 0  /* local variables moved into u.bp */
69284   VdbeCursor *pC;
69285   int res;
69286 #endif /* local variables moved into u.bp */
69287
69288   CHECK_FOR_INTERRUPT;
69289   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69290   assert( pOp->p5<=ArraySize(p->aCounter) );
69291   u.bp.pC = p->apCsr[pOp->p1];
69292   if( u.bp.pC==0 ){
69293     break;  /* See ticket #2273 */
69294   }
69295   assert( u.bp.pC->isSorter==(pOp->opcode==OP_SorterNext) );
69296   if( isSorter(u.bp.pC) ){
69297     assert( pOp->opcode==OP_SorterNext );
69298     rc = sqlcipher3VdbeSorterNext(db, u.bp.pC, &u.bp.res);
69299   }else{
69300     u.bp.res = 1;
69301     assert( u.bp.pC->deferredMoveto==0 );
69302     assert( u.bp.pC->pCursor );
69303     assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlcipher3BtreeNext );
69304     assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlcipher3BtreePrevious );
69305     rc = pOp->p4.xAdvance(u.bp.pC->pCursor, &u.bp.res);
69306   }
69307   u.bp.pC->nullRow = (u8)u.bp.res;
69308   u.bp.pC->cacheStatus = CACHE_STALE;
69309   if( u.bp.res==0 ){
69310     pc = pOp->p2 - 1;
69311     if( pOp->p5 ) p->aCounter[pOp->p5-1]++;
69312 #ifdef SQLCIPHER_TEST
69313     sqlcipher3_search_count++;
69314 #endif
69315   }
69316   u.bp.pC->rowidIsValid = 0;
69317   break;
69318 }
69319
69320 /* Opcode: IdxInsert P1 P2 P3 * P5
69321 **
69322 ** Register P2 holds an SQL index key made using the
69323 ** MakeRecord instructions.  This opcode writes that key
69324 ** into the index P1.  Data for the entry is nil.
69325 **
69326 ** P3 is a flag that provides a hint to the b-tree layer that this
69327 ** insert is likely to be an append.
69328 **
69329 ** This instruction only works for indices.  The equivalent instruction
69330 ** for tables is OP_Insert.
69331 */
69332 case OP_SorterInsert:       /* in2 */
69333 #ifdef SQLCIPHER_OMIT_MERGE_SORT
69334   pOp->opcode = OP_IdxInsert;
69335 #endif
69336 case OP_IdxInsert: {        /* in2 */
69337 #if 0  /* local variables moved into u.bq */
69338   VdbeCursor *pC;
69339   BtCursor *pCrsr;
69340   int nKey;
69341   const char *zKey;
69342 #endif /* local variables moved into u.bq */
69343
69344   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69345   u.bq.pC = p->apCsr[pOp->p1];
69346   assert( u.bq.pC!=0 );
69347   assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
69348   pIn2 = &aMem[pOp->p2];
69349   assert( pIn2->flags & MEM_Blob );
69350   u.bq.pCrsr = u.bq.pC->pCursor;
69351   if( ALWAYS(u.bq.pCrsr!=0) ){
69352     assert( u.bq.pC->isTable==0 );
69353     rc = ExpandBlob(pIn2);
69354     if( rc==SQLCIPHER_OK ){
69355       if( isSorter(u.bq.pC) ){
69356         rc = sqlcipher3VdbeSorterWrite(db, u.bq.pC, pIn2);
69357       }else{
69358         u.bq.nKey = pIn2->n;
69359         u.bq.zKey = pIn2->z;
69360         rc = sqlcipher3BtreeInsert(u.bq.pCrsr, u.bq.zKey, u.bq.nKey, "", 0, 0, pOp->p3,
69361             ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bq.pC->seekResult : 0)
69362             );
69363         assert( u.bq.pC->deferredMoveto==0 );
69364         u.bq.pC->cacheStatus = CACHE_STALE;
69365       }
69366     }
69367   }
69368   break;
69369 }
69370
69371 /* Opcode: IdxDelete P1 P2 P3 * *
69372 **
69373 ** The content of P3 registers starting at register P2 form
69374 ** an unpacked index key. This opcode removes that entry from the 
69375 ** index opened by cursor P1.
69376 */
69377 case OP_IdxDelete: {
69378 #if 0  /* local variables moved into u.br */
69379   VdbeCursor *pC;
69380   BtCursor *pCrsr;
69381   int res;
69382   UnpackedRecord r;
69383 #endif /* local variables moved into u.br */
69384
69385   assert( pOp->p3>0 );
69386   assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem+1 );
69387   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69388   u.br.pC = p->apCsr[pOp->p1];
69389   assert( u.br.pC!=0 );
69390   u.br.pCrsr = u.br.pC->pCursor;
69391   if( ALWAYS(u.br.pCrsr!=0) ){
69392     u.br.r.pKeyInfo = u.br.pC->pKeyInfo;
69393     u.br.r.nField = (u16)pOp->p3;
69394     u.br.r.flags = 0;
69395     u.br.r.aMem = &aMem[pOp->p2];
69396 #ifdef SQLCIPHER_DEBUG
69397     { int i; for(i=0; i<u.br.r.nField; i++) assert( memIsValid(&u.br.r.aMem[i]) ); }
69398 #endif
69399     rc = sqlcipher3BtreeMovetoUnpacked(u.br.pCrsr, &u.br.r, 0, 0, &u.br.res);
69400     if( rc==SQLCIPHER_OK && u.br.res==0 ){
69401       rc = sqlcipher3BtreeDelete(u.br.pCrsr);
69402     }
69403     assert( u.br.pC->deferredMoveto==0 );
69404     u.br.pC->cacheStatus = CACHE_STALE;
69405   }
69406   break;
69407 }
69408
69409 /* Opcode: IdxRowid P1 P2 * * *
69410 **
69411 ** Write into register P2 an integer which is the last entry in the record at
69412 ** the end of the index key pointed to by cursor P1.  This integer should be
69413 ** the rowid of the table entry to which this index entry points.
69414 **
69415 ** See also: Rowid, MakeRecord.
69416 */
69417 case OP_IdxRowid: {              /* out2-prerelease */
69418 #if 0  /* local variables moved into u.bs */
69419   BtCursor *pCrsr;
69420   VdbeCursor *pC;
69421   i64 rowid;
69422 #endif /* local variables moved into u.bs */
69423
69424   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69425   u.bs.pC = p->apCsr[pOp->p1];
69426   assert( u.bs.pC!=0 );
69427   u.bs.pCrsr = u.bs.pC->pCursor;
69428   pOut->flags = MEM_Null;
69429   if( ALWAYS(u.bs.pCrsr!=0) ){
69430     rc = sqlcipher3VdbeCursorMoveto(u.bs.pC);
69431     if( NEVER(rc) ) goto abort_due_to_error;
69432     assert( u.bs.pC->deferredMoveto==0 );
69433     assert( u.bs.pC->isTable==0 );
69434     if( !u.bs.pC->nullRow ){
69435       rc = sqlcipher3VdbeIdxRowid(db, u.bs.pCrsr, &u.bs.rowid);
69436       if( rc!=SQLCIPHER_OK ){
69437         goto abort_due_to_error;
69438       }
69439       pOut->u.i = u.bs.rowid;
69440       pOut->flags = MEM_Int;
69441     }
69442   }
69443   break;
69444 }
69445
69446 /* Opcode: IdxGE P1 P2 P3 P4 P5
69447 **
69448 ** The P4 register values beginning with P3 form an unpacked index 
69449 ** key that omits the ROWID.  Compare this key value against the index 
69450 ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
69451 **
69452 ** If the P1 index entry is greater than or equal to the key value
69453 ** then jump to P2.  Otherwise fall through to the next instruction.
69454 **
69455 ** If P5 is non-zero then the key value is increased by an epsilon 
69456 ** prior to the comparison.  This make the opcode work like IdxGT except
69457 ** that if the key from register P3 is a prefix of the key in the cursor,
69458 ** the result is false whereas it would be true with IdxGT.
69459 */
69460 /* Opcode: IdxLT P1 P2 P3 P4 P5
69461 **
69462 ** The P4 register values beginning with P3 form an unpacked index 
69463 ** key that omits the ROWID.  Compare this key value against the index 
69464 ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
69465 **
69466 ** If the P1 index entry is less than the key value then jump to P2.
69467 ** Otherwise fall through to the next instruction.
69468 **
69469 ** If P5 is non-zero then the key value is increased by an epsilon prior 
69470 ** to the comparison.  This makes the opcode work like IdxLE.
69471 */
69472 case OP_IdxLT:          /* jump */
69473 case OP_IdxGE: {        /* jump */
69474 #if 0  /* local variables moved into u.bt */
69475   VdbeCursor *pC;
69476   int res;
69477   UnpackedRecord r;
69478 #endif /* local variables moved into u.bt */
69479
69480   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69481   u.bt.pC = p->apCsr[pOp->p1];
69482   assert( u.bt.pC!=0 );
69483   assert( u.bt.pC->isOrdered );
69484   if( ALWAYS(u.bt.pC->pCursor!=0) ){
69485     assert( u.bt.pC->deferredMoveto==0 );
69486     assert( pOp->p5==0 || pOp->p5==1 );
69487     assert( pOp->p4type==P4_INT32 );
69488     u.bt.r.pKeyInfo = u.bt.pC->pKeyInfo;
69489     u.bt.r.nField = (u16)pOp->p4.i;
69490     if( pOp->p5 ){
69491       u.bt.r.flags = UNPACKED_INCRKEY | UNPACKED_IGNORE_ROWID;
69492     }else{
69493       u.bt.r.flags = UNPACKED_IGNORE_ROWID;
69494     }
69495     u.bt.r.aMem = &aMem[pOp->p3];
69496 #ifdef SQLCIPHER_DEBUG
69497     { int i; for(i=0; i<u.bt.r.nField; i++) assert( memIsValid(&u.bt.r.aMem[i]) ); }
69498 #endif
69499     rc = sqlcipher3VdbeIdxKeyCompare(u.bt.pC, &u.bt.r, &u.bt.res);
69500     if( pOp->opcode==OP_IdxLT ){
69501       u.bt.res = -u.bt.res;
69502     }else{
69503       assert( pOp->opcode==OP_IdxGE );
69504       u.bt.res++;
69505     }
69506     if( u.bt.res>0 ){
69507       pc = pOp->p2 - 1 ;
69508     }
69509   }
69510   break;
69511 }
69512
69513 /* Opcode: Destroy P1 P2 P3 * *
69514 **
69515 ** Delete an entire database table or index whose root page in the database
69516 ** file is given by P1.
69517 **
69518 ** The table being destroyed is in the main database file if P3==0.  If
69519 ** P3==1 then the table to be clear is in the auxiliary database file
69520 ** that is used to store tables create using CREATE TEMPORARY TABLE.
69521 **
69522 ** If AUTOVACUUM is enabled then it is possible that another root page
69523 ** might be moved into the newly deleted root page in order to keep all
69524 ** root pages contiguous at the beginning of the database.  The former
69525 ** value of the root page that moved - its value before the move occurred -
69526 ** is stored in register P2.  If no page 
69527 ** movement was required (because the table being dropped was already 
69528 ** the last one in the database) then a zero is stored in register P2.
69529 ** If AUTOVACUUM is disabled then a zero is stored in register P2.
69530 **
69531 ** See also: Clear
69532 */
69533 case OP_Destroy: {     /* out2-prerelease */
69534 #if 0  /* local variables moved into u.bu */
69535   int iMoved;
69536   int iCnt;
69537   Vdbe *pVdbe;
69538   int iDb;
69539 #endif /* local variables moved into u.bu */
69540 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
69541   u.bu.iCnt = 0;
69542   for(u.bu.pVdbe=db->pVdbe; u.bu.pVdbe; u.bu.pVdbe = u.bu.pVdbe->pNext){
69543     if( u.bu.pVdbe->magic==VDBE_MAGIC_RUN && u.bu.pVdbe->inVtabMethod<2 && u.bu.pVdbe->pc>=0 ){
69544       u.bu.iCnt++;
69545     }
69546   }
69547 #else
69548   u.bu.iCnt = db->activeVdbeCnt;
69549 #endif
69550   pOut->flags = MEM_Null;
69551   if( u.bu.iCnt>1 ){
69552     rc = SQLCIPHER_LOCKED;
69553     p->errorAction = OE_Abort;
69554   }else{
69555     u.bu.iDb = pOp->p3;
69556     assert( u.bu.iCnt==1 );
69557     assert( (p->btreeMask & (((yDbMask)1)<<u.bu.iDb))!=0 );
69558     rc = sqlcipher3BtreeDropTable(db->aDb[u.bu.iDb].pBt, pOp->p1, &u.bu.iMoved);
69559     pOut->flags = MEM_Int;
69560     pOut->u.i = u.bu.iMoved;
69561 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
69562     if( rc==SQLCIPHER_OK && u.bu.iMoved!=0 ){
69563       sqlcipher3RootPageMoved(db, u.bu.iDb, u.bu.iMoved, pOp->p1);
69564       /* All OP_Destroy operations occur on the same btree */
69565       assert( resetSchemaOnFault==0 || resetSchemaOnFault==u.bu.iDb+1 );
69566       resetSchemaOnFault = u.bu.iDb+1;
69567     }
69568 #endif
69569   }
69570   break;
69571 }
69572
69573 /* Opcode: Clear P1 P2 P3
69574 **
69575 ** Delete all contents of the database table or index whose root page
69576 ** in the database file is given by P1.  But, unlike Destroy, do not
69577 ** remove the table or index from the database file.
69578 **
69579 ** The table being clear is in the main database file if P2==0.  If
69580 ** P2==1 then the table to be clear is in the auxiliary database file
69581 ** that is used to store tables create using CREATE TEMPORARY TABLE.
69582 **
69583 ** If the P3 value is non-zero, then the table referred to must be an
69584 ** intkey table (an SQL table, not an index). In this case the row change 
69585 ** count is incremented by the number of rows in the table being cleared. 
69586 ** If P3 is greater than zero, then the value stored in register P3 is
69587 ** also incremented by the number of rows in the table being cleared.
69588 **
69589 ** See also: Destroy
69590 */
69591 case OP_Clear: {
69592 #if 0  /* local variables moved into u.bv */
69593   int nChange;
69594 #endif /* local variables moved into u.bv */
69595
69596   u.bv.nChange = 0;
69597   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
69598   rc = sqlcipher3BtreeClearTable(
69599       db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bv.nChange : 0)
69600   );
69601   if( pOp->p3 ){
69602     p->nChange += u.bv.nChange;
69603     if( pOp->p3>0 ){
69604       assert( memIsValid(&aMem[pOp->p3]) );
69605       memAboutToChange(p, &aMem[pOp->p3]);
69606       aMem[pOp->p3].u.i += u.bv.nChange;
69607     }
69608   }
69609   break;
69610 }
69611
69612 /* Opcode: CreateTable P1 P2 * * *
69613 **
69614 ** Allocate a new table in the main database file if P1==0 or in the
69615 ** auxiliary database file if P1==1 or in an attached database if
69616 ** P1>1.  Write the root page number of the new table into
69617 ** register P2
69618 **
69619 ** The difference between a table and an index is this:  A table must
69620 ** have a 4-byte integer key and can have arbitrary data.  An index
69621 ** has an arbitrary key but no data.
69622 **
69623 ** See also: CreateIndex
69624 */
69625 /* Opcode: CreateIndex P1 P2 * * *
69626 **
69627 ** Allocate a new index in the main database file if P1==0 or in the
69628 ** auxiliary database file if P1==1 or in an attached database if
69629 ** P1>1.  Write the root page number of the new table into
69630 ** register P2.
69631 **
69632 ** See documentation on OP_CreateTable for additional information.
69633 */
69634 case OP_CreateIndex:            /* out2-prerelease */
69635 case OP_CreateTable: {          /* out2-prerelease */
69636 #if 0  /* local variables moved into u.bw */
69637   int pgno;
69638   int flags;
69639   Db *pDb;
69640 #endif /* local variables moved into u.bw */
69641
69642   u.bw.pgno = 0;
69643   assert( pOp->p1>=0 && pOp->p1<db->nDb );
69644   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
69645   u.bw.pDb = &db->aDb[pOp->p1];
69646   assert( u.bw.pDb->pBt!=0 );
69647   if( pOp->opcode==OP_CreateTable ){
69648     /* u.bw.flags = BTREE_INTKEY; */
69649     u.bw.flags = BTREE_INTKEY;
69650   }else{
69651     u.bw.flags = BTREE_BLOBKEY;
69652   }
69653   rc = sqlcipher3BtreeCreateTable(u.bw.pDb->pBt, &u.bw.pgno, u.bw.flags);
69654   pOut->u.i = u.bw.pgno;
69655   break;
69656 }
69657
69658 /* Opcode: ParseSchema P1 * * P4 *
69659 **
69660 ** Read and parse all entries from the SQLCIPHER_MASTER table of database P1
69661 ** that match the WHERE clause P4. 
69662 **
69663 ** This opcode invokes the parser to create a new virtual machine,
69664 ** then runs the new virtual machine.  It is thus a re-entrant opcode.
69665 */
69666 case OP_ParseSchema: {
69667 #if 0  /* local variables moved into u.bx */
69668   int iDb;
69669   const char *zMaster;
69670   char *zSql;
69671   InitData initData;
69672 #endif /* local variables moved into u.bx */
69673
69674   /* Any prepared statement that invokes this opcode will hold mutexes
69675   ** on every btree.  This is a prerequisite for invoking
69676   ** sqlcipher3InitCallback().
69677   */
69678 #ifdef SQLCIPHER_DEBUG
69679   for(u.bx.iDb=0; u.bx.iDb<db->nDb; u.bx.iDb++){
69680     assert( u.bx.iDb==1 || sqlcipher3BtreeHoldsMutex(db->aDb[u.bx.iDb].pBt) );
69681   }
69682 #endif
69683
69684   u.bx.iDb = pOp->p1;
69685   assert( u.bx.iDb>=0 && u.bx.iDb<db->nDb );
69686   assert( DbHasProperty(db, u.bx.iDb, DB_SchemaLoaded) );
69687   /* Used to be a conditional */ {
69688     u.bx.zMaster = SCHEMA_TABLE(u.bx.iDb);
69689     u.bx.initData.db = db;
69690     u.bx.initData.iDb = pOp->p1;
69691     u.bx.initData.pzErrMsg = &p->zErrMsg;
69692     u.bx.zSql = sqlcipher3MPrintf(db,
69693        "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid",
69694        db->aDb[u.bx.iDb].zName, u.bx.zMaster, pOp->p4.z);
69695     if( u.bx.zSql==0 ){
69696       rc = SQLCIPHER_NOMEM;
69697     }else{
69698       assert( db->init.busy==0 );
69699       db->init.busy = 1;
69700       u.bx.initData.rc = SQLCIPHER_OK;
69701       assert( !db->mallocFailed );
69702       rc = sqlcipher3_exec(db, u.bx.zSql, sqlcipher3InitCallback, &u.bx.initData, 0);
69703       if( rc==SQLCIPHER_OK ) rc = u.bx.initData.rc;
69704       sqlcipher3DbFree(db, u.bx.zSql);
69705       db->init.busy = 0;
69706     }
69707   }
69708   if( rc==SQLCIPHER_NOMEM ){
69709     goto no_mem;
69710   }
69711   break;
69712 }
69713
69714 #if !defined(SQLCIPHER_OMIT_ANALYZE)
69715 /* Opcode: LoadAnalysis P1 * * * *
69716 **
69717 ** Read the sqlcipher_stat1 table for database P1 and load the content
69718 ** of that table into the internal index hash table.  This will cause
69719 ** the analysis to be used when preparing all subsequent queries.
69720 */
69721 case OP_LoadAnalysis: {
69722   assert( pOp->p1>=0 && pOp->p1<db->nDb );
69723   rc = sqlcipher3AnalysisLoad(db, pOp->p1);
69724   break;  
69725 }
69726 #endif /* !defined(SQLCIPHER_OMIT_ANALYZE) */
69727
69728 /* Opcode: DropTable P1 * * P4 *
69729 **
69730 ** Remove the internal (in-memory) data structures that describe
69731 ** the table named P4 in database P1.  This is called after a table
69732 ** is dropped in order to keep the internal representation of the
69733 ** schema consistent with what is on disk.
69734 */
69735 case OP_DropTable: {
69736   sqlcipher3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
69737   break;
69738 }
69739
69740 /* Opcode: DropIndex P1 * * P4 *
69741 **
69742 ** Remove the internal (in-memory) data structures that describe
69743 ** the index named P4 in database P1.  This is called after an index
69744 ** is dropped in order to keep the internal representation of the
69745 ** schema consistent with what is on disk.
69746 */
69747 case OP_DropIndex: {
69748   sqlcipher3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
69749   break;
69750 }
69751
69752 /* Opcode: DropTrigger P1 * * P4 *
69753 **
69754 ** Remove the internal (in-memory) data structures that describe
69755 ** the trigger named P4 in database P1.  This is called after a trigger
69756 ** is dropped in order to keep the internal representation of the
69757 ** schema consistent with what is on disk.
69758 */
69759 case OP_DropTrigger: {
69760   sqlcipher3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
69761   break;
69762 }
69763
69764
69765 #ifndef SQLCIPHER_OMIT_INTEGRITY_CHECK
69766 /* Opcode: IntegrityCk P1 P2 P3 * P5
69767 **
69768 ** Do an analysis of the currently open database.  Store in
69769 ** register P1 the text of an error message describing any problems.
69770 ** If no problems are found, store a NULL in register P1.
69771 **
69772 ** The register P3 contains the maximum number of allowed errors.
69773 ** At most reg(P3) errors will be reported.
69774 ** In other words, the analysis stops as soon as reg(P1) errors are 
69775 ** seen.  Reg(P1) is updated with the number of errors remaining.
69776 **
69777 ** The root page numbers of all tables in the database are integer
69778 ** stored in reg(P1), reg(P1+1), reg(P1+2), ....  There are P2 tables
69779 ** total.
69780 **
69781 ** If P5 is not zero, the check is done on the auxiliary database
69782 ** file, not the main database file.
69783 **
69784 ** This opcode is used to implement the integrity_check pragma.
69785 */
69786 case OP_IntegrityCk: {
69787 #if 0  /* local variables moved into u.by */
69788   int nRoot;      /* Number of tables to check.  (Number of root pages.) */
69789   int *aRoot;     /* Array of rootpage numbers for tables to be checked */
69790   int j;          /* Loop counter */
69791   int nErr;       /* Number of errors reported */
69792   char *z;        /* Text of the error report */
69793   Mem *pnErr;     /* Register keeping track of errors remaining */
69794 #endif /* local variables moved into u.by */
69795
69796   u.by.nRoot = pOp->p2;
69797   assert( u.by.nRoot>0 );
69798   u.by.aRoot = sqlcipher3DbMallocRaw(db, sizeof(int)*(u.by.nRoot+1) );
69799   if( u.by.aRoot==0 ) goto no_mem;
69800   assert( pOp->p3>0 && pOp->p3<=p->nMem );
69801   u.by.pnErr = &aMem[pOp->p3];
69802   assert( (u.by.pnErr->flags & MEM_Int)!=0 );
69803   assert( (u.by.pnErr->flags & (MEM_Str|MEM_Blob))==0 );
69804   pIn1 = &aMem[pOp->p1];
69805   for(u.by.j=0; u.by.j<u.by.nRoot; u.by.j++){
69806     u.by.aRoot[u.by.j] = (int)sqlcipher3VdbeIntValue(&pIn1[u.by.j]);
69807   }
69808   u.by.aRoot[u.by.j] = 0;
69809   assert( pOp->p5<db->nDb );
69810   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p5))!=0 );
69811   u.by.z = sqlcipher3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, u.by.aRoot, u.by.nRoot,
69812                                  (int)u.by.pnErr->u.i, &u.by.nErr);
69813   sqlcipher3DbFree(db, u.by.aRoot);
69814   u.by.pnErr->u.i -= u.by.nErr;
69815   sqlcipher3VdbeMemSetNull(pIn1);
69816   if( u.by.nErr==0 ){
69817     assert( u.by.z==0 );
69818   }else if( u.by.z==0 ){
69819     goto no_mem;
69820   }else{
69821     sqlcipher3VdbeMemSetStr(pIn1, u.by.z, -1, SQLCIPHER_UTF8, sqlcipher3_free);
69822   }
69823   UPDATE_MAX_BLOBSIZE(pIn1);
69824   sqlcipher3VdbeChangeEncoding(pIn1, encoding);
69825   break;
69826 }
69827 #endif /* SQLCIPHER_OMIT_INTEGRITY_CHECK */
69828
69829 /* Opcode: RowSetAdd P1 P2 * * *
69830 **
69831 ** Insert the integer value held by register P2 into a boolean index
69832 ** held in register P1.
69833 **
69834 ** An assertion fails if P2 is not an integer.
69835 */
69836 case OP_RowSetAdd: {       /* in1, in2 */
69837   pIn1 = &aMem[pOp->p1];
69838   pIn2 = &aMem[pOp->p2];
69839   assert( (pIn2->flags & MEM_Int)!=0 );
69840   if( (pIn1->flags & MEM_RowSet)==0 ){
69841     sqlcipher3VdbeMemSetRowSet(pIn1);
69842     if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
69843   }
69844   sqlcipher3RowSetInsert(pIn1->u.pRowSet, pIn2->u.i);
69845   break;
69846 }
69847
69848 /* Opcode: RowSetRead P1 P2 P3 * *
69849 **
69850 ** Extract the smallest value from boolean index P1 and put that value into
69851 ** register P3.  Or, if boolean index P1 is initially empty, leave P3
69852 ** unchanged and jump to instruction P2.
69853 */
69854 case OP_RowSetRead: {       /* jump, in1, out3 */
69855 #if 0  /* local variables moved into u.bz */
69856   i64 val;
69857 #endif /* local variables moved into u.bz */
69858   CHECK_FOR_INTERRUPT;
69859   pIn1 = &aMem[pOp->p1];
69860   if( (pIn1->flags & MEM_RowSet)==0
69861    || sqlcipher3RowSetNext(pIn1->u.pRowSet, &u.bz.val)==0
69862   ){
69863     /* The boolean index is empty */
69864     sqlcipher3VdbeMemSetNull(pIn1);
69865     pc = pOp->p2 - 1;
69866   }else{
69867     /* A value was pulled from the index */
69868     sqlcipher3VdbeMemSetInt64(&aMem[pOp->p3], u.bz.val);
69869   }
69870   break;
69871 }
69872
69873 /* Opcode: RowSetTest P1 P2 P3 P4
69874 **
69875 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
69876 ** contains a RowSet object and that RowSet object contains
69877 ** the value held in P3, jump to register P2. Otherwise, insert the
69878 ** integer in P3 into the RowSet and continue on to the
69879 ** next opcode.
69880 **
69881 ** The RowSet object is optimized for the case where successive sets
69882 ** of integers, where each set contains no duplicates. Each set
69883 ** of values is identified by a unique P4 value. The first set
69884 ** must have P4==0, the final set P4=-1.  P4 must be either -1 or
69885 ** non-negative.  For non-negative values of P4 only the lower 4
69886 ** bits are significant.
69887 **
69888 ** This allows optimizations: (a) when P4==0 there is no need to test
69889 ** the rowset object for P3, as it is guaranteed not to contain it,
69890 ** (b) when P4==-1 there is no need to insert the value, as it will
69891 ** never be tested for, and (c) when a value that is part of set X is
69892 ** inserted, there is no need to search to see if the same value was
69893 ** previously inserted as part of set X (only if it was previously
69894 ** inserted as part of some other set).
69895 */
69896 case OP_RowSetTest: {                     /* jump, in1, in3 */
69897 #if 0  /* local variables moved into u.ca */
69898   int iSet;
69899   int exists;
69900 #endif /* local variables moved into u.ca */
69901
69902   pIn1 = &aMem[pOp->p1];
69903   pIn3 = &aMem[pOp->p3];
69904   u.ca.iSet = pOp->p4.i;
69905   assert( pIn3->flags&MEM_Int );
69906
69907   /* If there is anything other than a rowset object in memory cell P1,
69908   ** delete it now and initialize P1 with an empty rowset
69909   */
69910   if( (pIn1->flags & MEM_RowSet)==0 ){
69911     sqlcipher3VdbeMemSetRowSet(pIn1);
69912     if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
69913   }
69914
69915   assert( pOp->p4type==P4_INT32 );
69916   assert( u.ca.iSet==-1 || u.ca.iSet>=0 );
69917   if( u.ca.iSet ){
69918     u.ca.exists = sqlcipher3RowSetTest(pIn1->u.pRowSet,
69919                                (u8)(u.ca.iSet>=0 ? u.ca.iSet & 0xf : 0xff),
69920                                pIn3->u.i);
69921     if( u.ca.exists ){
69922       pc = pOp->p2 - 1;
69923       break;
69924     }
69925   }
69926   if( u.ca.iSet>=0 ){
69927     sqlcipher3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i);
69928   }
69929   break;
69930 }
69931
69932
69933 #ifndef SQLCIPHER_OMIT_TRIGGER
69934
69935 /* Opcode: Program P1 P2 P3 P4 *
69936 **
69937 ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). 
69938 **
69939 ** P1 contains the address of the memory cell that contains the first memory 
69940 ** cell in an array of values used as arguments to the sub-program. P2 
69941 ** contains the address to jump to if the sub-program throws an IGNORE 
69942 ** exception using the RAISE() function. Register P3 contains the address 
69943 ** of a memory cell in this (the parent) VM that is used to allocate the 
69944 ** memory required by the sub-vdbe at runtime.
69945 **
69946 ** P4 is a pointer to the VM containing the trigger program.
69947 */
69948 case OP_Program: {        /* jump */
69949 #if 0  /* local variables moved into u.cb */
69950   int nMem;               /* Number of memory registers for sub-program */
69951   int nByte;              /* Bytes of runtime space required for sub-program */
69952   Mem *pRt;               /* Register to allocate runtime space */
69953   Mem *pMem;              /* Used to iterate through memory cells */
69954   Mem *pEnd;              /* Last memory cell in new array */
69955   VdbeFrame *pFrame;      /* New vdbe frame to execute in */
69956   SubProgram *pProgram;   /* Sub-program to execute */
69957   void *t;                /* Token identifying trigger */
69958 #endif /* local variables moved into u.cb */
69959
69960   u.cb.pProgram = pOp->p4.pProgram;
69961   u.cb.pRt = &aMem[pOp->p3];
69962   assert( memIsValid(u.cb.pRt) );
69963   assert( u.cb.pProgram->nOp>0 );
69964
69965   /* If the p5 flag is clear, then recursive invocation of triggers is
69966   ** disabled for backwards compatibility (p5 is set if this sub-program
69967   ** is really a trigger, not a foreign key action, and the flag set
69968   ** and cleared by the "PRAGMA recursive_triggers" command is clear).
69969   **
69970   ** It is recursive invocation of triggers, at the SQL level, that is
69971   ** disabled. In some cases a single trigger may generate more than one
69972   ** SubProgram (if the trigger may be executed with more than one different
69973   ** ON CONFLICT algorithm). SubProgram structures associated with a
69974   ** single trigger all have the same value for the SubProgram.token
69975   ** variable.  */
69976   if( pOp->p5 ){
69977     u.cb.t = u.cb.pProgram->token;
69978     for(u.cb.pFrame=p->pFrame; u.cb.pFrame && u.cb.pFrame->token!=u.cb.t; u.cb.pFrame=u.cb.pFrame->pParent);
69979     if( u.cb.pFrame ) break;
69980   }
69981
69982   if( p->nFrame>=db->aLimit[SQLCIPHER_LIMIT_TRIGGER_DEPTH] ){
69983     rc = SQLCIPHER_ERROR;
69984     sqlcipher3SetString(&p->zErrMsg, db, "too many levels of trigger recursion");
69985     break;
69986   }
69987
69988   /* Register u.cb.pRt is used to store the memory required to save the state
69989   ** of the current program, and the memory required at runtime to execute
69990   ** the trigger program. If this trigger has been fired before, then u.cb.pRt
69991   ** is already allocated. Otherwise, it must be initialized.  */
69992   if( (u.cb.pRt->flags&MEM_Frame)==0 ){
69993     /* SubProgram.nMem is set to the number of memory cells used by the
69994     ** program stored in SubProgram.aOp. As well as these, one memory
69995     ** cell is required for each cursor used by the program. Set local
69996     ** variable u.cb.nMem (and later, VdbeFrame.nChildMem) to this value.
69997     */
69998     u.cb.nMem = u.cb.pProgram->nMem + u.cb.pProgram->nCsr;
69999     u.cb.nByte = ROUND8(sizeof(VdbeFrame))
70000               + u.cb.nMem * sizeof(Mem)
70001               + u.cb.pProgram->nCsr * sizeof(VdbeCursor *);
70002     u.cb.pFrame = sqlcipher3DbMallocZero(db, u.cb.nByte);
70003     if( !u.cb.pFrame ){
70004       goto no_mem;
70005     }
70006     sqlcipher3VdbeMemRelease(u.cb.pRt);
70007     u.cb.pRt->flags = MEM_Frame;
70008     u.cb.pRt->u.pFrame = u.cb.pFrame;
70009
70010     u.cb.pFrame->v = p;
70011     u.cb.pFrame->nChildMem = u.cb.nMem;
70012     u.cb.pFrame->nChildCsr = u.cb.pProgram->nCsr;
70013     u.cb.pFrame->pc = pc;
70014     u.cb.pFrame->aMem = p->aMem;
70015     u.cb.pFrame->nMem = p->nMem;
70016     u.cb.pFrame->apCsr = p->apCsr;
70017     u.cb.pFrame->nCursor = p->nCursor;
70018     u.cb.pFrame->aOp = p->aOp;
70019     u.cb.pFrame->nOp = p->nOp;
70020     u.cb.pFrame->token = u.cb.pProgram->token;
70021
70022     u.cb.pEnd = &VdbeFrameMem(u.cb.pFrame)[u.cb.pFrame->nChildMem];
70023     for(u.cb.pMem=VdbeFrameMem(u.cb.pFrame); u.cb.pMem!=u.cb.pEnd; u.cb.pMem++){
70024       u.cb.pMem->flags = MEM_Null;
70025       u.cb.pMem->db = db;
70026     }
70027   }else{
70028     u.cb.pFrame = u.cb.pRt->u.pFrame;
70029     assert( u.cb.pProgram->nMem+u.cb.pProgram->nCsr==u.cb.pFrame->nChildMem );
70030     assert( u.cb.pProgram->nCsr==u.cb.pFrame->nChildCsr );
70031     assert( pc==u.cb.pFrame->pc );
70032   }
70033
70034   p->nFrame++;
70035   u.cb.pFrame->pParent = p->pFrame;
70036   u.cb.pFrame->lastRowid = lastRowid;
70037   u.cb.pFrame->nChange = p->nChange;
70038   p->nChange = 0;
70039   p->pFrame = u.cb.pFrame;
70040   p->aMem = aMem = &VdbeFrameMem(u.cb.pFrame)[-1];
70041   p->nMem = u.cb.pFrame->nChildMem;
70042   p->nCursor = (u16)u.cb.pFrame->nChildCsr;
70043   p->apCsr = (VdbeCursor **)&aMem[p->nMem+1];
70044   p->aOp = aOp = u.cb.pProgram->aOp;
70045   p->nOp = u.cb.pProgram->nOp;
70046   pc = -1;
70047
70048   break;
70049 }
70050
70051 /* Opcode: Param P1 P2 * * *
70052 **
70053 ** This opcode is only ever present in sub-programs called via the 
70054 ** OP_Program instruction. Copy a value currently stored in a memory 
70055 ** cell of the calling (parent) frame to cell P2 in the current frames 
70056 ** address space. This is used by trigger programs to access the new.* 
70057 ** and old.* values.
70058 **
70059 ** The address of the cell in the parent frame is determined by adding
70060 ** the value of the P1 argument to the value of the P1 argument to the
70061 ** calling OP_Program instruction.
70062 */
70063 case OP_Param: {           /* out2-prerelease */
70064 #if 0  /* local variables moved into u.cc */
70065   VdbeFrame *pFrame;
70066   Mem *pIn;
70067 #endif /* local variables moved into u.cc */
70068   u.cc.pFrame = p->pFrame;
70069   u.cc.pIn = &u.cc.pFrame->aMem[pOp->p1 + u.cc.pFrame->aOp[u.cc.pFrame->pc].p1];
70070   sqlcipher3VdbeMemShallowCopy(pOut, u.cc.pIn, MEM_Ephem);
70071   break;
70072 }
70073
70074 #endif /* #ifndef SQLCIPHER_OMIT_TRIGGER */
70075
70076 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
70077 /* Opcode: FkCounter P1 P2 * * *
70078 **
70079 ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
70080 ** If P1 is non-zero, the database constraint counter is incremented 
70081 ** (deferred foreign key constraints). Otherwise, if P1 is zero, the 
70082 ** statement counter is incremented (immediate foreign key constraints).
70083 */
70084 case OP_FkCounter: {
70085   if( pOp->p1 ){
70086     db->nDeferredCons += pOp->p2;
70087   }else{
70088     p->nFkConstraint += pOp->p2;
70089   }
70090   break;
70091 }
70092
70093 /* Opcode: FkIfZero P1 P2 * * *
70094 **
70095 ** This opcode tests if a foreign key constraint-counter is currently zero.
70096 ** If so, jump to instruction P2. Otherwise, fall through to the next 
70097 ** instruction.
70098 **
70099 ** If P1 is non-zero, then the jump is taken if the database constraint-counter
70100 ** is zero (the one that counts deferred constraint violations). If P1 is
70101 ** zero, the jump is taken if the statement constraint-counter is zero
70102 ** (immediate foreign key constraint violations).
70103 */
70104 case OP_FkIfZero: {         /* jump */
70105   if( pOp->p1 ){
70106     if( db->nDeferredCons==0 ) pc = pOp->p2-1;
70107   }else{
70108     if( p->nFkConstraint==0 ) pc = pOp->p2-1;
70109   }
70110   break;
70111 }
70112 #endif /* #ifndef SQLCIPHER_OMIT_FOREIGN_KEY */
70113
70114 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
70115 /* Opcode: MemMax P1 P2 * * *
70116 **
70117 ** P1 is a register in the root frame of this VM (the root frame is
70118 ** different from the current frame if this instruction is being executed
70119 ** within a sub-program). Set the value of register P1 to the maximum of 
70120 ** its current value and the value in register P2.
70121 **
70122 ** This instruction throws an error if the memory cell is not initially
70123 ** an integer.
70124 */
70125 case OP_MemMax: {        /* in2 */
70126 #if 0  /* local variables moved into u.cd */
70127   Mem *pIn1;
70128   VdbeFrame *pFrame;
70129 #endif /* local variables moved into u.cd */
70130   if( p->pFrame ){
70131     for(u.cd.pFrame=p->pFrame; u.cd.pFrame->pParent; u.cd.pFrame=u.cd.pFrame->pParent);
70132     u.cd.pIn1 = &u.cd.pFrame->aMem[pOp->p1];
70133   }else{
70134     u.cd.pIn1 = &aMem[pOp->p1];
70135   }
70136   assert( memIsValid(u.cd.pIn1) );
70137   sqlcipher3VdbeMemIntegerify(u.cd.pIn1);
70138   pIn2 = &aMem[pOp->p2];
70139   sqlcipher3VdbeMemIntegerify(pIn2);
70140   if( u.cd.pIn1->u.i<pIn2->u.i){
70141     u.cd.pIn1->u.i = pIn2->u.i;
70142   }
70143   break;
70144 }
70145 #endif /* SQLCIPHER_OMIT_AUTOINCREMENT */
70146
70147 /* Opcode: IfPos P1 P2 * * *
70148 **
70149 ** If the value of register P1 is 1 or greater, jump to P2.
70150 **
70151 ** It is illegal to use this instruction on a register that does
70152 ** not contain an integer.  An assertion fault will result if you try.
70153 */
70154 case OP_IfPos: {        /* jump, in1 */
70155   pIn1 = &aMem[pOp->p1];
70156   assert( pIn1->flags&MEM_Int );
70157   if( pIn1->u.i>0 ){
70158      pc = pOp->p2 - 1;
70159   }
70160   break;
70161 }
70162
70163 /* Opcode: IfNeg P1 P2 * * *
70164 **
70165 ** If the value of register P1 is less than zero, jump to P2. 
70166 **
70167 ** It is illegal to use this instruction on a register that does
70168 ** not contain an integer.  An assertion fault will result if you try.
70169 */
70170 case OP_IfNeg: {        /* jump, in1 */
70171   pIn1 = &aMem[pOp->p1];
70172   assert( pIn1->flags&MEM_Int );
70173   if( pIn1->u.i<0 ){
70174      pc = pOp->p2 - 1;
70175   }
70176   break;
70177 }
70178
70179 /* Opcode: IfZero P1 P2 P3 * *
70180 **
70181 ** The register P1 must contain an integer.  Add literal P3 to the
70182 ** value in register P1.  If the result is exactly 0, jump to P2. 
70183 **
70184 ** It is illegal to use this instruction on a register that does
70185 ** not contain an integer.  An assertion fault will result if you try.
70186 */
70187 case OP_IfZero: {        /* jump, in1 */
70188   pIn1 = &aMem[pOp->p1];
70189   assert( pIn1->flags&MEM_Int );
70190   pIn1->u.i += pOp->p3;
70191   if( pIn1->u.i==0 ){
70192      pc = pOp->p2 - 1;
70193   }
70194   break;
70195 }
70196
70197 /* Opcode: AggStep * P2 P3 P4 P5
70198 **
70199 ** Execute the step function for an aggregate.  The
70200 ** function has P5 arguments.   P4 is a pointer to the FuncDef
70201 ** structure that specifies the function.  Use register
70202 ** P3 as the accumulator.
70203 **
70204 ** The P5 arguments are taken from register P2 and its
70205 ** successors.
70206 */
70207 case OP_AggStep: {
70208 #if 0  /* local variables moved into u.ce */
70209   int n;
70210   int i;
70211   Mem *pMem;
70212   Mem *pRec;
70213   sqlcipher3_context ctx;
70214   sqlcipher3_value **apVal;
70215 #endif /* local variables moved into u.ce */
70216
70217   u.ce.n = pOp->p5;
70218   assert( u.ce.n>=0 );
70219   u.ce.pRec = &aMem[pOp->p2];
70220   u.ce.apVal = p->apArg;
70221   assert( u.ce.apVal || u.ce.n==0 );
70222   for(u.ce.i=0; u.ce.i<u.ce.n; u.ce.i++, u.ce.pRec++){
70223     assert( memIsValid(u.ce.pRec) );
70224     u.ce.apVal[u.ce.i] = u.ce.pRec;
70225     memAboutToChange(p, u.ce.pRec);
70226     sqlcipher3VdbeMemStoreType(u.ce.pRec);
70227   }
70228   u.ce.ctx.pFunc = pOp->p4.pFunc;
70229   assert( pOp->p3>0 && pOp->p3<=p->nMem );
70230   u.ce.ctx.pMem = u.ce.pMem = &aMem[pOp->p3];
70231   u.ce.pMem->n++;
70232   u.ce.ctx.s.flags = MEM_Null;
70233   u.ce.ctx.s.z = 0;
70234   u.ce.ctx.s.zMalloc = 0;
70235   u.ce.ctx.s.xDel = 0;
70236   u.ce.ctx.s.db = db;
70237   u.ce.ctx.isError = 0;
70238   u.ce.ctx.pColl = 0;
70239   if( u.ce.ctx.pFunc->flags & SQLCIPHER_FUNC_NEEDCOLL ){
70240     assert( pOp>p->aOp );
70241     assert( pOp[-1].p4type==P4_COLLSEQ );
70242     assert( pOp[-1].opcode==OP_CollSeq );
70243     u.ce.ctx.pColl = pOp[-1].p4.pColl;
70244   }
70245   (u.ce.ctx.pFunc->xStep)(&u.ce.ctx, u.ce.n, u.ce.apVal); /* IMP: R-24505-23230 */
70246   if( u.ce.ctx.isError ){
70247     sqlcipher3SetString(&p->zErrMsg, db, "%s", sqlcipher3_value_text(&u.ce.ctx.s));
70248     rc = u.ce.ctx.isError;
70249   }
70250
70251   sqlcipher3VdbeMemRelease(&u.ce.ctx.s);
70252
70253   break;
70254 }
70255
70256 /* Opcode: AggFinal P1 P2 * P4 *
70257 **
70258 ** Execute the finalizer function for an aggregate.  P1 is
70259 ** the memory location that is the accumulator for the aggregate.
70260 **
70261 ** P2 is the number of arguments that the step function takes and
70262 ** P4 is a pointer to the FuncDef for this function.  The P2
70263 ** argument is not used by this opcode.  It is only there to disambiguate
70264 ** functions that can take varying numbers of arguments.  The
70265 ** P4 argument is only needed for the degenerate case where
70266 ** the step function was not previously called.
70267 */
70268 case OP_AggFinal: {
70269 #if 0  /* local variables moved into u.cf */
70270   Mem *pMem;
70271 #endif /* local variables moved into u.cf */
70272   assert( pOp->p1>0 && pOp->p1<=p->nMem );
70273   u.cf.pMem = &aMem[pOp->p1];
70274   assert( (u.cf.pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
70275   rc = sqlcipher3VdbeMemFinalize(u.cf.pMem, pOp->p4.pFunc);
70276   if( rc ){
70277     sqlcipher3SetString(&p->zErrMsg, db, "%s", sqlcipher3_value_text(u.cf.pMem));
70278   }
70279   sqlcipher3VdbeChangeEncoding(u.cf.pMem, encoding);
70280   UPDATE_MAX_BLOBSIZE(u.cf.pMem);
70281   if( sqlcipher3VdbeMemTooBig(u.cf.pMem) ){
70282     goto too_big;
70283   }
70284   break;
70285 }
70286
70287 #ifndef SQLCIPHER_OMIT_WAL
70288 /* Opcode: Checkpoint P1 P2 P3 * *
70289 **
70290 ** Checkpoint database P1. This is a no-op if P1 is not currently in
70291 ** WAL mode. Parameter P2 is one of SQLCIPHER_CHECKPOINT_PASSIVE, FULL
70292 ** or RESTART.  Write 1 or 0 into mem[P3] if the checkpoint returns
70293 ** SQLCIPHER_BUSY or not, respectively.  Write the number of pages in the
70294 ** WAL after the checkpoint into mem[P3+1] and the number of pages
70295 ** in the WAL that have been checkpointed after the checkpoint
70296 ** completes into mem[P3+2].  However on an error, mem[P3+1] and
70297 ** mem[P3+2] are initialized to -1.
70298 */
70299 case OP_Checkpoint: {
70300 #if 0  /* local variables moved into u.cg */
70301   int i;                          /* Loop counter */
70302   int aRes[3];                    /* Results */
70303   Mem *pMem;                      /* Write results here */
70304 #endif /* local variables moved into u.cg */
70305
70306   u.cg.aRes[0] = 0;
70307   u.cg.aRes[1] = u.cg.aRes[2] = -1;
70308   assert( pOp->p2==SQLCIPHER_CHECKPOINT_PASSIVE
70309        || pOp->p2==SQLCIPHER_CHECKPOINT_FULL
70310        || pOp->p2==SQLCIPHER_CHECKPOINT_RESTART
70311   );
70312   rc = sqlcipher3Checkpoint(db, pOp->p1, pOp->p2, &u.cg.aRes[1], &u.cg.aRes[2]);
70313   if( rc==SQLCIPHER_BUSY ){
70314     rc = SQLCIPHER_OK;
70315     u.cg.aRes[0] = 1;
70316   }
70317   for(u.cg.i=0, u.cg.pMem = &aMem[pOp->p3]; u.cg.i<3; u.cg.i++, u.cg.pMem++){
70318     sqlcipher3VdbeMemSetInt64(u.cg.pMem, (i64)u.cg.aRes[u.cg.i]);
70319   }
70320   break;
70321 };  
70322 #endif
70323
70324 #ifndef SQLCIPHER_OMIT_PRAGMA
70325 /* Opcode: JournalMode P1 P2 P3 * P5
70326 **
70327 ** Change the journal mode of database P1 to P3. P3 must be one of the
70328 ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
70329 ** modes (delete, truncate, persist, off and memory), this is a simple
70330 ** operation. No IO is required.
70331 **
70332 ** If changing into or out of WAL mode the procedure is more complicated.
70333 **
70334 ** Write a string containing the final journal-mode to register P2.
70335 */
70336 case OP_JournalMode: {    /* out2-prerelease */
70337 #if 0  /* local variables moved into u.ch */
70338   Btree *pBt;                     /* Btree to change journal mode of */
70339   Pager *pPager;                  /* Pager associated with pBt */
70340   int eNew;                       /* New journal mode */
70341   int eOld;                       /* The old journal mode */
70342   const char *zFilename;          /* Name of database file for pPager */
70343 #endif /* local variables moved into u.ch */
70344
70345   u.ch.eNew = pOp->p3;
70346   assert( u.ch.eNew==PAGER_JOURNALMODE_DELETE
70347        || u.ch.eNew==PAGER_JOURNALMODE_TRUNCATE
70348        || u.ch.eNew==PAGER_JOURNALMODE_PERSIST
70349        || u.ch.eNew==PAGER_JOURNALMODE_OFF
70350        || u.ch.eNew==PAGER_JOURNALMODE_MEMORY
70351        || u.ch.eNew==PAGER_JOURNALMODE_WAL
70352        || u.ch.eNew==PAGER_JOURNALMODE_QUERY
70353   );
70354   assert( pOp->p1>=0 && pOp->p1<db->nDb );
70355
70356   u.ch.pBt = db->aDb[pOp->p1].pBt;
70357   u.ch.pPager = sqlcipher3BtreePager(u.ch.pBt);
70358   u.ch.eOld = sqlcipher3PagerGetJournalMode(u.ch.pPager);
70359   if( u.ch.eNew==PAGER_JOURNALMODE_QUERY ) u.ch.eNew = u.ch.eOld;
70360   if( !sqlcipher3PagerOkToChangeJournalMode(u.ch.pPager) ) u.ch.eNew = u.ch.eOld;
70361
70362 #ifndef SQLCIPHER_OMIT_WAL
70363   u.ch.zFilename = sqlcipher3PagerFilename(u.ch.pPager);
70364
70365   /* Do not allow a transition to journal_mode=WAL for a database
70366   ** in temporary storage or if the VFS does not support shared memory
70367   */
70368   if( u.ch.eNew==PAGER_JOURNALMODE_WAL
70369    && (sqlcipher3Strlen30(u.ch.zFilename)==0           /* Temp file */
70370        || !sqlcipher3PagerWalSupported(u.ch.pPager))   /* No shared-memory support */
70371   ){
70372     u.ch.eNew = u.ch.eOld;
70373   }
70374
70375   if( (u.ch.eNew!=u.ch.eOld)
70376    && (u.ch.eOld==PAGER_JOURNALMODE_WAL || u.ch.eNew==PAGER_JOURNALMODE_WAL)
70377   ){
70378     if( !db->autoCommit || db->activeVdbeCnt>1 ){
70379       rc = SQLCIPHER_ERROR;
70380       sqlcipher3SetString(&p->zErrMsg, db,
70381           "cannot change %s wal mode from within a transaction",
70382           (u.ch.eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
70383       );
70384       break;
70385     }else{
70386
70387       if( u.ch.eOld==PAGER_JOURNALMODE_WAL ){
70388         /* If leaving WAL mode, close the log file. If successful, the call
70389         ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
70390         ** file. An EXCLUSIVE lock may still be held on the database file
70391         ** after a successful return.
70392         */
70393         rc = sqlcipher3PagerCloseWal(u.ch.pPager);
70394         if( rc==SQLCIPHER_OK ){
70395           sqlcipher3PagerSetJournalMode(u.ch.pPager, u.ch.eNew);
70396         }
70397       }else if( u.ch.eOld==PAGER_JOURNALMODE_MEMORY ){
70398         /* Cannot transition directly from MEMORY to WAL.  Use mode OFF
70399         ** as an intermediate */
70400         sqlcipher3PagerSetJournalMode(u.ch.pPager, PAGER_JOURNALMODE_OFF);
70401       }
70402
70403       /* Open a transaction on the database file. Regardless of the journal
70404       ** mode, this transaction always uses a rollback journal.
70405       */
70406       assert( sqlcipher3BtreeIsInTrans(u.ch.pBt)==0 );
70407       if( rc==SQLCIPHER_OK ){
70408         rc = sqlcipher3BtreeSetVersion(u.ch.pBt, (u.ch.eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
70409       }
70410     }
70411   }
70412 #endif /* ifndef SQLCIPHER_OMIT_WAL */
70413
70414   if( rc ){
70415     u.ch.eNew = u.ch.eOld;
70416   }
70417   u.ch.eNew = sqlcipher3PagerSetJournalMode(u.ch.pPager, u.ch.eNew);
70418
70419   pOut = &aMem[pOp->p2];
70420   pOut->flags = MEM_Str|MEM_Static|MEM_Term;
70421   pOut->z = (char *)sqlcipher3JournalModename(u.ch.eNew);
70422   pOut->n = sqlcipher3Strlen30(pOut->z);
70423   pOut->enc = SQLCIPHER_UTF8;
70424   sqlcipher3VdbeChangeEncoding(pOut, encoding);
70425   break;
70426 };
70427 #endif /* SQLCIPHER_OMIT_PRAGMA */
70428
70429 #if !defined(SQLCIPHER_OMIT_VACUUM) && !defined(SQLCIPHER_OMIT_ATTACH)
70430 /* Opcode: Vacuum * * * * *
70431 **
70432 ** Vacuum the entire database.  This opcode will cause other virtual
70433 ** machines to be created and run.  It may not be called from within
70434 ** a transaction.
70435 */
70436 case OP_Vacuum: {
70437   rc = sqlcipher3RunVacuum(&p->zErrMsg, db);
70438   break;
70439 }
70440 #endif
70441
70442 #if !defined(SQLCIPHER_OMIT_AUTOVACUUM)
70443 /* Opcode: IncrVacuum P1 P2 * * *
70444 **
70445 ** Perform a single step of the incremental vacuum procedure on
70446 ** the P1 database. If the vacuum has finished, jump to instruction
70447 ** P2. Otherwise, fall through to the next instruction.
70448 */
70449 case OP_IncrVacuum: {        /* jump */
70450 #if 0  /* local variables moved into u.ci */
70451   Btree *pBt;
70452 #endif /* local variables moved into u.ci */
70453
70454   assert( pOp->p1>=0 && pOp->p1<db->nDb );
70455   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
70456   u.ci.pBt = db->aDb[pOp->p1].pBt;
70457   rc = sqlcipher3BtreeIncrVacuum(u.ci.pBt);
70458   if( rc==SQLCIPHER_DONE ){
70459     pc = pOp->p2 - 1;
70460     rc = SQLCIPHER_OK;
70461   }
70462   break;
70463 }
70464 #endif
70465
70466 /* Opcode: Expire P1 * * * *
70467 **
70468 ** Cause precompiled statements to become expired. An expired statement
70469 ** fails with an error code of SQLCIPHER_SCHEMA if it is ever executed 
70470 ** (via sqlcipher3_step()).
70471 ** 
70472 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
70473 ** then only the currently executing statement is affected. 
70474 */
70475 case OP_Expire: {
70476   if( !pOp->p1 ){
70477     sqlcipher3ExpirePreparedStatements(db);
70478   }else{
70479     p->expired = 1;
70480   }
70481   break;
70482 }
70483
70484 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
70485 /* Opcode: TableLock P1 P2 P3 P4 *
70486 **
70487 ** Obtain a lock on a particular table. This instruction is only used when
70488 ** the shared-cache feature is enabled. 
70489 **
70490 ** P1 is the index of the database in sqlcipher3.aDb[] of the database
70491 ** on which the lock is acquired.  A readlock is obtained if P3==0 or
70492 ** a write lock if P3==1.
70493 **
70494 ** P2 contains the root-page of the table to lock.
70495 **
70496 ** P4 contains a pointer to the name of the table being locked. This is only
70497 ** used to generate an error message if the lock cannot be obtained.
70498 */
70499 case OP_TableLock: {
70500   u8 isWriteLock = (u8)pOp->p3;
70501   if( isWriteLock || 0==(db->flags&SQLCIPHER_ReadUncommitted) ){
70502     int p1 = pOp->p1; 
70503     assert( p1>=0 && p1<db->nDb );
70504     assert( (p->btreeMask & (((yDbMask)1)<<p1))!=0 );
70505     assert( isWriteLock==0 || isWriteLock==1 );
70506     rc = sqlcipher3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
70507     if( (rc&0xFF)==SQLCIPHER_LOCKED ){
70508       const char *z = pOp->p4.z;
70509       sqlcipher3SetString(&p->zErrMsg, db, "database table is locked: %s", z);
70510     }
70511   }
70512   break;
70513 }
70514 #endif /* SQLCIPHER_OMIT_SHARED_CACHE */
70515
70516 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70517 /* Opcode: VBegin * * * P4 *
70518 **
70519 ** P4 may be a pointer to an sqlcipher3_vtab structure. If so, call the 
70520 ** xBegin method for that table.
70521 **
70522 ** Also, whether or not P4 is set, check that this is not being called from
70523 ** within a callback to a virtual table xSync() method. If it is, the error
70524 ** code will be set to SQLCIPHER_LOCKED.
70525 */
70526 case OP_VBegin: {
70527 #if 0  /* local variables moved into u.cj */
70528   VTable *pVTab;
70529 #endif /* local variables moved into u.cj */
70530   u.cj.pVTab = pOp->p4.pVtab;
70531   rc = sqlcipher3VtabBegin(db, u.cj.pVTab);
70532   if( u.cj.pVTab ) importVtabErrMsg(p, u.cj.pVTab->pVtab);
70533   break;
70534 }
70535 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70536
70537 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70538 /* Opcode: VCreate P1 * * P4 *
70539 **
70540 ** P4 is the name of a virtual table in database P1. Call the xCreate method
70541 ** for that table.
70542 */
70543 case OP_VCreate: {
70544   rc = sqlcipher3VtabCallCreate(db, pOp->p1, pOp->p4.z, &p->zErrMsg);
70545   break;
70546 }
70547 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70548
70549 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70550 /* Opcode: VDestroy P1 * * P4 *
70551 **
70552 ** P4 is the name of a virtual table in database P1.  Call the xDestroy method
70553 ** of that table.
70554 */
70555 case OP_VDestroy: {
70556   p->inVtabMethod = 2;
70557   rc = sqlcipher3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
70558   p->inVtabMethod = 0;
70559   break;
70560 }
70561 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70562
70563 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70564 /* Opcode: VOpen P1 * * P4 *
70565 **
70566 ** P4 is a pointer to a virtual table object, an sqlcipher3_vtab structure.
70567 ** P1 is a cursor number.  This opcode opens a cursor to the virtual
70568 ** table and stores that cursor in P1.
70569 */
70570 case OP_VOpen: {
70571 #if 0  /* local variables moved into u.ck */
70572   VdbeCursor *pCur;
70573   sqlcipher3_vtab_cursor *pVtabCursor;
70574   sqlcipher3_vtab *pVtab;
70575   sqlcipher3_module *pModule;
70576 #endif /* local variables moved into u.ck */
70577
70578   u.ck.pCur = 0;
70579   u.ck.pVtabCursor = 0;
70580   u.ck.pVtab = pOp->p4.pVtab->pVtab;
70581   u.ck.pModule = (sqlcipher3_module *)u.ck.pVtab->pModule;
70582   assert(u.ck.pVtab && u.ck.pModule);
70583   rc = u.ck.pModule->xOpen(u.ck.pVtab, &u.ck.pVtabCursor);
70584   importVtabErrMsg(p, u.ck.pVtab);
70585   if( SQLCIPHER_OK==rc ){
70586     /* Initialize sqlcipher3_vtab_cursor base class */
70587     u.ck.pVtabCursor->pVtab = u.ck.pVtab;
70588
70589     /* Initialise vdbe cursor object */
70590     u.ck.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
70591     if( u.ck.pCur ){
70592       u.ck.pCur->pVtabCursor = u.ck.pVtabCursor;
70593       u.ck.pCur->pModule = u.ck.pVtabCursor->pVtab->pModule;
70594     }else{
70595       db->mallocFailed = 1;
70596       u.ck.pModule->xClose(u.ck.pVtabCursor);
70597     }
70598   }
70599   break;
70600 }
70601 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70602
70603 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70604 /* Opcode: VFilter P1 P2 P3 P4 *
70605 **
70606 ** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
70607 ** the filtered result set is empty.
70608 **
70609 ** P4 is either NULL or a string that was generated by the xBestIndex
70610 ** method of the module.  The interpretation of the P4 string is left
70611 ** to the module implementation.
70612 **
70613 ** This opcode invokes the xFilter method on the virtual table specified
70614 ** by P1.  The integer query plan parameter to xFilter is stored in register
70615 ** P3. Register P3+1 stores the argc parameter to be passed to the
70616 ** xFilter method. Registers P3+2..P3+1+argc are the argc
70617 ** additional parameters which are passed to
70618 ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
70619 **
70620 ** A jump is made to P2 if the result set after filtering would be empty.
70621 */
70622 case OP_VFilter: {   /* jump */
70623 #if 0  /* local variables moved into u.cl */
70624   int nArg;
70625   int iQuery;
70626   const sqlcipher3_module *pModule;
70627   Mem *pQuery;
70628   Mem *pArgc;
70629   sqlcipher3_vtab_cursor *pVtabCursor;
70630   sqlcipher3_vtab *pVtab;
70631   VdbeCursor *pCur;
70632   int res;
70633   int i;
70634   Mem **apArg;
70635 #endif /* local variables moved into u.cl */
70636
70637   u.cl.pQuery = &aMem[pOp->p3];
70638   u.cl.pArgc = &u.cl.pQuery[1];
70639   u.cl.pCur = p->apCsr[pOp->p1];
70640   assert( memIsValid(u.cl.pQuery) );
70641   REGISTER_TRACE(pOp->p3, u.cl.pQuery);
70642   assert( u.cl.pCur->pVtabCursor );
70643   u.cl.pVtabCursor = u.cl.pCur->pVtabCursor;
70644   u.cl.pVtab = u.cl.pVtabCursor->pVtab;
70645   u.cl.pModule = u.cl.pVtab->pModule;
70646
70647   /* Grab the index number and argc parameters */
70648   assert( (u.cl.pQuery->flags&MEM_Int)!=0 && u.cl.pArgc->flags==MEM_Int );
70649   u.cl.nArg = (int)u.cl.pArgc->u.i;
70650   u.cl.iQuery = (int)u.cl.pQuery->u.i;
70651
70652   /* Invoke the xFilter method */
70653   {
70654     u.cl.res = 0;
70655     u.cl.apArg = p->apArg;
70656     for(u.cl.i = 0; u.cl.i<u.cl.nArg; u.cl.i++){
70657       u.cl.apArg[u.cl.i] = &u.cl.pArgc[u.cl.i+1];
70658       sqlcipher3VdbeMemStoreType(u.cl.apArg[u.cl.i]);
70659     }
70660
70661     p->inVtabMethod = 1;
70662     rc = u.cl.pModule->xFilter(u.cl.pVtabCursor, u.cl.iQuery, pOp->p4.z, u.cl.nArg, u.cl.apArg);
70663     p->inVtabMethod = 0;
70664     importVtabErrMsg(p, u.cl.pVtab);
70665     if( rc==SQLCIPHER_OK ){
70666       u.cl.res = u.cl.pModule->xEof(u.cl.pVtabCursor);
70667     }
70668
70669     if( u.cl.res ){
70670       pc = pOp->p2 - 1;
70671     }
70672   }
70673   u.cl.pCur->nullRow = 0;
70674
70675   break;
70676 }
70677 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70678
70679 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70680 /* Opcode: VColumn P1 P2 P3 * *
70681 **
70682 ** Store the value of the P2-th column of
70683 ** the row of the virtual-table that the 
70684 ** P1 cursor is pointing to into register P3.
70685 */
70686 case OP_VColumn: {
70687 #if 0  /* local variables moved into u.cm */
70688   sqlcipher3_vtab *pVtab;
70689   const sqlcipher3_module *pModule;
70690   Mem *pDest;
70691   sqlcipher3_context sContext;
70692 #endif /* local variables moved into u.cm */
70693
70694   VdbeCursor *pCur = p->apCsr[pOp->p1];
70695   assert( pCur->pVtabCursor );
70696   assert( pOp->p3>0 && pOp->p3<=p->nMem );
70697   u.cm.pDest = &aMem[pOp->p3];
70698   memAboutToChange(p, u.cm.pDest);
70699   if( pCur->nullRow ){
70700     sqlcipher3VdbeMemSetNull(u.cm.pDest);
70701     break;
70702   }
70703   u.cm.pVtab = pCur->pVtabCursor->pVtab;
70704   u.cm.pModule = u.cm.pVtab->pModule;
70705   assert( u.cm.pModule->xColumn );
70706   memset(&u.cm.sContext, 0, sizeof(u.cm.sContext));
70707
70708   /* The output cell may already have a buffer allocated. Move
70709   ** the current contents to u.cm.sContext.s so in case the user-function
70710   ** can use the already allocated buffer instead of allocating a
70711   ** new one.
70712   */
70713   sqlcipher3VdbeMemMove(&u.cm.sContext.s, u.cm.pDest);
70714   MemSetTypeFlag(&u.cm.sContext.s, MEM_Null);
70715
70716   rc = u.cm.pModule->xColumn(pCur->pVtabCursor, &u.cm.sContext, pOp->p2);
70717   importVtabErrMsg(p, u.cm.pVtab);
70718   if( u.cm.sContext.isError ){
70719     rc = u.cm.sContext.isError;
70720   }
70721
70722   /* Copy the result of the function to the P3 register. We
70723   ** do this regardless of whether or not an error occurred to ensure any
70724   ** dynamic allocation in u.cm.sContext.s (a Mem struct) is  released.
70725   */
70726   sqlcipher3VdbeChangeEncoding(&u.cm.sContext.s, encoding);
70727   sqlcipher3VdbeMemMove(u.cm.pDest, &u.cm.sContext.s);
70728   REGISTER_TRACE(pOp->p3, u.cm.pDest);
70729   UPDATE_MAX_BLOBSIZE(u.cm.pDest);
70730
70731   if( sqlcipher3VdbeMemTooBig(u.cm.pDest) ){
70732     goto too_big;
70733   }
70734   break;
70735 }
70736 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70737
70738 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70739 /* Opcode: VNext P1 P2 * * *
70740 **
70741 ** Advance virtual table P1 to the next row in its result set and
70742 ** jump to instruction P2.  Or, if the virtual table has reached
70743 ** the end of its result set, then fall through to the next instruction.
70744 */
70745 case OP_VNext: {   /* jump */
70746 #if 0  /* local variables moved into u.cn */
70747   sqlcipher3_vtab *pVtab;
70748   const sqlcipher3_module *pModule;
70749   int res;
70750   VdbeCursor *pCur;
70751 #endif /* local variables moved into u.cn */
70752
70753   u.cn.res = 0;
70754   u.cn.pCur = p->apCsr[pOp->p1];
70755   assert( u.cn.pCur->pVtabCursor );
70756   if( u.cn.pCur->nullRow ){
70757     break;
70758   }
70759   u.cn.pVtab = u.cn.pCur->pVtabCursor->pVtab;
70760   u.cn.pModule = u.cn.pVtab->pModule;
70761   assert( u.cn.pModule->xNext );
70762
70763   /* Invoke the xNext() method of the module. There is no way for the
70764   ** underlying implementation to return an error if one occurs during
70765   ** xNext(). Instead, if an error occurs, true is returned (indicating that
70766   ** data is available) and the error code returned when xColumn or
70767   ** some other method is next invoked on the save virtual table cursor.
70768   */
70769   p->inVtabMethod = 1;
70770   rc = u.cn.pModule->xNext(u.cn.pCur->pVtabCursor);
70771   p->inVtabMethod = 0;
70772   importVtabErrMsg(p, u.cn.pVtab);
70773   if( rc==SQLCIPHER_OK ){
70774     u.cn.res = u.cn.pModule->xEof(u.cn.pCur->pVtabCursor);
70775   }
70776
70777   if( !u.cn.res ){
70778     /* If there is data, jump to P2 */
70779     pc = pOp->p2 - 1;
70780   }
70781   break;
70782 }
70783 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70784
70785 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70786 /* Opcode: VRename P1 * * P4 *
70787 **
70788 ** P4 is a pointer to a virtual table object, an sqlcipher3_vtab structure.
70789 ** This opcode invokes the corresponding xRename method. The value
70790 ** in register P1 is passed as the zName argument to the xRename method.
70791 */
70792 case OP_VRename: {
70793 #if 0  /* local variables moved into u.co */
70794   sqlcipher3_vtab *pVtab;
70795   Mem *pName;
70796 #endif /* local variables moved into u.co */
70797
70798   u.co.pVtab = pOp->p4.pVtab->pVtab;
70799   u.co.pName = &aMem[pOp->p1];
70800   assert( u.co.pVtab->pModule->xRename );
70801   assert( memIsValid(u.co.pName) );
70802   REGISTER_TRACE(pOp->p1, u.co.pName);
70803   assert( u.co.pName->flags & MEM_Str );
70804   testcase( u.co.pName->enc==SQLCIPHER_UTF8 );
70805   testcase( u.co.pName->enc==SQLCIPHER_UTF16BE );
70806   testcase( u.co.pName->enc==SQLCIPHER_UTF16LE );
70807   rc = sqlcipher3VdbeChangeEncoding(u.co.pName, SQLCIPHER_UTF8);
70808   if( rc==SQLCIPHER_OK ){
70809     rc = u.co.pVtab->pModule->xRename(u.co.pVtab, u.co.pName->z);
70810     importVtabErrMsg(p, u.co.pVtab);
70811     p->expired = 0;
70812   }
70813   break;
70814 }
70815 #endif
70816
70817 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
70818 /* Opcode: VUpdate P1 P2 P3 P4 *
70819 **
70820 ** P4 is a pointer to a virtual table object, an sqlcipher3_vtab structure.
70821 ** This opcode invokes the corresponding xUpdate method. P2 values
70822 ** are contiguous memory cells starting at P3 to pass to the xUpdate 
70823 ** invocation. The value in register (P3+P2-1) corresponds to the 
70824 ** p2th element of the argv array passed to xUpdate.
70825 **
70826 ** The xUpdate method will do a DELETE or an INSERT or both.
70827 ** The argv[0] element (which corresponds to memory cell P3)
70828 ** is the rowid of a row to delete.  If argv[0] is NULL then no 
70829 ** deletion occurs.  The argv[1] element is the rowid of the new 
70830 ** row.  This can be NULL to have the virtual table select the new 
70831 ** rowid for itself.  The subsequent elements in the array are 
70832 ** the values of columns in the new row.
70833 **
70834 ** If P2==1 then no insert is performed.  argv[0] is the rowid of
70835 ** a row to delete.
70836 **
70837 ** P1 is a boolean flag. If it is set to true and the xUpdate call
70838 ** is successful, then the value returned by sqlcipher3_last_insert_rowid() 
70839 ** is set to the value of the rowid for the row just inserted.
70840 */
70841 case OP_VUpdate: {
70842 #if 0  /* local variables moved into u.cp */
70843   sqlcipher3_vtab *pVtab;
70844   sqlcipher3_module *pModule;
70845   int nArg;
70846   int i;
70847   sqlcipher_int64 rowid;
70848   Mem **apArg;
70849   Mem *pX;
70850 #endif /* local variables moved into u.cp */
70851
70852   assert( pOp->p2==1        || pOp->p5==OE_Fail   || pOp->p5==OE_Rollback
70853        || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
70854   );
70855   u.cp.pVtab = pOp->p4.pVtab->pVtab;
70856   u.cp.pModule = (sqlcipher3_module *)u.cp.pVtab->pModule;
70857   u.cp.nArg = pOp->p2;
70858   assert( pOp->p4type==P4_VTAB );
70859   if( ALWAYS(u.cp.pModule->xUpdate) ){
70860     u8 vtabOnConflict = db->vtabOnConflict;
70861     u.cp.apArg = p->apArg;
70862     u.cp.pX = &aMem[pOp->p3];
70863     for(u.cp.i=0; u.cp.i<u.cp.nArg; u.cp.i++){
70864       assert( memIsValid(u.cp.pX) );
70865       memAboutToChange(p, u.cp.pX);
70866       sqlcipher3VdbeMemStoreType(u.cp.pX);
70867       u.cp.apArg[u.cp.i] = u.cp.pX;
70868       u.cp.pX++;
70869     }
70870     db->vtabOnConflict = pOp->p5;
70871     rc = u.cp.pModule->xUpdate(u.cp.pVtab, u.cp.nArg, u.cp.apArg, &u.cp.rowid);
70872     db->vtabOnConflict = vtabOnConflict;
70873     importVtabErrMsg(p, u.cp.pVtab);
70874     if( rc==SQLCIPHER_OK && pOp->p1 ){
70875       assert( u.cp.nArg>1 && u.cp.apArg[0] && (u.cp.apArg[0]->flags&MEM_Null) );
70876       db->lastRowid = lastRowid = u.cp.rowid;
70877     }
70878     if( rc==SQLCIPHER_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
70879       if( pOp->p5==OE_Ignore ){
70880         rc = SQLCIPHER_OK;
70881       }else{
70882         p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
70883       }
70884     }else{
70885       p->nChange++;
70886     }
70887   }
70888   break;
70889 }
70890 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
70891
70892 #ifndef  SQLCIPHER_OMIT_PAGER_PRAGMAS
70893 /* Opcode: Pagecount P1 P2 * * *
70894 **
70895 ** Write the current number of pages in database P1 to memory cell P2.
70896 */
70897 case OP_Pagecount: {            /* out2-prerelease */
70898   pOut->u.i = sqlcipher3BtreeLastPage(db->aDb[pOp->p1].pBt);
70899   break;
70900 }
70901 #endif
70902
70903
70904 #ifndef  SQLCIPHER_OMIT_PAGER_PRAGMAS
70905 /* Opcode: MaxPgcnt P1 P2 P3 * *
70906 **
70907 ** Try to set the maximum page count for database P1 to the value in P3.
70908 ** Do not let the maximum page count fall below the current page count and
70909 ** do not change the maximum page count value if P3==0.
70910 **
70911 ** Store the maximum page count after the change in register P2.
70912 */
70913 case OP_MaxPgcnt: {            /* out2-prerelease */
70914   unsigned int newMax;
70915   Btree *pBt;
70916
70917   pBt = db->aDb[pOp->p1].pBt;
70918   newMax = 0;
70919   if( pOp->p3 ){
70920     newMax = sqlcipher3BtreeLastPage(pBt);
70921     if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
70922   }
70923   pOut->u.i = sqlcipher3BtreeMaxPageCount(pBt, newMax);
70924   break;
70925 }
70926 #endif
70927
70928
70929 #ifndef SQLCIPHER_OMIT_TRACE
70930 /* Opcode: Trace * * * P4 *
70931 **
70932 ** If tracing is enabled (by the sqlcipher3_trace()) interface, then
70933 ** the UTF-8 string contained in P4 is emitted on the trace callback.
70934 */
70935 case OP_Trace: {
70936 #if 0  /* local variables moved into u.cq */
70937   char *zTrace;
70938   char *z;
70939 #endif /* local variables moved into u.cq */
70940
70941   if( db->xTrace && (u.cq.zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 ){
70942     u.cq.z = sqlcipher3VdbeExpandSql(p, u.cq.zTrace);
70943     db->xTrace(db->pTraceArg, u.cq.z);
70944     sqlcipher3DbFree(db, u.cq.z);
70945   }
70946 #ifdef SQLCIPHER_DEBUG
70947   if( (db->flags & SQLCIPHER_SqlTrace)!=0
70948    && (u.cq.zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
70949   ){
70950     sqlcipher3DebugPrintf("SQL-trace: %s\n", u.cq.zTrace);
70951   }
70952 #endif /* SQLCIPHER_DEBUG */
70953   break;
70954 }
70955 #endif
70956
70957
70958 /* Opcode: Noop * * * * *
70959 **
70960 ** Do nothing.  This instruction is often useful as a jump
70961 ** destination.
70962 */
70963 /*
70964 ** The magic Explain opcode are only inserted when explain==2 (which
70965 ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
70966 ** This opcode records information from the optimizer.  It is the
70967 ** the same as a no-op.  This opcodesnever appears in a real VM program.
70968 */
70969 default: {          /* This is really OP_Noop and OP_Explain */
70970   assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
70971   break;
70972 }
70973
70974 /*****************************************************************************
70975 ** The cases of the switch statement above this line should all be indented
70976 ** by 6 spaces.  But the left-most 6 spaces have been removed to improve the
70977 ** readability.  From this point on down, the normal indentation rules are
70978 ** restored.
70979 *****************************************************************************/
70980     }
70981
70982 #ifdef VDBE_PROFILE
70983     {
70984       u64 elapsed = sqlcipher3Hwtime() - start;
70985       pOp->cycles += elapsed;
70986       pOp->cnt++;
70987 #if 0
70988         fprintf(stdout, "%10llu ", elapsed);
70989         sqlcipher3VdbePrintOp(stdout, origPc, &aOp[origPc]);
70990 #endif
70991     }
70992 #endif
70993
70994     /* The following code adds nothing to the actual functionality
70995     ** of the program.  It is only here for testing and debugging.
70996     ** On the other hand, it does burn CPU cycles every time through
70997     ** the evaluator loop.  So we can leave it out when NDEBUG is defined.
70998     */
70999 #ifndef NDEBUG
71000     assert( pc>=-1 && pc<p->nOp );
71001
71002 #ifdef SQLCIPHER_DEBUG
71003     if( p->trace ){
71004       if( rc!=0 ) fprintf(p->trace,"rc=%d\n",rc);
71005       if( pOp->opflags & (OPFLG_OUT2_PRERELEASE|OPFLG_OUT2) ){
71006         registerTrace(p->trace, pOp->p2, &aMem[pOp->p2]);
71007       }
71008       if( pOp->opflags & OPFLG_OUT3 ){
71009         registerTrace(p->trace, pOp->p3, &aMem[pOp->p3]);
71010       }
71011     }
71012 #endif  /* SQLCIPHER_DEBUG */
71013 #endif  /* NDEBUG */
71014   }  /* The end of the for(;;) loop the loops through opcodes */
71015
71016   /* If we reach this point, it means that execution is finished with
71017   ** an error of some kind.
71018   */
71019 vdbe_error_halt:
71020   assert( rc );
71021   p->rc = rc;
71022   testcase( sqlcipher3GlobalConfig.xLog!=0 );
71023   sqlcipher3_log(rc, "statement aborts at %d: [%s] %s", 
71024                    pc, p->zSql, p->zErrMsg);
71025   sqlcipher3VdbeHalt(p);
71026   if( rc==SQLCIPHER_IOERR_NOMEM ) db->mallocFailed = 1;
71027   rc = SQLCIPHER_ERROR;
71028   if( resetSchemaOnFault>0 ){
71029     sqlcipher3ResetInternalSchema(db, resetSchemaOnFault-1);
71030   }
71031
71032   /* This is the only way out of this procedure.  We have to
71033   ** release the mutexes on btrees that were acquired at the
71034   ** top. */
71035 vdbe_return:
71036   db->lastRowid = lastRowid;
71037   sqlcipher3VdbeLeave(p);
71038   return rc;
71039
71040   /* Jump to here if a string or blob larger than SQLCIPHER_MAX_LENGTH
71041   ** is encountered.
71042   */
71043 too_big:
71044   sqlcipher3SetString(&p->zErrMsg, db, "string or blob too big");
71045   rc = SQLCIPHER_TOOBIG;
71046   goto vdbe_error_halt;
71047
71048   /* Jump to here if a malloc() fails.
71049   */
71050 no_mem:
71051   db->mallocFailed = 1;
71052   sqlcipher3SetString(&p->zErrMsg, db, "out of memory");
71053   rc = SQLCIPHER_NOMEM;
71054   goto vdbe_error_halt;
71055
71056   /* Jump to here for any other kind of fatal error.  The "rc" variable
71057   ** should hold the error number.
71058   */
71059 abort_due_to_error:
71060   assert( p->zErrMsg==0 );
71061   if( db->mallocFailed ) rc = SQLCIPHER_NOMEM;
71062   if( rc!=SQLCIPHER_IOERR_NOMEM ){
71063     sqlcipher3SetString(&p->zErrMsg, db, "%s", sqlcipher3ErrStr(rc));
71064   }
71065   goto vdbe_error_halt;
71066
71067   /* Jump to here if the sqlcipher3_interrupt() API sets the interrupt
71068   ** flag.
71069   */
71070 abort_due_to_interrupt:
71071   assert( db->u1.isInterrupted );
71072   rc = SQLCIPHER_INTERRUPT;
71073   p->rc = rc;
71074   sqlcipher3SetString(&p->zErrMsg, db, "%s", sqlcipher3ErrStr(rc));
71075   goto vdbe_error_halt;
71076 }
71077
71078 /************** End of vdbe.c ************************************************/
71079 /************** Begin file vdbeblob.c ****************************************/
71080 /*
71081 ** 2007 May 1
71082 **
71083 ** The author disclaims copyright to this source code.  In place of
71084 ** a legal notice, here is a blessing:
71085 **
71086 **    May you do good and not evil.
71087 **    May you find forgiveness for yourself and forgive others.
71088 **    May you share freely, never taking more than you give.
71089 **
71090 *************************************************************************
71091 **
71092 ** This file contains code used to implement incremental BLOB I/O.
71093 */
71094
71095
71096 #ifndef SQLCIPHER_OMIT_INCRBLOB
71097
71098 /*
71099 ** Valid sqlcipher3_blob* handles point to Incrblob structures.
71100 */
71101 typedef struct Incrblob Incrblob;
71102 struct Incrblob {
71103   int flags;              /* Copy of "flags" passed to sqlcipher3_blob_open() */
71104   int nByte;              /* Size of open blob, in bytes */
71105   int iOffset;            /* Byte offset of blob in cursor data */
71106   int iCol;               /* Table column this handle is open on */
71107   BtCursor *pCsr;         /* Cursor pointing at blob row */
71108   sqlcipher3_stmt *pStmt;    /* Statement holding cursor open */
71109   sqlcipher3 *db;            /* The associated database */
71110 };
71111
71112
71113 /*
71114 ** This function is used by both blob_open() and blob_reopen(). It seeks
71115 ** the b-tree cursor associated with blob handle p to point to row iRow.
71116 ** If successful, SQLCIPHER_OK is returned and subsequent calls to
71117 ** sqlcipher3_blob_read() or sqlcipher3_blob_write() access the specified row.
71118 **
71119 ** If an error occurs, or if the specified row does not exist or does not
71120 ** contain a value of type TEXT or BLOB in the column nominated when the
71121 ** blob handle was opened, then an error code is returned and *pzErr may
71122 ** be set to point to a buffer containing an error message. It is the
71123 ** responsibility of the caller to free the error message buffer using
71124 ** sqlcipher3DbFree().
71125 **
71126 ** If an error does occur, then the b-tree cursor is closed. All subsequent
71127 ** calls to sqlcipher3_blob_read(), blob_write() or blob_reopen() will 
71128 ** immediately return SQLCIPHER_ABORT.
71129 */
71130 static int blobSeekToRow(Incrblob *p, sqlcipher3_int64 iRow, char **pzErr){
71131   int rc;                         /* Error code */
71132   char *zErr = 0;                 /* Error message */
71133   Vdbe *v = (Vdbe *)p->pStmt;
71134
71135   /* Set the value of the SQL statements only variable to integer iRow. 
71136   ** This is done directly instead of using sqlcipher3_bind_int64() to avoid 
71137   ** triggering asserts related to mutexes.
71138   */
71139   assert( v->aVar[0].flags&MEM_Int );
71140   v->aVar[0].u.i = iRow;
71141
71142   rc = sqlcipher3_step(p->pStmt);
71143   if( rc==SQLCIPHER_ROW ){
71144     u32 type = v->apCsr[0]->aType[p->iCol];
71145     if( type<12 ){
71146       zErr = sqlcipher3MPrintf(p->db, "cannot open value of type %s",
71147           type==0?"null": type==7?"real": "integer"
71148       );
71149       rc = SQLCIPHER_ERROR;
71150       sqlcipher3_finalize(p->pStmt);
71151       p->pStmt = 0;
71152     }else{
71153       p->iOffset = v->apCsr[0]->aOffset[p->iCol];
71154       p->nByte = sqlcipher3VdbeSerialTypeLen(type);
71155       p->pCsr =  v->apCsr[0]->pCursor;
71156       sqlcipher3BtreeEnterCursor(p->pCsr);
71157       sqlcipher3BtreeCacheOverflow(p->pCsr);
71158       sqlcipher3BtreeLeaveCursor(p->pCsr);
71159     }
71160   }
71161
71162   if( rc==SQLCIPHER_ROW ){
71163     rc = SQLCIPHER_OK;
71164   }else if( p->pStmt ){
71165     rc = sqlcipher3_finalize(p->pStmt);
71166     p->pStmt = 0;
71167     if( rc==SQLCIPHER_OK ){
71168       zErr = sqlcipher3MPrintf(p->db, "no such rowid: %lld", iRow);
71169       rc = SQLCIPHER_ERROR;
71170     }else{
71171       zErr = sqlcipher3MPrintf(p->db, "%s", sqlcipher3_errmsg(p->db));
71172     }
71173   }
71174
71175   assert( rc!=SQLCIPHER_OK || zErr==0 );
71176   assert( rc!=SQLCIPHER_ROW && rc!=SQLCIPHER_DONE );
71177
71178   *pzErr = zErr;
71179   return rc;
71180 }
71181
71182 /*
71183 ** Open a blob handle.
71184 */
71185 SQLCIPHER_API int sqlcipher3_blob_open(
71186   sqlcipher3* db,            /* The database connection */
71187   const char *zDb,        /* The attached database containing the blob */
71188   const char *zTable,     /* The table containing the blob */
71189   const char *zColumn,    /* The column containing the blob */
71190   sqlcipher_int64 iRow,      /* The row containing the glob */
71191   int flags,              /* True -> read/write access, false -> read-only */
71192   sqlcipher3_blob **ppBlob   /* Handle for accessing the blob returned here */
71193 ){
71194   int nAttempt = 0;
71195   int iCol;               /* Index of zColumn in row-record */
71196
71197   /* This VDBE program seeks a btree cursor to the identified 
71198   ** db/table/row entry. The reason for using a vdbe program instead
71199   ** of writing code to use the b-tree layer directly is that the
71200   ** vdbe program will take advantage of the various transaction,
71201   ** locking and error handling infrastructure built into the vdbe.
71202   **
71203   ** After seeking the cursor, the vdbe executes an OP_ResultRow.
71204   ** Code external to the Vdbe then "borrows" the b-tree cursor and
71205   ** uses it to implement the blob_read(), blob_write() and 
71206   ** blob_bytes() functions.
71207   **
71208   ** The sqlcipher3_blob_close() function finalizes the vdbe program,
71209   ** which closes the b-tree cursor and (possibly) commits the 
71210   ** transaction.
71211   */
71212   static const VdbeOpList openBlob[] = {
71213     {OP_Transaction, 0, 0, 0},     /* 0: Start a transaction */
71214     {OP_VerifyCookie, 0, 0, 0},    /* 1: Check the schema cookie */
71215     {OP_TableLock, 0, 0, 0},       /* 2: Acquire a read or write lock */
71216
71217     /* One of the following two instructions is replaced by an OP_Noop. */
71218     {OP_OpenRead, 0, 0, 0},        /* 3: Open cursor 0 for reading */
71219     {OP_OpenWrite, 0, 0, 0},       /* 4: Open cursor 0 for read/write */
71220
71221     {OP_Variable, 1, 1, 1},        /* 5: Push the rowid to the stack */
71222     {OP_NotExists, 0, 10, 1},      /* 6: Seek the cursor */
71223     {OP_Column, 0, 0, 1},          /* 7  */
71224     {OP_ResultRow, 1, 0, 0},       /* 8  */
71225     {OP_Goto, 0, 5, 0},            /* 9  */
71226     {OP_Close, 0, 0, 0},           /* 10 */
71227     {OP_Halt, 0, 0, 0},            /* 11 */
71228   };
71229
71230   int rc = SQLCIPHER_OK;
71231   char *zErr = 0;
71232   Table *pTab;
71233   Parse *pParse = 0;
71234   Incrblob *pBlob = 0;
71235
71236   flags = !!flags;                /* flags = (flags ? 1 : 0); */
71237   *ppBlob = 0;
71238
71239   sqlcipher3_mutex_enter(db->mutex);
71240
71241   pBlob = (Incrblob *)sqlcipher3DbMallocZero(db, sizeof(Incrblob));
71242   if( !pBlob ) goto blob_open_out;
71243   pParse = sqlcipher3StackAllocRaw(db, sizeof(*pParse));
71244   if( !pParse ) goto blob_open_out;
71245
71246   do {
71247     memset(pParse, 0, sizeof(Parse));
71248     pParse->db = db;
71249     sqlcipher3DbFree(db, zErr);
71250     zErr = 0;
71251
71252     sqlcipher3BtreeEnterAll(db);
71253     pTab = sqlcipher3LocateTable(pParse, 0, zTable, zDb);
71254     if( pTab && IsVirtual(pTab) ){
71255       pTab = 0;
71256       sqlcipher3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
71257     }
71258 #ifndef SQLCIPHER_OMIT_VIEW
71259     if( pTab && pTab->pSelect ){
71260       pTab = 0;
71261       sqlcipher3ErrorMsg(pParse, "cannot open view: %s", zTable);
71262     }
71263 #endif
71264     if( !pTab ){
71265       if( pParse->zErrMsg ){
71266         sqlcipher3DbFree(db, zErr);
71267         zErr = pParse->zErrMsg;
71268         pParse->zErrMsg = 0;
71269       }
71270       rc = SQLCIPHER_ERROR;
71271       sqlcipher3BtreeLeaveAll(db);
71272       goto blob_open_out;
71273     }
71274
71275     /* Now search pTab for the exact column. */
71276     for(iCol=0; iCol<pTab->nCol; iCol++) {
71277       if( sqlcipher3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
71278         break;
71279       }
71280     }
71281     if( iCol==pTab->nCol ){
71282       sqlcipher3DbFree(db, zErr);
71283       zErr = sqlcipher3MPrintf(db, "no such column: \"%s\"", zColumn);
71284       rc = SQLCIPHER_ERROR;
71285       sqlcipher3BtreeLeaveAll(db);
71286       goto blob_open_out;
71287     }
71288
71289     /* If the value is being opened for writing, check that the
71290     ** column is not indexed, and that it is not part of a foreign key. 
71291     ** It is against the rules to open a column to which either of these
71292     ** descriptions applies for writing.  */
71293     if( flags ){
71294       const char *zFault = 0;
71295       Index *pIdx;
71296 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
71297       if( db->flags&SQLCIPHER_ForeignKeys ){
71298         /* Check that the column is not part of an FK child key definition. It
71299         ** is not necessary to check if it is part of a parent key, as parent
71300         ** key columns must be indexed. The check below will pick up this 
71301         ** case.  */
71302         FKey *pFKey;
71303         for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
71304           int j;
71305           for(j=0; j<pFKey->nCol; j++){
71306             if( pFKey->aCol[j].iFrom==iCol ){
71307               zFault = "foreign key";
71308             }
71309           }
71310         }
71311       }
71312 #endif
71313       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
71314         int j;
71315         for(j=0; j<pIdx->nColumn; j++){
71316           if( pIdx->aiColumn[j]==iCol ){
71317             zFault = "indexed";
71318           }
71319         }
71320       }
71321       if( zFault ){
71322         sqlcipher3DbFree(db, zErr);
71323         zErr = sqlcipher3MPrintf(db, "cannot open %s column for writing", zFault);
71324         rc = SQLCIPHER_ERROR;
71325         sqlcipher3BtreeLeaveAll(db);
71326         goto blob_open_out;
71327       }
71328     }
71329
71330     pBlob->pStmt = (sqlcipher3_stmt *)sqlcipher3VdbeCreate(db);
71331     assert( pBlob->pStmt || db->mallocFailed );
71332     if( pBlob->pStmt ){
71333       Vdbe *v = (Vdbe *)pBlob->pStmt;
71334       int iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
71335
71336       sqlcipher3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
71337
71338
71339       /* Configure the OP_Transaction */
71340       sqlcipher3VdbeChangeP1(v, 0, iDb);
71341       sqlcipher3VdbeChangeP2(v, 0, flags);
71342
71343       /* Configure the OP_VerifyCookie */
71344       sqlcipher3VdbeChangeP1(v, 1, iDb);
71345       sqlcipher3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
71346       sqlcipher3VdbeChangeP3(v, 1, pTab->pSchema->iGeneration);
71347
71348       /* Make sure a mutex is held on the table to be accessed */
71349       sqlcipher3VdbeUsesBtree(v, iDb); 
71350
71351       /* Configure the OP_TableLock instruction */
71352 #ifdef SQLCIPHER_OMIT_SHARED_CACHE
71353       sqlcipher3VdbeChangeToNoop(v, 2);
71354 #else
71355       sqlcipher3VdbeChangeP1(v, 2, iDb);
71356       sqlcipher3VdbeChangeP2(v, 2, pTab->tnum);
71357       sqlcipher3VdbeChangeP3(v, 2, flags);
71358       sqlcipher3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
71359 #endif
71360
71361       /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
71362       ** parameter of the other to pTab->tnum.  */
71363       sqlcipher3VdbeChangeToNoop(v, 4 - flags);
71364       sqlcipher3VdbeChangeP2(v, 3 + flags, pTab->tnum);
71365       sqlcipher3VdbeChangeP3(v, 3 + flags, iDb);
71366
71367       /* Configure the number of columns. Configure the cursor to
71368       ** think that the table has one more column than it really
71369       ** does. An OP_Column to retrieve this imaginary column will
71370       ** always return an SQL NULL. This is useful because it means
71371       ** we can invoke OP_Column to fill in the vdbe cursors type 
71372       ** and offset cache without causing any IO.
71373       */
71374       sqlcipher3VdbeChangeP4(v, 3+flags, SQLCIPHER_INT_TO_PTR(pTab->nCol+1),P4_INT32);
71375       sqlcipher3VdbeChangeP2(v, 7, pTab->nCol);
71376       if( !db->mallocFailed ){
71377         pParse->nVar = 1;
71378         pParse->nMem = 1;
71379         pParse->nTab = 1;
71380         sqlcipher3VdbeMakeReady(v, pParse);
71381       }
71382     }
71383    
71384     pBlob->flags = flags;
71385     pBlob->iCol = iCol;
71386     pBlob->db = db;
71387     sqlcipher3BtreeLeaveAll(db);
71388     if( db->mallocFailed ){
71389       goto blob_open_out;
71390     }
71391     sqlcipher3_bind_int64(pBlob->pStmt, 1, iRow);
71392     rc = blobSeekToRow(pBlob, iRow, &zErr);
71393   } while( (++nAttempt)<5 && rc==SQLCIPHER_SCHEMA );
71394
71395 blob_open_out:
71396   if( rc==SQLCIPHER_OK && db->mallocFailed==0 ){
71397     *ppBlob = (sqlcipher3_blob *)pBlob;
71398   }else{
71399     if( pBlob && pBlob->pStmt ) sqlcipher3VdbeFinalize((Vdbe *)pBlob->pStmt);
71400     sqlcipher3DbFree(db, pBlob);
71401   }
71402   sqlcipher3Error(db, rc, (zErr ? "%s" : 0), zErr);
71403   sqlcipher3DbFree(db, zErr);
71404   sqlcipher3StackFree(db, pParse);
71405   rc = sqlcipher3ApiExit(db, rc);
71406   sqlcipher3_mutex_leave(db->mutex);
71407   return rc;
71408 }
71409
71410 /*
71411 ** Close a blob handle that was previously created using
71412 ** sqlcipher3_blob_open().
71413 */
71414 SQLCIPHER_API int sqlcipher3_blob_close(sqlcipher3_blob *pBlob){
71415   Incrblob *p = (Incrblob *)pBlob;
71416   int rc;
71417   sqlcipher3 *db;
71418
71419   if( p ){
71420     db = p->db;
71421     sqlcipher3_mutex_enter(db->mutex);
71422     rc = sqlcipher3_finalize(p->pStmt);
71423     sqlcipher3DbFree(db, p);
71424     sqlcipher3_mutex_leave(db->mutex);
71425   }else{
71426     rc = SQLCIPHER_OK;
71427   }
71428   return rc;
71429 }
71430
71431 /*
71432 ** Perform a read or write operation on a blob
71433 */
71434 static int blobReadWrite(
71435   sqlcipher3_blob *pBlob, 
71436   void *z, 
71437   int n, 
71438   int iOffset, 
71439   int (*xCall)(BtCursor*, u32, u32, void*)
71440 ){
71441   int rc;
71442   Incrblob *p = (Incrblob *)pBlob;
71443   Vdbe *v;
71444   sqlcipher3 *db;
71445
71446   if( p==0 ) return SQLCIPHER_MISUSE_BKPT;
71447   db = p->db;
71448   sqlcipher3_mutex_enter(db->mutex);
71449   v = (Vdbe*)p->pStmt;
71450
71451   if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
71452     /* Request is out of range. Return a transient error. */
71453     rc = SQLCIPHER_ERROR;
71454     sqlcipher3Error(db, SQLCIPHER_ERROR, 0);
71455   }else if( v==0 ){
71456     /* If there is no statement handle, then the blob-handle has
71457     ** already been invalidated. Return SQLCIPHER_ABORT in this case.
71458     */
71459     rc = SQLCIPHER_ABORT;
71460   }else{
71461     /* Call either BtreeData() or BtreePutData(). If SQLCIPHER_ABORT is
71462     ** returned, clean-up the statement handle.
71463     */
71464     assert( db == v->db );
71465     sqlcipher3BtreeEnterCursor(p->pCsr);
71466     rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
71467     sqlcipher3BtreeLeaveCursor(p->pCsr);
71468     if( rc==SQLCIPHER_ABORT ){
71469       sqlcipher3VdbeFinalize(v);
71470       p->pStmt = 0;
71471     }else{
71472       db->errCode = rc;
71473       v->rc = rc;
71474     }
71475   }
71476   rc = sqlcipher3ApiExit(db, rc);
71477   sqlcipher3_mutex_leave(db->mutex);
71478   return rc;
71479 }
71480
71481 /*
71482 ** Read data from a blob handle.
71483 */
71484 SQLCIPHER_API int sqlcipher3_blob_read(sqlcipher3_blob *pBlob, void *z, int n, int iOffset){
71485   return blobReadWrite(pBlob, z, n, iOffset, sqlcipher3BtreeData);
71486 }
71487
71488 /*
71489 ** Write data to a blob handle.
71490 */
71491 SQLCIPHER_API int sqlcipher3_blob_write(sqlcipher3_blob *pBlob, const void *z, int n, int iOffset){
71492   return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlcipher3BtreePutData);
71493 }
71494
71495 /*
71496 ** Query a blob handle for the size of the data.
71497 **
71498 ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
71499 ** so no mutex is required for access.
71500 */
71501 SQLCIPHER_API int sqlcipher3_blob_bytes(sqlcipher3_blob *pBlob){
71502   Incrblob *p = (Incrblob *)pBlob;
71503   return (p && p->pStmt) ? p->nByte : 0;
71504 }
71505
71506 /*
71507 ** Move an existing blob handle to point to a different row of the same
71508 ** database table.
71509 **
71510 ** If an error occurs, or if the specified row does not exist or does not
71511 ** contain a blob or text value, then an error code is returned and the
71512 ** database handle error code and message set. If this happens, then all 
71513 ** subsequent calls to sqlcipher3_blob_xxx() functions (except blob_close()) 
71514 ** immediately return SQLCIPHER_ABORT.
71515 */
71516 SQLCIPHER_API int sqlcipher3_blob_reopen(sqlcipher3_blob *pBlob, sqlcipher3_int64 iRow){
71517   int rc;
71518   Incrblob *p = (Incrblob *)pBlob;
71519   sqlcipher3 *db;
71520
71521   if( p==0 ) return SQLCIPHER_MISUSE_BKPT;
71522   db = p->db;
71523   sqlcipher3_mutex_enter(db->mutex);
71524
71525   if( p->pStmt==0 ){
71526     /* If there is no statement handle, then the blob-handle has
71527     ** already been invalidated. Return SQLCIPHER_ABORT in this case.
71528     */
71529     rc = SQLCIPHER_ABORT;
71530   }else{
71531     char *zErr;
71532     rc = blobSeekToRow(p, iRow, &zErr);
71533     if( rc!=SQLCIPHER_OK ){
71534       sqlcipher3Error(db, rc, (zErr ? "%s" : 0), zErr);
71535       sqlcipher3DbFree(db, zErr);
71536     }
71537     assert( rc!=SQLCIPHER_SCHEMA );
71538   }
71539
71540   rc = sqlcipher3ApiExit(db, rc);
71541   assert( rc==SQLCIPHER_OK || p->pStmt==0 );
71542   sqlcipher3_mutex_leave(db->mutex);
71543   return rc;
71544 }
71545
71546 #endif /* #ifndef SQLCIPHER_OMIT_INCRBLOB */
71547
71548 /************** End of vdbeblob.c ********************************************/
71549 /************** Begin file vdbesort.c ****************************************/
71550 /*
71551 ** 2011 July 9
71552 **
71553 ** The author disclaims copyright to this source code.  In place of
71554 ** a legal notice, here is a blessing:
71555 **
71556 **    May you do good and not evil.
71557 **    May you find forgiveness for yourself and forgive others.
71558 **    May you share freely, never taking more than you give.
71559 **
71560 *************************************************************************
71561 ** This file contains code for the VdbeSorter object, used in concert with
71562 ** a VdbeCursor to sort large numbers of keys (as may be required, for
71563 ** example, by CREATE INDEX statements on tables too large to fit in main
71564 ** memory).
71565 */
71566
71567
71568 #ifndef SQLCIPHER_OMIT_MERGE_SORT
71569
71570 typedef struct VdbeSorterIter VdbeSorterIter;
71571 typedef struct SorterRecord SorterRecord;
71572
71573 /*
71574 ** NOTES ON DATA STRUCTURE USED FOR N-WAY MERGES:
71575 **
71576 ** As keys are added to the sorter, they are written to disk in a series
71577 ** of sorted packed-memory-arrays (PMAs). The size of each PMA is roughly
71578 ** the same as the cache-size allowed for temporary databases. In order
71579 ** to allow the caller to extract keys from the sorter in sorted order,
71580 ** all PMAs currently stored on disk must be merged together. This comment
71581 ** describes the data structure used to do so. The structure supports 
71582 ** merging any number of arrays in a single pass with no redundant comparison 
71583 ** operations.
71584 **
71585 ** The aIter[] array contains an iterator for each of the PMAs being merged.
71586 ** An aIter[] iterator either points to a valid key or else is at EOF. For 
71587 ** the purposes of the paragraphs below, we assume that the array is actually 
71588 ** N elements in size, where N is the smallest power of 2 greater to or equal 
71589 ** to the number of iterators being merged. The extra aIter[] elements are 
71590 ** treated as if they are empty (always at EOF).
71591 **
71592 ** The aTree[] array is also N elements in size. The value of N is stored in
71593 ** the VdbeSorter.nTree variable.
71594 **
71595 ** The final (N/2) elements of aTree[] contain the results of comparing
71596 ** pairs of iterator keys together. Element i contains the result of 
71597 ** comparing aIter[2*i-N] and aIter[2*i-N+1]. Whichever key is smaller, the
71598 ** aTree element is set to the index of it. 
71599 **
71600 ** For the purposes of this comparison, EOF is considered greater than any
71601 ** other key value. If the keys are equal (only possible with two EOF
71602 ** values), it doesn't matter which index is stored.
71603 **
71604 ** The (N/4) elements of aTree[] that preceed the final (N/2) described 
71605 ** above contains the index of the smallest of each block of 4 iterators.
71606 ** And so on. So that aTree[1] contains the index of the iterator that 
71607 ** currently points to the smallest key value. aTree[0] is unused.
71608 **
71609 ** Example:
71610 **
71611 **     aIter[0] -> Banana
71612 **     aIter[1] -> Feijoa
71613 **     aIter[2] -> Elderberry
71614 **     aIter[3] -> Currant
71615 **     aIter[4] -> Grapefruit
71616 **     aIter[5] -> Apple
71617 **     aIter[6] -> Durian
71618 **     aIter[7] -> EOF
71619 **
71620 **     aTree[] = { X, 5   0, 5    0, 3, 5, 6 }
71621 **
71622 ** The current element is "Apple" (the value of the key indicated by 
71623 ** iterator 5). When the Next() operation is invoked, iterator 5 will
71624 ** be advanced to the next key in its segment. Say the next key is
71625 ** "Eggplant":
71626 **
71627 **     aIter[5] -> Eggplant
71628 **
71629 ** The contents of aTree[] are updated first by comparing the new iterator
71630 ** 5 key to the current key of iterator 4 (still "Grapefruit"). The iterator
71631 ** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree.
71632 ** The value of iterator 6 - "Durian" - is now smaller than that of iterator
71633 ** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Banana<Durian),
71634 ** so the value written into element 1 of the array is 0. As follows:
71635 **
71636 **     aTree[] = { X, 0   0, 6    0, 3, 5, 6 }
71637 **
71638 ** In other words, each time we advance to the next sorter element, log2(N)
71639 ** key comparison operations are required, where N is the number of segments
71640 ** being merged (rounded up to the next power of 2).
71641 */
71642 struct VdbeSorter {
71643   int nInMemory;                  /* Current size of pRecord list as PMA */
71644   int nTree;                      /* Used size of aTree/aIter (power of 2) */
71645   VdbeSorterIter *aIter;          /* Array of iterators to merge */
71646   int *aTree;                     /* Current state of incremental merge */
71647   i64 iWriteOff;                  /* Current write offset within file pTemp1 */
71648   i64 iReadOff;                   /* Current read offset within file pTemp1 */
71649   sqlcipher3_file *pTemp1;           /* PMA file 1 */
71650   int nPMA;                       /* Number of PMAs stored in pTemp1 */
71651   SorterRecord *pRecord;          /* Head of in-memory record list */
71652   int mnPmaSize;                  /* Minimum PMA size, in bytes */
71653   int mxPmaSize;                  /* Maximum PMA size, in bytes.  0==no limit */
71654   UnpackedRecord *pUnpacked;      /* Used to unpack keys */
71655 };
71656
71657 /*
71658 ** The following type is an iterator for a PMA. It caches the current key in 
71659 ** variables nKey/aKey. If the iterator is at EOF, pFile==0.
71660 */
71661 struct VdbeSorterIter {
71662   i64 iReadOff;                   /* Current read offset */
71663   i64 iEof;                       /* 1 byte past EOF for this iterator */
71664   sqlcipher3_file *pFile;            /* File iterator is reading from */
71665   int nAlloc;                     /* Bytes of space at aAlloc */
71666   u8 *aAlloc;                     /* Allocated space */
71667   int nKey;                       /* Number of bytes in key */
71668   u8 *aKey;                       /* Pointer to current key */
71669 };
71670
71671 /*
71672 ** A structure to store a single record. All in-memory records are connected
71673 ** together into a linked list headed at VdbeSorter.pRecord using the 
71674 ** SorterRecord.pNext pointer.
71675 */
71676 struct SorterRecord {
71677   void *pVal;
71678   int nVal;
71679   SorterRecord *pNext;
71680 };
71681
71682 /* Minimum allowable value for the VdbeSorter.nWorking variable */
71683 #define SORTER_MIN_WORKING 10
71684
71685 /* Maximum number of segments to merge in a single pass. */
71686 #define SORTER_MAX_MERGE_COUNT 16
71687
71688 /*
71689 ** Free all memory belonging to the VdbeSorterIter object passed as the second
71690 ** argument. All structure fields are set to zero before returning.
71691 */
71692 static void vdbeSorterIterZero(sqlcipher3 *db, VdbeSorterIter *pIter){
71693   sqlcipher3DbFree(db, pIter->aAlloc);
71694   memset(pIter, 0, sizeof(VdbeSorterIter));
71695 }
71696
71697 /*
71698 ** Advance iterator pIter to the next key in its PMA. Return SQLCIPHER_OK if
71699 ** no error occurs, or an SQLite error code if one does.
71700 */
71701 static int vdbeSorterIterNext(
71702   sqlcipher3 *db,                    /* Database handle (for sqlcipher3DbMalloc() ) */
71703   VdbeSorterIter *pIter           /* Iterator to advance */
71704 ){
71705   int rc;                         /* Return Code */
71706   int nRead;                      /* Number of bytes read */
71707   int nRec = 0;                   /* Size of record in bytes */
71708   int iOff = 0;                   /* Size of serialized size varint in bytes */
71709
71710   assert( pIter->iEof>=pIter->iReadOff );
71711   if( pIter->iEof-pIter->iReadOff>5 ){
71712     nRead = 5;
71713   }else{
71714     nRead = (int)(pIter->iEof - pIter->iReadOff);
71715   }
71716   if( nRead<=0 ){
71717     /* This is an EOF condition */
71718     vdbeSorterIterZero(db, pIter);
71719     return SQLCIPHER_OK;
71720   }
71721
71722   rc = sqlcipher3OsRead(pIter->pFile, pIter->aAlloc, nRead, pIter->iReadOff);
71723   if( rc==SQLCIPHER_OK ){
71724     iOff = getVarint32(pIter->aAlloc, nRec);
71725     if( (iOff+nRec)>nRead ){
71726       int nRead2;                   /* Number of extra bytes to read */
71727       if( (iOff+nRec)>pIter->nAlloc ){
71728         int nNew = pIter->nAlloc*2;
71729         while( (iOff+nRec)>nNew ) nNew = nNew*2;
71730         pIter->aAlloc = sqlcipher3DbReallocOrFree(db, pIter->aAlloc, nNew);
71731         if( !pIter->aAlloc ) return SQLCIPHER_NOMEM;
71732         pIter->nAlloc = nNew;
71733       }
71734   
71735       nRead2 = iOff + nRec - nRead;
71736       rc = sqlcipher3OsRead(
71737           pIter->pFile, &pIter->aAlloc[nRead], nRead2, pIter->iReadOff+nRead
71738       );
71739     }
71740   }
71741
71742   assert( rc!=SQLCIPHER_OK || nRec>0 );
71743   pIter->iReadOff += iOff+nRec;
71744   pIter->nKey = nRec;
71745   pIter->aKey = &pIter->aAlloc[iOff];
71746   return rc;
71747 }
71748
71749 /*
71750 ** Write a single varint, value iVal, to file-descriptor pFile. Return
71751 ** SQLCIPHER_OK if successful, or an SQLite error code if some error occurs.
71752 **
71753 ** The value of *piOffset when this function is called is used as the byte
71754 ** offset in file pFile to write to. Before returning, *piOffset is 
71755 ** incremented by the number of bytes written.
71756 */
71757 static int vdbeSorterWriteVarint(
71758   sqlcipher3_file *pFile,            /* File to write to */
71759   i64 iVal,                       /* Value to write as a varint */
71760   i64 *piOffset                   /* IN/OUT: Write offset in file pFile */
71761 ){
71762   u8 aVarint[9];                  /* Buffer large enough for a varint */
71763   int nVarint;                    /* Number of used bytes in varint */
71764   int rc;                         /* Result of write() call */
71765
71766   nVarint = sqlcipher3PutVarint(aVarint, iVal);
71767   rc = sqlcipher3OsWrite(pFile, aVarint, nVarint, *piOffset);
71768   *piOffset += nVarint;
71769
71770   return rc;
71771 }
71772
71773 /*
71774 ** Read a single varint from file-descriptor pFile. Return SQLCIPHER_OK if
71775 ** successful, or an SQLite error code if some error occurs.
71776 **
71777 ** The value of *piOffset when this function is called is used as the
71778 ** byte offset in file pFile from whence to read the varint. If successful
71779 ** (i.e. if no IO error occurs), then *piOffset is set to the offset of
71780 ** the first byte past the end of the varint before returning. *piVal is
71781 ** set to the integer value read. If an error occurs, the final values of
71782 ** both *piOffset and *piVal are undefined.
71783 */
71784 static int vdbeSorterReadVarint(
71785   sqlcipher3_file *pFile,            /* File to read from */
71786   i64 *piOffset,                  /* IN/OUT: Read offset in pFile */
71787   i64 *piVal                      /* OUT: Value read from file */
71788 ){
71789   u8 aVarint[9];                  /* Buffer large enough for a varint */
71790   i64 iOff = *piOffset;           /* Offset in file to read from */
71791   int rc;                         /* Return code */
71792
71793   rc = sqlcipher3OsRead(pFile, aVarint, 9, iOff);
71794   if( rc==SQLCIPHER_OK ){
71795     *piOffset += getVarint(aVarint, (u64 *)piVal);
71796   }
71797
71798   return rc;
71799 }
71800
71801 /*
71802 ** Initialize iterator pIter to scan through the PMA stored in file pFile
71803 ** starting at offset iStart and ending at offset iEof-1. This function 
71804 ** leaves the iterator pointing to the first key in the PMA (or EOF if the 
71805 ** PMA is empty).
71806 */
71807 static int vdbeSorterIterInit(
71808   sqlcipher3 *db,                    /* Database handle */
71809   VdbeSorter *pSorter,            /* Sorter object */
71810   i64 iStart,                     /* Start offset in pFile */
71811   VdbeSorterIter *pIter,          /* Iterator to populate */
71812   i64 *pnByte                     /* IN/OUT: Increment this value by PMA size */
71813 ){
71814   int rc;
71815
71816   assert( pSorter->iWriteOff>iStart );
71817   assert( pIter->aAlloc==0 );
71818   pIter->pFile = pSorter->pTemp1;
71819   pIter->iReadOff = iStart;
71820   pIter->nAlloc = 128;
71821   pIter->aAlloc = (u8 *)sqlcipher3DbMallocRaw(db, pIter->nAlloc);
71822   if( !pIter->aAlloc ){
71823     rc = SQLCIPHER_NOMEM;
71824   }else{
71825     i64 nByte;                         /* Total size of PMA in bytes */
71826     rc = vdbeSorterReadVarint(pSorter->pTemp1, &pIter->iReadOff, &nByte);
71827     *pnByte += nByte;
71828     pIter->iEof = pIter->iReadOff + nByte;
71829   }
71830   if( rc==SQLCIPHER_OK ){
71831     rc = vdbeSorterIterNext(db, pIter);
71832   }
71833   return rc;
71834 }
71835
71836
71837 /*
71838 ** Compare key1 (buffer pKey1, size nKey1 bytes) with key2 (buffer pKey2, 
71839 ** size nKey2 bytes).  Argument pKeyInfo supplies the collation functions
71840 ** used by the comparison. If an error occurs, return an SQLite error code.
71841 ** Otherwise, return SQLCIPHER_OK and set *pRes to a negative, zero or positive
71842 ** value, depending on whether key1 is smaller, equal to or larger than key2.
71843 **
71844 ** If the bOmitRowid argument is non-zero, assume both keys end in a rowid
71845 ** field. For the purposes of the comparison, ignore it. Also, if bOmitRowid
71846 ** is true and key1 contains even a single NULL value, it is considered to
71847 ** be less than key2. Even if key2 also contains NULL values.
71848 **
71849 ** If pKey2 is passed a NULL pointer, then it is assumed that the pCsr->aSpace
71850 ** has been allocated and contains an unpacked record that is used as key2.
71851 */
71852 static void vdbeSorterCompare(
71853   VdbeCursor *pCsr,               /* Cursor object (for pKeyInfo) */
71854   int bOmitRowid,                 /* Ignore rowid field at end of keys */
71855   void *pKey1, int nKey1,         /* Left side of comparison */
71856   void *pKey2, int nKey2,         /* Right side of comparison */
71857   int *pRes                       /* OUT: Result of comparison */
71858 ){
71859   KeyInfo *pKeyInfo = pCsr->pKeyInfo;
71860   VdbeSorter *pSorter = pCsr->pSorter;
71861   UnpackedRecord *r2 = pSorter->pUnpacked;
71862   int i;
71863
71864   if( pKey2 ){
71865     sqlcipher3VdbeRecordUnpack(pKeyInfo, nKey2, pKey2, r2);
71866   }
71867
71868   if( bOmitRowid ){
71869     r2->nField = pKeyInfo->nField;
71870     assert( r2->nField>0 );
71871     for(i=0; i<r2->nField; i++){
71872       if( r2->aMem[i].flags & MEM_Null ){
71873         *pRes = -1;
71874         return;
71875       }
71876     }
71877     r2->flags |= UNPACKED_PREFIX_MATCH;
71878   }
71879
71880   *pRes = sqlcipher3VdbeRecordCompare(nKey1, pKey1, r2);
71881 }
71882
71883 /*
71884 ** This function is called to compare two iterator keys when merging 
71885 ** multiple b-tree segments. Parameter iOut is the index of the aTree[] 
71886 ** value to recalculate.
71887 */
71888 static int vdbeSorterDoCompare(VdbeCursor *pCsr, int iOut){
71889   VdbeSorter *pSorter = pCsr->pSorter;
71890   int i1;
71891   int i2;
71892   int iRes;
71893   VdbeSorterIter *p1;
71894   VdbeSorterIter *p2;
71895
71896   assert( iOut<pSorter->nTree && iOut>0 );
71897
71898   if( iOut>=(pSorter->nTree/2) ){
71899     i1 = (iOut - pSorter->nTree/2) * 2;
71900     i2 = i1 + 1;
71901   }else{
71902     i1 = pSorter->aTree[iOut*2];
71903     i2 = pSorter->aTree[iOut*2+1];
71904   }
71905
71906   p1 = &pSorter->aIter[i1];
71907   p2 = &pSorter->aIter[i2];
71908
71909   if( p1->pFile==0 ){
71910     iRes = i2;
71911   }else if( p2->pFile==0 ){
71912     iRes = i1;
71913   }else{
71914     int res;
71915     assert( pCsr->pSorter->pUnpacked!=0 );  /* allocated in vdbeSorterMerge() */
71916     vdbeSorterCompare(
71917         pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res
71918     );
71919     if( res<=0 ){
71920       iRes = i1;
71921     }else{
71922       iRes = i2;
71923     }
71924   }
71925
71926   pSorter->aTree[iOut] = iRes;
71927   return SQLCIPHER_OK;
71928 }
71929
71930 /*
71931 ** Initialize the temporary index cursor just opened as a sorter cursor.
71932 */
71933 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterInit(sqlcipher3 *db, VdbeCursor *pCsr){
71934   int pgsz;                       /* Page size of main database */
71935   int mxCache;                    /* Cache size */
71936   VdbeSorter *pSorter;            /* The new sorter */
71937   char *d;                        /* Dummy */
71938
71939   assert( pCsr->pKeyInfo && pCsr->pBt==0 );
71940   pCsr->pSorter = pSorter = sqlcipher3DbMallocZero(db, sizeof(VdbeSorter));
71941   if( pSorter==0 ){
71942     return SQLCIPHER_NOMEM;
71943   }
71944   
71945   pSorter->pUnpacked = sqlcipher3VdbeAllocUnpackedRecord(pCsr->pKeyInfo, 0, 0, &d);
71946   if( pSorter->pUnpacked==0 ) return SQLCIPHER_NOMEM;
71947   assert( pSorter->pUnpacked==(UnpackedRecord *)d );
71948
71949   if( !sqlcipher3TempInMemory(db) ){
71950     pgsz = sqlcipher3BtreeGetPageSize(db->aDb[0].pBt);
71951     pSorter->mnPmaSize = SORTER_MIN_WORKING * pgsz;
71952     mxCache = db->aDb[0].pSchema->cache_size;
71953     if( mxCache<SORTER_MIN_WORKING ) mxCache = SORTER_MIN_WORKING;
71954     pSorter->mxPmaSize = mxCache * pgsz;
71955   }
71956
71957   return SQLCIPHER_OK;
71958 }
71959
71960 /*
71961 ** Free the list of sorted records starting at pRecord.
71962 */
71963 static void vdbeSorterRecordFree(sqlcipher3 *db, SorterRecord *pRecord){
71964   SorterRecord *p;
71965   SorterRecord *pNext;
71966   for(p=pRecord; p; p=pNext){
71967     pNext = p->pNext;
71968     sqlcipher3DbFree(db, p);
71969   }
71970 }
71971
71972 /*
71973 ** Free any cursor components allocated by sqlcipher3VdbeSorterXXX routines.
71974 */
71975 SQLCIPHER_PRIVATE void sqlcipher3VdbeSorterClose(sqlcipher3 *db, VdbeCursor *pCsr){
71976   VdbeSorter *pSorter = pCsr->pSorter;
71977   if( pSorter ){
71978     if( pSorter->aIter ){
71979       int i;
71980       for(i=0; i<pSorter->nTree; i++){
71981         vdbeSorterIterZero(db, &pSorter->aIter[i]);
71982       }
71983       sqlcipher3DbFree(db, pSorter->aIter);
71984     }
71985     if( pSorter->pTemp1 ){
71986       sqlcipher3OsCloseFree(pSorter->pTemp1);
71987     }
71988     vdbeSorterRecordFree(db, pSorter->pRecord);
71989     sqlcipher3DbFree(db, pSorter->pUnpacked);
71990     sqlcipher3DbFree(db, pSorter);
71991     pCsr->pSorter = 0;
71992   }
71993 }
71994
71995 /*
71996 ** Allocate space for a file-handle and open a temporary file. If successful,
71997 ** set *ppFile to point to the malloc'd file-handle and return SQLCIPHER_OK.
71998 ** Otherwise, set *ppFile to 0 and return an SQLite error code.
71999 */
72000 static int vdbeSorterOpenTempFile(sqlcipher3 *db, sqlcipher3_file **ppFile){
72001   int dummy;
72002   return sqlcipher3OsOpenMalloc(db->pVfs, 0, ppFile,
72003       SQLCIPHER_OPEN_TEMP_JOURNAL |
72004       SQLCIPHER_OPEN_READWRITE    | SQLCIPHER_OPEN_CREATE |
72005       SQLCIPHER_OPEN_EXCLUSIVE    | SQLCIPHER_OPEN_DELETEONCLOSE, &dummy
72006   );
72007 }
72008
72009 /*
72010 ** Merge the two sorted lists p1 and p2 into a single list.
72011 ** Set *ppOut to the head of the new list.
72012 */
72013 static void vdbeSorterMerge(
72014   VdbeCursor *pCsr,               /* For pKeyInfo */
72015   SorterRecord *p1,               /* First list to merge */
72016   SorterRecord *p2,               /* Second list to merge */
72017   SorterRecord **ppOut            /* OUT: Head of merged list */
72018 ){
72019   SorterRecord *pFinal = 0;
72020   SorterRecord **pp = &pFinal;
72021   void *pVal2 = p2 ? p2->pVal : 0;
72022
72023   while( p1 && p2 ){
72024     int res;
72025     vdbeSorterCompare(pCsr, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res);
72026     if( res<=0 ){
72027       *pp = p1;
72028       pp = &p1->pNext;
72029       p1 = p1->pNext;
72030       pVal2 = 0;
72031     }else{
72032       *pp = p2;
72033        pp = &p2->pNext;
72034       p2 = p2->pNext;
72035       if( p2==0 ) break;
72036       pVal2 = p2->pVal;
72037     }
72038   }
72039   *pp = p1 ? p1 : p2;
72040   *ppOut = pFinal;
72041 }
72042
72043 /*
72044 ** Sort the linked list of records headed at pCsr->pRecord. Return SQLCIPHER_OK
72045 ** if successful, or an SQLite error code (i.e. SQLCIPHER_NOMEM) if an error
72046 ** occurs.
72047 */
72048 static int vdbeSorterSort(VdbeCursor *pCsr){
72049   int i;
72050   SorterRecord **aSlot;
72051   SorterRecord *p;
72052   VdbeSorter *pSorter = pCsr->pSorter;
72053
72054   aSlot = (SorterRecord **)sqlcipher3MallocZero(64 * sizeof(SorterRecord *));
72055   if( !aSlot ){
72056     return SQLCIPHER_NOMEM;
72057   }
72058
72059   p = pSorter->pRecord;
72060   while( p ){
72061     SorterRecord *pNext = p->pNext;
72062     p->pNext = 0;
72063     for(i=0; aSlot[i]; i++){
72064       vdbeSorterMerge(pCsr, p, aSlot[i], &p);
72065       aSlot[i] = 0;
72066     }
72067     aSlot[i] = p;
72068     p = pNext;
72069   }
72070
72071   p = 0;
72072   for(i=0; i<64; i++){
72073     vdbeSorterMerge(pCsr, p, aSlot[i], &p);
72074   }
72075   pSorter->pRecord = p;
72076
72077   sqlcipher3_free(aSlot);
72078   return SQLCIPHER_OK;
72079 }
72080
72081
72082 /*
72083 ** Write the current contents of the in-memory linked-list to a PMA. Return
72084 ** SQLCIPHER_OK if successful, or an SQLite error code otherwise.
72085 **
72086 ** The format of a PMA is:
72087 **
72088 **     * A varint. This varint contains the total number of bytes of content
72089 **       in the PMA (not including the varint itself).
72090 **
72091 **     * One or more records packed end-to-end in order of ascending keys. 
72092 **       Each record consists of a varint followed by a blob of data (the 
72093 **       key). The varint is the number of bytes in the blob of data.
72094 */
72095 static int vdbeSorterListToPMA(sqlcipher3 *db, VdbeCursor *pCsr){
72096   int rc = SQLCIPHER_OK;             /* Return code */
72097   VdbeSorter *pSorter = pCsr->pSorter;
72098
72099   if( pSorter->nInMemory==0 ){
72100     assert( pSorter->pRecord==0 );
72101     return rc;
72102   }
72103
72104   rc = vdbeSorterSort(pCsr);
72105
72106   /* If the first temporary PMA file has not been opened, open it now. */
72107   if( rc==SQLCIPHER_OK && pSorter->pTemp1==0 ){
72108     rc = vdbeSorterOpenTempFile(db, &pSorter->pTemp1);
72109     assert( rc!=SQLCIPHER_OK || pSorter->pTemp1 );
72110     assert( pSorter->iWriteOff==0 );
72111     assert( pSorter->nPMA==0 );
72112   }
72113
72114   if( rc==SQLCIPHER_OK ){
72115     i64 iOff = pSorter->iWriteOff;
72116     SorterRecord *p;
72117     SorterRecord *pNext = 0;
72118     static const char eightZeros[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
72119
72120     pSorter->nPMA++;
72121     rc = vdbeSorterWriteVarint(pSorter->pTemp1, pSorter->nInMemory, &iOff);
72122     for(p=pSorter->pRecord; rc==SQLCIPHER_OK && p; p=pNext){
72123       pNext = p->pNext;
72124       rc = vdbeSorterWriteVarint(pSorter->pTemp1, p->nVal, &iOff);
72125
72126       if( rc==SQLCIPHER_OK ){
72127         rc = sqlcipher3OsWrite(pSorter->pTemp1, p->pVal, p->nVal, iOff);
72128         iOff += p->nVal;
72129       }
72130
72131       sqlcipher3DbFree(db, p);
72132     }
72133
72134     /* This assert verifies that unless an error has occurred, the size of 
72135     ** the PMA on disk is the same as the expected size stored in
72136     ** pSorter->nInMemory. */ 
72137     assert( rc!=SQLCIPHER_OK || pSorter->nInMemory==(
72138           iOff-pSorter->iWriteOff-sqlcipher3VarintLen(pSorter->nInMemory)
72139     ));
72140
72141     pSorter->iWriteOff = iOff;
72142     if( rc==SQLCIPHER_OK ){
72143       /* Terminate each file with 8 extra bytes so that from any offset
72144       ** in the file we can always read 9 bytes without a SHORT_READ error */
72145       rc = sqlcipher3OsWrite(pSorter->pTemp1, eightZeros, 8, iOff);
72146     }
72147     pSorter->pRecord = p;
72148   }
72149
72150   return rc;
72151 }
72152
72153 /*
72154 ** Add a record to the sorter.
72155 */
72156 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterWrite(
72157   sqlcipher3 *db,                    /* Database handle */
72158   VdbeCursor *pCsr,               /* Sorter cursor */
72159   Mem *pVal                       /* Memory cell containing record */
72160 ){
72161   VdbeSorter *pSorter = pCsr->pSorter;
72162   int rc = SQLCIPHER_OK;             /* Return Code */
72163   SorterRecord *pNew;             /* New list element */
72164
72165   assert( pSorter );
72166   pSorter->nInMemory += sqlcipher3VarintLen(pVal->n) + pVal->n;
72167
72168   pNew = (SorterRecord *)sqlcipher3DbMallocRaw(db, pVal->n + sizeof(SorterRecord));
72169   if( pNew==0 ){
72170     rc = SQLCIPHER_NOMEM;
72171   }else{
72172     pNew->pVal = (void *)&pNew[1];
72173     memcpy(pNew->pVal, pVal->z, pVal->n);
72174     pNew->nVal = pVal->n;
72175     pNew->pNext = pSorter->pRecord;
72176     pSorter->pRecord = pNew;
72177   }
72178
72179   /* See if the contents of the sorter should now be written out. They
72180   ** are written out when either of the following are true:
72181   **
72182   **   * The total memory allocated for the in-memory list is greater 
72183   **     than (page-size * cache-size), or
72184   **
72185   **   * The total memory allocated for the in-memory list is greater 
72186   **     than (page-size * 10) and sqlcipher3HeapNearlyFull() returns true.
72187   */
72188   if( rc==SQLCIPHER_OK && pSorter->mxPmaSize>0 && (
72189         (pSorter->nInMemory>pSorter->mxPmaSize)
72190      || (pSorter->nInMemory>pSorter->mnPmaSize && sqlcipher3HeapNearlyFull())
72191   )){
72192     rc = vdbeSorterListToPMA(db, pCsr);
72193     pSorter->nInMemory = 0;
72194   }
72195
72196   return rc;
72197 }
72198
72199 /*
72200 ** Helper function for sqlcipher3VdbeSorterRewind(). 
72201 */
72202 static int vdbeSorterInitMerge(
72203   sqlcipher3 *db,                    /* Database handle */
72204   VdbeCursor *pCsr,               /* Cursor handle for this sorter */
72205   i64 *pnByte                     /* Sum of bytes in all opened PMAs */
72206 ){
72207   VdbeSorter *pSorter = pCsr->pSorter;
72208   int rc = SQLCIPHER_OK;             /* Return code */
72209   int i;                          /* Used to iterator through aIter[] */
72210   i64 nByte = 0;                  /* Total bytes in all opened PMAs */
72211
72212   /* Initialize the iterators. */
72213   for(i=0; i<SORTER_MAX_MERGE_COUNT; i++){
72214     VdbeSorterIter *pIter = &pSorter->aIter[i];
72215     rc = vdbeSorterIterInit(db, pSorter, pSorter->iReadOff, pIter, &nByte);
72216     pSorter->iReadOff = pIter->iEof;
72217     assert( rc!=SQLCIPHER_OK || pSorter->iReadOff<=pSorter->iWriteOff );
72218     if( rc!=SQLCIPHER_OK || pSorter->iReadOff>=pSorter->iWriteOff ) break;
72219   }
72220
72221   /* Initialize the aTree[] array. */
72222   for(i=pSorter->nTree-1; rc==SQLCIPHER_OK && i>0; i--){
72223     rc = vdbeSorterDoCompare(pCsr, i);
72224   }
72225
72226   *pnByte = nByte;
72227   return rc;
72228 }
72229
72230 /*
72231 ** Once the sorter has been populated, this function is called to prepare
72232 ** for iterating through its contents in sorted order.
72233 */
72234 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterRewind(sqlcipher3 *db, VdbeCursor *pCsr, int *pbEof){
72235   VdbeSorter *pSorter = pCsr->pSorter;
72236   int rc;                         /* Return code */
72237   sqlcipher3_file *pTemp2 = 0;       /* Second temp file to use */
72238   i64 iWrite2 = 0;                /* Write offset for pTemp2 */
72239   int nIter;                      /* Number of iterators used */
72240   int nByte;                      /* Bytes of space required for aIter/aTree */
72241   int N = 2;                      /* Power of 2 >= nIter */
72242
72243   assert( pSorter );
72244
72245   /* If no data has been written to disk, then do not do so now. Instead,
72246   ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly
72247   ** from the in-memory list.  */
72248   if( pSorter->nPMA==0 ){
72249     *pbEof = !pSorter->pRecord;
72250     assert( pSorter->aTree==0 );
72251     return vdbeSorterSort(pCsr);
72252   }
72253
72254   /* Write the current b-tree to a PMA. Close the b-tree cursor. */
72255   rc = vdbeSorterListToPMA(db, pCsr);
72256   if( rc!=SQLCIPHER_OK ) return rc;
72257
72258   /* Allocate space for aIter[] and aTree[]. */
72259   nIter = pSorter->nPMA;
72260   if( nIter>SORTER_MAX_MERGE_COUNT ) nIter = SORTER_MAX_MERGE_COUNT;
72261   assert( nIter>0 );
72262   while( N<nIter ) N += N;
72263   nByte = N * (sizeof(int) + sizeof(VdbeSorterIter));
72264   pSorter->aIter = (VdbeSorterIter *)sqlcipher3DbMallocZero(db, nByte);
72265   if( !pSorter->aIter ) return SQLCIPHER_NOMEM;
72266   pSorter->aTree = (int *)&pSorter->aIter[N];
72267   pSorter->nTree = N;
72268
72269   do {
72270     int iNew;                     /* Index of new, merged, PMA */
72271
72272     for(iNew=0; 
72273         rc==SQLCIPHER_OK && iNew*SORTER_MAX_MERGE_COUNT<pSorter->nPMA; 
72274         iNew++
72275     ){
72276       i64 nWrite;                 /* Number of bytes in new PMA */
72277
72278       /* If there are SORTER_MAX_MERGE_COUNT or less PMAs in file pTemp1,
72279       ** initialize an iterator for each of them and break out of the loop.
72280       ** These iterators will be incrementally merged as the VDBE layer calls
72281       ** sqlcipher3VdbeSorterNext().
72282       **
72283       ** Otherwise, if pTemp1 contains more than SORTER_MAX_MERGE_COUNT PMAs,
72284       ** initialize interators for SORTER_MAX_MERGE_COUNT of them. These PMAs
72285       ** are merged into a single PMA that is written to file pTemp2.
72286       */
72287       rc = vdbeSorterInitMerge(db, pCsr, &nWrite);
72288       assert( rc!=SQLCIPHER_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
72289       if( rc!=SQLCIPHER_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
72290         break;
72291       }
72292
72293       /* Open the second temp file, if it is not already open. */
72294       if( pTemp2==0 ){
72295         assert( iWrite2==0 );
72296         rc = vdbeSorterOpenTempFile(db, &pTemp2);
72297       }
72298
72299       if( rc==SQLCIPHER_OK ){
72300         rc = vdbeSorterWriteVarint(pTemp2, nWrite, &iWrite2);
72301       }
72302
72303       if( rc==SQLCIPHER_OK ){
72304         int bEof = 0;
72305         while( rc==SQLCIPHER_OK && bEof==0 ){
72306           int nToWrite;
72307           VdbeSorterIter *pIter = &pSorter->aIter[ pSorter->aTree[1] ];
72308           assert( pIter->pFile );
72309           nToWrite = pIter->nKey + sqlcipher3VarintLen(pIter->nKey);
72310           rc = sqlcipher3OsWrite(pTemp2, pIter->aAlloc, nToWrite, iWrite2);
72311           iWrite2 += nToWrite;
72312           if( rc==SQLCIPHER_OK ){
72313             rc = sqlcipher3VdbeSorterNext(db, pCsr, &bEof);
72314           }
72315         }
72316       }
72317     }
72318
72319     if( pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
72320       break;
72321     }else{
72322       sqlcipher3_file *pTmp = pSorter->pTemp1;
72323       pSorter->nPMA = iNew;
72324       pSorter->pTemp1 = pTemp2;
72325       pTemp2 = pTmp;
72326       pSorter->iWriteOff = iWrite2;
72327       pSorter->iReadOff = 0;
72328       iWrite2 = 0;
72329     }
72330   }while( rc==SQLCIPHER_OK );
72331
72332   if( pTemp2 ){
72333     sqlcipher3OsCloseFree(pTemp2);
72334   }
72335   *pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
72336   return rc;
72337 }
72338
72339 /*
72340 ** Advance to the next element in the sorter.
72341 */
72342 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterNext(sqlcipher3 *db, VdbeCursor *pCsr, int *pbEof){
72343   VdbeSorter *pSorter = pCsr->pSorter;
72344   int rc;                         /* Return code */
72345
72346   if( pSorter->aTree ){
72347     int iPrev = pSorter->aTree[1];/* Index of iterator to advance */
72348     int i;                        /* Index of aTree[] to recalculate */
72349
72350     rc = vdbeSorterIterNext(db, &pSorter->aIter[iPrev]);
72351     for(i=(pSorter->nTree+iPrev)/2; rc==SQLCIPHER_OK && i>0; i=i/2){
72352       rc = vdbeSorterDoCompare(pCsr, i);
72353     }
72354
72355     *pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
72356   }else{
72357     SorterRecord *pFree = pSorter->pRecord;
72358     pSorter->pRecord = pFree->pNext;
72359     pFree->pNext = 0;
72360     vdbeSorterRecordFree(db, pFree);
72361     *pbEof = !pSorter->pRecord;
72362     rc = SQLCIPHER_OK;
72363   }
72364   return rc;
72365 }
72366
72367 /*
72368 ** Return a pointer to a buffer owned by the sorter that contains the 
72369 ** current key.
72370 */
72371 static void *vdbeSorterRowkey(
72372   VdbeSorter *pSorter,            /* Sorter object */
72373   int *pnKey                      /* OUT: Size of current key in bytes */
72374 ){
72375   void *pKey;
72376   if( pSorter->aTree ){
72377     VdbeSorterIter *pIter;
72378     pIter = &pSorter->aIter[ pSorter->aTree[1] ];
72379     *pnKey = pIter->nKey;
72380     pKey = pIter->aKey;
72381   }else{
72382     *pnKey = pSorter->pRecord->nVal;
72383     pKey = pSorter->pRecord->pVal;
72384   }
72385   return pKey;
72386 }
72387
72388 /*
72389 ** Copy the current sorter key into the memory cell pOut.
72390 */
72391 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterRowkey(VdbeCursor *pCsr, Mem *pOut){
72392   VdbeSorter *pSorter = pCsr->pSorter;
72393   void *pKey; int nKey;           /* Sorter key to copy into pOut */
72394
72395   pKey = vdbeSorterRowkey(pSorter, &nKey);
72396   if( sqlcipher3VdbeMemGrow(pOut, nKey, 0) ){
72397     return SQLCIPHER_NOMEM;
72398   }
72399   pOut->n = nKey;
72400   MemSetTypeFlag(pOut, MEM_Blob);
72401   memcpy(pOut->z, pKey, nKey);
72402
72403   return SQLCIPHER_OK;
72404 }
72405
72406 /*
72407 ** Compare the key in memory cell pVal with the key that the sorter cursor
72408 ** passed as the first argument currently points to. For the purposes of
72409 ** the comparison, ignore the rowid field at the end of each record.
72410 **
72411 ** If an error occurs, return an SQLite error code (i.e. SQLCIPHER_NOMEM).
72412 ** Otherwise, set *pRes to a negative, zero or positive value if the
72413 ** key in pVal is smaller than, equal to or larger than the current sorter
72414 ** key.
72415 */
72416 SQLCIPHER_PRIVATE int sqlcipher3VdbeSorterCompare(
72417   VdbeCursor *pCsr,               /* Sorter cursor */
72418   Mem *pVal,                      /* Value to compare to current sorter key */
72419   int *pRes                       /* OUT: Result of comparison */
72420 ){
72421   VdbeSorter *pSorter = pCsr->pSorter;
72422   void *pKey; int nKey;           /* Sorter key to compare pVal with */
72423
72424   pKey = vdbeSorterRowkey(pSorter, &nKey);
72425   vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
72426   return SQLCIPHER_OK;
72427 }
72428
72429 #endif /* #ifndef SQLCIPHER_OMIT_MERGE_SORT */
72430
72431 /************** End of vdbesort.c ********************************************/
72432 /************** Begin file journal.c *****************************************/
72433 /*
72434 ** 2007 August 22
72435 **
72436 ** The author disclaims copyright to this source code.  In place of
72437 ** a legal notice, here is a blessing:
72438 **
72439 **    May you do good and not evil.
72440 **    May you find forgiveness for yourself and forgive others.
72441 **    May you share freely, never taking more than you give.
72442 **
72443 *************************************************************************
72444 **
72445 ** This file implements a special kind of sqlcipher3_file object used
72446 ** by SQLite to create journal files if the atomic-write optimization
72447 ** is enabled.
72448 **
72449 ** The distinctive characteristic of this sqlcipher3_file is that the
72450 ** actual on disk file is created lazily. When the file is created,
72451 ** the caller specifies a buffer size for an in-memory buffer to
72452 ** be used to service read() and write() requests. The actual file
72453 ** on disk is not created or populated until either:
72454 **
72455 **   1) The in-memory representation grows too large for the allocated 
72456 **      buffer, or
72457 **   2) The sqlcipher3JournalCreate() function is called.
72458 */
72459 #ifdef SQLCIPHER_ENABLE_ATOMIC_WRITE
72460
72461
72462 /*
72463 ** A JournalFile object is a subclass of sqlcipher3_file used by
72464 ** as an open file handle for journal files.
72465 */
72466 struct JournalFile {
72467   sqlcipher3_io_methods *pMethod;    /* I/O methods on journal files */
72468   int nBuf;                       /* Size of zBuf[] in bytes */
72469   char *zBuf;                     /* Space to buffer journal writes */
72470   int iSize;                      /* Amount of zBuf[] currently used */
72471   int flags;                      /* xOpen flags */
72472   sqlcipher3_vfs *pVfs;              /* The "real" underlying VFS */
72473   sqlcipher3_file *pReal;            /* The "real" underlying file descriptor */
72474   const char *zJournal;           /* Name of the journal file */
72475 };
72476 typedef struct JournalFile JournalFile;
72477
72478 /*
72479 ** If it does not already exists, create and populate the on-disk file 
72480 ** for JournalFile p.
72481 */
72482 static int createFile(JournalFile *p){
72483   int rc = SQLCIPHER_OK;
72484   if( !p->pReal ){
72485     sqlcipher3_file *pReal = (sqlcipher3_file *)&p[1];
72486     rc = sqlcipher3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);
72487     if( rc==SQLCIPHER_OK ){
72488       p->pReal = pReal;
72489       if( p->iSize>0 ){
72490         assert(p->iSize<=p->nBuf);
72491         rc = sqlcipher3OsWrite(p->pReal, p->zBuf, p->iSize, 0);
72492       }
72493     }
72494   }
72495   return rc;
72496 }
72497
72498 /*
72499 ** Close the file.
72500 */
72501 static int jrnlClose(sqlcipher3_file *pJfd){
72502   JournalFile *p = (JournalFile *)pJfd;
72503   if( p->pReal ){
72504     sqlcipher3OsClose(p->pReal);
72505   }
72506   sqlcipher3_free(p->zBuf);
72507   return SQLCIPHER_OK;
72508 }
72509
72510 /*
72511 ** Read data from the file.
72512 */
72513 static int jrnlRead(
72514   sqlcipher3_file *pJfd,    /* The journal file from which to read */
72515   void *zBuf,            /* Put the results here */
72516   int iAmt,              /* Number of bytes to read */
72517   sqlcipher_int64 iOfst     /* Begin reading at this offset */
72518 ){
72519   int rc = SQLCIPHER_OK;
72520   JournalFile *p = (JournalFile *)pJfd;
72521   if( p->pReal ){
72522     rc = sqlcipher3OsRead(p->pReal, zBuf, iAmt, iOfst);
72523   }else if( (iAmt+iOfst)>p->iSize ){
72524     rc = SQLCIPHER_IOERR_SHORT_READ;
72525   }else{
72526     memcpy(zBuf, &p->zBuf[iOfst], iAmt);
72527   }
72528   return rc;
72529 }
72530
72531 /*
72532 ** Write data to the file.
72533 */
72534 static int jrnlWrite(
72535   sqlcipher3_file *pJfd,    /* The journal file into which to write */
72536   const void *zBuf,      /* Take data to be written from here */
72537   int iAmt,              /* Number of bytes to write */
72538   sqlcipher_int64 iOfst     /* Begin writing at this offset into the file */
72539 ){
72540   int rc = SQLCIPHER_OK;
72541   JournalFile *p = (JournalFile *)pJfd;
72542   if( !p->pReal && (iOfst+iAmt)>p->nBuf ){
72543     rc = createFile(p);
72544   }
72545   if( rc==SQLCIPHER_OK ){
72546     if( p->pReal ){
72547       rc = sqlcipher3OsWrite(p->pReal, zBuf, iAmt, iOfst);
72548     }else{
72549       memcpy(&p->zBuf[iOfst], zBuf, iAmt);
72550       if( p->iSize<(iOfst+iAmt) ){
72551         p->iSize = (iOfst+iAmt);
72552       }
72553     }
72554   }
72555   return rc;
72556 }
72557
72558 /*
72559 ** Truncate the file.
72560 */
72561 static int jrnlTruncate(sqlcipher3_file *pJfd, sqlcipher_int64 size){
72562   int rc = SQLCIPHER_OK;
72563   JournalFile *p = (JournalFile *)pJfd;
72564   if( p->pReal ){
72565     rc = sqlcipher3OsTruncate(p->pReal, size);
72566   }else if( size<p->iSize ){
72567     p->iSize = size;
72568   }
72569   return rc;
72570 }
72571
72572 /*
72573 ** Sync the file.
72574 */
72575 static int jrnlSync(sqlcipher3_file *pJfd, int flags){
72576   int rc;
72577   JournalFile *p = (JournalFile *)pJfd;
72578   if( p->pReal ){
72579     rc = sqlcipher3OsSync(p->pReal, flags);
72580   }else{
72581     rc = SQLCIPHER_OK;
72582   }
72583   return rc;
72584 }
72585
72586 /*
72587 ** Query the size of the file in bytes.
72588 */
72589 static int jrnlFileSize(sqlcipher3_file *pJfd, sqlcipher_int64 *pSize){
72590   int rc = SQLCIPHER_OK;
72591   JournalFile *p = (JournalFile *)pJfd;
72592   if( p->pReal ){
72593     rc = sqlcipher3OsFileSize(p->pReal, pSize);
72594   }else{
72595     *pSize = (sqlcipher_int64) p->iSize;
72596   }
72597   return rc;
72598 }
72599
72600 /*
72601 ** Table of methods for JournalFile sqlcipher3_file object.
72602 */
72603 static struct sqlcipher3_io_methods JournalFileMethods = {
72604   1,             /* iVersion */
72605   jrnlClose,     /* xClose */
72606   jrnlRead,      /* xRead */
72607   jrnlWrite,     /* xWrite */
72608   jrnlTruncate,  /* xTruncate */
72609   jrnlSync,      /* xSync */
72610   jrnlFileSize,  /* xFileSize */
72611   0,             /* xLock */
72612   0,             /* xUnlock */
72613   0,             /* xCheckReservedLock */
72614   0,             /* xFileControl */
72615   0,             /* xSectorSize */
72616   0,             /* xDeviceCharacteristics */
72617   0,             /* xShmMap */
72618   0,             /* xShmLock */
72619   0,             /* xShmBarrier */
72620   0              /* xShmUnmap */
72621 };
72622
72623 /* 
72624 ** Open a journal file.
72625 */
72626 SQLCIPHER_PRIVATE int sqlcipher3JournalOpen(
72627   sqlcipher3_vfs *pVfs,         /* The VFS to use for actual file I/O */
72628   const char *zName,         /* Name of the journal file */
72629   sqlcipher3_file *pJfd,        /* Preallocated, blank file handle */
72630   int flags,                 /* Opening flags */
72631   int nBuf                   /* Bytes buffered before opening the file */
72632 ){
72633   JournalFile *p = (JournalFile *)pJfd;
72634   memset(p, 0, sqlcipher3JournalSize(pVfs));
72635   if( nBuf>0 ){
72636     p->zBuf = sqlcipher3MallocZero(nBuf);
72637     if( !p->zBuf ){
72638       return SQLCIPHER_NOMEM;
72639     }
72640   }else{
72641     return sqlcipher3OsOpen(pVfs, zName, pJfd, flags, 0);
72642   }
72643   p->pMethod = &JournalFileMethods;
72644   p->nBuf = nBuf;
72645   p->flags = flags;
72646   p->zJournal = zName;
72647   p->pVfs = pVfs;
72648   return SQLCIPHER_OK;
72649 }
72650
72651 /*
72652 ** If the argument p points to a JournalFile structure, and the underlying
72653 ** file has not yet been created, create it now.
72654 */
72655 SQLCIPHER_PRIVATE int sqlcipher3JournalCreate(sqlcipher3_file *p){
72656   if( p->pMethods!=&JournalFileMethods ){
72657     return SQLCIPHER_OK;
72658   }
72659   return createFile((JournalFile *)p);
72660 }
72661
72662 /* 
72663 ** Return the number of bytes required to store a JournalFile that uses vfs
72664 ** pVfs to create the underlying on-disk files.
72665 */
72666 SQLCIPHER_PRIVATE int sqlcipher3JournalSize(sqlcipher3_vfs *pVfs){
72667   return (pVfs->szOsFile+sizeof(JournalFile));
72668 }
72669 #endif
72670
72671 /************** End of journal.c *********************************************/
72672 /************** Begin file memjournal.c **************************************/
72673 /*
72674 ** 2008 October 7
72675 **
72676 ** The author disclaims copyright to this source code.  In place of
72677 ** a legal notice, here is a blessing:
72678 **
72679 **    May you do good and not evil.
72680 **    May you find forgiveness for yourself and forgive others.
72681 **    May you share freely, never taking more than you give.
72682 **
72683 *************************************************************************
72684 **
72685 ** This file contains code use to implement an in-memory rollback journal.
72686 ** The in-memory rollback journal is used to journal transactions for
72687 ** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
72688 */
72689
72690 /* Forward references to internal structures */
72691 typedef struct MemJournal MemJournal;
72692 typedef struct FilePoint FilePoint;
72693 typedef struct FileChunk FileChunk;
72694
72695 /* Space to hold the rollback journal is allocated in increments of
72696 ** this many bytes.
72697 **
72698 ** The size chosen is a little less than a power of two.  That way,
72699 ** the FileChunk object will have a size that almost exactly fills
72700 ** a power-of-two allocation.  This mimimizes wasted space in power-of-two
72701 ** memory allocators.
72702 */
72703 #define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
72704
72705 /* Macro to find the minimum of two numeric values.
72706 */
72707 #ifndef MIN
72708 # define MIN(x,y) ((x)<(y)?(x):(y))
72709 #endif
72710
72711 /*
72712 ** The rollback journal is composed of a linked list of these structures.
72713 */
72714 struct FileChunk {
72715   FileChunk *pNext;               /* Next chunk in the journal */
72716   u8 zChunk[JOURNAL_CHUNKSIZE];   /* Content of this chunk */
72717 };
72718
72719 /*
72720 ** An instance of this object serves as a cursor into the rollback journal.
72721 ** The cursor can be either for reading or writing.
72722 */
72723 struct FilePoint {
72724   sqlcipher3_int64 iOffset;          /* Offset from the beginning of the file */
72725   FileChunk *pChunk;              /* Specific chunk into which cursor points */
72726 };
72727
72728 /*
72729 ** This subclass is a subclass of sqlcipher3_file.  Each open memory-journal
72730 ** is an instance of this class.
72731 */
72732 struct MemJournal {
72733   sqlcipher3_io_methods *pMethod;    /* Parent class. MUST BE FIRST */
72734   FileChunk *pFirst;              /* Head of in-memory chunk-list */
72735   FilePoint endpoint;             /* Pointer to the end of the file */
72736   FilePoint readpoint;            /* Pointer to the end of the last xRead() */
72737 };
72738
72739 /*
72740 ** Read data from the in-memory journal file.  This is the implementation
72741 ** of the sqlcipher3_vfs.xRead method.
72742 */
72743 static int memjrnlRead(
72744   sqlcipher3_file *pJfd,    /* The journal file from which to read */
72745   void *zBuf,            /* Put the results here */
72746   int iAmt,              /* Number of bytes to read */
72747   sqlcipher_int64 iOfst     /* Begin reading at this offset */
72748 ){
72749   MemJournal *p = (MemJournal *)pJfd;
72750   u8 *zOut = zBuf;
72751   int nRead = iAmt;
72752   int iChunkOffset;
72753   FileChunk *pChunk;
72754
72755   /* SQLite never tries to read past the end of a rollback journal file */
72756   assert( iOfst+iAmt<=p->endpoint.iOffset );
72757
72758   if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
72759     sqlcipher3_int64 iOff = 0;
72760     for(pChunk=p->pFirst; 
72761         ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
72762         pChunk=pChunk->pNext
72763     ){
72764       iOff += JOURNAL_CHUNKSIZE;
72765     }
72766   }else{
72767     pChunk = p->readpoint.pChunk;
72768   }
72769
72770   iChunkOffset = (int)(iOfst%JOURNAL_CHUNKSIZE);
72771   do {
72772     int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset;
72773     int nCopy = MIN(nRead, (JOURNAL_CHUNKSIZE - iChunkOffset));
72774     memcpy(zOut, &pChunk->zChunk[iChunkOffset], nCopy);
72775     zOut += nCopy;
72776     nRead -= iSpace;
72777     iChunkOffset = 0;
72778   } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
72779   p->readpoint.iOffset = iOfst+iAmt;
72780   p->readpoint.pChunk = pChunk;
72781
72782   return SQLCIPHER_OK;
72783 }
72784
72785 /*
72786 ** Write data to the file.
72787 */
72788 static int memjrnlWrite(
72789   sqlcipher3_file *pJfd,    /* The journal file into which to write */
72790   const void *zBuf,      /* Take data to be written from here */
72791   int iAmt,              /* Number of bytes to write */
72792   sqlcipher_int64 iOfst     /* Begin writing at this offset into the file */
72793 ){
72794   MemJournal *p = (MemJournal *)pJfd;
72795   int nWrite = iAmt;
72796   u8 *zWrite = (u8 *)zBuf;
72797
72798   /* An in-memory journal file should only ever be appended to. Random
72799   ** access writes are not required by sqlcipher.
72800   */
72801   assert( iOfst==p->endpoint.iOffset );
72802   UNUSED_PARAMETER(iOfst);
72803
72804   while( nWrite>0 ){
72805     FileChunk *pChunk = p->endpoint.pChunk;
72806     int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
72807     int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset);
72808
72809     if( iChunkOffset==0 ){
72810       /* New chunk is required to extend the file. */
72811       FileChunk *pNew = sqlcipher3_malloc(sizeof(FileChunk));
72812       if( !pNew ){
72813         return SQLCIPHER_IOERR_NOMEM;
72814       }
72815       pNew->pNext = 0;
72816       if( pChunk ){
72817         assert( p->pFirst );
72818         pChunk->pNext = pNew;
72819       }else{
72820         assert( !p->pFirst );
72821         p->pFirst = pNew;
72822       }
72823       p->endpoint.pChunk = pNew;
72824     }
72825
72826     memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
72827     zWrite += iSpace;
72828     nWrite -= iSpace;
72829     p->endpoint.iOffset += iSpace;
72830   }
72831
72832   return SQLCIPHER_OK;
72833 }
72834
72835 /*
72836 ** Truncate the file.
72837 */
72838 static int memjrnlTruncate(sqlcipher3_file *pJfd, sqlcipher_int64 size){
72839   MemJournal *p = (MemJournal *)pJfd;
72840   FileChunk *pChunk;
72841   assert(size==0);
72842   UNUSED_PARAMETER(size);
72843   pChunk = p->pFirst;
72844   while( pChunk ){
72845     FileChunk *pTmp = pChunk;
72846     pChunk = pChunk->pNext;
72847     sqlcipher3_free(pTmp);
72848   }
72849   sqlcipher3MemJournalOpen(pJfd);
72850   return SQLCIPHER_OK;
72851 }
72852
72853 /*
72854 ** Close the file.
72855 */
72856 static int memjrnlClose(sqlcipher3_file *pJfd){
72857   memjrnlTruncate(pJfd, 0);
72858   return SQLCIPHER_OK;
72859 }
72860
72861
72862 /*
72863 ** Sync the file.
72864 **
72865 ** Syncing an in-memory journal is a no-op.  And, in fact, this routine
72866 ** is never called in a working implementation.  This implementation
72867 ** exists purely as a contingency, in case some malfunction in some other
72868 ** part of SQLite causes Sync to be called by mistake.
72869 */
72870 static int memjrnlSync(sqlcipher3_file *NotUsed, int NotUsed2){
72871   UNUSED_PARAMETER2(NotUsed, NotUsed2);
72872   return SQLCIPHER_OK;
72873 }
72874
72875 /*
72876 ** Query the size of the file in bytes.
72877 */
72878 static int memjrnlFileSize(sqlcipher3_file *pJfd, sqlcipher_int64 *pSize){
72879   MemJournal *p = (MemJournal *)pJfd;
72880   *pSize = (sqlcipher_int64) p->endpoint.iOffset;
72881   return SQLCIPHER_OK;
72882 }
72883
72884 /*
72885 ** Table of methods for MemJournal sqlcipher3_file object.
72886 */
72887 static const struct sqlcipher3_io_methods MemJournalMethods = {
72888   1,                /* iVersion */
72889   memjrnlClose,     /* xClose */
72890   memjrnlRead,      /* xRead */
72891   memjrnlWrite,     /* xWrite */
72892   memjrnlTruncate,  /* xTruncate */
72893   memjrnlSync,      /* xSync */
72894   memjrnlFileSize,  /* xFileSize */
72895   0,                /* xLock */
72896   0,                /* xUnlock */
72897   0,                /* xCheckReservedLock */
72898   0,                /* xFileControl */
72899   0,                /* xSectorSize */
72900   0,                /* xDeviceCharacteristics */
72901   0,                /* xShmMap */
72902   0,                /* xShmLock */
72903   0,                /* xShmBarrier */
72904   0                 /* xShmUnlock */
72905 };
72906
72907 /* 
72908 ** Open a journal file.
72909 */
72910 SQLCIPHER_PRIVATE void sqlcipher3MemJournalOpen(sqlcipher3_file *pJfd){
72911   MemJournal *p = (MemJournal *)pJfd;
72912   assert( EIGHT_BYTE_ALIGNMENT(p) );
72913   memset(p, 0, sqlcipher3MemJournalSize());
72914   p->pMethod = (sqlcipher3_io_methods*)&MemJournalMethods;
72915 }
72916
72917 /*
72918 ** Return true if the file-handle passed as an argument is 
72919 ** an in-memory journal 
72920 */
72921 SQLCIPHER_PRIVATE int sqlcipher3IsMemJournal(sqlcipher3_file *pJfd){
72922   return pJfd->pMethods==&MemJournalMethods;
72923 }
72924
72925 /* 
72926 ** Return the number of bytes required to store a MemJournal file descriptor.
72927 */
72928 SQLCIPHER_PRIVATE int sqlcipher3MemJournalSize(void){
72929   return sizeof(MemJournal);
72930 }
72931
72932 /************** End of memjournal.c ******************************************/
72933 /************** Begin file walker.c ******************************************/
72934 /*
72935 ** 2008 August 16
72936 **
72937 ** The author disclaims copyright to this source code.  In place of
72938 ** a legal notice, here is a blessing:
72939 **
72940 **    May you do good and not evil.
72941 **    May you find forgiveness for yourself and forgive others.
72942 **    May you share freely, never taking more than you give.
72943 **
72944 *************************************************************************
72945 ** This file contains routines used for walking the parser tree for
72946 ** an SQL statement.
72947 */
72948 /* #include <stdlib.h> */
72949 /* #include <string.h> */
72950
72951
72952 /*
72953 ** Walk an expression tree.  Invoke the callback once for each node
72954 ** of the expression, while decending.  (In other words, the callback
72955 ** is invoked before visiting children.)
72956 **
72957 ** The return value from the callback should be one of the WRC_*
72958 ** constants to specify how to proceed with the walk.
72959 **
72960 **    WRC_Continue      Continue descending down the tree.
72961 **
72962 **    WRC_Prune         Do not descend into child nodes.  But allow
72963 **                      the walk to continue with sibling nodes.
72964 **
72965 **    WRC_Abort         Do no more callbacks.  Unwind the stack and
72966 **                      return the top-level walk call.
72967 **
72968 ** The return value from this routine is WRC_Abort to abandon the tree walk
72969 ** and WRC_Continue to continue.
72970 */
72971 SQLCIPHER_PRIVATE int sqlcipher3WalkExpr(Walker *pWalker, Expr *pExpr){
72972   int rc;
72973   if( pExpr==0 ) return WRC_Continue;
72974   testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
72975   testcase( ExprHasProperty(pExpr, EP_Reduced) );
72976   rc = pWalker->xExprCallback(pWalker, pExpr);
72977   if( rc==WRC_Continue
72978               && !ExprHasAnyProperty(pExpr,EP_TokenOnly) ){
72979     if( sqlcipher3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
72980     if( sqlcipher3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort;
72981     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
72982       if( sqlcipher3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
72983     }else{
72984       if( sqlcipher3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
72985     }
72986   }
72987   return rc & WRC_Abort;
72988 }
72989
72990 /*
72991 ** Call sqlcipher3WalkExpr() for every expression in list p or until
72992 ** an abort request is seen.
72993 */
72994 SQLCIPHER_PRIVATE int sqlcipher3WalkExprList(Walker *pWalker, ExprList *p){
72995   int i;
72996   struct ExprList_item *pItem;
72997   if( p ){
72998     for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
72999       if( sqlcipher3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
73000     }
73001   }
73002   return WRC_Continue;
73003 }
73004
73005 /*
73006 ** Walk all expressions associated with SELECT statement p.  Do
73007 ** not invoke the SELECT callback on p, but do (of course) invoke
73008 ** any expr callbacks and SELECT callbacks that come from subqueries.
73009 ** Return WRC_Abort or WRC_Continue.
73010 */
73011 SQLCIPHER_PRIVATE int sqlcipher3WalkSelectExpr(Walker *pWalker, Select *p){
73012   if( sqlcipher3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
73013   if( sqlcipher3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
73014   if( sqlcipher3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
73015   if( sqlcipher3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
73016   if( sqlcipher3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
73017   if( sqlcipher3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
73018   if( sqlcipher3WalkExpr(pWalker, p->pOffset) ) return WRC_Abort;
73019   return WRC_Continue;
73020 }
73021
73022 /*
73023 ** Walk the parse trees associated with all subqueries in the
73024 ** FROM clause of SELECT statement p.  Do not invoke the select
73025 ** callback on p, but do invoke it on each FROM clause subquery
73026 ** and on any subqueries further down in the tree.  Return 
73027 ** WRC_Abort or WRC_Continue;
73028 */
73029 SQLCIPHER_PRIVATE int sqlcipher3WalkSelectFrom(Walker *pWalker, Select *p){
73030   SrcList *pSrc;
73031   int i;
73032   struct SrcList_item *pItem;
73033
73034   pSrc = p->pSrc;
73035   if( ALWAYS(pSrc) ){
73036     for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
73037       if( sqlcipher3WalkSelect(pWalker, pItem->pSelect) ){
73038         return WRC_Abort;
73039       }
73040     }
73041   }
73042   return WRC_Continue;
73043
73044
73045 /*
73046 ** Call sqlcipher3WalkExpr() for every expression in Select statement p.
73047 ** Invoke sqlcipher3WalkSelect() for subqueries in the FROM clause and
73048 ** on the compound select chain, p->pPrior.
73049 **
73050 ** Return WRC_Continue under normal conditions.  Return WRC_Abort if
73051 ** there is an abort request.
73052 **
73053 ** If the Walker does not have an xSelectCallback() then this routine
73054 ** is a no-op returning WRC_Continue.
73055 */
73056 SQLCIPHER_PRIVATE int sqlcipher3WalkSelect(Walker *pWalker, Select *p){
73057   int rc;
73058   if( p==0 || pWalker->xSelectCallback==0 ) return WRC_Continue;
73059   rc = WRC_Continue;
73060   while( p  ){
73061     rc = pWalker->xSelectCallback(pWalker, p);
73062     if( rc ) break;
73063     if( sqlcipher3WalkSelectExpr(pWalker, p) ) return WRC_Abort;
73064     if( sqlcipher3WalkSelectFrom(pWalker, p) ) return WRC_Abort;
73065     p = p->pPrior;
73066   }
73067   return rc & WRC_Abort;
73068 }
73069
73070 /************** End of walker.c **********************************************/
73071 /************** Begin file resolve.c *****************************************/
73072 /*
73073 ** 2008 August 18
73074 **
73075 ** The author disclaims copyright to this source code.  In place of
73076 ** a legal notice, here is a blessing:
73077 **
73078 **    May you do good and not evil.
73079 **    May you find forgiveness for yourself and forgive others.
73080 **    May you share freely, never taking more than you give.
73081 **
73082 *************************************************************************
73083 **
73084 ** This file contains routines used for walking the parser tree and
73085 ** resolve all identifiers by associating them with a particular
73086 ** table and column.
73087 */
73088 /* #include <stdlib.h> */
73089 /* #include <string.h> */
73090
73091 /*
73092 ** Turn the pExpr expression into an alias for the iCol-th column of the
73093 ** result set in pEList.
73094 **
73095 ** If the result set column is a simple column reference, then this routine
73096 ** makes an exact copy.  But for any other kind of expression, this
73097 ** routine make a copy of the result set column as the argument to the
73098 ** TK_AS operator.  The TK_AS operator causes the expression to be
73099 ** evaluated just once and then reused for each alias.
73100 **
73101 ** The reason for suppressing the TK_AS term when the expression is a simple
73102 ** column reference is so that the column reference will be recognized as
73103 ** usable by indices within the WHERE clause processing logic. 
73104 **
73105 ** Hack:  The TK_AS operator is inhibited if zType[0]=='G'.  This means
73106 ** that in a GROUP BY clause, the expression is evaluated twice.  Hence:
73107 **
73108 **     SELECT random()%5 AS x, count(*) FROM tab GROUP BY x
73109 **
73110 ** Is equivalent to:
73111 **
73112 **     SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5
73113 **
73114 ** The result of random()%5 in the GROUP BY clause is probably different
73115 ** from the result in the result-set.  We might fix this someday.  Or
73116 ** then again, we might not...
73117 */
73118 static void resolveAlias(
73119   Parse *pParse,         /* Parsing context */
73120   ExprList *pEList,      /* A result set */
73121   int iCol,              /* A column in the result set.  0..pEList->nExpr-1 */
73122   Expr *pExpr,           /* Transform this into an alias to the result set */
73123   const char *zType      /* "GROUP" or "ORDER" or "" */
73124 ){
73125   Expr *pOrig;           /* The iCol-th column of the result set */
73126   Expr *pDup;            /* Copy of pOrig */
73127   sqlcipher3 *db;           /* The database connection */
73128
73129   assert( iCol>=0 && iCol<pEList->nExpr );
73130   pOrig = pEList->a[iCol].pExpr;
73131   assert( pOrig!=0 );
73132   assert( pOrig->flags & EP_Resolved );
73133   db = pParse->db;
73134   if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){
73135     pDup = sqlcipher3ExprDup(db, pOrig, 0);
73136     pDup = sqlcipher3PExpr(pParse, TK_AS, pDup, 0, 0);
73137     if( pDup==0 ) return;
73138     if( pEList->a[iCol].iAlias==0 ){
73139       pEList->a[iCol].iAlias = (u16)(++pParse->nAlias);
73140     }
73141     pDup->iTable = pEList->a[iCol].iAlias;
73142   }else if( ExprHasProperty(pOrig, EP_IntValue) || pOrig->u.zToken==0 ){
73143     pDup = sqlcipher3ExprDup(db, pOrig, 0);
73144     if( pDup==0 ) return;
73145   }else{
73146     char *zToken = pOrig->u.zToken;
73147     assert( zToken!=0 );
73148     pOrig->u.zToken = 0;
73149     pDup = sqlcipher3ExprDup(db, pOrig, 0);
73150     pOrig->u.zToken = zToken;
73151     if( pDup==0 ) return;
73152     assert( (pDup->flags & (EP_Reduced|EP_TokenOnly))==0 );
73153     pDup->flags2 |= EP2_MallocedToken;
73154     pDup->u.zToken = sqlcipher3DbStrDup(db, zToken);
73155   }
73156   if( pExpr->flags & EP_ExpCollate ){
73157     pDup->pColl = pExpr->pColl;
73158     pDup->flags |= EP_ExpCollate;
73159   }
73160
73161   /* Before calling sqlcipher3ExprDelete(), set the EP_Static flag. This 
73162   ** prevents ExprDelete() from deleting the Expr structure itself,
73163   ** allowing it to be repopulated by the memcpy() on the following line.
73164   */
73165   ExprSetProperty(pExpr, EP_Static);
73166   sqlcipher3ExprDelete(db, pExpr);
73167   memcpy(pExpr, pDup, sizeof(*pExpr));
73168   sqlcipher3DbFree(db, pDup);
73169 }
73170
73171
73172 /*
73173 ** Return TRUE if the name zCol occurs anywhere in the USING clause.
73174 **
73175 ** Return FALSE if the USING clause is NULL or if it does not contain
73176 ** zCol.
73177 */
73178 static int nameInUsingClause(IdList *pUsing, const char *zCol){
73179   if( pUsing ){
73180     int k;
73181     for(k=0; k<pUsing->nId; k++){
73182       if( sqlcipher3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
73183     }
73184   }
73185   return 0;
73186 }
73187
73188
73189 /*
73190 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
73191 ** that name in the set of source tables in pSrcList and make the pExpr 
73192 ** expression node refer back to that source column.  The following changes
73193 ** are made to pExpr:
73194 **
73195 **    pExpr->iDb           Set the index in db->aDb[] of the database X
73196 **                         (even if X is implied).
73197 **    pExpr->iTable        Set to the cursor number for the table obtained
73198 **                         from pSrcList.
73199 **    pExpr->pTab          Points to the Table structure of X.Y (even if
73200 **                         X and/or Y are implied.)
73201 **    pExpr->iColumn       Set to the column number within the table.
73202 **    pExpr->op            Set to TK_COLUMN.
73203 **    pExpr->pLeft         Any expression this points to is deleted
73204 **    pExpr->pRight        Any expression this points to is deleted.
73205 **
73206 ** The zDb variable is the name of the database (the "X").  This value may be
73207 ** NULL meaning that name is of the form Y.Z or Z.  Any available database
73208 ** can be used.  The zTable variable is the name of the table (the "Y").  This
73209 ** value can be NULL if zDb is also NULL.  If zTable is NULL it
73210 ** means that the form of the name is Z and that columns from any table
73211 ** can be used.
73212 **
73213 ** If the name cannot be resolved unambiguously, leave an error message
73214 ** in pParse and return WRC_Abort.  Return WRC_Prune on success.
73215 */
73216 static int lookupName(
73217   Parse *pParse,       /* The parsing context */
73218   const char *zDb,     /* Name of the database containing table, or NULL */
73219   const char *zTab,    /* Name of table containing column, or NULL */
73220   const char *zCol,    /* Name of the column. */
73221   NameContext *pNC,    /* The name context used to resolve the name */
73222   Expr *pExpr          /* Make this EXPR node point to the selected column */
73223 ){
73224   int i, j;            /* Loop counters */
73225   int cnt = 0;                      /* Number of matching column names */
73226   int cntTab = 0;                   /* Number of matching table names */
73227   sqlcipher3 *db = pParse->db;         /* The database connection */
73228   struct SrcList_item *pItem;       /* Use for looping over pSrcList items */
73229   struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */
73230   NameContext *pTopNC = pNC;        /* First namecontext in the list */
73231   Schema *pSchema = 0;              /* Schema of the expression */
73232   int isTrigger = 0;
73233
73234   assert( pNC );     /* the name context cannot be NULL. */
73235   assert( zCol );    /* The Z in X.Y.Z cannot be NULL */
73236   assert( ~ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
73237
73238   /* Initialize the node to no-match */
73239   pExpr->iTable = -1;
73240   pExpr->pTab = 0;
73241   ExprSetIrreducible(pExpr);
73242
73243   /* Start at the inner-most context and move outward until a match is found */
73244   while( pNC && cnt==0 ){
73245     ExprList *pEList;
73246     SrcList *pSrcList = pNC->pSrcList;
73247
73248     if( pSrcList ){
73249       for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
73250         Table *pTab;
73251         int iDb;
73252         Column *pCol;
73253   
73254         pTab = pItem->pTab;
73255         assert( pTab!=0 && pTab->zName!=0 );
73256         iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
73257         assert( pTab->nCol>0 );
73258         if( zTab ){
73259           if( pItem->zAlias ){
73260             char *zTabName = pItem->zAlias;
73261             if( sqlcipher3StrICmp(zTabName, zTab)!=0 ) continue;
73262           }else{
73263             char *zTabName = pTab->zName;
73264             if( NEVER(zTabName==0) || sqlcipher3StrICmp(zTabName, zTab)!=0 ){
73265               continue;
73266             }
73267             if( zDb!=0 && sqlcipher3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
73268               continue;
73269             }
73270           }
73271         }
73272         if( 0==(cntTab++) ){
73273           pExpr->iTable = pItem->iCursor;
73274           pExpr->pTab = pTab;
73275           pSchema = pTab->pSchema;
73276           pMatch = pItem;
73277         }
73278         for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
73279           if( sqlcipher3StrICmp(pCol->zName, zCol)==0 ){
73280             /* If there has been exactly one prior match and this match
73281             ** is for the right-hand table of a NATURAL JOIN or is in a 
73282             ** USING clause, then skip this match.
73283             */
73284             if( cnt==1 ){
73285               if( pItem->jointype & JT_NATURAL ) continue;
73286               if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
73287             }
73288             cnt++;
73289             pExpr->iTable = pItem->iCursor;
73290             pExpr->pTab = pTab;
73291             pMatch = pItem;
73292             pSchema = pTab->pSchema;
73293             /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
73294             pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
73295             break;
73296           }
73297         }
73298       }
73299     }
73300
73301 #ifndef SQLCIPHER_OMIT_TRIGGER
73302     /* If we have not already resolved the name, then maybe 
73303     ** it is a new.* or old.* trigger argument reference
73304     */
73305     if( zDb==0 && zTab!=0 && cnt==0 && pParse->pTriggerTab!=0 ){
73306       int op = pParse->eTriggerOp;
73307       Table *pTab = 0;
73308       assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
73309       if( op!=TK_DELETE && sqlcipher3StrICmp("new",zTab) == 0 ){
73310         pExpr->iTable = 1;
73311         pTab = pParse->pTriggerTab;
73312       }else if( op!=TK_INSERT && sqlcipher3StrICmp("old",zTab)==0 ){
73313         pExpr->iTable = 0;
73314         pTab = pParse->pTriggerTab;
73315       }
73316
73317       if( pTab ){ 
73318         int iCol;
73319         pSchema = pTab->pSchema;
73320         cntTab++;
73321         for(iCol=0; iCol<pTab->nCol; iCol++){
73322           Column *pCol = &pTab->aCol[iCol];
73323           if( sqlcipher3StrICmp(pCol->zName, zCol)==0 ){
73324             if( iCol==pTab->iPKey ){
73325               iCol = -1;
73326             }
73327             break;
73328           }
73329         }
73330         if( iCol>=pTab->nCol && sqlcipher3IsRowid(zCol) ){
73331           iCol = -1;        /* IMP: R-44911-55124 */
73332         }
73333         if( iCol<pTab->nCol ){
73334           cnt++;
73335           if( iCol<0 ){
73336             pExpr->affinity = SQLCIPHER_AFF_INTEGER;
73337           }else if( pExpr->iTable==0 ){
73338             testcase( iCol==31 );
73339             testcase( iCol==32 );
73340             pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73341           }else{
73342             testcase( iCol==31 );
73343             testcase( iCol==32 );
73344             pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73345           }
73346           pExpr->iColumn = (i16)iCol;
73347           pExpr->pTab = pTab;
73348           isTrigger = 1;
73349         }
73350       }
73351     }
73352 #endif /* !defined(SQLCIPHER_OMIT_TRIGGER) */
73353
73354     /*
73355     ** Perhaps the name is a reference to the ROWID
73356     */
73357     if( cnt==0 && cntTab==1 && sqlcipher3IsRowid(zCol) ){
73358       cnt = 1;
73359       pExpr->iColumn = -1;     /* IMP: R-44911-55124 */
73360       pExpr->affinity = SQLCIPHER_AFF_INTEGER;
73361     }
73362
73363     /*
73364     ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
73365     ** might refer to an result-set alias.  This happens, for example, when
73366     ** we are resolving names in the WHERE clause of the following command:
73367     **
73368     **     SELECT a+b AS x FROM table WHERE x<10;
73369     **
73370     ** In cases like this, replace pExpr with a copy of the expression that
73371     ** forms the result set entry ("a+b" in the example) and return immediately.
73372     ** Note that the expression in the result set should have already been
73373     ** resolved by the time the WHERE clause is resolved.
73374     */
73375     if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){
73376       for(j=0; j<pEList->nExpr; j++){
73377         char *zAs = pEList->a[j].zName;
73378         if( zAs!=0 && sqlcipher3StrICmp(zAs, zCol)==0 ){
73379           Expr *pOrig;
73380           assert( pExpr->pLeft==0 && pExpr->pRight==0 );
73381           assert( pExpr->x.pList==0 );
73382           assert( pExpr->x.pSelect==0 );
73383           pOrig = pEList->a[j].pExpr;
73384           if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){
73385             sqlcipher3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
73386             return WRC_Abort;
73387           }
73388           resolveAlias(pParse, pEList, j, pExpr, "");
73389           cnt = 1;
73390           pMatch = 0;
73391           assert( zTab==0 && zDb==0 );
73392           goto lookupname_end;
73393         }
73394       } 
73395     }
73396
73397     /* Advance to the next name context.  The loop will exit when either
73398     ** we have a match (cnt>0) or when we run out of name contexts.
73399     */
73400     if( cnt==0 ){
73401       pNC = pNC->pNext;
73402     }
73403   }
73404
73405   /*
73406   ** If X and Y are NULL (in other words if only the column name Z is
73407   ** supplied) and the value of Z is enclosed in double-quotes, then
73408   ** Z is a string literal if it doesn't match any column names.  In that
73409   ** case, we need to return right away and not make any changes to
73410   ** pExpr.
73411   **
73412   ** Because no reference was made to outer contexts, the pNC->nRef
73413   ** fields are not changed in any context.
73414   */
73415   if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){
73416     pExpr->op = TK_STRING;
73417     pExpr->pTab = 0;
73418     return WRC_Prune;
73419   }
73420
73421   /*
73422   ** cnt==0 means there was not match.  cnt>1 means there were two or
73423   ** more matches.  Either way, we have an error.
73424   */
73425   if( cnt!=1 ){
73426     const char *zErr;
73427     zErr = cnt==0 ? "no such column" : "ambiguous column name";
73428     if( zDb ){
73429       sqlcipher3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
73430     }else if( zTab ){
73431       sqlcipher3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
73432     }else{
73433       sqlcipher3ErrorMsg(pParse, "%s: %s", zErr, zCol);
73434     }
73435     pParse->checkSchema = 1;
73436     pTopNC->nErr++;
73437   }
73438
73439   /* If a column from a table in pSrcList is referenced, then record
73440   ** this fact in the pSrcList.a[].colUsed bitmask.  Column 0 causes
73441   ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  If the
73442   ** column number is greater than the number of bits in the bitmask
73443   ** then set the high-order bit of the bitmask.
73444   */
73445   if( pExpr->iColumn>=0 && pMatch!=0 ){
73446     int n = pExpr->iColumn;
73447     testcase( n==BMS-1 );
73448     if( n>=BMS ){
73449       n = BMS-1;
73450     }
73451     assert( pMatch->iCursor==pExpr->iTable );
73452     pMatch->colUsed |= ((Bitmask)1)<<n;
73453   }
73454
73455   /* Clean up and return
73456   */
73457   sqlcipher3ExprDelete(db, pExpr->pLeft);
73458   pExpr->pLeft = 0;
73459   sqlcipher3ExprDelete(db, pExpr->pRight);
73460   pExpr->pRight = 0;
73461   pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
73462 lookupname_end:
73463   if( cnt==1 ){
73464     assert( pNC!=0 );
73465     sqlcipher3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
73466     /* Increment the nRef value on all name contexts from TopNC up to
73467     ** the point where the name matched. */
73468     for(;;){
73469       assert( pTopNC!=0 );
73470       pTopNC->nRef++;
73471       if( pTopNC==pNC ) break;
73472       pTopNC = pTopNC->pNext;
73473     }
73474     return WRC_Prune;
73475   } else {
73476     return WRC_Abort;
73477   }
73478 }
73479
73480 /*
73481 ** Allocate and return a pointer to an expression to load the column iCol
73482 ** from datasource iSrc in SrcList pSrc.
73483 */
73484 SQLCIPHER_PRIVATE Expr *sqlcipher3CreateColumnExpr(sqlcipher3 *db, SrcList *pSrc, int iSrc, int iCol){
73485   Expr *p = sqlcipher3ExprAlloc(db, TK_COLUMN, 0, 0);
73486   if( p ){
73487     struct SrcList_item *pItem = &pSrc->a[iSrc];
73488     p->pTab = pItem->pTab;
73489     p->iTable = pItem->iCursor;
73490     if( p->pTab->iPKey==iCol ){
73491       p->iColumn = -1;
73492     }else{
73493       p->iColumn = (ynVar)iCol;
73494       testcase( iCol==BMS );
73495       testcase( iCol==BMS-1 );
73496       pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
73497     }
73498     ExprSetProperty(p, EP_Resolved);
73499   }
73500   return p;
73501 }
73502
73503 /*
73504 ** This routine is callback for sqlcipher3WalkExpr().
73505 **
73506 ** Resolve symbolic names into TK_COLUMN operators for the current
73507 ** node in the expression tree.  Return 0 to continue the search down
73508 ** the tree or 2 to abort the tree walk.
73509 **
73510 ** This routine also does error checking and name resolution for
73511 ** function names.  The operator for aggregate functions is changed
73512 ** to TK_AGG_FUNCTION.
73513 */
73514 static int resolveExprStep(Walker *pWalker, Expr *pExpr){
73515   NameContext *pNC;
73516   Parse *pParse;
73517
73518   pNC = pWalker->u.pNC;
73519   assert( pNC!=0 );
73520   pParse = pNC->pParse;
73521   assert( pParse==pWalker->pParse );
73522
73523   if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return WRC_Prune;
73524   ExprSetProperty(pExpr, EP_Resolved);
73525 #ifndef NDEBUG
73526   if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
73527     SrcList *pSrcList = pNC->pSrcList;
73528     int i;
73529     for(i=0; i<pNC->pSrcList->nSrc; i++){
73530       assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
73531     }
73532   }
73533 #endif
73534   switch( pExpr->op ){
73535
73536 #if defined(SQLCIPHER_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLCIPHER_OMIT_SUBQUERY)
73537     /* The special operator TK_ROW means use the rowid for the first
73538     ** column in the FROM clause.  This is used by the LIMIT and ORDER BY
73539     ** clause processing on UPDATE and DELETE statements.
73540     */
73541     case TK_ROW: {
73542       SrcList *pSrcList = pNC->pSrcList;
73543       struct SrcList_item *pItem;
73544       assert( pSrcList && pSrcList->nSrc==1 );
73545       pItem = pSrcList->a; 
73546       pExpr->op = TK_COLUMN;
73547       pExpr->pTab = pItem->pTab;
73548       pExpr->iTable = pItem->iCursor;
73549       pExpr->iColumn = -1;
73550       pExpr->affinity = SQLCIPHER_AFF_INTEGER;
73551       break;
73552     }
73553 #endif /* defined(SQLCIPHER_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLCIPHER_OMIT_SUBQUERY) */
73554
73555     /* A lone identifier is the name of a column.
73556     */
73557     case TK_ID: {
73558       return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
73559     }
73560   
73561     /* A table name and column name:     ID.ID
73562     ** Or a database, table and column:  ID.ID.ID
73563     */
73564     case TK_DOT: {
73565       const char *zColumn;
73566       const char *zTable;
73567       const char *zDb;
73568       Expr *pRight;
73569
73570       /* if( pSrcList==0 ) break; */
73571       pRight = pExpr->pRight;
73572       if( pRight->op==TK_ID ){
73573         zDb = 0;
73574         zTable = pExpr->pLeft->u.zToken;
73575         zColumn = pRight->u.zToken;
73576       }else{
73577         assert( pRight->op==TK_DOT );
73578         zDb = pExpr->pLeft->u.zToken;
73579         zTable = pRight->pLeft->u.zToken;
73580         zColumn = pRight->pRight->u.zToken;
73581       }
73582       return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
73583     }
73584
73585     /* Resolve function names
73586     */
73587     case TK_CONST_FUNC:
73588     case TK_FUNCTION: {
73589       ExprList *pList = pExpr->x.pList;    /* The argument list */
73590       int n = pList ? pList->nExpr : 0;    /* Number of arguments */
73591       int no_such_func = 0;       /* True if no such function exists */
73592       int wrong_num_args = 0;     /* True if wrong number of arguments */
73593       int is_agg = 0;             /* True if is an aggregate function */
73594       int auth;                   /* Authorization to use the function */
73595       int nId;                    /* Number of characters in function name */
73596       const char *zId;            /* The function name. */
73597       FuncDef *pDef;              /* Information about the function */
73598       u8 enc = ENC(pParse->db);   /* The database encoding */
73599
73600       testcase( pExpr->op==TK_CONST_FUNC );
73601       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
73602       zId = pExpr->u.zToken;
73603       nId = sqlcipher3Strlen30(zId);
73604       pDef = sqlcipher3FindFunction(pParse->db, zId, nId, n, enc, 0);
73605       if( pDef==0 ){
73606         pDef = sqlcipher3FindFunction(pParse->db, zId, nId, -1, enc, 0);
73607         if( pDef==0 ){
73608           no_such_func = 1;
73609         }else{
73610           wrong_num_args = 1;
73611         }
73612       }else{
73613         is_agg = pDef->xFunc==0;
73614       }
73615 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
73616       if( pDef ){
73617         auth = sqlcipher3AuthCheck(pParse, SQLCIPHER_FUNCTION, 0, pDef->zName, 0);
73618         if( auth!=SQLCIPHER_OK ){
73619           if( auth==SQLCIPHER_DENY ){
73620             sqlcipher3ErrorMsg(pParse, "not authorized to use function: %s",
73621                                     pDef->zName);
73622             pNC->nErr++;
73623           }
73624           pExpr->op = TK_NULL;
73625           return WRC_Prune;
73626         }
73627       }
73628 #endif
73629       if( is_agg && !pNC->allowAgg ){
73630         sqlcipher3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
73631         pNC->nErr++;
73632         is_agg = 0;
73633       }else if( no_such_func ){
73634         sqlcipher3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
73635         pNC->nErr++;
73636       }else if( wrong_num_args ){
73637         sqlcipher3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
73638              nId, zId);
73639         pNC->nErr++;
73640       }
73641       if( is_agg ){
73642         pExpr->op = TK_AGG_FUNCTION;
73643         pNC->hasAgg = 1;
73644       }
73645       if( is_agg ) pNC->allowAgg = 0;
73646       sqlcipher3WalkExprList(pWalker, pList);
73647       if( is_agg ) pNC->allowAgg = 1;
73648       /* FIX ME:  Compute pExpr->affinity based on the expected return
73649       ** type of the function 
73650       */
73651       return WRC_Prune;
73652     }
73653 #ifndef SQLCIPHER_OMIT_SUBQUERY
73654     case TK_SELECT:
73655     case TK_EXISTS:  testcase( pExpr->op==TK_EXISTS );
73656 #endif
73657     case TK_IN: {
73658       testcase( pExpr->op==TK_IN );
73659       if( ExprHasProperty(pExpr, EP_xIsSelect) ){
73660         int nRef = pNC->nRef;
73661 #ifndef SQLCIPHER_OMIT_CHECK
73662         if( pNC->isCheck ){
73663           sqlcipher3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
73664         }
73665 #endif
73666         sqlcipher3WalkSelect(pWalker, pExpr->x.pSelect);
73667         assert( pNC->nRef>=nRef );
73668         if( nRef!=pNC->nRef ){
73669           ExprSetProperty(pExpr, EP_VarSelect);
73670         }
73671       }
73672       break;
73673     }
73674 #ifndef SQLCIPHER_OMIT_CHECK
73675     case TK_VARIABLE: {
73676       if( pNC->isCheck ){
73677         sqlcipher3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
73678       }
73679       break;
73680     }
73681 #endif
73682   }
73683   return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
73684 }
73685
73686 /*
73687 ** pEList is a list of expressions which are really the result set of the
73688 ** a SELECT statement.  pE is a term in an ORDER BY or GROUP BY clause.
73689 ** This routine checks to see if pE is a simple identifier which corresponds
73690 ** to the AS-name of one of the terms of the expression list.  If it is,
73691 ** this routine return an integer between 1 and N where N is the number of
73692 ** elements in pEList, corresponding to the matching entry.  If there is
73693 ** no match, or if pE is not a simple identifier, then this routine
73694 ** return 0.
73695 **
73696 ** pEList has been resolved.  pE has not.
73697 */
73698 static int resolveAsName(
73699   Parse *pParse,     /* Parsing context for error messages */
73700   ExprList *pEList,  /* List of expressions to scan */
73701   Expr *pE           /* Expression we are trying to match */
73702 ){
73703   int i;             /* Loop counter */
73704
73705   UNUSED_PARAMETER(pParse);
73706
73707   if( pE->op==TK_ID ){
73708     char *zCol = pE->u.zToken;
73709     for(i=0; i<pEList->nExpr; i++){
73710       char *zAs = pEList->a[i].zName;
73711       if( zAs!=0 && sqlcipher3StrICmp(zAs, zCol)==0 ){
73712         return i+1;
73713       }
73714     }
73715   }
73716   return 0;
73717 }
73718
73719 /*
73720 ** pE is a pointer to an expression which is a single term in the
73721 ** ORDER BY of a compound SELECT.  The expression has not been
73722 ** name resolved.
73723 **
73724 ** At the point this routine is called, we already know that the
73725 ** ORDER BY term is not an integer index into the result set.  That
73726 ** case is handled by the calling routine.
73727 **
73728 ** Attempt to match pE against result set columns in the left-most
73729 ** SELECT statement.  Return the index i of the matching column,
73730 ** as an indication to the caller that it should sort by the i-th column.
73731 ** The left-most column is 1.  In other words, the value returned is the
73732 ** same integer value that would be used in the SQL statement to indicate
73733 ** the column.
73734 **
73735 ** If there is no match, return 0.  Return -1 if an error occurs.
73736 */
73737 static int resolveOrderByTermToExprList(
73738   Parse *pParse,     /* Parsing context for error messages */
73739   Select *pSelect,   /* The SELECT statement with the ORDER BY clause */
73740   Expr *pE           /* The specific ORDER BY term */
73741 ){
73742   int i;             /* Loop counter */
73743   ExprList *pEList;  /* The columns of the result set */
73744   NameContext nc;    /* Name context for resolving pE */
73745   sqlcipher3 *db;       /* Database connection */
73746   int rc;            /* Return code from subprocedures */
73747   u8 savedSuppErr;   /* Saved value of db->suppressErr */
73748
73749   assert( sqlcipher3ExprIsInteger(pE, &i)==0 );
73750   pEList = pSelect->pEList;
73751
73752   /* Resolve all names in the ORDER BY term expression
73753   */
73754   memset(&nc, 0, sizeof(nc));
73755   nc.pParse = pParse;
73756   nc.pSrcList = pSelect->pSrc;
73757   nc.pEList = pEList;
73758   nc.allowAgg = 1;
73759   nc.nErr = 0;
73760   db = pParse->db;
73761   savedSuppErr = db->suppressErr;
73762   db->suppressErr = 1;
73763   rc = sqlcipher3ResolveExprNames(&nc, pE);
73764   db->suppressErr = savedSuppErr;
73765   if( rc ) return 0;
73766
73767   /* Try to match the ORDER BY expression against an expression
73768   ** in the result set.  Return an 1-based index of the matching
73769   ** result-set entry.
73770   */
73771   for(i=0; i<pEList->nExpr; i++){
73772     if( sqlcipher3ExprCompare(pEList->a[i].pExpr, pE)<2 ){
73773       return i+1;
73774     }
73775   }
73776
73777   /* If no match, return 0. */
73778   return 0;
73779 }
73780
73781 /*
73782 ** Generate an ORDER BY or GROUP BY term out-of-range error.
73783 */
73784 static void resolveOutOfRangeError(
73785   Parse *pParse,         /* The error context into which to write the error */
73786   const char *zType,     /* "ORDER" or "GROUP" */
73787   int i,                 /* The index (1-based) of the term out of range */
73788   int mx                 /* Largest permissible value of i */
73789 ){
73790   sqlcipher3ErrorMsg(pParse, 
73791     "%r %s BY term out of range - should be "
73792     "between 1 and %d", i, zType, mx);
73793 }
73794
73795 /*
73796 ** Analyze the ORDER BY clause in a compound SELECT statement.   Modify
73797 ** each term of the ORDER BY clause is a constant integer between 1
73798 ** and N where N is the number of columns in the compound SELECT.
73799 **
73800 ** ORDER BY terms that are already an integer between 1 and N are
73801 ** unmodified.  ORDER BY terms that are integers outside the range of
73802 ** 1 through N generate an error.  ORDER BY terms that are expressions
73803 ** are matched against result set expressions of compound SELECT
73804 ** beginning with the left-most SELECT and working toward the right.
73805 ** At the first match, the ORDER BY expression is transformed into
73806 ** the integer column number.
73807 **
73808 ** Return the number of errors seen.
73809 */
73810 static int resolveCompoundOrderBy(
73811   Parse *pParse,        /* Parsing context.  Leave error messages here */
73812   Select *pSelect       /* The SELECT statement containing the ORDER BY */
73813 ){
73814   int i;
73815   ExprList *pOrderBy;
73816   ExprList *pEList;
73817   sqlcipher3 *db;
73818   int moreToDo = 1;
73819
73820   pOrderBy = pSelect->pOrderBy;
73821   if( pOrderBy==0 ) return 0;
73822   db = pParse->db;
73823 #if SQLCIPHER_MAX_COLUMN
73824   if( pOrderBy->nExpr>db->aLimit[SQLCIPHER_LIMIT_COLUMN] ){
73825     sqlcipher3ErrorMsg(pParse, "too many terms in ORDER BY clause");
73826     return 1;
73827   }
73828 #endif
73829   for(i=0; i<pOrderBy->nExpr; i++){
73830     pOrderBy->a[i].done = 0;
73831   }
73832   pSelect->pNext = 0;
73833   while( pSelect->pPrior ){
73834     pSelect->pPrior->pNext = pSelect;
73835     pSelect = pSelect->pPrior;
73836   }
73837   while( pSelect && moreToDo ){
73838     struct ExprList_item *pItem;
73839     moreToDo = 0;
73840     pEList = pSelect->pEList;
73841     assert( pEList!=0 );
73842     for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
73843       int iCol = -1;
73844       Expr *pE, *pDup;
73845       if( pItem->done ) continue;
73846       pE = pItem->pExpr;
73847       if( sqlcipher3ExprIsInteger(pE, &iCol) ){
73848         if( iCol<=0 || iCol>pEList->nExpr ){
73849           resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
73850           return 1;
73851         }
73852       }else{
73853         iCol = resolveAsName(pParse, pEList, pE);
73854         if( iCol==0 ){
73855           pDup = sqlcipher3ExprDup(db, pE, 0);
73856           if( !db->mallocFailed ){
73857             assert(pDup);
73858             iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
73859           }
73860           sqlcipher3ExprDelete(db, pDup);
73861         }
73862       }
73863       if( iCol>0 ){
73864         CollSeq *pColl = pE->pColl;
73865         int flags = pE->flags & EP_ExpCollate;
73866         sqlcipher3ExprDelete(db, pE);
73867         pItem->pExpr = pE = sqlcipher3Expr(db, TK_INTEGER, 0);
73868         if( pE==0 ) return 1;
73869         pE->pColl = pColl;
73870         pE->flags |= EP_IntValue | flags;
73871         pE->u.iValue = iCol;
73872         pItem->iCol = (u16)iCol;
73873         pItem->done = 1;
73874       }else{
73875         moreToDo = 1;
73876       }
73877     }
73878     pSelect = pSelect->pNext;
73879   }
73880   for(i=0; i<pOrderBy->nExpr; i++){
73881     if( pOrderBy->a[i].done==0 ){
73882       sqlcipher3ErrorMsg(pParse, "%r ORDER BY term does not match any "
73883             "column in the result set", i+1);
73884       return 1;
73885     }
73886   }
73887   return 0;
73888 }
73889
73890 /*
73891 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
73892 ** the SELECT statement pSelect.  If any term is reference to a
73893 ** result set expression (as determined by the ExprList.a.iCol field)
73894 ** then convert that term into a copy of the corresponding result set
73895 ** column.
73896 **
73897 ** If any errors are detected, add an error message to pParse and
73898 ** return non-zero.  Return zero if no errors are seen.
73899 */
73900 SQLCIPHER_PRIVATE int sqlcipher3ResolveOrderGroupBy(
73901   Parse *pParse,        /* Parsing context.  Leave error messages here */
73902   Select *pSelect,      /* The SELECT statement containing the clause */
73903   ExprList *pOrderBy,   /* The ORDER BY or GROUP BY clause to be processed */
73904   const char *zType     /* "ORDER" or "GROUP" */
73905 ){
73906   int i;
73907   sqlcipher3 *db = pParse->db;
73908   ExprList *pEList;
73909   struct ExprList_item *pItem;
73910
73911   if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
73912 #if SQLCIPHER_MAX_COLUMN
73913   if( pOrderBy->nExpr>db->aLimit[SQLCIPHER_LIMIT_COLUMN] ){
73914     sqlcipher3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
73915     return 1;
73916   }
73917 #endif
73918   pEList = pSelect->pEList;
73919   assert( pEList!=0 );  /* sqlcipher3SelectNew() guarantees this */
73920   for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
73921     if( pItem->iCol ){
73922       if( pItem->iCol>pEList->nExpr ){
73923         resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
73924         return 1;
73925       }
73926       resolveAlias(pParse, pEList, pItem->iCol-1, pItem->pExpr, zType);
73927     }
73928   }
73929   return 0;
73930 }
73931
73932 /*
73933 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
73934 ** The Name context of the SELECT statement is pNC.  zType is either
73935 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
73936 **
73937 ** This routine resolves each term of the clause into an expression.
73938 ** If the order-by term is an integer I between 1 and N (where N is the
73939 ** number of columns in the result set of the SELECT) then the expression
73940 ** in the resolution is a copy of the I-th result-set expression.  If
73941 ** the order-by term is an identify that corresponds to the AS-name of
73942 ** a result-set expression, then the term resolves to a copy of the
73943 ** result-set expression.  Otherwise, the expression is resolved in
73944 ** the usual way - using sqlcipher3ResolveExprNames().
73945 **
73946 ** This routine returns the number of errors.  If errors occur, then
73947 ** an appropriate error message might be left in pParse.  (OOM errors
73948 ** excepted.)
73949 */
73950 static int resolveOrderGroupBy(
73951   NameContext *pNC,     /* The name context of the SELECT statement */
73952   Select *pSelect,      /* The SELECT statement holding pOrderBy */
73953   ExprList *pOrderBy,   /* An ORDER BY or GROUP BY clause to resolve */
73954   const char *zType     /* Either "ORDER" or "GROUP", as appropriate */
73955 ){
73956   int i;                         /* Loop counter */
73957   int iCol;                      /* Column number */
73958   struct ExprList_item *pItem;   /* A term of the ORDER BY clause */
73959   Parse *pParse;                 /* Parsing context */
73960   int nResult;                   /* Number of terms in the result set */
73961
73962   if( pOrderBy==0 ) return 0;
73963   nResult = pSelect->pEList->nExpr;
73964   pParse = pNC->pParse;
73965   for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
73966     Expr *pE = pItem->pExpr;
73967     iCol = resolveAsName(pParse, pSelect->pEList, pE);
73968     if( iCol>0 ){
73969       /* If an AS-name match is found, mark this ORDER BY column as being
73970       ** a copy of the iCol-th result-set column.  The subsequent call to
73971       ** sqlcipher3ResolveOrderGroupBy() will convert the expression to a
73972       ** copy of the iCol-th result-set expression. */
73973       pItem->iCol = (u16)iCol;
73974       continue;
73975     }
73976     if( sqlcipher3ExprIsInteger(pE, &iCol) ){
73977       /* The ORDER BY term is an integer constant.  Again, set the column
73978       ** number so that sqlcipher3ResolveOrderGroupBy() will convert the
73979       ** order-by term to a copy of the result-set expression */
73980       if( iCol<1 ){
73981         resolveOutOfRangeError(pParse, zType, i+1, nResult);
73982         return 1;
73983       }
73984       pItem->iCol = (u16)iCol;
73985       continue;
73986     }
73987
73988     /* Otherwise, treat the ORDER BY term as an ordinary expression */
73989     pItem->iCol = 0;
73990     if( sqlcipher3ResolveExprNames(pNC, pE) ){
73991       return 1;
73992     }
73993   }
73994   return sqlcipher3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
73995 }
73996
73997 /*
73998 ** Resolve names in the SELECT statement p and all of its descendents.
73999 */
74000 static int resolveSelectStep(Walker *pWalker, Select *p){
74001   NameContext *pOuterNC;  /* Context that contains this SELECT */
74002   NameContext sNC;        /* Name context of this SELECT */
74003   int isCompound;         /* True if p is a compound select */
74004   int nCompound;          /* Number of compound terms processed so far */
74005   Parse *pParse;          /* Parsing context */
74006   ExprList *pEList;       /* Result set expression list */
74007   int i;                  /* Loop counter */
74008   ExprList *pGroupBy;     /* The GROUP BY clause */
74009   Select *pLeftmost;      /* Left-most of SELECT of a compound */
74010   sqlcipher3 *db;            /* Database connection */
74011   
74012
74013   assert( p!=0 );
74014   if( p->selFlags & SF_Resolved ){
74015     return WRC_Prune;
74016   }
74017   pOuterNC = pWalker->u.pNC;
74018   pParse = pWalker->pParse;
74019   db = pParse->db;
74020
74021   /* Normally sqlcipher3SelectExpand() will be called first and will have
74022   ** already expanded this SELECT.  However, if this is a subquery within
74023   ** an expression, sqlcipher3ResolveExprNames() will be called without a
74024   ** prior call to sqlcipher3SelectExpand().  When that happens, let
74025   ** sqlcipher3SelectPrep() do all of the processing for this SELECT.
74026   ** sqlcipher3SelectPrep() will invoke both sqlcipher3SelectExpand() and
74027   ** this routine in the correct order.
74028   */
74029   if( (p->selFlags & SF_Expanded)==0 ){
74030     sqlcipher3SelectPrep(pParse, p, pOuterNC);
74031     return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
74032   }
74033
74034   isCompound = p->pPrior!=0;
74035   nCompound = 0;
74036   pLeftmost = p;
74037   while( p ){
74038     assert( (p->selFlags & SF_Expanded)!=0 );
74039     assert( (p->selFlags & SF_Resolved)==0 );
74040     p->selFlags |= SF_Resolved;
74041
74042     /* Resolve the expressions in the LIMIT and OFFSET clauses. These
74043     ** are not allowed to refer to any names, so pass an empty NameContext.
74044     */
74045     memset(&sNC, 0, sizeof(sNC));
74046     sNC.pParse = pParse;
74047     if( sqlcipher3ResolveExprNames(&sNC, p->pLimit) ||
74048         sqlcipher3ResolveExprNames(&sNC, p->pOffset) ){
74049       return WRC_Abort;
74050     }
74051   
74052     /* Set up the local name-context to pass to sqlcipher3ResolveExprNames() to
74053     ** resolve the result-set expression list.
74054     */
74055     sNC.allowAgg = 1;
74056     sNC.pSrcList = p->pSrc;
74057     sNC.pNext = pOuterNC;
74058   
74059     /* Resolve names in the result set. */
74060     pEList = p->pEList;
74061     assert( pEList!=0 );
74062     for(i=0; i<pEList->nExpr; i++){
74063       Expr *pX = pEList->a[i].pExpr;
74064       if( sqlcipher3ResolveExprNames(&sNC, pX) ){
74065         return WRC_Abort;
74066       }
74067     }
74068   
74069     /* Recursively resolve names in all subqueries
74070     */
74071     for(i=0; i<p->pSrc->nSrc; i++){
74072       struct SrcList_item *pItem = &p->pSrc->a[i];
74073       if( pItem->pSelect ){
74074         NameContext *pNC;         /* Used to iterate name contexts */
74075         int nRef = 0;             /* Refcount for pOuterNC and outer contexts */
74076         const char *zSavedContext = pParse->zAuthContext;
74077
74078         /* Count the total number of references to pOuterNC and all of its
74079         ** parent contexts. After resolving references to expressions in
74080         ** pItem->pSelect, check if this value has changed. If so, then
74081         ** SELECT statement pItem->pSelect must be correlated. Set the
74082         ** pItem->isCorrelated flag if this is the case. */
74083         for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
74084
74085         if( pItem->zName ) pParse->zAuthContext = pItem->zName;
74086         sqlcipher3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
74087         pParse->zAuthContext = zSavedContext;
74088         if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
74089
74090         for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
74091         assert( pItem->isCorrelated==0 && nRef<=0 );
74092         pItem->isCorrelated = (nRef!=0);
74093       }
74094     }
74095   
74096     /* If there are no aggregate functions in the result-set, and no GROUP BY 
74097     ** expression, do not allow aggregates in any of the other expressions.
74098     */
74099     assert( (p->selFlags & SF_Aggregate)==0 );
74100     pGroupBy = p->pGroupBy;
74101     if( pGroupBy || sNC.hasAgg ){
74102       p->selFlags |= SF_Aggregate;
74103     }else{
74104       sNC.allowAgg = 0;
74105     }
74106   
74107     /* If a HAVING clause is present, then there must be a GROUP BY clause.
74108     */
74109     if( p->pHaving && !pGroupBy ){
74110       sqlcipher3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
74111       return WRC_Abort;
74112     }
74113   
74114     /* Add the expression list to the name-context before parsing the
74115     ** other expressions in the SELECT statement. This is so that
74116     ** expressions in the WHERE clause (etc.) can refer to expressions by
74117     ** aliases in the result set.
74118     **
74119     ** Minor point: If this is the case, then the expression will be
74120     ** re-evaluated for each reference to it.
74121     */
74122     sNC.pEList = p->pEList;
74123     if( sqlcipher3ResolveExprNames(&sNC, p->pWhere) ||
74124        sqlcipher3ResolveExprNames(&sNC, p->pHaving)
74125     ){
74126       return WRC_Abort;
74127     }
74128
74129     /* The ORDER BY and GROUP BY clauses may not refer to terms in
74130     ** outer queries 
74131     */
74132     sNC.pNext = 0;
74133     sNC.allowAgg = 1;
74134
74135     /* Process the ORDER BY clause for singleton SELECT statements.
74136     ** The ORDER BY clause for compounds SELECT statements is handled
74137     ** below, after all of the result-sets for all of the elements of
74138     ** the compound have been resolved.
74139     */
74140     if( !isCompound && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") ){
74141       return WRC_Abort;
74142     }
74143     if( db->mallocFailed ){
74144       return WRC_Abort;
74145     }
74146   
74147     /* Resolve the GROUP BY clause.  At the same time, make sure 
74148     ** the GROUP BY clause does not contain aggregate functions.
74149     */
74150     if( pGroupBy ){
74151       struct ExprList_item *pItem;
74152     
74153       if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
74154         return WRC_Abort;
74155       }
74156       for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
74157         if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
74158           sqlcipher3ErrorMsg(pParse, "aggregate functions are not allowed in "
74159               "the GROUP BY clause");
74160           return WRC_Abort;
74161         }
74162       }
74163     }
74164
74165     /* Advance to the next term of the compound
74166     */
74167     p = p->pPrior;
74168     nCompound++;
74169   }
74170
74171   /* Resolve the ORDER BY on a compound SELECT after all terms of
74172   ** the compound have been resolved.
74173   */
74174   if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
74175     return WRC_Abort;
74176   }
74177
74178   return WRC_Prune;
74179 }
74180
74181 /*
74182 ** This routine walks an expression tree and resolves references to
74183 ** table columns and result-set columns.  At the same time, do error
74184 ** checking on function usage and set a flag if any aggregate functions
74185 ** are seen.
74186 **
74187 ** To resolve table columns references we look for nodes (or subtrees) of the 
74188 ** form X.Y.Z or Y.Z or just Z where
74189 **
74190 **      X:   The name of a database.  Ex:  "main" or "temp" or
74191 **           the symbolic name assigned to an ATTACH-ed database.
74192 **
74193 **      Y:   The name of a table in a FROM clause.  Or in a trigger
74194 **           one of the special names "old" or "new".
74195 **
74196 **      Z:   The name of a column in table Y.
74197 **
74198 ** The node at the root of the subtree is modified as follows:
74199 **
74200 **    Expr.op        Changed to TK_COLUMN
74201 **    Expr.pTab      Points to the Table object for X.Y
74202 **    Expr.iColumn   The column index in X.Y.  -1 for the rowid.
74203 **    Expr.iTable    The VDBE cursor number for X.Y
74204 **
74205 **
74206 ** To resolve result-set references, look for expression nodes of the
74207 ** form Z (with no X and Y prefix) where the Z matches the right-hand
74208 ** size of an AS clause in the result-set of a SELECT.  The Z expression
74209 ** is replaced by a copy of the left-hand side of the result-set expression.
74210 ** Table-name and function resolution occurs on the substituted expression
74211 ** tree.  For example, in:
74212 **
74213 **      SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
74214 **
74215 ** The "x" term of the order by is replaced by "a+b" to render:
74216 **
74217 **      SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
74218 **
74219 ** Function calls are checked to make sure that the function is 
74220 ** defined and that the correct number of arguments are specified.
74221 ** If the function is an aggregate function, then the pNC->hasAgg is
74222 ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
74223 ** If an expression contains aggregate functions then the EP_Agg
74224 ** property on the expression is set.
74225 **
74226 ** An error message is left in pParse if anything is amiss.  The number
74227 ** if errors is returned.
74228 */
74229 SQLCIPHER_PRIVATE int sqlcipher3ResolveExprNames( 
74230   NameContext *pNC,       /* Namespace to resolve expressions in. */
74231   Expr *pExpr             /* The expression to be analyzed. */
74232 ){
74233   int savedHasAgg;
74234   Walker w;
74235
74236   if( pExpr==0 ) return 0;
74237 #if SQLCIPHER_MAX_EXPR_DEPTH>0
74238   {
74239     Parse *pParse = pNC->pParse;
74240     if( sqlcipher3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
74241       return 1;
74242     }
74243     pParse->nHeight += pExpr->nHeight;
74244   }
74245 #endif
74246   savedHasAgg = pNC->hasAgg;
74247   pNC->hasAgg = 0;
74248   w.xExprCallback = resolveExprStep;
74249   w.xSelectCallback = resolveSelectStep;
74250   w.pParse = pNC->pParse;
74251   w.u.pNC = pNC;
74252   sqlcipher3WalkExpr(&w, pExpr);
74253 #if SQLCIPHER_MAX_EXPR_DEPTH>0
74254   pNC->pParse->nHeight -= pExpr->nHeight;
74255 #endif
74256   if( pNC->nErr>0 || w.pParse->nErr>0 ){
74257     ExprSetProperty(pExpr, EP_Error);
74258   }
74259   if( pNC->hasAgg ){
74260     ExprSetProperty(pExpr, EP_Agg);
74261   }else if( savedHasAgg ){
74262     pNC->hasAgg = 1;
74263   }
74264   return ExprHasProperty(pExpr, EP_Error);
74265 }
74266
74267
74268 /*
74269 ** Resolve all names in all expressions of a SELECT and in all
74270 ** decendents of the SELECT, including compounds off of p->pPrior,
74271 ** subqueries in expressions, and subqueries used as FROM clause
74272 ** terms.
74273 **
74274 ** See sqlcipher3ResolveExprNames() for a description of the kinds of
74275 ** transformations that occur.
74276 **
74277 ** All SELECT statements should have been expanded using
74278 ** sqlcipher3SelectExpand() prior to invoking this routine.
74279 */
74280 SQLCIPHER_PRIVATE void sqlcipher3ResolveSelectNames(
74281   Parse *pParse,         /* The parser context */
74282   Select *p,             /* The SELECT statement being coded. */
74283   NameContext *pOuterNC  /* Name context for parent SELECT statement */
74284 ){
74285   Walker w;
74286
74287   assert( p!=0 );
74288   w.xExprCallback = resolveExprStep;
74289   w.xSelectCallback = resolveSelectStep;
74290   w.pParse = pParse;
74291   w.u.pNC = pOuterNC;
74292   sqlcipher3WalkSelect(&w, p);
74293 }
74294
74295 /************** End of resolve.c *********************************************/
74296 /************** Begin file expr.c ********************************************/
74297 /*
74298 ** 2001 September 15
74299 **
74300 ** The author disclaims copyright to this source code.  In place of
74301 ** a legal notice, here is a blessing:
74302 **
74303 **    May you do good and not evil.
74304 **    May you find forgiveness for yourself and forgive others.
74305 **    May you share freely, never taking more than you give.
74306 **
74307 *************************************************************************
74308 ** This file contains routines used for analyzing expressions and
74309 ** for generating VDBE code that evaluates expressions in SQLite.
74310 */
74311
74312 /*
74313 ** Return the 'affinity' of the expression pExpr if any.
74314 **
74315 ** If pExpr is a column, a reference to a column via an 'AS' alias,
74316 ** or a sub-select with a column as the return value, then the 
74317 ** affinity of that column is returned. Otherwise, 0x00 is returned,
74318 ** indicating no affinity for the expression.
74319 **
74320 ** i.e. the WHERE clause expresssions in the following statements all
74321 ** have an affinity:
74322 **
74323 ** CREATE TABLE t1(a);
74324 ** SELECT * FROM t1 WHERE a;
74325 ** SELECT a AS b FROM t1 WHERE b;
74326 ** SELECT * FROM t1 WHERE (select a from t1);
74327 */
74328 SQLCIPHER_PRIVATE char sqlcipher3ExprAffinity(Expr *pExpr){
74329   int op = pExpr->op;
74330   if( op==TK_SELECT ){
74331     assert( pExpr->flags&EP_xIsSelect );
74332     return sqlcipher3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
74333   }
74334 #ifndef SQLCIPHER_OMIT_CAST
74335   if( op==TK_CAST ){
74336     assert( !ExprHasProperty(pExpr, EP_IntValue) );
74337     return sqlcipher3AffinityType(pExpr->u.zToken);
74338   }
74339 #endif
74340   if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER) 
74341    && pExpr->pTab!=0
74342   ){
74343     /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
74344     ** a TK_COLUMN but was previously evaluated and cached in a register */
74345     int j = pExpr->iColumn;
74346     if( j<0 ) return SQLCIPHER_AFF_INTEGER;
74347     assert( pExpr->pTab && j<pExpr->pTab->nCol );
74348     return pExpr->pTab->aCol[j].affinity;
74349   }
74350   return pExpr->affinity;
74351 }
74352
74353 /*
74354 ** Set the explicit collating sequence for an expression to the
74355 ** collating sequence supplied in the second argument.
74356 */
74357 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprSetColl(Expr *pExpr, CollSeq *pColl){
74358   if( pExpr && pColl ){
74359     pExpr->pColl = pColl;
74360     pExpr->flags |= EP_ExpCollate;
74361   }
74362   return pExpr;
74363 }
74364
74365 /*
74366 ** Set the collating sequence for expression pExpr to be the collating
74367 ** sequence named by pToken.   Return a pointer to the revised expression.
74368 ** The collating sequence is marked as "explicit" using the EP_ExpCollate
74369 ** flag.  An explicit collating sequence will override implicit
74370 ** collating sequences.
74371 */
74372 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
74373   char *zColl = 0;            /* Dequoted name of collation sequence */
74374   CollSeq *pColl;
74375   sqlcipher3 *db = pParse->db;
74376   zColl = sqlcipher3NameFromToken(db, pCollName);
74377   pColl = sqlcipher3LocateCollSeq(pParse, zColl);
74378   sqlcipher3ExprSetColl(pExpr, pColl);
74379   sqlcipher3DbFree(db, zColl);
74380   return pExpr;
74381 }
74382
74383 /*
74384 ** Return the default collation sequence for the expression pExpr. If
74385 ** there is no default collation type, return 0.
74386 */
74387 SQLCIPHER_PRIVATE CollSeq *sqlcipher3ExprCollSeq(Parse *pParse, Expr *pExpr){
74388   CollSeq *pColl = 0;
74389   Expr *p = pExpr;
74390   while( p ){
74391     int op;
74392     pColl = p->pColl;
74393     if( pColl ) break;
74394     op = p->op;
74395     if( p->pTab!=0 && (
74396         op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
74397     )){
74398       /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
74399       ** a TK_COLUMN but was previously evaluated and cached in a register */
74400       const char *zColl;
74401       int j = p->iColumn;
74402       if( j>=0 ){
74403         sqlcipher3 *db = pParse->db;
74404         zColl = p->pTab->aCol[j].zColl;
74405         pColl = sqlcipher3FindCollSeq(db, ENC(db), zColl, 0);
74406         pExpr->pColl = pColl;
74407       }
74408       break;
74409     }
74410     if( op!=TK_CAST && op!=TK_UPLUS ){
74411       break;
74412     }
74413     p = p->pLeft;
74414   }
74415   if( sqlcipher3CheckCollSeq(pParse, pColl) ){ 
74416     pColl = 0;
74417   }
74418   return pColl;
74419 }
74420
74421 /*
74422 ** pExpr is an operand of a comparison operator.  aff2 is the
74423 ** type affinity of the other operand.  This routine returns the
74424 ** type affinity that should be used for the comparison operator.
74425 */
74426 SQLCIPHER_PRIVATE char sqlcipher3CompareAffinity(Expr *pExpr, char aff2){
74427   char aff1 = sqlcipher3ExprAffinity(pExpr);
74428   if( aff1 && aff2 ){
74429     /* Both sides of the comparison are columns. If one has numeric
74430     ** affinity, use that. Otherwise use no affinity.
74431     */
74432     if( sqlcipher3IsNumericAffinity(aff1) || sqlcipher3IsNumericAffinity(aff2) ){
74433       return SQLCIPHER_AFF_NUMERIC;
74434     }else{
74435       return SQLCIPHER_AFF_NONE;
74436     }
74437   }else if( !aff1 && !aff2 ){
74438     /* Neither side of the comparison is a column.  Compare the
74439     ** results directly.
74440     */
74441     return SQLCIPHER_AFF_NONE;
74442   }else{
74443     /* One side is a column, the other is not. Use the columns affinity. */
74444     assert( aff1==0 || aff2==0 );
74445     return (aff1 + aff2);
74446   }
74447 }
74448
74449 /*
74450 ** pExpr is a comparison operator.  Return the type affinity that should
74451 ** be applied to both operands prior to doing the comparison.
74452 */
74453 static char comparisonAffinity(Expr *pExpr){
74454   char aff;
74455   assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
74456           pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
74457           pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
74458   assert( pExpr->pLeft );
74459   aff = sqlcipher3ExprAffinity(pExpr->pLeft);
74460   if( pExpr->pRight ){
74461     aff = sqlcipher3CompareAffinity(pExpr->pRight, aff);
74462   }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
74463     aff = sqlcipher3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
74464   }else if( !aff ){
74465     aff = SQLCIPHER_AFF_NONE;
74466   }
74467   return aff;
74468 }
74469
74470 /*
74471 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
74472 ** idx_affinity is the affinity of an indexed column. Return true
74473 ** if the index with affinity idx_affinity may be used to implement
74474 ** the comparison in pExpr.
74475 */
74476 SQLCIPHER_PRIVATE int sqlcipher3IndexAffinityOk(Expr *pExpr, char idx_affinity){
74477   char aff = comparisonAffinity(pExpr);
74478   switch( aff ){
74479     case SQLCIPHER_AFF_NONE:
74480       return 1;
74481     case SQLCIPHER_AFF_TEXT:
74482       return idx_affinity==SQLCIPHER_AFF_TEXT;
74483     default:
74484       return sqlcipher3IsNumericAffinity(idx_affinity);
74485   }
74486 }
74487
74488 /*
74489 ** Return the P5 value that should be used for a binary comparison
74490 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
74491 */
74492 static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
74493   u8 aff = (char)sqlcipher3ExprAffinity(pExpr2);
74494   aff = (u8)sqlcipher3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
74495   return aff;
74496 }
74497
74498 /*
74499 ** Return a pointer to the collation sequence that should be used by
74500 ** a binary comparison operator comparing pLeft and pRight.
74501 **
74502 ** If the left hand expression has a collating sequence type, then it is
74503 ** used. Otherwise the collation sequence for the right hand expression
74504 ** is used, or the default (BINARY) if neither expression has a collating
74505 ** type.
74506 **
74507 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
74508 ** it is not considered.
74509 */
74510 SQLCIPHER_PRIVATE CollSeq *sqlcipher3BinaryCompareCollSeq(
74511   Parse *pParse, 
74512   Expr *pLeft, 
74513   Expr *pRight
74514 ){
74515   CollSeq *pColl;
74516   assert( pLeft );
74517   if( pLeft->flags & EP_ExpCollate ){
74518     assert( pLeft->pColl );
74519     pColl = pLeft->pColl;
74520   }else if( pRight && pRight->flags & EP_ExpCollate ){
74521     assert( pRight->pColl );
74522     pColl = pRight->pColl;
74523   }else{
74524     pColl = sqlcipher3ExprCollSeq(pParse, pLeft);
74525     if( !pColl ){
74526       pColl = sqlcipher3ExprCollSeq(pParse, pRight);
74527     }
74528   }
74529   return pColl;
74530 }
74531
74532 /*
74533 ** Generate code for a comparison operator.
74534 */
74535 static int codeCompare(
74536   Parse *pParse,    /* The parsing (and code generating) context */
74537   Expr *pLeft,      /* The left operand */
74538   Expr *pRight,     /* The right operand */
74539   int opcode,       /* The comparison opcode */
74540   int in1, int in2, /* Register holding operands */
74541   int dest,         /* Jump here if true.  */
74542   int jumpIfNull    /* If true, jump if either operand is NULL */
74543 ){
74544   int p5;
74545   int addr;
74546   CollSeq *p4;
74547
74548   p4 = sqlcipher3BinaryCompareCollSeq(pParse, pLeft, pRight);
74549   p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
74550   addr = sqlcipher3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
74551                            (void*)p4, P4_COLLSEQ);
74552   sqlcipher3VdbeChangeP5(pParse->pVdbe, (u8)p5);
74553   return addr;
74554 }
74555
74556 #if SQLCIPHER_MAX_EXPR_DEPTH>0
74557 /*
74558 ** Check that argument nHeight is less than or equal to the maximum
74559 ** expression depth allowed. If it is not, leave an error message in
74560 ** pParse.
74561 */
74562 SQLCIPHER_PRIVATE int sqlcipher3ExprCheckHeight(Parse *pParse, int nHeight){
74563   int rc = SQLCIPHER_OK;
74564   int mxHeight = pParse->db->aLimit[SQLCIPHER_LIMIT_EXPR_DEPTH];
74565   if( nHeight>mxHeight ){
74566     sqlcipher3ErrorMsg(pParse, 
74567        "Expression tree is too large (maximum depth %d)", mxHeight
74568     );
74569     rc = SQLCIPHER_ERROR;
74570   }
74571   return rc;
74572 }
74573
74574 /* The following three functions, heightOfExpr(), heightOfExprList()
74575 ** and heightOfSelect(), are used to determine the maximum height
74576 ** of any expression tree referenced by the structure passed as the
74577 ** first argument.
74578 **
74579 ** If this maximum height is greater than the current value pointed
74580 ** to by pnHeight, the second parameter, then set *pnHeight to that
74581 ** value.
74582 */
74583 static void heightOfExpr(Expr *p, int *pnHeight){
74584   if( p ){
74585     if( p->nHeight>*pnHeight ){
74586       *pnHeight = p->nHeight;
74587     }
74588   }
74589 }
74590 static void heightOfExprList(ExprList *p, int *pnHeight){
74591   if( p ){
74592     int i;
74593     for(i=0; i<p->nExpr; i++){
74594       heightOfExpr(p->a[i].pExpr, pnHeight);
74595     }
74596   }
74597 }
74598 static void heightOfSelect(Select *p, int *pnHeight){
74599   if( p ){
74600     heightOfExpr(p->pWhere, pnHeight);
74601     heightOfExpr(p->pHaving, pnHeight);
74602     heightOfExpr(p->pLimit, pnHeight);
74603     heightOfExpr(p->pOffset, pnHeight);
74604     heightOfExprList(p->pEList, pnHeight);
74605     heightOfExprList(p->pGroupBy, pnHeight);
74606     heightOfExprList(p->pOrderBy, pnHeight);
74607     heightOfSelect(p->pPrior, pnHeight);
74608   }
74609 }
74610
74611 /*
74612 ** Set the Expr.nHeight variable in the structure passed as an 
74613 ** argument. An expression with no children, Expr.pList or 
74614 ** Expr.pSelect member has a height of 1. Any other expression
74615 ** has a height equal to the maximum height of any other 
74616 ** referenced Expr plus one.
74617 */
74618 static void exprSetHeight(Expr *p){
74619   int nHeight = 0;
74620   heightOfExpr(p->pLeft, &nHeight);
74621   heightOfExpr(p->pRight, &nHeight);
74622   if( ExprHasProperty(p, EP_xIsSelect) ){
74623     heightOfSelect(p->x.pSelect, &nHeight);
74624   }else{
74625     heightOfExprList(p->x.pList, &nHeight);
74626   }
74627   p->nHeight = nHeight + 1;
74628 }
74629
74630 /*
74631 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
74632 ** the height is greater than the maximum allowed expression depth,
74633 ** leave an error in pParse.
74634 */
74635 SQLCIPHER_PRIVATE void sqlcipher3ExprSetHeight(Parse *pParse, Expr *p){
74636   exprSetHeight(p);
74637   sqlcipher3ExprCheckHeight(pParse, p->nHeight);
74638 }
74639
74640 /*
74641 ** Return the maximum height of any expression tree referenced
74642 ** by the select statement passed as an argument.
74643 */
74644 SQLCIPHER_PRIVATE int sqlcipher3SelectExprHeight(Select *p){
74645   int nHeight = 0;
74646   heightOfSelect(p, &nHeight);
74647   return nHeight;
74648 }
74649 #else
74650   #define exprSetHeight(y)
74651 #endif /* SQLCIPHER_MAX_EXPR_DEPTH>0 */
74652
74653 /*
74654 ** This routine is the core allocator for Expr nodes.
74655 **
74656 ** Construct a new expression node and return a pointer to it.  Memory
74657 ** for this node and for the pToken argument is a single allocation
74658 ** obtained from sqlcipher3DbMalloc().  The calling function
74659 ** is responsible for making sure the node eventually gets freed.
74660 **
74661 ** If dequote is true, then the token (if it exists) is dequoted.
74662 ** If dequote is false, no dequoting is performance.  The deQuote
74663 ** parameter is ignored if pToken is NULL or if the token does not
74664 ** appear to be quoted.  If the quotes were of the form "..." (double-quotes)
74665 ** then the EP_DblQuoted flag is set on the expression node.
74666 **
74667 ** Special case:  If op==TK_INTEGER and pToken points to a string that
74668 ** can be translated into a 32-bit integer, then the token is not
74669 ** stored in u.zToken.  Instead, the integer values is written
74670 ** into u.iValue and the EP_IntValue flag is set.  No extra storage
74671 ** is allocated to hold the integer text and the dequote flag is ignored.
74672 */
74673 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprAlloc(
74674   sqlcipher3 *db,            /* Handle for sqlcipher3DbMallocZero() (may be null) */
74675   int op,                 /* Expression opcode */
74676   const Token *pToken,    /* Token argument.  Might be NULL */
74677   int dequote             /* True to dequote */
74678 ){
74679   Expr *pNew;
74680   int nExtra = 0;
74681   int iValue = 0;
74682
74683   if( pToken ){
74684     if( op!=TK_INTEGER || pToken->z==0
74685           || sqlcipher3GetInt32(pToken->z, &iValue)==0 ){
74686       nExtra = pToken->n+1;
74687       assert( iValue>=0 );
74688     }
74689   }
74690   pNew = sqlcipher3DbMallocZero(db, sizeof(Expr)+nExtra);
74691   if( pNew ){
74692     pNew->op = (u8)op;
74693     pNew->iAgg = -1;
74694     if( pToken ){
74695       if( nExtra==0 ){
74696         pNew->flags |= EP_IntValue;
74697         pNew->u.iValue = iValue;
74698       }else{
74699         int c;
74700         pNew->u.zToken = (char*)&pNew[1];
74701         assert( pToken->z!=0 || pToken->n==0 );
74702         if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
74703         pNew->u.zToken[pToken->n] = 0;
74704         if( dequote && nExtra>=3 
74705              && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
74706           sqlcipher3Dequote(pNew->u.zToken);
74707           if( c=='"' ) pNew->flags |= EP_DblQuoted;
74708         }
74709       }
74710     }
74711 #if SQLCIPHER_MAX_EXPR_DEPTH>0
74712     pNew->nHeight = 1;
74713 #endif  
74714   }
74715   return pNew;
74716 }
74717
74718 /*
74719 ** Allocate a new expression node from a zero-terminated token that has
74720 ** already been dequoted.
74721 */
74722 SQLCIPHER_PRIVATE Expr *sqlcipher3Expr(
74723   sqlcipher3 *db,            /* Handle for sqlcipher3DbMallocZero() (may be null) */
74724   int op,                 /* Expression opcode */
74725   const char *zToken      /* Token argument.  Might be NULL */
74726 ){
74727   Token x;
74728   x.z = zToken;
74729   x.n = zToken ? sqlcipher3Strlen30(zToken) : 0;
74730   return sqlcipher3ExprAlloc(db, op, &x, 0);
74731 }
74732
74733 /*
74734 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
74735 **
74736 ** If pRoot==NULL that means that a memory allocation error has occurred.
74737 ** In that case, delete the subtrees pLeft and pRight.
74738 */
74739 SQLCIPHER_PRIVATE void sqlcipher3ExprAttachSubtrees(
74740   sqlcipher3 *db,
74741   Expr *pRoot,
74742   Expr *pLeft,
74743   Expr *pRight
74744 ){
74745   if( pRoot==0 ){
74746     assert( db->mallocFailed );
74747     sqlcipher3ExprDelete(db, pLeft);
74748     sqlcipher3ExprDelete(db, pRight);
74749   }else{
74750     if( pRight ){
74751       pRoot->pRight = pRight;
74752       if( pRight->flags & EP_ExpCollate ){
74753         pRoot->flags |= EP_ExpCollate;
74754         pRoot->pColl = pRight->pColl;
74755       }
74756     }
74757     if( pLeft ){
74758       pRoot->pLeft = pLeft;
74759       if( pLeft->flags & EP_ExpCollate ){
74760         pRoot->flags |= EP_ExpCollate;
74761         pRoot->pColl = pLeft->pColl;
74762       }
74763     }
74764     exprSetHeight(pRoot);
74765   }
74766 }
74767
74768 /*
74769 ** Allocate a Expr node which joins as many as two subtrees.
74770 **
74771 ** One or both of the subtrees can be NULL.  Return a pointer to the new
74772 ** Expr node.  Or, if an OOM error occurs, set pParse->db->mallocFailed,
74773 ** free the subtrees and return NULL.
74774 */
74775 SQLCIPHER_PRIVATE Expr *sqlcipher3PExpr(
74776   Parse *pParse,          /* Parsing context */
74777   int op,                 /* Expression opcode */
74778   Expr *pLeft,            /* Left operand */
74779   Expr *pRight,           /* Right operand */
74780   const Token *pToken     /* Argument token */
74781 ){
74782   Expr *p = sqlcipher3ExprAlloc(pParse->db, op, pToken, 1);
74783   sqlcipher3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
74784   if( p ) {
74785     sqlcipher3ExprCheckHeight(pParse, p->nHeight);
74786   }
74787   return p;
74788 }
74789
74790 /*
74791 ** Join two expressions using an AND operator.  If either expression is
74792 ** NULL, then just return the other expression.
74793 */
74794 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprAnd(sqlcipher3 *db, Expr *pLeft, Expr *pRight){
74795   if( pLeft==0 ){
74796     return pRight;
74797   }else if( pRight==0 ){
74798     return pLeft;
74799   }else{
74800     Expr *pNew = sqlcipher3ExprAlloc(db, TK_AND, 0, 0);
74801     sqlcipher3ExprAttachSubtrees(db, pNew, pLeft, pRight);
74802     return pNew;
74803   }
74804 }
74805
74806 /*
74807 ** Construct a new expression node for a function with multiple
74808 ** arguments.
74809 */
74810 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
74811   Expr *pNew;
74812   sqlcipher3 *db = pParse->db;
74813   assert( pToken );
74814   pNew = sqlcipher3ExprAlloc(db, TK_FUNCTION, pToken, 1);
74815   if( pNew==0 ){
74816     sqlcipher3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
74817     return 0;
74818   }
74819   pNew->x.pList = pList;
74820   assert( !ExprHasProperty(pNew, EP_xIsSelect) );
74821   sqlcipher3ExprSetHeight(pParse, pNew);
74822   return pNew;
74823 }
74824
74825 /*
74826 ** Assign a variable number to an expression that encodes a wildcard
74827 ** in the original SQL statement.  
74828 **
74829 ** Wildcards consisting of a single "?" are assigned the next sequential
74830 ** variable number.
74831 **
74832 ** Wildcards of the form "?nnn" are assigned the number "nnn".  We make
74833 ** sure "nnn" is not too be to avoid a denial of service attack when
74834 ** the SQL statement comes from an external source.
74835 **
74836 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
74837 ** as the previous instance of the same wildcard.  Or if this is the first
74838 ** instance of the wildcard, the next sequenial variable number is
74839 ** assigned.
74840 */
74841 SQLCIPHER_PRIVATE void sqlcipher3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
74842   sqlcipher3 *db = pParse->db;
74843   const char *z;
74844
74845   if( pExpr==0 ) return;
74846   assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
74847   z = pExpr->u.zToken;
74848   assert( z!=0 );
74849   assert( z[0]!=0 );
74850   if( z[1]==0 ){
74851     /* Wildcard of the form "?".  Assign the next variable number */
74852     assert( z[0]=='?' );
74853     pExpr->iColumn = (ynVar)(++pParse->nVar);
74854   }else{
74855     ynVar x = 0;
74856     u32 n = sqlcipher3Strlen30(z);
74857     if( z[0]=='?' ){
74858       /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
74859       ** use it as the variable number */
74860       i64 i;
74861       int bOk = 0==sqlcipher3Atoi64(&z[1], &i, n-1, SQLCIPHER_UTF8);
74862       pExpr->iColumn = x = (ynVar)i;
74863       testcase( i==0 );
74864       testcase( i==1 );
74865       testcase( i==db->aLimit[SQLCIPHER_LIMIT_VARIABLE_NUMBER]-1 );
74866       testcase( i==db->aLimit[SQLCIPHER_LIMIT_VARIABLE_NUMBER] );
74867       if( bOk==0 || i<1 || i>db->aLimit[SQLCIPHER_LIMIT_VARIABLE_NUMBER] ){
74868         sqlcipher3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
74869             db->aLimit[SQLCIPHER_LIMIT_VARIABLE_NUMBER]);
74870         x = 0;
74871       }
74872       if( i>pParse->nVar ){
74873         pParse->nVar = (int)i;
74874       }
74875     }else{
74876       /* Wildcards like ":aaa", "$aaa" or "@aaa".  Reuse the same variable
74877       ** number as the prior appearance of the same name, or if the name
74878       ** has never appeared before, reuse the same variable number
74879       */
74880       ynVar i;
74881       for(i=0; i<pParse->nzVar; i++){
74882         if( pParse->azVar[i] && memcmp(pParse->azVar[i],z,n+1)==0 ){
74883           pExpr->iColumn = x = (ynVar)i+1;
74884           break;
74885         }
74886       }
74887       if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
74888     }
74889     if( x>0 ){
74890       if( x>pParse->nzVar ){
74891         char **a;
74892         a = sqlcipher3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
74893         if( a==0 ) return;  /* Error reported through db->mallocFailed */
74894         pParse->azVar = a;
74895         memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
74896         pParse->nzVar = x;
74897       }
74898       if( z[0]!='?' || pParse->azVar[x-1]==0 ){
74899         sqlcipher3DbFree(db, pParse->azVar[x-1]);
74900         pParse->azVar[x-1] = sqlcipher3DbStrNDup(db, z, n);
74901       }
74902     }
74903   } 
74904   if( !pParse->nErr && pParse->nVar>db->aLimit[SQLCIPHER_LIMIT_VARIABLE_NUMBER] ){
74905     sqlcipher3ErrorMsg(pParse, "too many SQL variables");
74906   }
74907 }
74908
74909 /*
74910 ** Recursively delete an expression tree.
74911 */
74912 SQLCIPHER_PRIVATE void sqlcipher3ExprDelete(sqlcipher3 *db, Expr *p){
74913   if( p==0 ) return;
74914   /* Sanity check: Assert that the IntValue is non-negative if it exists */
74915   assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
74916   if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
74917     sqlcipher3ExprDelete(db, p->pLeft);
74918     sqlcipher3ExprDelete(db, p->pRight);
74919     if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
74920       sqlcipher3DbFree(db, p->u.zToken);
74921     }
74922     if( ExprHasProperty(p, EP_xIsSelect) ){
74923       sqlcipher3SelectDelete(db, p->x.pSelect);
74924     }else{
74925       sqlcipher3ExprListDelete(db, p->x.pList);
74926     }
74927   }
74928   if( !ExprHasProperty(p, EP_Static) ){
74929     sqlcipher3DbFree(db, p);
74930   }
74931 }
74932
74933 /*
74934 ** Return the number of bytes allocated for the expression structure 
74935 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
74936 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
74937 */
74938 static int exprStructSize(Expr *p){
74939   if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
74940   if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
74941   return EXPR_FULLSIZE;
74942 }
74943
74944 /*
74945 ** The dupedExpr*Size() routines each return the number of bytes required
74946 ** to store a copy of an expression or expression tree.  They differ in
74947 ** how much of the tree is measured.
74948 **
74949 **     dupedExprStructSize()     Size of only the Expr structure 
74950 **     dupedExprNodeSize()       Size of Expr + space for token
74951 **     dupedExprSize()           Expr + token + subtree components
74952 **
74953 ***************************************************************************
74954 **
74955 ** The dupedExprStructSize() function returns two values OR-ed together:  
74956 ** (1) the space required for a copy of the Expr structure only and 
74957 ** (2) the EP_xxx flags that indicate what the structure size should be.
74958 ** The return values is always one of:
74959 **
74960 **      EXPR_FULLSIZE
74961 **      EXPR_REDUCEDSIZE   | EP_Reduced
74962 **      EXPR_TOKENONLYSIZE | EP_TokenOnly
74963 **
74964 ** The size of the structure can be found by masking the return value
74965 ** of this routine with 0xfff.  The flags can be found by masking the
74966 ** return value with EP_Reduced|EP_TokenOnly.
74967 **
74968 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
74969 ** (unreduced) Expr objects as they or originally constructed by the parser.
74970 ** During expression analysis, extra information is computed and moved into
74971 ** later parts of teh Expr object and that extra information might get chopped
74972 ** off if the expression is reduced.  Note also that it does not work to
74973 ** make a EXPRDUP_REDUCE copy of a reduced expression.  It is only legal
74974 ** to reduce a pristine expression tree from the parser.  The implementation
74975 ** of dupedExprStructSize() contain multiple assert() statements that attempt
74976 ** to enforce this constraint.
74977 */
74978 static int dupedExprStructSize(Expr *p, int flags){
74979   int nSize;
74980   assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
74981   if( 0==(flags&EXPRDUP_REDUCE) ){
74982     nSize = EXPR_FULLSIZE;
74983   }else{
74984     assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
74985     assert( !ExprHasProperty(p, EP_FromJoin) ); 
74986     assert( (p->flags2 & EP2_MallocedToken)==0 );
74987     assert( (p->flags2 & EP2_Irreducible)==0 );
74988     if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
74989       nSize = EXPR_REDUCEDSIZE | EP_Reduced;
74990     }else{
74991       nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
74992     }
74993   }
74994   return nSize;
74995 }
74996
74997 /*
74998 ** This function returns the space in bytes required to store the copy 
74999 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
75000 ** string is defined.)
75001 */
75002 static int dupedExprNodeSize(Expr *p, int flags){
75003   int nByte = dupedExprStructSize(p, flags) & 0xfff;
75004   if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
75005     nByte += sqlcipher3Strlen30(p->u.zToken)+1;
75006   }
75007   return ROUND8(nByte);
75008 }
75009
75010 /*
75011 ** Return the number of bytes required to create a duplicate of the 
75012 ** expression passed as the first argument. The second argument is a
75013 ** mask containing EXPRDUP_XXX flags.
75014 **
75015 ** The value returned includes space to create a copy of the Expr struct
75016 ** itself and the buffer referred to by Expr.u.zToken, if any.
75017 **
75018 ** If the EXPRDUP_REDUCE flag is set, then the return value includes 
75019 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft 
75020 ** and Expr.pRight variables (but not for any structures pointed to or 
75021 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
75022 */
75023 static int dupedExprSize(Expr *p, int flags){
75024   int nByte = 0;
75025   if( p ){
75026     nByte = dupedExprNodeSize(p, flags);
75027     if( flags&EXPRDUP_REDUCE ){
75028       nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
75029     }
75030   }
75031   return nByte;
75032 }
75033
75034 /*
75035 ** This function is similar to sqlcipher3ExprDup(), except that if pzBuffer 
75036 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough 
75037 ** to store the copy of expression p, the copies of p->u.zToken
75038 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
75039 ** if any. Before returning, *pzBuffer is set to the first byte passed the
75040 ** portion of the buffer copied into by this function.
75041 */
75042 static Expr *exprDup(sqlcipher3 *db, Expr *p, int flags, u8 **pzBuffer){
75043   Expr *pNew = 0;                      /* Value to return */
75044   if( p ){
75045     const int isReduced = (flags&EXPRDUP_REDUCE);
75046     u8 *zAlloc;
75047     u32 staticFlag = 0;
75048
75049     assert( pzBuffer==0 || isReduced );
75050
75051     /* Figure out where to write the new Expr structure. */
75052     if( pzBuffer ){
75053       zAlloc = *pzBuffer;
75054       staticFlag = EP_Static;
75055     }else{
75056       zAlloc = sqlcipher3DbMallocRaw(db, dupedExprSize(p, flags));
75057     }
75058     pNew = (Expr *)zAlloc;
75059
75060     if( pNew ){
75061       /* Set nNewSize to the size allocated for the structure pointed to
75062       ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
75063       ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
75064       ** by the copy of the p->u.zToken string (if any).
75065       */
75066       const unsigned nStructSize = dupedExprStructSize(p, flags);
75067       const int nNewSize = nStructSize & 0xfff;
75068       int nToken;
75069       if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
75070         nToken = sqlcipher3Strlen30(p->u.zToken) + 1;
75071       }else{
75072         nToken = 0;
75073       }
75074       if( isReduced ){
75075         assert( ExprHasProperty(p, EP_Reduced)==0 );
75076         memcpy(zAlloc, p, nNewSize);
75077       }else{
75078         int nSize = exprStructSize(p);
75079         memcpy(zAlloc, p, nSize);
75080         memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
75081       }
75082
75083       /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
75084       pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
75085       pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
75086       pNew->flags |= staticFlag;
75087
75088       /* Copy the p->u.zToken string, if any. */
75089       if( nToken ){
75090         char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
75091         memcpy(zToken, p->u.zToken, nToken);
75092       }
75093
75094       if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
75095         /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
75096         if( ExprHasProperty(p, EP_xIsSelect) ){
75097           pNew->x.pSelect = sqlcipher3SelectDup(db, p->x.pSelect, isReduced);
75098         }else{
75099           pNew->x.pList = sqlcipher3ExprListDup(db, p->x.pList, isReduced);
75100         }
75101       }
75102
75103       /* Fill in pNew->pLeft and pNew->pRight. */
75104       if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
75105         zAlloc += dupedExprNodeSize(p, flags);
75106         if( ExprHasProperty(pNew, EP_Reduced) ){
75107           pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
75108           pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
75109         }
75110         if( pzBuffer ){
75111           *pzBuffer = zAlloc;
75112         }
75113       }else{
75114         pNew->flags2 = 0;
75115         if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
75116           pNew->pLeft = sqlcipher3ExprDup(db, p->pLeft, 0);
75117           pNew->pRight = sqlcipher3ExprDup(db, p->pRight, 0);
75118         }
75119       }
75120
75121     }
75122   }
75123   return pNew;
75124 }
75125
75126 /*
75127 ** The following group of routines make deep copies of expressions,
75128 ** expression lists, ID lists, and select statements.  The copies can
75129 ** be deleted (by being passed to their respective ...Delete() routines)
75130 ** without effecting the originals.
75131 **
75132 ** The expression list, ID, and source lists return by sqlcipher3ExprListDup(),
75133 ** sqlcipher3IdListDup(), and sqlcipher3SrcListDup() can not be further expanded 
75134 ** by subsequent calls to sqlcipher*ListAppend() routines.
75135 **
75136 ** Any tables that the SrcList might point to are not duplicated.
75137 **
75138 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
75139 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
75140 ** truncated version of the usual Expr structure that will be stored as
75141 ** part of the in-memory representation of the database schema.
75142 */
75143 SQLCIPHER_PRIVATE Expr *sqlcipher3ExprDup(sqlcipher3 *db, Expr *p, int flags){
75144   return exprDup(db, p, flags, 0);
75145 }
75146 SQLCIPHER_PRIVATE ExprList *sqlcipher3ExprListDup(sqlcipher3 *db, ExprList *p, int flags){
75147   ExprList *pNew;
75148   struct ExprList_item *pItem, *pOldItem;
75149   int i;
75150   if( p==0 ) return 0;
75151   pNew = sqlcipher3DbMallocRaw(db, sizeof(*pNew) );
75152   if( pNew==0 ) return 0;
75153   pNew->iECursor = 0;
75154   pNew->nExpr = pNew->nAlloc = p->nExpr;
75155   pNew->a = pItem = sqlcipher3DbMallocRaw(db,  p->nExpr*sizeof(p->a[0]) );
75156   if( pItem==0 ){
75157     sqlcipher3DbFree(db, pNew);
75158     return 0;
75159   } 
75160   pOldItem = p->a;
75161   for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
75162     Expr *pOldExpr = pOldItem->pExpr;
75163     pItem->pExpr = sqlcipher3ExprDup(db, pOldExpr, flags);
75164     pItem->zName = sqlcipher3DbStrDup(db, pOldItem->zName);
75165     pItem->zSpan = sqlcipher3DbStrDup(db, pOldItem->zSpan);
75166     pItem->sortOrder = pOldItem->sortOrder;
75167     pItem->done = 0;
75168     pItem->iCol = pOldItem->iCol;
75169     pItem->iAlias = pOldItem->iAlias;
75170   }
75171   return pNew;
75172 }
75173
75174 /*
75175 ** If cursors, triggers, views and subqueries are all omitted from
75176 ** the build, then none of the following routines, except for 
75177 ** sqlcipher3SelectDup(), can be called. sqlcipher3SelectDup() is sometimes
75178 ** called with a NULL argument.
75179 */
75180 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_TRIGGER) \
75181  || !defined(SQLCIPHER_OMIT_SUBQUERY)
75182 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListDup(sqlcipher3 *db, SrcList *p, int flags){
75183   SrcList *pNew;
75184   int i;
75185   int nByte;
75186   if( p==0 ) return 0;
75187   nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
75188   pNew = sqlcipher3DbMallocRaw(db, nByte );
75189   if( pNew==0 ) return 0;
75190   pNew->nSrc = pNew->nAlloc = p->nSrc;
75191   for(i=0; i<p->nSrc; i++){
75192     struct SrcList_item *pNewItem = &pNew->a[i];
75193     struct SrcList_item *pOldItem = &p->a[i];
75194     Table *pTab;
75195     pNewItem->zDatabase = sqlcipher3DbStrDup(db, pOldItem->zDatabase);
75196     pNewItem->zName = sqlcipher3DbStrDup(db, pOldItem->zName);
75197     pNewItem->zAlias = sqlcipher3DbStrDup(db, pOldItem->zAlias);
75198     pNewItem->jointype = pOldItem->jointype;
75199     pNewItem->iCursor = pOldItem->iCursor;
75200     pNewItem->addrFillSub = pOldItem->addrFillSub;
75201     pNewItem->regReturn = pOldItem->regReturn;
75202     pNewItem->isCorrelated = pOldItem->isCorrelated;
75203     pNewItem->zIndex = sqlcipher3DbStrDup(db, pOldItem->zIndex);
75204     pNewItem->notIndexed = pOldItem->notIndexed;
75205     pNewItem->pIndex = pOldItem->pIndex;
75206     pTab = pNewItem->pTab = pOldItem->pTab;
75207     if( pTab ){
75208       pTab->nRef++;
75209     }
75210     pNewItem->pSelect = sqlcipher3SelectDup(db, pOldItem->pSelect, flags);
75211     pNewItem->pOn = sqlcipher3ExprDup(db, pOldItem->pOn, flags);
75212     pNewItem->pUsing = sqlcipher3IdListDup(db, pOldItem->pUsing);
75213     pNewItem->colUsed = pOldItem->colUsed;
75214   }
75215   return pNew;
75216 }
75217 SQLCIPHER_PRIVATE IdList *sqlcipher3IdListDup(sqlcipher3 *db, IdList *p){
75218   IdList *pNew;
75219   int i;
75220   if( p==0 ) return 0;
75221   pNew = sqlcipher3DbMallocRaw(db, sizeof(*pNew) );
75222   if( pNew==0 ) return 0;
75223   pNew->nId = pNew->nAlloc = p->nId;
75224   pNew->a = sqlcipher3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
75225   if( pNew->a==0 ){
75226     sqlcipher3DbFree(db, pNew);
75227     return 0;
75228   }
75229   for(i=0; i<p->nId; i++){
75230     struct IdList_item *pNewItem = &pNew->a[i];
75231     struct IdList_item *pOldItem = &p->a[i];
75232     pNewItem->zName = sqlcipher3DbStrDup(db, pOldItem->zName);
75233     pNewItem->idx = pOldItem->idx;
75234   }
75235   return pNew;
75236 }
75237 SQLCIPHER_PRIVATE Select *sqlcipher3SelectDup(sqlcipher3 *db, Select *p, int flags){
75238   Select *pNew;
75239   if( p==0 ) return 0;
75240   pNew = sqlcipher3DbMallocRaw(db, sizeof(*p) );
75241   if( pNew==0 ) return 0;
75242   pNew->pEList = sqlcipher3ExprListDup(db, p->pEList, flags);
75243   pNew->pSrc = sqlcipher3SrcListDup(db, p->pSrc, flags);
75244   pNew->pWhere = sqlcipher3ExprDup(db, p->pWhere, flags);
75245   pNew->pGroupBy = sqlcipher3ExprListDup(db, p->pGroupBy, flags);
75246   pNew->pHaving = sqlcipher3ExprDup(db, p->pHaving, flags);
75247   pNew->pOrderBy = sqlcipher3ExprListDup(db, p->pOrderBy, flags);
75248   pNew->op = p->op;
75249   pNew->pPrior = sqlcipher3SelectDup(db, p->pPrior, flags);
75250   pNew->pLimit = sqlcipher3ExprDup(db, p->pLimit, flags);
75251   pNew->pOffset = sqlcipher3ExprDup(db, p->pOffset, flags);
75252   pNew->iLimit = 0;
75253   pNew->iOffset = 0;
75254   pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
75255   pNew->pRightmost = 0;
75256   pNew->addrOpenEphm[0] = -1;
75257   pNew->addrOpenEphm[1] = -1;
75258   pNew->addrOpenEphm[2] = -1;
75259   return pNew;
75260 }
75261 #else
75262 SQLCIPHER_PRIVATE Select *sqlcipher3SelectDup(sqlcipher3 *db, Select *p, int flags){
75263   assert( p==0 );
75264   return 0;
75265 }
75266 #endif
75267
75268
75269 /*
75270 ** Add a new element to the end of an expression list.  If pList is
75271 ** initially NULL, then create a new expression list.
75272 **
75273 ** If a memory allocation error occurs, the entire list is freed and
75274 ** NULL is returned.  If non-NULL is returned, then it is guaranteed
75275 ** that the new entry was successfully appended.
75276 */
75277 SQLCIPHER_PRIVATE ExprList *sqlcipher3ExprListAppend(
75278   Parse *pParse,          /* Parsing context */
75279   ExprList *pList,        /* List to which to append. Might be NULL */
75280   Expr *pExpr             /* Expression to be appended. Might be NULL */
75281 ){
75282   sqlcipher3 *db = pParse->db;
75283   if( pList==0 ){
75284     pList = sqlcipher3DbMallocZero(db, sizeof(ExprList) );
75285     if( pList==0 ){
75286       goto no_mem;
75287     }
75288     assert( pList->nAlloc==0 );
75289   }
75290   if( pList->nAlloc<=pList->nExpr ){
75291     struct ExprList_item *a;
75292     int n = pList->nAlloc*2 + 4;
75293     a = sqlcipher3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
75294     if( a==0 ){
75295       goto no_mem;
75296     }
75297     pList->a = a;
75298     pList->nAlloc = sqlcipher3DbMallocSize(db, a)/sizeof(a[0]);
75299   }
75300   assert( pList->a!=0 );
75301   if( 1 ){
75302     struct ExprList_item *pItem = &pList->a[pList->nExpr++];
75303     memset(pItem, 0, sizeof(*pItem));
75304     pItem->pExpr = pExpr;
75305   }
75306   return pList;
75307
75308 no_mem:     
75309   /* Avoid leaking memory if malloc has failed. */
75310   sqlcipher3ExprDelete(db, pExpr);
75311   sqlcipher3ExprListDelete(db, pList);
75312   return 0;
75313 }
75314
75315 /*
75316 ** Set the ExprList.a[].zName element of the most recently added item
75317 ** on the expression list.
75318 **
75319 ** pList might be NULL following an OOM error.  But pName should never be
75320 ** NULL.  If a memory allocation fails, the pParse->db->mallocFailed flag
75321 ** is set.
75322 */
75323 SQLCIPHER_PRIVATE void sqlcipher3ExprListSetName(
75324   Parse *pParse,          /* Parsing context */
75325   ExprList *pList,        /* List to which to add the span. */
75326   Token *pName,           /* Name to be added */
75327   int dequote             /* True to cause the name to be dequoted */
75328 ){
75329   assert( pList!=0 || pParse->db->mallocFailed!=0 );
75330   if( pList ){
75331     struct ExprList_item *pItem;
75332     assert( pList->nExpr>0 );
75333     pItem = &pList->a[pList->nExpr-1];
75334     assert( pItem->zName==0 );
75335     pItem->zName = sqlcipher3DbStrNDup(pParse->db, pName->z, pName->n);
75336     if( dequote && pItem->zName ) sqlcipher3Dequote(pItem->zName);
75337   }
75338 }
75339
75340 /*
75341 ** Set the ExprList.a[].zSpan element of the most recently added item
75342 ** on the expression list.
75343 **
75344 ** pList might be NULL following an OOM error.  But pSpan should never be
75345 ** NULL.  If a memory allocation fails, the pParse->db->mallocFailed flag
75346 ** is set.
75347 */
75348 SQLCIPHER_PRIVATE void sqlcipher3ExprListSetSpan(
75349   Parse *pParse,          /* Parsing context */
75350   ExprList *pList,        /* List to which to add the span. */
75351   ExprSpan *pSpan         /* The span to be added */
75352 ){
75353   sqlcipher3 *db = pParse->db;
75354   assert( pList!=0 || db->mallocFailed!=0 );
75355   if( pList ){
75356     struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
75357     assert( pList->nExpr>0 );
75358     assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
75359     sqlcipher3DbFree(db, pItem->zSpan);
75360     pItem->zSpan = sqlcipher3DbStrNDup(db, (char*)pSpan->zStart,
75361                                     (int)(pSpan->zEnd - pSpan->zStart));
75362   }
75363 }
75364
75365 /*
75366 ** If the expression list pEList contains more than iLimit elements,
75367 ** leave an error message in pParse.
75368 */
75369 SQLCIPHER_PRIVATE void sqlcipher3ExprListCheckLength(
75370   Parse *pParse,
75371   ExprList *pEList,
75372   const char *zObject
75373 ){
75374   int mx = pParse->db->aLimit[SQLCIPHER_LIMIT_COLUMN];
75375   testcase( pEList && pEList->nExpr==mx );
75376   testcase( pEList && pEList->nExpr==mx+1 );
75377   if( pEList && pEList->nExpr>mx ){
75378     sqlcipher3ErrorMsg(pParse, "too many columns in %s", zObject);
75379   }
75380 }
75381
75382 /*
75383 ** Delete an entire expression list.
75384 */
75385 SQLCIPHER_PRIVATE void sqlcipher3ExprListDelete(sqlcipher3 *db, ExprList *pList){
75386   int i;
75387   struct ExprList_item *pItem;
75388   if( pList==0 ) return;
75389   assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
75390   assert( pList->nExpr<=pList->nAlloc );
75391   for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
75392     sqlcipher3ExprDelete(db, pItem->pExpr);
75393     sqlcipher3DbFree(db, pItem->zName);
75394     sqlcipher3DbFree(db, pItem->zSpan);
75395   }
75396   sqlcipher3DbFree(db, pList->a);
75397   sqlcipher3DbFree(db, pList);
75398 }
75399
75400 /*
75401 ** These routines are Walker callbacks.  Walker.u.pi is a pointer
75402 ** to an integer.  These routines are checking an expression to see
75403 ** if it is a constant.  Set *Walker.u.pi to 0 if the expression is
75404 ** not constant.
75405 **
75406 ** These callback routines are used to implement the following:
75407 **
75408 **     sqlcipher3ExprIsConstant()
75409 **     sqlcipher3ExprIsConstantNotJoin()
75410 **     sqlcipher3ExprIsConstantOrFunction()
75411 **
75412 */
75413 static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
75414
75415   /* If pWalker->u.i is 3 then any term of the expression that comes from
75416   ** the ON or USING clauses of a join disqualifies the expression
75417   ** from being considered constant. */
75418   if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
75419     pWalker->u.i = 0;
75420     return WRC_Abort;
75421   }
75422
75423   switch( pExpr->op ){
75424     /* Consider functions to be constant if all their arguments are constant
75425     ** and pWalker->u.i==2 */
75426     case TK_FUNCTION:
75427       if( pWalker->u.i==2 ) return 0;
75428       /* Fall through */
75429     case TK_ID:
75430     case TK_COLUMN:
75431     case TK_AGG_FUNCTION:
75432     case TK_AGG_COLUMN:
75433       testcase( pExpr->op==TK_ID );
75434       testcase( pExpr->op==TK_COLUMN );
75435       testcase( pExpr->op==TK_AGG_FUNCTION );
75436       testcase( pExpr->op==TK_AGG_COLUMN );
75437       pWalker->u.i = 0;
75438       return WRC_Abort;
75439     default:
75440       testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
75441       testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
75442       return WRC_Continue;
75443   }
75444 }
75445 static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
75446   UNUSED_PARAMETER(NotUsed);
75447   pWalker->u.i = 0;
75448   return WRC_Abort;
75449 }
75450 static int exprIsConst(Expr *p, int initFlag){
75451   Walker w;
75452   w.u.i = initFlag;
75453   w.xExprCallback = exprNodeIsConstant;
75454   w.xSelectCallback = selectNodeIsConstant;
75455   sqlcipher3WalkExpr(&w, p);
75456   return w.u.i;
75457 }
75458
75459 /*
75460 ** Walk an expression tree.  Return 1 if the expression is constant
75461 ** and 0 if it involves variables or function calls.
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 SQLCIPHER_PRIVATE int sqlcipher3ExprIsConstant(Expr *p){
75468   return exprIsConst(p, 1);
75469 }
75470
75471 /*
75472 ** Walk an expression tree.  Return 1 if the expression is constant
75473 ** that does no originate from the ON or USING clauses of a join.
75474 ** Return 0 if it involves variables or function calls or terms from
75475 ** an ON or USING clause.
75476 */
75477 SQLCIPHER_PRIVATE int sqlcipher3ExprIsConstantNotJoin(Expr *p){
75478   return exprIsConst(p, 3);
75479 }
75480
75481 /*
75482 ** Walk an expression tree.  Return 1 if the expression is constant
75483 ** or a function call with constant arguments.  Return and 0 if there
75484 ** are any variables.
75485 **
75486 ** For the purposes of this function, a double-quoted string (ex: "abc")
75487 ** is considered a variable but a single-quoted string (ex: 'abc') is
75488 ** a constant.
75489 */
75490 SQLCIPHER_PRIVATE int sqlcipher3ExprIsConstantOrFunction(Expr *p){
75491   return exprIsConst(p, 2);
75492 }
75493
75494 /*
75495 ** If the expression p codes a constant integer that is small enough
75496 ** to fit in a 32-bit integer, return 1 and put the value of the integer
75497 ** in *pValue.  If the expression is not an integer or if it is too big
75498 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
75499 */
75500 SQLCIPHER_PRIVATE int sqlcipher3ExprIsInteger(Expr *p, int *pValue){
75501   int rc = 0;
75502
75503   /* If an expression is an integer literal that fits in a signed 32-bit
75504   ** integer, then the EP_IntValue flag will have already been set */
75505   assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
75506            || sqlcipher3GetInt32(p->u.zToken, &rc)==0 );
75507
75508   if( p->flags & EP_IntValue ){
75509     *pValue = p->u.iValue;
75510     return 1;
75511   }
75512   switch( p->op ){
75513     case TK_UPLUS: {
75514       rc = sqlcipher3ExprIsInteger(p->pLeft, pValue);
75515       break;
75516     }
75517     case TK_UMINUS: {
75518       int v;
75519       if( sqlcipher3ExprIsInteger(p->pLeft, &v) ){
75520         *pValue = -v;
75521         rc = 1;
75522       }
75523       break;
75524     }
75525     default: break;
75526   }
75527   return rc;
75528 }
75529
75530 /*
75531 ** Return FALSE if there is no chance that the expression can be NULL.
75532 **
75533 ** If the expression might be NULL or if the expression is too complex
75534 ** to tell return TRUE.  
75535 **
75536 ** This routine is used as an optimization, to skip OP_IsNull opcodes
75537 ** when we know that a value cannot be NULL.  Hence, a false positive
75538 ** (returning TRUE when in fact the expression can never be NULL) might
75539 ** be a small performance hit but is otherwise harmless.  On the other
75540 ** hand, a false negative (returning FALSE when the result could be NULL)
75541 ** will likely result in an incorrect answer.  So when in doubt, return
75542 ** TRUE.
75543 */
75544 SQLCIPHER_PRIVATE int sqlcipher3ExprCanBeNull(const Expr *p){
75545   u8 op;
75546   while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
75547   op = p->op;
75548   if( op==TK_REGISTER ) op = p->op2;
75549   switch( op ){
75550     case TK_INTEGER:
75551     case TK_STRING:
75552     case TK_FLOAT:
75553     case TK_BLOB:
75554       return 0;
75555     default:
75556       return 1;
75557   }
75558 }
75559
75560 /*
75561 ** Generate an OP_IsNull instruction that tests register iReg and jumps
75562 ** to location iDest if the value in iReg is NULL.  The value in iReg 
75563 ** was computed by pExpr.  If we can look at pExpr at compile-time and
75564 ** determine that it can never generate a NULL, then the OP_IsNull operation
75565 ** can be omitted.
75566 */
75567 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeIsNullJump(
75568   Vdbe *v,            /* The VDBE under construction */
75569   const Expr *pExpr,  /* Only generate OP_IsNull if this expr can be NULL */
75570   int iReg,           /* Test the value in this register for NULL */
75571   int iDest           /* Jump here if the value is null */
75572 ){
75573   if( sqlcipher3ExprCanBeNull(pExpr) ){
75574     sqlcipher3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
75575   }
75576 }
75577
75578 /*
75579 ** Return TRUE if the given expression is a constant which would be
75580 ** unchanged by OP_Affinity with the affinity given in the second
75581 ** argument.
75582 **
75583 ** This routine is used to determine if the OP_Affinity operation
75584 ** can be omitted.  When in doubt return FALSE.  A false negative
75585 ** is harmless.  A false positive, however, can result in the wrong
75586 ** answer.
75587 */
75588 SQLCIPHER_PRIVATE int sqlcipher3ExprNeedsNoAffinityChange(const Expr *p, char aff){
75589   u8 op;
75590   if( aff==SQLCIPHER_AFF_NONE ) return 1;
75591   while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
75592   op = p->op;
75593   if( op==TK_REGISTER ) op = p->op2;
75594   switch( op ){
75595     case TK_INTEGER: {
75596       return aff==SQLCIPHER_AFF_INTEGER || aff==SQLCIPHER_AFF_NUMERIC;
75597     }
75598     case TK_FLOAT: {
75599       return aff==SQLCIPHER_AFF_REAL || aff==SQLCIPHER_AFF_NUMERIC;
75600     }
75601     case TK_STRING: {
75602       return aff==SQLCIPHER_AFF_TEXT;
75603     }
75604     case TK_BLOB: {
75605       return 1;
75606     }
75607     case TK_COLUMN: {
75608       assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
75609       return p->iColumn<0
75610           && (aff==SQLCIPHER_AFF_INTEGER || aff==SQLCIPHER_AFF_NUMERIC);
75611     }
75612     default: {
75613       return 0;
75614     }
75615   }
75616 }
75617
75618 /*
75619 ** Return TRUE if the given string is a row-id column name.
75620 */
75621 SQLCIPHER_PRIVATE int sqlcipher3IsRowid(const char *z){
75622   if( sqlcipher3StrICmp(z, "_ROWID_")==0 ) return 1;
75623   if( sqlcipher3StrICmp(z, "ROWID")==0 ) return 1;
75624   if( sqlcipher3StrICmp(z, "OID")==0 ) return 1;
75625   return 0;
75626 }
75627
75628 /*
75629 ** Return true if we are able to the IN operator optimization on a
75630 ** query of the form
75631 **
75632 **       x IN (SELECT ...)
75633 **
75634 ** Where the SELECT... clause is as specified by the parameter to this
75635 ** routine.
75636 **
75637 ** The Select object passed in has already been preprocessed and no
75638 ** errors have been found.
75639 */
75640 #ifndef SQLCIPHER_OMIT_SUBQUERY
75641 static int isCandidateForInOpt(Select *p){
75642   SrcList *pSrc;
75643   ExprList *pEList;
75644   Table *pTab;
75645   if( p==0 ) return 0;                   /* right-hand side of IN is SELECT */
75646   if( p->pPrior ) return 0;              /* Not a compound SELECT */
75647   if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
75648     testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
75649     testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
75650     return 0; /* No DISTINCT keyword and no aggregate functions */
75651   }
75652   assert( p->pGroupBy==0 );              /* Has no GROUP BY clause */
75653   if( p->pLimit ) return 0;              /* Has no LIMIT clause */
75654   assert( p->pOffset==0 );               /* No LIMIT means no OFFSET */
75655   if( p->pWhere ) return 0;              /* Has no WHERE clause */
75656   pSrc = p->pSrc;
75657   assert( pSrc!=0 );
75658   if( pSrc->nSrc!=1 ) return 0;          /* Single term in FROM clause */
75659   if( pSrc->a[0].pSelect ) return 0;     /* FROM is not a subquery or view */
75660   pTab = pSrc->a[0].pTab;
75661   if( NEVER(pTab==0) ) return 0;
75662   assert( pTab->pSelect==0 );            /* FROM clause is not a view */
75663   if( IsVirtual(pTab) ) return 0;        /* FROM clause not a virtual table */
75664   pEList = p->pEList;
75665   if( pEList->nExpr!=1 ) return 0;       /* One column in the result set */
75666   if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
75667   return 1;
75668 }
75669 #endif /* SQLCIPHER_OMIT_SUBQUERY */
75670
75671 /*
75672 ** This function is used by the implementation of the IN (...) operator.
75673 ** It's job is to find or create a b-tree structure that may be used
75674 ** either to test for membership of the (...) set or to iterate through
75675 ** its members, skipping duplicates.
75676 **
75677 ** The index of the cursor opened on the b-tree (database table, database index 
75678 ** or ephermal table) is stored in pX->iTable before this function returns.
75679 ** The returned value of this function indicates the b-tree type, as follows:
75680 **
75681 **   IN_INDEX_ROWID - The cursor was opened on a database table.
75682 **   IN_INDEX_INDEX - The cursor was opened on a database index.
75683 **   IN_INDEX_EPH -   The cursor was opened on a specially created and
75684 **                    populated epheremal table.
75685 **
75686 ** An existing b-tree may only be used if the SELECT is of the simple
75687 ** form:
75688 **
75689 **     SELECT <column> FROM <table>
75690 **
75691 ** If the prNotFound parameter is 0, then the b-tree will be used to iterate
75692 ** through the set members, skipping any duplicates. In this case an
75693 ** epheremal table must be used unless the selected <column> is guaranteed
75694 ** to be unique - either because it is an INTEGER PRIMARY KEY or it
75695 ** has a UNIQUE constraint or UNIQUE index.
75696 **
75697 ** If the prNotFound parameter is not 0, then the b-tree will be used 
75698 ** for fast set membership tests. In this case an epheremal table must 
75699 ** be used unless <column> is an INTEGER PRIMARY KEY or an index can 
75700 ** be found with <column> as its left-most column.
75701 **
75702 ** When the b-tree is being used for membership tests, the calling function
75703 ** needs to know whether or not the structure contains an SQL NULL 
75704 ** value in order to correctly evaluate expressions like "X IN (Y, Z)".
75705 ** If there is any chance that the (...) might contain a NULL value at
75706 ** runtime, then a register is allocated and the register number written
75707 ** to *prNotFound. If there is no chance that the (...) contains a
75708 ** NULL value, then *prNotFound is left unchanged.
75709 **
75710 ** If a register is allocated and its location stored in *prNotFound, then
75711 ** its initial value is NULL.  If the (...) does not remain constant
75712 ** for the duration of the query (i.e. the SELECT within the (...)
75713 ** is a correlated subquery) then the value of the allocated register is
75714 ** reset to NULL each time the subquery is rerun. This allows the
75715 ** caller to use vdbe code equivalent to the following:
75716 **
75717 **   if( register==NULL ){
75718 **     has_null = <test if data structure contains null>
75719 **     register = 1
75720 **   }
75721 **
75722 ** in order to avoid running the <test if data structure contains null>
75723 ** test more often than is necessary.
75724 */
75725 #ifndef SQLCIPHER_OMIT_SUBQUERY
75726 SQLCIPHER_PRIVATE int sqlcipher3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
75727   Select *p;                            /* SELECT to the right of IN operator */
75728   int eType = 0;                        /* Type of RHS table. IN_INDEX_* */
75729   int iTab = pParse->nTab++;            /* Cursor of the RHS table */
75730   int mustBeUnique = (prNotFound==0);   /* True if RHS must be unique */
75731
75732   assert( pX->op==TK_IN );
75733
75734   /* Check to see if an existing table or index can be used to
75735   ** satisfy the query.  This is preferable to generating a new 
75736   ** ephemeral table.
75737   */
75738   p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
75739   if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
75740     sqlcipher3 *db = pParse->db;              /* Database connection */
75741     Vdbe *v = sqlcipher3GetVdbe(pParse);      /* Virtual machine being coded */
75742     Table *pTab;                           /* Table <table>. */
75743     Expr *pExpr;                           /* Expression <column> */
75744     int iCol;                              /* Index of column <column> */
75745     int iDb;                               /* Database idx for pTab */
75746
75747     assert( p );                        /* Because of isCandidateForInOpt(p) */
75748     assert( p->pEList!=0 );             /* Because of isCandidateForInOpt(p) */
75749     assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
75750     assert( p->pSrc!=0 );               /* Because of isCandidateForInOpt(p) */
75751     pTab = p->pSrc->a[0].pTab;
75752     pExpr = p->pEList->a[0].pExpr;
75753     iCol = pExpr->iColumn;
75754    
75755     /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
75756     iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
75757     sqlcipher3CodeVerifySchema(pParse, iDb);
75758     sqlcipher3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
75759
75760     /* This function is only called from two places. In both cases the vdbe
75761     ** has already been allocated. So assume sqlcipher3GetVdbe() is always
75762     ** successful here.
75763     */
75764     assert(v);
75765     if( iCol<0 ){
75766       int iMem = ++pParse->nMem;
75767       int iAddr;
75768
75769       iAddr = sqlcipher3VdbeAddOp1(v, OP_Once, iMem);
75770
75771       sqlcipher3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
75772       eType = IN_INDEX_ROWID;
75773
75774       sqlcipher3VdbeJumpHere(v, iAddr);
75775     }else{
75776       Index *pIdx;                         /* Iterator variable */
75777
75778       /* The collation sequence used by the comparison. If an index is to
75779       ** be used in place of a temp-table, it must be ordered according
75780       ** to this collation sequence.  */
75781       CollSeq *pReq = sqlcipher3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
75782
75783       /* Check that the affinity that will be used to perform the 
75784       ** comparison is the same as the affinity of the column. If
75785       ** it is not, it is not possible to use any index.
75786       */
75787       char aff = comparisonAffinity(pX);
75788       int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLCIPHER_AFF_NONE);
75789
75790       for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
75791         if( (pIdx->aiColumn[0]==iCol)
75792          && sqlcipher3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
75793          && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
75794         ){
75795           int iMem = ++pParse->nMem;
75796           int iAddr;
75797           char *pKey;
75798   
75799           pKey = (char *)sqlcipher3IndexKeyinfo(pParse, pIdx);
75800           iAddr = sqlcipher3VdbeAddOp1(v, OP_Once, iMem);
75801   
75802           sqlcipher3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
75803                                pKey,P4_KEYINFO_HANDOFF);
75804           VdbeComment((v, "%s", pIdx->zName));
75805           eType = IN_INDEX_INDEX;
75806
75807           sqlcipher3VdbeJumpHere(v, iAddr);
75808           if( prNotFound && !pTab->aCol[iCol].notNull ){
75809             *prNotFound = ++pParse->nMem;
75810           }
75811         }
75812       }
75813     }
75814   }
75815
75816   if( eType==0 ){
75817     /* Could not found an existing table or index to use as the RHS b-tree.
75818     ** We will have to generate an ephemeral table to do the job.
75819     */
75820     double savedNQueryLoop = pParse->nQueryLoop;
75821     int rMayHaveNull = 0;
75822     eType = IN_INDEX_EPH;
75823     if( prNotFound ){
75824       *prNotFound = rMayHaveNull = ++pParse->nMem;
75825     }else{
75826       testcase( pParse->nQueryLoop>(double)1 );
75827       pParse->nQueryLoop = (double)1;
75828       if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
75829         eType = IN_INDEX_ROWID;
75830       }
75831     }
75832     sqlcipher3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
75833     pParse->nQueryLoop = savedNQueryLoop;
75834   }else{
75835     pX->iTable = iTab;
75836   }
75837   return eType;
75838 }
75839 #endif
75840
75841 /*
75842 ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
75843 ** or IN operators.  Examples:
75844 **
75845 **     (SELECT a FROM b)          -- subquery
75846 **     EXISTS (SELECT a FROM b)   -- EXISTS subquery
75847 **     x IN (4,5,11)              -- IN operator with list on right-hand side
75848 **     x IN (SELECT a FROM b)     -- IN operator with subquery on the right
75849 **
75850 ** The pExpr parameter describes the expression that contains the IN
75851 ** operator or subquery.
75852 **
75853 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
75854 ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
75855 ** to some integer key column of a table B-Tree. In this case, use an
75856 ** intkey B-Tree to store the set of IN(...) values instead of the usual
75857 ** (slower) variable length keys B-Tree.
75858 **
75859 ** If rMayHaveNull is non-zero, that means that the operation is an IN
75860 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
75861 ** Furthermore, the IN is in a WHERE clause and that we really want
75862 ** to iterate over the RHS of the IN operator in order to quickly locate
75863 ** all corresponding LHS elements.  All this routine does is initialize
75864 ** the register given by rMayHaveNull to NULL.  Calling routines will take
75865 ** care of changing this register value to non-NULL if the RHS is NULL-free.
75866 **
75867 ** If rMayHaveNull is zero, that means that the subquery is being used
75868 ** for membership testing only.  There is no need to initialize any
75869 ** registers to indicate the presense or absence of NULLs on the RHS.
75870 **
75871 ** For a SELECT or EXISTS operator, return the register that holds the
75872 ** result.  For IN operators or if an error occurs, the return value is 0.
75873 */
75874 #ifndef SQLCIPHER_OMIT_SUBQUERY
75875 SQLCIPHER_PRIVATE int sqlcipher3CodeSubselect(
75876   Parse *pParse,          /* Parsing context */
75877   Expr *pExpr,            /* The IN, SELECT, or EXISTS operator */
75878   int rMayHaveNull,       /* Register that records whether NULLs exist in RHS */
75879   int isRowid             /* If true, LHS of IN operator is a rowid */
75880 ){
75881   int testAddr = -1;                      /* One-time test address */
75882   int rReg = 0;                           /* Register storing resulting */
75883   Vdbe *v = sqlcipher3GetVdbe(pParse);
75884   if( NEVER(v==0) ) return 0;
75885   sqlcipher3ExprCachePush(pParse);
75886
75887   /* This code must be run in its entirety every time it is encountered
75888   ** if any of the following is true:
75889   **
75890   **    *  The right-hand side is a correlated subquery
75891   **    *  The right-hand side is an expression list containing variables
75892   **    *  We are inside a trigger
75893   **
75894   ** If all of the above are false, then we can run this code just once
75895   ** save the results, and reuse the same result on subsequent invocations.
75896   */
75897   if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->pTriggerTab ){
75898     int mem = ++pParse->nMem;
75899     testAddr = sqlcipher3VdbeAddOp1(v, OP_Once, mem);
75900   }
75901
75902 #ifndef SQLCIPHER_OMIT_EXPLAIN
75903   if( pParse->explain==2 ){
75904     char *zMsg = sqlcipher3MPrintf(
75905         pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
75906         pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
75907     );
75908     sqlcipher3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
75909   }
75910 #endif
75911
75912   switch( pExpr->op ){
75913     case TK_IN: {
75914       char affinity;              /* Affinity of the LHS of the IN */
75915       KeyInfo keyInfo;            /* Keyinfo for the generated table */
75916       int addr;                   /* Address of OP_OpenEphemeral instruction */
75917       Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
75918
75919       if( rMayHaveNull ){
75920         sqlcipher3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
75921       }
75922
75923       affinity = sqlcipher3ExprAffinity(pLeft);
75924
75925       /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
75926       ** expression it is handled the same way.  An ephemeral table is 
75927       ** filled with single-field index keys representing the results
75928       ** from the SELECT or the <exprlist>.
75929       **
75930       ** If the 'x' expression is a column value, or the SELECT...
75931       ** statement returns a column value, then the affinity of that
75932       ** column is used to build the index keys. If both 'x' and the
75933       ** SELECT... statement are columns, then numeric affinity is used
75934       ** if either column has NUMERIC or INTEGER affinity. If neither
75935       ** 'x' nor the SELECT... statement are columns, then numeric affinity
75936       ** is used.
75937       */
75938       pExpr->iTable = pParse->nTab++;
75939       addr = sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
75940       if( rMayHaveNull==0 ) sqlcipher3VdbeChangeP5(v, BTREE_UNORDERED);
75941       memset(&keyInfo, 0, sizeof(keyInfo));
75942       keyInfo.nField = 1;
75943
75944       if( ExprHasProperty(pExpr, EP_xIsSelect) ){
75945         /* Case 1:     expr IN (SELECT ...)
75946         **
75947         ** Generate code to write the results of the select into the temporary
75948         ** table allocated and opened above.
75949         */
75950         SelectDest dest;
75951         ExprList *pEList;
75952
75953         assert( !isRowid );
75954         sqlcipher3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
75955         dest.affinity = (u8)affinity;
75956         assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
75957         pExpr->x.pSelect->iLimit = 0;
75958         if( sqlcipher3Select(pParse, pExpr->x.pSelect, &dest) ){
75959           return 0;
75960         }
75961         pEList = pExpr->x.pSelect->pEList;
75962         if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){ 
75963           keyInfo.aColl[0] = sqlcipher3BinaryCompareCollSeq(pParse, pExpr->pLeft,
75964               pEList->a[0].pExpr);
75965         }
75966       }else if( ALWAYS(pExpr->x.pList!=0) ){
75967         /* Case 2:     expr IN (exprlist)
75968         **
75969         ** For each expression, build an index key from the evaluation and
75970         ** store it in the temporary table. If <expr> is a column, then use
75971         ** that columns affinity when building index keys. If <expr> is not
75972         ** a column, use numeric affinity.
75973         */
75974         int i;
75975         ExprList *pList = pExpr->x.pList;
75976         struct ExprList_item *pItem;
75977         int r1, r2, r3;
75978
75979         if( !affinity ){
75980           affinity = SQLCIPHER_AFF_NONE;
75981         }
75982         keyInfo.aColl[0] = sqlcipher3ExprCollSeq(pParse, pExpr->pLeft);
75983
75984         /* Loop through each expression in <exprlist>. */
75985         r1 = sqlcipher3GetTempReg(pParse);
75986         r2 = sqlcipher3GetTempReg(pParse);
75987         sqlcipher3VdbeAddOp2(v, OP_Null, 0, r2);
75988         for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
75989           Expr *pE2 = pItem->pExpr;
75990           int iValToIns;
75991
75992           /* If the expression is not constant then we will need to
75993           ** disable the test that was generated above that makes sure
75994           ** this code only executes once.  Because for a non-constant
75995           ** expression we need to rerun this code each time.
75996           */
75997           if( testAddr>=0 && !sqlcipher3ExprIsConstant(pE2) ){
75998             sqlcipher3VdbeChangeToNoop(v, testAddr);
75999             testAddr = -1;
76000           }
76001
76002           /* Evaluate the expression and insert it into the temp table */
76003           if( isRowid && sqlcipher3ExprIsInteger(pE2, &iValToIns) ){
76004             sqlcipher3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
76005           }else{
76006             r3 = sqlcipher3ExprCodeTarget(pParse, pE2, r1);
76007             if( isRowid ){
76008               sqlcipher3VdbeAddOp2(v, OP_MustBeInt, r3,
76009                                 sqlcipher3VdbeCurrentAddr(v)+2);
76010               sqlcipher3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
76011             }else{
76012               sqlcipher3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
76013               sqlcipher3ExprCacheAffinityChange(pParse, r3, 1);
76014               sqlcipher3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
76015             }
76016           }
76017         }
76018         sqlcipher3ReleaseTempReg(pParse, r1);
76019         sqlcipher3ReleaseTempReg(pParse, r2);
76020       }
76021       if( !isRowid ){
76022         sqlcipher3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
76023       }
76024       break;
76025     }
76026
76027     case TK_EXISTS:
76028     case TK_SELECT:
76029     default: {
76030       /* If this has to be a scalar SELECT.  Generate code to put the
76031       ** value of this select in a memory cell and record the number
76032       ** of the memory cell in iColumn.  If this is an EXISTS, write
76033       ** an integer 0 (not exists) or 1 (exists) into a memory cell
76034       ** and record that memory cell in iColumn.
76035       */
76036       Select *pSel;                         /* SELECT statement to encode */
76037       SelectDest dest;                      /* How to deal with SELECt result */
76038
76039       testcase( pExpr->op==TK_EXISTS );
76040       testcase( pExpr->op==TK_SELECT );
76041       assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
76042
76043       assert( ExprHasProperty(pExpr, EP_xIsSelect) );
76044       pSel = pExpr->x.pSelect;
76045       sqlcipher3SelectDestInit(&dest, 0, ++pParse->nMem);
76046       if( pExpr->op==TK_SELECT ){
76047         dest.eDest = SRT_Mem;
76048         sqlcipher3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
76049         VdbeComment((v, "Init subquery result"));
76050       }else{
76051         dest.eDest = SRT_Exists;
76052         sqlcipher3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
76053         VdbeComment((v, "Init EXISTS result"));
76054       }
76055       sqlcipher3ExprDelete(pParse->db, pSel->pLimit);
76056       pSel->pLimit = sqlcipher3PExpr(pParse, TK_INTEGER, 0, 0,
76057                                   &sqlcipher3IntTokens[1]);
76058       pSel->iLimit = 0;
76059       if( sqlcipher3Select(pParse, pSel, &dest) ){
76060         return 0;
76061       }
76062       rReg = dest.iParm;
76063       ExprSetIrreducible(pExpr);
76064       break;
76065     }
76066   }
76067
76068   if( testAddr>=0 ){
76069     sqlcipher3VdbeJumpHere(v, testAddr);
76070   }
76071   sqlcipher3ExprCachePop(pParse, 1);
76072
76073   return rReg;
76074 }
76075 #endif /* SQLCIPHER_OMIT_SUBQUERY */
76076
76077 #ifndef SQLCIPHER_OMIT_SUBQUERY
76078 /*
76079 ** Generate code for an IN expression.
76080 **
76081 **      x IN (SELECT ...)
76082 **      x IN (value, value, ...)
76083 **
76084 ** The left-hand side (LHS) is a scalar expression.  The right-hand side (RHS)
76085 ** is an array of zero or more values.  The expression is true if the LHS is
76086 ** contained within the RHS.  The value of the expression is unknown (NULL)
76087 ** if the LHS is NULL or if the LHS is not contained within the RHS and the
76088 ** RHS contains one or more NULL values.
76089 **
76090 ** This routine generates code will jump to destIfFalse if the LHS is not 
76091 ** contained within the RHS.  If due to NULLs we cannot determine if the LHS
76092 ** is contained in the RHS then jump to destIfNull.  If the LHS is contained
76093 ** within the RHS then fall through.
76094 */
76095 static void sqlcipher3ExprCodeIN(
76096   Parse *pParse,        /* Parsing and code generating context */
76097   Expr *pExpr,          /* The IN expression */
76098   int destIfFalse,      /* Jump here if LHS is not contained in the RHS */
76099   int destIfNull        /* Jump here if the results are unknown due to NULLs */
76100 ){
76101   int rRhsHasNull = 0;  /* Register that is true if RHS contains NULL values */
76102   char affinity;        /* Comparison affinity to use */
76103   int eType;            /* Type of the RHS */
76104   int r1;               /* Temporary use register */
76105   Vdbe *v;              /* Statement under construction */
76106
76107   /* Compute the RHS.   After this step, the table with cursor
76108   ** pExpr->iTable will contains the values that make up the RHS.
76109   */
76110   v = pParse->pVdbe;
76111   assert( v!=0 );       /* OOM detected prior to this routine */
76112   VdbeNoopComment((v, "begin IN expr"));
76113   eType = sqlcipher3FindInIndex(pParse, pExpr, &rRhsHasNull);
76114
76115   /* Figure out the affinity to use to create a key from the results
76116   ** of the expression. affinityStr stores a static string suitable for
76117   ** P4 of OP_MakeRecord.
76118   */
76119   affinity = comparisonAffinity(pExpr);
76120
76121   /* Code the LHS, the <expr> from "<expr> IN (...)".
76122   */
76123   sqlcipher3ExprCachePush(pParse);
76124   r1 = sqlcipher3GetTempReg(pParse);
76125   sqlcipher3ExprCode(pParse, pExpr->pLeft, r1);
76126
76127   /* If the LHS is NULL, then the result is either false or NULL depending
76128   ** on whether the RHS is empty or not, respectively.
76129   */
76130   if( destIfNull==destIfFalse ){
76131     /* Shortcut for the common case where the false and NULL outcomes are
76132     ** the same. */
76133     sqlcipher3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
76134   }else{
76135     int addr1 = sqlcipher3VdbeAddOp1(v, OP_NotNull, r1);
76136     sqlcipher3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
76137     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
76138     sqlcipher3VdbeJumpHere(v, addr1);
76139   }
76140
76141   if( eType==IN_INDEX_ROWID ){
76142     /* In this case, the RHS is the ROWID of table b-tree
76143     */
76144     sqlcipher3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
76145     sqlcipher3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
76146   }else{
76147     /* In this case, the RHS is an index b-tree.
76148     */
76149     sqlcipher3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
76150
76151     /* If the set membership test fails, then the result of the 
76152     ** "x IN (...)" expression must be either 0 or NULL. If the set
76153     ** contains no NULL values, then the result is 0. If the set 
76154     ** contains one or more NULL values, then the result of the
76155     ** expression is also NULL.
76156     */
76157     if( rRhsHasNull==0 || destIfFalse==destIfNull ){
76158       /* This branch runs if it is known at compile time that the RHS
76159       ** cannot contain NULL values. This happens as the result
76160       ** of a "NOT NULL" constraint in the database schema.
76161       **
76162       ** Also run this branch if NULL is equivalent to FALSE
76163       ** for this particular IN operator.
76164       */
76165       sqlcipher3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
76166
76167     }else{
76168       /* In this branch, the RHS of the IN might contain a NULL and
76169       ** the presence of a NULL on the RHS makes a difference in the
76170       ** outcome.
76171       */
76172       int j1, j2, j3;
76173
76174       /* First check to see if the LHS is contained in the RHS.  If so,
76175       ** then the presence of NULLs in the RHS does not matter, so jump
76176       ** over all of the code that follows.
76177       */
76178       j1 = sqlcipher3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
76179
76180       /* Here we begin generating code that runs if the LHS is not
76181       ** contained within the RHS.  Generate additional code that
76182       ** tests the RHS for NULLs.  If the RHS contains a NULL then
76183       ** jump to destIfNull.  If there are no NULLs in the RHS then
76184       ** jump to destIfFalse.
76185       */
76186       j2 = sqlcipher3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
76187       j3 = sqlcipher3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
76188       sqlcipher3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
76189       sqlcipher3VdbeJumpHere(v, j3);
76190       sqlcipher3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
76191       sqlcipher3VdbeJumpHere(v, j2);
76192
76193       /* Jump to the appropriate target depending on whether or not
76194       ** the RHS contains a NULL
76195       */
76196       sqlcipher3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
76197       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
76198
76199       /* The OP_Found at the top of this branch jumps here when true, 
76200       ** causing the overall IN expression evaluation to fall through.
76201       */
76202       sqlcipher3VdbeJumpHere(v, j1);
76203     }
76204   }
76205   sqlcipher3ReleaseTempReg(pParse, r1);
76206   sqlcipher3ExprCachePop(pParse, 1);
76207   VdbeComment((v, "end IN expr"));
76208 }
76209 #endif /* SQLCIPHER_OMIT_SUBQUERY */
76210
76211 /*
76212 ** Duplicate an 8-byte value
76213 */
76214 static char *dup8bytes(Vdbe *v, const char *in){
76215   char *out = sqlcipher3DbMallocRaw(sqlcipher3VdbeDb(v), 8);
76216   if( out ){
76217     memcpy(out, in, 8);
76218   }
76219   return out;
76220 }
76221
76222 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
76223 /*
76224 ** Generate an instruction that will put the floating point
76225 ** value described by z[0..n-1] into register iMem.
76226 **
76227 ** The z[] string will probably not be zero-terminated.  But the 
76228 ** z[n] character is guaranteed to be something that does not look
76229 ** like the continuation of the number.
76230 */
76231 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
76232   if( ALWAYS(z!=0) ){
76233     double value;
76234     char *zV;
76235     sqlcipher3AtoF(z, &value, sqlcipher3Strlen30(z), SQLCIPHER_UTF8);
76236     assert( !sqlcipher3IsNaN(value) ); /* The new AtoF never returns NaN */
76237     if( negateFlag ) value = -value;
76238     zV = dup8bytes(v, (char*)&value);
76239     sqlcipher3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
76240   }
76241 }
76242 #endif
76243
76244
76245 /*
76246 ** Generate an instruction that will put the integer describe by
76247 ** text z[0..n-1] into register iMem.
76248 **
76249 ** Expr.u.zToken is always UTF8 and zero-terminated.
76250 */
76251 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
76252   Vdbe *v = pParse->pVdbe;
76253   if( pExpr->flags & EP_IntValue ){
76254     int i = pExpr->u.iValue;
76255     assert( i>=0 );
76256     if( negFlag ) i = -i;
76257     sqlcipher3VdbeAddOp2(v, OP_Integer, i, iMem);
76258   }else{
76259     int c;
76260     i64 value;
76261     const char *z = pExpr->u.zToken;
76262     assert( z!=0 );
76263     c = sqlcipher3Atoi64(z, &value, sqlcipher3Strlen30(z), SQLCIPHER_UTF8);
76264     if( c==0 || (c==2 && negFlag) ){
76265       char *zV;
76266       if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
76267       zV = dup8bytes(v, (char*)&value);
76268       sqlcipher3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
76269     }else{
76270 #ifdef SQLCIPHER_OMIT_FLOATING_POINT
76271       sqlcipher3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
76272 #else
76273       codeReal(v, z, negFlag, iMem);
76274 #endif
76275     }
76276   }
76277 }
76278
76279 /*
76280 ** Clear a cache entry.
76281 */
76282 static void cacheEntryClear(Parse *pParse, struct yColCache *p){
76283   if( p->tempReg ){
76284     if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
76285       pParse->aTempReg[pParse->nTempReg++] = p->iReg;
76286     }
76287     p->tempReg = 0;
76288   }
76289 }
76290
76291
76292 /*
76293 ** Record in the column cache that a particular column from a
76294 ** particular table is stored in a particular register.
76295 */
76296 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
76297   int i;
76298   int minLru;
76299   int idxLru;
76300   struct yColCache *p;
76301
76302   assert( iReg>0 );  /* Register numbers are always positive */
76303   assert( iCol>=-1 && iCol<32768 );  /* Finite column numbers */
76304
76305   /* The SQLCIPHER_ColumnCache flag disables the column cache.  This is used
76306   ** for testing only - to verify that SQLite always gets the same answer
76307   ** with and without the column cache.
76308   */
76309   if( pParse->db->flags & SQLCIPHER_ColumnCache ) return;
76310
76311   /* First replace any existing entry.
76312   **
76313   ** Actually, the way the column cache is currently used, we are guaranteed
76314   ** that the object will never already be in cache.  Verify this guarantee.
76315   */
76316 #ifndef NDEBUG
76317   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76318 #if 0 /* This code wold remove the entry from the cache if it existed */
76319     if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
76320       cacheEntryClear(pParse, p);
76321       p->iLevel = pParse->iCacheLevel;
76322       p->iReg = iReg;
76323       p->lru = pParse->iCacheCnt++;
76324       return;
76325     }
76326 #endif
76327     assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
76328   }
76329 #endif
76330
76331   /* Find an empty slot and replace it */
76332   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76333     if( p->iReg==0 ){
76334       p->iLevel = pParse->iCacheLevel;
76335       p->iTable = iTab;
76336       p->iColumn = iCol;
76337       p->iReg = iReg;
76338       p->tempReg = 0;
76339       p->lru = pParse->iCacheCnt++;
76340       return;
76341     }
76342   }
76343
76344   /* Replace the last recently used */
76345   minLru = 0x7fffffff;
76346   idxLru = -1;
76347   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76348     if( p->lru<minLru ){
76349       idxLru = i;
76350       minLru = p->lru;
76351     }
76352   }
76353   if( ALWAYS(idxLru>=0) ){
76354     p = &pParse->aColCache[idxLru];
76355     p->iLevel = pParse->iCacheLevel;
76356     p->iTable = iTab;
76357     p->iColumn = iCol;
76358     p->iReg = iReg;
76359     p->tempReg = 0;
76360     p->lru = pParse->iCacheCnt++;
76361     return;
76362   }
76363 }
76364
76365 /*
76366 ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
76367 ** Purge the range of registers from the column cache.
76368 */
76369 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
76370   int i;
76371   int iLast = iReg + nReg - 1;
76372   struct yColCache *p;
76373   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76374     int r = p->iReg;
76375     if( r>=iReg && r<=iLast ){
76376       cacheEntryClear(pParse, p);
76377       p->iReg = 0;
76378     }
76379   }
76380 }
76381
76382 /*
76383 ** Remember the current column cache context.  Any new entries added
76384 ** added to the column cache after this call are removed when the
76385 ** corresponding pop occurs.
76386 */
76387 SQLCIPHER_PRIVATE void sqlcipher3ExprCachePush(Parse *pParse){
76388   pParse->iCacheLevel++;
76389 }
76390
76391 /*
76392 ** Remove from the column cache any entries that were added since the
76393 ** the previous N Push operations.  In other words, restore the cache
76394 ** to the state it was in N Pushes ago.
76395 */
76396 SQLCIPHER_PRIVATE void sqlcipher3ExprCachePop(Parse *pParse, int N){
76397   int i;
76398   struct yColCache *p;
76399   assert( N>0 );
76400   assert( pParse->iCacheLevel>=N );
76401   pParse->iCacheLevel -= N;
76402   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76403     if( p->iReg && p->iLevel>pParse->iCacheLevel ){
76404       cacheEntryClear(pParse, p);
76405       p->iReg = 0;
76406     }
76407   }
76408 }
76409
76410 /*
76411 ** When a cached column is reused, make sure that its register is
76412 ** no longer available as a temp register.  ticket #3879:  that same
76413 ** register might be in the cache in multiple places, so be sure to
76414 ** get them all.
76415 */
76416 static void sqlcipher3ExprCachePinRegister(Parse *pParse, int iReg){
76417   int i;
76418   struct yColCache *p;
76419   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76420     if( p->iReg==iReg ){
76421       p->tempReg = 0;
76422     }
76423   }
76424 }
76425
76426 /*
76427 ** Generate code to extract the value of the iCol-th column of a table.
76428 */
76429 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeGetColumnOfTable(
76430   Vdbe *v,        /* The VDBE under construction */
76431   Table *pTab,    /* The table containing the value */
76432   int iTabCur,    /* The cursor for this table */
76433   int iCol,       /* Index of the column to extract */
76434   int regOut      /* Extract the valud into this register */
76435 ){
76436   if( iCol<0 || iCol==pTab->iPKey ){
76437     sqlcipher3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
76438   }else{
76439     int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
76440     sqlcipher3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
76441   }
76442   if( iCol>=0 ){
76443     sqlcipher3ColumnDefault(v, pTab, iCol, regOut);
76444   }
76445 }
76446
76447 /*
76448 ** Generate code that will extract the iColumn-th column from
76449 ** table pTab and store the column value in a register.  An effort
76450 ** is made to store the column value in register iReg, but this is
76451 ** not guaranteed.  The location of the column value is returned.
76452 **
76453 ** There must be an open cursor to pTab in iTable when this routine
76454 ** is called.  If iColumn<0 then code is generated that extracts the rowid.
76455 */
76456 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeGetColumn(
76457   Parse *pParse,   /* Parsing and code generating context */
76458   Table *pTab,     /* Description of the table we are reading from */
76459   int iColumn,     /* Index of the table column */
76460   int iTable,      /* The cursor pointing to the table */
76461   int iReg         /* Store results here */
76462 ){
76463   Vdbe *v = pParse->pVdbe;
76464   int i;
76465   struct yColCache *p;
76466
76467   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76468     if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
76469       p->lru = pParse->iCacheCnt++;
76470       sqlcipher3ExprCachePinRegister(pParse, p->iReg);
76471       return p->iReg;
76472     }
76473   }  
76474   assert( v!=0 );
76475   sqlcipher3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
76476   sqlcipher3ExprCacheStore(pParse, iTable, iColumn, iReg);
76477   return iReg;
76478 }
76479
76480 /*
76481 ** Clear all column cache entries.
76482 */
76483 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheClear(Parse *pParse){
76484   int i;
76485   struct yColCache *p;
76486
76487   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76488     if( p->iReg ){
76489       cacheEntryClear(pParse, p);
76490       p->iReg = 0;
76491     }
76492   }
76493 }
76494
76495 /*
76496 ** Record the fact that an affinity change has occurred on iCount
76497 ** registers starting with iStart.
76498 */
76499 SQLCIPHER_PRIVATE void sqlcipher3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
76500   sqlcipher3ExprCacheRemove(pParse, iStart, iCount);
76501 }
76502
76503 /*
76504 ** Generate code to move content from registers iFrom...iFrom+nReg-1
76505 ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
76506 */
76507 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
76508   int i;
76509   struct yColCache *p;
76510   if( NEVER(iFrom==iTo) ) return;
76511   sqlcipher3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
76512   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76513     int x = p->iReg;
76514     if( x>=iFrom && x<iFrom+nReg ){
76515       p->iReg += iTo-iFrom;
76516     }
76517   }
76518 }
76519
76520 /*
76521 ** Generate code to copy content from registers iFrom...iFrom+nReg-1
76522 ** over to iTo..iTo+nReg-1.
76523 */
76524 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
76525   int i;
76526   if( NEVER(iFrom==iTo) ) return;
76527   for(i=0; i<nReg; i++){
76528     sqlcipher3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
76529   }
76530 }
76531
76532 #if defined(SQLCIPHER_DEBUG) || defined(SQLCIPHER_COVERAGE_TEST)
76533 /*
76534 ** Return true if any register in the range iFrom..iTo (inclusive)
76535 ** is used as part of the column cache.
76536 **
76537 ** This routine is used within assert() and testcase() macros only
76538 ** and does not appear in a normal build.
76539 */
76540 static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
76541   int i;
76542   struct yColCache *p;
76543   for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
76544     int r = p->iReg;
76545     if( r>=iFrom && r<=iTo ) return 1;    /*NO_TEST*/
76546   }
76547   return 0;
76548 }
76549 #endif /* SQLCIPHER_DEBUG || SQLCIPHER_COVERAGE_TEST */
76550
76551 /*
76552 ** Generate code into the current Vdbe to evaluate the given
76553 ** expression.  Attempt to store the results in register "target".
76554 ** Return the register where results are stored.
76555 **
76556 ** With this routine, there is no guarantee that results will
76557 ** be stored in target.  The result might be stored in some other
76558 ** register if it is convenient to do so.  The calling function
76559 ** must check the return code and move the results to the desired
76560 ** register.
76561 */
76562 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
76563   Vdbe *v = pParse->pVdbe;  /* The VM under construction */
76564   int op;                   /* The opcode being coded */
76565   int inReg = target;       /* Results stored in register inReg */
76566   int regFree1 = 0;         /* If non-zero free this temporary register */
76567   int regFree2 = 0;         /* If non-zero free this temporary register */
76568   int r1, r2, r3, r4;       /* Various register numbers */
76569   sqlcipher3 *db = pParse->db; /* The database connection */
76570
76571   assert( target>0 && target<=pParse->nMem );
76572   if( v==0 ){
76573     assert( pParse->db->mallocFailed );
76574     return 0;
76575   }
76576
76577   if( pExpr==0 ){
76578     op = TK_NULL;
76579   }else{
76580     op = pExpr->op;
76581   }
76582   switch( op ){
76583     case TK_AGG_COLUMN: {
76584       AggInfo *pAggInfo = pExpr->pAggInfo;
76585       struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
76586       if( !pAggInfo->directMode ){
76587         assert( pCol->iMem>0 );
76588         inReg = pCol->iMem;
76589         break;
76590       }else if( pAggInfo->useSortingIdx ){
76591         sqlcipher3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
76592                               pCol->iSorterColumn, target);
76593         break;
76594       }
76595       /* Otherwise, fall thru into the TK_COLUMN case */
76596     }
76597     case TK_COLUMN: {
76598       if( pExpr->iTable<0 ){
76599         /* This only happens when coding check constraints */
76600         assert( pParse->ckBase>0 );
76601         inReg = pExpr->iColumn + pParse->ckBase;
76602       }else{
76603         inReg = sqlcipher3ExprCodeGetColumn(pParse, pExpr->pTab,
76604                                  pExpr->iColumn, pExpr->iTable, target);
76605       }
76606       break;
76607     }
76608     case TK_INTEGER: {
76609       codeInteger(pParse, pExpr, 0, target);
76610       break;
76611     }
76612 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
76613     case TK_FLOAT: {
76614       assert( !ExprHasProperty(pExpr, EP_IntValue) );
76615       codeReal(v, pExpr->u.zToken, 0, target);
76616       break;
76617     }
76618 #endif
76619     case TK_STRING: {
76620       assert( !ExprHasProperty(pExpr, EP_IntValue) );
76621       sqlcipher3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
76622       break;
76623     }
76624     case TK_NULL: {
76625       sqlcipher3VdbeAddOp2(v, OP_Null, 0, target);
76626       break;
76627     }
76628 #ifndef SQLCIPHER_OMIT_BLOB_LITERAL
76629     case TK_BLOB: {
76630       int n;
76631       const char *z;
76632       char *zBlob;
76633       assert( !ExprHasProperty(pExpr, EP_IntValue) );
76634       assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
76635       assert( pExpr->u.zToken[1]=='\'' );
76636       z = &pExpr->u.zToken[2];
76637       n = sqlcipher3Strlen30(z) - 1;
76638       assert( z[n]=='\'' );
76639       zBlob = sqlcipher3HexToBlob(sqlcipher3VdbeDb(v), z, n);
76640       sqlcipher3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
76641       break;
76642     }
76643 #endif
76644     case TK_VARIABLE: {
76645       assert( !ExprHasProperty(pExpr, EP_IntValue) );
76646       assert( pExpr->u.zToken!=0 );
76647       assert( pExpr->u.zToken[0]!=0 );
76648       sqlcipher3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
76649       if( pExpr->u.zToken[1]!=0 ){
76650         assert( pExpr->u.zToken[0]=='?' 
76651              || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
76652         sqlcipher3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
76653       }
76654       break;
76655     }
76656     case TK_REGISTER: {
76657       inReg = pExpr->iTable;
76658       break;
76659     }
76660     case TK_AS: {
76661       inReg = sqlcipher3ExprCodeTarget(pParse, pExpr->pLeft, target);
76662       break;
76663     }
76664 #ifndef SQLCIPHER_OMIT_CAST
76665     case TK_CAST: {
76666       /* Expressions of the form:   CAST(pLeft AS token) */
76667       int aff, to_op;
76668       inReg = sqlcipher3ExprCodeTarget(pParse, pExpr->pLeft, target);
76669       assert( !ExprHasProperty(pExpr, EP_IntValue) );
76670       aff = sqlcipher3AffinityType(pExpr->u.zToken);
76671       to_op = aff - SQLCIPHER_AFF_TEXT + OP_ToText;
76672       assert( to_op==OP_ToText    || aff!=SQLCIPHER_AFF_TEXT    );
76673       assert( to_op==OP_ToBlob    || aff!=SQLCIPHER_AFF_NONE    );
76674       assert( to_op==OP_ToNumeric || aff!=SQLCIPHER_AFF_NUMERIC );
76675       assert( to_op==OP_ToInt     || aff!=SQLCIPHER_AFF_INTEGER );
76676       assert( to_op==OP_ToReal    || aff!=SQLCIPHER_AFF_REAL    );
76677       testcase( to_op==OP_ToText );
76678       testcase( to_op==OP_ToBlob );
76679       testcase( to_op==OP_ToNumeric );
76680       testcase( to_op==OP_ToInt );
76681       testcase( to_op==OP_ToReal );
76682       if( inReg!=target ){
76683         sqlcipher3VdbeAddOp2(v, OP_SCopy, inReg, target);
76684         inReg = target;
76685       }
76686       sqlcipher3VdbeAddOp1(v, to_op, inReg);
76687       testcase( usedAsColumnCache(pParse, inReg, inReg) );
76688       sqlcipher3ExprCacheAffinityChange(pParse, inReg, 1);
76689       break;
76690     }
76691 #endif /* SQLCIPHER_OMIT_CAST */
76692     case TK_LT:
76693     case TK_LE:
76694     case TK_GT:
76695     case TK_GE:
76696     case TK_NE:
76697     case TK_EQ: {
76698       assert( TK_LT==OP_Lt );
76699       assert( TK_LE==OP_Le );
76700       assert( TK_GT==OP_Gt );
76701       assert( TK_GE==OP_Ge );
76702       assert( TK_EQ==OP_Eq );
76703       assert( TK_NE==OP_Ne );
76704       testcase( op==TK_LT );
76705       testcase( op==TK_LE );
76706       testcase( op==TK_GT );
76707       testcase( op==TK_GE );
76708       testcase( op==TK_EQ );
76709       testcase( op==TK_NE );
76710       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
76711       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
76712       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76713                   r1, r2, inReg, SQLCIPHER_STOREP2);
76714       testcase( regFree1==0 );
76715       testcase( regFree2==0 );
76716       break;
76717     }
76718     case TK_IS:
76719     case TK_ISNOT: {
76720       testcase( op==TK_IS );
76721       testcase( op==TK_ISNOT );
76722       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
76723       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
76724       op = (op==TK_IS) ? TK_EQ : TK_NE;
76725       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76726                   r1, r2, inReg, SQLCIPHER_STOREP2 | SQLCIPHER_NULLEQ);
76727       testcase( regFree1==0 );
76728       testcase( regFree2==0 );
76729       break;
76730     }
76731     case TK_AND:
76732     case TK_OR:
76733     case TK_PLUS:
76734     case TK_STAR:
76735     case TK_MINUS:
76736     case TK_REM:
76737     case TK_BITAND:
76738     case TK_BITOR:
76739     case TK_SLASH:
76740     case TK_LSHIFT:
76741     case TK_RSHIFT: 
76742     case TK_CONCAT: {
76743       assert( TK_AND==OP_And );
76744       assert( TK_OR==OP_Or );
76745       assert( TK_PLUS==OP_Add );
76746       assert( TK_MINUS==OP_Subtract );
76747       assert( TK_REM==OP_Remainder );
76748       assert( TK_BITAND==OP_BitAnd );
76749       assert( TK_BITOR==OP_BitOr );
76750       assert( TK_SLASH==OP_Divide );
76751       assert( TK_LSHIFT==OP_ShiftLeft );
76752       assert( TK_RSHIFT==OP_ShiftRight );
76753       assert( TK_CONCAT==OP_Concat );
76754       testcase( op==TK_AND );
76755       testcase( op==TK_OR );
76756       testcase( op==TK_PLUS );
76757       testcase( op==TK_MINUS );
76758       testcase( op==TK_REM );
76759       testcase( op==TK_BITAND );
76760       testcase( op==TK_BITOR );
76761       testcase( op==TK_SLASH );
76762       testcase( op==TK_LSHIFT );
76763       testcase( op==TK_RSHIFT );
76764       testcase( op==TK_CONCAT );
76765       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
76766       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
76767       sqlcipher3VdbeAddOp3(v, op, r2, r1, target);
76768       testcase( regFree1==0 );
76769       testcase( regFree2==0 );
76770       break;
76771     }
76772     case TK_UMINUS: {
76773       Expr *pLeft = pExpr->pLeft;
76774       assert( pLeft );
76775       if( pLeft->op==TK_INTEGER ){
76776         codeInteger(pParse, pLeft, 1, target);
76777 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
76778       }else if( pLeft->op==TK_FLOAT ){
76779         assert( !ExprHasProperty(pExpr, EP_IntValue) );
76780         codeReal(v, pLeft->u.zToken, 1, target);
76781 #endif
76782       }else{
76783         regFree1 = r1 = sqlcipher3GetTempReg(pParse);
76784         sqlcipher3VdbeAddOp2(v, OP_Integer, 0, r1);
76785         r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
76786         sqlcipher3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
76787         testcase( regFree2==0 );
76788       }
76789       inReg = target;
76790       break;
76791     }
76792     case TK_BITNOT:
76793     case TK_NOT: {
76794       assert( TK_BITNOT==OP_BitNot );
76795       assert( TK_NOT==OP_Not );
76796       testcase( op==TK_BITNOT );
76797       testcase( op==TK_NOT );
76798       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
76799       testcase( regFree1==0 );
76800       inReg = target;
76801       sqlcipher3VdbeAddOp2(v, op, r1, inReg);
76802       break;
76803     }
76804     case TK_ISNULL:
76805     case TK_NOTNULL: {
76806       int addr;
76807       assert( TK_ISNULL==OP_IsNull );
76808       assert( TK_NOTNULL==OP_NotNull );
76809       testcase( op==TK_ISNULL );
76810       testcase( op==TK_NOTNULL );
76811       sqlcipher3VdbeAddOp2(v, OP_Integer, 1, target);
76812       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
76813       testcase( regFree1==0 );
76814       addr = sqlcipher3VdbeAddOp1(v, op, r1);
76815       sqlcipher3VdbeAddOp2(v, OP_AddImm, target, -1);
76816       sqlcipher3VdbeJumpHere(v, addr);
76817       break;
76818     }
76819     case TK_AGG_FUNCTION: {
76820       AggInfo *pInfo = pExpr->pAggInfo;
76821       if( pInfo==0 ){
76822         assert( !ExprHasProperty(pExpr, EP_IntValue) );
76823         sqlcipher3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
76824       }else{
76825         inReg = pInfo->aFunc[pExpr->iAgg].iMem;
76826       }
76827       break;
76828     }
76829     case TK_CONST_FUNC:
76830     case TK_FUNCTION: {
76831       ExprList *pFarg;       /* List of function arguments */
76832       int nFarg;             /* Number of function arguments */
76833       FuncDef *pDef;         /* The function definition object */
76834       int nId;               /* Length of the function name in bytes */
76835       const char *zId;       /* The function name */
76836       int constMask = 0;     /* Mask of function arguments that are constant */
76837       int i;                 /* Loop counter */
76838       u8 enc = ENC(db);      /* The text encoding used by this database */
76839       CollSeq *pColl = 0;    /* A collating sequence */
76840
76841       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76842       testcase( op==TK_CONST_FUNC );
76843       testcase( op==TK_FUNCTION );
76844       if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
76845         pFarg = 0;
76846       }else{
76847         pFarg = pExpr->x.pList;
76848       }
76849       nFarg = pFarg ? pFarg->nExpr : 0;
76850       assert( !ExprHasProperty(pExpr, EP_IntValue) );
76851       zId = pExpr->u.zToken;
76852       nId = sqlcipher3Strlen30(zId);
76853       pDef = sqlcipher3FindFunction(db, zId, nId, nFarg, enc, 0);
76854       if( pDef==0 ){
76855         sqlcipher3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
76856         break;
76857       }
76858
76859       /* Attempt a direct implementation of the built-in COALESCE() and
76860       ** IFNULL() functions.  This avoids unnecessary evalation of
76861       ** arguments past the first non-NULL argument.
76862       */
76863       if( pDef->flags & SQLCIPHER_FUNC_COALESCE ){
76864         int endCoalesce = sqlcipher3VdbeMakeLabel(v);
76865         assert( nFarg>=2 );
76866         sqlcipher3ExprCode(pParse, pFarg->a[0].pExpr, target);
76867         for(i=1; i<nFarg; i++){
76868           sqlcipher3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
76869           sqlcipher3ExprCacheRemove(pParse, target, 1);
76870           sqlcipher3ExprCachePush(pParse);
76871           sqlcipher3ExprCode(pParse, pFarg->a[i].pExpr, target);
76872           sqlcipher3ExprCachePop(pParse, 1);
76873         }
76874         sqlcipher3VdbeResolveLabel(v, endCoalesce);
76875         break;
76876       }
76877
76878
76879       if( pFarg ){
76880         r1 = sqlcipher3GetTempRange(pParse, nFarg);
76881         sqlcipher3ExprCachePush(pParse);     /* Ticket 2ea2425d34be */
76882         sqlcipher3ExprCodeExprList(pParse, pFarg, r1, 1);
76883         sqlcipher3ExprCachePop(pParse, 1);   /* Ticket 2ea2425d34be */
76884       }else{
76885         r1 = 0;
76886       }
76887 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
76888       /* Possibly overload the function if the first argument is
76889       ** a virtual table column.
76890       **
76891       ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
76892       ** second argument, not the first, as the argument to test to
76893       ** see if it is a column in a virtual table.  This is done because
76894       ** the left operand of infix functions (the operand we want to
76895       ** control overloading) ends up as the second argument to the
76896       ** function.  The expression "A glob B" is equivalent to 
76897       ** "glob(B,A).  We want to use the A in "A glob B" to test
76898       ** for function overloading.  But we use the B term in "glob(B,A)".
76899       */
76900       if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
76901         pDef = sqlcipher3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
76902       }else if( nFarg>0 ){
76903         pDef = sqlcipher3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
76904       }
76905 #endif
76906       for(i=0; i<nFarg; i++){
76907         if( i<32 && sqlcipher3ExprIsConstant(pFarg->a[i].pExpr) ){
76908           constMask |= (1<<i);
76909         }
76910         if( (pDef->flags & SQLCIPHER_FUNC_NEEDCOLL)!=0 && !pColl ){
76911           pColl = sqlcipher3ExprCollSeq(pParse, pFarg->a[i].pExpr);
76912         }
76913       }
76914       if( pDef->flags & SQLCIPHER_FUNC_NEEDCOLL ){
76915         if( !pColl ) pColl = db->pDfltColl; 
76916         sqlcipher3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
76917       }
76918       sqlcipher3VdbeAddOp4(v, OP_Function, constMask, r1, target,
76919                         (char*)pDef, P4_FUNCDEF);
76920       sqlcipher3VdbeChangeP5(v, (u8)nFarg);
76921       if( nFarg ){
76922         sqlcipher3ReleaseTempRange(pParse, r1, nFarg);
76923       }
76924       break;
76925     }
76926 #ifndef SQLCIPHER_OMIT_SUBQUERY
76927     case TK_EXISTS:
76928     case TK_SELECT: {
76929       testcase( op==TK_EXISTS );
76930       testcase( op==TK_SELECT );
76931       inReg = sqlcipher3CodeSubselect(pParse, pExpr, 0, 0);
76932       break;
76933     }
76934     case TK_IN: {
76935       int destIfFalse = sqlcipher3VdbeMakeLabel(v);
76936       int destIfNull = sqlcipher3VdbeMakeLabel(v);
76937       sqlcipher3VdbeAddOp2(v, OP_Null, 0, target);
76938       sqlcipher3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
76939       sqlcipher3VdbeAddOp2(v, OP_Integer, 1, target);
76940       sqlcipher3VdbeResolveLabel(v, destIfFalse);
76941       sqlcipher3VdbeAddOp2(v, OP_AddImm, target, 0);
76942       sqlcipher3VdbeResolveLabel(v, destIfNull);
76943       break;
76944     }
76945 #endif /* SQLCIPHER_OMIT_SUBQUERY */
76946
76947
76948     /*
76949     **    x BETWEEN y AND z
76950     **
76951     ** This is equivalent to
76952     **
76953     **    x>=y AND x<=z
76954     **
76955     ** X is stored in pExpr->pLeft.
76956     ** Y is stored in pExpr->pList->a[0].pExpr.
76957     ** Z is stored in pExpr->pList->a[1].pExpr.
76958     */
76959     case TK_BETWEEN: {
76960       Expr *pLeft = pExpr->pLeft;
76961       struct ExprList_item *pLItem = pExpr->x.pList->a;
76962       Expr *pRight = pLItem->pExpr;
76963
76964       r1 = sqlcipher3ExprCodeTemp(pParse, pLeft, &regFree1);
76965       r2 = sqlcipher3ExprCodeTemp(pParse, pRight, &regFree2);
76966       testcase( regFree1==0 );
76967       testcase( regFree2==0 );
76968       r3 = sqlcipher3GetTempReg(pParse);
76969       r4 = sqlcipher3GetTempReg(pParse);
76970       codeCompare(pParse, pLeft, pRight, OP_Ge,
76971                   r1, r2, r3, SQLCIPHER_STOREP2);
76972       pLItem++;
76973       pRight = pLItem->pExpr;
76974       sqlcipher3ReleaseTempReg(pParse, regFree2);
76975       r2 = sqlcipher3ExprCodeTemp(pParse, pRight, &regFree2);
76976       testcase( regFree2==0 );
76977       codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLCIPHER_STOREP2);
76978       sqlcipher3VdbeAddOp3(v, OP_And, r3, r4, target);
76979       sqlcipher3ReleaseTempReg(pParse, r3);
76980       sqlcipher3ReleaseTempReg(pParse, r4);
76981       break;
76982     }
76983     case TK_UPLUS: {
76984       inReg = sqlcipher3ExprCodeTarget(pParse, pExpr->pLeft, target);
76985       break;
76986     }
76987
76988     case TK_TRIGGER: {
76989       /* If the opcode is TK_TRIGGER, then the expression is a reference
76990       ** to a column in the new.* or old.* pseudo-tables available to
76991       ** trigger programs. In this case Expr.iTable is set to 1 for the
76992       ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
76993       ** is set to the column of the pseudo-table to read, or to -1 to
76994       ** read the rowid field.
76995       **
76996       ** The expression is implemented using an OP_Param opcode. The p1
76997       ** parameter is set to 0 for an old.rowid reference, or to (i+1)
76998       ** to reference another column of the old.* pseudo-table, where 
76999       ** i is the index of the column. For a new.rowid reference, p1 is
77000       ** set to (n+1), where n is the number of columns in each pseudo-table.
77001       ** For a reference to any other column in the new.* pseudo-table, p1
77002       ** is set to (n+2+i), where n and i are as defined previously. For
77003       ** example, if the table on which triggers are being fired is
77004       ** declared as:
77005       **
77006       **   CREATE TABLE t1(a, b);
77007       **
77008       ** Then p1 is interpreted as follows:
77009       **
77010       **   p1==0   ->    old.rowid     p1==3   ->    new.rowid
77011       **   p1==1   ->    old.a         p1==4   ->    new.a
77012       **   p1==2   ->    old.b         p1==5   ->    new.b       
77013       */
77014       Table *pTab = pExpr->pTab;
77015       int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
77016
77017       assert( pExpr->iTable==0 || pExpr->iTable==1 );
77018       assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
77019       assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
77020       assert( p1>=0 && p1<(pTab->nCol*2+2) );
77021
77022       sqlcipher3VdbeAddOp2(v, OP_Param, p1, target);
77023       VdbeComment((v, "%s.%s -> $%d",
77024         (pExpr->iTable ? "new" : "old"),
77025         (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
77026         target
77027       ));
77028
77029 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
77030       /* If the column has REAL affinity, it may currently be stored as an
77031       ** integer. Use OP_RealAffinity to make sure it is really real.  */
77032       if( pExpr->iColumn>=0 
77033        && pTab->aCol[pExpr->iColumn].affinity==SQLCIPHER_AFF_REAL
77034       ){
77035         sqlcipher3VdbeAddOp1(v, OP_RealAffinity, target);
77036       }
77037 #endif
77038       break;
77039     }
77040
77041
77042     /*
77043     ** Form A:
77044     **   CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
77045     **
77046     ** Form B:
77047     **   CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
77048     **
77049     ** Form A is can be transformed into the equivalent form B as follows:
77050     **   CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
77051     **        WHEN x=eN THEN rN ELSE y END
77052     **
77053     ** X (if it exists) is in pExpr->pLeft.
77054     ** Y is in pExpr->pRight.  The Y is also optional.  If there is no
77055     ** ELSE clause and no other term matches, then the result of the
77056     ** exprssion is NULL.
77057     ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
77058     **
77059     ** The result of the expression is the Ri for the first matching Ei,
77060     ** or if there is no matching Ei, the ELSE term Y, or if there is
77061     ** no ELSE term, NULL.
77062     */
77063     default: assert( op==TK_CASE ); {
77064       int endLabel;                     /* GOTO label for end of CASE stmt */
77065       int nextCase;                     /* GOTO label for next WHEN clause */
77066       int nExpr;                        /* 2x number of WHEN terms */
77067       int i;                            /* Loop counter */
77068       ExprList *pEList;                 /* List of WHEN terms */
77069       struct ExprList_item *aListelem;  /* Array of WHEN terms */
77070       Expr opCompare;                   /* The X==Ei expression */
77071       Expr cacheX;                      /* Cached expression X */
77072       Expr *pX;                         /* The X expression */
77073       Expr *pTest = 0;                  /* X==Ei (form A) or just Ei (form B) */
77074       VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
77075
77076       assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
77077       assert((pExpr->x.pList->nExpr % 2) == 0);
77078       assert(pExpr->x.pList->nExpr > 0);
77079       pEList = pExpr->x.pList;
77080       aListelem = pEList->a;
77081       nExpr = pEList->nExpr;
77082       endLabel = sqlcipher3VdbeMakeLabel(v);
77083       if( (pX = pExpr->pLeft)!=0 ){
77084         cacheX = *pX;
77085         testcase( pX->op==TK_COLUMN );
77086         testcase( pX->op==TK_REGISTER );
77087         cacheX.iTable = sqlcipher3ExprCodeTemp(pParse, pX, &regFree1);
77088         testcase( regFree1==0 );
77089         cacheX.op = TK_REGISTER;
77090         opCompare.op = TK_EQ;
77091         opCompare.pLeft = &cacheX;
77092         pTest = &opCompare;
77093         /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
77094         ** The value in regFree1 might get SCopy-ed into the file result.
77095         ** So make sure that the regFree1 register is not reused for other
77096         ** purposes and possibly overwritten.  */
77097         regFree1 = 0;
77098       }
77099       for(i=0; i<nExpr; i=i+2){
77100         sqlcipher3ExprCachePush(pParse);
77101         if( pX ){
77102           assert( pTest!=0 );
77103           opCompare.pRight = aListelem[i].pExpr;
77104         }else{
77105           pTest = aListelem[i].pExpr;
77106         }
77107         nextCase = sqlcipher3VdbeMakeLabel(v);
77108         testcase( pTest->op==TK_COLUMN );
77109         sqlcipher3ExprIfFalse(pParse, pTest, nextCase, SQLCIPHER_JUMPIFNULL);
77110         testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
77111         testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
77112         sqlcipher3ExprCode(pParse, aListelem[i+1].pExpr, target);
77113         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, endLabel);
77114         sqlcipher3ExprCachePop(pParse, 1);
77115         sqlcipher3VdbeResolveLabel(v, nextCase);
77116       }
77117       if( pExpr->pRight ){
77118         sqlcipher3ExprCachePush(pParse);
77119         sqlcipher3ExprCode(pParse, pExpr->pRight, target);
77120         sqlcipher3ExprCachePop(pParse, 1);
77121       }else{
77122         sqlcipher3VdbeAddOp2(v, OP_Null, 0, target);
77123       }
77124       assert( db->mallocFailed || pParse->nErr>0 
77125            || pParse->iCacheLevel==iCacheLevel );
77126       sqlcipher3VdbeResolveLabel(v, endLabel);
77127       break;
77128     }
77129 #ifndef SQLCIPHER_OMIT_TRIGGER
77130     case TK_RAISE: {
77131       assert( pExpr->affinity==OE_Rollback 
77132            || pExpr->affinity==OE_Abort
77133            || pExpr->affinity==OE_Fail
77134            || pExpr->affinity==OE_Ignore
77135       );
77136       if( !pParse->pTriggerTab ){
77137         sqlcipher3ErrorMsg(pParse,
77138                        "RAISE() may only be used within a trigger-program");
77139         return 0;
77140       }
77141       if( pExpr->affinity==OE_Abort ){
77142         sqlcipher3MayAbort(pParse);
77143       }
77144       assert( !ExprHasProperty(pExpr, EP_IntValue) );
77145       if( pExpr->affinity==OE_Ignore ){
77146         sqlcipher3VdbeAddOp4(
77147             v, OP_Halt, SQLCIPHER_OK, OE_Ignore, 0, pExpr->u.zToken,0);
77148       }else{
77149         sqlcipher3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
77150       }
77151
77152       break;
77153     }
77154 #endif
77155   }
77156   sqlcipher3ReleaseTempReg(pParse, regFree1);
77157   sqlcipher3ReleaseTempReg(pParse, regFree2);
77158   return inReg;
77159 }
77160
77161 /*
77162 ** Generate code to evaluate an expression and store the results
77163 ** into a register.  Return the register number where the results
77164 ** are stored.
77165 **
77166 ** If the register is a temporary register that can be deallocated,
77167 ** then write its number into *pReg.  If the result register is not
77168 ** a temporary, then set *pReg to zero.
77169 */
77170 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
77171   int r1 = sqlcipher3GetTempReg(pParse);
77172   int r2 = sqlcipher3ExprCodeTarget(pParse, pExpr, r1);
77173   if( r2==r1 ){
77174     *pReg = r1;
77175   }else{
77176     sqlcipher3ReleaseTempReg(pParse, r1);
77177     *pReg = 0;
77178   }
77179   return r2;
77180 }
77181
77182 /*
77183 ** Generate code that will evaluate expression pExpr and store the
77184 ** results in register target.  The results are guaranteed to appear
77185 ** in register target.
77186 */
77187 SQLCIPHER_PRIVATE int sqlcipher3ExprCode(Parse *pParse, Expr *pExpr, int target){
77188   int inReg;
77189
77190   assert( target>0 && target<=pParse->nMem );
77191   if( pExpr && pExpr->op==TK_REGISTER ){
77192     sqlcipher3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
77193   }else{
77194     inReg = sqlcipher3ExprCodeTarget(pParse, pExpr, target);
77195     assert( pParse->pVdbe || pParse->db->mallocFailed );
77196     if( inReg!=target && pParse->pVdbe ){
77197       sqlcipher3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
77198     }
77199   }
77200   return target;
77201 }
77202
77203 /*
77204 ** Generate code that evalutes the given expression and puts the result
77205 ** in register target.
77206 **
77207 ** Also make a copy of the expression results into another "cache" register
77208 ** and modify the expression so that the next time it is evaluated,
77209 ** the result is a copy of the cache register.
77210 **
77211 ** This routine is used for expressions that are used multiple 
77212 ** times.  They are evaluated once and the results of the expression
77213 ** are reused.
77214 */
77215 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
77216   Vdbe *v = pParse->pVdbe;
77217   int inReg;
77218   inReg = sqlcipher3ExprCode(pParse, pExpr, target);
77219   assert( target>0 );
77220   /* This routine is called for terms to INSERT or UPDATE.  And the only
77221   ** other place where expressions can be converted into TK_REGISTER is
77222   ** in WHERE clause processing.  So as currently implemented, there is
77223   ** no way for a TK_REGISTER to exist here.  But it seems prudent to
77224   ** keep the ALWAYS() in case the conditions above change with future
77225   ** modifications or enhancements. */
77226   if( ALWAYS(pExpr->op!=TK_REGISTER) ){  
77227     int iMem;
77228     iMem = ++pParse->nMem;
77229     sqlcipher3VdbeAddOp2(v, OP_Copy, inReg, iMem);
77230     pExpr->iTable = iMem;
77231     pExpr->op2 = pExpr->op;
77232     pExpr->op = TK_REGISTER;
77233   }
77234   return inReg;
77235 }
77236
77237 /*
77238 ** Return TRUE if pExpr is an constant expression that is appropriate
77239 ** for factoring out of a loop.  Appropriate expressions are:
77240 **
77241 **    *  Any expression that evaluates to two or more opcodes.
77242 **
77243 **    *  Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null, 
77244 **       or OP_Variable that does not need to be placed in a 
77245 **       specific register.
77246 **
77247 ** There is no point in factoring out single-instruction constant
77248 ** expressions that need to be placed in a particular register.  
77249 ** We could factor them out, but then we would end up adding an
77250 ** OP_SCopy instruction to move the value into the correct register
77251 ** later.  We might as well just use the original instruction and
77252 ** avoid the OP_SCopy.
77253 */
77254 static int isAppropriateForFactoring(Expr *p){
77255   if( !sqlcipher3ExprIsConstantNotJoin(p) ){
77256     return 0;  /* Only constant expressions are appropriate for factoring */
77257   }
77258   if( (p->flags & EP_FixedDest)==0 ){
77259     return 1;  /* Any constant without a fixed destination is appropriate */
77260   }
77261   while( p->op==TK_UPLUS ) p = p->pLeft;
77262   switch( p->op ){
77263 #ifndef SQLCIPHER_OMIT_BLOB_LITERAL
77264     case TK_BLOB:
77265 #endif
77266     case TK_VARIABLE:
77267     case TK_INTEGER:
77268     case TK_FLOAT:
77269     case TK_NULL:
77270     case TK_STRING: {
77271       testcase( p->op==TK_BLOB );
77272       testcase( p->op==TK_VARIABLE );
77273       testcase( p->op==TK_INTEGER );
77274       testcase( p->op==TK_FLOAT );
77275       testcase( p->op==TK_NULL );
77276       testcase( p->op==TK_STRING );
77277       /* Single-instruction constants with a fixed destination are
77278       ** better done in-line.  If we factor them, they will just end
77279       ** up generating an OP_SCopy to move the value to the destination
77280       ** register. */
77281       return 0;
77282     }
77283     case TK_UMINUS: {
77284       if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
77285         return 0;
77286       }
77287       break;
77288     }
77289     default: {
77290       break;
77291     }
77292   }
77293   return 1;
77294 }
77295
77296 /*
77297 ** If pExpr is a constant expression that is appropriate for
77298 ** factoring out of a loop, then evaluate the expression
77299 ** into a register and convert the expression into a TK_REGISTER
77300 ** expression.
77301 */
77302 static int evalConstExpr(Walker *pWalker, Expr *pExpr){
77303   Parse *pParse = pWalker->pParse;
77304   switch( pExpr->op ){
77305     case TK_IN:
77306     case TK_REGISTER: {
77307       return WRC_Prune;
77308     }
77309     case TK_FUNCTION:
77310     case TK_AGG_FUNCTION:
77311     case TK_CONST_FUNC: {
77312       /* The arguments to a function have a fixed destination.
77313       ** Mark them this way to avoid generated unneeded OP_SCopy
77314       ** instructions. 
77315       */
77316       ExprList *pList = pExpr->x.pList;
77317       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
77318       if( pList ){
77319         int i = pList->nExpr;
77320         struct ExprList_item *pItem = pList->a;
77321         for(; i>0; i--, pItem++){
77322           if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
77323         }
77324       }
77325       break;
77326     }
77327   }
77328   if( isAppropriateForFactoring(pExpr) ){
77329     int r1 = ++pParse->nMem;
77330     int r2;
77331     r2 = sqlcipher3ExprCodeTarget(pParse, pExpr, r1);
77332     if( NEVER(r1!=r2) ) sqlcipher3ReleaseTempReg(pParse, r1);
77333     pExpr->op2 = pExpr->op;
77334     pExpr->op = TK_REGISTER;
77335     pExpr->iTable = r2;
77336     return WRC_Prune;
77337   }
77338   return WRC_Continue;
77339 }
77340
77341 /*
77342 ** Preevaluate constant subexpressions within pExpr and store the
77343 ** results in registers.  Modify pExpr so that the constant subexpresions
77344 ** are TK_REGISTER opcodes that refer to the precomputed values.
77345 **
77346 ** This routine is a no-op if the jump to the cookie-check code has
77347 ** already occur.  Since the cookie-check jump is generated prior to
77348 ** any other serious processing, this check ensures that there is no
77349 ** way to accidently bypass the constant initializations.
77350 **
77351 ** This routine is also a no-op if the SQLCIPHER_FactorOutConst optimization
77352 ** is disabled via the sqlcipher3_test_control(SQLCIPHER_TESTCTRL_OPTIMIZATIONS)
77353 ** interface.  This allows test logic to verify that the same answer is
77354 ** obtained for queries regardless of whether or not constants are
77355 ** precomputed into registers or if they are inserted in-line.
77356 */
77357 SQLCIPHER_PRIVATE void sqlcipher3ExprCodeConstants(Parse *pParse, Expr *pExpr){
77358   Walker w;
77359   if( pParse->cookieGoto ) return;
77360   if( (pParse->db->flags & SQLCIPHER_FactorOutConst)!=0 ) return;
77361   w.xExprCallback = evalConstExpr;
77362   w.xSelectCallback = 0;
77363   w.pParse = pParse;
77364   sqlcipher3WalkExpr(&w, pExpr);
77365 }
77366
77367
77368 /*
77369 ** Generate code that pushes the value of every element of the given
77370 ** expression list into a sequence of registers beginning at target.
77371 **
77372 ** Return the number of elements evaluated.
77373 */
77374 SQLCIPHER_PRIVATE int sqlcipher3ExprCodeExprList(
77375   Parse *pParse,     /* Parsing context */
77376   ExprList *pList,   /* The expression list to be coded */
77377   int target,        /* Where to write results */
77378   int doHardCopy     /* Make a hard copy of every element */
77379 ){
77380   struct ExprList_item *pItem;
77381   int i, n;
77382   assert( pList!=0 );
77383   assert( target>0 );
77384   assert( pParse->pVdbe!=0 );  /* Never gets this far otherwise */
77385   n = pList->nExpr;
77386   for(pItem=pList->a, i=0; i<n; i++, pItem++){
77387     Expr *pExpr = pItem->pExpr;
77388     int inReg = sqlcipher3ExprCodeTarget(pParse, pExpr, target+i);
77389     if( inReg!=target+i ){
77390       sqlcipher3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
77391                         inReg, target+i);
77392     }
77393   }
77394   return n;
77395 }
77396
77397 /*
77398 ** Generate code for a BETWEEN operator.
77399 **
77400 **    x BETWEEN y AND z
77401 **
77402 ** The above is equivalent to 
77403 **
77404 **    x>=y AND x<=z
77405 **
77406 ** Code it as such, taking care to do the common subexpression
77407 ** elementation of x.
77408 */
77409 static void exprCodeBetween(
77410   Parse *pParse,    /* Parsing and code generating context */
77411   Expr *pExpr,      /* The BETWEEN expression */
77412   int dest,         /* Jump here if the jump is taken */
77413   int jumpIfTrue,   /* Take the jump if the BETWEEN is true */
77414   int jumpIfNull    /* Take the jump if the BETWEEN is NULL */
77415 ){
77416   Expr exprAnd;     /* The AND operator in  x>=y AND x<=z  */
77417   Expr compLeft;    /* The  x>=y  term */
77418   Expr compRight;   /* The  x<=z  term */
77419   Expr exprX;       /* The  x  subexpression */
77420   int regFree1 = 0; /* Temporary use register */
77421
77422   assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
77423   exprX = *pExpr->pLeft;
77424   exprAnd.op = TK_AND;
77425   exprAnd.pLeft = &compLeft;
77426   exprAnd.pRight = &compRight;
77427   compLeft.op = TK_GE;
77428   compLeft.pLeft = &exprX;
77429   compLeft.pRight = pExpr->x.pList->a[0].pExpr;
77430   compRight.op = TK_LE;
77431   compRight.pLeft = &exprX;
77432   compRight.pRight = pExpr->x.pList->a[1].pExpr;
77433   exprX.iTable = sqlcipher3ExprCodeTemp(pParse, &exprX, &regFree1);
77434   exprX.op = TK_REGISTER;
77435   if( jumpIfTrue ){
77436     sqlcipher3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
77437   }else{
77438     sqlcipher3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
77439   }
77440   sqlcipher3ReleaseTempReg(pParse, regFree1);
77441
77442   /* Ensure adequate test coverage */
77443   testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
77444   testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
77445   testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
77446   testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
77447   testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
77448   testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
77449   testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
77450   testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
77451 }
77452
77453 /*
77454 ** Generate code for a boolean expression such that a jump is made
77455 ** to the label "dest" if the expression is true but execution
77456 ** continues straight thru if the expression is false.
77457 **
77458 ** If the expression evaluates to NULL (neither true nor false), then
77459 ** take the jump if the jumpIfNull flag is SQLCIPHER_JUMPIFNULL.
77460 **
77461 ** This code depends on the fact that certain token values (ex: TK_EQ)
77462 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
77463 ** operation.  Special comments in vdbe.c and the mkopcodeh.awk script in
77464 ** the make process cause these values to align.  Assert()s in the code
77465 ** below verify that the numbers are aligned correctly.
77466 */
77467 SQLCIPHER_PRIVATE void sqlcipher3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
77468   Vdbe *v = pParse->pVdbe;
77469   int op = 0;
77470   int regFree1 = 0;
77471   int regFree2 = 0;
77472   int r1, r2;
77473
77474   assert( jumpIfNull==SQLCIPHER_JUMPIFNULL || jumpIfNull==0 );
77475   if( NEVER(v==0) )     return;  /* Existance of VDBE checked by caller */
77476   if( NEVER(pExpr==0) ) return;  /* No way this can happen */
77477   op = pExpr->op;
77478   switch( op ){
77479     case TK_AND: {
77480       int d2 = sqlcipher3VdbeMakeLabel(v);
77481       testcase( jumpIfNull==0 );
77482       sqlcipher3ExprCachePush(pParse);
77483       sqlcipher3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLCIPHER_JUMPIFNULL);
77484       sqlcipher3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
77485       sqlcipher3VdbeResolveLabel(v, d2);
77486       sqlcipher3ExprCachePop(pParse, 1);
77487       break;
77488     }
77489     case TK_OR: {
77490       testcase( jumpIfNull==0 );
77491       sqlcipher3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
77492       sqlcipher3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
77493       break;
77494     }
77495     case TK_NOT: {
77496       testcase( jumpIfNull==0 );
77497       sqlcipher3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
77498       break;
77499     }
77500     case TK_LT:
77501     case TK_LE:
77502     case TK_GT:
77503     case TK_GE:
77504     case TK_NE:
77505     case TK_EQ: {
77506       assert( TK_LT==OP_Lt );
77507       assert( TK_LE==OP_Le );
77508       assert( TK_GT==OP_Gt );
77509       assert( TK_GE==OP_Ge );
77510       assert( TK_EQ==OP_Eq );
77511       assert( TK_NE==OP_Ne );
77512       testcase( op==TK_LT );
77513       testcase( op==TK_LE );
77514       testcase( op==TK_GT );
77515       testcase( op==TK_GE );
77516       testcase( op==TK_EQ );
77517       testcase( op==TK_NE );
77518       testcase( jumpIfNull==0 );
77519       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
77520       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
77521       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77522                   r1, r2, dest, jumpIfNull);
77523       testcase( regFree1==0 );
77524       testcase( regFree2==0 );
77525       break;
77526     }
77527     case TK_IS:
77528     case TK_ISNOT: {
77529       testcase( op==TK_IS );
77530       testcase( op==TK_ISNOT );
77531       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
77532       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
77533       op = (op==TK_IS) ? TK_EQ : TK_NE;
77534       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77535                   r1, r2, dest, SQLCIPHER_NULLEQ);
77536       testcase( regFree1==0 );
77537       testcase( regFree2==0 );
77538       break;
77539     }
77540     case TK_ISNULL:
77541     case TK_NOTNULL: {
77542       assert( TK_ISNULL==OP_IsNull );
77543       assert( TK_NOTNULL==OP_NotNull );
77544       testcase( op==TK_ISNULL );
77545       testcase( op==TK_NOTNULL );
77546       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
77547       sqlcipher3VdbeAddOp2(v, op, r1, dest);
77548       testcase( regFree1==0 );
77549       break;
77550     }
77551     case TK_BETWEEN: {
77552       testcase( jumpIfNull==0 );
77553       exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
77554       break;
77555     }
77556 #ifndef SQLCIPHER_OMIT_SUBQUERY
77557     case TK_IN: {
77558       int destIfFalse = sqlcipher3VdbeMakeLabel(v);
77559       int destIfNull = jumpIfNull ? dest : destIfFalse;
77560       sqlcipher3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
77561       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, dest);
77562       sqlcipher3VdbeResolveLabel(v, destIfFalse);
77563       break;
77564     }
77565 #endif
77566     default: {
77567       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr, &regFree1);
77568       sqlcipher3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
77569       testcase( regFree1==0 );
77570       testcase( jumpIfNull==0 );
77571       break;
77572     }
77573   }
77574   sqlcipher3ReleaseTempReg(pParse, regFree1);
77575   sqlcipher3ReleaseTempReg(pParse, regFree2);  
77576 }
77577
77578 /*
77579 ** Generate code for a boolean expression such that a jump is made
77580 ** to the label "dest" if the expression is false but execution
77581 ** continues straight thru if the expression is true.
77582 **
77583 ** If the expression evaluates to NULL (neither true nor false) then
77584 ** jump if jumpIfNull is SQLCIPHER_JUMPIFNULL or fall through if jumpIfNull
77585 ** is 0.
77586 */
77587 SQLCIPHER_PRIVATE void sqlcipher3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
77588   Vdbe *v = pParse->pVdbe;
77589   int op = 0;
77590   int regFree1 = 0;
77591   int regFree2 = 0;
77592   int r1, r2;
77593
77594   assert( jumpIfNull==SQLCIPHER_JUMPIFNULL || jumpIfNull==0 );
77595   if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
77596   if( pExpr==0 )    return;
77597
77598   /* The value of pExpr->op and op are related as follows:
77599   **
77600   **       pExpr->op            op
77601   **       ---------          ----------
77602   **       TK_ISNULL          OP_NotNull
77603   **       TK_NOTNULL         OP_IsNull
77604   **       TK_NE              OP_Eq
77605   **       TK_EQ              OP_Ne
77606   **       TK_GT              OP_Le
77607   **       TK_LE              OP_Gt
77608   **       TK_GE              OP_Lt
77609   **       TK_LT              OP_Ge
77610   **
77611   ** For other values of pExpr->op, op is undefined and unused.
77612   ** The value of TK_ and OP_ constants are arranged such that we
77613   ** can compute the mapping above using the following expression.
77614   ** Assert()s verify that the computation is correct.
77615   */
77616   op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
77617
77618   /* Verify correct alignment of TK_ and OP_ constants
77619   */
77620   assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
77621   assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
77622   assert( pExpr->op!=TK_NE || op==OP_Eq );
77623   assert( pExpr->op!=TK_EQ || op==OP_Ne );
77624   assert( pExpr->op!=TK_LT || op==OP_Ge );
77625   assert( pExpr->op!=TK_LE || op==OP_Gt );
77626   assert( pExpr->op!=TK_GT || op==OP_Le );
77627   assert( pExpr->op!=TK_GE || op==OP_Lt );
77628
77629   switch( pExpr->op ){
77630     case TK_AND: {
77631       testcase( jumpIfNull==0 );
77632       sqlcipher3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
77633       sqlcipher3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
77634       break;
77635     }
77636     case TK_OR: {
77637       int d2 = sqlcipher3VdbeMakeLabel(v);
77638       testcase( jumpIfNull==0 );
77639       sqlcipher3ExprCachePush(pParse);
77640       sqlcipher3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLCIPHER_JUMPIFNULL);
77641       sqlcipher3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
77642       sqlcipher3VdbeResolveLabel(v, d2);
77643       sqlcipher3ExprCachePop(pParse, 1);
77644       break;
77645     }
77646     case TK_NOT: {
77647       testcase( jumpIfNull==0 );
77648       sqlcipher3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
77649       break;
77650     }
77651     case TK_LT:
77652     case TK_LE:
77653     case TK_GT:
77654     case TK_GE:
77655     case TK_NE:
77656     case TK_EQ: {
77657       testcase( op==TK_LT );
77658       testcase( op==TK_LE );
77659       testcase( op==TK_GT );
77660       testcase( op==TK_GE );
77661       testcase( op==TK_EQ );
77662       testcase( op==TK_NE );
77663       testcase( jumpIfNull==0 );
77664       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
77665       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
77666       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77667                   r1, r2, dest, jumpIfNull);
77668       testcase( regFree1==0 );
77669       testcase( regFree2==0 );
77670       break;
77671     }
77672     case TK_IS:
77673     case TK_ISNOT: {
77674       testcase( pExpr->op==TK_IS );
77675       testcase( pExpr->op==TK_ISNOT );
77676       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
77677       r2 = sqlcipher3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
77678       op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
77679       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77680                   r1, r2, dest, SQLCIPHER_NULLEQ);
77681       testcase( regFree1==0 );
77682       testcase( regFree2==0 );
77683       break;
77684     }
77685     case TK_ISNULL:
77686     case TK_NOTNULL: {
77687       testcase( op==TK_ISNULL );
77688       testcase( op==TK_NOTNULL );
77689       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
77690       sqlcipher3VdbeAddOp2(v, op, r1, dest);
77691       testcase( regFree1==0 );
77692       break;
77693     }
77694     case TK_BETWEEN: {
77695       testcase( jumpIfNull==0 );
77696       exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
77697       break;
77698     }
77699 #ifndef SQLCIPHER_OMIT_SUBQUERY
77700     case TK_IN: {
77701       if( jumpIfNull ){
77702         sqlcipher3ExprCodeIN(pParse, pExpr, dest, dest);
77703       }else{
77704         int destIfNull = sqlcipher3VdbeMakeLabel(v);
77705         sqlcipher3ExprCodeIN(pParse, pExpr, dest, destIfNull);
77706         sqlcipher3VdbeResolveLabel(v, destIfNull);
77707       }
77708       break;
77709     }
77710 #endif
77711     default: {
77712       r1 = sqlcipher3ExprCodeTemp(pParse, pExpr, &regFree1);
77713       sqlcipher3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
77714       testcase( regFree1==0 );
77715       testcase( jumpIfNull==0 );
77716       break;
77717     }
77718   }
77719   sqlcipher3ReleaseTempReg(pParse, regFree1);
77720   sqlcipher3ReleaseTempReg(pParse, regFree2);
77721 }
77722
77723 /*
77724 ** Do a deep comparison of two expression trees.  Return 0 if the two
77725 ** expressions are completely identical.  Return 1 if they differ only
77726 ** by a COLLATE operator at the top level.  Return 2 if there are differences
77727 ** other than the top-level COLLATE operator.
77728 **
77729 ** Sometimes this routine will return 2 even if the two expressions
77730 ** really are equivalent.  If we cannot prove that the expressions are
77731 ** identical, we return 2 just to be safe.  So if this routine
77732 ** returns 2, then you do not really know for certain if the two
77733 ** expressions are the same.  But if you get a 0 or 1 return, then you
77734 ** can be sure the expressions are the same.  In the places where
77735 ** this routine is used, it does not hurt to get an extra 2 - that
77736 ** just might result in some slightly slower code.  But returning
77737 ** an incorrect 0 or 1 could lead to a malfunction.
77738 */
77739 SQLCIPHER_PRIVATE int sqlcipher3ExprCompare(Expr *pA, Expr *pB){
77740   if( pA==0||pB==0 ){
77741     return pB==pA ? 0 : 2;
77742   }
77743   assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
77744   assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
77745   if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
77746     return 2;
77747   }
77748   if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
77749   if( pA->op!=pB->op ) return 2;
77750   if( sqlcipher3ExprCompare(pA->pLeft, pB->pLeft) ) return 2;
77751   if( sqlcipher3ExprCompare(pA->pRight, pB->pRight) ) return 2;
77752   if( sqlcipher3ExprListCompare(pA->x.pList, pB->x.pList) ) return 2;
77753   if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 2;
77754   if( ExprHasProperty(pA, EP_IntValue) ){
77755     if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
77756       return 2;
77757     }
77758   }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
77759     if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
77760     if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
77761       return 2;
77762     }
77763   }
77764   if( (pA->flags & EP_ExpCollate)!=(pB->flags & EP_ExpCollate) ) return 1;
77765   if( (pA->flags & EP_ExpCollate)!=0 && pA->pColl!=pB->pColl ) return 2;
77766   return 0;
77767 }
77768
77769 /*
77770 ** Compare two ExprList objects.  Return 0 if they are identical and 
77771 ** non-zero if they differ in any way.
77772 **
77773 ** This routine might return non-zero for equivalent ExprLists.  The
77774 ** only consequence will be disabled optimizations.  But this routine
77775 ** must never return 0 if the two ExprList objects are different, or
77776 ** a malfunction will result.
77777 **
77778 ** Two NULL pointers are considered to be the same.  But a NULL pointer
77779 ** always differs from a non-NULL pointer.
77780 */
77781 SQLCIPHER_PRIVATE int sqlcipher3ExprListCompare(ExprList *pA, ExprList *pB){
77782   int i;
77783   if( pA==0 && pB==0 ) return 0;
77784   if( pA==0 || pB==0 ) return 1;
77785   if( pA->nExpr!=pB->nExpr ) return 1;
77786   for(i=0; i<pA->nExpr; i++){
77787     Expr *pExprA = pA->a[i].pExpr;
77788     Expr *pExprB = pB->a[i].pExpr;
77789     if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
77790     if( sqlcipher3ExprCompare(pExprA, pExprB) ) return 1;
77791   }
77792   return 0;
77793 }
77794
77795 /*
77796 ** Add a new element to the pAggInfo->aCol[] array.  Return the index of
77797 ** the new element.  Return a negative number if malloc fails.
77798 */
77799 static int addAggInfoColumn(sqlcipher3 *db, AggInfo *pInfo){
77800   int i;
77801   pInfo->aCol = sqlcipher3ArrayAllocate(
77802        db,
77803        pInfo->aCol,
77804        sizeof(pInfo->aCol[0]),
77805        3,
77806        &pInfo->nColumn,
77807        &pInfo->nColumnAlloc,
77808        &i
77809   );
77810   return i;
77811 }    
77812
77813 /*
77814 ** Add a new element to the pAggInfo->aFunc[] array.  Return the index of
77815 ** the new element.  Return a negative number if malloc fails.
77816 */
77817 static int addAggInfoFunc(sqlcipher3 *db, AggInfo *pInfo){
77818   int i;
77819   pInfo->aFunc = sqlcipher3ArrayAllocate(
77820        db, 
77821        pInfo->aFunc,
77822        sizeof(pInfo->aFunc[0]),
77823        3,
77824        &pInfo->nFunc,
77825        &pInfo->nFuncAlloc,
77826        &i
77827   );
77828   return i;
77829 }    
77830
77831 /*
77832 ** This is the xExprCallback for a tree walker.  It is used to
77833 ** implement sqlcipher3ExprAnalyzeAggregates().  See sqlcipher3ExprAnalyzeAggregates
77834 ** for additional information.
77835 */
77836 static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
77837   int i;
77838   NameContext *pNC = pWalker->u.pNC;
77839   Parse *pParse = pNC->pParse;
77840   SrcList *pSrcList = pNC->pSrcList;
77841   AggInfo *pAggInfo = pNC->pAggInfo;
77842
77843   switch( pExpr->op ){
77844     case TK_AGG_COLUMN:
77845     case TK_COLUMN: {
77846       testcase( pExpr->op==TK_AGG_COLUMN );
77847       testcase( pExpr->op==TK_COLUMN );
77848       /* Check to see if the column is in one of the tables in the FROM
77849       ** clause of the aggregate query */
77850       if( ALWAYS(pSrcList!=0) ){
77851         struct SrcList_item *pItem = pSrcList->a;
77852         for(i=0; i<pSrcList->nSrc; i++, pItem++){
77853           struct AggInfo_col *pCol;
77854           assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
77855           if( pExpr->iTable==pItem->iCursor ){
77856             /* If we reach this point, it means that pExpr refers to a table
77857             ** that is in the FROM clause of the aggregate query.  
77858             **
77859             ** Make an entry for the column in pAggInfo->aCol[] if there
77860             ** is not an entry there already.
77861             */
77862             int k;
77863             pCol = pAggInfo->aCol;
77864             for(k=0; k<pAggInfo->nColumn; k++, pCol++){
77865               if( pCol->iTable==pExpr->iTable &&
77866                   pCol->iColumn==pExpr->iColumn ){
77867                 break;
77868               }
77869             }
77870             if( (k>=pAggInfo->nColumn)
77871              && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 
77872             ){
77873               pCol = &pAggInfo->aCol[k];
77874               pCol->pTab = pExpr->pTab;
77875               pCol->iTable = pExpr->iTable;
77876               pCol->iColumn = pExpr->iColumn;
77877               pCol->iMem = ++pParse->nMem;
77878               pCol->iSorterColumn = -1;
77879               pCol->pExpr = pExpr;
77880               if( pAggInfo->pGroupBy ){
77881                 int j, n;
77882                 ExprList *pGB = pAggInfo->pGroupBy;
77883                 struct ExprList_item *pTerm = pGB->a;
77884                 n = pGB->nExpr;
77885                 for(j=0; j<n; j++, pTerm++){
77886                   Expr *pE = pTerm->pExpr;
77887                   if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
77888                       pE->iColumn==pExpr->iColumn ){
77889                     pCol->iSorterColumn = j;
77890                     break;
77891                   }
77892                 }
77893               }
77894               if( pCol->iSorterColumn<0 ){
77895                 pCol->iSorterColumn = pAggInfo->nSortingColumn++;
77896               }
77897             }
77898             /* There is now an entry for pExpr in pAggInfo->aCol[] (either
77899             ** because it was there before or because we just created it).
77900             ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
77901             ** pAggInfo->aCol[] entry.
77902             */
77903             ExprSetIrreducible(pExpr);
77904             pExpr->pAggInfo = pAggInfo;
77905             pExpr->op = TK_AGG_COLUMN;
77906             pExpr->iAgg = (i16)k;
77907             break;
77908           } /* endif pExpr->iTable==pItem->iCursor */
77909         } /* end loop over pSrcList */
77910       }
77911       return WRC_Prune;
77912     }
77913     case TK_AGG_FUNCTION: {
77914       /* The pNC->nDepth==0 test causes aggregate functions in subqueries
77915       ** to be ignored */
77916       if( pNC->nDepth==0 ){
77917         /* Check to see if pExpr is a duplicate of another aggregate 
77918         ** function that is already in the pAggInfo structure
77919         */
77920         struct AggInfo_func *pItem = pAggInfo->aFunc;
77921         for(i=0; i<pAggInfo->nFunc; i++, pItem++){
77922           if( sqlcipher3ExprCompare(pItem->pExpr, pExpr)==0 ){
77923             break;
77924           }
77925         }
77926         if( i>=pAggInfo->nFunc ){
77927           /* pExpr is original.  Make a new entry in pAggInfo->aFunc[]
77928           */
77929           u8 enc = ENC(pParse->db);
77930           i = addAggInfoFunc(pParse->db, pAggInfo);
77931           if( i>=0 ){
77932             assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
77933             pItem = &pAggInfo->aFunc[i];
77934             pItem->pExpr = pExpr;
77935             pItem->iMem = ++pParse->nMem;
77936             assert( !ExprHasProperty(pExpr, EP_IntValue) );
77937             pItem->pFunc = sqlcipher3FindFunction(pParse->db,
77938                    pExpr->u.zToken, sqlcipher3Strlen30(pExpr->u.zToken),
77939                    pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
77940             if( pExpr->flags & EP_Distinct ){
77941               pItem->iDistinct = pParse->nTab++;
77942             }else{
77943               pItem->iDistinct = -1;
77944             }
77945           }
77946         }
77947         /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
77948         */
77949         assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
77950         ExprSetIrreducible(pExpr);
77951         pExpr->iAgg = (i16)i;
77952         pExpr->pAggInfo = pAggInfo;
77953         return WRC_Prune;
77954       }
77955     }
77956   }
77957   return WRC_Continue;
77958 }
77959 static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
77960   NameContext *pNC = pWalker->u.pNC;
77961   if( pNC->nDepth==0 ){
77962     pNC->nDepth++;
77963     sqlcipher3WalkSelect(pWalker, pSelect);
77964     pNC->nDepth--;
77965     return WRC_Prune;
77966   }else{
77967     return WRC_Continue;
77968   }
77969 }
77970
77971 /*
77972 ** Analyze the given expression looking for aggregate functions and
77973 ** for variables that need to be added to the pParse->aAgg[] array.
77974 ** Make additional entries to the pParse->aAgg[] array as necessary.
77975 **
77976 ** This routine should only be called after the expression has been
77977 ** analyzed by sqlcipher3ResolveExprNames().
77978 */
77979 SQLCIPHER_PRIVATE void sqlcipher3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
77980   Walker w;
77981   w.xExprCallback = analyzeAggregate;
77982   w.xSelectCallback = analyzeAggregatesInSelect;
77983   w.u.pNC = pNC;
77984   assert( pNC->pSrcList!=0 );
77985   sqlcipher3WalkExpr(&w, pExpr);
77986 }
77987
77988 /*
77989 ** Call sqlcipher3ExprAnalyzeAggregates() for every expression in an
77990 ** expression list.  Return the number of errors.
77991 **
77992 ** If an error is found, the analysis is cut short.
77993 */
77994 SQLCIPHER_PRIVATE void sqlcipher3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
77995   struct ExprList_item *pItem;
77996   int i;
77997   if( pList ){
77998     for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
77999       sqlcipher3ExprAnalyzeAggregates(pNC, pItem->pExpr);
78000     }
78001   }
78002 }
78003
78004 /*
78005 ** Allocate a single new register for use to hold some intermediate result.
78006 */
78007 SQLCIPHER_PRIVATE int sqlcipher3GetTempReg(Parse *pParse){
78008   if( pParse->nTempReg==0 ){
78009     return ++pParse->nMem;
78010   }
78011   return pParse->aTempReg[--pParse->nTempReg];
78012 }
78013
78014 /*
78015 ** Deallocate a register, making available for reuse for some other
78016 ** purpose.
78017 **
78018 ** If a register is currently being used by the column cache, then
78019 ** the dallocation is deferred until the column cache line that uses
78020 ** the register becomes stale.
78021 */
78022 SQLCIPHER_PRIVATE void sqlcipher3ReleaseTempReg(Parse *pParse, int iReg){
78023   if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
78024     int i;
78025     struct yColCache *p;
78026     for(i=0, p=pParse->aColCache; i<SQLCIPHER_N_COLCACHE; i++, p++){
78027       if( p->iReg==iReg ){
78028         p->tempReg = 1;
78029         return;
78030       }
78031     }
78032     pParse->aTempReg[pParse->nTempReg++] = iReg;
78033   }
78034 }
78035
78036 /*
78037 ** Allocate or deallocate a block of nReg consecutive registers
78038 */
78039 SQLCIPHER_PRIVATE int sqlcipher3GetTempRange(Parse *pParse, int nReg){
78040   int i, n;
78041   i = pParse->iRangeReg;
78042   n = pParse->nRangeReg;
78043   if( nReg<=n ){
78044     assert( !usedAsColumnCache(pParse, i, i+n-1) );
78045     pParse->iRangeReg += nReg;
78046     pParse->nRangeReg -= nReg;
78047   }else{
78048     i = pParse->nMem+1;
78049     pParse->nMem += nReg;
78050   }
78051   return i;
78052 }
78053 SQLCIPHER_PRIVATE void sqlcipher3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
78054   sqlcipher3ExprCacheRemove(pParse, iReg, nReg);
78055   if( nReg>pParse->nRangeReg ){
78056     pParse->nRangeReg = nReg;
78057     pParse->iRangeReg = iReg;
78058   }
78059 }
78060
78061 /************** End of expr.c ************************************************/
78062 /************** Begin file alter.c *******************************************/
78063 /*
78064 ** 2005 February 15
78065 **
78066 ** The author disclaims copyright to this source code.  In place of
78067 ** a legal notice, here is a blessing:
78068 **
78069 **    May you do good and not evil.
78070 **    May you find forgiveness for yourself and forgive others.
78071 **    May you share freely, never taking more than you give.
78072 **
78073 *************************************************************************
78074 ** This file contains C code routines that used to generate VDBE code
78075 ** that implements the ALTER TABLE command.
78076 */
78077
78078 /*
78079 ** The code in this file only exists if we are not omitting the
78080 ** ALTER TABLE logic from the build.
78081 */
78082 #ifndef SQLCIPHER_OMIT_ALTERTABLE
78083
78084
78085 /*
78086 ** This function is used by SQL generated to implement the 
78087 ** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
78088 ** CREATE INDEX command. The second is a table name. The table name in 
78089 ** the CREATE TABLE or CREATE INDEX statement is replaced with the third
78090 ** argument and the result returned. Examples:
78091 **
78092 ** sqlcipher_rename_table('CREATE TABLE abc(a, b, c)', 'def')
78093 **     -> 'CREATE TABLE def(a, b, c)'
78094 **
78095 ** sqlcipher_rename_table('CREATE INDEX i ON abc(a)', 'def')
78096 **     -> 'CREATE INDEX i ON def(a, b, c)'
78097 */
78098 static void renameTableFunc(
78099   sqlcipher3_context *context,
78100   int NotUsed,
78101   sqlcipher3_value **argv
78102 ){
78103   unsigned char const *zSql = sqlcipher3_value_text(argv[0]);
78104   unsigned char const *zTableName = sqlcipher3_value_text(argv[1]);
78105
78106   int token;
78107   Token tname;
78108   unsigned char const *zCsr = zSql;
78109   int len = 0;
78110   char *zRet;
78111
78112   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
78113
78114   UNUSED_PARAMETER(NotUsed);
78115
78116   /* The principle used to locate the table name in the CREATE TABLE 
78117   ** statement is that the table name is the first non-space token that
78118   ** is immediately followed by a TK_LP or TK_USING token.
78119   */
78120   if( zSql ){
78121     do {
78122       if( !*zCsr ){
78123         /* Ran out of input before finding an opening bracket. Return NULL. */
78124         return;
78125       }
78126
78127       /* Store the token that zCsr points to in tname. */
78128       tname.z = (char*)zCsr;
78129       tname.n = len;
78130
78131       /* Advance zCsr to the next token. Store that token type in 'token',
78132       ** and its length in 'len' (to be used next iteration of this loop).
78133       */
78134       do {
78135         zCsr += len;
78136         len = sqlcipher3GetToken(zCsr, &token);
78137       } while( token==TK_SPACE );
78138       assert( len>0 );
78139     } while( token!=TK_LP && token!=TK_USING );
78140
78141     zRet = sqlcipher3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql, 
78142        zTableName, tname.z+tname.n);
78143     sqlcipher3_result_text(context, zRet, -1, SQLCIPHER_DYNAMIC);
78144   }
78145 }
78146
78147 /*
78148 ** This C function implements an SQL user function that is used by SQL code
78149 ** generated by the ALTER TABLE ... RENAME command to modify the definition
78150 ** of any foreign key constraints that use the table being renamed as the 
78151 ** parent table. It is passed three arguments:
78152 **
78153 **   1) The complete text of the CREATE TABLE statement being modified,
78154 **   2) The old name of the table being renamed, and
78155 **   3) The new name of the table being renamed.
78156 **
78157 ** It returns the new CREATE TABLE statement. For example:
78158 **
78159 **   sqlcipher_rename_parent('CREATE TABLE t1(a REFERENCES t2)', 't2', 't3')
78160 **       -> 'CREATE TABLE t1(a REFERENCES t3)'
78161 */
78162 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
78163 static void renameParentFunc(
78164   sqlcipher3_context *context,
78165   int NotUsed,
78166   sqlcipher3_value **argv
78167 ){
78168   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
78169   char *zOutput = 0;
78170   char *zResult;
78171   unsigned char const *zInput = sqlcipher3_value_text(argv[0]);
78172   unsigned char const *zOld = sqlcipher3_value_text(argv[1]);
78173   unsigned char const *zNew = sqlcipher3_value_text(argv[2]);
78174
78175   unsigned const char *z;         /* Pointer to token */
78176   int n;                          /* Length of token z */
78177   int token;                      /* Type of token */
78178
78179   UNUSED_PARAMETER(NotUsed);
78180   for(z=zInput; *z; z=z+n){
78181     n = sqlcipher3GetToken(z, &token);
78182     if( token==TK_REFERENCES ){
78183       char *zParent;
78184       do {
78185         z += n;
78186         n = sqlcipher3GetToken(z, &token);
78187       }while( token==TK_SPACE );
78188
78189       zParent = sqlcipher3DbStrNDup(db, (const char *)z, n);
78190       if( zParent==0 ) break;
78191       sqlcipher3Dequote(zParent);
78192       if( 0==sqlcipher3StrICmp((const char *)zOld, zParent) ){
78193         char *zOut = sqlcipher3MPrintf(db, "%s%.*s\"%w\"", 
78194             (zOutput?zOutput:""), z-zInput, zInput, (const char *)zNew
78195         );
78196         sqlcipher3DbFree(db, zOutput);
78197         zOutput = zOut;
78198         zInput = &z[n];
78199       }
78200       sqlcipher3DbFree(db, zParent);
78201     }
78202   }
78203
78204   zResult = sqlcipher3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput), 
78205   sqlcipher3_result_text(context, zResult, -1, SQLCIPHER_DYNAMIC);
78206   sqlcipher3DbFree(db, zOutput);
78207 }
78208 #endif
78209
78210 #ifndef SQLCIPHER_OMIT_TRIGGER
78211 /* This function is used by SQL generated to implement the
78212 ** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER 
78213 ** statement. The second is a table name. The table name in the CREATE 
78214 ** TRIGGER statement is replaced with the third argument and the result 
78215 ** returned. This is analagous to renameTableFunc() above, except for CREATE
78216 ** TRIGGER, not CREATE INDEX and CREATE TABLE.
78217 */
78218 static void renameTriggerFunc(
78219   sqlcipher3_context *context,
78220   int NotUsed,
78221   sqlcipher3_value **argv
78222 ){
78223   unsigned char const *zSql = sqlcipher3_value_text(argv[0]);
78224   unsigned char const *zTableName = sqlcipher3_value_text(argv[1]);
78225
78226   int token;
78227   Token tname;
78228   int dist = 3;
78229   unsigned char const *zCsr = zSql;
78230   int len = 0;
78231   char *zRet;
78232   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
78233
78234   UNUSED_PARAMETER(NotUsed);
78235
78236   /* The principle used to locate the table name in the CREATE TRIGGER 
78237   ** statement is that the table name is the first token that is immediatedly
78238   ** preceded by either TK_ON or TK_DOT and immediatedly followed by one
78239   ** of TK_WHEN, TK_BEGIN or TK_FOR.
78240   */
78241   if( zSql ){
78242     do {
78243
78244       if( !*zCsr ){
78245         /* Ran out of input before finding the table name. Return NULL. */
78246         return;
78247       }
78248
78249       /* Store the token that zCsr points to in tname. */
78250       tname.z = (char*)zCsr;
78251       tname.n = len;
78252
78253       /* Advance zCsr to the next token. Store that token type in 'token',
78254       ** and its length in 'len' (to be used next iteration of this loop).
78255       */
78256       do {
78257         zCsr += len;
78258         len = sqlcipher3GetToken(zCsr, &token);
78259       }while( token==TK_SPACE );
78260       assert( len>0 );
78261
78262       /* Variable 'dist' stores the number of tokens read since the most
78263       ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN 
78264       ** token is read and 'dist' equals 2, the condition stated above
78265       ** to be met.
78266       **
78267       ** Note that ON cannot be a database, table or column name, so
78268       ** there is no need to worry about syntax like 
78269       ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc.
78270       */
78271       dist++;
78272       if( token==TK_DOT || token==TK_ON ){
78273         dist = 0;
78274       }
78275     } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) );
78276
78277     /* Variable tname now contains the token that is the old table-name
78278     ** in the CREATE TRIGGER statement.
78279     */
78280     zRet = sqlcipher3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql, 
78281        zTableName, tname.z+tname.n);
78282     sqlcipher3_result_text(context, zRet, -1, SQLCIPHER_DYNAMIC);
78283   }
78284 }
78285 #endif   /* !SQLCIPHER_OMIT_TRIGGER */
78286
78287 /*
78288 ** Register built-in functions used to help implement ALTER TABLE
78289 */
78290 SQLCIPHER_PRIVATE void sqlcipher3AlterFunctions(void){
78291   static SQLCIPHER_WSD FuncDef aAlterTableFuncs[] = {
78292     FUNCTION(sqlcipher_rename_table,   2, 0, 0, renameTableFunc),
78293 #ifndef SQLCIPHER_OMIT_TRIGGER
78294     FUNCTION(sqlcipher_rename_trigger, 2, 0, 0, renameTriggerFunc),
78295 #endif
78296 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
78297     FUNCTION(sqlcipher_rename_parent,  3, 0, 0, renameParentFunc),
78298 #endif
78299   };
78300   int i;
78301   FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlcipher3GlobalFunctions);
78302   FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs);
78303
78304   for(i=0; i<ArraySize(aAlterTableFuncs); i++){
78305     sqlcipher3FuncDefInsert(pHash, &aFunc[i]);
78306   }
78307 }
78308
78309 /*
78310 ** This function is used to create the text of expressions of the form:
78311 **
78312 **   name=<constant1> OR name=<constant2> OR ...
78313 **
78314 ** If argument zWhere is NULL, then a pointer string containing the text 
78315 ** "name=<constant>" is returned, where <constant> is the quoted version
78316 ** of the string passed as argument zConstant. The returned buffer is
78317 ** allocated using sqlcipher3DbMalloc(). It is the responsibility of the
78318 ** caller to ensure that it is eventually freed.
78319 **
78320 ** If argument zWhere is not NULL, then the string returned is 
78321 ** "<where> OR name=<constant>", where <where> is the contents of zWhere.
78322 ** In this case zWhere is passed to sqlcipher3DbFree() before returning.
78323 ** 
78324 */
78325 static char *whereOrName(sqlcipher3 *db, char *zWhere, char *zConstant){
78326   char *zNew;
78327   if( !zWhere ){
78328     zNew = sqlcipher3MPrintf(db, "name=%Q", zConstant);
78329   }else{
78330     zNew = sqlcipher3MPrintf(db, "%s OR name=%Q", zWhere, zConstant);
78331     sqlcipher3DbFree(db, zWhere);
78332   }
78333   return zNew;
78334 }
78335
78336 #if !defined(SQLCIPHER_OMIT_FOREIGN_KEY) && !defined(SQLCIPHER_OMIT_TRIGGER)
78337 /*
78338 ** Generate the text of a WHERE expression which can be used to select all
78339 ** tables that have foreign key constraints that refer to table pTab (i.e.
78340 ** constraints for which pTab is the parent table) from the sqlcipher_master
78341 ** table.
78342 */
78343 static char *whereForeignKeys(Parse *pParse, Table *pTab){
78344   FKey *p;
78345   char *zWhere = 0;
78346   for(p=sqlcipher3FkReferences(pTab); p; p=p->pNextTo){
78347     zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
78348   }
78349   return zWhere;
78350 }
78351 #endif
78352
78353 /*
78354 ** Generate the text of a WHERE expression which can be used to select all
78355 ** temporary triggers on table pTab from the sqlcipher_temp_master table. If
78356 ** table pTab has no temporary triggers, or is itself stored in the 
78357 ** temporary database, NULL is returned.
78358 */
78359 static char *whereTempTriggers(Parse *pParse, Table *pTab){
78360   Trigger *pTrig;
78361   char *zWhere = 0;
78362   const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
78363
78364   /* If the table is not located in the temp-db (in which case NULL is 
78365   ** returned, loop through the tables list of triggers. For each trigger
78366   ** that is not part of the temp-db schema, add a clause to the WHERE 
78367   ** expression being built up in zWhere.
78368   */
78369   if( pTab->pSchema!=pTempSchema ){
78370     sqlcipher3 *db = pParse->db;
78371     for(pTrig=sqlcipher3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
78372       if( pTrig->pSchema==pTempSchema ){
78373         zWhere = whereOrName(db, zWhere, pTrig->zName);
78374       }
78375     }
78376   }
78377   if( zWhere ){
78378     char *zNew = sqlcipher3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
78379     sqlcipher3DbFree(pParse->db, zWhere);
78380     zWhere = zNew;
78381   }
78382   return zWhere;
78383 }
78384
78385 /*
78386 ** Generate code to drop and reload the internal representation of table
78387 ** pTab from the database, including triggers and temporary triggers.
78388 ** Argument zName is the name of the table in the database schema at
78389 ** the time the generated code is executed. This can be different from
78390 ** pTab->zName if this function is being called to code part of an 
78391 ** "ALTER TABLE RENAME TO" statement.
78392 */
78393 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
78394   Vdbe *v;
78395   char *zWhere;
78396   int iDb;                   /* Index of database containing pTab */
78397 #ifndef SQLCIPHER_OMIT_TRIGGER
78398   Trigger *pTrig;
78399 #endif
78400
78401   v = sqlcipher3GetVdbe(pParse);
78402   if( NEVER(v==0) ) return;
78403   assert( sqlcipher3BtreeHoldsAllMutexes(pParse->db) );
78404   iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
78405   assert( iDb>=0 );
78406
78407 #ifndef SQLCIPHER_OMIT_TRIGGER
78408   /* Drop any table triggers from the internal schema. */
78409   for(pTrig=sqlcipher3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
78410     int iTrigDb = sqlcipher3SchemaToIndex(pParse->db, pTrig->pSchema);
78411     assert( iTrigDb==iDb || iTrigDb==1 );
78412     sqlcipher3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
78413   }
78414 #endif
78415
78416   /* Drop the table and index from the internal schema.  */
78417   sqlcipher3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
78418
78419   /* Reload the table, index and permanent trigger schemas. */
78420   zWhere = sqlcipher3MPrintf(pParse->db, "tbl_name=%Q", zName);
78421   if( !zWhere ) return;
78422   sqlcipher3VdbeAddParseSchemaOp(v, iDb, zWhere);
78423
78424 #ifndef SQLCIPHER_OMIT_TRIGGER
78425   /* Now, if the table is not stored in the temp database, reload any temp 
78426   ** triggers. Don't use IN(...) in case SQLCIPHER_OMIT_SUBQUERY is defined. 
78427   */
78428   if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
78429     sqlcipher3VdbeAddParseSchemaOp(v, 1, zWhere);
78430   }
78431 #endif
78432 }
78433
78434 /*
78435 ** Parameter zName is the name of a table that is about to be altered
78436 ** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
78437 ** If the table is a system table, this function leaves an error message
78438 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
78439 **
78440 ** Or, if zName is not a system table, zero is returned.
78441 */
78442 static int isSystemTable(Parse *pParse, const char *zName){
78443   if( sqlcipher3Strlen30(zName)>6 && 0==sqlcipher3StrNICmp(zName, "sqlcipher_", 7) ){
78444     sqlcipher3ErrorMsg(pParse, "table %s may not be altered", zName);
78445     return 1;
78446   }
78447   return 0;
78448 }
78449
78450 /*
78451 ** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" 
78452 ** command. 
78453 */
78454 SQLCIPHER_PRIVATE void sqlcipher3AlterRenameTable(
78455   Parse *pParse,            /* Parser context. */
78456   SrcList *pSrc,            /* The table to rename. */
78457   Token *pName              /* The new table name. */
78458 ){
78459   int iDb;                  /* Database that contains the table */
78460   char *zDb;                /* Name of database iDb */
78461   Table *pTab;              /* Table being renamed */
78462   char *zName = 0;          /* NULL-terminated version of pName */ 
78463   sqlcipher3 *db = pParse->db; /* Database connection */
78464   int nTabName;             /* Number of UTF-8 characters in zTabName */
78465   const char *zTabName;     /* Original name of the table */
78466   Vdbe *v;
78467 #ifndef SQLCIPHER_OMIT_TRIGGER
78468   char *zWhere = 0;         /* Where clause to locate temp triggers */
78469 #endif
78470   VTable *pVTab = 0;        /* Non-zero if this is a v-tab with an xRename() */
78471   int savedDbFlags;         /* Saved value of db->flags */
78472
78473   savedDbFlags = db->flags;  
78474   if( NEVER(db->mallocFailed) ) goto exit_rename_table;
78475   assert( pSrc->nSrc==1 );
78476   assert( sqlcipher3BtreeHoldsAllMutexes(pParse->db) );
78477
78478   pTab = sqlcipher3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
78479   if( !pTab ) goto exit_rename_table;
78480   iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
78481   zDb = db->aDb[iDb].zName;
78482   db->flags |= SQLCIPHER_PreferBuiltin;
78483
78484   /* Get a NULL terminated version of the new table name. */
78485   zName = sqlcipher3NameFromToken(db, pName);
78486   if( !zName ) goto exit_rename_table;
78487
78488   /* Check that a table or index named 'zName' does not already exist
78489   ** in database iDb. If so, this is an error.
78490   */
78491   if( sqlcipher3FindTable(db, zName, zDb) || sqlcipher3FindIndex(db, zName, zDb) ){
78492     sqlcipher3ErrorMsg(pParse, 
78493         "there is already another table or index with this name: %s", zName);
78494     goto exit_rename_table;
78495   }
78496
78497   /* Make sure it is not a system table being altered, or a reserved name
78498   ** that the table is being renamed to.
78499   */
78500   if( SQLCIPHER_OK!=isSystemTable(pParse, pTab->zName) ){
78501     goto exit_rename_table;
78502   }
78503   if( SQLCIPHER_OK!=sqlcipher3CheckObjectName(pParse, zName) ){ goto
78504     exit_rename_table;
78505   }
78506
78507 #ifndef SQLCIPHER_OMIT_VIEW
78508   if( pTab->pSelect ){
78509     sqlcipher3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
78510     goto exit_rename_table;
78511   }
78512 #endif
78513
78514 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
78515   /* Invoke the authorization callback. */
78516   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_ALTER_TABLE, zDb, pTab->zName, 0) ){
78517     goto exit_rename_table;
78518   }
78519 #endif
78520
78521 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
78522   if( sqlcipher3ViewGetColumnNames(pParse, pTab) ){
78523     goto exit_rename_table;
78524   }
78525   if( IsVirtual(pTab) ){
78526     pVTab = sqlcipher3GetVTable(db, pTab);
78527     if( pVTab->pVtab->pModule->xRename==0 ){
78528       pVTab = 0;
78529     }
78530   }
78531 #endif
78532
78533   /* Begin a transaction and code the VerifyCookie for database iDb. 
78534   ** Then modify the schema cookie (since the ALTER TABLE modifies the
78535   ** schema). Open a statement transaction if the table is a virtual
78536   ** table.
78537   */
78538   v = sqlcipher3GetVdbe(pParse);
78539   if( v==0 ){
78540     goto exit_rename_table;
78541   }
78542   sqlcipher3BeginWriteOperation(pParse, pVTab!=0, iDb);
78543   sqlcipher3ChangeCookie(pParse, iDb);
78544
78545   /* If this is a virtual table, invoke the xRename() function if
78546   ** one is defined. The xRename() callback will modify the names
78547   ** of any resources used by the v-table implementation (including other
78548   ** SQLite tables) that are identified by the name of the virtual table.
78549   */
78550 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
78551   if( pVTab ){
78552     int i = ++pParse->nMem;
78553     sqlcipher3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
78554     sqlcipher3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
78555     sqlcipher3MayAbort(pParse);
78556   }
78557 #endif
78558
78559   /* figure out how many UTF-8 characters are in zName */
78560   zTabName = pTab->zName;
78561   nTabName = sqlcipher3Utf8CharLen(zTabName, -1);
78562
78563 #if !defined(SQLCIPHER_OMIT_FOREIGN_KEY) && !defined(SQLCIPHER_OMIT_TRIGGER)
78564   if( db->flags&SQLCIPHER_ForeignKeys ){
78565     /* If foreign-key support is enabled, rewrite the CREATE TABLE 
78566     ** statements corresponding to all child tables of foreign key constraints
78567     ** for which the renamed table is the parent table.  */
78568     if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
78569       sqlcipher3NestedParse(pParse, 
78570           "UPDATE \"%w\".%s SET "
78571               "sql = sqlcipher_rename_parent(sql, %Q, %Q) "
78572               "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
78573       sqlcipher3DbFree(db, zWhere);
78574     }
78575   }
78576 #endif
78577
78578   /* Modify the sqlcipher_master table to use the new table name. */
78579   sqlcipher3NestedParse(pParse,
78580       "UPDATE %Q.%s SET "
78581 #ifdef SQLCIPHER_OMIT_TRIGGER
78582           "sql = sqlcipher_rename_table(sql, %Q), "
78583 #else
78584           "sql = CASE "
78585             "WHEN type = 'trigger' THEN sqlcipher_rename_trigger(sql, %Q)"
78586             "ELSE sqlcipher_rename_table(sql, %Q) END, "
78587 #endif
78588           "tbl_name = %Q, "
78589           "name = CASE "
78590             "WHEN type='table' THEN %Q "
78591             "WHEN name LIKE 'sqlcipher_autoindex%%' AND type='index' THEN "
78592              "'sqlcipher_autoindex_' || %Q || substr(name,%d+18) "
78593             "ELSE name END "
78594       "WHERE tbl_name=%Q AND "
78595           "(type='table' OR type='index' OR type='trigger');", 
78596       zDb, SCHEMA_TABLE(iDb), zName, zName, zName, 
78597 #ifndef SQLCIPHER_OMIT_TRIGGER
78598       zName,
78599 #endif
78600       zName, nTabName, zTabName
78601   );
78602
78603 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
78604   /* If the sqlcipher_sequence table exists in this database, then update 
78605   ** it with the new table name.
78606   */
78607   if( sqlcipher3FindTable(db, "sqlcipher_sequence", zDb) ){
78608     sqlcipher3NestedParse(pParse,
78609         "UPDATE \"%w\".sqlcipher_sequence set name = %Q WHERE name = %Q",
78610         zDb, zName, pTab->zName);
78611   }
78612 #endif
78613
78614 #ifndef SQLCIPHER_OMIT_TRIGGER
78615   /* If there are TEMP triggers on this table, modify the sqlcipher_temp_master
78616   ** table. Don't do this if the table being ALTERed is itself located in
78617   ** the temp database.
78618   */
78619   if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
78620     sqlcipher3NestedParse(pParse, 
78621         "UPDATE sqlcipher_temp_master SET "
78622             "sql = sqlcipher_rename_trigger(sql, %Q), "
78623             "tbl_name = %Q "
78624             "WHERE %s;", zName, zName, zWhere);
78625     sqlcipher3DbFree(db, zWhere);
78626   }
78627 #endif
78628
78629 #if !defined(SQLCIPHER_OMIT_FOREIGN_KEY) && !defined(SQLCIPHER_OMIT_TRIGGER)
78630   if( db->flags&SQLCIPHER_ForeignKeys ){
78631     FKey *p;
78632     for(p=sqlcipher3FkReferences(pTab); p; p=p->pNextTo){
78633       Table *pFrom = p->pFrom;
78634       if( pFrom!=pTab ){
78635         reloadTableSchema(pParse, p->pFrom, pFrom->zName);
78636       }
78637     }
78638   }
78639 #endif
78640
78641   /* Drop and reload the internal table schema. */
78642   reloadTableSchema(pParse, pTab, zName);
78643
78644 exit_rename_table:
78645   sqlcipher3SrcListDelete(db, pSrc);
78646   sqlcipher3DbFree(db, zName);
78647   db->flags = savedDbFlags;
78648 }
78649
78650
78651 /*
78652 ** Generate code to make sure the file format number is at least minFormat.
78653 ** The generated code will increase the file format number if necessary.
78654 */
78655 SQLCIPHER_PRIVATE void sqlcipher3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
78656   Vdbe *v;
78657   v = sqlcipher3GetVdbe(pParse);
78658   /* The VDBE should have been allocated before this routine is called.
78659   ** If that allocation failed, we would have quit before reaching this
78660   ** point */
78661   if( ALWAYS(v) ){
78662     int r1 = sqlcipher3GetTempReg(pParse);
78663     int r2 = sqlcipher3GetTempReg(pParse);
78664     int j1;
78665     sqlcipher3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
78666     sqlcipher3VdbeUsesBtree(v, iDb);
78667     sqlcipher3VdbeAddOp2(v, OP_Integer, minFormat, r2);
78668     j1 = sqlcipher3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
78669     sqlcipher3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
78670     sqlcipher3VdbeJumpHere(v, j1);
78671     sqlcipher3ReleaseTempReg(pParse, r1);
78672     sqlcipher3ReleaseTempReg(pParse, r2);
78673   }
78674 }
78675
78676 /*
78677 ** This function is called after an "ALTER TABLE ... ADD" statement
78678 ** has been parsed. Argument pColDef contains the text of the new
78679 ** column definition.
78680 **
78681 ** The Table structure pParse->pNewTable was extended to include
78682 ** the new column during parsing.
78683 */
78684 SQLCIPHER_PRIVATE void sqlcipher3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
78685   Table *pNew;              /* Copy of pParse->pNewTable */
78686   Table *pTab;              /* Table being altered */
78687   int iDb;                  /* Database number */
78688   const char *zDb;          /* Database name */
78689   const char *zTab;         /* Table name */
78690   char *zCol;               /* Null-terminated column definition */
78691   Column *pCol;             /* The new column */
78692   Expr *pDflt;              /* Default value for the new column */
78693   sqlcipher3 *db;              /* The database connection; */
78694
78695   db = pParse->db;
78696   if( pParse->nErr || db->mallocFailed ) return;
78697   pNew = pParse->pNewTable;
78698   assert( pNew );
78699
78700   assert( sqlcipher3BtreeHoldsAllMutexes(db) );
78701   iDb = sqlcipher3SchemaToIndex(db, pNew->pSchema);
78702   zDb = db->aDb[iDb].zName;
78703   zTab = &pNew->zName[16];  /* Skip the "sqlcipher_altertab_" prefix on the name */
78704   pCol = &pNew->aCol[pNew->nCol-1];
78705   pDflt = pCol->pDflt;
78706   pTab = sqlcipher3FindTable(db, zTab, zDb);
78707   assert( pTab );
78708
78709 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
78710   /* Invoke the authorization callback. */
78711   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_ALTER_TABLE, zDb, pTab->zName, 0) ){
78712     return;
78713   }
78714 #endif
78715
78716   /* If the default value for the new column was specified with a 
78717   ** literal NULL, then set pDflt to 0. This simplifies checking
78718   ** for an SQL NULL default below.
78719   */
78720   if( pDflt && pDflt->op==TK_NULL ){
78721     pDflt = 0;
78722   }
78723
78724   /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
78725   ** If there is a NOT NULL constraint, then the default value for the
78726   ** column must not be NULL.
78727   */
78728   if( pCol->isPrimKey ){
78729     sqlcipher3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
78730     return;
78731   }
78732   if( pNew->pIndex ){
78733     sqlcipher3ErrorMsg(pParse, "Cannot add a UNIQUE column");
78734     return;
78735   }
78736   if( (db->flags&SQLCIPHER_ForeignKeys) && pNew->pFKey && pDflt ){
78737     sqlcipher3ErrorMsg(pParse, 
78738         "Cannot add a REFERENCES column with non-NULL default value");
78739     return;
78740   }
78741   if( pCol->notNull && !pDflt ){
78742     sqlcipher3ErrorMsg(pParse, 
78743         "Cannot add a NOT NULL column with default value NULL");
78744     return;
78745   }
78746
78747   /* Ensure the default expression is something that sqlcipher3ValueFromExpr()
78748   ** can handle (i.e. not CURRENT_TIME etc.)
78749   */
78750   if( pDflt ){
78751     sqlcipher3_value *pVal;
78752     if( sqlcipher3ValueFromExpr(db, pDflt, SQLCIPHER_UTF8, SQLCIPHER_AFF_NONE, &pVal) ){
78753       db->mallocFailed = 1;
78754       return;
78755     }
78756     if( !pVal ){
78757       sqlcipher3ErrorMsg(pParse, "Cannot add a column with non-constant default");
78758       return;
78759     }
78760     sqlcipher3ValueFree(pVal);
78761   }
78762
78763   /* Modify the CREATE TABLE statement. */
78764   zCol = sqlcipher3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
78765   if( zCol ){
78766     char *zEnd = &zCol[pColDef->n-1];
78767     int savedDbFlags = db->flags;
78768     while( zEnd>zCol && (*zEnd==';' || sqlcipher3Isspace(*zEnd)) ){
78769       *zEnd-- = '\0';
78770     }
78771     db->flags |= SQLCIPHER_PreferBuiltin;
78772     sqlcipher3NestedParse(pParse, 
78773         "UPDATE \"%w\".%s SET "
78774           "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
78775         "WHERE type = 'table' AND name = %Q", 
78776       zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
78777       zTab
78778     );
78779     sqlcipher3DbFree(db, zCol);
78780     db->flags = savedDbFlags;
78781   }
78782
78783   /* If the default value of the new column is NULL, then set the file
78784   ** format to 2. If the default value of the new column is not NULL,
78785   ** the file format becomes 3.
78786   */
78787   sqlcipher3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
78788
78789   /* Reload the schema of the modified table. */
78790   reloadTableSchema(pParse, pTab, pTab->zName);
78791 }
78792
78793 /*
78794 ** This function is called by the parser after the table-name in
78795 ** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument 
78796 ** pSrc is the full-name of the table being altered.
78797 **
78798 ** This routine makes a (partial) copy of the Table structure
78799 ** for the table being altered and sets Parse.pNewTable to point
78800 ** to it. Routines called by the parser as the column definition
78801 ** is parsed (i.e. sqlcipher3AddColumn()) add the new Column data to 
78802 ** the copy. The copy of the Table structure is deleted by tokenize.c 
78803 ** after parsing is finished.
78804 **
78805 ** Routine sqlcipher3AlterFinishAddColumn() will be called to complete
78806 ** coding the "ALTER TABLE ... ADD" statement.
78807 */
78808 SQLCIPHER_PRIVATE void sqlcipher3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
78809   Table *pNew;
78810   Table *pTab;
78811   Vdbe *v;
78812   int iDb;
78813   int i;
78814   int nAlloc;
78815   sqlcipher3 *db = pParse->db;
78816
78817   /* Look up the table being altered. */
78818   assert( pParse->pNewTable==0 );
78819   assert( sqlcipher3BtreeHoldsAllMutexes(db) );
78820   if( db->mallocFailed ) goto exit_begin_add_column;
78821   pTab = sqlcipher3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
78822   if( !pTab ) goto exit_begin_add_column;
78823
78824 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
78825   if( IsVirtual(pTab) ){
78826     sqlcipher3ErrorMsg(pParse, "virtual tables may not be altered");
78827     goto exit_begin_add_column;
78828   }
78829 #endif
78830
78831   /* Make sure this is not an attempt to ALTER a view. */
78832   if( pTab->pSelect ){
78833     sqlcipher3ErrorMsg(pParse, "Cannot add a column to a view");
78834     goto exit_begin_add_column;
78835   }
78836   if( SQLCIPHER_OK!=isSystemTable(pParse, pTab->zName) ){
78837     goto exit_begin_add_column;
78838   }
78839
78840   assert( pTab->addColOffset>0 );
78841   iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
78842
78843   /* Put a copy of the Table struct in Parse.pNewTable for the
78844   ** sqlcipher3AddColumn() function and friends to modify.  But modify
78845   ** the name by adding an "sqlcipher_altertab_" prefix.  By adding this
78846   ** prefix, we insure that the name will not collide with an existing
78847   ** table because user table are not allowed to have the "sqlcipher_"
78848   ** prefix on their name.
78849   */
78850   pNew = (Table*)sqlcipher3DbMallocZero(db, sizeof(Table));
78851   if( !pNew ) goto exit_begin_add_column;
78852   pParse->pNewTable = pNew;
78853   pNew->nRef = 1;
78854   pNew->nCol = pTab->nCol;
78855   assert( pNew->nCol>0 );
78856   nAlloc = (((pNew->nCol-1)/8)*8)+8;
78857   assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
78858   pNew->aCol = (Column*)sqlcipher3DbMallocZero(db, sizeof(Column)*nAlloc);
78859   pNew->zName = sqlcipher3MPrintf(db, "sqlcipher_altertab_%s", pTab->zName);
78860   if( !pNew->aCol || !pNew->zName ){
78861     db->mallocFailed = 1;
78862     goto exit_begin_add_column;
78863   }
78864   memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
78865   for(i=0; i<pNew->nCol; i++){
78866     Column *pCol = &pNew->aCol[i];
78867     pCol->zName = sqlcipher3DbStrDup(db, pCol->zName);
78868     pCol->zColl = 0;
78869     pCol->zType = 0;
78870     pCol->pDflt = 0;
78871     pCol->zDflt = 0;
78872   }
78873   pNew->pSchema = db->aDb[iDb].pSchema;
78874   pNew->addColOffset = pTab->addColOffset;
78875   pNew->nRef = 1;
78876
78877   /* Begin a transaction and increment the schema cookie.  */
78878   sqlcipher3BeginWriteOperation(pParse, 0, iDb);
78879   v = sqlcipher3GetVdbe(pParse);
78880   if( !v ) goto exit_begin_add_column;
78881   sqlcipher3ChangeCookie(pParse, iDb);
78882
78883 exit_begin_add_column:
78884   sqlcipher3SrcListDelete(db, pSrc);
78885   return;
78886 }
78887 #endif  /* SQLCIPHER_ALTER_TABLE */
78888
78889 /************** End of alter.c ***********************************************/
78890 /************** Begin file analyze.c *****************************************/
78891 /*
78892 ** 2005 July 8
78893 **
78894 ** The author disclaims copyright to this source code.  In place of
78895 ** a legal notice, here is a blessing:
78896 **
78897 **    May you do good and not evil.
78898 **    May you find forgiveness for yourself and forgive others.
78899 **    May you share freely, never taking more than you give.
78900 **
78901 *************************************************************************
78902 ** This file contains code associated with the ANALYZE command.
78903 **
78904 ** The ANALYZE command gather statistics about the content of tables
78905 ** and indices.  These statistics are made available to the query planner
78906 ** to help it make better decisions about how to perform queries.
78907 **
78908 ** The following system tables are or have been supported:
78909 **
78910 **    CREATE TABLE sqlcipher_stat1(tbl, idx, stat);
78911 **    CREATE TABLE sqlcipher_stat2(tbl, idx, sampleno, sample);
78912 **    CREATE TABLE sqlcipher_stat3(tbl, idx, nEq, nLt, nDLt, sample);
78913 **
78914 ** Additional tables might be added in future releases of SQLite.
78915 ** The sqlcipher_stat2 table is not created or used unless the SQLite version
78916 ** is between 3.6.18 and 3.7.8, inclusive, and unless SQLite is compiled
78917 ** with SQLCIPHER_ENABLE_STAT2.  The sqlcipher_stat2 table is deprecated.
78918 ** The sqlcipher_stat2 table is superceded by sqlcipher_stat3, which is only
78919 ** created and used by SQLite versions 3.7.9 and later and with
78920 ** SQLCIPHER_ENABLE_STAT3 defined.  The fucntionality of sqlcipher_stat3
78921 ** is a superset of sqlcipher_stat2.  
78922 **
78923 ** Format of sqlcipher_stat1:
78924 **
78925 ** There is normally one row per index, with the index identified by the
78926 ** name in the idx column.  The tbl column is the name of the table to
78927 ** which the index belongs.  In each such row, the stat column will be
78928 ** a string consisting of a list of integers.  The first integer in this
78929 ** list is the number of rows in the index and in the table.  The second
78930 ** integer is the average number of rows in the index that have the same
78931 ** value in the first column of the index.  The third integer is the average
78932 ** number of rows in the index that have the same value for the first two
78933 ** columns.  The N-th integer (for N>1) is the average number of rows in 
78934 ** the index which have the same value for the first N-1 columns.  For
78935 ** a K-column index, there will be K+1 integers in the stat column.  If
78936 ** the index is unique, then the last integer will be 1.
78937 **
78938 ** The list of integers in the stat column can optionally be followed
78939 ** by the keyword "unordered".  The "unordered" keyword, if it is present,
78940 ** must be separated from the last integer by a single space.  If the
78941 ** "unordered" keyword is present, then the query planner assumes that
78942 ** the index is unordered and will not use the index for a range query.
78943 ** 
78944 ** If the sqlcipher_stat1.idx column is NULL, then the sqlcipher_stat1.stat
78945 ** column contains a single integer which is the (estimated) number of
78946 ** rows in the table identified by sqlcipher_stat1.tbl.
78947 **
78948 ** Format of sqlcipher_stat2:
78949 **
78950 ** The sqlcipher_stat2 is only created and is only used if SQLite is compiled
78951 ** with SQLCIPHER_ENABLE_STAT2 and if the SQLite version number is between
78952 ** 3.6.18 and 3.7.8.  The "stat2" table contains additional information
78953 ** about the distribution of keys within an index.  The index is identified by
78954 ** the "idx" column and the "tbl" column is the name of the table to which
78955 ** the index belongs.  There are usually 10 rows in the sqlcipher_stat2
78956 ** table for each index.
78957 **
78958 ** The sqlcipher_stat2 entries for an index that have sampleno between 0 and 9
78959 ** inclusive are samples of the left-most key value in the index taken at
78960 ** evenly spaced points along the index.  Let the number of samples be S
78961 ** (10 in the standard build) and let C be the number of rows in the index.
78962 ** Then the sampled rows are given by:
78963 **
78964 **     rownumber = (i*C*2 + C)/(S*2)
78965 **
78966 ** For i between 0 and S-1.  Conceptually, the index space is divided into
78967 ** S uniform buckets and the samples are the middle row from each bucket.
78968 **
78969 ** The format for sqlcipher_stat2 is recorded here for legacy reference.  This
78970 ** version of SQLite does not support sqlcipher_stat2.  It neither reads nor
78971 ** writes the sqlcipher_stat2 table.  This version of SQLite only supports
78972 ** sqlcipher_stat3.
78973 **
78974 ** Format for sqlcipher_stat3:
78975 **
78976 ** The sqlcipher_stat3 is an enhancement to sqlcipher_stat2.  A new name is
78977 ** used to avoid compatibility problems.  
78978 **
78979 ** The format of the sqlcipher_stat3 table is similar to the format of
78980 ** the sqlcipher_stat2 table.  There are multiple entries for each index.
78981 ** The idx column names the index and the tbl column is the table of the
78982 ** index.  If the idx and tbl columns are the same, then the sample is
78983 ** of the INTEGER PRIMARY KEY.  The sample column is a value taken from
78984 ** the left-most column of the index.  The nEq column is the approximate
78985 ** number of entires in the index whose left-most column exactly matches
78986 ** the sample.  nLt is the approximate number of entires whose left-most
78987 ** column is less than the sample.  The nDLt column is the approximate
78988 ** number of distinct left-most entries in the index that are less than
78989 ** the sample.
78990 **
78991 ** Future versions of SQLite might change to store a string containing
78992 ** multiple integers values in the nDLt column of sqlcipher_stat3.  The first
78993 ** integer will be the number of prior index entires that are distinct in
78994 ** the left-most column.  The second integer will be the number of prior index
78995 ** entries that are distinct in the first two columns.  The third integer
78996 ** will be the number of prior index entries that are distinct in the first
78997 ** three columns.  And so forth.  With that extension, the nDLt field is
78998 ** similar in function to the sqlcipher_stat1.stat field.
78999 **
79000 ** There can be an arbitrary number of sqlcipher_stat3 entries per index.
79001 ** The ANALYZE command will typically generate sqlcipher_stat3 tables
79002 ** that contain between 10 and 40 samples which are distributed across
79003 ** the key space, though not uniformly, and which include samples with
79004 ** largest possible nEq values.
79005 */
79006 #ifndef SQLCIPHER_OMIT_ANALYZE
79007
79008 /*
79009 ** This routine generates code that opens the sqlcipher_stat1 table for
79010 ** writing with cursor iStatCur. If the library was built with the
79011 ** SQLCIPHER_ENABLE_STAT3 macro defined, then the sqlcipher_stat3 table is
79012 ** opened for writing using cursor (iStatCur+1)
79013 **
79014 ** If the sqlcipher_stat1 tables does not previously exist, it is created.
79015 ** Similarly, if the sqlcipher_stat3 table does not exist and the library
79016 ** is compiled with SQLCIPHER_ENABLE_STAT3 defined, it is created. 
79017 **
79018 ** Argument zWhere may be a pointer to a buffer containing a table name,
79019 ** or it may be a NULL pointer. If it is not NULL, then all entries in
79020 ** the sqlcipher_stat1 and (if applicable) sqlcipher_stat3 tables associated
79021 ** with the named table are deleted. If zWhere==0, then code is generated
79022 ** to delete all stat table entries.
79023 */
79024 static void openStatTable(
79025   Parse *pParse,          /* Parsing context */
79026   int iDb,                /* The database we are looking in */
79027   int iStatCur,           /* Open the sqlcipher_stat1 table on this cursor */
79028   const char *zWhere,     /* Delete entries for this table or index */
79029   const char *zWhereType  /* Either "tbl" or "idx" */
79030 ){
79031   static const struct {
79032     const char *zName;
79033     const char *zCols;
79034   } aTable[] = {
79035     { "sqlcipher_stat1", "tbl,idx,stat" },
79036 #ifdef SQLCIPHER_ENABLE_STAT3
79037     { "sqlcipher_stat3", "tbl,idx,neq,nlt,ndlt,sample" },
79038 #endif
79039   };
79040
79041   int aRoot[] = {0, 0};
79042   u8 aCreateTbl[] = {0, 0};
79043
79044   int i;
79045   sqlcipher3 *db = pParse->db;
79046   Db *pDb;
79047   Vdbe *v = sqlcipher3GetVdbe(pParse);
79048   if( v==0 ) return;
79049   assert( sqlcipher3BtreeHoldsAllMutexes(db) );
79050   assert( sqlcipher3VdbeDb(v)==db );
79051   pDb = &db->aDb[iDb];
79052
79053   /* Create new statistic tables if they do not exist, or clear them
79054   ** if they do already exist.
79055   */
79056   for(i=0; i<ArraySize(aTable); i++){
79057     const char *zTab = aTable[i].zName;
79058     Table *pStat;
79059     if( (pStat = sqlcipher3FindTable(db, zTab, pDb->zName))==0 ){
79060       /* The sqlcipher_stat[12] table does not exist. Create it. Note that a 
79061       ** side-effect of the CREATE TABLE statement is to leave the rootpage 
79062       ** of the new table in register pParse->regRoot. This is important 
79063       ** because the OpenWrite opcode below will be needing it. */
79064       sqlcipher3NestedParse(pParse,
79065           "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols
79066       );
79067       aRoot[i] = pParse->regRoot;
79068       aCreateTbl[i] = 1;
79069     }else{
79070       /* The table already exists. If zWhere is not NULL, delete all entries 
79071       ** associated with the table zWhere. If zWhere is NULL, delete the
79072       ** entire contents of the table. */
79073       aRoot[i] = pStat->tnum;
79074       sqlcipher3TableLock(pParse, iDb, aRoot[i], 1, zTab);
79075       if( zWhere ){
79076         sqlcipher3NestedParse(pParse,
79077            "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere
79078         );
79079       }else{
79080         /* The sqlcipher_stat[12] table already exists.  Delete all rows. */
79081         sqlcipher3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb);
79082       }
79083     }
79084   }
79085
79086   /* Open the sqlcipher_stat[13] tables for writing. */
79087   for(i=0; i<ArraySize(aTable); i++){
79088     sqlcipher3VdbeAddOp3(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb);
79089     sqlcipher3VdbeChangeP4(v, -1, (char *)3, P4_INT32);
79090     sqlcipher3VdbeChangeP5(v, aCreateTbl[i]);
79091   }
79092 }
79093
79094 /*
79095 ** Recommended number of samples for sqlcipher_stat3
79096 */
79097 #ifndef SQLCIPHER_STAT3_SAMPLES
79098 # define SQLCIPHER_STAT3_SAMPLES 24
79099 #endif
79100
79101 /*
79102 ** Three SQL functions - stat3_init(), stat3_push(), and stat3_pop() -
79103 ** share an instance of the following structure to hold their state
79104 ** information.
79105 */
79106 typedef struct Stat3Accum Stat3Accum;
79107 struct Stat3Accum {
79108   tRowcnt nRow;             /* Number of rows in the entire table */
79109   tRowcnt nPSample;         /* How often to do a periodic sample */
79110   int iMin;                 /* Index of entry with minimum nEq and hash */
79111   int mxSample;             /* Maximum number of samples to accumulate */
79112   int nSample;              /* Current number of samples */
79113   u32 iPrn;                 /* Pseudo-random number used for sampling */
79114   struct Stat3Sample {
79115     i64 iRowid;                /* Rowid in main table of the key */
79116     tRowcnt nEq;               /* sqlcipher_stat3.nEq */
79117     tRowcnt nLt;               /* sqlcipher_stat3.nLt */
79118     tRowcnt nDLt;              /* sqlcipher_stat3.nDLt */
79119     u8 isPSample;              /* True if a periodic sample */
79120     u32 iHash;                 /* Tiebreaker hash */
79121   } *a;                     /* An array of samples */
79122 };
79123
79124 #ifdef SQLCIPHER_ENABLE_STAT3
79125 /*
79126 ** Implementation of the stat3_init(C,S) SQL function.  The two parameters
79127 ** are the number of rows in the table or index (C) and the number of samples
79128 ** to accumulate (S).
79129 **
79130 ** This routine allocates the Stat3Accum object.
79131 **
79132 ** The return value is the Stat3Accum object (P).
79133 */
79134 static void stat3Init(
79135   sqlcipher3_context *context,
79136   int argc,
79137   sqlcipher3_value **argv
79138 ){
79139   Stat3Accum *p;
79140   tRowcnt nRow;
79141   int mxSample;
79142   int n;
79143
79144   UNUSED_PARAMETER(argc);
79145   nRow = (tRowcnt)sqlcipher3_value_int64(argv[0]);
79146   mxSample = sqlcipher3_value_int(argv[1]);
79147   n = sizeof(*p) + sizeof(p->a[0])*mxSample;
79148   p = sqlcipher3_malloc( n );
79149   if( p==0 ){
79150     sqlcipher3_result_error_nomem(context);
79151     return;
79152   }
79153   memset(p, 0, n);
79154   p->a = (struct Stat3Sample*)&p[1];
79155   p->nRow = nRow;
79156   p->mxSample = mxSample;
79157   p->nPSample = p->nRow/(mxSample/3+1) + 1;
79158   sqlcipher3_randomness(sizeof(p->iPrn), &p->iPrn);
79159   sqlcipher3_result_blob(context, p, sizeof(p), sqlcipher3_free);
79160 }
79161 static const FuncDef stat3InitFuncdef = {
79162   2,                /* nArg */
79163   SQLCIPHER_UTF8,      /* iPrefEnc */
79164   0,                /* flags */
79165   0,                /* pUserData */
79166   0,                /* pNext */
79167   stat3Init,        /* xFunc */
79168   0,                /* xStep */
79169   0,                /* xFinalize */
79170   "stat3_init",     /* zName */
79171   0,                /* pHash */
79172   0                 /* pDestructor */
79173 };
79174
79175
79176 /*
79177 ** Implementation of the stat3_push(nEq,nLt,nDLt,rowid,P) SQL function.  The
79178 ** arguments describe a single key instance.  This routine makes the 
79179 ** decision about whether or not to retain this key for the sqlcipher_stat3
79180 ** table.
79181 **
79182 ** The return value is NULL.
79183 */
79184 static void stat3Push(
79185   sqlcipher3_context *context,
79186   int argc,
79187   sqlcipher3_value **argv
79188 ){
79189   Stat3Accum *p = (Stat3Accum*)sqlcipher3_value_blob(argv[4]);
79190   tRowcnt nEq = sqlcipher3_value_int64(argv[0]);
79191   tRowcnt nLt = sqlcipher3_value_int64(argv[1]);
79192   tRowcnt nDLt = sqlcipher3_value_int64(argv[2]);
79193   i64 rowid = sqlcipher3_value_int64(argv[3]);
79194   u8 isPSample = 0;
79195   u8 doInsert = 0;
79196   int iMin = p->iMin;
79197   struct Stat3Sample *pSample;
79198   int i;
79199   u32 h;
79200
79201   UNUSED_PARAMETER(context);
79202   UNUSED_PARAMETER(argc);
79203   if( nEq==0 ) return;
79204   h = p->iPrn = p->iPrn*1103515245 + 12345;
79205   if( (nLt/p->nPSample)!=((nEq+nLt)/p->nPSample) ){
79206     doInsert = isPSample = 1;
79207   }else if( p->nSample<p->mxSample ){
79208     doInsert = 1;
79209   }else{
79210     if( nEq>p->a[iMin].nEq || (nEq==p->a[iMin].nEq && h>p->a[iMin].iHash) ){
79211       doInsert = 1;
79212     }
79213   }
79214   if( !doInsert ) return;
79215   if( p->nSample==p->mxSample ){
79216     assert( p->nSample - iMin - 1 >= 0 );
79217     memmove(&p->a[iMin], &p->a[iMin+1], sizeof(p->a[0])*(p->nSample-iMin-1));
79218     pSample = &p->a[p->nSample-1];
79219   }else{
79220     pSample = &p->a[p->nSample++];
79221   }
79222   pSample->iRowid = rowid;
79223   pSample->nEq = nEq;
79224   pSample->nLt = nLt;
79225   pSample->nDLt = nDLt;
79226   pSample->iHash = h;
79227   pSample->isPSample = isPSample;
79228
79229   /* Find the new minimum */
79230   if( p->nSample==p->mxSample ){
79231     pSample = p->a;
79232     i = 0;
79233     while( pSample->isPSample ){
79234       i++;
79235       pSample++;
79236       assert( i<p->nSample );
79237     }
79238     nEq = pSample->nEq;
79239     h = pSample->iHash;
79240     iMin = i;
79241     for(i++, pSample++; i<p->nSample; i++, pSample++){
79242       if( pSample->isPSample ) continue;
79243       if( pSample->nEq<nEq
79244        || (pSample->nEq==nEq && pSample->iHash<h)
79245       ){
79246         iMin = i;
79247         nEq = pSample->nEq;
79248         h = pSample->iHash;
79249       }
79250     }
79251     p->iMin = iMin;
79252   }
79253 }
79254 static const FuncDef stat3PushFuncdef = {
79255   5,                /* nArg */
79256   SQLCIPHER_UTF8,      /* iPrefEnc */
79257   0,                /* flags */
79258   0,                /* pUserData */
79259   0,                /* pNext */
79260   stat3Push,        /* xFunc */
79261   0,                /* xStep */
79262   0,                /* xFinalize */
79263   "stat3_push",     /* zName */
79264   0,                /* pHash */
79265   0                 /* pDestructor */
79266 };
79267
79268 /*
79269 ** Implementation of the stat3_get(P,N,...) SQL function.  This routine is
79270 ** used to query the results.  Content is returned for the Nth sqlcipher_stat3
79271 ** row where N is between 0 and S-1 and S is the number of samples.  The
79272 ** value returned depends on the number of arguments.
79273 **
79274 **   argc==2    result:  rowid
79275 **   argc==3    result:  nEq
79276 **   argc==4    result:  nLt
79277 **   argc==5    result:  nDLt
79278 */
79279 static void stat3Get(
79280   sqlcipher3_context *context,
79281   int argc,
79282   sqlcipher3_value **argv
79283 ){
79284   int n = sqlcipher3_value_int(argv[1]);
79285   Stat3Accum *p = (Stat3Accum*)sqlcipher3_value_blob(argv[0]);
79286
79287   assert( p!=0 );
79288   if( p->nSample<=n ) return;
79289   switch( argc ){
79290     case 2:  sqlcipher3_result_int64(context, p->a[n].iRowid); break;
79291     case 3:  sqlcipher3_result_int64(context, p->a[n].nEq);    break;
79292     case 4:  sqlcipher3_result_int64(context, p->a[n].nLt);    break;
79293     default: sqlcipher3_result_int64(context, p->a[n].nDLt);   break;
79294   }
79295 }
79296 static const FuncDef stat3GetFuncdef = {
79297   -1,               /* nArg */
79298   SQLCIPHER_UTF8,      /* iPrefEnc */
79299   0,                /* flags */
79300   0,                /* pUserData */
79301   0,                /* pNext */
79302   stat3Get,         /* xFunc */
79303   0,                /* xStep */
79304   0,                /* xFinalize */
79305   "stat3_get",     /* zName */
79306   0,                /* pHash */
79307   0                 /* pDestructor */
79308 };
79309 #endif /* SQLCIPHER_ENABLE_STAT3 */
79310
79311
79312
79313
79314 /*
79315 ** Generate code to do an analysis of all indices associated with
79316 ** a single table.
79317 */
79318 static void analyzeOneTable(
79319   Parse *pParse,   /* Parser context */
79320   Table *pTab,     /* Table whose indices are to be analyzed */
79321   Index *pOnlyIdx, /* If not NULL, only analyze this one index */
79322   int iStatCur,    /* Index of VdbeCursor that writes the sqlcipher_stat1 table */
79323   int iMem         /* Available memory locations begin here */
79324 ){
79325   sqlcipher3 *db = pParse->db;    /* Database handle */
79326   Index *pIdx;                 /* An index to being analyzed */
79327   int iIdxCur;                 /* Cursor open on index being analyzed */
79328   Vdbe *v;                     /* The virtual machine being built up */
79329   int i;                       /* Loop counter */
79330   int topOfLoop;               /* The top of the loop */
79331   int endOfLoop;               /* The end of the loop */
79332   int jZeroRows = -1;          /* Jump from here if number of rows is zero */
79333   int iDb;                     /* Index of database containing pTab */
79334   int regTabname = iMem++;     /* Register containing table name */
79335   int regIdxname = iMem++;     /* Register containing index name */
79336   int regStat1 = iMem++;       /* The stat column of sqlcipher_stat1 */
79337 #ifdef SQLCIPHER_ENABLE_STAT3
79338   int regNumEq = regStat1;     /* Number of instances.  Same as regStat1 */
79339   int regNumLt = iMem++;       /* Number of keys less than regSample */
79340   int regNumDLt = iMem++;      /* Number of distinct keys less than regSample */
79341   int regSample = iMem++;      /* The next sample value */
79342   int regRowid = regSample;    /* Rowid of a sample */
79343   int regAccum = iMem++;       /* Register to hold Stat3Accum object */
79344   int regLoop = iMem++;        /* Loop counter */
79345   int regCount = iMem++;       /* Number of rows in the table or index */
79346   int regTemp1 = iMem++;       /* Intermediate register */
79347   int regTemp2 = iMem++;       /* Intermediate register */
79348   int once = 1;                /* One-time initialization */
79349   int shortJump = 0;           /* Instruction address */
79350   int iTabCur = pParse->nTab++; /* Table cursor */
79351 #endif
79352   int regCol = iMem++;         /* Content of a column in analyzed table */
79353   int regRec = iMem++;         /* Register holding completed record */
79354   int regTemp = iMem++;        /* Temporary use register */
79355   int regNewRowid = iMem++;    /* Rowid for the inserted record */
79356
79357
79358   v = sqlcipher3GetVdbe(pParse);
79359   if( v==0 || NEVER(pTab==0) ){
79360     return;
79361   }
79362   if( pTab->tnum==0 ){
79363     /* Do not gather statistics on views or virtual tables */
79364     return;
79365   }
79366   if( memcmp(pTab->zName, "sqlcipher_", 7)==0 ){
79367     /* Do not gather statistics on system tables */
79368     return;
79369   }
79370   assert( sqlcipher3BtreeHoldsAllMutexes(db) );
79371   iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
79372   assert( iDb>=0 );
79373   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
79374 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
79375   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_ANALYZE, pTab->zName, 0,
79376       db->aDb[iDb].zName ) ){
79377     return;
79378   }
79379 #endif
79380
79381   /* Establish a read-lock on the table at the shared-cache level. */
79382   sqlcipher3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
79383
79384   iIdxCur = pParse->nTab++;
79385   sqlcipher3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
79386   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
79387     int nCol;
79388     KeyInfo *pKey;
79389     int addrIfNot = 0;           /* address of OP_IfNot */
79390     int *aChngAddr;              /* Array of jump instruction addresses */
79391
79392     if( pOnlyIdx && pOnlyIdx!=pIdx ) continue;
79393     VdbeNoopComment((v, "Begin analysis of %s", pIdx->zName));
79394     nCol = pIdx->nColumn;
79395     aChngAddr = sqlcipher3DbMallocRaw(db, sizeof(int)*nCol);
79396     if( aChngAddr==0 ) continue;
79397     pKey = sqlcipher3IndexKeyinfo(pParse, pIdx);
79398     if( iMem+1+(nCol*2)>pParse->nMem ){
79399       pParse->nMem = iMem+1+(nCol*2);
79400     }
79401
79402     /* Open a cursor to the index to be analyzed. */
79403     assert( iDb==sqlcipher3SchemaToIndex(db, pIdx->pSchema) );
79404     sqlcipher3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb,
79405         (char *)pKey, P4_KEYINFO_HANDOFF);
79406     VdbeComment((v, "%s", pIdx->zName));
79407
79408     /* Populate the register containing the index name. */
79409     sqlcipher3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0);
79410
79411 #ifdef SQLCIPHER_ENABLE_STAT3
79412     if( once ){
79413       once = 0;
79414       sqlcipher3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
79415     }
79416     sqlcipher3VdbeAddOp2(v, OP_Count, iIdxCur, regCount);
79417     sqlcipher3VdbeAddOp2(v, OP_Integer, SQLCIPHER_STAT3_SAMPLES, regTemp1);
79418     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regNumEq);
79419     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regNumLt);
79420     sqlcipher3VdbeAddOp2(v, OP_Integer, -1, regNumDLt);
79421     sqlcipher3VdbeAddOp4(v, OP_Function, 1, regCount, regAccum,
79422                       (char*)&stat3InitFuncdef, P4_FUNCDEF);
79423     sqlcipher3VdbeChangeP5(v, 2);
79424 #endif /* SQLCIPHER_ENABLE_STAT3 */
79425
79426     /* The block of memory cells initialized here is used as follows.
79427     **
79428     **    iMem:                
79429     **        The total number of rows in the table.
79430     **
79431     **    iMem+1 .. iMem+nCol: 
79432     **        Number of distinct entries in index considering the 
79433     **        left-most N columns only, where N is between 1 and nCol, 
79434     **        inclusive.
79435     **
79436     **    iMem+nCol+1 .. Mem+2*nCol:  
79437     **        Previous value of indexed columns, from left to right.
79438     **
79439     ** Cells iMem through iMem+nCol are initialized to 0. The others are 
79440     ** initialized to contain an SQL NULL.
79441     */
79442     for(i=0; i<=nCol; i++){
79443       sqlcipher3VdbeAddOp2(v, OP_Integer, 0, iMem+i);
79444     }
79445     for(i=0; i<nCol; i++){
79446       sqlcipher3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
79447     }
79448
79449     /* Start the analysis loop. This loop runs through all the entries in
79450     ** the index b-tree.  */
79451     endOfLoop = sqlcipher3VdbeMakeLabel(v);
79452     sqlcipher3VdbeAddOp2(v, OP_Rewind, iIdxCur, endOfLoop);
79453     topOfLoop = sqlcipher3VdbeCurrentAddr(v);
79454     sqlcipher3VdbeAddOp2(v, OP_AddImm, iMem, 1);  /* Increment row counter */
79455
79456     for(i=0; i<nCol; i++){
79457       CollSeq *pColl;
79458       sqlcipher3VdbeAddOp3(v, OP_Column, iIdxCur, i, regCol);
79459       if( i==0 ){
79460         /* Always record the very first row */
79461         addrIfNot = sqlcipher3VdbeAddOp1(v, OP_IfNot, iMem+1);
79462       }
79463       assert( pIdx->azColl!=0 );
79464       assert( pIdx->azColl[i]!=0 );
79465       pColl = sqlcipher3LocateCollSeq(pParse, pIdx->azColl[i]);
79466       aChngAddr[i] = sqlcipher3VdbeAddOp4(v, OP_Ne, regCol, 0, iMem+nCol+i+1,
79467                                       (char*)pColl, P4_COLLSEQ);
79468       sqlcipher3VdbeChangeP5(v, SQLCIPHER_NULLEQ);
79469       VdbeComment((v, "jump if column %d changed", i));
79470 #ifdef SQLCIPHER_ENABLE_STAT3
79471       if( i==0 ){
79472         sqlcipher3VdbeAddOp2(v, OP_AddImm, regNumEq, 1);
79473         VdbeComment((v, "incr repeat count"));
79474       }
79475 #endif
79476     }
79477     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, endOfLoop);
79478     for(i=0; i<nCol; i++){
79479       sqlcipher3VdbeJumpHere(v, aChngAddr[i]);  /* Set jump dest for the OP_Ne */
79480       if( i==0 ){
79481         sqlcipher3VdbeJumpHere(v, addrIfNot);   /* Jump dest for OP_IfNot */
79482 #ifdef SQLCIPHER_ENABLE_STAT3
79483         sqlcipher3VdbeAddOp4(v, OP_Function, 1, regNumEq, regTemp2,
79484                           (char*)&stat3PushFuncdef, P4_FUNCDEF);
79485         sqlcipher3VdbeChangeP5(v, 5);
79486         sqlcipher3VdbeAddOp3(v, OP_Column, iIdxCur, pIdx->nColumn, regRowid);
79487         sqlcipher3VdbeAddOp3(v, OP_Add, regNumEq, regNumLt, regNumLt);
79488         sqlcipher3VdbeAddOp2(v, OP_AddImm, regNumDLt, 1);
79489         sqlcipher3VdbeAddOp2(v, OP_Integer, 1, regNumEq);
79490 #endif        
79491       }
79492       sqlcipher3VdbeAddOp2(v, OP_AddImm, iMem+i+1, 1);
79493       sqlcipher3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
79494     }
79495     sqlcipher3DbFree(db, aChngAddr);
79496
79497     /* Always jump here after updating the iMem+1...iMem+1+nCol counters */
79498     sqlcipher3VdbeResolveLabel(v, endOfLoop);
79499
79500     sqlcipher3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop);
79501     sqlcipher3VdbeAddOp1(v, OP_Close, iIdxCur);
79502 #ifdef SQLCIPHER_ENABLE_STAT3
79503     sqlcipher3VdbeAddOp4(v, OP_Function, 1, regNumEq, regTemp2,
79504                       (char*)&stat3PushFuncdef, P4_FUNCDEF);
79505     sqlcipher3VdbeChangeP5(v, 5);
79506     sqlcipher3VdbeAddOp2(v, OP_Integer, -1, regLoop);
79507     shortJump = 
79508     sqlcipher3VdbeAddOp2(v, OP_AddImm, regLoop, 1);
79509     sqlcipher3VdbeAddOp4(v, OP_Function, 1, regAccum, regTemp1,
79510                       (char*)&stat3GetFuncdef, P4_FUNCDEF);
79511     sqlcipher3VdbeChangeP5(v, 2);
79512     sqlcipher3VdbeAddOp1(v, OP_IsNull, regTemp1);
79513     sqlcipher3VdbeAddOp3(v, OP_NotExists, iTabCur, shortJump, regTemp1);
79514     sqlcipher3VdbeAddOp3(v, OP_Column, iTabCur, pIdx->aiColumn[0], regSample);
79515     sqlcipher3ColumnDefault(v, pTab, pIdx->aiColumn[0], regSample);
79516     sqlcipher3VdbeAddOp4(v, OP_Function, 1, regAccum, regNumEq,
79517                       (char*)&stat3GetFuncdef, P4_FUNCDEF);
79518     sqlcipher3VdbeChangeP5(v, 3);
79519     sqlcipher3VdbeAddOp4(v, OP_Function, 1, regAccum, regNumLt,
79520                       (char*)&stat3GetFuncdef, P4_FUNCDEF);
79521     sqlcipher3VdbeChangeP5(v, 4);
79522     sqlcipher3VdbeAddOp4(v, OP_Function, 1, regAccum, regNumDLt,
79523                       (char*)&stat3GetFuncdef, P4_FUNCDEF);
79524     sqlcipher3VdbeChangeP5(v, 5);
79525     sqlcipher3VdbeAddOp4(v, OP_MakeRecord, regTabname, 6, regRec, "bbbbbb", 0);
79526     sqlcipher3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
79527     sqlcipher3VdbeAddOp3(v, OP_Insert, iStatCur+1, regRec, regNewRowid);
79528     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, shortJump);
79529     sqlcipher3VdbeJumpHere(v, shortJump+2);
79530 #endif        
79531
79532     /* Store the results in sqlcipher_stat1.
79533     **
79534     ** The result is a single row of the sqlcipher_stat1 table.  The first
79535     ** two columns are the names of the table and index.  The third column
79536     ** is a string composed of a list of integer statistics about the
79537     ** index.  The first integer in the list is the total number of entries
79538     ** in the index.  There is one additional integer in the list for each
79539     ** column of the table.  This additional integer is a guess of how many
79540     ** rows of the table the index will select.  If D is the count of distinct
79541     ** values and K is the total number of rows, then the integer is computed
79542     ** as:
79543     **
79544     **        I = (K+D-1)/D
79545     **
79546     ** If K==0 then no entry is made into the sqlcipher_stat1 table.  
79547     ** If K>0 then it is always the case the D>0 so division by zero
79548     ** is never possible.
79549     */
79550     sqlcipher3VdbeAddOp2(v, OP_SCopy, iMem, regStat1);
79551     if( jZeroRows<0 ){
79552       jZeroRows = sqlcipher3VdbeAddOp1(v, OP_IfNot, iMem);
79553     }
79554     for(i=0; i<nCol; i++){
79555       sqlcipher3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, " ", 0);
79556       sqlcipher3VdbeAddOp3(v, OP_Concat, regTemp, regStat1, regStat1);
79557       sqlcipher3VdbeAddOp3(v, OP_Add, iMem, iMem+i+1, regTemp);
79558       sqlcipher3VdbeAddOp2(v, OP_AddImm, regTemp, -1);
79559       sqlcipher3VdbeAddOp3(v, OP_Divide, iMem+i+1, regTemp, regTemp);
79560       sqlcipher3VdbeAddOp1(v, OP_ToInt, regTemp);
79561       sqlcipher3VdbeAddOp3(v, OP_Concat, regTemp, regStat1, regStat1);
79562     }
79563     sqlcipher3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);
79564     sqlcipher3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
79565     sqlcipher3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regNewRowid);
79566     sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
79567   }
79568
79569   /* If the table has no indices, create a single sqlcipher_stat1 entry
79570   ** containing NULL as the index name and the row count as the content.
79571   */
79572   if( pTab->pIndex==0 ){
79573     sqlcipher3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pTab->tnum, iDb);
79574     VdbeComment((v, "%s", pTab->zName));
79575     sqlcipher3VdbeAddOp2(v, OP_Count, iIdxCur, regStat1);
79576     sqlcipher3VdbeAddOp1(v, OP_Close, iIdxCur);
79577     jZeroRows = sqlcipher3VdbeAddOp1(v, OP_IfNot, regStat1);
79578   }else{
79579     sqlcipher3VdbeJumpHere(v, jZeroRows);
79580     jZeroRows = sqlcipher3VdbeAddOp0(v, OP_Goto);
79581   }
79582   sqlcipher3VdbeAddOp2(v, OP_Null, 0, regIdxname);
79583   sqlcipher3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);
79584   sqlcipher3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
79585   sqlcipher3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regNewRowid);
79586   sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
79587   if( pParse->nMem<regRec ) pParse->nMem = regRec;
79588   sqlcipher3VdbeJumpHere(v, jZeroRows);
79589 }
79590
79591
79592 /*
79593 ** Generate code that will cause the most recent index analysis to
79594 ** be loaded into internal hash tables where is can be used.
79595 */
79596 static void loadAnalysis(Parse *pParse, int iDb){
79597   Vdbe *v = sqlcipher3GetVdbe(pParse);
79598   if( v ){
79599     sqlcipher3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
79600   }
79601 }
79602
79603 /*
79604 ** Generate code that will do an analysis of an entire database
79605 */
79606 static void analyzeDatabase(Parse *pParse, int iDb){
79607   sqlcipher3 *db = pParse->db;
79608   Schema *pSchema = db->aDb[iDb].pSchema;    /* Schema of database iDb */
79609   HashElem *k;
79610   int iStatCur;
79611   int iMem;
79612
79613   sqlcipher3BeginWriteOperation(pParse, 0, iDb);
79614   iStatCur = pParse->nTab;
79615   pParse->nTab += 3;
79616   openStatTable(pParse, iDb, iStatCur, 0, 0);
79617   iMem = pParse->nMem+1;
79618   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
79619   for(k=sqlcipherHashFirst(&pSchema->tblHash); k; k=sqlcipherHashNext(k)){
79620     Table *pTab = (Table*)sqlcipherHashData(k);
79621     analyzeOneTable(pParse, pTab, 0, iStatCur, iMem);
79622   }
79623   loadAnalysis(pParse, iDb);
79624 }
79625
79626 /*
79627 ** Generate code that will do an analysis of a single table in
79628 ** a database.  If pOnlyIdx is not NULL then it is a single index
79629 ** in pTab that should be analyzed.
79630 */
79631 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
79632   int iDb;
79633   int iStatCur;
79634
79635   assert( pTab!=0 );
79636   assert( sqlcipher3BtreeHoldsAllMutexes(pParse->db) );
79637   iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
79638   sqlcipher3BeginWriteOperation(pParse, 0, iDb);
79639   iStatCur = pParse->nTab;
79640   pParse->nTab += 3;
79641   if( pOnlyIdx ){
79642     openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
79643   }else{
79644     openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
79645   }
79646   analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur, pParse->nMem+1);
79647   loadAnalysis(pParse, iDb);
79648 }
79649
79650 /*
79651 ** Generate code for the ANALYZE command.  The parser calls this routine
79652 ** when it recognizes an ANALYZE command.
79653 **
79654 **        ANALYZE                            -- 1
79655 **        ANALYZE  <database>                -- 2
79656 **        ANALYZE  ?<database>.?<tablename>  -- 3
79657 **
79658 ** Form 1 causes all indices in all attached databases to be analyzed.
79659 ** Form 2 analyzes all indices the single database named.
79660 ** Form 3 analyzes all indices associated with the named table.
79661 */
79662 SQLCIPHER_PRIVATE void sqlcipher3Analyze(Parse *pParse, Token *pName1, Token *pName2){
79663   sqlcipher3 *db = pParse->db;
79664   int iDb;
79665   int i;
79666   char *z, *zDb;
79667   Table *pTab;
79668   Index *pIdx;
79669   Token *pTableName;
79670
79671   /* Read the database schema. If an error occurs, leave an error message
79672   ** and code in pParse and return NULL. */
79673   assert( sqlcipher3BtreeHoldsAllMutexes(pParse->db) );
79674   if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
79675     return;
79676   }
79677
79678   assert( pName2!=0 || pName1==0 );
79679   if( pName1==0 ){
79680     /* Form 1:  Analyze everything */
79681     for(i=0; i<db->nDb; i++){
79682       if( i==1 ) continue;  /* Do not analyze the TEMP database */
79683       analyzeDatabase(pParse, i);
79684     }
79685   }else if( pName2->n==0 ){
79686     /* Form 2:  Analyze the database or table named */
79687     iDb = sqlcipher3FindDb(db, pName1);
79688     if( iDb>=0 ){
79689       analyzeDatabase(pParse, iDb);
79690     }else{
79691       z = sqlcipher3NameFromToken(db, pName1);
79692       if( z ){
79693         if( (pIdx = sqlcipher3FindIndex(db, z, 0))!=0 ){
79694           analyzeTable(pParse, pIdx->pTable, pIdx);
79695         }else if( (pTab = sqlcipher3LocateTable(pParse, 0, z, 0))!=0 ){
79696           analyzeTable(pParse, pTab, 0);
79697         }
79698         sqlcipher3DbFree(db, z);
79699       }
79700     }
79701   }else{
79702     /* Form 3: Analyze the fully qualified table name */
79703     iDb = sqlcipher3TwoPartName(pParse, pName1, pName2, &pTableName);
79704     if( iDb>=0 ){
79705       zDb = db->aDb[iDb].zName;
79706       z = sqlcipher3NameFromToken(db, pTableName);
79707       if( z ){
79708         if( (pIdx = sqlcipher3FindIndex(db, z, zDb))!=0 ){
79709           analyzeTable(pParse, pIdx->pTable, pIdx);
79710         }else if( (pTab = sqlcipher3LocateTable(pParse, 0, z, zDb))!=0 ){
79711           analyzeTable(pParse, pTab, 0);
79712         }
79713         sqlcipher3DbFree(db, z);
79714       }
79715     }   
79716   }
79717 }
79718
79719 /*
79720 ** Used to pass information from the analyzer reader through to the
79721 ** callback routine.
79722 */
79723 typedef struct analysisInfo analysisInfo;
79724 struct analysisInfo {
79725   sqlcipher3 *db;
79726   const char *zDatabase;
79727 };
79728
79729 /*
79730 ** This callback is invoked once for each index when reading the
79731 ** sqlcipher_stat1 table.  
79732 **
79733 **     argv[0] = name of the table
79734 **     argv[1] = name of the index (might be NULL)
79735 **     argv[2] = results of analysis - on integer for each column
79736 **
79737 ** Entries for which argv[1]==NULL simply record the number of rows in
79738 ** the table.
79739 */
79740 static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
79741   analysisInfo *pInfo = (analysisInfo*)pData;
79742   Index *pIndex;
79743   Table *pTable;
79744   int i, c, n;
79745   tRowcnt v;
79746   const char *z;
79747
79748   assert( argc==3 );
79749   UNUSED_PARAMETER2(NotUsed, argc);
79750
79751   if( argv==0 || argv[0]==0 || argv[2]==0 ){
79752     return 0;
79753   }
79754   pTable = sqlcipher3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
79755   if( pTable==0 ){
79756     return 0;
79757   }
79758   if( argv[1] ){
79759     pIndex = sqlcipher3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
79760   }else{
79761     pIndex = 0;
79762   }
79763   n = pIndex ? pIndex->nColumn : 0;
79764   z = argv[2];
79765   for(i=0; *z && i<=n; i++){
79766     v = 0;
79767     while( (c=z[0])>='0' && c<='9' ){
79768       v = v*10 + c - '0';
79769       z++;
79770     }
79771     if( i==0 ) pTable->nRowEst = v;
79772     if( pIndex==0 ) break;
79773     pIndex->aiRowEst[i] = v;
79774     if( *z==' ' ) z++;
79775     if( memcmp(z, "unordered", 10)==0 ){
79776       pIndex->bUnordered = 1;
79777       break;
79778     }
79779   }
79780   return 0;
79781 }
79782
79783 /*
79784 ** If the Index.aSample variable is not NULL, delete the aSample[] array
79785 ** and its contents.
79786 */
79787 SQLCIPHER_PRIVATE void sqlcipher3DeleteIndexSamples(sqlcipher3 *db, Index *pIdx){
79788 #ifdef SQLCIPHER_ENABLE_STAT3
79789   if( pIdx->aSample ){
79790     int j;
79791     for(j=0; j<pIdx->nSample; j++){
79792       IndexSample *p = &pIdx->aSample[j];
79793       if( p->eType==SQLCIPHER_TEXT || p->eType==SQLCIPHER_BLOB ){
79794         sqlcipher3DbFree(db, p->u.z);
79795       }
79796     }
79797     sqlcipher3DbFree(db, pIdx->aSample);
79798   }
79799   if( db && db->pnBytesFreed==0 ){
79800     pIdx->nSample = 0;
79801     pIdx->aSample = 0;
79802   }
79803 #else
79804   UNUSED_PARAMETER(db);
79805   UNUSED_PARAMETER(pIdx);
79806 #endif
79807 }
79808
79809 #ifdef SQLCIPHER_ENABLE_STAT3
79810 /*
79811 ** Load content from the sqlcipher_stat3 table into the Index.aSample[]
79812 ** arrays of all indices.
79813 */
79814 static int loadStat3(sqlcipher3 *db, const char *zDb){
79815   int rc;                       /* Result codes from subroutines */
79816   sqlcipher3_stmt *pStmt = 0;      /* An SQL statement being run */
79817   char *zSql;                   /* Text of the SQL statement */
79818   Index *pPrevIdx = 0;          /* Previous index in the loop */
79819   int idx = 0;                  /* slot in pIdx->aSample[] for next sample */
79820   int eType;                    /* Datatype of a sample */
79821   IndexSample *pSample;         /* A slot in pIdx->aSample[] */
79822
79823   if( !sqlcipher3FindTable(db, "sqlcipher_stat3", zDb) ){
79824     return SQLCIPHER_OK;
79825   }
79826
79827   zSql = sqlcipher3MPrintf(db, 
79828       "SELECT idx,count(*) FROM %Q.sqlcipher_stat3"
79829       " GROUP BY idx", zDb);
79830   if( !zSql ){
79831     return SQLCIPHER_NOMEM;
79832   }
79833   rc = sqlcipher3_prepare(db, zSql, -1, &pStmt, 0);
79834   sqlcipher3DbFree(db, zSql);
79835   if( rc ) return rc;
79836
79837   while( sqlcipher3_step(pStmt)==SQLCIPHER_ROW ){
79838     char *zIndex;   /* Index name */
79839     Index *pIdx;    /* Pointer to the index object */
79840     int nSample;    /* Number of samples */
79841
79842     zIndex = (char *)sqlcipher3_column_text(pStmt, 0);
79843     if( zIndex==0 ) continue;
79844     nSample = sqlcipher3_column_int(pStmt, 1);
79845     pIdx = sqlcipher3FindIndex(db, zIndex, zDb);
79846     if( pIdx==0 ) continue;
79847     assert( pIdx->nSample==0 );
79848     pIdx->nSample = nSample;
79849     pIdx->aSample = sqlcipher3MallocZero( nSample*sizeof(IndexSample) );
79850     pIdx->avgEq = pIdx->aiRowEst[1];
79851     if( pIdx->aSample==0 ){
79852       db->mallocFailed = 1;
79853       sqlcipher3_finalize(pStmt);
79854       return SQLCIPHER_NOMEM;
79855     }
79856   }
79857   rc = sqlcipher3_finalize(pStmt);
79858   if( rc ) return rc;
79859
79860   zSql = sqlcipher3MPrintf(db, 
79861       "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlcipher_stat3", zDb);
79862   if( !zSql ){
79863     return SQLCIPHER_NOMEM;
79864   }
79865   rc = sqlcipher3_prepare(db, zSql, -1, &pStmt, 0);
79866   sqlcipher3DbFree(db, zSql);
79867   if( rc ) return rc;
79868
79869   while( sqlcipher3_step(pStmt)==SQLCIPHER_ROW ){
79870     char *zIndex;   /* Index name */
79871     Index *pIdx;    /* Pointer to the index object */
79872     int i;          /* Loop counter */
79873     tRowcnt sumEq;  /* Sum of the nEq values */
79874
79875     zIndex = (char *)sqlcipher3_column_text(pStmt, 0);
79876     if( zIndex==0 ) continue;
79877     pIdx = sqlcipher3FindIndex(db, zIndex, zDb);
79878     if( pIdx==0 ) continue;
79879     if( pIdx==pPrevIdx ){
79880       idx++;
79881     }else{
79882       pPrevIdx = pIdx;
79883       idx = 0;
79884     }
79885     assert( idx<pIdx->nSample );
79886     pSample = &pIdx->aSample[idx];
79887     pSample->nEq = (tRowcnt)sqlcipher3_column_int64(pStmt, 1);
79888     pSample->nLt = (tRowcnt)sqlcipher3_column_int64(pStmt, 2);
79889     pSample->nDLt = (tRowcnt)sqlcipher3_column_int64(pStmt, 3);
79890     if( idx==pIdx->nSample-1 ){
79891       if( pSample->nDLt>0 ){
79892         for(i=0, sumEq=0; i<=idx-1; i++) sumEq += pIdx->aSample[i].nEq;
79893         pIdx->avgEq = (pSample->nLt - sumEq)/pSample->nDLt;
79894       }
79895       if( pIdx->avgEq<=0 ) pIdx->avgEq = 1;
79896     }
79897     eType = sqlcipher3_column_type(pStmt, 4);
79898     pSample->eType = (u8)eType;
79899     switch( eType ){
79900       case SQLCIPHER_INTEGER: {
79901         pSample->u.i = sqlcipher3_column_int64(pStmt, 4);
79902         break;
79903       }
79904       case SQLCIPHER_FLOAT: {
79905         pSample->u.r = sqlcipher3_column_double(pStmt, 4);
79906         break;
79907       }
79908       case SQLCIPHER_NULL: {
79909         break;
79910       }
79911       default: assert( eType==SQLCIPHER_TEXT || eType==SQLCIPHER_BLOB ); {
79912         const char *z = (const char *)(
79913               (eType==SQLCIPHER_BLOB) ?
79914               sqlcipher3_column_blob(pStmt, 4):
79915               sqlcipher3_column_text(pStmt, 4)
79916            );
79917         int n = z ? sqlcipher3_column_bytes(pStmt, 4) : 0;
79918         pSample->nByte = n;
79919         if( n < 1){
79920           pSample->u.z = 0;
79921         }else{
79922           pSample->u.z = sqlcipher3Malloc(n);
79923           if( pSample->u.z==0 ){
79924             db->mallocFailed = 1;
79925             sqlcipher3_finalize(pStmt);
79926             return SQLCIPHER_NOMEM;
79927           }
79928           memcpy(pSample->u.z, z, n);
79929         }
79930       }
79931     }
79932   }
79933   return sqlcipher3_finalize(pStmt);
79934 }
79935 #endif /* SQLCIPHER_ENABLE_STAT3 */
79936
79937 /*
79938 ** Load the content of the sqlcipher_stat1 and sqlcipher_stat3 tables. The
79939 ** contents of sqlcipher_stat1 are used to populate the Index.aiRowEst[]
79940 ** arrays. The contents of sqlcipher_stat3 are used to populate the
79941 ** Index.aSample[] arrays.
79942 **
79943 ** If the sqlcipher_stat1 table is not present in the database, SQLCIPHER_ERROR
79944 ** is returned. In this case, even if SQLCIPHER_ENABLE_STAT3 was defined 
79945 ** during compilation and the sqlcipher_stat3 table is present, no data is 
79946 ** read from it.
79947 **
79948 ** If SQLCIPHER_ENABLE_STAT3 was defined during compilation and the 
79949 ** sqlcipher_stat3 table is not present in the database, SQLCIPHER_ERROR is
79950 ** returned. However, in this case, data is read from the sqlcipher_stat1
79951 ** table (if it is present) before returning.
79952 **
79953 ** If an OOM error occurs, this function always sets db->mallocFailed.
79954 ** This means if the caller does not care about other errors, the return
79955 ** code may be ignored.
79956 */
79957 SQLCIPHER_PRIVATE int sqlcipher3AnalysisLoad(sqlcipher3 *db, int iDb){
79958   analysisInfo sInfo;
79959   HashElem *i;
79960   char *zSql;
79961   int rc;
79962
79963   assert( iDb>=0 && iDb<db->nDb );
79964   assert( db->aDb[iDb].pBt!=0 );
79965
79966   /* Clear any prior statistics */
79967   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
79968   for(i=sqlcipherHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqlcipherHashNext(i)){
79969     Index *pIdx = sqlcipherHashData(i);
79970     sqlcipher3DefaultRowEst(pIdx);
79971 #ifdef SQLCIPHER_ENABLE_STAT3
79972     sqlcipher3DeleteIndexSamples(db, pIdx);
79973     pIdx->aSample = 0;
79974 #endif
79975   }
79976
79977   /* Check to make sure the sqlcipher_stat1 table exists */
79978   sInfo.db = db;
79979   sInfo.zDatabase = db->aDb[iDb].zName;
79980   if( sqlcipher3FindTable(db, "sqlcipher_stat1", sInfo.zDatabase)==0 ){
79981     return SQLCIPHER_ERROR;
79982   }
79983
79984   /* Load new statistics out of the sqlcipher_stat1 table */
79985   zSql = sqlcipher3MPrintf(db, 
79986       "SELECT tbl,idx,stat FROM %Q.sqlcipher_stat1", sInfo.zDatabase);
79987   if( zSql==0 ){
79988     rc = SQLCIPHER_NOMEM;
79989   }else{
79990     rc = sqlcipher3_exec(db, zSql, analysisLoader, &sInfo, 0);
79991     sqlcipher3DbFree(db, zSql);
79992   }
79993
79994
79995   /* Load the statistics from the sqlcipher_stat3 table. */
79996 #ifdef SQLCIPHER_ENABLE_STAT3
79997   if( rc==SQLCIPHER_OK ){
79998     rc = loadStat3(db, sInfo.zDatabase);
79999   }
80000 #endif
80001
80002   if( rc==SQLCIPHER_NOMEM ){
80003     db->mallocFailed = 1;
80004   }
80005   return rc;
80006 }
80007
80008
80009 #endif /* SQLCIPHER_OMIT_ANALYZE */
80010
80011 /************** End of analyze.c *********************************************/
80012 /************** Begin file attach.c ******************************************/
80013 /*
80014 ** 2003 April 6
80015 **
80016 ** The author disclaims copyright to this source code.  In place of
80017 ** a legal notice, here is a blessing:
80018 **
80019 **    May you do good and not evil.
80020 **    May you find forgiveness for yourself and forgive others.
80021 **    May you share freely, never taking more than you give.
80022 **
80023 *************************************************************************
80024 ** This file contains code used to implement the ATTACH and DETACH commands.
80025 */
80026
80027 #ifndef SQLCIPHER_OMIT_ATTACH
80028 /*
80029 ** Resolve an expression that was part of an ATTACH or DETACH statement. This
80030 ** is slightly different from resolving a normal SQL expression, because simple
80031 ** identifiers are treated as strings, not possible column names or aliases.
80032 **
80033 ** i.e. if the parser sees:
80034 **
80035 **     ATTACH DATABASE abc AS def
80036 **
80037 ** it treats the two expressions as literal strings 'abc' and 'def' instead of
80038 ** looking for columns of the same name.
80039 **
80040 ** This only applies to the root node of pExpr, so the statement:
80041 **
80042 **     ATTACH DATABASE abc||def AS 'db2'
80043 **
80044 ** will fail because neither abc or def can be resolved.
80045 */
80046 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
80047 {
80048   int rc = SQLCIPHER_OK;
80049   if( pExpr ){
80050     if( pExpr->op!=TK_ID ){
80051       rc = sqlcipher3ResolveExprNames(pName, pExpr);
80052       if( rc==SQLCIPHER_OK && !sqlcipher3ExprIsConstant(pExpr) ){
80053         sqlcipher3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken);
80054         return SQLCIPHER_ERROR;
80055       }
80056     }else{
80057       pExpr->op = TK_STRING;
80058     }
80059   }
80060   return rc;
80061 }
80062
80063 /*
80064 ** An SQL user-function registered to do the work of an ATTACH statement. The
80065 ** three arguments to the function come directly from an attach statement:
80066 **
80067 **     ATTACH DATABASE x AS y KEY z
80068 **
80069 **     SELECT sqlcipher_attach(x, y, z)
80070 **
80071 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
80072 ** third argument.
80073 */
80074 static void attachFunc(
80075   sqlcipher3_context *context,
80076   int NotUsed,
80077   sqlcipher3_value **argv
80078 ){
80079   int i;
80080   int rc = 0;
80081   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
80082   const char *zName;
80083   const char *zFile;
80084   char *zPath = 0;
80085   char *zErr = 0;
80086   unsigned int flags;
80087   Db *aNew;
80088   char *zErrDyn = 0;
80089   sqlcipher3_vfs *pVfs;
80090
80091   UNUSED_PARAMETER(NotUsed);
80092
80093   zFile = (const char *)sqlcipher3_value_text(argv[0]);
80094   zName = (const char *)sqlcipher3_value_text(argv[1]);
80095   if( zFile==0 ) zFile = "";
80096   if( zName==0 ) zName = "";
80097
80098   /* Check for the following errors:
80099   **
80100   **     * Too many attached databases,
80101   **     * Transaction currently open
80102   **     * Specified database name already being used.
80103   */
80104   if( db->nDb>=db->aLimit[SQLCIPHER_LIMIT_ATTACHED]+2 ){
80105     zErrDyn = sqlcipher3MPrintf(db, "too many attached databases - max %d", 
80106       db->aLimit[SQLCIPHER_LIMIT_ATTACHED]
80107     );
80108     goto attach_error;
80109   }
80110   if( !db->autoCommit ){
80111     zErrDyn = sqlcipher3MPrintf(db, "cannot ATTACH database within transaction");
80112     goto attach_error;
80113   }
80114   for(i=0; i<db->nDb; i++){
80115     char *z = db->aDb[i].zName;
80116     assert( z && zName );
80117     if( sqlcipher3StrICmp(z, zName)==0 ){
80118       zErrDyn = sqlcipher3MPrintf(db, "database %s is already in use", zName);
80119       goto attach_error;
80120     }
80121   }
80122
80123   /* Allocate the new entry in the db->aDb[] array and initialise the schema
80124   ** hash tables.
80125   */
80126   if( db->aDb==db->aDbStatic ){
80127     aNew = sqlcipher3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
80128     if( aNew==0 ) return;
80129     memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
80130   }else{
80131     aNew = sqlcipher3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
80132     if( aNew==0 ) return;
80133   }
80134   db->aDb = aNew;
80135   aNew = &db->aDb[db->nDb];
80136   memset(aNew, 0, sizeof(*aNew));
80137
80138   /* Open the database file. If the btree is successfully opened, use
80139   ** it to obtain the database schema. At this point the schema may
80140   ** or may not be initialised.
80141   */
80142   flags = db->openFlags;
80143   rc = sqlcipher3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
80144   if( rc!=SQLCIPHER_OK ){
80145     if( rc==SQLCIPHER_NOMEM ) db->mallocFailed = 1;
80146     sqlcipher3_result_error(context, zErr, -1);
80147     sqlcipher3_free(zErr);
80148     return;
80149   }
80150   assert( pVfs );
80151   flags |= SQLCIPHER_OPEN_MAIN_DB;
80152   rc = sqlcipher3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);
80153   sqlcipher3_free( zPath );
80154   db->nDb++;
80155   if( rc==SQLCIPHER_CONSTRAINT ){
80156     rc = SQLCIPHER_ERROR;
80157     zErrDyn = sqlcipher3MPrintf(db, "database is already attached");
80158   }else if( rc==SQLCIPHER_OK ){
80159     Pager *pPager;
80160     aNew->pSchema = sqlcipher3SchemaGet(db, aNew->pBt);
80161     if( !aNew->pSchema ){
80162       rc = SQLCIPHER_NOMEM;
80163     }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
80164       zErrDyn = sqlcipher3MPrintf(db, 
80165         "attached databases must use the same text encoding as main database");
80166       rc = SQLCIPHER_ERROR;
80167     }
80168     pPager = sqlcipher3BtreePager(aNew->pBt);
80169     sqlcipher3PagerLockingMode(pPager, db->dfltLockMode);
80170     sqlcipher3BtreeSecureDelete(aNew->pBt,
80171                              sqlcipher3BtreeSecureDelete(db->aDb[0].pBt,-1) );
80172   }
80173   aNew->safety_level = 3;
80174   aNew->zName = sqlcipher3DbStrDup(db, zName);
80175   if( rc==SQLCIPHER_OK && aNew->zName==0 ){
80176     rc = SQLCIPHER_NOMEM;
80177   }
80178
80179
80180 #ifdef SQLCIPHER_HAS_CODEC
80181   if( rc==SQLCIPHER_OK ){
80182     extern int sqlcipher3CodecAttach(sqlcipher3*, int, const void*, int);
80183     extern void sqlcipher3CodecGetKey(sqlcipher3*, int, void**, int*);
80184     int nKey;
80185     char *zKey;
80186     int t = sqlcipher3_value_type(argv[2]);
80187     switch( t ){
80188       case SQLCIPHER_INTEGER:
80189       case SQLCIPHER_FLOAT:
80190         zErrDyn = sqlcipher3DbStrDup(db, "Invalid key value");
80191         rc = SQLCIPHER_ERROR;
80192         break;
80193         
80194       case SQLCIPHER_TEXT:
80195       case SQLCIPHER_BLOB:
80196         nKey = sqlcipher3_value_bytes(argv[2]);
80197         zKey = (char *)sqlcipher3_value_blob(argv[2]);
80198         rc = sqlcipher3CodecAttach(db, db->nDb-1, zKey, nKey);
80199         break;
80200
80201       case SQLCIPHER_NULL:
80202         /* No key specified.  Use the key from the main database */
80203         sqlcipher3CodecGetKey(db, 0, (void**)&zKey, &nKey);
80204         if( nKey>0 || sqlcipher3BtreeGetReserve(db->aDb[0].pBt)>0 ){
80205           rc = sqlcipher3CodecAttach(db, db->nDb-1, zKey, nKey);
80206         }
80207         break;
80208     }
80209   }
80210 #endif
80211
80212   /* If the file was opened successfully, read the schema for the new database.
80213   ** If this fails, or if opening the file failed, then close the file and 
80214   ** remove the entry from the db->aDb[] array. i.e. put everything back the way
80215   ** we found it.
80216   */
80217   if( rc==SQLCIPHER_OK ){
80218     sqlcipher3BtreeEnterAll(db);
80219     rc = sqlcipher3Init(db, &zErrDyn);
80220     sqlcipher3BtreeLeaveAll(db);
80221   }
80222   if( rc ){
80223     int iDb = db->nDb - 1;
80224     assert( iDb>=2 );
80225     if( db->aDb[iDb].pBt ){
80226       sqlcipher3BtreeClose(db->aDb[iDb].pBt);
80227       db->aDb[iDb].pBt = 0;
80228       db->aDb[iDb].pSchema = 0;
80229     }
80230     sqlcipher3ResetInternalSchema(db, -1);
80231     db->nDb = iDb;
80232     if( rc==SQLCIPHER_NOMEM || rc==SQLCIPHER_IOERR_NOMEM ){
80233       db->mallocFailed = 1;
80234       sqlcipher3DbFree(db, zErrDyn);
80235       zErrDyn = sqlcipher3MPrintf(db, "out of memory");
80236     }else if( zErrDyn==0 ){
80237       zErrDyn = sqlcipher3MPrintf(db, "unable to open database: %s", zFile);
80238     }
80239     goto attach_error;
80240   }
80241   
80242   return;
80243
80244 attach_error:
80245   /* Return an error if we get here */
80246   if( zErrDyn ){
80247     sqlcipher3_result_error(context, zErrDyn, -1);
80248     sqlcipher3DbFree(db, zErrDyn);
80249   }
80250   if( rc ) sqlcipher3_result_error_code(context, rc);
80251 }
80252
80253 /*
80254 ** An SQL user-function registered to do the work of an DETACH statement. The
80255 ** three arguments to the function come directly from a detach statement:
80256 **
80257 **     DETACH DATABASE x
80258 **
80259 **     SELECT sqlcipher_detach(x)
80260 */
80261 static void detachFunc(
80262   sqlcipher3_context *context,
80263   int NotUsed,
80264   sqlcipher3_value **argv
80265 ){
80266   const char *zName = (const char *)sqlcipher3_value_text(argv[0]);
80267   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
80268   int i;
80269   Db *pDb = 0;
80270   char zErr[128];
80271
80272   UNUSED_PARAMETER(NotUsed);
80273
80274   if( zName==0 ) zName = "";
80275   for(i=0; i<db->nDb; i++){
80276     pDb = &db->aDb[i];
80277     if( pDb->pBt==0 ) continue;
80278     if( sqlcipher3StrICmp(pDb->zName, zName)==0 ) break;
80279   }
80280
80281   if( i>=db->nDb ){
80282     sqlcipher3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
80283     goto detach_error;
80284   }
80285   if( i<2 ){
80286     sqlcipher3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
80287     goto detach_error;
80288   }
80289   if( !db->autoCommit ){
80290     sqlcipher3_snprintf(sizeof(zErr), zErr,
80291                      "cannot DETACH database within transaction");
80292     goto detach_error;
80293   }
80294   if( sqlcipher3BtreeIsInReadTrans(pDb->pBt) || sqlcipher3BtreeIsInBackup(pDb->pBt) ){
80295     sqlcipher3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
80296     goto detach_error;
80297   }
80298
80299   sqlcipher3BtreeClose(pDb->pBt);
80300   pDb->pBt = 0;
80301   pDb->pSchema = 0;
80302   sqlcipher3ResetInternalSchema(db, -1);
80303   return;
80304
80305 detach_error:
80306   sqlcipher3_result_error(context, zErr, -1);
80307 }
80308
80309 /*
80310 ** This procedure generates VDBE code for a single invocation of either the
80311 ** sqlcipher_detach() or sqlcipher_attach() SQL user functions.
80312 */
80313 static void codeAttach(
80314   Parse *pParse,       /* The parser context */
80315   int type,            /* Either SQLCIPHER_ATTACH or SQLCIPHER_DETACH */
80316   FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
80317   Expr *pAuthArg,      /* Expression to pass to authorization callback */
80318   Expr *pFilename,     /* Name of database file */
80319   Expr *pDbname,       /* Name of the database to use internally */
80320   Expr *pKey           /* Database key for encryption extension */
80321 ){
80322   int rc;
80323   NameContext sName;
80324   Vdbe *v;
80325   sqlcipher3* db = pParse->db;
80326   int regArgs;
80327
80328   memset(&sName, 0, sizeof(NameContext));
80329   sName.pParse = pParse;
80330
80331   if( 
80332       SQLCIPHER_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
80333       SQLCIPHER_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
80334       SQLCIPHER_OK!=(rc = resolveAttachExpr(&sName, pKey))
80335   ){
80336     pParse->nErr++;
80337     goto attach_end;
80338   }
80339
80340 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
80341   if( pAuthArg ){
80342     char *zAuthArg;
80343     if( pAuthArg->op==TK_STRING ){
80344       zAuthArg = pAuthArg->u.zToken;
80345     }else{
80346       zAuthArg = 0;
80347     }
80348     rc = sqlcipher3AuthCheck(pParse, type, zAuthArg, 0, 0);
80349     if(rc!=SQLCIPHER_OK ){
80350       goto attach_end;
80351     }
80352   }
80353 #endif /* SQLCIPHER_OMIT_AUTHORIZATION */
80354
80355
80356   v = sqlcipher3GetVdbe(pParse);
80357   regArgs = sqlcipher3GetTempRange(pParse, 4);
80358   sqlcipher3ExprCode(pParse, pFilename, regArgs);
80359   sqlcipher3ExprCode(pParse, pDbname, regArgs+1);
80360   sqlcipher3ExprCode(pParse, pKey, regArgs+2);
80361
80362   assert( v || db->mallocFailed );
80363   if( v ){
80364     sqlcipher3VdbeAddOp3(v, OP_Function, 0, regArgs+3-pFunc->nArg, regArgs+3);
80365     assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
80366     sqlcipher3VdbeChangeP5(v, (u8)(pFunc->nArg));
80367     sqlcipher3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
80368
80369     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
80370     ** statement only). For DETACH, set it to false (expire all existing
80371     ** statements).
80372     */
80373     sqlcipher3VdbeAddOp1(v, OP_Expire, (type==SQLCIPHER_ATTACH));
80374   }
80375   
80376 attach_end:
80377   sqlcipher3ExprDelete(db, pFilename);
80378   sqlcipher3ExprDelete(db, pDbname);
80379   sqlcipher3ExprDelete(db, pKey);
80380 }
80381
80382 /*
80383 ** Called by the parser to compile a DETACH statement.
80384 **
80385 **     DETACH pDbname
80386 */
80387 SQLCIPHER_PRIVATE void sqlcipher3Detach(Parse *pParse, Expr *pDbname){
80388   static const FuncDef detach_func = {
80389     1,                /* nArg */
80390     SQLCIPHER_UTF8,      /* iPrefEnc */
80391     0,                /* flags */
80392     0,                /* pUserData */
80393     0,                /* pNext */
80394     detachFunc,       /* xFunc */
80395     0,                /* xStep */
80396     0,                /* xFinalize */
80397     "sqlcipher_detach",  /* zName */
80398     0,                /* pHash */
80399     0                 /* pDestructor */
80400   };
80401   codeAttach(pParse, SQLCIPHER_DETACH, &detach_func, pDbname, 0, 0, pDbname);
80402 }
80403
80404 /*
80405 ** Called by the parser to compile an ATTACH statement.
80406 **
80407 **     ATTACH p AS pDbname KEY pKey
80408 */
80409 SQLCIPHER_PRIVATE void sqlcipher3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
80410   static const FuncDef attach_func = {
80411     3,                /* nArg */
80412     SQLCIPHER_UTF8,      /* iPrefEnc */
80413     0,                /* flags */
80414     0,                /* pUserData */
80415     0,                /* pNext */
80416     attachFunc,       /* xFunc */
80417     0,                /* xStep */
80418     0,                /* xFinalize */
80419     "sqlcipher_attach",  /* zName */
80420     0,                /* pHash */
80421     0                 /* pDestructor */
80422   };
80423   codeAttach(pParse, SQLCIPHER_ATTACH, &attach_func, p, p, pDbname, pKey);
80424 }
80425 #endif /* SQLCIPHER_OMIT_ATTACH */
80426
80427 /*
80428 ** Initialize a DbFixer structure.  This routine must be called prior
80429 ** to passing the structure to one of the sqlcipherFixAAAA() routines below.
80430 **
80431 ** The return value indicates whether or not fixation is required.  TRUE
80432 ** means we do need to fix the database references, FALSE means we do not.
80433 */
80434 SQLCIPHER_PRIVATE int sqlcipher3FixInit(
80435   DbFixer *pFix,      /* The fixer to be initialized */
80436   Parse *pParse,      /* Error messages will be written here */
80437   int iDb,            /* This is the database that must be used */
80438   const char *zType,  /* "view", "trigger", or "index" */
80439   const Token *pName  /* Name of the view, trigger, or index */
80440 ){
80441   sqlcipher3 *db;
80442
80443   if( NEVER(iDb<0) || iDb==1 ) return 0;
80444   db = pParse->db;
80445   assert( db->nDb>iDb );
80446   pFix->pParse = pParse;
80447   pFix->zDb = db->aDb[iDb].zName;
80448   pFix->zType = zType;
80449   pFix->pName = pName;
80450   return 1;
80451 }
80452
80453 /*
80454 ** The following set of routines walk through the parse tree and assign
80455 ** a specific database to all table references where the database name
80456 ** was left unspecified in the original SQL statement.  The pFix structure
80457 ** must have been initialized by a prior call to sqlcipher3FixInit().
80458 **
80459 ** These routines are used to make sure that an index, trigger, or
80460 ** view in one database does not refer to objects in a different database.
80461 ** (Exception: indices, triggers, and views in the TEMP database are
80462 ** allowed to refer to anything.)  If a reference is explicitly made
80463 ** to an object in a different database, an error message is added to
80464 ** pParse->zErrMsg and these routines return non-zero.  If everything
80465 ** checks out, these routines return 0.
80466 */
80467 SQLCIPHER_PRIVATE int sqlcipher3FixSrcList(
80468   DbFixer *pFix,       /* Context of the fixation */
80469   SrcList *pList       /* The Source list to check and modify */
80470 ){
80471   int i;
80472   const char *zDb;
80473   struct SrcList_item *pItem;
80474
80475   if( NEVER(pList==0) ) return 0;
80476   zDb = pFix->zDb;
80477   for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
80478     if( pItem->zDatabase==0 ){
80479       pItem->zDatabase = sqlcipher3DbStrDup(pFix->pParse->db, zDb);
80480     }else if( sqlcipher3StrICmp(pItem->zDatabase,zDb)!=0 ){
80481       sqlcipher3ErrorMsg(pFix->pParse,
80482          "%s %T cannot reference objects in database %s",
80483          pFix->zType, pFix->pName, pItem->zDatabase);
80484       return 1;
80485     }
80486 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_TRIGGER)
80487     if( sqlcipher3FixSelect(pFix, pItem->pSelect) ) return 1;
80488     if( sqlcipher3FixExpr(pFix, pItem->pOn) ) return 1;
80489 #endif
80490   }
80491   return 0;
80492 }
80493 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_TRIGGER)
80494 SQLCIPHER_PRIVATE int sqlcipher3FixSelect(
80495   DbFixer *pFix,       /* Context of the fixation */
80496   Select *pSelect      /* The SELECT statement to be fixed to one database */
80497 ){
80498   while( pSelect ){
80499     if( sqlcipher3FixExprList(pFix, pSelect->pEList) ){
80500       return 1;
80501     }
80502     if( sqlcipher3FixSrcList(pFix, pSelect->pSrc) ){
80503       return 1;
80504     }
80505     if( sqlcipher3FixExpr(pFix, pSelect->pWhere) ){
80506       return 1;
80507     }
80508     if( sqlcipher3FixExpr(pFix, pSelect->pHaving) ){
80509       return 1;
80510     }
80511     pSelect = pSelect->pPrior;
80512   }
80513   return 0;
80514 }
80515 SQLCIPHER_PRIVATE int sqlcipher3FixExpr(
80516   DbFixer *pFix,     /* Context of the fixation */
80517   Expr *pExpr        /* The expression to be fixed to one database */
80518 ){
80519   while( pExpr ){
80520     if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ) break;
80521     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
80522       if( sqlcipher3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
80523     }else{
80524       if( sqlcipher3FixExprList(pFix, pExpr->x.pList) ) return 1;
80525     }
80526     if( sqlcipher3FixExpr(pFix, pExpr->pRight) ){
80527       return 1;
80528     }
80529     pExpr = pExpr->pLeft;
80530   }
80531   return 0;
80532 }
80533 SQLCIPHER_PRIVATE int sqlcipher3FixExprList(
80534   DbFixer *pFix,     /* Context of the fixation */
80535   ExprList *pList    /* The expression to be fixed to one database */
80536 ){
80537   int i;
80538   struct ExprList_item *pItem;
80539   if( pList==0 ) return 0;
80540   for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
80541     if( sqlcipher3FixExpr(pFix, pItem->pExpr) ){
80542       return 1;
80543     }
80544   }
80545   return 0;
80546 }
80547 #endif
80548
80549 #ifndef SQLCIPHER_OMIT_TRIGGER
80550 SQLCIPHER_PRIVATE int sqlcipher3FixTriggerStep(
80551   DbFixer *pFix,     /* Context of the fixation */
80552   TriggerStep *pStep /* The trigger step be fixed to one database */
80553 ){
80554   while( pStep ){
80555     if( sqlcipher3FixSelect(pFix, pStep->pSelect) ){
80556       return 1;
80557     }
80558     if( sqlcipher3FixExpr(pFix, pStep->pWhere) ){
80559       return 1;
80560     }
80561     if( sqlcipher3FixExprList(pFix, pStep->pExprList) ){
80562       return 1;
80563     }
80564     pStep = pStep->pNext;
80565   }
80566   return 0;
80567 }
80568 #endif
80569
80570 /************** End of attach.c **********************************************/
80571 /************** Begin file auth.c ********************************************/
80572 /*
80573 ** 2003 January 11
80574 **
80575 ** The author disclaims copyright to this source code.  In place of
80576 ** a legal notice, here is a blessing:
80577 **
80578 **    May you do good and not evil.
80579 **    May you find forgiveness for yourself and forgive others.
80580 **    May you share freely, never taking more than you give.
80581 **
80582 *************************************************************************
80583 ** This file contains code used to implement the sqlcipher3_set_authorizer()
80584 ** API.  This facility is an optional feature of the library.  Embedded
80585 ** systems that do not need this facility may omit it by recompiling
80586 ** the library with -DSQLCIPHER_OMIT_AUTHORIZATION=1
80587 */
80588
80589 /*
80590 ** All of the code in this file may be omitted by defining a single
80591 ** macro.
80592 */
80593 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
80594
80595 /*
80596 ** Set or clear the access authorization function.
80597 **
80598 ** The access authorization function is be called during the compilation
80599 ** phase to verify that the user has read and/or write access permission on
80600 ** various fields of the database.  The first argument to the auth function
80601 ** is a copy of the 3rd argument to this routine.  The second argument
80602 ** to the auth function is one of these constants:
80603 **
80604 **       SQLCIPHER_CREATE_INDEX
80605 **       SQLCIPHER_CREATE_TABLE
80606 **       SQLCIPHER_CREATE_TEMP_INDEX
80607 **       SQLCIPHER_CREATE_TEMP_TABLE
80608 **       SQLCIPHER_CREATE_TEMP_TRIGGER
80609 **       SQLCIPHER_CREATE_TEMP_VIEW
80610 **       SQLCIPHER_CREATE_TRIGGER
80611 **       SQLCIPHER_CREATE_VIEW
80612 **       SQLCIPHER_DELETE
80613 **       SQLCIPHER_DROP_INDEX
80614 **       SQLCIPHER_DROP_TABLE
80615 **       SQLCIPHER_DROP_TEMP_INDEX
80616 **       SQLCIPHER_DROP_TEMP_TABLE
80617 **       SQLCIPHER_DROP_TEMP_TRIGGER
80618 **       SQLCIPHER_DROP_TEMP_VIEW
80619 **       SQLCIPHER_DROP_TRIGGER
80620 **       SQLCIPHER_DROP_VIEW
80621 **       SQLCIPHER_INSERT
80622 **       SQLCIPHER_PRAGMA
80623 **       SQLCIPHER_READ
80624 **       SQLCIPHER_SELECT
80625 **       SQLCIPHER_TRANSACTION
80626 **       SQLCIPHER_UPDATE
80627 **
80628 ** The third and fourth arguments to the auth function are the name of
80629 ** the table and the column that are being accessed.  The auth function
80630 ** should return either SQLCIPHER_OK, SQLCIPHER_DENY, or SQLCIPHER_IGNORE.  If
80631 ** SQLCIPHER_OK is returned, it means that access is allowed.  SQLCIPHER_DENY
80632 ** means that the SQL statement will never-run - the sqlcipher3_exec() call
80633 ** will return with an error.  SQLCIPHER_IGNORE means that the SQL statement
80634 ** should run but attempts to read the specified column will return NULL
80635 ** and attempts to write the column will be ignored.
80636 **
80637 ** Setting the auth function to NULL disables this hook.  The default
80638 ** setting of the auth function is NULL.
80639 */
80640 SQLCIPHER_API int sqlcipher3_set_authorizer(
80641   sqlcipher3 *db,
80642   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
80643   void *pArg
80644 ){
80645   sqlcipher3_mutex_enter(db->mutex);
80646   db->xAuth = xAuth;
80647   db->pAuthArg = pArg;
80648   sqlcipher3ExpirePreparedStatements(db);
80649   sqlcipher3_mutex_leave(db->mutex);
80650   return SQLCIPHER_OK;
80651 }
80652
80653 /*
80654 ** Write an error message into pParse->zErrMsg that explains that the
80655 ** user-supplied authorization function returned an illegal value.
80656 */
80657 static void sqlcipherAuthBadReturnCode(Parse *pParse){
80658   sqlcipher3ErrorMsg(pParse, "authorizer malfunction");
80659   pParse->rc = SQLCIPHER_ERROR;
80660 }
80661
80662 /*
80663 ** Invoke the authorization callback for permission to read column zCol from
80664 ** table zTab in database zDb. This function assumes that an authorization
80665 ** callback has been registered (i.e. that sqlcipher3.xAuth is not NULL).
80666 **
80667 ** If SQLCIPHER_IGNORE is returned and pExpr is not NULL, then pExpr is changed
80668 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLCIPHER_IGNORE
80669 ** is treated as SQLCIPHER_DENY. In this case an error is left in pParse.
80670 */
80671 SQLCIPHER_PRIVATE int sqlcipher3AuthReadCol(
80672   Parse *pParse,                  /* The parser context */
80673   const char *zTab,               /* Table name */
80674   const char *zCol,               /* Column name */
80675   int iDb                         /* Index of containing database. */
80676 ){
80677   sqlcipher3 *db = pParse->db;       /* Database handle */
80678   char *zDb = db->aDb[iDb].zName; /* Name of attached database */
80679   int rc;                         /* Auth callback return code */
80680
80681   rc = db->xAuth(db->pAuthArg, SQLCIPHER_READ, zTab,zCol,zDb,pParse->zAuthContext);
80682   if( rc==SQLCIPHER_DENY ){
80683     if( db->nDb>2 || iDb!=0 ){
80684       sqlcipher3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol);
80685     }else{
80686       sqlcipher3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol);
80687     }
80688     pParse->rc = SQLCIPHER_AUTH;
80689   }else if( rc!=SQLCIPHER_IGNORE && rc!=SQLCIPHER_OK ){
80690     sqlcipherAuthBadReturnCode(pParse);
80691   }
80692   return rc;
80693 }
80694
80695 /*
80696 ** The pExpr should be a TK_COLUMN expression.  The table referred to
80697 ** is in pTabList or else it is the NEW or OLD table of a trigger.  
80698 ** Check to see if it is OK to read this particular column.
80699 **
80700 ** If the auth function returns SQLCIPHER_IGNORE, change the TK_COLUMN 
80701 ** instruction into a TK_NULL.  If the auth function returns SQLCIPHER_DENY,
80702 ** then generate an error.
80703 */
80704 SQLCIPHER_PRIVATE void sqlcipher3AuthRead(
80705   Parse *pParse,        /* The parser context */
80706   Expr *pExpr,          /* The expression to check authorization on */
80707   Schema *pSchema,      /* The schema of the expression */
80708   SrcList *pTabList     /* All table that pExpr might refer to */
80709 ){
80710   sqlcipher3 *db = pParse->db;
80711   Table *pTab = 0;      /* The table being read */
80712   const char *zCol;     /* Name of the column of the table */
80713   int iSrc;             /* Index in pTabList->a[] of table being read */
80714   int iDb;              /* The index of the database the expression refers to */
80715   int iCol;             /* Index of column in table */
80716
80717   if( db->xAuth==0 ) return;
80718   iDb = sqlcipher3SchemaToIndex(pParse->db, pSchema);
80719   if( iDb<0 ){
80720     /* An attempt to read a column out of a subquery or other
80721     ** temporary table. */
80722     return;
80723   }
80724
80725   assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
80726   if( pExpr->op==TK_TRIGGER ){
80727     pTab = pParse->pTriggerTab;
80728   }else{
80729     assert( pTabList );
80730     for(iSrc=0; ALWAYS(iSrc<pTabList->nSrc); iSrc++){
80731       if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
80732         pTab = pTabList->a[iSrc].pTab;
80733         break;
80734       }
80735     }
80736   }
80737   iCol = pExpr->iColumn;
80738   if( NEVER(pTab==0) ) return;
80739
80740   if( iCol>=0 ){
80741     assert( iCol<pTab->nCol );
80742     zCol = pTab->aCol[iCol].zName;
80743   }else if( pTab->iPKey>=0 ){
80744     assert( pTab->iPKey<pTab->nCol );
80745     zCol = pTab->aCol[pTab->iPKey].zName;
80746   }else{
80747     zCol = "ROWID";
80748   }
80749   assert( iDb>=0 && iDb<db->nDb );
80750   if( SQLCIPHER_IGNORE==sqlcipher3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
80751     pExpr->op = TK_NULL;
80752   }
80753 }
80754
80755 /*
80756 ** Do an authorization check using the code and arguments given.  Return
80757 ** either SQLCIPHER_OK (zero) or SQLCIPHER_IGNORE or SQLCIPHER_DENY.  If SQLCIPHER_DENY
80758 ** is returned, then the error count and error message in pParse are
80759 ** modified appropriately.
80760 */
80761 SQLCIPHER_PRIVATE int sqlcipher3AuthCheck(
80762   Parse *pParse,
80763   int code,
80764   const char *zArg1,
80765   const char *zArg2,
80766   const char *zArg3
80767 ){
80768   sqlcipher3 *db = pParse->db;
80769   int rc;
80770
80771   /* Don't do any authorization checks if the database is initialising
80772   ** or if the parser is being invoked from within sqlcipher3_declare_vtab.
80773   */
80774   if( db->init.busy || IN_DECLARE_VTAB ){
80775     return SQLCIPHER_OK;
80776   }
80777
80778   if( db->xAuth==0 ){
80779     return SQLCIPHER_OK;
80780   }
80781   rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext);
80782   if( rc==SQLCIPHER_DENY ){
80783     sqlcipher3ErrorMsg(pParse, "not authorized");
80784     pParse->rc = SQLCIPHER_AUTH;
80785   }else if( rc!=SQLCIPHER_OK && rc!=SQLCIPHER_IGNORE ){
80786     rc = SQLCIPHER_DENY;
80787     sqlcipherAuthBadReturnCode(pParse);
80788   }
80789   return rc;
80790 }
80791
80792 /*
80793 ** Push an authorization context.  After this routine is called, the
80794 ** zArg3 argument to authorization callbacks will be zContext until
80795 ** popped.  Or if pParse==0, this routine is a no-op.
80796 */
80797 SQLCIPHER_PRIVATE void sqlcipher3AuthContextPush(
80798   Parse *pParse,
80799   AuthContext *pContext, 
80800   const char *zContext
80801 ){
80802   assert( pParse );
80803   pContext->pParse = pParse;
80804   pContext->zAuthContext = pParse->zAuthContext;
80805   pParse->zAuthContext = zContext;
80806 }
80807
80808 /*
80809 ** Pop an authorization context that was previously pushed
80810 ** by sqlcipher3AuthContextPush
80811 */
80812 SQLCIPHER_PRIVATE void sqlcipher3AuthContextPop(AuthContext *pContext){
80813   if( pContext->pParse ){
80814     pContext->pParse->zAuthContext = pContext->zAuthContext;
80815     pContext->pParse = 0;
80816   }
80817 }
80818
80819 #endif /* SQLCIPHER_OMIT_AUTHORIZATION */
80820
80821 /************** End of auth.c ************************************************/
80822 /************** Begin file build.c *******************************************/
80823 /*
80824 ** 2001 September 15
80825 **
80826 ** The author disclaims copyright to this source code.  In place of
80827 ** a legal notice, here is a blessing:
80828 **
80829 **    May you do good and not evil.
80830 **    May you find forgiveness for yourself and forgive others.
80831 **    May you share freely, never taking more than you give.
80832 **
80833 *************************************************************************
80834 ** This file contains C code routines that are called by the SQLite parser
80835 ** when syntax rules are reduced.  The routines in this file handle the
80836 ** following kinds of SQL syntax:
80837 **
80838 **     CREATE TABLE
80839 **     DROP TABLE
80840 **     CREATE INDEX
80841 **     DROP INDEX
80842 **     creating ID lists
80843 **     BEGIN TRANSACTION
80844 **     COMMIT
80845 **     ROLLBACK
80846 */
80847
80848 /*
80849 ** This routine is called when a new SQL statement is beginning to
80850 ** be parsed.  Initialize the pParse structure as needed.
80851 */
80852 SQLCIPHER_PRIVATE void sqlcipher3BeginParse(Parse *pParse, int explainFlag){
80853   pParse->explain = (u8)explainFlag;
80854   pParse->nVar = 0;
80855 }
80856
80857 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
80858 /*
80859 ** The TableLock structure is only used by the sqlcipher3TableLock() and
80860 ** codeTableLocks() functions.
80861 */
80862 struct TableLock {
80863   int iDb;             /* The database containing the table to be locked */
80864   int iTab;            /* The root page of the table to be locked */
80865   u8 isWriteLock;      /* True for write lock.  False for a read lock */
80866   const char *zName;   /* Name of the table */
80867 };
80868
80869 /*
80870 ** Record the fact that we want to lock a table at run-time.  
80871 **
80872 ** The table to be locked has root page iTab and is found in database iDb.
80873 ** A read or a write lock can be taken depending on isWritelock.
80874 **
80875 ** This routine just records the fact that the lock is desired.  The
80876 ** code to make the lock occur is generated by a later call to
80877 ** codeTableLocks() which occurs during sqlcipher3FinishCoding().
80878 */
80879 SQLCIPHER_PRIVATE void sqlcipher3TableLock(
80880   Parse *pParse,     /* Parsing context */
80881   int iDb,           /* Index of the database containing the table to lock */
80882   int iTab,          /* Root page number of the table to be locked */
80883   u8 isWriteLock,    /* True for a write lock */
80884   const char *zName  /* Name of the table to be locked */
80885 ){
80886   Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
80887   int i;
80888   int nBytes;
80889   TableLock *p;
80890   assert( iDb>=0 );
80891
80892   for(i=0; i<pToplevel->nTableLock; i++){
80893     p = &pToplevel->aTableLock[i];
80894     if( p->iDb==iDb && p->iTab==iTab ){
80895       p->isWriteLock = (p->isWriteLock || isWriteLock);
80896       return;
80897     }
80898   }
80899
80900   nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
80901   pToplevel->aTableLock =
80902       sqlcipher3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
80903   if( pToplevel->aTableLock ){
80904     p = &pToplevel->aTableLock[pToplevel->nTableLock++];
80905     p->iDb = iDb;
80906     p->iTab = iTab;
80907     p->isWriteLock = isWriteLock;
80908     p->zName = zName;
80909   }else{
80910     pToplevel->nTableLock = 0;
80911     pToplevel->db->mallocFailed = 1;
80912   }
80913 }
80914
80915 /*
80916 ** Code an OP_TableLock instruction for each table locked by the
80917 ** statement (configured by calls to sqlcipher3TableLock()).
80918 */
80919 static void codeTableLocks(Parse *pParse){
80920   int i;
80921   Vdbe *pVdbe; 
80922
80923   pVdbe = sqlcipher3GetVdbe(pParse);
80924   assert( pVdbe!=0 ); /* sqlcipher3GetVdbe cannot fail: VDBE already allocated */
80925
80926   for(i=0; i<pParse->nTableLock; i++){
80927     TableLock *p = &pParse->aTableLock[i];
80928     int p1 = p->iDb;
80929     sqlcipher3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
80930                       p->zName, P4_STATIC);
80931   }
80932 }
80933 #else
80934   #define codeTableLocks(x)
80935 #endif
80936
80937 /*
80938 ** This routine is called after a single SQL statement has been
80939 ** parsed and a VDBE program to execute that statement has been
80940 ** prepared.  This routine puts the finishing touches on the
80941 ** VDBE program and resets the pParse structure for the next
80942 ** parse.
80943 **
80944 ** Note that if an error occurred, it might be the case that
80945 ** no VDBE code was generated.
80946 */
80947 SQLCIPHER_PRIVATE void sqlcipher3FinishCoding(Parse *pParse){
80948   sqlcipher3 *db;
80949   Vdbe *v;
80950
80951   db = pParse->db;
80952   if( db->mallocFailed ) return;
80953   if( pParse->nested ) return;
80954   if( pParse->nErr ) return;
80955
80956   /* Begin by generating some termination code at the end of the
80957   ** vdbe program
80958   */
80959   v = sqlcipher3GetVdbe(pParse);
80960   assert( !pParse->isMultiWrite 
80961        || sqlcipher3VdbeAssertMayAbort(v, pParse->mayAbort));
80962   if( v ){
80963     sqlcipher3VdbeAddOp0(v, OP_Halt);
80964
80965     /* The cookie mask contains one bit for each database file open.
80966     ** (Bit 0 is for main, bit 1 is for temp, and so forth.)  Bits are
80967     ** set for each database that is used.  Generate code to start a
80968     ** transaction on each used database and to verify the schema cookie
80969     ** on each used database.
80970     */
80971     if( pParse->cookieGoto>0 ){
80972       yDbMask mask;
80973       int iDb;
80974       sqlcipher3VdbeJumpHere(v, pParse->cookieGoto-1);
80975       for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
80976         if( (mask & pParse->cookieMask)==0 ) continue;
80977         sqlcipher3VdbeUsesBtree(v, iDb);
80978         sqlcipher3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
80979         if( db->init.busy==0 ){
80980           assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
80981           sqlcipher3VdbeAddOp3(v, OP_VerifyCookie,
80982                             iDb, pParse->cookieValue[iDb],
80983                             db->aDb[iDb].pSchema->iGeneration);
80984         }
80985       }
80986 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
80987       {
80988         int i;
80989         for(i=0; i<pParse->nVtabLock; i++){
80990           char *vtab = (char *)sqlcipher3GetVTable(db, pParse->apVtabLock[i]);
80991           sqlcipher3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
80992         }
80993         pParse->nVtabLock = 0;
80994       }
80995 #endif
80996
80997       /* Once all the cookies have been verified and transactions opened, 
80998       ** obtain the required table-locks. This is a no-op unless the 
80999       ** shared-cache feature is enabled.
81000       */
81001       codeTableLocks(pParse);
81002
81003       /* Initialize any AUTOINCREMENT data structures required.
81004       */
81005       sqlcipher3AutoincrementBegin(pParse);
81006
81007       /* Finally, jump back to the beginning of the executable code. */
81008       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
81009     }
81010   }
81011
81012
81013   /* Get the VDBE program ready for execution
81014   */
81015   if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){
81016 #ifdef SQLCIPHER_DEBUG
81017     FILE *trace = (db->flags & SQLCIPHER_VdbeTrace)!=0 ? stdout : 0;
81018     sqlcipher3VdbeTrace(v, trace);
81019 #endif
81020     assert( pParse->iCacheLevel==0 );  /* Disables and re-enables match */
81021     /* A minimum of one cursor is required if autoincrement is used
81022     *  See ticket [a696379c1f08866] */
81023     if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
81024     sqlcipher3VdbeMakeReady(v, pParse);
81025     pParse->rc = SQLCIPHER_DONE;
81026     pParse->colNamesSet = 0;
81027   }else{
81028     pParse->rc = SQLCIPHER_ERROR;
81029   }
81030   pParse->nTab = 0;
81031   pParse->nMem = 0;
81032   pParse->nSet = 0;
81033   pParse->nVar = 0;
81034   pParse->cookieMask = 0;
81035   pParse->cookieGoto = 0;
81036 }
81037
81038 /*
81039 ** Run the parser and code generator recursively in order to generate
81040 ** code for the SQL statement given onto the end of the pParse context
81041 ** currently under construction.  When the parser is run recursively
81042 ** this way, the final OP_Halt is not appended and other initialization
81043 ** and finalization steps are omitted because those are handling by the
81044 ** outermost parser.
81045 **
81046 ** Not everything is nestable.  This facility is designed to permit
81047 ** INSERT, UPDATE, and DELETE operations against SQLCIPHER_MASTER.  Use
81048 ** care if you decide to try to use this routine for some other purposes.
81049 */
81050 SQLCIPHER_PRIVATE void sqlcipher3NestedParse(Parse *pParse, const char *zFormat, ...){
81051   va_list ap;
81052   char *zSql;
81053   char *zErrMsg = 0;
81054   sqlcipher3 *db = pParse->db;
81055 # define SAVE_SZ  (sizeof(Parse) - offsetof(Parse,nVar))
81056   char saveBuf[SAVE_SZ];
81057
81058   if( pParse->nErr ) return;
81059   assert( pParse->nested<10 );  /* Nesting should only be of limited depth */
81060   va_start(ap, zFormat);
81061   zSql = sqlcipher3VMPrintf(db, zFormat, ap);
81062   va_end(ap);
81063   if( zSql==0 ){
81064     return;   /* A malloc must have failed */
81065   }
81066   pParse->nested++;
81067   memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
81068   memset(&pParse->nVar, 0, SAVE_SZ);
81069   sqlcipher3RunParser(pParse, zSql, &zErrMsg);
81070   sqlcipher3DbFree(db, zErrMsg);
81071   sqlcipher3DbFree(db, zSql);
81072   memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
81073   pParse->nested--;
81074 }
81075
81076 /*
81077 ** Locate the in-memory structure that describes a particular database
81078 ** table given the name of that table and (optionally) the name of the
81079 ** database containing the table.  Return NULL if not found.
81080 **
81081 ** If zDatabase is 0, all databases are searched for the table and the
81082 ** first matching table is returned.  (No checking for duplicate table
81083 ** names is done.)  The search order is TEMP first, then MAIN, then any
81084 ** auxiliary databases added using the ATTACH command.
81085 **
81086 ** See also sqlcipher3LocateTable().
81087 */
81088 SQLCIPHER_PRIVATE Table *sqlcipher3FindTable(sqlcipher3 *db, const char *zName, const char *zDatabase){
81089   Table *p = 0;
81090   int i;
81091   int nName;
81092   assert( zName!=0 );
81093   nName = sqlcipher3Strlen30(zName);
81094   /* All mutexes are required for schema access.  Make sure we hold them. */
81095   assert( zDatabase!=0 || sqlcipher3BtreeHoldsAllMutexes(db) );
81096   for(i=OMIT_TEMPDB; i<db->nDb; i++){
81097     int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
81098     if( zDatabase!=0 && sqlcipher3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
81099     assert( sqlcipher3SchemaMutexHeld(db, j, 0) );
81100     p = sqlcipher3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);
81101     if( p ) break;
81102   }
81103   return p;
81104 }
81105
81106 /*
81107 ** Locate the in-memory structure that describes a particular database
81108 ** table given the name of that table and (optionally) the name of the
81109 ** database containing the table.  Return NULL if not found.  Also leave an
81110 ** error message in pParse->zErrMsg.
81111 **
81112 ** The difference between this routine and sqlcipher3FindTable() is that this
81113 ** routine leaves an error message in pParse->zErrMsg where
81114 ** sqlcipher3FindTable() does not.
81115 */
81116 SQLCIPHER_PRIVATE Table *sqlcipher3LocateTable(
81117   Parse *pParse,         /* context in which to report errors */
81118   int isView,            /* True if looking for a VIEW rather than a TABLE */
81119   const char *zName,     /* Name of the table we are looking for */
81120   const char *zDbase     /* Name of the database.  Might be NULL */
81121 ){
81122   Table *p;
81123
81124   /* Read the database schema. If an error occurs, leave an error message
81125   ** and code in pParse and return NULL. */
81126   if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
81127     return 0;
81128   }
81129
81130   p = sqlcipher3FindTable(pParse->db, zName, zDbase);
81131   if( p==0 ){
81132     const char *zMsg = isView ? "no such view" : "no such table";
81133     if( zDbase ){
81134       sqlcipher3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
81135     }else{
81136       sqlcipher3ErrorMsg(pParse, "%s: %s", zMsg, zName);
81137     }
81138     pParse->checkSchema = 1;
81139   }
81140   return p;
81141 }
81142
81143 /*
81144 ** Locate the in-memory structure that describes 
81145 ** a particular index given the name of that index
81146 ** and the name of the database that contains the index.
81147 ** Return NULL if not found.
81148 **
81149 ** If zDatabase is 0, all databases are searched for the
81150 ** table and the first matching index is returned.  (No checking
81151 ** for duplicate index names is done.)  The search order is
81152 ** TEMP first, then MAIN, then any auxiliary databases added
81153 ** using the ATTACH command.
81154 */
81155 SQLCIPHER_PRIVATE Index *sqlcipher3FindIndex(sqlcipher3 *db, const char *zName, const char *zDb){
81156   Index *p = 0;
81157   int i;
81158   int nName = sqlcipher3Strlen30(zName);
81159   /* All mutexes are required for schema access.  Make sure we hold them. */
81160   assert( zDb!=0 || sqlcipher3BtreeHoldsAllMutexes(db) );
81161   for(i=OMIT_TEMPDB; i<db->nDb; i++){
81162     int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
81163     Schema *pSchema = db->aDb[j].pSchema;
81164     assert( pSchema );
81165     if( zDb && sqlcipher3StrICmp(zDb, db->aDb[j].zName) ) continue;
81166     assert( sqlcipher3SchemaMutexHeld(db, j, 0) );
81167     p = sqlcipher3HashFind(&pSchema->idxHash, zName, nName);
81168     if( p ) break;
81169   }
81170   return p;
81171 }
81172
81173 /*
81174 ** Reclaim the memory used by an index
81175 */
81176 static void freeIndex(sqlcipher3 *db, Index *p){
81177 #ifndef SQLCIPHER_OMIT_ANALYZE
81178   sqlcipher3DeleteIndexSamples(db, p);
81179 #endif
81180   sqlcipher3DbFree(db, p->zColAff);
81181   sqlcipher3DbFree(db, p);
81182 }
81183
81184 /*
81185 ** For the index called zIdxName which is found in the database iDb,
81186 ** unlike that index from its Table then remove the index from
81187 ** the index hash table and free all memory structures associated
81188 ** with the index.
81189 */
81190 SQLCIPHER_PRIVATE void sqlcipher3UnlinkAndDeleteIndex(sqlcipher3 *db, int iDb, const char *zIdxName){
81191   Index *pIndex;
81192   int len;
81193   Hash *pHash;
81194
81195   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
81196   pHash = &db->aDb[iDb].pSchema->idxHash;
81197   len = sqlcipher3Strlen30(zIdxName);
81198   pIndex = sqlcipher3HashInsert(pHash, zIdxName, len, 0);
81199   if( ALWAYS(pIndex) ){
81200     if( pIndex->pTable->pIndex==pIndex ){
81201       pIndex->pTable->pIndex = pIndex->pNext;
81202     }else{
81203       Index *p;
81204       /* Justification of ALWAYS();  The index must be on the list of
81205       ** indices. */
81206       p = pIndex->pTable->pIndex;
81207       while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
81208       if( ALWAYS(p && p->pNext==pIndex) ){
81209         p->pNext = pIndex->pNext;
81210       }
81211     }
81212     freeIndex(db, pIndex);
81213   }
81214   db->flags |= SQLCIPHER_InternChanges;
81215 }
81216
81217 /*
81218 ** Erase all schema information from the in-memory hash tables of
81219 ** a single database.  This routine is called to reclaim memory
81220 ** before the database closes.  It is also called during a rollback
81221 ** if there were schema changes during the transaction or if a
81222 ** schema-cookie mismatch occurs.
81223 **
81224 ** If iDb<0 then reset the internal schema tables for all database
81225 ** files.  If iDb>=0 then reset the internal schema for only the
81226 ** single file indicated.
81227 */
81228 SQLCIPHER_PRIVATE void sqlcipher3ResetInternalSchema(sqlcipher3 *db, int iDb){
81229   int i, j;
81230   assert( iDb<db->nDb );
81231
81232   if( iDb>=0 ){
81233     /* Case 1:  Reset the single schema identified by iDb */
81234     Db *pDb = &db->aDb[iDb];
81235     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
81236     assert( pDb->pSchema!=0 );
81237     sqlcipher3SchemaClear(pDb->pSchema);
81238
81239     /* If any database other than TEMP is reset, then also reset TEMP
81240     ** since TEMP might be holding triggers that reference tables in the
81241     ** other database.
81242     */
81243     if( iDb!=1 ){
81244       pDb = &db->aDb[1];
81245       assert( pDb->pSchema!=0 );
81246       sqlcipher3SchemaClear(pDb->pSchema);
81247     }
81248     return;
81249   }
81250   /* Case 2 (from here to the end): Reset all schemas for all attached
81251   ** databases. */
81252   assert( iDb<0 );
81253   sqlcipher3BtreeEnterAll(db);
81254   for(i=0; i<db->nDb; i++){
81255     Db *pDb = &db->aDb[i];
81256     if( pDb->pSchema ){
81257       sqlcipher3SchemaClear(pDb->pSchema);
81258     }
81259   }
81260   db->flags &= ~SQLCIPHER_InternChanges;
81261   sqlcipher3VtabUnlockList(db);
81262   sqlcipher3BtreeLeaveAll(db);
81263
81264   /* If one or more of the auxiliary database files has been closed,
81265   ** then remove them from the auxiliary database list.  We take the
81266   ** opportunity to do this here since we have just deleted all of the
81267   ** schema hash tables and therefore do not have to make any changes
81268   ** to any of those tables.
81269   */
81270   for(i=j=2; i<db->nDb; i++){
81271     struct Db *pDb = &db->aDb[i];
81272     if( pDb->pBt==0 ){
81273       sqlcipher3DbFree(db, pDb->zName);
81274       pDb->zName = 0;
81275       continue;
81276     }
81277     if( j<i ){
81278       db->aDb[j] = db->aDb[i];
81279     }
81280     j++;
81281   }
81282   memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
81283   db->nDb = j;
81284   if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
81285     memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
81286     sqlcipher3DbFree(db, db->aDb);
81287     db->aDb = db->aDbStatic;
81288   }
81289 }
81290
81291 /*
81292 ** This routine is called when a commit occurs.
81293 */
81294 SQLCIPHER_PRIVATE void sqlcipher3CommitInternalChanges(sqlcipher3 *db){
81295   db->flags &= ~SQLCIPHER_InternChanges;
81296 }
81297
81298 /*
81299 ** Delete memory allocated for the column names of a table or view (the
81300 ** Table.aCol[] array).
81301 */
81302 static void sqlcipherDeleteColumnNames(sqlcipher3 *db, Table *pTable){
81303   int i;
81304   Column *pCol;
81305   assert( pTable!=0 );
81306   if( (pCol = pTable->aCol)!=0 ){
81307     for(i=0; i<pTable->nCol; i++, pCol++){
81308       sqlcipher3DbFree(db, pCol->zName);
81309       sqlcipher3ExprDelete(db, pCol->pDflt);
81310       sqlcipher3DbFree(db, pCol->zDflt);
81311       sqlcipher3DbFree(db, pCol->zType);
81312       sqlcipher3DbFree(db, pCol->zColl);
81313     }
81314     sqlcipher3DbFree(db, pTable->aCol);
81315   }
81316 }
81317
81318 /*
81319 ** Remove the memory data structures associated with the given
81320 ** Table.  No changes are made to disk by this routine.
81321 **
81322 ** This routine just deletes the data structure.  It does not unlink
81323 ** the table data structure from the hash table.  But it does destroy
81324 ** memory structures of the indices and foreign keys associated with 
81325 ** the table.
81326 */
81327 SQLCIPHER_PRIVATE void sqlcipher3DeleteTable(sqlcipher3 *db, Table *pTable){
81328   Index *pIndex, *pNext;
81329
81330   assert( !pTable || pTable->nRef>0 );
81331
81332   /* Do not delete the table until the reference count reaches zero. */
81333   if( !pTable ) return;
81334   if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return;
81335
81336   /* Delete all indices associated with this table. */
81337   for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
81338     pNext = pIndex->pNext;
81339     assert( pIndex->pSchema==pTable->pSchema );
81340     if( !db || db->pnBytesFreed==0 ){
81341       char *zName = pIndex->zName; 
81342       TESTONLY ( Index *pOld = ) sqlcipher3HashInsert(
81343           &pIndex->pSchema->idxHash, zName, sqlcipher3Strlen30(zName), 0
81344       );
81345       assert( db==0 || sqlcipher3SchemaMutexHeld(db, 0, pIndex->pSchema) );
81346       assert( pOld==pIndex || pOld==0 );
81347     }
81348     freeIndex(db, pIndex);
81349   }
81350
81351   /* Delete any foreign keys attached to this table. */
81352   sqlcipher3FkDelete(db, pTable);
81353
81354   /* Delete the Table structure itself.
81355   */
81356   sqlcipherDeleteColumnNames(db, pTable);
81357   sqlcipher3DbFree(db, pTable->zName);
81358   sqlcipher3DbFree(db, pTable->zColAff);
81359   sqlcipher3SelectDelete(db, pTable->pSelect);
81360 #ifndef SQLCIPHER_OMIT_CHECK
81361   sqlcipher3ExprDelete(db, pTable->pCheck);
81362 #endif
81363 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
81364   sqlcipher3VtabClear(db, pTable);
81365 #endif
81366   sqlcipher3DbFree(db, pTable);
81367 }
81368
81369 /*
81370 ** Unlink the given table from the hash tables and the delete the
81371 ** table structure with all its indices and foreign keys.
81372 */
81373 SQLCIPHER_PRIVATE void sqlcipher3UnlinkAndDeleteTable(sqlcipher3 *db, int iDb, const char *zTabName){
81374   Table *p;
81375   Db *pDb;
81376
81377   assert( db!=0 );
81378   assert( iDb>=0 && iDb<db->nDb );
81379   assert( zTabName );
81380   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
81381   testcase( zTabName[0]==0 );  /* Zero-length table names are allowed */
81382   pDb = &db->aDb[iDb];
81383   p = sqlcipher3HashInsert(&pDb->pSchema->tblHash, zTabName,
81384                         sqlcipher3Strlen30(zTabName),0);
81385   sqlcipher3DeleteTable(db, p);
81386   db->flags |= SQLCIPHER_InternChanges;
81387 }
81388
81389 /*
81390 ** Given a token, return a string that consists of the text of that
81391 ** token.  Space to hold the returned string
81392 ** is obtained from sqlcipherMalloc() and must be freed by the calling
81393 ** function.
81394 **
81395 ** Any quotation marks (ex:  "name", 'name', [name], or `name`) that
81396 ** surround the body of the token are removed.
81397 **
81398 ** Tokens are often just pointers into the original SQL text and so
81399 ** are not \000 terminated and are not persistent.  The returned string
81400 ** is \000 terminated and is persistent.
81401 */
81402 SQLCIPHER_PRIVATE char *sqlcipher3NameFromToken(sqlcipher3 *db, Token *pName){
81403   char *zName;
81404   if( pName ){
81405     zName = sqlcipher3DbStrNDup(db, (char*)pName->z, pName->n);
81406     sqlcipher3Dequote(zName);
81407   }else{
81408     zName = 0;
81409   }
81410   return zName;
81411 }
81412
81413 /*
81414 ** Open the sqlcipher_master table stored in database number iDb for
81415 ** writing. The table is opened using cursor 0.
81416 */
81417 SQLCIPHER_PRIVATE void sqlcipher3OpenMasterTable(Parse *p, int iDb){
81418   Vdbe *v = sqlcipher3GetVdbe(p);
81419   sqlcipher3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
81420   sqlcipher3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
81421   sqlcipher3VdbeChangeP4(v, -1, (char *)5, P4_INT32);  /* 5 column table */
81422   if( p->nTab==0 ){
81423     p->nTab = 1;
81424   }
81425 }
81426
81427 /*
81428 ** Parameter zName points to a nul-terminated buffer containing the name
81429 ** of a database ("main", "temp" or the name of an attached db). This
81430 ** function returns the index of the named database in db->aDb[], or
81431 ** -1 if the named db cannot be found.
81432 */
81433 SQLCIPHER_PRIVATE int sqlcipher3FindDbName(sqlcipher3 *db, const char *zName){
81434   int i = -1;         /* Database number */
81435   if( zName ){
81436     Db *pDb;
81437     int n = sqlcipher3Strlen30(zName);
81438     for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
81439       if( (!OMIT_TEMPDB || i!=1 ) && n==sqlcipher3Strlen30(pDb->zName) && 
81440           0==sqlcipher3StrICmp(pDb->zName, zName) ){
81441         break;
81442       }
81443     }
81444   }
81445   return i;
81446 }
81447
81448 /*
81449 ** The token *pName contains the name of a database (either "main" or
81450 ** "temp" or the name of an attached db). This routine returns the
81451 ** index of the named database in db->aDb[], or -1 if the named db 
81452 ** does not exist.
81453 */
81454 SQLCIPHER_PRIVATE int sqlcipher3FindDb(sqlcipher3 *db, Token *pName){
81455   int i;                               /* Database number */
81456   char *zName;                         /* Name we are searching for */
81457   zName = sqlcipher3NameFromToken(db, pName);
81458   i = sqlcipher3FindDbName(db, zName);
81459   sqlcipher3DbFree(db, zName);
81460   return i;
81461 }
81462
81463 /* The table or view or trigger name is passed to this routine via tokens
81464 ** pName1 and pName2. If the table name was fully qualified, for example:
81465 **
81466 ** CREATE TABLE xxx.yyy (...);
81467 ** 
81468 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
81469 ** the table name is not fully qualified, i.e.:
81470 **
81471 ** CREATE TABLE yyy(...);
81472 **
81473 ** Then pName1 is set to "yyy" and pName2 is "".
81474 **
81475 ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
81476 ** pName2) that stores the unqualified table name.  The index of the
81477 ** database "xxx" is returned.
81478 */
81479 SQLCIPHER_PRIVATE int sqlcipher3TwoPartName(
81480   Parse *pParse,      /* Parsing and code generating context */
81481   Token *pName1,      /* The "xxx" in the name "xxx.yyy" or "xxx" */
81482   Token *pName2,      /* The "yyy" in the name "xxx.yyy" */
81483   Token **pUnqual     /* Write the unqualified object name here */
81484 ){
81485   int iDb;                    /* Database holding the object */
81486   sqlcipher3 *db = pParse->db;
81487
81488   if( ALWAYS(pName2!=0) && pName2->n>0 ){
81489     if( db->init.busy ) {
81490       sqlcipher3ErrorMsg(pParse, "corrupt database");
81491       pParse->nErr++;
81492       return -1;
81493     }
81494     *pUnqual = pName2;
81495     iDb = sqlcipher3FindDb(db, pName1);
81496     if( iDb<0 ){
81497       sqlcipher3ErrorMsg(pParse, "unknown database %T", pName1);
81498       pParse->nErr++;
81499       return -1;
81500     }
81501   }else{
81502     assert( db->init.iDb==0 || db->init.busy );
81503     iDb = db->init.iDb;
81504     *pUnqual = pName1;
81505   }
81506   return iDb;
81507 }
81508
81509 /*
81510 ** This routine is used to check if the UTF-8 string zName is a legal
81511 ** unqualified name for a new schema object (table, index, view or
81512 ** trigger). All names are legal except those that begin with the string
81513 ** "sqlcipher_" (in upper, lower or mixed case). This portion of the namespace
81514 ** is reserved for internal use.
81515 */
81516 SQLCIPHER_PRIVATE int sqlcipher3CheckObjectName(Parse *pParse, const char *zName){
81517   if( !pParse->db->init.busy && pParse->nested==0 
81518           && (pParse->db->flags & SQLCIPHER_WriteSchema)==0
81519           && 0==sqlcipher3StrNICmp(zName, "sqlcipher_", 7) ){
81520     sqlcipher3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
81521     return SQLCIPHER_ERROR;
81522   }
81523   return SQLCIPHER_OK;
81524 }
81525
81526 /*
81527 ** Begin constructing a new table representation in memory.  This is
81528 ** the first of several action routines that get called in response
81529 ** to a CREATE TABLE statement.  In particular, this routine is called
81530 ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
81531 ** flag is true if the table should be stored in the auxiliary database
81532 ** file instead of in the main database file.  This is normally the case
81533 ** when the "TEMP" or "TEMPORARY" keyword occurs in between
81534 ** CREATE and TABLE.
81535 **
81536 ** The new table record is initialized and put in pParse->pNewTable.
81537 ** As more of the CREATE TABLE statement is parsed, additional action
81538 ** routines will be called to add more information to this record.
81539 ** At the end of the CREATE TABLE statement, the sqlcipher3EndTable() routine
81540 ** is called to complete the construction of the new table record.
81541 */
81542 SQLCIPHER_PRIVATE void sqlcipher3StartTable(
81543   Parse *pParse,   /* Parser context */
81544   Token *pName1,   /* First part of the name of the table or view */
81545   Token *pName2,   /* Second part of the name of the table or view */
81546   int isTemp,      /* True if this is a TEMP table */
81547   int isView,      /* True if this is a VIEW */
81548   int isVirtual,   /* True if this is a VIRTUAL table */
81549   int noErr        /* Do nothing if table already exists */
81550 ){
81551   Table *pTable;
81552   char *zName = 0; /* The name of the new table */
81553   sqlcipher3 *db = pParse->db;
81554   Vdbe *v;
81555   int iDb;         /* Database number to create the table in */
81556   Token *pName;    /* Unqualified name of the table to create */
81557
81558   /* The table or view name to create is passed to this routine via tokens
81559   ** pName1 and pName2. If the table name was fully qualified, for example:
81560   **
81561   ** CREATE TABLE xxx.yyy (...);
81562   ** 
81563   ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
81564   ** the table name is not fully qualified, i.e.:
81565   **
81566   ** CREATE TABLE yyy(...);
81567   **
81568   ** Then pName1 is set to "yyy" and pName2 is "".
81569   **
81570   ** The call below sets the pName pointer to point at the token (pName1 or
81571   ** pName2) that stores the unqualified table name. The variable iDb is
81572   ** set to the index of the database that the table or view is to be
81573   ** created in.
81574   */
81575   iDb = sqlcipher3TwoPartName(pParse, pName1, pName2, &pName);
81576   if( iDb<0 ) return;
81577   if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
81578     /* If creating a temp table, the name may not be qualified. Unless 
81579     ** the database name is "temp" anyway.  */
81580     sqlcipher3ErrorMsg(pParse, "temporary table name must be unqualified");
81581     return;
81582   }
81583   if( !OMIT_TEMPDB && isTemp ) iDb = 1;
81584
81585   pParse->sNameToken = *pName;
81586   zName = sqlcipher3NameFromToken(db, pName);
81587   if( zName==0 ) return;
81588   if( SQLCIPHER_OK!=sqlcipher3CheckObjectName(pParse, zName) ){
81589     goto begin_table_error;
81590   }
81591   if( db->init.iDb==1 ) isTemp = 1;
81592 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
81593   assert( (isTemp & 1)==isTemp );
81594   {
81595     int code;
81596     char *zDb = db->aDb[iDb].zName;
81597     if( sqlcipher3AuthCheck(pParse, SQLCIPHER_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
81598       goto begin_table_error;
81599     }
81600     if( isView ){
81601       if( !OMIT_TEMPDB && isTemp ){
81602         code = SQLCIPHER_CREATE_TEMP_VIEW;
81603       }else{
81604         code = SQLCIPHER_CREATE_VIEW;
81605       }
81606     }else{
81607       if( !OMIT_TEMPDB && isTemp ){
81608         code = SQLCIPHER_CREATE_TEMP_TABLE;
81609       }else{
81610         code = SQLCIPHER_CREATE_TABLE;
81611       }
81612     }
81613     if( !isVirtual && sqlcipher3AuthCheck(pParse, code, zName, 0, zDb) ){
81614       goto begin_table_error;
81615     }
81616   }
81617 #endif
81618
81619   /* Make sure the new table name does not collide with an existing
81620   ** index or table name in the same database.  Issue an error message if
81621   ** it does. The exception is if the statement being parsed was passed
81622   ** to an sqlcipher3_declare_vtab() call. In that case only the column names
81623   ** and types will be used, so there is no need to test for namespace
81624   ** collisions.
81625   */
81626   if( !IN_DECLARE_VTAB ){
81627     char *zDb = db->aDb[iDb].zName;
81628     if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
81629       goto begin_table_error;
81630     }
81631     pTable = sqlcipher3FindTable(db, zName, zDb);
81632     if( pTable ){
81633       if( !noErr ){
81634         sqlcipher3ErrorMsg(pParse, "table %T already exists", pName);
81635       }else{
81636         assert( !db->init.busy );
81637         sqlcipher3CodeVerifySchema(pParse, iDb);
81638       }
81639       goto begin_table_error;
81640     }
81641     if( sqlcipher3FindIndex(db, zName, zDb)!=0 ){
81642       sqlcipher3ErrorMsg(pParse, "there is already an index named %s", zName);
81643       goto begin_table_error;
81644     }
81645   }
81646
81647   pTable = sqlcipher3DbMallocZero(db, sizeof(Table));
81648   if( pTable==0 ){
81649     db->mallocFailed = 1;
81650     pParse->rc = SQLCIPHER_NOMEM;
81651     pParse->nErr++;
81652     goto begin_table_error;
81653   }
81654   pTable->zName = zName;
81655   pTable->iPKey = -1;
81656   pTable->pSchema = db->aDb[iDb].pSchema;
81657   pTable->nRef = 1;
81658   pTable->nRowEst = 1000000;
81659   assert( pParse->pNewTable==0 );
81660   pParse->pNewTable = pTable;
81661
81662   /* If this is the magic sqlcipher_sequence table used by autoincrement,
81663   ** then record a pointer to this table in the main database structure
81664   ** so that INSERT can find the table easily.
81665   */
81666 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
81667   if( !pParse->nested && strcmp(zName, "sqlcipher_sequence")==0 ){
81668     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
81669     pTable->pSchema->pSeqTab = pTable;
81670   }
81671 #endif
81672
81673   /* Begin generating the code that will insert the table record into
81674   ** the SQLCIPHER_MASTER table.  Note in particular that we must go ahead
81675   ** and allocate the record number for the table entry now.  Before any
81676   ** PRIMARY KEY or UNIQUE keywords are parsed.  Those keywords will cause
81677   ** indices to be created and the table record must come before the 
81678   ** indices.  Hence, the record number for the table must be allocated
81679   ** now.
81680   */
81681   if( !db->init.busy && (v = sqlcipher3GetVdbe(pParse))!=0 ){
81682     int j1;
81683     int fileFormat;
81684     int reg1, reg2, reg3;
81685     sqlcipher3BeginWriteOperation(pParse, 0, iDb);
81686
81687 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
81688     if( isVirtual ){
81689       sqlcipher3VdbeAddOp0(v, OP_VBegin);
81690     }
81691 #endif
81692
81693     /* If the file format and encoding in the database have not been set, 
81694     ** set them now.
81695     */
81696     reg1 = pParse->regRowid = ++pParse->nMem;
81697     reg2 = pParse->regRoot = ++pParse->nMem;
81698     reg3 = ++pParse->nMem;
81699     sqlcipher3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
81700     sqlcipher3VdbeUsesBtree(v, iDb);
81701     j1 = sqlcipher3VdbeAddOp1(v, OP_If, reg3);
81702     fileFormat = (db->flags & SQLCIPHER_LegacyFileFmt)!=0 ?
81703                   1 : SQLCIPHER_MAX_FILE_FORMAT;
81704     sqlcipher3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);
81705     sqlcipher3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3);
81706     sqlcipher3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
81707     sqlcipher3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3);
81708     sqlcipher3VdbeJumpHere(v, j1);
81709
81710     /* This just creates a place-holder record in the sqlcipher_master table.
81711     ** The record created does not contain anything yet.  It will be replaced
81712     ** by the real entry in code generated at sqlcipher3EndTable().
81713     **
81714     ** The rowid for the new entry is left in register pParse->regRowid.
81715     ** The root page number of the new table is left in reg pParse->regRoot.
81716     ** The rowid and root page number values are needed by the code that
81717     ** sqlcipher3EndTable will generate.
81718     */
81719 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_VIRTUALTABLE)
81720     if( isView || isVirtual ){
81721       sqlcipher3VdbeAddOp2(v, OP_Integer, 0, reg2);
81722     }else
81723 #endif
81724     {
81725       sqlcipher3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
81726     }
81727     sqlcipher3OpenMasterTable(pParse, iDb);
81728     sqlcipher3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
81729     sqlcipher3VdbeAddOp2(v, OP_Null, 0, reg3);
81730     sqlcipher3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
81731     sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
81732     sqlcipher3VdbeAddOp0(v, OP_Close);
81733   }
81734
81735   /* Normal (non-error) return. */
81736   return;
81737
81738   /* If an error occurs, we jump here */
81739 begin_table_error:
81740   sqlcipher3DbFree(db, zName);
81741   return;
81742 }
81743
81744 /*
81745 ** This macro is used to compare two strings in a case-insensitive manner.
81746 ** It is slightly faster than calling sqlcipher3StrICmp() directly, but
81747 ** produces larger code.
81748 **
81749 ** WARNING: This macro is not compatible with the strcmp() family. It
81750 ** returns true if the two strings are equal, otherwise false.
81751 */
81752 #define STRICMP(x, y) (\
81753 sqlcipher3UpperToLower[*(unsigned char *)(x)]==   \
81754 sqlcipher3UpperToLower[*(unsigned char *)(y)]     \
81755 && sqlcipher3StrICmp((x)+1,(y)+1)==0 )
81756
81757 /*
81758 ** Add a new column to the table currently being constructed.
81759 **
81760 ** The parser calls this routine once for each column declaration
81761 ** in a CREATE TABLE statement.  sqlcipher3StartTable() gets called
81762 ** first to get things going.  Then this routine is called for each
81763 ** column.
81764 */
81765 SQLCIPHER_PRIVATE void sqlcipher3AddColumn(Parse *pParse, Token *pName){
81766   Table *p;
81767   int i;
81768   char *z;
81769   Column *pCol;
81770   sqlcipher3 *db = pParse->db;
81771   if( (p = pParse->pNewTable)==0 ) return;
81772 #if SQLCIPHER_MAX_COLUMN
81773   if( p->nCol+1>db->aLimit[SQLCIPHER_LIMIT_COLUMN] ){
81774     sqlcipher3ErrorMsg(pParse, "too many columns on %s", p->zName);
81775     return;
81776   }
81777 #endif
81778   z = sqlcipher3NameFromToken(db, pName);
81779   if( z==0 ) return;
81780   for(i=0; i<p->nCol; i++){
81781     if( STRICMP(z, p->aCol[i].zName) ){
81782       sqlcipher3ErrorMsg(pParse, "duplicate column name: %s", z);
81783       sqlcipher3DbFree(db, z);
81784       return;
81785     }
81786   }
81787   if( (p->nCol & 0x7)==0 ){
81788     Column *aNew;
81789     aNew = sqlcipher3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
81790     if( aNew==0 ){
81791       sqlcipher3DbFree(db, z);
81792       return;
81793     }
81794     p->aCol = aNew;
81795   }
81796   pCol = &p->aCol[p->nCol];
81797   memset(pCol, 0, sizeof(p->aCol[0]));
81798   pCol->zName = z;
81799  
81800   /* If there is no type specified, columns have the default affinity
81801   ** 'NONE'. If there is a type specified, then sqlcipher3AddColumnType() will
81802   ** be called next to set pCol->affinity correctly.
81803   */
81804   pCol->affinity = SQLCIPHER_AFF_NONE;
81805   p->nCol++;
81806 }
81807
81808 /*
81809 ** This routine is called by the parser while in the middle of
81810 ** parsing a CREATE TABLE statement.  A "NOT NULL" constraint has
81811 ** been seen on a column.  This routine sets the notNull flag on
81812 ** the column currently under construction.
81813 */
81814 SQLCIPHER_PRIVATE void sqlcipher3AddNotNull(Parse *pParse, int onError){
81815   Table *p;
81816   p = pParse->pNewTable;
81817   if( p==0 || NEVER(p->nCol<1) ) return;
81818   p->aCol[p->nCol-1].notNull = (u8)onError;
81819 }
81820
81821 /*
81822 ** Scan the column type name zType (length nType) and return the
81823 ** associated affinity type.
81824 **
81825 ** This routine does a case-independent search of zType for the 
81826 ** substrings in the following table. If one of the substrings is
81827 ** found, the corresponding affinity is returned. If zType contains
81828 ** more than one of the substrings, entries toward the top of 
81829 ** the table take priority. For example, if zType is 'BLOBINT', 
81830 ** SQLCIPHER_AFF_INTEGER is returned.
81831 **
81832 ** Substring     | Affinity
81833 ** --------------------------------
81834 ** 'INT'         | SQLCIPHER_AFF_INTEGER
81835 ** 'CHAR'        | SQLCIPHER_AFF_TEXT
81836 ** 'CLOB'        | SQLCIPHER_AFF_TEXT
81837 ** 'TEXT'        | SQLCIPHER_AFF_TEXT
81838 ** 'BLOB'        | SQLCIPHER_AFF_NONE
81839 ** 'REAL'        | SQLCIPHER_AFF_REAL
81840 ** 'FLOA'        | SQLCIPHER_AFF_REAL
81841 ** 'DOUB'        | SQLCIPHER_AFF_REAL
81842 **
81843 ** If none of the substrings in the above table are found,
81844 ** SQLCIPHER_AFF_NUMERIC is returned.
81845 */
81846 SQLCIPHER_PRIVATE char sqlcipher3AffinityType(const char *zIn){
81847   u32 h = 0;
81848   char aff = SQLCIPHER_AFF_NUMERIC;
81849
81850   if( zIn ) while( zIn[0] ){
81851     h = (h<<8) + sqlcipher3UpperToLower[(*zIn)&0xff];
81852     zIn++;
81853     if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){             /* CHAR */
81854       aff = SQLCIPHER_AFF_TEXT; 
81855     }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){       /* CLOB */
81856       aff = SQLCIPHER_AFF_TEXT;
81857     }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){       /* TEXT */
81858       aff = SQLCIPHER_AFF_TEXT;
81859     }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b')          /* BLOB */
81860         && (aff==SQLCIPHER_AFF_NUMERIC || aff==SQLCIPHER_AFF_REAL) ){
81861       aff = SQLCIPHER_AFF_NONE;
81862 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
81863     }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l')          /* REAL */
81864         && aff==SQLCIPHER_AFF_NUMERIC ){
81865       aff = SQLCIPHER_AFF_REAL;
81866     }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a')          /* FLOA */
81867         && aff==SQLCIPHER_AFF_NUMERIC ){
81868       aff = SQLCIPHER_AFF_REAL;
81869     }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b')          /* DOUB */
81870         && aff==SQLCIPHER_AFF_NUMERIC ){
81871       aff = SQLCIPHER_AFF_REAL;
81872 #endif
81873     }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){    /* INT */
81874       aff = SQLCIPHER_AFF_INTEGER;
81875       break;
81876     }
81877   }
81878
81879   return aff;
81880 }
81881
81882 /*
81883 ** This routine is called by the parser while in the middle of
81884 ** parsing a CREATE TABLE statement.  The pFirst token is the first
81885 ** token in the sequence of tokens that describe the type of the
81886 ** column currently under construction.   pLast is the last token
81887 ** in the sequence.  Use this information to construct a string
81888 ** that contains the typename of the column and store that string
81889 ** in zType.
81890 */ 
81891 SQLCIPHER_PRIVATE void sqlcipher3AddColumnType(Parse *pParse, Token *pType){
81892   Table *p;
81893   Column *pCol;
81894
81895   p = pParse->pNewTable;
81896   if( p==0 || NEVER(p->nCol<1) ) return;
81897   pCol = &p->aCol[p->nCol-1];
81898   assert( pCol->zType==0 );
81899   pCol->zType = sqlcipher3NameFromToken(pParse->db, pType);
81900   pCol->affinity = sqlcipher3AffinityType(pCol->zType);
81901 }
81902
81903 /*
81904 ** The expression is the default value for the most recently added column
81905 ** of the table currently under construction.
81906 **
81907 ** Default value expressions must be constant.  Raise an exception if this
81908 ** is not the case.
81909 **
81910 ** This routine is called by the parser while in the middle of
81911 ** parsing a CREATE TABLE statement.
81912 */
81913 SQLCIPHER_PRIVATE void sqlcipher3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
81914   Table *p;
81915   Column *pCol;
81916   sqlcipher3 *db = pParse->db;
81917   p = pParse->pNewTable;
81918   if( p!=0 ){
81919     pCol = &(p->aCol[p->nCol-1]);
81920     if( !sqlcipher3ExprIsConstantOrFunction(pSpan->pExpr) ){
81921       sqlcipher3ErrorMsg(pParse, "default value of column [%s] is not constant",
81922           pCol->zName);
81923     }else{
81924       /* A copy of pExpr is used instead of the original, as pExpr contains
81925       ** tokens that point to volatile memory. The 'span' of the expression
81926       ** is required by pragma table_info.
81927       */
81928       sqlcipher3ExprDelete(db, pCol->pDflt);
81929       pCol->pDflt = sqlcipher3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
81930       sqlcipher3DbFree(db, pCol->zDflt);
81931       pCol->zDflt = sqlcipher3DbStrNDup(db, (char*)pSpan->zStart,
81932                                      (int)(pSpan->zEnd - pSpan->zStart));
81933     }
81934   }
81935   sqlcipher3ExprDelete(db, pSpan->pExpr);
81936 }
81937
81938 /*
81939 ** Designate the PRIMARY KEY for the table.  pList is a list of names 
81940 ** of columns that form the primary key.  If pList is NULL, then the
81941 ** most recently added column of the table is the primary key.
81942 **
81943 ** A table can have at most one primary key.  If the table already has
81944 ** a primary key (and this is the second primary key) then create an
81945 ** error.
81946 **
81947 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
81948 ** then we will try to use that column as the rowid.  Set the Table.iPKey
81949 ** field of the table under construction to be the index of the
81950 ** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is
81951 ** no INTEGER PRIMARY KEY.
81952 **
81953 ** If the key is not an INTEGER PRIMARY KEY, then create a unique
81954 ** index for the key.  No index is created for INTEGER PRIMARY KEYs.
81955 */
81956 SQLCIPHER_PRIVATE void sqlcipher3AddPrimaryKey(
81957   Parse *pParse,    /* Parsing context */
81958   ExprList *pList,  /* List of field names to be indexed */
81959   int onError,      /* What to do with a uniqueness conflict */
81960   int autoInc,      /* True if the AUTOINCREMENT keyword is present */
81961   int sortOrder     /* SQLCIPHER_SO_ASC or SQLCIPHER_SO_DESC */
81962 ){
81963   Table *pTab = pParse->pNewTable;
81964   char *zType = 0;
81965   int iCol = -1, i;
81966   if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
81967   if( pTab->tabFlags & TF_HasPrimaryKey ){
81968     sqlcipher3ErrorMsg(pParse, 
81969       "table \"%s\" has more than one primary key", pTab->zName);
81970     goto primary_key_exit;
81971   }
81972   pTab->tabFlags |= TF_HasPrimaryKey;
81973   if( pList==0 ){
81974     iCol = pTab->nCol - 1;
81975     pTab->aCol[iCol].isPrimKey = 1;
81976   }else{
81977     for(i=0; i<pList->nExpr; i++){
81978       for(iCol=0; iCol<pTab->nCol; iCol++){
81979         if( sqlcipher3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
81980           break;
81981         }
81982       }
81983       if( iCol<pTab->nCol ){
81984         pTab->aCol[iCol].isPrimKey = 1;
81985       }
81986     }
81987     if( pList->nExpr>1 ) iCol = -1;
81988   }
81989   if( iCol>=0 && iCol<pTab->nCol ){
81990     zType = pTab->aCol[iCol].zType;
81991   }
81992   if( zType && sqlcipher3StrICmp(zType, "INTEGER")==0
81993         && sortOrder==SQLCIPHER_SO_ASC ){
81994     pTab->iPKey = iCol;
81995     pTab->keyConf = (u8)onError;
81996     assert( autoInc==0 || autoInc==1 );
81997     pTab->tabFlags |= autoInc*TF_Autoincrement;
81998   }else if( autoInc ){
81999 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
82000     sqlcipher3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
82001        "INTEGER PRIMARY KEY");
82002 #endif
82003   }else{
82004     Index *p;
82005     p = sqlcipher3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);
82006     if( p ){
82007       p->autoIndex = 2;
82008     }
82009     pList = 0;
82010   }
82011
82012 primary_key_exit:
82013   sqlcipher3ExprListDelete(pParse->db, pList);
82014   return;
82015 }
82016
82017 /*
82018 ** Add a new CHECK constraint to the table currently under construction.
82019 */
82020 SQLCIPHER_PRIVATE void sqlcipher3AddCheckConstraint(
82021   Parse *pParse,    /* Parsing context */
82022   Expr *pCheckExpr  /* The check expression */
82023 ){
82024   sqlcipher3 *db = pParse->db;
82025 #ifndef SQLCIPHER_OMIT_CHECK
82026   Table *pTab = pParse->pNewTable;
82027   if( pTab && !IN_DECLARE_VTAB ){
82028     pTab->pCheck = sqlcipher3ExprAnd(db, pTab->pCheck, pCheckExpr);
82029   }else
82030 #endif
82031   {
82032     sqlcipher3ExprDelete(db, pCheckExpr);
82033   }
82034 }
82035
82036 /*
82037 ** Set the collation function of the most recently parsed table column
82038 ** to the CollSeq given.
82039 */
82040 SQLCIPHER_PRIVATE void sqlcipher3AddCollateType(Parse *pParse, Token *pToken){
82041   Table *p;
82042   int i;
82043   char *zColl;              /* Dequoted name of collation sequence */
82044   sqlcipher3 *db;
82045
82046   if( (p = pParse->pNewTable)==0 ) return;
82047   i = p->nCol-1;
82048   db = pParse->db;
82049   zColl = sqlcipher3NameFromToken(db, pToken);
82050   if( !zColl ) return;
82051
82052   if( sqlcipher3LocateCollSeq(pParse, zColl) ){
82053     Index *pIdx;
82054     p->aCol[i].zColl = zColl;
82055   
82056     /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
82057     ** then an index may have been created on this column before the
82058     ** collation type was added. Correct this if it is the case.
82059     */
82060     for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
82061       assert( pIdx->nColumn==1 );
82062       if( pIdx->aiColumn[0]==i ){
82063         pIdx->azColl[0] = p->aCol[i].zColl;
82064       }
82065     }
82066   }else{
82067     sqlcipher3DbFree(db, zColl);
82068   }
82069 }
82070
82071 /*
82072 ** This function returns the collation sequence for database native text
82073 ** encoding identified by the string zName, length nName.
82074 **
82075 ** If the requested collation sequence is not available, or not available
82076 ** in the database native encoding, the collation factory is invoked to
82077 ** request it. If the collation factory does not supply such a sequence,
82078 ** and the sequence is available in another text encoding, then that is
82079 ** returned instead.
82080 **
82081 ** If no versions of the requested collations sequence are available, or
82082 ** another error occurs, NULL is returned and an error message written into
82083 ** pParse.
82084 **
82085 ** This routine is a wrapper around sqlcipher3FindCollSeq().  This routine
82086 ** invokes the collation factory if the named collation cannot be found
82087 ** and generates an error message.
82088 **
82089 ** See also: sqlcipher3FindCollSeq(), sqlcipher3GetCollSeq()
82090 */
82091 SQLCIPHER_PRIVATE CollSeq *sqlcipher3LocateCollSeq(Parse *pParse, const char *zName){
82092   sqlcipher3 *db = pParse->db;
82093   u8 enc = ENC(db);
82094   u8 initbusy = db->init.busy;
82095   CollSeq *pColl;
82096
82097   pColl = sqlcipher3FindCollSeq(db, enc, zName, initbusy);
82098   if( !initbusy && (!pColl || !pColl->xCmp) ){
82099     pColl = sqlcipher3GetCollSeq(db, enc, pColl, zName);
82100     if( !pColl ){
82101       sqlcipher3ErrorMsg(pParse, "no such collation sequence: %s", zName);
82102     }
82103   }
82104
82105   return pColl;
82106 }
82107
82108
82109 /*
82110 ** Generate code that will increment the schema cookie.
82111 **
82112 ** The schema cookie is used to determine when the schema for the
82113 ** database changes.  After each schema change, the cookie value
82114 ** changes.  When a process first reads the schema it records the
82115 ** cookie.  Thereafter, whenever it goes to access the database,
82116 ** it checks the cookie to make sure the schema has not changed
82117 ** since it was last read.
82118 **
82119 ** This plan is not completely bullet-proof.  It is possible for
82120 ** the schema to change multiple times and for the cookie to be
82121 ** set back to prior value.  But schema changes are infrequent
82122 ** and the probability of hitting the same cookie value is only
82123 ** 1 chance in 2^32.  So we're safe enough.
82124 */
82125 SQLCIPHER_PRIVATE void sqlcipher3ChangeCookie(Parse *pParse, int iDb){
82126   int r1 = sqlcipher3GetTempReg(pParse);
82127   sqlcipher3 *db = pParse->db;
82128   Vdbe *v = pParse->pVdbe;
82129   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
82130   sqlcipher3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
82131   sqlcipher3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, r1);
82132   sqlcipher3ReleaseTempReg(pParse, r1);
82133 }
82134
82135 /*
82136 ** Measure the number of characters needed to output the given
82137 ** identifier.  The number returned includes any quotes used
82138 ** but does not include the null terminator.
82139 **
82140 ** The estimate is conservative.  It might be larger that what is
82141 ** really needed.
82142 */
82143 static int identLength(const char *z){
82144   int n;
82145   for(n=0; *z; n++, z++){
82146     if( *z=='"' ){ n++; }
82147   }
82148   return n + 2;
82149 }
82150
82151 /*
82152 ** The first parameter is a pointer to an output buffer. The second 
82153 ** parameter is a pointer to an integer that contains the offset at
82154 ** which to write into the output buffer. This function copies the
82155 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
82156 ** to the specified offset in the buffer and updates *pIdx to refer
82157 ** to the first byte after the last byte written before returning.
82158 ** 
82159 ** If the string zSignedIdent consists entirely of alpha-numeric
82160 ** characters, does not begin with a digit and is not an SQL keyword,
82161 ** then it is copied to the output buffer exactly as it is. Otherwise,
82162 ** it is quoted using double-quotes.
82163 */
82164 static void identPut(char *z, int *pIdx, char *zSignedIdent){
82165   unsigned char *zIdent = (unsigned char*)zSignedIdent;
82166   int i, j, needQuote;
82167   i = *pIdx;
82168
82169   for(j=0; zIdent[j]; j++){
82170     if( !sqlcipher3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
82171   }
82172   needQuote = sqlcipher3Isdigit(zIdent[0]) || sqlcipher3KeywordCode(zIdent, j)!=TK_ID;
82173   if( !needQuote ){
82174     needQuote = zIdent[j];
82175   }
82176
82177   if( needQuote ) z[i++] = '"';
82178   for(j=0; zIdent[j]; j++){
82179     z[i++] = zIdent[j];
82180     if( zIdent[j]=='"' ) z[i++] = '"';
82181   }
82182   if( needQuote ) z[i++] = '"';
82183   z[i] = 0;
82184   *pIdx = i;
82185 }
82186
82187 /*
82188 ** Generate a CREATE TABLE statement appropriate for the given
82189 ** table.  Memory to hold the text of the statement is obtained
82190 ** from sqlcipherMalloc() and must be freed by the calling function.
82191 */
82192 static char *createTableStmt(sqlcipher3 *db, Table *p){
82193   int i, k, n;
82194   char *zStmt;
82195   char *zSep, *zSep2, *zEnd;
82196   Column *pCol;
82197   n = 0;
82198   for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
82199     n += identLength(pCol->zName) + 5;
82200   }
82201   n += identLength(p->zName);
82202   if( n<50 ){ 
82203     zSep = "";
82204     zSep2 = ",";
82205     zEnd = ")";
82206   }else{
82207     zSep = "\n  ";
82208     zSep2 = ",\n  ";
82209     zEnd = "\n)";
82210   }
82211   n += 35 + 6*p->nCol;
82212   zStmt = sqlcipher3DbMallocRaw(0, n);
82213   if( zStmt==0 ){
82214     db->mallocFailed = 1;
82215     return 0;
82216   }
82217   sqlcipher3_snprintf(n, zStmt, "CREATE TABLE ");
82218   k = sqlcipher3Strlen30(zStmt);
82219   identPut(zStmt, &k, p->zName);
82220   zStmt[k++] = '(';
82221   for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
82222     static const char * const azType[] = {
82223         /* SQLCIPHER_AFF_TEXT    */ " TEXT",
82224         /* SQLCIPHER_AFF_NONE    */ "",
82225         /* SQLCIPHER_AFF_NUMERIC */ " NUM",
82226         /* SQLCIPHER_AFF_INTEGER */ " INT",
82227         /* SQLCIPHER_AFF_REAL    */ " REAL"
82228     };
82229     int len;
82230     const char *zType;
82231
82232     sqlcipher3_snprintf(n-k, &zStmt[k], zSep);
82233     k += sqlcipher3Strlen30(&zStmt[k]);
82234     zSep = zSep2;
82235     identPut(zStmt, &k, pCol->zName);
82236     assert( pCol->affinity-SQLCIPHER_AFF_TEXT >= 0 );
82237     assert( pCol->affinity-SQLCIPHER_AFF_TEXT < ArraySize(azType) );
82238     testcase( pCol->affinity==SQLCIPHER_AFF_TEXT );
82239     testcase( pCol->affinity==SQLCIPHER_AFF_NONE );
82240     testcase( pCol->affinity==SQLCIPHER_AFF_NUMERIC );
82241     testcase( pCol->affinity==SQLCIPHER_AFF_INTEGER );
82242     testcase( pCol->affinity==SQLCIPHER_AFF_REAL );
82243     
82244     zType = azType[pCol->affinity - SQLCIPHER_AFF_TEXT];
82245     len = sqlcipher3Strlen30(zType);
82246     assert( pCol->affinity==SQLCIPHER_AFF_NONE 
82247             || pCol->affinity==sqlcipher3AffinityType(zType) );
82248     memcpy(&zStmt[k], zType, len);
82249     k += len;
82250     assert( k<=n );
82251   }
82252   sqlcipher3_snprintf(n-k, &zStmt[k], "%s", zEnd);
82253   return zStmt;
82254 }
82255
82256 /*
82257 ** This routine is called to report the final ")" that terminates
82258 ** a CREATE TABLE statement.
82259 **
82260 ** The table structure that other action routines have been building
82261 ** is added to the internal hash tables, assuming no errors have
82262 ** occurred.
82263 **
82264 ** An entry for the table is made in the master table on disk, unless
82265 ** this is a temporary table or db->init.busy==1.  When db->init.busy==1
82266 ** it means we are reading the sqlcipher_master table because we just
82267 ** connected to the database or because the sqlcipher_master table has
82268 ** recently changed, so the entry for this table already exists in
82269 ** the sqlcipher_master table.  We do not want to create it again.
82270 **
82271 ** If the pSelect argument is not NULL, it means that this routine
82272 ** was called to create a table generated from a 
82273 ** "CREATE TABLE ... AS SELECT ..." statement.  The column names of
82274 ** the new table will match the result set of the SELECT.
82275 */
82276 SQLCIPHER_PRIVATE void sqlcipher3EndTable(
82277   Parse *pParse,          /* Parse context */
82278   Token *pCons,           /* The ',' token after the last column defn. */
82279   Token *pEnd,            /* The final ')' token in the CREATE TABLE */
82280   Select *pSelect         /* Select from a "CREATE ... AS SELECT" */
82281 ){
82282   Table *p;
82283   sqlcipher3 *db = pParse->db;
82284   int iDb;
82285
82286   if( (pEnd==0 && pSelect==0) || db->mallocFailed ){
82287     return;
82288   }
82289   p = pParse->pNewTable;
82290   if( p==0 ) return;
82291
82292   assert( !db->init.busy || !pSelect );
82293
82294   iDb = sqlcipher3SchemaToIndex(db, p->pSchema);
82295
82296 #ifndef SQLCIPHER_OMIT_CHECK
82297   /* Resolve names in all CHECK constraint expressions.
82298   */
82299   if( p->pCheck ){
82300     SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
82301     NameContext sNC;                /* Name context for pParse->pNewTable */
82302
82303     memset(&sNC, 0, sizeof(sNC));
82304     memset(&sSrc, 0, sizeof(sSrc));
82305     sSrc.nSrc = 1;
82306     sSrc.a[0].zName = p->zName;
82307     sSrc.a[0].pTab = p;
82308     sSrc.a[0].iCursor = -1;
82309     sNC.pParse = pParse;
82310     sNC.pSrcList = &sSrc;
82311     sNC.isCheck = 1;
82312     if( sqlcipher3ResolveExprNames(&sNC, p->pCheck) ){
82313       return;
82314     }
82315   }
82316 #endif /* !defined(SQLCIPHER_OMIT_CHECK) */
82317
82318   /* If the db->init.busy is 1 it means we are reading the SQL off the
82319   ** "sqlcipher_master" or "sqlcipher_temp_master" table on the disk.
82320   ** So do not write to the disk again.  Extract the root page number
82321   ** for the table from the db->init.newTnum field.  (The page number
82322   ** should have been put there by the sqlcipherOpenCb routine.)
82323   */
82324   if( db->init.busy ){
82325     p->tnum = db->init.newTnum;
82326   }
82327
82328   /* If not initializing, then create a record for the new table
82329   ** in the SQLCIPHER_MASTER table of the database.
82330   **
82331   ** If this is a TEMPORARY table, write the entry into the auxiliary
82332   ** file instead of into the main database file.
82333   */
82334   if( !db->init.busy ){
82335     int n;
82336     Vdbe *v;
82337     char *zType;    /* "view" or "table" */
82338     char *zType2;   /* "VIEW" or "TABLE" */
82339     char *zStmt;    /* Text of the CREATE TABLE or CREATE VIEW statement */
82340
82341     v = sqlcipher3GetVdbe(pParse);
82342     if( NEVER(v==0) ) return;
82343
82344     sqlcipher3VdbeAddOp1(v, OP_Close, 0);
82345
82346     /* 
82347     ** Initialize zType for the new view or table.
82348     */
82349     if( p->pSelect==0 ){
82350       /* A regular table */
82351       zType = "table";
82352       zType2 = "TABLE";
82353 #ifndef SQLCIPHER_OMIT_VIEW
82354     }else{
82355       /* A view */
82356       zType = "view";
82357       zType2 = "VIEW";
82358 #endif
82359     }
82360
82361     /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
82362     ** statement to populate the new table. The root-page number for the
82363     ** new table is in register pParse->regRoot.
82364     **
82365     ** Once the SELECT has been coded by sqlcipher3Select(), it is in a
82366     ** suitable state to query for the column names and types to be used
82367     ** by the new table.
82368     **
82369     ** A shared-cache write-lock is not required to write to the new table,
82370     ** as a schema-lock must have already been obtained to create it. Since
82371     ** a schema-lock excludes all other database users, the write-lock would
82372     ** be redundant.
82373     */
82374     if( pSelect ){
82375       SelectDest dest;
82376       Table *pSelTab;
82377
82378       assert(pParse->nTab==1);
82379       sqlcipher3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
82380       sqlcipher3VdbeChangeP5(v, 1);
82381       pParse->nTab = 2;
82382       sqlcipher3SelectDestInit(&dest, SRT_Table, 1);
82383       sqlcipher3Select(pParse, pSelect, &dest);
82384       sqlcipher3VdbeAddOp1(v, OP_Close, 1);
82385       if( pParse->nErr==0 ){
82386         pSelTab = sqlcipher3ResultSetOfSelect(pParse, pSelect);
82387         if( pSelTab==0 ) return;
82388         assert( p->aCol==0 );
82389         p->nCol = pSelTab->nCol;
82390         p->aCol = pSelTab->aCol;
82391         pSelTab->nCol = 0;
82392         pSelTab->aCol = 0;
82393         sqlcipher3DeleteTable(db, pSelTab);
82394       }
82395     }
82396
82397     /* Compute the complete text of the CREATE statement */
82398     if( pSelect ){
82399       zStmt = createTableStmt(db, p);
82400     }else{
82401       n = (int)(pEnd->z - pParse->sNameToken.z) + 1;
82402       zStmt = sqlcipher3MPrintf(db, 
82403           "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
82404       );
82405     }
82406
82407     /* A slot for the record has already been allocated in the 
82408     ** SQLCIPHER_MASTER table.  We just need to update that slot with all
82409     ** the information we've collected.
82410     */
82411     sqlcipher3NestedParse(pParse,
82412       "UPDATE %Q.%s "
82413          "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
82414        "WHERE rowid=#%d",
82415       db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
82416       zType,
82417       p->zName,
82418       p->zName,
82419       pParse->regRoot,
82420       zStmt,
82421       pParse->regRowid
82422     );
82423     sqlcipher3DbFree(db, zStmt);
82424     sqlcipher3ChangeCookie(pParse, iDb);
82425
82426 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
82427     /* Check to see if we need to create an sqlcipher_sequence table for
82428     ** keeping track of autoincrement keys.
82429     */
82430     if( p->tabFlags & TF_Autoincrement ){
82431       Db *pDb = &db->aDb[iDb];
82432       assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
82433       if( pDb->pSchema->pSeqTab==0 ){
82434         sqlcipher3NestedParse(pParse,
82435           "CREATE TABLE %Q.sqlcipher_sequence(name,seq)",
82436           pDb->zName
82437         );
82438       }
82439     }
82440 #endif
82441
82442     /* Reparse everything to update our internal data structures */
82443     sqlcipher3VdbeAddParseSchemaOp(v, iDb,
82444                sqlcipher3MPrintf(db, "tbl_name='%q'", p->zName));
82445   }
82446
82447
82448   /* Add the table to the in-memory representation of the database.
82449   */
82450   if( db->init.busy ){
82451     Table *pOld;
82452     Schema *pSchema = p->pSchema;
82453     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
82454     pOld = sqlcipher3HashInsert(&pSchema->tblHash, p->zName,
82455                              sqlcipher3Strlen30(p->zName),p);
82456     if( pOld ){
82457       assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
82458       db->mallocFailed = 1;
82459       return;
82460     }
82461     pParse->pNewTable = 0;
82462     db->nTable++;
82463     db->flags |= SQLCIPHER_InternChanges;
82464
82465 #ifndef SQLCIPHER_OMIT_ALTERTABLE
82466     if( !p->pSelect ){
82467       const char *zName = (const char *)pParse->sNameToken.z;
82468       int nName;
82469       assert( !pSelect && pCons && pEnd );
82470       if( pCons->z==0 ){
82471         pCons = pEnd;
82472       }
82473       nName = (int)((const char *)pCons->z - zName);
82474       p->addColOffset = 13 + sqlcipher3Utf8CharLen(zName, nName);
82475     }
82476 #endif
82477   }
82478 }
82479
82480 #ifndef SQLCIPHER_OMIT_VIEW
82481 /*
82482 ** The parser calls this routine in order to create a new VIEW
82483 */
82484 SQLCIPHER_PRIVATE void sqlcipher3CreateView(
82485   Parse *pParse,     /* The parsing context */
82486   Token *pBegin,     /* The CREATE token that begins the statement */
82487   Token *pName1,     /* The token that holds the name of the view */
82488   Token *pName2,     /* The token that holds the name of the view */
82489   Select *pSelect,   /* A SELECT statement that will become the new view */
82490   int isTemp,        /* TRUE for a TEMPORARY view */
82491   int noErr          /* Suppress error messages if VIEW already exists */
82492 ){
82493   Table *p;
82494   int n;
82495   const char *z;
82496   Token sEnd;
82497   DbFixer sFix;
82498   Token *pName = 0;
82499   int iDb;
82500   sqlcipher3 *db = pParse->db;
82501
82502   if( pParse->nVar>0 ){
82503     sqlcipher3ErrorMsg(pParse, "parameters are not allowed in views");
82504     sqlcipher3SelectDelete(db, pSelect);
82505     return;
82506   }
82507   sqlcipher3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
82508   p = pParse->pNewTable;
82509   if( p==0 || pParse->nErr ){
82510     sqlcipher3SelectDelete(db, pSelect);
82511     return;
82512   }
82513   sqlcipher3TwoPartName(pParse, pName1, pName2, &pName);
82514   iDb = sqlcipher3SchemaToIndex(db, p->pSchema);
82515   if( sqlcipher3FixInit(&sFix, pParse, iDb, "view", pName)
82516     && sqlcipher3FixSelect(&sFix, pSelect)
82517   ){
82518     sqlcipher3SelectDelete(db, pSelect);
82519     return;
82520   }
82521
82522   /* Make a copy of the entire SELECT statement that defines the view.
82523   ** This will force all the Expr.token.z values to be dynamically
82524   ** allocated rather than point to the input string - which means that
82525   ** they will persist after the current sqlcipher3_exec() call returns.
82526   */
82527   p->pSelect = sqlcipher3SelectDup(db, pSelect, EXPRDUP_REDUCE);
82528   sqlcipher3SelectDelete(db, pSelect);
82529   if( db->mallocFailed ){
82530     return;
82531   }
82532   if( !db->init.busy ){
82533     sqlcipher3ViewGetColumnNames(pParse, p);
82534   }
82535
82536   /* Locate the end of the CREATE VIEW statement.  Make sEnd point to
82537   ** the end.
82538   */
82539   sEnd = pParse->sLastToken;
82540   if( ALWAYS(sEnd.z[0]!=0) && sEnd.z[0]!=';' ){
82541     sEnd.z += sEnd.n;
82542   }
82543   sEnd.n = 0;
82544   n = (int)(sEnd.z - pBegin->z);
82545   z = pBegin->z;
82546   while( ALWAYS(n>0) && sqlcipher3Isspace(z[n-1]) ){ n--; }
82547   sEnd.z = &z[n-1];
82548   sEnd.n = 1;
82549
82550   /* Use sqlcipher3EndTable() to add the view to the SQLCIPHER_MASTER table */
82551   sqlcipher3EndTable(pParse, 0, &sEnd, 0);
82552   return;
82553 }
82554 #endif /* SQLCIPHER_OMIT_VIEW */
82555
82556 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_VIRTUALTABLE)
82557 /*
82558 ** The Table structure pTable is really a VIEW.  Fill in the names of
82559 ** the columns of the view in the pTable structure.  Return the number
82560 ** of errors.  If an error is seen leave an error message in pParse->zErrMsg.
82561 */
82562 SQLCIPHER_PRIVATE int sqlcipher3ViewGetColumnNames(Parse *pParse, Table *pTable){
82563   Table *pSelTab;   /* A fake table from which we get the result set */
82564   Select *pSel;     /* Copy of the SELECT that implements the view */
82565   int nErr = 0;     /* Number of errors encountered */
82566   int n;            /* Temporarily holds the number of cursors assigned */
82567   sqlcipher3 *db = pParse->db;  /* Database connection for malloc errors */
82568   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
82569
82570   assert( pTable );
82571
82572 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
82573   if( sqlcipher3VtabCallConnect(pParse, pTable) ){
82574     return SQLCIPHER_ERROR;
82575   }
82576   if( IsVirtual(pTable) ) return 0;
82577 #endif
82578
82579 #ifndef SQLCIPHER_OMIT_VIEW
82580   /* A positive nCol means the columns names for this view are
82581   ** already known.
82582   */
82583   if( pTable->nCol>0 ) return 0;
82584
82585   /* A negative nCol is a special marker meaning that we are currently
82586   ** trying to compute the column names.  If we enter this routine with
82587   ** a negative nCol, it means two or more views form a loop, like this:
82588   **
82589   **     CREATE VIEW one AS SELECT * FROM two;
82590   **     CREATE VIEW two AS SELECT * FROM one;
82591   **
82592   ** Actually, the error above is now caught prior to reaching this point.
82593   ** But the following test is still important as it does come up
82594   ** in the following:
82595   ** 
82596   **     CREATE TABLE main.ex1(a);
82597   **     CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
82598   **     SELECT * FROM temp.ex1;
82599   */
82600   if( pTable->nCol<0 ){
82601     sqlcipher3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
82602     return 1;
82603   }
82604   assert( pTable->nCol>=0 );
82605
82606   /* If we get this far, it means we need to compute the table names.
82607   ** Note that the call to sqlcipher3ResultSetOfSelect() will expand any
82608   ** "*" elements in the results set of the view and will assign cursors
82609   ** to the elements of the FROM clause.  But we do not want these changes
82610   ** to be permanent.  So the computation is done on a copy of the SELECT
82611   ** statement that defines the view.
82612   */
82613   assert( pTable->pSelect );
82614   pSel = sqlcipher3SelectDup(db, pTable->pSelect, 0);
82615   if( pSel ){
82616     u8 enableLookaside = db->lookaside.bEnabled;
82617     n = pParse->nTab;
82618     sqlcipher3SrcListAssignCursors(pParse, pSel->pSrc);
82619     pTable->nCol = -1;
82620     db->lookaside.bEnabled = 0;
82621 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
82622     xAuth = db->xAuth;
82623     db->xAuth = 0;
82624     pSelTab = sqlcipher3ResultSetOfSelect(pParse, pSel);
82625     db->xAuth = xAuth;
82626 #else
82627     pSelTab = sqlcipher3ResultSetOfSelect(pParse, pSel);
82628 #endif
82629     db->lookaside.bEnabled = enableLookaside;
82630     pParse->nTab = n;
82631     if( pSelTab ){
82632       assert( pTable->aCol==0 );
82633       pTable->nCol = pSelTab->nCol;
82634       pTable->aCol = pSelTab->aCol;
82635       pSelTab->nCol = 0;
82636       pSelTab->aCol = 0;
82637       sqlcipher3DeleteTable(db, pSelTab);
82638       assert( sqlcipher3SchemaMutexHeld(db, 0, pTable->pSchema) );
82639       pTable->pSchema->flags |= DB_UnresetViews;
82640     }else{
82641       pTable->nCol = 0;
82642       nErr++;
82643     }
82644     sqlcipher3SelectDelete(db, pSel);
82645   } else {
82646     nErr++;
82647   }
82648 #endif /* SQLCIPHER_OMIT_VIEW */
82649   return nErr;  
82650 }
82651 #endif /* !defined(SQLCIPHER_OMIT_VIEW) || !defined(SQLCIPHER_OMIT_VIRTUALTABLE) */
82652
82653 #ifndef SQLCIPHER_OMIT_VIEW
82654 /*
82655 ** Clear the column names from every VIEW in database idx.
82656 */
82657 static void sqlcipherViewResetAll(sqlcipher3 *db, int idx){
82658   HashElem *i;
82659   assert( sqlcipher3SchemaMutexHeld(db, idx, 0) );
82660   if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
82661   for(i=sqlcipherHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqlcipherHashNext(i)){
82662     Table *pTab = sqlcipherHashData(i);
82663     if( pTab->pSelect ){
82664       sqlcipherDeleteColumnNames(db, pTab);
82665       pTab->aCol = 0;
82666       pTab->nCol = 0;
82667     }
82668   }
82669   DbClearProperty(db, idx, DB_UnresetViews);
82670 }
82671 #else
82672 # define sqlcipherViewResetAll(A,B)
82673 #endif /* SQLCIPHER_OMIT_VIEW */
82674
82675 /*
82676 ** This function is called by the VDBE to adjust the internal schema
82677 ** used by SQLite when the btree layer moves a table root page. The
82678 ** root-page of a table or index in database iDb has changed from iFrom
82679 ** to iTo.
82680 **
82681 ** Ticket #1728:  The symbol table might still contain information
82682 ** on tables and/or indices that are the process of being deleted.
82683 ** If you are unlucky, one of those deleted indices or tables might
82684 ** have the same rootpage number as the real table or index that is
82685 ** being moved.  So we cannot stop searching after the first match 
82686 ** because the first match might be for one of the deleted indices
82687 ** or tables and not the table/index that is actually being moved.
82688 ** We must continue looping until all tables and indices with
82689 ** rootpage==iFrom have been converted to have a rootpage of iTo
82690 ** in order to be certain that we got the right one.
82691 */
82692 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
82693 SQLCIPHER_PRIVATE void sqlcipher3RootPageMoved(sqlcipher3 *db, int iDb, int iFrom, int iTo){
82694   HashElem *pElem;
82695   Hash *pHash;
82696   Db *pDb;
82697
82698   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
82699   pDb = &db->aDb[iDb];
82700   pHash = &pDb->pSchema->tblHash;
82701   for(pElem=sqlcipherHashFirst(pHash); pElem; pElem=sqlcipherHashNext(pElem)){
82702     Table *pTab = sqlcipherHashData(pElem);
82703     if( pTab->tnum==iFrom ){
82704       pTab->tnum = iTo;
82705     }
82706   }
82707   pHash = &pDb->pSchema->idxHash;
82708   for(pElem=sqlcipherHashFirst(pHash); pElem; pElem=sqlcipherHashNext(pElem)){
82709     Index *pIdx = sqlcipherHashData(pElem);
82710     if( pIdx->tnum==iFrom ){
82711       pIdx->tnum = iTo;
82712     }
82713   }
82714 }
82715 #endif
82716
82717 /*
82718 ** Write code to erase the table with root-page iTable from database iDb.
82719 ** Also write code to modify the sqlcipher_master table and internal schema
82720 ** if a root-page of another table is moved by the btree-layer whilst
82721 ** erasing iTable (this can happen with an auto-vacuum database).
82722 */ 
82723 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
82724   Vdbe *v = sqlcipher3GetVdbe(pParse);
82725   int r1 = sqlcipher3GetTempReg(pParse);
82726   sqlcipher3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
82727   sqlcipher3MayAbort(pParse);
82728 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
82729   /* OP_Destroy stores an in integer r1. If this integer
82730   ** is non-zero, then it is the root page number of a table moved to
82731   ** location iTable. The following code modifies the sqlcipher_master table to
82732   ** reflect this.
82733   **
82734   ** The "#NNN" in the SQL is a special constant that means whatever value
82735   ** is in register NNN.  See grammar rules associated with the TK_REGISTER
82736   ** token for additional information.
82737   */
82738   sqlcipher3NestedParse(pParse, 
82739      "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
82740      pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
82741 #endif
82742   sqlcipher3ReleaseTempReg(pParse, r1);
82743 }
82744
82745 /*
82746 ** Write VDBE code to erase table pTab and all associated indices on disk.
82747 ** Code to update the sqlcipher_master tables and internal schema definitions
82748 ** in case a root-page belonging to another table is moved by the btree layer
82749 ** is also added (this can happen with an auto-vacuum database).
82750 */
82751 static void destroyTable(Parse *pParse, Table *pTab){
82752 #ifdef SQLCIPHER_OMIT_AUTOVACUUM
82753   Index *pIdx;
82754   int iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
82755   destroyRootPage(pParse, pTab->tnum, iDb);
82756   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
82757     destroyRootPage(pParse, pIdx->tnum, iDb);
82758   }
82759 #else
82760   /* If the database may be auto-vacuum capable (if SQLCIPHER_OMIT_AUTOVACUUM
82761   ** is not defined), then it is important to call OP_Destroy on the
82762   ** table and index root-pages in order, starting with the numerically 
82763   ** largest root-page number. This guarantees that none of the root-pages
82764   ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
82765   ** following were coded:
82766   **
82767   ** OP_Destroy 4 0
82768   ** ...
82769   ** OP_Destroy 5 0
82770   **
82771   ** and root page 5 happened to be the largest root-page number in the
82772   ** database, then root page 5 would be moved to page 4 by the 
82773   ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
82774   ** a free-list page.
82775   */
82776   int iTab = pTab->tnum;
82777   int iDestroyed = 0;
82778
82779   while( 1 ){
82780     Index *pIdx;
82781     int iLargest = 0;
82782
82783     if( iDestroyed==0 || iTab<iDestroyed ){
82784       iLargest = iTab;
82785     }
82786     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
82787       int iIdx = pIdx->tnum;
82788       assert( pIdx->pSchema==pTab->pSchema );
82789       if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
82790         iLargest = iIdx;
82791       }
82792     }
82793     if( iLargest==0 ){
82794       return;
82795     }else{
82796       int iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
82797       destroyRootPage(pParse, iLargest, iDb);
82798       iDestroyed = iLargest;
82799     }
82800   }
82801 #endif
82802 }
82803
82804 /*
82805 ** Remove entries from the sqlcipher_statN tables (for N in (1,2,3))
82806 ** after a DROP INDEX or DROP TABLE command.
82807 */
82808 static void sqlcipher3ClearStatTables(
82809   Parse *pParse,         /* The parsing context */
82810   int iDb,               /* The database number */
82811   const char *zType,     /* "idx" or "tbl" */
82812   const char *zName      /* Name of index or table */
82813 ){
82814   int i;
82815   const char *zDbName = pParse->db->aDb[iDb].zName;
82816   for(i=1; i<=3; i++){
82817     char zTab[24];
82818     sqlcipher3_snprintf(sizeof(zTab),zTab,"sqlcipher_stat%d",i);
82819     if( sqlcipher3FindTable(pParse->db, zTab, zDbName) ){
82820       sqlcipher3NestedParse(pParse,
82821         "DELETE FROM %Q.%s WHERE %s=%Q",
82822         zDbName, zTab, zType, zName
82823       );
82824     }
82825   }
82826 }
82827
82828 /*
82829 ** Generate code to drop a table.
82830 */
82831 SQLCIPHER_PRIVATE void sqlcipher3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
82832   Vdbe *v;
82833   sqlcipher3 *db = pParse->db;
82834   Trigger *pTrigger;
82835   Db *pDb = &db->aDb[iDb];
82836
82837   v = sqlcipher3GetVdbe(pParse);
82838   assert( v!=0 );
82839   sqlcipher3BeginWriteOperation(pParse, 1, iDb);
82840
82841 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
82842   if( IsVirtual(pTab) ){
82843     sqlcipher3VdbeAddOp0(v, OP_VBegin);
82844   }
82845 #endif
82846
82847   /* Drop all triggers associated with the table being dropped. Code
82848   ** is generated to remove entries from sqlcipher_master and/or
82849   ** sqlcipher_temp_master if required.
82850   */
82851   pTrigger = sqlcipher3TriggerList(pParse, pTab);
82852   while( pTrigger ){
82853     assert( pTrigger->pSchema==pTab->pSchema || 
82854         pTrigger->pSchema==db->aDb[1].pSchema );
82855     sqlcipher3DropTriggerPtr(pParse, pTrigger);
82856     pTrigger = pTrigger->pNext;
82857   }
82858
82859 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
82860   /* Remove any entries of the sqlcipher_sequence table associated with
82861   ** the table being dropped. This is done before the table is dropped
82862   ** at the btree level, in case the sqlcipher_sequence table needs to
82863   ** move as a result of the drop (can happen in auto-vacuum mode).
82864   */
82865   if( pTab->tabFlags & TF_Autoincrement ){
82866     sqlcipher3NestedParse(pParse,
82867       "DELETE FROM %Q.sqlcipher_sequence WHERE name=%Q",
82868       pDb->zName, pTab->zName
82869     );
82870   }
82871 #endif
82872
82873   /* Drop all SQLCIPHER_MASTER table and index entries that refer to the
82874   ** table. The program name loops through the master table and deletes
82875   ** every row that refers to a table of the same name as the one being
82876   ** dropped. Triggers are handled seperately because a trigger can be
82877   ** created in the temp database that refers to a table in another
82878   ** database.
82879   */
82880   sqlcipher3NestedParse(pParse, 
82881       "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
82882       pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
82883   if( !isView && !IsVirtual(pTab) ){
82884     destroyTable(pParse, pTab);
82885   }
82886
82887   /* Remove the table entry from SQLite's internal schema and modify
82888   ** the schema cookie.
82889   */
82890   if( IsVirtual(pTab) ){
82891     sqlcipher3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
82892   }
82893   sqlcipher3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
82894   sqlcipher3ChangeCookie(pParse, iDb);
82895   sqlcipherViewResetAll(db, iDb);
82896 }
82897
82898 /*
82899 ** This routine is called to do the work of a DROP TABLE statement.
82900 ** pName is the name of the table to be dropped.
82901 */
82902 SQLCIPHER_PRIVATE void sqlcipher3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
82903   Table *pTab;
82904   Vdbe *v;
82905   sqlcipher3 *db = pParse->db;
82906   int iDb;
82907
82908   if( db->mallocFailed ){
82909     goto exit_drop_table;
82910   }
82911   assert( pParse->nErr==0 );
82912   assert( pName->nSrc==1 );
82913   if( noErr ) db->suppressErr++;
82914   pTab = sqlcipher3LocateTable(pParse, isView, 
82915                             pName->a[0].zName, pName->a[0].zDatabase);
82916   if( noErr ) db->suppressErr--;
82917
82918   if( pTab==0 ){
82919     if( noErr ) sqlcipher3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
82920     goto exit_drop_table;
82921   }
82922   iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
82923   assert( iDb>=0 && iDb<db->nDb );
82924
82925   /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
82926   ** it is initialized.
82927   */
82928   if( IsVirtual(pTab) && sqlcipher3ViewGetColumnNames(pParse, pTab) ){
82929     goto exit_drop_table;
82930   }
82931 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
82932   {
82933     int code;
82934     const char *zTab = SCHEMA_TABLE(iDb);
82935     const char *zDb = db->aDb[iDb].zName;
82936     const char *zArg2 = 0;
82937     if( sqlcipher3AuthCheck(pParse, SQLCIPHER_DELETE, zTab, 0, zDb)){
82938       goto exit_drop_table;
82939     }
82940     if( isView ){
82941       if( !OMIT_TEMPDB && iDb==1 ){
82942         code = SQLCIPHER_DROP_TEMP_VIEW;
82943       }else{
82944         code = SQLCIPHER_DROP_VIEW;
82945       }
82946 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
82947     }else if( IsVirtual(pTab) ){
82948       code = SQLCIPHER_DROP_VTABLE;
82949       zArg2 = sqlcipher3GetVTable(db, pTab)->pMod->zName;
82950 #endif
82951     }else{
82952       if( !OMIT_TEMPDB && iDb==1 ){
82953         code = SQLCIPHER_DROP_TEMP_TABLE;
82954       }else{
82955         code = SQLCIPHER_DROP_TABLE;
82956       }
82957     }
82958     if( sqlcipher3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
82959       goto exit_drop_table;
82960     }
82961     if( sqlcipher3AuthCheck(pParse, SQLCIPHER_DELETE, pTab->zName, 0, zDb) ){
82962       goto exit_drop_table;
82963     }
82964   }
82965 #endif
82966   if( sqlcipher3StrNICmp(pTab->zName, "sqlcipher_", 7)==0 
82967     && sqlcipher3StrNICmp(pTab->zName, "sqlcipher_stat", 11)!=0 ){
82968     sqlcipher3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
82969     goto exit_drop_table;
82970   }
82971
82972 #ifndef SQLCIPHER_OMIT_VIEW
82973   /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
82974   ** on a table.
82975   */
82976   if( isView && pTab->pSelect==0 ){
82977     sqlcipher3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
82978     goto exit_drop_table;
82979   }
82980   if( !isView && pTab->pSelect ){
82981     sqlcipher3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
82982     goto exit_drop_table;
82983   }
82984 #endif
82985
82986   /* Generate code to remove the table from the master table
82987   ** on disk.
82988   */
82989   v = sqlcipher3GetVdbe(pParse);
82990   if( v ){
82991     sqlcipher3BeginWriteOperation(pParse, 1, iDb);
82992     sqlcipher3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
82993     sqlcipher3FkDropTable(pParse, pName, pTab);
82994     sqlcipher3CodeDropTable(pParse, pTab, iDb, isView);
82995   }
82996
82997 exit_drop_table:
82998   sqlcipher3SrcListDelete(db, pName);
82999 }
83000
83001 /*
83002 ** This routine is called to create a new foreign key on the table
83003 ** currently under construction.  pFromCol determines which columns
83004 ** in the current table point to the foreign key.  If pFromCol==0 then
83005 ** connect the key to the last column inserted.  pTo is the name of
83006 ** the table referred to.  pToCol is a list of tables in the other
83007 ** pTo table that the foreign key points to.  flags contains all
83008 ** information about the conflict resolution algorithms specified
83009 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
83010 **
83011 ** An FKey structure is created and added to the table currently
83012 ** under construction in the pParse->pNewTable field.
83013 **
83014 ** The foreign key is set for IMMEDIATE processing.  A subsequent call
83015 ** to sqlcipher3DeferForeignKey() might change this to DEFERRED.
83016 */
83017 SQLCIPHER_PRIVATE void sqlcipher3CreateForeignKey(
83018   Parse *pParse,       /* Parsing context */
83019   ExprList *pFromCol,  /* Columns in this table that point to other table */
83020   Token *pTo,          /* Name of the other table */
83021   ExprList *pToCol,    /* Columns in the other table */
83022   int flags            /* Conflict resolution algorithms. */
83023 ){
83024   sqlcipher3 *db = pParse->db;
83025 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
83026   FKey *pFKey = 0;
83027   FKey *pNextTo;
83028   Table *p = pParse->pNewTable;
83029   int nByte;
83030   int i;
83031   int nCol;
83032   char *z;
83033
83034   assert( pTo!=0 );
83035   if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
83036   if( pFromCol==0 ){
83037     int iCol = p->nCol-1;
83038     if( NEVER(iCol<0) ) goto fk_end;
83039     if( pToCol && pToCol->nExpr!=1 ){
83040       sqlcipher3ErrorMsg(pParse, "foreign key on %s"
83041          " should reference only one column of table %T",
83042          p->aCol[iCol].zName, pTo);
83043       goto fk_end;
83044     }
83045     nCol = 1;
83046   }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
83047     sqlcipher3ErrorMsg(pParse,
83048         "number of columns in foreign key does not match the number of "
83049         "columns in the referenced table");
83050     goto fk_end;
83051   }else{
83052     nCol = pFromCol->nExpr;
83053   }
83054   nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
83055   if( pToCol ){
83056     for(i=0; i<pToCol->nExpr; i++){
83057       nByte += sqlcipher3Strlen30(pToCol->a[i].zName) + 1;
83058     }
83059   }
83060   pFKey = sqlcipher3DbMallocZero(db, nByte );
83061   if( pFKey==0 ){
83062     goto fk_end;
83063   }
83064   pFKey->pFrom = p;
83065   pFKey->pNextFrom = p->pFKey;
83066   z = (char*)&pFKey->aCol[nCol];
83067   pFKey->zTo = z;
83068   memcpy(z, pTo->z, pTo->n);
83069   z[pTo->n] = 0;
83070   sqlcipher3Dequote(z);
83071   z += pTo->n+1;
83072   pFKey->nCol = nCol;
83073   if( pFromCol==0 ){
83074     pFKey->aCol[0].iFrom = p->nCol-1;
83075   }else{
83076     for(i=0; i<nCol; i++){
83077       int j;
83078       for(j=0; j<p->nCol; j++){
83079         if( sqlcipher3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
83080           pFKey->aCol[i].iFrom = j;
83081           break;
83082         }
83083       }
83084       if( j>=p->nCol ){
83085         sqlcipher3ErrorMsg(pParse, 
83086           "unknown column \"%s\" in foreign key definition", 
83087           pFromCol->a[i].zName);
83088         goto fk_end;
83089       }
83090     }
83091   }
83092   if( pToCol ){
83093     for(i=0; i<nCol; i++){
83094       int n = sqlcipher3Strlen30(pToCol->a[i].zName);
83095       pFKey->aCol[i].zCol = z;
83096       memcpy(z, pToCol->a[i].zName, n);
83097       z[n] = 0;
83098       z += n+1;
83099     }
83100   }
83101   pFKey->isDeferred = 0;
83102   pFKey->aAction[0] = (u8)(flags & 0xff);            /* ON DELETE action */
83103   pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff);    /* ON UPDATE action */
83104
83105   assert( sqlcipher3SchemaMutexHeld(db, 0, p->pSchema) );
83106   pNextTo = (FKey *)sqlcipher3HashInsert(&p->pSchema->fkeyHash, 
83107       pFKey->zTo, sqlcipher3Strlen30(pFKey->zTo), (void *)pFKey
83108   );
83109   if( pNextTo==pFKey ){
83110     db->mallocFailed = 1;
83111     goto fk_end;
83112   }
83113   if( pNextTo ){
83114     assert( pNextTo->pPrevTo==0 );
83115     pFKey->pNextTo = pNextTo;
83116     pNextTo->pPrevTo = pFKey;
83117   }
83118
83119   /* Link the foreign key to the table as the last step.
83120   */
83121   p->pFKey = pFKey;
83122   pFKey = 0;
83123
83124 fk_end:
83125   sqlcipher3DbFree(db, pFKey);
83126 #endif /* !defined(SQLCIPHER_OMIT_FOREIGN_KEY) */
83127   sqlcipher3ExprListDelete(db, pFromCol);
83128   sqlcipher3ExprListDelete(db, pToCol);
83129 }
83130
83131 /*
83132 ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
83133 ** clause is seen as part of a foreign key definition.  The isDeferred
83134 ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
83135 ** The behavior of the most recently created foreign key is adjusted
83136 ** accordingly.
83137 */
83138 SQLCIPHER_PRIVATE void sqlcipher3DeferForeignKey(Parse *pParse, int isDeferred){
83139 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
83140   Table *pTab;
83141   FKey *pFKey;
83142   if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
83143   assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
83144   pFKey->isDeferred = (u8)isDeferred;
83145 #endif
83146 }
83147
83148 /*
83149 ** Generate code that will erase and refill index *pIdx.  This is
83150 ** used to initialize a newly created index or to recompute the
83151 ** content of an index in response to a REINDEX command.
83152 **
83153 ** if memRootPage is not negative, it means that the index is newly
83154 ** created.  The register specified by memRootPage contains the
83155 ** root page number of the index.  If memRootPage is negative, then
83156 ** the index already exists and must be cleared before being refilled and
83157 ** the root page number of the index is taken from pIndex->tnum.
83158 */
83159 static void sqlcipher3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
83160   Table *pTab = pIndex->pTable;  /* The table that is indexed */
83161   int iTab = pParse->nTab++;     /* Btree cursor used for pTab */
83162   int iIdx = pParse->nTab++;     /* Btree cursor used for pIndex */
83163   int iSorter;                   /* Cursor opened by OpenSorter (if in use) */
83164   int addr1;                     /* Address of top of loop */
83165   int addr2;                     /* Address to jump to for next iteration */
83166   int tnum;                      /* Root page of index */
83167   Vdbe *v;                       /* Generate code into this virtual machine */
83168   KeyInfo *pKey;                 /* KeyInfo for index */
83169 #ifdef SQLCIPHER_OMIT_MERGE_SORT
83170   int regIdxKey;                 /* Registers containing the index key */
83171 #endif
83172   int regRecord;                 /* Register holding assemblied index record */
83173   sqlcipher3 *db = pParse->db;      /* The database connection */
83174   int iDb = sqlcipher3SchemaToIndex(db, pIndex->pSchema);
83175
83176 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
83177   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_REINDEX, pIndex->zName, 0,
83178       db->aDb[iDb].zName ) ){
83179     return;
83180   }
83181 #endif
83182
83183   /* Require a write-lock on the table to perform this operation */
83184   sqlcipher3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
83185
83186   v = sqlcipher3GetVdbe(pParse);
83187   if( v==0 ) return;
83188   if( memRootPage>=0 ){
83189     tnum = memRootPage;
83190   }else{
83191     tnum = pIndex->tnum;
83192     sqlcipher3VdbeAddOp2(v, OP_Clear, tnum, iDb);
83193   }
83194   pKey = sqlcipher3IndexKeyinfo(pParse, pIndex);
83195   sqlcipher3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb, 
83196                     (char *)pKey, P4_KEYINFO_HANDOFF);
83197   if( memRootPage>=0 ){
83198     sqlcipher3VdbeChangeP5(v, 1);
83199   }
83200
83201 #ifndef SQLCIPHER_OMIT_MERGE_SORT
83202   /* Open the sorter cursor if we are to use one. */
83203   iSorter = pParse->nTab++;
83204   sqlcipher3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, 0, (char*)pKey, P4_KEYINFO);
83205 #else
83206   iSorter = iTab;
83207 #endif
83208
83209   /* Open the table. Loop through all rows of the table, inserting index
83210   ** records into the sorter. */
83211   sqlcipher3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
83212   addr1 = sqlcipher3VdbeAddOp2(v, OP_Rewind, iTab, 0);
83213   regRecord = sqlcipher3GetTempReg(pParse);
83214
83215 #ifndef SQLCIPHER_OMIT_MERGE_SORT
83216   sqlcipher3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
83217   sqlcipher3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
83218   sqlcipher3VdbeAddOp2(v, OP_Next, iTab, addr1+1);
83219   sqlcipher3VdbeJumpHere(v, addr1);
83220   addr1 = sqlcipher3VdbeAddOp2(v, OP_SorterSort, iSorter, 0);
83221   if( pIndex->onError!=OE_None ){
83222     int j2 = sqlcipher3VdbeCurrentAddr(v) + 3;
83223     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, j2);
83224     addr2 = sqlcipher3VdbeCurrentAddr(v);
83225     sqlcipher3VdbeAddOp3(v, OP_SorterCompare, iSorter, j2, regRecord);
83226     sqlcipher3HaltConstraint(
83227         pParse, OE_Abort, "indexed columns are not unique", P4_STATIC
83228     );
83229   }else{
83230     addr2 = sqlcipher3VdbeCurrentAddr(v);
83231   }
83232   sqlcipher3VdbeAddOp2(v, OP_SorterData, iSorter, regRecord);
83233   sqlcipher3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 1);
83234   sqlcipher3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
83235 #else
83236   regIdxKey = sqlcipher3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
83237   addr2 = addr1 + 1;
83238   if( pIndex->onError!=OE_None ){
83239     const int regRowid = regIdxKey + pIndex->nColumn;
83240     const int j2 = sqlcipher3VdbeCurrentAddr(v) + 2;
83241     void * const pRegKey = SQLCIPHER_INT_TO_PTR(regIdxKey);
83242
83243     /* The registers accessed by the OP_IsUnique opcode were allocated
83244     ** using sqlcipher3GetTempRange() inside of the sqlcipher3GenerateIndexKey()
83245     ** call above. Just before that function was freed they were released
83246     ** (made available to the compiler for reuse) using 
83247     ** sqlcipher3ReleaseTempRange(). So in some ways having the OP_IsUnique
83248     ** opcode use the values stored within seems dangerous. However, since
83249     ** we can be sure that no other temp registers have been allocated
83250     ** since sqlcipher3ReleaseTempRange() was called, it is safe to do so.
83251     */
83252     sqlcipher3VdbeAddOp4(v, OP_IsUnique, iIdx, j2, regRowid, pRegKey, P4_INT32);
83253     sqlcipher3HaltConstraint(
83254         pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
83255   }
83256   sqlcipher3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 0);
83257   sqlcipher3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
83258 #endif
83259   sqlcipher3ReleaseTempReg(pParse, regRecord);
83260   sqlcipher3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2);
83261   sqlcipher3VdbeJumpHere(v, addr1);
83262
83263   sqlcipher3VdbeAddOp1(v, OP_Close, iTab);
83264   sqlcipher3VdbeAddOp1(v, OP_Close, iIdx);
83265   sqlcipher3VdbeAddOp1(v, OP_Close, iSorter);
83266 }
83267
83268 /*
83269 ** Create a new index for an SQL table.  pName1.pName2 is the name of the index 
83270 ** and pTblList is the name of the table that is to be indexed.  Both will 
83271 ** be NULL for a primary key or an index that is created to satisfy a
83272 ** UNIQUE constraint.  If pTable and pIndex are NULL, use pParse->pNewTable
83273 ** as the table to be indexed.  pParse->pNewTable is a table that is
83274 ** currently being constructed by a CREATE TABLE statement.
83275 **
83276 ** pList is a list of columns to be indexed.  pList will be NULL if this
83277 ** is a primary key or unique-constraint on the most recent column added
83278 ** to the table currently under construction.  
83279 **
83280 ** If the index is created successfully, return a pointer to the new Index
83281 ** structure. This is used by sqlcipher3AddPrimaryKey() to mark the index
83282 ** as the tables primary key (Index.autoIndex==2).
83283 */
83284 SQLCIPHER_PRIVATE Index *sqlcipher3CreateIndex(
83285   Parse *pParse,     /* All information about this parse */
83286   Token *pName1,     /* First part of index name. May be NULL */
83287   Token *pName2,     /* Second part of index name. May be NULL */
83288   SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
83289   ExprList *pList,   /* A list of columns to be indexed */
83290   int onError,       /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
83291   Token *pStart,     /* The CREATE token that begins this statement */
83292   Token *pEnd,       /* The ")" that closes the CREATE INDEX statement */
83293   int sortOrder,     /* Sort order of primary key when pList==NULL */
83294   int ifNotExist     /* Omit error if index already exists */
83295 ){
83296   Index *pRet = 0;     /* Pointer to return */
83297   Table *pTab = 0;     /* Table to be indexed */
83298   Index *pIndex = 0;   /* The index to be created */
83299   char *zName = 0;     /* Name of the index */
83300   int nName;           /* Number of characters in zName */
83301   int i, j;
83302   Token nullId;        /* Fake token for an empty ID list */
83303   DbFixer sFix;        /* For assigning database names to pTable */
83304   int sortOrderMask;   /* 1 to honor DESC in index.  0 to ignore. */
83305   sqlcipher3 *db = pParse->db;
83306   Db *pDb;             /* The specific table containing the indexed database */
83307   int iDb;             /* Index of the database that is being written */
83308   Token *pName = 0;    /* Unqualified name of the index to create */
83309   struct ExprList_item *pListItem; /* For looping over pList */
83310   int nCol;
83311   int nExtra = 0;
83312   char *zExtra;
83313
83314   assert( pStart==0 || pEnd!=0 ); /* pEnd must be non-NULL if pStart is */
83315   assert( pParse->nErr==0 );      /* Never called with prior errors */
83316   if( db->mallocFailed || IN_DECLARE_VTAB ){
83317     goto exit_create_index;
83318   }
83319   if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
83320     goto exit_create_index;
83321   }
83322
83323   /*
83324   ** Find the table that is to be indexed.  Return early if not found.
83325   */
83326   if( pTblName!=0 ){
83327
83328     /* Use the two-part index name to determine the database 
83329     ** to search for the table. 'Fix' the table name to this db
83330     ** before looking up the table.
83331     */
83332     assert( pName1 && pName2 );
83333     iDb = sqlcipher3TwoPartName(pParse, pName1, pName2, &pName);
83334     if( iDb<0 ) goto exit_create_index;
83335     assert( pName && pName->z );
83336
83337 #ifndef SQLCIPHER_OMIT_TEMPDB
83338     /* If the index name was unqualified, check if the the table
83339     ** is a temp table. If so, set the database to 1. Do not do this
83340     ** if initialising a database schema.
83341     */
83342     if( !db->init.busy ){
83343       pTab = sqlcipher3SrcListLookup(pParse, pTblName);
83344       if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
83345         iDb = 1;
83346       }
83347     }
83348 #endif
83349
83350     if( sqlcipher3FixInit(&sFix, pParse, iDb, "index", pName) &&
83351         sqlcipher3FixSrcList(&sFix, pTblName)
83352     ){
83353       /* Because the parser constructs pTblName from a single identifier,
83354       ** sqlcipher3FixSrcList can never fail. */
83355       assert(0);
83356     }
83357     pTab = sqlcipher3LocateTable(pParse, 0, pTblName->a[0].zName, 
83358         pTblName->a[0].zDatabase);
83359     if( !pTab || db->mallocFailed ) goto exit_create_index;
83360     assert( db->aDb[iDb].pSchema==pTab->pSchema );
83361   }else{
83362     assert( pName==0 );
83363     assert( pStart==0 );
83364     pTab = pParse->pNewTable;
83365     if( !pTab ) goto exit_create_index;
83366     iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
83367   }
83368   pDb = &db->aDb[iDb];
83369
83370   assert( pTab!=0 );
83371   assert( pParse->nErr==0 );
83372   if( sqlcipher3StrNICmp(pTab->zName, "sqlcipher_", 7)==0 
83373        && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
83374     sqlcipher3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
83375     goto exit_create_index;
83376   }
83377 #ifndef SQLCIPHER_OMIT_VIEW
83378   if( pTab->pSelect ){
83379     sqlcipher3ErrorMsg(pParse, "views may not be indexed");
83380     goto exit_create_index;
83381   }
83382 #endif
83383 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
83384   if( IsVirtual(pTab) ){
83385     sqlcipher3ErrorMsg(pParse, "virtual tables may not be indexed");
83386     goto exit_create_index;
83387   }
83388 #endif
83389
83390   /*
83391   ** Find the name of the index.  Make sure there is not already another
83392   ** index or table with the same name.  
83393   **
83394   ** Exception:  If we are reading the names of permanent indices from the
83395   ** sqlcipher_master table (because some other process changed the schema) and
83396   ** one of the index names collides with the name of a temporary table or
83397   ** index, then we will continue to process this index.
83398   **
83399   ** If pName==0 it means that we are
83400   ** dealing with a primary key or UNIQUE constraint.  We have to invent our
83401   ** own name.
83402   */
83403   if( pName ){
83404     zName = sqlcipher3NameFromToken(db, pName);
83405     if( zName==0 ) goto exit_create_index;
83406     assert( pName->z!=0 );
83407     if( SQLCIPHER_OK!=sqlcipher3CheckObjectName(pParse, zName) ){
83408       goto exit_create_index;
83409     }
83410     if( !db->init.busy ){
83411       if( sqlcipher3FindTable(db, zName, 0)!=0 ){
83412         sqlcipher3ErrorMsg(pParse, "there is already a table named %s", zName);
83413         goto exit_create_index;
83414       }
83415     }
83416     if( sqlcipher3FindIndex(db, zName, pDb->zName)!=0 ){
83417       if( !ifNotExist ){
83418         sqlcipher3ErrorMsg(pParse, "index %s already exists", zName);
83419       }else{
83420         assert( !db->init.busy );
83421         sqlcipher3CodeVerifySchema(pParse, iDb);
83422       }
83423       goto exit_create_index;
83424     }
83425   }else{
83426     int n;
83427     Index *pLoop;
83428     for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
83429     zName = sqlcipher3MPrintf(db, "sqlcipher_autoindex_%s_%d", pTab->zName, n);
83430     if( zName==0 ){
83431       goto exit_create_index;
83432     }
83433   }
83434
83435   /* Check for authorization to create an index.
83436   */
83437 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
83438   {
83439     const char *zDb = pDb->zName;
83440     if( sqlcipher3AuthCheck(pParse, SQLCIPHER_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
83441       goto exit_create_index;
83442     }
83443     i = SQLCIPHER_CREATE_INDEX;
83444     if( !OMIT_TEMPDB && iDb==1 ) i = SQLCIPHER_CREATE_TEMP_INDEX;
83445     if( sqlcipher3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
83446       goto exit_create_index;
83447     }
83448   }
83449 #endif
83450
83451   /* If pList==0, it means this routine was called to make a primary
83452   ** key out of the last column added to the table under construction.
83453   ** So create a fake list to simulate this.
83454   */
83455   if( pList==0 ){
83456     nullId.z = pTab->aCol[pTab->nCol-1].zName;
83457     nullId.n = sqlcipher3Strlen30((char*)nullId.z);
83458     pList = sqlcipher3ExprListAppend(pParse, 0, 0);
83459     if( pList==0 ) goto exit_create_index;
83460     sqlcipher3ExprListSetName(pParse, pList, &nullId, 0);
83461     pList->a[0].sortOrder = (u8)sortOrder;
83462   }
83463
83464   /* Figure out how many bytes of space are required to store explicitly
83465   ** specified collation sequence names.
83466   */
83467   for(i=0; i<pList->nExpr; i++){
83468     Expr *pExpr = pList->a[i].pExpr;
83469     if( pExpr ){
83470       CollSeq *pColl = pExpr->pColl;
83471       /* Either pColl!=0 or there was an OOM failure.  But if an OOM
83472       ** failure we have quit before reaching this point. */
83473       if( ALWAYS(pColl) ){
83474         nExtra += (1 + sqlcipher3Strlen30(pColl->zName));
83475       }
83476     }
83477   }
83478
83479   /* 
83480   ** Allocate the index structure. 
83481   */
83482   nName = sqlcipher3Strlen30(zName);
83483   nCol = pList->nExpr;
83484   pIndex = sqlcipher3DbMallocZero(db, 
83485       sizeof(Index) +              /* Index structure  */
83486       sizeof(tRowcnt)*(nCol+1) +   /* Index.aiRowEst   */
83487       sizeof(int)*nCol +           /* Index.aiColumn   */
83488       sizeof(char *)*nCol +        /* Index.azColl     */
83489       sizeof(u8)*nCol +            /* Index.aSortOrder */
83490       nName + 1 +                  /* Index.zName      */
83491       nExtra                       /* Collation sequence names */
83492   );
83493   if( db->mallocFailed ){
83494     goto exit_create_index;
83495   }
83496   pIndex->aiRowEst = (tRowcnt*)(&pIndex[1]);
83497   pIndex->azColl = (char**)(&pIndex->aiRowEst[nCol+1]);
83498   pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
83499   pIndex->aSortOrder = (u8 *)(&pIndex->aiColumn[nCol]);
83500   pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
83501   zExtra = (char *)(&pIndex->zName[nName+1]);
83502   memcpy(pIndex->zName, zName, nName+1);
83503   pIndex->pTable = pTab;
83504   pIndex->nColumn = pList->nExpr;
83505   pIndex->onError = (u8)onError;
83506   pIndex->autoIndex = (u8)(pName==0);
83507   pIndex->pSchema = db->aDb[iDb].pSchema;
83508   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
83509
83510   /* Check to see if we should honor DESC requests on index columns
83511   */
83512   if( pDb->pSchema->file_format>=4 ){
83513     sortOrderMask = -1;   /* Honor DESC */
83514   }else{
83515     sortOrderMask = 0;    /* Ignore DESC */
83516   }
83517
83518   /* Scan the names of the columns of the table to be indexed and
83519   ** load the column indices into the Index structure.  Report an error
83520   ** if any column is not found.
83521   **
83522   ** TODO:  Add a test to make sure that the same column is not named
83523   ** more than once within the same index.  Only the first instance of
83524   ** the column will ever be used by the optimizer.  Note that using the
83525   ** same column more than once cannot be an error because that would 
83526   ** break backwards compatibility - it needs to be a warning.
83527   */
83528   for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
83529     const char *zColName = pListItem->zName;
83530     Column *pTabCol;
83531     int requestedSortOrder;
83532     char *zColl;                   /* Collation sequence name */
83533
83534     for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
83535       if( sqlcipher3StrICmp(zColName, pTabCol->zName)==0 ) break;
83536     }
83537     if( j>=pTab->nCol ){
83538       sqlcipher3ErrorMsg(pParse, "table %s has no column named %s",
83539         pTab->zName, zColName);
83540       pParse->checkSchema = 1;
83541       goto exit_create_index;
83542     }
83543     pIndex->aiColumn[i] = j;
83544     /* Justification of the ALWAYS(pListItem->pExpr->pColl):  Because of
83545     ** the way the "idxlist" non-terminal is constructed by the parser,
83546     ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
83547     ** must exist or else there must have been an OOM error.  But if there
83548     ** was an OOM error, we would never reach this point. */
83549     if( pListItem->pExpr && ALWAYS(pListItem->pExpr->pColl) ){
83550       int nColl;
83551       zColl = pListItem->pExpr->pColl->zName;
83552       nColl = sqlcipher3Strlen30(zColl) + 1;
83553       assert( nExtra>=nColl );
83554       memcpy(zExtra, zColl, nColl);
83555       zColl = zExtra;
83556       zExtra += nColl;
83557       nExtra -= nColl;
83558     }else{
83559       zColl = pTab->aCol[j].zColl;
83560       if( !zColl ){
83561         zColl = db->pDfltColl->zName;
83562       }
83563     }
83564     if( !db->init.busy && !sqlcipher3LocateCollSeq(pParse, zColl) ){
83565       goto exit_create_index;
83566     }
83567     pIndex->azColl[i] = zColl;
83568     requestedSortOrder = pListItem->sortOrder & sortOrderMask;
83569     pIndex->aSortOrder[i] = (u8)requestedSortOrder;
83570   }
83571   sqlcipher3DefaultRowEst(pIndex);
83572
83573   if( pTab==pParse->pNewTable ){
83574     /* This routine has been called to create an automatic index as a
83575     ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
83576     ** a PRIMARY KEY or UNIQUE clause following the column definitions.
83577     ** i.e. one of:
83578     **
83579     ** CREATE TABLE t(x PRIMARY KEY, y);
83580     ** CREATE TABLE t(x, y, UNIQUE(x, y));
83581     **
83582     ** Either way, check to see if the table already has such an index. If
83583     ** so, don't bother creating this one. This only applies to
83584     ** automatically created indices. Users can do as they wish with
83585     ** explicit indices.
83586     **
83587     ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
83588     ** (and thus suppressing the second one) even if they have different
83589     ** sort orders.
83590     **
83591     ** If there are different collating sequences or if the columns of
83592     ** the constraint occur in different orders, then the constraints are
83593     ** considered distinct and both result in separate indices.
83594     */
83595     Index *pIdx;
83596     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83597       int k;
83598       assert( pIdx->onError!=OE_None );
83599       assert( pIdx->autoIndex );
83600       assert( pIndex->onError!=OE_None );
83601
83602       if( pIdx->nColumn!=pIndex->nColumn ) continue;
83603       for(k=0; k<pIdx->nColumn; k++){
83604         const char *z1;
83605         const char *z2;
83606         if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
83607         z1 = pIdx->azColl[k];
83608         z2 = pIndex->azColl[k];
83609         if( z1!=z2 && sqlcipher3StrICmp(z1, z2) ) break;
83610       }
83611       if( k==pIdx->nColumn ){
83612         if( pIdx->onError!=pIndex->onError ){
83613           /* This constraint creates the same index as a previous
83614           ** constraint specified somewhere in the CREATE TABLE statement.
83615           ** However the ON CONFLICT clauses are different. If both this 
83616           ** constraint and the previous equivalent constraint have explicit
83617           ** ON CONFLICT clauses this is an error. Otherwise, use the
83618           ** explicitly specified behaviour for the index.
83619           */
83620           if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
83621             sqlcipher3ErrorMsg(pParse, 
83622                 "conflicting ON CONFLICT clauses specified", 0);
83623           }
83624           if( pIdx->onError==OE_Default ){
83625             pIdx->onError = pIndex->onError;
83626           }
83627         }
83628         goto exit_create_index;
83629       }
83630     }
83631   }
83632
83633   /* Link the new Index structure to its table and to the other
83634   ** in-memory database structures. 
83635   */
83636   if( db->init.busy ){
83637     Index *p;
83638     assert( sqlcipher3SchemaMutexHeld(db, 0, pIndex->pSchema) );
83639     p = sqlcipher3HashInsert(&pIndex->pSchema->idxHash, 
83640                           pIndex->zName, sqlcipher3Strlen30(pIndex->zName),
83641                           pIndex);
83642     if( p ){
83643       assert( p==pIndex );  /* Malloc must have failed */
83644       db->mallocFailed = 1;
83645       goto exit_create_index;
83646     }
83647     db->flags |= SQLCIPHER_InternChanges;
83648     if( pTblName!=0 ){
83649       pIndex->tnum = db->init.newTnum;
83650     }
83651   }
83652
83653   /* If the db->init.busy is 0 then create the index on disk.  This
83654   ** involves writing the index into the master table and filling in the
83655   ** index with the current table contents.
83656   **
83657   ** The db->init.busy is 0 when the user first enters a CREATE INDEX 
83658   ** command.  db->init.busy is 1 when a database is opened and 
83659   ** CREATE INDEX statements are read out of the master table.  In
83660   ** the latter case the index already exists on disk, which is why
83661   ** we don't want to recreate it.
83662   **
83663   ** If pTblName==0 it means this index is generated as a primary key
83664   ** or UNIQUE constraint of a CREATE TABLE statement.  Since the table
83665   ** has just been created, it contains no data and the index initialization
83666   ** step can be skipped.
83667   */
83668   else{ /* if( db->init.busy==0 ) */
83669     Vdbe *v;
83670     char *zStmt;
83671     int iMem = ++pParse->nMem;
83672
83673     v = sqlcipher3GetVdbe(pParse);
83674     if( v==0 ) goto exit_create_index;
83675
83676
83677     /* Create the rootpage for the index
83678     */
83679     sqlcipher3BeginWriteOperation(pParse, 1, iDb);
83680     sqlcipher3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
83681
83682     /* Gather the complete text of the CREATE INDEX statement into
83683     ** the zStmt variable
83684     */
83685     if( pStart ){
83686       assert( pEnd!=0 );
83687       /* A named index with an explicit CREATE INDEX statement */
83688       zStmt = sqlcipher3MPrintf(db, "CREATE%s INDEX %.*s",
83689         onError==OE_None ? "" : " UNIQUE",
83690         (int)(pEnd->z - pName->z) + 1,
83691         pName->z);
83692     }else{
83693       /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
83694       /* zStmt = sqlcipher3MPrintf(""); */
83695       zStmt = 0;
83696     }
83697
83698     /* Add an entry in sqlcipher_master for this index
83699     */
83700     sqlcipher3NestedParse(pParse, 
83701         "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
83702         db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
83703         pIndex->zName,
83704         pTab->zName,
83705         iMem,
83706         zStmt
83707     );
83708     sqlcipher3DbFree(db, zStmt);
83709
83710     /* Fill the index with data and reparse the schema. Code an OP_Expire
83711     ** to invalidate all pre-compiled statements.
83712     */
83713     if( pTblName ){
83714       sqlcipher3RefillIndex(pParse, pIndex, iMem);
83715       sqlcipher3ChangeCookie(pParse, iDb);
83716       sqlcipher3VdbeAddParseSchemaOp(v, iDb,
83717          sqlcipher3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
83718       sqlcipher3VdbeAddOp1(v, OP_Expire, 0);
83719     }
83720   }
83721
83722   /* When adding an index to the list of indices for a table, make
83723   ** sure all indices labeled OE_Replace come after all those labeled
83724   ** OE_Ignore.  This is necessary for the correct constraint check
83725   ** processing (in sqlcipher3GenerateConstraintChecks()) as part of
83726   ** UPDATE and INSERT statements.  
83727   */
83728   if( db->init.busy || pTblName==0 ){
83729     if( onError!=OE_Replace || pTab->pIndex==0
83730          || pTab->pIndex->onError==OE_Replace){
83731       pIndex->pNext = pTab->pIndex;
83732       pTab->pIndex = pIndex;
83733     }else{
83734       Index *pOther = pTab->pIndex;
83735       while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
83736         pOther = pOther->pNext;
83737       }
83738       pIndex->pNext = pOther->pNext;
83739       pOther->pNext = pIndex;
83740     }
83741     pRet = pIndex;
83742     pIndex = 0;
83743   }
83744
83745   /* Clean up before exiting */
83746 exit_create_index:
83747   if( pIndex ){
83748     sqlcipher3DbFree(db, pIndex->zColAff);
83749     sqlcipher3DbFree(db, pIndex);
83750   }
83751   sqlcipher3ExprListDelete(db, pList);
83752   sqlcipher3SrcListDelete(db, pTblName);
83753   sqlcipher3DbFree(db, zName);
83754   return pRet;
83755 }
83756
83757 /*
83758 ** Fill the Index.aiRowEst[] array with default information - information
83759 ** to be used when we have not run the ANALYZE command.
83760 **
83761 ** aiRowEst[0] is suppose to contain the number of elements in the index.
83762 ** Since we do not know, guess 1 million.  aiRowEst[1] is an estimate of the
83763 ** number of rows in the table that match any particular value of the
83764 ** first column of the index.  aiRowEst[2] is an estimate of the number
83765 ** of rows that match any particular combiniation of the first 2 columns
83766 ** of the index.  And so forth.  It must always be the case that
83767 *
83768 **           aiRowEst[N]<=aiRowEst[N-1]
83769 **           aiRowEst[N]>=1
83770 **
83771 ** Apart from that, we have little to go on besides intuition as to
83772 ** how aiRowEst[] should be initialized.  The numbers generated here
83773 ** are based on typical values found in actual indices.
83774 */
83775 SQLCIPHER_PRIVATE void sqlcipher3DefaultRowEst(Index *pIdx){
83776   tRowcnt *a = pIdx->aiRowEst;
83777   int i;
83778   tRowcnt n;
83779   assert( a!=0 );
83780   a[0] = pIdx->pTable->nRowEst;
83781   if( a[0]<10 ) a[0] = 10;
83782   n = 10;
83783   for(i=1; i<=pIdx->nColumn; i++){
83784     a[i] = n;
83785     if( n>5 ) n--;
83786   }
83787   if( pIdx->onError!=OE_None ){
83788     a[pIdx->nColumn] = 1;
83789   }
83790 }
83791
83792 /*
83793 ** This routine will drop an existing named index.  This routine
83794 ** implements the DROP INDEX statement.
83795 */
83796 SQLCIPHER_PRIVATE void sqlcipher3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
83797   Index *pIndex;
83798   Vdbe *v;
83799   sqlcipher3 *db = pParse->db;
83800   int iDb;
83801
83802   assert( pParse->nErr==0 );   /* Never called with prior errors */
83803   if( db->mallocFailed ){
83804     goto exit_drop_index;
83805   }
83806   assert( pName->nSrc==1 );
83807   if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
83808     goto exit_drop_index;
83809   }
83810   pIndex = sqlcipher3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
83811   if( pIndex==0 ){
83812     if( !ifExists ){
83813       sqlcipher3ErrorMsg(pParse, "no such index: %S", pName, 0);
83814     }else{
83815       sqlcipher3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
83816     }
83817     pParse->checkSchema = 1;
83818     goto exit_drop_index;
83819   }
83820   if( pIndex->autoIndex ){
83821     sqlcipher3ErrorMsg(pParse, "index associated with UNIQUE "
83822       "or PRIMARY KEY constraint cannot be dropped", 0);
83823     goto exit_drop_index;
83824   }
83825   iDb = sqlcipher3SchemaToIndex(db, pIndex->pSchema);
83826 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
83827   {
83828     int code = SQLCIPHER_DROP_INDEX;
83829     Table *pTab = pIndex->pTable;
83830     const char *zDb = db->aDb[iDb].zName;
83831     const char *zTab = SCHEMA_TABLE(iDb);
83832     if( sqlcipher3AuthCheck(pParse, SQLCIPHER_DELETE, zTab, 0, zDb) ){
83833       goto exit_drop_index;
83834     }
83835     if( !OMIT_TEMPDB && iDb ) code = SQLCIPHER_DROP_TEMP_INDEX;
83836     if( sqlcipher3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
83837       goto exit_drop_index;
83838     }
83839   }
83840 #endif
83841
83842   /* Generate code to remove the index and from the master table */
83843   v = sqlcipher3GetVdbe(pParse);
83844   if( v ){
83845     sqlcipher3BeginWriteOperation(pParse, 1, iDb);
83846     sqlcipher3NestedParse(pParse,
83847        "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
83848        db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
83849     );
83850     sqlcipher3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
83851     sqlcipher3ChangeCookie(pParse, iDb);
83852     destroyRootPage(pParse, pIndex->tnum, iDb);
83853     sqlcipher3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
83854   }
83855
83856 exit_drop_index:
83857   sqlcipher3SrcListDelete(db, pName);
83858 }
83859
83860 /*
83861 ** pArray is a pointer to an array of objects.  Each object in the
83862 ** array is szEntry bytes in size.  This routine allocates a new
83863 ** object on the end of the array.
83864 **
83865 ** *pnEntry is the number of entries already in use.  *pnAlloc is
83866 ** the previously allocated size of the array.  initSize is the
83867 ** suggested initial array size allocation.
83868 **
83869 ** The index of the new entry is returned in *pIdx.
83870 **
83871 ** This routine returns a pointer to the array of objects.  This
83872 ** might be the same as the pArray parameter or it might be a different
83873 ** pointer if the array was resized.
83874 */
83875 SQLCIPHER_PRIVATE void *sqlcipher3ArrayAllocate(
83876   sqlcipher3 *db,      /* Connection to notify of malloc failures */
83877   void *pArray,     /* Array of objects.  Might be reallocated */
83878   int szEntry,      /* Size of each object in the array */
83879   int initSize,     /* Suggested initial allocation, in elements */
83880   int *pnEntry,     /* Number of objects currently in use */
83881   int *pnAlloc,     /* Current size of the allocation, in elements */
83882   int *pIdx         /* Write the index of a new slot here */
83883 ){
83884   char *z;
83885   if( *pnEntry >= *pnAlloc ){
83886     void *pNew;
83887     int newSize;
83888     newSize = (*pnAlloc)*2 + initSize;
83889     pNew = sqlcipher3DbRealloc(db, pArray, newSize*szEntry);
83890     if( pNew==0 ){
83891       *pIdx = -1;
83892       return pArray;
83893     }
83894     *pnAlloc = sqlcipher3DbMallocSize(db, pNew)/szEntry;
83895     pArray = pNew;
83896   }
83897   z = (char*)pArray;
83898   memset(&z[*pnEntry * szEntry], 0, szEntry);
83899   *pIdx = *pnEntry;
83900   ++*pnEntry;
83901   return pArray;
83902 }
83903
83904 /*
83905 ** Append a new element to the given IdList.  Create a new IdList if
83906 ** need be.
83907 **
83908 ** A new IdList is returned, or NULL if malloc() fails.
83909 */
83910 SQLCIPHER_PRIVATE IdList *sqlcipher3IdListAppend(sqlcipher3 *db, IdList *pList, Token *pToken){
83911   int i;
83912   if( pList==0 ){
83913     pList = sqlcipher3DbMallocZero(db, sizeof(IdList) );
83914     if( pList==0 ) return 0;
83915     pList->nAlloc = 0;
83916   }
83917   pList->a = sqlcipher3ArrayAllocate(
83918       db,
83919       pList->a,
83920       sizeof(pList->a[0]),
83921       5,
83922       &pList->nId,
83923       &pList->nAlloc,
83924       &i
83925   );
83926   if( i<0 ){
83927     sqlcipher3IdListDelete(db, pList);
83928     return 0;
83929   }
83930   pList->a[i].zName = sqlcipher3NameFromToken(db, pToken);
83931   return pList;
83932 }
83933
83934 /*
83935 ** Delete an IdList.
83936 */
83937 SQLCIPHER_PRIVATE void sqlcipher3IdListDelete(sqlcipher3 *db, IdList *pList){
83938   int i;
83939   if( pList==0 ) return;
83940   for(i=0; i<pList->nId; i++){
83941     sqlcipher3DbFree(db, pList->a[i].zName);
83942   }
83943   sqlcipher3DbFree(db, pList->a);
83944   sqlcipher3DbFree(db, pList);
83945 }
83946
83947 /*
83948 ** Return the index in pList of the identifier named zId.  Return -1
83949 ** if not found.
83950 */
83951 SQLCIPHER_PRIVATE int sqlcipher3IdListIndex(IdList *pList, const char *zName){
83952   int i;
83953   if( pList==0 ) return -1;
83954   for(i=0; i<pList->nId; i++){
83955     if( sqlcipher3StrICmp(pList->a[i].zName, zName)==0 ) return i;
83956   }
83957   return -1;
83958 }
83959
83960 /*
83961 ** Expand the space allocated for the given SrcList object by
83962 ** creating nExtra new slots beginning at iStart.  iStart is zero based.
83963 ** New slots are zeroed.
83964 **
83965 ** For example, suppose a SrcList initially contains two entries: A,B.
83966 ** To append 3 new entries onto the end, do this:
83967 **
83968 **    sqlcipher3SrcListEnlarge(db, pSrclist, 3, 2);
83969 **
83970 ** After the call above it would contain:  A, B, nil, nil, nil.
83971 ** If the iStart argument had been 1 instead of 2, then the result
83972 ** would have been:  A, nil, nil, nil, B.  To prepend the new slots,
83973 ** the iStart value would be 0.  The result then would
83974 ** be: nil, nil, nil, A, B.
83975 **
83976 ** If a memory allocation fails the SrcList is unchanged.  The
83977 ** db->mallocFailed flag will be set to true.
83978 */
83979 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListEnlarge(
83980   sqlcipher3 *db,       /* Database connection to notify of OOM errors */
83981   SrcList *pSrc,     /* The SrcList to be enlarged */
83982   int nExtra,        /* Number of new slots to add to pSrc->a[] */
83983   int iStart         /* Index in pSrc->a[] of first new slot */
83984 ){
83985   int i;
83986
83987   /* Sanity checking on calling parameters */
83988   assert( iStart>=0 );
83989   assert( nExtra>=1 );
83990   assert( pSrc!=0 );
83991   assert( iStart<=pSrc->nSrc );
83992
83993   /* Allocate additional space if needed */
83994   if( pSrc->nSrc+nExtra>pSrc->nAlloc ){
83995     SrcList *pNew;
83996     int nAlloc = pSrc->nSrc+nExtra;
83997     int nGot;
83998     pNew = sqlcipher3DbRealloc(db, pSrc,
83999                sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
84000     if( pNew==0 ){
84001       assert( db->mallocFailed );
84002       return pSrc;
84003     }
84004     pSrc = pNew;
84005     nGot = (sqlcipher3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
84006     pSrc->nAlloc = (u16)nGot;
84007   }
84008
84009   /* Move existing slots that come after the newly inserted slots
84010   ** out of the way */
84011   for(i=pSrc->nSrc-1; i>=iStart; i--){
84012     pSrc->a[i+nExtra] = pSrc->a[i];
84013   }
84014   pSrc->nSrc += (i16)nExtra;
84015
84016   /* Zero the newly allocated slots */
84017   memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
84018   for(i=iStart; i<iStart+nExtra; i++){
84019     pSrc->a[i].iCursor = -1;
84020   }
84021
84022   /* Return a pointer to the enlarged SrcList */
84023   return pSrc;
84024 }
84025
84026
84027 /*
84028 ** Append a new table name to the given SrcList.  Create a new SrcList if
84029 ** need be.  A new entry is created in the SrcList even if pTable is NULL.
84030 **
84031 ** A SrcList is returned, or NULL if there is an OOM error.  The returned
84032 ** SrcList might be the same as the SrcList that was input or it might be
84033 ** a new one.  If an OOM error does occurs, then the prior value of pList
84034 ** that is input to this routine is automatically freed.
84035 **
84036 ** If pDatabase is not null, it means that the table has an optional
84037 ** database name prefix.  Like this:  "database.table".  The pDatabase
84038 ** points to the table name and the pTable points to the database name.
84039 ** The SrcList.a[].zName field is filled with the table name which might
84040 ** come from pTable (if pDatabase is NULL) or from pDatabase.  
84041 ** SrcList.a[].zDatabase is filled with the database name from pTable,
84042 ** or with NULL if no database is specified.
84043 **
84044 ** In other words, if call like this:
84045 **
84046 **         sqlcipher3SrcListAppend(D,A,B,0);
84047 **
84048 ** Then B is a table name and the database name is unspecified.  If called
84049 ** like this:
84050 **
84051 **         sqlcipher3SrcListAppend(D,A,B,C);
84052 **
84053 ** Then C is the table name and B is the database name.  If C is defined
84054 ** then so is B.  In other words, we never have a case where:
84055 **
84056 **         sqlcipher3SrcListAppend(D,A,0,C);
84057 **
84058 ** Both pTable and pDatabase are assumed to be quoted.  They are dequoted
84059 ** before being added to the SrcList.
84060 */
84061 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListAppend(
84062   sqlcipher3 *db,        /* Connection to notify of malloc failures */
84063   SrcList *pList,     /* Append to this SrcList. NULL creates a new SrcList */
84064   Token *pTable,      /* Table to append */
84065   Token *pDatabase    /* Database of the table */
84066 ){
84067   struct SrcList_item *pItem;
84068   assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
84069   if( pList==0 ){
84070     pList = sqlcipher3DbMallocZero(db, sizeof(SrcList) );
84071     if( pList==0 ) return 0;
84072     pList->nAlloc = 1;
84073   }
84074   pList = sqlcipher3SrcListEnlarge(db, pList, 1, pList->nSrc);
84075   if( db->mallocFailed ){
84076     sqlcipher3SrcListDelete(db, pList);
84077     return 0;
84078   }
84079   pItem = &pList->a[pList->nSrc-1];
84080   if( pDatabase && pDatabase->z==0 ){
84081     pDatabase = 0;
84082   }
84083   if( pDatabase ){
84084     Token *pTemp = pDatabase;
84085     pDatabase = pTable;
84086     pTable = pTemp;
84087   }
84088   pItem->zName = sqlcipher3NameFromToken(db, pTable);
84089   pItem->zDatabase = sqlcipher3NameFromToken(db, pDatabase);
84090   return pList;
84091 }
84092
84093 /*
84094 ** Assign VdbeCursor index numbers to all tables in a SrcList
84095 */
84096 SQLCIPHER_PRIVATE void sqlcipher3SrcListAssignCursors(Parse *pParse, SrcList *pList){
84097   int i;
84098   struct SrcList_item *pItem;
84099   assert(pList || pParse->db->mallocFailed );
84100   if( pList ){
84101     for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
84102       if( pItem->iCursor>=0 ) break;
84103       pItem->iCursor = pParse->nTab++;
84104       if( pItem->pSelect ){
84105         sqlcipher3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
84106       }
84107     }
84108   }
84109 }
84110
84111 /*
84112 ** Delete an entire SrcList including all its substructure.
84113 */
84114 SQLCIPHER_PRIVATE void sqlcipher3SrcListDelete(sqlcipher3 *db, SrcList *pList){
84115   int i;
84116   struct SrcList_item *pItem;
84117   if( pList==0 ) return;
84118   for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
84119     sqlcipher3DbFree(db, pItem->zDatabase);
84120     sqlcipher3DbFree(db, pItem->zName);
84121     sqlcipher3DbFree(db, pItem->zAlias);
84122     sqlcipher3DbFree(db, pItem->zIndex);
84123     sqlcipher3DeleteTable(db, pItem->pTab);
84124     sqlcipher3SelectDelete(db, pItem->pSelect);
84125     sqlcipher3ExprDelete(db, pItem->pOn);
84126     sqlcipher3IdListDelete(db, pItem->pUsing);
84127   }
84128   sqlcipher3DbFree(db, pList);
84129 }
84130
84131 /*
84132 ** This routine is called by the parser to add a new term to the
84133 ** end of a growing FROM clause.  The "p" parameter is the part of
84134 ** the FROM clause that has already been constructed.  "p" is NULL
84135 ** if this is the first term of the FROM clause.  pTable and pDatabase
84136 ** are the name of the table and database named in the FROM clause term.
84137 ** pDatabase is NULL if the database name qualifier is missing - the
84138 ** usual case.  If the term has a alias, then pAlias points to the
84139 ** alias token.  If the term is a subquery, then pSubquery is the
84140 ** SELECT statement that the subquery encodes.  The pTable and
84141 ** pDatabase parameters are NULL for subqueries.  The pOn and pUsing
84142 ** parameters are the content of the ON and USING clauses.
84143 **
84144 ** Return a new SrcList which encodes is the FROM with the new
84145 ** term added.
84146 */
84147 SQLCIPHER_PRIVATE SrcList *sqlcipher3SrcListAppendFromTerm(
84148   Parse *pParse,          /* Parsing context */
84149   SrcList *p,             /* The left part of the FROM clause already seen */
84150   Token *pTable,          /* Name of the table to add to the FROM clause */
84151   Token *pDatabase,       /* Name of the database containing pTable */
84152   Token *pAlias,          /* The right-hand side of the AS subexpression */
84153   Select *pSubquery,      /* A subquery used in place of a table name */
84154   Expr *pOn,              /* The ON clause of a join */
84155   IdList *pUsing          /* The USING clause of a join */
84156 ){
84157   struct SrcList_item *pItem;
84158   sqlcipher3 *db = pParse->db;
84159   if( !p && (pOn || pUsing) ){
84160     sqlcipher3ErrorMsg(pParse, "a JOIN clause is required before %s", 
84161       (pOn ? "ON" : "USING")
84162     );
84163     goto append_from_error;
84164   }
84165   p = sqlcipher3SrcListAppend(db, p, pTable, pDatabase);
84166   if( p==0 || NEVER(p->nSrc==0) ){
84167     goto append_from_error;
84168   }
84169   pItem = &p->a[p->nSrc-1];
84170   assert( pAlias!=0 );
84171   if( pAlias->n ){
84172     pItem->zAlias = sqlcipher3NameFromToken(db, pAlias);
84173   }
84174   pItem->pSelect = pSubquery;
84175   pItem->pOn = pOn;
84176   pItem->pUsing = pUsing;
84177   return p;
84178
84179  append_from_error:
84180   assert( p==0 );
84181   sqlcipher3ExprDelete(db, pOn);
84182   sqlcipher3IdListDelete(db, pUsing);
84183   sqlcipher3SelectDelete(db, pSubquery);
84184   return 0;
84185 }
84186
84187 /*
84188 ** Add an INDEXED BY or NOT INDEXED clause to the most recently added 
84189 ** element of the source-list passed as the second argument.
84190 */
84191 SQLCIPHER_PRIVATE void sqlcipher3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
84192   assert( pIndexedBy!=0 );
84193   if( p && ALWAYS(p->nSrc>0) ){
84194     struct SrcList_item *pItem = &p->a[p->nSrc-1];
84195     assert( pItem->notIndexed==0 && pItem->zIndex==0 );
84196     if( pIndexedBy->n==1 && !pIndexedBy->z ){
84197       /* A "NOT INDEXED" clause was supplied. See parse.y 
84198       ** construct "indexed_opt" for details. */
84199       pItem->notIndexed = 1;
84200     }else{
84201       pItem->zIndex = sqlcipher3NameFromToken(pParse->db, pIndexedBy);
84202     }
84203   }
84204 }
84205
84206 /*
84207 ** When building up a FROM clause in the parser, the join operator
84208 ** is initially attached to the left operand.  But the code generator
84209 ** expects the join operator to be on the right operand.  This routine
84210 ** Shifts all join operators from left to right for an entire FROM
84211 ** clause.
84212 **
84213 ** Example: Suppose the join is like this:
84214 **
84215 **           A natural cross join B
84216 **
84217 ** The operator is "natural cross join".  The A and B operands are stored
84218 ** in p->a[0] and p->a[1], respectively.  The parser initially stores the
84219 ** operator with A.  This routine shifts that operator over to B.
84220 */
84221 SQLCIPHER_PRIVATE void sqlcipher3SrcListShiftJoinType(SrcList *p){
84222   if( p ){
84223     int i;
84224     assert( p->a || p->nSrc==0 );
84225     for(i=p->nSrc-1; i>0; i--){
84226       p->a[i].jointype = p->a[i-1].jointype;
84227     }
84228     p->a[0].jointype = 0;
84229   }
84230 }
84231
84232 /*
84233 ** Begin a transaction
84234 */
84235 SQLCIPHER_PRIVATE void sqlcipher3BeginTransaction(Parse *pParse, int type){
84236   sqlcipher3 *db;
84237   Vdbe *v;
84238   int i;
84239
84240   assert( pParse!=0 );
84241   db = pParse->db;
84242   assert( db!=0 );
84243 /*  if( db->aDb[0].pBt==0 ) return; */
84244   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_TRANSACTION, "BEGIN", 0, 0) ){
84245     return;
84246   }
84247   v = sqlcipher3GetVdbe(pParse);
84248   if( !v ) return;
84249   if( type!=TK_DEFERRED ){
84250     for(i=0; i<db->nDb; i++){
84251       sqlcipher3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
84252       sqlcipher3VdbeUsesBtree(v, i);
84253     }
84254   }
84255   sqlcipher3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
84256 }
84257
84258 /*
84259 ** Commit a transaction
84260 */
84261 SQLCIPHER_PRIVATE void sqlcipher3CommitTransaction(Parse *pParse){
84262   Vdbe *v;
84263
84264   assert( pParse!=0 );
84265   assert( pParse->db!=0 );
84266   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_TRANSACTION, "COMMIT", 0, 0) ){
84267     return;
84268   }
84269   v = sqlcipher3GetVdbe(pParse);
84270   if( v ){
84271     sqlcipher3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
84272   }
84273 }
84274
84275 /*
84276 ** Rollback a transaction
84277 */
84278 SQLCIPHER_PRIVATE void sqlcipher3RollbackTransaction(Parse *pParse){
84279   Vdbe *v;
84280
84281   assert( pParse!=0 );
84282   assert( pParse->db!=0 );
84283   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_TRANSACTION, "ROLLBACK", 0, 0) ){
84284     return;
84285   }
84286   v = sqlcipher3GetVdbe(pParse);
84287   if( v ){
84288     sqlcipher3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
84289   }
84290 }
84291
84292 /*
84293 ** This function is called by the parser when it parses a command to create,
84294 ** release or rollback an SQL savepoint. 
84295 */
84296 SQLCIPHER_PRIVATE void sqlcipher3Savepoint(Parse *pParse, int op, Token *pName){
84297   char *zName = sqlcipher3NameFromToken(pParse->db, pName);
84298   if( zName ){
84299     Vdbe *v = sqlcipher3GetVdbe(pParse);
84300 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
84301     static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
84302     assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
84303 #endif
84304     if( !v || sqlcipher3AuthCheck(pParse, SQLCIPHER_SAVEPOINT, az[op], zName, 0) ){
84305       sqlcipher3DbFree(pParse->db, zName);
84306       return;
84307     }
84308     sqlcipher3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
84309   }
84310 }
84311
84312 /*
84313 ** Make sure the TEMP database is open and available for use.  Return
84314 ** the number of errors.  Leave any error messages in the pParse structure.
84315 */
84316 SQLCIPHER_PRIVATE int sqlcipher3OpenTempDatabase(Parse *pParse){
84317   sqlcipher3 *db = pParse->db;
84318   if( db->aDb[1].pBt==0 && !pParse->explain ){
84319     int rc;
84320     Btree *pBt;
84321     static const int flags = 
84322           SQLCIPHER_OPEN_READWRITE |
84323           SQLCIPHER_OPEN_CREATE |
84324           SQLCIPHER_OPEN_EXCLUSIVE |
84325           SQLCIPHER_OPEN_DELETEONCLOSE |
84326           SQLCIPHER_OPEN_TEMP_DB;
84327
84328     rc = sqlcipher3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
84329     if( rc!=SQLCIPHER_OK ){
84330       sqlcipher3ErrorMsg(pParse, "unable to open a temporary database "
84331         "file for storing temporary tables");
84332       pParse->rc = rc;
84333       return 1;
84334     }
84335     db->aDb[1].pBt = pBt;
84336     assert( db->aDb[1].pSchema );
84337     if( SQLCIPHER_NOMEM==sqlcipher3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
84338       db->mallocFailed = 1;
84339       return 1;
84340     }
84341   }
84342   return 0;
84343 }
84344
84345 /*
84346 ** Generate VDBE code that will verify the schema cookie and start
84347 ** a read-transaction for all named database files.
84348 **
84349 ** It is important that all schema cookies be verified and all
84350 ** read transactions be started before anything else happens in
84351 ** the VDBE program.  But this routine can be called after much other
84352 ** code has been generated.  So here is what we do:
84353 **
84354 ** The first time this routine is called, we code an OP_Goto that
84355 ** will jump to a subroutine at the end of the program.  Then we
84356 ** record every database that needs its schema verified in the
84357 ** pParse->cookieMask field.  Later, after all other code has been
84358 ** generated, the subroutine that does the cookie verifications and
84359 ** starts the transactions will be coded and the OP_Goto P2 value
84360 ** will be made to point to that subroutine.  The generation of the
84361 ** cookie verification subroutine code happens in sqlcipher3FinishCoding().
84362 **
84363 ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
84364 ** schema on any databases.  This can be used to position the OP_Goto
84365 ** early in the code, before we know if any database tables will be used.
84366 */
84367 SQLCIPHER_PRIVATE void sqlcipher3CodeVerifySchema(Parse *pParse, int iDb){
84368   Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
84369
84370   if( pToplevel->cookieGoto==0 ){
84371     Vdbe *v = sqlcipher3GetVdbe(pToplevel);
84372     if( v==0 ) return;  /* This only happens if there was a prior error */
84373     pToplevel->cookieGoto = sqlcipher3VdbeAddOp2(v, OP_Goto, 0, 0)+1;
84374   }
84375   if( iDb>=0 ){
84376     sqlcipher3 *db = pToplevel->db;
84377     yDbMask mask;
84378
84379     assert( iDb<db->nDb );
84380     assert( db->aDb[iDb].pBt!=0 || iDb==1 );
84381     assert( iDb<SQLCIPHER_MAX_ATTACHED+2 );
84382     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
84383     mask = ((yDbMask)1)<<iDb;
84384     if( (pToplevel->cookieMask & mask)==0 ){
84385       pToplevel->cookieMask |= mask;
84386       pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
84387       if( !OMIT_TEMPDB && iDb==1 ){
84388         sqlcipher3OpenTempDatabase(pToplevel);
84389       }
84390     }
84391   }
84392 }
84393
84394 /*
84395 ** If argument zDb is NULL, then call sqlcipher3CodeVerifySchema() for each 
84396 ** attached database. Otherwise, invoke it for the database named zDb only.
84397 */
84398 SQLCIPHER_PRIVATE void sqlcipher3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
84399   sqlcipher3 *db = pParse->db;
84400   int i;
84401   for(i=0; i<db->nDb; i++){
84402     Db *pDb = &db->aDb[i];
84403     if( pDb->pBt && (!zDb || 0==sqlcipher3StrICmp(zDb, pDb->zName)) ){
84404       sqlcipher3CodeVerifySchema(pParse, i);
84405     }
84406   }
84407 }
84408
84409 /*
84410 ** Generate VDBE code that prepares for doing an operation that
84411 ** might change the database.
84412 **
84413 ** This routine starts a new transaction if we are not already within
84414 ** a transaction.  If we are already within a transaction, then a checkpoint
84415 ** is set if the setStatement parameter is true.  A checkpoint should
84416 ** be set for operations that might fail (due to a constraint) part of
84417 ** the way through and which will need to undo some writes without having to
84418 ** rollback the whole transaction.  For operations where all constraints
84419 ** can be checked before any changes are made to the database, it is never
84420 ** necessary to undo a write and the checkpoint should not be set.
84421 */
84422 SQLCIPHER_PRIVATE void sqlcipher3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
84423   Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
84424   sqlcipher3CodeVerifySchema(pParse, iDb);
84425   pToplevel->writeMask |= ((yDbMask)1)<<iDb;
84426   pToplevel->isMultiWrite |= setStatement;
84427 }
84428
84429 /*
84430 ** Indicate that the statement currently under construction might write
84431 ** more than one entry (example: deleting one row then inserting another,
84432 ** inserting multiple rows in a table, or inserting a row and index entries.)
84433 ** If an abort occurs after some of these writes have completed, then it will
84434 ** be necessary to undo the completed writes.
84435 */
84436 SQLCIPHER_PRIVATE void sqlcipher3MultiWrite(Parse *pParse){
84437   Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
84438   pToplevel->isMultiWrite = 1;
84439 }
84440
84441 /* 
84442 ** The code generator calls this routine if is discovers that it is
84443 ** possible to abort a statement prior to completion.  In order to 
84444 ** perform this abort without corrupting the database, we need to make
84445 ** sure that the statement is protected by a statement transaction.
84446 **
84447 ** Technically, we only need to set the mayAbort flag if the
84448 ** isMultiWrite flag was previously set.  There is a time dependency
84449 ** such that the abort must occur after the multiwrite.  This makes
84450 ** some statements involving the REPLACE conflict resolution algorithm
84451 ** go a little faster.  But taking advantage of this time dependency
84452 ** makes it more difficult to prove that the code is correct (in 
84453 ** particular, it prevents us from writing an effective
84454 ** implementation of sqlcipher3AssertMayAbort()) and so we have chosen
84455 ** to take the safe route and skip the optimization.
84456 */
84457 SQLCIPHER_PRIVATE void sqlcipher3MayAbort(Parse *pParse){
84458   Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
84459   pToplevel->mayAbort = 1;
84460 }
84461
84462 /*
84463 ** Code an OP_Halt that causes the vdbe to return an SQLCIPHER_CONSTRAINT
84464 ** error. The onError parameter determines which (if any) of the statement
84465 ** and/or current transaction is rolled back.
84466 */
84467 SQLCIPHER_PRIVATE void sqlcipher3HaltConstraint(Parse *pParse, int onError, char *p4, int p4type){
84468   Vdbe *v = sqlcipher3GetVdbe(pParse);
84469   if( onError==OE_Abort ){
84470     sqlcipher3MayAbort(pParse);
84471   }
84472   sqlcipher3VdbeAddOp4(v, OP_Halt, SQLCIPHER_CONSTRAINT, onError, 0, p4, p4type);
84473 }
84474
84475 /*
84476 ** Check to see if pIndex uses the collating sequence pColl.  Return
84477 ** true if it does and false if it does not.
84478 */
84479 #ifndef SQLCIPHER_OMIT_REINDEX
84480 static int collationMatch(const char *zColl, Index *pIndex){
84481   int i;
84482   assert( zColl!=0 );
84483   for(i=0; i<pIndex->nColumn; i++){
84484     const char *z = pIndex->azColl[i];
84485     assert( z!=0 );
84486     if( 0==sqlcipher3StrICmp(z, zColl) ){
84487       return 1;
84488     }
84489   }
84490   return 0;
84491 }
84492 #endif
84493
84494 /*
84495 ** Recompute all indices of pTab that use the collating sequence pColl.
84496 ** If pColl==0 then recompute all indices of pTab.
84497 */
84498 #ifndef SQLCIPHER_OMIT_REINDEX
84499 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
84500   Index *pIndex;              /* An index associated with pTab */
84501
84502   for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
84503     if( zColl==0 || collationMatch(zColl, pIndex) ){
84504       int iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
84505       sqlcipher3BeginWriteOperation(pParse, 0, iDb);
84506       sqlcipher3RefillIndex(pParse, pIndex, -1);
84507     }
84508   }
84509 }
84510 #endif
84511
84512 /*
84513 ** Recompute all indices of all tables in all databases where the
84514 ** indices use the collating sequence pColl.  If pColl==0 then recompute
84515 ** all indices everywhere.
84516 */
84517 #ifndef SQLCIPHER_OMIT_REINDEX
84518 static void reindexDatabases(Parse *pParse, char const *zColl){
84519   Db *pDb;                    /* A single database */
84520   int iDb;                    /* The database index number */
84521   sqlcipher3 *db = pParse->db;   /* The database connection */
84522   HashElem *k;                /* For looping over tables in pDb */
84523   Table *pTab;                /* A table in the database */
84524
84525   assert( sqlcipher3BtreeHoldsAllMutexes(db) );  /* Needed for schema access */
84526   for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
84527     assert( pDb!=0 );
84528     for(k=sqlcipherHashFirst(&pDb->pSchema->tblHash);  k; k=sqlcipherHashNext(k)){
84529       pTab = (Table*)sqlcipherHashData(k);
84530       reindexTable(pParse, pTab, zColl);
84531     }
84532   }
84533 }
84534 #endif
84535
84536 /*
84537 ** Generate code for the REINDEX command.
84538 **
84539 **        REINDEX                            -- 1
84540 **        REINDEX  <collation>               -- 2
84541 **        REINDEX  ?<database>.?<tablename>  -- 3
84542 **        REINDEX  ?<database>.?<indexname>  -- 4
84543 **
84544 ** Form 1 causes all indices in all attached databases to be rebuilt.
84545 ** Form 2 rebuilds all indices in all databases that use the named
84546 ** collating function.  Forms 3 and 4 rebuild the named index or all
84547 ** indices associated with the named table.
84548 */
84549 #ifndef SQLCIPHER_OMIT_REINDEX
84550 SQLCIPHER_PRIVATE void sqlcipher3Reindex(Parse *pParse, Token *pName1, Token *pName2){
84551   CollSeq *pColl;             /* Collating sequence to be reindexed, or NULL */
84552   char *z;                    /* Name of a table or index */
84553   const char *zDb;            /* Name of the database */
84554   Table *pTab;                /* A table in the database */
84555   Index *pIndex;              /* An index associated with pTab */
84556   int iDb;                    /* The database index number */
84557   sqlcipher3 *db = pParse->db;   /* The database connection */
84558   Token *pObjName;            /* Name of the table or index to be reindexed */
84559
84560   /* Read the database schema. If an error occurs, leave an error message
84561   ** and code in pParse and return NULL. */
84562   if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
84563     return;
84564   }
84565
84566   if( pName1==0 ){
84567     reindexDatabases(pParse, 0);
84568     return;
84569   }else if( NEVER(pName2==0) || pName2->z==0 ){
84570     char *zColl;
84571     assert( pName1->z );
84572     zColl = sqlcipher3NameFromToken(pParse->db, pName1);
84573     if( !zColl ) return;
84574     pColl = sqlcipher3FindCollSeq(db, ENC(db), zColl, 0);
84575     if( pColl ){
84576       reindexDatabases(pParse, zColl);
84577       sqlcipher3DbFree(db, zColl);
84578       return;
84579     }
84580     sqlcipher3DbFree(db, zColl);
84581   }
84582   iDb = sqlcipher3TwoPartName(pParse, pName1, pName2, &pObjName);
84583   if( iDb<0 ) return;
84584   z = sqlcipher3NameFromToken(db, pObjName);
84585   if( z==0 ) return;
84586   zDb = db->aDb[iDb].zName;
84587   pTab = sqlcipher3FindTable(db, z, zDb);
84588   if( pTab ){
84589     reindexTable(pParse, pTab, 0);
84590     sqlcipher3DbFree(db, z);
84591     return;
84592   }
84593   pIndex = sqlcipher3FindIndex(db, z, zDb);
84594   sqlcipher3DbFree(db, z);
84595   if( pIndex ){
84596     sqlcipher3BeginWriteOperation(pParse, 0, iDb);
84597     sqlcipher3RefillIndex(pParse, pIndex, -1);
84598     return;
84599   }
84600   sqlcipher3ErrorMsg(pParse, "unable to identify the object to be reindexed");
84601 }
84602 #endif
84603
84604 /*
84605 ** Return a dynamicly allocated KeyInfo structure that can be used
84606 ** with OP_OpenRead or OP_OpenWrite to access database index pIdx.
84607 **
84608 ** If successful, a pointer to the new structure is returned. In this case
84609 ** the caller is responsible for calling sqlcipher3DbFree(db, ) on the returned 
84610 ** pointer. If an error occurs (out of memory or missing collation 
84611 ** sequence), NULL is returned and the state of pParse updated to reflect
84612 ** the error.
84613 */
84614 SQLCIPHER_PRIVATE KeyInfo *sqlcipher3IndexKeyinfo(Parse *pParse, Index *pIdx){
84615   int i;
84616   int nCol = pIdx->nColumn;
84617   int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
84618   sqlcipher3 *db = pParse->db;
84619   KeyInfo *pKey = (KeyInfo *)sqlcipher3DbMallocZero(db, nBytes);
84620
84621   if( pKey ){
84622     pKey->db = pParse->db;
84623     pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
84624     assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
84625     for(i=0; i<nCol; i++){
84626       char *zColl = pIdx->azColl[i];
84627       assert( zColl );
84628       pKey->aColl[i] = sqlcipher3LocateCollSeq(pParse, zColl);
84629       pKey->aSortOrder[i] = pIdx->aSortOrder[i];
84630     }
84631     pKey->nField = (u16)nCol;
84632   }
84633
84634   if( pParse->nErr ){
84635     sqlcipher3DbFree(db, pKey);
84636     pKey = 0;
84637   }
84638   return pKey;
84639 }
84640
84641 /************** End of build.c ***********************************************/
84642 /************** Begin file callback.c ****************************************/
84643 /*
84644 ** 2005 May 23 
84645 **
84646 ** The author disclaims copyright to this source code.  In place of
84647 ** a legal notice, here is a blessing:
84648 **
84649 **    May you do good and not evil.
84650 **    May you find forgiveness for yourself and forgive others.
84651 **    May you share freely, never taking more than you give.
84652 **
84653 *************************************************************************
84654 **
84655 ** This file contains functions used to access the internal hash tables
84656 ** of user defined functions and collation sequences.
84657 */
84658
84659
84660 /*
84661 ** Invoke the 'collation needed' callback to request a collation sequence
84662 ** in the encoding enc of name zName, length nName.
84663 */
84664 static void callCollNeeded(sqlcipher3 *db, int enc, const char *zName){
84665   assert( !db->xCollNeeded || !db->xCollNeeded16 );
84666   if( db->xCollNeeded ){
84667     char *zExternal = sqlcipher3DbStrDup(db, zName);
84668     if( !zExternal ) return;
84669     db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
84670     sqlcipher3DbFree(db, zExternal);
84671   }
84672 #ifndef SQLCIPHER_OMIT_UTF16
84673   if( db->xCollNeeded16 ){
84674     char const *zExternal;
84675     sqlcipher3_value *pTmp = sqlcipher3ValueNew(db);
84676     sqlcipher3ValueSetStr(pTmp, -1, zName, SQLCIPHER_UTF8, SQLCIPHER_STATIC);
84677     zExternal = sqlcipher3ValueText(pTmp, SQLCIPHER_UTF16NATIVE);
84678     if( zExternal ){
84679       db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
84680     }
84681     sqlcipher3ValueFree(pTmp);
84682   }
84683 #endif
84684 }
84685
84686 /*
84687 ** This routine is called if the collation factory fails to deliver a
84688 ** collation function in the best encoding but there may be other versions
84689 ** of this collation function (for other text encodings) available. Use one
84690 ** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if
84691 ** possible.
84692 */
84693 static int synthCollSeq(sqlcipher3 *db, CollSeq *pColl){
84694   CollSeq *pColl2;
84695   char *z = pColl->zName;
84696   int i;
84697   static const u8 aEnc[] = { SQLCIPHER_UTF16BE, SQLCIPHER_UTF16LE, SQLCIPHER_UTF8 };
84698   for(i=0; i<3; i++){
84699     pColl2 = sqlcipher3FindCollSeq(db, aEnc[i], z, 0);
84700     if( pColl2->xCmp!=0 ){
84701       memcpy(pColl, pColl2, sizeof(CollSeq));
84702       pColl->xDel = 0;         /* Do not copy the destructor */
84703       return SQLCIPHER_OK;
84704     }
84705   }
84706   return SQLCIPHER_ERROR;
84707 }
84708
84709 /*
84710 ** This function is responsible for invoking the collation factory callback
84711 ** or substituting a collation sequence of a different encoding when the
84712 ** requested collation sequence is not available in the desired encoding.
84713 ** 
84714 ** If it is not NULL, then pColl must point to the database native encoding 
84715 ** collation sequence with name zName, length nName.
84716 **
84717 ** The return value is either the collation sequence to be used in database
84718 ** db for collation type name zName, length nName, or NULL, if no collation
84719 ** sequence can be found.
84720 **
84721 ** See also: sqlcipher3LocateCollSeq(), sqlcipher3FindCollSeq()
84722 */
84723 SQLCIPHER_PRIVATE CollSeq *sqlcipher3GetCollSeq(
84724   sqlcipher3* db,          /* The database connection */
84725   u8 enc,               /* The desired encoding for the collating sequence */
84726   CollSeq *pColl,       /* Collating sequence with native encoding, or NULL */
84727   const char *zName     /* Collating sequence name */
84728 ){
84729   CollSeq *p;
84730
84731   p = pColl;
84732   if( !p ){
84733     p = sqlcipher3FindCollSeq(db, enc, zName, 0);
84734   }
84735   if( !p || !p->xCmp ){
84736     /* No collation sequence of this type for this encoding is registered.
84737     ** Call the collation factory to see if it can supply us with one.
84738     */
84739     callCollNeeded(db, enc, zName);
84740     p = sqlcipher3FindCollSeq(db, enc, zName, 0);
84741   }
84742   if( p && !p->xCmp && synthCollSeq(db, p) ){
84743     p = 0;
84744   }
84745   assert( !p || p->xCmp );
84746   return p;
84747 }
84748
84749 /*
84750 ** This routine is called on a collation sequence before it is used to
84751 ** check that it is defined. An undefined collation sequence exists when
84752 ** a database is loaded that contains references to collation sequences
84753 ** that have not been defined by sqlcipher3_create_collation() etc.
84754 **
84755 ** If required, this routine calls the 'collation needed' callback to
84756 ** request a definition of the collating sequence. If this doesn't work, 
84757 ** an equivalent collating sequence that uses a text encoding different
84758 ** from the main database is substituted, if one is available.
84759 */
84760 SQLCIPHER_PRIVATE int sqlcipher3CheckCollSeq(Parse *pParse, CollSeq *pColl){
84761   if( pColl ){
84762     const char *zName = pColl->zName;
84763     sqlcipher3 *db = pParse->db;
84764     CollSeq *p = sqlcipher3GetCollSeq(db, ENC(db), pColl, zName);
84765     if( !p ){
84766       sqlcipher3ErrorMsg(pParse, "no such collation sequence: %s", zName);
84767       pParse->nErr++;
84768       return SQLCIPHER_ERROR;
84769     }
84770     assert( p==pColl );
84771   }
84772   return SQLCIPHER_OK;
84773 }
84774
84775
84776
84777 /*
84778 ** Locate and return an entry from the db.aCollSeq hash table. If the entry
84779 ** specified by zName and nName is not found and parameter 'create' is
84780 ** true, then create a new entry. Otherwise return NULL.
84781 **
84782 ** Each pointer stored in the sqlcipher3.aCollSeq hash table contains an
84783 ** array of three CollSeq structures. The first is the collation sequence
84784 ** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be.
84785 **
84786 ** Stored immediately after the three collation sequences is a copy of
84787 ** the collation sequence name. A pointer to this string is stored in
84788 ** each collation sequence structure.
84789 */
84790 static CollSeq *findCollSeqEntry(
84791   sqlcipher3 *db,          /* Database connection */
84792   const char *zName,    /* Name of the collating sequence */
84793   int create            /* Create a new entry if true */
84794 ){
84795   CollSeq *pColl;
84796   int nName = sqlcipher3Strlen30(zName);
84797   pColl = sqlcipher3HashFind(&db->aCollSeq, zName, nName);
84798
84799   if( 0==pColl && create ){
84800     pColl = sqlcipher3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );
84801     if( pColl ){
84802       CollSeq *pDel = 0;
84803       pColl[0].zName = (char*)&pColl[3];
84804       pColl[0].enc = SQLCIPHER_UTF8;
84805       pColl[1].zName = (char*)&pColl[3];
84806       pColl[1].enc = SQLCIPHER_UTF16LE;
84807       pColl[2].zName = (char*)&pColl[3];
84808       pColl[2].enc = SQLCIPHER_UTF16BE;
84809       memcpy(pColl[0].zName, zName, nName);
84810       pColl[0].zName[nName] = 0;
84811       pDel = sqlcipher3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
84812
84813       /* If a malloc() failure occurred in sqlcipher3HashInsert(), it will 
84814       ** return the pColl pointer to be deleted (because it wasn't added
84815       ** to the hash table).
84816       */
84817       assert( pDel==0 || pDel==pColl );
84818       if( pDel!=0 ){
84819         db->mallocFailed = 1;
84820         sqlcipher3DbFree(db, pDel);
84821         pColl = 0;
84822       }
84823     }
84824   }
84825   return pColl;
84826 }
84827
84828 /*
84829 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
84830 ** Return the CollSeq* pointer for the collation sequence named zName
84831 ** for the encoding 'enc' from the database 'db'.
84832 **
84833 ** If the entry specified is not found and 'create' is true, then create a
84834 ** new entry.  Otherwise return NULL.
84835 **
84836 ** A separate function sqlcipher3LocateCollSeq() is a wrapper around
84837 ** this routine.  sqlcipher3LocateCollSeq() invokes the collation factory
84838 ** if necessary and generates an error message if the collating sequence
84839 ** cannot be found.
84840 **
84841 ** See also: sqlcipher3LocateCollSeq(), sqlcipher3GetCollSeq()
84842 */
84843 SQLCIPHER_PRIVATE CollSeq *sqlcipher3FindCollSeq(
84844   sqlcipher3 *db,
84845   u8 enc,
84846   const char *zName,
84847   int create
84848 ){
84849   CollSeq *pColl;
84850   if( zName ){
84851     pColl = findCollSeqEntry(db, zName, create);
84852   }else{
84853     pColl = db->pDfltColl;
84854   }
84855   assert( SQLCIPHER_UTF8==1 && SQLCIPHER_UTF16LE==2 && SQLCIPHER_UTF16BE==3 );
84856   assert( enc>=SQLCIPHER_UTF8 && enc<=SQLCIPHER_UTF16BE );
84857   if( pColl ) pColl += enc-1;
84858   return pColl;
84859 }
84860
84861 /* During the search for the best function definition, this procedure
84862 ** is called to test how well the function passed as the first argument
84863 ** matches the request for a function with nArg arguments in a system
84864 ** that uses encoding enc. The value returned indicates how well the
84865 ** request is matched. A higher value indicates a better match.
84866 **
84867 ** The returned value is always between 0 and 6, as follows:
84868 **
84869 ** 0: Not a match, or if nArg<0 and the function is has no implementation.
84870 ** 1: A variable arguments function that prefers UTF-8 when a UTF-16
84871 **    encoding is requested, or vice versa.
84872 ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is
84873 **    requested, or vice versa.
84874 ** 3: A variable arguments function using the same text encoding.
84875 ** 4: A function with the exact number of arguments requested that
84876 **    prefers UTF-8 when a UTF-16 encoding is requested, or vice versa.
84877 ** 5: A function with the exact number of arguments requested that
84878 **    prefers UTF-16LE when UTF-16BE is requested, or vice versa.
84879 ** 6: An exact match.
84880 **
84881 */
84882 static int matchQuality(FuncDef *p, int nArg, u8 enc){
84883   int match = 0;
84884   if( p->nArg==-1 || p->nArg==nArg 
84885    || (nArg==-1 && (p->xFunc!=0 || p->xStep!=0))
84886   ){
84887     match = 1;
84888     if( p->nArg==nArg || nArg==-1 ){
84889       match = 4;
84890     }
84891     if( enc==p->iPrefEnc ){
84892       match += 2;
84893     }
84894     else if( (enc==SQLCIPHER_UTF16LE && p->iPrefEnc==SQLCIPHER_UTF16BE) ||
84895              (enc==SQLCIPHER_UTF16BE && p->iPrefEnc==SQLCIPHER_UTF16LE) ){
84896       match += 1;
84897     }
84898   }
84899   return match;
84900 }
84901
84902 /*
84903 ** Search a FuncDefHash for a function with the given name.  Return
84904 ** a pointer to the matching FuncDef if found, or 0 if there is no match.
84905 */
84906 static FuncDef *functionSearch(
84907   FuncDefHash *pHash,  /* Hash table to search */
84908   int h,               /* Hash of the name */
84909   const char *zFunc,   /* Name of function */
84910   int nFunc            /* Number of bytes in zFunc */
84911 ){
84912   FuncDef *p;
84913   for(p=pHash->a[h]; p; p=p->pHash){
84914     if( sqlcipher3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
84915       return p;
84916     }
84917   }
84918   return 0;
84919 }
84920
84921 /*
84922 ** Insert a new FuncDef into a FuncDefHash hash table.
84923 */
84924 SQLCIPHER_PRIVATE void sqlcipher3FuncDefInsert(
84925   FuncDefHash *pHash,  /* The hash table into which to insert */
84926   FuncDef *pDef        /* The function definition to insert */
84927 ){
84928   FuncDef *pOther;
84929   int nName = sqlcipher3Strlen30(pDef->zName);
84930   u8 c1 = (u8)pDef->zName[0];
84931   int h = (sqlcipher3UpperToLower[c1] + nName) % ArraySize(pHash->a);
84932   pOther = functionSearch(pHash, h, pDef->zName, nName);
84933   if( pOther ){
84934     assert( pOther!=pDef && pOther->pNext!=pDef );
84935     pDef->pNext = pOther->pNext;
84936     pOther->pNext = pDef;
84937   }else{
84938     pDef->pNext = 0;
84939     pDef->pHash = pHash->a[h];
84940     pHash->a[h] = pDef;
84941   }
84942 }
84943   
84944   
84945
84946 /*
84947 ** Locate a user function given a name, a number of arguments and a flag
84948 ** indicating whether the function prefers UTF-16 over UTF-8.  Return a
84949 ** pointer to the FuncDef structure that defines that function, or return
84950 ** NULL if the function does not exist.
84951 **
84952 ** If the createFlag argument is true, then a new (blank) FuncDef
84953 ** structure is created and liked into the "db" structure if a
84954 ** no matching function previously existed.  When createFlag is true
84955 ** and the nArg parameter is -1, then only a function that accepts
84956 ** any number of arguments will be returned.
84957 **
84958 ** If createFlag is false and nArg is -1, then the first valid
84959 ** function found is returned.  A function is valid if either xFunc
84960 ** or xStep is non-zero.
84961 **
84962 ** If createFlag is false, then a function with the required name and
84963 ** number of arguments may be returned even if the eTextRep flag does not
84964 ** match that requested.
84965 */
84966 SQLCIPHER_PRIVATE FuncDef *sqlcipher3FindFunction(
84967   sqlcipher3 *db,       /* An open database */
84968   const char *zName, /* Name of the function.  Not null-terminated */
84969   int nName,         /* Number of characters in the name */
84970   int nArg,          /* Number of arguments.  -1 means any number */
84971   u8 enc,            /* Preferred text encoding */
84972   int createFlag     /* Create new entry if true and does not otherwise exist */
84973 ){
84974   FuncDef *p;         /* Iterator variable */
84975   FuncDef *pBest = 0; /* Best match found so far */
84976   int bestScore = 0;  /* Score of best match */
84977   int h;              /* Hash value */
84978
84979
84980   assert( enc==SQLCIPHER_UTF8 || enc==SQLCIPHER_UTF16LE || enc==SQLCIPHER_UTF16BE );
84981   h = (sqlcipher3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
84982
84983   /* First search for a match amongst the application-defined functions.
84984   */
84985   p = functionSearch(&db->aFunc, h, zName, nName);
84986   while( p ){
84987     int score = matchQuality(p, nArg, enc);
84988     if( score>bestScore ){
84989       pBest = p;
84990       bestScore = score;
84991     }
84992     p = p->pNext;
84993   }
84994
84995   /* If no match is found, search the built-in functions.
84996   **
84997   ** If the SQLCIPHER_PreferBuiltin flag is set, then search the built-in
84998   ** functions even if a prior app-defined function was found.  And give
84999   ** priority to built-in functions.
85000   **
85001   ** Except, if createFlag is true, that means that we are trying to
85002   ** install a new function.  Whatever FuncDef structure is returned it will
85003   ** have fields overwritten with new information appropriate for the
85004   ** new function.  But the FuncDefs for built-in functions are read-only.
85005   ** So we must not search for built-ins when creating a new function.
85006   */ 
85007   if( !createFlag && (pBest==0 || (db->flags & SQLCIPHER_PreferBuiltin)!=0) ){
85008     FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlcipher3GlobalFunctions);
85009     bestScore = 0;
85010     p = functionSearch(pHash, h, zName, nName);
85011     while( p ){
85012       int score = matchQuality(p, nArg, enc);
85013       if( score>bestScore ){
85014         pBest = p;
85015         bestScore = score;
85016       }
85017       p = p->pNext;
85018     }
85019   }
85020
85021   /* If the createFlag parameter is true and the search did not reveal an
85022   ** exact match for the name, number of arguments and encoding, then add a
85023   ** new entry to the hash table and return it.
85024   */
85025   if( createFlag && (bestScore<6 || pBest->nArg!=nArg) && 
85026       (pBest = sqlcipher3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
85027     pBest->zName = (char *)&pBest[1];
85028     pBest->nArg = (u16)nArg;
85029     pBest->iPrefEnc = enc;
85030     memcpy(pBest->zName, zName, nName);
85031     pBest->zName[nName] = 0;
85032     sqlcipher3FuncDefInsert(&db->aFunc, pBest);
85033   }
85034
85035   if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
85036     return pBest;
85037   }
85038   return 0;
85039 }
85040
85041 /*
85042 ** Free all resources held by the schema structure. The void* argument points
85043 ** at a Schema struct. This function does not call sqlcipher3DbFree(db, ) on the 
85044 ** pointer itself, it just cleans up subsidiary resources (i.e. the contents
85045 ** of the schema hash tables).
85046 **
85047 ** The Schema.cache_size variable is not cleared.
85048 */
85049 SQLCIPHER_PRIVATE void sqlcipher3SchemaClear(void *p){
85050   Hash temp1;
85051   Hash temp2;
85052   HashElem *pElem;
85053   Schema *pSchema = (Schema *)p;
85054
85055   temp1 = pSchema->tblHash;
85056   temp2 = pSchema->trigHash;
85057   sqlcipher3HashInit(&pSchema->trigHash);
85058   sqlcipher3HashClear(&pSchema->idxHash);
85059   for(pElem=sqlcipherHashFirst(&temp2); pElem; pElem=sqlcipherHashNext(pElem)){
85060     sqlcipher3DeleteTrigger(0, (Trigger*)sqlcipherHashData(pElem));
85061   }
85062   sqlcipher3HashClear(&temp2);
85063   sqlcipher3HashInit(&pSchema->tblHash);
85064   for(pElem=sqlcipherHashFirst(&temp1); pElem; pElem=sqlcipherHashNext(pElem)){
85065     Table *pTab = sqlcipherHashData(pElem);
85066     sqlcipher3DeleteTable(0, pTab);
85067   }
85068   sqlcipher3HashClear(&temp1);
85069   sqlcipher3HashClear(&pSchema->fkeyHash);
85070   pSchema->pSeqTab = 0;
85071   if( pSchema->flags & DB_SchemaLoaded ){
85072     pSchema->iGeneration++;
85073     pSchema->flags &= ~DB_SchemaLoaded;
85074   }
85075 }
85076
85077 /*
85078 ** Find and return the schema associated with a BTree.  Create
85079 ** a new one if necessary.
85080 */
85081 SQLCIPHER_PRIVATE Schema *sqlcipher3SchemaGet(sqlcipher3 *db, Btree *pBt){
85082   Schema * p;
85083   if( pBt ){
85084     p = (Schema *)sqlcipher3BtreeSchema(pBt, sizeof(Schema), sqlcipher3SchemaClear);
85085   }else{
85086     p = (Schema *)sqlcipher3DbMallocZero(0, sizeof(Schema));
85087   }
85088   if( !p ){
85089     db->mallocFailed = 1;
85090   }else if ( 0==p->file_format ){
85091     sqlcipher3HashInit(&p->tblHash);
85092     sqlcipher3HashInit(&p->idxHash);
85093     sqlcipher3HashInit(&p->trigHash);
85094     sqlcipher3HashInit(&p->fkeyHash);
85095     p->enc = SQLCIPHER_UTF8;
85096   }
85097   return p;
85098 }
85099
85100 /************** End of callback.c ********************************************/
85101 /************** Begin file delete.c ******************************************/
85102 /*
85103 ** 2001 September 15
85104 **
85105 ** The author disclaims copyright to this source code.  In place of
85106 ** a legal notice, here is a blessing:
85107 **
85108 **    May you do good and not evil.
85109 **    May you find forgiveness for yourself and forgive others.
85110 **    May you share freely, never taking more than you give.
85111 **
85112 *************************************************************************
85113 ** This file contains C code routines that are called by the parser
85114 ** in order to generate code for DELETE FROM statements.
85115 */
85116
85117 /*
85118 ** While a SrcList can in general represent multiple tables and subqueries
85119 ** (as in the FROM clause of a SELECT statement) in this case it contains
85120 ** the name of a single table, as one might find in an INSERT, DELETE,
85121 ** or UPDATE statement.  Look up that table in the symbol table and
85122 ** return a pointer.  Set an error message and return NULL if the table 
85123 ** name is not found or if any other error occurs.
85124 **
85125 ** The following fields are initialized appropriate in pSrc:
85126 **
85127 **    pSrc->a[0].pTab       Pointer to the Table object
85128 **    pSrc->a[0].pIndex     Pointer to the INDEXED BY index, if there is one
85129 **
85130 */
85131 SQLCIPHER_PRIVATE Table *sqlcipher3SrcListLookup(Parse *pParse, SrcList *pSrc){
85132   struct SrcList_item *pItem = pSrc->a;
85133   Table *pTab;
85134   assert( pItem && pSrc->nSrc==1 );
85135   pTab = sqlcipher3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
85136   sqlcipher3DeleteTable(pParse->db, pItem->pTab);
85137   pItem->pTab = pTab;
85138   if( pTab ){
85139     pTab->nRef++;
85140   }
85141   if( sqlcipher3IndexedByLookup(pParse, pItem) ){
85142     pTab = 0;
85143   }
85144   return pTab;
85145 }
85146
85147 /*
85148 ** Check to make sure the given table is writable.  If it is not
85149 ** writable, generate an error message and return 1.  If it is
85150 ** writable return 0;
85151 */
85152 SQLCIPHER_PRIVATE int sqlcipher3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
85153   /* A table is not writable under the following circumstances:
85154   **
85155   **   1) It is a virtual table and no implementation of the xUpdate method
85156   **      has been provided, or
85157   **   2) It is a system table (i.e. sqlcipher_master), this call is not
85158   **      part of a nested parse and writable_schema pragma has not 
85159   **      been specified.
85160   **
85161   ** In either case leave an error message in pParse and return non-zero.
85162   */
85163   if( ( IsVirtual(pTab) 
85164      && sqlcipher3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
85165    || ( (pTab->tabFlags & TF_Readonly)!=0
85166      && (pParse->db->flags & SQLCIPHER_WriteSchema)==0
85167      && pParse->nested==0 )
85168   ){
85169     sqlcipher3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
85170     return 1;
85171   }
85172
85173 #ifndef SQLCIPHER_OMIT_VIEW
85174   if( !viewOk && pTab->pSelect ){
85175     sqlcipher3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
85176     return 1;
85177   }
85178 #endif
85179   return 0;
85180 }
85181
85182
85183 #if !defined(SQLCIPHER_OMIT_VIEW) && !defined(SQLCIPHER_OMIT_TRIGGER)
85184 /*
85185 ** Evaluate a view and store its result in an ephemeral table.  The
85186 ** pWhere argument is an optional WHERE clause that restricts the
85187 ** set of rows in the view that are to be added to the ephemeral table.
85188 */
85189 SQLCIPHER_PRIVATE void sqlcipher3MaterializeView(
85190   Parse *pParse,       /* Parsing context */
85191   Table *pView,        /* View definition */
85192   Expr *pWhere,        /* Optional WHERE clause to be added */
85193   int iCur             /* Cursor number for ephemerial table */
85194 ){
85195   SelectDest dest;
85196   Select *pDup;
85197   sqlcipher3 *db = pParse->db;
85198
85199   pDup = sqlcipher3SelectDup(db, pView->pSelect, 0);
85200   if( pWhere ){
85201     SrcList *pFrom;
85202     
85203     pWhere = sqlcipher3ExprDup(db, pWhere, 0);
85204     pFrom = sqlcipher3SrcListAppend(db, 0, 0, 0);
85205     if( pFrom ){
85206       assert( pFrom->nSrc==1 );
85207       pFrom->a[0].zAlias = sqlcipher3DbStrDup(db, pView->zName);
85208       pFrom->a[0].pSelect = pDup;
85209       assert( pFrom->a[0].pOn==0 );
85210       assert( pFrom->a[0].pUsing==0 );
85211     }else{
85212       sqlcipher3SelectDelete(db, pDup);
85213     }
85214     pDup = sqlcipher3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
85215   }
85216   sqlcipher3SelectDestInit(&dest, SRT_EphemTab, iCur);
85217   sqlcipher3Select(pParse, pDup, &dest);
85218   sqlcipher3SelectDelete(db, pDup);
85219 }
85220 #endif /* !defined(SQLCIPHER_OMIT_VIEW) && !defined(SQLCIPHER_OMIT_TRIGGER) */
85221
85222 #if defined(SQLCIPHER_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLCIPHER_OMIT_SUBQUERY)
85223 /*
85224 ** Generate an expression tree to implement the WHERE, ORDER BY,
85225 ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
85226 **
85227 **     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
85228 **                            \__________________________/
85229 **                               pLimitWhere (pInClause)
85230 */
85231 SQLCIPHER_PRIVATE Expr *sqlcipher3LimitWhere(
85232   Parse *pParse,               /* The parser context */
85233   SrcList *pSrc,               /* the FROM clause -- which tables to scan */
85234   Expr *pWhere,                /* The WHERE clause.  May be null */
85235   ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */
85236   Expr *pLimit,                /* The LIMIT clause.  May be null */
85237   Expr *pOffset,               /* The OFFSET clause.  May be null */
85238   char *zStmtType              /* Either DELETE or UPDATE.  For error messages. */
85239 ){
85240   Expr *pWhereRowid = NULL;    /* WHERE rowid .. */
85241   Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */
85242   Expr *pSelectRowid = NULL;   /* SELECT rowid ... */
85243   ExprList *pEList = NULL;     /* Expression list contaning only pSelectRowid */
85244   SrcList *pSelectSrc = NULL;  /* SELECT rowid FROM x ... (dup of pSrc) */
85245   Select *pSelect = NULL;      /* Complete SELECT tree */
85246
85247   /* Check that there isn't an ORDER BY without a LIMIT clause.
85248   */
85249   if( pOrderBy && (pLimit == 0) ) {
85250     sqlcipher3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
85251     pParse->parseError = 1;
85252     goto limit_where_cleanup_2;
85253   }
85254
85255   /* We only need to generate a select expression if there
85256   ** is a limit/offset term to enforce.
85257   */
85258   if( pLimit == 0 ) {
85259     /* if pLimit is null, pOffset will always be null as well. */
85260     assert( pOffset == 0 );
85261     return pWhere;
85262   }
85263
85264   /* Generate a select expression tree to enforce the limit/offset 
85265   ** term for the DELETE or UPDATE statement.  For example:
85266   **   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
85267   ** becomes:
85268   **   DELETE FROM table_a WHERE rowid IN ( 
85269   **     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
85270   **   );
85271   */
85272
85273   pSelectRowid = sqlcipher3PExpr(pParse, TK_ROW, 0, 0, 0);
85274   if( pSelectRowid == 0 ) goto limit_where_cleanup_2;
85275   pEList = sqlcipher3ExprListAppend(pParse, 0, pSelectRowid);
85276   if( pEList == 0 ) goto limit_where_cleanup_2;
85277
85278   /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
85279   ** and the SELECT subtree. */
85280   pSelectSrc = sqlcipher3SrcListDup(pParse->db, pSrc, 0);
85281   if( pSelectSrc == 0 ) {
85282     sqlcipher3ExprListDelete(pParse->db, pEList);
85283     goto limit_where_cleanup_2;
85284   }
85285
85286   /* generate the SELECT expression tree. */
85287   pSelect = sqlcipher3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
85288                              pOrderBy,0,pLimit,pOffset);
85289   if( pSelect == 0 ) return 0;
85290
85291   /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
85292   pWhereRowid = sqlcipher3PExpr(pParse, TK_ROW, 0, 0, 0);
85293   if( pWhereRowid == 0 ) goto limit_where_cleanup_1;
85294   pInClause = sqlcipher3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
85295   if( pInClause == 0 ) goto limit_where_cleanup_1;
85296
85297   pInClause->x.pSelect = pSelect;
85298   pInClause->flags |= EP_xIsSelect;
85299   sqlcipher3ExprSetHeight(pParse, pInClause);
85300   return pInClause;
85301
85302   /* something went wrong. clean up anything allocated. */
85303 limit_where_cleanup_1:
85304   sqlcipher3SelectDelete(pParse->db, pSelect);
85305   return 0;
85306
85307 limit_where_cleanup_2:
85308   sqlcipher3ExprDelete(pParse->db, pWhere);
85309   sqlcipher3ExprListDelete(pParse->db, pOrderBy);
85310   sqlcipher3ExprDelete(pParse->db, pLimit);
85311   sqlcipher3ExprDelete(pParse->db, pOffset);
85312   return 0;
85313 }
85314 #endif /* defined(SQLCIPHER_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLCIPHER_OMIT_SUBQUERY) */
85315
85316 /*
85317 ** Generate code for a DELETE FROM statement.
85318 **
85319 **     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
85320 **                 \________/       \________________/
85321 **                  pTabList              pWhere
85322 */
85323 SQLCIPHER_PRIVATE void sqlcipher3DeleteFrom(
85324   Parse *pParse,         /* The parser context */
85325   SrcList *pTabList,     /* The table from which we should delete things */
85326   Expr *pWhere           /* The WHERE clause.  May be null */
85327 ){
85328   Vdbe *v;               /* The virtual database engine */
85329   Table *pTab;           /* The table from which records will be deleted */
85330   const char *zDb;       /* Name of database holding pTab */
85331   int end, addr = 0;     /* A couple addresses of generated code */
85332   int i;                 /* Loop counter */
85333   WhereInfo *pWInfo;     /* Information about the WHERE clause */
85334   Index *pIdx;           /* For looping over indices of the table */
85335   int iCur;              /* VDBE Cursor number for pTab */
85336   sqlcipher3 *db;           /* Main database structure */
85337   AuthContext sContext;  /* Authorization context */
85338   NameContext sNC;       /* Name context to resolve expressions in */
85339   int iDb;               /* Database number */
85340   int memCnt = -1;       /* Memory cell used for change counting */
85341   int rcauth;            /* Value returned by authorization callback */
85342
85343 #ifndef SQLCIPHER_OMIT_TRIGGER
85344   int isView;                  /* True if attempting to delete from a view */
85345   Trigger *pTrigger;           /* List of table triggers, if required */
85346 #endif
85347
85348   memset(&sContext, 0, sizeof(sContext));
85349   db = pParse->db;
85350   if( pParse->nErr || db->mallocFailed ){
85351     goto delete_from_cleanup;
85352   }
85353   assert( pTabList->nSrc==1 );
85354
85355   /* Locate the table which we want to delete.  This table has to be
85356   ** put in an SrcList structure because some of the subroutines we
85357   ** will be calling are designed to work with multiple tables and expect
85358   ** an SrcList* parameter instead of just a Table* parameter.
85359   */
85360   pTab = sqlcipher3SrcListLookup(pParse, pTabList);
85361   if( pTab==0 )  goto delete_from_cleanup;
85362
85363   /* Figure out if we have any triggers and if the table being
85364   ** deleted from is a view
85365   */
85366 #ifndef SQLCIPHER_OMIT_TRIGGER
85367   pTrigger = sqlcipher3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
85368   isView = pTab->pSelect!=0;
85369 #else
85370 # define pTrigger 0
85371 # define isView 0
85372 #endif
85373 #ifdef SQLCIPHER_OMIT_VIEW
85374 # undef isView
85375 # define isView 0
85376 #endif
85377
85378   /* If pTab is really a view, make sure it has been initialized.
85379   */
85380   if( sqlcipher3ViewGetColumnNames(pParse, pTab) ){
85381     goto delete_from_cleanup;
85382   }
85383
85384   if( sqlcipher3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
85385     goto delete_from_cleanup;
85386   }
85387   iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
85388   assert( iDb<db->nDb );
85389   zDb = db->aDb[iDb].zName;
85390   rcauth = sqlcipher3AuthCheck(pParse, SQLCIPHER_DELETE, pTab->zName, 0, zDb);
85391   assert( rcauth==SQLCIPHER_OK || rcauth==SQLCIPHER_DENY || rcauth==SQLCIPHER_IGNORE );
85392   if( rcauth==SQLCIPHER_DENY ){
85393     goto delete_from_cleanup;
85394   }
85395   assert(!isView || pTrigger);
85396
85397   /* Assign  cursor number to the table and all its indices.
85398   */
85399   assert( pTabList->nSrc==1 );
85400   iCur = pTabList->a[0].iCursor = pParse->nTab++;
85401   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85402     pParse->nTab++;
85403   }
85404
85405   /* Start the view context
85406   */
85407   if( isView ){
85408     sqlcipher3AuthContextPush(pParse, &sContext, pTab->zName);
85409   }
85410
85411   /* Begin generating code.
85412   */
85413   v = sqlcipher3GetVdbe(pParse);
85414   if( v==0 ){
85415     goto delete_from_cleanup;
85416   }
85417   if( pParse->nested==0 ) sqlcipher3VdbeCountChanges(v);
85418   sqlcipher3BeginWriteOperation(pParse, 1, iDb);
85419
85420   /* If we are trying to delete from a view, realize that view into
85421   ** a ephemeral table.
85422   */
85423 #if !defined(SQLCIPHER_OMIT_VIEW) && !defined(SQLCIPHER_OMIT_TRIGGER)
85424   if( isView ){
85425     sqlcipher3MaterializeView(pParse, pTab, pWhere, iCur);
85426   }
85427 #endif
85428
85429   /* Resolve the column names in the WHERE clause.
85430   */
85431   memset(&sNC, 0, sizeof(sNC));
85432   sNC.pParse = pParse;
85433   sNC.pSrcList = pTabList;
85434   if( sqlcipher3ResolveExprNames(&sNC, pWhere) ){
85435     goto delete_from_cleanup;
85436   }
85437
85438   /* Initialize the counter of the number of rows deleted, if
85439   ** we are counting rows.
85440   */
85441   if( db->flags & SQLCIPHER_CountRows ){
85442     memCnt = ++pParse->nMem;
85443     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, memCnt);
85444   }
85445
85446 #ifndef SQLCIPHER_OMIT_TRUNCATE_OPTIMIZATION
85447   /* Special case: A DELETE without a WHERE clause deletes everything.
85448   ** It is easier just to erase the whole table. Prior to version 3.6.5,
85449   ** this optimization caused the row change count (the value returned by 
85450   ** API function sqlcipher3_count_changes) to be set incorrectly.  */
85451   if( rcauth==SQLCIPHER_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab) 
85452    && 0==sqlcipher3FkRequired(pParse, pTab, 0, 0)
85453   ){
85454     assert( !isView );
85455     sqlcipher3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
85456                       pTab->zName, P4_STATIC);
85457     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85458       assert( pIdx->pSchema==pTab->pSchema );
85459       sqlcipher3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
85460     }
85461   }else
85462 #endif /* SQLCIPHER_OMIT_TRUNCATE_OPTIMIZATION */
85463   /* The usual case: There is a WHERE clause so we have to scan through
85464   ** the table and pick which records to delete.
85465   */
85466   {
85467     int iRowSet = ++pParse->nMem;   /* Register for rowset of rows to delete */
85468     int iRowid = ++pParse->nMem;    /* Used for storing rowid values. */
85469     int regRowid;                   /* Actual register containing rowids */
85470
85471     /* Collect rowids of every row to be deleted.
85472     */
85473     sqlcipher3VdbeAddOp2(v, OP_Null, 0, iRowSet);
85474     pWInfo = sqlcipher3WhereBegin(
85475         pParse, pTabList, pWhere, 0, 0, WHERE_DUPLICATES_OK
85476     );
85477     if( pWInfo==0 ) goto delete_from_cleanup;
85478     regRowid = sqlcipher3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid);
85479     sqlcipher3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid);
85480     if( db->flags & SQLCIPHER_CountRows ){
85481       sqlcipher3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
85482     }
85483     sqlcipher3WhereEnd(pWInfo);
85484
85485     /* Delete every item whose key was written to the list during the
85486     ** database scan.  We have to delete items after the scan is complete
85487     ** because deleting an item can change the scan order.  */
85488     end = sqlcipher3VdbeMakeLabel(v);
85489
85490     /* Unless this is a view, open cursors for the table we are 
85491     ** deleting from and all its indices. If this is a view, then the
85492     ** only effect this statement has is to fire the INSTEAD OF 
85493     ** triggers.  */
85494     if( !isView ){
85495       sqlcipher3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
85496     }
85497
85498     addr = sqlcipher3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);
85499
85500     /* Delete the row */
85501 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
85502     if( IsVirtual(pTab) ){
85503       const char *pVTab = (const char *)sqlcipher3GetVTable(db, pTab);
85504       sqlcipher3VtabMakeWritable(pParse, pTab);
85505       sqlcipher3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);
85506       sqlcipher3VdbeChangeP5(v, OE_Abort);
85507       sqlcipher3MayAbort(pParse);
85508     }else
85509 #endif
85510     {
85511       int count = (pParse->nested==0);    /* True to count changes */
85512       sqlcipher3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
85513     }
85514
85515     /* End of the delete loop */
85516     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addr);
85517     sqlcipher3VdbeResolveLabel(v, end);
85518
85519     /* Close the cursors open on the table and its indexes. */
85520     if( !isView && !IsVirtual(pTab) ){
85521       for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
85522         sqlcipher3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
85523       }
85524       sqlcipher3VdbeAddOp1(v, OP_Close, iCur);
85525     }
85526   }
85527
85528   /* Update the sqlcipher_sequence table by storing the content of the
85529   ** maximum rowid counter values recorded while inserting into
85530   ** autoincrement tables.
85531   */
85532   if( pParse->nested==0 && pParse->pTriggerTab==0 ){
85533     sqlcipher3AutoincrementEnd(pParse);
85534   }
85535
85536   /* Return the number of rows that were deleted. If this routine is 
85537   ** generating code because of a call to sqlcipher3NestedParse(), do not
85538   ** invoke the callback function.
85539   */
85540   if( (db->flags&SQLCIPHER_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
85541     sqlcipher3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
85542     sqlcipher3VdbeSetNumCols(v, 1);
85543     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLCIPHER_STATIC);
85544   }
85545
85546 delete_from_cleanup:
85547   sqlcipher3AuthContextPop(&sContext);
85548   sqlcipher3SrcListDelete(db, pTabList);
85549   sqlcipher3ExprDelete(db, pWhere);
85550   return;
85551 }
85552 /* Make sure "isView" and other macros defined above are undefined. Otherwise
85553 ** thely may interfere with compilation of other functions in this file
85554 ** (or in another file, if this file becomes part of the amalgamation).  */
85555 #ifdef isView
85556  #undef isView
85557 #endif
85558 #ifdef pTrigger
85559  #undef pTrigger
85560 #endif
85561
85562 /*
85563 ** This routine generates VDBE code that causes a single row of a
85564 ** single table to be deleted.
85565 **
85566 ** The VDBE must be in a particular state when this routine is called.
85567 ** These are the requirements:
85568 **
85569 **   1.  A read/write cursor pointing to pTab, the table containing the row
85570 **       to be deleted, must be opened as cursor number $iCur.
85571 **
85572 **   2.  Read/write cursors for all indices of pTab must be open as
85573 **       cursor number base+i for the i-th index.
85574 **
85575 **   3.  The record number of the row to be deleted must be stored in
85576 **       memory cell iRowid.
85577 **
85578 ** This routine generates code to remove both the table record and all 
85579 ** index entries that point to that record.
85580 */
85581 SQLCIPHER_PRIVATE void sqlcipher3GenerateRowDelete(
85582   Parse *pParse,     /* Parsing context */
85583   Table *pTab,       /* Table containing the row to be deleted */
85584   int iCur,          /* Cursor number for the table */
85585   int iRowid,        /* Memory cell that contains the rowid to delete */
85586   int count,         /* If non-zero, increment the row change counter */
85587   Trigger *pTrigger, /* List of triggers to (potentially) fire */
85588   int onconf         /* Default ON CONFLICT policy for triggers */
85589 ){
85590   Vdbe *v = pParse->pVdbe;        /* Vdbe */
85591   int iOld = 0;                   /* First register in OLD.* array */
85592   int iLabel;                     /* Label resolved to end of generated code */
85593
85594   /* Vdbe is guaranteed to have been allocated by this stage. */
85595   assert( v );
85596
85597   /* Seek cursor iCur to the row to delete. If this row no longer exists 
85598   ** (this can happen if a trigger program has already deleted it), do
85599   ** not attempt to delete it or fire any DELETE triggers.  */
85600   iLabel = sqlcipher3VdbeMakeLabel(v);
85601   sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
85602  
85603   /* If there are any triggers to fire, allocate a range of registers to
85604   ** use for the old.* references in the triggers.  */
85605   if( sqlcipher3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
85606     u32 mask;                     /* Mask of OLD.* columns in use */
85607     int iCol;                     /* Iterator used while populating OLD.* */
85608
85609     /* TODO: Could use temporary registers here. Also could attempt to
85610     ** avoid copying the contents of the rowid register.  */
85611     mask = sqlcipher3TriggerColmask(
85612         pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
85613     );
85614     mask |= sqlcipher3FkOldmask(pParse, pTab);
85615     iOld = pParse->nMem+1;
85616     pParse->nMem += (1 + pTab->nCol);
85617
85618     /* Populate the OLD.* pseudo-table register array. These values will be 
85619     ** used by any BEFORE and AFTER triggers that exist.  */
85620     sqlcipher3VdbeAddOp2(v, OP_Copy, iRowid, iOld);
85621     for(iCol=0; iCol<pTab->nCol; iCol++){
85622       if( mask==0xffffffff || mask&(1<<iCol) ){
85623         sqlcipher3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);
85624       }
85625     }
85626
85627     /* Invoke BEFORE DELETE trigger programs. */
85628     sqlcipher3CodeRowTrigger(pParse, pTrigger, 
85629         TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
85630     );
85631
85632     /* Seek the cursor to the row to be deleted again. It may be that
85633     ** the BEFORE triggers coded above have already removed the row
85634     ** being deleted. Do not attempt to delete the row a second time, and 
85635     ** do not fire AFTER triggers.  */
85636     sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
85637
85638     /* Do FK processing. This call checks that any FK constraints that
85639     ** refer to this table (i.e. constraints attached to other tables) 
85640     ** are not violated by deleting this row.  */
85641     sqlcipher3FkCheck(pParse, pTab, iOld, 0);
85642   }
85643
85644   /* Delete the index and table entries. Skip this step if pTab is really
85645   ** a view (in which case the only effect of the DELETE statement is to
85646   ** fire the INSTEAD OF triggers).  */ 
85647   if( pTab->pSelect==0 ){
85648     sqlcipher3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
85649     sqlcipher3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
85650     if( count ){
85651       sqlcipher3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
85652     }
85653   }
85654
85655   /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
85656   ** handle rows (possibly in other tables) that refer via a foreign key
85657   ** to the row just deleted. */ 
85658   sqlcipher3FkActions(pParse, pTab, 0, iOld);
85659
85660   /* Invoke AFTER DELETE trigger programs. */
85661   sqlcipher3CodeRowTrigger(pParse, pTrigger, 
85662       TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
85663   );
85664
85665   /* Jump here if the row had already been deleted before any BEFORE
85666   ** trigger programs were invoked. Or if a trigger program throws a 
85667   ** RAISE(IGNORE) exception.  */
85668   sqlcipher3VdbeResolveLabel(v, iLabel);
85669 }
85670
85671 /*
85672 ** This routine generates VDBE code that causes the deletion of all
85673 ** index entries associated with a single row of a single table.
85674 **
85675 ** The VDBE must be in a particular state when this routine is called.
85676 ** These are the requirements:
85677 **
85678 **   1.  A read/write cursor pointing to pTab, the table containing the row
85679 **       to be deleted, must be opened as cursor number "iCur".
85680 **
85681 **   2.  Read/write cursors for all indices of pTab must be open as
85682 **       cursor number iCur+i for the i-th index.
85683 **
85684 **   3.  The "iCur" cursor must be pointing to the row that is to be
85685 **       deleted.
85686 */
85687 SQLCIPHER_PRIVATE void sqlcipher3GenerateRowIndexDelete(
85688   Parse *pParse,     /* Parsing and code generating context */
85689   Table *pTab,       /* Table containing the row to be deleted */
85690   int iCur,          /* Cursor number for the table */
85691   int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
85692 ){
85693   int i;
85694   Index *pIdx;
85695   int r1;
85696
85697   for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
85698     if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
85699     r1 = sqlcipher3GenerateIndexKey(pParse, pIdx, iCur, 0, 0);
85700     sqlcipher3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1);
85701   }
85702 }
85703
85704 /*
85705 ** Generate code that will assemble an index key and put it in register
85706 ** regOut.  The key with be for index pIdx which is an index on pTab.
85707 ** iCur is the index of a cursor open on the pTab table and pointing to
85708 ** the entry that needs indexing.
85709 **
85710 ** Return a register number which is the first in a block of
85711 ** registers that holds the elements of the index key.  The
85712 ** block of registers has already been deallocated by the time
85713 ** this routine returns.
85714 */
85715 SQLCIPHER_PRIVATE int sqlcipher3GenerateIndexKey(
85716   Parse *pParse,     /* Parsing context */
85717   Index *pIdx,       /* The index for which to generate a key */
85718   int iCur,          /* Cursor number for the pIdx->pTable table */
85719   int regOut,        /* Write the new index key to this register */
85720   int doMakeRec      /* Run the OP_MakeRecord instruction if true */
85721 ){
85722   Vdbe *v = pParse->pVdbe;
85723   int j;
85724   Table *pTab = pIdx->pTable;
85725   int regBase;
85726   int nCol;
85727
85728   nCol = pIdx->nColumn;
85729   regBase = sqlcipher3GetTempRange(pParse, nCol+1);
85730   sqlcipher3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
85731   for(j=0; j<nCol; j++){
85732     int idx = pIdx->aiColumn[j];
85733     if( idx==pTab->iPKey ){
85734       sqlcipher3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
85735     }else{
85736       sqlcipher3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
85737       sqlcipher3ColumnDefault(v, pTab, idx, -1);
85738     }
85739   }
85740   if( doMakeRec ){
85741     const char *zAff;
85742     if( pTab->pSelect || (pParse->db->flags & SQLCIPHER_IdxRealAsInt)!=0 ){
85743       zAff = 0;
85744     }else{
85745       zAff = sqlcipher3IndexAffinityStr(v, pIdx);
85746     }
85747     sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
85748     sqlcipher3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);
85749   }
85750   sqlcipher3ReleaseTempRange(pParse, regBase, nCol+1);
85751   return regBase;
85752 }
85753
85754 /************** End of delete.c **********************************************/
85755 /************** Begin file func.c ********************************************/
85756 /*
85757 ** 2002 February 23
85758 **
85759 ** The author disclaims copyright to this source code.  In place of
85760 ** a legal notice, here is a blessing:
85761 **
85762 **    May you do good and not evil.
85763 **    May you find forgiveness for yourself and forgive others.
85764 **    May you share freely, never taking more than you give.
85765 **
85766 *************************************************************************
85767 ** This file contains the C functions that implement various SQL
85768 ** functions of SQLite.  
85769 **
85770 ** There is only one exported symbol in this file - the function
85771 ** sqlcipherRegisterBuildinFunctions() found at the bottom of the file.
85772 ** All other code has file scope.
85773 */
85774 /* #include <stdlib.h> */
85775 /* #include <assert.h> */
85776
85777 /*
85778 ** Return the collating function associated with a function.
85779 */
85780 static CollSeq *sqlcipher3GetFuncCollSeq(sqlcipher3_context *context){
85781   return context->pColl;
85782 }
85783
85784 /*
85785 ** Implementation of the non-aggregate min() and max() functions
85786 */
85787 static void minmaxFunc(
85788   sqlcipher3_context *context,
85789   int argc,
85790   sqlcipher3_value **argv
85791 ){
85792   int i;
85793   int mask;    /* 0 for min() or 0xffffffff for max() */
85794   int iBest;
85795   CollSeq *pColl;
85796
85797   assert( argc>1 );
85798   mask = sqlcipher3_user_data(context)==0 ? 0 : -1;
85799   pColl = sqlcipher3GetFuncCollSeq(context);
85800   assert( pColl );
85801   assert( mask==-1 || mask==0 );
85802   iBest = 0;
85803   if( sqlcipher3_value_type(argv[0])==SQLCIPHER_NULL ) return;
85804   for(i=1; i<argc; i++){
85805     if( sqlcipher3_value_type(argv[i])==SQLCIPHER_NULL ) return;
85806     if( (sqlcipher3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
85807       testcase( mask==0 );
85808       iBest = i;
85809     }
85810   }
85811   sqlcipher3_result_value(context, argv[iBest]);
85812 }
85813
85814 /*
85815 ** Return the type of the argument.
85816 */
85817 static void typeofFunc(
85818   sqlcipher3_context *context,
85819   int NotUsed,
85820   sqlcipher3_value **argv
85821 ){
85822   const char *z = 0;
85823   UNUSED_PARAMETER(NotUsed);
85824   switch( sqlcipher3_value_type(argv[0]) ){
85825     case SQLCIPHER_INTEGER: z = "integer"; break;
85826     case SQLCIPHER_TEXT:    z = "text";    break;
85827     case SQLCIPHER_FLOAT:   z = "real";    break;
85828     case SQLCIPHER_BLOB:    z = "blob";    break;
85829     default:             z = "null";    break;
85830   }
85831   sqlcipher3_result_text(context, z, -1, SQLCIPHER_STATIC);
85832 }
85833
85834
85835 /*
85836 ** Implementation of the length() function
85837 */
85838 static void lengthFunc(
85839   sqlcipher3_context *context,
85840   int argc,
85841   sqlcipher3_value **argv
85842 ){
85843   int len;
85844
85845   assert( argc==1 );
85846   UNUSED_PARAMETER(argc);
85847   switch( sqlcipher3_value_type(argv[0]) ){
85848     case SQLCIPHER_BLOB:
85849     case SQLCIPHER_INTEGER:
85850     case SQLCIPHER_FLOAT: {
85851       sqlcipher3_result_int(context, sqlcipher3_value_bytes(argv[0]));
85852       break;
85853     }
85854     case SQLCIPHER_TEXT: {
85855       const unsigned char *z = sqlcipher3_value_text(argv[0]);
85856       if( z==0 ) return;
85857       len = 0;
85858       while( *z ){
85859         len++;
85860         SQLCIPHER_SKIP_UTF8(z);
85861       }
85862       sqlcipher3_result_int(context, len);
85863       break;
85864     }
85865     default: {
85866       sqlcipher3_result_null(context);
85867       break;
85868     }
85869   }
85870 }
85871
85872 /*
85873 ** Implementation of the abs() function.
85874 **
85875 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
85876 ** the numeric argument X. 
85877 */
85878 static void absFunc(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
85879   assert( argc==1 );
85880   UNUSED_PARAMETER(argc);
85881   switch( sqlcipher3_value_type(argv[0]) ){
85882     case SQLCIPHER_INTEGER: {
85883       i64 iVal = sqlcipher3_value_int64(argv[0]);
85884       if( iVal<0 ){
85885         if( (iVal<<1)==0 ){
85886           /* IMP: R-35460-15084 If X is the integer -9223372036854775807 then
85887           ** abs(X) throws an integer overflow error since there is no
85888           ** equivalent positive 64-bit two complement value. */
85889           sqlcipher3_result_error(context, "integer overflow", -1);
85890           return;
85891         }
85892         iVal = -iVal;
85893       } 
85894       sqlcipher3_result_int64(context, iVal);
85895       break;
85896     }
85897     case SQLCIPHER_NULL: {
85898       /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
85899       sqlcipher3_result_null(context);
85900       break;
85901     }
85902     default: {
85903       /* Because sqlcipher3_value_double() returns 0.0 if the argument is not
85904       ** something that can be converted into a number, we have:
85905       ** IMP: R-57326-31541 Abs(X) return 0.0 if X is a string or blob that
85906       ** cannot be converted to a numeric value. 
85907       */
85908       double rVal = sqlcipher3_value_double(argv[0]);
85909       if( rVal<0 ) rVal = -rVal;
85910       sqlcipher3_result_double(context, rVal);
85911       break;
85912     }
85913   }
85914 }
85915
85916 /*
85917 ** Implementation of the substr() function.
85918 **
85919 ** substr(x,p1,p2)  returns p2 characters of x[] beginning with p1.
85920 ** p1 is 1-indexed.  So substr(x,1,1) returns the first character
85921 ** of x.  If x is text, then we actually count UTF-8 characters.
85922 ** If x is a blob, then we count bytes.
85923 **
85924 ** If p1 is negative, then we begin abs(p1) from the end of x[].
85925 **
85926 ** If p2 is negative, return the p2 characters preceeding p1.
85927 */
85928 static void substrFunc(
85929   sqlcipher3_context *context,
85930   int argc,
85931   sqlcipher3_value **argv
85932 ){
85933   const unsigned char *z;
85934   const unsigned char *z2;
85935   int len;
85936   int p0type;
85937   i64 p1, p2;
85938   int negP2 = 0;
85939
85940   assert( argc==3 || argc==2 );
85941   if( sqlcipher3_value_type(argv[1])==SQLCIPHER_NULL
85942    || (argc==3 && sqlcipher3_value_type(argv[2])==SQLCIPHER_NULL)
85943   ){
85944     return;
85945   }
85946   p0type = sqlcipher3_value_type(argv[0]);
85947   p1 = sqlcipher3_value_int(argv[1]);
85948   if( p0type==SQLCIPHER_BLOB ){
85949     len = sqlcipher3_value_bytes(argv[0]);
85950     z = sqlcipher3_value_blob(argv[0]);
85951     if( z==0 ) return;
85952     assert( len==sqlcipher3_value_bytes(argv[0]) );
85953   }else{
85954     z = sqlcipher3_value_text(argv[0]);
85955     if( z==0 ) return;
85956     len = 0;
85957     if( p1<0 ){
85958       for(z2=z; *z2; len++){
85959         SQLCIPHER_SKIP_UTF8(z2);
85960       }
85961     }
85962   }
85963   if( argc==3 ){
85964     p2 = sqlcipher3_value_int(argv[2]);
85965     if( p2<0 ){
85966       p2 = -p2;
85967       negP2 = 1;
85968     }
85969   }else{
85970     p2 = sqlcipher3_context_db_handle(context)->aLimit[SQLCIPHER_LIMIT_LENGTH];
85971   }
85972   if( p1<0 ){
85973     p1 += len;
85974     if( p1<0 ){
85975       p2 += p1;
85976       if( p2<0 ) p2 = 0;
85977       p1 = 0;
85978     }
85979   }else if( p1>0 ){
85980     p1--;
85981   }else if( p2>0 ){
85982     p2--;
85983   }
85984   if( negP2 ){
85985     p1 -= p2;
85986     if( p1<0 ){
85987       p2 += p1;
85988       p1 = 0;
85989     }
85990   }
85991   assert( p1>=0 && p2>=0 );
85992   if( p0type!=SQLCIPHER_BLOB ){
85993     while( *z && p1 ){
85994       SQLCIPHER_SKIP_UTF8(z);
85995       p1--;
85996     }
85997     for(z2=z; *z2 && p2; p2--){
85998       SQLCIPHER_SKIP_UTF8(z2);
85999     }
86000     sqlcipher3_result_text(context, (char*)z, (int)(z2-z), SQLCIPHER_TRANSIENT);
86001   }else{
86002     if( p1+p2>len ){
86003       p2 = len-p1;
86004       if( p2<0 ) p2 = 0;
86005     }
86006     sqlcipher3_result_blob(context, (char*)&z[p1], (int)p2, SQLCIPHER_TRANSIENT);
86007   }
86008 }
86009
86010 /*
86011 ** Implementation of the round() function
86012 */
86013 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
86014 static void roundFunc(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
86015   int n = 0;
86016   double r;
86017   char *zBuf;
86018   assert( argc==1 || argc==2 );
86019   if( argc==2 ){
86020     if( SQLCIPHER_NULL==sqlcipher3_value_type(argv[1]) ) return;
86021     n = sqlcipher3_value_int(argv[1]);
86022     if( n>30 ) n = 30;
86023     if( n<0 ) n = 0;
86024   }
86025   if( sqlcipher3_value_type(argv[0])==SQLCIPHER_NULL ) return;
86026   r = sqlcipher3_value_double(argv[0]);
86027   /* If Y==0 and X will fit in a 64-bit int,
86028   ** handle the rounding directly,
86029   ** otherwise use printf.
86030   */
86031   if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
86032     r = (double)((sqlcipher_int64)(r+0.5));
86033   }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
86034     r = -(double)((sqlcipher_int64)((-r)+0.5));
86035   }else{
86036     zBuf = sqlcipher3_mprintf("%.*f",n,r);
86037     if( zBuf==0 ){
86038       sqlcipher3_result_error_nomem(context);
86039       return;
86040     }
86041     sqlcipher3AtoF(zBuf, &r, sqlcipher3Strlen30(zBuf), SQLCIPHER_UTF8);
86042     sqlcipher3_free(zBuf);
86043   }
86044   sqlcipher3_result_double(context, r);
86045 }
86046 #endif
86047
86048 /*
86049 ** Allocate nByte bytes of space using sqlcipher3_malloc(). If the
86050 ** allocation fails, call sqlcipher3_result_error_nomem() to notify
86051 ** the database handle that malloc() has failed and return NULL.
86052 ** If nByte is larger than the maximum string or blob length, then
86053 ** raise an SQLCIPHER_TOOBIG exception and return NULL.
86054 */
86055 static void *contextMalloc(sqlcipher3_context *context, i64 nByte){
86056   char *z;
86057   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86058   assert( nByte>0 );
86059   testcase( nByte==db->aLimit[SQLCIPHER_LIMIT_LENGTH] );
86060   testcase( nByte==db->aLimit[SQLCIPHER_LIMIT_LENGTH]+1 );
86061   if( nByte>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
86062     sqlcipher3_result_error_toobig(context);
86063     z = 0;
86064   }else{
86065     z = sqlcipher3Malloc((int)nByte);
86066     if( !z ){
86067       sqlcipher3_result_error_nomem(context);
86068     }
86069   }
86070   return z;
86071 }
86072
86073 /*
86074 ** Implementation of the upper() and lower() SQL functions.
86075 */
86076 static void upperFunc(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
86077   char *z1;
86078   const char *z2;
86079   int i, n;
86080   UNUSED_PARAMETER(argc);
86081   z2 = (char*)sqlcipher3_value_text(argv[0]);
86082   n = sqlcipher3_value_bytes(argv[0]);
86083   /* Verify that the call to _bytes() does not invalidate the _text() pointer */
86084   assert( z2==(char*)sqlcipher3_value_text(argv[0]) );
86085   if( z2 ){
86086     z1 = contextMalloc(context, ((i64)n)+1);
86087     if( z1 ){
86088       for(i=0; i<n; i++){
86089         z1[i] = (char)sqlcipher3Toupper(z2[i]);
86090       }
86091       sqlcipher3_result_text(context, z1, n, sqlcipher3_free);
86092     }
86093   }
86094 }
86095 static void lowerFunc(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
86096   char *z1;
86097   const char *z2;
86098   int i, n;
86099   UNUSED_PARAMETER(argc);
86100   z2 = (char*)sqlcipher3_value_text(argv[0]);
86101   n = sqlcipher3_value_bytes(argv[0]);
86102   /* Verify that the call to _bytes() does not invalidate the _text() pointer */
86103   assert( z2==(char*)sqlcipher3_value_text(argv[0]) );
86104   if( z2 ){
86105     z1 = contextMalloc(context, ((i64)n)+1);
86106     if( z1 ){
86107       for(i=0; i<n; i++){
86108         z1[i] = sqlcipher3Tolower(z2[i]);
86109       }
86110       sqlcipher3_result_text(context, z1, n, sqlcipher3_free);
86111     }
86112   }
86113 }
86114
86115
86116 #if 0  /* This function is never used. */
86117 /*
86118 ** The COALESCE() and IFNULL() functions used to be implemented as shown
86119 ** here.  But now they are implemented as VDBE code so that unused arguments
86120 ** do not have to be computed.  This legacy implementation is retained as
86121 ** comment.
86122 */
86123 /*
86124 ** Implementation of the IFNULL(), NVL(), and COALESCE() functions.  
86125 ** All three do the same thing.  They return the first non-NULL
86126 ** argument.
86127 */
86128 static void ifnullFunc(
86129   sqlcipher3_context *context,
86130   int argc,
86131   sqlcipher3_value **argv
86132 ){
86133   int i;
86134   for(i=0; i<argc; i++){
86135     if( SQLCIPHER_NULL!=sqlcipher3_value_type(argv[i]) ){
86136       sqlcipher3_result_value(context, argv[i]);
86137       break;
86138     }
86139   }
86140 }
86141 #endif /* NOT USED */
86142 #define ifnullFunc versionFunc   /* Substitute function - never called */
86143
86144 /*
86145 ** Implementation of random().  Return a random integer.  
86146 */
86147 static void randomFunc(
86148   sqlcipher3_context *context,
86149   int NotUsed,
86150   sqlcipher3_value **NotUsed2
86151 ){
86152   sqlcipher_int64 r;
86153   UNUSED_PARAMETER2(NotUsed, NotUsed2);
86154   sqlcipher3_randomness(sizeof(r), &r);
86155   if( r<0 ){
86156     /* We need to prevent a random number of 0x8000000000000000 
86157     ** (or -9223372036854775808) since when you do abs() of that
86158     ** number of you get the same value back again.  To do this
86159     ** in a way that is testable, mask the sign bit off of negative
86160     ** values, resulting in a positive value.  Then take the 
86161     ** 2s complement of that positive value.  The end result can
86162     ** therefore be no less than -9223372036854775807.
86163     */
86164     r = -(r ^ (((sqlcipher3_int64)1)<<63));
86165   }
86166   sqlcipher3_result_int64(context, r);
86167 }
86168
86169 /*
86170 ** Implementation of randomblob(N).  Return a random blob
86171 ** that is N bytes long.
86172 */
86173 static void randomBlob(
86174   sqlcipher3_context *context,
86175   int argc,
86176   sqlcipher3_value **argv
86177 ){
86178   int n;
86179   unsigned char *p;
86180   assert( argc==1 );
86181   UNUSED_PARAMETER(argc);
86182   n = sqlcipher3_value_int(argv[0]);
86183   if( n<1 ){
86184     n = 1;
86185   }
86186   p = contextMalloc(context, n);
86187   if( p ){
86188     sqlcipher3_randomness(n, p);
86189     sqlcipher3_result_blob(context, (char*)p, n, sqlcipher3_free);
86190   }
86191 }
86192
86193 /*
86194 ** Implementation of the last_insert_rowid() SQL function.  The return
86195 ** value is the same as the sqlcipher3_last_insert_rowid() API function.
86196 */
86197 static void last_insert_rowid(
86198   sqlcipher3_context *context, 
86199   int NotUsed, 
86200   sqlcipher3_value **NotUsed2
86201 ){
86202   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86203   UNUSED_PARAMETER2(NotUsed, NotUsed2);
86204   /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
86205   ** wrapper around the sqlcipher3_last_insert_rowid() C/C++ interface
86206   ** function. */
86207   sqlcipher3_result_int64(context, sqlcipher3_last_insert_rowid(db));
86208 }
86209
86210 /*
86211 ** Implementation of the changes() SQL function.
86212 **
86213 ** IMP: R-62073-11209 The changes() SQL function is a wrapper
86214 ** around the sqlcipher3_changes() C/C++ function and hence follows the same
86215 ** rules for counting changes.
86216 */
86217 static void changes(
86218   sqlcipher3_context *context,
86219   int NotUsed,
86220   sqlcipher3_value **NotUsed2
86221 ){
86222   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86223   UNUSED_PARAMETER2(NotUsed, NotUsed2);
86224   sqlcipher3_result_int(context, sqlcipher3_changes(db));
86225 }
86226
86227 /*
86228 ** Implementation of the total_changes() SQL function.  The return value is
86229 ** the same as the sqlcipher3_total_changes() API function.
86230 */
86231 static void total_changes(
86232   sqlcipher3_context *context,
86233   int NotUsed,
86234   sqlcipher3_value **NotUsed2
86235 ){
86236   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86237   UNUSED_PARAMETER2(NotUsed, NotUsed2);
86238   /* IMP: R-52756-41993 This function is a wrapper around the
86239   ** sqlcipher3_total_changes() C/C++ interface. */
86240   sqlcipher3_result_int(context, sqlcipher3_total_changes(db));
86241 }
86242
86243 /*
86244 ** A structure defining how to do GLOB-style comparisons.
86245 */
86246 struct compareInfo {
86247   u8 matchAll;
86248   u8 matchOne;
86249   u8 matchSet;
86250   u8 noCase;
86251 };
86252
86253 /*
86254 ** For LIKE and GLOB matching on EBCDIC machines, assume that every
86255 ** character is exactly one byte in size.  Also, all characters are
86256 ** able to participate in upper-case-to-lower-case mappings in EBCDIC
86257 ** whereas only characters less than 0x80 do in ASCII.
86258 */
86259 #if defined(SQLCIPHER_EBCDIC)
86260 # define sqlcipher3Utf8Read(A,C)  (*(A++))
86261 # define GlogUpperToLower(A)   A = sqlcipher3UpperToLower[A]
86262 #else
86263 # define GlogUpperToLower(A)   if( !((A)&~0x7f) ){ A = sqlcipher3UpperToLower[A]; }
86264 #endif
86265
86266 static const struct compareInfo globInfo = { '*', '?', '[', 0 };
86267 /* The correct SQL-92 behavior is for the LIKE operator to ignore
86268 ** case.  Thus  'a' LIKE 'A' would be true. */
86269 static const struct compareInfo likeInfoNorm = { '%', '_',   0, 1 };
86270 /* If SQLCIPHER_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
86271 ** is case sensitive causing 'a' LIKE 'A' to be false */
86272 static const struct compareInfo likeInfoAlt = { '%', '_',   0, 0 };
86273
86274 /*
86275 ** Compare two UTF-8 strings for equality where the first string can
86276 ** potentially be a "glob" expression.  Return true (1) if they
86277 ** are the same and false (0) if they are different.
86278 **
86279 ** Globbing rules:
86280 **
86281 **      '*'       Matches any sequence of zero or more characters.
86282 **
86283 **      '?'       Matches exactly one character.
86284 **
86285 **     [...]      Matches one character from the enclosed list of
86286 **                characters.
86287 **
86288 **     [^...]     Matches one character not in the enclosed list.
86289 **
86290 ** With the [...] and [^...] matching, a ']' character can be included
86291 ** in the list by making it the first character after '[' or '^'.  A
86292 ** range of characters can be specified using '-'.  Example:
86293 ** "[a-z]" matches any single lower-case letter.  To match a '-', make
86294 ** it the last character in the list.
86295 **
86296 ** This routine is usually quick, but can be N**2 in the worst case.
86297 **
86298 ** Hints: to match '*' or '?', put them in "[]".  Like this:
86299 **
86300 **         abc[*]xyz        Matches "abc*xyz" only
86301 */
86302 static int patternCompare(
86303   const u8 *zPattern,              /* The glob pattern */
86304   const u8 *zString,               /* The string to compare against the glob */
86305   const struct compareInfo *pInfo, /* Information about how to do the compare */
86306   u32 esc                          /* The escape character */
86307 ){
86308   u32 c, c2;
86309   int invert;
86310   int seen;
86311   u8 matchOne = pInfo->matchOne;
86312   u8 matchAll = pInfo->matchAll;
86313   u8 matchSet = pInfo->matchSet;
86314   u8 noCase = pInfo->noCase; 
86315   int prevEscape = 0;     /* True if the previous character was 'escape' */
86316
86317   while( (c = sqlcipher3Utf8Read(zPattern,&zPattern))!=0 ){
86318     if( !prevEscape && c==matchAll ){
86319       while( (c=sqlcipher3Utf8Read(zPattern,&zPattern)) == matchAll
86320                || c == matchOne ){
86321         if( c==matchOne && sqlcipher3Utf8Read(zString, &zString)==0 ){
86322           return 0;
86323         }
86324       }
86325       if( c==0 ){
86326         return 1;
86327       }else if( c==esc ){
86328         c = sqlcipher3Utf8Read(zPattern, &zPattern);
86329         if( c==0 ){
86330           return 0;
86331         }
86332       }else if( c==matchSet ){
86333         assert( esc==0 );         /* This is GLOB, not LIKE */
86334         assert( matchSet<0x80 );  /* '[' is a single-byte character */
86335         while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
86336           SQLCIPHER_SKIP_UTF8(zString);
86337         }
86338         return *zString!=0;
86339       }
86340       while( (c2 = sqlcipher3Utf8Read(zString,&zString))!=0 ){
86341         if( noCase ){
86342           GlogUpperToLower(c2);
86343           GlogUpperToLower(c);
86344           while( c2 != 0 && c2 != c ){
86345             c2 = sqlcipher3Utf8Read(zString, &zString);
86346             GlogUpperToLower(c2);
86347           }
86348         }else{
86349           while( c2 != 0 && c2 != c ){
86350             c2 = sqlcipher3Utf8Read(zString, &zString);
86351           }
86352         }
86353         if( c2==0 ) return 0;
86354         if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
86355       }
86356       return 0;
86357     }else if( !prevEscape && c==matchOne ){
86358       if( sqlcipher3Utf8Read(zString, &zString)==0 ){
86359         return 0;
86360       }
86361     }else if( c==matchSet ){
86362       u32 prior_c = 0;
86363       assert( esc==0 );    /* This only occurs for GLOB, not LIKE */
86364       seen = 0;
86365       invert = 0;
86366       c = sqlcipher3Utf8Read(zString, &zString);
86367       if( c==0 ) return 0;
86368       c2 = sqlcipher3Utf8Read(zPattern, &zPattern);
86369       if( c2=='^' ){
86370         invert = 1;
86371         c2 = sqlcipher3Utf8Read(zPattern, &zPattern);
86372       }
86373       if( c2==']' ){
86374         if( c==']' ) seen = 1;
86375         c2 = sqlcipher3Utf8Read(zPattern, &zPattern);
86376       }
86377       while( c2 && c2!=']' ){
86378         if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
86379           c2 = sqlcipher3Utf8Read(zPattern, &zPattern);
86380           if( c>=prior_c && c<=c2 ) seen = 1;
86381           prior_c = 0;
86382         }else{
86383           if( c==c2 ){
86384             seen = 1;
86385           }
86386           prior_c = c2;
86387         }
86388         c2 = sqlcipher3Utf8Read(zPattern, &zPattern);
86389       }
86390       if( c2==0 || (seen ^ invert)==0 ){
86391         return 0;
86392       }
86393     }else if( esc==c && !prevEscape ){
86394       prevEscape = 1;
86395     }else{
86396       c2 = sqlcipher3Utf8Read(zString, &zString);
86397       if( noCase ){
86398         GlogUpperToLower(c);
86399         GlogUpperToLower(c2);
86400       }
86401       if( c!=c2 ){
86402         return 0;
86403       }
86404       prevEscape = 0;
86405     }
86406   }
86407   return *zString==0;
86408 }
86409
86410 /*
86411 ** Count the number of times that the LIKE operator (or GLOB which is
86412 ** just a variation of LIKE) gets called.  This is used for testing
86413 ** only.
86414 */
86415 #ifdef SQLCIPHER_TEST
86416 SQLCIPHER_API int sqlcipher3_like_count = 0;
86417 #endif
86418
86419
86420 /*
86421 ** Implementation of the like() SQL function.  This function implements
86422 ** the build-in LIKE operator.  The first argument to the function is the
86423 ** pattern and the second argument is the string.  So, the SQL statements:
86424 **
86425 **       A LIKE B
86426 **
86427 ** is implemented as like(B,A).
86428 **
86429 ** This same function (with a different compareInfo structure) computes
86430 ** the GLOB operator.
86431 */
86432 static void likeFunc(
86433   sqlcipher3_context *context, 
86434   int argc, 
86435   sqlcipher3_value **argv
86436 ){
86437   const unsigned char *zA, *zB;
86438   u32 escape = 0;
86439   int nPat;
86440   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86441
86442   zB = sqlcipher3_value_text(argv[0]);
86443   zA = sqlcipher3_value_text(argv[1]);
86444
86445   /* Limit the length of the LIKE or GLOB pattern to avoid problems
86446   ** of deep recursion and N*N behavior in patternCompare().
86447   */
86448   nPat = sqlcipher3_value_bytes(argv[0]);
86449   testcase( nPat==db->aLimit[SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH] );
86450   testcase( nPat==db->aLimit[SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH]+1 );
86451   if( nPat > db->aLimit[SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH] ){
86452     sqlcipher3_result_error(context, "LIKE or GLOB pattern too complex", -1);
86453     return;
86454   }
86455   assert( zB==sqlcipher3_value_text(argv[0]) );  /* Encoding did not change */
86456
86457   if( argc==3 ){
86458     /* The escape character string must consist of a single UTF-8 character.
86459     ** Otherwise, return an error.
86460     */
86461     const unsigned char *zEsc = sqlcipher3_value_text(argv[2]);
86462     if( zEsc==0 ) return;
86463     if( sqlcipher3Utf8CharLen((char*)zEsc, -1)!=1 ){
86464       sqlcipher3_result_error(context, 
86465           "ESCAPE expression must be a single character", -1);
86466       return;
86467     }
86468     escape = sqlcipher3Utf8Read(zEsc, &zEsc);
86469   }
86470   if( zA && zB ){
86471     struct compareInfo *pInfo = sqlcipher3_user_data(context);
86472 #ifdef SQLCIPHER_TEST
86473     sqlcipher3_like_count++;
86474 #endif
86475     
86476     sqlcipher3_result_int(context, patternCompare(zB, zA, pInfo, escape));
86477   }
86478 }
86479
86480 /*
86481 ** Implementation of the NULLIF(x,y) function.  The result is the first
86482 ** argument if the arguments are different.  The result is NULL if the
86483 ** arguments are equal to each other.
86484 */
86485 static void nullifFunc(
86486   sqlcipher3_context *context,
86487   int NotUsed,
86488   sqlcipher3_value **argv
86489 ){
86490   CollSeq *pColl = sqlcipher3GetFuncCollSeq(context);
86491   UNUSED_PARAMETER(NotUsed);
86492   if( sqlcipher3MemCompare(argv[0], argv[1], pColl)!=0 ){
86493     sqlcipher3_result_value(context, argv[0]);
86494   }
86495 }
86496
86497 /*
86498 ** Implementation of the sqlcipher_version() function.  The result is the version
86499 ** of the SQLite library that is running.
86500 */
86501 static void versionFunc(
86502   sqlcipher3_context *context,
86503   int NotUsed,
86504   sqlcipher3_value **NotUsed2
86505 ){
86506   UNUSED_PARAMETER2(NotUsed, NotUsed2);
86507   /* IMP: R-48699-48617 This function is an SQL wrapper around the
86508   ** sqlcipher3_libversion() C-interface. */
86509   sqlcipher3_result_text(context, sqlcipher3_libversion(), -1, SQLCIPHER_STATIC);
86510 }
86511
86512 /*
86513 ** Implementation of the sqlcipher_source_id() function. The result is a string
86514 ** that identifies the particular version of the source code used to build
86515 ** SQLite.
86516 */
86517 static void sourceidFunc(
86518   sqlcipher3_context *context,
86519   int NotUsed,
86520   sqlcipher3_value **NotUsed2
86521 ){
86522   UNUSED_PARAMETER2(NotUsed, NotUsed2);
86523   /* IMP: R-24470-31136 This function is an SQL wrapper around the
86524   ** sqlcipher3_sourceid() C interface. */
86525   sqlcipher3_result_text(context, sqlcipher3_sourceid(), -1, SQLCIPHER_STATIC);
86526 }
86527
86528 /*
86529 ** Implementation of the sqlcipher_log() function.  This is a wrapper around
86530 ** sqlcipher3_log().  The return value is NULL.  The function exists purely for
86531 ** its side-effects.
86532 */
86533 static void errlogFunc(
86534   sqlcipher3_context *context,
86535   int argc,
86536   sqlcipher3_value **argv
86537 ){
86538   UNUSED_PARAMETER(argc);
86539   UNUSED_PARAMETER(context);
86540   sqlcipher3_log(sqlcipher3_value_int(argv[0]), "%s", sqlcipher3_value_text(argv[1]));
86541 }
86542
86543 /*
86544 ** Implementation of the sqlcipher_compileoption_used() function.
86545 ** The result is an integer that identifies if the compiler option
86546 ** was used to build SQLite.
86547 */
86548 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
86549 static void compileoptionusedFunc(
86550   sqlcipher3_context *context,
86551   int argc,
86552   sqlcipher3_value **argv
86553 ){
86554   const char *zOptName;
86555   assert( argc==1 );
86556   UNUSED_PARAMETER(argc);
86557   /* IMP: R-39564-36305 The sqlcipher_compileoption_used() SQL
86558   ** function is a wrapper around the sqlcipher3_compileoption_used() C/C++
86559   ** function.
86560   */
86561   if( (zOptName = (const char*)sqlcipher3_value_text(argv[0]))!=0 ){
86562     sqlcipher3_result_int(context, sqlcipher3_compileoption_used(zOptName));
86563   }
86564 }
86565 #endif /* SQLCIPHER_OMIT_COMPILEOPTION_DIAGS */
86566
86567 /*
86568 ** Implementation of the sqlcipher_compileoption_get() function. 
86569 ** The result is a string that identifies the compiler options 
86570 ** used to build SQLite.
86571 */
86572 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
86573 static void compileoptiongetFunc(
86574   sqlcipher3_context *context,
86575   int argc,
86576   sqlcipher3_value **argv
86577 ){
86578   int n;
86579   assert( argc==1 );
86580   UNUSED_PARAMETER(argc);
86581   /* IMP: R-04922-24076 The sqlcipher_compileoption_get() SQL function
86582   ** is a wrapper around the sqlcipher3_compileoption_get() C/C++ function.
86583   */
86584   n = sqlcipher3_value_int(argv[0]);
86585   sqlcipher3_result_text(context, sqlcipher3_compileoption_get(n), -1, SQLCIPHER_STATIC);
86586 }
86587 #endif /* SQLCIPHER_OMIT_COMPILEOPTION_DIAGS */
86588
86589 /* Array for converting from half-bytes (nybbles) into ASCII hex
86590 ** digits. */
86591 static const char hexdigits[] = {
86592   '0', '1', '2', '3', '4', '5', '6', '7',
86593   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 
86594 };
86595
86596 /*
86597 ** EXPERIMENTAL - This is not an official function.  The interface may
86598 ** change.  This function may disappear.  Do not write code that depends
86599 ** on this function.
86600 **
86601 ** Implementation of the QUOTE() function.  This function takes a single
86602 ** argument.  If the argument is numeric, the return value is the same as
86603 ** the argument.  If the argument is NULL, the return value is the string
86604 ** "NULL".  Otherwise, the argument is enclosed in single quotes with
86605 ** single-quote escapes.
86606 */
86607 static void quoteFunc(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
86608   assert( argc==1 );
86609   UNUSED_PARAMETER(argc);
86610   switch( sqlcipher3_value_type(argv[0]) ){
86611     case SQLCIPHER_INTEGER:
86612     case SQLCIPHER_FLOAT: {
86613       sqlcipher3_result_value(context, argv[0]);
86614       break;
86615     }
86616     case SQLCIPHER_BLOB: {
86617       char *zText = 0;
86618       char const *zBlob = sqlcipher3_value_blob(argv[0]);
86619       int nBlob = sqlcipher3_value_bytes(argv[0]);
86620       assert( zBlob==sqlcipher3_value_blob(argv[0]) ); /* No encoding change */
86621       zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4); 
86622       if( zText ){
86623         int i;
86624         for(i=0; i<nBlob; i++){
86625           zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
86626           zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
86627         }
86628         zText[(nBlob*2)+2] = '\'';
86629         zText[(nBlob*2)+3] = '\0';
86630         zText[0] = 'X';
86631         zText[1] = '\'';
86632         sqlcipher3_result_text(context, zText, -1, SQLCIPHER_TRANSIENT);
86633         sqlcipher3_free(zText);
86634       }
86635       break;
86636     }
86637     case SQLCIPHER_TEXT: {
86638       int i,j;
86639       u64 n;
86640       const unsigned char *zArg = sqlcipher3_value_text(argv[0]);
86641       char *z;
86642
86643       if( zArg==0 ) return;
86644       for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
86645       z = contextMalloc(context, ((i64)i)+((i64)n)+3);
86646       if( z ){
86647         z[0] = '\'';
86648         for(i=0, j=1; zArg[i]; i++){
86649           z[j++] = zArg[i];
86650           if( zArg[i]=='\'' ){
86651             z[j++] = '\'';
86652           }
86653         }
86654         z[j++] = '\'';
86655         z[j] = 0;
86656         sqlcipher3_result_text(context, z, j, sqlcipher3_free);
86657       }
86658       break;
86659     }
86660     default: {
86661       assert( sqlcipher3_value_type(argv[0])==SQLCIPHER_NULL );
86662       sqlcipher3_result_text(context, "NULL", 4, SQLCIPHER_STATIC);
86663       break;
86664     }
86665   }
86666 }
86667
86668 /*
86669 ** The hex() function.  Interpret the argument as a blob.  Return
86670 ** a hexadecimal rendering as text.
86671 */
86672 static void hexFunc(
86673   sqlcipher3_context *context,
86674   int argc,
86675   sqlcipher3_value **argv
86676 ){
86677   int i, n;
86678   const unsigned char *pBlob;
86679   char *zHex, *z;
86680   assert( argc==1 );
86681   UNUSED_PARAMETER(argc);
86682   pBlob = sqlcipher3_value_blob(argv[0]);
86683   n = sqlcipher3_value_bytes(argv[0]);
86684   assert( pBlob==sqlcipher3_value_blob(argv[0]) );  /* No encoding change */
86685   z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
86686   if( zHex ){
86687     for(i=0; i<n; i++, pBlob++){
86688       unsigned char c = *pBlob;
86689       *(z++) = hexdigits[(c>>4)&0xf];
86690       *(z++) = hexdigits[c&0xf];
86691     }
86692     *z = 0;
86693     sqlcipher3_result_text(context, zHex, n*2, sqlcipher3_free);
86694   }
86695 }
86696
86697 /*
86698 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
86699 */
86700 static void zeroblobFunc(
86701   sqlcipher3_context *context,
86702   int argc,
86703   sqlcipher3_value **argv
86704 ){
86705   i64 n;
86706   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86707   assert( argc==1 );
86708   UNUSED_PARAMETER(argc);
86709   n = sqlcipher3_value_int64(argv[0]);
86710   testcase( n==db->aLimit[SQLCIPHER_LIMIT_LENGTH] );
86711   testcase( n==db->aLimit[SQLCIPHER_LIMIT_LENGTH]+1 );
86712   if( n>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
86713     sqlcipher3_result_error_toobig(context);
86714   }else{
86715     sqlcipher3_result_zeroblob(context, (int)n); /* IMP: R-00293-64994 */
86716   }
86717 }
86718
86719 /*
86720 ** The replace() function.  Three arguments are all strings: call
86721 ** them A, B, and C. The result is also a string which is derived
86722 ** from A by replacing every occurance of B with C.  The match
86723 ** must be exact.  Collating sequences are not used.
86724 */
86725 static void replaceFunc(
86726   sqlcipher3_context *context,
86727   int argc,
86728   sqlcipher3_value **argv
86729 ){
86730   const unsigned char *zStr;        /* The input string A */
86731   const unsigned char *zPattern;    /* The pattern string B */
86732   const unsigned char *zRep;        /* The replacement string C */
86733   unsigned char *zOut;              /* The output */
86734   int nStr;                /* Size of zStr */
86735   int nPattern;            /* Size of zPattern */
86736   int nRep;                /* Size of zRep */
86737   i64 nOut;                /* Maximum size of zOut */
86738   int loopLimit;           /* Last zStr[] that might match zPattern[] */
86739   int i, j;                /* Loop counters */
86740
86741   assert( argc==3 );
86742   UNUSED_PARAMETER(argc);
86743   zStr = sqlcipher3_value_text(argv[0]);
86744   if( zStr==0 ) return;
86745   nStr = sqlcipher3_value_bytes(argv[0]);
86746   assert( zStr==sqlcipher3_value_text(argv[0]) );  /* No encoding change */
86747   zPattern = sqlcipher3_value_text(argv[1]);
86748   if( zPattern==0 ){
86749     assert( sqlcipher3_value_type(argv[1])==SQLCIPHER_NULL
86750             || sqlcipher3_context_db_handle(context)->mallocFailed );
86751     return;
86752   }
86753   if( zPattern[0]==0 ){
86754     assert( sqlcipher3_value_type(argv[1])!=SQLCIPHER_NULL );
86755     sqlcipher3_result_value(context, argv[0]);
86756     return;
86757   }
86758   nPattern = sqlcipher3_value_bytes(argv[1]);
86759   assert( zPattern==sqlcipher3_value_text(argv[1]) );  /* No encoding change */
86760   zRep = sqlcipher3_value_text(argv[2]);
86761   if( zRep==0 ) return;
86762   nRep = sqlcipher3_value_bytes(argv[2]);
86763   assert( zRep==sqlcipher3_value_text(argv[2]) );
86764   nOut = nStr + 1;
86765   assert( nOut<SQLCIPHER_MAX_LENGTH );
86766   zOut = contextMalloc(context, (i64)nOut);
86767   if( zOut==0 ){
86768     return;
86769   }
86770   loopLimit = nStr - nPattern;  
86771   for(i=j=0; i<=loopLimit; i++){
86772     if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
86773       zOut[j++] = zStr[i];
86774     }else{
86775       u8 *zOld;
86776       sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86777       nOut += nRep - nPattern;
86778       testcase( nOut-1==db->aLimit[SQLCIPHER_LIMIT_LENGTH] );
86779       testcase( nOut-2==db->aLimit[SQLCIPHER_LIMIT_LENGTH] );
86780       if( nOut-1>db->aLimit[SQLCIPHER_LIMIT_LENGTH] ){
86781         sqlcipher3_result_error_toobig(context);
86782         sqlcipher3_free(zOut);
86783         return;
86784       }
86785       zOld = zOut;
86786       zOut = sqlcipher3_realloc(zOut, (int)nOut);
86787       if( zOut==0 ){
86788         sqlcipher3_result_error_nomem(context);
86789         sqlcipher3_free(zOld);
86790         return;
86791       }
86792       memcpy(&zOut[j], zRep, nRep);
86793       j += nRep;
86794       i += nPattern-1;
86795     }
86796   }
86797   assert( j+nStr-i+1==nOut );
86798   memcpy(&zOut[j], &zStr[i], nStr-i);
86799   j += nStr - i;
86800   assert( j<=nOut );
86801   zOut[j] = 0;
86802   sqlcipher3_result_text(context, (char*)zOut, j, sqlcipher3_free);
86803 }
86804
86805 /*
86806 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
86807 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
86808 */
86809 static void trimFunc(
86810   sqlcipher3_context *context,
86811   int argc,
86812   sqlcipher3_value **argv
86813 ){
86814   const unsigned char *zIn;         /* Input string */
86815   const unsigned char *zCharSet;    /* Set of characters to trim */
86816   int nIn;                          /* Number of bytes in input */
86817   int flags;                        /* 1: trimleft  2: trimright  3: trim */
86818   int i;                            /* Loop counter */
86819   unsigned char *aLen = 0;          /* Length of each character in zCharSet */
86820   unsigned char **azChar = 0;       /* Individual characters in zCharSet */
86821   int nChar;                        /* Number of characters in zCharSet */
86822
86823   if( sqlcipher3_value_type(argv[0])==SQLCIPHER_NULL ){
86824     return;
86825   }
86826   zIn = sqlcipher3_value_text(argv[0]);
86827   if( zIn==0 ) return;
86828   nIn = sqlcipher3_value_bytes(argv[0]);
86829   assert( zIn==sqlcipher3_value_text(argv[0]) );
86830   if( argc==1 ){
86831     static const unsigned char lenOne[] = { 1 };
86832     static unsigned char * const azOne[] = { (u8*)" " };
86833     nChar = 1;
86834     aLen = (u8*)lenOne;
86835     azChar = (unsigned char **)azOne;
86836     zCharSet = 0;
86837   }else if( (zCharSet = sqlcipher3_value_text(argv[1]))==0 ){
86838     return;
86839   }else{
86840     const unsigned char *z;
86841     for(z=zCharSet, nChar=0; *z; nChar++){
86842       SQLCIPHER_SKIP_UTF8(z);
86843     }
86844     if( nChar>0 ){
86845       azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
86846       if( azChar==0 ){
86847         return;
86848       }
86849       aLen = (unsigned char*)&azChar[nChar];
86850       for(z=zCharSet, nChar=0; *z; nChar++){
86851         azChar[nChar] = (unsigned char *)z;
86852         SQLCIPHER_SKIP_UTF8(z);
86853         aLen[nChar] = (u8)(z - azChar[nChar]);
86854       }
86855     }
86856   }
86857   if( nChar>0 ){
86858     flags = SQLCIPHER_PTR_TO_INT(sqlcipher3_user_data(context));
86859     if( flags & 1 ){
86860       while( nIn>0 ){
86861         int len = 0;
86862         for(i=0; i<nChar; i++){
86863           len = aLen[i];
86864           if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
86865         }
86866         if( i>=nChar ) break;
86867         zIn += len;
86868         nIn -= len;
86869       }
86870     }
86871     if( flags & 2 ){
86872       while( nIn>0 ){
86873         int len = 0;
86874         for(i=0; i<nChar; i++){
86875           len = aLen[i];
86876           if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
86877         }
86878         if( i>=nChar ) break;
86879         nIn -= len;
86880       }
86881     }
86882     if( zCharSet ){
86883       sqlcipher3_free(azChar);
86884     }
86885   }
86886   sqlcipher3_result_text(context, (char*)zIn, nIn, SQLCIPHER_TRANSIENT);
86887 }
86888
86889
86890 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
86891 ** is only available if the SQLCIPHER_SOUNDEX compile-time option is used
86892 ** when SQLite is built.
86893 */
86894 #ifdef SQLCIPHER_SOUNDEX
86895 /*
86896 ** Compute the soundex encoding of a word.
86897 **
86898 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
86899 ** soundex encoding of the string X. 
86900 */
86901 static void soundexFunc(
86902   sqlcipher3_context *context,
86903   int argc,
86904   sqlcipher3_value **argv
86905 ){
86906   char zResult[8];
86907   const u8 *zIn;
86908   int i, j;
86909   static const unsigned char iCode[] = {
86910     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
86911     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
86912     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
86913     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
86914     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
86915     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
86916     0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
86917     1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
86918   };
86919   assert( argc==1 );
86920   zIn = (u8*)sqlcipher3_value_text(argv[0]);
86921   if( zIn==0 ) zIn = (u8*)"";
86922   for(i=0; zIn[i] && !sqlcipher3Isalpha(zIn[i]); i++){}
86923   if( zIn[i] ){
86924     u8 prevcode = iCode[zIn[i]&0x7f];
86925     zResult[0] = sqlcipher3Toupper(zIn[i]);
86926     for(j=1; j<4 && zIn[i]; i++){
86927       int code = iCode[zIn[i]&0x7f];
86928       if( code>0 ){
86929         if( code!=prevcode ){
86930           prevcode = code;
86931           zResult[j++] = code + '0';
86932         }
86933       }else{
86934         prevcode = 0;
86935       }
86936     }
86937     while( j<4 ){
86938       zResult[j++] = '0';
86939     }
86940     zResult[j] = 0;
86941     sqlcipher3_result_text(context, zResult, 4, SQLCIPHER_TRANSIENT);
86942   }else{
86943     /* IMP: R-64894-50321 The string "?000" is returned if the argument
86944     ** is NULL or contains no ASCII alphabetic characters. */
86945     sqlcipher3_result_text(context, "?000", 4, SQLCIPHER_STATIC);
86946   }
86947 }
86948 #endif /* SQLCIPHER_SOUNDEX */
86949
86950 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
86951 /*
86952 ** A function that loads a shared-library extension then returns NULL.
86953 */
86954 static void loadExt(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
86955   const char *zFile = (const char *)sqlcipher3_value_text(argv[0]);
86956   const char *zProc;
86957   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
86958   char *zErrMsg = 0;
86959
86960   if( argc==2 ){
86961     zProc = (const char *)sqlcipher3_value_text(argv[1]);
86962   }else{
86963     zProc = 0;
86964   }
86965   if( zFile && sqlcipher3_load_extension(db, zFile, zProc, &zErrMsg) ){
86966     sqlcipher3_result_error(context, zErrMsg, -1);
86967     sqlcipher3_free(zErrMsg);
86968   }
86969 }
86970 #endif
86971
86972
86973 /*
86974 ** An instance of the following structure holds the context of a
86975 ** sum() or avg() aggregate computation.
86976 */
86977 typedef struct SumCtx SumCtx;
86978 struct SumCtx {
86979   double rSum;      /* Floating point sum */
86980   i64 iSum;         /* Integer sum */   
86981   i64 cnt;          /* Number of elements summed */
86982   u8 overflow;      /* True if integer overflow seen */
86983   u8 approx;        /* True if non-integer value was input to the sum */
86984 };
86985
86986 /*
86987 ** Routines used to compute the sum, average, and total.
86988 **
86989 ** The SUM() function follows the (broken) SQL standard which means
86990 ** that it returns NULL if it sums over no inputs.  TOTAL returns
86991 ** 0.0 in that case.  In addition, TOTAL always returns a float where
86992 ** SUM might return an integer if it never encounters a floating point
86993 ** value.  TOTAL never fails, but SUM might through an exception if
86994 ** it overflows an integer.
86995 */
86996 static void sumStep(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
86997   SumCtx *p;
86998   int type;
86999   assert( argc==1 );
87000   UNUSED_PARAMETER(argc);
87001   p = sqlcipher3_aggregate_context(context, sizeof(*p));
87002   type = sqlcipher3_value_numeric_type(argv[0]);
87003   if( p && type!=SQLCIPHER_NULL ){
87004     p->cnt++;
87005     if( type==SQLCIPHER_INTEGER ){
87006       i64 v = sqlcipher3_value_int64(argv[0]);
87007       p->rSum += v;
87008       if( (p->approx|p->overflow)==0 && sqlcipher3AddInt64(&p->iSum, v) ){
87009         p->overflow = 1;
87010       }
87011     }else{
87012       p->rSum += sqlcipher3_value_double(argv[0]);
87013       p->approx = 1;
87014     }
87015   }
87016 }
87017 static void sumFinalize(sqlcipher3_context *context){
87018   SumCtx *p;
87019   p = sqlcipher3_aggregate_context(context, 0);
87020   if( p && p->cnt>0 ){
87021     if( p->overflow ){
87022       sqlcipher3_result_error(context,"integer overflow",-1);
87023     }else if( p->approx ){
87024       sqlcipher3_result_double(context, p->rSum);
87025     }else{
87026       sqlcipher3_result_int64(context, p->iSum);
87027     }
87028   }
87029 }
87030 static void avgFinalize(sqlcipher3_context *context){
87031   SumCtx *p;
87032   p = sqlcipher3_aggregate_context(context, 0);
87033   if( p && p->cnt>0 ){
87034     sqlcipher3_result_double(context, p->rSum/(double)p->cnt);
87035   }
87036 }
87037 static void totalFinalize(sqlcipher3_context *context){
87038   SumCtx *p;
87039   p = sqlcipher3_aggregate_context(context, 0);
87040   /* (double)0 In case of SQLCIPHER_OMIT_FLOATING_POINT... */
87041   sqlcipher3_result_double(context, p ? p->rSum : (double)0);
87042 }
87043
87044 /*
87045 ** The following structure keeps track of state information for the
87046 ** count() aggregate function.
87047 */
87048 typedef struct CountCtx CountCtx;
87049 struct CountCtx {
87050   i64 n;
87051 };
87052
87053 /*
87054 ** Routines to implement the count() aggregate function.
87055 */
87056 static void countStep(sqlcipher3_context *context, int argc, sqlcipher3_value **argv){
87057   CountCtx *p;
87058   p = sqlcipher3_aggregate_context(context, sizeof(*p));
87059   if( (argc==0 || SQLCIPHER_NULL!=sqlcipher3_value_type(argv[0])) && p ){
87060     p->n++;
87061   }
87062
87063 #ifndef SQLCIPHER_OMIT_DEPRECATED
87064   /* The sqlcipher3_aggregate_count() function is deprecated.  But just to make
87065   ** sure it still operates correctly, verify that its count agrees with our 
87066   ** internal count when using count(*) and when the total count can be
87067   ** expressed as a 32-bit integer. */
87068   assert( argc==1 || p==0 || p->n>0x7fffffff
87069           || p->n==sqlcipher3_aggregate_count(context) );
87070 #endif
87071 }   
87072 static void countFinalize(sqlcipher3_context *context){
87073   CountCtx *p;
87074   p = sqlcipher3_aggregate_context(context, 0);
87075   sqlcipher3_result_int64(context, p ? p->n : 0);
87076 }
87077
87078 /*
87079 ** Routines to implement min() and max() aggregate functions.
87080 */
87081 static void minmaxStep(
87082   sqlcipher3_context *context, 
87083   int NotUsed, 
87084   sqlcipher3_value **argv
87085 ){
87086   Mem *pArg  = (Mem *)argv[0];
87087   Mem *pBest;
87088   UNUSED_PARAMETER(NotUsed);
87089
87090   if( sqlcipher3_value_type(argv[0])==SQLCIPHER_NULL ) return;
87091   pBest = (Mem *)sqlcipher3_aggregate_context(context, sizeof(*pBest));
87092   if( !pBest ) return;
87093
87094   if( pBest->flags ){
87095     int max;
87096     int cmp;
87097     CollSeq *pColl = sqlcipher3GetFuncCollSeq(context);
87098     /* This step function is used for both the min() and max() aggregates,
87099     ** the only difference between the two being that the sense of the
87100     ** comparison is inverted. For the max() aggregate, the
87101     ** sqlcipher3_user_data() function returns (void *)-1. For min() it
87102     ** returns (void *)db, where db is the sqlcipher3* database pointer.
87103     ** Therefore the next statement sets variable 'max' to 1 for the max()
87104     ** aggregate, or 0 for min().
87105     */
87106     max = sqlcipher3_user_data(context)!=0;
87107     cmp = sqlcipher3MemCompare(pBest, pArg, pColl);
87108     if( (max && cmp<0) || (!max && cmp>0) ){
87109       sqlcipher3VdbeMemCopy(pBest, pArg);
87110     }
87111   }else{
87112     sqlcipher3VdbeMemCopy(pBest, pArg);
87113   }
87114 }
87115 static void minMaxFinalize(sqlcipher3_context *context){
87116   sqlcipher3_value *pRes;
87117   pRes = (sqlcipher3_value *)sqlcipher3_aggregate_context(context, 0);
87118   if( pRes ){
87119     if( ALWAYS(pRes->flags) ){
87120       sqlcipher3_result_value(context, pRes);
87121     }
87122     sqlcipher3VdbeMemRelease(pRes);
87123   }
87124 }
87125
87126 /*
87127 ** group_concat(EXPR, ?SEPARATOR?)
87128 */
87129 static void groupConcatStep(
87130   sqlcipher3_context *context,
87131   int argc,
87132   sqlcipher3_value **argv
87133 ){
87134   const char *zVal;
87135   StrAccum *pAccum;
87136   const char *zSep;
87137   int nVal, nSep;
87138   assert( argc==1 || argc==2 );
87139   if( sqlcipher3_value_type(argv[0])==SQLCIPHER_NULL ) return;
87140   pAccum = (StrAccum*)sqlcipher3_aggregate_context(context, sizeof(*pAccum));
87141
87142   if( pAccum ){
87143     sqlcipher3 *db = sqlcipher3_context_db_handle(context);
87144     int firstTerm = pAccum->useMalloc==0;
87145     pAccum->useMalloc = 2;
87146     pAccum->mxAlloc = db->aLimit[SQLCIPHER_LIMIT_LENGTH];
87147     if( !firstTerm ){
87148       if( argc==2 ){
87149         zSep = (char*)sqlcipher3_value_text(argv[1]);
87150         nSep = sqlcipher3_value_bytes(argv[1]);
87151       }else{
87152         zSep = ",";
87153         nSep = 1;
87154       }
87155       sqlcipher3StrAccumAppend(pAccum, zSep, nSep);
87156     }
87157     zVal = (char*)sqlcipher3_value_text(argv[0]);
87158     nVal = sqlcipher3_value_bytes(argv[0]);
87159     sqlcipher3StrAccumAppend(pAccum, zVal, nVal);
87160   }
87161 }
87162 static void groupConcatFinalize(sqlcipher3_context *context){
87163   StrAccum *pAccum;
87164   pAccum = sqlcipher3_aggregate_context(context, 0);
87165   if( pAccum ){
87166     if( pAccum->tooBig ){
87167       sqlcipher3_result_error_toobig(context);
87168     }else if( pAccum->mallocFailed ){
87169       sqlcipher3_result_error_nomem(context);
87170     }else{    
87171       sqlcipher3_result_text(context, sqlcipher3StrAccumFinish(pAccum), -1, 
87172                           sqlcipher3_free);
87173     }
87174   }
87175 }
87176
87177 /*
87178 ** This routine does per-connection function registration.  Most
87179 ** of the built-in functions above are part of the global function set.
87180 ** This routine only deals with those that are not global.
87181 */
87182 SQLCIPHER_PRIVATE void sqlcipher3RegisterBuiltinFunctions(sqlcipher3 *db){
87183   int rc = sqlcipher3_overload_function(db, "MATCH", 2);
87184 #ifndef OMIT_EXPORT
87185   extern void sqlcipher_exportFunc(sqlcipher3_context *, int, sqlcipher3_value **);
87186 #endif
87187   assert( rc==SQLCIPHER_NOMEM || rc==SQLCIPHER_OK );
87188   if( rc==SQLCIPHER_NOMEM ){
87189     db->mallocFailed = 1;
87190   }
87191 #ifndef OMIT_EXPORT
87192   sqlcipher3CreateFunc(db, "sqlcipher_export", 1, SQLCIPHER_TEXT, 0, sqlcipher_exportFunc, 0, 0, 0);
87193 #endif
87194 }
87195
87196 /*
87197 ** Set the LIKEOPT flag on the 2-argument function with the given name.
87198 */
87199 static void setLikeOptFlag(sqlcipher3 *db, const char *zName, u8 flagVal){
87200   FuncDef *pDef;
87201   pDef = sqlcipher3FindFunction(db, zName, sqlcipher3Strlen30(zName),
87202                              2, SQLCIPHER_UTF8, 0);
87203   if( ALWAYS(pDef) ){
87204     pDef->flags = flagVal;
87205   }
87206 }
87207
87208 /*
87209 ** Register the built-in LIKE and GLOB functions.  The caseSensitive
87210 ** parameter determines whether or not the LIKE operator is case
87211 ** sensitive.  GLOB is always case sensitive.
87212 */
87213 SQLCIPHER_PRIVATE void sqlcipher3RegisterLikeFunctions(sqlcipher3 *db, int caseSensitive){
87214   struct compareInfo *pInfo;
87215   if( caseSensitive ){
87216     pInfo = (struct compareInfo*)&likeInfoAlt;
87217   }else{
87218     pInfo = (struct compareInfo*)&likeInfoNorm;
87219   }
87220   sqlcipher3CreateFunc(db, "like", 2, SQLCIPHER_UTF8, pInfo, likeFunc, 0, 0, 0);
87221   sqlcipher3CreateFunc(db, "like", 3, SQLCIPHER_UTF8, pInfo, likeFunc, 0, 0, 0);
87222   sqlcipher3CreateFunc(db, "glob", 2, SQLCIPHER_UTF8, 
87223       (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0);
87224   setLikeOptFlag(db, "glob", SQLCIPHER_FUNC_LIKE | SQLCIPHER_FUNC_CASE);
87225   setLikeOptFlag(db, "like", 
87226       caseSensitive ? (SQLCIPHER_FUNC_LIKE | SQLCIPHER_FUNC_CASE) : SQLCIPHER_FUNC_LIKE);
87227 }
87228
87229 /*
87230 ** pExpr points to an expression which implements a function.  If
87231 ** it is appropriate to apply the LIKE optimization to that function
87232 ** then set aWc[0] through aWc[2] to the wildcard characters and
87233 ** return TRUE.  If the function is not a LIKE-style function then
87234 ** return FALSE.
87235 */
87236 SQLCIPHER_PRIVATE int sqlcipher3IsLikeFunction(sqlcipher3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
87237   FuncDef *pDef;
87238   if( pExpr->op!=TK_FUNCTION 
87239    || !pExpr->x.pList 
87240    || pExpr->x.pList->nExpr!=2
87241   ){
87242     return 0;
87243   }
87244   assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
87245   pDef = sqlcipher3FindFunction(db, pExpr->u.zToken, 
87246                              sqlcipher3Strlen30(pExpr->u.zToken),
87247                              2, SQLCIPHER_UTF8, 0);
87248   if( NEVER(pDef==0) || (pDef->flags & SQLCIPHER_FUNC_LIKE)==0 ){
87249     return 0;
87250   }
87251
87252   /* The memcpy() statement assumes that the wildcard characters are
87253   ** the first three statements in the compareInfo structure.  The
87254   ** asserts() that follow verify that assumption
87255   */
87256   memcpy(aWc, pDef->pUserData, 3);
87257   assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
87258   assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
87259   assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
87260   *pIsNocase = (pDef->flags & SQLCIPHER_FUNC_CASE)==0;
87261   return 1;
87262 }
87263
87264 /*
87265 ** All all of the FuncDef structures in the aBuiltinFunc[] array above
87266 ** to the global function hash table.  This occurs at start-time (as
87267 ** a consequence of calling sqlcipher3_initialize()).
87268 **
87269 ** After this routine runs
87270 */
87271 SQLCIPHER_PRIVATE void sqlcipher3RegisterGlobalFunctions(void){
87272   /*
87273   ** The following array holds FuncDef structures for all of the functions
87274   ** defined in this file.
87275   **
87276   ** The array cannot be constant since changes are made to the
87277   ** FuncDef.pHash elements at start-time.  The elements of this array
87278   ** are read-only after initialization is complete.
87279   */
87280   static SQLCIPHER_WSD FuncDef aBuiltinFunc[] = {
87281     FUNCTION(ltrim,              1, 1, 0, trimFunc         ),
87282     FUNCTION(ltrim,              2, 1, 0, trimFunc         ),
87283     FUNCTION(rtrim,              1, 2, 0, trimFunc         ),
87284     FUNCTION(rtrim,              2, 2, 0, trimFunc         ),
87285     FUNCTION(trim,               1, 3, 0, trimFunc         ),
87286     FUNCTION(trim,               2, 3, 0, trimFunc         ),
87287     FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
87288     FUNCTION(min,                0, 0, 1, 0                ),
87289     AGGREGATE(min,               1, 0, 1, minmaxStep,      minMaxFinalize ),
87290     FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
87291     FUNCTION(max,                0, 1, 1, 0                ),
87292     AGGREGATE(max,               1, 1, 1, minmaxStep,      minMaxFinalize ),
87293     FUNCTION(typeof,             1, 0, 0, typeofFunc       ),
87294     FUNCTION(length,             1, 0, 0, lengthFunc       ),
87295     FUNCTION(substr,             2, 0, 0, substrFunc       ),
87296     FUNCTION(substr,             3, 0, 0, substrFunc       ),
87297     FUNCTION(abs,                1, 0, 0, absFunc          ),
87298 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
87299     FUNCTION(round,              1, 0, 0, roundFunc        ),
87300     FUNCTION(round,              2, 0, 0, roundFunc        ),
87301 #endif
87302     FUNCTION(upper,              1, 0, 0, upperFunc        ),
87303     FUNCTION(lower,              1, 0, 0, lowerFunc        ),
87304     FUNCTION(coalesce,           1, 0, 0, 0                ),
87305     FUNCTION(coalesce,           0, 0, 0, 0                ),
87306 /*  FUNCTION(coalesce,          -1, 0, 0, ifnullFunc       ), */
87307     {-1,SQLCIPHER_UTF8,SQLCIPHER_FUNC_COALESCE,0,0,ifnullFunc,0,0,"coalesce",0,0},
87308     FUNCTION(hex,                1, 0, 0, hexFunc          ),
87309 /*  FUNCTION(ifnull,             2, 0, 0, ifnullFunc       ), */
87310     {2,SQLCIPHER_UTF8,SQLCIPHER_FUNC_COALESCE,0,0,ifnullFunc,0,0,"ifnull",0,0},
87311     FUNCTION(random,             0, 0, 0, randomFunc       ),
87312     FUNCTION(randomblob,         1, 0, 0, randomBlob       ),
87313     FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
87314     FUNCTION(sqlcipher_version,     0, 0, 0, versionFunc      ),
87315     FUNCTION(sqlcipher_source_id,   0, 0, 0, sourceidFunc     ),
87316     FUNCTION(sqlcipher_log,         2, 0, 0, errlogFunc       ),
87317 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
87318     FUNCTION(sqlcipher_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
87319     FUNCTION(sqlcipher_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
87320 #endif /* SQLCIPHER_OMIT_COMPILEOPTION_DIAGS */
87321     FUNCTION(quote,              1, 0, 0, quoteFunc        ),
87322     FUNCTION(last_insert_rowid,  0, 0, 0, last_insert_rowid),
87323     FUNCTION(changes,            0, 0, 0, changes          ),
87324     FUNCTION(total_changes,      0, 0, 0, total_changes    ),
87325     FUNCTION(replace,            3, 0, 0, replaceFunc      ),
87326     FUNCTION(zeroblob,           1, 0, 0, zeroblobFunc     ),
87327   #ifdef SQLCIPHER_SOUNDEX
87328     FUNCTION(soundex,            1, 0, 0, soundexFunc      ),
87329   #endif
87330   #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
87331     FUNCTION(load_extension,     1, 0, 0, loadExt          ),
87332     FUNCTION(load_extension,     2, 0, 0, loadExt          ),
87333   #endif
87334     AGGREGATE(sum,               1, 0, 0, sumStep,         sumFinalize    ),
87335     AGGREGATE(total,             1, 0, 0, sumStep,         totalFinalize    ),
87336     AGGREGATE(avg,               1, 0, 0, sumStep,         avgFinalize    ),
87337  /* AGGREGATE(count,             0, 0, 0, countStep,       countFinalize  ), */
87338     {0,SQLCIPHER_UTF8,SQLCIPHER_FUNC_COUNT,0,0,0,countStep,countFinalize,"count",0,0},
87339     AGGREGATE(count,             1, 0, 0, countStep,       countFinalize  ),
87340     AGGREGATE(group_concat,      1, 0, 0, groupConcatStep, groupConcatFinalize),
87341     AGGREGATE(group_concat,      2, 0, 0, groupConcatStep, groupConcatFinalize),
87342   
87343     LIKEFUNC(glob, 2, &globInfo, SQLCIPHER_FUNC_LIKE|SQLCIPHER_FUNC_CASE),
87344   #ifdef SQLCIPHER_CASE_SENSITIVE_LIKE
87345     LIKEFUNC(like, 2, &likeInfoAlt, SQLCIPHER_FUNC_LIKE|SQLCIPHER_FUNC_CASE),
87346     LIKEFUNC(like, 3, &likeInfoAlt, SQLCIPHER_FUNC_LIKE|SQLCIPHER_FUNC_CASE),
87347   #else
87348     LIKEFUNC(like, 2, &likeInfoNorm, SQLCIPHER_FUNC_LIKE),
87349     LIKEFUNC(like, 3, &likeInfoNorm, SQLCIPHER_FUNC_LIKE),
87350   #endif
87351   };
87352
87353   int i;
87354   FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlcipher3GlobalFunctions);
87355   FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aBuiltinFunc);
87356
87357   for(i=0; i<ArraySize(aBuiltinFunc); i++){
87358     sqlcipher3FuncDefInsert(pHash, &aFunc[i]);
87359   }
87360   sqlcipher3RegisterDateTimeFunctions();
87361 #ifndef SQLCIPHER_OMIT_ALTERTABLE
87362   sqlcipher3AlterFunctions();
87363 #endif
87364 }
87365
87366 /************** End of func.c ************************************************/
87367 /************** Begin file fkey.c ********************************************/
87368 /*
87369 **
87370 ** The author disclaims copyright to this source code.  In place of
87371 ** a legal notice, here is a blessing:
87372 **
87373 **    May you do good and not evil.
87374 **    May you find forgiveness for yourself and forgive others.
87375 **    May you share freely, never taking more than you give.
87376 **
87377 *************************************************************************
87378 ** This file contains code used by the compiler to add foreign key
87379 ** support to compiled SQL statements.
87380 */
87381
87382 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
87383 #ifndef SQLCIPHER_OMIT_TRIGGER
87384
87385 /*
87386 ** Deferred and Immediate FKs
87387 ** --------------------------
87388 **
87389 ** Foreign keys in SQLite come in two flavours: deferred and immediate.
87390 ** If an immediate foreign key constraint is violated, SQLCIPHER_CONSTRAINT
87391 ** is returned and the current statement transaction rolled back. If a 
87392 ** deferred foreign key constraint is violated, no action is taken 
87393 ** immediately. However if the application attempts to commit the 
87394 ** transaction before fixing the constraint violation, the attempt fails.
87395 **
87396 ** Deferred constraints are implemented using a simple counter associated
87397 ** with the database handle. The counter is set to zero each time a 
87398 ** database transaction is opened. Each time a statement is executed 
87399 ** that causes a foreign key violation, the counter is incremented. Each
87400 ** time a statement is executed that removes an existing violation from
87401 ** the database, the counter is decremented. When the transaction is
87402 ** committed, the commit fails if the current value of the counter is
87403 ** greater than zero. This scheme has two big drawbacks:
87404 **
87405 **   * When a commit fails due to a deferred foreign key constraint, 
87406 **     there is no way to tell which foreign constraint is not satisfied,
87407 **     or which row it is not satisfied for.
87408 **
87409 **   * If the database contains foreign key violations when the 
87410 **     transaction is opened, this may cause the mechanism to malfunction.
87411 **
87412 ** Despite these problems, this approach is adopted as it seems simpler
87413 ** than the alternatives.
87414 **
87415 ** INSERT operations:
87416 **
87417 **   I.1) For each FK for which the table is the child table, search
87418 **        the parent table for a match. If none is found increment the
87419 **        constraint counter.
87420 **
87421 **   I.2) For each FK for which the table is the parent table, 
87422 **        search the child table for rows that correspond to the new
87423 **        row in the parent table. Decrement the counter for each row
87424 **        found (as the constraint is now satisfied).
87425 **
87426 ** DELETE operations:
87427 **
87428 **   D.1) For each FK for which the table is the child table, 
87429 **        search the parent table for a row that corresponds to the 
87430 **        deleted row in the child table. If such a row is not found, 
87431 **        decrement the counter.
87432 **
87433 **   D.2) For each FK for which the table is the parent table, search 
87434 **        the child table for rows that correspond to the deleted row 
87435 **        in the parent table. For each found increment the counter.
87436 **
87437 ** UPDATE operations:
87438 **
87439 **   An UPDATE command requires that all 4 steps above are taken, but only
87440 **   for FK constraints for which the affected columns are actually 
87441 **   modified (values must be compared at runtime).
87442 **
87443 ** Note that I.1 and D.1 are very similar operations, as are I.2 and D.2.
87444 ** This simplifies the implementation a bit.
87445 **
87446 ** For the purposes of immediate FK constraints, the OR REPLACE conflict
87447 ** resolution is considered to delete rows before the new row is inserted.
87448 ** If a delete caused by OR REPLACE violates an FK constraint, an exception
87449 ** is thrown, even if the FK constraint would be satisfied after the new 
87450 ** row is inserted.
87451 **
87452 ** Immediate constraints are usually handled similarly. The only difference 
87453 ** is that the counter used is stored as part of each individual statement
87454 ** object (struct Vdbe). If, after the statement has run, its immediate
87455 ** constraint counter is greater than zero, it returns SQLCIPHER_CONSTRAINT
87456 ** and the statement transaction is rolled back. An exception is an INSERT
87457 ** statement that inserts a single row only (no triggers). In this case,
87458 ** instead of using a counter, an exception is thrown immediately if the
87459 ** INSERT violates a foreign key constraint. This is necessary as such
87460 ** an INSERT does not open a statement transaction.
87461 **
87462 ** TODO: How should dropping a table be handled? How should renaming a 
87463 ** table be handled?
87464 **
87465 **
87466 ** Query API Notes
87467 ** ---------------
87468 **
87469 ** Before coding an UPDATE or DELETE row operation, the code-generator
87470 ** for those two operations needs to know whether or not the operation
87471 ** requires any FK processing and, if so, which columns of the original
87472 ** row are required by the FK processing VDBE code (i.e. if FKs were
87473 ** implemented using triggers, which of the old.* columns would be 
87474 ** accessed). No information is required by the code-generator before
87475 ** coding an INSERT operation. The functions used by the UPDATE/DELETE
87476 ** generation code to query for this information are:
87477 **
87478 **   sqlcipher3FkRequired() - Test to see if FK processing is required.
87479 **   sqlcipher3FkOldmask()  - Query for the set of required old.* columns.
87480 **
87481 **
87482 ** Externally accessible module functions
87483 ** --------------------------------------
87484 **
87485 **   sqlcipher3FkCheck()    - Check for foreign key violations.
87486 **   sqlcipher3FkActions()  - Code triggers for ON UPDATE/ON DELETE actions.
87487 **   sqlcipher3FkDelete()   - Delete an FKey structure.
87488 */
87489
87490 /*
87491 ** VDBE Calling Convention
87492 ** -----------------------
87493 **
87494 ** Example:
87495 **
87496 **   For the following INSERT statement:
87497 **
87498 **     CREATE TABLE t1(a, b INTEGER PRIMARY KEY, c);
87499 **     INSERT INTO t1 VALUES(1, 2, 3.1);
87500 **
87501 **   Register (x):        2    (type integer)
87502 **   Register (x+1):      1    (type integer)
87503 **   Register (x+2):      NULL (type NULL)
87504 **   Register (x+3):      3.1  (type real)
87505 */
87506
87507 /*
87508 ** A foreign key constraint requires that the key columns in the parent
87509 ** table are collectively subject to a UNIQUE or PRIMARY KEY constraint.
87510 ** Given that pParent is the parent table for foreign key constraint pFKey, 
87511 ** search the schema a unique index on the parent key columns. 
87512 **
87513 ** If successful, zero is returned. If the parent key is an INTEGER PRIMARY 
87514 ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx 
87515 ** is set to point to the unique index. 
87516 ** 
87517 ** If the parent key consists of a single column (the foreign key constraint
87518 ** is not a composite foreign key), output variable *paiCol is set to NULL.
87519 ** Otherwise, it is set to point to an allocated array of size N, where
87520 ** N is the number of columns in the parent key. The first element of the
87521 ** array is the index of the child table column that is mapped by the FK
87522 ** constraint to the parent table column stored in the left-most column
87523 ** of index *ppIdx. The second element of the array is the index of the
87524 ** child table column that corresponds to the second left-most column of
87525 ** *ppIdx, and so on.
87526 **
87527 ** If the required index cannot be found, either because:
87528 **
87529 **   1) The named parent key columns do not exist, or
87530 **
87531 **   2) The named parent key columns do exist, but are not subject to a
87532 **      UNIQUE or PRIMARY KEY constraint, or
87533 **
87534 **   3) No parent key columns were provided explicitly as part of the
87535 **      foreign key definition, and the parent table does not have a
87536 **      PRIMARY KEY, or
87537 **
87538 **   4) No parent key columns were provided explicitly as part of the
87539 **      foreign key definition, and the PRIMARY KEY of the parent table 
87540 **      consists of a a different number of columns to the child key in 
87541 **      the child table.
87542 **
87543 ** then non-zero is returned, and a "foreign key mismatch" error loaded
87544 ** into pParse. If an OOM error occurs, non-zero is returned and the
87545 ** pParse->db->mallocFailed flag is set.
87546 */
87547 static int locateFkeyIndex(
87548   Parse *pParse,                  /* Parse context to store any error in */
87549   Table *pParent,                 /* Parent table of FK constraint pFKey */
87550   FKey *pFKey,                    /* Foreign key to find index for */
87551   Index **ppIdx,                  /* OUT: Unique index on parent table */
87552   int **paiCol                    /* OUT: Map of index columns in pFKey */
87553 ){
87554   Index *pIdx = 0;                    /* Value to return via *ppIdx */
87555   int *aiCol = 0;                     /* Value to return via *paiCol */
87556   int nCol = pFKey->nCol;             /* Number of columns in parent key */
87557   char *zKey = pFKey->aCol[0].zCol;   /* Name of left-most parent key column */
87558
87559   /* The caller is responsible for zeroing output parameters. */
87560   assert( ppIdx && *ppIdx==0 );
87561   assert( !paiCol || *paiCol==0 );
87562   assert( pParse );
87563
87564   /* If this is a non-composite (single column) foreign key, check if it 
87565   ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx 
87566   ** and *paiCol set to zero and return early. 
87567   **
87568   ** Otherwise, for a composite foreign key (more than one column), allocate
87569   ** space for the aiCol array (returned via output parameter *paiCol).
87570   ** Non-composite foreign keys do not require the aiCol array.
87571   */
87572   if( nCol==1 ){
87573     /* The FK maps to the IPK if any of the following are true:
87574     **
87575     **   1) There is an INTEGER PRIMARY KEY column and the FK is implicitly 
87576     **      mapped to the primary key of table pParent, or
87577     **   2) The FK is explicitly mapped to a column declared as INTEGER
87578     **      PRIMARY KEY.
87579     */
87580     if( pParent->iPKey>=0 ){
87581       if( !zKey ) return 0;
87582       if( !sqlcipher3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
87583     }
87584   }else if( paiCol ){
87585     assert( nCol>1 );
87586     aiCol = (int *)sqlcipher3DbMallocRaw(pParse->db, nCol*sizeof(int));
87587     if( !aiCol ) return 1;
87588     *paiCol = aiCol;
87589   }
87590
87591   for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
87592     if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){ 
87593       /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number
87594       ** of columns. If each indexed column corresponds to a foreign key
87595       ** column of pFKey, then this index is a winner.  */
87596
87597       if( zKey==0 ){
87598         /* If zKey is NULL, then this foreign key is implicitly mapped to 
87599         ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be 
87600         ** identified by the test (Index.autoIndex==2).  */
87601         if( pIdx->autoIndex==2 ){
87602           if( aiCol ){
87603             int i;
87604             for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
87605           }
87606           break;
87607         }
87608       }else{
87609         /* If zKey is non-NULL, then this foreign key was declared to
87610         ** map to an explicit list of columns in table pParent. Check if this
87611         ** index matches those columns. Also, check that the index uses
87612         ** the default collation sequences for each column. */
87613         int i, j;
87614         for(i=0; i<nCol; i++){
87615           int iCol = pIdx->aiColumn[i];     /* Index of column in parent tbl */
87616           char *zDfltColl;                  /* Def. collation for column */
87617           char *zIdxCol;                    /* Name of indexed column */
87618
87619           /* If the index uses a collation sequence that is different from
87620           ** the default collation sequence for the column, this index is
87621           ** unusable. Bail out early in this case.  */
87622           zDfltColl = pParent->aCol[iCol].zColl;
87623           if( !zDfltColl ){
87624             zDfltColl = "BINARY";
87625           }
87626           if( sqlcipher3StrICmp(pIdx->azColl[i], zDfltColl) ) break;
87627
87628           zIdxCol = pParent->aCol[iCol].zName;
87629           for(j=0; j<nCol; j++){
87630             if( sqlcipher3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){
87631               if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom;
87632               break;
87633             }
87634           }
87635           if( j==nCol ) break;
87636         }
87637         if( i==nCol ) break;      /* pIdx is usable */
87638       }
87639     }
87640   }
87641
87642   if( !pIdx ){
87643     if( !pParse->disableTriggers ){
87644       sqlcipher3ErrorMsg(pParse, "foreign key mismatch");
87645     }
87646     sqlcipher3DbFree(pParse->db, aiCol);
87647     return 1;
87648   }
87649
87650   *ppIdx = pIdx;
87651   return 0;
87652 }
87653
87654 /*
87655 ** This function is called when a row is inserted into or deleted from the 
87656 ** child table of foreign key constraint pFKey. If an SQL UPDATE is executed 
87657 ** on the child table of pFKey, this function is invoked twice for each row
87658 ** affected - once to "delete" the old row, and then again to "insert" the
87659 ** new row.
87660 **
87661 ** Each time it is called, this function generates VDBE code to locate the
87662 ** row in the parent table that corresponds to the row being inserted into 
87663 ** or deleted from the child table. If the parent row can be found, no 
87664 ** special action is taken. Otherwise, if the parent row can *not* be
87665 ** found in the parent table:
87666 **
87667 **   Operation | FK type   | Action taken
87668 **   --------------------------------------------------------------------------
87669 **   INSERT      immediate   Increment the "immediate constraint counter".
87670 **
87671 **   DELETE      immediate   Decrement the "immediate constraint counter".
87672 **
87673 **   INSERT      deferred    Increment the "deferred constraint counter".
87674 **
87675 **   DELETE      deferred    Decrement the "deferred constraint counter".
87676 **
87677 ** These operations are identified in the comment at the top of this file 
87678 ** (fkey.c) as "I.1" and "D.1".
87679 */
87680 static void fkLookupParent(
87681   Parse *pParse,        /* Parse context */
87682   int iDb,              /* Index of database housing pTab */
87683   Table *pTab,          /* Parent table of FK pFKey */
87684   Index *pIdx,          /* Unique index on parent key columns in pTab */
87685   FKey *pFKey,          /* Foreign key constraint */
87686   int *aiCol,           /* Map from parent key columns to child table columns */
87687   int regData,          /* Address of array containing child table row */
87688   int nIncr,            /* Increment constraint counter by this */
87689   int isIgnore          /* If true, pretend pTab contains all NULL values */
87690 ){
87691   int i;                                    /* Iterator variable */
87692   Vdbe *v = sqlcipher3GetVdbe(pParse);         /* Vdbe to add code to */
87693   int iCur = pParse->nTab - 1;              /* Cursor number to use */
87694   int iOk = sqlcipher3VdbeMakeLabel(v);        /* jump here if parent key found */
87695
87696   /* If nIncr is less than zero, then check at runtime if there are any
87697   ** outstanding constraints to resolve. If there are not, there is no need
87698   ** to check if deleting this row resolves any outstanding violations.
87699   **
87700   ** Check if any of the key columns in the child table row are NULL. If 
87701   ** any are, then the constraint is considered satisfied. No need to 
87702   ** search for a matching row in the parent table.  */
87703   if( nIncr<0 ){
87704     sqlcipher3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
87705   }
87706   for(i=0; i<pFKey->nCol; i++){
87707     int iReg = aiCol[i] + regData + 1;
87708     sqlcipher3VdbeAddOp2(v, OP_IsNull, iReg, iOk);
87709   }
87710
87711   if( isIgnore==0 ){
87712     if( pIdx==0 ){
87713       /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
87714       ** column of the parent table (table pTab).  */
87715       int iMustBeInt;               /* Address of MustBeInt instruction */
87716       int regTemp = sqlcipher3GetTempReg(pParse);
87717   
87718       /* Invoke MustBeInt to coerce the child key value to an integer (i.e. 
87719       ** apply the affinity of the parent key). If this fails, then there
87720       ** is no matching parent key. Before using MustBeInt, make a copy of
87721       ** the value. Otherwise, the value inserted into the child key column
87722       ** will have INTEGER affinity applied to it, which may not be correct.  */
87723       sqlcipher3VdbeAddOp2(v, OP_SCopy, aiCol[0]+1+regData, regTemp);
87724       iMustBeInt = sqlcipher3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);
87725   
87726       /* If the parent table is the same as the child table, and we are about
87727       ** to increment the constraint-counter (i.e. this is an INSERT operation),
87728       ** then check if the row being inserted matches itself. If so, do not
87729       ** increment the constraint-counter.  */
87730       if( pTab==pFKey->pFrom && nIncr==1 ){
87731         sqlcipher3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp);
87732       }
87733   
87734       sqlcipher3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
87735       sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp);
87736       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, iOk);
87737       sqlcipher3VdbeJumpHere(v, sqlcipher3VdbeCurrentAddr(v)-2);
87738       sqlcipher3VdbeJumpHere(v, iMustBeInt);
87739       sqlcipher3ReleaseTempReg(pParse, regTemp);
87740     }else{
87741       int nCol = pFKey->nCol;
87742       int regTemp = sqlcipher3GetTempRange(pParse, nCol);
87743       int regRec = sqlcipher3GetTempReg(pParse);
87744       KeyInfo *pKey = sqlcipher3IndexKeyinfo(pParse, pIdx);
87745   
87746       sqlcipher3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
87747       sqlcipher3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);
87748       for(i=0; i<nCol; i++){
87749         sqlcipher3VdbeAddOp2(v, OP_Copy, aiCol[i]+1+regData, regTemp+i);
87750       }
87751   
87752       /* If the parent table is the same as the child table, and we are about
87753       ** to increment the constraint-counter (i.e. this is an INSERT operation),
87754       ** then check if the row being inserted matches itself. If so, do not
87755       ** increment the constraint-counter. 
87756       **
87757       ** If any of the parent-key values are NULL, then the row cannot match 
87758       ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any
87759       ** of the parent-key values are NULL (at this point it is known that
87760       ** none of the child key values are).
87761       */
87762       if( pTab==pFKey->pFrom && nIncr==1 ){
87763         int iJump = sqlcipher3VdbeCurrentAddr(v) + nCol + 1;
87764         for(i=0; i<nCol; i++){
87765           int iChild = aiCol[i]+1+regData;
87766           int iParent = pIdx->aiColumn[i]+1+regData;
87767           assert( aiCol[i]!=pTab->iPKey );
87768           if( pIdx->aiColumn[i]==pTab->iPKey ){
87769             /* The parent key is a composite key that includes the IPK column */
87770             iParent = regData;
87771           }
87772           sqlcipher3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent);
87773           sqlcipher3VdbeChangeP5(v, SQLCIPHER_JUMPIFNULL);
87774         }
87775         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, iOk);
87776       }
87777   
87778       sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
87779       sqlcipher3VdbeChangeP4(v, -1, sqlcipher3IndexAffinityStr(v,pIdx), P4_TRANSIENT);
87780       sqlcipher3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0);
87781   
87782       sqlcipher3ReleaseTempReg(pParse, regRec);
87783       sqlcipher3ReleaseTempRange(pParse, regTemp, nCol);
87784     }
87785   }
87786
87787   if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){
87788     /* Special case: If this is an INSERT statement that will insert exactly
87789     ** one row into the table, raise a constraint immediately instead of
87790     ** incrementing a counter. This is necessary as the VM code is being
87791     ** generated for will not open a statement transaction.  */
87792     assert( nIncr==1 );
87793     sqlcipher3HaltConstraint(
87794         pParse, OE_Abort, "foreign key constraint failed", P4_STATIC
87795     );
87796   }else{
87797     if( nIncr>0 && pFKey->isDeferred==0 ){
87798       sqlcipher3ParseToplevel(pParse)->mayAbort = 1;
87799     }
87800     sqlcipher3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
87801   }
87802
87803   sqlcipher3VdbeResolveLabel(v, iOk);
87804   sqlcipher3VdbeAddOp1(v, OP_Close, iCur);
87805 }
87806
87807 /*
87808 ** This function is called to generate code executed when a row is deleted
87809 ** from the parent table of foreign key constraint pFKey and, if pFKey is 
87810 ** deferred, when a row is inserted into the same table. When generating
87811 ** code for an SQL UPDATE operation, this function may be called twice -
87812 ** once to "delete" the old row and once to "insert" the new row.
87813 **
87814 ** The code generated by this function scans through the rows in the child
87815 ** table that correspond to the parent table row being deleted or inserted.
87816 ** For each child row found, one of the following actions is taken:
87817 **
87818 **   Operation | FK type   | Action taken
87819 **   --------------------------------------------------------------------------
87820 **   DELETE      immediate   Increment the "immediate constraint counter".
87821 **                           Or, if the ON (UPDATE|DELETE) action is RESTRICT,
87822 **                           throw a "foreign key constraint failed" exception.
87823 **
87824 **   INSERT      immediate   Decrement the "immediate constraint counter".
87825 **
87826 **   DELETE      deferred    Increment the "deferred constraint counter".
87827 **                           Or, if the ON (UPDATE|DELETE) action is RESTRICT,
87828 **                           throw a "foreign key constraint failed" exception.
87829 **
87830 **   INSERT      deferred    Decrement the "deferred constraint counter".
87831 **
87832 ** These operations are identified in the comment at the top of this file 
87833 ** (fkey.c) as "I.2" and "D.2".
87834 */
87835 static void fkScanChildren(
87836   Parse *pParse,                  /* Parse context */
87837   SrcList *pSrc,                  /* SrcList containing the table to scan */
87838   Table *pTab,
87839   Index *pIdx,                    /* Foreign key index */
87840   FKey *pFKey,                    /* Foreign key relationship */
87841   int *aiCol,                     /* Map from pIdx cols to child table cols */
87842   int regData,                    /* Referenced table data starts here */
87843   int nIncr                       /* Amount to increment deferred counter by */
87844 ){
87845   sqlcipher3 *db = pParse->db;       /* Database handle */
87846   int i;                          /* Iterator variable */
87847   Expr *pWhere = 0;               /* WHERE clause to scan with */
87848   NameContext sNameContext;       /* Context used to resolve WHERE clause */
87849   WhereInfo *pWInfo;              /* Context used by sqlcipher3WhereXXX() */
87850   int iFkIfZero = 0;              /* Address of OP_FkIfZero */
87851   Vdbe *v = sqlcipher3GetVdbe(pParse);
87852
87853   assert( !pIdx || pIdx->pTable==pTab );
87854
87855   if( nIncr<0 ){
87856     iFkIfZero = sqlcipher3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
87857   }
87858
87859   /* Create an Expr object representing an SQL expression like:
87860   **
87861   **   <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
87862   **
87863   ** The collation sequence used for the comparison should be that of
87864   ** the parent key columns. The affinity of the parent key column should
87865   ** be applied to each child key value before the comparison takes place.
87866   */
87867   for(i=0; i<pFKey->nCol; i++){
87868     Expr *pLeft;                  /* Value from parent table row */
87869     Expr *pRight;                 /* Column ref to child table */
87870     Expr *pEq;                    /* Expression (pLeft = pRight) */
87871     int iCol;                     /* Index of column in child table */ 
87872     const char *zCol;             /* Name of column in child table */
87873
87874     pLeft = sqlcipher3Expr(db, TK_REGISTER, 0);
87875     if( pLeft ){
87876       /* Set the collation sequence and affinity of the LHS of each TK_EQ
87877       ** expression to the parent key column defaults.  */
87878       if( pIdx ){
87879         Column *pCol;
87880         iCol = pIdx->aiColumn[i];
87881         pCol = &pTab->aCol[iCol];
87882         if( pTab->iPKey==iCol ) iCol = -1;
87883         pLeft->iTable = regData+iCol+1;
87884         pLeft->affinity = pCol->affinity;
87885         pLeft->pColl = sqlcipher3LocateCollSeq(pParse, pCol->zColl);
87886       }else{
87887         pLeft->iTable = regData;
87888         pLeft->affinity = SQLCIPHER_AFF_INTEGER;
87889       }
87890     }
87891     iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
87892     assert( iCol>=0 );
87893     zCol = pFKey->pFrom->aCol[iCol].zName;
87894     pRight = sqlcipher3Expr(db, TK_ID, zCol);
87895     pEq = sqlcipher3PExpr(pParse, TK_EQ, pLeft, pRight, 0);
87896     pWhere = sqlcipher3ExprAnd(db, pWhere, pEq);
87897   }
87898
87899   /* If the child table is the same as the parent table, and this scan
87900   ** is taking place as part of a DELETE operation (operation D.2), omit the
87901   ** row being deleted from the scan by adding ($rowid != rowid) to the WHERE 
87902   ** clause, where $rowid is the rowid of the row being deleted.  */
87903   if( pTab==pFKey->pFrom && nIncr>0 ){
87904     Expr *pEq;                    /* Expression (pLeft = pRight) */
87905     Expr *pLeft;                  /* Value from parent table row */
87906     Expr *pRight;                 /* Column ref to child table */
87907     pLeft = sqlcipher3Expr(db, TK_REGISTER, 0);
87908     pRight = sqlcipher3Expr(db, TK_COLUMN, 0);
87909     if( pLeft && pRight ){
87910       pLeft->iTable = regData;
87911       pLeft->affinity = SQLCIPHER_AFF_INTEGER;
87912       pRight->iTable = pSrc->a[0].iCursor;
87913       pRight->iColumn = -1;
87914     }
87915     pEq = sqlcipher3PExpr(pParse, TK_NE, pLeft, pRight, 0);
87916     pWhere = sqlcipher3ExprAnd(db, pWhere, pEq);
87917   }
87918
87919   /* Resolve the references in the WHERE clause. */
87920   memset(&sNameContext, 0, sizeof(NameContext));
87921   sNameContext.pSrcList = pSrc;
87922   sNameContext.pParse = pParse;
87923   sqlcipher3ResolveExprNames(&sNameContext, pWhere);
87924
87925   /* Create VDBE to loop through the entries in pSrc that match the WHERE
87926   ** clause. If the constraint is not deferred, throw an exception for
87927   ** each row found. Otherwise, for deferred constraints, increment the
87928   ** deferred constraint counter by nIncr for each row selected.  */
87929   pWInfo = sqlcipher3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0);
87930   if( nIncr>0 && pFKey->isDeferred==0 ){
87931     sqlcipher3ParseToplevel(pParse)->mayAbort = 1;
87932   }
87933   sqlcipher3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
87934   if( pWInfo ){
87935     sqlcipher3WhereEnd(pWInfo);
87936   }
87937
87938   /* Clean up the WHERE clause constructed above. */
87939   sqlcipher3ExprDelete(db, pWhere);
87940   if( iFkIfZero ){
87941     sqlcipher3VdbeJumpHere(v, iFkIfZero);
87942   }
87943 }
87944
87945 /*
87946 ** This function returns a pointer to the head of a linked list of FK
87947 ** constraints for which table pTab is the parent table. For example,
87948 ** given the following schema:
87949 **
87950 **   CREATE TABLE t1(a PRIMARY KEY);
87951 **   CREATE TABLE t2(b REFERENCES t1(a);
87952 **
87953 ** Calling this function with table "t1" as an argument returns a pointer
87954 ** to the FKey structure representing the foreign key constraint on table
87955 ** "t2". Calling this function with "t2" as the argument would return a
87956 ** NULL pointer (as there are no FK constraints for which t2 is the parent
87957 ** table).
87958 */
87959 SQLCIPHER_PRIVATE FKey *sqlcipher3FkReferences(Table *pTab){
87960   int nName = sqlcipher3Strlen30(pTab->zName);
87961   return (FKey *)sqlcipher3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
87962 }
87963
87964 /*
87965 ** The second argument is a Trigger structure allocated by the 
87966 ** fkActionTrigger() routine. This function deletes the Trigger structure
87967 ** and all of its sub-components.
87968 **
87969 ** The Trigger structure or any of its sub-components may be allocated from
87970 ** the lookaside buffer belonging to database handle dbMem.
87971 */
87972 static void fkTriggerDelete(sqlcipher3 *dbMem, Trigger *p){
87973   if( p ){
87974     TriggerStep *pStep = p->step_list;
87975     sqlcipher3ExprDelete(dbMem, pStep->pWhere);
87976     sqlcipher3ExprListDelete(dbMem, pStep->pExprList);
87977     sqlcipher3SelectDelete(dbMem, pStep->pSelect);
87978     sqlcipher3ExprDelete(dbMem, p->pWhen);
87979     sqlcipher3DbFree(dbMem, p);
87980   }
87981 }
87982
87983 /*
87984 ** This function is called to generate code that runs when table pTab is
87985 ** being dropped from the database. The SrcList passed as the second argument
87986 ** to this function contains a single entry guaranteed to resolve to
87987 ** table pTab.
87988 **
87989 ** Normally, no code is required. However, if either
87990 **
87991 **   (a) The table is the parent table of a FK constraint, or
87992 **   (b) The table is the child table of a deferred FK constraint and it is
87993 **       determined at runtime that there are outstanding deferred FK 
87994 **       constraint violations in the database,
87995 **
87996 ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping
87997 ** the table from the database. Triggers are disabled while running this
87998 ** DELETE, but foreign key actions are not.
87999 */
88000 SQLCIPHER_PRIVATE void sqlcipher3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
88001   sqlcipher3 *db = pParse->db;
88002   if( (db->flags&SQLCIPHER_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){
88003     int iSkip = 0;
88004     Vdbe *v = sqlcipher3GetVdbe(pParse);
88005
88006     assert( v );                  /* VDBE has already been allocated */
88007     if( sqlcipher3FkReferences(pTab)==0 ){
88008       /* Search for a deferred foreign key constraint for which this table
88009       ** is the child table. If one cannot be found, return without 
88010       ** generating any VDBE code. If one can be found, then jump over
88011       ** the entire DELETE if there are no outstanding deferred constraints
88012       ** when this statement is run.  */
88013       FKey *p;
88014       for(p=pTab->pFKey; p; p=p->pNextFrom){
88015         if( p->isDeferred ) break;
88016       }
88017       if( !p ) return;
88018       iSkip = sqlcipher3VdbeMakeLabel(v);
88019       sqlcipher3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip);
88020     }
88021
88022     pParse->disableTriggers = 1;
88023     sqlcipher3DeleteFrom(pParse, sqlcipher3SrcListDup(db, pName, 0), 0);
88024     pParse->disableTriggers = 0;
88025
88026     /* If the DELETE has generated immediate foreign key constraint 
88027     ** violations, halt the VDBE and return an error at this point, before
88028     ** any modifications to the schema are made. This is because statement
88029     ** transactions are not able to rollback schema changes.  */
88030     sqlcipher3VdbeAddOp2(v, OP_FkIfZero, 0, sqlcipher3VdbeCurrentAddr(v)+2);
88031     sqlcipher3HaltConstraint(
88032         pParse, OE_Abort, "foreign key constraint failed", P4_STATIC
88033     );
88034
88035     if( iSkip ){
88036       sqlcipher3VdbeResolveLabel(v, iSkip);
88037     }
88038   }
88039 }
88040
88041 /*
88042 ** This function is called when inserting, deleting or updating a row of
88043 ** table pTab to generate VDBE code to perform foreign key constraint 
88044 ** processing for the operation.
88045 **
88046 ** For a DELETE operation, parameter regOld is passed the index of the
88047 ** first register in an array of (pTab->nCol+1) registers containing the
88048 ** rowid of the row being deleted, followed by each of the column values
88049 ** of the row being deleted, from left to right. Parameter regNew is passed
88050 ** zero in this case.
88051 **
88052 ** For an INSERT operation, regOld is passed zero and regNew is passed the
88053 ** first register of an array of (pTab->nCol+1) registers containing the new
88054 ** row data.
88055 **
88056 ** For an UPDATE operation, this function is called twice. Once before
88057 ** the original record is deleted from the table using the calling convention
88058 ** described for DELETE. Then again after the original record is deleted
88059 ** but before the new record is inserted using the INSERT convention. 
88060 */
88061 SQLCIPHER_PRIVATE void sqlcipher3FkCheck(
88062   Parse *pParse,                  /* Parse context */
88063   Table *pTab,                    /* Row is being deleted from this table */ 
88064   int regOld,                     /* Previous row data is stored here */
88065   int regNew                      /* New row data is stored here */
88066 ){
88067   sqlcipher3 *db = pParse->db;       /* Database handle */
88068   FKey *pFKey;                    /* Used to iterate through FKs */
88069   int iDb;                        /* Index of database containing pTab */
88070   const char *zDb;                /* Name of database containing pTab */
88071   int isIgnoreErrors = pParse->disableTriggers;
88072
88073   /* Exactly one of regOld and regNew should be non-zero. */
88074   assert( (regOld==0)!=(regNew==0) );
88075
88076   /* If foreign-keys are disabled, this function is a no-op. */
88077   if( (db->flags&SQLCIPHER_ForeignKeys)==0 ) return;
88078
88079   iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
88080   zDb = db->aDb[iDb].zName;
88081
88082   /* Loop through all the foreign key constraints for which pTab is the
88083   ** child table (the table that the foreign key definition is part of).  */
88084   for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
88085     Table *pTo;                   /* Parent table of foreign key pFKey */
88086     Index *pIdx = 0;              /* Index on key columns in pTo */
88087     int *aiFree = 0;
88088     int *aiCol;
88089     int iCol;
88090     int i;
88091     int isIgnore = 0;
88092
88093     /* Find the parent table of this foreign key. Also find a unique index 
88094     ** on the parent key columns in the parent table. If either of these 
88095     ** schema items cannot be located, set an error in pParse and return 
88096     ** early.  */
88097     if( pParse->disableTriggers ){
88098       pTo = sqlcipher3FindTable(db, pFKey->zTo, zDb);
88099     }else{
88100       pTo = sqlcipher3LocateTable(pParse, 0, pFKey->zTo, zDb);
88101     }
88102     if( !pTo || locateFkeyIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
88103       assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );
88104       if( !isIgnoreErrors || db->mallocFailed ) return;
88105       if( pTo==0 ){
88106         /* If isIgnoreErrors is true, then a table is being dropped. In this
88107         ** case SQLite runs a "DELETE FROM xxx" on the table being dropped
88108         ** before actually dropping it in order to check FK constraints.
88109         ** If the parent table of an FK constraint on the current table is
88110         ** missing, behave as if it is empty. i.e. decrement the relevant
88111         ** FK counter for each row of the current table with non-NULL keys.
88112         */
88113         Vdbe *v = sqlcipher3GetVdbe(pParse);
88114         int iJump = sqlcipher3VdbeCurrentAddr(v) + pFKey->nCol + 1;
88115         for(i=0; i<pFKey->nCol; i++){
88116           int iReg = pFKey->aCol[i].iFrom + regOld + 1;
88117           sqlcipher3VdbeAddOp2(v, OP_IsNull, iReg, iJump);
88118         }
88119         sqlcipher3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
88120       }
88121       continue;
88122     }
88123     assert( pFKey->nCol==1 || (aiFree && pIdx) );
88124
88125     if( aiFree ){
88126       aiCol = aiFree;
88127     }else{
88128       iCol = pFKey->aCol[0].iFrom;
88129       aiCol = &iCol;
88130     }
88131     for(i=0; i<pFKey->nCol; i++){
88132       if( aiCol[i]==pTab->iPKey ){
88133         aiCol[i] = -1;
88134       }
88135 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
88136       /* Request permission to read the parent key columns. If the 
88137       ** authorization callback returns SQLCIPHER_IGNORE, behave as if any
88138       ** values read from the parent table are NULL. */
88139       if( db->xAuth ){
88140         int rcauth;
88141         char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
88142         rcauth = sqlcipher3AuthReadCol(pParse, pTo->zName, zCol, iDb);
88143         isIgnore = (rcauth==SQLCIPHER_IGNORE);
88144       }
88145 #endif
88146     }
88147
88148     /* Take a shared-cache advisory read-lock on the parent table. Allocate 
88149     ** a cursor to use to search the unique index on the parent key columns 
88150     ** in the parent table.  */
88151     sqlcipher3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
88152     pParse->nTab++;
88153
88154     if( regOld!=0 ){
88155       /* A row is being removed from the child table. Search for the parent.
88156       ** If the parent does not exist, removing the child row resolves an 
88157       ** outstanding foreign key constraint violation. */
88158       fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1,isIgnore);
88159     }
88160     if( regNew!=0 ){
88161       /* A row is being added to the child table. If a parent row cannot
88162       ** be found, adding the child row has violated the FK constraint. */ 
88163       fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1,isIgnore);
88164     }
88165
88166     sqlcipher3DbFree(db, aiFree);
88167   }
88168
88169   /* Loop through all the foreign key constraints that refer to this table */
88170   for(pFKey = sqlcipher3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
88171     Index *pIdx = 0;              /* Foreign key index for pFKey */
88172     SrcList *pSrc;
88173     int *aiCol = 0;
88174
88175     if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){
88176       assert( regOld==0 && regNew!=0 );
88177       /* Inserting a single row into a parent table cannot cause an immediate
88178       ** foreign key violation. So do nothing in this case.  */
88179       continue;
88180     }
88181
88182     if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
88183       if( !isIgnoreErrors || db->mallocFailed ) return;
88184       continue;
88185     }
88186     assert( aiCol || pFKey->nCol==1 );
88187
88188     /* Create a SrcList structure containing a single table (the table 
88189     ** the foreign key that refers to this table is attached to). This
88190     ** is required for the sqlcipher3WhereXXX() interface.  */
88191     pSrc = sqlcipher3SrcListAppend(db, 0, 0, 0);
88192     if( pSrc ){
88193       struct SrcList_item *pItem = pSrc->a;
88194       pItem->pTab = pFKey->pFrom;
88195       pItem->zName = pFKey->pFrom->zName;
88196       pItem->pTab->nRef++;
88197       pItem->iCursor = pParse->nTab++;
88198   
88199       if( regNew!=0 ){
88200         fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
88201       }
88202       if( regOld!=0 ){
88203         /* If there is a RESTRICT action configured for the current operation
88204         ** on the parent table of this FK, then throw an exception 
88205         ** immediately if the FK constraint is violated, even if this is a
88206         ** deferred trigger. That's what RESTRICT means. To defer checking
88207         ** the constraint, the FK should specify NO ACTION (represented
88208         ** using OE_None). NO ACTION is the default.  */
88209         fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
88210       }
88211       pItem->zName = 0;
88212       sqlcipher3SrcListDelete(db, pSrc);
88213     }
88214     sqlcipher3DbFree(db, aiCol);
88215   }
88216 }
88217
88218 #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))
88219
88220 /*
88221 ** This function is called before generating code to update or delete a 
88222 ** row contained in table pTab.
88223 */
88224 SQLCIPHER_PRIVATE u32 sqlcipher3FkOldmask(
88225   Parse *pParse,                  /* Parse context */
88226   Table *pTab                     /* Table being modified */
88227 ){
88228   u32 mask = 0;
88229   if( pParse->db->flags&SQLCIPHER_ForeignKeys ){
88230     FKey *p;
88231     int i;
88232     for(p=pTab->pFKey; p; p=p->pNextFrom){
88233       for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
88234     }
88235     for(p=sqlcipher3FkReferences(pTab); p; p=p->pNextTo){
88236       Index *pIdx = 0;
88237       locateFkeyIndex(pParse, pTab, p, &pIdx, 0);
88238       if( pIdx ){
88239         for(i=0; i<pIdx->nColumn; i++) mask |= COLUMN_MASK(pIdx->aiColumn[i]);
88240       }
88241     }
88242   }
88243   return mask;
88244 }
88245
88246 /*
88247 ** This function is called before generating code to update or delete a 
88248 ** row contained in table pTab. If the operation is a DELETE, then
88249 ** parameter aChange is passed a NULL value. For an UPDATE, aChange points
88250 ** to an array of size N, where N is the number of columns in table pTab.
88251 ** If the i'th column is not modified by the UPDATE, then the corresponding 
88252 ** entry in the aChange[] array is set to -1. If the column is modified,
88253 ** the value is 0 or greater. Parameter chngRowid is set to true if the
88254 ** UPDATE statement modifies the rowid fields of the table.
88255 **
88256 ** If any foreign key processing will be required, this function returns
88257 ** true. If there is no foreign key related processing, this function 
88258 ** returns false.
88259 */
88260 SQLCIPHER_PRIVATE int sqlcipher3FkRequired(
88261   Parse *pParse,                  /* Parse context */
88262   Table *pTab,                    /* Table being modified */
88263   int *aChange,                   /* Non-NULL for UPDATE operations */
88264   int chngRowid                   /* True for UPDATE that affects rowid */
88265 ){
88266   if( pParse->db->flags&SQLCIPHER_ForeignKeys ){
88267     if( !aChange ){
88268       /* A DELETE operation. Foreign key processing is required if the 
88269       ** table in question is either the child or parent table for any 
88270       ** foreign key constraint.  */
88271       return (sqlcipher3FkReferences(pTab) || pTab->pFKey);
88272     }else{
88273       /* This is an UPDATE. Foreign key processing is only required if the
88274       ** operation modifies one or more child or parent key columns. */
88275       int i;
88276       FKey *p;
88277
88278       /* Check if any child key columns are being modified. */
88279       for(p=pTab->pFKey; p; p=p->pNextFrom){
88280         for(i=0; i<p->nCol; i++){
88281           int iChildKey = p->aCol[i].iFrom;
88282           if( aChange[iChildKey]>=0 ) return 1;
88283           if( iChildKey==pTab->iPKey && chngRowid ) return 1;
88284         }
88285       }
88286
88287       /* Check if any parent key columns are being modified. */
88288       for(p=sqlcipher3FkReferences(pTab); p; p=p->pNextTo){
88289         for(i=0; i<p->nCol; i++){
88290           char *zKey = p->aCol[i].zCol;
88291           int iKey;
88292           for(iKey=0; iKey<pTab->nCol; iKey++){
88293             Column *pCol = &pTab->aCol[iKey];
88294             if( (zKey ? !sqlcipher3StrICmp(pCol->zName, zKey) : pCol->isPrimKey) ){
88295               if( aChange[iKey]>=0 ) return 1;
88296               if( iKey==pTab->iPKey && chngRowid ) return 1;
88297             }
88298           }
88299         }
88300       }
88301     }
88302   }
88303   return 0;
88304 }
88305
88306 /*
88307 ** This function is called when an UPDATE or DELETE operation is being 
88308 ** compiled on table pTab, which is the parent table of foreign-key pFKey.
88309 ** If the current operation is an UPDATE, then the pChanges parameter is
88310 ** passed a pointer to the list of columns being modified. If it is a
88311 ** DELETE, pChanges is passed a NULL pointer.
88312 **
88313 ** It returns a pointer to a Trigger structure containing a trigger
88314 ** equivalent to the ON UPDATE or ON DELETE action specified by pFKey.
88315 ** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is
88316 ** returned (these actions require no special handling by the triggers
88317 ** sub-system, code for them is created by fkScanChildren()).
88318 **
88319 ** For example, if pFKey is the foreign key and pTab is table "p" in 
88320 ** the following schema:
88321 **
88322 **   CREATE TABLE p(pk PRIMARY KEY);
88323 **   CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE);
88324 **
88325 ** then the returned trigger structure is equivalent to:
88326 **
88327 **   CREATE TRIGGER ... DELETE ON p BEGIN
88328 **     DELETE FROM c WHERE ck = old.pk;
88329 **   END;
88330 **
88331 ** The returned pointer is cached as part of the foreign key object. It
88332 ** is eventually freed along with the rest of the foreign key object by 
88333 ** sqlcipher3FkDelete().
88334 */
88335 static Trigger *fkActionTrigger(
88336   Parse *pParse,                  /* Parse context */
88337   Table *pTab,                    /* Table being updated or deleted from */
88338   FKey *pFKey,                    /* Foreign key to get action for */
88339   ExprList *pChanges              /* Change-list for UPDATE, NULL for DELETE */
88340 ){
88341   sqlcipher3 *db = pParse->db;       /* Database handle */
88342   int action;                     /* One of OE_None, OE_Cascade etc. */
88343   Trigger *pTrigger;              /* Trigger definition to return */
88344   int iAction = (pChanges!=0);    /* 1 for UPDATE, 0 for DELETE */
88345
88346   action = pFKey->aAction[iAction];
88347   pTrigger = pFKey->apTrigger[iAction];
88348
88349   if( action!=OE_None && !pTrigger ){
88350     u8 enableLookaside;           /* Copy of db->lookaside.bEnabled */
88351     char const *zFrom;            /* Name of child table */
88352     int nFrom;                    /* Length in bytes of zFrom */
88353     Index *pIdx = 0;              /* Parent key index for this FK */
88354     int *aiCol = 0;               /* child table cols -> parent key cols */
88355     TriggerStep *pStep = 0;        /* First (only) step of trigger program */
88356     Expr *pWhere = 0;             /* WHERE clause of trigger step */
88357     ExprList *pList = 0;          /* Changes list if ON UPDATE CASCADE */
88358     Select *pSelect = 0;          /* If RESTRICT, "SELECT RAISE(...)" */
88359     int i;                        /* Iterator variable */
88360     Expr *pWhen = 0;              /* WHEN clause for the trigger */
88361
88362     if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
88363     assert( aiCol || pFKey->nCol==1 );
88364
88365     for(i=0; i<pFKey->nCol; i++){
88366       Token tOld = { "old", 3 };  /* Literal "old" token */
88367       Token tNew = { "new", 3 };  /* Literal "new" token */
88368       Token tFromCol;             /* Name of column in child table */
88369       Token tToCol;               /* Name of column in parent table */
88370       int iFromCol;               /* Idx of column in child table */
88371       Expr *pEq;                  /* tFromCol = OLD.tToCol */
88372
88373       iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
88374       assert( iFromCol>=0 );
88375       tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
88376       tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
88377
88378       tToCol.n = sqlcipher3Strlen30(tToCol.z);
88379       tFromCol.n = sqlcipher3Strlen30(tFromCol.z);
88380
88381       /* Create the expression "OLD.zToCol = zFromCol". It is important
88382       ** that the "OLD.zToCol" term is on the LHS of the = operator, so
88383       ** that the affinity and collation sequence associated with the
88384       ** parent table are used for the comparison. */
88385       pEq = sqlcipher3PExpr(pParse, TK_EQ,
88386           sqlcipher3PExpr(pParse, TK_DOT, 
88387             sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tOld),
88388             sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tToCol)
88389           , 0),
88390           sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tFromCol)
88391       , 0);
88392       pWhere = sqlcipher3ExprAnd(db, pWhere, pEq);
88393
88394       /* For ON UPDATE, construct the next term of the WHEN clause.
88395       ** The final WHEN clause will be like this:
88396       **
88397       **    WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN)
88398       */
88399       if( pChanges ){
88400         pEq = sqlcipher3PExpr(pParse, TK_IS,
88401             sqlcipher3PExpr(pParse, TK_DOT, 
88402               sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tOld),
88403               sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tToCol),
88404               0),
88405             sqlcipher3PExpr(pParse, TK_DOT, 
88406               sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tNew),
88407               sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tToCol),
88408               0),
88409             0);
88410         pWhen = sqlcipher3ExprAnd(db, pWhen, pEq);
88411       }
88412   
88413       if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){
88414         Expr *pNew;
88415         if( action==OE_Cascade ){
88416           pNew = sqlcipher3PExpr(pParse, TK_DOT, 
88417             sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tNew),
88418             sqlcipher3PExpr(pParse, TK_ID, 0, 0, &tToCol)
88419           , 0);
88420         }else if( action==OE_SetDflt ){
88421           Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt;
88422           if( pDflt ){
88423             pNew = sqlcipher3ExprDup(db, pDflt, 0);
88424           }else{
88425             pNew = sqlcipher3PExpr(pParse, TK_NULL, 0, 0, 0);
88426           }
88427         }else{
88428           pNew = sqlcipher3PExpr(pParse, TK_NULL, 0, 0, 0);
88429         }
88430         pList = sqlcipher3ExprListAppend(pParse, pList, pNew);
88431         sqlcipher3ExprListSetName(pParse, pList, &tFromCol, 0);
88432       }
88433     }
88434     sqlcipher3DbFree(db, aiCol);
88435
88436     zFrom = pFKey->pFrom->zName;
88437     nFrom = sqlcipher3Strlen30(zFrom);
88438
88439     if( action==OE_Restrict ){
88440       Token tFrom;
88441       Expr *pRaise; 
88442
88443       tFrom.z = zFrom;
88444       tFrom.n = nFrom;
88445       pRaise = sqlcipher3Expr(db, TK_RAISE, "foreign key constraint failed");
88446       if( pRaise ){
88447         pRaise->affinity = OE_Abort;
88448       }
88449       pSelect = sqlcipher3SelectNew(pParse, 
88450           sqlcipher3ExprListAppend(pParse, 0, pRaise),
88451           sqlcipher3SrcListAppend(db, 0, &tFrom, 0),
88452           pWhere,
88453           0, 0, 0, 0, 0, 0
88454       );
88455       pWhere = 0;
88456     }
88457
88458     /* Disable lookaside memory allocation */
88459     enableLookaside = db->lookaside.bEnabled;
88460     db->lookaside.bEnabled = 0;
88461
88462     pTrigger = (Trigger *)sqlcipher3DbMallocZero(db, 
88463         sizeof(Trigger) +         /* struct Trigger */
88464         sizeof(TriggerStep) +     /* Single step in trigger program */
88465         nFrom + 1                 /* Space for pStep->target.z */
88466     );
88467     if( pTrigger ){
88468       pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];
88469       pStep->target.z = (char *)&pStep[1];
88470       pStep->target.n = nFrom;
88471       memcpy((char *)pStep->target.z, zFrom, nFrom);
88472   
88473       pStep->pWhere = sqlcipher3ExprDup(db, pWhere, EXPRDUP_REDUCE);
88474       pStep->pExprList = sqlcipher3ExprListDup(db, pList, EXPRDUP_REDUCE);
88475       pStep->pSelect = sqlcipher3SelectDup(db, pSelect, EXPRDUP_REDUCE);
88476       if( pWhen ){
88477         pWhen = sqlcipher3PExpr(pParse, TK_NOT, pWhen, 0, 0);
88478         pTrigger->pWhen = sqlcipher3ExprDup(db, pWhen, EXPRDUP_REDUCE);
88479       }
88480     }
88481
88482     /* Re-enable the lookaside buffer, if it was disabled earlier. */
88483     db->lookaside.bEnabled = enableLookaside;
88484
88485     sqlcipher3ExprDelete(db, pWhere);
88486     sqlcipher3ExprDelete(db, pWhen);
88487     sqlcipher3ExprListDelete(db, pList);
88488     sqlcipher3SelectDelete(db, pSelect);
88489     if( db->mallocFailed==1 ){
88490       fkTriggerDelete(db, pTrigger);
88491       return 0;
88492     }
88493     assert( pStep!=0 );
88494
88495     switch( action ){
88496       case OE_Restrict:
88497         pStep->op = TK_SELECT; 
88498         break;
88499       case OE_Cascade: 
88500         if( !pChanges ){ 
88501           pStep->op = TK_DELETE; 
88502           break; 
88503         }
88504       default:
88505         pStep->op = TK_UPDATE;
88506     }
88507     pStep->pTrig = pTrigger;
88508     pTrigger->pSchema = pTab->pSchema;
88509     pTrigger->pTabSchema = pTab->pSchema;
88510     pFKey->apTrigger[iAction] = pTrigger;
88511     pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
88512   }
88513
88514   return pTrigger;
88515 }
88516
88517 /*
88518 ** This function is called when deleting or updating a row to implement
88519 ** any required CASCADE, SET NULL or SET DEFAULT actions.
88520 */
88521 SQLCIPHER_PRIVATE void sqlcipher3FkActions(
88522   Parse *pParse,                  /* Parse context */
88523   Table *pTab,                    /* Table being updated or deleted from */
88524   ExprList *pChanges,             /* Change-list for UPDATE, NULL for DELETE */
88525   int regOld                      /* Address of array containing old row */
88526 ){
88527   /* If foreign-key support is enabled, iterate through all FKs that 
88528   ** refer to table pTab. If there is an action associated with the FK 
88529   ** for this operation (either update or delete), invoke the associated 
88530   ** trigger sub-program.  */
88531   if( pParse->db->flags&SQLCIPHER_ForeignKeys ){
88532     FKey *pFKey;                  /* Iterator variable */
88533     for(pFKey = sqlcipher3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
88534       Trigger *pAction = fkActionTrigger(pParse, pTab, pFKey, pChanges);
88535       if( pAction ){
88536         sqlcipher3CodeRowTriggerDirect(pParse, pAction, pTab, regOld, OE_Abort, 0);
88537       }
88538     }
88539   }
88540 }
88541
88542 #endif /* ifndef SQLCIPHER_OMIT_TRIGGER */
88543
88544 /*
88545 ** Free all memory associated with foreign key definitions attached to
88546 ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash
88547 ** hash table.
88548 */
88549 SQLCIPHER_PRIVATE void sqlcipher3FkDelete(sqlcipher3 *db, Table *pTab){
88550   FKey *pFKey;                    /* Iterator variable */
88551   FKey *pNext;                    /* Copy of pFKey->pNextFrom */
88552
88553   assert( db==0 || sqlcipher3SchemaMutexHeld(db, 0, pTab->pSchema) );
88554   for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
88555
88556     /* Remove the FK from the fkeyHash hash table. */
88557     if( !db || db->pnBytesFreed==0 ){
88558       if( pFKey->pPrevTo ){
88559         pFKey->pPrevTo->pNextTo = pFKey->pNextTo;
88560       }else{
88561         void *p = (void *)pFKey->pNextTo;
88562         const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo);
88563         sqlcipher3HashInsert(&pTab->pSchema->fkeyHash, z, sqlcipher3Strlen30(z), p);
88564       }
88565       if( pFKey->pNextTo ){
88566         pFKey->pNextTo->pPrevTo = pFKey->pPrevTo;
88567       }
88568     }
88569
88570     /* EV: R-30323-21917 Each foreign key constraint in SQLite is
88571     ** classified as either immediate or deferred.
88572     */
88573     assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
88574
88575     /* Delete any triggers created to implement actions for this FK. */
88576 #ifndef SQLCIPHER_OMIT_TRIGGER
88577     fkTriggerDelete(db, pFKey->apTrigger[0]);
88578     fkTriggerDelete(db, pFKey->apTrigger[1]);
88579 #endif
88580
88581     pNext = pFKey->pNextFrom;
88582     sqlcipher3DbFree(db, pFKey);
88583   }
88584 }
88585 #endif /* ifndef SQLCIPHER_OMIT_FOREIGN_KEY */
88586
88587 /************** End of fkey.c ************************************************/
88588 /************** Begin file insert.c ******************************************/
88589 /*
88590 ** 2001 September 15
88591 **
88592 ** The author disclaims copyright to this source code.  In place of
88593 ** a legal notice, here is a blessing:
88594 **
88595 **    May you do good and not evil.
88596 **    May you find forgiveness for yourself and forgive others.
88597 **    May you share freely, never taking more than you give.
88598 **
88599 *************************************************************************
88600 ** This file contains C code routines that are called by the parser
88601 ** to handle INSERT statements in SQLite.
88602 */
88603
88604 /*
88605 ** Generate code that will open a table for reading.
88606 */
88607 SQLCIPHER_PRIVATE void sqlcipher3OpenTable(
88608   Parse *p,       /* Generate code into this VDBE */
88609   int iCur,       /* The cursor number of the table */
88610   int iDb,        /* The database index in sqlcipher3.aDb[] */
88611   Table *pTab,    /* The table to be opened */
88612   int opcode      /* OP_OpenRead or OP_OpenWrite */
88613 ){
88614   Vdbe *v;
88615   if( IsVirtual(pTab) ) return;
88616   v = sqlcipher3GetVdbe(p);
88617   assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
88618   sqlcipher3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
88619   sqlcipher3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
88620   sqlcipher3VdbeChangeP4(v, -1, SQLCIPHER_INT_TO_PTR(pTab->nCol), P4_INT32);
88621   VdbeComment((v, "%s", pTab->zName));
88622 }
88623
88624 /*
88625 ** Return a pointer to the column affinity string associated with index
88626 ** pIdx. A column affinity string has one character for each column in 
88627 ** the table, according to the affinity of the column:
88628 **
88629 **  Character      Column affinity
88630 **  ------------------------------
88631 **  'a'            TEXT
88632 **  'b'            NONE
88633 **  'c'            NUMERIC
88634 **  'd'            INTEGER
88635 **  'e'            REAL
88636 **
88637 ** An extra 'b' is appended to the end of the string to cover the
88638 ** rowid that appears as the last column in every index.
88639 **
88640 ** Memory for the buffer containing the column index affinity string
88641 ** is managed along with the rest of the Index structure. It will be
88642 ** released when sqlcipher3DeleteIndex() is called.
88643 */
88644 SQLCIPHER_PRIVATE const char *sqlcipher3IndexAffinityStr(Vdbe *v, Index *pIdx){
88645   if( !pIdx->zColAff ){
88646     /* The first time a column affinity string for a particular index is
88647     ** required, it is allocated and populated here. It is then stored as
88648     ** a member of the Index structure for subsequent use.
88649     **
88650     ** The column affinity string will eventually be deleted by
88651     ** sqlcipherDeleteIndex() when the Index structure itself is cleaned
88652     ** up.
88653     */
88654     int n;
88655     Table *pTab = pIdx->pTable;
88656     sqlcipher3 *db = sqlcipher3VdbeDb(v);
88657     pIdx->zColAff = (char *)sqlcipher3DbMallocRaw(0, pIdx->nColumn+2);
88658     if( !pIdx->zColAff ){
88659       db->mallocFailed = 1;
88660       return 0;
88661     }
88662     for(n=0; n<pIdx->nColumn; n++){
88663       pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
88664     }
88665     pIdx->zColAff[n++] = SQLCIPHER_AFF_NONE;
88666     pIdx->zColAff[n] = 0;
88667   }
88668  
88669   return pIdx->zColAff;
88670 }
88671
88672 /*
88673 ** Set P4 of the most recently inserted opcode to a column affinity
88674 ** string for table pTab. A column affinity string has one character
88675 ** for each column indexed by the index, according to the affinity of the
88676 ** column:
88677 **
88678 **  Character      Column affinity
88679 **  ------------------------------
88680 **  'a'            TEXT
88681 **  'b'            NONE
88682 **  'c'            NUMERIC
88683 **  'd'            INTEGER
88684 **  'e'            REAL
88685 */
88686 SQLCIPHER_PRIVATE void sqlcipher3TableAffinityStr(Vdbe *v, Table *pTab){
88687   /* The first time a column affinity string for a particular table
88688   ** is required, it is allocated and populated here. It is then 
88689   ** stored as a member of the Table structure for subsequent use.
88690   **
88691   ** The column affinity string will eventually be deleted by
88692   ** sqlcipher3DeleteTable() when the Table structure itself is cleaned up.
88693   */
88694   if( !pTab->zColAff ){
88695     char *zColAff;
88696     int i;
88697     sqlcipher3 *db = sqlcipher3VdbeDb(v);
88698
88699     zColAff = (char *)sqlcipher3DbMallocRaw(0, pTab->nCol+1);
88700     if( !zColAff ){
88701       db->mallocFailed = 1;
88702       return;
88703     }
88704
88705     for(i=0; i<pTab->nCol; i++){
88706       zColAff[i] = pTab->aCol[i].affinity;
88707     }
88708     zColAff[pTab->nCol] = '\0';
88709
88710     pTab->zColAff = zColAff;
88711   }
88712
88713   sqlcipher3VdbeChangeP4(v, -1, pTab->zColAff, P4_TRANSIENT);
88714 }
88715
88716 /*
88717 ** Return non-zero if the table pTab in database iDb or any of its indices
88718 ** have been opened at any point in the VDBE program beginning at location
88719 ** iStartAddr throught the end of the program.  This is used to see if 
88720 ** a statement of the form  "INSERT INTO <iDb, pTab> SELECT ..." can 
88721 ** run without using temporary table for the results of the SELECT. 
88722 */
88723 static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){
88724   Vdbe *v = sqlcipher3GetVdbe(p);
88725   int i;
88726   int iEnd = sqlcipher3VdbeCurrentAddr(v);
88727 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
88728   VTable *pVTab = IsVirtual(pTab) ? sqlcipher3GetVTable(p->db, pTab) : 0;
88729 #endif
88730
88731   for(i=iStartAddr; i<iEnd; i++){
88732     VdbeOp *pOp = sqlcipher3VdbeGetOp(v, i);
88733     assert( pOp!=0 );
88734     if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
88735       Index *pIndex;
88736       int tnum = pOp->p2;
88737       if( tnum==pTab->tnum ){
88738         return 1;
88739       }
88740       for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
88741         if( tnum==pIndex->tnum ){
88742           return 1;
88743         }
88744       }
88745     }
88746 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
88747     if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
88748       assert( pOp->p4.pVtab!=0 );
88749       assert( pOp->p4type==P4_VTAB );
88750       return 1;
88751     }
88752 #endif
88753   }
88754   return 0;
88755 }
88756
88757 #ifndef SQLCIPHER_OMIT_AUTOINCREMENT
88758 /*
88759 ** Locate or create an AutoincInfo structure associated with table pTab
88760 ** which is in database iDb.  Return the register number for the register
88761 ** that holds the maximum rowid.
88762 **
88763 ** There is at most one AutoincInfo structure per table even if the
88764 ** same table is autoincremented multiple times due to inserts within
88765 ** triggers.  A new AutoincInfo structure is created if this is the
88766 ** first use of table pTab.  On 2nd and subsequent uses, the original
88767 ** AutoincInfo structure is used.
88768 **
88769 ** Three memory locations are allocated:
88770 **
88771 **   (1)  Register to hold the name of the pTab table.
88772 **   (2)  Register to hold the maximum ROWID of pTab.
88773 **   (3)  Register to hold the rowid in sqlcipher_sequence of pTab
88774 **
88775 ** The 2nd register is the one that is returned.  That is all the
88776 ** insert routine needs to know about.
88777 */
88778 static int autoIncBegin(
88779   Parse *pParse,      /* Parsing context */
88780   int iDb,            /* Index of the database holding pTab */
88781   Table *pTab         /* The table we are writing to */
88782 ){
88783   int memId = 0;      /* Register holding maximum rowid */
88784   if( pTab->tabFlags & TF_Autoincrement ){
88785     Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
88786     AutoincInfo *pInfo;
88787
88788     pInfo = pToplevel->pAinc;
88789     while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
88790     if( pInfo==0 ){
88791       pInfo = sqlcipher3DbMallocRaw(pParse->db, sizeof(*pInfo));
88792       if( pInfo==0 ) return 0;
88793       pInfo->pNext = pToplevel->pAinc;
88794       pToplevel->pAinc = pInfo;
88795       pInfo->pTab = pTab;
88796       pInfo->iDb = iDb;
88797       pToplevel->nMem++;                  /* Register to hold name of table */
88798       pInfo->regCtr = ++pToplevel->nMem;  /* Max rowid register */
88799       pToplevel->nMem++;                  /* Rowid in sqlcipher_sequence */
88800     }
88801     memId = pInfo->regCtr;
88802   }
88803   return memId;
88804 }
88805
88806 /*
88807 ** This routine generates code that will initialize all of the
88808 ** register used by the autoincrement tracker.  
88809 */
88810 SQLCIPHER_PRIVATE void sqlcipher3AutoincrementBegin(Parse *pParse){
88811   AutoincInfo *p;            /* Information about an AUTOINCREMENT */
88812   sqlcipher3 *db = pParse->db;  /* The database connection */
88813   Db *pDb;                   /* Database only autoinc table */
88814   int memId;                 /* Register holding max rowid */
88815   int addr;                  /* A VDBE address */
88816   Vdbe *v = pParse->pVdbe;   /* VDBE under construction */
88817
88818   /* This routine is never called during trigger-generation.  It is
88819   ** only called from the top-level */
88820   assert( pParse->pTriggerTab==0 );
88821   assert( pParse==sqlcipher3ParseToplevel(pParse) );
88822
88823   assert( v );   /* We failed long ago if this is not so */
88824   for(p = pParse->pAinc; p; p = p->pNext){
88825     pDb = &db->aDb[p->iDb];
88826     memId = p->regCtr;
88827     assert( sqlcipher3SchemaMutexHeld(db, 0, pDb->pSchema) );
88828     sqlcipher3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
88829     addr = sqlcipher3VdbeCurrentAddr(v);
88830     sqlcipher3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
88831     sqlcipher3VdbeAddOp2(v, OP_Rewind, 0, addr+9);
88832     sqlcipher3VdbeAddOp3(v, OP_Column, 0, 0, memId);
88833     sqlcipher3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);
88834     sqlcipher3VdbeChangeP5(v, SQLCIPHER_JUMPIFNULL);
88835     sqlcipher3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
88836     sqlcipher3VdbeAddOp3(v, OP_Column, 0, 1, memId);
88837     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addr+9);
88838     sqlcipher3VdbeAddOp2(v, OP_Next, 0, addr+2);
88839     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, memId);
88840     sqlcipher3VdbeAddOp0(v, OP_Close);
88841   }
88842 }
88843
88844 /*
88845 ** Update the maximum rowid for an autoincrement calculation.
88846 **
88847 ** This routine should be called when the top of the stack holds a
88848 ** new rowid that is about to be inserted.  If that new rowid is
88849 ** larger than the maximum rowid in the memId memory cell, then the
88850 ** memory cell is updated.  The stack is unchanged.
88851 */
88852 static void autoIncStep(Parse *pParse, int memId, int regRowid){
88853   if( memId>0 ){
88854     sqlcipher3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
88855   }
88856 }
88857
88858 /*
88859 ** This routine generates the code needed to write autoincrement
88860 ** maximum rowid values back into the sqlcipher_sequence register.
88861 ** Every statement that might do an INSERT into an autoincrement
88862 ** table (either directly or through triggers) needs to call this
88863 ** routine just before the "exit" code.
88864 */
88865 SQLCIPHER_PRIVATE void sqlcipher3AutoincrementEnd(Parse *pParse){
88866   AutoincInfo *p;
88867   Vdbe *v = pParse->pVdbe;
88868   sqlcipher3 *db = pParse->db;
88869
88870   assert( v );
88871   for(p = pParse->pAinc; p; p = p->pNext){
88872     Db *pDb = &db->aDb[p->iDb];
88873     int j1, j2, j3, j4, j5;
88874     int iRec;
88875     int memId = p->regCtr;
88876
88877     iRec = sqlcipher3GetTempReg(pParse);
88878     assert( sqlcipher3SchemaMutexHeld(db, 0, pDb->pSchema) );
88879     sqlcipher3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
88880     j1 = sqlcipher3VdbeAddOp1(v, OP_NotNull, memId+1);
88881     j2 = sqlcipher3VdbeAddOp0(v, OP_Rewind);
88882     j3 = sqlcipher3VdbeAddOp3(v, OP_Column, 0, 0, iRec);
88883     j4 = sqlcipher3VdbeAddOp3(v, OP_Eq, memId-1, 0, iRec);
88884     sqlcipher3VdbeAddOp2(v, OP_Next, 0, j3);
88885     sqlcipher3VdbeJumpHere(v, j2);
88886     sqlcipher3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
88887     j5 = sqlcipher3VdbeAddOp0(v, OP_Goto);
88888     sqlcipher3VdbeJumpHere(v, j4);
88889     sqlcipher3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
88890     sqlcipher3VdbeJumpHere(v, j1);
88891     sqlcipher3VdbeJumpHere(v, j5);
88892     sqlcipher3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
88893     sqlcipher3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
88894     sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
88895     sqlcipher3VdbeAddOp0(v, OP_Close);
88896     sqlcipher3ReleaseTempReg(pParse, iRec);
88897   }
88898 }
88899 #else
88900 /*
88901 ** If SQLCIPHER_OMIT_AUTOINCREMENT is defined, then the three routines
88902 ** above are all no-ops
88903 */
88904 # define autoIncBegin(A,B,C) (0)
88905 # define autoIncStep(A,B,C)
88906 #endif /* SQLCIPHER_OMIT_AUTOINCREMENT */
88907
88908
88909 /* Forward declaration */
88910 static int xferOptimization(
88911   Parse *pParse,        /* Parser context */
88912   Table *pDest,         /* The table we are inserting into */
88913   Select *pSelect,      /* A SELECT statement to use as the data source */
88914   int onError,          /* How to handle constraint errors */
88915   int iDbDest           /* The database of pDest */
88916 );
88917
88918 /*
88919 ** This routine is call to handle SQL of the following forms:
88920 **
88921 **    insert into TABLE (IDLIST) values(EXPRLIST)
88922 **    insert into TABLE (IDLIST) select
88923 **
88924 ** The IDLIST following the table name is always optional.  If omitted,
88925 ** then a list of all columns for the table is substituted.  The IDLIST
88926 ** appears in the pColumn parameter.  pColumn is NULL if IDLIST is omitted.
88927 **
88928 ** The pList parameter holds EXPRLIST in the first form of the INSERT
88929 ** statement above, and pSelect is NULL.  For the second form, pList is
88930 ** NULL and pSelect is a pointer to the select statement used to generate
88931 ** data for the insert.
88932 **
88933 ** The code generated follows one of four templates.  For a simple
88934 ** select with data coming from a VALUES clause, the code executes
88935 ** once straight down through.  Pseudo-code follows (we call this
88936 ** the "1st template"):
88937 **
88938 **         open write cursor to <table> and its indices
88939 **         puts VALUES clause expressions onto the stack
88940 **         write the resulting record into <table>
88941 **         cleanup
88942 **
88943 ** The three remaining templates assume the statement is of the form
88944 **
88945 **   INSERT INTO <table> SELECT ...
88946 **
88947 ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
88948 ** in other words if the SELECT pulls all columns from a single table
88949 ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
88950 ** if <table2> and <table1> are distinct tables but have identical
88951 ** schemas, including all the same indices, then a special optimization
88952 ** is invoked that copies raw records from <table2> over to <table1>.
88953 ** See the xferOptimization() function for the implementation of this
88954 ** template.  This is the 2nd template.
88955 **
88956 **         open a write cursor to <table>
88957 **         open read cursor on <table2>
88958 **         transfer all records in <table2> over to <table>
88959 **         close cursors
88960 **         foreach index on <table>
88961 **           open a write cursor on the <table> index
88962 **           open a read cursor on the corresponding <table2> index
88963 **           transfer all records from the read to the write cursors
88964 **           close cursors
88965 **         end foreach
88966 **
88967 ** The 3rd template is for when the second template does not apply
88968 ** and the SELECT clause does not read from <table> at any time.
88969 ** The generated code follows this template:
88970 **
88971 **         EOF <- 0
88972 **         X <- A
88973 **         goto B
88974 **      A: setup for the SELECT
88975 **         loop over the rows in the SELECT
88976 **           load values into registers R..R+n
88977 **           yield X
88978 **         end loop
88979 **         cleanup after the SELECT
88980 **         EOF <- 1
88981 **         yield X
88982 **         goto A
88983 **      B: open write cursor to <table> and its indices
88984 **      C: yield X
88985 **         if EOF goto D
88986 **         insert the select result into <table> from R..R+n
88987 **         goto C
88988 **      D: cleanup
88989 **
88990 ** The 4th template is used if the insert statement takes its
88991 ** values from a SELECT but the data is being inserted into a table
88992 ** that is also read as part of the SELECT.  In the third form,
88993 ** we have to use a intermediate table to store the results of
88994 ** the select.  The template is like this:
88995 **
88996 **         EOF <- 0
88997 **         X <- A
88998 **         goto B
88999 **      A: setup for the SELECT
89000 **         loop over the tables in the SELECT
89001 **           load value into register R..R+n
89002 **           yield X
89003 **         end loop
89004 **         cleanup after the SELECT
89005 **         EOF <- 1
89006 **         yield X
89007 **         halt-error
89008 **      B: open temp table
89009 **      L: yield X
89010 **         if EOF goto M
89011 **         insert row from R..R+n into temp table
89012 **         goto L
89013 **      M: open write cursor to <table> and its indices
89014 **         rewind temp table
89015 **      C: loop over rows of intermediate table
89016 **           transfer values form intermediate table into <table>
89017 **         end loop
89018 **      D: cleanup
89019 */
89020 SQLCIPHER_PRIVATE void sqlcipher3Insert(
89021   Parse *pParse,        /* Parser context */
89022   SrcList *pTabList,    /* Name of table into which we are inserting */
89023   ExprList *pList,      /* List of values to be inserted */
89024   Select *pSelect,      /* A SELECT statement to use as the data source */
89025   IdList *pColumn,      /* Column names corresponding to IDLIST. */
89026   int onError           /* How to handle constraint errors */
89027 ){
89028   sqlcipher3 *db;          /* The main database structure */
89029   Table *pTab;          /* The table to insert into.  aka TABLE */
89030   char *zTab;           /* Name of the table into which we are inserting */
89031   const char *zDb;      /* Name of the database holding this table */
89032   int i, j, idx;        /* Loop counters */
89033   Vdbe *v;              /* Generate code into this virtual machine */
89034   Index *pIdx;          /* For looping over indices of the table */
89035   int nColumn;          /* Number of columns in the data */
89036   int nHidden = 0;      /* Number of hidden columns if TABLE is virtual */
89037   int baseCur = 0;      /* VDBE Cursor number for pTab */
89038   int keyColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
89039   int endOfLoop;        /* Label for the end of the insertion loop */
89040   int useTempTable = 0; /* Store SELECT results in intermediate table */
89041   int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */
89042   int addrInsTop = 0;   /* Jump to label "D" */
89043   int addrCont = 0;     /* Top of insert loop. Label "C" in templates 3 and 4 */
89044   int addrSelect = 0;   /* Address of coroutine that implements the SELECT */
89045   SelectDest dest;      /* Destination for SELECT on rhs of INSERT */
89046   int iDb;              /* Index of database holding TABLE */
89047   Db *pDb;              /* The database containing table being inserted into */
89048   int appendFlag = 0;   /* True if the insert is likely to be an append */
89049
89050   /* Register allocations */
89051   int regFromSelect = 0;/* Base register for data coming from SELECT */
89052   int regAutoinc = 0;   /* Register holding the AUTOINCREMENT counter */
89053   int regRowCount = 0;  /* Memory cell used for the row counter */
89054   int regIns;           /* Block of regs holding rowid+data being inserted */
89055   int regRowid;         /* registers holding insert rowid */
89056   int regData;          /* register holding first column to insert */
89057   int regEof = 0;       /* Register recording end of SELECT data */
89058   int *aRegIdx = 0;     /* One register allocated to each index */
89059
89060 #ifndef SQLCIPHER_OMIT_TRIGGER
89061   int isView;                 /* True if attempting to insert into a view */
89062   Trigger *pTrigger;          /* List of triggers on pTab, if required */
89063   int tmask;                  /* Mask of trigger times */
89064 #endif
89065
89066   db = pParse->db;
89067   memset(&dest, 0, sizeof(dest));
89068   if( pParse->nErr || db->mallocFailed ){
89069     goto insert_cleanup;
89070   }
89071
89072   /* Locate the table into which we will be inserting new information.
89073   */
89074   assert( pTabList->nSrc==1 );
89075   zTab = pTabList->a[0].zName;
89076   if( NEVER(zTab==0) ) goto insert_cleanup;
89077   pTab = sqlcipher3SrcListLookup(pParse, pTabList);
89078   if( pTab==0 ){
89079     goto insert_cleanup;
89080   }
89081   iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
89082   assert( iDb<db->nDb );
89083   pDb = &db->aDb[iDb];
89084   zDb = pDb->zName;
89085   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_INSERT, pTab->zName, 0, zDb) ){
89086     goto insert_cleanup;
89087   }
89088
89089   /* Figure out if we have any triggers and if the table being
89090   ** inserted into is a view
89091   */
89092 #ifndef SQLCIPHER_OMIT_TRIGGER
89093   pTrigger = sqlcipher3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
89094   isView = pTab->pSelect!=0;
89095 #else
89096 # define pTrigger 0
89097 # define tmask 0
89098 # define isView 0
89099 #endif
89100 #ifdef SQLCIPHER_OMIT_VIEW
89101 # undef isView
89102 # define isView 0
89103 #endif
89104   assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
89105
89106   /* If pTab is really a view, make sure it has been initialized.
89107   ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual 
89108   ** module table).
89109   */
89110   if( sqlcipher3ViewGetColumnNames(pParse, pTab) ){
89111     goto insert_cleanup;
89112   }
89113
89114   /* Ensure that:
89115   *  (a) the table is not read-only, 
89116   *  (b) that if it is a view then ON INSERT triggers exist
89117   */
89118   if( sqlcipher3IsReadOnly(pParse, pTab, tmask) ){
89119     goto insert_cleanup;
89120   }
89121
89122   /* Allocate a VDBE
89123   */
89124   v = sqlcipher3GetVdbe(pParse);
89125   if( v==0 ) goto insert_cleanup;
89126   if( pParse->nested==0 ) sqlcipher3VdbeCountChanges(v);
89127   sqlcipher3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
89128
89129 #ifndef SQLCIPHER_OMIT_XFER_OPT
89130   /* If the statement is of the form
89131   **
89132   **       INSERT INTO <table1> SELECT * FROM <table2>;
89133   **
89134   ** Then special optimizations can be applied that make the transfer
89135   ** very fast and which reduce fragmentation of indices.
89136   **
89137   ** This is the 2nd template.
89138   */
89139   if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
89140     assert( !pTrigger );
89141     assert( pList==0 );
89142     goto insert_end;
89143   }
89144 #endif /* SQLCIPHER_OMIT_XFER_OPT */
89145
89146   /* If this is an AUTOINCREMENT table, look up the sequence number in the
89147   ** sqlcipher_sequence table and store it in memory cell regAutoinc.
89148   */
89149   regAutoinc = autoIncBegin(pParse, iDb, pTab);
89150
89151   /* Figure out how many columns of data are supplied.  If the data
89152   ** is coming from a SELECT statement, then generate a co-routine that
89153   ** produces a single row of the SELECT on each invocation.  The
89154   ** co-routine is the common header to the 3rd and 4th templates.
89155   */
89156   if( pSelect ){
89157     /* Data is coming from a SELECT.  Generate code to implement that SELECT
89158     ** as a co-routine.  The code is common to both the 3rd and 4th
89159     ** templates:
89160     **
89161     **         EOF <- 0
89162     **         X <- A
89163     **         goto B
89164     **      A: setup for the SELECT
89165     **         loop over the tables in the SELECT
89166     **           load value into register R..R+n
89167     **           yield X
89168     **         end loop
89169     **         cleanup after the SELECT
89170     **         EOF <- 1
89171     **         yield X
89172     **         halt-error
89173     **
89174     ** On each invocation of the co-routine, it puts a single row of the
89175     ** SELECT result into registers dest.iMem...dest.iMem+dest.nMem-1.
89176     ** (These output registers are allocated by sqlcipher3Select().)  When
89177     ** the SELECT completes, it sets the EOF flag stored in regEof.
89178     */
89179     int rc, j1;
89180
89181     regEof = ++pParse->nMem;
89182     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regEof);      /* EOF <- 0 */
89183     VdbeComment((v, "SELECT eof flag"));
89184     sqlcipher3SelectDestInit(&dest, SRT_Coroutine, ++pParse->nMem);
89185     addrSelect = sqlcipher3VdbeCurrentAddr(v)+2;
89186     sqlcipher3VdbeAddOp2(v, OP_Integer, addrSelect-1, dest.iParm);
89187     j1 = sqlcipher3VdbeAddOp2(v, OP_Goto, 0, 0);
89188     VdbeComment((v, "Jump over SELECT coroutine"));
89189
89190     /* Resolve the expressions in the SELECT statement and execute it. */
89191     rc = sqlcipher3Select(pParse, pSelect, &dest);
89192     assert( pParse->nErr==0 || rc );
89193     if( rc || NEVER(pParse->nErr) || db->mallocFailed ){
89194       goto insert_cleanup;
89195     }
89196     sqlcipher3VdbeAddOp2(v, OP_Integer, 1, regEof);         /* EOF <- 1 */
89197     sqlcipher3VdbeAddOp1(v, OP_Yield, dest.iParm);   /* yield X */
89198     sqlcipher3VdbeAddOp2(v, OP_Halt, SQLCIPHER_INTERNAL, OE_Abort);
89199     VdbeComment((v, "End of SELECT coroutine"));
89200     sqlcipher3VdbeJumpHere(v, j1);                          /* label B: */
89201
89202     regFromSelect = dest.iMem;
89203     assert( pSelect->pEList );
89204     nColumn = pSelect->pEList->nExpr;
89205     assert( dest.nMem==nColumn );
89206
89207     /* Set useTempTable to TRUE if the result of the SELECT statement
89208     ** should be written into a temporary table (template 4).  Set to
89209     ** FALSE if each* row of the SELECT can be written directly into
89210     ** the destination table (template 3).
89211     **
89212     ** A temp table must be used if the table being updated is also one
89213     ** of the tables being read by the SELECT statement.  Also use a 
89214     ** temp table in the case of row triggers.
89215     */
89216     if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
89217       useTempTable = 1;
89218     }
89219
89220     if( useTempTable ){
89221       /* Invoke the coroutine to extract information from the SELECT
89222       ** and add it to a transient table srcTab.  The code generated
89223       ** here is from the 4th template:
89224       **
89225       **      B: open temp table
89226       **      L: yield X
89227       **         if EOF goto M
89228       **         insert row from R..R+n into temp table
89229       **         goto L
89230       **      M: ...
89231       */
89232       int regRec;          /* Register to hold packed record */
89233       int regTempRowid;    /* Register to hold temp table ROWID */
89234       int addrTop;         /* Label "L" */
89235       int addrIf;          /* Address of jump to M */
89236
89237       srcTab = pParse->nTab++;
89238       regRec = sqlcipher3GetTempReg(pParse);
89239       regTempRowid = sqlcipher3GetTempReg(pParse);
89240       sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
89241       addrTop = sqlcipher3VdbeAddOp1(v, OP_Yield, dest.iParm);
89242       addrIf = sqlcipher3VdbeAddOp1(v, OP_If, regEof);
89243       sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
89244       sqlcipher3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
89245       sqlcipher3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
89246       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addrTop);
89247       sqlcipher3VdbeJumpHere(v, addrIf);
89248       sqlcipher3ReleaseTempReg(pParse, regRec);
89249       sqlcipher3ReleaseTempReg(pParse, regTempRowid);
89250     }
89251   }else{
89252     /* This is the case if the data for the INSERT is coming from a VALUES
89253     ** clause
89254     */
89255     NameContext sNC;
89256     memset(&sNC, 0, sizeof(sNC));
89257     sNC.pParse = pParse;
89258     srcTab = -1;
89259     assert( useTempTable==0 );
89260     nColumn = pList ? pList->nExpr : 0;
89261     for(i=0; i<nColumn; i++){
89262       if( sqlcipher3ResolveExprNames(&sNC, pList->a[i].pExpr) ){
89263         goto insert_cleanup;
89264       }
89265     }
89266   }
89267
89268   /* Make sure the number of columns in the source data matches the number
89269   ** of columns to be inserted into the table.
89270   */
89271   if( IsVirtual(pTab) ){
89272     for(i=0; i<pTab->nCol; i++){
89273       nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
89274     }
89275   }
89276   if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
89277     sqlcipher3ErrorMsg(pParse, 
89278        "table %S has %d columns but %d values were supplied",
89279        pTabList, 0, pTab->nCol-nHidden, nColumn);
89280     goto insert_cleanup;
89281   }
89282   if( pColumn!=0 && nColumn!=pColumn->nId ){
89283     sqlcipher3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
89284     goto insert_cleanup;
89285   }
89286
89287   /* If the INSERT statement included an IDLIST term, then make sure
89288   ** all elements of the IDLIST really are columns of the table and 
89289   ** remember the column indices.
89290   **
89291   ** If the table has an INTEGER PRIMARY KEY column and that column
89292   ** is named in the IDLIST, then record in the keyColumn variable
89293   ** the index into IDLIST of the primary key column.  keyColumn is
89294   ** the index of the primary key as it appears in IDLIST, not as
89295   ** is appears in the original table.  (The index of the primary
89296   ** key in the original table is pTab->iPKey.)
89297   */
89298   if( pColumn ){
89299     for(i=0; i<pColumn->nId; i++){
89300       pColumn->a[i].idx = -1;
89301     }
89302     for(i=0; i<pColumn->nId; i++){
89303       for(j=0; j<pTab->nCol; j++){
89304         if( sqlcipher3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
89305           pColumn->a[i].idx = j;
89306           if( j==pTab->iPKey ){
89307             keyColumn = i;
89308           }
89309           break;
89310         }
89311       }
89312       if( j>=pTab->nCol ){
89313         if( sqlcipher3IsRowid(pColumn->a[i].zName) ){
89314           keyColumn = i;
89315         }else{
89316           sqlcipher3ErrorMsg(pParse, "table %S has no column named %s",
89317               pTabList, 0, pColumn->a[i].zName);
89318           pParse->checkSchema = 1;
89319           goto insert_cleanup;
89320         }
89321       }
89322     }
89323   }
89324
89325   /* If there is no IDLIST term but the table has an integer primary
89326   ** key, the set the keyColumn variable to the primary key column index
89327   ** in the original table definition.
89328   */
89329   if( pColumn==0 && nColumn>0 ){
89330     keyColumn = pTab->iPKey;
89331   }
89332     
89333   /* Initialize the count of rows to be inserted
89334   */
89335   if( db->flags & SQLCIPHER_CountRows ){
89336     regRowCount = ++pParse->nMem;
89337     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
89338   }
89339
89340   /* If this is not a view, open the table and and all indices */
89341   if( !isView ){
89342     int nIdx;
89343
89344     baseCur = pParse->nTab;
89345     nIdx = sqlcipher3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
89346     aRegIdx = sqlcipher3DbMallocRaw(db, sizeof(int)*(nIdx+1));
89347     if( aRegIdx==0 ){
89348       goto insert_cleanup;
89349     }
89350     for(i=0; i<nIdx; i++){
89351       aRegIdx[i] = ++pParse->nMem;
89352     }
89353   }
89354
89355   /* This is the top of the main insertion loop */
89356   if( useTempTable ){
89357     /* This block codes the top of loop only.  The complete loop is the
89358     ** following pseudocode (template 4):
89359     **
89360     **         rewind temp table
89361     **      C: loop over rows of intermediate table
89362     **           transfer values form intermediate table into <table>
89363     **         end loop
89364     **      D: ...
89365     */
89366     addrInsTop = sqlcipher3VdbeAddOp1(v, OP_Rewind, srcTab);
89367     addrCont = sqlcipher3VdbeCurrentAddr(v);
89368   }else if( pSelect ){
89369     /* This block codes the top of loop only.  The complete loop is the
89370     ** following pseudocode (template 3):
89371     **
89372     **      C: yield X
89373     **         if EOF goto D
89374     **         insert the select result into <table> from R..R+n
89375     **         goto C
89376     **      D: ...
89377     */
89378     addrCont = sqlcipher3VdbeAddOp1(v, OP_Yield, dest.iParm);
89379     addrInsTop = sqlcipher3VdbeAddOp1(v, OP_If, regEof);
89380   }
89381
89382   /* Allocate registers for holding the rowid of the new row,
89383   ** the content of the new row, and the assemblied row record.
89384   */
89385   regRowid = regIns = pParse->nMem+1;
89386   pParse->nMem += pTab->nCol + 1;
89387   if( IsVirtual(pTab) ){
89388     regRowid++;
89389     pParse->nMem++;
89390   }
89391   regData = regRowid+1;
89392
89393   /* Run the BEFORE and INSTEAD OF triggers, if there are any
89394   */
89395   endOfLoop = sqlcipher3VdbeMakeLabel(v);
89396   if( tmask & TRIGGER_BEFORE ){
89397     int regCols = sqlcipher3GetTempRange(pParse, pTab->nCol+1);
89398
89399     /* build the NEW.* reference row.  Note that if there is an INTEGER
89400     ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
89401     ** translated into a unique ID for the row.  But on a BEFORE trigger,
89402     ** we do not know what the unique ID will be (because the insert has
89403     ** not happened yet) so we substitute a rowid of -1
89404     */
89405     if( keyColumn<0 ){
89406       sqlcipher3VdbeAddOp2(v, OP_Integer, -1, regCols);
89407     }else{
89408       int j1;
89409       if( useTempTable ){
89410         sqlcipher3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regCols);
89411       }else{
89412         assert( pSelect==0 );  /* Otherwise useTempTable is true */
89413         sqlcipher3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
89414       }
89415       j1 = sqlcipher3VdbeAddOp1(v, OP_NotNull, regCols);
89416       sqlcipher3VdbeAddOp2(v, OP_Integer, -1, regCols);
89417       sqlcipher3VdbeJumpHere(v, j1);
89418       sqlcipher3VdbeAddOp1(v, OP_MustBeInt, regCols);
89419     }
89420
89421     /* Cannot have triggers on a virtual table. If it were possible,
89422     ** this block would have to account for hidden column.
89423     */
89424     assert( !IsVirtual(pTab) );
89425
89426     /* Create the new column data
89427     */
89428     for(i=0; i<pTab->nCol; i++){
89429       if( pColumn==0 ){
89430         j = i;
89431       }else{
89432         for(j=0; j<pColumn->nId; j++){
89433           if( pColumn->a[j].idx==i ) break;
89434         }
89435       }
89436       if( (!useTempTable && !pList) || (pColumn && j>=pColumn->nId) ){
89437         sqlcipher3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
89438       }else if( useTempTable ){
89439         sqlcipher3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i+1); 
89440       }else{
89441         assert( pSelect==0 ); /* Otherwise useTempTable is true */
89442         sqlcipher3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
89443       }
89444     }
89445
89446     /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
89447     ** do not attempt any conversions before assembling the record.
89448     ** If this is a real table, attempt conversions as required by the
89449     ** table column affinities.
89450     */
89451     if( !isView ){
89452       sqlcipher3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
89453       sqlcipher3TableAffinityStr(v, pTab);
89454     }
89455
89456     /* Fire BEFORE or INSTEAD OF triggers */
89457     sqlcipher3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE, 
89458         pTab, regCols-pTab->nCol-1, onError, endOfLoop);
89459
89460     sqlcipher3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
89461   }
89462
89463   /* Push the record number for the new entry onto the stack.  The
89464   ** record number is a randomly generate integer created by NewRowid
89465   ** except when the table has an INTEGER PRIMARY KEY column, in which
89466   ** case the record number is the same as that column. 
89467   */
89468   if( !isView ){
89469     if( IsVirtual(pTab) ){
89470       /* The row that the VUpdate opcode will delete: none */
89471       sqlcipher3VdbeAddOp2(v, OP_Null, 0, regIns);
89472     }
89473     if( keyColumn>=0 ){
89474       if( useTempTable ){
89475         sqlcipher3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
89476       }else if( pSelect ){
89477         sqlcipher3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);
89478       }else{
89479         VdbeOp *pOp;
89480         sqlcipher3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
89481         pOp = sqlcipher3VdbeGetOp(v, -1);
89482         if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
89483           appendFlag = 1;
89484           pOp->opcode = OP_NewRowid;
89485           pOp->p1 = baseCur;
89486           pOp->p2 = regRowid;
89487           pOp->p3 = regAutoinc;
89488         }
89489       }
89490       /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
89491       ** to generate a unique primary key value.
89492       */
89493       if( !appendFlag ){
89494         int j1;
89495         if( !IsVirtual(pTab) ){
89496           j1 = sqlcipher3VdbeAddOp1(v, OP_NotNull, regRowid);
89497           sqlcipher3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
89498           sqlcipher3VdbeJumpHere(v, j1);
89499         }else{
89500           j1 = sqlcipher3VdbeCurrentAddr(v);
89501           sqlcipher3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2);
89502         }
89503         sqlcipher3VdbeAddOp1(v, OP_MustBeInt, regRowid);
89504       }
89505     }else if( IsVirtual(pTab) ){
89506       sqlcipher3VdbeAddOp2(v, OP_Null, 0, regRowid);
89507     }else{
89508       sqlcipher3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
89509       appendFlag = 1;
89510     }
89511     autoIncStep(pParse, regAutoinc, regRowid);
89512
89513     /* Push onto the stack, data for all columns of the new entry, beginning
89514     ** with the first column.
89515     */
89516     nHidden = 0;
89517     for(i=0; i<pTab->nCol; i++){
89518       int iRegStore = regRowid+1+i;
89519       if( i==pTab->iPKey ){
89520         /* The value of the INTEGER PRIMARY KEY column is always a NULL.
89521         ** Whenever this column is read, the record number will be substituted
89522         ** in its place.  So will fill this column with a NULL to avoid
89523         ** taking up data space with information that will never be used. */
89524         sqlcipher3VdbeAddOp2(v, OP_Null, 0, iRegStore);
89525         continue;
89526       }
89527       if( pColumn==0 ){
89528         if( IsHiddenColumn(&pTab->aCol[i]) ){
89529           assert( IsVirtual(pTab) );
89530           j = -1;
89531           nHidden++;
89532         }else{
89533           j = i - nHidden;
89534         }
89535       }else{
89536         for(j=0; j<pColumn->nId; j++){
89537           if( pColumn->a[j].idx==i ) break;
89538         }
89539       }
89540       if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){
89541         sqlcipher3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
89542       }else if( useTempTable ){
89543         sqlcipher3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore); 
89544       }else if( pSelect ){
89545         sqlcipher3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
89546       }else{
89547         sqlcipher3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
89548       }
89549     }
89550
89551     /* Generate code to check constraints and generate index keys and
89552     ** do the insertion.
89553     */
89554 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
89555     if( IsVirtual(pTab) ){
89556       const char *pVTab = (const char *)sqlcipher3GetVTable(db, pTab);
89557       sqlcipher3VtabMakeWritable(pParse, pTab);
89558       sqlcipher3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
89559       sqlcipher3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
89560       sqlcipher3MayAbort(pParse);
89561     }else
89562 #endif
89563     {
89564       int isReplace;    /* Set to true if constraints may cause a replace */
89565       sqlcipher3GenerateConstraintChecks(pParse, pTab, baseCur, regIns, aRegIdx,
89566           keyColumn>=0, 0, onError, endOfLoop, &isReplace
89567       );
89568       sqlcipher3FkCheck(pParse, pTab, 0, regIns);
89569       sqlcipher3CompleteInsertion(
89570           pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0
89571       );
89572     }
89573   }
89574
89575   /* Update the count of rows that are inserted
89576   */
89577   if( (db->flags & SQLCIPHER_CountRows)!=0 ){
89578     sqlcipher3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
89579   }
89580
89581   if( pTrigger ){
89582     /* Code AFTER triggers */
89583     sqlcipher3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER, 
89584         pTab, regData-2-pTab->nCol, onError, endOfLoop);
89585   }
89586
89587   /* The bottom of the main insertion loop, if the data source
89588   ** is a SELECT statement.
89589   */
89590   sqlcipher3VdbeResolveLabel(v, endOfLoop);
89591   if( useTempTable ){
89592     sqlcipher3VdbeAddOp2(v, OP_Next, srcTab, addrCont);
89593     sqlcipher3VdbeJumpHere(v, addrInsTop);
89594     sqlcipher3VdbeAddOp1(v, OP_Close, srcTab);
89595   }else if( pSelect ){
89596     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addrCont);
89597     sqlcipher3VdbeJumpHere(v, addrInsTop);
89598   }
89599
89600   if( !IsVirtual(pTab) && !isView ){
89601     /* Close all tables opened */
89602     sqlcipher3VdbeAddOp1(v, OP_Close, baseCur);
89603     for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
89604       sqlcipher3VdbeAddOp1(v, OP_Close, idx+baseCur);
89605     }
89606   }
89607
89608 insert_end:
89609   /* Update the sqlcipher_sequence table by storing the content of the
89610   ** maximum rowid counter values recorded while inserting into
89611   ** autoincrement tables.
89612   */
89613   if( pParse->nested==0 && pParse->pTriggerTab==0 ){
89614     sqlcipher3AutoincrementEnd(pParse);
89615   }
89616
89617   /*
89618   ** Return the number of rows inserted. If this routine is 
89619   ** generating code because of a call to sqlcipher3NestedParse(), do not
89620   ** invoke the callback function.
89621   */
89622   if( (db->flags&SQLCIPHER_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
89623     sqlcipher3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
89624     sqlcipher3VdbeSetNumCols(v, 1);
89625     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLCIPHER_STATIC);
89626   }
89627
89628 insert_cleanup:
89629   sqlcipher3SrcListDelete(db, pTabList);
89630   sqlcipher3ExprListDelete(db, pList);
89631   sqlcipher3SelectDelete(db, pSelect);
89632   sqlcipher3IdListDelete(db, pColumn);
89633   sqlcipher3DbFree(db, aRegIdx);
89634 }
89635
89636 /* Make sure "isView" and other macros defined above are undefined. Otherwise
89637 ** thely may interfere with compilation of other functions in this file
89638 ** (or in another file, if this file becomes part of the amalgamation).  */
89639 #ifdef isView
89640  #undef isView
89641 #endif
89642 #ifdef pTrigger
89643  #undef pTrigger
89644 #endif
89645 #ifdef tmask
89646  #undef tmask
89647 #endif
89648
89649
89650 /*
89651 ** Generate code to do constraint checks prior to an INSERT or an UPDATE.
89652 **
89653 ** The input is a range of consecutive registers as follows:
89654 **
89655 **    1.  The rowid of the row after the update.
89656 **
89657 **    2.  The data in the first column of the entry after the update.
89658 **
89659 **    i.  Data from middle columns...
89660 **
89661 **    N.  The data in the last column of the entry after the update.
89662 **
89663 ** The regRowid parameter is the index of the register containing (1).
89664 **
89665 ** If isUpdate is true and rowidChng is non-zero, then rowidChng contains
89666 ** the address of a register containing the rowid before the update takes
89667 ** place. isUpdate is true for UPDATEs and false for INSERTs. If isUpdate
89668 ** is false, indicating an INSERT statement, then a non-zero rowidChng 
89669 ** indicates that the rowid was explicitly specified as part of the
89670 ** INSERT statement. If rowidChng is false, it means that  the rowid is
89671 ** computed automatically in an insert or that the rowid value is not 
89672 ** modified by an update.
89673 **
89674 ** The code generated by this routine store new index entries into
89675 ** registers identified by aRegIdx[].  No index entry is created for
89676 ** indices where aRegIdx[i]==0.  The order of indices in aRegIdx[] is
89677 ** the same as the order of indices on the linked list of indices
89678 ** attached to the table.
89679 **
89680 ** This routine also generates code to check constraints.  NOT NULL,
89681 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
89682 ** then the appropriate action is performed.  There are five possible
89683 ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
89684 **
89685 **  Constraint type  Action       What Happens
89686 **  ---------------  ----------   ----------------------------------------
89687 **  any              ROLLBACK     The current transaction is rolled back and
89688 **                                sqlcipher3_exec() returns immediately with a
89689 **                                return code of SQLCIPHER_CONSTRAINT.
89690 **
89691 **  any              ABORT        Back out changes from the current command
89692 **                                only (do not do a complete rollback) then
89693 **                                cause sqlcipher3_exec() to return immediately
89694 **                                with SQLCIPHER_CONSTRAINT.
89695 **
89696 **  any              FAIL         Sqlite_exec() returns immediately with a
89697 **                                return code of SQLCIPHER_CONSTRAINT.  The
89698 **                                transaction is not rolled back and any
89699 **                                prior changes are retained.
89700 **
89701 **  any              IGNORE       The record number and data is popped from
89702 **                                the stack and there is an immediate jump
89703 **                                to label ignoreDest.
89704 **
89705 **  NOT NULL         REPLACE      The NULL value is replace by the default
89706 **                                value for that column.  If the default value
89707 **                                is NULL, the action is the same as ABORT.
89708 **
89709 **  UNIQUE           REPLACE      The other row that conflicts with the row
89710 **                                being inserted is removed.
89711 **
89712 **  CHECK            REPLACE      Illegal.  The results in an exception.
89713 **
89714 ** Which action to take is determined by the overrideError parameter.
89715 ** Or if overrideError==OE_Default, then the pParse->onError parameter
89716 ** is used.  Or if pParse->onError==OE_Default then the onError value
89717 ** for the constraint is used.
89718 **
89719 ** The calling routine must open a read/write cursor for pTab with
89720 ** cursor number "baseCur".  All indices of pTab must also have open
89721 ** read/write cursors with cursor number baseCur+i for the i-th cursor.
89722 ** Except, if there is no possibility of a REPLACE action then
89723 ** cursors do not need to be open for indices where aRegIdx[i]==0.
89724 */
89725 SQLCIPHER_PRIVATE void sqlcipher3GenerateConstraintChecks(
89726   Parse *pParse,      /* The parser context */
89727   Table *pTab,        /* the table into which we are inserting */
89728   int baseCur,        /* Index of a read/write cursor pointing at pTab */
89729   int regRowid,       /* Index of the range of input registers */
89730   int *aRegIdx,       /* Register used by each index.  0 for unused indices */
89731   int rowidChng,      /* True if the rowid might collide with existing entry */
89732   int isUpdate,       /* True for UPDATE, False for INSERT */
89733   int overrideError,  /* Override onError to this if not OE_Default */
89734   int ignoreDest,     /* Jump to this label on an OE_Ignore resolution */
89735   int *pbMayReplace   /* OUT: Set to true if constraint may cause a replace */
89736 ){
89737   int i;              /* loop counter */
89738   Vdbe *v;            /* VDBE under constrution */
89739   int nCol;           /* Number of columns */
89740   int onError;        /* Conflict resolution strategy */
89741   int j1;             /* Addresss of jump instruction */
89742   int j2 = 0, j3;     /* Addresses of jump instructions */
89743   int regData;        /* Register containing first data column */
89744   int iCur;           /* Table cursor number */
89745   Index *pIdx;         /* Pointer to one of the indices */
89746   int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
89747   int regOldRowid = (rowidChng && isUpdate) ? rowidChng : regRowid;
89748
89749   v = sqlcipher3GetVdbe(pParse);
89750   assert( v!=0 );
89751   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
89752   nCol = pTab->nCol;
89753   regData = regRowid + 1;
89754
89755   /* Test all NOT NULL constraints.
89756   */
89757   for(i=0; i<nCol; i++){
89758     if( i==pTab->iPKey ){
89759       continue;
89760     }
89761     onError = pTab->aCol[i].notNull;
89762     if( onError==OE_None ) continue;
89763     if( overrideError!=OE_Default ){
89764       onError = overrideError;
89765     }else if( onError==OE_Default ){
89766       onError = OE_Abort;
89767     }
89768     if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
89769       onError = OE_Abort;
89770     }
89771     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
89772         || onError==OE_Ignore || onError==OE_Replace );
89773     switch( onError ){
89774       case OE_Abort:
89775         sqlcipher3MayAbort(pParse);
89776       case OE_Rollback:
89777       case OE_Fail: {
89778         char *zMsg;
89779         sqlcipher3VdbeAddOp3(v, OP_HaltIfNull,
89780                                   SQLCIPHER_CONSTRAINT, onError, regData+i);
89781         zMsg = sqlcipher3MPrintf(pParse->db, "%s.%s may not be NULL",
89782                               pTab->zName, pTab->aCol[i].zName);
89783         sqlcipher3VdbeChangeP4(v, -1, zMsg, P4_DYNAMIC);
89784         break;
89785       }
89786       case OE_Ignore: {
89787         sqlcipher3VdbeAddOp2(v, OP_IsNull, regData+i, ignoreDest);
89788         break;
89789       }
89790       default: {
89791         assert( onError==OE_Replace );
89792         j1 = sqlcipher3VdbeAddOp1(v, OP_NotNull, regData+i);
89793         sqlcipher3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
89794         sqlcipher3VdbeJumpHere(v, j1);
89795         break;
89796       }
89797     }
89798   }
89799
89800   /* Test all CHECK constraints
89801   */
89802 #ifndef SQLCIPHER_OMIT_CHECK
89803   if( pTab->pCheck && (pParse->db->flags & SQLCIPHER_IgnoreChecks)==0 ){
89804     int allOk = sqlcipher3VdbeMakeLabel(v);
89805     pParse->ckBase = regData;
89806     sqlcipher3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLCIPHER_JUMPIFNULL);
89807     onError = overrideError!=OE_Default ? overrideError : OE_Abort;
89808     if( onError==OE_Ignore ){
89809       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
89810     }else{
89811       if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-15569-63625 */
89812       sqlcipher3HaltConstraint(pParse, onError, 0, 0);
89813     }
89814     sqlcipher3VdbeResolveLabel(v, allOk);
89815   }
89816 #endif /* !defined(SQLCIPHER_OMIT_CHECK) */
89817
89818   /* If we have an INTEGER PRIMARY KEY, make sure the primary key
89819   ** of the new record does not previously exist.  Except, if this
89820   ** is an UPDATE and the primary key is not changing, that is OK.
89821   */
89822   if( rowidChng ){
89823     onError = pTab->keyConf;
89824     if( overrideError!=OE_Default ){
89825       onError = overrideError;
89826     }else if( onError==OE_Default ){
89827       onError = OE_Abort;
89828     }
89829     
89830     if( isUpdate ){
89831       j2 = sqlcipher3VdbeAddOp3(v, OP_Eq, regRowid, 0, rowidChng);
89832     }
89833     j3 = sqlcipher3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
89834     switch( onError ){
89835       default: {
89836         onError = OE_Abort;
89837         /* Fall thru into the next case */
89838       }
89839       case OE_Rollback:
89840       case OE_Abort:
89841       case OE_Fail: {
89842         sqlcipher3HaltConstraint(
89843           pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
89844         break;
89845       }
89846       case OE_Replace: {
89847         /* If there are DELETE triggers on this table and the
89848         ** recursive-triggers flag is set, call GenerateRowDelete() to
89849         ** remove the conflicting row from the the table. This will fire
89850         ** the triggers and remove both the table and index b-tree entries.
89851         **
89852         ** Otherwise, if there are no triggers or the recursive-triggers
89853         ** flag is not set, but the table has one or more indexes, call 
89854         ** GenerateRowIndexDelete(). This removes the index b-tree entries 
89855         ** only. The table b-tree entry will be replaced by the new entry 
89856         ** when it is inserted.  
89857         **
89858         ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
89859         ** also invoke MultiWrite() to indicate that this VDBE may require
89860         ** statement rollback (if the statement is aborted after the delete
89861         ** takes place). Earlier versions called sqlcipher3MultiWrite() regardless,
89862         ** but being more selective here allows statements like:
89863         **
89864         **   REPLACE INTO t(rowid) VALUES($newrowid)
89865         **
89866         ** to run without a statement journal if there are no indexes on the
89867         ** table.
89868         */
89869         Trigger *pTrigger = 0;
89870         if( pParse->db->flags&SQLCIPHER_RecTriggers ){
89871           pTrigger = sqlcipher3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
89872         }
89873         if( pTrigger || sqlcipher3FkRequired(pParse, pTab, 0, 0) ){
89874           sqlcipher3MultiWrite(pParse);
89875           sqlcipher3GenerateRowDelete(
89876               pParse, pTab, baseCur, regRowid, 0, pTrigger, OE_Replace
89877           );
89878         }else if( pTab->pIndex ){
89879           sqlcipher3MultiWrite(pParse);
89880           sqlcipher3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
89881         }
89882         seenReplace = 1;
89883         break;
89884       }
89885       case OE_Ignore: {
89886         assert( seenReplace==0 );
89887         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
89888         break;
89889       }
89890     }
89891     sqlcipher3VdbeJumpHere(v, j3);
89892     if( isUpdate ){
89893       sqlcipher3VdbeJumpHere(v, j2);
89894     }
89895   }
89896
89897   /* Test all UNIQUE constraints by creating entries for each UNIQUE
89898   ** index and making sure that duplicate entries do not already exist.
89899   ** Add the new records to the indices as we go.
89900   */
89901   for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
89902     int regIdx;
89903     int regR;
89904
89905     if( aRegIdx[iCur]==0 ) continue;  /* Skip unused indices */
89906
89907     /* Create a key for accessing the index entry */
89908     regIdx = sqlcipher3GetTempRange(pParse, pIdx->nColumn+1);
89909     for(i=0; i<pIdx->nColumn; i++){
89910       int idx = pIdx->aiColumn[i];
89911       if( idx==pTab->iPKey ){
89912         sqlcipher3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
89913       }else{
89914         sqlcipher3VdbeAddOp2(v, OP_SCopy, regData+idx, regIdx+i);
89915       }
89916     }
89917     sqlcipher3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
89918     sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn+1, aRegIdx[iCur]);
89919     sqlcipher3VdbeChangeP4(v, -1, sqlcipher3IndexAffinityStr(v, pIdx), P4_TRANSIENT);
89920     sqlcipher3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn+1);
89921
89922     /* Find out what action to take in case there is an indexing conflict */
89923     onError = pIdx->onError;
89924     if( onError==OE_None ){ 
89925       sqlcipher3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
89926       continue;  /* pIdx is not a UNIQUE index */
89927     }
89928     if( overrideError!=OE_Default ){
89929       onError = overrideError;
89930     }else if( onError==OE_Default ){
89931       onError = OE_Abort;
89932     }
89933     if( seenReplace ){
89934       if( onError==OE_Ignore ) onError = OE_Replace;
89935       else if( onError==OE_Fail ) onError = OE_Abort;
89936     }
89937     
89938     /* Check to see if the new index entry will be unique */
89939     regR = sqlcipher3GetTempReg(pParse);
89940     sqlcipher3VdbeAddOp2(v, OP_SCopy, regOldRowid, regR);
89941     j3 = sqlcipher3VdbeAddOp4(v, OP_IsUnique, baseCur+iCur+1, 0,
89942                            regR, SQLCIPHER_INT_TO_PTR(regIdx),
89943                            P4_INT32);
89944     sqlcipher3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
89945
89946     /* Generate code that executes if the new index entry is not unique */
89947     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
89948         || onError==OE_Ignore || onError==OE_Replace );
89949     switch( onError ){
89950       case OE_Rollback:
89951       case OE_Abort:
89952       case OE_Fail: {
89953         int j;
89954         StrAccum errMsg;
89955         const char *zSep;
89956         char *zErr;
89957
89958         sqlcipher3StrAccumInit(&errMsg, 0, 0, 200);
89959         errMsg.db = pParse->db;
89960         zSep = pIdx->nColumn>1 ? "columns " : "column ";
89961         for(j=0; j<pIdx->nColumn; j++){
89962           char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
89963           sqlcipher3StrAccumAppend(&errMsg, zSep, -1);
89964           zSep = ", ";
89965           sqlcipher3StrAccumAppend(&errMsg, zCol, -1);
89966         }
89967         sqlcipher3StrAccumAppend(&errMsg,
89968             pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
89969         zErr = sqlcipher3StrAccumFinish(&errMsg);
89970         sqlcipher3HaltConstraint(pParse, onError, zErr, 0);
89971         sqlcipher3DbFree(errMsg.db, zErr);
89972         break;
89973       }
89974       case OE_Ignore: {
89975         assert( seenReplace==0 );
89976         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
89977         break;
89978       }
89979       default: {
89980         Trigger *pTrigger = 0;
89981         assert( onError==OE_Replace );
89982         sqlcipher3MultiWrite(pParse);
89983         if( pParse->db->flags&SQLCIPHER_RecTriggers ){
89984           pTrigger = sqlcipher3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
89985         }
89986         sqlcipher3GenerateRowDelete(
89987             pParse, pTab, baseCur, regR, 0, pTrigger, OE_Replace
89988         );
89989         seenReplace = 1;
89990         break;
89991       }
89992     }
89993     sqlcipher3VdbeJumpHere(v, j3);
89994     sqlcipher3ReleaseTempReg(pParse, regR);
89995   }
89996   
89997   if( pbMayReplace ){
89998     *pbMayReplace = seenReplace;
89999   }
90000 }
90001
90002 /*
90003 ** This routine generates code to finish the INSERT or UPDATE operation
90004 ** that was started by a prior call to sqlcipher3GenerateConstraintChecks.
90005 ** A consecutive range of registers starting at regRowid contains the
90006 ** rowid and the content to be inserted.
90007 **
90008 ** The arguments to this routine should be the same as the first six
90009 ** arguments to sqlcipher3GenerateConstraintChecks.
90010 */
90011 SQLCIPHER_PRIVATE void sqlcipher3CompleteInsertion(
90012   Parse *pParse,      /* The parser context */
90013   Table *pTab,        /* the table into which we are inserting */
90014   int baseCur,        /* Index of a read/write cursor pointing at pTab */
90015   int regRowid,       /* Range of content */
90016   int *aRegIdx,       /* Register used by each index.  0 for unused indices */
90017   int isUpdate,       /* True for UPDATE, False for INSERT */
90018   int appendBias,     /* True if this is likely to be an append */
90019   int useSeekResult   /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
90020 ){
90021   int i;
90022   Vdbe *v;
90023   int nIdx;
90024   Index *pIdx;
90025   u8 pik_flags;
90026   int regData;
90027   int regRec;
90028
90029   v = sqlcipher3GetVdbe(pParse);
90030   assert( v!=0 );
90031   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
90032   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
90033   for(i=nIdx-1; i>=0; i--){
90034     if( aRegIdx[i]==0 ) continue;
90035     sqlcipher3VdbeAddOp2(v, OP_IdxInsert, baseCur+i+1, aRegIdx[i]);
90036     if( useSeekResult ){
90037       sqlcipher3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
90038     }
90039   }
90040   regData = regRowid + 1;
90041   regRec = sqlcipher3GetTempReg(pParse);
90042   sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
90043   sqlcipher3TableAffinityStr(v, pTab);
90044   sqlcipher3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
90045   if( pParse->nested ){
90046     pik_flags = 0;
90047   }else{
90048     pik_flags = OPFLAG_NCHANGE;
90049     pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID);
90050   }
90051   if( appendBias ){
90052     pik_flags |= OPFLAG_APPEND;
90053   }
90054   if( useSeekResult ){
90055     pik_flags |= OPFLAG_USESEEKRESULT;
90056   }
90057   sqlcipher3VdbeAddOp3(v, OP_Insert, baseCur, regRec, regRowid);
90058   if( !pParse->nested ){
90059     sqlcipher3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
90060   }
90061   sqlcipher3VdbeChangeP5(v, pik_flags);
90062 }
90063
90064 /*
90065 ** Generate code that will open cursors for a table and for all
90066 ** indices of that table.  The "baseCur" parameter is the cursor number used
90067 ** for the table.  Indices are opened on subsequent cursors.
90068 **
90069 ** Return the number of indices on the table.
90070 */
90071 SQLCIPHER_PRIVATE int sqlcipher3OpenTableAndIndices(
90072   Parse *pParse,   /* Parsing context */
90073   Table *pTab,     /* Table to be opened */
90074   int baseCur,     /* Cursor number assigned to the table */
90075   int op           /* OP_OpenRead or OP_OpenWrite */
90076 ){
90077   int i;
90078   int iDb;
90079   Index *pIdx;
90080   Vdbe *v;
90081
90082   if( IsVirtual(pTab) ) return 0;
90083   iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
90084   v = sqlcipher3GetVdbe(pParse);
90085   assert( v!=0 );
90086   sqlcipher3OpenTable(pParse, baseCur, iDb, pTab, op);
90087   for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
90088     KeyInfo *pKey = sqlcipher3IndexKeyinfo(pParse, pIdx);
90089     assert( pIdx->pSchema==pTab->pSchema );
90090     sqlcipher3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
90091                       (char*)pKey, P4_KEYINFO_HANDOFF);
90092     VdbeComment((v, "%s", pIdx->zName));
90093   }
90094   if( pParse->nTab<baseCur+i ){
90095     pParse->nTab = baseCur+i;
90096   }
90097   return i-1;
90098 }
90099
90100
90101 #ifdef SQLCIPHER_TEST
90102 /*
90103 ** The following global variable is incremented whenever the
90104 ** transfer optimization is used.  This is used for testing
90105 ** purposes only - to make sure the transfer optimization really
90106 ** is happening when it is suppose to.
90107 */
90108 SQLCIPHER_API int sqlcipher3_xferopt_count;
90109 #endif /* SQLCIPHER_TEST */
90110
90111
90112 #ifndef SQLCIPHER_OMIT_XFER_OPT
90113 /*
90114 ** Check to collation names to see if they are compatible.
90115 */
90116 static int xferCompatibleCollation(const char *z1, const char *z2){
90117   if( z1==0 ){
90118     return z2==0;
90119   }
90120   if( z2==0 ){
90121     return 0;
90122   }
90123   return sqlcipher3StrICmp(z1, z2)==0;
90124 }
90125
90126
90127 /*
90128 ** Check to see if index pSrc is compatible as a source of data
90129 ** for index pDest in an insert transfer optimization.  The rules
90130 ** for a compatible index:
90131 **
90132 **    *   The index is over the same set of columns
90133 **    *   The same DESC and ASC markings occurs on all columns
90134 **    *   The same onError processing (OE_Abort, OE_Ignore, etc)
90135 **    *   The same collating sequence on each column
90136 */
90137 static int xferCompatibleIndex(Index *pDest, Index *pSrc){
90138   int i;
90139   assert( pDest && pSrc );
90140   assert( pDest->pTable!=pSrc->pTable );
90141   if( pDest->nColumn!=pSrc->nColumn ){
90142     return 0;   /* Different number of columns */
90143   }
90144   if( pDest->onError!=pSrc->onError ){
90145     return 0;   /* Different conflict resolution strategies */
90146   }
90147   for(i=0; i<pSrc->nColumn; i++){
90148     if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
90149       return 0;   /* Different columns indexed */
90150     }
90151     if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
90152       return 0;   /* Different sort orders */
90153     }
90154     if( !xferCompatibleCollation(pSrc->azColl[i],pDest->azColl[i]) ){
90155       return 0;   /* Different collating sequences */
90156     }
90157   }
90158
90159   /* If no test above fails then the indices must be compatible */
90160   return 1;
90161 }
90162
90163 /*
90164 ** Attempt the transfer optimization on INSERTs of the form
90165 **
90166 **     INSERT INTO tab1 SELECT * FROM tab2;
90167 **
90168 ** This optimization is only attempted if
90169 **
90170 **    (1)  tab1 and tab2 have identical schemas including all the
90171 **         same indices and constraints
90172 **
90173 **    (2)  tab1 and tab2 are different tables
90174 **
90175 **    (3)  There must be no triggers on tab1
90176 **
90177 **    (4)  The result set of the SELECT statement is "*"
90178 **
90179 **    (5)  The SELECT statement has no WHERE, HAVING, ORDER BY, GROUP BY,
90180 **         or LIMIT clause.
90181 **
90182 **    (6)  The SELECT statement is a simple (not a compound) select that
90183 **         contains only tab2 in its FROM clause
90184 **
90185 ** This method for implementing the INSERT transfers raw records from
90186 ** tab2 over to tab1.  The columns are not decoded.  Raw records from
90187 ** the indices of tab2 are transfered to tab1 as well.  In so doing,
90188 ** the resulting tab1 has much less fragmentation.
90189 **
90190 ** This routine returns TRUE if the optimization is attempted.  If any
90191 ** of the conditions above fail so that the optimization should not
90192 ** be attempted, then this routine returns FALSE.
90193 */
90194 static int xferOptimization(
90195   Parse *pParse,        /* Parser context */
90196   Table *pDest,         /* The table we are inserting into */
90197   Select *pSelect,      /* A SELECT statement to use as the data source */
90198   int onError,          /* How to handle constraint errors */
90199   int iDbDest           /* The database of pDest */
90200 ){
90201   ExprList *pEList;                /* The result set of the SELECT */
90202   Table *pSrc;                     /* The table in the FROM clause of SELECT */
90203   Index *pSrcIdx, *pDestIdx;       /* Source and destination indices */
90204   struct SrcList_item *pItem;      /* An element of pSelect->pSrc */
90205   int i;                           /* Loop counter */
90206   int iDbSrc;                      /* The database of pSrc */
90207   int iSrc, iDest;                 /* Cursors from source and destination */
90208   int addr1, addr2;                /* Loop addresses */
90209   int emptyDestTest;               /* Address of test for empty pDest */
90210   int emptySrcTest;                /* Address of test for empty pSrc */
90211   Vdbe *v;                         /* The VDBE we are building */
90212   KeyInfo *pKey;                   /* Key information for an index */
90213   int regAutoinc;                  /* Memory register used by AUTOINC */
90214   int destHasUniqueIdx = 0;        /* True if pDest has a UNIQUE index */
90215   int regData, regRowid;           /* Registers holding data and rowid */
90216
90217   if( pSelect==0 ){
90218     return 0;   /* Must be of the form  INSERT INTO ... SELECT ... */
90219   }
90220   if( sqlcipher3TriggerList(pParse, pDest) ){
90221     return 0;   /* tab1 must not have triggers */
90222   }
90223 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
90224   if( pDest->tabFlags & TF_Virtual ){
90225     return 0;   /* tab1 must not be a virtual table */
90226   }
90227 #endif
90228   if( onError==OE_Default ){
90229     onError = OE_Abort;
90230   }
90231   if( onError!=OE_Abort && onError!=OE_Rollback ){
90232     return 0;   /* Cannot do OR REPLACE or OR IGNORE or OR FAIL */
90233   }
90234   assert(pSelect->pSrc);   /* allocated even if there is no FROM clause */
90235   if( pSelect->pSrc->nSrc!=1 ){
90236     return 0;   /* FROM clause must have exactly one term */
90237   }
90238   if( pSelect->pSrc->a[0].pSelect ){
90239     return 0;   /* FROM clause cannot contain a subquery */
90240   }
90241   if( pSelect->pWhere ){
90242     return 0;   /* SELECT may not have a WHERE clause */
90243   }
90244   if( pSelect->pOrderBy ){
90245     return 0;   /* SELECT may not have an ORDER BY clause */
90246   }
90247   /* Do not need to test for a HAVING clause.  If HAVING is present but
90248   ** there is no ORDER BY, we will get an error. */
90249   if( pSelect->pGroupBy ){
90250     return 0;   /* SELECT may not have a GROUP BY clause */
90251   }
90252   if( pSelect->pLimit ){
90253     return 0;   /* SELECT may not have a LIMIT clause */
90254   }
90255   assert( pSelect->pOffset==0 );  /* Must be so if pLimit==0 */
90256   if( pSelect->pPrior ){
90257     return 0;   /* SELECT may not be a compound query */
90258   }
90259   if( pSelect->selFlags & SF_Distinct ){
90260     return 0;   /* SELECT may not be DISTINCT */
90261   }
90262   pEList = pSelect->pEList;
90263   assert( pEList!=0 );
90264   if( pEList->nExpr!=1 ){
90265     return 0;   /* The result set must have exactly one column */
90266   }
90267   assert( pEList->a[0].pExpr );
90268   if( pEList->a[0].pExpr->op!=TK_ALL ){
90269     return 0;   /* The result set must be the special operator "*" */
90270   }
90271
90272   /* At this point we have established that the statement is of the
90273   ** correct syntactic form to participate in this optimization.  Now
90274   ** we have to check the semantics.
90275   */
90276   pItem = pSelect->pSrc->a;
90277   pSrc = sqlcipher3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
90278   if( pSrc==0 ){
90279     return 0;   /* FROM clause does not contain a real table */
90280   }
90281   if( pSrc==pDest ){
90282     return 0;   /* tab1 and tab2 may not be the same table */
90283   }
90284 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
90285   if( pSrc->tabFlags & TF_Virtual ){
90286     return 0;   /* tab2 must not be a virtual table */
90287   }
90288 #endif
90289   if( pSrc->pSelect ){
90290     return 0;   /* tab2 may not be a view */
90291   }
90292   if( pDest->nCol!=pSrc->nCol ){
90293     return 0;   /* Number of columns must be the same in tab1 and tab2 */
90294   }
90295   if( pDest->iPKey!=pSrc->iPKey ){
90296     return 0;   /* Both tables must have the same INTEGER PRIMARY KEY */
90297   }
90298   for(i=0; i<pDest->nCol; i++){
90299     if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
90300       return 0;    /* Affinity must be the same on all columns */
90301     }
90302     if( !xferCompatibleCollation(pDest->aCol[i].zColl, pSrc->aCol[i].zColl) ){
90303       return 0;    /* Collating sequence must be the same on all columns */
90304     }
90305     if( pDest->aCol[i].notNull && !pSrc->aCol[i].notNull ){
90306       return 0;    /* tab2 must be NOT NULL if tab1 is */
90307     }
90308   }
90309   for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90310     if( pDestIdx->onError!=OE_None ){
90311       destHasUniqueIdx = 1;
90312     }
90313     for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
90314       if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
90315     }
90316     if( pSrcIdx==0 ){
90317       return 0;    /* pDestIdx has no corresponding index in pSrc */
90318     }
90319   }
90320 #ifndef SQLCIPHER_OMIT_CHECK
90321   if( pDest->pCheck && sqlcipher3ExprCompare(pSrc->pCheck, pDest->pCheck) ){
90322     return 0;   /* Tables have different CHECK constraints.  Ticket #2252 */
90323   }
90324 #endif
90325 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
90326   /* Disallow the transfer optimization if the destination table constains
90327   ** any foreign key constraints.  This is more restrictive than necessary.
90328   ** But the main beneficiary of the transfer optimization is the VACUUM 
90329   ** command, and the VACUUM command disables foreign key constraints.  So
90330   ** the extra complication to make this rule less restrictive is probably
90331   ** not worth the effort.  Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
90332   */
90333   if( (pParse->db->flags & SQLCIPHER_ForeignKeys)!=0 && pDest->pFKey!=0 ){
90334     return 0;
90335   }
90336 #endif
90337   if( (pParse->db->flags & SQLCIPHER_CountRows)!=0 ){
90338     return 0;
90339   }
90340
90341   /* If we get this far, it means either:
90342   **
90343   **    *   We can always do the transfer if the table contains an
90344   **        an integer primary key
90345   **
90346   **    *   We can conditionally do the transfer if the destination
90347   **        table is empty.
90348   */
90349 #ifdef SQLCIPHER_TEST
90350   sqlcipher3_xferopt_count++;
90351 #endif
90352   iDbSrc = sqlcipher3SchemaToIndex(pParse->db, pSrc->pSchema);
90353   v = sqlcipher3GetVdbe(pParse);
90354   sqlcipher3CodeVerifySchema(pParse, iDbSrc);
90355   iSrc = pParse->nTab++;
90356   iDest = pParse->nTab++;
90357   regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
90358   sqlcipher3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
90359   if( (pDest->iPKey<0 && pDest->pIndex!=0) || destHasUniqueIdx ){
90360     /* If tables do not have an INTEGER PRIMARY KEY and there
90361     ** are indices to be copied and the destination is not empty,
90362     ** we have to disallow the transfer optimization because the
90363     ** the rowids might change which will mess up indexing.
90364     **
90365     ** Or if the destination has a UNIQUE index and is not empty,
90366     ** we also disallow the transfer optimization because we cannot
90367     ** insure that all entries in the union of DEST and SRC will be
90368     ** unique.
90369     */
90370     addr1 = sqlcipher3VdbeAddOp2(v, OP_Rewind, iDest, 0);
90371     emptyDestTest = sqlcipher3VdbeAddOp2(v, OP_Goto, 0, 0);
90372     sqlcipher3VdbeJumpHere(v, addr1);
90373   }else{
90374     emptyDestTest = 0;
90375   }
90376   sqlcipher3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
90377   emptySrcTest = sqlcipher3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
90378   regData = sqlcipher3GetTempReg(pParse);
90379   regRowid = sqlcipher3GetTempReg(pParse);
90380   if( pDest->iPKey>=0 ){
90381     addr1 = sqlcipher3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
90382     addr2 = sqlcipher3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
90383     sqlcipher3HaltConstraint(
90384         pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
90385     sqlcipher3VdbeJumpHere(v, addr2);
90386     autoIncStep(pParse, regAutoinc, regRowid);
90387   }else if( pDest->pIndex==0 ){
90388     addr1 = sqlcipher3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
90389   }else{
90390     addr1 = sqlcipher3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
90391     assert( (pDest->tabFlags & TF_Autoincrement)==0 );
90392   }
90393   sqlcipher3VdbeAddOp2(v, OP_RowData, iSrc, regData);
90394   sqlcipher3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
90395   sqlcipher3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
90396   sqlcipher3VdbeChangeP4(v, -1, pDest->zName, 0);
90397   sqlcipher3VdbeAddOp2(v, OP_Next, iSrc, addr1);
90398   for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90399     for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
90400       if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
90401     }
90402     assert( pSrcIdx );
90403     sqlcipher3VdbeAddOp2(v, OP_Close, iSrc, 0);
90404     sqlcipher3VdbeAddOp2(v, OP_Close, iDest, 0);
90405     pKey = sqlcipher3IndexKeyinfo(pParse, pSrcIdx);
90406     sqlcipher3VdbeAddOp4(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc,
90407                       (char*)pKey, P4_KEYINFO_HANDOFF);
90408     VdbeComment((v, "%s", pSrcIdx->zName));
90409     pKey = sqlcipher3IndexKeyinfo(pParse, pDestIdx);
90410     sqlcipher3VdbeAddOp4(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest,
90411                       (char*)pKey, P4_KEYINFO_HANDOFF);
90412     VdbeComment((v, "%s", pDestIdx->zName));
90413     addr1 = sqlcipher3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
90414     sqlcipher3VdbeAddOp2(v, OP_RowKey, iSrc, regData);
90415     sqlcipher3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
90416     sqlcipher3VdbeAddOp2(v, OP_Next, iSrc, addr1+1);
90417     sqlcipher3VdbeJumpHere(v, addr1);
90418   }
90419   sqlcipher3VdbeJumpHere(v, emptySrcTest);
90420   sqlcipher3ReleaseTempReg(pParse, regRowid);
90421   sqlcipher3ReleaseTempReg(pParse, regData);
90422   sqlcipher3VdbeAddOp2(v, OP_Close, iSrc, 0);
90423   sqlcipher3VdbeAddOp2(v, OP_Close, iDest, 0);
90424   if( emptyDestTest ){
90425     sqlcipher3VdbeAddOp2(v, OP_Halt, SQLCIPHER_OK, 0);
90426     sqlcipher3VdbeJumpHere(v, emptyDestTest);
90427     sqlcipher3VdbeAddOp2(v, OP_Close, iDest, 0);
90428     return 0;
90429   }else{
90430     return 1;
90431   }
90432 }
90433 #endif /* SQLCIPHER_OMIT_XFER_OPT */
90434
90435 /************** End of insert.c **********************************************/
90436 /************** Begin file legacy.c ******************************************/
90437 /*
90438 ** 2001 September 15
90439 **
90440 ** The author disclaims copyright to this source code.  In place of
90441 ** a legal notice, here is a blessing:
90442 **
90443 **    May you do good and not evil.
90444 **    May you find forgiveness for yourself and forgive others.
90445 **    May you share freely, never taking more than you give.
90446 **
90447 *************************************************************************
90448 ** Main file for the SQLite library.  The routines in this file
90449 ** implement the programmer interface to the library.  Routines in
90450 ** other files are for internal use by SQLite and should not be
90451 ** accessed by users of the library.
90452 */
90453
90454
90455 /*
90456 ** Execute SQL code.  Return one of the SQLCIPHER_ success/failure
90457 ** codes.  Also write an error message into memory obtained from
90458 ** malloc() and make *pzErrMsg point to that message.
90459 **
90460 ** If the SQL is a query, then for each row in the query result
90461 ** the xCallback() function is called.  pArg becomes the first
90462 ** argument to xCallback().  If xCallback=NULL then no callback
90463 ** is invoked, even for queries.
90464 */
90465 SQLCIPHER_API int sqlcipher3_exec(
90466   sqlcipher3 *db,                /* The database on which the SQL executes */
90467   const char *zSql,           /* The SQL to be executed */
90468   sqlcipher3_callback xCallback, /* Invoke this callback routine */
90469   void *pArg,                 /* First argument to xCallback() */
90470   char **pzErrMsg             /* Write error messages here */
90471 ){
90472   int rc = SQLCIPHER_OK;         /* Return code */
90473   const char *zLeftover;      /* Tail of unprocessed SQL */
90474   sqlcipher3_stmt *pStmt = 0;    /* The current SQL statement */
90475   char **azCols = 0;          /* Names of result columns */
90476   int nRetry = 0;             /* Number of retry attempts */
90477   int callbackIsInit;         /* True if callback data is initialized */
90478
90479   if( !sqlcipher3SafetyCheckOk(db) ) return SQLCIPHER_MISUSE_BKPT;
90480   if( zSql==0 ) zSql = "";
90481
90482   sqlcipher3_mutex_enter(db->mutex);
90483   sqlcipher3Error(db, SQLCIPHER_OK, 0);
90484   while( (rc==SQLCIPHER_OK || (rc==SQLCIPHER_SCHEMA && (++nRetry)<2)) && zSql[0] ){
90485     int nCol;
90486     char **azVals = 0;
90487
90488     pStmt = 0;
90489     rc = sqlcipher3_prepare(db, zSql, -1, &pStmt, &zLeftover);
90490     assert( rc==SQLCIPHER_OK || pStmt==0 );
90491     if( rc!=SQLCIPHER_OK ){
90492       continue;
90493     }
90494     if( !pStmt ){
90495       /* this happens for a comment or white-space */
90496       zSql = zLeftover;
90497       continue;
90498     }
90499
90500     callbackIsInit = 0;
90501     nCol = sqlcipher3_column_count(pStmt);
90502
90503     while( 1 ){
90504       int i;
90505       rc = sqlcipher3_step(pStmt);
90506
90507       /* Invoke the callback function if required */
90508       if( xCallback && (SQLCIPHER_ROW==rc || 
90509           (SQLCIPHER_DONE==rc && !callbackIsInit
90510                            && db->flags&SQLCIPHER_NullCallback)) ){
90511         if( !callbackIsInit ){
90512           azCols = sqlcipher3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
90513           if( azCols==0 ){
90514             goto exec_out;
90515           }
90516           for(i=0; i<nCol; i++){
90517             azCols[i] = (char *)sqlcipher3_column_name(pStmt, i);
90518             /* sqlcipher3VdbeSetColName() installs column names as UTF8
90519             ** strings so there is no way for sqlcipher3_column_name() to fail. */
90520             assert( azCols[i]!=0 );
90521           }
90522           callbackIsInit = 1;
90523         }
90524         if( rc==SQLCIPHER_ROW ){
90525           azVals = &azCols[nCol];
90526           for(i=0; i<nCol; i++){
90527             azVals[i] = (char *)sqlcipher3_column_text(pStmt, i);
90528             if( !azVals[i] && sqlcipher3_column_type(pStmt, i)!=SQLCIPHER_NULL ){
90529               db->mallocFailed = 1;
90530               goto exec_out;
90531             }
90532           }
90533         }
90534         if( xCallback(pArg, nCol, azVals, azCols) ){
90535           rc = SQLCIPHER_ABORT;
90536           sqlcipher3VdbeFinalize((Vdbe *)pStmt);
90537           pStmt = 0;
90538           sqlcipher3Error(db, SQLCIPHER_ABORT, 0);
90539           goto exec_out;
90540         }
90541       }
90542
90543       if( rc!=SQLCIPHER_ROW ){
90544         rc = sqlcipher3VdbeFinalize((Vdbe *)pStmt);
90545         pStmt = 0;
90546         if( rc!=SQLCIPHER_SCHEMA ){
90547           nRetry = 0;
90548           zSql = zLeftover;
90549           while( sqlcipher3Isspace(zSql[0]) ) zSql++;
90550         }
90551         break;
90552       }
90553     }
90554
90555     sqlcipher3DbFree(db, azCols);
90556     azCols = 0;
90557   }
90558
90559 exec_out:
90560   if( pStmt ) sqlcipher3VdbeFinalize((Vdbe *)pStmt);
90561   sqlcipher3DbFree(db, azCols);
90562
90563   rc = sqlcipher3ApiExit(db, rc);
90564   if( rc!=SQLCIPHER_OK && ALWAYS(rc==sqlcipher3_errcode(db)) && pzErrMsg ){
90565     int nErrMsg = 1 + sqlcipher3Strlen30(sqlcipher3_errmsg(db));
90566     *pzErrMsg = sqlcipher3Malloc(nErrMsg);
90567     if( *pzErrMsg ){
90568       memcpy(*pzErrMsg, sqlcipher3_errmsg(db), nErrMsg);
90569     }else{
90570       rc = SQLCIPHER_NOMEM;
90571       sqlcipher3Error(db, SQLCIPHER_NOMEM, 0);
90572     }
90573   }else if( pzErrMsg ){
90574     *pzErrMsg = 0;
90575   }
90576
90577   assert( (rc&db->errMask)==rc );
90578   sqlcipher3_mutex_leave(db->mutex);
90579   return rc;
90580 }
90581
90582 /************** End of legacy.c **********************************************/
90583 /************** Begin file loadext.c *****************************************/
90584 /*
90585 ** 2006 June 7
90586 **
90587 ** The author disclaims copyright to this source code.  In place of
90588 ** a legal notice, here is a blessing:
90589 **
90590 **    May you do good and not evil.
90591 **    May you find forgiveness for yourself and forgive others.
90592 **    May you share freely, never taking more than you give.
90593 **
90594 *************************************************************************
90595 ** This file contains code used to dynamically load extensions into
90596 ** the SQLite library.
90597 */
90598
90599 #ifndef SQLCIPHER_CORE
90600   #define SQLCIPHER_CORE 1  /* Disable the API redefinition in sqlcipher3ext.h */
90601 #endif
90602 /************** Include sqlcipher3ext.h in the middle of loadext.c **************/
90603 /************** Begin file sqlcipher3ext.h **************************************/
90604 /*
90605 ** 2006 June 7
90606 **
90607 ** The author disclaims copyright to this source code.  In place of
90608 ** a legal notice, here is a blessing:
90609 **
90610 **    May you do good and not evil.
90611 **    May you find forgiveness for yourself and forgive others.
90612 **    May you share freely, never taking more than you give.
90613 **
90614 *************************************************************************
90615 ** This header file defines the SQLite interface for use by
90616 ** shared libraries that want to be imported as extensions into
90617 ** an SQLite instance.  Shared libraries that intend to be loaded
90618 ** as extensions by SQLite should #include this file instead of 
90619 ** sqlcipher3.h.
90620 */
90621 #ifndef _SQLCIPHER3EXT_H_
90622 #define _SQLCIPHER3EXT_H_
90623
90624 typedef struct sqlcipher3_api_routines sqlcipher3_api_routines;
90625
90626 /*
90627 ** The following structure holds pointers to all of the SQLite API
90628 ** routines.
90629 **
90630 ** WARNING:  In order to maintain backwards compatibility, add new
90631 ** interfaces to the end of this structure only.  If you insert new
90632 ** interfaces in the middle of this structure, then older different
90633 ** versions of SQLite will not be able to load each others' shared
90634 ** libraries!
90635 */
90636 struct sqlcipher3_api_routines {
90637   void * (*aggregate_context)(sqlcipher3_context*,int nBytes);
90638   int  (*aggregate_count)(sqlcipher3_context*);
90639   int  (*bind_blob)(sqlcipher3_stmt*,int,const void*,int n,void(*)(void*));
90640   int  (*bind_double)(sqlcipher3_stmt*,int,double);
90641   int  (*bind_int)(sqlcipher3_stmt*,int,int);
90642   int  (*bind_int64)(sqlcipher3_stmt*,int,sqlcipher_int64);
90643   int  (*bind_null)(sqlcipher3_stmt*,int);
90644   int  (*bind_parameter_count)(sqlcipher3_stmt*);
90645   int  (*bind_parameter_index)(sqlcipher3_stmt*,const char*zName);
90646   const char * (*bind_parameter_name)(sqlcipher3_stmt*,int);
90647   int  (*bind_text)(sqlcipher3_stmt*,int,const char*,int n,void(*)(void*));
90648   int  (*bind_text16)(sqlcipher3_stmt*,int,const void*,int,void(*)(void*));
90649   int  (*bind_value)(sqlcipher3_stmt*,int,const sqlcipher3_value*);
90650   int  (*busy_handler)(sqlcipher3*,int(*)(void*,int),void*);
90651   int  (*busy_timeout)(sqlcipher3*,int ms);
90652   int  (*changes)(sqlcipher3*);
90653   int  (*close)(sqlcipher3*);
90654   int  (*collation_needed)(sqlcipher3*,void*,void(*)(void*,sqlcipher3*,
90655                            int eTextRep,const char*));
90656   int  (*collation_needed16)(sqlcipher3*,void*,void(*)(void*,sqlcipher3*,
90657                              int eTextRep,const void*));
90658   const void * (*column_blob)(sqlcipher3_stmt*,int iCol);
90659   int  (*column_bytes)(sqlcipher3_stmt*,int iCol);
90660   int  (*column_bytes16)(sqlcipher3_stmt*,int iCol);
90661   int  (*column_count)(sqlcipher3_stmt*pStmt);
90662   const char * (*column_database_name)(sqlcipher3_stmt*,int);
90663   const void * (*column_database_name16)(sqlcipher3_stmt*,int);
90664   const char * (*column_decltype)(sqlcipher3_stmt*,int i);
90665   const void * (*column_decltype16)(sqlcipher3_stmt*,int);
90666   double  (*column_double)(sqlcipher3_stmt*,int iCol);
90667   int  (*column_int)(sqlcipher3_stmt*,int iCol);
90668   sqlcipher_int64  (*column_int64)(sqlcipher3_stmt*,int iCol);
90669   const char * (*column_name)(sqlcipher3_stmt*,int);
90670   const void * (*column_name16)(sqlcipher3_stmt*,int);
90671   const char * (*column_origin_name)(sqlcipher3_stmt*,int);
90672   const void * (*column_origin_name16)(sqlcipher3_stmt*,int);
90673   const char * (*column_table_name)(sqlcipher3_stmt*,int);
90674   const void * (*column_table_name16)(sqlcipher3_stmt*,int);
90675   const unsigned char * (*column_text)(sqlcipher3_stmt*,int iCol);
90676   const void * (*column_text16)(sqlcipher3_stmt*,int iCol);
90677   int  (*column_type)(sqlcipher3_stmt*,int iCol);
90678   sqlcipher3_value* (*column_value)(sqlcipher3_stmt*,int iCol);
90679   void * (*commit_hook)(sqlcipher3*,int(*)(void*),void*);
90680   int  (*complete)(const char*sql);
90681   int  (*complete16)(const void*sql);
90682   int  (*create_collation)(sqlcipher3*,const char*,int,void*,
90683                            int(*)(void*,int,const void*,int,const void*));
90684   int  (*create_collation16)(sqlcipher3*,const void*,int,void*,
90685                              int(*)(void*,int,const void*,int,const void*));
90686   int  (*create_function)(sqlcipher3*,const char*,int,int,void*,
90687                           void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
90688                           void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
90689                           void (*xFinal)(sqlcipher3_context*));
90690   int  (*create_function16)(sqlcipher3*,const void*,int,int,void*,
90691                             void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
90692                             void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
90693                             void (*xFinal)(sqlcipher3_context*));
90694   int (*create_module)(sqlcipher3*,const char*,const sqlcipher3_module*,void*);
90695   int  (*data_count)(sqlcipher3_stmt*pStmt);
90696   sqlcipher3 * (*db_handle)(sqlcipher3_stmt*);
90697   int (*declare_vtab)(sqlcipher3*,const char*);
90698   int  (*enable_shared_cache)(int);
90699   int  (*errcode)(sqlcipher3*db);
90700   const char * (*errmsg)(sqlcipher3*);
90701   const void * (*errmsg16)(sqlcipher3*);
90702   int  (*exec)(sqlcipher3*,const char*,sqlcipher3_callback,void*,char**);
90703   int  (*expired)(sqlcipher3_stmt*);
90704   int  (*finalize)(sqlcipher3_stmt*pStmt);
90705   void  (*free)(void*);
90706   void  (*free_table)(char**result);
90707   int  (*get_autocommit)(sqlcipher3*);
90708   void * (*get_auxdata)(sqlcipher3_context*,int);
90709   int  (*get_table)(sqlcipher3*,const char*,char***,int*,int*,char**);
90710   int  (*global_recover)(void);
90711   void  (*interruptx)(sqlcipher3*);
90712   sqlcipher_int64  (*last_insert_rowid)(sqlcipher3*);
90713   const char * (*libversion)(void);
90714   int  (*libversion_number)(void);
90715   void *(*malloc)(int);
90716   char * (*mprintf)(const char*,...);
90717   int  (*open)(const char*,sqlcipher3**);
90718   int  (*open16)(const void*,sqlcipher3**);
90719   int  (*prepare)(sqlcipher3*,const char*,int,sqlcipher3_stmt**,const char**);
90720   int  (*prepare16)(sqlcipher3*,const void*,int,sqlcipher3_stmt**,const void**);
90721   void * (*profile)(sqlcipher3*,void(*)(void*,const char*,sqlcipher_uint64),void*);
90722   void  (*progress_handler)(sqlcipher3*,int,int(*)(void*),void*);
90723   void *(*realloc)(void*,int);
90724   int  (*reset)(sqlcipher3_stmt*pStmt);
90725   void  (*result_blob)(sqlcipher3_context*,const void*,int,void(*)(void*));
90726   void  (*result_double)(sqlcipher3_context*,double);
90727   void  (*result_error)(sqlcipher3_context*,const char*,int);
90728   void  (*result_error16)(sqlcipher3_context*,const void*,int);
90729   void  (*result_int)(sqlcipher3_context*,int);
90730   void  (*result_int64)(sqlcipher3_context*,sqlcipher_int64);
90731   void  (*result_null)(sqlcipher3_context*);
90732   void  (*result_text)(sqlcipher3_context*,const char*,int,void(*)(void*));
90733   void  (*result_text16)(sqlcipher3_context*,const void*,int,void(*)(void*));
90734   void  (*result_text16be)(sqlcipher3_context*,const void*,int,void(*)(void*));
90735   void  (*result_text16le)(sqlcipher3_context*,const void*,int,void(*)(void*));
90736   void  (*result_value)(sqlcipher3_context*,sqlcipher3_value*);
90737   void * (*rollback_hook)(sqlcipher3*,void(*)(void*),void*);
90738   int  (*set_authorizer)(sqlcipher3*,int(*)(void*,int,const char*,const char*,
90739                          const char*,const char*),void*);
90740   void  (*set_auxdata)(sqlcipher3_context*,int,void*,void (*)(void*));
90741   char * (*snprintf)(int,char*,const char*,...);
90742   int  (*step)(sqlcipher3_stmt*);
90743   int  (*table_column_metadata)(sqlcipher3*,const char*,const char*,const char*,
90744                                 char const**,char const**,int*,int*,int*);
90745   void  (*thread_cleanup)(void);
90746   int  (*total_changes)(sqlcipher3*);
90747   void * (*trace)(sqlcipher3*,void(*xTrace)(void*,const char*),void*);
90748   int  (*transfer_bindings)(sqlcipher3_stmt*,sqlcipher3_stmt*);
90749   void * (*update_hook)(sqlcipher3*,void(*)(void*,int ,char const*,char const*,
90750                                          sqlcipher_int64),void*);
90751   void * (*user_data)(sqlcipher3_context*);
90752   const void * (*value_blob)(sqlcipher3_value*);
90753   int  (*value_bytes)(sqlcipher3_value*);
90754   int  (*value_bytes16)(sqlcipher3_value*);
90755   double  (*value_double)(sqlcipher3_value*);
90756   int  (*value_int)(sqlcipher3_value*);
90757   sqlcipher_int64  (*value_int64)(sqlcipher3_value*);
90758   int  (*value_numeric_type)(sqlcipher3_value*);
90759   const unsigned char * (*value_text)(sqlcipher3_value*);
90760   const void * (*value_text16)(sqlcipher3_value*);
90761   const void * (*value_text16be)(sqlcipher3_value*);
90762   const void * (*value_text16le)(sqlcipher3_value*);
90763   int  (*value_type)(sqlcipher3_value*);
90764   char *(*vmprintf)(const char*,va_list);
90765   /* Added ??? */
90766   int (*overload_function)(sqlcipher3*, const char *zFuncName, int nArg);
90767   /* Added by 3.3.13 */
90768   int (*prepare_v2)(sqlcipher3*,const char*,int,sqlcipher3_stmt**,const char**);
90769   int (*prepare16_v2)(sqlcipher3*,const void*,int,sqlcipher3_stmt**,const void**);
90770   int (*clear_bindings)(sqlcipher3_stmt*);
90771   /* Added by 3.4.1 */
90772   int (*create_module_v2)(sqlcipher3*,const char*,const sqlcipher3_module*,void*,
90773                           void (*xDestroy)(void *));
90774   /* Added by 3.5.0 */
90775   int (*bind_zeroblob)(sqlcipher3_stmt*,int,int);
90776   int (*blob_bytes)(sqlcipher3_blob*);
90777   int (*blob_close)(sqlcipher3_blob*);
90778   int (*blob_open)(sqlcipher3*,const char*,const char*,const char*,sqlcipher3_int64,
90779                    int,sqlcipher3_blob**);
90780   int (*blob_read)(sqlcipher3_blob*,void*,int,int);
90781   int (*blob_write)(sqlcipher3_blob*,const void*,int,int);
90782   int (*create_collation_v2)(sqlcipher3*,const char*,int,void*,
90783                              int(*)(void*,int,const void*,int,const void*),
90784                              void(*)(void*));
90785   int (*file_control)(sqlcipher3*,const char*,int,void*);
90786   sqlcipher3_int64 (*memory_highwater)(int);
90787   sqlcipher3_int64 (*memory_used)(void);
90788   sqlcipher3_mutex *(*mutex_alloc)(int);
90789   void (*mutex_enter)(sqlcipher3_mutex*);
90790   void (*mutex_free)(sqlcipher3_mutex*);
90791   void (*mutex_leave)(sqlcipher3_mutex*);
90792   int (*mutex_try)(sqlcipher3_mutex*);
90793   int (*open_v2)(const char*,sqlcipher3**,int,const char*);
90794   int (*release_memory)(int);
90795   void (*result_error_nomem)(sqlcipher3_context*);
90796   void (*result_error_toobig)(sqlcipher3_context*);
90797   int (*sleep)(int);
90798   void (*soft_heap_limit)(int);
90799   sqlcipher3_vfs *(*vfs_find)(const char*);
90800   int (*vfs_register)(sqlcipher3_vfs*,int);
90801   int (*vfs_unregister)(sqlcipher3_vfs*);
90802   int (*xthreadsafe)(void);
90803   void (*result_zeroblob)(sqlcipher3_context*,int);
90804   void (*result_error_code)(sqlcipher3_context*,int);
90805   int (*test_control)(int, ...);
90806   void (*randomness)(int,void*);
90807   sqlcipher3 *(*context_db_handle)(sqlcipher3_context*);
90808   int (*extended_result_codes)(sqlcipher3*,int);
90809   int (*limit)(sqlcipher3*,int,int);
90810   sqlcipher3_stmt *(*next_stmt)(sqlcipher3*,sqlcipher3_stmt*);
90811   const char *(*sql)(sqlcipher3_stmt*);
90812   int (*status)(int,int*,int*,int);
90813   int (*backup_finish)(sqlcipher3_backup*);
90814   sqlcipher3_backup *(*backup_init)(sqlcipher3*,const char*,sqlcipher3*,const char*);
90815   int (*backup_pagecount)(sqlcipher3_backup*);
90816   int (*backup_remaining)(sqlcipher3_backup*);
90817   int (*backup_step)(sqlcipher3_backup*,int);
90818   const char *(*compileoption_get)(int);
90819   int (*compileoption_used)(const char*);
90820   int (*create_function_v2)(sqlcipher3*,const char*,int,int,void*,
90821                             void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
90822                             void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
90823                             void (*xFinal)(sqlcipher3_context*),
90824                             void(*xDestroy)(void*));
90825   int (*db_config)(sqlcipher3*,int,...);
90826   sqlcipher3_mutex *(*db_mutex)(sqlcipher3*);
90827   int (*db_status)(sqlcipher3*,int,int*,int*,int);
90828   int (*extended_errcode)(sqlcipher3*);
90829   void (*log)(int,const char*,...);
90830   sqlcipher3_int64 (*soft_heap_limit64)(sqlcipher3_int64);
90831   const char *(*sourceid)(void);
90832   int (*stmt_status)(sqlcipher3_stmt*,int,int);
90833   int (*strnicmp)(const char*,const char*,int);
90834   int (*unlock_notify)(sqlcipher3*,void(*)(void**,int),void*);
90835   int (*wal_autocheckpoint)(sqlcipher3*,int);
90836   int (*wal_checkpoint)(sqlcipher3*,const char*);
90837   void *(*wal_hook)(sqlcipher3*,int(*)(void*,sqlcipher3*,const char*,int),void*);
90838   int (*blob_reopen)(sqlcipher3_blob*,sqlcipher3_int64);
90839   int (*vtab_config)(sqlcipher3*,int op,...);
90840   int (*vtab_on_conflict)(sqlcipher3*);
90841 };
90842
90843 /*
90844 ** The following macros redefine the API routines so that they are
90845 ** redirected throught the global sqlcipher3_api structure.
90846 **
90847 ** This header file is also used by the loadext.c source file
90848 ** (part of the main SQLite library - not an extension) so that
90849 ** it can get access to the sqlcipher3_api_routines structure
90850 ** definition.  But the main library does not want to redefine
90851 ** the API.  So the redefinition macros are only valid if the
90852 ** SQLCIPHER_CORE macros is undefined.
90853 */
90854 #ifndef SQLCIPHER_CORE
90855 #define sqlcipher3_aggregate_context      sqlcipher3_api->aggregate_context
90856 #ifndef SQLCIPHER_OMIT_DEPRECATED
90857 #define sqlcipher3_aggregate_count        sqlcipher3_api->aggregate_count
90858 #endif
90859 #define sqlcipher3_bind_blob              sqlcipher3_api->bind_blob
90860 #define sqlcipher3_bind_double            sqlcipher3_api->bind_double
90861 #define sqlcipher3_bind_int               sqlcipher3_api->bind_int
90862 #define sqlcipher3_bind_int64             sqlcipher3_api->bind_int64
90863 #define sqlcipher3_bind_null              sqlcipher3_api->bind_null
90864 #define sqlcipher3_bind_parameter_count   sqlcipher3_api->bind_parameter_count
90865 #define sqlcipher3_bind_parameter_index   sqlcipher3_api->bind_parameter_index
90866 #define sqlcipher3_bind_parameter_name    sqlcipher3_api->bind_parameter_name
90867 #define sqlcipher3_bind_text              sqlcipher3_api->bind_text
90868 #define sqlcipher3_bind_text16            sqlcipher3_api->bind_text16
90869 #define sqlcipher3_bind_value             sqlcipher3_api->bind_value
90870 #define sqlcipher3_busy_handler           sqlcipher3_api->busy_handler
90871 #define sqlcipher3_busy_timeout           sqlcipher3_api->busy_timeout
90872 #define sqlcipher3_changes                sqlcipher3_api->changes
90873 #define sqlcipher3_close                  sqlcipher3_api->close
90874 #define sqlcipher3_collation_needed       sqlcipher3_api->collation_needed
90875 #define sqlcipher3_collation_needed16     sqlcipher3_api->collation_needed16
90876 #define sqlcipher3_column_blob            sqlcipher3_api->column_blob
90877 #define sqlcipher3_column_bytes           sqlcipher3_api->column_bytes
90878 #define sqlcipher3_column_bytes16         sqlcipher3_api->column_bytes16
90879 #define sqlcipher3_column_count           sqlcipher3_api->column_count
90880 #define sqlcipher3_column_database_name   sqlcipher3_api->column_database_name
90881 #define sqlcipher3_column_database_name16 sqlcipher3_api->column_database_name16
90882 #define sqlcipher3_column_decltype        sqlcipher3_api->column_decltype
90883 #define sqlcipher3_column_decltype16      sqlcipher3_api->column_decltype16
90884 #define sqlcipher3_column_double          sqlcipher3_api->column_double
90885 #define sqlcipher3_column_int             sqlcipher3_api->column_int
90886 #define sqlcipher3_column_int64           sqlcipher3_api->column_int64
90887 #define sqlcipher3_column_name            sqlcipher3_api->column_name
90888 #define sqlcipher3_column_name16          sqlcipher3_api->column_name16
90889 #define sqlcipher3_column_origin_name     sqlcipher3_api->column_origin_name
90890 #define sqlcipher3_column_origin_name16   sqlcipher3_api->column_origin_name16
90891 #define sqlcipher3_column_table_name      sqlcipher3_api->column_table_name
90892 #define sqlcipher3_column_table_name16    sqlcipher3_api->column_table_name16
90893 #define sqlcipher3_column_text            sqlcipher3_api->column_text
90894 #define sqlcipher3_column_text16          sqlcipher3_api->column_text16
90895 #define sqlcipher3_column_type            sqlcipher3_api->column_type
90896 #define sqlcipher3_column_value           sqlcipher3_api->column_value
90897 #define sqlcipher3_commit_hook            sqlcipher3_api->commit_hook
90898 #define sqlcipher3_complete               sqlcipher3_api->complete
90899 #define sqlcipher3_complete16             sqlcipher3_api->complete16
90900 #define sqlcipher3_create_collation       sqlcipher3_api->create_collation
90901 #define sqlcipher3_create_collation16     sqlcipher3_api->create_collation16
90902 #define sqlcipher3_create_function        sqlcipher3_api->create_function
90903 #define sqlcipher3_create_function16      sqlcipher3_api->create_function16
90904 #define sqlcipher3_create_module          sqlcipher3_api->create_module
90905 #define sqlcipher3_create_module_v2       sqlcipher3_api->create_module_v2
90906 #define sqlcipher3_data_count             sqlcipher3_api->data_count
90907 #define sqlcipher3_db_handle              sqlcipher3_api->db_handle
90908 #define sqlcipher3_declare_vtab           sqlcipher3_api->declare_vtab
90909 #define sqlcipher3_enable_shared_cache    sqlcipher3_api->enable_shared_cache
90910 #define sqlcipher3_errcode                sqlcipher3_api->errcode
90911 #define sqlcipher3_errmsg                 sqlcipher3_api->errmsg
90912 #define sqlcipher3_errmsg16               sqlcipher3_api->errmsg16
90913 #define sqlcipher3_exec                   sqlcipher3_api->exec
90914 #ifndef SQLCIPHER_OMIT_DEPRECATED
90915 #define sqlcipher3_expired                sqlcipher3_api->expired
90916 #endif
90917 #define sqlcipher3_finalize               sqlcipher3_api->finalize
90918 #define sqlcipher3_free                   sqlcipher3_api->free
90919 #define sqlcipher3_free_table             sqlcipher3_api->free_table
90920 #define sqlcipher3_get_autocommit         sqlcipher3_api->get_autocommit
90921 #define sqlcipher3_get_auxdata            sqlcipher3_api->get_auxdata
90922 #define sqlcipher3_get_table              sqlcipher3_api->get_table
90923 #ifndef SQLCIPHER_OMIT_DEPRECATED
90924 #define sqlcipher3_global_recover         sqlcipher3_api->global_recover
90925 #endif
90926 #define sqlcipher3_interrupt              sqlcipher3_api->interruptx
90927 #define sqlcipher3_last_insert_rowid      sqlcipher3_api->last_insert_rowid
90928 #define sqlcipher3_libversion             sqlcipher3_api->libversion
90929 #define sqlcipher3_libversion_number      sqlcipher3_api->libversion_number
90930 #define sqlcipher3_malloc                 sqlcipher3_api->malloc
90931 #define sqlcipher3_mprintf                sqlcipher3_api->mprintf
90932 #define sqlcipher3_open                   sqlcipher3_api->open
90933 #define sqlcipher3_open16                 sqlcipher3_api->open16
90934 #define sqlcipher3_prepare                sqlcipher3_api->prepare
90935 #define sqlcipher3_prepare16              sqlcipher3_api->prepare16
90936 #define sqlcipher3_prepare_v2             sqlcipher3_api->prepare_v2
90937 #define sqlcipher3_prepare16_v2           sqlcipher3_api->prepare16_v2
90938 #define sqlcipher3_profile                sqlcipher3_api->profile
90939 #define sqlcipher3_progress_handler       sqlcipher3_api->progress_handler
90940 #define sqlcipher3_realloc                sqlcipher3_api->realloc
90941 #define sqlcipher3_reset                  sqlcipher3_api->reset
90942 #define sqlcipher3_result_blob            sqlcipher3_api->result_blob
90943 #define sqlcipher3_result_double          sqlcipher3_api->result_double
90944 #define sqlcipher3_result_error           sqlcipher3_api->result_error
90945 #define sqlcipher3_result_error16         sqlcipher3_api->result_error16
90946 #define sqlcipher3_result_int             sqlcipher3_api->result_int
90947 #define sqlcipher3_result_int64           sqlcipher3_api->result_int64
90948 #define sqlcipher3_result_null            sqlcipher3_api->result_null
90949 #define sqlcipher3_result_text            sqlcipher3_api->result_text
90950 #define sqlcipher3_result_text16          sqlcipher3_api->result_text16
90951 #define sqlcipher3_result_text16be        sqlcipher3_api->result_text16be
90952 #define sqlcipher3_result_text16le        sqlcipher3_api->result_text16le
90953 #define sqlcipher3_result_value           sqlcipher3_api->result_value
90954 #define sqlcipher3_rollback_hook          sqlcipher3_api->rollback_hook
90955 #define sqlcipher3_set_authorizer         sqlcipher3_api->set_authorizer
90956 #define sqlcipher3_set_auxdata            sqlcipher3_api->set_auxdata
90957 #define sqlcipher3_snprintf               sqlcipher3_api->snprintf
90958 #define sqlcipher3_step                   sqlcipher3_api->step
90959 #define sqlcipher3_table_column_metadata  sqlcipher3_api->table_column_metadata
90960 #define sqlcipher3_thread_cleanup         sqlcipher3_api->thread_cleanup
90961 #define sqlcipher3_total_changes          sqlcipher3_api->total_changes
90962 #define sqlcipher3_trace                  sqlcipher3_api->trace
90963 #ifndef SQLCIPHER_OMIT_DEPRECATED
90964 #define sqlcipher3_transfer_bindings      sqlcipher3_api->transfer_bindings
90965 #endif
90966 #define sqlcipher3_update_hook            sqlcipher3_api->update_hook
90967 #define sqlcipher3_user_data              sqlcipher3_api->user_data
90968 #define sqlcipher3_value_blob             sqlcipher3_api->value_blob
90969 #define sqlcipher3_value_bytes            sqlcipher3_api->value_bytes
90970 #define sqlcipher3_value_bytes16          sqlcipher3_api->value_bytes16
90971 #define sqlcipher3_value_double           sqlcipher3_api->value_double
90972 #define sqlcipher3_value_int              sqlcipher3_api->value_int
90973 #define sqlcipher3_value_int64            sqlcipher3_api->value_int64
90974 #define sqlcipher3_value_numeric_type     sqlcipher3_api->value_numeric_type
90975 #define sqlcipher3_value_text             sqlcipher3_api->value_text
90976 #define sqlcipher3_value_text16           sqlcipher3_api->value_text16
90977 #define sqlcipher3_value_text16be         sqlcipher3_api->value_text16be
90978 #define sqlcipher3_value_text16le         sqlcipher3_api->value_text16le
90979 #define sqlcipher3_value_type             sqlcipher3_api->value_type
90980 #define sqlcipher3_vmprintf               sqlcipher3_api->vmprintf
90981 #define sqlcipher3_overload_function      sqlcipher3_api->overload_function
90982 #define sqlcipher3_prepare_v2             sqlcipher3_api->prepare_v2
90983 #define sqlcipher3_prepare16_v2           sqlcipher3_api->prepare16_v2
90984 #define sqlcipher3_clear_bindings         sqlcipher3_api->clear_bindings
90985 #define sqlcipher3_bind_zeroblob          sqlcipher3_api->bind_zeroblob
90986 #define sqlcipher3_blob_bytes             sqlcipher3_api->blob_bytes
90987 #define sqlcipher3_blob_close             sqlcipher3_api->blob_close
90988 #define sqlcipher3_blob_open              sqlcipher3_api->blob_open
90989 #define sqlcipher3_blob_read              sqlcipher3_api->blob_read
90990 #define sqlcipher3_blob_write             sqlcipher3_api->blob_write
90991 #define sqlcipher3_create_collation_v2    sqlcipher3_api->create_collation_v2
90992 #define sqlcipher3_file_control           sqlcipher3_api->file_control
90993 #define sqlcipher3_memory_highwater       sqlcipher3_api->memory_highwater
90994 #define sqlcipher3_memory_used            sqlcipher3_api->memory_used
90995 #define sqlcipher3_mutex_alloc            sqlcipher3_api->mutex_alloc
90996 #define sqlcipher3_mutex_enter            sqlcipher3_api->mutex_enter
90997 #define sqlcipher3_mutex_free             sqlcipher3_api->mutex_free
90998 #define sqlcipher3_mutex_leave            sqlcipher3_api->mutex_leave
90999 #define sqlcipher3_mutex_try              sqlcipher3_api->mutex_try
91000 #define sqlcipher3_open_v2                sqlcipher3_api->open_v2
91001 #define sqlcipher3_release_memory         sqlcipher3_api->release_memory
91002 #define sqlcipher3_result_error_nomem     sqlcipher3_api->result_error_nomem
91003 #define sqlcipher3_result_error_toobig    sqlcipher3_api->result_error_toobig
91004 #define sqlcipher3_sleep                  sqlcipher3_api->sleep
91005 #define sqlcipher3_soft_heap_limit        sqlcipher3_api->soft_heap_limit
91006 #define sqlcipher3_vfs_find               sqlcipher3_api->vfs_find
91007 #define sqlcipher3_vfs_register           sqlcipher3_api->vfs_register
91008 #define sqlcipher3_vfs_unregister         sqlcipher3_api->vfs_unregister
91009 #define sqlcipher3_threadsafe             sqlcipher3_api->xthreadsafe
91010 #define sqlcipher3_result_zeroblob        sqlcipher3_api->result_zeroblob
91011 #define sqlcipher3_result_error_code      sqlcipher3_api->result_error_code
91012 #define sqlcipher3_test_control           sqlcipher3_api->test_control
91013 #define sqlcipher3_randomness             sqlcipher3_api->randomness
91014 #define sqlcipher3_context_db_handle      sqlcipher3_api->context_db_handle
91015 #define sqlcipher3_extended_result_codes  sqlcipher3_api->extended_result_codes
91016 #define sqlcipher3_limit                  sqlcipher3_api->limit
91017 #define sqlcipher3_next_stmt              sqlcipher3_api->next_stmt
91018 #define sqlcipher3_sql                    sqlcipher3_api->sql
91019 #define sqlcipher3_status                 sqlcipher3_api->status
91020 #define sqlcipher3_backup_finish          sqlcipher3_api->backup_finish
91021 #define sqlcipher3_backup_init            sqlcipher3_api->backup_init
91022 #define sqlcipher3_backup_pagecount       sqlcipher3_api->backup_pagecount
91023 #define sqlcipher3_backup_remaining       sqlcipher3_api->backup_remaining
91024 #define sqlcipher3_backup_step            sqlcipher3_api->backup_step
91025 #define sqlcipher3_compileoption_get      sqlcipher3_api->compileoption_get
91026 #define sqlcipher3_compileoption_used     sqlcipher3_api->compileoption_used
91027 #define sqlcipher3_create_function_v2     sqlcipher3_api->create_function_v2
91028 #define sqlcipher3_db_config              sqlcipher3_api->db_config
91029 #define sqlcipher3_db_mutex               sqlcipher3_api->db_mutex
91030 #define sqlcipher3_db_status              sqlcipher3_api->db_status
91031 #define sqlcipher3_extended_errcode       sqlcipher3_api->extended_errcode
91032 #define sqlcipher3_log                    sqlcipher3_api->log
91033 #define sqlcipher3_soft_heap_limit64      sqlcipher3_api->soft_heap_limit64
91034 #define sqlcipher3_sourceid               sqlcipher3_api->sourceid
91035 #define sqlcipher3_stmt_status            sqlcipher3_api->stmt_status
91036 #define sqlcipher3_strnicmp               sqlcipher3_api->strnicmp
91037 #define sqlcipher3_unlock_notify          sqlcipher3_api->unlock_notify
91038 #define sqlcipher3_wal_autocheckpoint     sqlcipher3_api->wal_autocheckpoint
91039 #define sqlcipher3_wal_checkpoint         sqlcipher3_api->wal_checkpoint
91040 #define sqlcipher3_wal_hook               sqlcipher3_api->wal_hook
91041 #define sqlcipher3_blob_reopen            sqlcipher3_api->blob_reopen
91042 #define sqlcipher3_vtab_config            sqlcipher3_api->vtab_config
91043 #define sqlcipher3_vtab_on_conflict       sqlcipher3_api->vtab_on_conflict
91044 #endif /* SQLCIPHER_CORE */
91045
91046 #define SQLCIPHER_EXTENSION_INIT1     const sqlcipher3_api_routines *sqlcipher3_api = 0;
91047 #define SQLCIPHER_EXTENSION_INIT2(v)  sqlcipher3_api = v;
91048
91049 #endif /* _SQLCIPHER3EXT_H_ */
91050
91051 /************** End of sqlcipher3ext.h ******************************************/
91052 /************** Continuing where we left off in loadext.c ********************/
91053 /* #include <string.h> */
91054
91055 #ifndef SQLCIPHER_OMIT_LOAD_EXTENSION
91056
91057 /*
91058 ** Some API routines are omitted when various features are
91059 ** excluded from a build of SQLite.  Substitute a NULL pointer
91060 ** for any missing APIs.
91061 */
91062 #ifndef SQLCIPHER_ENABLE_COLUMN_METADATA
91063 # define sqlcipher3_column_database_name   0
91064 # define sqlcipher3_column_database_name16 0
91065 # define sqlcipher3_column_table_name      0
91066 # define sqlcipher3_column_table_name16    0
91067 # define sqlcipher3_column_origin_name     0
91068 # define sqlcipher3_column_origin_name16   0
91069 # define sqlcipher3_table_column_metadata  0
91070 #endif
91071
91072 #ifdef SQLCIPHER_OMIT_AUTHORIZATION
91073 # define sqlcipher3_set_authorizer         0
91074 #endif
91075
91076 #ifdef SQLCIPHER_OMIT_UTF16
91077 # define sqlcipher3_bind_text16            0
91078 # define sqlcipher3_collation_needed16     0
91079 # define sqlcipher3_column_decltype16      0
91080 # define sqlcipher3_column_name16          0
91081 # define sqlcipher3_column_text16          0
91082 # define sqlcipher3_complete16             0
91083 # define sqlcipher3_create_collation16     0
91084 # define sqlcipher3_create_function16      0
91085 # define sqlcipher3_errmsg16               0
91086 # define sqlcipher3_open16                 0
91087 # define sqlcipher3_prepare16              0
91088 # define sqlcipher3_prepare16_v2           0
91089 # define sqlcipher3_result_error16         0
91090 # define sqlcipher3_result_text16          0
91091 # define sqlcipher3_result_text16be        0
91092 # define sqlcipher3_result_text16le        0
91093 # define sqlcipher3_value_text16           0
91094 # define sqlcipher3_value_text16be         0
91095 # define sqlcipher3_value_text16le         0
91096 # define sqlcipher3_column_database_name16 0
91097 # define sqlcipher3_column_table_name16    0
91098 # define sqlcipher3_column_origin_name16   0
91099 #endif
91100
91101 #ifdef SQLCIPHER_OMIT_COMPLETE
91102 # define sqlcipher3_complete 0
91103 # define sqlcipher3_complete16 0
91104 #endif
91105
91106 #ifdef SQLCIPHER_OMIT_DECLTYPE
91107 # define sqlcipher3_column_decltype16      0
91108 # define sqlcipher3_column_decltype        0
91109 #endif
91110
91111 #ifdef SQLCIPHER_OMIT_PROGRESS_CALLBACK
91112 # define sqlcipher3_progress_handler 0
91113 #endif
91114
91115 #ifdef SQLCIPHER_OMIT_VIRTUALTABLE
91116 # define sqlcipher3_create_module 0
91117 # define sqlcipher3_create_module_v2 0
91118 # define sqlcipher3_declare_vtab 0
91119 # define sqlcipher3_vtab_config 0
91120 # define sqlcipher3_vtab_on_conflict 0
91121 #endif
91122
91123 #ifdef SQLCIPHER_OMIT_SHARED_CACHE
91124 # define sqlcipher3_enable_shared_cache 0
91125 #endif
91126
91127 #ifdef SQLCIPHER_OMIT_TRACE
91128 # define sqlcipher3_profile       0
91129 # define sqlcipher3_trace         0
91130 #endif
91131
91132 #ifdef SQLCIPHER_OMIT_GET_TABLE
91133 # define sqlcipher3_free_table    0
91134 # define sqlcipher3_get_table     0
91135 #endif
91136
91137 #ifdef SQLCIPHER_OMIT_INCRBLOB
91138 #define sqlcipher3_bind_zeroblob  0
91139 #define sqlcipher3_blob_bytes     0
91140 #define sqlcipher3_blob_close     0
91141 #define sqlcipher3_blob_open      0
91142 #define sqlcipher3_blob_read      0
91143 #define sqlcipher3_blob_write     0
91144 #define sqlcipher3_blob_reopen    0
91145 #endif
91146
91147 /*
91148 ** The following structure contains pointers to all SQLite API routines.
91149 ** A pointer to this structure is passed into extensions when they are
91150 ** loaded so that the extension can make calls back into the SQLite
91151 ** library.
91152 **
91153 ** When adding new APIs, add them to the bottom of this structure
91154 ** in order to preserve backwards compatibility.
91155 **
91156 ** Extensions that use newer APIs should first call the
91157 ** sqlcipher3_libversion_number() to make sure that the API they
91158 ** intend to use is supported by the library.  Extensions should
91159 ** also check to make sure that the pointer to the function is
91160 ** not NULL before calling it.
91161 */
91162 static const sqlcipher3_api_routines sqlcipher3Apis = {
91163   sqlcipher3_aggregate_context,
91164 #ifndef SQLCIPHER_OMIT_DEPRECATED
91165   sqlcipher3_aggregate_count,
91166 #else
91167   0,
91168 #endif
91169   sqlcipher3_bind_blob,
91170   sqlcipher3_bind_double,
91171   sqlcipher3_bind_int,
91172   sqlcipher3_bind_int64,
91173   sqlcipher3_bind_null,
91174   sqlcipher3_bind_parameter_count,
91175   sqlcipher3_bind_parameter_index,
91176   sqlcipher3_bind_parameter_name,
91177   sqlcipher3_bind_text,
91178   sqlcipher3_bind_text16,
91179   sqlcipher3_bind_value,
91180   sqlcipher3_busy_handler,
91181   sqlcipher3_busy_timeout,
91182   sqlcipher3_changes,
91183   sqlcipher3_close,
91184   sqlcipher3_collation_needed,
91185   sqlcipher3_collation_needed16,
91186   sqlcipher3_column_blob,
91187   sqlcipher3_column_bytes,
91188   sqlcipher3_column_bytes16,
91189   sqlcipher3_column_count,
91190   sqlcipher3_column_database_name,
91191   sqlcipher3_column_database_name16,
91192   sqlcipher3_column_decltype,
91193   sqlcipher3_column_decltype16,
91194   sqlcipher3_column_double,
91195   sqlcipher3_column_int,
91196   sqlcipher3_column_int64,
91197   sqlcipher3_column_name,
91198   sqlcipher3_column_name16,
91199   sqlcipher3_column_origin_name,
91200   sqlcipher3_column_origin_name16,
91201   sqlcipher3_column_table_name,
91202   sqlcipher3_column_table_name16,
91203   sqlcipher3_column_text,
91204   sqlcipher3_column_text16,
91205   sqlcipher3_column_type,
91206   sqlcipher3_column_value,
91207   sqlcipher3_commit_hook,
91208   sqlcipher3_complete,
91209   sqlcipher3_complete16,
91210   sqlcipher3_create_collation,
91211   sqlcipher3_create_collation16,
91212   sqlcipher3_create_function,
91213   sqlcipher3_create_function16,
91214   sqlcipher3_create_module,
91215   sqlcipher3_data_count,
91216   sqlcipher3_db_handle,
91217   sqlcipher3_declare_vtab,
91218   sqlcipher3_enable_shared_cache,
91219   sqlcipher3_errcode,
91220   sqlcipher3_errmsg,
91221   sqlcipher3_errmsg16,
91222   sqlcipher3_exec,
91223 #ifndef SQLCIPHER_OMIT_DEPRECATED
91224   sqlcipher3_expired,
91225 #else
91226   0,
91227 #endif
91228   sqlcipher3_finalize,
91229   sqlcipher3_free,
91230   sqlcipher3_free_table,
91231   sqlcipher3_get_autocommit,
91232   sqlcipher3_get_auxdata,
91233   sqlcipher3_get_table,
91234   0,     /* Was sqlcipher3_global_recover(), but that function is deprecated */
91235   sqlcipher3_interrupt,
91236   sqlcipher3_last_insert_rowid,
91237   sqlcipher3_libversion,
91238   sqlcipher3_libversion_number,
91239   sqlcipher3_malloc,
91240   sqlcipher3_mprintf,
91241   sqlcipher3_open,
91242   sqlcipher3_open16,
91243   sqlcipher3_prepare,
91244   sqlcipher3_prepare16,
91245   sqlcipher3_profile,
91246   sqlcipher3_progress_handler,
91247   sqlcipher3_realloc,
91248   sqlcipher3_reset,
91249   sqlcipher3_result_blob,
91250   sqlcipher3_result_double,
91251   sqlcipher3_result_error,
91252   sqlcipher3_result_error16,
91253   sqlcipher3_result_int,
91254   sqlcipher3_result_int64,
91255   sqlcipher3_result_null,
91256   sqlcipher3_result_text,
91257   sqlcipher3_result_text16,
91258   sqlcipher3_result_text16be,
91259   sqlcipher3_result_text16le,
91260   sqlcipher3_result_value,
91261   sqlcipher3_rollback_hook,
91262   sqlcipher3_set_authorizer,
91263   sqlcipher3_set_auxdata,
91264   sqlcipher3_snprintf,
91265   sqlcipher3_step,
91266   sqlcipher3_table_column_metadata,
91267 #ifndef SQLCIPHER_OMIT_DEPRECATED
91268   sqlcipher3_thread_cleanup,
91269 #else
91270   0,
91271 #endif
91272   sqlcipher3_total_changes,
91273   sqlcipher3_trace,
91274 #ifndef SQLCIPHER_OMIT_DEPRECATED
91275   sqlcipher3_transfer_bindings,
91276 #else
91277   0,
91278 #endif
91279   sqlcipher3_update_hook,
91280   sqlcipher3_user_data,
91281   sqlcipher3_value_blob,
91282   sqlcipher3_value_bytes,
91283   sqlcipher3_value_bytes16,
91284   sqlcipher3_value_double,
91285   sqlcipher3_value_int,
91286   sqlcipher3_value_int64,
91287   sqlcipher3_value_numeric_type,
91288   sqlcipher3_value_text,
91289   sqlcipher3_value_text16,
91290   sqlcipher3_value_text16be,
91291   sqlcipher3_value_text16le,
91292   sqlcipher3_value_type,
91293   sqlcipher3_vmprintf,
91294   /*
91295   ** The original API set ends here.  All extensions can call any
91296   ** of the APIs above provided that the pointer is not NULL.  But
91297   ** before calling APIs that follow, extension should check the
91298   ** sqlcipher3_libversion_number() to make sure they are dealing with
91299   ** a library that is new enough to support that API.
91300   *************************************************************************
91301   */
91302   sqlcipher3_overload_function,
91303
91304   /*
91305   ** Added after 3.3.13
91306   */
91307   sqlcipher3_prepare_v2,
91308   sqlcipher3_prepare16_v2,
91309   sqlcipher3_clear_bindings,
91310
91311   /*
91312   ** Added for 3.4.1
91313   */
91314   sqlcipher3_create_module_v2,
91315
91316   /*
91317   ** Added for 3.5.0
91318   */
91319   sqlcipher3_bind_zeroblob,
91320   sqlcipher3_blob_bytes,
91321   sqlcipher3_blob_close,
91322   sqlcipher3_blob_open,
91323   sqlcipher3_blob_read,
91324   sqlcipher3_blob_write,
91325   sqlcipher3_create_collation_v2,
91326   sqlcipher3_file_control,
91327   sqlcipher3_memory_highwater,
91328   sqlcipher3_memory_used,
91329 #ifdef SQLCIPHER_MUTEX_OMIT
91330   0, 
91331   0, 
91332   0,
91333   0,
91334   0,
91335 #else
91336   sqlcipher3_mutex_alloc,
91337   sqlcipher3_mutex_enter,
91338   sqlcipher3_mutex_free,
91339   sqlcipher3_mutex_leave,
91340   sqlcipher3_mutex_try,
91341 #endif
91342   sqlcipher3_open_v2,
91343   sqlcipher3_release_memory,
91344   sqlcipher3_result_error_nomem,
91345   sqlcipher3_result_error_toobig,
91346   sqlcipher3_sleep,
91347   sqlcipher3_soft_heap_limit,
91348   sqlcipher3_vfs_find,
91349   sqlcipher3_vfs_register,
91350   sqlcipher3_vfs_unregister,
91351
91352   /*
91353   ** Added for 3.5.8
91354   */
91355   sqlcipher3_threadsafe,
91356   sqlcipher3_result_zeroblob,
91357   sqlcipher3_result_error_code,
91358   sqlcipher3_test_control,
91359   sqlcipher3_randomness,
91360   sqlcipher3_context_db_handle,
91361
91362   /*
91363   ** Added for 3.6.0
91364   */
91365   sqlcipher3_extended_result_codes,
91366   sqlcipher3_limit,
91367   sqlcipher3_next_stmt,
91368   sqlcipher3_sql,
91369   sqlcipher3_status,
91370
91371   /*
91372   ** Added for 3.7.4
91373   */
91374   sqlcipher3_backup_finish,
91375   sqlcipher3_backup_init,
91376   sqlcipher3_backup_pagecount,
91377   sqlcipher3_backup_remaining,
91378   sqlcipher3_backup_step,
91379 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
91380   sqlcipher3_compileoption_get,
91381   sqlcipher3_compileoption_used,
91382 #else
91383   0,
91384   0,
91385 #endif
91386   sqlcipher3_create_function_v2,
91387   sqlcipher3_db_config,
91388   sqlcipher3_db_mutex,
91389   sqlcipher3_db_status,
91390   sqlcipher3_extended_errcode,
91391   sqlcipher3_log,
91392   sqlcipher3_soft_heap_limit64,
91393   sqlcipher3_sourceid,
91394   sqlcipher3_stmt_status,
91395   sqlcipher3_strnicmp,
91396 #ifdef SQLCIPHER_ENABLE_UNLOCK_NOTIFY
91397   sqlcipher3_unlock_notify,
91398 #else
91399   0,
91400 #endif
91401 #ifndef SQLCIPHER_OMIT_WAL
91402   sqlcipher3_wal_autocheckpoint,
91403   sqlcipher3_wal_checkpoint,
91404   sqlcipher3_wal_hook,
91405 #else
91406   0,
91407   0,
91408   0,
91409 #endif
91410   sqlcipher3_blob_reopen,
91411   sqlcipher3_vtab_config,
91412   sqlcipher3_vtab_on_conflict,
91413 };
91414
91415 /*
91416 ** Attempt to load an SQLite extension library contained in the file
91417 ** zFile.  The entry point is zProc.  zProc may be 0 in which case a
91418 ** default entry point name (sqlcipher3_extension_init) is used.  Use
91419 ** of the default name is recommended.
91420 **
91421 ** Return SQLCIPHER_OK on success and SQLCIPHER_ERROR if something goes wrong.
91422 **
91423 ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with 
91424 ** error message text.  The calling function should free this memory
91425 ** by calling sqlcipher3DbFree(db, ).
91426 */
91427 static int sqlcipher3LoadExtension(
91428   sqlcipher3 *db,          /* Load the extension into this database connection */
91429   const char *zFile,    /* Name of the shared library containing extension */
91430   const char *zProc,    /* Entry point.  Use "sqlcipher3_extension_init" if 0 */
91431   char **pzErrMsg       /* Put error message here if not 0 */
91432 ){
91433   sqlcipher3_vfs *pVfs = db->pVfs;
91434   void *handle;
91435   int (*xInit)(sqlcipher3*,char**,const sqlcipher3_api_routines*);
91436   char *zErrmsg = 0;
91437   void **aHandle;
91438   int nMsg = 300 + sqlcipher3Strlen30(zFile);
91439
91440   if( pzErrMsg ) *pzErrMsg = 0;
91441
91442   /* Ticket #1863.  To avoid a creating security problems for older
91443   ** applications that relink against newer versions of SQLite, the
91444   ** ability to run load_extension is turned off by default.  One
91445   ** must call sqlcipher3_enable_load_extension() to turn on extension
91446   ** loading.  Otherwise you get the following error.
91447   */
91448   if( (db->flags & SQLCIPHER_LoadExtension)==0 ){
91449     if( pzErrMsg ){
91450       *pzErrMsg = sqlcipher3_mprintf("not authorized");
91451     }
91452     return SQLCIPHER_ERROR;
91453   }
91454
91455   if( zProc==0 ){
91456     zProc = "sqlcipher3_extension_init";
91457   }
91458
91459   handle = sqlcipher3OsDlOpen(pVfs, zFile);
91460   if( handle==0 ){
91461     if( pzErrMsg ){
91462       *pzErrMsg = zErrmsg = sqlcipher3_malloc(nMsg);
91463       if( zErrmsg ){
91464         sqlcipher3_snprintf(nMsg, zErrmsg, 
91465             "unable to open shared library [%s]", zFile);
91466         sqlcipher3OsDlError(pVfs, nMsg-1, zErrmsg);
91467       }
91468     }
91469     return SQLCIPHER_ERROR;
91470   }
91471   xInit = (int(*)(sqlcipher3*,char**,const sqlcipher3_api_routines*))
91472                    sqlcipher3OsDlSym(pVfs, handle, zProc);
91473   if( xInit==0 ){
91474     if( pzErrMsg ){
91475       nMsg += sqlcipher3Strlen30(zProc);
91476       *pzErrMsg = zErrmsg = sqlcipher3_malloc(nMsg);
91477       if( zErrmsg ){
91478         sqlcipher3_snprintf(nMsg, zErrmsg,
91479             "no entry point [%s] in shared library [%s]", zProc,zFile);
91480         sqlcipher3OsDlError(pVfs, nMsg-1, zErrmsg);
91481       }
91482       sqlcipher3OsDlClose(pVfs, handle);
91483     }
91484     return SQLCIPHER_ERROR;
91485   }else if( xInit(db, &zErrmsg, &sqlcipher3Apis) ){
91486     if( pzErrMsg ){
91487       *pzErrMsg = sqlcipher3_mprintf("error during initialization: %s", zErrmsg);
91488     }
91489     sqlcipher3_free(zErrmsg);
91490     sqlcipher3OsDlClose(pVfs, handle);
91491     return SQLCIPHER_ERROR;
91492   }
91493
91494   /* Append the new shared library handle to the db->aExtension array. */
91495   aHandle = sqlcipher3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
91496   if( aHandle==0 ){
91497     return SQLCIPHER_NOMEM;
91498   }
91499   if( db->nExtension>0 ){
91500     memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
91501   }
91502   sqlcipher3DbFree(db, db->aExtension);
91503   db->aExtension = aHandle;
91504
91505   db->aExtension[db->nExtension++] = handle;
91506   return SQLCIPHER_OK;
91507 }
91508 SQLCIPHER_API int sqlcipher3_load_extension(
91509   sqlcipher3 *db,          /* Load the extension into this database connection */
91510   const char *zFile,    /* Name of the shared library containing extension */
91511   const char *zProc,    /* Entry point.  Use "sqlcipher3_extension_init" if 0 */
91512   char **pzErrMsg       /* Put error message here if not 0 */
91513 ){
91514   int rc;
91515   sqlcipher3_mutex_enter(db->mutex);
91516   rc = sqlcipher3LoadExtension(db, zFile, zProc, pzErrMsg);
91517   rc = sqlcipher3ApiExit(db, rc);
91518   sqlcipher3_mutex_leave(db->mutex);
91519   return rc;
91520 }
91521
91522 /*
91523 ** Call this routine when the database connection is closing in order
91524 ** to clean up loaded extensions
91525 */
91526 SQLCIPHER_PRIVATE void sqlcipher3CloseExtensions(sqlcipher3 *db){
91527   int i;
91528   assert( sqlcipher3_mutex_held(db->mutex) );
91529   for(i=0; i<db->nExtension; i++){
91530     sqlcipher3OsDlClose(db->pVfs, db->aExtension[i]);
91531   }
91532   sqlcipher3DbFree(db, db->aExtension);
91533 }
91534
91535 /*
91536 ** Enable or disable extension loading.  Extension loading is disabled by
91537 ** default so as not to open security holes in older applications.
91538 */
91539 SQLCIPHER_API int sqlcipher3_enable_load_extension(sqlcipher3 *db, int onoff){
91540   sqlcipher3_mutex_enter(db->mutex);
91541   if( onoff ){
91542     db->flags |= SQLCIPHER_LoadExtension;
91543   }else{
91544     db->flags &= ~SQLCIPHER_LoadExtension;
91545   }
91546   sqlcipher3_mutex_leave(db->mutex);
91547   return SQLCIPHER_OK;
91548 }
91549
91550 #endif /* SQLCIPHER_OMIT_LOAD_EXTENSION */
91551
91552 /*
91553 ** The auto-extension code added regardless of whether or not extension
91554 ** loading is supported.  We need a dummy sqlcipher3Apis pointer for that
91555 ** code if regular extension loading is not available.  This is that
91556 ** dummy pointer.
91557 */
91558 #ifdef SQLCIPHER_OMIT_LOAD_EXTENSION
91559 static const sqlcipher3_api_routines sqlcipher3Apis = { 0 };
91560 #endif
91561
91562
91563 /*
91564 ** The following object holds the list of automatically loaded
91565 ** extensions.
91566 **
91567 ** This list is shared across threads.  The SQLCIPHER_MUTEX_STATIC_MASTER
91568 ** mutex must be held while accessing this list.
91569 */
91570 typedef struct sqlcipher3AutoExtList sqlcipher3AutoExtList;
91571 static SQLCIPHER_WSD struct sqlcipher3AutoExtList {
91572   int nExt;              /* Number of entries in aExt[] */          
91573   void (**aExt)(void);   /* Pointers to the extension init functions */
91574 } sqlcipher3Autoext = { 0, 0 };
91575
91576 /* The "wsdAutoext" macro will resolve to the autoextension
91577 ** state vector.  If writable static data is unsupported on the target,
91578 ** we have to locate the state vector at run-time.  In the more common
91579 ** case where writable static data is supported, wsdStat can refer directly
91580 ** to the "sqlcipher3Autoext" state vector declared above.
91581 */
91582 #ifdef SQLCIPHER_OMIT_WSD
91583 # define wsdAutoextInit \
91584   sqlcipher3AutoExtList *x = &GLOBAL(sqlcipher3AutoExtList,sqlcipher3Autoext)
91585 # define wsdAutoext x[0]
91586 #else
91587 # define wsdAutoextInit
91588 # define wsdAutoext sqlcipher3Autoext
91589 #endif
91590
91591
91592 /*
91593 ** Register a statically linked extension that is automatically
91594 ** loaded by every new database connection.
91595 */
91596 SQLCIPHER_API int sqlcipher3_auto_extension(void (*xInit)(void)){
91597   int rc = SQLCIPHER_OK;
91598 #ifndef SQLCIPHER_OMIT_AUTOINIT
91599   rc = sqlcipher3_initialize();
91600   if( rc ){
91601     return rc;
91602   }else
91603 #endif
91604   {
91605     int i;
91606 #if SQLCIPHER_THREADSAFE
91607     sqlcipher3_mutex *mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
91608 #endif
91609     wsdAutoextInit;
91610     sqlcipher3_mutex_enter(mutex);
91611     for(i=0; i<wsdAutoext.nExt; i++){
91612       if( wsdAutoext.aExt[i]==xInit ) break;
91613     }
91614     if( i==wsdAutoext.nExt ){
91615       int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
91616       void (**aNew)(void);
91617       aNew = sqlcipher3_realloc(wsdAutoext.aExt, nByte);
91618       if( aNew==0 ){
91619         rc = SQLCIPHER_NOMEM;
91620       }else{
91621         wsdAutoext.aExt = aNew;
91622         wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
91623         wsdAutoext.nExt++;
91624       }
91625     }
91626     sqlcipher3_mutex_leave(mutex);
91627     assert( (rc&0xff)==rc );
91628     return rc;
91629   }
91630 }
91631
91632 /*
91633 ** Reset the automatic extension loading mechanism.
91634 */
91635 SQLCIPHER_API void sqlcipher3_reset_auto_extension(void){
91636 #ifndef SQLCIPHER_OMIT_AUTOINIT
91637   if( sqlcipher3_initialize()==SQLCIPHER_OK )
91638 #endif
91639   {
91640 #if SQLCIPHER_THREADSAFE
91641     sqlcipher3_mutex *mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
91642 #endif
91643     wsdAutoextInit;
91644     sqlcipher3_mutex_enter(mutex);
91645     sqlcipher3_free(wsdAutoext.aExt);
91646     wsdAutoext.aExt = 0;
91647     wsdAutoext.nExt = 0;
91648     sqlcipher3_mutex_leave(mutex);
91649   }
91650 }
91651
91652 /*
91653 ** Load all automatic extensions.
91654 **
91655 ** If anything goes wrong, set an error in the database connection.
91656 */
91657 SQLCIPHER_PRIVATE void sqlcipher3AutoLoadExtensions(sqlcipher3 *db){
91658   int i;
91659   int go = 1;
91660   int (*xInit)(sqlcipher3*,char**,const sqlcipher3_api_routines*);
91661
91662   wsdAutoextInit;
91663   if( wsdAutoext.nExt==0 ){
91664     /* Common case: early out without every having to acquire a mutex */
91665     return;
91666   }
91667   for(i=0; go; i++){
91668     char *zErrmsg;
91669 #if SQLCIPHER_THREADSAFE
91670     sqlcipher3_mutex *mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER);
91671 #endif
91672     sqlcipher3_mutex_enter(mutex);
91673     if( i>=wsdAutoext.nExt ){
91674       xInit = 0;
91675       go = 0;
91676     }else{
91677       xInit = (int(*)(sqlcipher3*,char**,const sqlcipher3_api_routines*))
91678               wsdAutoext.aExt[i];
91679     }
91680     sqlcipher3_mutex_leave(mutex);
91681     zErrmsg = 0;
91682     if( xInit && xInit(db, &zErrmsg, &sqlcipher3Apis) ){
91683       sqlcipher3Error(db, SQLCIPHER_ERROR,
91684             "automatic extension loading failed: %s", zErrmsg);
91685       go = 0;
91686     }
91687     sqlcipher3_free(zErrmsg);
91688   }
91689 }
91690
91691 /************** End of loadext.c *********************************************/
91692 /************** Begin file pragma.c ******************************************/
91693 /*
91694 ** 2003 April 6
91695 **
91696 ** The author disclaims copyright to this source code.  In place of
91697 ** a legal notice, here is a blessing:
91698 **
91699 **    May you do good and not evil.
91700 **    May you find forgiveness for yourself and forgive others.
91701 **    May you share freely, never taking more than you give.
91702 **
91703 *************************************************************************
91704 ** This file contains code used to implement the PRAGMA command.
91705 */
91706
91707 /*
91708 ** Interpret the given string as a safety level.  Return 0 for OFF,
91709 ** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or 
91710 ** unrecognized string argument.
91711 **
91712 ** Note that the values returned are one less that the values that
91713 ** should be passed into sqlcipher3BtreeSetSafetyLevel().  The is done
91714 ** to support legacy SQL code.  The safety level used to be boolean
91715 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
91716 */
91717 static u8 getSafetyLevel(const char *z){
91718                              /* 123456789 123456789 */
91719   static const char zText[] = "onoffalseyestruefull";
91720   static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
91721   static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
91722   static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};
91723   int i, n;
91724   if( sqlcipher3Isdigit(*z) ){
91725     return (u8)sqlcipher3Atoi(z);
91726   }
91727   n = sqlcipher3Strlen30(z);
91728   for(i=0; i<ArraySize(iLength); i++){
91729     if( iLength[i]==n && sqlcipher3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
91730       return iValue[i];
91731     }
91732   }
91733   return 1;
91734 }
91735
91736 /*
91737 ** Interpret the given string as a boolean value.
91738 */
91739 SQLCIPHER_PRIVATE u8 sqlcipher3GetBoolean(const char *z){
91740   return getSafetyLevel(z)&1;
91741 }
91742
91743 /* The sqlcipher3GetBoolean() function is used by other modules but the
91744 ** remainder of this file is specific to PRAGMA processing.  So omit
91745 ** the rest of the file if PRAGMAs are omitted from the build.
91746 */
91747 #if !defined(SQLCIPHER_OMIT_PRAGMA)
91748
91749 /*
91750 ** Interpret the given string as a locking mode value.
91751 */
91752 static int getLockingMode(const char *z){
91753   if( z ){
91754     if( 0==sqlcipher3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
91755     if( 0==sqlcipher3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
91756   }
91757   return PAGER_LOCKINGMODE_QUERY;
91758 }
91759
91760 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
91761 /*
91762 ** Interpret the given string as an auto-vacuum mode value.
91763 **
91764 ** The following strings, "none", "full" and "incremental" are 
91765 ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
91766 */
91767 static int getAutoVacuum(const char *z){
91768   int i;
91769   if( 0==sqlcipher3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
91770   if( 0==sqlcipher3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
91771   if( 0==sqlcipher3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
91772   i = sqlcipher3Atoi(z);
91773   return (u8)((i>=0&&i<=2)?i:0);
91774 }
91775 #endif /* ifndef SQLCIPHER_OMIT_AUTOVACUUM */
91776
91777 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
91778 /*
91779 ** Interpret the given string as a temp db location. Return 1 for file
91780 ** backed temporary databases, 2 for the Red-Black tree in memory database
91781 ** and 0 to use the compile-time default.
91782 */
91783 static int getTempStore(const char *z){
91784   if( z[0]>='0' && z[0]<='2' ){
91785     return z[0] - '0';
91786   }else if( sqlcipher3StrICmp(z, "file")==0 ){
91787     return 1;
91788   }else if( sqlcipher3StrICmp(z, "memory")==0 ){
91789     return 2;
91790   }else{
91791     return 0;
91792   }
91793 }
91794 #endif /* SQLCIPHER_PAGER_PRAGMAS */
91795
91796 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
91797 /*
91798 ** Invalidate temp storage, either when the temp storage is changed
91799 ** from default, or when 'file' and the temp_store_directory has changed
91800 */
91801 static int invalidateTempStorage(Parse *pParse){
91802   sqlcipher3 *db = pParse->db;
91803   if( db->aDb[1].pBt!=0 ){
91804     if( !db->autoCommit || sqlcipher3BtreeIsInReadTrans(db->aDb[1].pBt) ){
91805       sqlcipher3ErrorMsg(pParse, "temporary storage cannot be changed "
91806         "from within a transaction");
91807       return SQLCIPHER_ERROR;
91808     }
91809     sqlcipher3BtreeClose(db->aDb[1].pBt);
91810     db->aDb[1].pBt = 0;
91811     sqlcipher3ResetInternalSchema(db, -1);
91812   }
91813   return SQLCIPHER_OK;
91814 }
91815 #endif /* SQLCIPHER_PAGER_PRAGMAS */
91816
91817 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
91818 /*
91819 ** If the TEMP database is open, close it and mark the database schema
91820 ** as needing reloading.  This must be done when using the SQLCIPHER_TEMP_STORE
91821 ** or DEFAULT_TEMP_STORE pragmas.
91822 */
91823 static int changeTempStorage(Parse *pParse, const char *zStorageType){
91824   int ts = getTempStore(zStorageType);
91825   sqlcipher3 *db = pParse->db;
91826   if( db->temp_store==ts ) return SQLCIPHER_OK;
91827   if( invalidateTempStorage( pParse ) != SQLCIPHER_OK ){
91828     return SQLCIPHER_ERROR;
91829   }
91830   db->temp_store = (u8)ts;
91831   return SQLCIPHER_OK;
91832 }
91833 #endif /* SQLCIPHER_PAGER_PRAGMAS */
91834
91835 /*
91836 ** Generate code to return a single integer value.
91837 */
91838 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
91839   Vdbe *v = sqlcipher3GetVdbe(pParse);
91840   int mem = ++pParse->nMem;
91841   i64 *pI64 = sqlcipher3DbMallocRaw(pParse->db, sizeof(value));
91842   if( pI64 ){
91843     memcpy(pI64, &value, sizeof(value));
91844   }
91845   sqlcipher3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
91846   sqlcipher3VdbeSetNumCols(v, 1);
91847   sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLCIPHER_STATIC);
91848   sqlcipher3VdbeAddOp2(v, OP_ResultRow, mem, 1);
91849 }
91850
91851 #ifndef SQLCIPHER_OMIT_FLAG_PRAGMAS
91852 /*
91853 ** Check to see if zRight and zLeft refer to a pragma that queries
91854 ** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.
91855 ** Also, implement the pragma.
91856 */
91857 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
91858   static const struct sPragmaType {
91859     const char *zName;  /* Name of the pragma */
91860     int mask;           /* Mask for the db->flags value */
91861   } aPragma[] = {
91862     { "full_column_names",        SQLCIPHER_FullColNames  },
91863     { "short_column_names",       SQLCIPHER_ShortColNames },
91864     { "count_changes",            SQLCIPHER_CountRows     },
91865     { "empty_result_callbacks",   SQLCIPHER_NullCallback  },
91866     { "legacy_file_format",       SQLCIPHER_LegacyFileFmt },
91867     { "fullfsync",                SQLCIPHER_FullFSync     },
91868     { "checkpoint_fullfsync",     SQLCIPHER_CkptFullFSync },
91869     { "reverse_unordered_selects", SQLCIPHER_ReverseOrder  },
91870 #ifndef SQLCIPHER_OMIT_AUTOMATIC_INDEX
91871     { "automatic_index",          SQLCIPHER_AutoIndex     },
91872 #endif
91873 #ifdef SQLCIPHER_DEBUG
91874     { "sql_trace",                SQLCIPHER_SqlTrace      },
91875     { "vdbe_listing",             SQLCIPHER_VdbeListing   },
91876     { "vdbe_trace",               SQLCIPHER_VdbeTrace     },
91877 #endif
91878 #ifndef SQLCIPHER_OMIT_CHECK
91879     { "ignore_check_constraints", SQLCIPHER_IgnoreChecks  },
91880 #endif
91881     /* The following is VERY experimental */
91882     { "writable_schema",          SQLCIPHER_WriteSchema|SQLCIPHER_RecoveryMode },
91883     { "omit_readlock",            SQLCIPHER_NoReadlock    },
91884
91885     /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
91886     ** flag if there are any active statements. */
91887     { "read_uncommitted",         SQLCIPHER_ReadUncommitted },
91888     { "recursive_triggers",       SQLCIPHER_RecTriggers },
91889
91890     /* This flag may only be set if both foreign-key and trigger support
91891     ** are present in the build.  */
91892 #if !defined(SQLCIPHER_OMIT_FOREIGN_KEY) && !defined(SQLCIPHER_OMIT_TRIGGER)
91893     { "foreign_keys",             SQLCIPHER_ForeignKeys },
91894 #endif
91895   };
91896   int i;
91897   const struct sPragmaType *p;
91898   for(i=0, p=aPragma; i<ArraySize(aPragma); i++, p++){
91899     if( sqlcipher3StrICmp(zLeft, p->zName)==0 ){
91900       sqlcipher3 *db = pParse->db;
91901       Vdbe *v;
91902       v = sqlcipher3GetVdbe(pParse);
91903       assert( v!=0 );  /* Already allocated by sqlcipher3Pragma() */
91904       if( ALWAYS(v) ){
91905         if( zRight==0 ){
91906           returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
91907         }else{
91908           int mask = p->mask;          /* Mask of bits to set or clear. */
91909           if( db->autoCommit==0 ){
91910             /* Foreign key support may not be enabled or disabled while not
91911             ** in auto-commit mode.  */
91912             mask &= ~(SQLCIPHER_ForeignKeys);
91913           }
91914
91915           if( sqlcipher3GetBoolean(zRight) ){
91916             db->flags |= mask;
91917           }else{
91918             db->flags &= ~mask;
91919           }
91920
91921           /* Many of the flag-pragmas modify the code generated by the SQL 
91922           ** compiler (eg. count_changes). So add an opcode to expire all
91923           ** compiled SQL statements after modifying a pragma value.
91924           */
91925           sqlcipher3VdbeAddOp2(v, OP_Expire, 0, 0);
91926         }
91927       }
91928
91929       return 1;
91930     }
91931   }
91932   return 0;
91933 }
91934 #endif /* SQLCIPHER_OMIT_FLAG_PRAGMAS */
91935
91936 /*
91937 ** Return a human-readable name for a constraint resolution action.
91938 */
91939 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
91940 static const char *actionName(u8 action){
91941   const char *zName;
91942   switch( action ){
91943     case OE_SetNull:  zName = "SET NULL";        break;
91944     case OE_SetDflt:  zName = "SET DEFAULT";     break;
91945     case OE_Cascade:  zName = "CASCADE";         break;
91946     case OE_Restrict: zName = "RESTRICT";        break;
91947     default:          zName = "NO ACTION";  
91948                       assert( action==OE_None ); break;
91949   }
91950   return zName;
91951 }
91952 #endif
91953
91954
91955 /*
91956 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
91957 ** defined in pager.h. This function returns the associated lowercase
91958 ** journal-mode name.
91959 */
91960 SQLCIPHER_PRIVATE const char *sqlcipher3JournalModename(int eMode){
91961   static char * const azModeName[] = {
91962     "delete", "persist", "off", "truncate", "memory"
91963 #ifndef SQLCIPHER_OMIT_WAL
91964      , "wal"
91965 #endif
91966   };
91967   assert( PAGER_JOURNALMODE_DELETE==0 );
91968   assert( PAGER_JOURNALMODE_PERSIST==1 );
91969   assert( PAGER_JOURNALMODE_OFF==2 );
91970   assert( PAGER_JOURNALMODE_TRUNCATE==3 );
91971   assert( PAGER_JOURNALMODE_MEMORY==4 );
91972   assert( PAGER_JOURNALMODE_WAL==5 );
91973   assert( eMode>=0 && eMode<=ArraySize(azModeName) );
91974
91975   if( eMode==ArraySize(azModeName) ) return 0;
91976   return azModeName[eMode];
91977 }
91978
91979 /*
91980 ** Process a pragma statement.  
91981 **
91982 ** Pragmas are of this form:
91983 **
91984 **      PRAGMA [database.]id [= value]
91985 **
91986 ** The identifier might also be a string.  The value is a string, and
91987 ** identifier, or a number.  If minusFlag is true, then the value is
91988 ** a number that was preceded by a minus sign.
91989 **
91990 ** If the left side is "database.id" then pId1 is the database name
91991 ** and pId2 is the id.  If the left side is just "id" then pId1 is the
91992 ** id and pId2 is any empty string.
91993 */
91994 SQLCIPHER_PRIVATE void sqlcipher3Pragma(
91995   Parse *pParse, 
91996   Token *pId1,        /* First part of [database.]id field */
91997   Token *pId2,        /* Second part of [database.]id field, or NULL */
91998   Token *pValue,      /* Token for <value>, or NULL */
91999   int minusFlag       /* True if a '-' sign preceded <value> */
92000 ){
92001   char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */
92002   char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */
92003   const char *zDb = 0;   /* The database name */
92004   Token *pId;            /* Pointer to <id> token */
92005   int iDb;               /* Database index for <database> */
92006   sqlcipher3 *db = pParse->db;
92007   Db *pDb;
92008   Vdbe *v = pParse->pVdbe = sqlcipher3VdbeCreate(db);
92009   if( v==0 ) return;
92010   sqlcipher3VdbeRunOnlyOnce(v);
92011   pParse->nMem = 2;
92012
92013   /* Interpret the [database.] part of the pragma statement. iDb is the
92014   ** index of the database this pragma is being applied to in db.aDb[]. */
92015   iDb = sqlcipher3TwoPartName(pParse, pId1, pId2, &pId);
92016   if( iDb<0 ) return;
92017   pDb = &db->aDb[iDb];
92018
92019   /* If the temp database has been explicitly named as part of the 
92020   ** pragma, make sure it is open. 
92021   */
92022   if( iDb==1 && sqlcipher3OpenTempDatabase(pParse) ){
92023     return;
92024   }
92025
92026   zLeft = sqlcipher3NameFromToken(db, pId);
92027   if( !zLeft ) return;
92028   if( minusFlag ){
92029     zRight = sqlcipher3MPrintf(db, "-%T", pValue);
92030   }else{
92031     zRight = sqlcipher3NameFromToken(db, pValue);
92032   }
92033
92034   assert( pId2 );
92035   zDb = pId2->n>0 ? pDb->zName : 0;
92036   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_PRAGMA, zLeft, zRight, zDb) ){
92037     goto pragma_out;
92038   }
92039  
92040 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
92041   /*
92042   **  PRAGMA [database.]default_cache_size
92043   **  PRAGMA [database.]default_cache_size=N
92044   **
92045   ** The first form reports the current persistent setting for the
92046   ** page cache size.  The value returned is the maximum number of
92047   ** pages in the page cache.  The second form sets both the current
92048   ** page cache size value and the persistent page cache size value
92049   ** stored in the database file.
92050   **
92051   ** Older versions of SQLite would set the default cache size to a
92052   ** negative number to indicate synchronous=OFF.  These days, synchronous
92053   ** is always on by default regardless of the sign of the default cache
92054   ** size.  But continue to take the absolute value of the default cache
92055   ** size of historical compatibility.
92056   */
92057   if( sqlcipher3StrICmp(zLeft,"default_cache_size")==0 ){
92058     static const VdbeOpList getCacheSize[] = {
92059       { OP_Transaction, 0, 0,        0},                         /* 0 */
92060       { OP_ReadCookie,  0, 1,        BTREE_DEFAULT_CACHE_SIZE},  /* 1 */
92061       { OP_IfPos,       1, 7,        0},
92062       { OP_Integer,     0, 2,        0},
92063       { OP_Subtract,    1, 2,        1},
92064       { OP_IfPos,       1, 7,        0},
92065       { OP_Integer,     0, 1,        0},                         /* 6 */
92066       { OP_ResultRow,   1, 1,        0},
92067     };
92068     int addr;
92069     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92070     sqlcipher3VdbeUsesBtree(v, iDb);
92071     if( !zRight ){
92072       sqlcipher3VdbeSetNumCols(v, 1);
92073       sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLCIPHER_STATIC);
92074       pParse->nMem += 2;
92075       addr = sqlcipher3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
92076       sqlcipher3VdbeChangeP1(v, addr, iDb);
92077       sqlcipher3VdbeChangeP1(v, addr+1, iDb);
92078       sqlcipher3VdbeChangeP1(v, addr+6, SQLCIPHER_DEFAULT_CACHE_SIZE);
92079     }else{
92080       int size = sqlcipher3AbsInt32(sqlcipher3Atoi(zRight));
92081       sqlcipher3BeginWriteOperation(pParse, 0, iDb);
92082       sqlcipher3VdbeAddOp2(v, OP_Integer, size, 1);
92083       sqlcipher3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
92084       assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
92085       pDb->pSchema->cache_size = size;
92086       sqlcipher3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
92087     }
92088   }else
92089
92090   /*
92091   **  PRAGMA [database.]page_size
92092   **  PRAGMA [database.]page_size=N
92093   **
92094   ** The first form reports the current setting for the
92095   ** database page size in bytes.  The second form sets the
92096   ** database page size value.  The value can only be set if
92097   ** the database has not yet been created.
92098   */
92099   if( sqlcipher3StrICmp(zLeft,"page_size")==0 ){
92100     Btree *pBt = pDb->pBt;
92101     assert( pBt!=0 );
92102     if( !zRight ){
92103       int size = ALWAYS(pBt) ? sqlcipher3BtreeGetPageSize(pBt) : 0;
92104       returnSingleInt(pParse, "page_size", size);
92105     }else{
92106       /* Malloc may fail when setting the page-size, as there is an internal
92107       ** buffer that the pager module resizes using sqlcipher3_realloc().
92108       */
92109       db->nextPagesize = sqlcipher3Atoi(zRight);
92110       if( SQLCIPHER_NOMEM==sqlcipher3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
92111         db->mallocFailed = 1;
92112       }
92113     }
92114   }else
92115
92116   /*
92117   **  PRAGMA [database.]secure_delete
92118   **  PRAGMA [database.]secure_delete=ON/OFF
92119   **
92120   ** The first form reports the current setting for the
92121   ** secure_delete flag.  The second form changes the secure_delete
92122   ** flag setting and reports thenew value.
92123   */
92124   if( sqlcipher3StrICmp(zLeft,"secure_delete")==0 ){
92125     Btree *pBt = pDb->pBt;
92126     int b = -1;
92127     assert( pBt!=0 );
92128     if( zRight ){
92129       b = sqlcipher3GetBoolean(zRight);
92130     }
92131     if( pId2->n==0 && b>=0 ){
92132       int ii;
92133       for(ii=0; ii<db->nDb; ii++){
92134         sqlcipher3BtreeSecureDelete(db->aDb[ii].pBt, b);
92135       }
92136     }
92137     b = sqlcipher3BtreeSecureDelete(pBt, b);
92138     returnSingleInt(pParse, "secure_delete", b);
92139   }else
92140
92141   /*
92142   **  PRAGMA [database.]max_page_count
92143   **  PRAGMA [database.]max_page_count=N
92144   **
92145   ** The first form reports the current setting for the
92146   ** maximum number of pages in the database file.  The 
92147   ** second form attempts to change this setting.  Both
92148   ** forms return the current setting.
92149   **
92150   **  PRAGMA [database.]page_count
92151   **
92152   ** Return the number of pages in the specified database.
92153   */
92154   if( sqlcipher3StrICmp(zLeft,"page_count")==0
92155    || sqlcipher3StrICmp(zLeft,"max_page_count")==0
92156   ){
92157     int iReg;
92158     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92159     sqlcipher3CodeVerifySchema(pParse, iDb);
92160     iReg = ++pParse->nMem;
92161     if( sqlcipher3Tolower(zLeft[0])=='p' ){
92162       sqlcipher3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
92163     }else{
92164       sqlcipher3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, sqlcipher3Atoi(zRight));
92165     }
92166     sqlcipher3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
92167     sqlcipher3VdbeSetNumCols(v, 1);
92168     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLCIPHER_TRANSIENT);
92169   }else
92170
92171   /*
92172   **  PRAGMA [database.]locking_mode
92173   **  PRAGMA [database.]locking_mode = (normal|exclusive)
92174   */
92175   if( sqlcipher3StrICmp(zLeft,"locking_mode")==0 ){
92176     const char *zRet = "normal";
92177     int eMode = getLockingMode(zRight);
92178
92179     if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
92180       /* Simple "PRAGMA locking_mode;" statement. This is a query for
92181       ** the current default locking mode (which may be different to
92182       ** the locking-mode of the main database).
92183       */
92184       eMode = db->dfltLockMode;
92185     }else{
92186       Pager *pPager;
92187       if( pId2->n==0 ){
92188         /* This indicates that no database name was specified as part
92189         ** of the PRAGMA command. In this case the locking-mode must be
92190         ** set on all attached databases, as well as the main db file.
92191         **
92192         ** Also, the sqlcipher3.dfltLockMode variable is set so that
92193         ** any subsequently attached databases also use the specified
92194         ** locking mode.
92195         */
92196         int ii;
92197         assert(pDb==&db->aDb[0]);
92198         for(ii=2; ii<db->nDb; ii++){
92199           pPager = sqlcipher3BtreePager(db->aDb[ii].pBt);
92200           sqlcipher3PagerLockingMode(pPager, eMode);
92201         }
92202         db->dfltLockMode = (u8)eMode;
92203       }
92204       pPager = sqlcipher3BtreePager(pDb->pBt);
92205       eMode = sqlcipher3PagerLockingMode(pPager, eMode);
92206     }
92207
92208     assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
92209     if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
92210       zRet = "exclusive";
92211     }
92212     sqlcipher3VdbeSetNumCols(v, 1);
92213     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", SQLCIPHER_STATIC);
92214     sqlcipher3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
92215     sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92216   }else
92217
92218   /*
92219   **  PRAGMA [database.]journal_mode
92220   **  PRAGMA [database.]journal_mode =
92221   **                      (delete|persist|off|truncate|memory|wal|off)
92222   */
92223   if( sqlcipher3StrICmp(zLeft,"journal_mode")==0 ){
92224     int eMode;        /* One of the PAGER_JOURNALMODE_XXX symbols */
92225     int ii;           /* Loop counter */
92226
92227     /* Force the schema to be loaded on all databases.  This causes all
92228     ** database files to be opened and the journal_modes set.  This is
92229     ** necessary because subsequent processing must know if the databases
92230     ** are in WAL mode. */
92231     if( sqlcipher3ReadSchema(pParse) ){
92232       goto pragma_out;
92233     }
92234
92235     sqlcipher3VdbeSetNumCols(v, 1);
92236     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", SQLCIPHER_STATIC);
92237
92238     if( zRight==0 ){
92239       /* If there is no "=MODE" part of the pragma, do a query for the
92240       ** current mode */
92241       eMode = PAGER_JOURNALMODE_QUERY;
92242     }else{
92243       const char *zMode;
92244       int n = sqlcipher3Strlen30(zRight);
92245       for(eMode=0; (zMode = sqlcipher3JournalModename(eMode))!=0; eMode++){
92246         if( sqlcipher3StrNICmp(zRight, zMode, n)==0 ) break;
92247       }
92248       if( !zMode ){
92249         /* If the "=MODE" part does not match any known journal mode,
92250         ** then do a query */
92251         eMode = PAGER_JOURNALMODE_QUERY;
92252       }
92253     }
92254     if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
92255       /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
92256       iDb = 0;
92257       pId2->n = 1;
92258     }
92259     for(ii=db->nDb-1; ii>=0; ii--){
92260       if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
92261         sqlcipher3VdbeUsesBtree(v, ii);
92262         sqlcipher3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
92263       }
92264     }
92265     sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92266   }else
92267
92268   /*
92269   **  PRAGMA [database.]journal_size_limit
92270   **  PRAGMA [database.]journal_size_limit=N
92271   **
92272   ** Get or set the size limit on rollback journal files.
92273   */
92274   if( sqlcipher3StrICmp(zLeft,"journal_size_limit")==0 ){
92275     Pager *pPager = sqlcipher3BtreePager(pDb->pBt);
92276     i64 iLimit = -2;
92277     if( zRight ){
92278       sqlcipher3Atoi64(zRight, &iLimit, 1000000, SQLCIPHER_UTF8);
92279       if( iLimit<-1 ) iLimit = -1;
92280     }
92281     iLimit = sqlcipher3PagerJournalSizeLimit(pPager, iLimit);
92282     returnSingleInt(pParse, "journal_size_limit", iLimit);
92283   }else
92284
92285 #endif /* SQLCIPHER_OMIT_PAGER_PRAGMAS */
92286
92287   /*
92288   **  PRAGMA [database.]auto_vacuum
92289   **  PRAGMA [database.]auto_vacuum=N
92290   **
92291   ** Get or set the value of the database 'auto-vacuum' parameter.
92292   ** The value is one of:  0 NONE 1 FULL 2 INCREMENTAL
92293   */
92294 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
92295   if( sqlcipher3StrICmp(zLeft,"auto_vacuum")==0 ){
92296     Btree *pBt = pDb->pBt;
92297     assert( pBt!=0 );
92298     if( sqlcipher3ReadSchema(pParse) ){
92299       goto pragma_out;
92300     }
92301     if( !zRight ){
92302       int auto_vacuum;
92303       if( ALWAYS(pBt) ){
92304          auto_vacuum = sqlcipher3BtreeGetAutoVacuum(pBt);
92305       }else{
92306          auto_vacuum = SQLCIPHER_DEFAULT_AUTOVACUUM;
92307       }
92308       returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
92309     }else{
92310       int eAuto = getAutoVacuum(zRight);
92311       assert( eAuto>=0 && eAuto<=2 );
92312       db->nextAutovac = (u8)eAuto;
92313       if( ALWAYS(eAuto>=0) ){
92314         /* Call SetAutoVacuum() to set initialize the internal auto and
92315         ** incr-vacuum flags. This is required in case this connection
92316         ** creates the database file. It is important that it is created
92317         ** as an auto-vacuum capable db.
92318         */
92319         int rc = sqlcipher3BtreeSetAutoVacuum(pBt, eAuto);
92320         if( rc==SQLCIPHER_OK && (eAuto==1 || eAuto==2) ){
92321           /* When setting the auto_vacuum mode to either "full" or 
92322           ** "incremental", write the value of meta[6] in the database
92323           ** file. Before writing to meta[6], check that meta[3] indicates
92324           ** that this really is an auto-vacuum capable database.
92325           */
92326           static const VdbeOpList setMeta6[] = {
92327             { OP_Transaction,    0,         1,                 0},    /* 0 */
92328             { OP_ReadCookie,     0,         1,         BTREE_LARGEST_ROOT_PAGE},
92329             { OP_If,             1,         0,                 0},    /* 2 */
92330             { OP_Halt,           SQLCIPHER_OK, OE_Abort,          0},    /* 3 */
92331             { OP_Integer,        0,         1,                 0},    /* 4 */
92332             { OP_SetCookie,      0,         BTREE_INCR_VACUUM, 1},    /* 5 */
92333           };
92334           int iAddr;
92335           iAddr = sqlcipher3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
92336           sqlcipher3VdbeChangeP1(v, iAddr, iDb);
92337           sqlcipher3VdbeChangeP1(v, iAddr+1, iDb);
92338           sqlcipher3VdbeChangeP2(v, iAddr+2, iAddr+4);
92339           sqlcipher3VdbeChangeP1(v, iAddr+4, eAuto-1);
92340           sqlcipher3VdbeChangeP1(v, iAddr+5, iDb);
92341           sqlcipher3VdbeUsesBtree(v, iDb);
92342         }
92343       }
92344     }
92345   }else
92346 #endif
92347
92348   /*
92349   **  PRAGMA [database.]incremental_vacuum(N)
92350   **
92351   ** Do N steps of incremental vacuuming on a database.
92352   */
92353 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
92354   if( sqlcipher3StrICmp(zLeft,"incremental_vacuum")==0 ){
92355     int iLimit, addr;
92356     if( sqlcipher3ReadSchema(pParse) ){
92357       goto pragma_out;
92358     }
92359     if( zRight==0 || !sqlcipher3GetInt32(zRight, &iLimit) || iLimit<=0 ){
92360       iLimit = 0x7fffffff;
92361     }
92362     sqlcipher3BeginWriteOperation(pParse, 0, iDb);
92363     sqlcipher3VdbeAddOp2(v, OP_Integer, iLimit, 1);
92364     addr = sqlcipher3VdbeAddOp1(v, OP_IncrVacuum, iDb);
92365     sqlcipher3VdbeAddOp1(v, OP_ResultRow, 1);
92366     sqlcipher3VdbeAddOp2(v, OP_AddImm, 1, -1);
92367     sqlcipher3VdbeAddOp2(v, OP_IfPos, 1, addr);
92368     sqlcipher3VdbeJumpHere(v, addr);
92369   }else
92370 #endif
92371
92372 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
92373   /*
92374   **  PRAGMA [database.]cache_size
92375   **  PRAGMA [database.]cache_size=N
92376   **
92377   ** The first form reports the current local setting for the
92378   ** page cache size.  The local setting can be different from
92379   ** the persistent cache size value that is stored in the database
92380   ** file itself.  The value returned is the maximum number of
92381   ** pages in the page cache.  The second form sets the local
92382   ** page cache size value.  It does not change the persistent
92383   ** cache size stored on the disk so the cache size will revert
92384   ** to its default value when the database is closed and reopened.
92385   ** N should be a positive integer.
92386   */
92387   if( sqlcipher3StrICmp(zLeft,"cache_size")==0 ){
92388     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92389     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
92390     if( !zRight ){
92391       returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
92392     }else{
92393       int size = sqlcipher3AbsInt32(sqlcipher3Atoi(zRight));
92394       pDb->pSchema->cache_size = size;
92395       sqlcipher3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
92396     }
92397   }else
92398
92399   /*
92400   **   PRAGMA temp_store
92401   **   PRAGMA temp_store = "default"|"memory"|"file"
92402   **
92403   ** Return or set the local value of the temp_store flag.  Changing
92404   ** the local value does not make changes to the disk file and the default
92405   ** value will be restored the next time the database is opened.
92406   **
92407   ** Note that it is possible for the library compile-time options to
92408   ** override this setting
92409   */
92410   if( sqlcipher3StrICmp(zLeft, "temp_store")==0 ){
92411     if( !zRight ){
92412       returnSingleInt(pParse, "temp_store", db->temp_store);
92413     }else{
92414       changeTempStorage(pParse, zRight);
92415     }
92416   }else
92417
92418   /*
92419   **   PRAGMA temp_store_directory
92420   **   PRAGMA temp_store_directory = ""|"directory_name"
92421   **
92422   ** Return or set the local value of the temp_store_directory flag.  Changing
92423   ** the value sets a specific directory to be used for temporary files.
92424   ** Setting to a null string reverts to the default temporary directory search.
92425   ** If temporary directory is changed, then invalidateTempStorage.
92426   **
92427   */
92428   if( sqlcipher3StrICmp(zLeft, "temp_store_directory")==0 ){
92429     if( !zRight ){
92430       if( sqlcipher3_temp_directory ){
92431         sqlcipher3VdbeSetNumCols(v, 1);
92432         sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, 
92433             "temp_store_directory", SQLCIPHER_STATIC);
92434         sqlcipher3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlcipher3_temp_directory, 0);
92435         sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92436       }
92437     }else{
92438 #ifndef SQLCIPHER_OMIT_WSD
92439       if( zRight[0] ){
92440         int rc;
92441         int res;
92442         rc = sqlcipher3OsAccess(db->pVfs, zRight, SQLCIPHER_ACCESS_READWRITE, &res);
92443         if( rc!=SQLCIPHER_OK || res==0 ){
92444           sqlcipher3ErrorMsg(pParse, "not a writable directory");
92445           goto pragma_out;
92446         }
92447       }
92448       if( SQLCIPHER_TEMP_STORE==0
92449        || (SQLCIPHER_TEMP_STORE==1 && db->temp_store<=1)
92450        || (SQLCIPHER_TEMP_STORE==2 && db->temp_store==1)
92451       ){
92452         invalidateTempStorage(pParse);
92453       }
92454       sqlcipher3_free(sqlcipher3_temp_directory);
92455       if( zRight[0] ){
92456         sqlcipher3_temp_directory = sqlcipher3_mprintf("%s", zRight);
92457       }else{
92458         sqlcipher3_temp_directory = 0;
92459       }
92460 #endif /* SQLCIPHER_OMIT_WSD */
92461     }
92462   }else
92463
92464 #if !defined(SQLCIPHER_ENABLE_LOCKING_STYLE)
92465 #  if defined(__APPLE__)
92466 #    define SQLCIPHER_ENABLE_LOCKING_STYLE 1
92467 #  else
92468 #    define SQLCIPHER_ENABLE_LOCKING_STYLE 0
92469 #  endif
92470 #endif
92471 #if SQLCIPHER_ENABLE_LOCKING_STYLE
92472   /*
92473    **   PRAGMA [database.]lock_proxy_file
92474    **   PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"
92475    **
92476    ** Return or set the value of the lock_proxy_file flag.  Changing
92477    ** the value sets a specific file to be used for database access locks.
92478    **
92479    */
92480   if( sqlcipher3StrICmp(zLeft, "lock_proxy_file")==0 ){
92481     if( !zRight ){
92482       Pager *pPager = sqlcipher3BtreePager(pDb->pBt);
92483       char *proxy_file_path = NULL;
92484       sqlcipher3_file *pFile = sqlcipher3PagerFile(pPager);
92485       sqlcipher3OsFileControl(pFile, SQLCIPHER_GET_LOCKPROXYFILE, 
92486                            &proxy_file_path);
92487       
92488       if( proxy_file_path ){
92489         sqlcipher3VdbeSetNumCols(v, 1);
92490         sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, 
92491                               "lock_proxy_file", SQLCIPHER_STATIC);
92492         sqlcipher3VdbeAddOp4(v, OP_String8, 0, 1, 0, proxy_file_path, 0);
92493         sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92494       }
92495     }else{
92496       Pager *pPager = sqlcipher3BtreePager(pDb->pBt);
92497       sqlcipher3_file *pFile = sqlcipher3PagerFile(pPager);
92498       int res;
92499       if( zRight[0] ){
92500         res=sqlcipher3OsFileControl(pFile, SQLCIPHER_SET_LOCKPROXYFILE, 
92501                                      zRight);
92502       } else {
92503         res=sqlcipher3OsFileControl(pFile, SQLCIPHER_SET_LOCKPROXYFILE, 
92504                                      NULL);
92505       }
92506       if( res!=SQLCIPHER_OK ){
92507         sqlcipher3ErrorMsg(pParse, "failed to set lock proxy file");
92508         goto pragma_out;
92509       }
92510     }
92511   }else
92512 #endif /* SQLCIPHER_ENABLE_LOCKING_STYLE */      
92513     
92514   /*
92515   **   PRAGMA [database.]synchronous
92516   **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
92517   **
92518   ** Return or set the local value of the synchronous flag.  Changing
92519   ** the local value does not make changes to the disk file and the
92520   ** default value will be restored the next time the database is
92521   ** opened.
92522   */
92523   if( sqlcipher3StrICmp(zLeft,"synchronous")==0 ){
92524     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92525     if( !zRight ){
92526       returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
92527     }else{
92528       if( !db->autoCommit ){
92529         sqlcipher3ErrorMsg(pParse, 
92530             "Safety level may not be changed inside a transaction");
92531       }else{
92532         pDb->safety_level = getSafetyLevel(zRight)+1;
92533       }
92534     }
92535   }else
92536 #endif /* SQLCIPHER_OMIT_PAGER_PRAGMAS */
92537
92538 #ifndef SQLCIPHER_OMIT_FLAG_PRAGMAS
92539   if( flagPragma(pParse, zLeft, zRight) ){
92540     /* The flagPragma() subroutine also generates any necessary code
92541     ** there is nothing more to do here */
92542   }else
92543 #endif /* SQLCIPHER_OMIT_FLAG_PRAGMAS */
92544
92545 #ifndef SQLCIPHER_OMIT_SCHEMA_PRAGMAS
92546   /*
92547   **   PRAGMA table_info(<table>)
92548   **
92549   ** Return a single row for each column of the named table. The columns of
92550   ** the returned data set are:
92551   **
92552   ** cid:        Column id (numbered from left to right, starting at 0)
92553   ** name:       Column name
92554   ** type:       Column declaration type.
92555   ** notnull:    True if 'NOT NULL' is part of column declaration
92556   ** dflt_value: The default value for the column, if any.
92557   */
92558   if( sqlcipher3StrICmp(zLeft, "table_info")==0 && zRight ){
92559     Table *pTab;
92560     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92561     pTab = sqlcipher3FindTable(db, zRight, zDb);
92562     if( pTab ){
92563       int i;
92564       int nHidden = 0;
92565       Column *pCol;
92566       sqlcipher3VdbeSetNumCols(v, 6);
92567       pParse->nMem = 6;
92568       sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "cid", SQLCIPHER_STATIC);
92569       sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLCIPHER_STATIC);
92570       sqlcipher3VdbeSetColName(v, 2, COLNAME_NAME, "type", SQLCIPHER_STATIC);
92571       sqlcipher3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", SQLCIPHER_STATIC);
92572       sqlcipher3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", SQLCIPHER_STATIC);
92573       sqlcipher3VdbeSetColName(v, 5, COLNAME_NAME, "pk", SQLCIPHER_STATIC);
92574       sqlcipher3ViewGetColumnNames(pParse, pTab);
92575       for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
92576         if( IsHiddenColumn(pCol) ){
92577           nHidden++;
92578           continue;
92579         }
92580         sqlcipher3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
92581         sqlcipher3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
92582         sqlcipher3VdbeAddOp4(v, OP_String8, 0, 3, 0,
92583            pCol->zType ? pCol->zType : "", 0);
92584         sqlcipher3VdbeAddOp2(v, OP_Integer, (pCol->notNull ? 1 : 0), 4);
92585         if( pCol->zDflt ){
92586           sqlcipher3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pCol->zDflt, 0);
92587         }else{
92588           sqlcipher3VdbeAddOp2(v, OP_Null, 0, 5);
92589         }
92590         sqlcipher3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
92591         sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 6);
92592       }
92593     }
92594   }else
92595
92596   if( sqlcipher3StrICmp(zLeft, "index_info")==0 && zRight ){
92597     Index *pIdx;
92598     Table *pTab;
92599     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92600     pIdx = sqlcipher3FindIndex(db, zRight, zDb);
92601     if( pIdx ){
92602       int i;
92603       pTab = pIdx->pTable;
92604       sqlcipher3VdbeSetNumCols(v, 3);
92605       pParse->nMem = 3;
92606       sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLCIPHER_STATIC);
92607       sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLCIPHER_STATIC);
92608       sqlcipher3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLCIPHER_STATIC);
92609       for(i=0; i<pIdx->nColumn; i++){
92610         int cnum = pIdx->aiColumn[i];
92611         sqlcipher3VdbeAddOp2(v, OP_Integer, i, 1);
92612         sqlcipher3VdbeAddOp2(v, OP_Integer, cnum, 2);
92613         assert( pTab->nCol>cnum );
92614         sqlcipher3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
92615         sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 3);
92616       }
92617     }
92618   }else
92619
92620   if( sqlcipher3StrICmp(zLeft, "index_list")==0 && zRight ){
92621     Index *pIdx;
92622     Table *pTab;
92623     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92624     pTab = sqlcipher3FindTable(db, zRight, zDb);
92625     if( pTab ){
92626       v = sqlcipher3GetVdbe(pParse);
92627       pIdx = pTab->pIndex;
92628       if( pIdx ){
92629         int i = 0; 
92630         sqlcipher3VdbeSetNumCols(v, 3);
92631         pParse->nMem = 3;
92632         sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLCIPHER_STATIC);
92633         sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLCIPHER_STATIC);
92634         sqlcipher3VdbeSetColName(v, 2, COLNAME_NAME, "unique", SQLCIPHER_STATIC);
92635         while(pIdx){
92636           sqlcipher3VdbeAddOp2(v, OP_Integer, i, 1);
92637           sqlcipher3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
92638           sqlcipher3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
92639           sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 3);
92640           ++i;
92641           pIdx = pIdx->pNext;
92642         }
92643       }
92644     }
92645   }else
92646
92647   if( sqlcipher3StrICmp(zLeft, "database_list")==0 ){
92648     int i;
92649     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92650     sqlcipher3VdbeSetNumCols(v, 3);
92651     pParse->nMem = 3;
92652     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLCIPHER_STATIC);
92653     sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLCIPHER_STATIC);
92654     sqlcipher3VdbeSetColName(v, 2, COLNAME_NAME, "file", SQLCIPHER_STATIC);
92655     for(i=0; i<db->nDb; i++){
92656       if( db->aDb[i].pBt==0 ) continue;
92657       assert( db->aDb[i].zName!=0 );
92658       sqlcipher3VdbeAddOp2(v, OP_Integer, i, 1);
92659       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
92660       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 3, 0,
92661            sqlcipher3BtreeGetFilename(db->aDb[i].pBt), 0);
92662       sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 3);
92663     }
92664   }else
92665
92666   if( sqlcipher3StrICmp(zLeft, "collation_list")==0 ){
92667     int i = 0;
92668     HashElem *p;
92669     sqlcipher3VdbeSetNumCols(v, 2);
92670     pParse->nMem = 2;
92671     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLCIPHER_STATIC);
92672     sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLCIPHER_STATIC);
92673     for(p=sqlcipherHashFirst(&db->aCollSeq); p; p=sqlcipherHashNext(p)){
92674       CollSeq *pColl = (CollSeq *)sqlcipherHashData(p);
92675       sqlcipher3VdbeAddOp2(v, OP_Integer, i++, 1);
92676       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
92677       sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 2);
92678     }
92679   }else
92680 #endif /* SQLCIPHER_OMIT_SCHEMA_PRAGMAS */
92681
92682 #ifndef SQLCIPHER_OMIT_FOREIGN_KEY
92683   if( sqlcipher3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
92684     FKey *pFK;
92685     Table *pTab;
92686     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92687     pTab = sqlcipher3FindTable(db, zRight, zDb);
92688     if( pTab ){
92689       v = sqlcipher3GetVdbe(pParse);
92690       pFK = pTab->pFKey;
92691       if( pFK ){
92692         int i = 0; 
92693         sqlcipher3VdbeSetNumCols(v, 8);
92694         pParse->nMem = 8;
92695         sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "id", SQLCIPHER_STATIC);
92696         sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "seq", SQLCIPHER_STATIC);
92697         sqlcipher3VdbeSetColName(v, 2, COLNAME_NAME, "table", SQLCIPHER_STATIC);
92698         sqlcipher3VdbeSetColName(v, 3, COLNAME_NAME, "from", SQLCIPHER_STATIC);
92699         sqlcipher3VdbeSetColName(v, 4, COLNAME_NAME, "to", SQLCIPHER_STATIC);
92700         sqlcipher3VdbeSetColName(v, 5, COLNAME_NAME, "on_update", SQLCIPHER_STATIC);
92701         sqlcipher3VdbeSetColName(v, 6, COLNAME_NAME, "on_delete", SQLCIPHER_STATIC);
92702         sqlcipher3VdbeSetColName(v, 7, COLNAME_NAME, "match", SQLCIPHER_STATIC);
92703         while(pFK){
92704           int j;
92705           for(j=0; j<pFK->nCol; j++){
92706             char *zCol = pFK->aCol[j].zCol;
92707             char *zOnDelete = (char *)actionName(pFK->aAction[0]);
92708             char *zOnUpdate = (char *)actionName(pFK->aAction[1]);
92709             sqlcipher3VdbeAddOp2(v, OP_Integer, i, 1);
92710             sqlcipher3VdbeAddOp2(v, OP_Integer, j, 2);
92711             sqlcipher3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
92712             sqlcipher3VdbeAddOp4(v, OP_String8, 0, 4, 0,
92713                               pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
92714             sqlcipher3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
92715             sqlcipher3VdbeAddOp4(v, OP_String8, 0, 6, 0, zOnUpdate, 0);
92716             sqlcipher3VdbeAddOp4(v, OP_String8, 0, 7, 0, zOnDelete, 0);
92717             sqlcipher3VdbeAddOp4(v, OP_String8, 0, 8, 0, "NONE", 0);
92718             sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 8);
92719           }
92720           ++i;
92721           pFK = pFK->pNextFrom;
92722         }
92723       }
92724     }
92725   }else
92726 #endif /* !defined(SQLCIPHER_OMIT_FOREIGN_KEY) */
92727
92728 #ifndef NDEBUG
92729   if( sqlcipher3StrICmp(zLeft, "parser_trace")==0 ){
92730     if( zRight ){
92731       if( sqlcipher3GetBoolean(zRight) ){
92732         sqlcipher3ParserTrace(stderr, "parser: ");
92733       }else{
92734         sqlcipher3ParserTrace(0, 0);
92735       }
92736     }
92737   }else
92738 #endif
92739
92740   /* Reinstall the LIKE and GLOB functions.  The variant of LIKE
92741   ** used will be case sensitive or not depending on the RHS.
92742   */
92743   if( sqlcipher3StrICmp(zLeft, "case_sensitive_like")==0 ){
92744     if( zRight ){
92745       sqlcipher3RegisterLikeFunctions(db, sqlcipher3GetBoolean(zRight));
92746     }
92747   }else
92748
92749 #ifndef SQLCIPHER_INTEGRITY_CHECK_ERROR_MAX
92750 # define SQLCIPHER_INTEGRITY_CHECK_ERROR_MAX 100
92751 #endif
92752
92753 #ifndef SQLCIPHER_OMIT_INTEGRITY_CHECK
92754   /* Pragma "quick_check" is an experimental reduced version of 
92755   ** integrity_check designed to detect most database corruption
92756   ** without most of the overhead of a full integrity-check.
92757   */
92758   if( sqlcipher3StrICmp(zLeft, "integrity_check")==0
92759    || sqlcipher3StrICmp(zLeft, "quick_check")==0 
92760   ){
92761     int i, j, addr, mxErr;
92762
92763     /* Code that appears at the end of the integrity check.  If no error
92764     ** messages have been generated, output OK.  Otherwise output the
92765     ** error message
92766     */
92767     static const VdbeOpList endCode[] = {
92768       { OP_AddImm,      1, 0,        0},    /* 0 */
92769       { OP_IfNeg,       1, 0,        0},    /* 1 */
92770       { OP_String8,     0, 3,        0},    /* 2 */
92771       { OP_ResultRow,   3, 1,        0},
92772     };
92773
92774     int isQuick = (sqlcipher3Tolower(zLeft[0])=='q');
92775
92776     /* Initialize the VDBE program */
92777     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92778     pParse->nMem = 6;
92779     sqlcipher3VdbeSetNumCols(v, 1);
92780     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", SQLCIPHER_STATIC);
92781
92782     /* Set the maximum error count */
92783     mxErr = SQLCIPHER_INTEGRITY_CHECK_ERROR_MAX;
92784     if( zRight ){
92785       sqlcipher3GetInt32(zRight, &mxErr);
92786       if( mxErr<=0 ){
92787         mxErr = SQLCIPHER_INTEGRITY_CHECK_ERROR_MAX;
92788       }
92789     }
92790     sqlcipher3VdbeAddOp2(v, OP_Integer, mxErr, 1);  /* reg[1] holds errors left */
92791
92792     /* Do an integrity check on each database file */
92793     for(i=0; i<db->nDb; i++){
92794       HashElem *x;
92795       Hash *pTbls;
92796       int cnt = 0;
92797
92798       if( OMIT_TEMPDB && i==1 ) continue;
92799
92800       sqlcipher3CodeVerifySchema(pParse, i);
92801       addr = sqlcipher3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
92802       sqlcipher3VdbeAddOp2(v, OP_Halt, 0, 0);
92803       sqlcipher3VdbeJumpHere(v, addr);
92804
92805       /* Do an integrity check of the B-Tree
92806       **
92807       ** Begin by filling registers 2, 3, ... with the root pages numbers
92808       ** for all tables and indices in the database.
92809       */
92810       assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
92811       pTbls = &db->aDb[i].pSchema->tblHash;
92812       for(x=sqlcipherHashFirst(pTbls); x; x=sqlcipherHashNext(x)){
92813         Table *pTab = sqlcipherHashData(x);
92814         Index *pIdx;
92815         sqlcipher3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
92816         cnt++;
92817         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
92818           sqlcipher3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
92819           cnt++;
92820         }
92821       }
92822
92823       /* Make sure sufficient number of registers have been allocated */
92824       if( pParse->nMem < cnt+4 ){
92825         pParse->nMem = cnt+4;
92826       }
92827
92828       /* Do the b-tree integrity checks */
92829       sqlcipher3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
92830       sqlcipher3VdbeChangeP5(v, (u8)i);
92831       addr = sqlcipher3VdbeAddOp1(v, OP_IsNull, 2);
92832       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 3, 0,
92833          sqlcipher3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
92834          P4_DYNAMIC);
92835       sqlcipher3VdbeAddOp3(v, OP_Move, 2, 4, 1);
92836       sqlcipher3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
92837       sqlcipher3VdbeAddOp2(v, OP_ResultRow, 2, 1);
92838       sqlcipher3VdbeJumpHere(v, addr);
92839
92840       /* Make sure all the indices are constructed correctly.
92841       */
92842       for(x=sqlcipherHashFirst(pTbls); x && !isQuick; x=sqlcipherHashNext(x)){
92843         Table *pTab = sqlcipherHashData(x);
92844         Index *pIdx;
92845         int loopTop;
92846
92847         if( pTab->pIndex==0 ) continue;
92848         addr = sqlcipher3VdbeAddOp1(v, OP_IfPos, 1);  /* Stop if out of errors */
92849         sqlcipher3VdbeAddOp2(v, OP_Halt, 0, 0);
92850         sqlcipher3VdbeJumpHere(v, addr);
92851         sqlcipher3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
92852         sqlcipher3VdbeAddOp2(v, OP_Integer, 0, 2);  /* reg(2) will count entries */
92853         loopTop = sqlcipher3VdbeAddOp2(v, OP_Rewind, 1, 0);
92854         sqlcipher3VdbeAddOp2(v, OP_AddImm, 2, 1);   /* increment entry count */
92855         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
92856           int jmp2;
92857           int r1;
92858           static const VdbeOpList idxErr[] = {
92859             { OP_AddImm,      1, -1,  0},
92860             { OP_String8,     0,  3,  0},    /* 1 */
92861             { OP_Rowid,       1,  4,  0},
92862             { OP_String8,     0,  5,  0},    /* 3 */
92863             { OP_String8,     0,  6,  0},    /* 4 */
92864             { OP_Concat,      4,  3,  3},
92865             { OP_Concat,      5,  3,  3},
92866             { OP_Concat,      6,  3,  3},
92867             { OP_ResultRow,   3,  1,  0},
92868             { OP_IfPos,       1,  0,  0},    /* 9 */
92869             { OP_Halt,        0,  0,  0},
92870           };
92871           r1 = sqlcipher3GenerateIndexKey(pParse, pIdx, 1, 3, 0);
92872           jmp2 = sqlcipher3VdbeAddOp4Int(v, OP_Found, j+2, 0, r1, pIdx->nColumn+1);
92873           addr = sqlcipher3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
92874           sqlcipher3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
92875           sqlcipher3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
92876           sqlcipher3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
92877           sqlcipher3VdbeJumpHere(v, addr+9);
92878           sqlcipher3VdbeJumpHere(v, jmp2);
92879         }
92880         sqlcipher3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
92881         sqlcipher3VdbeJumpHere(v, loopTop);
92882         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
92883           static const VdbeOpList cntIdx[] = {
92884              { OP_Integer,      0,  3,  0},
92885              { OP_Rewind,       0,  0,  0},  /* 1 */
92886              { OP_AddImm,       3,  1,  0},
92887              { OP_Next,         0,  0,  0},  /* 3 */
92888              { OP_Eq,           2,  0,  3},  /* 4 */
92889              { OP_AddImm,       1, -1,  0},
92890              { OP_String8,      0,  2,  0},  /* 6 */
92891              { OP_String8,      0,  3,  0},  /* 7 */
92892              { OP_Concat,       3,  2,  2},
92893              { OP_ResultRow,    2,  1,  0},
92894           };
92895           addr = sqlcipher3VdbeAddOp1(v, OP_IfPos, 1);
92896           sqlcipher3VdbeAddOp2(v, OP_Halt, 0, 0);
92897           sqlcipher3VdbeJumpHere(v, addr);
92898           addr = sqlcipher3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
92899           sqlcipher3VdbeChangeP1(v, addr+1, j+2);
92900           sqlcipher3VdbeChangeP2(v, addr+1, addr+4);
92901           sqlcipher3VdbeChangeP1(v, addr+3, j+2);
92902           sqlcipher3VdbeChangeP2(v, addr+3, addr+2);
92903           sqlcipher3VdbeJumpHere(v, addr+4);
92904           sqlcipher3VdbeChangeP4(v, addr+6, 
92905                      "wrong # of entries in index ", P4_STATIC);
92906           sqlcipher3VdbeChangeP4(v, addr+7, pIdx->zName, P4_TRANSIENT);
92907         }
92908       } 
92909     }
92910     addr = sqlcipher3VdbeAddOpList(v, ArraySize(endCode), endCode);
92911     sqlcipher3VdbeChangeP2(v, addr, -mxErr);
92912     sqlcipher3VdbeJumpHere(v, addr+1);
92913     sqlcipher3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
92914   }else
92915 #endif /* SQLCIPHER_OMIT_INTEGRITY_CHECK */
92916
92917 #ifndef SQLCIPHER_OMIT_UTF16
92918   /*
92919   **   PRAGMA encoding
92920   **   PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
92921   **
92922   ** In its first form, this pragma returns the encoding of the main
92923   ** database. If the database is not initialized, it is initialized now.
92924   **
92925   ** The second form of this pragma is a no-op if the main database file
92926   ** has not already been initialized. In this case it sets the default
92927   ** encoding that will be used for the main database file if a new file
92928   ** is created. If an existing main database file is opened, then the
92929   ** default text encoding for the existing database is used.
92930   ** 
92931   ** In all cases new databases created using the ATTACH command are
92932   ** created to use the same default text encoding as the main database. If
92933   ** the main database has not been initialized and/or created when ATTACH
92934   ** is executed, this is done before the ATTACH operation.
92935   **
92936   ** In the second form this pragma sets the text encoding to be used in
92937   ** new database files created using this database handle. It is only
92938   ** useful if invoked immediately after the main database i
92939   */
92940   if( sqlcipher3StrICmp(zLeft, "encoding")==0 ){
92941     static const struct EncName {
92942       char *zName;
92943       u8 enc;
92944     } encnames[] = {
92945       { "UTF8",     SQLCIPHER_UTF8        },
92946       { "UTF-8",    SQLCIPHER_UTF8        },  /* Must be element [1] */
92947       { "UTF-16le", SQLCIPHER_UTF16LE     },  /* Must be element [2] */
92948       { "UTF-16be", SQLCIPHER_UTF16BE     },  /* Must be element [3] */
92949       { "UTF16le",  SQLCIPHER_UTF16LE     },
92950       { "UTF16be",  SQLCIPHER_UTF16BE     },
92951       { "UTF-16",   0                  }, /* SQLCIPHER_UTF16NATIVE */
92952       { "UTF16",    0                  }, /* SQLCIPHER_UTF16NATIVE */
92953       { 0, 0 }
92954     };
92955     const struct EncName *pEnc;
92956     if( !zRight ){    /* "PRAGMA encoding" */
92957       if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
92958       sqlcipher3VdbeSetNumCols(v, 1);
92959       sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", SQLCIPHER_STATIC);
92960       sqlcipher3VdbeAddOp2(v, OP_String8, 0, 1);
92961       assert( encnames[SQLCIPHER_UTF8].enc==SQLCIPHER_UTF8 );
92962       assert( encnames[SQLCIPHER_UTF16LE].enc==SQLCIPHER_UTF16LE );
92963       assert( encnames[SQLCIPHER_UTF16BE].enc==SQLCIPHER_UTF16BE );
92964       sqlcipher3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
92965       sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92966     }else{                        /* "PRAGMA encoding = XXX" */
92967       /* Only change the value of sqlcipher.enc if the database handle is not
92968       ** initialized. If the main database exists, the new sqlcipher.enc value
92969       ** will be overwritten when the schema is next loaded. If it does not
92970       ** already exists, it will be created to use the new encoding value.
92971       */
92972       if( 
92973         !(DbHasProperty(db, 0, DB_SchemaLoaded)) || 
92974         DbHasProperty(db, 0, DB_Empty) 
92975       ){
92976         for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
92977           if( 0==sqlcipher3StrICmp(zRight, pEnc->zName) ){
92978             ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLCIPHER_UTF16NATIVE;
92979             break;
92980           }
92981         }
92982         if( !pEnc->zName ){
92983           sqlcipher3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
92984         }
92985       }
92986     }
92987   }else
92988 #endif /* SQLCIPHER_OMIT_UTF16 */
92989
92990 #ifndef SQLCIPHER_OMIT_SCHEMA_VERSION_PRAGMAS
92991   /*
92992   **   PRAGMA [database.]schema_version
92993   **   PRAGMA [database.]schema_version = <integer>
92994   **
92995   **   PRAGMA [database.]user_version
92996   **   PRAGMA [database.]user_version = <integer>
92997   **
92998   ** The pragma's schema_version and user_version are used to set or get
92999   ** the value of the schema-version and user-version, respectively. Both
93000   ** the schema-version and the user-version are 32-bit signed integers
93001   ** stored in the database header.
93002   **
93003   ** The schema-cookie is usually only manipulated internally by SQLite. It
93004   ** is incremented by SQLite whenever the database schema is modified (by
93005   ** creating or dropping a table or index). The schema version is used by
93006   ** SQLite each time a query is executed to ensure that the internal cache
93007   ** of the schema used when compiling the SQL query matches the schema of
93008   ** the database against which the compiled query is actually executed.
93009   ** Subverting this mechanism by using "PRAGMA schema_version" to modify
93010   ** the schema-version is potentially dangerous and may lead to program
93011   ** crashes or database corruption. Use with caution!
93012   **
93013   ** The user-version is not used internally by SQLite. It may be used by
93014   ** applications for any purpose.
93015   */
93016   if( sqlcipher3StrICmp(zLeft, "schema_version")==0 
93017    || sqlcipher3StrICmp(zLeft, "user_version")==0 
93018    || sqlcipher3StrICmp(zLeft, "freelist_count")==0 
93019   ){
93020     int iCookie;   /* Cookie index. 1 for schema-cookie, 6 for user-cookie. */
93021     sqlcipher3VdbeUsesBtree(v, iDb);
93022     switch( zLeft[0] ){
93023       case 'f': case 'F':
93024         iCookie = BTREE_FREE_PAGE_COUNT;
93025         break;
93026       case 's': case 'S':
93027         iCookie = BTREE_SCHEMA_VERSION;
93028         break;
93029       default:
93030         iCookie = BTREE_USER_VERSION;
93031         break;
93032     }
93033
93034     if( zRight && iCookie!=BTREE_FREE_PAGE_COUNT ){
93035       /* Write the specified cookie value */
93036       static const VdbeOpList setCookie[] = {
93037         { OP_Transaction,    0,  1,  0},    /* 0 */
93038         { OP_Integer,        0,  1,  0},    /* 1 */
93039         { OP_SetCookie,      0,  0,  1},    /* 2 */
93040       };
93041       int addr = sqlcipher3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
93042       sqlcipher3VdbeChangeP1(v, addr, iDb);
93043       sqlcipher3VdbeChangeP1(v, addr+1, sqlcipher3Atoi(zRight));
93044       sqlcipher3VdbeChangeP1(v, addr+2, iDb);
93045       sqlcipher3VdbeChangeP2(v, addr+2, iCookie);
93046     }else{
93047       /* Read the specified cookie value */
93048       static const VdbeOpList readCookie[] = {
93049         { OP_Transaction,     0,  0,  0},    /* 0 */
93050         { OP_ReadCookie,      0,  1,  0},    /* 1 */
93051         { OP_ResultRow,       1,  1,  0}
93052       };
93053       int addr = sqlcipher3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
93054       sqlcipher3VdbeChangeP1(v, addr, iDb);
93055       sqlcipher3VdbeChangeP1(v, addr+1, iDb);
93056       sqlcipher3VdbeChangeP3(v, addr+1, iCookie);
93057       sqlcipher3VdbeSetNumCols(v, 1);
93058       sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLCIPHER_TRANSIENT);
93059     }
93060   }else
93061 #endif /* SQLCIPHER_OMIT_SCHEMA_VERSION_PRAGMAS */
93062
93063 #ifndef SQLCIPHER_OMIT_COMPILEOPTION_DIAGS
93064   /*
93065   **   PRAGMA compile_options
93066   **
93067   ** Return the names of all compile-time options used in this build,
93068   ** one option per row.
93069   */
93070   if( sqlcipher3StrICmp(zLeft, "compile_options")==0 ){
93071     int i = 0;
93072     const char *zOpt;
93073     sqlcipher3VdbeSetNumCols(v, 1);
93074     pParse->nMem = 1;
93075     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "compile_option", SQLCIPHER_STATIC);
93076     while( (zOpt = sqlcipher3_compileoption_get(i++))!=0 ){
93077       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 1, 0, zOpt, 0);
93078       sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 1);
93079     }
93080   }else
93081 #endif /* SQLCIPHER_OMIT_COMPILEOPTION_DIAGS */
93082
93083 #ifndef SQLCIPHER_OMIT_WAL
93084   /*
93085   **   PRAGMA [database.]wal_checkpoint = passive|full|restart
93086   **
93087   ** Checkpoint the database.
93088   */
93089   if( sqlcipher3StrICmp(zLeft, "wal_checkpoint")==0 ){
93090     int iBt = (pId2->z?iDb:SQLCIPHER_MAX_ATTACHED);
93091     int eMode = SQLCIPHER_CHECKPOINT_PASSIVE;
93092     if( zRight ){
93093       if( sqlcipher3StrICmp(zRight, "full")==0 ){
93094         eMode = SQLCIPHER_CHECKPOINT_FULL;
93095       }else if( sqlcipher3StrICmp(zRight, "restart")==0 ){
93096         eMode = SQLCIPHER_CHECKPOINT_RESTART;
93097       }
93098     }
93099     if( sqlcipher3ReadSchema(pParse) ) goto pragma_out;
93100     sqlcipher3VdbeSetNumCols(v, 3);
93101     pParse->nMem = 3;
93102     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "busy", SQLCIPHER_STATIC);
93103     sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLCIPHER_STATIC);
93104     sqlcipher3VdbeSetColName(v, 2, COLNAME_NAME, "checkpointed", SQLCIPHER_STATIC);
93105
93106     sqlcipher3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
93107     sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 3);
93108   }else
93109
93110   /*
93111   **   PRAGMA wal_autocheckpoint
93112   **   PRAGMA wal_autocheckpoint = N
93113   **
93114   ** Configure a database connection to automatically checkpoint a database
93115   ** after accumulating N frames in the log. Or query for the current value
93116   ** of N.
93117   */
93118   if( sqlcipher3StrICmp(zLeft, "wal_autocheckpoint")==0 ){
93119     if( zRight ){
93120       sqlcipher3_wal_autocheckpoint(db, sqlcipher3Atoi(zRight));
93121     }
93122     returnSingleInt(pParse, "wal_autocheckpoint", 
93123        db->xWalCallback==sqlcipher3WalDefaultHook ? 
93124            SQLCIPHER_PTR_TO_INT(db->pWalArg) : 0);
93125   }else
93126 #endif
93127
93128 #if defined(SQLCIPHER_DEBUG) || defined(SQLCIPHER_TEST)
93129   /*
93130   ** Report the current state of file logs for all databases
93131   */
93132   if( sqlcipher3StrICmp(zLeft, "lock_status")==0 ){
93133     static const char *const azLockName[] = {
93134       "unlocked", "shared", "reserved", "pending", "exclusive"
93135     };
93136     int i;
93137     sqlcipher3VdbeSetNumCols(v, 2);
93138     pParse->nMem = 2;
93139     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "database", SQLCIPHER_STATIC);
93140     sqlcipher3VdbeSetColName(v, 1, COLNAME_NAME, "status", SQLCIPHER_STATIC);
93141     for(i=0; i<db->nDb; i++){
93142       Btree *pBt;
93143       Pager *pPager;
93144       const char *zState = "unknown";
93145       int j;
93146       if( db->aDb[i].zName==0 ) continue;
93147       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
93148       pBt = db->aDb[i].pBt;
93149       if( pBt==0 || (pPager = sqlcipher3BtreePager(pBt))==0 ){
93150         zState = "closed";
93151       }else if( sqlcipher3_file_control(db, i ? db->aDb[i].zName : 0, 
93152                                      SQLCIPHER_FCNTL_LOCKSTATE, &j)==SQLCIPHER_OK ){
93153          zState = azLockName[j];
93154       }
93155       sqlcipher3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
93156       sqlcipher3VdbeAddOp2(v, OP_ResultRow, 1, 2);
93157     }
93158
93159   }else
93160 #endif
93161
93162 #ifdef SQLCIPHER_HAS_CODEC
93163   if( sqlcipher3StrICmp(zLeft, "key")==0 && zRight ){
93164     sqlcipher3_key(db, zRight, sqlcipher3Strlen30(zRight));
93165   }else
93166   if( sqlcipher3StrICmp(zLeft, "rekey")==0 && zRight ){
93167     sqlcipher3_rekey(db, zRight, sqlcipher3Strlen30(zRight));
93168   }else
93169   if( zRight && (sqlcipher3StrICmp(zLeft, "hexkey")==0 ||
93170                  sqlcipher3StrICmp(zLeft, "hexrekey")==0) ){
93171     int i, h1, h2;
93172     char zKey[40];
93173     for(i=0; (h1 = zRight[i])!=0 && (h2 = zRight[i+1])!=0; i+=2){
93174       h1 += 9*(1&(h1>>6));
93175       h2 += 9*(1&(h2>>6));
93176       zKey[i/2] = (h2 & 0x0f) | ((h1 & 0xf)<<4);
93177     }
93178     if( (zLeft[3] & 0xf)==0xb ){
93179       sqlcipher3_key(db, zKey, i/2);
93180     }else{
93181       sqlcipher3_rekey(db, zKey, i/2);
93182     }
93183   }else
93184 /** BEGIN CRYPTO **/
93185   if( sqlcipher3StrICmp(zLeft, "cipher")==0 && zRight ){
93186     extern int codec_set_cipher_name(sqlcipher3*, int, const char *, int);
93187     codec_set_cipher_name(db, iDb, zRight, 2); // change cipher for both
93188   }else
93189   if( sqlcipher3StrICmp(zLeft, "rekey_cipher")==0 && zRight ){
93190     extern int codec_set_cipher_name(sqlcipher3*, int, const char *, int); 
93191     codec_set_cipher_name(db, iDb, zRight, 1); // change write cipher only
93192   }else
93193   if( sqlcipher3StrICmp(zLeft, "kdf_iter")==0 && zRight ){
93194     extern int codec_set_kdf_iter(sqlcipher3*, int, int, int);
93195     codec_set_kdf_iter(db, iDb, atoi(zRight), 2); // change of RW PBKDF2 iteration
93196   }else
93197   if( sqlcipher3StrICmp(zLeft, "fast_kdf_iter")==0 && zRight ){
93198     extern int codec_set_fast_kdf_iter(sqlcipher3*, int, int, int);
93199     codec_set_fast_kdf_iter(db, iDb, atoi(zRight), 2); // change of RW PBKDF2 iteration
93200   }else
93201   if( sqlcipher3StrICmp(zLeft, "rekey_kdf_iter")==0 && zRight ){
93202     extern int codec_set_kdf_iter(sqlcipher3*, int, int, int); 
93203     codec_set_kdf_iter(db, iDb, atoi(zRight), 1); // change # if W iterations
93204   }else
93205   if( sqlcipher3StrICmp(zLeft,"cipher_page_size")==0 ){
93206     extern int codec_set_page_size(sqlcipher3*, int, int); 
93207     codec_set_page_size(db, iDb, atoi(zRight)); // change page size
93208   }else
93209   if( sqlcipher3StrICmp(zLeft,"cipher_use_hmac")==0 ){
93210     extern int codec_set_use_hmac(sqlcipher3*, int, int);
93211     if(sqlcipher3GetBoolean(zRight)) {
93212       codec_set_use_hmac(db, iDb, 1);
93213     } else {
93214       codec_set_use_hmac(db, iDb, 0);
93215     }
93216   }else
93217 /** END CRYPTO **/
93218 #endif
93219 #if defined(SQLCIPHER_HAS_CODEC) || defined(SQLCIPHER_ENABLE_CEROD)
93220   if( sqlcipher3StrICmp(zLeft, "activate_extensions")==0 ){
93221 #ifdef SQLCIPHER_HAS_CODEC
93222     if( sqlcipher3StrNICmp(zRight, "see-", 4)==0 ){
93223       sqlcipher3_activate_see(&zRight[4]);
93224     }
93225 #endif
93226 #ifdef SQLCIPHER_ENABLE_CEROD
93227     if( sqlcipher3StrNICmp(zRight, "cerod-", 6)==0 ){
93228       sqlcipher3_activate_cerod(&zRight[6]);
93229     }
93230 #endif
93231   }else
93232 #endif
93233
93234  
93235   {/* Empty ELSE clause */}
93236
93237   /*
93238   ** Reset the safety level, in case the fullfsync flag or synchronous
93239   ** setting changed.
93240   */
93241 #ifndef SQLCIPHER_OMIT_PAGER_PRAGMAS
93242   if( db->autoCommit ){
93243     sqlcipher3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
93244                (db->flags&SQLCIPHER_FullFSync)!=0,
93245                (db->flags&SQLCIPHER_CkptFullFSync)!=0);
93246   }
93247 #endif
93248 pragma_out:
93249   sqlcipher3DbFree(db, zLeft);
93250   sqlcipher3DbFree(db, zRight);
93251 }
93252
93253 #endif /* SQLCIPHER_OMIT_PRAGMA */
93254
93255 /************** End of pragma.c **********************************************/
93256 /************** Begin file prepare.c *****************************************/
93257 /*
93258 ** 2005 May 25
93259 **
93260 ** The author disclaims copyright to this source code.  In place of
93261 ** a legal notice, here is a blessing:
93262 **
93263 **    May you do good and not evil.
93264 **    May you find forgiveness for yourself and forgive others.
93265 **    May you share freely, never taking more than you give.
93266 **
93267 *************************************************************************
93268 ** This file contains the implementation of the sqlcipher3_prepare()
93269 ** interface, and routines that contribute to loading the database schema
93270 ** from disk.
93271 */
93272
93273 /*
93274 ** Fill the InitData structure with an error message that indicates
93275 ** that the database is corrupt.
93276 */
93277 static void corruptSchema(
93278   InitData *pData,     /* Initialization context */
93279   const char *zObj,    /* Object being parsed at the point of error */
93280   const char *zExtra   /* Error information */
93281 ){
93282   sqlcipher3 *db = pData->db;
93283   if( !db->mallocFailed && (db->flags & SQLCIPHER_RecoveryMode)==0 ){
93284     if( zObj==0 ) zObj = "?";
93285     sqlcipher3SetString(pData->pzErrMsg, db,
93286       "malformed database schema (%s)", zObj);
93287     if( zExtra ){
93288       *pData->pzErrMsg = sqlcipher3MAppendf(db, *pData->pzErrMsg, 
93289                                  "%s - %s", *pData->pzErrMsg, zExtra);
93290     }
93291   }
93292   pData->rc = db->mallocFailed ? SQLCIPHER_NOMEM : SQLCIPHER_CORRUPT_BKPT;
93293 }
93294
93295 /*
93296 ** This is the callback routine for the code that initializes the
93297 ** database.  See sqlcipher3Init() below for additional information.
93298 ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
93299 **
93300 ** Each callback contains the following information:
93301 **
93302 **     argv[0] = name of thing being created
93303 **     argv[1] = root page number for table or index. 0 for trigger or view.
93304 **     argv[2] = SQL text for the CREATE statement.
93305 **
93306 */
93307 SQLCIPHER_PRIVATE int sqlcipher3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
93308   InitData *pData = (InitData*)pInit;
93309   sqlcipher3 *db = pData->db;
93310   int iDb = pData->iDb;
93311
93312   assert( argc==3 );
93313   UNUSED_PARAMETER2(NotUsed, argc);
93314   assert( sqlcipher3_mutex_held(db->mutex) );
93315   DbClearProperty(db, iDb, DB_Empty);
93316   if( db->mallocFailed ){
93317     corruptSchema(pData, argv[0], 0);
93318     return 1;
93319   }
93320
93321   assert( iDb>=0 && iDb<db->nDb );
93322   if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
93323   if( argv[1]==0 ){
93324     corruptSchema(pData, argv[0], 0);
93325   }else if( argv[2] && argv[2][0] ){
93326     /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
93327     ** But because db->init.busy is set to 1, no VDBE code is generated
93328     ** or executed.  All the parser does is build the internal data
93329     ** structures that describe the table, index, or view.
93330     */
93331     int rc;
93332     sqlcipher3_stmt *pStmt;
93333     TESTONLY(int rcp);            /* Return code from sqlcipher3_prepare() */
93334
93335     assert( db->init.busy );
93336     db->init.iDb = iDb;
93337     db->init.newTnum = sqlcipher3Atoi(argv[1]);
93338     db->init.orphanTrigger = 0;
93339     TESTONLY(rcp = ) sqlcipher3_prepare(db, argv[2], -1, &pStmt, 0);
93340     rc = db->errCode;
93341     assert( (rc&0xFF)==(rcp&0xFF) );
93342     db->init.iDb = 0;
93343     if( SQLCIPHER_OK!=rc ){
93344       if( db->init.orphanTrigger ){
93345         assert( iDb==1 );
93346       }else{
93347         pData->rc = rc;
93348         if( rc==SQLCIPHER_NOMEM ){
93349           db->mallocFailed = 1;
93350         }else if( rc!=SQLCIPHER_INTERRUPT && (rc&0xFF)!=SQLCIPHER_LOCKED ){
93351           corruptSchema(pData, argv[0], sqlcipher3_errmsg(db));
93352         }
93353       }
93354     }
93355     sqlcipher3_finalize(pStmt);
93356   }else if( argv[0]==0 ){
93357     corruptSchema(pData, 0, 0);
93358   }else{
93359     /* If the SQL column is blank it means this is an index that
93360     ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
93361     ** constraint for a CREATE TABLE.  The index should have already
93362     ** been created when we processed the CREATE TABLE.  All we have
93363     ** to do here is record the root page number for that index.
93364     */
93365     Index *pIndex;
93366     pIndex = sqlcipher3FindIndex(db, argv[0], db->aDb[iDb].zName);
93367     if( pIndex==0 ){
93368       /* This can occur if there exists an index on a TEMP table which
93369       ** has the same name as another index on a permanent index.  Since
93370       ** the permanent table is hidden by the TEMP table, we can also
93371       ** safely ignore the index on the permanent table.
93372       */
93373       /* Do Nothing */;
93374     }else if( sqlcipher3GetInt32(argv[1], &pIndex->tnum)==0 ){
93375       corruptSchema(pData, argv[0], "invalid rootpage");
93376     }
93377   }
93378   return 0;
93379 }
93380
93381 /*
93382 ** Attempt to read the database schema and initialize internal
93383 ** data structures for a single database file.  The index of the
93384 ** database file is given by iDb.  iDb==0 is used for the main
93385 ** database.  iDb==1 should never be used.  iDb>=2 is used for
93386 ** auxiliary databases.  Return one of the SQLCIPHER_ error codes to
93387 ** indicate success or failure.
93388 */
93389 static int sqlcipher3InitOne(sqlcipher3 *db, int iDb, char **pzErrMsg){
93390   int rc;
93391   int i;
93392   int size;
93393   Table *pTab;
93394   Db *pDb;
93395   char const *azArg[4];
93396   int meta[5];
93397   InitData initData;
93398   char const *zMasterSchema;
93399   char const *zMasterName;
93400   int openedTransaction = 0;
93401
93402   /*
93403   ** The master database table has a structure like this
93404   */
93405   static const char master_schema[] = 
93406      "CREATE TABLE sqlcipher_master(\n"
93407      "  type text,\n"
93408      "  name text,\n"
93409      "  tbl_name text,\n"
93410      "  rootpage integer,\n"
93411      "  sql text\n"
93412      ")"
93413   ;
93414 #ifndef SQLCIPHER_OMIT_TEMPDB
93415   static const char temp_master_schema[] = 
93416      "CREATE TEMP TABLE sqlcipher_temp_master(\n"
93417      "  type text,\n"
93418      "  name text,\n"
93419      "  tbl_name text,\n"
93420      "  rootpage integer,\n"
93421      "  sql text\n"
93422      ")"
93423   ;
93424 #else
93425   #define temp_master_schema 0
93426 #endif
93427
93428   assert( iDb>=0 && iDb<db->nDb );
93429   assert( db->aDb[iDb].pSchema );
93430   assert( sqlcipher3_mutex_held(db->mutex) );
93431   assert( iDb==1 || sqlcipher3BtreeHoldsMutex(db->aDb[iDb].pBt) );
93432
93433   /* zMasterSchema and zInitScript are set to point at the master schema
93434   ** and initialisation script appropriate for the database being
93435   ** initialised. zMasterName is the name of the master table.
93436   */
93437   if( !OMIT_TEMPDB && iDb==1 ){
93438     zMasterSchema = temp_master_schema;
93439   }else{
93440     zMasterSchema = master_schema;
93441   }
93442   zMasterName = SCHEMA_TABLE(iDb);
93443
93444   /* Construct the schema tables.  */
93445   azArg[0] = zMasterName;
93446   azArg[1] = "1";
93447   azArg[2] = zMasterSchema;
93448   azArg[3] = 0;
93449   initData.db = db;
93450   initData.iDb = iDb;
93451   initData.rc = SQLCIPHER_OK;
93452   initData.pzErrMsg = pzErrMsg;
93453   sqlcipher3InitCallback(&initData, 3, (char **)azArg, 0);
93454   if( initData.rc ){
93455     rc = initData.rc;
93456     goto error_out;
93457   }
93458   pTab = sqlcipher3FindTable(db, zMasterName, db->aDb[iDb].zName);
93459   if( ALWAYS(pTab) ){
93460     pTab->tabFlags |= TF_Readonly;
93461   }
93462
93463   /* Create a cursor to hold the database open
93464   */
93465   pDb = &db->aDb[iDb];
93466   if( pDb->pBt==0 ){
93467     if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){
93468       DbSetProperty(db, 1, DB_SchemaLoaded);
93469     }
93470     return SQLCIPHER_OK;
93471   }
93472
93473   /* If there is not already a read-only (or read-write) transaction opened
93474   ** on the b-tree database, open one now. If a transaction is opened, it 
93475   ** will be closed before this function returns.  */
93476   sqlcipher3BtreeEnter(pDb->pBt);
93477   if( !sqlcipher3BtreeIsInReadTrans(pDb->pBt) ){
93478     rc = sqlcipher3BtreeBeginTrans(pDb->pBt, 0);
93479     if( rc!=SQLCIPHER_OK ){
93480       sqlcipher3SetString(pzErrMsg, db, "%s", sqlcipher3ErrStr(rc));
93481       goto initone_error_out;
93482     }
93483     openedTransaction = 1;
93484   }
93485
93486   /* Get the database meta information.
93487   **
93488   ** Meta values are as follows:
93489   **    meta[0]   Schema cookie.  Changes with each schema change.
93490   **    meta[1]   File format of schema layer.
93491   **    meta[2]   Size of the page cache.
93492   **    meta[3]   Largest rootpage (auto/incr_vacuum mode)
93493   **    meta[4]   Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
93494   **    meta[5]   User version
93495   **    meta[6]   Incremental vacuum mode
93496   **    meta[7]   unused
93497   **    meta[8]   unused
93498   **    meta[9]   unused
93499   **
93500   ** Note: The #defined SQLCIPHER_UTF* symbols in sqlcipherInt.h correspond to
93501   ** the possible values of meta[4].
93502   */
93503   for(i=0; i<ArraySize(meta); i++){
93504     sqlcipher3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
93505   }
93506   pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
93507
93508   /* If opening a non-empty database, check the text encoding. For the
93509   ** main database, set sqlcipher3.enc to the encoding of the main database.
93510   ** For an attached db, it is an error if the encoding is not the same
93511   ** as sqlcipher3.enc.
93512   */
93513   if( meta[BTREE_TEXT_ENCODING-1] ){  /* text encoding */
93514     if( iDb==0 ){
93515       u8 encoding;
93516       /* If opening the main database, set ENC(db). */
93517       encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
93518       if( encoding==0 ) encoding = SQLCIPHER_UTF8;
93519       ENC(db) = encoding;
93520       db->pDfltColl = sqlcipher3FindCollSeq(db, SQLCIPHER_UTF8, "BINARY", 0);
93521     }else{
93522       /* If opening an attached database, the encoding much match ENC(db) */
93523       if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){
93524         sqlcipher3SetString(pzErrMsg, db, "attached databases must use the same"
93525             " text encoding as main database");
93526         rc = SQLCIPHER_ERROR;
93527         goto initone_error_out;
93528       }
93529     }
93530   }else{
93531     DbSetProperty(db, iDb, DB_Empty);
93532   }
93533   pDb->pSchema->enc = ENC(db);
93534
93535   if( pDb->pSchema->cache_size==0 ){
93536     size = sqlcipher3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
93537     if( size==0 ){ size = SQLCIPHER_DEFAULT_CACHE_SIZE; }
93538     pDb->pSchema->cache_size = size;
93539     sqlcipher3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
93540   }
93541
93542   /*
93543   ** file_format==1    Version 3.0.0.
93544   ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN
93545   ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults
93546   ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants
93547   */
93548   pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
93549   if( pDb->pSchema->file_format==0 ){
93550     pDb->pSchema->file_format = 1;
93551   }
93552   if( pDb->pSchema->file_format>SQLCIPHER_MAX_FILE_FORMAT ){
93553     sqlcipher3SetString(pzErrMsg, db, "unsupported file format");
93554     rc = SQLCIPHER_ERROR;
93555     goto initone_error_out;
93556   }
93557
93558   /* Ticket #2804:  When we open a database in the newer file format,
93559   ** clear the legacy_file_format pragma flag so that a VACUUM will
93560   ** not downgrade the database and thus invalidate any descending
93561   ** indices that the user might have created.
93562   */
93563   if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
93564     db->flags &= ~SQLCIPHER_LegacyFileFmt;
93565   }
93566
93567   /* Read the schema information out of the schema tables
93568   */
93569   assert( db->init.busy );
93570   {
93571     char *zSql;
93572     zSql = sqlcipher3MPrintf(db, 
93573         "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
93574         db->aDb[iDb].zName, zMasterName);
93575 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
93576     {
93577       int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
93578       xAuth = db->xAuth;
93579       db->xAuth = 0;
93580 #endif
93581       rc = sqlcipher3_exec(db, zSql, sqlcipher3InitCallback, &initData, 0);
93582 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
93583       db->xAuth = xAuth;
93584     }
93585 #endif
93586     if( rc==SQLCIPHER_OK ) rc = initData.rc;
93587     sqlcipher3DbFree(db, zSql);
93588 #ifndef SQLCIPHER_OMIT_ANALYZE
93589     if( rc==SQLCIPHER_OK ){
93590       sqlcipher3AnalysisLoad(db, iDb);
93591     }
93592 #endif
93593   }
93594   if( db->mallocFailed ){
93595     rc = SQLCIPHER_NOMEM;
93596     sqlcipher3ResetInternalSchema(db, -1);
93597   }
93598   if( rc==SQLCIPHER_OK || (db->flags&SQLCIPHER_RecoveryMode)){
93599     /* Black magic: If the SQLCIPHER_RecoveryMode flag is set, then consider
93600     ** the schema loaded, even if errors occurred. In this situation the 
93601     ** current sqlcipher3_prepare() operation will fail, but the following one
93602     ** will attempt to compile the supplied statement against whatever subset
93603     ** of the schema was loaded before the error occurred. The primary
93604     ** purpose of this is to allow access to the sqlcipher_master table
93605     ** even when its contents have been corrupted.
93606     */
93607     DbSetProperty(db, iDb, DB_SchemaLoaded);
93608     rc = SQLCIPHER_OK;
93609   }
93610
93611   /* Jump here for an error that occurs after successfully allocating
93612   ** curMain and calling sqlcipher3BtreeEnter(). For an error that occurs
93613   ** before that point, jump to error_out.
93614   */
93615 initone_error_out:
93616   if( openedTransaction ){
93617     sqlcipher3BtreeCommit(pDb->pBt);
93618   }
93619   sqlcipher3BtreeLeave(pDb->pBt);
93620
93621 error_out:
93622   if( rc==SQLCIPHER_NOMEM || rc==SQLCIPHER_IOERR_NOMEM ){
93623     db->mallocFailed = 1;
93624   }
93625   return rc;
93626 }
93627
93628 /*
93629 ** Initialize all database files - the main database file, the file
93630 ** used to store temporary tables, and any additional database files
93631 ** created using ATTACH statements.  Return a success code.  If an
93632 ** error occurs, write an error message into *pzErrMsg.
93633 **
93634 ** After a database is initialized, the DB_SchemaLoaded bit is set
93635 ** bit is set in the flags field of the Db structure. If the database
93636 ** file was of zero-length, then the DB_Empty flag is also set.
93637 */
93638 SQLCIPHER_PRIVATE int sqlcipher3Init(sqlcipher3 *db, char **pzErrMsg){
93639   int i, rc;
93640   int commit_internal = !(db->flags&SQLCIPHER_InternChanges);
93641   
93642   assert( sqlcipher3_mutex_held(db->mutex) );
93643   rc = SQLCIPHER_OK;
93644   db->init.busy = 1;
93645   for(i=0; rc==SQLCIPHER_OK && i<db->nDb; i++){
93646     if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
93647     rc = sqlcipher3InitOne(db, i, pzErrMsg);
93648     if( rc ){
93649       sqlcipher3ResetInternalSchema(db, i);
93650     }
93651   }
93652
93653   /* Once all the other databases have been initialised, load the schema
93654   ** for the TEMP database. This is loaded last, as the TEMP database
93655   ** schema may contain references to objects in other databases.
93656   */
93657 #ifndef SQLCIPHER_OMIT_TEMPDB
93658   if( rc==SQLCIPHER_OK && ALWAYS(db->nDb>1)
93659                     && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
93660     rc = sqlcipher3InitOne(db, 1, pzErrMsg);
93661     if( rc ){
93662       sqlcipher3ResetInternalSchema(db, 1);
93663     }
93664   }
93665 #endif
93666
93667   db->init.busy = 0;
93668   if( rc==SQLCIPHER_OK && commit_internal ){
93669     sqlcipher3CommitInternalChanges(db);
93670   }
93671
93672   return rc; 
93673 }
93674
93675 /*
93676 ** This routine is a no-op if the database schema is already initialised.
93677 ** Otherwise, the schema is loaded. An error code is returned.
93678 */
93679 SQLCIPHER_PRIVATE int sqlcipher3ReadSchema(Parse *pParse){
93680   int rc = SQLCIPHER_OK;
93681   sqlcipher3 *db = pParse->db;
93682   assert( sqlcipher3_mutex_held(db->mutex) );
93683   if( !db->init.busy ){
93684     rc = sqlcipher3Init(db, &pParse->zErrMsg);
93685   }
93686   if( rc!=SQLCIPHER_OK ){
93687     pParse->rc = rc;
93688     pParse->nErr++;
93689   }
93690   return rc;
93691 }
93692
93693
93694 /*
93695 ** Check schema cookies in all databases.  If any cookie is out
93696 ** of date set pParse->rc to SQLCIPHER_SCHEMA.  If all schema cookies
93697 ** make no changes to pParse->rc.
93698 */
93699 static void schemaIsValid(Parse *pParse){
93700   sqlcipher3 *db = pParse->db;
93701   int iDb;
93702   int rc;
93703   int cookie;
93704
93705   assert( pParse->checkSchema );
93706   assert( sqlcipher3_mutex_held(db->mutex) );
93707   for(iDb=0; iDb<db->nDb; iDb++){
93708     int openedTransaction = 0;         /* True if a transaction is opened */
93709     Btree *pBt = db->aDb[iDb].pBt;     /* Btree database to read cookie from */
93710     if( pBt==0 ) continue;
93711
93712     /* If there is not already a read-only (or read-write) transaction opened
93713     ** on the b-tree database, open one now. If a transaction is opened, it 
93714     ** will be closed immediately after reading the meta-value. */
93715     if( !sqlcipher3BtreeIsInReadTrans(pBt) ){
93716       rc = sqlcipher3BtreeBeginTrans(pBt, 0);
93717       if( rc==SQLCIPHER_NOMEM || rc==SQLCIPHER_IOERR_NOMEM ){
93718         db->mallocFailed = 1;
93719       }
93720       if( rc!=SQLCIPHER_OK ) return;
93721       openedTransaction = 1;
93722     }
93723
93724     /* Read the schema cookie from the database. If it does not match the 
93725     ** value stored as part of the in-memory schema representation,
93726     ** set Parse.rc to SQLCIPHER_SCHEMA. */
93727     sqlcipher3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
93728     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
93729     if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
93730       sqlcipher3ResetInternalSchema(db, iDb);
93731       pParse->rc = SQLCIPHER_SCHEMA;
93732     }
93733
93734     /* Close the transaction, if one was opened. */
93735     if( openedTransaction ){
93736       sqlcipher3BtreeCommit(pBt);
93737     }
93738   }
93739 }
93740
93741 /*
93742 ** Convert a schema pointer into the iDb index that indicates
93743 ** which database file in db->aDb[] the schema refers to.
93744 **
93745 ** If the same database is attached more than once, the first
93746 ** attached database is returned.
93747 */
93748 SQLCIPHER_PRIVATE int sqlcipher3SchemaToIndex(sqlcipher3 *db, Schema *pSchema){
93749   int i = -1000000;
93750
93751   /* If pSchema is NULL, then return -1000000. This happens when code in 
93752   ** expr.c is trying to resolve a reference to a transient table (i.e. one
93753   ** created by a sub-select). In this case the return value of this 
93754   ** function should never be used.
93755   **
93756   ** We return -1000000 instead of the more usual -1 simply because using
93757   ** -1000000 as the incorrect index into db->aDb[] is much 
93758   ** more likely to cause a segfault than -1 (of course there are assert()
93759   ** statements too, but it never hurts to play the odds).
93760   */
93761   assert( sqlcipher3_mutex_held(db->mutex) );
93762   if( pSchema ){
93763     for(i=0; ALWAYS(i<db->nDb); i++){
93764       if( db->aDb[i].pSchema==pSchema ){
93765         break;
93766       }
93767     }
93768     assert( i>=0 && i<db->nDb );
93769   }
93770   return i;
93771 }
93772
93773 /*
93774 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
93775 */
93776 static int sqlcipher3Prepare(
93777   sqlcipher3 *db,              /* Database handle. */
93778   const char *zSql,         /* UTF-8 encoded SQL statement. */
93779   int nBytes,               /* Length of zSql in bytes. */
93780   int saveSqlFlag,          /* True to copy SQL text into the sqlcipher3_stmt */
93781   Vdbe *pReprepare,         /* VM being reprepared */
93782   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
93783   const char **pzTail       /* OUT: End of parsed string */
93784 ){
93785   Parse *pParse;            /* Parsing context */
93786   char *zErrMsg = 0;        /* Error message */
93787   int rc = SQLCIPHER_OK;       /* Result code */
93788   int i;                    /* Loop counter */
93789
93790   /* Allocate the parsing context */
93791   pParse = sqlcipher3StackAllocZero(db, sizeof(*pParse));
93792   if( pParse==0 ){
93793     rc = SQLCIPHER_NOMEM;
93794     goto end_prepare;
93795   }
93796   pParse->pReprepare = pReprepare;
93797   assert( ppStmt && *ppStmt==0 );
93798   assert( !db->mallocFailed );
93799   assert( sqlcipher3_mutex_held(db->mutex) );
93800
93801   /* Check to verify that it is possible to get a read lock on all
93802   ** database schemas.  The inability to get a read lock indicates that
93803   ** some other database connection is holding a write-lock, which in
93804   ** turn means that the other connection has made uncommitted changes
93805   ** to the schema.
93806   **
93807   ** Were we to proceed and prepare the statement against the uncommitted
93808   ** schema changes and if those schema changes are subsequently rolled
93809   ** back and different changes are made in their place, then when this
93810   ** prepared statement goes to run the schema cookie would fail to detect
93811   ** the schema change.  Disaster would follow.
93812   **
93813   ** This thread is currently holding mutexes on all Btrees (because
93814   ** of the sqlcipher3BtreeEnterAll() in sqlcipher3LockAndPrepare()) so it
93815   ** is not possible for another thread to start a new schema change
93816   ** while this routine is running.  Hence, we do not need to hold 
93817   ** locks on the schema, we just need to make sure nobody else is 
93818   ** holding them.
93819   **
93820   ** Note that setting READ_UNCOMMITTED overrides most lock detection,
93821   ** but it does *not* override schema lock detection, so this all still
93822   ** works even if READ_UNCOMMITTED is set.
93823   */
93824   for(i=0; i<db->nDb; i++) {
93825     Btree *pBt = db->aDb[i].pBt;
93826     if( pBt ){
93827       assert( sqlcipher3BtreeHoldsMutex(pBt) );
93828       rc = sqlcipher3BtreeSchemaLocked(pBt);
93829       if( rc ){
93830         const char *zDb = db->aDb[i].zName;
93831         sqlcipher3Error(db, rc, "database schema is locked: %s", zDb);
93832         testcase( db->flags & SQLCIPHER_ReadUncommitted );
93833         goto end_prepare;
93834       }
93835     }
93836   }
93837
93838   sqlcipher3VtabUnlockList(db);
93839
93840   pParse->db = db;
93841   pParse->nQueryLoop = (double)1;
93842   if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
93843     char *zSqlCopy;
93844     int mxLen = db->aLimit[SQLCIPHER_LIMIT_SQL_LENGTH];
93845     testcase( nBytes==mxLen );
93846     testcase( nBytes==mxLen+1 );
93847     if( nBytes>mxLen ){
93848       sqlcipher3Error(db, SQLCIPHER_TOOBIG, "statement too long");
93849       rc = sqlcipher3ApiExit(db, SQLCIPHER_TOOBIG);
93850       goto end_prepare;
93851     }
93852     zSqlCopy = sqlcipher3DbStrNDup(db, zSql, nBytes);
93853     if( zSqlCopy ){
93854       sqlcipher3RunParser(pParse, zSqlCopy, &zErrMsg);
93855       sqlcipher3DbFree(db, zSqlCopy);
93856       pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
93857     }else{
93858       pParse->zTail = &zSql[nBytes];
93859     }
93860   }else{
93861     sqlcipher3RunParser(pParse, zSql, &zErrMsg);
93862   }
93863   assert( 1==(int)pParse->nQueryLoop );
93864
93865   if( db->mallocFailed ){
93866     pParse->rc = SQLCIPHER_NOMEM;
93867   }
93868   if( pParse->rc==SQLCIPHER_DONE ) pParse->rc = SQLCIPHER_OK;
93869   if( pParse->checkSchema ){
93870     schemaIsValid(pParse);
93871   }
93872   if( db->mallocFailed ){
93873     pParse->rc = SQLCIPHER_NOMEM;
93874   }
93875   if( pzTail ){
93876     *pzTail = pParse->zTail;
93877   }
93878   rc = pParse->rc;
93879
93880 #ifndef SQLCIPHER_OMIT_EXPLAIN
93881   if( rc==SQLCIPHER_OK && pParse->pVdbe && pParse->explain ){
93882     static const char * const azColName[] = {
93883        "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
93884        "selectid", "order", "from", "detail"
93885     };
93886     int iFirst, mx;
93887     if( pParse->explain==2 ){
93888       sqlcipher3VdbeSetNumCols(pParse->pVdbe, 4);
93889       iFirst = 8;
93890       mx = 12;
93891     }else{
93892       sqlcipher3VdbeSetNumCols(pParse->pVdbe, 8);
93893       iFirst = 0;
93894       mx = 8;
93895     }
93896     for(i=iFirst; i<mx; i++){
93897       sqlcipher3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME,
93898                             azColName[i], SQLCIPHER_STATIC);
93899     }
93900   }
93901 #endif
93902
93903   assert( db->init.busy==0 || saveSqlFlag==0 );
93904   if( db->init.busy==0 ){
93905     Vdbe *pVdbe = pParse->pVdbe;
93906     sqlcipher3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
93907   }
93908   if( pParse->pVdbe && (rc!=SQLCIPHER_OK || db->mallocFailed) ){
93909     sqlcipher3VdbeFinalize(pParse->pVdbe);
93910     assert(!(*ppStmt));
93911   }else{
93912     *ppStmt = (sqlcipher3_stmt*)pParse->pVdbe;
93913   }
93914
93915   if( zErrMsg ){
93916     sqlcipher3Error(db, rc, "%s", zErrMsg);
93917     sqlcipher3DbFree(db, zErrMsg);
93918   }else{
93919     sqlcipher3Error(db, rc, 0);
93920   }
93921
93922   /* Delete any TriggerPrg structures allocated while parsing this statement. */
93923   while( pParse->pTriggerPrg ){
93924     TriggerPrg *pT = pParse->pTriggerPrg;
93925     pParse->pTriggerPrg = pT->pNext;
93926     sqlcipher3DbFree(db, pT);
93927   }
93928
93929 end_prepare:
93930
93931   sqlcipher3StackFree(db, pParse);
93932   rc = sqlcipher3ApiExit(db, rc);
93933   assert( (rc&db->errMask)==rc );
93934   return rc;
93935 }
93936 static int sqlcipher3LockAndPrepare(
93937   sqlcipher3 *db,              /* Database handle. */
93938   const char *zSql,         /* UTF-8 encoded SQL statement. */
93939   int nBytes,               /* Length of zSql in bytes. */
93940   int saveSqlFlag,          /* True to copy SQL text into the sqlcipher3_stmt */
93941   Vdbe *pOld,               /* VM being reprepared */
93942   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
93943   const char **pzTail       /* OUT: End of parsed string */
93944 ){
93945   int rc;
93946   assert( ppStmt!=0 );
93947   *ppStmt = 0;
93948   if( !sqlcipher3SafetyCheckOk(db) ){
93949     return SQLCIPHER_MISUSE_BKPT;
93950   }
93951   sqlcipher3_mutex_enter(db->mutex);
93952   sqlcipher3BtreeEnterAll(db);
93953   rc = sqlcipher3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
93954   if( rc==SQLCIPHER_SCHEMA ){
93955     sqlcipher3_finalize(*ppStmt);
93956     rc = sqlcipher3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
93957   }
93958   sqlcipher3BtreeLeaveAll(db);
93959   sqlcipher3_mutex_leave(db->mutex);
93960   return rc;
93961 }
93962
93963 /*
93964 ** Rerun the compilation of a statement after a schema change.
93965 **
93966 ** If the statement is successfully recompiled, return SQLCIPHER_OK. Otherwise,
93967 ** if the statement cannot be recompiled because another connection has
93968 ** locked the sqlcipher3_master table, return SQLCIPHER_LOCKED. If any other error
93969 ** occurs, return SQLCIPHER_SCHEMA.
93970 */
93971 SQLCIPHER_PRIVATE int sqlcipher3Reprepare(Vdbe *p){
93972   int rc;
93973   sqlcipher3_stmt *pNew;
93974   const char *zSql;
93975   sqlcipher3 *db;
93976
93977   assert( sqlcipher3_mutex_held(sqlcipher3VdbeDb(p)->mutex) );
93978   zSql = sqlcipher3_sql((sqlcipher3_stmt *)p);
93979   assert( zSql!=0 );  /* Reprepare only called for prepare_v2() statements */
93980   db = sqlcipher3VdbeDb(p);
93981   assert( sqlcipher3_mutex_held(db->mutex) );
93982   rc = sqlcipher3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
93983   if( rc ){
93984     if( rc==SQLCIPHER_NOMEM ){
93985       db->mallocFailed = 1;
93986     }
93987     assert( pNew==0 );
93988     return rc;
93989   }else{
93990     assert( pNew!=0 );
93991   }
93992   sqlcipher3VdbeSwap((Vdbe*)pNew, p);
93993   sqlcipher3TransferBindings(pNew, (sqlcipher3_stmt*)p);
93994   sqlcipher3VdbeResetStepResult((Vdbe*)pNew);
93995   sqlcipher3VdbeFinalize((Vdbe*)pNew);
93996   return SQLCIPHER_OK;
93997 }
93998
93999
94000 /*
94001 ** Two versions of the official API.  Legacy and new use.  In the legacy
94002 ** version, the original SQL text is not saved in the prepared statement
94003 ** and so if a schema change occurs, SQLCIPHER_SCHEMA is returned by
94004 ** sqlcipher3_step().  In the new version, the original SQL text is retained
94005 ** and the statement is automatically recompiled if an schema change
94006 ** occurs.
94007 */
94008 SQLCIPHER_API int sqlcipher3_prepare(
94009   sqlcipher3 *db,              /* Database handle. */
94010   const char *zSql,         /* UTF-8 encoded SQL statement. */
94011   int nBytes,               /* Length of zSql in bytes. */
94012   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
94013   const char **pzTail       /* OUT: End of parsed string */
94014 ){
94015   int rc;
94016   rc = sqlcipher3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
94017   assert( rc==SQLCIPHER_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
94018   return rc;
94019 }
94020 SQLCIPHER_API int sqlcipher3_prepare_v2(
94021   sqlcipher3 *db,              /* Database handle. */
94022   const char *zSql,         /* UTF-8 encoded SQL statement. */
94023   int nBytes,               /* Length of zSql in bytes. */
94024   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
94025   const char **pzTail       /* OUT: End of parsed string */
94026 ){
94027   int rc;
94028   rc = sqlcipher3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
94029   assert( rc==SQLCIPHER_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
94030   return rc;
94031 }
94032
94033
94034 #ifndef SQLCIPHER_OMIT_UTF16
94035 /*
94036 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
94037 */
94038 static int sqlcipher3Prepare16(
94039   sqlcipher3 *db,              /* Database handle. */ 
94040   const void *zSql,         /* UTF-16 encoded SQL statement. */
94041   int nBytes,               /* Length of zSql in bytes. */
94042   int saveSqlFlag,          /* True to save SQL text into the sqlcipher3_stmt */
94043   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
94044   const void **pzTail       /* OUT: End of parsed string */
94045 ){
94046   /* This function currently works by first transforming the UTF-16
94047   ** encoded string to UTF-8, then invoking sqlcipher3_prepare(). The
94048   ** tricky bit is figuring out the pointer to return in *pzTail.
94049   */
94050   char *zSql8;
94051   const char *zTail8 = 0;
94052   int rc = SQLCIPHER_OK;
94053
94054   assert( ppStmt );
94055   *ppStmt = 0;
94056   if( !sqlcipher3SafetyCheckOk(db) ){
94057     return SQLCIPHER_MISUSE_BKPT;
94058   }
94059   sqlcipher3_mutex_enter(db->mutex);
94060   zSql8 = sqlcipher3Utf16to8(db, zSql, nBytes, SQLCIPHER_UTF16NATIVE);
94061   if( zSql8 ){
94062     rc = sqlcipher3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8);
94063   }
94064
94065   if( zTail8 && pzTail ){
94066     /* If sqlcipher3_prepare returns a tail pointer, we calculate the
94067     ** equivalent pointer into the UTF-16 string by counting the unicode
94068     ** characters between zSql8 and zTail8, and then returning a pointer
94069     ** the same number of characters into the UTF-16 string.
94070     */
94071     int chars_parsed = sqlcipher3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
94072     *pzTail = (u8 *)zSql + sqlcipher3Utf16ByteLen(zSql, chars_parsed);
94073   }
94074   sqlcipher3DbFree(db, zSql8); 
94075   rc = sqlcipher3ApiExit(db, rc);
94076   sqlcipher3_mutex_leave(db->mutex);
94077   return rc;
94078 }
94079
94080 /*
94081 ** Two versions of the official API.  Legacy and new use.  In the legacy
94082 ** version, the original SQL text is not saved in the prepared statement
94083 ** and so if a schema change occurs, SQLCIPHER_SCHEMA is returned by
94084 ** sqlcipher3_step().  In the new version, the original SQL text is retained
94085 ** and the statement is automatically recompiled if an schema change
94086 ** occurs.
94087 */
94088 SQLCIPHER_API int sqlcipher3_prepare16(
94089   sqlcipher3 *db,              /* Database handle. */ 
94090   const void *zSql,         /* UTF-16 encoded SQL statement. */
94091   int nBytes,               /* Length of zSql in bytes. */
94092   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
94093   const void **pzTail       /* OUT: End of parsed string */
94094 ){
94095   int rc;
94096   rc = sqlcipher3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
94097   assert( rc==SQLCIPHER_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
94098   return rc;
94099 }
94100 SQLCIPHER_API int sqlcipher3_prepare16_v2(
94101   sqlcipher3 *db,              /* Database handle. */ 
94102   const void *zSql,         /* UTF-16 encoded SQL statement. */
94103   int nBytes,               /* Length of zSql in bytes. */
94104   sqlcipher3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
94105   const void **pzTail       /* OUT: End of parsed string */
94106 ){
94107   int rc;
94108   rc = sqlcipher3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
94109   assert( rc==SQLCIPHER_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
94110   return rc;
94111 }
94112
94113 #endif /* SQLCIPHER_OMIT_UTF16 */
94114
94115 /************** End of prepare.c *********************************************/
94116 /************** Begin file select.c ******************************************/
94117 /*
94118 ** 2001 September 15
94119 **
94120 ** The author disclaims copyright to this source code.  In place of
94121 ** a legal notice, here is a blessing:
94122 **
94123 **    May you do good and not evil.
94124 **    May you find forgiveness for yourself and forgive others.
94125 **    May you share freely, never taking more than you give.
94126 **
94127 *************************************************************************
94128 ** This file contains C code routines that are called by the parser
94129 ** to handle SELECT statements in SQLite.
94130 */
94131
94132
94133 /*
94134 ** Delete all the content of a Select structure but do not deallocate
94135 ** the select structure itself.
94136 */
94137 static void clearSelect(sqlcipher3 *db, Select *p){
94138   sqlcipher3ExprListDelete(db, p->pEList);
94139   sqlcipher3SrcListDelete(db, p->pSrc);
94140   sqlcipher3ExprDelete(db, p->pWhere);
94141   sqlcipher3ExprListDelete(db, p->pGroupBy);
94142   sqlcipher3ExprDelete(db, p->pHaving);
94143   sqlcipher3ExprListDelete(db, p->pOrderBy);
94144   sqlcipher3SelectDelete(db, p->pPrior);
94145   sqlcipher3ExprDelete(db, p->pLimit);
94146   sqlcipher3ExprDelete(db, p->pOffset);
94147 }
94148
94149 /*
94150 ** Initialize a SelectDest structure.
94151 */
94152 SQLCIPHER_PRIVATE void sqlcipher3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
94153   pDest->eDest = (u8)eDest;
94154   pDest->iParm = iParm;
94155   pDest->affinity = 0;
94156   pDest->iMem = 0;
94157   pDest->nMem = 0;
94158 }
94159
94160
94161 /*
94162 ** Allocate a new Select structure and return a pointer to that
94163 ** structure.
94164 */
94165 SQLCIPHER_PRIVATE Select *sqlcipher3SelectNew(
94166   Parse *pParse,        /* Parsing context */
94167   ExprList *pEList,     /* which columns to include in the result */
94168   SrcList *pSrc,        /* the FROM clause -- which tables to scan */
94169   Expr *pWhere,         /* the WHERE clause */
94170   ExprList *pGroupBy,   /* the GROUP BY clause */
94171   Expr *pHaving,        /* the HAVING clause */
94172   ExprList *pOrderBy,   /* the ORDER BY clause */
94173   int isDistinct,       /* true if the DISTINCT keyword is present */
94174   Expr *pLimit,         /* LIMIT value.  NULL means not used */
94175   Expr *pOffset         /* OFFSET value.  NULL means no offset */
94176 ){
94177   Select *pNew;
94178   Select standin;
94179   sqlcipher3 *db = pParse->db;
94180   pNew = sqlcipher3DbMallocZero(db, sizeof(*pNew) );
94181   assert( db->mallocFailed || !pOffset || pLimit ); /* OFFSET implies LIMIT */
94182   if( pNew==0 ){
94183     assert( db->mallocFailed );
94184     pNew = &standin;
94185     memset(pNew, 0, sizeof(*pNew));
94186   }
94187   if( pEList==0 ){
94188     pEList = sqlcipher3ExprListAppend(pParse, 0, sqlcipher3Expr(db,TK_ALL,0));
94189   }
94190   pNew->pEList = pEList;
94191   pNew->pSrc = pSrc;
94192   pNew->pWhere = pWhere;
94193   pNew->pGroupBy = pGroupBy;
94194   pNew->pHaving = pHaving;
94195   pNew->pOrderBy = pOrderBy;
94196   pNew->selFlags = isDistinct ? SF_Distinct : 0;
94197   pNew->op = TK_SELECT;
94198   pNew->pLimit = pLimit;
94199   pNew->pOffset = pOffset;
94200   assert( pOffset==0 || pLimit!=0 );
94201   pNew->addrOpenEphm[0] = -1;
94202   pNew->addrOpenEphm[1] = -1;
94203   pNew->addrOpenEphm[2] = -1;
94204   if( db->mallocFailed ) {
94205     clearSelect(db, pNew);
94206     if( pNew!=&standin ) sqlcipher3DbFree(db, pNew);
94207     pNew = 0;
94208   }else{
94209     assert( pNew->pSrc!=0 || pParse->nErr>0 );
94210   }
94211   assert( pNew!=&standin );
94212   return pNew;
94213 }
94214
94215 /*
94216 ** Delete the given Select structure and all of its substructures.
94217 */
94218 SQLCIPHER_PRIVATE void sqlcipher3SelectDelete(sqlcipher3 *db, Select *p){
94219   if( p ){
94220     clearSelect(db, p);
94221     sqlcipher3DbFree(db, p);
94222   }
94223 }
94224
94225 /*
94226 ** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
94227 ** type of join.  Return an integer constant that expresses that type
94228 ** in terms of the following bit values:
94229 **
94230 **     JT_INNER
94231 **     JT_CROSS
94232 **     JT_OUTER
94233 **     JT_NATURAL
94234 **     JT_LEFT
94235 **     JT_RIGHT
94236 **
94237 ** A full outer join is the combination of JT_LEFT and JT_RIGHT.
94238 **
94239 ** If an illegal or unsupported join type is seen, then still return
94240 ** a join type, but put an error in the pParse structure.
94241 */
94242 SQLCIPHER_PRIVATE int sqlcipher3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
94243   int jointype = 0;
94244   Token *apAll[3];
94245   Token *p;
94246                              /*   0123456789 123456789 123456789 123 */
94247   static const char zKeyText[] = "naturaleftouterightfullinnercross";
94248   static const struct {
94249     u8 i;        /* Beginning of keyword text in zKeyText[] */
94250     u8 nChar;    /* Length of the keyword in characters */
94251     u8 code;     /* Join type mask */
94252   } aKeyword[] = {
94253     /* natural */ { 0,  7, JT_NATURAL                },
94254     /* left    */ { 6,  4, JT_LEFT|JT_OUTER          },
94255     /* outer   */ { 10, 5, JT_OUTER                  },
94256     /* right   */ { 14, 5, JT_RIGHT|JT_OUTER         },
94257     /* full    */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
94258     /* inner   */ { 23, 5, JT_INNER                  },
94259     /* cross   */ { 28, 5, JT_INNER|JT_CROSS         },
94260   };
94261   int i, j;
94262   apAll[0] = pA;
94263   apAll[1] = pB;
94264   apAll[2] = pC;
94265   for(i=0; i<3 && apAll[i]; i++){
94266     p = apAll[i];
94267     for(j=0; j<ArraySize(aKeyword); j++){
94268       if( p->n==aKeyword[j].nChar 
94269           && sqlcipher3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
94270         jointype |= aKeyword[j].code;
94271         break;
94272       }
94273     }
94274     testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
94275     if( j>=ArraySize(aKeyword) ){
94276       jointype |= JT_ERROR;
94277       break;
94278     }
94279   }
94280   if(
94281      (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
94282      (jointype & JT_ERROR)!=0
94283   ){
94284     const char *zSp = " ";
94285     assert( pB!=0 );
94286     if( pC==0 ){ zSp++; }
94287     sqlcipher3ErrorMsg(pParse, "unknown or unsupported join type: "
94288        "%T %T%s%T", pA, pB, zSp, pC);
94289     jointype = JT_INNER;
94290   }else if( (jointype & JT_OUTER)!=0 
94291          && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){
94292     sqlcipher3ErrorMsg(pParse, 
94293       "RIGHT and FULL OUTER JOINs are not currently supported");
94294     jointype = JT_INNER;
94295   }
94296   return jointype;
94297 }
94298
94299 /*
94300 ** Return the index of a column in a table.  Return -1 if the column
94301 ** is not contained in the table.
94302 */
94303 static int columnIndex(Table *pTab, const char *zCol){
94304   int i;
94305   for(i=0; i<pTab->nCol; i++){
94306     if( sqlcipher3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
94307   }
94308   return -1;
94309 }
94310
94311 /*
94312 ** Search the first N tables in pSrc, from left to right, looking for a
94313 ** table that has a column named zCol.  
94314 **
94315 ** When found, set *piTab and *piCol to the table index and column index
94316 ** of the matching column and return TRUE.
94317 **
94318 ** If not found, return FALSE.
94319 */
94320 static int tableAndColumnIndex(
94321   SrcList *pSrc,       /* Array of tables to search */
94322   int N,               /* Number of tables in pSrc->a[] to search */
94323   const char *zCol,    /* Name of the column we are looking for */
94324   int *piTab,          /* Write index of pSrc->a[] here */
94325   int *piCol           /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
94326 ){
94327   int i;               /* For looping over tables in pSrc */
94328   int iCol;            /* Index of column matching zCol */
94329
94330   assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
94331   for(i=0; i<N; i++){
94332     iCol = columnIndex(pSrc->a[i].pTab, zCol);
94333     if( iCol>=0 ){
94334       if( piTab ){
94335         *piTab = i;
94336         *piCol = iCol;
94337       }
94338       return 1;
94339     }
94340   }
94341   return 0;
94342 }
94343
94344 /*
94345 ** This function is used to add terms implied by JOIN syntax to the
94346 ** WHERE clause expression of a SELECT statement. The new term, which
94347 ** is ANDed with the existing WHERE clause, is of the form:
94348 **
94349 **    (tab1.col1 = tab2.col2)
94350 **
94351 ** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the 
94352 ** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
94353 ** column iColRight of tab2.
94354 */
94355 static void addWhereTerm(
94356   Parse *pParse,                  /* Parsing context */
94357   SrcList *pSrc,                  /* List of tables in FROM clause */
94358   int iLeft,                      /* Index of first table to join in pSrc */
94359   int iColLeft,                   /* Index of column in first table */
94360   int iRight,                     /* Index of second table in pSrc */
94361   int iColRight,                  /* Index of column in second table */
94362   int isOuterJoin,                /* True if this is an OUTER join */
94363   Expr **ppWhere                  /* IN/OUT: The WHERE clause to add to */
94364 ){
94365   sqlcipher3 *db = pParse->db;
94366   Expr *pE1;
94367   Expr *pE2;
94368   Expr *pEq;
94369
94370   assert( iLeft<iRight );
94371   assert( pSrc->nSrc>iRight );
94372   assert( pSrc->a[iLeft].pTab );
94373   assert( pSrc->a[iRight].pTab );
94374
94375   pE1 = sqlcipher3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
94376   pE2 = sqlcipher3CreateColumnExpr(db, pSrc, iRight, iColRight);
94377
94378   pEq = sqlcipher3PExpr(pParse, TK_EQ, pE1, pE2, 0);
94379   if( pEq && isOuterJoin ){
94380     ExprSetProperty(pEq, EP_FromJoin);
94381     assert( !ExprHasAnyProperty(pEq, EP_TokenOnly|EP_Reduced) );
94382     ExprSetIrreducible(pEq);
94383     pEq->iRightJoinTable = (i16)pE2->iTable;
94384   }
94385   *ppWhere = sqlcipher3ExprAnd(db, *ppWhere, pEq);
94386 }
94387
94388 /*
94389 ** Set the EP_FromJoin property on all terms of the given expression.
94390 ** And set the Expr.iRightJoinTable to iTable for every term in the
94391 ** expression.
94392 **
94393 ** The EP_FromJoin property is used on terms of an expression to tell
94394 ** the LEFT OUTER JOIN processing logic that this term is part of the
94395 ** join restriction specified in the ON or USING clause and not a part
94396 ** of the more general WHERE clause.  These terms are moved over to the
94397 ** WHERE clause during join processing but we need to remember that they
94398 ** originated in the ON or USING clause.
94399 **
94400 ** The Expr.iRightJoinTable tells the WHERE clause processing that the
94401 ** expression depends on table iRightJoinTable even if that table is not
94402 ** explicitly mentioned in the expression.  That information is needed
94403 ** for cases like this:
94404 **
94405 **    SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
94406 **
94407 ** The where clause needs to defer the handling of the t1.x=5
94408 ** term until after the t2 loop of the join.  In that way, a
94409 ** NULL t2 row will be inserted whenever t1.x!=5.  If we do not
94410 ** defer the handling of t1.x=5, it will be processed immediately
94411 ** after the t1 loop and rows with t1.x!=5 will never appear in
94412 ** the output, which is incorrect.
94413 */
94414 static void setJoinExpr(Expr *p, int iTable){
94415   while( p ){
94416     ExprSetProperty(p, EP_FromJoin);
94417     assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
94418     ExprSetIrreducible(p);
94419     p->iRightJoinTable = (i16)iTable;
94420     setJoinExpr(p->pLeft, iTable);
94421     p = p->pRight;
94422   } 
94423 }
94424
94425 /*
94426 ** This routine processes the join information for a SELECT statement.
94427 ** ON and USING clauses are converted into extra terms of the WHERE clause.
94428 ** NATURAL joins also create extra WHERE clause terms.
94429 **
94430 ** The terms of a FROM clause are contained in the Select.pSrc structure.
94431 ** The left most table is the first entry in Select.pSrc.  The right-most
94432 ** table is the last entry.  The join operator is held in the entry to
94433 ** the left.  Thus entry 0 contains the join operator for the join between
94434 ** entries 0 and 1.  Any ON or USING clauses associated with the join are
94435 ** also attached to the left entry.
94436 **
94437 ** This routine returns the number of errors encountered.
94438 */
94439 static int sqlcipherProcessJoin(Parse *pParse, Select *p){
94440   SrcList *pSrc;                  /* All tables in the FROM clause */
94441   int i, j;                       /* Loop counters */
94442   struct SrcList_item *pLeft;     /* Left table being joined */
94443   struct SrcList_item *pRight;    /* Right table being joined */
94444
94445   pSrc = p->pSrc;
94446   pLeft = &pSrc->a[0];
94447   pRight = &pLeft[1];
94448   for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
94449     Table *pLeftTab = pLeft->pTab;
94450     Table *pRightTab = pRight->pTab;
94451     int isOuter;
94452
94453     if( NEVER(pLeftTab==0 || pRightTab==0) ) continue;
94454     isOuter = (pRight->jointype & JT_OUTER)!=0;
94455
94456     /* When the NATURAL keyword is present, add WHERE clause terms for
94457     ** every column that the two tables have in common.
94458     */
94459     if( pRight->jointype & JT_NATURAL ){
94460       if( pRight->pOn || pRight->pUsing ){
94461         sqlcipher3ErrorMsg(pParse, "a NATURAL join may not have "
94462            "an ON or USING clause", 0);
94463         return 1;
94464       }
94465       for(j=0; j<pRightTab->nCol; j++){
94466         char *zName;   /* Name of column in the right table */
94467         int iLeft;     /* Matching left table */
94468         int iLeftCol;  /* Matching column in the left table */
94469
94470         zName = pRightTab->aCol[j].zName;
94471         if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
94472           addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
94473                        isOuter, &p->pWhere);
94474         }
94475       }
94476     }
94477
94478     /* Disallow both ON and USING clauses in the same join
94479     */
94480     if( pRight->pOn && pRight->pUsing ){
94481       sqlcipher3ErrorMsg(pParse, "cannot have both ON and USING "
94482         "clauses in the same join");
94483       return 1;
94484     }
94485
94486     /* Add the ON clause to the end of the WHERE clause, connected by
94487     ** an AND operator.
94488     */
94489     if( pRight->pOn ){
94490       if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);
94491       p->pWhere = sqlcipher3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
94492       pRight->pOn = 0;
94493     }
94494
94495     /* Create extra terms on the WHERE clause for each column named
94496     ** in the USING clause.  Example: If the two tables to be joined are 
94497     ** A and B and the USING clause names X, Y, and Z, then add this
94498     ** to the WHERE clause:    A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
94499     ** Report an error if any column mentioned in the USING clause is
94500     ** not contained in both tables to be joined.
94501     */
94502     if( pRight->pUsing ){
94503       IdList *pList = pRight->pUsing;
94504       for(j=0; j<pList->nId; j++){
94505         char *zName;     /* Name of the term in the USING clause */
94506         int iLeft;       /* Table on the left with matching column name */
94507         int iLeftCol;    /* Column number of matching column on the left */
94508         int iRightCol;   /* Column number of matching column on the right */
94509
94510         zName = pList->a[j].zName;
94511         iRightCol = columnIndex(pRightTab, zName);
94512         if( iRightCol<0
94513          || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
94514         ){
94515           sqlcipher3ErrorMsg(pParse, "cannot join using column %s - column "
94516             "not present in both tables", zName);
94517           return 1;
94518         }
94519         addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
94520                      isOuter, &p->pWhere);
94521       }
94522     }
94523   }
94524   return 0;
94525 }
94526
94527 /*
94528 ** Insert code into "v" that will push the record on the top of the
94529 ** stack into the sorter.
94530 */
94531 static void pushOntoSorter(
94532   Parse *pParse,         /* Parser context */
94533   ExprList *pOrderBy,    /* The ORDER BY clause */
94534   Select *pSelect,       /* The whole SELECT statement */
94535   int regData            /* Register holding data to be sorted */
94536 ){
94537   Vdbe *v = pParse->pVdbe;
94538   int nExpr = pOrderBy->nExpr;
94539   int regBase = sqlcipher3GetTempRange(pParse, nExpr+2);
94540   int regRecord = sqlcipher3GetTempReg(pParse);
94541   int op;
94542   sqlcipher3ExprCacheClear(pParse);
94543   sqlcipher3ExprCodeExprList(pParse, pOrderBy, regBase, 0);
94544   sqlcipher3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr);
94545   sqlcipher3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1);
94546   sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord);
94547   if( pSelect->selFlags & SF_UseSorter ){
94548     op = OP_SorterInsert;
94549   }else{
94550     op = OP_IdxInsert;
94551   }
94552   sqlcipher3VdbeAddOp2(v, op, pOrderBy->iECursor, regRecord);
94553   sqlcipher3ReleaseTempReg(pParse, regRecord);
94554   sqlcipher3ReleaseTempRange(pParse, regBase, nExpr+2);
94555   if( pSelect->iLimit ){
94556     int addr1, addr2;
94557     int iLimit;
94558     if( pSelect->iOffset ){
94559       iLimit = pSelect->iOffset+1;
94560     }else{
94561       iLimit = pSelect->iLimit;
94562     }
94563     addr1 = sqlcipher3VdbeAddOp1(v, OP_IfZero, iLimit);
94564     sqlcipher3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
94565     addr2 = sqlcipher3VdbeAddOp0(v, OP_Goto);
94566     sqlcipher3VdbeJumpHere(v, addr1);
94567     sqlcipher3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor);
94568     sqlcipher3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor);
94569     sqlcipher3VdbeJumpHere(v, addr2);
94570   }
94571 }
94572
94573 /*
94574 ** Add code to implement the OFFSET
94575 */
94576 static void codeOffset(
94577   Vdbe *v,          /* Generate code into this VM */
94578   Select *p,        /* The SELECT statement being coded */
94579   int iContinue     /* Jump here to skip the current record */
94580 ){
94581   if( p->iOffset && iContinue!=0 ){
94582     int addr;
94583     sqlcipher3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
94584     addr = sqlcipher3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
94585     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, iContinue);
94586     VdbeComment((v, "skip OFFSET records"));
94587     sqlcipher3VdbeJumpHere(v, addr);
94588   }
94589 }
94590
94591 /*
94592 ** Add code that will check to make sure the N registers starting at iMem
94593 ** form a distinct entry.  iTab is a sorting index that holds previously
94594 ** seen combinations of the N values.  A new entry is made in iTab
94595 ** if the current N values are new.
94596 **
94597 ** A jump to addrRepeat is made and the N+1 values are popped from the
94598 ** stack if the top N elements are not distinct.
94599 */
94600 static void codeDistinct(
94601   Parse *pParse,     /* Parsing and code generating context */
94602   int iTab,          /* A sorting index used to test for distinctness */
94603   int addrRepeat,    /* Jump to here if not distinct */
94604   int N,             /* Number of elements */
94605   int iMem           /* First element */
94606 ){
94607   Vdbe *v;
94608   int r1;
94609
94610   v = pParse->pVdbe;
94611   r1 = sqlcipher3GetTempReg(pParse);
94612   sqlcipher3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N);
94613   sqlcipher3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
94614   sqlcipher3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
94615   sqlcipher3ReleaseTempReg(pParse, r1);
94616 }
94617
94618 #ifndef SQLCIPHER_OMIT_SUBQUERY
94619 /*
94620 ** Generate an error message when a SELECT is used within a subexpression
94621 ** (example:  "a IN (SELECT * FROM table)") but it has more than 1 result
94622 ** column.  We do this in a subroutine because the error used to occur
94623 ** in multiple places.  (The error only occurs in one place now, but we
94624 ** retain the subroutine to minimize code disruption.)
94625 */
94626 static int checkForMultiColumnSelectError(
94627   Parse *pParse,       /* Parse context. */
94628   SelectDest *pDest,   /* Destination of SELECT results */
94629   int nExpr            /* Number of result columns returned by SELECT */
94630 ){
94631   int eDest = pDest->eDest;
94632   if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
94633     sqlcipher3ErrorMsg(pParse, "only a single result allowed for "
94634        "a SELECT that is part of an expression");
94635     return 1;
94636   }else{
94637     return 0;
94638   }
94639 }
94640 #endif
94641
94642 /*
94643 ** This routine generates the code for the inside of the inner loop
94644 ** of a SELECT.
94645 **
94646 ** If srcTab and nColumn are both zero, then the pEList expressions
94647 ** are evaluated in order to get the data for this row.  If nColumn>0
94648 ** then data is pulled from srcTab and pEList is used only to get the
94649 ** datatypes for each column.
94650 */
94651 static void selectInnerLoop(
94652   Parse *pParse,          /* The parser context */
94653   Select *p,              /* The complete select statement being coded */
94654   ExprList *pEList,       /* List of values being extracted */
94655   int srcTab,             /* Pull data from this table */
94656   int nColumn,            /* Number of columns in the source table */
94657   ExprList *pOrderBy,     /* If not NULL, sort results using this key */
94658   int distinct,           /* If >=0, make sure results are distinct */
94659   SelectDest *pDest,      /* How to dispose of the results */
94660   int iContinue,          /* Jump here to continue with next row */
94661   int iBreak              /* Jump here to break out of the inner loop */
94662 ){
94663   Vdbe *v = pParse->pVdbe;
94664   int i;
94665   int hasDistinct;        /* True if the DISTINCT keyword is present */
94666   int regResult;              /* Start of memory holding result set */
94667   int eDest = pDest->eDest;   /* How to dispose of results */
94668   int iParm = pDest->iParm;   /* First argument to disposal method */
94669   int nResultCol;             /* Number of result columns */
94670
94671   assert( v );
94672   if( NEVER(v==0) ) return;
94673   assert( pEList!=0 );
94674   hasDistinct = distinct>=0;
94675   if( pOrderBy==0 && !hasDistinct ){
94676     codeOffset(v, p, iContinue);
94677   }
94678
94679   /* Pull the requested columns.
94680   */
94681   if( nColumn>0 ){
94682     nResultCol = nColumn;
94683   }else{
94684     nResultCol = pEList->nExpr;
94685   }
94686   if( pDest->iMem==0 ){
94687     pDest->iMem = pParse->nMem+1;
94688     pDest->nMem = nResultCol;
94689     pParse->nMem += nResultCol;
94690   }else{ 
94691     assert( pDest->nMem==nResultCol );
94692   }
94693   regResult = pDest->iMem;
94694   if( nColumn>0 ){
94695     for(i=0; i<nColumn; i++){
94696       sqlcipher3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
94697     }
94698   }else if( eDest!=SRT_Exists ){
94699     /* If the destination is an EXISTS(...) expression, the actual
94700     ** values returned by the SELECT are not required.
94701     */
94702     sqlcipher3ExprCacheClear(pParse);
94703     sqlcipher3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Output);
94704   }
94705   nColumn = nResultCol;
94706
94707   /* If the DISTINCT keyword was present on the SELECT statement
94708   ** and this row has been seen before, then do not make this row
94709   ** part of the result.
94710   */
94711   if( hasDistinct ){
94712     assert( pEList!=0 );
94713     assert( pEList->nExpr==nColumn );
94714     codeDistinct(pParse, distinct, iContinue, nColumn, regResult);
94715     if( pOrderBy==0 ){
94716       codeOffset(v, p, iContinue);
94717     }
94718   }
94719
94720   switch( eDest ){
94721     /* In this mode, write each query result to the key of the temporary
94722     ** table iParm.
94723     */
94724 #ifndef SQLCIPHER_OMIT_COMPOUND_SELECT
94725     case SRT_Union: {
94726       int r1;
94727       r1 = sqlcipher3GetTempReg(pParse);
94728       sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
94729       sqlcipher3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
94730       sqlcipher3ReleaseTempReg(pParse, r1);
94731       break;
94732     }
94733
94734     /* Construct a record from the query result, but instead of
94735     ** saving that record, use it as a key to delete elements from
94736     ** the temporary table iParm.
94737     */
94738     case SRT_Except: {
94739       sqlcipher3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn);
94740       break;
94741     }
94742 #endif
94743
94744     /* Store the result as data using a unique key.
94745     */
94746     case SRT_Table:
94747     case SRT_EphemTab: {
94748       int r1 = sqlcipher3GetTempReg(pParse);
94749       testcase( eDest==SRT_Table );
94750       testcase( eDest==SRT_EphemTab );
94751       sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
94752       if( pOrderBy ){
94753         pushOntoSorter(pParse, pOrderBy, p, r1);
94754       }else{
94755         int r2 = sqlcipher3GetTempReg(pParse);
94756         sqlcipher3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
94757         sqlcipher3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
94758         sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
94759         sqlcipher3ReleaseTempReg(pParse, r2);
94760       }
94761       sqlcipher3ReleaseTempReg(pParse, r1);
94762       break;
94763     }
94764
94765 #ifndef SQLCIPHER_OMIT_SUBQUERY
94766     /* If we are creating a set for an "expr IN (SELECT ...)" construct,
94767     ** then there should be a single item on the stack.  Write this
94768     ** item into the set table with bogus data.
94769     */
94770     case SRT_Set: {
94771       assert( nColumn==1 );
94772       p->affinity = sqlcipher3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
94773       if( pOrderBy ){
94774         /* At first glance you would think we could optimize out the
94775         ** ORDER BY in this case since the order of entries in the set
94776         ** does not matter.  But there might be a LIMIT clause, in which
94777         ** case the order does matter */
94778         pushOntoSorter(pParse, pOrderBy, p, regResult);
94779       }else{
94780         int r1 = sqlcipher3GetTempReg(pParse);
94781         sqlcipher3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
94782         sqlcipher3ExprCacheAffinityChange(pParse, regResult, 1);
94783         sqlcipher3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
94784         sqlcipher3ReleaseTempReg(pParse, r1);
94785       }
94786       break;
94787     }
94788
94789     /* If any row exist in the result set, record that fact and abort.
94790     */
94791     case SRT_Exists: {
94792       sqlcipher3VdbeAddOp2(v, OP_Integer, 1, iParm);
94793       /* The LIMIT clause will terminate the loop for us */
94794       break;
94795     }
94796
94797     /* If this is a scalar select that is part of an expression, then
94798     ** store the results in the appropriate memory cell and break out
94799     ** of the scan loop.
94800     */
94801     case SRT_Mem: {
94802       assert( nColumn==1 );
94803       if( pOrderBy ){
94804         pushOntoSorter(pParse, pOrderBy, p, regResult);
94805       }else{
94806         sqlcipher3ExprCodeMove(pParse, regResult, iParm, 1);
94807         /* The LIMIT clause will jump out of the loop for us */
94808       }
94809       break;
94810     }
94811 #endif /* #ifndef SQLCIPHER_OMIT_SUBQUERY */
94812
94813     /* Send the data to the callback function or to a subroutine.  In the
94814     ** case of a subroutine, the subroutine itself is responsible for
94815     ** popping the data from the stack.
94816     */
94817     case SRT_Coroutine:
94818     case SRT_Output: {
94819       testcase( eDest==SRT_Coroutine );
94820       testcase( eDest==SRT_Output );
94821       if( pOrderBy ){
94822         int r1 = sqlcipher3GetTempReg(pParse);
94823         sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
94824         pushOntoSorter(pParse, pOrderBy, p, r1);
94825         sqlcipher3ReleaseTempReg(pParse, r1);
94826       }else if( eDest==SRT_Coroutine ){
94827         sqlcipher3VdbeAddOp1(v, OP_Yield, pDest->iParm);
94828       }else{
94829         sqlcipher3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
94830         sqlcipher3ExprCacheAffinityChange(pParse, regResult, nColumn);
94831       }
94832       break;
94833     }
94834
94835 #if !defined(SQLCIPHER_OMIT_TRIGGER)
94836     /* Discard the results.  This is used for SELECT statements inside
94837     ** the body of a TRIGGER.  The purpose of such selects is to call
94838     ** user-defined functions that have side effects.  We do not care
94839     ** about the actual results of the select.
94840     */
94841     default: {
94842       assert( eDest==SRT_Discard );
94843       break;
94844     }
94845 #endif
94846   }
94847
94848   /* Jump to the end of the loop if the LIMIT is reached.  Except, if
94849   ** there is a sorter, in which case the sorter has already limited
94850   ** the output for us.
94851   */
94852   if( pOrderBy==0 && p->iLimit ){
94853     sqlcipher3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
94854   }
94855 }
94856
94857 /*
94858 ** Given an expression list, generate a KeyInfo structure that records
94859 ** the collating sequence for each expression in that expression list.
94860 **
94861 ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
94862 ** KeyInfo structure is appropriate for initializing a virtual index to
94863 ** implement that clause.  If the ExprList is the result set of a SELECT
94864 ** then the KeyInfo structure is appropriate for initializing a virtual
94865 ** index to implement a DISTINCT test.
94866 **
94867 ** Space to hold the KeyInfo structure is obtain from malloc.  The calling
94868 ** function is responsible for seeing that this structure is eventually
94869 ** freed.  Add the KeyInfo structure to the P4 field of an opcode using
94870 ** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
94871 */
94872 static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
94873   sqlcipher3 *db = pParse->db;
94874   int nExpr;
94875   KeyInfo *pInfo;
94876   struct ExprList_item *pItem;
94877   int i;
94878
94879   nExpr = pList->nExpr;
94880   pInfo = sqlcipher3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
94881   if( pInfo ){
94882     pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
94883     pInfo->nField = (u16)nExpr;
94884     pInfo->enc = ENC(db);
94885     pInfo->db = db;
94886     for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
94887       CollSeq *pColl;
94888       pColl = sqlcipher3ExprCollSeq(pParse, pItem->pExpr);
94889       if( !pColl ){
94890         pColl = db->pDfltColl;
94891       }
94892       pInfo->aColl[i] = pColl;
94893       pInfo->aSortOrder[i] = pItem->sortOrder;
94894     }
94895   }
94896   return pInfo;
94897 }
94898
94899 #ifndef SQLCIPHER_OMIT_COMPOUND_SELECT
94900 /*
94901 ** Name of the connection operator, used for error messages.
94902 */
94903 static const char *selectOpName(int id){
94904   char *z;
94905   switch( id ){
94906     case TK_ALL:       z = "UNION ALL";   break;
94907     case TK_INTERSECT: z = "INTERSECT";   break;
94908     case TK_EXCEPT:    z = "EXCEPT";      break;
94909     default:           z = "UNION";       break;
94910   }
94911   return z;
94912 }
94913 #endif /* SQLCIPHER_OMIT_COMPOUND_SELECT */
94914
94915 #ifndef SQLCIPHER_OMIT_EXPLAIN
94916 /*
94917 ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
94918 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
94919 ** where the caption is of the form:
94920 **
94921 **   "USE TEMP B-TREE FOR xxx"
94922 **
94923 ** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
94924 ** is determined by the zUsage argument.
94925 */
94926 static void explainTempTable(Parse *pParse, const char *zUsage){
94927   if( pParse->explain==2 ){
94928     Vdbe *v = pParse->pVdbe;
94929     char *zMsg = sqlcipher3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage);
94930     sqlcipher3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
94931   }
94932 }
94933
94934 /*
94935 ** Assign expression b to lvalue a. A second, no-op, version of this macro
94936 ** is provided when SQLCIPHER_OMIT_EXPLAIN is defined. This allows the code
94937 ** in sqlcipher3Select() to assign values to structure member variables that
94938 ** only exist if SQLCIPHER_OMIT_EXPLAIN is not defined without polluting the
94939 ** code with #ifndef directives.
94940 */
94941 # define explainSetInteger(a, b) a = b
94942
94943 #else
94944 /* No-op versions of the explainXXX() functions and macros. */
94945 # define explainTempTable(y,z)
94946 # define explainSetInteger(y,z)
94947 #endif
94948
94949 #if !defined(SQLCIPHER_OMIT_EXPLAIN) && !defined(SQLCIPHER_OMIT_COMPOUND_SELECT)
94950 /*
94951 ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
94952 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
94953 ** where the caption is of one of the two forms:
94954 **
94955 **   "COMPOSITE SUBQUERIES iSub1 and iSub2 (op)"
94956 **   "COMPOSITE SUBQUERIES iSub1 and iSub2 USING TEMP B-TREE (op)"
94957 **
94958 ** where iSub1 and iSub2 are the integers passed as the corresponding
94959 ** function parameters, and op is the text representation of the parameter
94960 ** of the same name. The parameter "op" must be one of TK_UNION, TK_EXCEPT,
94961 ** TK_INTERSECT or TK_ALL. The first form is used if argument bUseTmp is 
94962 ** false, or the second form if it is true.
94963 */
94964 static void explainComposite(
94965   Parse *pParse,                  /* Parse context */
94966   int op,                         /* One of TK_UNION, TK_EXCEPT etc. */
94967   int iSub1,                      /* Subquery id 1 */
94968   int iSub2,                      /* Subquery id 2 */
94969   int bUseTmp                     /* True if a temp table was used */
94970 ){
94971   assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
94972   if( pParse->explain==2 ){
94973     Vdbe *v = pParse->pVdbe;
94974     char *zMsg = sqlcipher3MPrintf(
94975         pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
94976         bUseTmp?"USING TEMP B-TREE ":"", selectOpName(op)
94977     );
94978     sqlcipher3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
94979   }
94980 }
94981 #else
94982 /* No-op versions of the explainXXX() functions and macros. */
94983 # define explainComposite(v,w,x,y,z)
94984 #endif
94985
94986 /*
94987 ** If the inner loop was generated using a non-null pOrderBy argument,
94988 ** then the results were placed in a sorter.  After the loop is terminated
94989 ** we need to run the sorter and output the results.  The following
94990 ** routine generates the code needed to do that.
94991 */
94992 static void generateSortTail(
94993   Parse *pParse,    /* Parsing context */
94994   Select *p,        /* The SELECT statement */
94995   Vdbe *v,          /* Generate code into this VDBE */
94996   int nColumn,      /* Number of columns of data */
94997   SelectDest *pDest /* Write the sorted results here */
94998 ){
94999   int addrBreak = sqlcipher3VdbeMakeLabel(v);     /* Jump here to exit loop */
95000   int addrContinue = sqlcipher3VdbeMakeLabel(v);  /* Jump here for next cycle */
95001   int addr;
95002   int iTab;
95003   int pseudoTab = 0;
95004   ExprList *pOrderBy = p->pOrderBy;
95005
95006   int eDest = pDest->eDest;
95007   int iParm = pDest->iParm;
95008
95009   int regRow;
95010   int regRowid;
95011
95012   iTab = pOrderBy->iECursor;
95013   regRow = sqlcipher3GetTempReg(pParse);
95014   if( eDest==SRT_Output || eDest==SRT_Coroutine ){
95015     pseudoTab = pParse->nTab++;
95016     sqlcipher3VdbeAddOp3(v, OP_OpenPseudo, pseudoTab, regRow, nColumn);
95017     regRowid = 0;
95018   }else{
95019     regRowid = sqlcipher3GetTempReg(pParse);
95020   }
95021   if( p->selFlags & SF_UseSorter ){
95022     int regSortOut = ++pParse->nMem;
95023     int ptab2 = pParse->nTab++;
95024     sqlcipher3VdbeAddOp3(v, OP_OpenPseudo, ptab2, regSortOut, pOrderBy->nExpr+2);
95025     addr = 1 + sqlcipher3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
95026     codeOffset(v, p, addrContinue);
95027     sqlcipher3VdbeAddOp2(v, OP_SorterData, iTab, regSortOut);
95028     sqlcipher3VdbeAddOp3(v, OP_Column, ptab2, pOrderBy->nExpr+1, regRow);
95029     sqlcipher3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
95030   }else{
95031     addr = 1 + sqlcipher3VdbeAddOp2(v, OP_Sort, iTab, addrBreak);
95032     codeOffset(v, p, addrContinue);
95033     sqlcipher3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr+1, regRow);
95034   }
95035   switch( eDest ){
95036     case SRT_Table:
95037     case SRT_EphemTab: {
95038       testcase( eDest==SRT_Table );
95039       testcase( eDest==SRT_EphemTab );
95040       sqlcipher3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
95041       sqlcipher3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
95042       sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
95043       break;
95044     }
95045 #ifndef SQLCIPHER_OMIT_SUBQUERY
95046     case SRT_Set: {
95047       assert( nColumn==1 );
95048       sqlcipher3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
95049       sqlcipher3ExprCacheAffinityChange(pParse, regRow, 1);
95050       sqlcipher3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
95051       break;
95052     }
95053     case SRT_Mem: {
95054       assert( nColumn==1 );
95055       sqlcipher3ExprCodeMove(pParse, regRow, iParm, 1);
95056       /* The LIMIT clause will terminate the loop for us */
95057       break;
95058     }
95059 #endif
95060     default: {
95061       int i;
95062       assert( eDest==SRT_Output || eDest==SRT_Coroutine ); 
95063       testcase( eDest==SRT_Output );
95064       testcase( eDest==SRT_Coroutine );
95065       for(i=0; i<nColumn; i++){
95066         assert( regRow!=pDest->iMem+i );
95067         sqlcipher3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iMem+i);
95068         if( i==0 ){
95069           sqlcipher3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
95070         }
95071       }
95072       if( eDest==SRT_Output ){
95073         sqlcipher3VdbeAddOp2(v, OP_ResultRow, pDest->iMem, nColumn);
95074         sqlcipher3ExprCacheAffinityChange(pParse, pDest->iMem, nColumn);
95075       }else{
95076         sqlcipher3VdbeAddOp1(v, OP_Yield, pDest->iParm);
95077       }
95078       break;
95079     }
95080   }
95081   sqlcipher3ReleaseTempReg(pParse, regRow);
95082   sqlcipher3ReleaseTempReg(pParse, regRowid);
95083
95084   /* The bottom of the loop
95085   */
95086   sqlcipher3VdbeResolveLabel(v, addrContinue);
95087   if( p->selFlags & SF_UseSorter ){
95088     sqlcipher3VdbeAddOp2(v, OP_SorterNext, iTab, addr);
95089   }else{
95090     sqlcipher3VdbeAddOp2(v, OP_Next, iTab, addr);
95091   }
95092   sqlcipher3VdbeResolveLabel(v, addrBreak);
95093   if( eDest==SRT_Output || eDest==SRT_Coroutine ){
95094     sqlcipher3VdbeAddOp2(v, OP_Close, pseudoTab, 0);
95095   }
95096 }
95097
95098 /*
95099 ** Return a pointer to a string containing the 'declaration type' of the
95100 ** expression pExpr. The string may be treated as static by the caller.
95101 **
95102 ** The declaration type is the exact datatype definition extracted from the
95103 ** original CREATE TABLE statement if the expression is a column. The
95104 ** declaration type for a ROWID field is INTEGER. Exactly when an expression
95105 ** is considered a column can be complex in the presence of subqueries. The
95106 ** result-set expression in all of the following SELECT statements is 
95107 ** considered a column by this function.
95108 **
95109 **   SELECT col FROM tbl;
95110 **   SELECT (SELECT col FROM tbl;
95111 **   SELECT (SELECT col FROM tbl);
95112 **   SELECT abc FROM (SELECT col AS abc FROM tbl);
95113 ** 
95114 ** The declaration type for any expression other than a column is NULL.
95115 */
95116 static const char *columnType(
95117   NameContext *pNC, 
95118   Expr *pExpr,
95119   const char **pzOriginDb,
95120   const char **pzOriginTab,
95121   const char **pzOriginCol
95122 ){
95123   char const *zType = 0;
95124   char const *zOriginDb = 0;
95125   char const *zOriginTab = 0;
95126   char const *zOriginCol = 0;
95127   int j;
95128   if( NEVER(pExpr==0) || pNC->pSrcList==0 ) return 0;
95129
95130   switch( pExpr->op ){
95131     case TK_AGG_COLUMN:
95132     case TK_COLUMN: {
95133       /* The expression is a column. Locate the table the column is being
95134       ** extracted from in NameContext.pSrcList. This table may be real
95135       ** database table or a subquery.
95136       */
95137       Table *pTab = 0;            /* Table structure column is extracted from */
95138       Select *pS = 0;             /* Select the column is extracted from */
95139       int iCol = pExpr->iColumn;  /* Index of column in pTab */
95140       testcase( pExpr->op==TK_AGG_COLUMN );
95141       testcase( pExpr->op==TK_COLUMN );
95142       while( pNC && !pTab ){
95143         SrcList *pTabList = pNC->pSrcList;
95144         for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
95145         if( j<pTabList->nSrc ){
95146           pTab = pTabList->a[j].pTab;
95147           pS = pTabList->a[j].pSelect;
95148         }else{
95149           pNC = pNC->pNext;
95150         }
95151       }
95152
95153       if( pTab==0 ){
95154         /* At one time, code such as "SELECT new.x" within a trigger would
95155         ** cause this condition to run.  Since then, we have restructured how
95156         ** trigger code is generated and so this condition is no longer 
95157         ** possible. However, it can still be true for statements like
95158         ** the following:
95159         **
95160         **   CREATE TABLE t1(col INTEGER);
95161         **   SELECT (SELECT t1.col) FROM FROM t1;
95162         **
95163         ** when columnType() is called on the expression "t1.col" in the 
95164         ** sub-select. In this case, set the column type to NULL, even
95165         ** though it should really be "INTEGER".
95166         **
95167         ** This is not a problem, as the column type of "t1.col" is never
95168         ** used. When columnType() is called on the expression 
95169         ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
95170         ** branch below.  */
95171         break;
95172       }
95173
95174       assert( pTab && pExpr->pTab==pTab );
95175       if( pS ){
95176         /* The "table" is actually a sub-select or a view in the FROM clause
95177         ** of the SELECT statement. Return the declaration type and origin
95178         ** data for the result-set column of the sub-select.
95179         */
95180         if( iCol>=0 && ALWAYS(iCol<pS->pEList->nExpr) ){
95181           /* If iCol is less than zero, then the expression requests the
95182           ** rowid of the sub-select or view. This expression is legal (see 
95183           ** test case misc2.2.2) - it always evaluates to NULL.
95184           */
95185           NameContext sNC;
95186           Expr *p = pS->pEList->a[iCol].pExpr;
95187           sNC.pSrcList = pS->pSrc;
95188           sNC.pNext = pNC;
95189           sNC.pParse = pNC->pParse;
95190           zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); 
95191         }
95192       }else if( ALWAYS(pTab->pSchema) ){
95193         /* A real table */
95194         assert( !pS );
95195         if( iCol<0 ) iCol = pTab->iPKey;
95196         assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95197         if( iCol<0 ){
95198           zType = "INTEGER";
95199           zOriginCol = "rowid";
95200         }else{
95201           zType = pTab->aCol[iCol].zType;
95202           zOriginCol = pTab->aCol[iCol].zName;
95203         }
95204         zOriginTab = pTab->zName;
95205         if( pNC->pParse ){
95206           int iDb = sqlcipher3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
95207           zOriginDb = pNC->pParse->db->aDb[iDb].zName;
95208         }
95209       }
95210       break;
95211     }
95212 #ifndef SQLCIPHER_OMIT_SUBQUERY
95213     case TK_SELECT: {
95214       /* The expression is a sub-select. Return the declaration type and
95215       ** origin info for the single column in the result set of the SELECT
95216       ** statement.
95217       */
95218       NameContext sNC;
95219       Select *pS = pExpr->x.pSelect;
95220       Expr *p = pS->pEList->a[0].pExpr;
95221       assert( ExprHasProperty(pExpr, EP_xIsSelect) );
95222       sNC.pSrcList = pS->pSrc;
95223       sNC.pNext = pNC;
95224       sNC.pParse = pNC->pParse;
95225       zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); 
95226       break;
95227     }
95228 #endif
95229   }
95230   
95231   if( pzOriginDb ){
95232     assert( pzOriginTab && pzOriginCol );
95233     *pzOriginDb = zOriginDb;
95234     *pzOriginTab = zOriginTab;
95235     *pzOriginCol = zOriginCol;
95236   }
95237   return zType;
95238 }
95239
95240 /*
95241 ** Generate code that will tell the VDBE the declaration types of columns
95242 ** in the result set.
95243 */
95244 static void generateColumnTypes(
95245   Parse *pParse,      /* Parser context */
95246   SrcList *pTabList,  /* List of tables */
95247   ExprList *pEList    /* Expressions defining the result set */
95248 ){
95249 #ifndef SQLCIPHER_OMIT_DECLTYPE
95250   Vdbe *v = pParse->pVdbe;
95251   int i;
95252   NameContext sNC;
95253   sNC.pSrcList = pTabList;
95254   sNC.pParse = pParse;
95255   for(i=0; i<pEList->nExpr; i++){
95256     Expr *p = pEList->a[i].pExpr;
95257     const char *zType;
95258 #ifdef SQLCIPHER_ENABLE_COLUMN_METADATA
95259     const char *zOrigDb = 0;
95260     const char *zOrigTab = 0;
95261     const char *zOrigCol = 0;
95262     zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
95263
95264     /* The vdbe must make its own copy of the column-type and other 
95265     ** column specific strings, in case the schema is reset before this
95266     ** virtual machine is deleted.
95267     */
95268     sqlcipher3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLCIPHER_TRANSIENT);
95269     sqlcipher3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLCIPHER_TRANSIENT);
95270     sqlcipher3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLCIPHER_TRANSIENT);
95271 #else
95272     zType = columnType(&sNC, p, 0, 0, 0);
95273 #endif
95274     sqlcipher3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLCIPHER_TRANSIENT);
95275   }
95276 #endif /* SQLCIPHER_OMIT_DECLTYPE */
95277 }
95278
95279 /*
95280 ** Generate code that will tell the VDBE the names of columns
95281 ** in the result set.  This information is used to provide the
95282 ** azCol[] values in the callback.
95283 */
95284 static void generateColumnNames(
95285   Parse *pParse,      /* Parser context */
95286   SrcList *pTabList,  /* List of tables */
95287   ExprList *pEList    /* Expressions defining the result set */
95288 ){
95289   Vdbe *v = pParse->pVdbe;
95290   int i, j;
95291   sqlcipher3 *db = pParse->db;
95292   int fullNames, shortNames;
95293
95294 #ifndef SQLCIPHER_OMIT_EXPLAIN
95295   /* If this is an EXPLAIN, skip this step */
95296   if( pParse->explain ){
95297     return;
95298   }
95299 #endif
95300
95301   if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return;
95302   pParse->colNamesSet = 1;
95303   fullNames = (db->flags & SQLCIPHER_FullColNames)!=0;
95304   shortNames = (db->flags & SQLCIPHER_ShortColNames)!=0;
95305   sqlcipher3VdbeSetNumCols(v, pEList->nExpr);
95306   for(i=0; i<pEList->nExpr; i++){
95307     Expr *p;
95308     p = pEList->a[i].pExpr;
95309     if( NEVER(p==0) ) continue;
95310     if( pEList->a[i].zName ){
95311       char *zName = pEList->a[i].zName;
95312       sqlcipher3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLCIPHER_TRANSIENT);
95313     }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){
95314       Table *pTab;
95315       char *zCol;
95316       int iCol = p->iColumn;
95317       for(j=0; ALWAYS(j<pTabList->nSrc); j++){
95318         if( pTabList->a[j].iCursor==p->iTable ) break;
95319       }
95320       assert( j<pTabList->nSrc );
95321       pTab = pTabList->a[j].pTab;
95322       if( iCol<0 ) iCol = pTab->iPKey;
95323       assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95324       if( iCol<0 ){
95325         zCol = "rowid";
95326       }else{
95327         zCol = pTab->aCol[iCol].zName;
95328       }
95329       if( !shortNames && !fullNames ){
95330         sqlcipher3VdbeSetColName(v, i, COLNAME_NAME, 
95331             sqlcipher3DbStrDup(db, pEList->a[i].zSpan), SQLCIPHER_DYNAMIC);
95332       }else if( fullNames ){
95333         char *zName = 0;
95334         zName = sqlcipher3MPrintf(db, "%s.%s", pTab->zName, zCol);
95335         sqlcipher3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLCIPHER_DYNAMIC);
95336       }else{
95337         sqlcipher3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLCIPHER_TRANSIENT);
95338       }
95339     }else{
95340       sqlcipher3VdbeSetColName(v, i, COLNAME_NAME, 
95341           sqlcipher3DbStrDup(db, pEList->a[i].zSpan), SQLCIPHER_DYNAMIC);
95342     }
95343   }
95344   generateColumnTypes(pParse, pTabList, pEList);
95345 }
95346
95347 /*
95348 ** Given a an expression list (which is really the list of expressions
95349 ** that form the result set of a SELECT statement) compute appropriate
95350 ** column names for a table that would hold the expression list.
95351 **
95352 ** All column names will be unique.
95353 **
95354 ** Only the column names are computed.  Column.zType, Column.zColl,
95355 ** and other fields of Column are zeroed.
95356 **
95357 ** Return SQLCIPHER_OK on success.  If a memory allocation error occurs,
95358 ** store NULL in *paCol and 0 in *pnCol and return SQLCIPHER_NOMEM.
95359 */
95360 static int selectColumnsFromExprList(
95361   Parse *pParse,          /* Parsing context */
95362   ExprList *pEList,       /* Expr list from which to derive column names */
95363   int *pnCol,             /* Write the number of columns here */
95364   Column **paCol          /* Write the new column list here */
95365 ){
95366   sqlcipher3 *db = pParse->db;   /* Database connection */
95367   int i, j;                   /* Loop counters */
95368   int cnt;                    /* Index added to make the name unique */
95369   Column *aCol, *pCol;        /* For looping over result columns */
95370   int nCol;                   /* Number of columns in the result set */
95371   Expr *p;                    /* Expression for a single result column */
95372   char *zName;                /* Column name */
95373   int nName;                  /* Size of name in zName[] */
95374
95375   *pnCol = nCol = pEList->nExpr;
95376   aCol = *paCol = sqlcipher3DbMallocZero(db, sizeof(aCol[0])*nCol);
95377   if( aCol==0 ) return SQLCIPHER_NOMEM;
95378   for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95379     /* Get an appropriate name for the column
95380     */
95381     p = pEList->a[i].pExpr;
95382     assert( p->pRight==0 || ExprHasProperty(p->pRight, EP_IntValue)
95383                || p->pRight->u.zToken==0 || p->pRight->u.zToken[0]!=0 );
95384     if( (zName = pEList->a[i].zName)!=0 ){
95385       /* If the column contains an "AS <name>" phrase, use <name> as the name */
95386       zName = sqlcipher3DbStrDup(db, zName);
95387     }else{
95388       Expr *pColExpr = p;  /* The expression that is the result column name */
95389       Table *pTab;         /* Table associated with this expression */
95390       while( pColExpr->op==TK_DOT ){
95391         pColExpr = pColExpr->pRight;
95392         assert( pColExpr!=0 );
95393       }
95394       if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
95395         /* For columns use the column name name */
95396         int iCol = pColExpr->iColumn;
95397         pTab = pColExpr->pTab;
95398         if( iCol<0 ) iCol = pTab->iPKey;
95399         zName = sqlcipher3MPrintf(db, "%s",
95400                  iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
95401       }else if( pColExpr->op==TK_ID ){
95402         assert( !ExprHasProperty(pColExpr, EP_IntValue) );
95403         zName = sqlcipher3MPrintf(db, "%s", pColExpr->u.zToken);
95404       }else{
95405         /* Use the original text of the column expression as its name */
95406         zName = sqlcipher3MPrintf(db, "%s", pEList->a[i].zSpan);
95407       }
95408     }
95409     if( db->mallocFailed ){
95410       sqlcipher3DbFree(db, zName);
95411       break;
95412     }
95413
95414     /* Make sure the column name is unique.  If the name is not unique,
95415     ** append a integer to the name so that it becomes unique.
95416     */
95417     nName = sqlcipher3Strlen30(zName);
95418     for(j=cnt=0; j<i; j++){
95419       if( sqlcipher3StrICmp(aCol[j].zName, zName)==0 ){
95420         char *zNewName;
95421         zName[nName] = 0;
95422         zNewName = sqlcipher3MPrintf(db, "%s:%d", zName, ++cnt);
95423         sqlcipher3DbFree(db, zName);
95424         zName = zNewName;
95425         j = -1;
95426         if( zName==0 ) break;
95427       }
95428     }
95429     pCol->zName = zName;
95430   }
95431   if( db->mallocFailed ){
95432     for(j=0; j<i; j++){
95433       sqlcipher3DbFree(db, aCol[j].zName);
95434     }
95435     sqlcipher3DbFree(db, aCol);
95436     *paCol = 0;
95437     *pnCol = 0;
95438     return SQLCIPHER_NOMEM;
95439   }
95440   return SQLCIPHER_OK;
95441 }
95442
95443 /*
95444 ** Add type and collation information to a column list based on
95445 ** a SELECT statement.
95446 ** 
95447 ** The column list presumably came from selectColumnNamesFromExprList().
95448 ** The column list has only names, not types or collations.  This
95449 ** routine goes through and adds the types and collations.
95450 **
95451 ** This routine requires that all identifiers in the SELECT
95452 ** statement be resolved.
95453 */
95454 static void selectAddColumnTypeAndCollation(
95455   Parse *pParse,        /* Parsing contexts */
95456   int nCol,             /* Number of columns */
95457   Column *aCol,         /* List of columns */
95458   Select *pSelect       /* SELECT used to determine types and collations */
95459 ){
95460   sqlcipher3 *db = pParse->db;
95461   NameContext sNC;
95462   Column *pCol;
95463   CollSeq *pColl;
95464   int i;
95465   Expr *p;
95466   struct ExprList_item *a;
95467
95468   assert( pSelect!=0 );
95469   assert( (pSelect->selFlags & SF_Resolved)!=0 );
95470   assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
95471   if( db->mallocFailed ) return;
95472   memset(&sNC, 0, sizeof(sNC));
95473   sNC.pSrcList = pSelect->pSrc;
95474   a = pSelect->pEList->a;
95475   for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95476     p = a[i].pExpr;
95477     pCol->zType = sqlcipher3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
95478     pCol->affinity = sqlcipher3ExprAffinity(p);
95479     if( pCol->affinity==0 ) pCol->affinity = SQLCIPHER_AFF_NONE;
95480     pColl = sqlcipher3ExprCollSeq(pParse, p);
95481     if( pColl ){
95482       pCol->zColl = sqlcipher3DbStrDup(db, pColl->zName);
95483     }
95484   }
95485 }
95486
95487 /*
95488 ** Given a SELECT statement, generate a Table structure that describes
95489 ** the result set of that SELECT.
95490 */
95491 SQLCIPHER_PRIVATE Table *sqlcipher3ResultSetOfSelect(Parse *pParse, Select *pSelect){
95492   Table *pTab;
95493   sqlcipher3 *db = pParse->db;
95494   int savedFlags;
95495
95496   savedFlags = db->flags;
95497   db->flags &= ~SQLCIPHER_FullColNames;
95498   db->flags |= SQLCIPHER_ShortColNames;
95499   sqlcipher3SelectPrep(pParse, pSelect, 0);
95500   if( pParse->nErr ) return 0;
95501   while( pSelect->pPrior ) pSelect = pSelect->pPrior;
95502   db->flags = savedFlags;
95503   pTab = sqlcipher3DbMallocZero(db, sizeof(Table) );
95504   if( pTab==0 ){
95505     return 0;
95506   }
95507   /* The sqlcipher3ResultSetOfSelect() is only used n contexts where lookaside
95508   ** is disabled */
95509   assert( db->lookaside.bEnabled==0 );
95510   pTab->nRef = 1;
95511   pTab->zName = 0;
95512   pTab->nRowEst = 1000000;
95513   selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
95514   selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
95515   pTab->iPKey = -1;
95516   if( db->mallocFailed ){
95517     sqlcipher3DeleteTable(db, pTab);
95518     return 0;
95519   }
95520   return pTab;
95521 }
95522
95523 /*
95524 ** Get a VDBE for the given parser context.  Create a new one if necessary.
95525 ** If an error occurs, return NULL and leave a message in pParse.
95526 */
95527 SQLCIPHER_PRIVATE Vdbe *sqlcipher3GetVdbe(Parse *pParse){
95528   Vdbe *v = pParse->pVdbe;
95529   if( v==0 ){
95530     v = pParse->pVdbe = sqlcipher3VdbeCreate(pParse->db);
95531 #ifndef SQLCIPHER_OMIT_TRACE
95532     if( v ){
95533       sqlcipher3VdbeAddOp0(v, OP_Trace);
95534     }
95535 #endif
95536   }
95537   return v;
95538 }
95539
95540
95541 /*
95542 ** Compute the iLimit and iOffset fields of the SELECT based on the
95543 ** pLimit and pOffset expressions.  pLimit and pOffset hold the expressions
95544 ** that appear in the original SQL statement after the LIMIT and OFFSET
95545 ** keywords.  Or NULL if those keywords are omitted. iLimit and iOffset 
95546 ** are the integer memory register numbers for counters used to compute 
95547 ** the limit and offset.  If there is no limit and/or offset, then 
95548 ** iLimit and iOffset are negative.
95549 **
95550 ** This routine changes the values of iLimit and iOffset only if
95551 ** a limit or offset is defined by pLimit and pOffset.  iLimit and
95552 ** iOffset should have been preset to appropriate default values
95553 ** (usually but not always -1) prior to calling this routine.
95554 ** Only if pLimit!=0 or pOffset!=0 do the limit registers get
95555 ** redefined.  The UNION ALL operator uses this property to force
95556 ** the reuse of the same limit and offset registers across multiple
95557 ** SELECT statements.
95558 */
95559 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
95560   Vdbe *v = 0;
95561   int iLimit = 0;
95562   int iOffset;
95563   int addr1, n;
95564   if( p->iLimit ) return;
95565
95566   /* 
95567   ** "LIMIT -1" always shows all rows.  There is some
95568   ** contraversy about what the correct behavior should be.
95569   ** The current implementation interprets "LIMIT 0" to mean
95570   ** no rows.
95571   */
95572   sqlcipher3ExprCacheClear(pParse);
95573   assert( p->pOffset==0 || p->pLimit!=0 );
95574   if( p->pLimit ){
95575     p->iLimit = iLimit = ++pParse->nMem;
95576     v = sqlcipher3GetVdbe(pParse);
95577     if( NEVER(v==0) ) return;  /* VDBE should have already been allocated */
95578     if( sqlcipher3ExprIsInteger(p->pLimit, &n) ){
95579       sqlcipher3VdbeAddOp2(v, OP_Integer, n, iLimit);
95580       VdbeComment((v, "LIMIT counter"));
95581       if( n==0 ){
95582         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, iBreak);
95583       }else{
95584         if( p->nSelectRow > (double)n ) p->nSelectRow = (double)n;
95585       }
95586     }else{
95587       sqlcipher3ExprCode(pParse, p->pLimit, iLimit);
95588       sqlcipher3VdbeAddOp1(v, OP_MustBeInt, iLimit);
95589       VdbeComment((v, "LIMIT counter"));
95590       sqlcipher3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
95591     }
95592     if( p->pOffset ){
95593       p->iOffset = iOffset = ++pParse->nMem;
95594       pParse->nMem++;   /* Allocate an extra register for limit+offset */
95595       sqlcipher3ExprCode(pParse, p->pOffset, iOffset);
95596       sqlcipher3VdbeAddOp1(v, OP_MustBeInt, iOffset);
95597       VdbeComment((v, "OFFSET counter"));
95598       addr1 = sqlcipher3VdbeAddOp1(v, OP_IfPos, iOffset);
95599       sqlcipher3VdbeAddOp2(v, OP_Integer, 0, iOffset);
95600       sqlcipher3VdbeJumpHere(v, addr1);
95601       sqlcipher3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
95602       VdbeComment((v, "LIMIT+OFFSET"));
95603       addr1 = sqlcipher3VdbeAddOp1(v, OP_IfPos, iLimit);
95604       sqlcipher3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
95605       sqlcipher3VdbeJumpHere(v, addr1);
95606     }
95607   }
95608 }
95609
95610 #ifndef SQLCIPHER_OMIT_COMPOUND_SELECT
95611 /*
95612 ** Return the appropriate collating sequence for the iCol-th column of
95613 ** the result set for the compound-select statement "p".  Return NULL if
95614 ** the column has no default collating sequence.
95615 **
95616 ** The collating sequence for the compound select is taken from the
95617 ** left-most term of the select that has a collating sequence.
95618 */
95619 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
95620   CollSeq *pRet;
95621   if( p->pPrior ){
95622     pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
95623   }else{
95624     pRet = 0;
95625   }
95626   assert( iCol>=0 );
95627   if( pRet==0 && iCol<p->pEList->nExpr ){
95628     pRet = sqlcipher3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
95629   }
95630   return pRet;
95631 }
95632 #endif /* SQLCIPHER_OMIT_COMPOUND_SELECT */
95633
95634 /* Forward reference */
95635 static int multiSelectOrderBy(
95636   Parse *pParse,        /* Parsing context */
95637   Select *p,            /* The right-most of SELECTs to be coded */
95638   SelectDest *pDest     /* What to do with query results */
95639 );
95640
95641
95642 #ifndef SQLCIPHER_OMIT_COMPOUND_SELECT
95643 /*
95644 ** This routine is called to process a compound query form from
95645 ** two or more separate queries using UNION, UNION ALL, EXCEPT, or
95646 ** INTERSECT
95647 **
95648 ** "p" points to the right-most of the two queries.  the query on the
95649 ** left is p->pPrior.  The left query could also be a compound query
95650 ** in which case this routine will be called recursively. 
95651 **
95652 ** The results of the total query are to be written into a destination
95653 ** of type eDest with parameter iParm.
95654 **
95655 ** Example 1:  Consider a three-way compound SQL statement.
95656 **
95657 **     SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
95658 **
95659 ** This statement is parsed up as follows:
95660 **
95661 **     SELECT c FROM t3
95662 **      |
95663 **      `----->  SELECT b FROM t2
95664 **                |
95665 **                `------>  SELECT a FROM t1
95666 **
95667 ** The arrows in the diagram above represent the Select.pPrior pointer.
95668 ** So if this routine is called with p equal to the t3 query, then
95669 ** pPrior will be the t2 query.  p->op will be TK_UNION in this case.
95670 **
95671 ** Notice that because of the way SQLite parses compound SELECTs, the
95672 ** individual selects always group from left to right.
95673 */
95674 static int multiSelect(
95675   Parse *pParse,        /* Parsing context */
95676   Select *p,            /* The right-most of SELECTs to be coded */
95677   SelectDest *pDest     /* What to do with query results */
95678 ){
95679   int rc = SQLCIPHER_OK;   /* Success code from a subroutine */
95680   Select *pPrior;       /* Another SELECT immediately to our left */
95681   Vdbe *v;              /* Generate code to this VDBE */
95682   SelectDest dest;      /* Alternative data destination */
95683   Select *pDelete = 0;  /* Chain of simple selects to delete */
95684   sqlcipher3 *db;          /* Database connection */
95685 #ifndef SQLCIPHER_OMIT_EXPLAIN
95686   int iSub1;            /* EQP id of left-hand query */
95687   int iSub2;            /* EQP id of right-hand query */
95688 #endif
95689
95690   /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs.  Only
95691   ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
95692   */
95693   assert( p && p->pPrior );  /* Calling function guarantees this much */
95694   db = pParse->db;
95695   pPrior = p->pPrior;
95696   assert( pPrior->pRightmost!=pPrior );
95697   assert( pPrior->pRightmost==p->pRightmost );
95698   dest = *pDest;
95699   if( pPrior->pOrderBy ){
95700     sqlcipher3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
95701       selectOpName(p->op));
95702     rc = 1;
95703     goto multi_select_end;
95704   }
95705   if( pPrior->pLimit ){
95706     sqlcipher3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
95707       selectOpName(p->op));
95708     rc = 1;
95709     goto multi_select_end;
95710   }
95711
95712   v = sqlcipher3GetVdbe(pParse);
95713   assert( v!=0 );  /* The VDBE already created by calling function */
95714
95715   /* Create the destination temporary table if necessary
95716   */
95717   if( dest.eDest==SRT_EphemTab ){
95718     assert( p->pEList );
95719     sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, dest.iParm, p->pEList->nExpr);
95720     sqlcipher3VdbeChangeP5(v, BTREE_UNORDERED);
95721     dest.eDest = SRT_Table;
95722   }
95723
95724   /* Make sure all SELECTs in the statement have the same number of elements
95725   ** in their result sets.
95726   */
95727   assert( p->pEList && pPrior->pEList );
95728   if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
95729     sqlcipher3ErrorMsg(pParse, "SELECTs to the left and right of %s"
95730       " do not have the same number of result columns", selectOpName(p->op));
95731     rc = 1;
95732     goto multi_select_end;
95733   }
95734
95735   /* Compound SELECTs that have an ORDER BY clause are handled separately.
95736   */
95737   if( p->pOrderBy ){
95738     return multiSelectOrderBy(pParse, p, pDest);
95739   }
95740
95741   /* Generate code for the left and right SELECT statements.
95742   */
95743   switch( p->op ){
95744     case TK_ALL: {
95745       int addr = 0;
95746       int nLimit;
95747       assert( !pPrior->pLimit );
95748       pPrior->pLimit = p->pLimit;
95749       pPrior->pOffset = p->pOffset;
95750       explainSetInteger(iSub1, pParse->iNextSelectId);
95751       rc = sqlcipher3Select(pParse, pPrior, &dest);
95752       p->pLimit = 0;
95753       p->pOffset = 0;
95754       if( rc ){
95755         goto multi_select_end;
95756       }
95757       p->pPrior = 0;
95758       p->iLimit = pPrior->iLimit;
95759       p->iOffset = pPrior->iOffset;
95760       if( p->iLimit ){
95761         addr = sqlcipher3VdbeAddOp1(v, OP_IfZero, p->iLimit);
95762         VdbeComment((v, "Jump ahead if LIMIT reached"));
95763       }
95764       explainSetInteger(iSub2, pParse->iNextSelectId);
95765       rc = sqlcipher3Select(pParse, p, &dest);
95766       testcase( rc!=SQLCIPHER_OK );
95767       pDelete = p->pPrior;
95768       p->pPrior = pPrior;
95769       p->nSelectRow += pPrior->nSelectRow;
95770       if( pPrior->pLimit
95771        && sqlcipher3ExprIsInteger(pPrior->pLimit, &nLimit)
95772        && p->nSelectRow > (double)nLimit 
95773       ){
95774         p->nSelectRow = (double)nLimit;
95775       }
95776       if( addr ){
95777         sqlcipher3VdbeJumpHere(v, addr);
95778       }
95779       break;
95780     }
95781     case TK_EXCEPT:
95782     case TK_UNION: {
95783       int unionTab;    /* Cursor number of the temporary table holding result */
95784       u8 op = 0;       /* One of the SRT_ operations to apply to self */
95785       int priorOp;     /* The SRT_ operation to apply to prior selects */
95786       Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
95787       int addr;
95788       SelectDest uniondest;
95789
95790       testcase( p->op==TK_EXCEPT );
95791       testcase( p->op==TK_UNION );
95792       priorOp = SRT_Union;
95793       if( dest.eDest==priorOp && ALWAYS(!p->pLimit &&!p->pOffset) ){
95794         /* We can reuse a temporary table generated by a SELECT to our
95795         ** right.
95796         */
95797         assert( p->pRightmost!=p );  /* Can only happen for leftward elements
95798                                      ** of a 3-way or more compound */
95799         assert( p->pLimit==0 );      /* Not allowed on leftward elements */
95800         assert( p->pOffset==0 );     /* Not allowed on leftward elements */
95801         unionTab = dest.iParm;
95802       }else{
95803         /* We will need to create our own temporary table to hold the
95804         ** intermediate results.
95805         */
95806         unionTab = pParse->nTab++;
95807         assert( p->pOrderBy==0 );
95808         addr = sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
95809         assert( p->addrOpenEphm[0] == -1 );
95810         p->addrOpenEphm[0] = addr;
95811         p->pRightmost->selFlags |= SF_UsesEphemeral;
95812         assert( p->pEList );
95813       }
95814
95815       /* Code the SELECT statements to our left
95816       */
95817       assert( !pPrior->pOrderBy );
95818       sqlcipher3SelectDestInit(&uniondest, priorOp, unionTab);
95819       explainSetInteger(iSub1, pParse->iNextSelectId);
95820       rc = sqlcipher3Select(pParse, pPrior, &uniondest);
95821       if( rc ){
95822         goto multi_select_end;
95823       }
95824
95825       /* Code the current SELECT statement
95826       */
95827       if( p->op==TK_EXCEPT ){
95828         op = SRT_Except;
95829       }else{
95830         assert( p->op==TK_UNION );
95831         op = SRT_Union;
95832       }
95833       p->pPrior = 0;
95834       pLimit = p->pLimit;
95835       p->pLimit = 0;
95836       pOffset = p->pOffset;
95837       p->pOffset = 0;
95838       uniondest.eDest = op;
95839       explainSetInteger(iSub2, pParse->iNextSelectId);
95840       rc = sqlcipher3Select(pParse, p, &uniondest);
95841       testcase( rc!=SQLCIPHER_OK );
95842       /* Query flattening in sqlcipher3Select() might refill p->pOrderBy.
95843       ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
95844       sqlcipher3ExprListDelete(db, p->pOrderBy);
95845       pDelete = p->pPrior;
95846       p->pPrior = pPrior;
95847       p->pOrderBy = 0;
95848       if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
95849       sqlcipher3ExprDelete(db, p->pLimit);
95850       p->pLimit = pLimit;
95851       p->pOffset = pOffset;
95852       p->iLimit = 0;
95853       p->iOffset = 0;
95854
95855       /* Convert the data in the temporary table into whatever form
95856       ** it is that we currently need.
95857       */
95858       assert( unionTab==dest.iParm || dest.eDest!=priorOp );
95859       if( dest.eDest!=priorOp ){
95860         int iCont, iBreak, iStart;
95861         assert( p->pEList );
95862         if( dest.eDest==SRT_Output ){
95863           Select *pFirst = p;
95864           while( pFirst->pPrior ) pFirst = pFirst->pPrior;
95865           generateColumnNames(pParse, 0, pFirst->pEList);
95866         }
95867         iBreak = sqlcipher3VdbeMakeLabel(v);
95868         iCont = sqlcipher3VdbeMakeLabel(v);
95869         computeLimitRegisters(pParse, p, iBreak);
95870         sqlcipher3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
95871         iStart = sqlcipher3VdbeCurrentAddr(v);
95872         selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
95873                         0, -1, &dest, iCont, iBreak);
95874         sqlcipher3VdbeResolveLabel(v, iCont);
95875         sqlcipher3VdbeAddOp2(v, OP_Next, unionTab, iStart);
95876         sqlcipher3VdbeResolveLabel(v, iBreak);
95877         sqlcipher3VdbeAddOp2(v, OP_Close, unionTab, 0);
95878       }
95879       break;
95880     }
95881     default: assert( p->op==TK_INTERSECT ); {
95882       int tab1, tab2;
95883       int iCont, iBreak, iStart;
95884       Expr *pLimit, *pOffset;
95885       int addr;
95886       SelectDest intersectdest;
95887       int r1;
95888
95889       /* INTERSECT is different from the others since it requires
95890       ** two temporary tables.  Hence it has its own case.  Begin
95891       ** by allocating the tables we will need.
95892       */
95893       tab1 = pParse->nTab++;
95894       tab2 = pParse->nTab++;
95895       assert( p->pOrderBy==0 );
95896
95897       addr = sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
95898       assert( p->addrOpenEphm[0] == -1 );
95899       p->addrOpenEphm[0] = addr;
95900       p->pRightmost->selFlags |= SF_UsesEphemeral;
95901       assert( p->pEList );
95902
95903       /* Code the SELECTs to our left into temporary table "tab1".
95904       */
95905       sqlcipher3SelectDestInit(&intersectdest, SRT_Union, tab1);
95906       explainSetInteger(iSub1, pParse->iNextSelectId);
95907       rc = sqlcipher3Select(pParse, pPrior, &intersectdest);
95908       if( rc ){
95909         goto multi_select_end;
95910       }
95911
95912       /* Code the current SELECT into temporary table "tab2"
95913       */
95914       addr = sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
95915       assert( p->addrOpenEphm[1] == -1 );
95916       p->addrOpenEphm[1] = addr;
95917       p->pPrior = 0;
95918       pLimit = p->pLimit;
95919       p->pLimit = 0;
95920       pOffset = p->pOffset;
95921       p->pOffset = 0;
95922       intersectdest.iParm = tab2;
95923       explainSetInteger(iSub2, pParse->iNextSelectId);
95924       rc = sqlcipher3Select(pParse, p, &intersectdest);
95925       testcase( rc!=SQLCIPHER_OK );
95926       pDelete = p->pPrior;
95927       p->pPrior = pPrior;
95928       if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
95929       sqlcipher3ExprDelete(db, p->pLimit);
95930       p->pLimit = pLimit;
95931       p->pOffset = pOffset;
95932
95933       /* Generate code to take the intersection of the two temporary
95934       ** tables.
95935       */
95936       assert( p->pEList );
95937       if( dest.eDest==SRT_Output ){
95938         Select *pFirst = p;
95939         while( pFirst->pPrior ) pFirst = pFirst->pPrior;
95940         generateColumnNames(pParse, 0, pFirst->pEList);
95941       }
95942       iBreak = sqlcipher3VdbeMakeLabel(v);
95943       iCont = sqlcipher3VdbeMakeLabel(v);
95944       computeLimitRegisters(pParse, p, iBreak);
95945       sqlcipher3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
95946       r1 = sqlcipher3GetTempReg(pParse);
95947       iStart = sqlcipher3VdbeAddOp2(v, OP_RowKey, tab1, r1);
95948       sqlcipher3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
95949       sqlcipher3ReleaseTempReg(pParse, r1);
95950       selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
95951                       0, -1, &dest, iCont, iBreak);
95952       sqlcipher3VdbeResolveLabel(v, iCont);
95953       sqlcipher3VdbeAddOp2(v, OP_Next, tab1, iStart);
95954       sqlcipher3VdbeResolveLabel(v, iBreak);
95955       sqlcipher3VdbeAddOp2(v, OP_Close, tab2, 0);
95956       sqlcipher3VdbeAddOp2(v, OP_Close, tab1, 0);
95957       break;
95958     }
95959   }
95960
95961   explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
95962
95963   /* Compute collating sequences used by 
95964   ** temporary tables needed to implement the compound select.
95965   ** Attach the KeyInfo structure to all temporary tables.
95966   **
95967   ** This section is run by the right-most SELECT statement only.
95968   ** SELECT statements to the left always skip this part.  The right-most
95969   ** SELECT might also skip this part if it has no ORDER BY clause and
95970   ** no temp tables are required.
95971   */
95972   if( p->selFlags & SF_UsesEphemeral ){
95973     int i;                        /* Loop counter */
95974     KeyInfo *pKeyInfo;            /* Collating sequence for the result set */
95975     Select *pLoop;                /* For looping through SELECT statements */
95976     CollSeq **apColl;             /* For looping through pKeyInfo->aColl[] */
95977     int nCol;                     /* Number of columns in result set */
95978
95979     assert( p->pRightmost==p );
95980     nCol = p->pEList->nExpr;
95981     pKeyInfo = sqlcipher3DbMallocZero(db,
95982                        sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
95983     if( !pKeyInfo ){
95984       rc = SQLCIPHER_NOMEM;
95985       goto multi_select_end;
95986     }
95987
95988     pKeyInfo->enc = ENC(db);
95989     pKeyInfo->nField = (u16)nCol;
95990
95991     for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
95992       *apColl = multiSelectCollSeq(pParse, p, i);
95993       if( 0==*apColl ){
95994         *apColl = db->pDfltColl;
95995       }
95996     }
95997
95998     for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
95999       for(i=0; i<2; i++){
96000         int addr = pLoop->addrOpenEphm[i];
96001         if( addr<0 ){
96002           /* If [0] is unused then [1] is also unused.  So we can
96003           ** always safely abort as soon as the first unused slot is found */
96004           assert( pLoop->addrOpenEphm[1]<0 );
96005           break;
96006         }
96007         sqlcipher3VdbeChangeP2(v, addr, nCol);
96008         sqlcipher3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO);
96009         pLoop->addrOpenEphm[i] = -1;
96010       }
96011     }
96012     sqlcipher3DbFree(db, pKeyInfo);
96013   }
96014
96015 multi_select_end:
96016   pDest->iMem = dest.iMem;
96017   pDest->nMem = dest.nMem;
96018   sqlcipher3SelectDelete(db, pDelete);
96019   return rc;
96020 }
96021 #endif /* SQLCIPHER_OMIT_COMPOUND_SELECT */
96022
96023 /*
96024 ** Code an output subroutine for a coroutine implementation of a
96025 ** SELECT statment.
96026 **
96027 ** The data to be output is contained in pIn->iMem.  There are
96028 ** pIn->nMem columns to be output.  pDest is where the output should
96029 ** be sent.
96030 **
96031 ** regReturn is the number of the register holding the subroutine
96032 ** return address.
96033 **
96034 ** If regPrev>0 then it is the first register in a vector that
96035 ** records the previous output.  mem[regPrev] is a flag that is false
96036 ** if there has been no previous output.  If regPrev>0 then code is
96037 ** generated to suppress duplicates.  pKeyInfo is used for comparing
96038 ** keys.
96039 **
96040 ** If the LIMIT found in p->iLimit is reached, jump immediately to
96041 ** iBreak.
96042 */
96043 static int generateOutputSubroutine(
96044   Parse *pParse,          /* Parsing context */
96045   Select *p,              /* The SELECT statement */
96046   SelectDest *pIn,        /* Coroutine supplying data */
96047   SelectDest *pDest,      /* Where to send the data */
96048   int regReturn,          /* The return address register */
96049   int regPrev,            /* Previous result register.  No uniqueness if 0 */
96050   KeyInfo *pKeyInfo,      /* For comparing with previous entry */
96051   int p4type,             /* The p4 type for pKeyInfo */
96052   int iBreak              /* Jump here if we hit the LIMIT */
96053 ){
96054   Vdbe *v = pParse->pVdbe;
96055   int iContinue;
96056   int addr;
96057
96058   addr = sqlcipher3VdbeCurrentAddr(v);
96059   iContinue = sqlcipher3VdbeMakeLabel(v);
96060
96061   /* Suppress duplicates for UNION, EXCEPT, and INTERSECT 
96062   */
96063   if( regPrev ){
96064     int j1, j2;
96065     j1 = sqlcipher3VdbeAddOp1(v, OP_IfNot, regPrev);
96066     j2 = sqlcipher3VdbeAddOp4(v, OP_Compare, pIn->iMem, regPrev+1, pIn->nMem,
96067                               (char*)pKeyInfo, p4type);
96068     sqlcipher3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2);
96069     sqlcipher3VdbeJumpHere(v, j1);
96070     sqlcipher3ExprCodeCopy(pParse, pIn->iMem, regPrev+1, pIn->nMem);
96071     sqlcipher3VdbeAddOp2(v, OP_Integer, 1, regPrev);
96072   }
96073   if( pParse->db->mallocFailed ) return 0;
96074
96075   /* Suppress the the first OFFSET entries if there is an OFFSET clause
96076   */
96077   codeOffset(v, p, iContinue);
96078
96079   switch( pDest->eDest ){
96080     /* Store the result as data using a unique key.
96081     */
96082     case SRT_Table:
96083     case SRT_EphemTab: {
96084       int r1 = sqlcipher3GetTempReg(pParse);
96085       int r2 = sqlcipher3GetTempReg(pParse);
96086       testcase( pDest->eDest==SRT_Table );
96087       testcase( pDest->eDest==SRT_EphemTab );
96088       sqlcipher3VdbeAddOp3(v, OP_MakeRecord, pIn->iMem, pIn->nMem, r1);
96089       sqlcipher3VdbeAddOp2(v, OP_NewRowid, pDest->iParm, r2);
96090       sqlcipher3VdbeAddOp3(v, OP_Insert, pDest->iParm, r1, r2);
96091       sqlcipher3VdbeChangeP5(v, OPFLAG_APPEND);
96092       sqlcipher3ReleaseTempReg(pParse, r2);
96093       sqlcipher3ReleaseTempReg(pParse, r1);
96094       break;
96095     }
96096
96097 #ifndef SQLCIPHER_OMIT_SUBQUERY
96098     /* If we are creating a set for an "expr IN (SELECT ...)" construct,
96099     ** then there should be a single item on the stack.  Write this
96100     ** item into the set table with bogus data.
96101     */
96102     case SRT_Set: {
96103       int r1;
96104       assert( pIn->nMem==1 );
96105       p->affinity = 
96106          sqlcipher3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
96107       r1 = sqlcipher3GetTempReg(pParse);
96108       sqlcipher3VdbeAddOp4(v, OP_MakeRecord, pIn->iMem, 1, r1, &p->affinity, 1);
96109       sqlcipher3ExprCacheAffinityChange(pParse, pIn->iMem, 1);
96110       sqlcipher3VdbeAddOp2(v, OP_IdxInsert, pDest->iParm, r1);
96111       sqlcipher3ReleaseTempReg(pParse, r1);
96112       break;
96113     }
96114
96115 #if 0  /* Never occurs on an ORDER BY query */
96116     /* If any row exist in the result set, record that fact and abort.
96117     */
96118     case SRT_Exists: {
96119       sqlcipher3VdbeAddOp2(v, OP_Integer, 1, pDest->iParm);
96120       /* The LIMIT clause will terminate the loop for us */
96121       break;
96122     }
96123 #endif
96124
96125     /* If this is a scalar select that is part of an expression, then
96126     ** store the results in the appropriate memory cell and break out
96127     ** of the scan loop.
96128     */
96129     case SRT_Mem: {
96130       assert( pIn->nMem==1 );
96131       sqlcipher3ExprCodeMove(pParse, pIn->iMem, pDest->iParm, 1);
96132       /* The LIMIT clause will jump out of the loop for us */
96133       break;
96134     }
96135 #endif /* #ifndef SQLCIPHER_OMIT_SUBQUERY */
96136
96137     /* The results are stored in a sequence of registers
96138     ** starting at pDest->iMem.  Then the co-routine yields.
96139     */
96140     case SRT_Coroutine: {
96141       if( pDest->iMem==0 ){
96142         pDest->iMem = sqlcipher3GetTempRange(pParse, pIn->nMem);
96143         pDest->nMem = pIn->nMem;
96144       }
96145       sqlcipher3ExprCodeMove(pParse, pIn->iMem, pDest->iMem, pDest->nMem);
96146       sqlcipher3VdbeAddOp1(v, OP_Yield, pDest->iParm);
96147       break;
96148     }
96149
96150     /* If none of the above, then the result destination must be
96151     ** SRT_Output.  This routine is never called with any other
96152     ** destination other than the ones handled above or SRT_Output.
96153     **
96154     ** For SRT_Output, results are stored in a sequence of registers.  
96155     ** Then the OP_ResultRow opcode is used to cause sqlcipher3_step() to
96156     ** return the next row of result.
96157     */
96158     default: {
96159       assert( pDest->eDest==SRT_Output );
96160       sqlcipher3VdbeAddOp2(v, OP_ResultRow, pIn->iMem, pIn->nMem);
96161       sqlcipher3ExprCacheAffinityChange(pParse, pIn->iMem, pIn->nMem);
96162       break;
96163     }
96164   }
96165
96166   /* Jump to the end of the loop if the LIMIT is reached.
96167   */
96168   if( p->iLimit ){
96169     sqlcipher3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
96170   }
96171
96172   /* Generate the subroutine return
96173   */
96174   sqlcipher3VdbeResolveLabel(v, iContinue);
96175   sqlcipher3VdbeAddOp1(v, OP_Return, regReturn);
96176
96177   return addr;
96178 }
96179
96180 /*
96181 ** Alternative compound select code generator for cases when there
96182 ** is an ORDER BY clause.
96183 **
96184 ** We assume a query of the following form:
96185 **
96186 **      <selectA>  <operator>  <selectB>  ORDER BY <orderbylist>
96187 **
96188 ** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT.  The idea
96189 ** is to code both <selectA> and <selectB> with the ORDER BY clause as
96190 ** co-routines.  Then run the co-routines in parallel and merge the results
96191 ** into the output.  In addition to the two coroutines (called selectA and
96192 ** selectB) there are 7 subroutines:
96193 **
96194 **    outA:    Move the output of the selectA coroutine into the output
96195 **             of the compound query.
96196 **
96197 **    outB:    Move the output of the selectB coroutine into the output
96198 **             of the compound query.  (Only generated for UNION and
96199 **             UNION ALL.  EXCEPT and INSERTSECT never output a row that
96200 **             appears only in B.)
96201 **
96202 **    AltB:    Called when there is data from both coroutines and A<B.
96203 **
96204 **    AeqB:    Called when there is data from both coroutines and A==B.
96205 **
96206 **    AgtB:    Called when there is data from both coroutines and A>B.
96207 **
96208 **    EofA:    Called when data is exhausted from selectA.
96209 **
96210 **    EofB:    Called when data is exhausted from selectB.
96211 **
96212 ** The implementation of the latter five subroutines depend on which 
96213 ** <operator> is used:
96214 **
96215 **
96216 **             UNION ALL         UNION            EXCEPT          INTERSECT
96217 **          -------------  -----------------  --------------  -----------------
96218 **   AltB:   outA, nextA      outA, nextA       outA, nextA         nextA
96219 **
96220 **   AeqB:   outA, nextA         nextA             nextA         outA, nextA
96221 **
96222 **   AgtB:   outB, nextB      outB, nextB          nextB            nextB
96223 **
96224 **   EofA:   outB, nextB      outB, nextB          halt             halt
96225 **
96226 **   EofB:   outA, nextA      outA, nextA       outA, nextA         halt
96227 **
96228 ** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
96229 ** causes an immediate jump to EofA and an EOF on B following nextB causes
96230 ** an immediate jump to EofB.  Within EofA and EofB, and EOF on entry or
96231 ** following nextX causes a jump to the end of the select processing.
96232 **
96233 ** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
96234 ** within the output subroutine.  The regPrev register set holds the previously
96235 ** output value.  A comparison is made against this value and the output
96236 ** is skipped if the next results would be the same as the previous.
96237 **
96238 ** The implementation plan is to implement the two coroutines and seven
96239 ** subroutines first, then put the control logic at the bottom.  Like this:
96240 **
96241 **          goto Init
96242 **     coA: coroutine for left query (A)
96243 **     coB: coroutine for right query (B)
96244 **    outA: output one row of A
96245 **    outB: output one row of B (UNION and UNION ALL only)
96246 **    EofA: ...
96247 **    EofB: ...
96248 **    AltB: ...
96249 **    AeqB: ...
96250 **    AgtB: ...
96251 **    Init: initialize coroutine registers
96252 **          yield coA
96253 **          if eof(A) goto EofA
96254 **          yield coB
96255 **          if eof(B) goto EofB
96256 **    Cmpr: Compare A, B
96257 **          Jump AltB, AeqB, AgtB
96258 **     End: ...
96259 **
96260 ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
96261 ** actually called using Gosub and they do not Return.  EofA and EofB loop
96262 ** until all data is exhausted then jump to the "end" labe.  AltB, AeqB,
96263 ** and AgtB jump to either L2 or to one of EofA or EofB.
96264 */
96265 #ifndef SQLCIPHER_OMIT_COMPOUND_SELECT
96266 static int multiSelectOrderBy(
96267   Parse *pParse,        /* Parsing context */
96268   Select *p,            /* The right-most of SELECTs to be coded */
96269   SelectDest *pDest     /* What to do with query results */
96270 ){
96271   int i, j;             /* Loop counters */
96272   Select *pPrior;       /* Another SELECT immediately to our left */
96273   Vdbe *v;              /* Generate code to this VDBE */
96274   SelectDest destA;     /* Destination for coroutine A */
96275   SelectDest destB;     /* Destination for coroutine B */
96276   int regAddrA;         /* Address register for select-A coroutine */
96277   int regEofA;          /* Flag to indicate when select-A is complete */
96278   int regAddrB;         /* Address register for select-B coroutine */
96279   int regEofB;          /* Flag to indicate when select-B is complete */
96280   int addrSelectA;      /* Address of the select-A coroutine */
96281   int addrSelectB;      /* Address of the select-B coroutine */
96282   int regOutA;          /* Address register for the output-A subroutine */
96283   int regOutB;          /* Address register for the output-B subroutine */
96284   int addrOutA;         /* Address of the output-A subroutine */
96285   int addrOutB = 0;     /* Address of the output-B subroutine */
96286   int addrEofA;         /* Address of the select-A-exhausted subroutine */
96287   int addrEofB;         /* Address of the select-B-exhausted subroutine */
96288   int addrAltB;         /* Address of the A<B subroutine */
96289   int addrAeqB;         /* Address of the A==B subroutine */
96290   int addrAgtB;         /* Address of the A>B subroutine */
96291   int regLimitA;        /* Limit register for select-A */
96292   int regLimitB;        /* Limit register for select-A */
96293   int regPrev;          /* A range of registers to hold previous output */
96294   int savedLimit;       /* Saved value of p->iLimit */
96295   int savedOffset;      /* Saved value of p->iOffset */
96296   int labelCmpr;        /* Label for the start of the merge algorithm */
96297   int labelEnd;         /* Label for the end of the overall SELECT stmt */
96298   int j1;               /* Jump instructions that get retargetted */
96299   int op;               /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
96300   KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
96301   KeyInfo *pKeyMerge;   /* Comparison information for merging rows */
96302   sqlcipher3 *db;          /* Database connection */
96303   ExprList *pOrderBy;   /* The ORDER BY clause */
96304   int nOrderBy;         /* Number of terms in the ORDER BY clause */
96305   int *aPermute;        /* Mapping from ORDER BY terms to result set columns */
96306 #ifndef SQLCIPHER_OMIT_EXPLAIN
96307   int iSub1;            /* EQP id of left-hand query */
96308   int iSub2;            /* EQP id of right-hand query */
96309 #endif
96310
96311   assert( p->pOrderBy!=0 );
96312   assert( pKeyDup==0 ); /* "Managed" code needs this.  Ticket #3382. */
96313   db = pParse->db;
96314   v = pParse->pVdbe;
96315   assert( v!=0 );       /* Already thrown the error if VDBE alloc failed */
96316   labelEnd = sqlcipher3VdbeMakeLabel(v);
96317   labelCmpr = sqlcipher3VdbeMakeLabel(v);
96318
96319
96320   /* Patch up the ORDER BY clause
96321   */
96322   op = p->op;  
96323   pPrior = p->pPrior;
96324   assert( pPrior->pOrderBy==0 );
96325   pOrderBy = p->pOrderBy;
96326   assert( pOrderBy );
96327   nOrderBy = pOrderBy->nExpr;
96328
96329   /* For operators other than UNION ALL we have to make sure that
96330   ** the ORDER BY clause covers every term of the result set.  Add
96331   ** terms to the ORDER BY clause as necessary.
96332   */
96333   if( op!=TK_ALL ){
96334     for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
96335       struct ExprList_item *pItem;
96336       for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
96337         assert( pItem->iCol>0 );
96338         if( pItem->iCol==i ) break;
96339       }
96340       if( j==nOrderBy ){
96341         Expr *pNew = sqlcipher3Expr(db, TK_INTEGER, 0);
96342         if( pNew==0 ) return SQLCIPHER_NOMEM;
96343         pNew->flags |= EP_IntValue;
96344         pNew->u.iValue = i;
96345         pOrderBy = sqlcipher3ExprListAppend(pParse, pOrderBy, pNew);
96346         pOrderBy->a[nOrderBy++].iCol = (u16)i;
96347       }
96348     }
96349   }
96350
96351   /* Compute the comparison permutation and keyinfo that is used with
96352   ** the permutation used to determine if the next
96353   ** row of results comes from selectA or selectB.  Also add explicit
96354   ** collations to the ORDER BY clause terms so that when the subqueries
96355   ** to the right and the left are evaluated, they use the correct
96356   ** collation.
96357   */
96358   aPermute = sqlcipher3DbMallocRaw(db, sizeof(int)*nOrderBy);
96359   if( aPermute ){
96360     struct ExprList_item *pItem;
96361     for(i=0, pItem=pOrderBy->a; i<nOrderBy; i++, pItem++){
96362       assert( pItem->iCol>0  && pItem->iCol<=p->pEList->nExpr );
96363       aPermute[i] = pItem->iCol - 1;
96364     }
96365     pKeyMerge =
96366       sqlcipher3DbMallocRaw(db, sizeof(*pKeyMerge)+nOrderBy*(sizeof(CollSeq*)+1));
96367     if( pKeyMerge ){
96368       pKeyMerge->aSortOrder = (u8*)&pKeyMerge->aColl[nOrderBy];
96369       pKeyMerge->nField = (u16)nOrderBy;
96370       pKeyMerge->enc = ENC(db);
96371       for(i=0; i<nOrderBy; i++){
96372         CollSeq *pColl;
96373         Expr *pTerm = pOrderBy->a[i].pExpr;
96374         if( pTerm->flags & EP_ExpCollate ){
96375           pColl = pTerm->pColl;
96376         }else{
96377           pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
96378           pTerm->flags |= EP_ExpCollate;
96379           pTerm->pColl = pColl;
96380         }
96381         pKeyMerge->aColl[i] = pColl;
96382         pKeyMerge->aSortOrder[i] = pOrderBy->a[i].sortOrder;
96383       }
96384     }
96385   }else{
96386     pKeyMerge = 0;
96387   }
96388
96389   /* Reattach the ORDER BY clause to the query.
96390   */
96391   p->pOrderBy = pOrderBy;
96392   pPrior->pOrderBy = sqlcipher3ExprListDup(pParse->db, pOrderBy, 0);
96393
96394   /* Allocate a range of temporary registers and the KeyInfo needed
96395   ** for the logic that removes duplicate result rows when the
96396   ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
96397   */
96398   if( op==TK_ALL ){
96399     regPrev = 0;
96400   }else{
96401     int nExpr = p->pEList->nExpr;
96402     assert( nOrderBy>=nExpr || db->mallocFailed );
96403     regPrev = sqlcipher3GetTempRange(pParse, nExpr+1);
96404     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regPrev);
96405     pKeyDup = sqlcipher3DbMallocZero(db,
96406                   sizeof(*pKeyDup) + nExpr*(sizeof(CollSeq*)+1) );
96407     if( pKeyDup ){
96408       pKeyDup->aSortOrder = (u8*)&pKeyDup->aColl[nExpr];
96409       pKeyDup->nField = (u16)nExpr;
96410       pKeyDup->enc = ENC(db);
96411       for(i=0; i<nExpr; i++){
96412         pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
96413         pKeyDup->aSortOrder[i] = 0;
96414       }
96415     }
96416   }
96417  
96418   /* Separate the left and the right query from one another
96419   */
96420   p->pPrior = 0;
96421   sqlcipher3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
96422   if( pPrior->pPrior==0 ){
96423     sqlcipher3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
96424   }
96425
96426   /* Compute the limit registers */
96427   computeLimitRegisters(pParse, p, labelEnd);
96428   if( p->iLimit && op==TK_ALL ){
96429     regLimitA = ++pParse->nMem;
96430     regLimitB = ++pParse->nMem;
96431     sqlcipher3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
96432                                   regLimitA);
96433     sqlcipher3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
96434   }else{
96435     regLimitA = regLimitB = 0;
96436   }
96437   sqlcipher3ExprDelete(db, p->pLimit);
96438   p->pLimit = 0;
96439   sqlcipher3ExprDelete(db, p->pOffset);
96440   p->pOffset = 0;
96441
96442   regAddrA = ++pParse->nMem;
96443   regEofA = ++pParse->nMem;
96444   regAddrB = ++pParse->nMem;
96445   regEofB = ++pParse->nMem;
96446   regOutA = ++pParse->nMem;
96447   regOutB = ++pParse->nMem;
96448   sqlcipher3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
96449   sqlcipher3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
96450
96451   /* Jump past the various subroutines and coroutines to the main
96452   ** merge loop
96453   */
96454   j1 = sqlcipher3VdbeAddOp0(v, OP_Goto);
96455   addrSelectA = sqlcipher3VdbeCurrentAddr(v);
96456
96457
96458   /* Generate a coroutine to evaluate the SELECT statement to the
96459   ** left of the compound operator - the "A" select.
96460   */
96461   VdbeNoopComment((v, "Begin coroutine for left SELECT"));
96462   pPrior->iLimit = regLimitA;
96463   explainSetInteger(iSub1, pParse->iNextSelectId);
96464   sqlcipher3Select(pParse, pPrior, &destA);
96465   sqlcipher3VdbeAddOp2(v, OP_Integer, 1, regEofA);
96466   sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrA);
96467   VdbeNoopComment((v, "End coroutine for left SELECT"));
96468
96469   /* Generate a coroutine to evaluate the SELECT statement on 
96470   ** the right - the "B" select
96471   */
96472   addrSelectB = sqlcipher3VdbeCurrentAddr(v);
96473   VdbeNoopComment((v, "Begin coroutine for right SELECT"));
96474   savedLimit = p->iLimit;
96475   savedOffset = p->iOffset;
96476   p->iLimit = regLimitB;
96477   p->iOffset = 0;  
96478   explainSetInteger(iSub2, pParse->iNextSelectId);
96479   sqlcipher3Select(pParse, p, &destB);
96480   p->iLimit = savedLimit;
96481   p->iOffset = savedOffset;
96482   sqlcipher3VdbeAddOp2(v, OP_Integer, 1, regEofB);
96483   sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrB);
96484   VdbeNoopComment((v, "End coroutine for right SELECT"));
96485
96486   /* Generate a subroutine that outputs the current row of the A
96487   ** select as the next output row of the compound select.
96488   */
96489   VdbeNoopComment((v, "Output routine for A"));
96490   addrOutA = generateOutputSubroutine(pParse,
96491                  p, &destA, pDest, regOutA,
96492                  regPrev, pKeyDup, P4_KEYINFO_HANDOFF, labelEnd);
96493   
96494   /* Generate a subroutine that outputs the current row of the B
96495   ** select as the next output row of the compound select.
96496   */
96497   if( op==TK_ALL || op==TK_UNION ){
96498     VdbeNoopComment((v, "Output routine for B"));
96499     addrOutB = generateOutputSubroutine(pParse,
96500                  p, &destB, pDest, regOutB,
96501                  regPrev, pKeyDup, P4_KEYINFO_STATIC, labelEnd);
96502   }
96503
96504   /* Generate a subroutine to run when the results from select A
96505   ** are exhausted and only data in select B remains.
96506   */
96507   VdbeNoopComment((v, "eof-A subroutine"));
96508   if( op==TK_EXCEPT || op==TK_INTERSECT ){
96509     addrEofA = sqlcipher3VdbeAddOp2(v, OP_Goto, 0, labelEnd);
96510   }else{  
96511     addrEofA = sqlcipher3VdbeAddOp2(v, OP_If, regEofB, labelEnd);
96512     sqlcipher3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
96513     sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrB);
96514     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addrEofA);
96515     p->nSelectRow += pPrior->nSelectRow;
96516   }
96517
96518   /* Generate a subroutine to run when the results from select B
96519   ** are exhausted and only data in select A remains.
96520   */
96521   if( op==TK_INTERSECT ){
96522     addrEofB = addrEofA;
96523     if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
96524   }else{  
96525     VdbeNoopComment((v, "eof-B subroutine"));
96526     addrEofB = sqlcipher3VdbeAddOp2(v, OP_If, regEofA, labelEnd);
96527     sqlcipher3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
96528     sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrA);
96529     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addrEofB);
96530   }
96531
96532   /* Generate code to handle the case of A<B
96533   */
96534   VdbeNoopComment((v, "A-lt-B subroutine"));
96535   addrAltB = sqlcipher3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
96536   sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrA);
96537   sqlcipher3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
96538   sqlcipher3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
96539
96540   /* Generate code to handle the case of A==B
96541   */
96542   if( op==TK_ALL ){
96543     addrAeqB = addrAltB;
96544   }else if( op==TK_INTERSECT ){
96545     addrAeqB = addrAltB;
96546     addrAltB++;
96547   }else{
96548     VdbeNoopComment((v, "A-eq-B subroutine"));
96549     addrAeqB =
96550     sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrA);
96551     sqlcipher3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
96552     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
96553   }
96554
96555   /* Generate code to handle the case of A>B
96556   */
96557   VdbeNoopComment((v, "A-gt-B subroutine"));
96558   addrAgtB = sqlcipher3VdbeCurrentAddr(v);
96559   if( op==TK_ALL || op==TK_UNION ){
96560     sqlcipher3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
96561   }
96562   sqlcipher3VdbeAddOp1(v, OP_Yield, regAddrB);
96563   sqlcipher3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
96564   sqlcipher3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
96565
96566   /* This code runs once to initialize everything.
96567   */
96568   sqlcipher3VdbeJumpHere(v, j1);
96569   sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regEofA);
96570   sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regEofB);
96571   sqlcipher3VdbeAddOp2(v, OP_Gosub, regAddrA, addrSelectA);
96572   sqlcipher3VdbeAddOp2(v, OP_Gosub, regAddrB, addrSelectB);
96573   sqlcipher3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
96574   sqlcipher3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
96575
96576   /* Implement the main merge loop
96577   */
96578   sqlcipher3VdbeResolveLabel(v, labelCmpr);
96579   sqlcipher3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
96580   sqlcipher3VdbeAddOp4(v, OP_Compare, destA.iMem, destB.iMem, nOrderBy,
96581                          (char*)pKeyMerge, P4_KEYINFO_HANDOFF);
96582   sqlcipher3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB);
96583
96584   /* Release temporary registers
96585   */
96586   if( regPrev ){
96587     sqlcipher3ReleaseTempRange(pParse, regPrev, nOrderBy+1);
96588   }
96589
96590   /* Jump to the this point in order to terminate the query.
96591   */
96592   sqlcipher3VdbeResolveLabel(v, labelEnd);
96593
96594   /* Set the number of output columns
96595   */
96596   if( pDest->eDest==SRT_Output ){
96597     Select *pFirst = pPrior;
96598     while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96599     generateColumnNames(pParse, 0, pFirst->pEList);
96600   }
96601
96602   /* Reassembly the compound query so that it will be freed correctly
96603   ** by the calling function */
96604   if( p->pPrior ){
96605     sqlcipher3SelectDelete(db, p->pPrior);
96606   }
96607   p->pPrior = pPrior;
96608
96609   /*** TBD:  Insert subroutine calls to close cursors on incomplete
96610   **** subqueries ****/
96611   explainComposite(pParse, p->op, iSub1, iSub2, 0);
96612   return SQLCIPHER_OK;
96613 }
96614 #endif
96615
96616 #if !defined(SQLCIPHER_OMIT_SUBQUERY) || !defined(SQLCIPHER_OMIT_VIEW)
96617 /* Forward Declarations */
96618 static void substExprList(sqlcipher3*, ExprList*, int, ExprList*);
96619 static void substSelect(sqlcipher3*, Select *, int, ExprList *);
96620
96621 /*
96622 ** Scan through the expression pExpr.  Replace every reference to
96623 ** a column in table number iTable with a copy of the iColumn-th
96624 ** entry in pEList.  (But leave references to the ROWID column 
96625 ** unchanged.)
96626 **
96627 ** This routine is part of the flattening procedure.  A subquery
96628 ** whose result set is defined by pEList appears as entry in the
96629 ** FROM clause of a SELECT such that the VDBE cursor assigned to that
96630 ** FORM clause entry is iTable.  This routine make the necessary 
96631 ** changes to pExpr so that it refers directly to the source table
96632 ** of the subquery rather the result set of the subquery.
96633 */
96634 static Expr *substExpr(
96635   sqlcipher3 *db,        /* Report malloc errors to this connection */
96636   Expr *pExpr,        /* Expr in which substitution occurs */
96637   int iTable,         /* Table to be substituted */
96638   ExprList *pEList    /* Substitute expressions */
96639 ){
96640   if( pExpr==0 ) return 0;
96641   if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
96642     if( pExpr->iColumn<0 ){
96643       pExpr->op = TK_NULL;
96644     }else{
96645       Expr *pNew;
96646       assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
96647       assert( pExpr->pLeft==0 && pExpr->pRight==0 );
96648       pNew = sqlcipher3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
96649       if( pNew && pExpr->pColl ){
96650         pNew->pColl = pExpr->pColl;
96651       }
96652       sqlcipher3ExprDelete(db, pExpr);
96653       pExpr = pNew;
96654     }
96655   }else{
96656     pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
96657     pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
96658     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
96659       substSelect(db, pExpr->x.pSelect, iTable, pEList);
96660     }else{
96661       substExprList(db, pExpr->x.pList, iTable, pEList);
96662     }
96663   }
96664   return pExpr;
96665 }
96666 static void substExprList(
96667   sqlcipher3 *db,         /* Report malloc errors here */
96668   ExprList *pList,     /* List to scan and in which to make substitutes */
96669   int iTable,          /* Table to be substituted */
96670   ExprList *pEList     /* Substitute values */
96671 ){
96672   int i;
96673   if( pList==0 ) return;
96674   for(i=0; i<pList->nExpr; i++){
96675     pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
96676   }
96677 }
96678 static void substSelect(
96679   sqlcipher3 *db,         /* Report malloc errors here */
96680   Select *p,           /* SELECT statement in which to make substitutions */
96681   int iTable,          /* Table to be replaced */
96682   ExprList *pEList     /* Substitute values */
96683 ){
96684   SrcList *pSrc;
96685   struct SrcList_item *pItem;
96686   int i;
96687   if( !p ) return;
96688   substExprList(db, p->pEList, iTable, pEList);
96689   substExprList(db, p->pGroupBy, iTable, pEList);
96690   substExprList(db, p->pOrderBy, iTable, pEList);
96691   p->pHaving = substExpr(db, p->pHaving, iTable, pEList);
96692   p->pWhere = substExpr(db, p->pWhere, iTable, pEList);
96693   substSelect(db, p->pPrior, iTable, pEList);
96694   pSrc = p->pSrc;
96695   assert( pSrc );  /* Even for (SELECT 1) we have: pSrc!=0 but pSrc->nSrc==0 */
96696   if( ALWAYS(pSrc) ){
96697     for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
96698       substSelect(db, pItem->pSelect, iTable, pEList);
96699     }
96700   }
96701 }
96702 #endif /* !defined(SQLCIPHER_OMIT_SUBQUERY) || !defined(SQLCIPHER_OMIT_VIEW) */
96703
96704 #if !defined(SQLCIPHER_OMIT_SUBQUERY) || !defined(SQLCIPHER_OMIT_VIEW)
96705 /*
96706 ** This routine attempts to flatten subqueries in order to speed
96707 ** execution.  It returns 1 if it makes changes and 0 if no flattening
96708 ** occurs.
96709 **
96710 ** To understand the concept of flattening, consider the following
96711 ** query:
96712 **
96713 **     SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
96714 **
96715 ** The default way of implementing this query is to execute the
96716 ** subquery first and store the results in a temporary table, then
96717 ** run the outer query on that temporary table.  This requires two
96718 ** passes over the data.  Furthermore, because the temporary table
96719 ** has no indices, the WHERE clause on the outer query cannot be
96720 ** optimized.
96721 **
96722 ** This routine attempts to rewrite queries such as the above into
96723 ** a single flat select, like this:
96724 **
96725 **     SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
96726 **
96727 ** The code generated for this simpification gives the same result
96728 ** but only has to scan the data once.  And because indices might 
96729 ** exist on the table t1, a complete scan of the data might be
96730 ** avoided.
96731 **
96732 ** Flattening is only attempted if all of the following are true:
96733 **
96734 **   (1)  The subquery and the outer query do not both use aggregates.
96735 **
96736 **   (2)  The subquery is not an aggregate or the outer query is not a join.
96737 **
96738 **   (3)  The subquery is not the right operand of a left outer join
96739 **        (Originally ticket #306.  Strengthened by ticket #3300)
96740 **
96741 **   (4)  The subquery is not DISTINCT.
96742 **
96743 **  (**)  At one point restrictions (4) and (5) defined a subset of DISTINCT
96744 **        sub-queries that were excluded from this optimization. Restriction 
96745 **        (4) has since been expanded to exclude all DISTINCT subqueries.
96746 **
96747 **   (6)  The subquery does not use aggregates or the outer query is not
96748 **        DISTINCT.
96749 **
96750 **   (7)  The subquery has a FROM clause.
96751 **
96752 **   (8)  The subquery does not use LIMIT or the outer query is not a join.
96753 **
96754 **   (9)  The subquery does not use LIMIT or the outer query does not use
96755 **        aggregates.
96756 **
96757 **  (10)  The subquery does not use aggregates or the outer query does not
96758 **        use LIMIT.
96759 **
96760 **  (11)  The subquery and the outer query do not both have ORDER BY clauses.
96761 **
96762 **  (**)  Not implemented.  Subsumed into restriction (3).  Was previously
96763 **        a separate restriction deriving from ticket #350.
96764 **
96765 **  (13)  The subquery and outer query do not both use LIMIT.
96766 **
96767 **  (14)  The subquery does not use OFFSET.
96768 **
96769 **  (15)  The outer query is not part of a compound select or the
96770 **        subquery does not have a LIMIT clause.
96771 **        (See ticket #2339 and ticket [02a8e81d44]).
96772 **
96773 **  (16)  The outer query is not an aggregate or the subquery does
96774 **        not contain ORDER BY.  (Ticket #2942)  This used to not matter
96775 **        until we introduced the group_concat() function.  
96776 **
96777 **  (17)  The sub-query is not a compound select, or it is a UNION ALL 
96778 **        compound clause made up entirely of non-aggregate queries, and 
96779 **        the parent query:
96780 **
96781 **          * is not itself part of a compound select,
96782 **          * is not an aggregate or DISTINCT query, and
96783 **          * has no other tables or sub-selects in the FROM clause.
96784 **
96785 **        The parent and sub-query may contain WHERE clauses. Subject to
96786 **        rules (11), (13) and (14), they may also contain ORDER BY,
96787 **        LIMIT and OFFSET clauses.
96788 **
96789 **  (18)  If the sub-query is a compound select, then all terms of the
96790 **        ORDER by clause of the parent must be simple references to 
96791 **        columns of the sub-query.
96792 **
96793 **  (19)  The subquery does not use LIMIT or the outer query does not
96794 **        have a WHERE clause.
96795 **
96796 **  (20)  If the sub-query is a compound select, then it must not use
96797 **        an ORDER BY clause.  Ticket #3773.  We could relax this constraint
96798 **        somewhat by saying that the terms of the ORDER BY clause must
96799 **        appear as unmodified result columns in the outer query.  But
96800 **        have other optimizations in mind to deal with that case.
96801 **
96802 **  (21)  The subquery does not use LIMIT or the outer query is not
96803 **        DISTINCT.  (See ticket [752e1646fc]).
96804 **
96805 ** In this routine, the "p" parameter is a pointer to the outer query.
96806 ** The subquery is p->pSrc->a[iFrom].  isAgg is true if the outer query
96807 ** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
96808 **
96809 ** If flattening is not attempted, this routine is a no-op and returns 0.
96810 ** If flattening is attempted this routine returns 1.
96811 **
96812 ** All of the expression analysis must occur on both the outer query and
96813 ** the subquery before this routine runs.
96814 */
96815 static int flattenSubquery(
96816   Parse *pParse,       /* Parsing context */
96817   Select *p,           /* The parent or outer SELECT statement */
96818   int iFrom,           /* Index in p->pSrc->a[] of the inner subquery */
96819   int isAgg,           /* True if outer SELECT uses aggregate functions */
96820   int subqueryIsAgg    /* True if the subquery uses aggregate functions */
96821 ){
96822   const char *zSavedAuthContext = pParse->zAuthContext;
96823   Select *pParent;
96824   Select *pSub;       /* The inner query or "subquery" */
96825   Select *pSub1;      /* Pointer to the rightmost select in sub-query */
96826   SrcList *pSrc;      /* The FROM clause of the outer query */
96827   SrcList *pSubSrc;   /* The FROM clause of the subquery */
96828   ExprList *pList;    /* The result set of the outer query */
96829   int iParent;        /* VDBE cursor number of the pSub result set temp table */
96830   int i;              /* Loop counter */
96831   Expr *pWhere;                    /* The WHERE clause */
96832   struct SrcList_item *pSubitem;   /* The subquery */
96833   sqlcipher3 *db = pParse->db;
96834
96835   /* Check to see if flattening is permitted.  Return 0 if not.
96836   */
96837   assert( p!=0 );
96838   assert( p->pPrior==0 );  /* Unable to flatten compound queries */
96839   if( db->flags & SQLCIPHER_QueryFlattener ) return 0;
96840   pSrc = p->pSrc;
96841   assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
96842   pSubitem = &pSrc->a[iFrom];
96843   iParent = pSubitem->iCursor;
96844   pSub = pSubitem->pSelect;
96845   assert( pSub!=0 );
96846   if( isAgg && subqueryIsAgg ) return 0;                 /* Restriction (1)  */
96847   if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;          /* Restriction (2)  */
96848   pSubSrc = pSub->pSrc;
96849   assert( pSubSrc );
96850   /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
96851   ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
96852   ** because they could be computed at compile-time.  But when LIMIT and OFFSET
96853   ** became arbitrary expressions, we were forced to add restrictions (13)
96854   ** and (14). */
96855   if( pSub->pLimit && p->pLimit ) return 0;              /* Restriction (13) */
96856   if( pSub->pOffset ) return 0;                          /* Restriction (14) */
96857   if( p->pRightmost && pSub->pLimit ){
96858     return 0;                                            /* Restriction (15) */
96859   }
96860   if( pSubSrc->nSrc==0 ) return 0;                       /* Restriction (7)  */
96861   if( pSub->selFlags & SF_Distinct ) return 0;           /* Restriction (5)  */
96862   if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
96863      return 0;         /* Restrictions (8)(9) */
96864   }
96865   if( (p->selFlags & SF_Distinct)!=0 && subqueryIsAgg ){
96866      return 0;         /* Restriction (6)  */
96867   }
96868   if( p->pOrderBy && pSub->pOrderBy ){
96869      return 0;                                           /* Restriction (11) */
96870   }
96871   if( isAgg && pSub->pOrderBy ) return 0;                /* Restriction (16) */
96872   if( pSub->pLimit && p->pWhere ) return 0;              /* Restriction (19) */
96873   if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
96874      return 0;         /* Restriction (21) */
96875   }
96876
96877   /* OBSOLETE COMMENT 1:
96878   ** Restriction 3:  If the subquery is a join, make sure the subquery is 
96879   ** not used as the right operand of an outer join.  Examples of why this
96880   ** is not allowed:
96881   **
96882   **         t1 LEFT OUTER JOIN (t2 JOIN t3)
96883   **
96884   ** If we flatten the above, we would get
96885   **
96886   **         (t1 LEFT OUTER JOIN t2) JOIN t3
96887   **
96888   ** which is not at all the same thing.
96889   **
96890   ** OBSOLETE COMMENT 2:
96891   ** Restriction 12:  If the subquery is the right operand of a left outer
96892   ** join, make sure the subquery has no WHERE clause.
96893   ** An examples of why this is not allowed:
96894   **
96895   **         t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
96896   **
96897   ** If we flatten the above, we would get
96898   **
96899   **         (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
96900   **
96901   ** But the t2.x>0 test will always fail on a NULL row of t2, which
96902   ** effectively converts the OUTER JOIN into an INNER JOIN.
96903   **
96904   ** THIS OVERRIDES OBSOLETE COMMENTS 1 AND 2 ABOVE:
96905   ** Ticket #3300 shows that flattening the right term of a LEFT JOIN
96906   ** is fraught with danger.  Best to avoid the whole thing.  If the
96907   ** subquery is the right term of a LEFT JOIN, then do not flatten.
96908   */
96909   if( (pSubitem->jointype & JT_OUTER)!=0 ){
96910     return 0;
96911   }
96912
96913   /* Restriction 17: If the sub-query is a compound SELECT, then it must
96914   ** use only the UNION ALL operator. And none of the simple select queries
96915   ** that make up the compound SELECT are allowed to be aggregate or distinct
96916   ** queries.
96917   */
96918   if( pSub->pPrior ){
96919     if( pSub->pOrderBy ){
96920       return 0;  /* Restriction 20 */
96921     }
96922     if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
96923       return 0;
96924     }
96925     for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
96926       testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
96927       testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
96928       if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0
96929        || (pSub1->pPrior && pSub1->op!=TK_ALL) 
96930        || NEVER(pSub1->pSrc==0) || pSub1->pSrc->nSrc!=1
96931       ){
96932         return 0;
96933       }
96934     }
96935
96936     /* Restriction 18. */
96937     if( p->pOrderBy ){
96938       int ii;
96939       for(ii=0; ii<p->pOrderBy->nExpr; ii++){
96940         if( p->pOrderBy->a[ii].iCol==0 ) return 0;
96941       }
96942     }
96943   }
96944
96945   /***** If we reach this point, flattening is permitted. *****/
96946
96947   /* Authorize the subquery */
96948   pParse->zAuthContext = pSubitem->zName;
96949   sqlcipher3AuthCheck(pParse, SQLCIPHER_SELECT, 0, 0, 0);
96950   pParse->zAuthContext = zSavedAuthContext;
96951
96952   /* If the sub-query is a compound SELECT statement, then (by restrictions
96953   ** 17 and 18 above) it must be a UNION ALL and the parent query must 
96954   ** be of the form:
96955   **
96956   **     SELECT <expr-list> FROM (<sub-query>) <where-clause> 
96957   **
96958   ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
96959   ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or 
96960   ** OFFSET clauses and joins them to the left-hand-side of the original
96961   ** using UNION ALL operators. In this case N is the number of simple
96962   ** select statements in the compound sub-query.
96963   **
96964   ** Example:
96965   **
96966   **     SELECT a+1 FROM (
96967   **        SELECT x FROM tab
96968   **        UNION ALL
96969   **        SELECT y FROM tab
96970   **        UNION ALL
96971   **        SELECT abs(z*2) FROM tab2
96972   **     ) WHERE a!=5 ORDER BY 1
96973   **
96974   ** Transformed into:
96975   **
96976   **     SELECT x+1 FROM tab WHERE x+1!=5
96977   **     UNION ALL
96978   **     SELECT y+1 FROM tab WHERE y+1!=5
96979   **     UNION ALL
96980   **     SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
96981   **     ORDER BY 1
96982   **
96983   ** We call this the "compound-subquery flattening".
96984   */
96985   for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
96986     Select *pNew;
96987     ExprList *pOrderBy = p->pOrderBy;
96988     Expr *pLimit = p->pLimit;
96989     Select *pPrior = p->pPrior;
96990     p->pOrderBy = 0;
96991     p->pSrc = 0;
96992     p->pPrior = 0;
96993     p->pLimit = 0;
96994     pNew = sqlcipher3SelectDup(db, p, 0);
96995     p->pLimit = pLimit;
96996     p->pOrderBy = pOrderBy;
96997     p->pSrc = pSrc;
96998     p->op = TK_ALL;
96999     p->pRightmost = 0;
97000     if( pNew==0 ){
97001       pNew = pPrior;
97002     }else{
97003       pNew->pPrior = pPrior;
97004       pNew->pRightmost = 0;
97005     }
97006     p->pPrior = pNew;
97007     if( db->mallocFailed ) return 1;
97008   }
97009
97010   /* Begin flattening the iFrom-th entry of the FROM clause 
97011   ** in the outer query.
97012   */
97013   pSub = pSub1 = pSubitem->pSelect;
97014
97015   /* Delete the transient table structure associated with the
97016   ** subquery
97017   */
97018   sqlcipher3DbFree(db, pSubitem->zDatabase);
97019   sqlcipher3DbFree(db, pSubitem->zName);
97020   sqlcipher3DbFree(db, pSubitem->zAlias);
97021   pSubitem->zDatabase = 0;
97022   pSubitem->zName = 0;
97023   pSubitem->zAlias = 0;
97024   pSubitem->pSelect = 0;
97025
97026   /* Defer deleting the Table object associated with the
97027   ** subquery until code generation is
97028   ** complete, since there may still exist Expr.pTab entries that
97029   ** refer to the subquery even after flattening.  Ticket #3346.
97030   **
97031   ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
97032   */
97033   if( ALWAYS(pSubitem->pTab!=0) ){
97034     Table *pTabToDel = pSubitem->pTab;
97035     if( pTabToDel->nRef==1 ){
97036       Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
97037       pTabToDel->pNextZombie = pToplevel->pZombieTab;
97038       pToplevel->pZombieTab = pTabToDel;
97039     }else{
97040       pTabToDel->nRef--;
97041     }
97042     pSubitem->pTab = 0;
97043   }
97044
97045   /* The following loop runs once for each term in a compound-subquery
97046   ** flattening (as described above).  If we are doing a different kind
97047   ** of flattening - a flattening other than a compound-subquery flattening -
97048   ** then this loop only runs once.
97049   **
97050   ** This loop moves all of the FROM elements of the subquery into the
97051   ** the FROM clause of the outer query.  Before doing this, remember
97052   ** the cursor number for the original outer query FROM element in
97053   ** iParent.  The iParent cursor will never be used.  Subsequent code
97054   ** will scan expressions looking for iParent references and replace
97055   ** those references with expressions that resolve to the subquery FROM
97056   ** elements we are now copying in.
97057   */
97058   for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
97059     int nSubSrc;
97060     u8 jointype = 0;
97061     pSubSrc = pSub->pSrc;     /* FROM clause of subquery */
97062     nSubSrc = pSubSrc->nSrc;  /* Number of terms in subquery FROM clause */
97063     pSrc = pParent->pSrc;     /* FROM clause of the outer query */
97064
97065     if( pSrc ){
97066       assert( pParent==p );  /* First time through the loop */
97067       jointype = pSubitem->jointype;
97068     }else{
97069       assert( pParent!=p );  /* 2nd and subsequent times through the loop */
97070       pSrc = pParent->pSrc = sqlcipher3SrcListAppend(db, 0, 0, 0);
97071       if( pSrc==0 ){
97072         assert( db->mallocFailed );
97073         break;
97074       }
97075     }
97076
97077     /* The subquery uses a single slot of the FROM clause of the outer
97078     ** query.  If the subquery has more than one element in its FROM clause,
97079     ** then expand the outer query to make space for it to hold all elements
97080     ** of the subquery.
97081     **
97082     ** Example:
97083     **
97084     **    SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
97085     **
97086     ** The outer query has 3 slots in its FROM clause.  One slot of the
97087     ** outer query (the middle slot) is used by the subquery.  The next
97088     ** block of code will expand the out query to 4 slots.  The middle
97089     ** slot is expanded to two slots in order to make space for the
97090     ** two elements in the FROM clause of the subquery.
97091     */
97092     if( nSubSrc>1 ){
97093       pParent->pSrc = pSrc = sqlcipher3SrcListEnlarge(db, pSrc, nSubSrc-1,iFrom+1);
97094       if( db->mallocFailed ){
97095         break;
97096       }
97097     }
97098
97099     /* Transfer the FROM clause terms from the subquery into the
97100     ** outer query.
97101     */
97102     for(i=0; i<nSubSrc; i++){
97103       sqlcipher3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
97104       pSrc->a[i+iFrom] = pSubSrc->a[i];
97105       memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
97106     }
97107     pSrc->a[iFrom].jointype = jointype;
97108   
97109     /* Now begin substituting subquery result set expressions for 
97110     ** references to the iParent in the outer query.
97111     ** 
97112     ** Example:
97113     **
97114     **   SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
97115     **   \                     \_____________ subquery __________/          /
97116     **    \_____________________ outer query ______________________________/
97117     **
97118     ** We look at every expression in the outer query and every place we see
97119     ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
97120     */
97121     pList = pParent->pEList;
97122     for(i=0; i<pList->nExpr; i++){
97123       if( pList->a[i].zName==0 ){
97124         const char *zSpan = pList->a[i].zSpan;
97125         if( ALWAYS(zSpan) ){
97126           pList->a[i].zName = sqlcipher3DbStrDup(db, zSpan);
97127         }
97128       }
97129     }
97130     substExprList(db, pParent->pEList, iParent, pSub->pEList);
97131     if( isAgg ){
97132       substExprList(db, pParent->pGroupBy, iParent, pSub->pEList);
97133       pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
97134     }
97135     if( pSub->pOrderBy ){
97136       assert( pParent->pOrderBy==0 );
97137       pParent->pOrderBy = pSub->pOrderBy;
97138       pSub->pOrderBy = 0;
97139     }else if( pParent->pOrderBy ){
97140       substExprList(db, pParent->pOrderBy, iParent, pSub->pEList);
97141     }
97142     if( pSub->pWhere ){
97143       pWhere = sqlcipher3ExprDup(db, pSub->pWhere, 0);
97144     }else{
97145       pWhere = 0;
97146     }
97147     if( subqueryIsAgg ){
97148       assert( pParent->pHaving==0 );
97149       pParent->pHaving = pParent->pWhere;
97150       pParent->pWhere = pWhere;
97151       pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
97152       pParent->pHaving = sqlcipher3ExprAnd(db, pParent->pHaving, 
97153                                   sqlcipher3ExprDup(db, pSub->pHaving, 0));
97154       assert( pParent->pGroupBy==0 );
97155       pParent->pGroupBy = sqlcipher3ExprListDup(db, pSub->pGroupBy, 0);
97156     }else{
97157       pParent->pWhere = substExpr(db, pParent->pWhere, iParent, pSub->pEList);
97158       pParent->pWhere = sqlcipher3ExprAnd(db, pParent->pWhere, pWhere);
97159     }
97160   
97161     /* The flattened query is distinct if either the inner or the
97162     ** outer query is distinct. 
97163     */
97164     pParent->selFlags |= pSub->selFlags & SF_Distinct;
97165   
97166     /*
97167     ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
97168     **
97169     ** One is tempted to try to add a and b to combine the limits.  But this
97170     ** does not work if either limit is negative.
97171     */
97172     if( pSub->pLimit ){
97173       pParent->pLimit = pSub->pLimit;
97174       pSub->pLimit = 0;
97175     }
97176   }
97177
97178   /* Finially, delete what is left of the subquery and return
97179   ** success.
97180   */
97181   sqlcipher3SelectDelete(db, pSub1);
97182
97183   return 1;
97184 }
97185 #endif /* !defined(SQLCIPHER_OMIT_SUBQUERY) || !defined(SQLCIPHER_OMIT_VIEW) */
97186
97187 /*
97188 ** Analyze the SELECT statement passed as an argument to see if it
97189 ** is a min() or max() query. Return WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX if 
97190 ** it is, or 0 otherwise. At present, a query is considered to be
97191 ** a min()/max() query if:
97192 **
97193 **   1. There is a single object in the FROM clause.
97194 **
97195 **   2. There is a single expression in the result set, and it is
97196 **      either min(x) or max(x), where x is a column reference.
97197 */
97198 static u8 minMaxQuery(Select *p){
97199   Expr *pExpr;
97200   ExprList *pEList = p->pEList;
97201
97202   if( pEList->nExpr!=1 ) return WHERE_ORDERBY_NORMAL;
97203   pExpr = pEList->a[0].pExpr;
97204   if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
97205   if( NEVER(ExprHasProperty(pExpr, EP_xIsSelect)) ) return 0;
97206   pEList = pExpr->x.pList;
97207   if( pEList==0 || pEList->nExpr!=1 ) return 0;
97208   if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
97209   assert( !ExprHasProperty(pExpr, EP_IntValue) );
97210   if( sqlcipher3StrICmp(pExpr->u.zToken,"min")==0 ){
97211     return WHERE_ORDERBY_MIN;
97212   }else if( sqlcipher3StrICmp(pExpr->u.zToken,"max")==0 ){
97213     return WHERE_ORDERBY_MAX;
97214   }
97215   return WHERE_ORDERBY_NORMAL;
97216 }
97217
97218 /*
97219 ** The select statement passed as the first argument is an aggregate query.
97220 ** The second argment is the associated aggregate-info object. This 
97221 ** function tests if the SELECT is of the form:
97222 **
97223 **   SELECT count(*) FROM <tbl>
97224 **
97225 ** where table is a database table, not a sub-select or view. If the query
97226 ** does match this pattern, then a pointer to the Table object representing
97227 ** <tbl> is returned. Otherwise, 0 is returned.
97228 */
97229 static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
97230   Table *pTab;
97231   Expr *pExpr;
97232
97233   assert( !p->pGroupBy );
97234
97235   if( p->pWhere || p->pEList->nExpr!=1 
97236    || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
97237   ){
97238     return 0;
97239   }
97240   pTab = p->pSrc->a[0].pTab;
97241   pExpr = p->pEList->a[0].pExpr;
97242   assert( pTab && !pTab->pSelect && pExpr );
97243
97244   if( IsVirtual(pTab) ) return 0;
97245   if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
97246   if( (pAggInfo->aFunc[0].pFunc->flags&SQLCIPHER_FUNC_COUNT)==0 ) return 0;
97247   if( pExpr->flags&EP_Distinct ) return 0;
97248
97249   return pTab;
97250 }
97251
97252 /*
97253 ** If the source-list item passed as an argument was augmented with an
97254 ** INDEXED BY clause, then try to locate the specified index. If there
97255 ** was such a clause and the named index cannot be found, return 
97256 ** SQLCIPHER_ERROR and leave an error in pParse. Otherwise, populate 
97257 ** pFrom->pIndex and return SQLCIPHER_OK.
97258 */
97259 SQLCIPHER_PRIVATE int sqlcipher3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
97260   if( pFrom->pTab && pFrom->zIndex ){
97261     Table *pTab = pFrom->pTab;
97262     char *zIndex = pFrom->zIndex;
97263     Index *pIdx;
97264     for(pIdx=pTab->pIndex; 
97265         pIdx && sqlcipher3StrICmp(pIdx->zName, zIndex); 
97266         pIdx=pIdx->pNext
97267     );
97268     if( !pIdx ){
97269       sqlcipher3ErrorMsg(pParse, "no such index: %s", zIndex, 0);
97270       pParse->checkSchema = 1;
97271       return SQLCIPHER_ERROR;
97272     }
97273     pFrom->pIndex = pIdx;
97274   }
97275   return SQLCIPHER_OK;
97276 }
97277
97278 /*
97279 ** This routine is a Walker callback for "expanding" a SELECT statement.
97280 ** "Expanding" means to do the following:
97281 **
97282 **    (1)  Make sure VDBE cursor numbers have been assigned to every
97283 **         element of the FROM clause.
97284 **
97285 **    (2)  Fill in the pTabList->a[].pTab fields in the SrcList that 
97286 **         defines FROM clause.  When views appear in the FROM clause,
97287 **         fill pTabList->a[].pSelect with a copy of the SELECT statement
97288 **         that implements the view.  A copy is made of the view's SELECT
97289 **         statement so that we can freely modify or delete that statement
97290 **         without worrying about messing up the presistent representation
97291 **         of the view.
97292 **
97293 **    (3)  Add terms to the WHERE clause to accomodate the NATURAL keyword
97294 **         on joins and the ON and USING clause of joins.
97295 **
97296 **    (4)  Scan the list of columns in the result set (pEList) looking
97297 **         for instances of the "*" operator or the TABLE.* operator.
97298 **         If found, expand each "*" to be every column in every table
97299 **         and TABLE.* to be every column in TABLE.
97300 **
97301 */
97302 static int selectExpander(Walker *pWalker, Select *p){
97303   Parse *pParse = pWalker->pParse;
97304   int i, j, k;
97305   SrcList *pTabList;
97306   ExprList *pEList;
97307   struct SrcList_item *pFrom;
97308   sqlcipher3 *db = pParse->db;
97309
97310   if( db->mallocFailed  ){
97311     return WRC_Abort;
97312   }
97313   if( NEVER(p->pSrc==0) || (p->selFlags & SF_Expanded)!=0 ){
97314     return WRC_Prune;
97315   }
97316   p->selFlags |= SF_Expanded;
97317   pTabList = p->pSrc;
97318   pEList = p->pEList;
97319
97320   /* Make sure cursor numbers have been assigned to all entries in
97321   ** the FROM clause of the SELECT statement.
97322   */
97323   sqlcipher3SrcListAssignCursors(pParse, pTabList);
97324
97325   /* Look up every table named in the FROM clause of the select.  If
97326   ** an entry of the FROM clause is a subquery instead of a table or view,
97327   ** then create a transient table structure to describe the subquery.
97328   */
97329   for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
97330     Table *pTab;
97331     if( pFrom->pTab!=0 ){
97332       /* This statement has already been prepared.  There is no need
97333       ** to go further. */
97334       assert( i==0 );
97335       return WRC_Prune;
97336     }
97337     if( pFrom->zName==0 ){
97338 #ifndef SQLCIPHER_OMIT_SUBQUERY
97339       Select *pSel = pFrom->pSelect;
97340       /* A sub-query in the FROM clause of a SELECT */
97341       assert( pSel!=0 );
97342       assert( pFrom->pTab==0 );
97343       sqlcipher3WalkSelect(pWalker, pSel);
97344       pFrom->pTab = pTab = sqlcipher3DbMallocZero(db, sizeof(Table));
97345       if( pTab==0 ) return WRC_Abort;
97346       pTab->nRef = 1;
97347       pTab->zName = sqlcipher3MPrintf(db, "sqlcipher_subquery_%p_", (void*)pTab);
97348       while( pSel->pPrior ){ pSel = pSel->pPrior; }
97349       selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
97350       pTab->iPKey = -1;
97351       pTab->nRowEst = 1000000;
97352       pTab->tabFlags |= TF_Ephemeral;
97353 #endif
97354     }else{
97355       /* An ordinary table or view name in the FROM clause */
97356       assert( pFrom->pTab==0 );
97357       pFrom->pTab = pTab = 
97358         sqlcipher3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
97359       if( pTab==0 ) return WRC_Abort;
97360       pTab->nRef++;
97361 #if !defined(SQLCIPHER_OMIT_VIEW) || !defined (SQLCIPHER_OMIT_VIRTUALTABLE)
97362       if( pTab->pSelect || IsVirtual(pTab) ){
97363         /* We reach here if the named table is a really a view */
97364         if( sqlcipher3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
97365         assert( pFrom->pSelect==0 );
97366         pFrom->pSelect = sqlcipher3SelectDup(db, pTab->pSelect, 0);
97367         sqlcipher3WalkSelect(pWalker, pFrom->pSelect);
97368       }
97369 #endif
97370     }
97371
97372     /* Locate the index named by the INDEXED BY clause, if any. */
97373     if( sqlcipher3IndexedByLookup(pParse, pFrom) ){
97374       return WRC_Abort;
97375     }
97376   }
97377
97378   /* Process NATURAL keywords, and ON and USING clauses of joins.
97379   */
97380   if( db->mallocFailed || sqlcipherProcessJoin(pParse, p) ){
97381     return WRC_Abort;
97382   }
97383
97384   /* For every "*" that occurs in the column list, insert the names of
97385   ** all columns in all tables.  And for every TABLE.* insert the names
97386   ** of all columns in TABLE.  The parser inserted a special expression
97387   ** with the TK_ALL operator for each "*" that it found in the column list.
97388   ** The following code just has to locate the TK_ALL expressions and expand
97389   ** each one to the list of all columns in all tables.
97390   **
97391   ** The first loop just checks to see if there are any "*" operators
97392   ** that need expanding.
97393   */
97394   for(k=0; k<pEList->nExpr; k++){
97395     Expr *pE = pEList->a[k].pExpr;
97396     if( pE->op==TK_ALL ) break;
97397     assert( pE->op!=TK_DOT || pE->pRight!=0 );
97398     assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
97399     if( pE->op==TK_DOT && pE->pRight->op==TK_ALL ) break;
97400   }
97401   if( k<pEList->nExpr ){
97402     /*
97403     ** If we get here it means the result set contains one or more "*"
97404     ** operators that need to be expanded.  Loop through each expression
97405     ** in the result set and expand them one by one.
97406     */
97407     struct ExprList_item *a = pEList->a;
97408     ExprList *pNew = 0;
97409     int flags = pParse->db->flags;
97410     int longNames = (flags & SQLCIPHER_FullColNames)!=0
97411                       && (flags & SQLCIPHER_ShortColNames)==0;
97412
97413     for(k=0; k<pEList->nExpr; k++){
97414       Expr *pE = a[k].pExpr;
97415       assert( pE->op!=TK_DOT || pE->pRight!=0 );
97416       if( pE->op!=TK_ALL && (pE->op!=TK_DOT || pE->pRight->op!=TK_ALL) ){
97417         /* This particular expression does not need to be expanded.
97418         */
97419         pNew = sqlcipher3ExprListAppend(pParse, pNew, a[k].pExpr);
97420         if( pNew ){
97421           pNew->a[pNew->nExpr-1].zName = a[k].zName;
97422           pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
97423           a[k].zName = 0;
97424           a[k].zSpan = 0;
97425         }
97426         a[k].pExpr = 0;
97427       }else{
97428         /* This expression is a "*" or a "TABLE.*" and needs to be
97429         ** expanded. */
97430         int tableSeen = 0;      /* Set to 1 when TABLE matches */
97431         char *zTName;            /* text of name of TABLE */
97432         if( pE->op==TK_DOT ){
97433           assert( pE->pLeft!=0 );
97434           assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
97435           zTName = pE->pLeft->u.zToken;
97436         }else{
97437           zTName = 0;
97438         }
97439         for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
97440           Table *pTab = pFrom->pTab;
97441           char *zTabName = pFrom->zAlias;
97442           if( zTabName==0 ){
97443             zTabName = pTab->zName;
97444           }
97445           if( db->mallocFailed ) break;
97446           if( zTName && sqlcipher3StrICmp(zTName, zTabName)!=0 ){
97447             continue;
97448           }
97449           tableSeen = 1;
97450           for(j=0; j<pTab->nCol; j++){
97451             Expr *pExpr, *pRight;
97452             char *zName = pTab->aCol[j].zName;
97453             char *zColname;  /* The computed column name */
97454             char *zToFree;   /* Malloced string that needs to be freed */
97455             Token sColname;  /* Computed column name as a token */
97456
97457             /* If a column is marked as 'hidden' (currently only possible
97458             ** for virtual tables), do not include it in the expanded
97459             ** result-set list.
97460             */
97461             if( IsHiddenColumn(&pTab->aCol[j]) ){
97462               assert(IsVirtual(pTab));
97463               continue;
97464             }
97465
97466             if( i>0 && zTName==0 ){
97467               if( (pFrom->jointype & JT_NATURAL)!=0
97468                 && tableAndColumnIndex(pTabList, i, zName, 0, 0)
97469               ){
97470                 /* In a NATURAL join, omit the join columns from the 
97471                 ** table to the right of the join */
97472                 continue;
97473               }
97474               if( sqlcipher3IdListIndex(pFrom->pUsing, zName)>=0 ){
97475                 /* In a join with a USING clause, omit columns in the
97476                 ** using clause from the table on the right. */
97477                 continue;
97478               }
97479             }
97480             pRight = sqlcipher3Expr(db, TK_ID, zName);
97481             zColname = zName;
97482             zToFree = 0;
97483             if( longNames || pTabList->nSrc>1 ){
97484               Expr *pLeft;
97485               pLeft = sqlcipher3Expr(db, TK_ID, zTabName);
97486               pExpr = sqlcipher3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
97487               if( longNames ){
97488                 zColname = sqlcipher3MPrintf(db, "%s.%s", zTabName, zName);
97489                 zToFree = zColname;
97490               }
97491             }else{
97492               pExpr = pRight;
97493             }
97494             pNew = sqlcipher3ExprListAppend(pParse, pNew, pExpr);
97495             sColname.z = zColname;
97496             sColname.n = sqlcipher3Strlen30(zColname);
97497             sqlcipher3ExprListSetName(pParse, pNew, &sColname, 0);
97498             sqlcipher3DbFree(db, zToFree);
97499           }
97500         }
97501         if( !tableSeen ){
97502           if( zTName ){
97503             sqlcipher3ErrorMsg(pParse, "no such table: %s", zTName);
97504           }else{
97505             sqlcipher3ErrorMsg(pParse, "no tables specified");
97506           }
97507         }
97508       }
97509     }
97510     sqlcipher3ExprListDelete(db, pEList);
97511     p->pEList = pNew;
97512   }
97513 #if SQLCIPHER_MAX_COLUMN
97514   if( p->pEList && p->pEList->nExpr>db->aLimit[SQLCIPHER_LIMIT_COLUMN] ){
97515     sqlcipher3ErrorMsg(pParse, "too many columns in result set");
97516   }
97517 #endif
97518   return WRC_Continue;
97519 }
97520
97521 /*
97522 ** No-op routine for the parse-tree walker.
97523 **
97524 ** When this routine is the Walker.xExprCallback then expression trees
97525 ** are walked without any actions being taken at each node.  Presumably,
97526 ** when this routine is used for Walker.xExprCallback then 
97527 ** Walker.xSelectCallback is set to do something useful for every 
97528 ** subquery in the parser tree.
97529 */
97530 static int exprWalkNoop(Walker *NotUsed, Expr *NotUsed2){
97531   UNUSED_PARAMETER2(NotUsed, NotUsed2);
97532   return WRC_Continue;
97533 }
97534
97535 /*
97536 ** This routine "expands" a SELECT statement and all of its subqueries.
97537 ** For additional information on what it means to "expand" a SELECT
97538 ** statement, see the comment on the selectExpand worker callback above.
97539 **
97540 ** Expanding a SELECT statement is the first step in processing a
97541 ** SELECT statement.  The SELECT statement must be expanded before
97542 ** name resolution is performed.
97543 **
97544 ** If anything goes wrong, an error message is written into pParse.
97545 ** The calling function can detect the problem by looking at pParse->nErr
97546 ** and/or pParse->db->mallocFailed.
97547 */
97548 static void sqlcipher3SelectExpand(Parse *pParse, Select *pSelect){
97549   Walker w;
97550   w.xSelectCallback = selectExpander;
97551   w.xExprCallback = exprWalkNoop;
97552   w.pParse = pParse;
97553   sqlcipher3WalkSelect(&w, pSelect);
97554 }
97555
97556
97557 #ifndef SQLCIPHER_OMIT_SUBQUERY
97558 /*
97559 ** This is a Walker.xSelectCallback callback for the sqlcipher3SelectTypeInfo()
97560 ** interface.
97561 **
97562 ** For each FROM-clause subquery, add Column.zType and Column.zColl
97563 ** information to the Table structure that represents the result set
97564 ** of that subquery.
97565 **
97566 ** The Table structure that represents the result set was constructed
97567 ** by selectExpander() but the type and collation information was omitted
97568 ** at that point because identifiers had not yet been resolved.  This
97569 ** routine is called after identifier resolution.
97570 */
97571 static int selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
97572   Parse *pParse;
97573   int i;
97574   SrcList *pTabList;
97575   struct SrcList_item *pFrom;
97576
97577   assert( p->selFlags & SF_Resolved );
97578   if( (p->selFlags & SF_HasTypeInfo)==0 ){
97579     p->selFlags |= SF_HasTypeInfo;
97580     pParse = pWalker->pParse;
97581     pTabList = p->pSrc;
97582     for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
97583       Table *pTab = pFrom->pTab;
97584       if( ALWAYS(pTab!=0) && (pTab->tabFlags & TF_Ephemeral)!=0 ){
97585         /* A sub-query in the FROM clause of a SELECT */
97586         Select *pSel = pFrom->pSelect;
97587         assert( pSel );
97588         while( pSel->pPrior ) pSel = pSel->pPrior;
97589         selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
97590       }
97591     }
97592   }
97593   return WRC_Continue;
97594 }
97595 #endif
97596
97597
97598 /*
97599 ** This routine adds datatype and collating sequence information to
97600 ** the Table structures of all FROM-clause subqueries in a
97601 ** SELECT statement.
97602 **
97603 ** Use this routine after name resolution.
97604 */
97605 static void sqlcipher3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
97606 #ifndef SQLCIPHER_OMIT_SUBQUERY
97607   Walker w;
97608   w.xSelectCallback = selectAddSubqueryTypeInfo;
97609   w.xExprCallback = exprWalkNoop;
97610   w.pParse = pParse;
97611   sqlcipher3WalkSelect(&w, pSelect);
97612 #endif
97613 }
97614
97615
97616 /*
97617 ** This routine sets of a SELECT statement for processing.  The
97618 ** following is accomplished:
97619 **
97620 **     *  VDBE Cursor numbers are assigned to all FROM-clause terms.
97621 **     *  Ephemeral Table objects are created for all FROM-clause subqueries.
97622 **     *  ON and USING clauses are shifted into WHERE statements
97623 **     *  Wildcards "*" and "TABLE.*" in result sets are expanded.
97624 **     *  Identifiers in expression are matched to tables.
97625 **
97626 ** This routine acts recursively on all subqueries within the SELECT.
97627 */
97628 SQLCIPHER_PRIVATE void sqlcipher3SelectPrep(
97629   Parse *pParse,         /* The parser context */
97630   Select *p,             /* The SELECT statement being coded. */
97631   NameContext *pOuterNC  /* Name context for container */
97632 ){
97633   sqlcipher3 *db;
97634   if( NEVER(p==0) ) return;
97635   db = pParse->db;
97636   if( p->selFlags & SF_HasTypeInfo ) return;
97637   sqlcipher3SelectExpand(pParse, p);
97638   if( pParse->nErr || db->mallocFailed ) return;
97639   sqlcipher3ResolveSelectNames(pParse, p, pOuterNC);
97640   if( pParse->nErr || db->mallocFailed ) return;
97641   sqlcipher3SelectAddTypeInfo(pParse, p);
97642 }
97643
97644 /*
97645 ** Reset the aggregate accumulator.
97646 **
97647 ** The aggregate accumulator is a set of memory cells that hold
97648 ** intermediate results while calculating an aggregate.  This
97649 ** routine simply stores NULLs in all of those memory cells.
97650 */
97651 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
97652   Vdbe *v = pParse->pVdbe;
97653   int i;
97654   struct AggInfo_func *pFunc;
97655   if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
97656     return;
97657   }
97658   for(i=0; i<pAggInfo->nColumn; i++){
97659     sqlcipher3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem);
97660   }
97661   for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
97662     sqlcipher3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem);
97663     if( pFunc->iDistinct>=0 ){
97664       Expr *pE = pFunc->pExpr;
97665       assert( !ExprHasProperty(pE, EP_xIsSelect) );
97666       if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
97667         sqlcipher3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
97668            "argument");
97669         pFunc->iDistinct = -1;
97670       }else{
97671         KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList);
97672         sqlcipher3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
97673                           (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
97674       }
97675     }
97676   }
97677 }
97678
97679 /*
97680 ** Invoke the OP_AggFinalize opcode for every aggregate function
97681 ** in the AggInfo structure.
97682 */
97683 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
97684   Vdbe *v = pParse->pVdbe;
97685   int i;
97686   struct AggInfo_func *pF;
97687   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
97688     ExprList *pList = pF->pExpr->x.pList;
97689     assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
97690     sqlcipher3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0,
97691                       (void*)pF->pFunc, P4_FUNCDEF);
97692   }
97693 }
97694
97695 /*
97696 ** Update the accumulator memory cells for an aggregate based on
97697 ** the current cursor position.
97698 */
97699 static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
97700   Vdbe *v = pParse->pVdbe;
97701   int i;
97702   struct AggInfo_func *pF;
97703   struct AggInfo_col *pC;
97704
97705   pAggInfo->directMode = 1;
97706   sqlcipher3ExprCacheClear(pParse);
97707   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
97708     int nArg;
97709     int addrNext = 0;
97710     int regAgg;
97711     ExprList *pList = pF->pExpr->x.pList;
97712     assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
97713     if( pList ){
97714       nArg = pList->nExpr;
97715       regAgg = sqlcipher3GetTempRange(pParse, nArg);
97716       sqlcipher3ExprCodeExprList(pParse, pList, regAgg, 1);
97717     }else{
97718       nArg = 0;
97719       regAgg = 0;
97720     }
97721     if( pF->iDistinct>=0 ){
97722       addrNext = sqlcipher3VdbeMakeLabel(v);
97723       assert( nArg==1 );
97724       codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
97725     }
97726     if( pF->pFunc->flags & SQLCIPHER_FUNC_NEEDCOLL ){
97727       CollSeq *pColl = 0;
97728       struct ExprList_item *pItem;
97729       int j;
97730       assert( pList!=0 );  /* pList!=0 if pF->pFunc has NEEDCOLL */
97731       for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
97732         pColl = sqlcipher3ExprCollSeq(pParse, pItem->pExpr);
97733       }
97734       if( !pColl ){
97735         pColl = pParse->db->pDfltColl;
97736       }
97737       sqlcipher3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
97738     }
97739     sqlcipher3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem,
97740                       (void*)pF->pFunc, P4_FUNCDEF);
97741     sqlcipher3VdbeChangeP5(v, (u8)nArg);
97742     sqlcipher3ExprCacheAffinityChange(pParse, regAgg, nArg);
97743     sqlcipher3ReleaseTempRange(pParse, regAgg, nArg);
97744     if( addrNext ){
97745       sqlcipher3VdbeResolveLabel(v, addrNext);
97746       sqlcipher3ExprCacheClear(pParse);
97747     }
97748   }
97749
97750   /* Before populating the accumulator registers, clear the column cache.
97751   ** Otherwise, if any of the required column values are already present 
97752   ** in registers, sqlcipher3ExprCode() may use OP_SCopy to copy the value
97753   ** to pC->iMem. But by the time the value is used, the original register
97754   ** may have been used, invalidating the underlying buffer holding the
97755   ** text or blob value. See ticket [883034dcb5].
97756   **
97757   ** Another solution would be to change the OP_SCopy used to copy cached
97758   ** values to an OP_Copy.
97759   */
97760   sqlcipher3ExprCacheClear(pParse);
97761   for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
97762     sqlcipher3ExprCode(pParse, pC->pExpr, pC->iMem);
97763   }
97764   pAggInfo->directMode = 0;
97765   sqlcipher3ExprCacheClear(pParse);
97766 }
97767
97768 /*
97769 ** Add a single OP_Explain instruction to the VDBE to explain a simple
97770 ** count(*) query ("SELECT count(*) FROM pTab").
97771 */
97772 #ifndef SQLCIPHER_OMIT_EXPLAIN
97773 static void explainSimpleCount(
97774   Parse *pParse,                  /* Parse context */
97775   Table *pTab,                    /* Table being queried */
97776   Index *pIdx                     /* Index used to optimize scan, or NULL */
97777 ){
97778   if( pParse->explain==2 ){
97779     char *zEqp = sqlcipher3MPrintf(pParse->db, "SCAN TABLE %s %s%s(~%d rows)",
97780         pTab->zName, 
97781         pIdx ? "USING COVERING INDEX " : "",
97782         pIdx ? pIdx->zName : "",
97783         pTab->nRowEst
97784     );
97785     sqlcipher3VdbeAddOp4(
97786         pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC
97787     );
97788   }
97789 }
97790 #else
97791 # define explainSimpleCount(a,b,c)
97792 #endif
97793
97794 /*
97795 ** Generate code for the SELECT statement given in the p argument.  
97796 **
97797 ** The results are distributed in various ways depending on the
97798 ** contents of the SelectDest structure pointed to by argument pDest
97799 ** as follows:
97800 **
97801 **     pDest->eDest    Result
97802 **     ------------    -------------------------------------------
97803 **     SRT_Output      Generate a row of output (using the OP_ResultRow
97804 **                     opcode) for each row in the result set.
97805 **
97806 **     SRT_Mem         Only valid if the result is a single column.
97807 **                     Store the first column of the first result row
97808 **                     in register pDest->iParm then abandon the rest
97809 **                     of the query.  This destination implies "LIMIT 1".
97810 **
97811 **     SRT_Set         The result must be a single column.  Store each
97812 **                     row of result as the key in table pDest->iParm. 
97813 **                     Apply the affinity pDest->affinity before storing
97814 **                     results.  Used to implement "IN (SELECT ...)".
97815 **
97816 **     SRT_Union       Store results as a key in a temporary table pDest->iParm.
97817 **
97818 **     SRT_Except      Remove results from the temporary table pDest->iParm.
97819 **
97820 **     SRT_Table       Store results in temporary table pDest->iParm.
97821 **                     This is like SRT_EphemTab except that the table
97822 **                     is assumed to already be open.
97823 **
97824 **     SRT_EphemTab    Create an temporary table pDest->iParm and store
97825 **                     the result there. The cursor is left open after
97826 **                     returning.  This is like SRT_Table except that
97827 **                     this destination uses OP_OpenEphemeral to create
97828 **                     the table first.
97829 **
97830 **     SRT_Coroutine   Generate a co-routine that returns a new row of
97831 **                     results each time it is invoked.  The entry point
97832 **                     of the co-routine is stored in register pDest->iParm.
97833 **
97834 **     SRT_Exists      Store a 1 in memory cell pDest->iParm if the result
97835 **                     set is not empty.
97836 **
97837 **     SRT_Discard     Throw the results away.  This is used by SELECT
97838 **                     statements within triggers whose only purpose is
97839 **                     the side-effects of functions.
97840 **
97841 ** This routine returns the number of errors.  If any errors are
97842 ** encountered, then an appropriate error message is left in
97843 ** pParse->zErrMsg.
97844 **
97845 ** This routine does NOT free the Select structure passed in.  The
97846 ** calling function needs to do that.
97847 */
97848 SQLCIPHER_PRIVATE int sqlcipher3Select(
97849   Parse *pParse,         /* The parser context */
97850   Select *p,             /* The SELECT statement being coded. */
97851   SelectDest *pDest      /* What to do with the query results */
97852 ){
97853   int i, j;              /* Loop counters */
97854   WhereInfo *pWInfo;     /* Return from sqlcipher3WhereBegin() */
97855   Vdbe *v;               /* The virtual machine under construction */
97856   int isAgg;             /* True for select lists like "count(*)" */
97857   ExprList *pEList;      /* List of columns to extract. */
97858   SrcList *pTabList;     /* List of tables to select from */
97859   Expr *pWhere;          /* The WHERE clause.  May be NULL */
97860   ExprList *pOrderBy;    /* The ORDER BY clause.  May be NULL */
97861   ExprList *pGroupBy;    /* The GROUP BY clause.  May be NULL */
97862   Expr *pHaving;         /* The HAVING clause.  May be NULL */
97863   int isDistinct;        /* True if the DISTINCT keyword is present */
97864   int distinct;          /* Table to use for the distinct set */
97865   int rc = 1;            /* Value to return from this function */
97866   int addrSortIndex;     /* Address of an OP_OpenEphemeral instruction */
97867   int addrDistinctIndex; /* Address of an OP_OpenEphemeral instruction */
97868   AggInfo sAggInfo;      /* Information used by aggregate queries */
97869   int iEnd;              /* Address of the end of the query */
97870   sqlcipher3 *db;           /* The database connection */
97871
97872 #ifndef SQLCIPHER_OMIT_EXPLAIN
97873   int iRestoreSelectId = pParse->iSelectId;
97874   pParse->iSelectId = pParse->iNextSelectId++;
97875 #endif
97876
97877   db = pParse->db;
97878   if( p==0 || db->mallocFailed || pParse->nErr ){
97879     return 1;
97880   }
97881   if( sqlcipher3AuthCheck(pParse, SQLCIPHER_SELECT, 0, 0, 0) ) return 1;
97882   memset(&sAggInfo, 0, sizeof(sAggInfo));
97883
97884   if( IgnorableOrderby(pDest) ){
97885     assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || 
97886            pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard);
97887     /* If ORDER BY makes no difference in the output then neither does
97888     ** DISTINCT so it can be removed too. */
97889     sqlcipher3ExprListDelete(db, p->pOrderBy);
97890     p->pOrderBy = 0;
97891     p->selFlags &= ~SF_Distinct;
97892   }
97893   sqlcipher3SelectPrep(pParse, p, 0);
97894   pOrderBy = p->pOrderBy;
97895   pTabList = p->pSrc;
97896   pEList = p->pEList;
97897   if( pParse->nErr || db->mallocFailed ){
97898     goto select_end;
97899   }
97900   isAgg = (p->selFlags & SF_Aggregate)!=0;
97901   assert( pEList!=0 );
97902
97903   /* Begin generating code.
97904   */
97905   v = sqlcipher3GetVdbe(pParse);
97906   if( v==0 ) goto select_end;
97907
97908   /* If writing to memory or generating a set
97909   ** only a single column may be output.
97910   */
97911 #ifndef SQLCIPHER_OMIT_SUBQUERY
97912   if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
97913     goto select_end;
97914   }
97915 #endif
97916
97917   /* Generate code for all sub-queries in the FROM clause
97918   */
97919 #if !defined(SQLCIPHER_OMIT_SUBQUERY) || !defined(SQLCIPHER_OMIT_VIEW)
97920   for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
97921     struct SrcList_item *pItem = &pTabList->a[i];
97922     SelectDest dest;
97923     Select *pSub = pItem->pSelect;
97924     int isAggSub;
97925
97926     if( pSub==0 ) continue;
97927     if( pItem->addrFillSub ){
97928       sqlcipher3VdbeAddOp2(v, OP_Gosub, pItem->regReturn, pItem->addrFillSub);
97929       continue;
97930     }
97931
97932     /* Increment Parse.nHeight by the height of the largest expression
97933     ** tree refered to by this, the parent select. The child select
97934     ** may contain expression trees of at most
97935     ** (SQLCIPHER_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
97936     ** more conservative than necessary, but much easier than enforcing
97937     ** an exact limit.
97938     */
97939     pParse->nHeight += sqlcipher3SelectExprHeight(p);
97940
97941     isAggSub = (pSub->selFlags & SF_Aggregate)!=0;
97942     if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){
97943       /* This subquery can be absorbed into its parent. */
97944       if( isAggSub ){
97945         isAgg = 1;
97946         p->selFlags |= SF_Aggregate;
97947       }
97948       i = -1;
97949     }else{
97950       /* Generate a subroutine that will fill an ephemeral table with
97951       ** the content of this subquery.  pItem->addrFillSub will point
97952       ** to the address of the generated subroutine.  pItem->regReturn
97953       ** is a register allocated to hold the subroutine return address
97954       */
97955       int topAddr;
97956       int onceAddr = 0;
97957       int retAddr;
97958       assert( pItem->addrFillSub==0 );
97959       pItem->regReturn = ++pParse->nMem;
97960       topAddr = sqlcipher3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
97961       pItem->addrFillSub = topAddr+1;
97962       VdbeNoopComment((v, "materialize %s", pItem->pTab->zName));
97963       if( pItem->isCorrelated==0 && pParse->pTriggerTab==0 ){
97964         /* If the subquery is no correlated and if we are not inside of
97965         ** a trigger, then we only need to compute the value of the subquery
97966         ** once. */
97967         int regOnce = ++pParse->nMem;
97968         onceAddr = sqlcipher3VdbeAddOp1(v, OP_Once, regOnce);
97969       }
97970       sqlcipher3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
97971       explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
97972       sqlcipher3Select(pParse, pSub, &dest);
97973       pItem->pTab->nRowEst = (unsigned)pSub->nSelectRow;
97974       if( onceAddr ) sqlcipher3VdbeJumpHere(v, onceAddr);
97975       retAddr = sqlcipher3VdbeAddOp1(v, OP_Return, pItem->regReturn);
97976       VdbeComment((v, "end %s", pItem->pTab->zName));
97977       sqlcipher3VdbeChangeP1(v, topAddr, retAddr);
97978
97979     }
97980     if( /*pParse->nErr ||*/ db->mallocFailed ){
97981       goto select_end;
97982     }
97983     pParse->nHeight -= sqlcipher3SelectExprHeight(p);
97984     pTabList = p->pSrc;
97985     if( !IgnorableOrderby(pDest) ){
97986       pOrderBy = p->pOrderBy;
97987     }
97988   }
97989   pEList = p->pEList;
97990 #endif
97991   pWhere = p->pWhere;
97992   pGroupBy = p->pGroupBy;
97993   pHaving = p->pHaving;
97994   isDistinct = (p->selFlags & SF_Distinct)!=0;
97995
97996 #ifndef SQLCIPHER_OMIT_COMPOUND_SELECT
97997   /* If there is are a sequence of queries, do the earlier ones first.
97998   */
97999   if( p->pPrior ){
98000     if( p->pRightmost==0 ){
98001       Select *pLoop, *pRight = 0;
98002       int cnt = 0;
98003       int mxSelect;
98004       for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
98005         pLoop->pRightmost = p;
98006         pLoop->pNext = pRight;
98007         pRight = pLoop;
98008       }
98009       mxSelect = db->aLimit[SQLCIPHER_LIMIT_COMPOUND_SELECT];
98010       if( mxSelect && cnt>mxSelect ){
98011         sqlcipher3ErrorMsg(pParse, "too many terms in compound SELECT");
98012         goto select_end;
98013       }
98014     }
98015     rc = multiSelect(pParse, p, pDest);
98016     explainSetInteger(pParse->iSelectId, iRestoreSelectId);
98017     return rc;
98018   }
98019 #endif
98020
98021   /* If there is both a GROUP BY and an ORDER BY clause and they are
98022   ** identical, then disable the ORDER BY clause since the GROUP BY
98023   ** will cause elements to come out in the correct order.  This is
98024   ** an optimization - the correct answer should result regardless.
98025   ** Use the SQLCIPHER_GroupByOrder flag with SQLCIPHER_TESTCTRL_OPTIMIZER
98026   ** to disable this optimization for testing purposes.
98027   */
98028   if( sqlcipher3ExprListCompare(p->pGroupBy, pOrderBy)==0
98029          && (db->flags & SQLCIPHER_GroupByOrder)==0 ){
98030     pOrderBy = 0;
98031   }
98032
98033   /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and 
98034   ** if the select-list is the same as the ORDER BY list, then this query
98035   ** can be rewritten as a GROUP BY. In other words, this:
98036   **
98037   **     SELECT DISTINCT xyz FROM ... ORDER BY xyz
98038   **
98039   ** is transformed to:
98040   **
98041   **     SELECT xyz FROM ... GROUP BY xyz
98042   **
98043   ** The second form is preferred as a single index (or temp-table) may be 
98044   ** used for both the ORDER BY and DISTINCT processing. As originally 
98045   ** written the query must use a temp-table for at least one of the ORDER 
98046   ** BY and DISTINCT, and an index or separate temp-table for the other.
98047   */
98048   if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct 
98049    && sqlcipher3ExprListCompare(pOrderBy, p->pEList)==0
98050   ){
98051     p->selFlags &= ~SF_Distinct;
98052     p->pGroupBy = sqlcipher3ExprListDup(db, p->pEList, 0);
98053     pGroupBy = p->pGroupBy;
98054     pOrderBy = 0;
98055   }
98056
98057   /* If there is an ORDER BY clause, then this sorting
98058   ** index might end up being unused if the data can be 
98059   ** extracted in pre-sorted order.  If that is the case, then the
98060   ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
98061   ** we figure out that the sorting index is not needed.  The addrSortIndex
98062   ** variable is used to facilitate that change.
98063   */
98064   if( pOrderBy ){
98065     KeyInfo *pKeyInfo;
98066     pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
98067     pOrderBy->iECursor = pParse->nTab++;
98068     p->addrOpenEphm[2] = addrSortIndex =
98069       sqlcipher3VdbeAddOp4(v, OP_OpenEphemeral,
98070                            pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
98071                            (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
98072   }else{
98073     addrSortIndex = -1;
98074   }
98075
98076   /* If the output is destined for a temporary table, open that table.
98077   */
98078   if( pDest->eDest==SRT_EphemTab ){
98079     sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iParm, pEList->nExpr);
98080   }
98081
98082   /* Set the limiter.
98083   */
98084   iEnd = sqlcipher3VdbeMakeLabel(v);
98085   p->nSelectRow = (double)LARGEST_INT64;
98086   computeLimitRegisters(pParse, p, iEnd);
98087   if( p->iLimit==0 && addrSortIndex>=0 ){
98088     sqlcipher3VdbeGetOp(v, addrSortIndex)->opcode = OP_SorterOpen;
98089     p->selFlags |= SF_UseSorter;
98090   }
98091
98092   /* Open a virtual index to use for the distinct set.
98093   */
98094   if( p->selFlags & SF_Distinct ){
98095     KeyInfo *pKeyInfo;
98096     distinct = pParse->nTab++;
98097     pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
98098     addrDistinctIndex = sqlcipher3VdbeAddOp4(v, OP_OpenEphemeral, distinct, 0, 0,
98099         (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
98100     sqlcipher3VdbeChangeP5(v, BTREE_UNORDERED);
98101   }else{
98102     distinct = addrDistinctIndex = -1;
98103   }
98104
98105   /* Aggregate and non-aggregate queries are handled differently */
98106   if( !isAgg && pGroupBy==0 ){
98107     ExprList *pDist = (isDistinct ? p->pEList : 0);
98108
98109     /* Begin the database scan. */
98110     pWInfo = sqlcipher3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, pDist, 0);
98111     if( pWInfo==0 ) goto select_end;
98112     if( pWInfo->nRowOut < p->nSelectRow ) p->nSelectRow = pWInfo->nRowOut;
98113
98114     /* If sorting index that was created by a prior OP_OpenEphemeral 
98115     ** instruction ended up not being needed, then change the OP_OpenEphemeral
98116     ** into an OP_Noop.
98117     */
98118     if( addrSortIndex>=0 && pOrderBy==0 ){
98119       sqlcipher3VdbeChangeToNoop(v, addrSortIndex);
98120       p->addrOpenEphm[2] = -1;
98121     }
98122
98123     if( pWInfo->eDistinct ){
98124       VdbeOp *pOp;                /* No longer required OpenEphemeral instr. */
98125      
98126       assert( addrDistinctIndex>=0 );
98127       pOp = sqlcipher3VdbeGetOp(v, addrDistinctIndex);
98128
98129       assert( isDistinct );
98130       assert( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED 
98131            || pWInfo->eDistinct==WHERE_DISTINCT_UNIQUE 
98132       );
98133       distinct = -1;
98134       if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED ){
98135         int iJump;
98136         int iExpr;
98137         int iFlag = ++pParse->nMem;
98138         int iBase = pParse->nMem+1;
98139         int iBase2 = iBase + pEList->nExpr;
98140         pParse->nMem += (pEList->nExpr*2);
98141
98142         /* Change the OP_OpenEphemeral coded earlier to an OP_Integer. The
98143         ** OP_Integer initializes the "first row" flag.  */
98144         pOp->opcode = OP_Integer;
98145         pOp->p1 = 1;
98146         pOp->p2 = iFlag;
98147
98148         sqlcipher3ExprCodeExprList(pParse, pEList, iBase, 1);
98149         iJump = sqlcipher3VdbeCurrentAddr(v) + 1 + pEList->nExpr + 1 + 1;
98150         sqlcipher3VdbeAddOp2(v, OP_If, iFlag, iJump-1);
98151         for(iExpr=0; iExpr<pEList->nExpr; iExpr++){
98152           CollSeq *pColl = sqlcipher3ExprCollSeq(pParse, pEList->a[iExpr].pExpr);
98153           sqlcipher3VdbeAddOp3(v, OP_Ne, iBase+iExpr, iJump, iBase2+iExpr);
98154           sqlcipher3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
98155           sqlcipher3VdbeChangeP5(v, SQLCIPHER_NULLEQ);
98156         }
98157         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iContinue);
98158
98159         sqlcipher3VdbeAddOp2(v, OP_Integer, 0, iFlag);
98160         assert( sqlcipher3VdbeCurrentAddr(v)==iJump );
98161         sqlcipher3VdbeAddOp3(v, OP_Move, iBase, iBase2, pEList->nExpr);
98162       }else{
98163         pOp->opcode = OP_Noop;
98164       }
98165     }
98166
98167     /* Use the standard inner loop. */
98168     selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, pDest,
98169                     pWInfo->iContinue, pWInfo->iBreak);
98170
98171     /* End the database scan loop.
98172     */
98173     sqlcipher3WhereEnd(pWInfo);
98174   }else{
98175     /* This is the processing for aggregate queries */
98176     NameContext sNC;    /* Name context for processing aggregate information */
98177     int iAMem;          /* First Mem address for storing current GROUP BY */
98178     int iBMem;          /* First Mem address for previous GROUP BY */
98179     int iUseFlag;       /* Mem address holding flag indicating that at least
98180                         ** one row of the input to the aggregator has been
98181                         ** processed */
98182     int iAbortFlag;     /* Mem address which causes query abort if positive */
98183     int groupBySort;    /* Rows come from source in GROUP BY order */
98184     int addrEnd;        /* End of processing for this SELECT */
98185     int sortPTab = 0;   /* Pseudotable used to decode sorting results */
98186     int sortOut = 0;    /* Output register from the sorter */
98187
98188     /* Remove any and all aliases between the result set and the
98189     ** GROUP BY clause.
98190     */
98191     if( pGroupBy ){
98192       int k;                        /* Loop counter */
98193       struct ExprList_item *pItem;  /* For looping over expression in a list */
98194
98195       for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
98196         pItem->iAlias = 0;
98197       }
98198       for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
98199         pItem->iAlias = 0;
98200       }
98201       if( p->nSelectRow>(double)100 ) p->nSelectRow = (double)100;
98202     }else{
98203       p->nSelectRow = (double)1;
98204     }
98205
98206  
98207     /* Create a label to jump to when we want to abort the query */
98208     addrEnd = sqlcipher3VdbeMakeLabel(v);
98209
98210     /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
98211     ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
98212     ** SELECT statement.
98213     */
98214     memset(&sNC, 0, sizeof(sNC));
98215     sNC.pParse = pParse;
98216     sNC.pSrcList = pTabList;
98217     sNC.pAggInfo = &sAggInfo;
98218     sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
98219     sAggInfo.pGroupBy = pGroupBy;
98220     sqlcipher3ExprAnalyzeAggList(&sNC, pEList);
98221     sqlcipher3ExprAnalyzeAggList(&sNC, pOrderBy);
98222     if( pHaving ){
98223       sqlcipher3ExprAnalyzeAggregates(&sNC, pHaving);
98224     }
98225     sAggInfo.nAccumulator = sAggInfo.nColumn;
98226     for(i=0; i<sAggInfo.nFunc; i++){
98227       assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
98228       sqlcipher3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
98229     }
98230     if( db->mallocFailed ) goto select_end;
98231
98232     /* Processing for aggregates with GROUP BY is very different and
98233     ** much more complex than aggregates without a GROUP BY.
98234     */
98235     if( pGroupBy ){
98236       KeyInfo *pKeyInfo;  /* Keying information for the group by clause */
98237       int j1;             /* A-vs-B comparision jump */
98238       int addrOutputRow;  /* Start of subroutine that outputs a result row */
98239       int regOutputRow;   /* Return address register for output subroutine */
98240       int addrSetAbort;   /* Set the abort flag and return */
98241       int addrTopOfLoop;  /* Top of the input loop */
98242       int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
98243       int addrReset;      /* Subroutine for resetting the accumulator */
98244       int regReset;       /* Return address register for reset subroutine */
98245
98246       /* If there is a GROUP BY clause we might need a sorting index to
98247       ** implement it.  Allocate that sorting index now.  If it turns out
98248       ** that we do not need it after all, the OP_SorterOpen instruction
98249       ** will be converted into a Noop.  
98250       */
98251       sAggInfo.sortingIdx = pParse->nTab++;
98252       pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
98253       addrSortingIdx = sqlcipher3VdbeAddOp4(v, OP_SorterOpen, 
98254           sAggInfo.sortingIdx, sAggInfo.nSortingColumn, 
98255           0, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
98256
98257       /* Initialize memory locations used by GROUP BY aggregate processing
98258       */
98259       iUseFlag = ++pParse->nMem;
98260       iAbortFlag = ++pParse->nMem;
98261       regOutputRow = ++pParse->nMem;
98262       addrOutputRow = sqlcipher3VdbeMakeLabel(v);
98263       regReset = ++pParse->nMem;
98264       addrReset = sqlcipher3VdbeMakeLabel(v);
98265       iAMem = pParse->nMem + 1;
98266       pParse->nMem += pGroupBy->nExpr;
98267       iBMem = pParse->nMem + 1;
98268       pParse->nMem += pGroupBy->nExpr;
98269       sqlcipher3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
98270       VdbeComment((v, "clear abort flag"));
98271       sqlcipher3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
98272       VdbeComment((v, "indicate accumulator empty"));
98273
98274       /* Begin a loop that will extract all source rows in GROUP BY order.
98275       ** This might involve two separate loops with an OP_Sort in between, or
98276       ** it might be a single loop that uses an index to extract information
98277       ** in the right order to begin with.
98278       */
98279       sqlcipher3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
98280       pWInfo = sqlcipher3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0, 0);
98281       if( pWInfo==0 ) goto select_end;
98282       if( pGroupBy==0 ){
98283         /* The optimizer is able to deliver rows in group by order so
98284         ** we do not have to sort.  The OP_OpenEphemeral table will be
98285         ** cancelled later because we still need to use the pKeyInfo
98286         */
98287         pGroupBy = p->pGroupBy;
98288         groupBySort = 0;
98289       }else{
98290         /* Rows are coming out in undetermined order.  We have to push
98291         ** each row into a sorting index, terminate the first loop,
98292         ** then loop over the sorting index in order to get the output
98293         ** in sorted order
98294         */
98295         int regBase;
98296         int regRecord;
98297         int nCol;
98298         int nGroupBy;
98299
98300         explainTempTable(pParse, 
98301             isDistinct && !(p->selFlags&SF_Distinct)?"DISTINCT":"GROUP BY");
98302
98303         groupBySort = 1;
98304         nGroupBy = pGroupBy->nExpr;
98305         nCol = nGroupBy + 1;
98306         j = nGroupBy+1;
98307         for(i=0; i<sAggInfo.nColumn; i++){
98308           if( sAggInfo.aCol[i].iSorterColumn>=j ){
98309             nCol++;
98310             j++;
98311           }
98312         }
98313         regBase = sqlcipher3GetTempRange(pParse, nCol);
98314         sqlcipher3ExprCacheClear(pParse);
98315         sqlcipher3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
98316         sqlcipher3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy);
98317         j = nGroupBy+1;
98318         for(i=0; i<sAggInfo.nColumn; i++){
98319           struct AggInfo_col *pCol = &sAggInfo.aCol[i];
98320           if( pCol->iSorterColumn>=j ){
98321             int r1 = j + regBase;
98322             int r2;
98323
98324             r2 = sqlcipher3ExprCodeGetColumn(pParse, 
98325                                pCol->pTab, pCol->iColumn, pCol->iTable, r1);
98326             if( r1!=r2 ){
98327               sqlcipher3VdbeAddOp2(v, OP_SCopy, r2, r1);
98328             }
98329             j++;
98330           }
98331         }
98332         regRecord = sqlcipher3GetTempReg(pParse);
98333         sqlcipher3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
98334         sqlcipher3VdbeAddOp2(v, OP_SorterInsert, sAggInfo.sortingIdx, regRecord);
98335         sqlcipher3ReleaseTempReg(pParse, regRecord);
98336         sqlcipher3ReleaseTempRange(pParse, regBase, nCol);
98337         sqlcipher3WhereEnd(pWInfo);
98338         sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++;
98339         sortOut = sqlcipher3GetTempReg(pParse);
98340         sqlcipher3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
98341         sqlcipher3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd);
98342         VdbeComment((v, "GROUP BY sort"));
98343         sAggInfo.useSortingIdx = 1;
98344         sqlcipher3ExprCacheClear(pParse);
98345       }
98346
98347       /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
98348       ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
98349       ** Then compare the current GROUP BY terms against the GROUP BY terms
98350       ** from the previous row currently stored in a0, a1, a2...
98351       */
98352       addrTopOfLoop = sqlcipher3VdbeCurrentAddr(v);
98353       sqlcipher3ExprCacheClear(pParse);
98354       if( groupBySort ){
98355         sqlcipher3VdbeAddOp2(v, OP_SorterData, sAggInfo.sortingIdx, sortOut);
98356       }
98357       for(j=0; j<pGroupBy->nExpr; j++){
98358         if( groupBySort ){
98359           sqlcipher3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
98360           if( j==0 ) sqlcipher3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
98361         }else{
98362           sAggInfo.directMode = 1;
98363           sqlcipher3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
98364         }
98365       }
98366       sqlcipher3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
98367                           (char*)pKeyInfo, P4_KEYINFO);
98368       j1 = sqlcipher3VdbeCurrentAddr(v);
98369       sqlcipher3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1);
98370
98371       /* Generate code that runs whenever the GROUP BY changes.
98372       ** Changes in the GROUP BY are detected by the previous code
98373       ** block.  If there were no changes, this block is skipped.
98374       **
98375       ** This code copies current group by terms in b0,b1,b2,...
98376       ** over to a0,a1,a2.  It then calls the output subroutine
98377       ** and resets the aggregate accumulator registers in preparation
98378       ** for the next GROUP BY batch.
98379       */
98380       sqlcipher3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
98381       sqlcipher3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
98382       VdbeComment((v, "output one row"));
98383       sqlcipher3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
98384       VdbeComment((v, "check abort flag"));
98385       sqlcipher3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
98386       VdbeComment((v, "reset accumulator"));
98387
98388       /* Update the aggregate accumulators based on the content of
98389       ** the current row
98390       */
98391       sqlcipher3VdbeJumpHere(v, j1);
98392       updateAccumulator(pParse, &sAggInfo);
98393       sqlcipher3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
98394       VdbeComment((v, "indicate data in accumulator"));
98395
98396       /* End of the loop
98397       */
98398       if( groupBySort ){
98399         sqlcipher3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop);
98400       }else{
98401         sqlcipher3WhereEnd(pWInfo);
98402         sqlcipher3VdbeChangeToNoop(v, addrSortingIdx);
98403       }
98404
98405       /* Output the final row of result
98406       */
98407       sqlcipher3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
98408       VdbeComment((v, "output final row"));
98409
98410       /* Jump over the subroutines
98411       */
98412       sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addrEnd);
98413
98414       /* Generate a subroutine that outputs a single row of the result
98415       ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
98416       ** is less than or equal to zero, the subroutine is a no-op.  If
98417       ** the processing calls for the query to abort, this subroutine
98418       ** increments the iAbortFlag memory location before returning in
98419       ** order to signal the caller to abort.
98420       */
98421       addrSetAbort = sqlcipher3VdbeCurrentAddr(v);
98422       sqlcipher3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
98423       VdbeComment((v, "set abort flag"));
98424       sqlcipher3VdbeAddOp1(v, OP_Return, regOutputRow);
98425       sqlcipher3VdbeResolveLabel(v, addrOutputRow);
98426       addrOutputRow = sqlcipher3VdbeCurrentAddr(v);
98427       sqlcipher3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
98428       VdbeComment((v, "Groupby result generator entry point"));
98429       sqlcipher3VdbeAddOp1(v, OP_Return, regOutputRow);
98430       finalizeAggFunctions(pParse, &sAggInfo);
98431       sqlcipher3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLCIPHER_JUMPIFNULL);
98432       selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
98433                       distinct, pDest,
98434                       addrOutputRow+1, addrSetAbort);
98435       sqlcipher3VdbeAddOp1(v, OP_Return, regOutputRow);
98436       VdbeComment((v, "end groupby result generator"));
98437
98438       /* Generate a subroutine that will reset the group-by accumulator
98439       */
98440       sqlcipher3VdbeResolveLabel(v, addrReset);
98441       resetAccumulator(pParse, &sAggInfo);
98442       sqlcipher3VdbeAddOp1(v, OP_Return, regReset);
98443      
98444     } /* endif pGroupBy.  Begin aggregate queries without GROUP BY: */
98445     else {
98446       ExprList *pDel = 0;
98447 #ifndef SQLCIPHER_OMIT_BTREECOUNT
98448       Table *pTab;
98449       if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
98450         /* If isSimpleCount() returns a pointer to a Table structure, then
98451         ** the SQL statement is of the form:
98452         **
98453         **   SELECT count(*) FROM <tbl>
98454         **
98455         ** where the Table structure returned represents table <tbl>.
98456         **
98457         ** This statement is so common that it is optimized specially. The
98458         ** OP_Count instruction is executed either on the intkey table that
98459         ** contains the data for table <tbl> or on one of its indexes. It
98460         ** is better to execute the op on an index, as indexes are almost
98461         ** always spread across less pages than their corresponding tables.
98462         */
98463         const int iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
98464         const int iCsr = pParse->nTab++;     /* Cursor to scan b-tree */
98465         Index *pIdx;                         /* Iterator variable */
98466         KeyInfo *pKeyInfo = 0;               /* Keyinfo for scanned index */
98467         Index *pBest = 0;                    /* Best index found so far */
98468         int iRoot = pTab->tnum;              /* Root page of scanned b-tree */
98469
98470         sqlcipher3CodeVerifySchema(pParse, iDb);
98471         sqlcipher3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
98472
98473         /* Search for the index that has the least amount of columns. If
98474         ** there is such an index, and it has less columns than the table
98475         ** does, then we can assume that it consumes less space on disk and
98476         ** will therefore be cheaper to scan to determine the query result.
98477         ** In this case set iRoot to the root page number of the index b-tree
98478         ** and pKeyInfo to the KeyInfo structure required to navigate the
98479         ** index.
98480         **
98481         ** (2011-04-15) Do not do a full scan of an unordered index.
98482         **
98483         ** In practice the KeyInfo structure will not be used. It is only 
98484         ** passed to keep OP_OpenRead happy.
98485         */
98486         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
98487           if( pIdx->bUnordered==0 && (!pBest || pIdx->nColumn<pBest->nColumn) ){
98488             pBest = pIdx;
98489           }
98490         }
98491         if( pBest && pBest->nColumn<pTab->nCol ){
98492           iRoot = pBest->tnum;
98493           pKeyInfo = sqlcipher3IndexKeyinfo(pParse, pBest);
98494         }
98495
98496         /* Open a read-only cursor, execute the OP_Count, close the cursor. */
98497         sqlcipher3VdbeAddOp3(v, OP_OpenRead, iCsr, iRoot, iDb);
98498         if( pKeyInfo ){
98499           sqlcipher3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO_HANDOFF);
98500         }
98501         sqlcipher3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem);
98502         sqlcipher3VdbeAddOp1(v, OP_Close, iCsr);
98503         explainSimpleCount(pParse, pTab, pBest);
98504       }else
98505 #endif /* SQLCIPHER_OMIT_BTREECOUNT */
98506       {
98507         /* Check if the query is of one of the following forms:
98508         **
98509         **   SELECT min(x) FROM ...
98510         **   SELECT max(x) FROM ...
98511         **
98512         ** If it is, then ask the code in where.c to attempt to sort results
98513         ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause. 
98514         ** If where.c is able to produce results sorted in this order, then
98515         ** add vdbe code to break out of the processing loop after the 
98516         ** first iteration (since the first iteration of the loop is 
98517         ** guaranteed to operate on the row with the minimum or maximum 
98518         ** value of x, the only row required).
98519         **
98520         ** A special flag must be passed to sqlcipher3WhereBegin() to slightly
98521         ** modify behaviour as follows:
98522         **
98523         **   + If the query is a "SELECT min(x)", then the loop coded by
98524         **     where.c should not iterate over any values with a NULL value
98525         **     for x.
98526         **
98527         **   + The optimizer code in where.c (the thing that decides which
98528         **     index or indices to use) should place a different priority on 
98529         **     satisfying the 'ORDER BY' clause than it does in other cases.
98530         **     Refer to code and comments in where.c for details.
98531         */
98532         ExprList *pMinMax = 0;
98533         u8 flag = minMaxQuery(p);
98534         if( flag ){
98535           assert( !ExprHasProperty(p->pEList->a[0].pExpr, EP_xIsSelect) );
98536           pMinMax = sqlcipher3ExprListDup(db, p->pEList->a[0].pExpr->x.pList,0);
98537           pDel = pMinMax;
98538           if( pMinMax && !db->mallocFailed ){
98539             pMinMax->a[0].sortOrder = flag!=WHERE_ORDERBY_MIN ?1:0;
98540             pMinMax->a[0].pExpr->op = TK_COLUMN;
98541           }
98542         }
98543   
98544         /* This case runs if the aggregate has no GROUP BY clause.  The
98545         ** processing is much simpler since there is only a single row
98546         ** of output.
98547         */
98548         resetAccumulator(pParse, &sAggInfo);
98549         pWInfo = sqlcipher3WhereBegin(pParse, pTabList, pWhere, &pMinMax, 0, flag);
98550         if( pWInfo==0 ){
98551           sqlcipher3ExprListDelete(db, pDel);
98552           goto select_end;
98553         }
98554         updateAccumulator(pParse, &sAggInfo);
98555         if( !pMinMax && flag ){
98556           sqlcipher3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak);
98557           VdbeComment((v, "%s() by index",
98558                 (flag==WHERE_ORDERBY_MIN?"min":"max")));
98559         }
98560         sqlcipher3WhereEnd(pWInfo);
98561         finalizeAggFunctions(pParse, &sAggInfo);
98562       }
98563
98564       pOrderBy = 0;
98565       sqlcipher3ExprIfFalse(pParse, pHaving, addrEnd, SQLCIPHER_JUMPIFNULL);
98566       selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1, 
98567                       pDest, addrEnd, addrEnd);
98568       sqlcipher3ExprListDelete(db, pDel);
98569     }
98570     sqlcipher3VdbeResolveLabel(v, addrEnd);
98571     
98572   } /* endif aggregate query */
98573
98574   if( distinct>=0 ){
98575     explainTempTable(pParse, "DISTINCT");
98576   }
98577
98578   /* If there is an ORDER BY clause, then we need to sort the results
98579   ** and send them to the callback one by one.
98580   */
98581   if( pOrderBy ){
98582     explainTempTable(pParse, "ORDER BY");
98583     generateSortTail(pParse, p, v, pEList->nExpr, pDest);
98584   }
98585
98586   /* Jump here to skip this query
98587   */
98588   sqlcipher3VdbeResolveLabel(v, iEnd);
98589
98590   /* The SELECT was successfully coded.   Set the return code to 0
98591   ** to indicate no errors.
98592   */
98593   rc = 0;
98594
98595   /* Control jumps to here if an error is encountered above, or upon
98596   ** successful coding of the SELECT.
98597   */
98598 select_end:
98599   explainSetInteger(pParse->iSelectId, iRestoreSelectId);
98600
98601   /* Identify column names if results of the SELECT are to be output.
98602   */
98603   if( rc==SQLCIPHER_OK && pDest->eDest==SRT_Output ){
98604     generateColumnNames(pParse, pTabList, pEList);
98605   }
98606
98607   sqlcipher3DbFree(db, sAggInfo.aCol);
98608   sqlcipher3DbFree(db, sAggInfo.aFunc);
98609   return rc;
98610 }
98611
98612 #if defined(SQLCIPHER_DEBUG)
98613 /*
98614 *******************************************************************************
98615 ** The following code is used for testing and debugging only.  The code
98616 ** that follows does not appear in normal builds.
98617 **
98618 ** These routines are used to print out the content of all or part of a 
98619 ** parse structures such as Select or Expr.  Such printouts are useful
98620 ** for helping to understand what is happening inside the code generator
98621 ** during the execution of complex SELECT statements.
98622 **
98623 ** These routine are not called anywhere from within the normal
98624 ** code base.  Then are intended to be called from within the debugger
98625 ** or from temporary "printf" statements inserted for debugging.
98626 */
98627 SQLCIPHER_PRIVATE void sqlcipher3PrintExpr(Expr *p){
98628   if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
98629     sqlcipher3DebugPrintf("(%s", p->u.zToken);
98630   }else{
98631     sqlcipher3DebugPrintf("(%d", p->op);
98632   }
98633   if( p->pLeft ){
98634     sqlcipher3DebugPrintf(" ");
98635     sqlcipher3PrintExpr(p->pLeft);
98636   }
98637   if( p->pRight ){
98638     sqlcipher3DebugPrintf(" ");
98639     sqlcipher3PrintExpr(p->pRight);
98640   }
98641   sqlcipher3DebugPrintf(")");
98642 }
98643 SQLCIPHER_PRIVATE void sqlcipher3PrintExprList(ExprList *pList){
98644   int i;
98645   for(i=0; i<pList->nExpr; i++){
98646     sqlcipher3PrintExpr(pList->a[i].pExpr);
98647     if( i<pList->nExpr-1 ){
98648       sqlcipher3DebugPrintf(", ");
98649     }
98650   }
98651 }
98652 SQLCIPHER_PRIVATE void sqlcipher3PrintSelect(Select *p, int indent){
98653   sqlcipher3DebugPrintf("%*sSELECT(%p) ", indent, "", p);
98654   sqlcipher3PrintExprList(p->pEList);
98655   sqlcipher3DebugPrintf("\n");
98656   if( p->pSrc ){
98657     char *zPrefix;
98658     int i;
98659     zPrefix = "FROM";
98660     for(i=0; i<p->pSrc->nSrc; i++){
98661       struct SrcList_item *pItem = &p->pSrc->a[i];
98662       sqlcipher3DebugPrintf("%*s ", indent+6, zPrefix);
98663       zPrefix = "";
98664       if( pItem->pSelect ){
98665         sqlcipher3DebugPrintf("(\n");
98666         sqlcipher3PrintSelect(pItem->pSelect, indent+10);
98667         sqlcipher3DebugPrintf("%*s)", indent+8, "");
98668       }else if( pItem->zName ){
98669         sqlcipher3DebugPrintf("%s", pItem->zName);
98670       }
98671       if( pItem->pTab ){
98672         sqlcipher3DebugPrintf("(table: %s)", pItem->pTab->zName);
98673       }
98674       if( pItem->zAlias ){
98675         sqlcipher3DebugPrintf(" AS %s", pItem->zAlias);
98676       }
98677       if( i<p->pSrc->nSrc-1 ){
98678         sqlcipher3DebugPrintf(",");
98679       }
98680       sqlcipher3DebugPrintf("\n");
98681     }
98682   }
98683   if( p->pWhere ){
98684     sqlcipher3DebugPrintf("%*s WHERE ", indent, "");
98685     sqlcipher3PrintExpr(p->pWhere);
98686     sqlcipher3DebugPrintf("\n");
98687   }
98688   if( p->pGroupBy ){
98689     sqlcipher3DebugPrintf("%*s GROUP BY ", indent, "");
98690     sqlcipher3PrintExprList(p->pGroupBy);
98691     sqlcipher3DebugPrintf("\n");
98692   }
98693   if( p->pHaving ){
98694     sqlcipher3DebugPrintf("%*s HAVING ", indent, "");
98695     sqlcipher3PrintExpr(p->pHaving);
98696     sqlcipher3DebugPrintf("\n");
98697   }
98698   if( p->pOrderBy ){
98699     sqlcipher3DebugPrintf("%*s ORDER BY ", indent, "");
98700     sqlcipher3PrintExprList(p->pOrderBy);
98701     sqlcipher3DebugPrintf("\n");
98702   }
98703 }
98704 /* End of the structure debug printing code
98705 *****************************************************************************/
98706 #endif /* defined(SQLCIPHER_TEST) || defined(SQLCIPHER_DEBUG) */
98707
98708 /************** End of select.c **********************************************/
98709 /************** Begin file table.c *******************************************/
98710 /*
98711 ** 2001 September 15
98712 **
98713 ** The author disclaims copyright to this source code.  In place of
98714 ** a legal notice, here is a blessing:
98715 **
98716 **    May you do good and not evil.
98717 **    May you find forgiveness for yourself and forgive others.
98718 **    May you share freely, never taking more than you give.
98719 **
98720 *************************************************************************
98721 ** This file contains the sqlcipher3_get_table() and sqlcipher3_free_table()
98722 ** interface routines.  These are just wrappers around the main
98723 ** interface routine of sqlcipher3_exec().
98724 **
98725 ** These routines are in a separate files so that they will not be linked
98726 ** if they are not used.
98727 */
98728 /* #include <stdlib.h> */
98729 /* #include <string.h> */
98730
98731 #ifndef SQLCIPHER_OMIT_GET_TABLE
98732
98733 /*
98734 ** This structure is used to pass data from sqlcipher3_get_table() through
98735 ** to the callback function is uses to build the result.
98736 */
98737 typedef struct TabResult {
98738   char **azResult;   /* Accumulated output */
98739   char *zErrMsg;     /* Error message text, if an error occurs */
98740   int nAlloc;        /* Slots allocated for azResult[] */
98741   int nRow;          /* Number of rows in the result */
98742   int nColumn;       /* Number of columns in the result */
98743   int nData;         /* Slots used in azResult[].  (nRow+1)*nColumn */
98744   int rc;            /* Return code from sqlcipher3_exec() */
98745 } TabResult;
98746
98747 /*
98748 ** This routine is called once for each row in the result table.  Its job
98749 ** is to fill in the TabResult structure appropriately, allocating new
98750 ** memory as necessary.
98751 */
98752 static int sqlcipher3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
98753   TabResult *p = (TabResult*)pArg;  /* Result accumulator */
98754   int need;                         /* Slots needed in p->azResult[] */
98755   int i;                            /* Loop counter */
98756   char *z;                          /* A single column of result */
98757
98758   /* Make sure there is enough space in p->azResult to hold everything
98759   ** we need to remember from this invocation of the callback.
98760   */
98761   if( p->nRow==0 && argv!=0 ){
98762     need = nCol*2;
98763   }else{
98764     need = nCol;
98765   }
98766   if( p->nData + need > p->nAlloc ){
98767     char **azNew;
98768     p->nAlloc = p->nAlloc*2 + need;
98769     azNew = sqlcipher3_realloc( p->azResult, sizeof(char*)*p->nAlloc );
98770     if( azNew==0 ) goto malloc_failed;
98771     p->azResult = azNew;
98772   }
98773
98774   /* If this is the first row, then generate an extra row containing
98775   ** the names of all columns.
98776   */
98777   if( p->nRow==0 ){
98778     p->nColumn = nCol;
98779     for(i=0; i<nCol; i++){
98780       z = sqlcipher3_mprintf("%s", colv[i]);
98781       if( z==0 ) goto malloc_failed;
98782       p->azResult[p->nData++] = z;
98783     }
98784   }else if( p->nColumn!=nCol ){
98785     sqlcipher3_free(p->zErrMsg);
98786     p->zErrMsg = sqlcipher3_mprintf(
98787        "sqlcipher3_get_table() called with two or more incompatible queries"
98788     );
98789     p->rc = SQLCIPHER_ERROR;
98790     return 1;
98791   }
98792
98793   /* Copy over the row data
98794   */
98795   if( argv!=0 ){
98796     for(i=0; i<nCol; i++){
98797       if( argv[i]==0 ){
98798         z = 0;
98799       }else{
98800         int n = sqlcipher3Strlen30(argv[i])+1;
98801         z = sqlcipher3_malloc( n );
98802         if( z==0 ) goto malloc_failed;
98803         memcpy(z, argv[i], n);
98804       }
98805       p->azResult[p->nData++] = z;
98806     }
98807     p->nRow++;
98808   }
98809   return 0;
98810
98811 malloc_failed:
98812   p->rc = SQLCIPHER_NOMEM;
98813   return 1;
98814 }
98815
98816 /*
98817 ** Query the database.  But instead of invoking a callback for each row,
98818 ** malloc() for space to hold the result and return the entire results
98819 ** at the conclusion of the call.
98820 **
98821 ** The result that is written to ***pazResult is held in memory obtained
98822 ** from malloc().  But the caller cannot free this memory directly.  
98823 ** Instead, the entire table should be passed to sqlcipher3_free_table() when
98824 ** the calling procedure is finished using it.
98825 */
98826 SQLCIPHER_API int sqlcipher3_get_table(
98827   sqlcipher3 *db,                /* The database on which the SQL executes */
98828   const char *zSql,           /* The SQL to be executed */
98829   char ***pazResult,          /* Write the result table here */
98830   int *pnRow,                 /* Write the number of rows in the result here */
98831   int *pnColumn,              /* Write the number of columns of result here */
98832   char **pzErrMsg             /* Write error messages here */
98833 ){
98834   int rc;
98835   TabResult res;
98836
98837   *pazResult = 0;
98838   if( pnColumn ) *pnColumn = 0;
98839   if( pnRow ) *pnRow = 0;
98840   if( pzErrMsg ) *pzErrMsg = 0;
98841   res.zErrMsg = 0;
98842   res.nRow = 0;
98843   res.nColumn = 0;
98844   res.nData = 1;
98845   res.nAlloc = 20;
98846   res.rc = SQLCIPHER_OK;
98847   res.azResult = sqlcipher3_malloc(sizeof(char*)*res.nAlloc );
98848   if( res.azResult==0 ){
98849      db->errCode = SQLCIPHER_NOMEM;
98850      return SQLCIPHER_NOMEM;
98851   }
98852   res.azResult[0] = 0;
98853   rc = sqlcipher3_exec(db, zSql, sqlcipher3_get_table_cb, &res, pzErrMsg);
98854   assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
98855   res.azResult[0] = SQLCIPHER_INT_TO_PTR(res.nData);
98856   if( (rc&0xff)==SQLCIPHER_ABORT ){
98857     sqlcipher3_free_table(&res.azResult[1]);
98858     if( res.zErrMsg ){
98859       if( pzErrMsg ){
98860         sqlcipher3_free(*pzErrMsg);
98861         *pzErrMsg = sqlcipher3_mprintf("%s",res.zErrMsg);
98862       }
98863       sqlcipher3_free(res.zErrMsg);
98864     }
98865     db->errCode = res.rc;  /* Assume 32-bit assignment is atomic */
98866     return res.rc;
98867   }
98868   sqlcipher3_free(res.zErrMsg);
98869   if( rc!=SQLCIPHER_OK ){
98870     sqlcipher3_free_table(&res.azResult[1]);
98871     return rc;
98872   }
98873   if( res.nAlloc>res.nData ){
98874     char **azNew;
98875     azNew = sqlcipher3_realloc( res.azResult, sizeof(char*)*res.nData );
98876     if( azNew==0 ){
98877       sqlcipher3_free_table(&res.azResult[1]);
98878       db->errCode = SQLCIPHER_NOMEM;
98879       return SQLCIPHER_NOMEM;
98880     }
98881     res.azResult = azNew;
98882   }
98883   *pazResult = &res.azResult[1];
98884   if( pnColumn ) *pnColumn = res.nColumn;
98885   if( pnRow ) *pnRow = res.nRow;
98886   return rc;
98887 }
98888
98889 /*
98890 ** This routine frees the space the sqlcipher3_get_table() malloced.
98891 */
98892 SQLCIPHER_API void sqlcipher3_free_table(
98893   char **azResult            /* Result returned from from sqlcipher3_get_table() */
98894 ){
98895   if( azResult ){
98896     int i, n;
98897     azResult--;
98898     assert( azResult!=0 );
98899     n = SQLCIPHER_PTR_TO_INT(azResult[0]);
98900     for(i=1; i<n; i++){ if( azResult[i] ) sqlcipher3_free(azResult[i]); }
98901     sqlcipher3_free(azResult);
98902   }
98903 }
98904
98905 #endif /* SQLCIPHER_OMIT_GET_TABLE */
98906
98907 /************** End of table.c ***********************************************/
98908 /************** Begin file trigger.c *****************************************/
98909 /*
98910 **
98911 ** The author disclaims copyright to this source code.  In place of
98912 ** a legal notice, here is a blessing:
98913 **
98914 **    May you do good and not evil.
98915 **    May you find forgiveness for yourself and forgive others.
98916 **    May you share freely, never taking more than you give.
98917 **
98918 *************************************************************************
98919 ** This file contains the implementation for TRIGGERs
98920 */
98921
98922 #ifndef SQLCIPHER_OMIT_TRIGGER
98923 /*
98924 ** Delete a linked list of TriggerStep structures.
98925 */
98926 SQLCIPHER_PRIVATE void sqlcipher3DeleteTriggerStep(sqlcipher3 *db, TriggerStep *pTriggerStep){
98927   while( pTriggerStep ){
98928     TriggerStep * pTmp = pTriggerStep;
98929     pTriggerStep = pTriggerStep->pNext;
98930
98931     sqlcipher3ExprDelete(db, pTmp->pWhere);
98932     sqlcipher3ExprListDelete(db, pTmp->pExprList);
98933     sqlcipher3SelectDelete(db, pTmp->pSelect);
98934     sqlcipher3IdListDelete(db, pTmp->pIdList);
98935
98936     sqlcipher3DbFree(db, pTmp);
98937   }
98938 }
98939
98940 /*
98941 ** Given table pTab, return a list of all the triggers attached to 
98942 ** the table. The list is connected by Trigger.pNext pointers.
98943 **
98944 ** All of the triggers on pTab that are in the same database as pTab
98945 ** are already attached to pTab->pTrigger.  But there might be additional
98946 ** triggers on pTab in the TEMP schema.  This routine prepends all
98947 ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
98948 ** and returns the combined list.
98949 **
98950 ** To state it another way:  This routine returns a list of all triggers
98951 ** that fire off of pTab.  The list will include any TEMP triggers on
98952 ** pTab as well as the triggers lised in pTab->pTrigger.
98953 */
98954 SQLCIPHER_PRIVATE Trigger *sqlcipher3TriggerList(Parse *pParse, Table *pTab){
98955   Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
98956   Trigger *pList = 0;                  /* List of triggers to return */
98957
98958   if( pParse->disableTriggers ){
98959     return 0;
98960   }
98961
98962   if( pTmpSchema!=pTab->pSchema ){
98963     HashElem *p;
98964     assert( sqlcipher3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
98965     for(p=sqlcipherHashFirst(&pTmpSchema->trigHash); p; p=sqlcipherHashNext(p)){
98966       Trigger *pTrig = (Trigger *)sqlcipherHashData(p);
98967       if( pTrig->pTabSchema==pTab->pSchema
98968        && 0==sqlcipher3StrICmp(pTrig->table, pTab->zName) 
98969       ){
98970         pTrig->pNext = (pList ? pList : pTab->pTrigger);
98971         pList = pTrig;
98972       }
98973     }
98974   }
98975
98976   return (pList ? pList : pTab->pTrigger);
98977 }
98978
98979 /*
98980 ** This is called by the parser when it sees a CREATE TRIGGER statement
98981 ** up to the point of the BEGIN before the trigger actions.  A Trigger
98982 ** structure is generated based on the information available and stored
98983 ** in pParse->pNewTrigger.  After the trigger actions have been parsed, the
98984 ** sqlcipher3FinishTrigger() function is called to complete the trigger
98985 ** construction process.
98986 */
98987 SQLCIPHER_PRIVATE void sqlcipher3BeginTrigger(
98988   Parse *pParse,      /* The parse context of the CREATE TRIGGER statement */
98989   Token *pName1,      /* The name of the trigger */
98990   Token *pName2,      /* The name of the trigger */
98991   int tr_tm,          /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */
98992   int op,             /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
98993   IdList *pColumns,   /* column list if this is an UPDATE OF trigger */
98994   SrcList *pTableName,/* The name of the table/view the trigger applies to */
98995   Expr *pWhen,        /* WHEN clause */
98996   int isTemp,         /* True if the TEMPORARY keyword is present */
98997   int noErr           /* Suppress errors if the trigger already exists */
98998 ){
98999   Trigger *pTrigger = 0;  /* The new trigger */
99000   Table *pTab;            /* Table that the trigger fires off of */
99001   char *zName = 0;        /* Name of the trigger */
99002   sqlcipher3 *db = pParse->db;  /* The database connection */
99003   int iDb;                /* The database to store the trigger in */
99004   Token *pName;           /* The unqualified db name */
99005   DbFixer sFix;           /* State vector for the DB fixer */
99006   int iTabDb;             /* Index of the database holding pTab */
99007
99008   assert( pName1!=0 );   /* pName1->z might be NULL, but not pName1 itself */
99009   assert( pName2!=0 );
99010   assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
99011   assert( op>0 && op<0xff );
99012   if( isTemp ){
99013     /* If TEMP was specified, then the trigger name may not be qualified. */
99014     if( pName2->n>0 ){
99015       sqlcipher3ErrorMsg(pParse, "temporary trigger may not have qualified name");
99016       goto trigger_cleanup;
99017     }
99018     iDb = 1;
99019     pName = pName1;
99020   }else{
99021     /* Figure out the db that the the trigger will be created in */
99022     iDb = sqlcipher3TwoPartName(pParse, pName1, pName2, &pName);
99023     if( iDb<0 ){
99024       goto trigger_cleanup;
99025     }
99026   }
99027   if( !pTableName || db->mallocFailed ){
99028     goto trigger_cleanup;
99029   }
99030
99031   /* A long-standing parser bug is that this syntax was allowed:
99032   **
99033   **    CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
99034   **                                                 ^^^^^^^^
99035   **
99036   ** To maintain backwards compatibility, ignore the database
99037   ** name on pTableName if we are reparsing our of SQLCIPHER_MASTER.
99038   */
99039   if( db->init.busy && iDb!=1 ){
99040     sqlcipher3DbFree(db, pTableName->a[0].zDatabase);
99041     pTableName->a[0].zDatabase = 0;
99042   }
99043
99044   /* If the trigger name was unqualified, and the table is a temp table,
99045   ** then set iDb to 1 to create the trigger in the temporary database.
99046   ** If sqlcipher3SrcListLookup() returns 0, indicating the table does not
99047   ** exist, the error is caught by the block below.
99048   */
99049   pTab = sqlcipher3SrcListLookup(pParse, pTableName);
99050   if( db->init.busy==0 && pName2->n==0 && pTab
99051         && pTab->pSchema==db->aDb[1].pSchema ){
99052     iDb = 1;
99053   }
99054
99055   /* Ensure the table name matches database name and that the table exists */
99056   if( db->mallocFailed ) goto trigger_cleanup;
99057   assert( pTableName->nSrc==1 );
99058   if( sqlcipher3FixInit(&sFix, pParse, iDb, "trigger", pName) && 
99059       sqlcipher3FixSrcList(&sFix, pTableName) ){
99060     goto trigger_cleanup;
99061   }
99062   pTab = sqlcipher3SrcListLookup(pParse, pTableName);
99063   if( !pTab ){
99064     /* The table does not exist. */
99065     if( db->init.iDb==1 ){
99066       /* Ticket #3810.
99067       ** Normally, whenever a table is dropped, all associated triggers are
99068       ** dropped too.  But if a TEMP trigger is created on a non-TEMP table
99069       ** and the table is dropped by a different database connection, the
99070       ** trigger is not visible to the database connection that does the
99071       ** drop so the trigger cannot be dropped.  This results in an
99072       ** "orphaned trigger" - a trigger whose associated table is missing.
99073       */
99074       db->init.orphanTrigger = 1;
99075     }
99076     goto trigger_cleanup;
99077   }
99078   if( IsVirtual(pTab) ){
99079     sqlcipher3ErrorMsg(pParse, "cannot create triggers on virtual tables");
99080     goto trigger_cleanup;
99081   }
99082
99083   /* Check that the trigger name is not reserved and that no trigger of the
99084   ** specified name exists */
99085   zName = sqlcipher3NameFromToken(db, pName);
99086   if( !zName || SQLCIPHER_OK!=sqlcipher3CheckObjectName(pParse, zName) ){
99087     goto trigger_cleanup;
99088   }
99089   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
99090   if( sqlcipher3HashFind(&(db->aDb[iDb].pSchema->trigHash),
99091                       zName, sqlcipher3Strlen30(zName)) ){
99092     if( !noErr ){
99093       sqlcipher3ErrorMsg(pParse, "trigger %T already exists", pName);
99094     }else{
99095       assert( !db->init.busy );
99096       sqlcipher3CodeVerifySchema(pParse, iDb);
99097     }
99098     goto trigger_cleanup;
99099   }
99100
99101   /* Do not create a trigger on a system table */
99102   if( sqlcipher3StrNICmp(pTab->zName, "sqlcipher_", 7)==0 ){
99103     sqlcipher3ErrorMsg(pParse, "cannot create trigger on system table");
99104     pParse->nErr++;
99105     goto trigger_cleanup;
99106   }
99107
99108   /* INSTEAD of triggers are only for views and views only support INSTEAD
99109   ** of triggers.
99110   */
99111   if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
99112     sqlcipher3ErrorMsg(pParse, "cannot create %s trigger on view: %S", 
99113         (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
99114     goto trigger_cleanup;
99115   }
99116   if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
99117     sqlcipher3ErrorMsg(pParse, "cannot create INSTEAD OF"
99118         " trigger on table: %S", pTableName, 0);
99119     goto trigger_cleanup;
99120   }
99121   iTabDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
99122
99123 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
99124   {
99125     int code = SQLCIPHER_CREATE_TRIGGER;
99126     const char *zDb = db->aDb[iTabDb].zName;
99127     const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
99128     if( iTabDb==1 || isTemp ) code = SQLCIPHER_CREATE_TEMP_TRIGGER;
99129     if( sqlcipher3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
99130       goto trigger_cleanup;
99131     }
99132     if( sqlcipher3AuthCheck(pParse, SQLCIPHER_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
99133       goto trigger_cleanup;
99134     }
99135   }
99136 #endif
99137
99138   /* INSTEAD OF triggers can only appear on views and BEFORE triggers
99139   ** cannot appear on views.  So we might as well translate every
99140   ** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code
99141   ** elsewhere.
99142   */
99143   if (tr_tm == TK_INSTEAD){
99144     tr_tm = TK_BEFORE;
99145   }
99146
99147   /* Build the Trigger object */
99148   pTrigger = (Trigger*)sqlcipher3DbMallocZero(db, sizeof(Trigger));
99149   if( pTrigger==0 ) goto trigger_cleanup;
99150   pTrigger->zName = zName;
99151   zName = 0;
99152   pTrigger->table = sqlcipher3DbStrDup(db, pTableName->a[0].zName);
99153   pTrigger->pSchema = db->aDb[iDb].pSchema;
99154   pTrigger->pTabSchema = pTab->pSchema;
99155   pTrigger->op = (u8)op;
99156   pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
99157   pTrigger->pWhen = sqlcipher3ExprDup(db, pWhen, EXPRDUP_REDUCE);
99158   pTrigger->pColumns = sqlcipher3IdListDup(db, pColumns);
99159   assert( pParse->pNewTrigger==0 );
99160   pParse->pNewTrigger = pTrigger;
99161
99162 trigger_cleanup:
99163   sqlcipher3DbFree(db, zName);
99164   sqlcipher3SrcListDelete(db, pTableName);
99165   sqlcipher3IdListDelete(db, pColumns);
99166   sqlcipher3ExprDelete(db, pWhen);
99167   if( !pParse->pNewTrigger ){
99168     sqlcipher3DeleteTrigger(db, pTrigger);
99169   }else{
99170     assert( pParse->pNewTrigger==pTrigger );
99171   }
99172 }
99173
99174 /*
99175 ** This routine is called after all of the trigger actions have been parsed
99176 ** in order to complete the process of building the trigger.
99177 */
99178 SQLCIPHER_PRIVATE void sqlcipher3FinishTrigger(
99179   Parse *pParse,          /* Parser context */
99180   TriggerStep *pStepList, /* The triggered program */
99181   Token *pAll             /* Token that describes the complete CREATE TRIGGER */
99182 ){
99183   Trigger *pTrig = pParse->pNewTrigger;   /* Trigger being finished */
99184   char *zName;                            /* Name of trigger */
99185   sqlcipher3 *db = pParse->db;               /* The database */
99186   DbFixer sFix;                           /* Fixer object */
99187   int iDb;                                /* Database containing the trigger */
99188   Token nameToken;                        /* Trigger name for error reporting */
99189
99190   pParse->pNewTrigger = 0;
99191   if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
99192   zName = pTrig->zName;
99193   iDb = sqlcipher3SchemaToIndex(pParse->db, pTrig->pSchema);
99194   pTrig->step_list = pStepList;
99195   while( pStepList ){
99196     pStepList->pTrig = pTrig;
99197     pStepList = pStepList->pNext;
99198   }
99199   nameToken.z = pTrig->zName;
99200   nameToken.n = sqlcipher3Strlen30(nameToken.z);
99201   if( sqlcipher3FixInit(&sFix, pParse, iDb, "trigger", &nameToken) 
99202           && sqlcipher3FixTriggerStep(&sFix, pTrig->step_list) ){
99203     goto triggerfinish_cleanup;
99204   }
99205
99206   /* if we are not initializing,
99207   ** build the sqlcipher_master entry
99208   */
99209   if( !db->init.busy ){
99210     Vdbe *v;
99211     char *z;
99212
99213     /* Make an entry in the sqlcipher_master table */
99214     v = sqlcipher3GetVdbe(pParse);
99215     if( v==0 ) goto triggerfinish_cleanup;
99216     sqlcipher3BeginWriteOperation(pParse, 0, iDb);
99217     z = sqlcipher3DbStrNDup(db, (char*)pAll->z, pAll->n);
99218     sqlcipher3NestedParse(pParse,
99219        "INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
99220        db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
99221        pTrig->table, z);
99222     sqlcipher3DbFree(db, z);
99223     sqlcipher3ChangeCookie(pParse, iDb);
99224     sqlcipher3VdbeAddParseSchemaOp(v, iDb,
99225         sqlcipher3MPrintf(db, "type='trigger' AND name='%q'", zName));
99226   }
99227
99228   if( db->init.busy ){
99229     Trigger *pLink = pTrig;
99230     Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
99231     assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
99232     pTrig = sqlcipher3HashInsert(pHash, zName, sqlcipher3Strlen30(zName), pTrig);
99233     if( pTrig ){
99234       db->mallocFailed = 1;
99235     }else if( pLink->pSchema==pLink->pTabSchema ){
99236       Table *pTab;
99237       int n = sqlcipher3Strlen30(pLink->table);
99238       pTab = sqlcipher3HashFind(&pLink->pTabSchema->tblHash, pLink->table, n);
99239       assert( pTab!=0 );
99240       pLink->pNext = pTab->pTrigger;
99241       pTab->pTrigger = pLink;
99242     }
99243   }
99244
99245 triggerfinish_cleanup:
99246   sqlcipher3DeleteTrigger(db, pTrig);
99247   assert( !pParse->pNewTrigger );
99248   sqlcipher3DeleteTriggerStep(db, pStepList);
99249 }
99250
99251 /*
99252 ** Turn a SELECT statement (that the pSelect parameter points to) into
99253 ** a trigger step.  Return a pointer to a TriggerStep structure.
99254 **
99255 ** The parser calls this routine when it finds a SELECT statement in
99256 ** body of a TRIGGER.  
99257 */
99258 SQLCIPHER_PRIVATE TriggerStep *sqlcipher3TriggerSelectStep(sqlcipher3 *db, Select *pSelect){
99259   TriggerStep *pTriggerStep = sqlcipher3DbMallocZero(db, sizeof(TriggerStep));
99260   if( pTriggerStep==0 ) {
99261     sqlcipher3SelectDelete(db, pSelect);
99262     return 0;
99263   }
99264   pTriggerStep->op = TK_SELECT;
99265   pTriggerStep->pSelect = pSelect;
99266   pTriggerStep->orconf = OE_Default;
99267   return pTriggerStep;
99268 }
99269
99270 /*
99271 ** Allocate space to hold a new trigger step.  The allocated space
99272 ** holds both the TriggerStep object and the TriggerStep.target.z string.
99273 **
99274 ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
99275 */
99276 static TriggerStep *triggerStepAllocate(
99277   sqlcipher3 *db,                /* Database connection */
99278   u8 op,                      /* Trigger opcode */
99279   Token *pName                /* The target name */
99280 ){
99281   TriggerStep *pTriggerStep;
99282
99283   pTriggerStep = sqlcipher3DbMallocZero(db, sizeof(TriggerStep) + pName->n);
99284   if( pTriggerStep ){
99285     char *z = (char*)&pTriggerStep[1];
99286     memcpy(z, pName->z, pName->n);
99287     pTriggerStep->target.z = z;
99288     pTriggerStep->target.n = pName->n;
99289     pTriggerStep->op = op;
99290   }
99291   return pTriggerStep;
99292 }
99293
99294 /*
99295 ** Build a trigger step out of an INSERT statement.  Return a pointer
99296 ** to the new trigger step.
99297 **
99298 ** The parser calls this routine when it sees an INSERT inside the
99299 ** body of a trigger.
99300 */
99301 SQLCIPHER_PRIVATE TriggerStep *sqlcipher3TriggerInsertStep(
99302   sqlcipher3 *db,        /* The database connection */
99303   Token *pTableName,  /* Name of the table into which we insert */
99304   IdList *pColumn,    /* List of columns in pTableName to insert into */
99305   ExprList *pEList,   /* The VALUE clause: a list of values to be inserted */
99306   Select *pSelect,    /* A SELECT statement that supplies values */
99307   u8 orconf           /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
99308 ){
99309   TriggerStep *pTriggerStep;
99310
99311   assert(pEList == 0 || pSelect == 0);
99312   assert(pEList != 0 || pSelect != 0 || db->mallocFailed);
99313
99314   pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName);
99315   if( pTriggerStep ){
99316     pTriggerStep->pSelect = sqlcipher3SelectDup(db, pSelect, EXPRDUP_REDUCE);
99317     pTriggerStep->pIdList = pColumn;
99318     pTriggerStep->pExprList = sqlcipher3ExprListDup(db, pEList, EXPRDUP_REDUCE);
99319     pTriggerStep->orconf = orconf;
99320   }else{
99321     sqlcipher3IdListDelete(db, pColumn);
99322   }
99323   sqlcipher3ExprListDelete(db, pEList);
99324   sqlcipher3SelectDelete(db, pSelect);
99325
99326   return pTriggerStep;
99327 }
99328
99329 /*
99330 ** Construct a trigger step that implements an UPDATE statement and return
99331 ** a pointer to that trigger step.  The parser calls this routine when it
99332 ** sees an UPDATE statement inside the body of a CREATE TRIGGER.
99333 */
99334 SQLCIPHER_PRIVATE TriggerStep *sqlcipher3TriggerUpdateStep(
99335   sqlcipher3 *db,         /* The database connection */
99336   Token *pTableName,   /* Name of the table to be updated */
99337   ExprList *pEList,    /* The SET clause: list of column and new values */
99338   Expr *pWhere,        /* The WHERE clause */
99339   u8 orconf            /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
99340 ){
99341   TriggerStep *pTriggerStep;
99342
99343   pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName);
99344   if( pTriggerStep ){
99345     pTriggerStep->pExprList = sqlcipher3ExprListDup(db, pEList, EXPRDUP_REDUCE);
99346     pTriggerStep->pWhere = sqlcipher3ExprDup(db, pWhere, EXPRDUP_REDUCE);
99347     pTriggerStep->orconf = orconf;
99348   }
99349   sqlcipher3ExprListDelete(db, pEList);
99350   sqlcipher3ExprDelete(db, pWhere);
99351   return pTriggerStep;
99352 }
99353
99354 /*
99355 ** Construct a trigger step that implements a DELETE statement and return
99356 ** a pointer to that trigger step.  The parser calls this routine when it
99357 ** sees a DELETE statement inside the body of a CREATE TRIGGER.
99358 */
99359 SQLCIPHER_PRIVATE TriggerStep *sqlcipher3TriggerDeleteStep(
99360   sqlcipher3 *db,            /* Database connection */
99361   Token *pTableName,      /* The table from which rows are deleted */
99362   Expr *pWhere            /* The WHERE clause */
99363 ){
99364   TriggerStep *pTriggerStep;
99365
99366   pTriggerStep = triggerStepAllocate(db, TK_DELETE, pTableName);
99367   if( pTriggerStep ){
99368     pTriggerStep->pWhere = sqlcipher3ExprDup(db, pWhere, EXPRDUP_REDUCE);
99369     pTriggerStep->orconf = OE_Default;
99370   }
99371   sqlcipher3ExprDelete(db, pWhere);
99372   return pTriggerStep;
99373 }
99374
99375 /* 
99376 ** Recursively delete a Trigger structure
99377 */
99378 SQLCIPHER_PRIVATE void sqlcipher3DeleteTrigger(sqlcipher3 *db, Trigger *pTrigger){
99379   if( pTrigger==0 ) return;
99380   sqlcipher3DeleteTriggerStep(db, pTrigger->step_list);
99381   sqlcipher3DbFree(db, pTrigger->zName);
99382   sqlcipher3DbFree(db, pTrigger->table);
99383   sqlcipher3ExprDelete(db, pTrigger->pWhen);
99384   sqlcipher3IdListDelete(db, pTrigger->pColumns);
99385   sqlcipher3DbFree(db, pTrigger);
99386 }
99387
99388 /*
99389 ** This function is called to drop a trigger from the database schema. 
99390 **
99391 ** This may be called directly from the parser and therefore identifies
99392 ** the trigger by name.  The sqlcipher3DropTriggerPtr() routine does the
99393 ** same job as this routine except it takes a pointer to the trigger
99394 ** instead of the trigger name.
99395 **/
99396 SQLCIPHER_PRIVATE void sqlcipher3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
99397   Trigger *pTrigger = 0;
99398   int i;
99399   const char *zDb;
99400   const char *zName;
99401   int nName;
99402   sqlcipher3 *db = pParse->db;
99403
99404   if( db->mallocFailed ) goto drop_trigger_cleanup;
99405   if( SQLCIPHER_OK!=sqlcipher3ReadSchema(pParse) ){
99406     goto drop_trigger_cleanup;
99407   }
99408
99409   assert( pName->nSrc==1 );
99410   zDb = pName->a[0].zDatabase;
99411   zName = pName->a[0].zName;
99412   nName = sqlcipher3Strlen30(zName);
99413   assert( zDb!=0 || sqlcipher3BtreeHoldsAllMutexes(db) );
99414   for(i=OMIT_TEMPDB; i<db->nDb; i++){
99415     int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
99416     if( zDb && sqlcipher3StrICmp(db->aDb[j].zName, zDb) ) continue;
99417     assert( sqlcipher3SchemaMutexHeld(db, j, 0) );
99418     pTrigger = sqlcipher3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);
99419     if( pTrigger ) break;
99420   }
99421   if( !pTrigger ){
99422     if( !noErr ){
99423       sqlcipher3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
99424     }else{
99425       sqlcipher3CodeVerifyNamedSchema(pParse, zDb);
99426     }
99427     pParse->checkSchema = 1;
99428     goto drop_trigger_cleanup;
99429   }
99430   sqlcipher3DropTriggerPtr(pParse, pTrigger);
99431
99432 drop_trigger_cleanup:
99433   sqlcipher3SrcListDelete(db, pName);
99434 }
99435
99436 /*
99437 ** Return a pointer to the Table structure for the table that a trigger
99438 ** is set on.
99439 */
99440 static Table *tableOfTrigger(Trigger *pTrigger){
99441   int n = sqlcipher3Strlen30(pTrigger->table);
99442   return sqlcipher3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table, n);
99443 }
99444
99445
99446 /*
99447 ** Drop a trigger given a pointer to that trigger. 
99448 */
99449 SQLCIPHER_PRIVATE void sqlcipher3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
99450   Table   *pTable;
99451   Vdbe *v;
99452   sqlcipher3 *db = pParse->db;
99453   int iDb;
99454
99455   iDb = sqlcipher3SchemaToIndex(pParse->db, pTrigger->pSchema);
99456   assert( iDb>=0 && iDb<db->nDb );
99457   pTable = tableOfTrigger(pTrigger);
99458   assert( pTable );
99459   assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
99460 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
99461   {
99462     int code = SQLCIPHER_DROP_TRIGGER;
99463     const char *zDb = db->aDb[iDb].zName;
99464     const char *zTab = SCHEMA_TABLE(iDb);
99465     if( iDb==1 ) code = SQLCIPHER_DROP_TEMP_TRIGGER;
99466     if( sqlcipher3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
99467       sqlcipher3AuthCheck(pParse, SQLCIPHER_DELETE, zTab, 0, zDb) ){
99468       return;
99469     }
99470   }
99471 #endif
99472
99473   /* Generate code to destroy the database record of the trigger.
99474   */
99475   assert( pTable!=0 );
99476   if( (v = sqlcipher3GetVdbe(pParse))!=0 ){
99477     int base;
99478     static const VdbeOpList dropTrigger[] = {
99479       { OP_Rewind,     0, ADDR(9),  0},
99480       { OP_String8,    0, 1,        0}, /* 1 */
99481       { OP_Column,     0, 1,        2},
99482       { OP_Ne,         2, ADDR(8),  1},
99483       { OP_String8,    0, 1,        0}, /* 4: "trigger" */
99484       { OP_Column,     0, 0,        2},
99485       { OP_Ne,         2, ADDR(8),  1},
99486       { OP_Delete,     0, 0,        0},
99487       { OP_Next,       0, ADDR(1),  0}, /* 8 */
99488     };
99489
99490     sqlcipher3BeginWriteOperation(pParse, 0, iDb);
99491     sqlcipher3OpenMasterTable(pParse, iDb);
99492     base = sqlcipher3VdbeAddOpList(v,  ArraySize(dropTrigger), dropTrigger);
99493     sqlcipher3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT);
99494     sqlcipher3VdbeChangeP4(v, base+4, "trigger", P4_STATIC);
99495     sqlcipher3ChangeCookie(pParse, iDb);
99496     sqlcipher3VdbeAddOp2(v, OP_Close, 0, 0);
99497     sqlcipher3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
99498     if( pParse->nMem<3 ){
99499       pParse->nMem = 3;
99500     }
99501   }
99502 }
99503
99504 /*
99505 ** Remove a trigger from the hash tables of the sqlcipher* pointer.
99506 */
99507 SQLCIPHER_PRIVATE void sqlcipher3UnlinkAndDeleteTrigger(sqlcipher3 *db, int iDb, const char *zName){
99508   Trigger *pTrigger;
99509   Hash *pHash;
99510
99511   assert( sqlcipher3SchemaMutexHeld(db, iDb, 0) );
99512   pHash = &(db->aDb[iDb].pSchema->trigHash);
99513   pTrigger = sqlcipher3HashInsert(pHash, zName, sqlcipher3Strlen30(zName), 0);
99514   if( ALWAYS(pTrigger) ){
99515     if( pTrigger->pSchema==pTrigger->pTabSchema ){
99516       Table *pTab = tableOfTrigger(pTrigger);
99517       Trigger **pp;
99518       for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
99519       *pp = (*pp)->pNext;
99520     }
99521     sqlcipher3DeleteTrigger(db, pTrigger);
99522     db->flags |= SQLCIPHER_InternChanges;
99523   }
99524 }
99525
99526 /*
99527 ** pEList is the SET clause of an UPDATE statement.  Each entry
99528 ** in pEList is of the format <id>=<expr>.  If any of the entries
99529 ** in pEList have an <id> which matches an identifier in pIdList,
99530 ** then return TRUE.  If pIdList==NULL, then it is considered a
99531 ** wildcard that matches anything.  Likewise if pEList==NULL then
99532 ** it matches anything so always return true.  Return false only
99533 ** if there is no match.
99534 */
99535 static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){
99536   int e;
99537   if( pIdList==0 || NEVER(pEList==0) ) return 1;
99538   for(e=0; e<pEList->nExpr; e++){
99539     if( sqlcipher3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
99540   }
99541   return 0; 
99542 }
99543
99544 /*
99545 ** Return a list of all triggers on table pTab if there exists at least
99546 ** one trigger that must be fired when an operation of type 'op' is 
99547 ** performed on the table, and, if that operation is an UPDATE, if at
99548 ** least one of the columns in pChanges is being modified.
99549 */
99550 SQLCIPHER_PRIVATE Trigger *sqlcipher3TriggersExist(
99551   Parse *pParse,          /* Parse context */
99552   Table *pTab,            /* The table the contains the triggers */
99553   int op,                 /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
99554   ExprList *pChanges,     /* Columns that change in an UPDATE statement */
99555   int *pMask              /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
99556 ){
99557   int mask = 0;
99558   Trigger *pList = 0;
99559   Trigger *p;
99560
99561   if( (pParse->db->flags & SQLCIPHER_EnableTrigger)!=0 ){
99562     pList = sqlcipher3TriggerList(pParse, pTab);
99563   }
99564   assert( pList==0 || IsVirtual(pTab)==0 );
99565   for(p=pList; p; p=p->pNext){
99566     if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
99567       mask |= p->tr_tm;
99568     }
99569   }
99570   if( pMask ){
99571     *pMask = mask;
99572   }
99573   return (mask ? pList : 0);
99574 }
99575
99576 /*
99577 ** Convert the pStep->target token into a SrcList and return a pointer
99578 ** to that SrcList.
99579 **
99580 ** This routine adds a specific database name, if needed, to the target when
99581 ** forming the SrcList.  This prevents a trigger in one database from
99582 ** referring to a target in another database.  An exception is when the
99583 ** trigger is in TEMP in which case it can refer to any other database it
99584 ** wants.
99585 */
99586 static SrcList *targetSrcList(
99587   Parse *pParse,       /* The parsing context */
99588   TriggerStep *pStep   /* The trigger containing the target token */
99589 ){
99590   int iDb;             /* Index of the database to use */
99591   SrcList *pSrc;       /* SrcList to be returned */
99592
99593   pSrc = sqlcipher3SrcListAppend(pParse->db, 0, &pStep->target, 0);
99594   if( pSrc ){
99595     assert( pSrc->nSrc>0 );
99596     assert( pSrc->a!=0 );
99597     iDb = sqlcipher3SchemaToIndex(pParse->db, pStep->pTrig->pSchema);
99598     if( iDb==0 || iDb>=2 ){
99599       sqlcipher3 *db = pParse->db;
99600       assert( iDb<pParse->db->nDb );
99601       pSrc->a[pSrc->nSrc-1].zDatabase = sqlcipher3DbStrDup(db, db->aDb[iDb].zName);
99602     }
99603   }
99604   return pSrc;
99605 }
99606
99607 /*
99608 ** Generate VDBE code for the statements inside the body of a single 
99609 ** trigger.
99610 */
99611 static int codeTriggerProgram(
99612   Parse *pParse,            /* The parser context */
99613   TriggerStep *pStepList,   /* List of statements inside the trigger body */
99614   int orconf                /* Conflict algorithm. (OE_Abort, etc) */  
99615 ){
99616   TriggerStep *pStep;
99617   Vdbe *v = pParse->pVdbe;
99618   sqlcipher3 *db = pParse->db;
99619
99620   assert( pParse->pTriggerTab && pParse->pToplevel );
99621   assert( pStepList );
99622   assert( v!=0 );
99623   for(pStep=pStepList; pStep; pStep=pStep->pNext){
99624     /* Figure out the ON CONFLICT policy that will be used for this step
99625     ** of the trigger program. If the statement that caused this trigger
99626     ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
99627     ** the ON CONFLICT policy that was specified as part of the trigger
99628     ** step statement. Example:
99629     **
99630     **   CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
99631     **     INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
99632     **   END;
99633     **
99634     **   INSERT INTO t1 ... ;            -- insert into t2 uses REPLACE policy
99635     **   INSERT OR IGNORE INTO t1 ... ;  -- insert into t2 uses IGNORE policy
99636     */
99637     pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
99638
99639     switch( pStep->op ){
99640       case TK_UPDATE: {
99641         sqlcipher3Update(pParse, 
99642           targetSrcList(pParse, pStep),
99643           sqlcipher3ExprListDup(db, pStep->pExprList, 0), 
99644           sqlcipher3ExprDup(db, pStep->pWhere, 0), 
99645           pParse->eOrconf
99646         );
99647         break;
99648       }
99649       case TK_INSERT: {
99650         sqlcipher3Insert(pParse, 
99651           targetSrcList(pParse, pStep),
99652           sqlcipher3ExprListDup(db, pStep->pExprList, 0), 
99653           sqlcipher3SelectDup(db, pStep->pSelect, 0), 
99654           sqlcipher3IdListDup(db, pStep->pIdList), 
99655           pParse->eOrconf
99656         );
99657         break;
99658       }
99659       case TK_DELETE: {
99660         sqlcipher3DeleteFrom(pParse, 
99661           targetSrcList(pParse, pStep),
99662           sqlcipher3ExprDup(db, pStep->pWhere, 0)
99663         );
99664         break;
99665       }
99666       default: assert( pStep->op==TK_SELECT ); {
99667         SelectDest sDest;
99668         Select *pSelect = sqlcipher3SelectDup(db, pStep->pSelect, 0);
99669         sqlcipher3SelectDestInit(&sDest, SRT_Discard, 0);
99670         sqlcipher3Select(pParse, pSelect, &sDest);
99671         sqlcipher3SelectDelete(db, pSelect);
99672         break;
99673       }
99674     } 
99675     if( pStep->op!=TK_SELECT ){
99676       sqlcipher3VdbeAddOp0(v, OP_ResetCount);
99677     }
99678   }
99679
99680   return 0;
99681 }
99682
99683 #ifdef SQLCIPHER_DEBUG
99684 /*
99685 ** This function is used to add VdbeComment() annotations to a VDBE
99686 ** program. It is not used in production code, only for debugging.
99687 */
99688 static const char *onErrorText(int onError){
99689   switch( onError ){
99690     case OE_Abort:    return "abort";
99691     case OE_Rollback: return "rollback";
99692     case OE_Fail:     return "fail";
99693     case OE_Replace:  return "replace";
99694     case OE_Ignore:   return "ignore";
99695     case OE_Default:  return "default";
99696   }
99697   return "n/a";
99698 }
99699 #endif
99700
99701 /*
99702 ** Parse context structure pFrom has just been used to create a sub-vdbe
99703 ** (trigger program). If an error has occurred, transfer error information
99704 ** from pFrom to pTo.
99705 */
99706 static void transferParseError(Parse *pTo, Parse *pFrom){
99707   assert( pFrom->zErrMsg==0 || pFrom->nErr );
99708   assert( pTo->zErrMsg==0 || pTo->nErr );
99709   if( pTo->nErr==0 ){
99710     pTo->zErrMsg = pFrom->zErrMsg;
99711     pTo->nErr = pFrom->nErr;
99712   }else{
99713     sqlcipher3DbFree(pFrom->db, pFrom->zErrMsg);
99714   }
99715 }
99716
99717 /*
99718 ** Create and populate a new TriggerPrg object with a sub-program 
99719 ** implementing trigger pTrigger with ON CONFLICT policy orconf.
99720 */
99721 static TriggerPrg *codeRowTrigger(
99722   Parse *pParse,       /* Current parse context */
99723   Trigger *pTrigger,   /* Trigger to code */
99724   Table *pTab,         /* The table pTrigger is attached to */
99725   int orconf           /* ON CONFLICT policy to code trigger program with */
99726 ){
99727   Parse *pTop = sqlcipher3ParseToplevel(pParse);
99728   sqlcipher3 *db = pParse->db;   /* Database handle */
99729   TriggerPrg *pPrg;           /* Value to return */
99730   Expr *pWhen = 0;            /* Duplicate of trigger WHEN expression */
99731   Vdbe *v;                    /* Temporary VM */
99732   NameContext sNC;            /* Name context for sub-vdbe */
99733   SubProgram *pProgram = 0;   /* Sub-vdbe for trigger program */
99734   Parse *pSubParse;           /* Parse context for sub-vdbe */
99735   int iEndTrigger = 0;        /* Label to jump to if WHEN is false */
99736
99737   assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
99738   assert( pTop->pVdbe );
99739
99740   /* Allocate the TriggerPrg and SubProgram objects. To ensure that they
99741   ** are freed if an error occurs, link them into the Parse.pTriggerPrg 
99742   ** list of the top-level Parse object sooner rather than later.  */
99743   pPrg = sqlcipher3DbMallocZero(db, sizeof(TriggerPrg));
99744   if( !pPrg ) return 0;
99745   pPrg->pNext = pTop->pTriggerPrg;
99746   pTop->pTriggerPrg = pPrg;
99747   pPrg->pProgram = pProgram = sqlcipher3DbMallocZero(db, sizeof(SubProgram));
99748   if( !pProgram ) return 0;
99749   sqlcipher3VdbeLinkSubProgram(pTop->pVdbe, pProgram);
99750   pPrg->pTrigger = pTrigger;
99751   pPrg->orconf = orconf;
99752   pPrg->aColmask[0] = 0xffffffff;
99753   pPrg->aColmask[1] = 0xffffffff;
99754
99755   /* Allocate and populate a new Parse context to use for coding the 
99756   ** trigger sub-program.  */
99757   pSubParse = sqlcipher3StackAllocZero(db, sizeof(Parse));
99758   if( !pSubParse ) return 0;
99759   memset(&sNC, 0, sizeof(sNC));
99760   sNC.pParse = pSubParse;
99761   pSubParse->db = db;
99762   pSubParse->pTriggerTab = pTab;
99763   pSubParse->pToplevel = pTop;
99764   pSubParse->zAuthContext = pTrigger->zName;
99765   pSubParse->eTriggerOp = pTrigger->op;
99766   pSubParse->nQueryLoop = pParse->nQueryLoop;
99767
99768   v = sqlcipher3GetVdbe(pSubParse);
99769   if( v ){
99770     VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)", 
99771       pTrigger->zName, onErrorText(orconf),
99772       (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
99773         (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
99774         (pTrigger->op==TK_INSERT ? "INSERT" : ""),
99775         (pTrigger->op==TK_DELETE ? "DELETE" : ""),
99776       pTab->zName
99777     ));
99778 #ifndef SQLCIPHER_OMIT_TRACE
99779     sqlcipher3VdbeChangeP4(v, -1, 
99780       sqlcipher3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
99781     );
99782 #endif
99783
99784     /* If one was specified, code the WHEN clause. If it evaluates to false
99785     ** (or NULL) the sub-vdbe is immediately halted by jumping to the 
99786     ** OP_Halt inserted at the end of the program.  */
99787     if( pTrigger->pWhen ){
99788       pWhen = sqlcipher3ExprDup(db, pTrigger->pWhen, 0);
99789       if( SQLCIPHER_OK==sqlcipher3ResolveExprNames(&sNC, pWhen) 
99790        && db->mallocFailed==0 
99791       ){
99792         iEndTrigger = sqlcipher3VdbeMakeLabel(v);
99793         sqlcipher3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLCIPHER_JUMPIFNULL);
99794       }
99795       sqlcipher3ExprDelete(db, pWhen);
99796     }
99797
99798     /* Code the trigger program into the sub-vdbe. */
99799     codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);
99800
99801     /* Insert an OP_Halt at the end of the sub-program. */
99802     if( iEndTrigger ){
99803       sqlcipher3VdbeResolveLabel(v, iEndTrigger);
99804     }
99805     sqlcipher3VdbeAddOp0(v, OP_Halt);
99806     VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
99807
99808     transferParseError(pParse, pSubParse);
99809     if( db->mallocFailed==0 ){
99810       pProgram->aOp = sqlcipher3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
99811     }
99812     pProgram->nMem = pSubParse->nMem;
99813     pProgram->nCsr = pSubParse->nTab;
99814     pProgram->token = (void *)pTrigger;
99815     pPrg->aColmask[0] = pSubParse->oldmask;
99816     pPrg->aColmask[1] = pSubParse->newmask;
99817     sqlcipher3VdbeDelete(v);
99818   }
99819
99820   assert( !pSubParse->pAinc       && !pSubParse->pZombieTab );
99821   assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
99822   sqlcipher3StackFree(db, pSubParse);
99823
99824   return pPrg;
99825 }
99826     
99827 /*
99828 ** Return a pointer to a TriggerPrg object containing the sub-program for
99829 ** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such
99830 ** TriggerPrg object exists, a new object is allocated and populated before
99831 ** being returned.
99832 */
99833 static TriggerPrg *getRowTrigger(
99834   Parse *pParse,       /* Current parse context */
99835   Trigger *pTrigger,   /* Trigger to code */
99836   Table *pTab,         /* The table trigger pTrigger is attached to */
99837   int orconf           /* ON CONFLICT algorithm. */
99838 ){
99839   Parse *pRoot = sqlcipher3ParseToplevel(pParse);
99840   TriggerPrg *pPrg;
99841
99842   assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
99843
99844   /* It may be that this trigger has already been coded (or is in the
99845   ** process of being coded). If this is the case, then an entry with
99846   ** a matching TriggerPrg.pTrigger field will be present somewhere
99847   ** in the Parse.pTriggerPrg list. Search for such an entry.  */
99848   for(pPrg=pRoot->pTriggerPrg; 
99849       pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf); 
99850       pPrg=pPrg->pNext
99851   );
99852
99853   /* If an existing TriggerPrg could not be located, create a new one. */
99854   if( !pPrg ){
99855     pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
99856   }
99857
99858   return pPrg;
99859 }
99860
99861 /*
99862 ** Generate code for the trigger program associated with trigger p on 
99863 ** table pTab. The reg, orconf and ignoreJump parameters passed to this
99864 ** function are the same as those described in the header function for
99865 ** sqlcipher3CodeRowTrigger()
99866 */
99867 SQLCIPHER_PRIVATE void sqlcipher3CodeRowTriggerDirect(
99868   Parse *pParse,       /* Parse context */
99869   Trigger *p,          /* Trigger to code */
99870   Table *pTab,         /* The table to code triggers from */
99871   int reg,             /* Reg array containing OLD.* and NEW.* values */
99872   int orconf,          /* ON CONFLICT policy */
99873   int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */
99874 ){
99875   Vdbe *v = sqlcipher3GetVdbe(pParse); /* Main VM */
99876   TriggerPrg *pPrg;
99877   pPrg = getRowTrigger(pParse, p, pTab, orconf);
99878   assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
99879
99880   /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program 
99881   ** is a pointer to the sub-vdbe containing the trigger program.  */
99882   if( pPrg ){
99883     int bRecursive = (p->zName && 0==(pParse->db->flags&SQLCIPHER_RecTriggers));
99884
99885     sqlcipher3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem);
99886     sqlcipher3VdbeChangeP4(v, -1, (const char *)pPrg->pProgram, P4_SUBPROGRAM);
99887     VdbeComment(
99888         (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
99889
99890     /* Set the P5 operand of the OP_Program instruction to non-zero if
99891     ** recursive invocation of this trigger program is disallowed. Recursive
99892     ** invocation is disallowed if (a) the sub-program is really a trigger,
99893     ** not a foreign key action, and (b) the flag to enable recursive triggers
99894     ** is clear.  */
99895     sqlcipher3VdbeChangeP5(v, (u8)bRecursive);
99896   }
99897 }
99898
99899 /*
99900 ** This is called to code the required FOR EACH ROW triggers for an operation
99901 ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
99902 ** is given by the op paramater. The tr_tm parameter determines whether the
99903 ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
99904 ** parameter pChanges is passed the list of columns being modified.
99905 **
99906 ** If there are no triggers that fire at the specified time for the specified
99907 ** operation on pTab, this function is a no-op.
99908 **
99909 ** The reg argument is the address of the first in an array of registers 
99910 ** that contain the values substituted for the new.* and old.* references
99911 ** in the trigger program. If N is the number of columns in table pTab
99912 ** (a copy of pTab->nCol), then registers are populated as follows:
99913 **
99914 **   Register       Contains
99915 **   ------------------------------------------------------
99916 **   reg+0          OLD.rowid
99917 **   reg+1          OLD.* value of left-most column of pTab
99918 **   ...            ...
99919 **   reg+N          OLD.* value of right-most column of pTab
99920 **   reg+N+1        NEW.rowid
99921 **   reg+N+2        OLD.* value of left-most column of pTab
99922 **   ...            ...
99923 **   reg+N+N+1      NEW.* value of right-most column of pTab
99924 **
99925 ** For ON DELETE triggers, the registers containing the NEW.* values will
99926 ** never be accessed by the trigger program, so they are not allocated or 
99927 ** populated by the caller (there is no data to populate them with anyway). 
99928 ** Similarly, for ON INSERT triggers the values stored in the OLD.* registers
99929 ** are never accessed, and so are not allocated by the caller. So, for an
99930 ** ON INSERT trigger, the value passed to this function as parameter reg
99931 ** is not a readable register, although registers (reg+N) through 
99932 ** (reg+N+N+1) are.
99933 **
99934 ** Parameter orconf is the default conflict resolution algorithm for the
99935 ** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump
99936 ** is the instruction that control should jump to if a trigger program
99937 ** raises an IGNORE exception.
99938 */
99939 SQLCIPHER_PRIVATE void sqlcipher3CodeRowTrigger(
99940   Parse *pParse,       /* Parse context */
99941   Trigger *pTrigger,   /* List of triggers on table pTab */
99942   int op,              /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
99943   ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */
99944   int tr_tm,           /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
99945   Table *pTab,         /* The table to code triggers from */
99946   int reg,             /* The first in an array of registers (see above) */
99947   int orconf,          /* ON CONFLICT policy */
99948   int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */
99949 ){
99950   Trigger *p;          /* Used to iterate through pTrigger list */
99951
99952   assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
99953   assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
99954   assert( (op==TK_UPDATE)==(pChanges!=0) );
99955
99956   for(p=pTrigger; p; p=p->pNext){
99957
99958     /* Sanity checking:  The schema for the trigger and for the table are
99959     ** always defined.  The trigger must be in the same schema as the table
99960     ** or else it must be a TEMP trigger. */
99961     assert( p->pSchema!=0 );
99962     assert( p->pTabSchema!=0 );
99963     assert( p->pSchema==p->pTabSchema 
99964          || p->pSchema==pParse->db->aDb[1].pSchema );
99965
99966     /* Determine whether we should code this trigger */
99967     if( p->op==op 
99968      && p->tr_tm==tr_tm 
99969      && checkColumnOverlap(p->pColumns, pChanges)
99970     ){
99971       sqlcipher3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
99972     }
99973   }
99974 }
99975
99976 /*
99977 ** Triggers may access values stored in the old.* or new.* pseudo-table. 
99978 ** This function returns a 32-bit bitmask indicating which columns of the 
99979 ** old.* or new.* tables actually are used by triggers. This information 
99980 ** may be used by the caller, for example, to avoid having to load the entire
99981 ** old.* record into memory when executing an UPDATE or DELETE command.
99982 **
99983 ** Bit 0 of the returned mask is set if the left-most column of the
99984 ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
99985 ** the second leftmost column value is required, and so on. If there
99986 ** are more than 32 columns in the table, and at least one of the columns
99987 ** with an index greater than 32 may be accessed, 0xffffffff is returned.
99988 **
99989 ** It is not possible to determine if the old.rowid or new.rowid column is 
99990 ** accessed by triggers. The caller must always assume that it is.
99991 **
99992 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
99993 ** applies to the old.* table. If 1, the new.* table.
99994 **
99995 ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
99996 ** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only
99997 ** included in the returned mask if the TRIGGER_BEFORE bit is set in the
99998 ** tr_tm parameter. Similarly, values accessed by AFTER triggers are only
99999 ** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
100000 */
100001 SQLCIPHER_PRIVATE u32 sqlcipher3TriggerColmask(
100002   Parse *pParse,       /* Parse context */
100003   Trigger *pTrigger,   /* List of triggers on table pTab */
100004   ExprList *pChanges,  /* Changes list for any UPDATE OF triggers */
100005   int isNew,           /* 1 for new.* ref mask, 0 for old.* ref mask */
100006   int tr_tm,           /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
100007   Table *pTab,         /* The table to code triggers from */
100008   int orconf           /* Default ON CONFLICT policy for trigger steps */
100009 ){
100010   const int op = pChanges ? TK_UPDATE : TK_DELETE;
100011   u32 mask = 0;
100012   Trigger *p;
100013
100014   assert( isNew==1 || isNew==0 );
100015   for(p=pTrigger; p; p=p->pNext){
100016     if( p->op==op && (tr_tm&p->tr_tm)
100017      && checkColumnOverlap(p->pColumns,pChanges)
100018     ){
100019       TriggerPrg *pPrg;
100020       pPrg = getRowTrigger(pParse, p, pTab, orconf);
100021       if( pPrg ){
100022         mask |= pPrg->aColmask[isNew];
100023       }
100024     }
100025   }
100026
100027   return mask;
100028 }
100029
100030 #endif /* !defined(SQLCIPHER_OMIT_TRIGGER) */
100031
100032 /************** End of trigger.c *********************************************/
100033 /************** Begin file update.c ******************************************/
100034 /*
100035 ** 2001 September 15
100036 **
100037 ** The author disclaims copyright to this source code.  In place of
100038 ** a legal notice, here is a blessing:
100039 **
100040 **    May you do good and not evil.
100041 **    May you find forgiveness for yourself and forgive others.
100042 **    May you share freely, never taking more than you give.
100043 **
100044 *************************************************************************
100045 ** This file contains C code routines that are called by the parser
100046 ** to handle UPDATE statements.
100047 */
100048
100049 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
100050 /* Forward declaration */
100051 static void updateVirtualTable(
100052   Parse *pParse,       /* The parsing context */
100053   SrcList *pSrc,       /* The virtual table to be modified */
100054   Table *pTab,         /* The virtual table */
100055   ExprList *pChanges,  /* The columns to change in the UPDATE statement */
100056   Expr *pRowidExpr,    /* Expression used to recompute the rowid */
100057   int *aXRef,          /* Mapping from columns of pTab to entries in pChanges */
100058   Expr *pWhere,        /* WHERE clause of the UPDATE statement */
100059   int onError          /* ON CONFLICT strategy */
100060 );
100061 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
100062
100063 /*
100064 ** The most recently coded instruction was an OP_Column to retrieve the
100065 ** i-th column of table pTab. This routine sets the P4 parameter of the 
100066 ** OP_Column to the default value, if any.
100067 **
100068 ** The default value of a column is specified by a DEFAULT clause in the 
100069 ** column definition. This was either supplied by the user when the table
100070 ** was created, or added later to the table definition by an ALTER TABLE
100071 ** command. If the latter, then the row-records in the table btree on disk
100072 ** may not contain a value for the column and the default value, taken
100073 ** from the P4 parameter of the OP_Column instruction, is returned instead.
100074 ** If the former, then all row-records are guaranteed to include a value
100075 ** for the column and the P4 value is not required.
100076 **
100077 ** Column definitions created by an ALTER TABLE command may only have 
100078 ** literal default values specified: a number, null or a string. (If a more
100079 ** complicated default expression value was provided, it is evaluated 
100080 ** when the ALTER TABLE is executed and one of the literal values written
100081 ** into the sqlcipher_master table.)
100082 **
100083 ** Therefore, the P4 parameter is only required if the default value for
100084 ** the column is a literal number, string or null. The sqlcipher3ValueFromExpr()
100085 ** function is capable of transforming these types of expressions into
100086 ** sqlcipher3_value objects.
100087 **
100088 ** If parameter iReg is not negative, code an OP_RealAffinity instruction
100089 ** on register iReg. This is used when an equivalent integer value is 
100090 ** stored in place of an 8-byte floating point value in order to save 
100091 ** space.
100092 */
100093 SQLCIPHER_PRIVATE void sqlcipher3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
100094   assert( pTab!=0 );
100095   if( !pTab->pSelect ){
100096     sqlcipher3_value *pValue;
100097     u8 enc = ENC(sqlcipher3VdbeDb(v));
100098     Column *pCol = &pTab->aCol[i];
100099     VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
100100     assert( i<pTab->nCol );
100101     sqlcipher3ValueFromExpr(sqlcipher3VdbeDb(v), pCol->pDflt, enc, 
100102                          pCol->affinity, &pValue);
100103     if( pValue ){
100104       sqlcipher3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
100105     }
100106 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
100107     if( iReg>=0 && pTab->aCol[i].affinity==SQLCIPHER_AFF_REAL ){
100108       sqlcipher3VdbeAddOp1(v, OP_RealAffinity, iReg);
100109     }
100110 #endif
100111   }
100112 }
100113
100114 /*
100115 ** Process an UPDATE statement.
100116 **
100117 **   UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
100118 **          \_______/ \________/     \______/       \________________/
100119 *            onError   pTabList      pChanges             pWhere
100120 */
100121 SQLCIPHER_PRIVATE void sqlcipher3Update(
100122   Parse *pParse,         /* The parser context */
100123   SrcList *pTabList,     /* The table in which we should change things */
100124   ExprList *pChanges,    /* Things to be changed */
100125   Expr *pWhere,          /* The WHERE clause.  May be null */
100126   int onError            /* How to handle constraint errors */
100127 ){
100128   int i, j;              /* Loop counters */
100129   Table *pTab;           /* The table to be updated */
100130   int addr = 0;          /* VDBE instruction address of the start of the loop */
100131   WhereInfo *pWInfo;     /* Information about the WHERE clause */
100132   Vdbe *v;               /* The virtual database engine */
100133   Index *pIdx;           /* For looping over indices */
100134   int nIdx;              /* Number of indices that need updating */
100135   int iCur;              /* VDBE Cursor number of pTab */
100136   sqlcipher3 *db;           /* The database structure */
100137   int *aRegIdx = 0;      /* One register assigned to each index to be updated */
100138   int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
100139                          ** an expression for the i-th column of the table.
100140                          ** aXRef[i]==-1 if the i-th column is not changed. */
100141   int chngRowid;         /* True if the record number is being changed */
100142   Expr *pRowidExpr = 0;  /* Expression defining the new record number */
100143   int openAll = 0;       /* True if all indices need to be opened */
100144   AuthContext sContext;  /* The authorization context */
100145   NameContext sNC;       /* The name-context to resolve expressions in */
100146   int iDb;               /* Database containing the table being updated */
100147   int okOnePass;         /* True for one-pass algorithm without the FIFO */
100148   int hasFK;             /* True if foreign key processing is required */
100149
100150 #ifndef SQLCIPHER_OMIT_TRIGGER
100151   int isView;            /* True when updating a view (INSTEAD OF trigger) */
100152   Trigger *pTrigger;     /* List of triggers on pTab, if required */
100153   int tmask;             /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
100154 #endif
100155   int newmask;           /* Mask of NEW.* columns accessed by BEFORE triggers */
100156
100157   /* Register Allocations */
100158   int regRowCount = 0;   /* A count of rows changed */
100159   int regOldRowid;       /* The old rowid */
100160   int regNewRowid;       /* The new rowid */
100161   int regNew;
100162   int regOld = 0;
100163   int regRowSet = 0;     /* Rowset of rows to be updated */
100164
100165   memset(&sContext, 0, sizeof(sContext));
100166   db = pParse->db;
100167   if( pParse->nErr || db->mallocFailed ){
100168     goto update_cleanup;
100169   }
100170   assert( pTabList->nSrc==1 );
100171
100172   /* Locate the table which we want to update. 
100173   */
100174   pTab = sqlcipher3SrcListLookup(pParse, pTabList);
100175   if( pTab==0 ) goto update_cleanup;
100176   iDb = sqlcipher3SchemaToIndex(pParse->db, pTab->pSchema);
100177
100178   /* Figure out if we have any triggers and if the table being
100179   ** updated is a view.
100180   */
100181 #ifndef SQLCIPHER_OMIT_TRIGGER
100182   pTrigger = sqlcipher3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
100183   isView = pTab->pSelect!=0;
100184   assert( pTrigger || tmask==0 );
100185 #else
100186 # define pTrigger 0
100187 # define isView 0
100188 # define tmask 0
100189 #endif
100190 #ifdef SQLCIPHER_OMIT_VIEW
100191 # undef isView
100192 # define isView 0
100193 #endif
100194
100195   if( sqlcipher3ViewGetColumnNames(pParse, pTab) ){
100196     goto update_cleanup;
100197   }
100198   if( sqlcipher3IsReadOnly(pParse, pTab, tmask) ){
100199     goto update_cleanup;
100200   }
100201   aXRef = sqlcipher3DbMallocRaw(db, sizeof(int) * pTab->nCol );
100202   if( aXRef==0 ) goto update_cleanup;
100203   for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
100204
100205   /* Allocate a cursors for the main database table and for all indices.
100206   ** The index cursors might not be used, but if they are used they
100207   ** need to occur right after the database cursor.  So go ahead and
100208   ** allocate enough space, just in case.
100209   */
100210   pTabList->a[0].iCursor = iCur = pParse->nTab++;
100211   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100212     pParse->nTab++;
100213   }
100214
100215   /* Initialize the name-context */
100216   memset(&sNC, 0, sizeof(sNC));
100217   sNC.pParse = pParse;
100218   sNC.pSrcList = pTabList;
100219
100220   /* Resolve the column names in all the expressions of the
100221   ** of the UPDATE statement.  Also find the column index
100222   ** for each column to be updated in the pChanges array.  For each
100223   ** column to be updated, make sure we have authorization to change
100224   ** that column.
100225   */
100226   chngRowid = 0;
100227   for(i=0; i<pChanges->nExpr; i++){
100228     if( sqlcipher3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
100229       goto update_cleanup;
100230     }
100231     for(j=0; j<pTab->nCol; j++){
100232       if( sqlcipher3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
100233         if( j==pTab->iPKey ){
100234           chngRowid = 1;
100235           pRowidExpr = pChanges->a[i].pExpr;
100236         }
100237         aXRef[j] = i;
100238         break;
100239       }
100240     }
100241     if( j>=pTab->nCol ){
100242       if( sqlcipher3IsRowid(pChanges->a[i].zName) ){
100243         chngRowid = 1;
100244         pRowidExpr = pChanges->a[i].pExpr;
100245       }else{
100246         sqlcipher3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
100247         pParse->checkSchema = 1;
100248         goto update_cleanup;
100249       }
100250     }
100251 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
100252     {
100253       int rc;
100254       rc = sqlcipher3AuthCheck(pParse, SQLCIPHER_UPDATE, pTab->zName,
100255                            pTab->aCol[j].zName, db->aDb[iDb].zName);
100256       if( rc==SQLCIPHER_DENY ){
100257         goto update_cleanup;
100258       }else if( rc==SQLCIPHER_IGNORE ){
100259         aXRef[j] = -1;
100260       }
100261     }
100262 #endif
100263   }
100264
100265   hasFK = sqlcipher3FkRequired(pParse, pTab, aXRef, chngRowid);
100266
100267   /* Allocate memory for the array aRegIdx[].  There is one entry in the
100268   ** array for each index associated with table being updated.  Fill in
100269   ** the value with a register number for indices that are to be used
100270   ** and with zero for unused indices.
100271   */
100272   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
100273   if( nIdx>0 ){
100274     aRegIdx = sqlcipher3DbMallocRaw(db, sizeof(Index*) * nIdx );
100275     if( aRegIdx==0 ) goto update_cleanup;
100276   }
100277   for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100278     int reg;
100279     if( hasFK || chngRowid ){
100280       reg = ++pParse->nMem;
100281     }else{
100282       reg = 0;
100283       for(i=0; i<pIdx->nColumn; i++){
100284         if( aXRef[pIdx->aiColumn[i]]>=0 ){
100285           reg = ++pParse->nMem;
100286           break;
100287         }
100288       }
100289     }
100290     aRegIdx[j] = reg;
100291   }
100292
100293   /* Begin generating code. */
100294   v = sqlcipher3GetVdbe(pParse);
100295   if( v==0 ) goto update_cleanup;
100296   if( pParse->nested==0 ) sqlcipher3VdbeCountChanges(v);
100297   sqlcipher3BeginWriteOperation(pParse, 1, iDb);
100298
100299 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
100300   /* Virtual tables must be handled separately */
100301   if( IsVirtual(pTab) ){
100302     updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
100303                        pWhere, onError);
100304     pWhere = 0;
100305     pTabList = 0;
100306     goto update_cleanup;
100307   }
100308 #endif
100309
100310   /* Allocate required registers. */
100311   regOldRowid = regNewRowid = ++pParse->nMem;
100312   if( pTrigger || hasFK ){
100313     regOld = pParse->nMem + 1;
100314     pParse->nMem += pTab->nCol;
100315   }
100316   if( chngRowid || pTrigger || hasFK ){
100317     regNewRowid = ++pParse->nMem;
100318   }
100319   regNew = pParse->nMem + 1;
100320   pParse->nMem += pTab->nCol;
100321
100322   /* Start the view context. */
100323   if( isView ){
100324     sqlcipher3AuthContextPush(pParse, &sContext, pTab->zName);
100325   }
100326
100327   /* If we are trying to update a view, realize that view into
100328   ** a ephemeral table.
100329   */
100330 #if !defined(SQLCIPHER_OMIT_VIEW) && !defined(SQLCIPHER_OMIT_TRIGGER)
100331   if( isView ){
100332     sqlcipher3MaterializeView(pParse, pTab, pWhere, iCur);
100333   }
100334 #endif
100335
100336   /* Resolve the column names in all the expressions in the
100337   ** WHERE clause.
100338   */
100339   if( sqlcipher3ResolveExprNames(&sNC, pWhere) ){
100340     goto update_cleanup;
100341   }
100342
100343   /* Begin the database scan
100344   */
100345   sqlcipher3VdbeAddOp2(v, OP_Null, 0, regOldRowid);
100346   pWInfo = sqlcipher3WhereBegin(
100347       pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED
100348   );
100349   if( pWInfo==0 ) goto update_cleanup;
100350   okOnePass = pWInfo->okOnePass;
100351
100352   /* Remember the rowid of every item to be updated.
100353   */
100354   sqlcipher3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid);
100355   if( !okOnePass ){
100356     regRowSet = ++pParse->nMem;
100357     sqlcipher3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
100358   }
100359
100360   /* End the database scan loop.
100361   */
100362   sqlcipher3WhereEnd(pWInfo);
100363
100364   /* Initialize the count of updated rows
100365   */
100366   if( (db->flags & SQLCIPHER_CountRows) && !pParse->pTriggerTab ){
100367     regRowCount = ++pParse->nMem;
100368     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
100369   }
100370
100371   if( !isView ){
100372     /* 
100373     ** Open every index that needs updating.  Note that if any
100374     ** index could potentially invoke a REPLACE conflict resolution 
100375     ** action, then we need to open all indices because we might need
100376     ** to be deleting some records.
100377     */
100378     if( !okOnePass ) sqlcipher3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite); 
100379     if( onError==OE_Replace ){
100380       openAll = 1;
100381     }else{
100382       openAll = 0;
100383       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100384         if( pIdx->onError==OE_Replace ){
100385           openAll = 1;
100386           break;
100387         }
100388       }
100389     }
100390     for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
100391       assert( aRegIdx );
100392       if( openAll || aRegIdx[i]>0 ){
100393         KeyInfo *pKey = sqlcipher3IndexKeyinfo(pParse, pIdx);
100394         sqlcipher3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
100395                        (char*)pKey, P4_KEYINFO_HANDOFF);
100396         assert( pParse->nTab>iCur+i+1 );
100397       }
100398     }
100399   }
100400
100401   /* Top of the update loop */
100402   if( okOnePass ){
100403     int a1 = sqlcipher3VdbeAddOp1(v, OP_NotNull, regOldRowid);
100404     addr = sqlcipher3VdbeAddOp0(v, OP_Goto);
100405     sqlcipher3VdbeJumpHere(v, a1);
100406   }else{
100407     addr = sqlcipher3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);
100408   }
100409
100410   /* Make cursor iCur point to the record that is being updated. If
100411   ** this record does not exist for some reason (deleted by a trigger,
100412   ** for example, then jump to the next iteration of the RowSet loop.  */
100413   sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
100414
100415   /* If the record number will change, set register regNewRowid to
100416   ** contain the new value. If the record number is not being modified,
100417   ** then regNewRowid is the same register as regOldRowid, which is
100418   ** already populated.  */
100419   assert( chngRowid || pTrigger || hasFK || regOldRowid==regNewRowid );
100420   if( chngRowid ){
100421     sqlcipher3ExprCode(pParse, pRowidExpr, regNewRowid);
100422     sqlcipher3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
100423   }
100424
100425   /* If there are triggers on this table, populate an array of registers 
100426   ** with the required old.* column data.  */
100427   if( hasFK || pTrigger ){
100428     u32 oldmask = (hasFK ? sqlcipher3FkOldmask(pParse, pTab) : 0);
100429     oldmask |= sqlcipher3TriggerColmask(pParse, 
100430         pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
100431     );
100432     for(i=0; i<pTab->nCol; i++){
100433       if( aXRef[i]<0 || oldmask==0xffffffff || (i<32 && (oldmask & (1<<i))) ){
100434         sqlcipher3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOld+i);
100435       }else{
100436         sqlcipher3VdbeAddOp2(v, OP_Null, 0, regOld+i);
100437       }
100438     }
100439     if( chngRowid==0 ){
100440       sqlcipher3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
100441     }
100442   }
100443
100444   /* Populate the array of registers beginning at regNew with the new
100445   ** row data. This array is used to check constaints, create the new
100446   ** table and index records, and as the values for any new.* references
100447   ** made by triggers.
100448   **
100449   ** If there are one or more BEFORE triggers, then do not populate the
100450   ** registers associated with columns that are (a) not modified by
100451   ** this UPDATE statement and (b) not accessed by new.* references. The
100452   ** values for registers not modified by the UPDATE must be reloaded from 
100453   ** the database after the BEFORE triggers are fired anyway (as the trigger 
100454   ** may have modified them). So not loading those that are not going to
100455   ** be used eliminates some redundant opcodes.
100456   */
100457   newmask = sqlcipher3TriggerColmask(
100458       pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
100459   );
100460   for(i=0; i<pTab->nCol; i++){
100461     if( i==pTab->iPKey ){
100462       sqlcipher3VdbeAddOp2(v, OP_Null, 0, regNew+i);
100463     }else{
100464       j = aXRef[i];
100465       if( j>=0 ){
100466         sqlcipher3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
100467       }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask&(1<<i)) ){
100468         /* This branch loads the value of a column that will not be changed 
100469         ** into a register. This is done if there are no BEFORE triggers, or
100470         ** if there are one or more BEFORE triggers that use this value via
100471         ** a new.* reference in a trigger program.
100472         */
100473         testcase( i==31 );
100474         testcase( i==32 );
100475         sqlcipher3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
100476         sqlcipher3ColumnDefault(v, pTab, i, regNew+i);
100477       }
100478     }
100479   }
100480
100481   /* Fire any BEFORE UPDATE triggers. This happens before constraints are
100482   ** verified. One could argue that this is wrong.
100483   */
100484   if( tmask&TRIGGER_BEFORE ){
100485     sqlcipher3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
100486     sqlcipher3TableAffinityStr(v, pTab);
100487     sqlcipher3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, 
100488         TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
100489
100490     /* The row-trigger may have deleted the row being updated. In this
100491     ** case, jump to the next row. No updates or AFTER triggers are 
100492     ** required. This behaviour - what happens when the row being updated
100493     ** is deleted or renamed by a BEFORE trigger - is left undefined in the
100494     ** documentation.
100495     */
100496     sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
100497
100498     /* If it did not delete it, the row-trigger may still have modified 
100499     ** some of the columns of the row being updated. Load the values for 
100500     ** all columns not modified by the update statement into their 
100501     ** registers in case this has happened.
100502     */
100503     for(i=0; i<pTab->nCol; i++){
100504       if( aXRef[i]<0 && i!=pTab->iPKey ){
100505         sqlcipher3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
100506         sqlcipher3ColumnDefault(v, pTab, i, regNew+i);
100507       }
100508     }
100509   }
100510
100511   if( !isView ){
100512     int j1;                       /* Address of jump instruction */
100513
100514     /* Do constraint checks. */
100515     sqlcipher3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
100516         aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);
100517
100518     /* Do FK constraint checks. */
100519     if( hasFK ){
100520       sqlcipher3FkCheck(pParse, pTab, regOldRowid, 0);
100521     }
100522
100523     /* Delete the index entries associated with the current record.  */
100524     j1 = sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
100525     sqlcipher3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
100526   
100527     /* If changing the record number, delete the old record.  */
100528     if( hasFK || chngRowid ){
100529       sqlcipher3VdbeAddOp2(v, OP_Delete, iCur, 0);
100530     }
100531     sqlcipher3VdbeJumpHere(v, j1);
100532
100533     if( hasFK ){
100534       sqlcipher3FkCheck(pParse, pTab, 0, regNewRowid);
100535     }
100536   
100537     /* Insert the new index entries and the new record. */
100538     sqlcipher3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
100539
100540     /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
100541     ** handle rows (possibly in other tables) that refer via a foreign key
100542     ** to the row just updated. */ 
100543     if( hasFK ){
100544       sqlcipher3FkActions(pParse, pTab, pChanges, regOldRowid);
100545     }
100546   }
100547
100548   /* Increment the row counter 
100549   */
100550   if( (db->flags & SQLCIPHER_CountRows) && !pParse->pTriggerTab){
100551     sqlcipher3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
100552   }
100553
100554   sqlcipher3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, 
100555       TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
100556
100557   /* Repeat the above with the next record to be updated, until
100558   ** all record selected by the WHERE clause have been updated.
100559   */
100560   sqlcipher3VdbeAddOp2(v, OP_Goto, 0, addr);
100561   sqlcipher3VdbeJumpHere(v, addr);
100562
100563   /* Close all tables */
100564   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
100565     assert( aRegIdx );
100566     if( openAll || aRegIdx[i]>0 ){
100567       sqlcipher3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);
100568     }
100569   }
100570   sqlcipher3VdbeAddOp2(v, OP_Close, iCur, 0);
100571
100572   /* Update the sqlcipher_sequence table by storing the content of the
100573   ** maximum rowid counter values recorded while inserting into
100574   ** autoincrement tables.
100575   */
100576   if( pParse->nested==0 && pParse->pTriggerTab==0 ){
100577     sqlcipher3AutoincrementEnd(pParse);
100578   }
100579
100580   /*
100581   ** Return the number of rows that were changed. If this routine is 
100582   ** generating code because of a call to sqlcipher3NestedParse(), do not
100583   ** invoke the callback function.
100584   */
100585   if( (db->flags&SQLCIPHER_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
100586     sqlcipher3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
100587     sqlcipher3VdbeSetNumCols(v, 1);
100588     sqlcipher3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLCIPHER_STATIC);
100589   }
100590
100591 update_cleanup:
100592   sqlcipher3AuthContextPop(&sContext);
100593   sqlcipher3DbFree(db, aRegIdx);
100594   sqlcipher3DbFree(db, aXRef);
100595   sqlcipher3SrcListDelete(db, pTabList);
100596   sqlcipher3ExprListDelete(db, pChanges);
100597   sqlcipher3ExprDelete(db, pWhere);
100598   return;
100599 }
100600 /* Make sure "isView" and other macros defined above are undefined. Otherwise
100601 ** thely may interfere with compilation of other functions in this file
100602 ** (or in another file, if this file becomes part of the amalgamation).  */
100603 #ifdef isView
100604  #undef isView
100605 #endif
100606 #ifdef pTrigger
100607  #undef pTrigger
100608 #endif
100609
100610 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
100611 /*
100612 ** Generate code for an UPDATE of a virtual table.
100613 **
100614 ** The strategy is that we create an ephemerial table that contains
100615 ** for each row to be changed:
100616 **
100617 **   (A)  The original rowid of that row.
100618 **   (B)  The revised rowid for the row. (note1)
100619 **   (C)  The content of every column in the row.
100620 **
100621 ** Then we loop over this ephemeral table and for each row in
100622 ** the ephermeral table call VUpdate.
100623 **
100624 ** When finished, drop the ephemeral table.
100625 **
100626 ** (note1) Actually, if we know in advance that (A) is always the same
100627 ** as (B) we only store (A), then duplicate (A) when pulling
100628 ** it out of the ephemeral table before calling VUpdate.
100629 */
100630 static void updateVirtualTable(
100631   Parse *pParse,       /* The parsing context */
100632   SrcList *pSrc,       /* The virtual table to be modified */
100633   Table *pTab,         /* The virtual table */
100634   ExprList *pChanges,  /* The columns to change in the UPDATE statement */
100635   Expr *pRowid,        /* Expression used to recompute the rowid */
100636   int *aXRef,          /* Mapping from columns of pTab to entries in pChanges */
100637   Expr *pWhere,        /* WHERE clause of the UPDATE statement */
100638   int onError          /* ON CONFLICT strategy */
100639 ){
100640   Vdbe *v = pParse->pVdbe;  /* Virtual machine under construction */
100641   ExprList *pEList = 0;     /* The result set of the SELECT statement */
100642   Select *pSelect = 0;      /* The SELECT statement */
100643   Expr *pExpr;              /* Temporary expression */
100644   int ephemTab;             /* Table holding the result of the SELECT */
100645   int i;                    /* Loop counter */
100646   int addr;                 /* Address of top of loop */
100647   int iReg;                 /* First register in set passed to OP_VUpdate */
100648   sqlcipher3 *db = pParse->db; /* Database connection */
100649   const char *pVTab = (const char*)sqlcipher3GetVTable(db, pTab);
100650   SelectDest dest;
100651
100652   /* Construct the SELECT statement that will find the new values for
100653   ** all updated rows. 
100654   */
100655   pEList = sqlcipher3ExprListAppend(pParse, 0, sqlcipher3Expr(db, TK_ID, "_rowid_"));
100656   if( pRowid ){
100657     pEList = sqlcipher3ExprListAppend(pParse, pEList,
100658                                    sqlcipher3ExprDup(db, pRowid, 0));
100659   }
100660   assert( pTab->iPKey<0 );
100661   for(i=0; i<pTab->nCol; i++){
100662     if( aXRef[i]>=0 ){
100663       pExpr = sqlcipher3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
100664     }else{
100665       pExpr = sqlcipher3Expr(db, TK_ID, pTab->aCol[i].zName);
100666     }
100667     pEList = sqlcipher3ExprListAppend(pParse, pEList, pExpr);
100668   }
100669   pSelect = sqlcipher3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
100670   
100671   /* Create the ephemeral table into which the update results will
100672   ** be stored.
100673   */
100674   assert( v );
100675   ephemTab = pParse->nTab++;
100676   sqlcipher3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
100677   sqlcipher3VdbeChangeP5(v, BTREE_UNORDERED);
100678
100679   /* fill the ephemeral table 
100680   */
100681   sqlcipher3SelectDestInit(&dest, SRT_Table, ephemTab);
100682   sqlcipher3Select(pParse, pSelect, &dest);
100683
100684   /* Generate code to scan the ephemeral table and call VUpdate. */
100685   iReg = ++pParse->nMem;
100686   pParse->nMem += pTab->nCol+1;
100687   addr = sqlcipher3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
100688   sqlcipher3VdbeAddOp3(v, OP_Column,  ephemTab, 0, iReg);
100689   sqlcipher3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1);
100690   for(i=0; i<pTab->nCol; i++){
100691     sqlcipher3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i);
100692   }
100693   sqlcipher3VtabMakeWritable(pParse, pTab);
100694   sqlcipher3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
100695   sqlcipher3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
100696   sqlcipher3MayAbort(pParse);
100697   sqlcipher3VdbeAddOp2(v, OP_Next, ephemTab, addr+1);
100698   sqlcipher3VdbeJumpHere(v, addr);
100699   sqlcipher3VdbeAddOp2(v, OP_Close, ephemTab, 0);
100700
100701   /* Cleanup */
100702   sqlcipher3SelectDelete(db, pSelect);  
100703 }
100704 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
100705
100706 /************** End of update.c **********************************************/
100707 /************** Begin file vacuum.c ******************************************/
100708 /*
100709 ** 2003 April 6
100710 **
100711 ** The author disclaims copyright to this source code.  In place of
100712 ** a legal notice, here is a blessing:
100713 **
100714 **    May you do good and not evil.
100715 **    May you find forgiveness for yourself and forgive others.
100716 **    May you share freely, never taking more than you give.
100717 **
100718 *************************************************************************
100719 ** This file contains code used to implement the VACUUM command.
100720 **
100721 ** Most of the code in this file may be omitted by defining the
100722 ** SQLCIPHER_OMIT_VACUUM macro.
100723 */
100724
100725 #if !defined(SQLCIPHER_OMIT_VACUUM) && !defined(SQLCIPHER_OMIT_ATTACH)
100726 /*
100727 ** Finalize a prepared statement.  If there was an error, store the
100728 ** text of the error message in *pzErrMsg.  Return the result code.
100729 */
100730 static int vacuumFinalize(sqlcipher3 *db, sqlcipher3_stmt *pStmt, char **pzErrMsg){
100731   int rc;
100732   rc = sqlcipher3VdbeFinalize((Vdbe*)pStmt);
100733   if( rc ){
100734     sqlcipher3SetString(pzErrMsg, db, sqlcipher3_errmsg(db));
100735   }
100736   return rc;
100737 }
100738
100739 /*
100740 ** Execute zSql on database db. Return an error code.
100741 */
100742 static int execSql(sqlcipher3 *db, char **pzErrMsg, const char *zSql){
100743   sqlcipher3_stmt *pStmt;
100744   VVA_ONLY( int rc; )
100745   if( !zSql ){
100746     return SQLCIPHER_NOMEM;
100747   }
100748   if( SQLCIPHER_OK!=sqlcipher3_prepare(db, zSql, -1, &pStmt, 0) ){
100749     sqlcipher3SetString(pzErrMsg, db, sqlcipher3_errmsg(db));
100750     return sqlcipher3_errcode(db);
100751   }
100752   VVA_ONLY( rc = ) sqlcipher3_step(pStmt);
100753   assert( rc!=SQLCIPHER_ROW || (db->flags&SQLCIPHER_CountRows) );
100754   return vacuumFinalize(db, pStmt, pzErrMsg);
100755 }
100756
100757 /*
100758 ** Execute zSql on database db. The statement returns exactly
100759 ** one column. Execute this as SQL on the same database.
100760 */
100761 static int execExecSql(sqlcipher3 *db, char **pzErrMsg, const char *zSql){
100762   sqlcipher3_stmt *pStmt;
100763   int rc;
100764
100765   rc = sqlcipher3_prepare(db, zSql, -1, &pStmt, 0);
100766   if( rc!=SQLCIPHER_OK ) return rc;
100767
100768   while( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
100769     rc = execSql(db, pzErrMsg, (char*)sqlcipher3_column_text(pStmt, 0));
100770     if( rc!=SQLCIPHER_OK ){
100771       vacuumFinalize(db, pStmt, pzErrMsg);
100772       return rc;
100773     }
100774   }
100775
100776   return vacuumFinalize(db, pStmt, pzErrMsg);
100777 }
100778
100779 /*
100780 ** The non-standard VACUUM command is used to clean up the database,
100781 ** collapse free space, etc.  It is modelled after the VACUUM command
100782 ** in PostgreSQL.
100783 **
100784 ** In version 1.0.x of SQLite, the VACUUM command would call
100785 ** gdbm_reorganize() on all the database tables.  But beginning
100786 ** with 2.0.0, SQLite no longer uses GDBM so this command has
100787 ** become a no-op.
100788 */
100789 SQLCIPHER_PRIVATE void sqlcipher3Vacuum(Parse *pParse){
100790   Vdbe *v = sqlcipher3GetVdbe(pParse);
100791   if( v ){
100792     sqlcipher3VdbeAddOp2(v, OP_Vacuum, 0, 0);
100793   }
100794   return;
100795 }
100796
100797 /*
100798 ** This routine implements the OP_Vacuum opcode of the VDBE.
100799 */
100800 SQLCIPHER_PRIVATE int sqlcipher3RunVacuum(char **pzErrMsg, sqlcipher3 *db){
100801   int rc = SQLCIPHER_OK;     /* Return code from service routines */
100802   Btree *pMain;           /* The database being vacuumed */
100803   Btree *pTemp;           /* The temporary database we vacuum into */
100804   char *zSql = 0;         /* SQL statements */
100805   int saved_flags;        /* Saved value of the db->flags */
100806   int saved_nChange;      /* Saved value of db->nChange */
100807   int saved_nTotalChange; /* Saved value of db->nTotalChange */
100808   void (*saved_xTrace)(void*,const char*);  /* Saved db->xTrace */
100809   Db *pDb = 0;            /* Database to detach at end of vacuum */
100810   int isMemDb;            /* True if vacuuming a :memory: database */
100811   int nRes;               /* Bytes of reserved space at the end of each page */
100812   int nDb;                /* Number of attached databases */
100813
100814   if( !db->autoCommit ){
100815     sqlcipher3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
100816     return SQLCIPHER_ERROR;
100817   }
100818   if( db->activeVdbeCnt>1 ){
100819     sqlcipher3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
100820     return SQLCIPHER_ERROR;
100821   }
100822
100823   /* Save the current value of the database flags so that it can be 
100824   ** restored before returning. Then set the writable-schema flag, and
100825   ** disable CHECK and foreign key constraints.  */
100826   saved_flags = db->flags;
100827   saved_nChange = db->nChange;
100828   saved_nTotalChange = db->nTotalChange;
100829   saved_xTrace = db->xTrace;
100830   db->flags |= SQLCIPHER_WriteSchema | SQLCIPHER_IgnoreChecks | SQLCIPHER_PreferBuiltin;
100831   db->flags &= ~(SQLCIPHER_ForeignKeys | SQLCIPHER_ReverseOrder);
100832   db->xTrace = 0;
100833
100834   pMain = db->aDb[0].pBt;
100835   isMemDb = sqlcipher3PagerIsMemdb(sqlcipher3BtreePager(pMain));
100836
100837   /* Attach the temporary database as 'vacuum_db'. The synchronous pragma
100838   ** can be set to 'off' for this file, as it is not recovered if a crash
100839   ** occurs anyway. The integrity of the database is maintained by a
100840   ** (possibly synchronous) transaction opened on the main database before
100841   ** sqlcipher3BtreeCopyFile() is called.
100842   **
100843   ** An optimisation would be to use a non-journaled pager.
100844   ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but
100845   ** that actually made the VACUUM run slower.  Very little journalling
100846   ** actually occurs when doing a vacuum since the vacuum_db is initially
100847   ** empty.  Only the journal header is written.  Apparently it takes more
100848   ** time to parse and run the PRAGMA to turn journalling off than it does
100849   ** to write the journal header file.
100850   */
100851   nDb = db->nDb;
100852   if( sqlcipher3TempInMemory(db) ){
100853     zSql = "ATTACH ':memory:' AS vacuum_db;";
100854   }else{
100855     zSql = "ATTACH '' AS vacuum_db;";
100856   }
100857   rc = execSql(db, pzErrMsg, zSql);
100858   if( db->nDb>nDb ){
100859     pDb = &db->aDb[db->nDb-1];
100860     assert( strcmp(pDb->zName,"vacuum_db")==0 );
100861   }
100862   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100863   pTemp = db->aDb[db->nDb-1].pBt;
100864
100865   /* The call to execSql() to attach the temp database has left the file
100866   ** locked (as there was more than one active statement when the transaction
100867   ** to read the schema was concluded. Unlock it here so that this doesn't
100868   ** cause problems for the call to BtreeSetPageSize() below.  */
100869   sqlcipher3BtreeCommit(pTemp);
100870
100871   nRes = sqlcipher3BtreeGetReserve(pMain);
100872
100873   /* A VACUUM cannot change the pagesize of an encrypted database. */
100874 #ifdef SQLCIPHER_HAS_CODEC
100875   if( db->nextPagesize ){
100876     extern void sqlcipher3CodecGetKey(sqlcipher3*, int, void**, int*);
100877     int nKey;
100878     char *zKey;
100879     sqlcipher3CodecGetKey(db, 0, (void**)&zKey, &nKey);
100880     if( nKey ) db->nextPagesize = 0;
100881   }
100882 #endif
100883
100884   /* Do not attempt to change the page size for a WAL database */
100885   if( sqlcipher3PagerGetJournalMode(sqlcipher3BtreePager(pMain))
100886                                                ==PAGER_JOURNALMODE_WAL ){
100887     db->nextPagesize = 0;
100888   }
100889
100890   if( sqlcipher3BtreeSetPageSize(pTemp, sqlcipher3BtreeGetPageSize(pMain), nRes, 0)
100891    || (!isMemDb && sqlcipher3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0))
100892    || NEVER(db->mallocFailed)
100893   ){
100894     rc = SQLCIPHER_NOMEM;
100895     goto end_of_vacuum;
100896   }
100897   rc = execSql(db, pzErrMsg, "PRAGMA vacuum_db.synchronous=OFF");
100898   if( rc!=SQLCIPHER_OK ){
100899     goto end_of_vacuum;
100900   }
100901
100902 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
100903   sqlcipher3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
100904                                            sqlcipher3BtreeGetAutoVacuum(pMain));
100905 #endif
100906
100907   /* Begin a transaction */
100908   rc = execSql(db, pzErrMsg, "BEGIN EXCLUSIVE;");
100909   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100910
100911   /* Query the schema of the main database. Create a mirror schema
100912   ** in the temporary database.
100913   */
100914   rc = execExecSql(db, pzErrMsg,
100915       "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) "
100916       "  FROM sqlcipher_master WHERE type='table' AND name!='sqlcipher_sequence'"
100917       "   AND rootpage>0"
100918   );
100919   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100920   rc = execExecSql(db, pzErrMsg,
100921       "SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14)"
100922       "  FROM sqlcipher_master WHERE sql LIKE 'CREATE INDEX %' ");
100923   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100924   rc = execExecSql(db, pzErrMsg,
100925       "SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21) "
100926       "  FROM sqlcipher_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'");
100927   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100928
100929   /* Loop through the tables in the main database. For each, do
100930   ** an "INSERT INTO vacuum_db.xxx SELECT * FROM main.xxx;" to copy
100931   ** the contents to the temporary database.
100932   */
100933   rc = execExecSql(db, pzErrMsg,
100934       "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
100935       "|| ' SELECT * FROM main.' || quote(name) || ';'"
100936       "FROM main.sqlcipher_master "
100937       "WHERE type = 'table' AND name!='sqlcipher_sequence' "
100938       "  AND rootpage>0"
100939   );
100940   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100941
100942   /* Copy over the sequence table
100943   */
100944   rc = execExecSql(db, pzErrMsg,
100945       "SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' "
100946       "FROM vacuum_db.sqlcipher_master WHERE name='sqlcipher_sequence' "
100947   );
100948   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100949   rc = execExecSql(db, pzErrMsg,
100950       "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
100951       "|| ' SELECT * FROM main.' || quote(name) || ';' "
100952       "FROM vacuum_db.sqlcipher_master WHERE name=='sqlcipher_sequence';"
100953   );
100954   if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
100955
100956
100957   /* Copy the triggers, views, and virtual tables from the main database
100958   ** over to the temporary database.  None of these objects has any
100959   ** associated storage, so all we have to do is copy their entries
100960   ** from the SQLCIPHER_MASTER table.
100961   */
100962   rc = execSql(db, pzErrMsg,
100963       "INSERT INTO vacuum_db.sqlcipher_master "
100964       "  SELECT type, name, tbl_name, rootpage, sql"
100965       "    FROM main.sqlcipher_master"
100966       "   WHERE type='view' OR type='trigger'"
100967       "      OR (type='table' AND rootpage=0)"
100968   );
100969   if( rc ) goto end_of_vacuum;
100970
100971   /* At this point, there is a write transaction open on both the 
100972   ** vacuum database and the main database. Assuming no error occurs,
100973   ** both transactions are closed by this block - the main database
100974   ** transaction by sqlcipher3BtreeCopyFile() and the other by an explicit
100975   ** call to sqlcipher3BtreeCommit().
100976   */
100977   {
100978     u32 meta;
100979     int i;
100980
100981     /* This array determines which meta meta values are preserved in the
100982     ** vacuum.  Even entries are the meta value number and odd entries
100983     ** are an increment to apply to the meta value after the vacuum.
100984     ** The increment is used to increase the schema cookie so that other
100985     ** connections to the same database will know to reread the schema.
100986     */
100987     static const unsigned char aCopy[] = {
100988        BTREE_SCHEMA_VERSION,     1,  /* Add one to the old schema cookie */
100989        BTREE_DEFAULT_CACHE_SIZE, 0,  /* Preserve the default page cache size */
100990        BTREE_TEXT_ENCODING,      0,  /* Preserve the text encoding */
100991        BTREE_USER_VERSION,       0,  /* Preserve the user version */
100992     };
100993
100994     assert( 1==sqlcipher3BtreeIsInTrans(pTemp) );
100995     assert( 1==sqlcipher3BtreeIsInTrans(pMain) );
100996
100997     /* Copy Btree meta values */
100998     for(i=0; i<ArraySize(aCopy); i+=2){
100999       /* GetMeta() and UpdateMeta() cannot fail in this context because
101000       ** we already have page 1 loaded into cache and marked dirty. */
101001       sqlcipher3BtreeGetMeta(pMain, aCopy[i], &meta);
101002       rc = sqlcipher3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
101003       if( NEVER(rc!=SQLCIPHER_OK) ) goto end_of_vacuum;
101004     }
101005
101006     rc = sqlcipher3BtreeCopyFile(pMain, pTemp);
101007     if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
101008     rc = sqlcipher3BtreeCommit(pTemp);
101009     if( rc!=SQLCIPHER_OK ) goto end_of_vacuum;
101010 #ifndef SQLCIPHER_OMIT_AUTOVACUUM
101011     sqlcipher3BtreeSetAutoVacuum(pMain, sqlcipher3BtreeGetAutoVacuum(pTemp));
101012 #endif
101013   }
101014
101015   assert( rc==SQLCIPHER_OK );
101016   rc = sqlcipher3BtreeSetPageSize(pMain, sqlcipher3BtreeGetPageSize(pTemp), nRes,1);
101017
101018 end_of_vacuum:
101019   /* Restore the original value of db->flags */
101020   db->flags = saved_flags;
101021   db->nChange = saved_nChange;
101022   db->nTotalChange = saved_nTotalChange;
101023   db->xTrace = saved_xTrace;
101024   sqlcipher3BtreeSetPageSize(pMain, -1, -1, 1);
101025
101026   /* Currently there is an SQL level transaction open on the vacuum
101027   ** database. No locks are held on any other files (since the main file
101028   ** was committed at the btree level). So it safe to end the transaction
101029   ** by manually setting the autoCommit flag to true and detaching the
101030   ** vacuum database. The vacuum_db journal file is deleted when the pager
101031   ** is closed by the DETACH.
101032   */
101033   db->autoCommit = 1;
101034
101035   if( pDb ){
101036     sqlcipher3BtreeClose(pDb->pBt);
101037     pDb->pBt = 0;
101038     pDb->pSchema = 0;
101039   }
101040
101041   /* This both clears the schemas and reduces the size of the db->aDb[]
101042   ** array. */ 
101043   sqlcipher3ResetInternalSchema(db, -1);
101044
101045   return rc;
101046 }
101047
101048 #endif  /* SQLCIPHER_OMIT_VACUUM && SQLCIPHER_OMIT_ATTACH */
101049
101050 /************** End of vacuum.c **********************************************/
101051 /************** Begin file vtab.c ********************************************/
101052 /*
101053 ** 2006 June 10
101054 **
101055 ** The author disclaims copyright to this source code.  In place of
101056 ** a legal notice, here is a blessing:
101057 **
101058 **    May you do good and not evil.
101059 **    May you find forgiveness for yourself and forgive others.
101060 **    May you share freely, never taking more than you give.
101061 **
101062 *************************************************************************
101063 ** This file contains code used to help implement virtual tables.
101064 */
101065 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
101066
101067 /*
101068 ** Before a virtual table xCreate() or xConnect() method is invoked, the
101069 ** sqlcipher3.pVtabCtx member variable is set to point to an instance of
101070 ** this struct allocated on the stack. It is used by the implementation of 
101071 ** the sqlcipher3_declare_vtab() and sqlcipher3_vtab_config() APIs, both of which
101072 ** are invoked only from within xCreate and xConnect methods.
101073 */
101074 struct VtabCtx {
101075   Table *pTab;
101076   VTable *pVTable;
101077 };
101078
101079 /*
101080 ** The actual function that does the work of creating a new module.
101081 ** This function implements the sqlcipher3_create_module() and
101082 ** sqlcipher3_create_module_v2() interfaces.
101083 */
101084 static int createModule(
101085   sqlcipher3 *db,                    /* Database in which module is registered */
101086   const char *zName,              /* Name assigned to this module */
101087   const sqlcipher3_module *pModule,  /* The definition of the module */
101088   void *pAux,                     /* Context pointer for xCreate/xConnect */
101089   void (*xDestroy)(void *)        /* Module destructor function */
101090 ){
101091   int rc, nName;
101092   Module *pMod;
101093
101094   sqlcipher3_mutex_enter(db->mutex);
101095   nName = sqlcipher3Strlen30(zName);
101096   pMod = (Module *)sqlcipher3DbMallocRaw(db, sizeof(Module) + nName + 1);
101097   if( pMod ){
101098     Module *pDel;
101099     char *zCopy = (char *)(&pMod[1]);
101100     memcpy(zCopy, zName, nName+1);
101101     pMod->zName = zCopy;
101102     pMod->pModule = pModule;
101103     pMod->pAux = pAux;
101104     pMod->xDestroy = xDestroy;
101105     pDel = (Module *)sqlcipher3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);
101106     if( pDel && pDel->xDestroy ){
101107       sqlcipher3ResetInternalSchema(db, -1);
101108       pDel->xDestroy(pDel->pAux);
101109     }
101110     sqlcipher3DbFree(db, pDel);
101111     if( pDel==pMod ){
101112       db->mallocFailed = 1;
101113     }
101114   }else if( xDestroy ){
101115     xDestroy(pAux);
101116   }
101117   rc = sqlcipher3ApiExit(db, SQLCIPHER_OK);
101118   sqlcipher3_mutex_leave(db->mutex);
101119   return rc;
101120 }
101121
101122
101123 /*
101124 ** External API function used to create a new virtual-table module.
101125 */
101126 SQLCIPHER_API int sqlcipher3_create_module(
101127   sqlcipher3 *db,                    /* Database in which module is registered */
101128   const char *zName,              /* Name assigned to this module */
101129   const sqlcipher3_module *pModule,  /* The definition of the module */
101130   void *pAux                      /* Context pointer for xCreate/xConnect */
101131 ){
101132   return createModule(db, zName, pModule, pAux, 0);
101133 }
101134
101135 /*
101136 ** External API function used to create a new virtual-table module.
101137 */
101138 SQLCIPHER_API int sqlcipher3_create_module_v2(
101139   sqlcipher3 *db,                    /* Database in which module is registered */
101140   const char *zName,              /* Name assigned to this module */
101141   const sqlcipher3_module *pModule,  /* The definition of the module */
101142   void *pAux,                     /* Context pointer for xCreate/xConnect */
101143   void (*xDestroy)(void *)        /* Module destructor function */
101144 ){
101145   return createModule(db, zName, pModule, pAux, xDestroy);
101146 }
101147
101148 /*
101149 ** Lock the virtual table so that it cannot be disconnected.
101150 ** Locks nest.  Every lock should have a corresponding unlock.
101151 ** If an unlock is omitted, resources leaks will occur.  
101152 **
101153 ** If a disconnect is attempted while a virtual table is locked,
101154 ** the disconnect is deferred until all locks have been removed.
101155 */
101156 SQLCIPHER_PRIVATE void sqlcipher3VtabLock(VTable *pVTab){
101157   pVTab->nRef++;
101158 }
101159
101160
101161 /*
101162 ** pTab is a pointer to a Table structure representing a virtual-table.
101163 ** Return a pointer to the VTable object used by connection db to access 
101164 ** this virtual-table, if one has been created, or NULL otherwise.
101165 */
101166 SQLCIPHER_PRIVATE VTable *sqlcipher3GetVTable(sqlcipher3 *db, Table *pTab){
101167   VTable *pVtab;
101168   assert( IsVirtual(pTab) );
101169   for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
101170   return pVtab;
101171 }
101172
101173 /*
101174 ** Decrement the ref-count on a virtual table object. When the ref-count
101175 ** reaches zero, call the xDisconnect() method to delete the object.
101176 */
101177 SQLCIPHER_PRIVATE void sqlcipher3VtabUnlock(VTable *pVTab){
101178   sqlcipher3 *db = pVTab->db;
101179
101180   assert( db );
101181   assert( pVTab->nRef>0 );
101182   assert( sqlcipher3SafetyCheckOk(db) );
101183
101184   pVTab->nRef--;
101185   if( pVTab->nRef==0 ){
101186     sqlcipher3_vtab *p = pVTab->pVtab;
101187     if( p ){
101188       p->pModule->xDisconnect(p);
101189     }
101190     sqlcipher3DbFree(db, pVTab);
101191   }
101192 }
101193
101194 /*
101195 ** Table p is a virtual table. This function moves all elements in the
101196 ** p->pVTable list to the sqlcipher3.pDisconnect lists of their associated
101197 ** database connections to be disconnected at the next opportunity. 
101198 ** Except, if argument db is not NULL, then the entry associated with
101199 ** connection db is left in the p->pVTable list.
101200 */
101201 static VTable *vtabDisconnectAll(sqlcipher3 *db, Table *p){
101202   VTable *pRet = 0;
101203   VTable *pVTable = p->pVTable;
101204   p->pVTable = 0;
101205
101206   /* Assert that the mutex (if any) associated with the BtShared database 
101207   ** that contains table p is held by the caller. See header comments 
101208   ** above function sqlcipher3VtabUnlockList() for an explanation of why
101209   ** this makes it safe to access the sqlcipher3.pDisconnect list of any
101210   ** database connection that may have an entry in the p->pVTable list.
101211   */
101212   assert( db==0 || sqlcipher3SchemaMutexHeld(db, 0, p->pSchema) );
101213
101214   while( pVTable ){
101215     sqlcipher3 *db2 = pVTable->db;
101216     VTable *pNext = pVTable->pNext;
101217     assert( db2 );
101218     if( db2==db ){
101219       pRet = pVTable;
101220       p->pVTable = pRet;
101221       pRet->pNext = 0;
101222     }else{
101223       pVTable->pNext = db2->pDisconnect;
101224       db2->pDisconnect = pVTable;
101225     }
101226     pVTable = pNext;
101227   }
101228
101229   assert( !db || pRet );
101230   return pRet;
101231 }
101232
101233
101234 /*
101235 ** Disconnect all the virtual table objects in the sqlcipher3.pDisconnect list.
101236 **
101237 ** This function may only be called when the mutexes associated with all
101238 ** shared b-tree databases opened using connection db are held by the 
101239 ** caller. This is done to protect the sqlcipher3.pDisconnect list. The
101240 ** sqlcipher3.pDisconnect list is accessed only as follows:
101241 **
101242 **   1) By this function. In this case, all BtShared mutexes and the mutex
101243 **      associated with the database handle itself must be held.
101244 **
101245 **   2) By function vtabDisconnectAll(), when it adds a VTable entry to
101246 **      the sqlcipher3.pDisconnect list. In this case either the BtShared mutex
101247 **      associated with the database the virtual table is stored in is held
101248 **      or, if the virtual table is stored in a non-sharable database, then
101249 **      the database handle mutex is held.
101250 **
101251 ** As a result, a sqlcipher3.pDisconnect cannot be accessed simultaneously 
101252 ** by multiple threads. It is thread-safe.
101253 */
101254 SQLCIPHER_PRIVATE void sqlcipher3VtabUnlockList(sqlcipher3 *db){
101255   VTable *p = db->pDisconnect;
101256   db->pDisconnect = 0;
101257
101258   assert( sqlcipher3BtreeHoldsAllMutexes(db) );
101259   assert( sqlcipher3_mutex_held(db->mutex) );
101260
101261   if( p ){
101262     sqlcipher3ExpirePreparedStatements(db);
101263     do {
101264       VTable *pNext = p->pNext;
101265       sqlcipher3VtabUnlock(p);
101266       p = pNext;
101267     }while( p );
101268   }
101269 }
101270
101271 /*
101272 ** Clear any and all virtual-table information from the Table record.
101273 ** This routine is called, for example, just before deleting the Table
101274 ** record.
101275 **
101276 ** Since it is a virtual-table, the Table structure contains a pointer
101277 ** to the head of a linked list of VTable structures. Each VTable 
101278 ** structure is associated with a single sqlcipher3* user of the schema.
101279 ** The reference count of the VTable structure associated with database 
101280 ** connection db is decremented immediately (which may lead to the 
101281 ** structure being xDisconnected and free). Any other VTable structures
101282 ** in the list are moved to the sqlcipher3.pDisconnect list of the associated 
101283 ** database connection.
101284 */
101285 SQLCIPHER_PRIVATE void sqlcipher3VtabClear(sqlcipher3 *db, Table *p){
101286   if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
101287   if( p->azModuleArg ){
101288     int i;
101289     for(i=0; i<p->nModuleArg; i++){
101290       sqlcipher3DbFree(db, p->azModuleArg[i]);
101291     }
101292     sqlcipher3DbFree(db, p->azModuleArg);
101293   }
101294 }
101295
101296 /*
101297 ** Add a new module argument to pTable->azModuleArg[].
101298 ** The string is not copied - the pointer is stored.  The
101299 ** string will be freed automatically when the table is
101300 ** deleted.
101301 */
101302 static void addModuleArgument(sqlcipher3 *db, Table *pTable, char *zArg){
101303   int i = pTable->nModuleArg++;
101304   int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
101305   char **azModuleArg;
101306   azModuleArg = sqlcipher3DbRealloc(db, pTable->azModuleArg, nBytes);
101307   if( azModuleArg==0 ){
101308     int j;
101309     for(j=0; j<i; j++){
101310       sqlcipher3DbFree(db, pTable->azModuleArg[j]);
101311     }
101312     sqlcipher3DbFree(db, zArg);
101313     sqlcipher3DbFree(db, pTable->azModuleArg);
101314     pTable->nModuleArg = 0;
101315   }else{
101316     azModuleArg[i] = zArg;
101317     azModuleArg[i+1] = 0;
101318   }
101319   pTable->azModuleArg = azModuleArg;
101320 }
101321
101322 /*
101323 ** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
101324 ** statement.  The module name has been parsed, but the optional list
101325 ** of parameters that follow the module name are still pending.
101326 */
101327 SQLCIPHER_PRIVATE void sqlcipher3VtabBeginParse(
101328   Parse *pParse,        /* Parsing context */
101329   Token *pName1,        /* Name of new table, or database name */
101330   Token *pName2,        /* Name of new table or NULL */
101331   Token *pModuleName    /* Name of the module for the virtual table */
101332 ){
101333   int iDb;              /* The database the table is being created in */
101334   Table *pTable;        /* The new virtual table */
101335   sqlcipher3 *db;          /* Database connection */
101336
101337   sqlcipher3StartTable(pParse, pName1, pName2, 0, 0, 1, 0);
101338   pTable = pParse->pNewTable;
101339   if( pTable==0 ) return;
101340   assert( 0==pTable->pIndex );
101341
101342   db = pParse->db;
101343   iDb = sqlcipher3SchemaToIndex(db, pTable->pSchema);
101344   assert( iDb>=0 );
101345
101346   pTable->tabFlags |= TF_Virtual;
101347   pTable->nModuleArg = 0;
101348   addModuleArgument(db, pTable, sqlcipher3NameFromToken(db, pModuleName));
101349   addModuleArgument(db, pTable, sqlcipher3DbStrDup(db, db->aDb[iDb].zName));
101350   addModuleArgument(db, pTable, sqlcipher3DbStrDup(db, pTable->zName));
101351   pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z);
101352
101353 #ifndef SQLCIPHER_OMIT_AUTHORIZATION
101354   /* Creating a virtual table invokes the authorization callback twice.
101355   ** The first invocation, to obtain permission to INSERT a row into the
101356   ** sqlcipher_master table, has already been made by sqlcipher3StartTable().
101357   ** The second call, to obtain permission to create the table, is made now.
101358   */
101359   if( pTable->azModuleArg ){
101360     sqlcipher3AuthCheck(pParse, SQLCIPHER_CREATE_VTABLE, pTable->zName, 
101361             pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
101362   }
101363 #endif
101364 }
101365
101366 /*
101367 ** This routine takes the module argument that has been accumulating
101368 ** in pParse->zArg[] and appends it to the list of arguments on the
101369 ** virtual table currently under construction in pParse->pTable.
101370 */
101371 static void addArgumentToVtab(Parse *pParse){
101372   if( pParse->sArg.z && ALWAYS(pParse->pNewTable) ){
101373     const char *z = (const char*)pParse->sArg.z;
101374     int n = pParse->sArg.n;
101375     sqlcipher3 *db = pParse->db;
101376     addModuleArgument(db, pParse->pNewTable, sqlcipher3DbStrNDup(db, z, n));
101377   }
101378 }
101379
101380 /*
101381 ** The parser calls this routine after the CREATE VIRTUAL TABLE statement
101382 ** has been completely parsed.
101383 */
101384 SQLCIPHER_PRIVATE void sqlcipher3VtabFinishParse(Parse *pParse, Token *pEnd){
101385   Table *pTab = pParse->pNewTable;  /* The table being constructed */
101386   sqlcipher3 *db = pParse->db;         /* The database connection */
101387
101388   if( pTab==0 ) return;
101389   addArgumentToVtab(pParse);
101390   pParse->sArg.z = 0;
101391   if( pTab->nModuleArg<1 ) return;
101392   
101393   /* If the CREATE VIRTUAL TABLE statement is being entered for the
101394   ** first time (in other words if the virtual table is actually being
101395   ** created now instead of just being read out of sqlcipher_master) then
101396   ** do additional initialization work and store the statement text
101397   ** in the sqlcipher_master table.
101398   */
101399   if( !db->init.busy ){
101400     char *zStmt;
101401     char *zWhere;
101402     int iDb;
101403     Vdbe *v;
101404
101405     /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
101406     if( pEnd ){
101407       pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
101408     }
101409     zStmt = sqlcipher3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
101410
101411     /* A slot for the record has already been allocated in the 
101412     ** SQLCIPHER_MASTER table.  We just need to update that slot with all
101413     ** the information we've collected.  
101414     **
101415     ** The VM register number pParse->regRowid holds the rowid of an
101416     ** entry in the sqlcipher_master table tht was created for this vtab
101417     ** by sqlcipher3StartTable().
101418     */
101419     iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
101420     sqlcipher3NestedParse(pParse,
101421       "UPDATE %Q.%s "
101422          "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
101423        "WHERE rowid=#%d",
101424       db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
101425       pTab->zName,
101426       pTab->zName,
101427       zStmt,
101428       pParse->regRowid
101429     );
101430     sqlcipher3DbFree(db, zStmt);
101431     v = sqlcipher3GetVdbe(pParse);
101432     sqlcipher3ChangeCookie(pParse, iDb);
101433
101434     sqlcipher3VdbeAddOp2(v, OP_Expire, 0, 0);
101435     zWhere = sqlcipher3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
101436     sqlcipher3VdbeAddParseSchemaOp(v, iDb, zWhere);
101437     sqlcipher3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0, 
101438                          pTab->zName, sqlcipher3Strlen30(pTab->zName) + 1);
101439   }
101440
101441   /* If we are rereading the sqlcipher_master table create the in-memory
101442   ** record of the table. The xConnect() method is not called until
101443   ** the first time the virtual table is used in an SQL statement. This
101444   ** allows a schema that contains virtual tables to be loaded before
101445   ** the required virtual table implementations are registered.  */
101446   else {
101447     Table *pOld;
101448     Schema *pSchema = pTab->pSchema;
101449     const char *zName = pTab->zName;
101450     int nName = sqlcipher3Strlen30(zName);
101451     assert( sqlcipher3SchemaMutexHeld(db, 0, pSchema) );
101452     pOld = sqlcipher3HashInsert(&pSchema->tblHash, zName, nName, pTab);
101453     if( pOld ){
101454       db->mallocFailed = 1;
101455       assert( pTab==pOld );  /* Malloc must have failed inside HashInsert() */
101456       return;
101457     }
101458     pParse->pNewTable = 0;
101459   }
101460 }
101461
101462 /*
101463 ** The parser calls this routine when it sees the first token
101464 ** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
101465 */
101466 SQLCIPHER_PRIVATE void sqlcipher3VtabArgInit(Parse *pParse){
101467   addArgumentToVtab(pParse);
101468   pParse->sArg.z = 0;
101469   pParse->sArg.n = 0;
101470 }
101471
101472 /*
101473 ** The parser calls this routine for each token after the first token
101474 ** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
101475 */
101476 SQLCIPHER_PRIVATE void sqlcipher3VtabArgExtend(Parse *pParse, Token *p){
101477   Token *pArg = &pParse->sArg;
101478   if( pArg->z==0 ){
101479     pArg->z = p->z;
101480     pArg->n = p->n;
101481   }else{
101482     assert(pArg->z < p->z);
101483     pArg->n = (int)(&p->z[p->n] - pArg->z);
101484   }
101485 }
101486
101487 /*
101488 ** Invoke a virtual table constructor (either xCreate or xConnect). The
101489 ** pointer to the function to invoke is passed as the fourth parameter
101490 ** to this procedure.
101491 */
101492 static int vtabCallConstructor(
101493   sqlcipher3 *db, 
101494   Table *pTab,
101495   Module *pMod,
101496   int (*xConstruct)(sqlcipher3*,void*,int,const char*const*,sqlcipher3_vtab**,char**),
101497   char **pzErr
101498 ){
101499   VtabCtx sCtx;
101500   VTable *pVTable;
101501   int rc;
101502   const char *const*azArg = (const char *const*)pTab->azModuleArg;
101503   int nArg = pTab->nModuleArg;
101504   char *zErr = 0;
101505   char *zModuleName = sqlcipher3MPrintf(db, "%s", pTab->zName);
101506
101507   if( !zModuleName ){
101508     return SQLCIPHER_NOMEM;
101509   }
101510
101511   pVTable = sqlcipher3DbMallocZero(db, sizeof(VTable));
101512   if( !pVTable ){
101513     sqlcipher3DbFree(db, zModuleName);
101514     return SQLCIPHER_NOMEM;
101515   }
101516   pVTable->db = db;
101517   pVTable->pMod = pMod;
101518
101519   /* Invoke the virtual table constructor */
101520   assert( &db->pVtabCtx );
101521   assert( xConstruct );
101522   sCtx.pTab = pTab;
101523   sCtx.pVTable = pVTable;
101524   db->pVtabCtx = &sCtx;
101525   rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
101526   db->pVtabCtx = 0;
101527   if( rc==SQLCIPHER_NOMEM ) db->mallocFailed = 1;
101528
101529   if( SQLCIPHER_OK!=rc ){
101530     if( zErr==0 ){
101531       *pzErr = sqlcipher3MPrintf(db, "vtable constructor failed: %s", zModuleName);
101532     }else {
101533       *pzErr = sqlcipher3MPrintf(db, "%s", zErr);
101534       sqlcipher3_free(zErr);
101535     }
101536     sqlcipher3DbFree(db, pVTable);
101537   }else if( ALWAYS(pVTable->pVtab) ){
101538     /* Justification of ALWAYS():  A correct vtab constructor must allocate
101539     ** the sqlcipher3_vtab object if successful.  */
101540     pVTable->pVtab->pModule = pMod->pModule;
101541     pVTable->nRef = 1;
101542     if( sCtx.pTab ){
101543       const char *zFormat = "vtable constructor did not declare schema: %s";
101544       *pzErr = sqlcipher3MPrintf(db, zFormat, pTab->zName);
101545       sqlcipher3VtabUnlock(pVTable);
101546       rc = SQLCIPHER_ERROR;
101547     }else{
101548       int iCol;
101549       /* If everything went according to plan, link the new VTable structure
101550       ** into the linked list headed by pTab->pVTable. Then loop through the 
101551       ** columns of the table to see if any of them contain the token "hidden".
101552       ** If so, set the Column.isHidden flag and remove the token from
101553       ** the type string.  */
101554       pVTable->pNext = pTab->pVTable;
101555       pTab->pVTable = pVTable;
101556
101557       for(iCol=0; iCol<pTab->nCol; iCol++){
101558         char *zType = pTab->aCol[iCol].zType;
101559         int nType;
101560         int i = 0;
101561         if( !zType ) continue;
101562         nType = sqlcipher3Strlen30(zType);
101563         if( sqlcipher3StrNICmp("hidden", zType, 6)||(zType[6] && zType[6]!=' ') ){
101564           for(i=0; i<nType; i++){
101565             if( (0==sqlcipher3StrNICmp(" hidden", &zType[i], 7))
101566              && (zType[i+7]=='\0' || zType[i+7]==' ')
101567             ){
101568               i++;
101569               break;
101570             }
101571           }
101572         }
101573         if( i<nType ){
101574           int j;
101575           int nDel = 6 + (zType[i+6] ? 1 : 0);
101576           for(j=i; (j+nDel)<=nType; j++){
101577             zType[j] = zType[j+nDel];
101578           }
101579           if( zType[i]=='\0' && i>0 ){
101580             assert(zType[i-1]==' ');
101581             zType[i-1] = '\0';
101582           }
101583           pTab->aCol[iCol].isHidden = 1;
101584         }
101585       }
101586     }
101587   }
101588
101589   sqlcipher3DbFree(db, zModuleName);
101590   return rc;
101591 }
101592
101593 /*
101594 ** This function is invoked by the parser to call the xConnect() method
101595 ** of the virtual table pTab. If an error occurs, an error code is returned 
101596 ** and an error left in pParse.
101597 **
101598 ** This call is a no-op if table pTab is not a virtual table.
101599 */
101600 SQLCIPHER_PRIVATE int sqlcipher3VtabCallConnect(Parse *pParse, Table *pTab){
101601   sqlcipher3 *db = pParse->db;
101602   const char *zMod;
101603   Module *pMod;
101604   int rc;
101605
101606   assert( pTab );
101607   if( (pTab->tabFlags & TF_Virtual)==0 || sqlcipher3GetVTable(db, pTab) ){
101608     return SQLCIPHER_OK;
101609   }
101610
101611   /* Locate the required virtual table module */
101612   zMod = pTab->azModuleArg[0];
101613   pMod = (Module*)sqlcipher3HashFind(&db->aModule, zMod, sqlcipher3Strlen30(zMod));
101614
101615   if( !pMod ){
101616     const char *zModule = pTab->azModuleArg[0];
101617     sqlcipher3ErrorMsg(pParse, "no such module: %s", zModule);
101618     rc = SQLCIPHER_ERROR;
101619   }else{
101620     char *zErr = 0;
101621     rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
101622     if( rc!=SQLCIPHER_OK ){
101623       sqlcipher3ErrorMsg(pParse, "%s", zErr);
101624     }
101625     sqlcipher3DbFree(db, zErr);
101626   }
101627
101628   return rc;
101629 }
101630 /*
101631 ** Grow the db->aVTrans[] array so that there is room for at least one
101632 ** more v-table. Return SQLCIPHER_NOMEM if a malloc fails, or SQLCIPHER_OK otherwise.
101633 */
101634 static int growVTrans(sqlcipher3 *db){
101635   const int ARRAY_INCR = 5;
101636
101637   /* Grow the sqlcipher3.aVTrans array if required */
101638   if( (db->nVTrans%ARRAY_INCR)==0 ){
101639     VTable **aVTrans;
101640     int nBytes = sizeof(sqlcipher3_vtab *) * (db->nVTrans + ARRAY_INCR);
101641     aVTrans = sqlcipher3DbRealloc(db, (void *)db->aVTrans, nBytes);
101642     if( !aVTrans ){
101643       return SQLCIPHER_NOMEM;
101644     }
101645     memset(&aVTrans[db->nVTrans], 0, sizeof(sqlcipher3_vtab *)*ARRAY_INCR);
101646     db->aVTrans = aVTrans;
101647   }
101648
101649   return SQLCIPHER_OK;
101650 }
101651
101652 /*
101653 ** Add the virtual table pVTab to the array sqlcipher3.aVTrans[]. Space should
101654 ** have already been reserved using growVTrans().
101655 */
101656 static void addToVTrans(sqlcipher3 *db, VTable *pVTab){
101657   /* Add pVtab to the end of sqlcipher3.aVTrans */
101658   db->aVTrans[db->nVTrans++] = pVTab;
101659   sqlcipher3VtabLock(pVTab);
101660 }
101661
101662 /*
101663 ** This function is invoked by the vdbe to call the xCreate method
101664 ** of the virtual table named zTab in database iDb. 
101665 **
101666 ** If an error occurs, *pzErr is set to point an an English language
101667 ** description of the error and an SQLCIPHER_XXX error code is returned.
101668 ** In this case the caller must call sqlcipher3DbFree(db, ) on *pzErr.
101669 */
101670 SQLCIPHER_PRIVATE int sqlcipher3VtabCallCreate(sqlcipher3 *db, int iDb, const char *zTab, char **pzErr){
101671   int rc = SQLCIPHER_OK;
101672   Table *pTab;
101673   Module *pMod;
101674   const char *zMod;
101675
101676   pTab = sqlcipher3FindTable(db, zTab, db->aDb[iDb].zName);
101677   assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
101678
101679   /* Locate the required virtual table module */
101680   zMod = pTab->azModuleArg[0];
101681   pMod = (Module*)sqlcipher3HashFind(&db->aModule, zMod, sqlcipher3Strlen30(zMod));
101682
101683   /* If the module has been registered and includes a Create method, 
101684   ** invoke it now. If the module has not been registered, return an 
101685   ** error. Otherwise, do nothing.
101686   */
101687   if( !pMod ){
101688     *pzErr = sqlcipher3MPrintf(db, "no such module: %s", zMod);
101689     rc = SQLCIPHER_ERROR;
101690   }else{
101691     rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
101692   }
101693
101694   /* Justification of ALWAYS():  The xConstructor method is required to
101695   ** create a valid sqlcipher3_vtab if it returns SQLCIPHER_OK. */
101696   if( rc==SQLCIPHER_OK && ALWAYS(sqlcipher3GetVTable(db, pTab)) ){
101697     rc = growVTrans(db);
101698     if( rc==SQLCIPHER_OK ){
101699       addToVTrans(db, sqlcipher3GetVTable(db, pTab));
101700     }
101701   }
101702
101703   return rc;
101704 }
101705
101706 /*
101707 ** This function is used to set the schema of a virtual table.  It is only
101708 ** valid to call this function from within the xCreate() or xConnect() of a
101709 ** virtual table module.
101710 */
101711 SQLCIPHER_API int sqlcipher3_declare_vtab(sqlcipher3 *db, const char *zCreateTable){
101712   Parse *pParse;
101713
101714   int rc = SQLCIPHER_OK;
101715   Table *pTab;
101716   char *zErr = 0;
101717
101718   sqlcipher3_mutex_enter(db->mutex);
101719   if( !db->pVtabCtx || !(pTab = db->pVtabCtx->pTab) ){
101720     sqlcipher3Error(db, SQLCIPHER_MISUSE, 0);
101721     sqlcipher3_mutex_leave(db->mutex);
101722     return SQLCIPHER_MISUSE_BKPT;
101723   }
101724   assert( (pTab->tabFlags & TF_Virtual)!=0 );
101725
101726   pParse = sqlcipher3StackAllocZero(db, sizeof(*pParse));
101727   if( pParse==0 ){
101728     rc = SQLCIPHER_NOMEM;
101729   }else{
101730     pParse->declareVtab = 1;
101731     pParse->db = db;
101732     pParse->nQueryLoop = 1;
101733   
101734     if( SQLCIPHER_OK==sqlcipher3RunParser(pParse, zCreateTable, &zErr) 
101735      && pParse->pNewTable
101736      && !db->mallocFailed
101737      && !pParse->pNewTable->pSelect
101738      && (pParse->pNewTable->tabFlags & TF_Virtual)==0
101739     ){
101740       if( !pTab->aCol ){
101741         pTab->aCol = pParse->pNewTable->aCol;
101742         pTab->nCol = pParse->pNewTable->nCol;
101743         pParse->pNewTable->nCol = 0;
101744         pParse->pNewTable->aCol = 0;
101745       }
101746       db->pVtabCtx->pTab = 0;
101747     }else{
101748       sqlcipher3Error(db, SQLCIPHER_ERROR, (zErr ? "%s" : 0), zErr);
101749       sqlcipher3DbFree(db, zErr);
101750       rc = SQLCIPHER_ERROR;
101751     }
101752     pParse->declareVtab = 0;
101753   
101754     if( pParse->pVdbe ){
101755       sqlcipher3VdbeFinalize(pParse->pVdbe);
101756     }
101757     sqlcipher3DeleteTable(db, pParse->pNewTable);
101758     sqlcipher3StackFree(db, pParse);
101759   }
101760
101761   assert( (rc&0xff)==rc );
101762   rc = sqlcipher3ApiExit(db, rc);
101763   sqlcipher3_mutex_leave(db->mutex);
101764   return rc;
101765 }
101766
101767 /*
101768 ** This function is invoked by the vdbe to call the xDestroy method
101769 ** of the virtual table named zTab in database iDb. This occurs
101770 ** when a DROP TABLE is mentioned.
101771 **
101772 ** This call is a no-op if zTab is not a virtual table.
101773 */
101774 SQLCIPHER_PRIVATE int sqlcipher3VtabCallDestroy(sqlcipher3 *db, int iDb, const char *zTab){
101775   int rc = SQLCIPHER_OK;
101776   Table *pTab;
101777
101778   pTab = sqlcipher3FindTable(db, zTab, db->aDb[iDb].zName);
101779   if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
101780     VTable *p = vtabDisconnectAll(db, pTab);
101781
101782     assert( rc==SQLCIPHER_OK );
101783     rc = p->pMod->pModule->xDestroy(p->pVtab);
101784
101785     /* Remove the sqlcipher3_vtab* from the aVTrans[] array, if applicable */
101786     if( rc==SQLCIPHER_OK ){
101787       assert( pTab->pVTable==p && p->pNext==0 );
101788       p->pVtab = 0;
101789       pTab->pVTable = 0;
101790       sqlcipher3VtabUnlock(p);
101791     }
101792   }
101793
101794   return rc;
101795 }
101796
101797 /*
101798 ** This function invokes either the xRollback or xCommit method
101799 ** of each of the virtual tables in the sqlcipher3.aVTrans array. The method
101800 ** called is identified by the second argument, "offset", which is
101801 ** the offset of the method to call in the sqlcipher3_module structure.
101802 **
101803 ** The array is cleared after invoking the callbacks. 
101804 */
101805 static void callFinaliser(sqlcipher3 *db, int offset){
101806   int i;
101807   if( db->aVTrans ){
101808     for(i=0; i<db->nVTrans; i++){
101809       VTable *pVTab = db->aVTrans[i];
101810       sqlcipher3_vtab *p = pVTab->pVtab;
101811       if( p ){
101812         int (*x)(sqlcipher3_vtab *);
101813         x = *(int (**)(sqlcipher3_vtab *))((char *)p->pModule + offset);
101814         if( x ) x(p);
101815       }
101816       pVTab->iSavepoint = 0;
101817       sqlcipher3VtabUnlock(pVTab);
101818     }
101819     sqlcipher3DbFree(db, db->aVTrans);
101820     db->nVTrans = 0;
101821     db->aVTrans = 0;
101822   }
101823 }
101824
101825 /*
101826 ** Invoke the xSync method of all virtual tables in the sqlcipher3.aVTrans
101827 ** array. Return the error code for the first error that occurs, or
101828 ** SQLCIPHER_OK if all xSync operations are successful.
101829 **
101830 ** Set *pzErrmsg to point to a buffer that should be released using 
101831 ** sqlcipher3DbFree() containing an error message, if one is available.
101832 */
101833 SQLCIPHER_PRIVATE int sqlcipher3VtabSync(sqlcipher3 *db, char **pzErrmsg){
101834   int i;
101835   int rc = SQLCIPHER_OK;
101836   VTable **aVTrans = db->aVTrans;
101837
101838   db->aVTrans = 0;
101839   for(i=0; rc==SQLCIPHER_OK && i<db->nVTrans; i++){
101840     int (*x)(sqlcipher3_vtab *);
101841     sqlcipher3_vtab *pVtab = aVTrans[i]->pVtab;
101842     if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
101843       rc = x(pVtab);
101844       sqlcipher3DbFree(db, *pzErrmsg);
101845       *pzErrmsg = sqlcipher3DbStrDup(db, pVtab->zErrMsg);
101846       sqlcipher3_free(pVtab->zErrMsg);
101847     }
101848   }
101849   db->aVTrans = aVTrans;
101850   return rc;
101851 }
101852
101853 /*
101854 ** Invoke the xRollback method of all virtual tables in the 
101855 ** sqlcipher3.aVTrans array. Then clear the array itself.
101856 */
101857 SQLCIPHER_PRIVATE int sqlcipher3VtabRollback(sqlcipher3 *db){
101858   callFinaliser(db, offsetof(sqlcipher3_module,xRollback));
101859   return SQLCIPHER_OK;
101860 }
101861
101862 /*
101863 ** Invoke the xCommit method of all virtual tables in the 
101864 ** sqlcipher3.aVTrans array. Then clear the array itself.
101865 */
101866 SQLCIPHER_PRIVATE int sqlcipher3VtabCommit(sqlcipher3 *db){
101867   callFinaliser(db, offsetof(sqlcipher3_module,xCommit));
101868   return SQLCIPHER_OK;
101869 }
101870
101871 /*
101872 ** If the virtual table pVtab supports the transaction interface
101873 ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
101874 ** not currently open, invoke the xBegin method now.
101875 **
101876 ** If the xBegin call is successful, place the sqlcipher3_vtab pointer
101877 ** in the sqlcipher3.aVTrans array.
101878 */
101879 SQLCIPHER_PRIVATE int sqlcipher3VtabBegin(sqlcipher3 *db, VTable *pVTab){
101880   int rc = SQLCIPHER_OK;
101881   const sqlcipher3_module *pModule;
101882
101883   /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
101884   ** than zero, then this function is being called from within a
101885   ** virtual module xSync() callback. It is illegal to write to 
101886   ** virtual module tables in this case, so return SQLCIPHER_LOCKED.
101887   */
101888   if( sqlcipher3VtabInSync(db) ){
101889     return SQLCIPHER_LOCKED;
101890   }
101891   if( !pVTab ){
101892     return SQLCIPHER_OK;
101893   } 
101894   pModule = pVTab->pVtab->pModule;
101895
101896   if( pModule->xBegin ){
101897     int i;
101898
101899     /* If pVtab is already in the aVTrans array, return early */
101900     for(i=0; i<db->nVTrans; i++){
101901       if( db->aVTrans[i]==pVTab ){
101902         return SQLCIPHER_OK;
101903       }
101904     }
101905
101906     /* Invoke the xBegin method. If successful, add the vtab to the 
101907     ** sqlcipher3.aVTrans[] array. */
101908     rc = growVTrans(db);
101909     if( rc==SQLCIPHER_OK ){
101910       rc = pModule->xBegin(pVTab->pVtab);
101911       if( rc==SQLCIPHER_OK ){
101912         addToVTrans(db, pVTab);
101913       }
101914     }
101915   }
101916   return rc;
101917 }
101918
101919 /*
101920 ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
101921 ** virtual tables that currently have an open transaction. Pass iSavepoint
101922 ** as the second argument to the virtual table method invoked.
101923 **
101924 ** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is
101925 ** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is 
101926 ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
101927 ** an open transaction is invoked.
101928 **
101929 ** If any virtual table method returns an error code other than SQLCIPHER_OK, 
101930 ** processing is abandoned and the error returned to the caller of this
101931 ** function immediately. If all calls to virtual table methods are successful,
101932 ** SQLCIPHER_OK is returned.
101933 */
101934 SQLCIPHER_PRIVATE int sqlcipher3VtabSavepoint(sqlcipher3 *db, int op, int iSavepoint){
101935   int rc = SQLCIPHER_OK;
101936
101937   assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
101938   assert( iSavepoint>=0 );
101939   if( db->aVTrans ){
101940     int i;
101941     for(i=0; rc==SQLCIPHER_OK && i<db->nVTrans; i++){
101942       VTable *pVTab = db->aVTrans[i];
101943       const sqlcipher3_module *pMod = pVTab->pMod->pModule;
101944       if( pVTab->pVtab && pMod->iVersion>=2 ){
101945         int (*xMethod)(sqlcipher3_vtab *, int);
101946         switch( op ){
101947           case SAVEPOINT_BEGIN:
101948             xMethod = pMod->xSavepoint;
101949             pVTab->iSavepoint = iSavepoint+1;
101950             break;
101951           case SAVEPOINT_ROLLBACK:
101952             xMethod = pMod->xRollbackTo;
101953             break;
101954           default:
101955             xMethod = pMod->xRelease;
101956             break;
101957         }
101958         if( xMethod && pVTab->iSavepoint>iSavepoint ){
101959           rc = xMethod(pVTab->pVtab, iSavepoint);
101960         }
101961       }
101962     }
101963   }
101964   return rc;
101965 }
101966
101967 /*
101968 ** The first parameter (pDef) is a function implementation.  The
101969 ** second parameter (pExpr) is the first argument to this function.
101970 ** If pExpr is a column in a virtual table, then let the virtual
101971 ** table implementation have an opportunity to overload the function.
101972 **
101973 ** This routine is used to allow virtual table implementations to
101974 ** overload MATCH, LIKE, GLOB, and REGEXP operators.
101975 **
101976 ** Return either the pDef argument (indicating no change) or a 
101977 ** new FuncDef structure that is marked as ephemeral using the
101978 ** SQLCIPHER_FUNC_EPHEM flag.
101979 */
101980 SQLCIPHER_PRIVATE FuncDef *sqlcipher3VtabOverloadFunction(
101981   sqlcipher3 *db,    /* Database connection for reporting malloc problems */
101982   FuncDef *pDef,  /* Function to possibly overload */
101983   int nArg,       /* Number of arguments to the function */
101984   Expr *pExpr     /* First argument to the function */
101985 ){
101986   Table *pTab;
101987   sqlcipher3_vtab *pVtab;
101988   sqlcipher3_module *pMod;
101989   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**) = 0;
101990   void *pArg = 0;
101991   FuncDef *pNew;
101992   int rc = 0;
101993   char *zLowerName;
101994   unsigned char *z;
101995
101996
101997   /* Check to see the left operand is a column in a virtual table */
101998   if( NEVER(pExpr==0) ) return pDef;
101999   if( pExpr->op!=TK_COLUMN ) return pDef;
102000   pTab = pExpr->pTab;
102001   if( NEVER(pTab==0) ) return pDef;
102002   if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
102003   pVtab = sqlcipher3GetVTable(db, pTab)->pVtab;
102004   assert( pVtab!=0 );
102005   assert( pVtab->pModule!=0 );
102006   pMod = (sqlcipher3_module *)pVtab->pModule;
102007   if( pMod->xFindFunction==0 ) return pDef;
102008  
102009   /* Call the xFindFunction method on the virtual table implementation
102010   ** to see if the implementation wants to overload this function 
102011   */
102012   zLowerName = sqlcipher3DbStrDup(db, pDef->zName);
102013   if( zLowerName ){
102014     for(z=(unsigned char*)zLowerName; *z; z++){
102015       *z = sqlcipher3UpperToLower[*z];
102016     }
102017     rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
102018     sqlcipher3DbFree(db, zLowerName);
102019   }
102020   if( rc==0 ){
102021     return pDef;
102022   }
102023
102024   /* Create a new ephemeral function definition for the overloaded
102025   ** function */
102026   pNew = sqlcipher3DbMallocZero(db, sizeof(*pNew)
102027                              + sqlcipher3Strlen30(pDef->zName) + 1);
102028   if( pNew==0 ){
102029     return pDef;
102030   }
102031   *pNew = *pDef;
102032   pNew->zName = (char *)&pNew[1];
102033   memcpy(pNew->zName, pDef->zName, sqlcipher3Strlen30(pDef->zName)+1);
102034   pNew->xFunc = xFunc;
102035   pNew->pUserData = pArg;
102036   pNew->flags |= SQLCIPHER_FUNC_EPHEM;
102037   return pNew;
102038 }
102039
102040 /*
102041 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
102042 ** array so that an OP_VBegin will get generated for it.  Add pTab to the
102043 ** array if it is missing.  If pTab is already in the array, this routine
102044 ** is a no-op.
102045 */
102046 SQLCIPHER_PRIVATE void sqlcipher3VtabMakeWritable(Parse *pParse, Table *pTab){
102047   Parse *pToplevel = sqlcipher3ParseToplevel(pParse);
102048   int i, n;
102049   Table **apVtabLock;
102050
102051   assert( IsVirtual(pTab) );
102052   for(i=0; i<pToplevel->nVtabLock; i++){
102053     if( pTab==pToplevel->apVtabLock[i] ) return;
102054   }
102055   n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
102056   apVtabLock = sqlcipher3_realloc(pToplevel->apVtabLock, n);
102057   if( apVtabLock ){
102058     pToplevel->apVtabLock = apVtabLock;
102059     pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
102060   }else{
102061     pToplevel->db->mallocFailed = 1;
102062   }
102063 }
102064
102065 /*
102066 ** Return the ON CONFLICT resolution mode in effect for the virtual
102067 ** table update operation currently in progress.
102068 **
102069 ** The results of this routine are undefined unless it is called from
102070 ** within an xUpdate method.
102071 */
102072 SQLCIPHER_API int sqlcipher3_vtab_on_conflict(sqlcipher3 *db){
102073   static const unsigned char aMap[] = { 
102074     SQLCIPHER_ROLLBACK, SQLCIPHER_ABORT, SQLCIPHER_FAIL, SQLCIPHER_IGNORE, SQLCIPHER_REPLACE 
102075   };
102076   assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
102077   assert( OE_Ignore==4 && OE_Replace==5 );
102078   assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
102079   return (int)aMap[db->vtabOnConflict-1];
102080 }
102081
102082 /*
102083 ** Call from within the xCreate() or xConnect() methods to provide 
102084 ** the SQLite core with additional information about the behavior
102085 ** of the virtual table being implemented.
102086 */
102087 SQLCIPHER_API int sqlcipher3_vtab_config(sqlcipher3 *db, int op, ...){
102088   va_list ap;
102089   int rc = SQLCIPHER_OK;
102090
102091   sqlcipher3_mutex_enter(db->mutex);
102092
102093   va_start(ap, op);
102094   switch( op ){
102095     case SQLCIPHER_VTAB_CONSTRAINT_SUPPORT: {
102096       VtabCtx *p = db->pVtabCtx;
102097       if( !p ){
102098         rc = SQLCIPHER_MISUSE_BKPT;
102099       }else{
102100         assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
102101         p->pVTable->bConstraint = (u8)va_arg(ap, int);
102102       }
102103       break;
102104     }
102105     default:
102106       rc = SQLCIPHER_MISUSE_BKPT;
102107       break;
102108   }
102109   va_end(ap);
102110
102111   if( rc!=SQLCIPHER_OK ) sqlcipher3Error(db, rc, 0);
102112   sqlcipher3_mutex_leave(db->mutex);
102113   return rc;
102114 }
102115
102116 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
102117
102118 /************** End of vtab.c ************************************************/
102119 /************** Begin file where.c *******************************************/
102120 /*
102121 ** 2001 September 15
102122 **
102123 ** The author disclaims copyright to this source code.  In place of
102124 ** a legal notice, here is a blessing:
102125 **
102126 **    May you do good and not evil.
102127 **    May you find forgiveness for yourself and forgive others.
102128 **    May you share freely, never taking more than you give.
102129 **
102130 *************************************************************************
102131 ** This module contains C code that generates VDBE code used to process
102132 ** the WHERE clause of SQL statements.  This module is responsible for
102133 ** generating the code that loops through a table looking for applicable
102134 ** rows.  Indices are selected and used to speed the search when doing
102135 ** so is applicable.  Because this module is responsible for selecting
102136 ** indices, you might also think of this module as the "query optimizer".
102137 */
102138
102139
102140 /*
102141 ** Trace output macros
102142 */
102143 #if defined(SQLCIPHER_TEST) || defined(SQLCIPHER_DEBUG)
102144 SQLCIPHER_PRIVATE int sqlcipher3WhereTrace = 0;
102145 #endif
102146 #if defined(SQLCIPHER_TEST) && defined(SQLCIPHER_DEBUG)
102147 # define WHERETRACE(X)  if(sqlcipher3WhereTrace) sqlcipher3DebugPrintf X
102148 #else
102149 # define WHERETRACE(X)
102150 #endif
102151
102152 /* Forward reference
102153 */
102154 typedef struct WhereClause WhereClause;
102155 typedef struct WhereMaskSet WhereMaskSet;
102156 typedef struct WhereOrInfo WhereOrInfo;
102157 typedef struct WhereAndInfo WhereAndInfo;
102158 typedef struct WhereCost WhereCost;
102159
102160 /*
102161 ** The query generator uses an array of instances of this structure to
102162 ** help it analyze the subexpressions of the WHERE clause.  Each WHERE
102163 ** clause subexpression is separated from the others by AND operators,
102164 ** usually, or sometimes subexpressions separated by OR.
102165 **
102166 ** All WhereTerms are collected into a single WhereClause structure.  
102167 ** The following identity holds:
102168 **
102169 **        WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm
102170 **
102171 ** When a term is of the form:
102172 **
102173 **              X <op> <expr>
102174 **
102175 ** where X is a column name and <op> is one of certain operators,
102176 ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the
102177 ** cursor number and column number for X.  WhereTerm.eOperator records
102178 ** the <op> using a bitmask encoding defined by WO_xxx below.  The
102179 ** use of a bitmask encoding for the operator allows us to search
102180 ** quickly for terms that match any of several different operators.
102181 **
102182 ** A WhereTerm might also be two or more subterms connected by OR:
102183 **
102184 **         (t1.X <op> <expr>) OR (t1.Y <op> <expr>) OR ....
102185 **
102186 ** In this second case, wtFlag as the TERM_ORINFO set and eOperator==WO_OR
102187 ** and the WhereTerm.u.pOrInfo field points to auxiliary information that
102188 ** is collected about the
102189 **
102190 ** If a term in the WHERE clause does not match either of the two previous
102191 ** categories, then eOperator==0.  The WhereTerm.pExpr field is still set
102192 ** to the original subexpression content and wtFlags is set up appropriately
102193 ** but no other fields in the WhereTerm object are meaningful.
102194 **
102195 ** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers,
102196 ** but they do so indirectly.  A single WhereMaskSet structure translates
102197 ** cursor number into bits and the translated bit is stored in the prereq
102198 ** fields.  The translation is used in order to maximize the number of
102199 ** bits that will fit in a Bitmask.  The VDBE cursor numbers might be
102200 ** spread out over the non-negative integers.  For example, the cursor
102201 ** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45.  The WhereMaskSet
102202 ** translates these sparse cursor numbers into consecutive integers
102203 ** beginning with 0 in order to make the best possible use of the available
102204 ** bits in the Bitmask.  So, in the example above, the cursor numbers
102205 ** would be mapped into integers 0 through 7.
102206 **
102207 ** The number of terms in a join is limited by the number of bits
102208 ** in prereqRight and prereqAll.  The default is 64 bits, hence SQLite
102209 ** is only able to process joins with 64 or fewer tables.
102210 */
102211 typedef struct WhereTerm WhereTerm;
102212 struct WhereTerm {
102213   Expr *pExpr;            /* Pointer to the subexpression that is this term */
102214   int iParent;            /* Disable pWC->a[iParent] when this term disabled */
102215   int leftCursor;         /* Cursor number of X in "X <op> <expr>" */
102216   union {
102217     int leftColumn;         /* Column number of X in "X <op> <expr>" */
102218     WhereOrInfo *pOrInfo;   /* Extra information if eOperator==WO_OR */
102219     WhereAndInfo *pAndInfo; /* Extra information if eOperator==WO_AND */
102220   } u;
102221   u16 eOperator;          /* A WO_xx value describing <op> */
102222   u8 wtFlags;             /* TERM_xxx bit flags.  See below */
102223   u8 nChild;              /* Number of children that must disable us */
102224   WhereClause *pWC;       /* The clause this term is part of */
102225   Bitmask prereqRight;    /* Bitmask of tables used by pExpr->pRight */
102226   Bitmask prereqAll;      /* Bitmask of tables referenced by pExpr */
102227 };
102228
102229 /*
102230 ** Allowed values of WhereTerm.wtFlags
102231 */
102232 #define TERM_DYNAMIC    0x01   /* Need to call sqlcipher3ExprDelete(db, pExpr) */
102233 #define TERM_VIRTUAL    0x02   /* Added by the optimizer.  Do not code */
102234 #define TERM_CODED      0x04   /* This term is already coded */
102235 #define TERM_COPIED     0x08   /* Has a child */
102236 #define TERM_ORINFO     0x10   /* Need to free the WhereTerm.u.pOrInfo object */
102237 #define TERM_ANDINFO    0x20   /* Need to free the WhereTerm.u.pAndInfo obj */
102238 #define TERM_OR_OK      0x40   /* Used during OR-clause processing */
102239 #ifdef SQLCIPHER_ENABLE_STAT3
102240 #  define TERM_VNULL    0x80   /* Manufactured x>NULL or x<=NULL term */
102241 #else
102242 #  define TERM_VNULL    0x00   /* Disabled if not using stat3 */
102243 #endif
102244
102245 /*
102246 ** An instance of the following structure holds all information about a
102247 ** WHERE clause.  Mostly this is a container for one or more WhereTerms.
102248 **
102249 ** Explanation of pOuter:  For a WHERE clause of the form
102250 **
102251 **           a AND ((b AND c) OR (d AND e)) AND f
102252 **
102253 ** There are separate WhereClause objects for the whole clause and for
102254 ** the subclauses "(b AND c)" and "(d AND e)".  The pOuter field of the
102255 ** subclauses points to the WhereClause object for the whole clause.
102256 */
102257 struct WhereClause {
102258   Parse *pParse;           /* The parser context */
102259   WhereMaskSet *pMaskSet;  /* Mapping of table cursor numbers to bitmasks */
102260   Bitmask vmask;           /* Bitmask identifying virtual table cursors */
102261   WhereClause *pOuter;     /* Outer conjunction */
102262   u8 op;                   /* Split operator.  TK_AND or TK_OR */
102263   u16 wctrlFlags;          /* Might include WHERE_AND_ONLY */
102264   int nTerm;               /* Number of terms */
102265   int nSlot;               /* Number of entries in a[] */
102266   WhereTerm *a;            /* Each a[] describes a term of the WHERE cluase */
102267 #if defined(SQLCIPHER_SMALL_STACK)
102268   WhereTerm aStatic[1];    /* Initial static space for a[] */
102269 #else
102270   WhereTerm aStatic[8];    /* Initial static space for a[] */
102271 #endif
102272 };
102273
102274 /*
102275 ** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to
102276 ** a dynamically allocated instance of the following structure.
102277 */
102278 struct WhereOrInfo {
102279   WhereClause wc;          /* Decomposition into subterms */
102280   Bitmask indexable;       /* Bitmask of all indexable tables in the clause */
102281 };
102282
102283 /*
102284 ** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to
102285 ** a dynamically allocated instance of the following structure.
102286 */
102287 struct WhereAndInfo {
102288   WhereClause wc;          /* The subexpression broken out */
102289 };
102290
102291 /*
102292 ** An instance of the following structure keeps track of a mapping
102293 ** between VDBE cursor numbers and bits of the bitmasks in WhereTerm.
102294 **
102295 ** The VDBE cursor numbers are small integers contained in 
102296 ** SrcList_item.iCursor and Expr.iTable fields.  For any given WHERE 
102297 ** clause, the cursor numbers might not begin with 0 and they might
102298 ** contain gaps in the numbering sequence.  But we want to make maximum
102299 ** use of the bits in our bitmasks.  This structure provides a mapping
102300 ** from the sparse cursor numbers into consecutive integers beginning
102301 ** with 0.
102302 **
102303 ** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask
102304 ** corresponds VDBE cursor number B.  The A-th bit of a bitmask is 1<<A.
102305 **
102306 ** For example, if the WHERE clause expression used these VDBE
102307 ** cursors:  4, 5, 8, 29, 57, 73.  Then the  WhereMaskSet structure
102308 ** would map those cursor numbers into bits 0 through 5.
102309 **
102310 ** Note that the mapping is not necessarily ordered.  In the example
102311 ** above, the mapping might go like this:  4->3, 5->1, 8->2, 29->0,
102312 ** 57->5, 73->4.  Or one of 719 other combinations might be used. It
102313 ** does not really matter.  What is important is that sparse cursor
102314 ** numbers all get mapped into bit numbers that begin with 0 and contain
102315 ** no gaps.
102316 */
102317 struct WhereMaskSet {
102318   int n;                        /* Number of assigned cursor values */
102319   int ix[BMS];                  /* Cursor assigned to each bit */
102320 };
102321
102322 /*
102323 ** A WhereCost object records a lookup strategy and the estimated
102324 ** cost of pursuing that strategy.
102325 */
102326 struct WhereCost {
102327   WherePlan plan;    /* The lookup strategy */
102328   double rCost;      /* Overall cost of pursuing this search strategy */
102329   Bitmask used;      /* Bitmask of cursors used by this plan */
102330 };
102331
102332 /*
102333 ** Bitmasks for the operators that indices are able to exploit.  An
102334 ** OR-ed combination of these values can be used when searching for
102335 ** terms in the where clause.
102336 */
102337 #define WO_IN     0x001
102338 #define WO_EQ     0x002
102339 #define WO_LT     (WO_EQ<<(TK_LT-TK_EQ))
102340 #define WO_LE     (WO_EQ<<(TK_LE-TK_EQ))
102341 #define WO_GT     (WO_EQ<<(TK_GT-TK_EQ))
102342 #define WO_GE     (WO_EQ<<(TK_GE-TK_EQ))
102343 #define WO_MATCH  0x040
102344 #define WO_ISNULL 0x080
102345 #define WO_OR     0x100       /* Two or more OR-connected terms */
102346 #define WO_AND    0x200       /* Two or more AND-connected terms */
102347 #define WO_NOOP   0x800       /* This term does not restrict search space */
102348
102349 #define WO_ALL    0xfff       /* Mask of all possible WO_* values */
102350 #define WO_SINGLE 0x0ff       /* Mask of all non-compound WO_* values */
102351
102352 /*
102353 ** Value for wsFlags returned by bestIndex() and stored in
102354 ** WhereLevel.wsFlags.  These flags determine which search
102355 ** strategies are appropriate.
102356 **
102357 ** The least significant 12 bits is reserved as a mask for WO_ values above.
102358 ** The WhereLevel.wsFlags field is usually set to WO_IN|WO_EQ|WO_ISNULL.
102359 ** But if the table is the right table of a left join, WhereLevel.wsFlags
102360 ** is set to WO_IN|WO_EQ.  The WhereLevel.wsFlags field can then be used as
102361 ** the "op" parameter to findTerm when we are resolving equality constraints.
102362 ** ISNULL constraints will then not be used on the right table of a left
102363 ** join.  Tickets #2177 and #2189.
102364 */
102365 #define WHERE_ROWID_EQ     0x00001000  /* rowid=EXPR or rowid IN (...) */
102366 #define WHERE_ROWID_RANGE  0x00002000  /* rowid<EXPR and/or rowid>EXPR */
102367 #define WHERE_COLUMN_EQ    0x00010000  /* x=EXPR or x IN (...) or x IS NULL */
102368 #define WHERE_COLUMN_RANGE 0x00020000  /* x<EXPR and/or x>EXPR */
102369 #define WHERE_COLUMN_IN    0x00040000  /* x IN (...) */
102370 #define WHERE_COLUMN_NULL  0x00080000  /* x IS NULL */
102371 #define WHERE_INDEXED      0x000f0000  /* Anything that uses an index */
102372 #define WHERE_NOT_FULLSCAN 0x100f3000  /* Does not do a full table scan */
102373 #define WHERE_IN_ABLE      0x000f1000  /* Able to support an IN operator */
102374 #define WHERE_TOP_LIMIT    0x00100000  /* x<EXPR or x<=EXPR constraint */
102375 #define WHERE_BTM_LIMIT    0x00200000  /* x>EXPR or x>=EXPR constraint */
102376 #define WHERE_BOTH_LIMIT   0x00300000  /* Both x>EXPR and x<EXPR */
102377 #define WHERE_IDX_ONLY     0x00800000  /* Use index only - omit table */
102378 #define WHERE_ORDERBY      0x01000000  /* Output will appear in correct order */
102379 #define WHERE_REVERSE      0x02000000  /* Scan in reverse order */
102380 #define WHERE_UNIQUE       0x04000000  /* Selects no more than one row */
102381 #define WHERE_VIRTUALTABLE 0x08000000  /* Use virtual-table processing */
102382 #define WHERE_MULTI_OR     0x10000000  /* OR using multiple indices */
102383 #define WHERE_TEMP_INDEX   0x20000000  /* Uses an ephemeral index */
102384 #define WHERE_DISTINCT     0x40000000  /* Correct order for DISTINCT */
102385
102386 /*
102387 ** Initialize a preallocated WhereClause structure.
102388 */
102389 static void whereClauseInit(
102390   WhereClause *pWC,        /* The WhereClause to be initialized */
102391   Parse *pParse,           /* The parsing context */
102392   WhereMaskSet *pMaskSet,  /* Mapping from table cursor numbers to bitmasks */
102393   u16 wctrlFlags           /* Might include WHERE_AND_ONLY */
102394 ){
102395   pWC->pParse = pParse;
102396   pWC->pMaskSet = pMaskSet;
102397   pWC->pOuter = 0;
102398   pWC->nTerm = 0;
102399   pWC->nSlot = ArraySize(pWC->aStatic);
102400   pWC->a = pWC->aStatic;
102401   pWC->vmask = 0;
102402   pWC->wctrlFlags = wctrlFlags;
102403 }
102404
102405 /* Forward reference */
102406 static void whereClauseClear(WhereClause*);
102407
102408 /*
102409 ** Deallocate all memory associated with a WhereOrInfo object.
102410 */
102411 static void whereOrInfoDelete(sqlcipher3 *db, WhereOrInfo *p){
102412   whereClauseClear(&p->wc);
102413   sqlcipher3DbFree(db, p);
102414 }
102415
102416 /*
102417 ** Deallocate all memory associated with a WhereAndInfo object.
102418 */
102419 static void whereAndInfoDelete(sqlcipher3 *db, WhereAndInfo *p){
102420   whereClauseClear(&p->wc);
102421   sqlcipher3DbFree(db, p);
102422 }
102423
102424 /*
102425 ** Deallocate a WhereClause structure.  The WhereClause structure
102426 ** itself is not freed.  This routine is the inverse of whereClauseInit().
102427 */
102428 static void whereClauseClear(WhereClause *pWC){
102429   int i;
102430   WhereTerm *a;
102431   sqlcipher3 *db = pWC->pParse->db;
102432   for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){
102433     if( a->wtFlags & TERM_DYNAMIC ){
102434       sqlcipher3ExprDelete(db, a->pExpr);
102435     }
102436     if( a->wtFlags & TERM_ORINFO ){
102437       whereOrInfoDelete(db, a->u.pOrInfo);
102438     }else if( a->wtFlags & TERM_ANDINFO ){
102439       whereAndInfoDelete(db, a->u.pAndInfo);
102440     }
102441   }
102442   if( pWC->a!=pWC->aStatic ){
102443     sqlcipher3DbFree(db, pWC->a);
102444   }
102445 }
102446
102447 /*
102448 ** Add a single new WhereTerm entry to the WhereClause object pWC.
102449 ** The new WhereTerm object is constructed from Expr p and with wtFlags.
102450 ** The index in pWC->a[] of the new WhereTerm is returned on success.
102451 ** 0 is returned if the new WhereTerm could not be added due to a memory
102452 ** allocation error.  The memory allocation failure will be recorded in
102453 ** the db->mallocFailed flag so that higher-level functions can detect it.
102454 **
102455 ** This routine will increase the size of the pWC->a[] array as necessary.
102456 **
102457 ** If the wtFlags argument includes TERM_DYNAMIC, then responsibility
102458 ** for freeing the expression p is assumed by the WhereClause object pWC.
102459 ** This is true even if this routine fails to allocate a new WhereTerm.
102460 **
102461 ** WARNING:  This routine might reallocate the space used to store
102462 ** WhereTerms.  All pointers to WhereTerms should be invalidated after
102463 ** calling this routine.  Such pointers may be reinitialized by referencing
102464 ** the pWC->a[] array.
102465 */
102466 static int whereClauseInsert(WhereClause *pWC, Expr *p, u8 wtFlags){
102467   WhereTerm *pTerm;
102468   int idx;
102469   testcase( wtFlags & TERM_VIRTUAL );  /* EV: R-00211-15100 */
102470   if( pWC->nTerm>=pWC->nSlot ){
102471     WhereTerm *pOld = pWC->a;
102472     sqlcipher3 *db = pWC->pParse->db;
102473     pWC->a = sqlcipher3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
102474     if( pWC->a==0 ){
102475       if( wtFlags & TERM_DYNAMIC ){
102476         sqlcipher3ExprDelete(db, p);
102477       }
102478       pWC->a = pOld;
102479       return 0;
102480     }
102481     memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
102482     if( pOld!=pWC->aStatic ){
102483       sqlcipher3DbFree(db, pOld);
102484     }
102485     pWC->nSlot = sqlcipher3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
102486   }
102487   pTerm = &pWC->a[idx = pWC->nTerm++];
102488   pTerm->pExpr = p;
102489   pTerm->wtFlags = wtFlags;
102490   pTerm->pWC = pWC;
102491   pTerm->iParent = -1;
102492   return idx;
102493 }
102494
102495 /*
102496 ** This routine identifies subexpressions in the WHERE clause where
102497 ** each subexpression is separated by the AND operator or some other
102498 ** operator specified in the op parameter.  The WhereClause structure
102499 ** is filled with pointers to subexpressions.  For example:
102500 **
102501 **    WHERE  a=='hello' AND coalesce(b,11)<10 AND (c+12!=d OR c==22)
102502 **           \________/     \_______________/     \________________/
102503 **            slot[0]            slot[1]               slot[2]
102504 **
102505 ** The original WHERE clause in pExpr is unaltered.  All this routine
102506 ** does is make slot[] entries point to substructure within pExpr.
102507 **
102508 ** In the previous sentence and in the diagram, "slot[]" refers to
102509 ** the WhereClause.a[] array.  The slot[] array grows as needed to contain
102510 ** all terms of the WHERE clause.
102511 */
102512 static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
102513   pWC->op = (u8)op;
102514   if( pExpr==0 ) return;
102515   if( pExpr->op!=op ){
102516     whereClauseInsert(pWC, pExpr, 0);
102517   }else{
102518     whereSplit(pWC, pExpr->pLeft, op);
102519     whereSplit(pWC, pExpr->pRight, op);
102520   }
102521 }
102522
102523 /*
102524 ** Initialize an expression mask set (a WhereMaskSet object)
102525 */
102526 #define initMaskSet(P)  memset(P, 0, sizeof(*P))
102527
102528 /*
102529 ** Return the bitmask for the given cursor number.  Return 0 if
102530 ** iCursor is not in the set.
102531 */
102532 static Bitmask getMask(WhereMaskSet *pMaskSet, int iCursor){
102533   int i;
102534   assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
102535   for(i=0; i<pMaskSet->n; i++){
102536     if( pMaskSet->ix[i]==iCursor ){
102537       return ((Bitmask)1)<<i;
102538     }
102539   }
102540   return 0;
102541 }
102542
102543 /*
102544 ** Create a new mask for cursor iCursor.
102545 **
102546 ** There is one cursor per table in the FROM clause.  The number of
102547 ** tables in the FROM clause is limited by a test early in the
102548 ** sqlcipher3WhereBegin() routine.  So we know that the pMaskSet->ix[]
102549 ** array will never overflow.
102550 */
102551 static void createMask(WhereMaskSet *pMaskSet, int iCursor){
102552   assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
102553   pMaskSet->ix[pMaskSet->n++] = iCursor;
102554 }
102555
102556 /*
102557 ** This routine walks (recursively) an expression tree and generates
102558 ** a bitmask indicating which tables are used in that expression
102559 ** tree.
102560 **
102561 ** In order for this routine to work, the calling function must have
102562 ** previously invoked sqlcipher3ResolveExprNames() on the expression.  See
102563 ** the header comment on that routine for additional information.
102564 ** The sqlcipher3ResolveExprNames() routines looks for column names and
102565 ** sets their opcodes to TK_COLUMN and their Expr.iTable fields to
102566 ** the VDBE cursor number of the table.  This routine just has to
102567 ** translate the cursor numbers into bitmask values and OR all
102568 ** the bitmasks together.
102569 */
102570 static Bitmask exprListTableUsage(WhereMaskSet*, ExprList*);
102571 static Bitmask exprSelectTableUsage(WhereMaskSet*, Select*);
102572 static Bitmask exprTableUsage(WhereMaskSet *pMaskSet, Expr *p){
102573   Bitmask mask = 0;
102574   if( p==0 ) return 0;
102575   if( p->op==TK_COLUMN ){
102576     mask = getMask(pMaskSet, p->iTable);
102577     return mask;
102578   }
102579   mask = exprTableUsage(pMaskSet, p->pRight);
102580   mask |= exprTableUsage(pMaskSet, p->pLeft);
102581   if( ExprHasProperty(p, EP_xIsSelect) ){
102582     mask |= exprSelectTableUsage(pMaskSet, p->x.pSelect);
102583   }else{
102584     mask |= exprListTableUsage(pMaskSet, p->x.pList);
102585   }
102586   return mask;
102587 }
102588 static Bitmask exprListTableUsage(WhereMaskSet *pMaskSet, ExprList *pList){
102589   int i;
102590   Bitmask mask = 0;
102591   if( pList ){
102592     for(i=0; i<pList->nExpr; i++){
102593       mask |= exprTableUsage(pMaskSet, pList->a[i].pExpr);
102594     }
102595   }
102596   return mask;
102597 }
102598 static Bitmask exprSelectTableUsage(WhereMaskSet *pMaskSet, Select *pS){
102599   Bitmask mask = 0;
102600   while( pS ){
102601     SrcList *pSrc = pS->pSrc;
102602     mask |= exprListTableUsage(pMaskSet, pS->pEList);
102603     mask |= exprListTableUsage(pMaskSet, pS->pGroupBy);
102604     mask |= exprListTableUsage(pMaskSet, pS->pOrderBy);
102605     mask |= exprTableUsage(pMaskSet, pS->pWhere);
102606     mask |= exprTableUsage(pMaskSet, pS->pHaving);
102607     if( ALWAYS(pSrc!=0) ){
102608       int i;
102609       for(i=0; i<pSrc->nSrc; i++){
102610         mask |= exprSelectTableUsage(pMaskSet, pSrc->a[i].pSelect);
102611         mask |= exprTableUsage(pMaskSet, pSrc->a[i].pOn);
102612       }
102613     }
102614     pS = pS->pPrior;
102615   }
102616   return mask;
102617 }
102618
102619 /*
102620 ** Return TRUE if the given operator is one of the operators that is
102621 ** allowed for an indexable WHERE clause term.  The allowed operators are
102622 ** "=", "<", ">", "<=", ">=", and "IN".
102623 **
102624 ** IMPLEMENTATION-OF: R-59926-26393 To be usable by an index a term must be
102625 ** of one of the following forms: column = expression column > expression
102626 ** column >= expression column < expression column <= expression
102627 ** expression = column expression > column expression >= column
102628 ** expression < column expression <= column column IN
102629 ** (expression-list) column IN (subquery) column IS NULL
102630 */
102631 static int allowedOp(int op){
102632   assert( TK_GT>TK_EQ && TK_GT<TK_GE );
102633   assert( TK_LT>TK_EQ && TK_LT<TK_GE );
102634   assert( TK_LE>TK_EQ && TK_LE<TK_GE );
102635   assert( TK_GE==TK_EQ+4 );
102636   return op==TK_IN || (op>=TK_EQ && op<=TK_GE) || op==TK_ISNULL;
102637 }
102638
102639 /*
102640 ** Swap two objects of type TYPE.
102641 */
102642 #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
102643
102644 /*
102645 ** Commute a comparison operator.  Expressions of the form "X op Y"
102646 ** are converted into "Y op X".
102647 **
102648 ** If a collation sequence is associated with either the left or right
102649 ** side of the comparison, it remains associated with the same side after
102650 ** the commutation. So "Y collate NOCASE op X" becomes 
102651 ** "X collate NOCASE op Y". This is because any collation sequence on
102652 ** the left hand side of a comparison overrides any collation sequence 
102653 ** attached to the right. For the same reason the EP_ExpCollate flag
102654 ** is not commuted.
102655 */
102656 static void exprCommute(Parse *pParse, Expr *pExpr){
102657   u16 expRight = (pExpr->pRight->flags & EP_ExpCollate);
102658   u16 expLeft = (pExpr->pLeft->flags & EP_ExpCollate);
102659   assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
102660   pExpr->pRight->pColl = sqlcipher3ExprCollSeq(pParse, pExpr->pRight);
102661   pExpr->pLeft->pColl = sqlcipher3ExprCollSeq(pParse, pExpr->pLeft);
102662   SWAP(CollSeq*,pExpr->pRight->pColl,pExpr->pLeft->pColl);
102663   pExpr->pRight->flags = (pExpr->pRight->flags & ~EP_ExpCollate) | expLeft;
102664   pExpr->pLeft->flags = (pExpr->pLeft->flags & ~EP_ExpCollate) | expRight;
102665   SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
102666   if( pExpr->op>=TK_GT ){
102667     assert( TK_LT==TK_GT+2 );
102668     assert( TK_GE==TK_LE+2 );
102669     assert( TK_GT>TK_EQ );
102670     assert( TK_GT<TK_LE );
102671     assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
102672     pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
102673   }
102674 }
102675
102676 /*
102677 ** Translate from TK_xx operator to WO_xx bitmask.
102678 */
102679 static u16 operatorMask(int op){
102680   u16 c;
102681   assert( allowedOp(op) );
102682   if( op==TK_IN ){
102683     c = WO_IN;
102684   }else if( op==TK_ISNULL ){
102685     c = WO_ISNULL;
102686   }else{
102687     assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
102688     c = (u16)(WO_EQ<<(op-TK_EQ));
102689   }
102690   assert( op!=TK_ISNULL || c==WO_ISNULL );
102691   assert( op!=TK_IN || c==WO_IN );
102692   assert( op!=TK_EQ || c==WO_EQ );
102693   assert( op!=TK_LT || c==WO_LT );
102694   assert( op!=TK_LE || c==WO_LE );
102695   assert( op!=TK_GT || c==WO_GT );
102696   assert( op!=TK_GE || c==WO_GE );
102697   return c;
102698 }
102699
102700 /*
102701 ** Search for a term in the WHERE clause that is of the form "X <op> <expr>"
102702 ** where X is a reference to the iColumn of table iCur and <op> is one of
102703 ** the WO_xx operator codes specified by the op parameter.
102704 ** Return a pointer to the term.  Return 0 if not found.
102705 */
102706 static WhereTerm *findTerm(
102707   WhereClause *pWC,     /* The WHERE clause to be searched */
102708   int iCur,             /* Cursor number of LHS */
102709   int iColumn,          /* Column number of LHS */
102710   Bitmask notReady,     /* RHS must not overlap with this mask */
102711   u32 op,               /* Mask of WO_xx values describing operator */
102712   Index *pIdx           /* Must be compatible with this index, if not NULL */
102713 ){
102714   WhereTerm *pTerm;
102715   int k;
102716   assert( iCur>=0 );
102717   op &= WO_ALL;
102718   for(; pWC; pWC=pWC->pOuter){
102719     for(pTerm=pWC->a, k=pWC->nTerm; k; k--, pTerm++){
102720       if( pTerm->leftCursor==iCur
102721          && (pTerm->prereqRight & notReady)==0
102722          && pTerm->u.leftColumn==iColumn
102723          && (pTerm->eOperator & op)!=0
102724       ){
102725         if( pIdx && pTerm->eOperator!=WO_ISNULL ){
102726           Expr *pX = pTerm->pExpr;
102727           CollSeq *pColl;
102728           char idxaff;
102729           int j;
102730           Parse *pParse = pWC->pParse;
102731   
102732           idxaff = pIdx->pTable->aCol[iColumn].affinity;
102733           if( !sqlcipher3IndexAffinityOk(pX, idxaff) ) continue;
102734   
102735           /* Figure out the collation sequence required from an index for
102736           ** it to be useful for optimising expression pX. Store this
102737           ** value in variable pColl.
102738           */
102739           assert(pX->pLeft);
102740           pColl = sqlcipher3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
102741           assert(pColl || pParse->nErr);
102742   
102743           for(j=0; pIdx->aiColumn[j]!=iColumn; j++){
102744             if( NEVER(j>=pIdx->nColumn) ) return 0;
102745           }
102746           if( pColl && sqlcipher3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
102747         }
102748         return pTerm;
102749       }
102750     }
102751   }
102752   return 0;
102753 }
102754
102755 /* Forward reference */
102756 static void exprAnalyze(SrcList*, WhereClause*, int);
102757
102758 /*
102759 ** Call exprAnalyze on all terms in a WHERE clause.  
102760 **
102761 **
102762 */
102763 static void exprAnalyzeAll(
102764   SrcList *pTabList,       /* the FROM clause */
102765   WhereClause *pWC         /* the WHERE clause to be analyzed */
102766 ){
102767   int i;
102768   for(i=pWC->nTerm-1; i>=0; i--){
102769     exprAnalyze(pTabList, pWC, i);
102770   }
102771 }
102772
102773 #ifndef SQLCIPHER_OMIT_LIKE_OPTIMIZATION
102774 /*
102775 ** Check to see if the given expression is a LIKE or GLOB operator that
102776 ** can be optimized using inequality constraints.  Return TRUE if it is
102777 ** so and false if not.
102778 **
102779 ** In order for the operator to be optimizible, the RHS must be a string
102780 ** literal that does not begin with a wildcard.  
102781 */
102782 static int isLikeOrGlob(
102783   Parse *pParse,    /* Parsing and code generating context */
102784   Expr *pExpr,      /* Test this expression */
102785   Expr **ppPrefix,  /* Pointer to TK_STRING expression with pattern prefix */
102786   int *pisComplete, /* True if the only wildcard is % in the last character */
102787   int *pnoCase      /* True if uppercase is equivalent to lowercase */
102788 ){
102789   const char *z = 0;         /* String on RHS of LIKE operator */
102790   Expr *pRight, *pLeft;      /* Right and left size of LIKE operator */
102791   ExprList *pList;           /* List of operands to the LIKE operator */
102792   int c;                     /* One character in z[] */
102793   int cnt;                   /* Number of non-wildcard prefix characters */
102794   char wc[3];                /* Wildcard characters */
102795   sqlcipher3 *db = pParse->db;  /* Database connection */
102796   sqlcipher3_value *pVal = 0;
102797   int op;                    /* Opcode of pRight */
102798
102799   if( !sqlcipher3IsLikeFunction(db, pExpr, pnoCase, wc) ){
102800     return 0;
102801   }
102802 #ifdef SQLCIPHER_EBCDIC
102803   if( *pnoCase ) return 0;
102804 #endif
102805   pList = pExpr->x.pList;
102806   pLeft = pList->a[1].pExpr;
102807   if( pLeft->op!=TK_COLUMN || sqlcipher3ExprAffinity(pLeft)!=SQLCIPHER_AFF_TEXT ){
102808     /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
102809     ** be the name of an indexed column with TEXT affinity. */
102810     return 0;
102811   }
102812   assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
102813
102814   pRight = pList->a[0].pExpr;
102815   op = pRight->op;
102816   if( op==TK_REGISTER ){
102817     op = pRight->op2;
102818   }
102819   if( op==TK_VARIABLE ){
102820     Vdbe *pReprepare = pParse->pReprepare;
102821     int iCol = pRight->iColumn;
102822     pVal = sqlcipher3VdbeGetValue(pReprepare, iCol, SQLCIPHER_AFF_NONE);
102823     if( pVal && sqlcipher3_value_type(pVal)==SQLCIPHER_TEXT ){
102824       z = (char *)sqlcipher3_value_text(pVal);
102825     }
102826     sqlcipher3VdbeSetVarmask(pParse->pVdbe, iCol);
102827     assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
102828   }else if( op==TK_STRING ){
102829     z = pRight->u.zToken;
102830   }
102831   if( z ){
102832     cnt = 0;
102833     while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
102834       cnt++;
102835     }
102836     if( cnt!=0 && 255!=(u8)z[cnt-1] ){
102837       Expr *pPrefix;
102838       *pisComplete = c==wc[0] && z[cnt+1]==0;
102839       pPrefix = sqlcipher3Expr(db, TK_STRING, z);
102840       if( pPrefix ) pPrefix->u.zToken[cnt] = 0;
102841       *ppPrefix = pPrefix;
102842       if( op==TK_VARIABLE ){
102843         Vdbe *v = pParse->pVdbe;
102844         sqlcipher3VdbeSetVarmask(v, pRight->iColumn);
102845         if( *pisComplete && pRight->u.zToken[1] ){
102846           /* If the rhs of the LIKE expression is a variable, and the current
102847           ** value of the variable means there is no need to invoke the LIKE
102848           ** function, then no OP_Variable will be added to the program.
102849           ** This causes problems for the sqlcipher3_bind_parameter_name()
102850           ** API. To workaround them, add a dummy OP_Variable here.
102851           */ 
102852           int r1 = sqlcipher3GetTempReg(pParse);
102853           sqlcipher3ExprCodeTarget(pParse, pRight, r1);
102854           sqlcipher3VdbeChangeP3(v, sqlcipher3VdbeCurrentAddr(v)-1, 0);
102855           sqlcipher3ReleaseTempReg(pParse, r1);
102856         }
102857       }
102858     }else{
102859       z = 0;
102860     }
102861   }
102862
102863   sqlcipher3ValueFree(pVal);
102864   return (z!=0);
102865 }
102866 #endif /* SQLCIPHER_OMIT_LIKE_OPTIMIZATION */
102867
102868
102869 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
102870 /*
102871 ** Check to see if the given expression is of the form
102872 **
102873 **         column MATCH expr
102874 **
102875 ** If it is then return TRUE.  If not, return FALSE.
102876 */
102877 static int isMatchOfColumn(
102878   Expr *pExpr      /* Test this expression */
102879 ){
102880   ExprList *pList;
102881
102882   if( pExpr->op!=TK_FUNCTION ){
102883     return 0;
102884   }
102885   if( sqlcipher3StrICmp(pExpr->u.zToken,"match")!=0 ){
102886     return 0;
102887   }
102888   pList = pExpr->x.pList;
102889   if( pList->nExpr!=2 ){
102890     return 0;
102891   }
102892   if( pList->a[1].pExpr->op != TK_COLUMN ){
102893     return 0;
102894   }
102895   return 1;
102896 }
102897 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
102898
102899 /*
102900 ** If the pBase expression originated in the ON or USING clause of
102901 ** a join, then transfer the appropriate markings over to derived.
102902 */
102903 static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
102904   pDerived->flags |= pBase->flags & EP_FromJoin;
102905   pDerived->iRightJoinTable = pBase->iRightJoinTable;
102906 }
102907
102908 #if !defined(SQLCIPHER_OMIT_OR_OPTIMIZATION) && !defined(SQLCIPHER_OMIT_SUBQUERY)
102909 /*
102910 ** Analyze a term that consists of two or more OR-connected
102911 ** subterms.  So in:
102912 **
102913 **     ... WHERE  (a=5) AND (b=7 OR c=9 OR d=13) AND (d=13)
102914 **                          ^^^^^^^^^^^^^^^^^^^^
102915 **
102916 ** This routine analyzes terms such as the middle term in the above example.
102917 ** A WhereOrTerm object is computed and attached to the term under
102918 ** analysis, regardless of the outcome of the analysis.  Hence:
102919 **
102920 **     WhereTerm.wtFlags   |=  TERM_ORINFO
102921 **     WhereTerm.u.pOrInfo  =  a dynamically allocated WhereOrTerm object
102922 **
102923 ** The term being analyzed must have two or more of OR-connected subterms.
102924 ** A single subterm might be a set of AND-connected sub-subterms.
102925 ** Examples of terms under analysis:
102926 **
102927 **     (A)     t1.x=t2.y OR t1.x=t2.z OR t1.y=15 OR t1.z=t3.a+5
102928 **     (B)     x=expr1 OR expr2=x OR x=expr3
102929 **     (C)     t1.x=t2.y OR (t1.x=t2.z AND t1.y=15)
102930 **     (D)     x=expr1 OR (y>11 AND y<22 AND z LIKE '*hello*')
102931 **     (E)     (p.a=1 AND q.b=2 AND r.c=3) OR (p.x=4 AND q.y=5 AND r.z=6)
102932 **
102933 ** CASE 1:
102934 **
102935 ** If all subterms are of the form T.C=expr for some single column of C
102936 ** a single table T (as shown in example B above) then create a new virtual
102937 ** term that is an equivalent IN expression.  In other words, if the term
102938 ** being analyzed is:
102939 **
102940 **      x = expr1  OR  expr2 = x  OR  x = expr3
102941 **
102942 ** then create a new virtual term like this:
102943 **
102944 **      x IN (expr1,expr2,expr3)
102945 **
102946 ** CASE 2:
102947 **
102948 ** If all subterms are indexable by a single table T, then set
102949 **
102950 **     WhereTerm.eOperator              =  WO_OR
102951 **     WhereTerm.u.pOrInfo->indexable  |=  the cursor number for table T
102952 **
102953 ** A subterm is "indexable" if it is of the form
102954 ** "T.C <op> <expr>" where C is any column of table T and 
102955 ** <op> is one of "=", "<", "<=", ">", ">=", "IS NULL", or "IN".
102956 ** A subterm is also indexable if it is an AND of two or more
102957 ** subsubterms at least one of which is indexable.  Indexable AND 
102958 ** subterms have their eOperator set to WO_AND and they have
102959 ** u.pAndInfo set to a dynamically allocated WhereAndTerm object.
102960 **
102961 ** From another point of view, "indexable" means that the subterm could
102962 ** potentially be used with an index if an appropriate index exists.
102963 ** This analysis does not consider whether or not the index exists; that
102964 ** is something the bestIndex() routine will determine.  This analysis
102965 ** only looks at whether subterms appropriate for indexing exist.
102966 **
102967 ** All examples A through E above all satisfy case 2.  But if a term
102968 ** also statisfies case 1 (such as B) we know that the optimizer will
102969 ** always prefer case 1, so in that case we pretend that case 2 is not
102970 ** satisfied.
102971 **
102972 ** It might be the case that multiple tables are indexable.  For example,
102973 ** (E) above is indexable on tables P, Q, and R.
102974 **
102975 ** Terms that satisfy case 2 are candidates for lookup by using
102976 ** separate indices to find rowids for each subterm and composing
102977 ** the union of all rowids using a RowSet object.  This is similar
102978 ** to "bitmap indices" in other database engines.
102979 **
102980 ** OTHERWISE:
102981 **
102982 ** If neither case 1 nor case 2 apply, then leave the eOperator set to
102983 ** zero.  This term is not useful for search.
102984 */
102985 static void exprAnalyzeOrTerm(
102986   SrcList *pSrc,            /* the FROM clause */
102987   WhereClause *pWC,         /* the complete WHERE clause */
102988   int idxTerm               /* Index of the OR-term to be analyzed */
102989 ){
102990   Parse *pParse = pWC->pParse;            /* Parser context */
102991   sqlcipher3 *db = pParse->db;               /* Database connection */
102992   WhereTerm *pTerm = &pWC->a[idxTerm];    /* The term to be analyzed */
102993   Expr *pExpr = pTerm->pExpr;             /* The expression of the term */
102994   WhereMaskSet *pMaskSet = pWC->pMaskSet; /* Table use masks */
102995   int i;                                  /* Loop counters */
102996   WhereClause *pOrWc;       /* Breakup of pTerm into subterms */
102997   WhereTerm *pOrTerm;       /* A Sub-term within the pOrWc */
102998   WhereOrInfo *pOrInfo;     /* Additional information associated with pTerm */
102999   Bitmask chngToIN;         /* Tables that might satisfy case 1 */
103000   Bitmask indexable;        /* Tables that are indexable, satisfying case 2 */
103001
103002   /*
103003   ** Break the OR clause into its separate subterms.  The subterms are
103004   ** stored in a WhereClause structure containing within the WhereOrInfo
103005   ** object that is attached to the original OR clause term.
103006   */
103007   assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
103008   assert( pExpr->op==TK_OR );
103009   pTerm->u.pOrInfo = pOrInfo = sqlcipher3DbMallocZero(db, sizeof(*pOrInfo));
103010   if( pOrInfo==0 ) return;
103011   pTerm->wtFlags |= TERM_ORINFO;
103012   pOrWc = &pOrInfo->wc;
103013   whereClauseInit(pOrWc, pWC->pParse, pMaskSet, pWC->wctrlFlags);
103014   whereSplit(pOrWc, pExpr, TK_OR);
103015   exprAnalyzeAll(pSrc, pOrWc);
103016   if( db->mallocFailed ) return;
103017   assert( pOrWc->nTerm>=2 );
103018
103019   /*
103020   ** Compute the set of tables that might satisfy cases 1 or 2.
103021   */
103022   indexable = ~(Bitmask)0;
103023   chngToIN = ~(pWC->vmask);
103024   for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){
103025     if( (pOrTerm->eOperator & WO_SINGLE)==0 ){
103026       WhereAndInfo *pAndInfo;
103027       assert( pOrTerm->eOperator==0 );
103028       assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
103029       chngToIN = 0;
103030       pAndInfo = sqlcipher3DbMallocRaw(db, sizeof(*pAndInfo));
103031       if( pAndInfo ){
103032         WhereClause *pAndWC;
103033         WhereTerm *pAndTerm;
103034         int j;
103035         Bitmask b = 0;
103036         pOrTerm->u.pAndInfo = pAndInfo;
103037         pOrTerm->wtFlags |= TERM_ANDINFO;
103038         pOrTerm->eOperator = WO_AND;
103039         pAndWC = &pAndInfo->wc;
103040         whereClauseInit(pAndWC, pWC->pParse, pMaskSet, pWC->wctrlFlags);
103041         whereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
103042         exprAnalyzeAll(pSrc, pAndWC);
103043         pAndWC->pOuter = pWC;
103044         testcase( db->mallocFailed );
103045         if( !db->mallocFailed ){
103046           for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
103047             assert( pAndTerm->pExpr );
103048             if( allowedOp(pAndTerm->pExpr->op) ){
103049               b |= getMask(pMaskSet, pAndTerm->leftCursor);
103050             }
103051           }
103052         }
103053         indexable &= b;
103054       }
103055     }else if( pOrTerm->wtFlags & TERM_COPIED ){
103056       /* Skip this term for now.  We revisit it when we process the
103057       ** corresponding TERM_VIRTUAL term */
103058     }else{
103059       Bitmask b;
103060       b = getMask(pMaskSet, pOrTerm->leftCursor);
103061       if( pOrTerm->wtFlags & TERM_VIRTUAL ){
103062         WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent];
103063         b |= getMask(pMaskSet, pOther->leftCursor);
103064       }
103065       indexable &= b;
103066       if( pOrTerm->eOperator!=WO_EQ ){
103067         chngToIN = 0;
103068       }else{
103069         chngToIN &= b;
103070       }
103071     }
103072   }
103073
103074   /*
103075   ** Record the set of tables that satisfy case 2.  The set might be
103076   ** empty.
103077   */
103078   pOrInfo->indexable = indexable;
103079   pTerm->eOperator = indexable==0 ? 0 : WO_OR;
103080
103081   /*
103082   ** chngToIN holds a set of tables that *might* satisfy case 1.  But
103083   ** we have to do some additional checking to see if case 1 really
103084   ** is satisfied.
103085   **
103086   ** chngToIN will hold either 0, 1, or 2 bits.  The 0-bit case means
103087   ** that there is no possibility of transforming the OR clause into an
103088   ** IN operator because one or more terms in the OR clause contain
103089   ** something other than == on a column in the single table.  The 1-bit
103090   ** case means that every term of the OR clause is of the form
103091   ** "table.column=expr" for some single table.  The one bit that is set
103092   ** will correspond to the common table.  We still need to check to make
103093   ** sure the same column is used on all terms.  The 2-bit case is when
103094   ** the all terms are of the form "table1.column=table2.column".  It
103095   ** might be possible to form an IN operator with either table1.column
103096   ** or table2.column as the LHS if either is common to every term of
103097   ** the OR clause.
103098   **
103099   ** Note that terms of the form "table.column1=table.column2" (the
103100   ** same table on both sizes of the ==) cannot be optimized.
103101   */
103102   if( chngToIN ){
103103     int okToChngToIN = 0;     /* True if the conversion to IN is valid */
103104     int iColumn = -1;         /* Column index on lhs of IN operator */
103105     int iCursor = -1;         /* Table cursor common to all terms */
103106     int j = 0;                /* Loop counter */
103107
103108     /* Search for a table and column that appears on one side or the
103109     ** other of the == operator in every subterm.  That table and column
103110     ** will be recorded in iCursor and iColumn.  There might not be any
103111     ** such table and column.  Set okToChngToIN if an appropriate table
103112     ** and column is found but leave okToChngToIN false if not found.
103113     */
103114     for(j=0; j<2 && !okToChngToIN; j++){
103115       pOrTerm = pOrWc->a;
103116       for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){
103117         assert( pOrTerm->eOperator==WO_EQ );
103118         pOrTerm->wtFlags &= ~TERM_OR_OK;
103119         if( pOrTerm->leftCursor==iCursor ){
103120           /* This is the 2-bit case and we are on the second iteration and
103121           ** current term is from the first iteration.  So skip this term. */
103122           assert( j==1 );
103123           continue;
103124         }
103125         if( (chngToIN & getMask(pMaskSet, pOrTerm->leftCursor))==0 ){
103126           /* This term must be of the form t1.a==t2.b where t2 is in the
103127           ** chngToIN set but t1 is not.  This term will be either preceeded
103128           ** or follwed by an inverted copy (t2.b==t1.a).  Skip this term 
103129           ** and use its inversion. */
103130           testcase( pOrTerm->wtFlags & TERM_COPIED );
103131           testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
103132           assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
103133           continue;
103134         }
103135         iColumn = pOrTerm->u.leftColumn;
103136         iCursor = pOrTerm->leftCursor;
103137         break;
103138       }
103139       if( i<0 ){
103140         /* No candidate table+column was found.  This can only occur
103141         ** on the second iteration */
103142         assert( j==1 );
103143         assert( (chngToIN&(chngToIN-1))==0 );
103144         assert( chngToIN==getMask(pMaskSet, iCursor) );
103145         break;
103146       }
103147       testcase( j==1 );
103148
103149       /* We have found a candidate table and column.  Check to see if that
103150       ** table and column is common to every term in the OR clause */
103151       okToChngToIN = 1;
103152       for(; i>=0 && okToChngToIN; i--, pOrTerm++){
103153         assert( pOrTerm->eOperator==WO_EQ );
103154         if( pOrTerm->leftCursor!=iCursor ){
103155           pOrTerm->wtFlags &= ~TERM_OR_OK;
103156         }else if( pOrTerm->u.leftColumn!=iColumn ){
103157           okToChngToIN = 0;
103158         }else{
103159           int affLeft, affRight;
103160           /* If the right-hand side is also a column, then the affinities
103161           ** of both right and left sides must be such that no type
103162           ** conversions are required on the right.  (Ticket #2249)
103163           */
103164           affRight = sqlcipher3ExprAffinity(pOrTerm->pExpr->pRight);
103165           affLeft = sqlcipher3ExprAffinity(pOrTerm->pExpr->pLeft);
103166           if( affRight!=0 && affRight!=affLeft ){
103167             okToChngToIN = 0;
103168           }else{
103169             pOrTerm->wtFlags |= TERM_OR_OK;
103170           }
103171         }
103172       }
103173     }
103174
103175     /* At this point, okToChngToIN is true if original pTerm satisfies
103176     ** case 1.  In that case, construct a new virtual term that is 
103177     ** pTerm converted into an IN operator.
103178     **
103179     ** EV: R-00211-15100
103180     */
103181     if( okToChngToIN ){
103182       Expr *pDup;            /* A transient duplicate expression */
103183       ExprList *pList = 0;   /* The RHS of the IN operator */
103184       Expr *pLeft = 0;       /* The LHS of the IN operator */
103185       Expr *pNew;            /* The complete IN operator */
103186
103187       for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){
103188         if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue;
103189         assert( pOrTerm->eOperator==WO_EQ );
103190         assert( pOrTerm->leftCursor==iCursor );
103191         assert( pOrTerm->u.leftColumn==iColumn );
103192         pDup = sqlcipher3ExprDup(db, pOrTerm->pExpr->pRight, 0);
103193         pList = sqlcipher3ExprListAppend(pWC->pParse, pList, pDup);
103194         pLeft = pOrTerm->pExpr->pLeft;
103195       }
103196       assert( pLeft!=0 );
103197       pDup = sqlcipher3ExprDup(db, pLeft, 0);
103198       pNew = sqlcipher3PExpr(pParse, TK_IN, pDup, 0, 0);
103199       if( pNew ){
103200         int idxNew;
103201         transferJoinMarkings(pNew, pExpr);
103202         assert( !ExprHasProperty(pNew, EP_xIsSelect) );
103203         pNew->x.pList = pList;
103204         idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
103205         testcase( idxNew==0 );
103206         exprAnalyze(pSrc, pWC, idxNew);
103207         pTerm = &pWC->a[idxTerm];
103208         pWC->a[idxNew].iParent = idxTerm;
103209         pTerm->nChild = 1;
103210       }else{
103211         sqlcipher3ExprListDelete(db, pList);
103212       }
103213       pTerm->eOperator = WO_NOOP;  /* case 1 trumps case 2 */
103214     }
103215   }
103216 }
103217 #endif /* !SQLCIPHER_OMIT_OR_OPTIMIZATION && !SQLCIPHER_OMIT_SUBQUERY */
103218
103219
103220 /*
103221 ** The input to this routine is an WhereTerm structure with only the
103222 ** "pExpr" field filled in.  The job of this routine is to analyze the
103223 ** subexpression and populate all the other fields of the WhereTerm
103224 ** structure.
103225 **
103226 ** If the expression is of the form "<expr> <op> X" it gets commuted
103227 ** to the standard form of "X <op> <expr>".
103228 **
103229 ** If the expression is of the form "X <op> Y" where both X and Y are
103230 ** columns, then the original expression is unchanged and a new virtual
103231 ** term of the form "Y <op> X" is added to the WHERE clause and
103232 ** analyzed separately.  The original term is marked with TERM_COPIED
103233 ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
103234 ** needs to be freed with the WhereClause) and TERM_VIRTUAL (because it
103235 ** is a commuted copy of a prior term.)  The original term has nChild=1
103236 ** and the copy has idxParent set to the index of the original term.
103237 */
103238 static void exprAnalyze(
103239   SrcList *pSrc,            /* the FROM clause */
103240   WhereClause *pWC,         /* the WHERE clause */
103241   int idxTerm               /* Index of the term to be analyzed */
103242 ){
103243   WhereTerm *pTerm;                /* The term to be analyzed */
103244   WhereMaskSet *pMaskSet;          /* Set of table index masks */
103245   Expr *pExpr;                     /* The expression to be analyzed */
103246   Bitmask prereqLeft;              /* Prerequesites of the pExpr->pLeft */
103247   Bitmask prereqAll;               /* Prerequesites of pExpr */
103248   Bitmask extraRight = 0;          /* Extra dependencies on LEFT JOIN */
103249   Expr *pStr1 = 0;                 /* RHS of LIKE/GLOB operator */
103250   int isComplete = 0;              /* RHS of LIKE/GLOB ends with wildcard */
103251   int noCase = 0;                  /* LIKE/GLOB distinguishes case */
103252   int op;                          /* Top-level operator.  pExpr->op */
103253   Parse *pParse = pWC->pParse;     /* Parsing context */
103254   sqlcipher3 *db = pParse->db;        /* Database connection */
103255
103256   if( db->mallocFailed ){
103257     return;
103258   }
103259   pTerm = &pWC->a[idxTerm];
103260   pMaskSet = pWC->pMaskSet;
103261   pExpr = pTerm->pExpr;
103262   prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
103263   op = pExpr->op;
103264   if( op==TK_IN ){
103265     assert( pExpr->pRight==0 );
103266     if( ExprHasProperty(pExpr, EP_xIsSelect) ){
103267       pTerm->prereqRight = exprSelectTableUsage(pMaskSet, pExpr->x.pSelect);
103268     }else{
103269       pTerm->prereqRight = exprListTableUsage(pMaskSet, pExpr->x.pList);
103270     }
103271   }else if( op==TK_ISNULL ){
103272     pTerm->prereqRight = 0;
103273   }else{
103274     pTerm->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight);
103275   }
103276   prereqAll = exprTableUsage(pMaskSet, pExpr);
103277   if( ExprHasProperty(pExpr, EP_FromJoin) ){
103278     Bitmask x = getMask(pMaskSet, pExpr->iRightJoinTable);
103279     prereqAll |= x;
103280     extraRight = x-1;  /* ON clause terms may not be used with an index
103281                        ** on left table of a LEFT JOIN.  Ticket #3015 */
103282   }
103283   pTerm->prereqAll = prereqAll;
103284   pTerm->leftCursor = -1;
103285   pTerm->iParent = -1;
103286   pTerm->eOperator = 0;
103287   if( allowedOp(op) && (pTerm->prereqRight & prereqLeft)==0 ){
103288     Expr *pLeft = pExpr->pLeft;
103289     Expr *pRight = pExpr->pRight;
103290     if( pLeft->op==TK_COLUMN ){
103291       pTerm->leftCursor = pLeft->iTable;
103292       pTerm->u.leftColumn = pLeft->iColumn;
103293       pTerm->eOperator = operatorMask(op);
103294     }
103295     if( pRight && pRight->op==TK_COLUMN ){
103296       WhereTerm *pNew;
103297       Expr *pDup;
103298       if( pTerm->leftCursor>=0 ){
103299         int idxNew;
103300         pDup = sqlcipher3ExprDup(db, pExpr, 0);
103301         if( db->mallocFailed ){
103302           sqlcipher3ExprDelete(db, pDup);
103303           return;
103304         }
103305         idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC);
103306         if( idxNew==0 ) return;
103307         pNew = &pWC->a[idxNew];
103308         pNew->iParent = idxTerm;
103309         pTerm = &pWC->a[idxTerm];
103310         pTerm->nChild = 1;
103311         pTerm->wtFlags |= TERM_COPIED;
103312       }else{
103313         pDup = pExpr;
103314         pNew = pTerm;
103315       }
103316       exprCommute(pParse, pDup);
103317       pLeft = pDup->pLeft;
103318       pNew->leftCursor = pLeft->iTable;
103319       pNew->u.leftColumn = pLeft->iColumn;
103320       testcase( (prereqLeft | extraRight) != prereqLeft );
103321       pNew->prereqRight = prereqLeft | extraRight;
103322       pNew->prereqAll = prereqAll;
103323       pNew->eOperator = operatorMask(pDup->op);
103324     }
103325   }
103326
103327 #ifndef SQLCIPHER_OMIT_BETWEEN_OPTIMIZATION
103328   /* If a term is the BETWEEN operator, create two new virtual terms
103329   ** that define the range that the BETWEEN implements.  For example:
103330   **
103331   **      a BETWEEN b AND c
103332   **
103333   ** is converted into:
103334   **
103335   **      (a BETWEEN b AND c) AND (a>=b) AND (a<=c)
103336   **
103337   ** The two new terms are added onto the end of the WhereClause object.
103338   ** The new terms are "dynamic" and are children of the original BETWEEN
103339   ** term.  That means that if the BETWEEN term is coded, the children are
103340   ** skipped.  Or, if the children are satisfied by an index, the original
103341   ** BETWEEN term is skipped.
103342   */
103343   else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
103344     ExprList *pList = pExpr->x.pList;
103345     int i;
103346     static const u8 ops[] = {TK_GE, TK_LE};
103347     assert( pList!=0 );
103348     assert( pList->nExpr==2 );
103349     for(i=0; i<2; i++){
103350       Expr *pNewExpr;
103351       int idxNew;
103352       pNewExpr = sqlcipher3PExpr(pParse, ops[i], 
103353                              sqlcipher3ExprDup(db, pExpr->pLeft, 0),
103354                              sqlcipher3ExprDup(db, pList->a[i].pExpr, 0), 0);
103355       idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
103356       testcase( idxNew==0 );
103357       exprAnalyze(pSrc, pWC, idxNew);
103358       pTerm = &pWC->a[idxTerm];
103359       pWC->a[idxNew].iParent = idxTerm;
103360     }
103361     pTerm->nChild = 2;
103362   }
103363 #endif /* SQLCIPHER_OMIT_BETWEEN_OPTIMIZATION */
103364
103365 #if !defined(SQLCIPHER_OMIT_OR_OPTIMIZATION) && !defined(SQLCIPHER_OMIT_SUBQUERY)
103366   /* Analyze a term that is composed of two or more subterms connected by
103367   ** an OR operator.
103368   */
103369   else if( pExpr->op==TK_OR ){
103370     assert( pWC->op==TK_AND );
103371     exprAnalyzeOrTerm(pSrc, pWC, idxTerm);
103372     pTerm = &pWC->a[idxTerm];
103373   }
103374 #endif /* SQLCIPHER_OMIT_OR_OPTIMIZATION */
103375
103376 #ifndef SQLCIPHER_OMIT_LIKE_OPTIMIZATION
103377   /* Add constraints to reduce the search space on a LIKE or GLOB
103378   ** operator.
103379   **
103380   ** A like pattern of the form "x LIKE 'abc%'" is changed into constraints
103381   **
103382   **          x>='abc' AND x<'abd' AND x LIKE 'abc%'
103383   **
103384   ** The last character of the prefix "abc" is incremented to form the
103385   ** termination condition "abd".
103386   */
103387   if( pWC->op==TK_AND 
103388    && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
103389   ){
103390     Expr *pLeft;       /* LHS of LIKE/GLOB operator */
103391     Expr *pStr2;       /* Copy of pStr1 - RHS of LIKE/GLOB operator */
103392     Expr *pNewExpr1;
103393     Expr *pNewExpr2;
103394     int idxNew1;
103395     int idxNew2;
103396     CollSeq *pColl;    /* Collating sequence to use */
103397
103398     pLeft = pExpr->x.pList->a[1].pExpr;
103399     pStr2 = sqlcipher3ExprDup(db, pStr1, 0);
103400     if( !db->mallocFailed ){
103401       u8 c, *pC;       /* Last character before the first wildcard */
103402       pC = (u8*)&pStr2->u.zToken[sqlcipher3Strlen30(pStr2->u.zToken)-1];
103403       c = *pC;
103404       if( noCase ){
103405         /* The point is to increment the last character before the first
103406         ** wildcard.  But if we increment '@', that will push it into the
103407         ** alphabetic range where case conversions will mess up the 
103408         ** inequality.  To avoid this, make sure to also run the full
103409         ** LIKE on all candidate expressions by clearing the isComplete flag
103410         */
103411         if( c=='A'-1 ) isComplete = 0;   /* EV: R-64339-08207 */
103412
103413
103414         c = sqlcipher3UpperToLower[c];
103415       }
103416       *pC = c + 1;
103417     }
103418     pColl = sqlcipher3FindCollSeq(db, SQLCIPHER_UTF8, noCase ? "NOCASE" : "BINARY",0);
103419     pNewExpr1 = sqlcipher3PExpr(pParse, TK_GE, 
103420                      sqlcipher3ExprSetColl(sqlcipher3ExprDup(db,pLeft,0), pColl),
103421                      pStr1, 0);
103422     idxNew1 = whereClauseInsert(pWC, pNewExpr1, TERM_VIRTUAL|TERM_DYNAMIC);
103423     testcase( idxNew1==0 );
103424     exprAnalyze(pSrc, pWC, idxNew1);
103425     pNewExpr2 = sqlcipher3PExpr(pParse, TK_LT,
103426                      sqlcipher3ExprSetColl(sqlcipher3ExprDup(db,pLeft,0), pColl),
103427                      pStr2, 0);
103428     idxNew2 = whereClauseInsert(pWC, pNewExpr2, TERM_VIRTUAL|TERM_DYNAMIC);
103429     testcase( idxNew2==0 );
103430     exprAnalyze(pSrc, pWC, idxNew2);
103431     pTerm = &pWC->a[idxTerm];
103432     if( isComplete ){
103433       pWC->a[idxNew1].iParent = idxTerm;
103434       pWC->a[idxNew2].iParent = idxTerm;
103435       pTerm->nChild = 2;
103436     }
103437   }
103438 #endif /* SQLCIPHER_OMIT_LIKE_OPTIMIZATION */
103439
103440 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
103441   /* Add a WO_MATCH auxiliary term to the constraint set if the
103442   ** current expression is of the form:  column MATCH expr.
103443   ** This information is used by the xBestIndex methods of
103444   ** virtual tables.  The native query optimizer does not attempt
103445   ** to do anything with MATCH functions.
103446   */
103447   if( isMatchOfColumn(pExpr) ){
103448     int idxNew;
103449     Expr *pRight, *pLeft;
103450     WhereTerm *pNewTerm;
103451     Bitmask prereqColumn, prereqExpr;
103452
103453     pRight = pExpr->x.pList->a[0].pExpr;
103454     pLeft = pExpr->x.pList->a[1].pExpr;
103455     prereqExpr = exprTableUsage(pMaskSet, pRight);
103456     prereqColumn = exprTableUsage(pMaskSet, pLeft);
103457     if( (prereqExpr & prereqColumn)==0 ){
103458       Expr *pNewExpr;
103459       pNewExpr = sqlcipher3PExpr(pParse, TK_MATCH, 
103460                               0, sqlcipher3ExprDup(db, pRight, 0), 0);
103461       idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
103462       testcase( idxNew==0 );
103463       pNewTerm = &pWC->a[idxNew];
103464       pNewTerm->prereqRight = prereqExpr;
103465       pNewTerm->leftCursor = pLeft->iTable;
103466       pNewTerm->u.leftColumn = pLeft->iColumn;
103467       pNewTerm->eOperator = WO_MATCH;
103468       pNewTerm->iParent = idxTerm;
103469       pTerm = &pWC->a[idxTerm];
103470       pTerm->nChild = 1;
103471       pTerm->wtFlags |= TERM_COPIED;
103472       pNewTerm->prereqAll = pTerm->prereqAll;
103473     }
103474   }
103475 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
103476
103477 #ifdef SQLCIPHER_ENABLE_STAT3
103478   /* When sqlcipher_stat3 histogram data is available an operator of the
103479   ** form "x IS NOT NULL" can sometimes be evaluated more efficiently
103480   ** as "x>NULL" if x is not an INTEGER PRIMARY KEY.  So construct a
103481   ** virtual term of that form.
103482   **
103483   ** Note that the virtual term must be tagged with TERM_VNULL.  This
103484   ** TERM_VNULL tag will suppress the not-null check at the beginning
103485   ** of the loop.  Without the TERM_VNULL flag, the not-null check at
103486   ** the start of the loop will prevent any results from being returned.
103487   */
103488   if( pExpr->op==TK_NOTNULL
103489    && pExpr->pLeft->op==TK_COLUMN
103490    && pExpr->pLeft->iColumn>=0
103491   ){
103492     Expr *pNewExpr;
103493     Expr *pLeft = pExpr->pLeft;
103494     int idxNew;
103495     WhereTerm *pNewTerm;
103496
103497     pNewExpr = sqlcipher3PExpr(pParse, TK_GT,
103498                             sqlcipher3ExprDup(db, pLeft, 0),
103499                             sqlcipher3PExpr(pParse, TK_NULL, 0, 0, 0), 0);
103500
103501     idxNew = whereClauseInsert(pWC, pNewExpr,
103502                               TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL);
103503     if( idxNew ){
103504       pNewTerm = &pWC->a[idxNew];
103505       pNewTerm->prereqRight = 0;
103506       pNewTerm->leftCursor = pLeft->iTable;
103507       pNewTerm->u.leftColumn = pLeft->iColumn;
103508       pNewTerm->eOperator = WO_GT;
103509       pNewTerm->iParent = idxTerm;
103510       pTerm = &pWC->a[idxTerm];
103511       pTerm->nChild = 1;
103512       pTerm->wtFlags |= TERM_COPIED;
103513       pNewTerm->prereqAll = pTerm->prereqAll;
103514     }
103515   }
103516 #endif /* SQLCIPHER_ENABLE_STAT */
103517
103518   /* Prevent ON clause terms of a LEFT JOIN from being used to drive
103519   ** an index for tables to the left of the join.
103520   */
103521   pTerm->prereqRight |= extraRight;
103522 }
103523
103524 /*
103525 ** Return TRUE if any of the expressions in pList->a[iFirst...] contain
103526 ** a reference to any table other than the iBase table.
103527 */
103528 static int referencesOtherTables(
103529   ExprList *pList,          /* Search expressions in ths list */
103530   WhereMaskSet *pMaskSet,   /* Mapping from tables to bitmaps */
103531   int iFirst,               /* Be searching with the iFirst-th expression */
103532   int iBase                 /* Ignore references to this table */
103533 ){
103534   Bitmask allowed = ~getMask(pMaskSet, iBase);
103535   while( iFirst<pList->nExpr ){
103536     if( (exprTableUsage(pMaskSet, pList->a[iFirst++].pExpr)&allowed)!=0 ){
103537       return 1;
103538     }
103539   }
103540   return 0;
103541 }
103542
103543 /*
103544 ** This function searches the expression list passed as the second argument
103545 ** for an expression of type TK_COLUMN that refers to the same column and
103546 ** uses the same collation sequence as the iCol'th column of index pIdx.
103547 ** Argument iBase is the cursor number used for the table that pIdx refers
103548 ** to.
103549 **
103550 ** If such an expression is found, its index in pList->a[] is returned. If
103551 ** no expression is found, -1 is returned.
103552 */
103553 static int findIndexCol(
103554   Parse *pParse,                  /* Parse context */
103555   ExprList *pList,                /* Expression list to search */
103556   int iBase,                      /* Cursor for table associated with pIdx */
103557   Index *pIdx,                    /* Index to match column of */
103558   int iCol                        /* Column of index to match */
103559 ){
103560   int i;
103561   const char *zColl = pIdx->azColl[iCol];
103562
103563   for(i=0; i<pList->nExpr; i++){
103564     Expr *p = pList->a[i].pExpr;
103565     if( p->op==TK_COLUMN
103566      && p->iColumn==pIdx->aiColumn[iCol]
103567      && p->iTable==iBase
103568     ){
103569       CollSeq *pColl = sqlcipher3ExprCollSeq(pParse, p);
103570       if( ALWAYS(pColl) && 0==sqlcipher3StrICmp(pColl->zName, zColl) ){
103571         return i;
103572       }
103573     }
103574   }
103575
103576   return -1;
103577 }
103578
103579 /*
103580 ** This routine determines if pIdx can be used to assist in processing a
103581 ** DISTINCT qualifier. In other words, it tests whether or not using this
103582 ** index for the outer loop guarantees that rows with equal values for
103583 ** all expressions in the pDistinct list are delivered grouped together.
103584 **
103585 ** For example, the query 
103586 **
103587 **   SELECT DISTINCT a, b, c FROM tbl WHERE a = ?
103588 **
103589 ** can benefit from any index on columns "b" and "c".
103590 */
103591 static int isDistinctIndex(
103592   Parse *pParse,                  /* Parsing context */
103593   WhereClause *pWC,               /* The WHERE clause */
103594   Index *pIdx,                    /* The index being considered */
103595   int base,                       /* Cursor number for the table pIdx is on */
103596   ExprList *pDistinct,            /* The DISTINCT expressions */
103597   int nEqCol                      /* Number of index columns with == */
103598 ){
103599   Bitmask mask = 0;               /* Mask of unaccounted for pDistinct exprs */
103600   int i;                          /* Iterator variable */
103601
103602   if( pIdx->zName==0 || pDistinct==0 || pDistinct->nExpr>=BMS ) return 0;
103603   testcase( pDistinct->nExpr==BMS-1 );
103604
103605   /* Loop through all the expressions in the distinct list. If any of them
103606   ** are not simple column references, return early. Otherwise, test if the
103607   ** WHERE clause contains a "col=X" clause. If it does, the expression
103608   ** can be ignored. If it does not, and the column does not belong to the
103609   ** same table as index pIdx, return early. Finally, if there is no
103610   ** matching "col=X" expression and the column is on the same table as pIdx,
103611   ** set the corresponding bit in variable mask.
103612   */
103613   for(i=0; i<pDistinct->nExpr; i++){
103614     WhereTerm *pTerm;
103615     Expr *p = pDistinct->a[i].pExpr;
103616     if( p->op!=TK_COLUMN ) return 0;
103617     pTerm = findTerm(pWC, p->iTable, p->iColumn, ~(Bitmask)0, WO_EQ, 0);
103618     if( pTerm ){
103619       Expr *pX = pTerm->pExpr;
103620       CollSeq *p1 = sqlcipher3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
103621       CollSeq *p2 = sqlcipher3ExprCollSeq(pParse, p);
103622       if( p1==p2 ) continue;
103623     }
103624     if( p->iTable!=base ) return 0;
103625     mask |= (((Bitmask)1) << i);
103626   }
103627
103628   for(i=nEqCol; mask && i<pIdx->nColumn; i++){
103629     int iExpr = findIndexCol(pParse, pDistinct, base, pIdx, i);
103630     if( iExpr<0 ) break;
103631     mask &= ~(((Bitmask)1) << iExpr);
103632   }
103633
103634   return (mask==0);
103635 }
103636
103637
103638 /*
103639 ** Return true if the DISTINCT expression-list passed as the third argument
103640 ** is redundant. A DISTINCT list is redundant if the database contains a
103641 ** UNIQUE index that guarantees that the result of the query will be distinct
103642 ** anyway.
103643 */
103644 static int isDistinctRedundant(
103645   Parse *pParse,
103646   SrcList *pTabList,
103647   WhereClause *pWC,
103648   ExprList *pDistinct
103649 ){
103650   Table *pTab;
103651   Index *pIdx;
103652   int i;                          
103653   int iBase;
103654
103655   /* If there is more than one table or sub-select in the FROM clause of
103656   ** this query, then it will not be possible to show that the DISTINCT 
103657   ** clause is redundant. */
103658   if( pTabList->nSrc!=1 ) return 0;
103659   iBase = pTabList->a[0].iCursor;
103660   pTab = pTabList->a[0].pTab;
103661
103662   /* If any of the expressions is an IPK column on table iBase, then return 
103663   ** true. Note: The (p->iTable==iBase) part of this test may be false if the
103664   ** current SELECT is a correlated sub-query.
103665   */
103666   for(i=0; i<pDistinct->nExpr; i++){
103667     Expr *p = pDistinct->a[i].pExpr;
103668     if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1;
103669   }
103670
103671   /* Loop through all indices on the table, checking each to see if it makes
103672   ** the DISTINCT qualifier redundant. It does so if:
103673   **
103674   **   1. The index is itself UNIQUE, and
103675   **
103676   **   2. All of the columns in the index are either part of the pDistinct
103677   **      list, or else the WHERE clause contains a term of the form "col=X",
103678   **      where X is a constant value. The collation sequences of the
103679   **      comparison and select-list expressions must match those of the index.
103680   */
103681   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
103682     if( pIdx->onError==OE_None ) continue;
103683     for(i=0; i<pIdx->nColumn; i++){
103684       int iCol = pIdx->aiColumn[i];
103685       if( 0==findTerm(pWC, iBase, iCol, ~(Bitmask)0, WO_EQ, pIdx) 
103686        && 0>findIndexCol(pParse, pDistinct, iBase, pIdx, i)
103687       ){
103688         break;
103689       }
103690     }
103691     if( i==pIdx->nColumn ){
103692       /* This index implies that the DISTINCT qualifier is redundant. */
103693       return 1;
103694     }
103695   }
103696
103697   return 0;
103698 }
103699
103700 /*
103701 ** This routine decides if pIdx can be used to satisfy the ORDER BY
103702 ** clause.  If it can, it returns 1.  If pIdx cannot satisfy the
103703 ** ORDER BY clause, this routine returns 0.
103704 **
103705 ** pOrderBy is an ORDER BY clause from a SELECT statement.  pTab is the
103706 ** left-most table in the FROM clause of that same SELECT statement and
103707 ** the table has a cursor number of "base".  pIdx is an index on pTab.
103708 **
103709 ** nEqCol is the number of columns of pIdx that are used as equality
103710 ** constraints.  Any of these columns may be missing from the ORDER BY
103711 ** clause and the match can still be a success.
103712 **
103713 ** All terms of the ORDER BY that match against the index must be either
103714 ** ASC or DESC.  (Terms of the ORDER BY clause past the end of a UNIQUE
103715 ** index do not need to satisfy this constraint.)  The *pbRev value is
103716 ** set to 1 if the ORDER BY clause is all DESC and it is set to 0 if
103717 ** the ORDER BY clause is all ASC.
103718 */
103719 static int isSortingIndex(
103720   Parse *pParse,          /* Parsing context */
103721   WhereMaskSet *pMaskSet, /* Mapping from table cursor numbers to bitmaps */
103722   Index *pIdx,            /* The index we are testing */
103723   int base,               /* Cursor number for the table to be sorted */
103724   ExprList *pOrderBy,     /* The ORDER BY clause */
103725   int nEqCol,             /* Number of index columns with == constraints */
103726   int wsFlags,            /* Index usages flags */
103727   int *pbRev              /* Set to 1 if ORDER BY is DESC */
103728 ){
103729   int i, j;                       /* Loop counters */
103730   int sortOrder = 0;              /* XOR of index and ORDER BY sort direction */
103731   int nTerm;                      /* Number of ORDER BY terms */
103732   struct ExprList_item *pTerm;    /* A term of the ORDER BY clause */
103733   sqlcipher3 *db = pParse->db;
103734
103735   if( !pOrderBy ) return 0;
103736   if( wsFlags & WHERE_COLUMN_IN ) return 0;
103737   if( pIdx->bUnordered ) return 0;
103738
103739   nTerm = pOrderBy->nExpr;
103740   assert( nTerm>0 );
103741
103742   /* Argument pIdx must either point to a 'real' named index structure, 
103743   ** or an index structure allocated on the stack by bestBtreeIndex() to
103744   ** represent the rowid index that is part of every table.  */
103745   assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) );
103746
103747   /* Match terms of the ORDER BY clause against columns of
103748   ** the index.
103749   **
103750   ** Note that indices have pIdx->nColumn regular columns plus
103751   ** one additional column containing the rowid.  The rowid column
103752   ** of the index is also allowed to match against the ORDER BY
103753   ** clause.
103754   */
103755   for(i=j=0, pTerm=pOrderBy->a; j<nTerm && i<=pIdx->nColumn; i++){
103756     Expr *pExpr;       /* The expression of the ORDER BY pTerm */
103757     CollSeq *pColl;    /* The collating sequence of pExpr */
103758     int termSortOrder; /* Sort order for this term */
103759     int iColumn;       /* The i-th column of the index.  -1 for rowid */
103760     int iSortOrder;    /* 1 for DESC, 0 for ASC on the i-th index term */
103761     const char *zColl; /* Name of the collating sequence for i-th index term */
103762
103763     pExpr = pTerm->pExpr;
103764     if( pExpr->op!=TK_COLUMN || pExpr->iTable!=base ){
103765       /* Can not use an index sort on anything that is not a column in the
103766       ** left-most table of the FROM clause */
103767       break;
103768     }
103769     pColl = sqlcipher3ExprCollSeq(pParse, pExpr);
103770     if( !pColl ){
103771       pColl = db->pDfltColl;
103772     }
103773     if( pIdx->zName && i<pIdx->nColumn ){
103774       iColumn = pIdx->aiColumn[i];
103775       if( iColumn==pIdx->pTable->iPKey ){
103776         iColumn = -1;
103777       }
103778       iSortOrder = pIdx->aSortOrder[i];
103779       zColl = pIdx->azColl[i];
103780     }else{
103781       iColumn = -1;
103782       iSortOrder = 0;
103783       zColl = pColl->zName;
103784     }
103785     if( pExpr->iColumn!=iColumn || sqlcipher3StrICmp(pColl->zName, zColl) ){
103786       /* Term j of the ORDER BY clause does not match column i of the index */
103787       if( i<nEqCol ){
103788         /* If an index column that is constrained by == fails to match an
103789         ** ORDER BY term, that is OK.  Just ignore that column of the index
103790         */
103791         continue;
103792       }else if( i==pIdx->nColumn ){
103793         /* Index column i is the rowid.  All other terms match. */
103794         break;
103795       }else{
103796         /* If an index column fails to match and is not constrained by ==
103797         ** then the index cannot satisfy the ORDER BY constraint.
103798         */
103799         return 0;
103800       }
103801     }
103802     assert( pIdx->aSortOrder!=0 || iColumn==-1 );
103803     assert( pTerm->sortOrder==0 || pTerm->sortOrder==1 );
103804     assert( iSortOrder==0 || iSortOrder==1 );
103805     termSortOrder = iSortOrder ^ pTerm->sortOrder;
103806     if( i>nEqCol ){
103807       if( termSortOrder!=sortOrder ){
103808         /* Indices can only be used if all ORDER BY terms past the
103809         ** equality constraints are all either DESC or ASC. */
103810         return 0;
103811       }
103812     }else{
103813       sortOrder = termSortOrder;
103814     }
103815     j++;
103816     pTerm++;
103817     if( iColumn<0 && !referencesOtherTables(pOrderBy, pMaskSet, j, base) ){
103818       /* If the indexed column is the primary key and everything matches
103819       ** so far and none of the ORDER BY terms to the right reference other
103820       ** tables in the join, then we are assured that the index can be used 
103821       ** to sort because the primary key is unique and so none of the other
103822       ** columns will make any difference
103823       */
103824       j = nTerm;
103825     }
103826   }
103827
103828   *pbRev = sortOrder!=0;
103829   if( j>=nTerm ){
103830     /* All terms of the ORDER BY clause are covered by this index so
103831     ** this index can be used for sorting. */
103832     return 1;
103833   }
103834   if( pIdx->onError!=OE_None && i==pIdx->nColumn
103835       && (wsFlags & WHERE_COLUMN_NULL)==0
103836       && !referencesOtherTables(pOrderBy, pMaskSet, j, base) ){
103837     /* All terms of this index match some prefix of the ORDER BY clause
103838     ** and the index is UNIQUE and no terms on the tail of the ORDER BY
103839     ** clause reference other tables in a join.  If this is all true then
103840     ** the order by clause is superfluous.  Not that if the matching
103841     ** condition is IS NULL then the result is not necessarily unique
103842     ** even on a UNIQUE index, so disallow those cases. */
103843     return 1;
103844   }
103845   return 0;
103846 }
103847
103848 /*
103849 ** Prepare a crude estimate of the logarithm of the input value.
103850 ** The results need not be exact.  This is only used for estimating
103851 ** the total cost of performing operations with O(logN) or O(NlogN)
103852 ** complexity.  Because N is just a guess, it is no great tragedy if
103853 ** logN is a little off.
103854 */
103855 static double estLog(double N){
103856   double logN = 1;
103857   double x = 10;
103858   while( N>x ){
103859     logN += 1;
103860     x *= 10;
103861   }
103862   return logN;
103863 }
103864
103865 /*
103866 ** Two routines for printing the content of an sqlcipher3_index_info
103867 ** structure.  Used for testing and debugging only.  If neither
103868 ** SQLCIPHER_TEST or SQLCIPHER_DEBUG are defined, then these routines
103869 ** are no-ops.
103870 */
103871 #if !defined(SQLCIPHER_OMIT_VIRTUALTABLE) && defined(SQLCIPHER_DEBUG)
103872 static void TRACE_IDX_INPUTS(sqlcipher3_index_info *p){
103873   int i;
103874   if( !sqlcipher3WhereTrace ) return;
103875   for(i=0; i<p->nConstraint; i++){
103876     sqlcipher3DebugPrintf("  constraint[%d]: col=%d termid=%d op=%d usabled=%d\n",
103877        i,
103878        p->aConstraint[i].iColumn,
103879        p->aConstraint[i].iTermOffset,
103880        p->aConstraint[i].op,
103881        p->aConstraint[i].usable);
103882   }
103883   for(i=0; i<p->nOrderBy; i++){
103884     sqlcipher3DebugPrintf("  orderby[%d]: col=%d desc=%d\n",
103885        i,
103886        p->aOrderBy[i].iColumn,
103887        p->aOrderBy[i].desc);
103888   }
103889 }
103890 static void TRACE_IDX_OUTPUTS(sqlcipher3_index_info *p){
103891   int i;
103892   if( !sqlcipher3WhereTrace ) return;
103893   for(i=0; i<p->nConstraint; i++){
103894     sqlcipher3DebugPrintf("  usage[%d]: argvIdx=%d omit=%d\n",
103895        i,
103896        p->aConstraintUsage[i].argvIndex,
103897        p->aConstraintUsage[i].omit);
103898   }
103899   sqlcipher3DebugPrintf("  idxNum=%d\n", p->idxNum);
103900   sqlcipher3DebugPrintf("  idxStr=%s\n", p->idxStr);
103901   sqlcipher3DebugPrintf("  orderByConsumed=%d\n", p->orderByConsumed);
103902   sqlcipher3DebugPrintf("  estimatedCost=%g\n", p->estimatedCost);
103903 }
103904 #else
103905 #define TRACE_IDX_INPUTS(A)
103906 #define TRACE_IDX_OUTPUTS(A)
103907 #endif
103908
103909 /* 
103910 ** Required because bestIndex() is called by bestOrClauseIndex() 
103911 */
103912 static void bestIndex(
103913     Parse*, WhereClause*, struct SrcList_item*,
103914     Bitmask, Bitmask, ExprList*, WhereCost*);
103915
103916 /*
103917 ** This routine attempts to find an scanning strategy that can be used 
103918 ** to optimize an 'OR' expression that is part of a WHERE clause. 
103919 **
103920 ** The table associated with FROM clause term pSrc may be either a
103921 ** regular B-Tree table or a virtual table.
103922 */
103923 static void bestOrClauseIndex(
103924   Parse *pParse,              /* The parsing context */
103925   WhereClause *pWC,           /* The WHERE clause */
103926   struct SrcList_item *pSrc,  /* The FROM clause term to search */
103927   Bitmask notReady,           /* Mask of cursors not available for indexing */
103928   Bitmask notValid,           /* Cursors not available for any purpose */
103929   ExprList *pOrderBy,         /* The ORDER BY clause */
103930   WhereCost *pCost            /* Lowest cost query plan */
103931 ){
103932 #ifndef SQLCIPHER_OMIT_OR_OPTIMIZATION
103933   const int iCur = pSrc->iCursor;   /* The cursor of the table to be accessed */
103934   const Bitmask maskSrc = getMask(pWC->pMaskSet, iCur);  /* Bitmask for pSrc */
103935   WhereTerm * const pWCEnd = &pWC->a[pWC->nTerm];        /* End of pWC->a[] */
103936   WhereTerm *pTerm;                 /* A single term of the WHERE clause */
103937
103938   /* The OR-clause optimization is disallowed if the INDEXED BY or
103939   ** NOT INDEXED clauses are used or if the WHERE_AND_ONLY bit is set. */
103940   if( pSrc->notIndexed || pSrc->pIndex!=0 ){
103941     return;
103942   }
103943   if( pWC->wctrlFlags & WHERE_AND_ONLY ){
103944     return;
103945   }
103946
103947   /* Search the WHERE clause terms for a usable WO_OR term. */
103948   for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
103949     if( pTerm->eOperator==WO_OR 
103950      && ((pTerm->prereqAll & ~maskSrc) & notReady)==0
103951      && (pTerm->u.pOrInfo->indexable & maskSrc)!=0 
103952     ){
103953       WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
103954       WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm];
103955       WhereTerm *pOrTerm;
103956       int flags = WHERE_MULTI_OR;
103957       double rTotal = 0;
103958       double nRow = 0;
103959       Bitmask used = 0;
103960
103961       for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){
103962         WhereCost sTermCost;
103963         WHERETRACE(("... Multi-index OR testing for term %d of %d....\n", 
103964           (pOrTerm - pOrWC->a), (pTerm - pWC->a)
103965         ));
103966         if( pOrTerm->eOperator==WO_AND ){
103967           WhereClause *pAndWC = &pOrTerm->u.pAndInfo->wc;
103968           bestIndex(pParse, pAndWC, pSrc, notReady, notValid, 0, &sTermCost);
103969         }else if( pOrTerm->leftCursor==iCur ){
103970           WhereClause tempWC;
103971           tempWC.pParse = pWC->pParse;
103972           tempWC.pMaskSet = pWC->pMaskSet;
103973           tempWC.pOuter = pWC;
103974           tempWC.op = TK_AND;
103975           tempWC.a = pOrTerm;
103976           tempWC.wctrlFlags = 0;
103977           tempWC.nTerm = 1;
103978           bestIndex(pParse, &tempWC, pSrc, notReady, notValid, 0, &sTermCost);
103979         }else{
103980           continue;
103981         }
103982         rTotal += sTermCost.rCost;
103983         nRow += sTermCost.plan.nRow;
103984         used |= sTermCost.used;
103985         if( rTotal>=pCost->rCost ) break;
103986       }
103987
103988       /* If there is an ORDER BY clause, increase the scan cost to account 
103989       ** for the cost of the sort. */
103990       if( pOrderBy!=0 ){
103991         WHERETRACE(("... sorting increases OR cost %.9g to %.9g\n",
103992                     rTotal, rTotal+nRow*estLog(nRow)));
103993         rTotal += nRow*estLog(nRow);
103994       }
103995
103996       /* If the cost of scanning using this OR term for optimization is
103997       ** less than the current cost stored in pCost, replace the contents
103998       ** of pCost. */
103999       WHERETRACE(("... multi-index OR cost=%.9g nrow=%.9g\n", rTotal, nRow));
104000       if( rTotal<pCost->rCost ){
104001         pCost->rCost = rTotal;
104002         pCost->used = used;
104003         pCost->plan.nRow = nRow;
104004         pCost->plan.wsFlags = flags;
104005         pCost->plan.u.pTerm = pTerm;
104006       }
104007     }
104008   }
104009 #endif /* SQLCIPHER_OMIT_OR_OPTIMIZATION */
104010 }
104011
104012 #ifndef SQLCIPHER_OMIT_AUTOMATIC_INDEX
104013 /*
104014 ** Return TRUE if the WHERE clause term pTerm is of a form where it
104015 ** could be used with an index to access pSrc, assuming an appropriate
104016 ** index existed.
104017 */
104018 static int termCanDriveIndex(
104019   WhereTerm *pTerm,              /* WHERE clause term to check */
104020   struct SrcList_item *pSrc,     /* Table we are trying to access */
104021   Bitmask notReady               /* Tables in outer loops of the join */
104022 ){
104023   char aff;
104024   if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
104025   if( pTerm->eOperator!=WO_EQ ) return 0;
104026   if( (pTerm->prereqRight & notReady)!=0 ) return 0;
104027   aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
104028   if( !sqlcipher3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
104029   return 1;
104030 }
104031 #endif
104032
104033 #ifndef SQLCIPHER_OMIT_AUTOMATIC_INDEX
104034 /*
104035 ** If the query plan for pSrc specified in pCost is a full table scan
104036 ** and indexing is allows (if there is no NOT INDEXED clause) and it
104037 ** possible to construct a transient index that would perform better
104038 ** than a full table scan even when the cost of constructing the index
104039 ** is taken into account, then alter the query plan to use the
104040 ** transient index.
104041 */
104042 static void bestAutomaticIndex(
104043   Parse *pParse,              /* The parsing context */
104044   WhereClause *pWC,           /* The WHERE clause */
104045   struct SrcList_item *pSrc,  /* The FROM clause term to search */
104046   Bitmask notReady,           /* Mask of cursors that are not available */
104047   WhereCost *pCost            /* Lowest cost query plan */
104048 ){
104049   double nTableRow;           /* Rows in the input table */
104050   double logN;                /* log(nTableRow) */
104051   double costTempIdx;         /* per-query cost of the transient index */
104052   WhereTerm *pTerm;           /* A single term of the WHERE clause */
104053   WhereTerm *pWCEnd;          /* End of pWC->a[] */
104054   Table *pTable;              /* Table tht might be indexed */
104055
104056   if( pParse->nQueryLoop<=(double)1 ){
104057     /* There is no point in building an automatic index for a single scan */
104058     return;
104059   }
104060   if( (pParse->db->flags & SQLCIPHER_AutoIndex)==0 ){
104061     /* Automatic indices are disabled at run-time */
104062     return;
104063   }
104064   if( (pCost->plan.wsFlags & WHERE_NOT_FULLSCAN)!=0 ){
104065     /* We already have some kind of index in use for this query. */
104066     return;
104067   }
104068   if( pSrc->notIndexed ){
104069     /* The NOT INDEXED clause appears in the SQL. */
104070     return;
104071   }
104072   if( pSrc->isCorrelated ){
104073     /* The source is a correlated sub-query. No point in indexing it. */
104074     return;
104075   }
104076
104077   assert( pParse->nQueryLoop >= (double)1 );
104078   pTable = pSrc->pTab;
104079   nTableRow = pTable->nRowEst;
104080   logN = estLog(nTableRow);
104081   costTempIdx = 2*logN*(nTableRow/pParse->nQueryLoop + 1);
104082   if( costTempIdx>=pCost->rCost ){
104083     /* The cost of creating the transient table would be greater than
104084     ** doing the full table scan */
104085     return;
104086   }
104087
104088   /* Search for any equality comparison term */
104089   pWCEnd = &pWC->a[pWC->nTerm];
104090   for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104091     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
104092       WHERETRACE(("auto-index reduces cost from %.1f to %.1f\n",
104093                     pCost->rCost, costTempIdx));
104094       pCost->rCost = costTempIdx;
104095       pCost->plan.nRow = logN + 1;
104096       pCost->plan.wsFlags = WHERE_TEMP_INDEX;
104097       pCost->used = pTerm->prereqRight;
104098       break;
104099     }
104100   }
104101 }
104102 #else
104103 # define bestAutomaticIndex(A,B,C,D,E)  /* no-op */
104104 #endif /* SQLCIPHER_OMIT_AUTOMATIC_INDEX */
104105
104106
104107 #ifndef SQLCIPHER_OMIT_AUTOMATIC_INDEX
104108 /*
104109 ** Generate code to construct the Index object for an automatic index
104110 ** and to set up the WhereLevel object pLevel so that the code generator
104111 ** makes use of the automatic index.
104112 */
104113 static void constructAutomaticIndex(
104114   Parse *pParse,              /* The parsing context */
104115   WhereClause *pWC,           /* The WHERE clause */
104116   struct SrcList_item *pSrc,  /* The FROM clause term to get the next index */
104117   Bitmask notReady,           /* Mask of cursors that are not available */
104118   WhereLevel *pLevel          /* Write new index here */
104119 ){
104120   int nColumn;                /* Number of columns in the constructed index */
104121   WhereTerm *pTerm;           /* A single term of the WHERE clause */
104122   WhereTerm *pWCEnd;          /* End of pWC->a[] */
104123   int nByte;                  /* Byte of memory needed for pIdx */
104124   Index *pIdx;                /* Object describing the transient index */
104125   Vdbe *v;                    /* Prepared statement under construction */
104126   int regIsInit;              /* Register set by initialization */
104127   int addrInit;               /* Address of the initialization bypass jump */
104128   Table *pTable;              /* The table being indexed */
104129   KeyInfo *pKeyinfo;          /* Key information for the index */   
104130   int addrTop;                /* Top of the index fill loop */
104131   int regRecord;              /* Register holding an index record */
104132   int n;                      /* Column counter */
104133   int i;                      /* Loop counter */
104134   int mxBitCol;               /* Maximum column in pSrc->colUsed */
104135   CollSeq *pColl;             /* Collating sequence to on a column */
104136   Bitmask idxCols;            /* Bitmap of columns used for indexing */
104137   Bitmask extraCols;          /* Bitmap of additional columns */
104138
104139   /* Generate code to skip over the creation and initialization of the
104140   ** transient index on 2nd and subsequent iterations of the loop. */
104141   v = pParse->pVdbe;
104142   assert( v!=0 );
104143   regIsInit = ++pParse->nMem;
104144   addrInit = sqlcipher3VdbeAddOp1(v, OP_Once, regIsInit);
104145
104146   /* Count the number of columns that will be added to the index
104147   ** and used to match WHERE clause constraints */
104148   nColumn = 0;
104149   pTable = pSrc->pTab;
104150   pWCEnd = &pWC->a[pWC->nTerm];
104151   idxCols = 0;
104152   for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104153     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
104154       int iCol = pTerm->u.leftColumn;
104155       Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol;
104156       testcase( iCol==BMS );
104157       testcase( iCol==BMS-1 );
104158       if( (idxCols & cMask)==0 ){
104159         nColumn++;
104160         idxCols |= cMask;
104161       }
104162     }
104163   }
104164   assert( nColumn>0 );
104165   pLevel->plan.nEq = nColumn;
104166
104167   /* Count the number of additional columns needed to create a
104168   ** covering index.  A "covering index" is an index that contains all
104169   ** columns that are needed by the query.  With a covering index, the
104170   ** original table never needs to be accessed.  Automatic indices must
104171   ** be a covering index because the index will not be updated if the
104172   ** original table changes and the index and table cannot both be used
104173   ** if they go out of sync.
104174   */
104175   extraCols = pSrc->colUsed & (~idxCols | (((Bitmask)1)<<(BMS-1)));
104176   mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol;
104177   testcase( pTable->nCol==BMS-1 );
104178   testcase( pTable->nCol==BMS-2 );
104179   for(i=0; i<mxBitCol; i++){
104180     if( extraCols & (((Bitmask)1)<<i) ) nColumn++;
104181   }
104182   if( pSrc->colUsed & (((Bitmask)1)<<(BMS-1)) ){
104183     nColumn += pTable->nCol - BMS + 1;
104184   }
104185   pLevel->plan.wsFlags |= WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WO_EQ;
104186
104187   /* Construct the Index object to describe this index */
104188   nByte = sizeof(Index);
104189   nByte += nColumn*sizeof(int);     /* Index.aiColumn */
104190   nByte += nColumn*sizeof(char*);   /* Index.azColl */
104191   nByte += nColumn;                 /* Index.aSortOrder */
104192   pIdx = sqlcipher3DbMallocZero(pParse->db, nByte);
104193   if( pIdx==0 ) return;
104194   pLevel->plan.u.pIdx = pIdx;
104195   pIdx->azColl = (char**)&pIdx[1];
104196   pIdx->aiColumn = (int*)&pIdx->azColl[nColumn];
104197   pIdx->aSortOrder = (u8*)&pIdx->aiColumn[nColumn];
104198   pIdx->zName = "auto-index";
104199   pIdx->nColumn = nColumn;
104200   pIdx->pTable = pTable;
104201   n = 0;
104202   idxCols = 0;
104203   for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104204     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
104205       int iCol = pTerm->u.leftColumn;
104206       Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol;
104207       if( (idxCols & cMask)==0 ){
104208         Expr *pX = pTerm->pExpr;
104209         idxCols |= cMask;
104210         pIdx->aiColumn[n] = pTerm->u.leftColumn;
104211         pColl = sqlcipher3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
104212         pIdx->azColl[n] = ALWAYS(pColl) ? pColl->zName : "BINARY";
104213         n++;
104214       }
104215     }
104216   }
104217   assert( (u32)n==pLevel->plan.nEq );
104218
104219   /* Add additional columns needed to make the automatic index into
104220   ** a covering index */
104221   for(i=0; i<mxBitCol; i++){
104222     if( extraCols & (((Bitmask)1)<<i) ){
104223       pIdx->aiColumn[n] = i;
104224       pIdx->azColl[n] = "BINARY";
104225       n++;
104226     }
104227   }
104228   if( pSrc->colUsed & (((Bitmask)1)<<(BMS-1)) ){
104229     for(i=BMS-1; i<pTable->nCol; i++){
104230       pIdx->aiColumn[n] = i;
104231       pIdx->azColl[n] = "BINARY";
104232       n++;
104233     }
104234   }
104235   assert( n==nColumn );
104236
104237   /* Create the automatic index */
104238   pKeyinfo = sqlcipher3IndexKeyinfo(pParse, pIdx);
104239   assert( pLevel->iIdxCur>=0 );
104240   sqlcipher3VdbeAddOp4(v, OP_OpenAutoindex, pLevel->iIdxCur, nColumn+1, 0,
104241                     (char*)pKeyinfo, P4_KEYINFO_HANDOFF);
104242   VdbeComment((v, "for %s", pTable->zName));
104243
104244   /* Fill the automatic index with content */
104245   addrTop = sqlcipher3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur);
104246   regRecord = sqlcipher3GetTempReg(pParse);
104247   sqlcipher3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 1);
104248   sqlcipher3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
104249   sqlcipher3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
104250   sqlcipher3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1);
104251   sqlcipher3VdbeChangeP5(v, SQLCIPHER_STMTSTATUS_AUTOINDEX);
104252   sqlcipher3VdbeJumpHere(v, addrTop);
104253   sqlcipher3ReleaseTempReg(pParse, regRecord);
104254   
104255   /* Jump here when skipping the initialization */
104256   sqlcipher3VdbeJumpHere(v, addrInit);
104257 }
104258 #endif /* SQLCIPHER_OMIT_AUTOMATIC_INDEX */
104259
104260 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
104261 /*
104262 ** Allocate and populate an sqlcipher3_index_info structure. It is the 
104263 ** responsibility of the caller to eventually release the structure
104264 ** by passing the pointer returned by this function to sqlcipher3_free().
104265 */
104266 static sqlcipher3_index_info *allocateIndexInfo(
104267   Parse *pParse, 
104268   WhereClause *pWC,
104269   struct SrcList_item *pSrc,
104270   ExprList *pOrderBy
104271 ){
104272   int i, j;
104273   int nTerm;
104274   struct sqlcipher3_index_constraint *pIdxCons;
104275   struct sqlcipher3_index_orderby *pIdxOrderBy;
104276   struct sqlcipher3_index_constraint_usage *pUsage;
104277   WhereTerm *pTerm;
104278   int nOrderBy;
104279   sqlcipher3_index_info *pIdxInfo;
104280
104281   WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName));
104282
104283   /* Count the number of possible WHERE clause constraints referring
104284   ** to this virtual table */
104285   for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
104286     if( pTerm->leftCursor != pSrc->iCursor ) continue;
104287     assert( (pTerm->eOperator&(pTerm->eOperator-1))==0 );
104288     testcase( pTerm->eOperator==WO_IN );
104289     testcase( pTerm->eOperator==WO_ISNULL );
104290     if( pTerm->eOperator & (WO_IN|WO_ISNULL) ) continue;
104291     if( pTerm->wtFlags & TERM_VNULL ) continue;
104292     nTerm++;
104293   }
104294
104295   /* If the ORDER BY clause contains only columns in the current 
104296   ** virtual table then allocate space for the aOrderBy part of
104297   ** the sqlcipher3_index_info structure.
104298   */
104299   nOrderBy = 0;
104300   if( pOrderBy ){
104301     for(i=0; i<pOrderBy->nExpr; i++){
104302       Expr *pExpr = pOrderBy->a[i].pExpr;
104303       if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
104304     }
104305     if( i==pOrderBy->nExpr ){
104306       nOrderBy = pOrderBy->nExpr;
104307     }
104308   }
104309
104310   /* Allocate the sqlcipher3_index_info structure
104311   */
104312   pIdxInfo = sqlcipher3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
104313                            + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
104314                            + sizeof(*pIdxOrderBy)*nOrderBy );
104315   if( pIdxInfo==0 ){
104316     sqlcipher3ErrorMsg(pParse, "out of memory");
104317     /* (double)0 In case of SQLCIPHER_OMIT_FLOATING_POINT... */
104318     return 0;
104319   }
104320
104321   /* Initialize the structure.  The sqlcipher3_index_info structure contains
104322   ** many fields that are declared "const" to prevent xBestIndex from
104323   ** changing them.  We have to do some funky casting in order to
104324   ** initialize those fields.
104325   */
104326   pIdxCons = (struct sqlcipher3_index_constraint*)&pIdxInfo[1];
104327   pIdxOrderBy = (struct sqlcipher3_index_orderby*)&pIdxCons[nTerm];
104328   pUsage = (struct sqlcipher3_index_constraint_usage*)&pIdxOrderBy[nOrderBy];
104329   *(int*)&pIdxInfo->nConstraint = nTerm;
104330   *(int*)&pIdxInfo->nOrderBy = nOrderBy;
104331   *(struct sqlcipher3_index_constraint**)&pIdxInfo->aConstraint = pIdxCons;
104332   *(struct sqlcipher3_index_orderby**)&pIdxInfo->aOrderBy = pIdxOrderBy;
104333   *(struct sqlcipher3_index_constraint_usage**)&pIdxInfo->aConstraintUsage =
104334                                                                    pUsage;
104335
104336   for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
104337     if( pTerm->leftCursor != pSrc->iCursor ) continue;
104338     assert( (pTerm->eOperator&(pTerm->eOperator-1))==0 );
104339     testcase( pTerm->eOperator==WO_IN );
104340     testcase( pTerm->eOperator==WO_ISNULL );
104341     if( pTerm->eOperator & (WO_IN|WO_ISNULL) ) continue;
104342     if( pTerm->wtFlags & TERM_VNULL ) continue;
104343     pIdxCons[j].iColumn = pTerm->u.leftColumn;
104344     pIdxCons[j].iTermOffset = i;
104345     pIdxCons[j].op = (u8)pTerm->eOperator;
104346     /* The direct assignment in the previous line is possible only because
104347     ** the WO_ and SQLCIPHER_INDEX_CONSTRAINT_ codes are identical.  The
104348     ** following asserts verify this fact. */
104349     assert( WO_EQ==SQLCIPHER_INDEX_CONSTRAINT_EQ );
104350     assert( WO_LT==SQLCIPHER_INDEX_CONSTRAINT_LT );
104351     assert( WO_LE==SQLCIPHER_INDEX_CONSTRAINT_LE );
104352     assert( WO_GT==SQLCIPHER_INDEX_CONSTRAINT_GT );
104353     assert( WO_GE==SQLCIPHER_INDEX_CONSTRAINT_GE );
104354     assert( WO_MATCH==SQLCIPHER_INDEX_CONSTRAINT_MATCH );
104355     assert( pTerm->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_MATCH) );
104356     j++;
104357   }
104358   for(i=0; i<nOrderBy; i++){
104359     Expr *pExpr = pOrderBy->a[i].pExpr;
104360     pIdxOrderBy[i].iColumn = pExpr->iColumn;
104361     pIdxOrderBy[i].desc = pOrderBy->a[i].sortOrder;
104362   }
104363
104364   return pIdxInfo;
104365 }
104366
104367 /*
104368 ** The table object reference passed as the second argument to this function
104369 ** must represent a virtual table. This function invokes the xBestIndex()
104370 ** method of the virtual table with the sqlcipher3_index_info pointer passed
104371 ** as the argument.
104372 **
104373 ** If an error occurs, pParse is populated with an error message and a
104374 ** non-zero value is returned. Otherwise, 0 is returned and the output
104375 ** part of the sqlcipher3_index_info structure is left populated.
104376 **
104377 ** Whether or not an error is returned, it is the responsibility of the
104378 ** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
104379 ** that this is required.
104380 */
104381 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlcipher3_index_info *p){
104382   sqlcipher3_vtab *pVtab = sqlcipher3GetVTable(pParse->db, pTab)->pVtab;
104383   int i;
104384   int rc;
104385
104386   WHERETRACE(("xBestIndex for %s\n", pTab->zName));
104387   TRACE_IDX_INPUTS(p);
104388   rc = pVtab->pModule->xBestIndex(pVtab, p);
104389   TRACE_IDX_OUTPUTS(p);
104390
104391   if( rc!=SQLCIPHER_OK ){
104392     if( rc==SQLCIPHER_NOMEM ){
104393       pParse->db->mallocFailed = 1;
104394     }else if( !pVtab->zErrMsg ){
104395       sqlcipher3ErrorMsg(pParse, "%s", sqlcipher3ErrStr(rc));
104396     }else{
104397       sqlcipher3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
104398     }
104399   }
104400   sqlcipher3_free(pVtab->zErrMsg);
104401   pVtab->zErrMsg = 0;
104402
104403   for(i=0; i<p->nConstraint; i++){
104404     if( !p->aConstraint[i].usable && p->aConstraintUsage[i].argvIndex>0 ){
104405       sqlcipher3ErrorMsg(pParse, 
104406           "table %s: xBestIndex returned an invalid plan", pTab->zName);
104407     }
104408   }
104409
104410   return pParse->nErr;
104411 }
104412
104413
104414 /*
104415 ** Compute the best index for a virtual table.
104416 **
104417 ** The best index is computed by the xBestIndex method of the virtual
104418 ** table module.  This routine is really just a wrapper that sets up
104419 ** the sqlcipher3_index_info structure that is used to communicate with
104420 ** xBestIndex.
104421 **
104422 ** In a join, this routine might be called multiple times for the
104423 ** same virtual table.  The sqlcipher3_index_info structure is created
104424 ** and initialized on the first invocation and reused on all subsequent
104425 ** invocations.  The sqlcipher3_index_info structure is also used when
104426 ** code is generated to access the virtual table.  The whereInfoDelete() 
104427 ** routine takes care of freeing the sqlcipher3_index_info structure after
104428 ** everybody has finished with it.
104429 */
104430 static void bestVirtualIndex(
104431   Parse *pParse,                  /* The parsing context */
104432   WhereClause *pWC,               /* The WHERE clause */
104433   struct SrcList_item *pSrc,      /* The FROM clause term to search */
104434   Bitmask notReady,               /* Mask of cursors not available for index */
104435   Bitmask notValid,               /* Cursors not valid for any purpose */
104436   ExprList *pOrderBy,             /* The order by clause */
104437   WhereCost *pCost,               /* Lowest cost query plan */
104438   sqlcipher3_index_info **ppIdxInfo  /* Index information passed to xBestIndex */
104439 ){
104440   Table *pTab = pSrc->pTab;
104441   sqlcipher3_index_info *pIdxInfo;
104442   struct sqlcipher3_index_constraint *pIdxCons;
104443   struct sqlcipher3_index_constraint_usage *pUsage;
104444   WhereTerm *pTerm;
104445   int i, j;
104446   int nOrderBy;
104447   double rCost;
104448
104449   /* Make sure wsFlags is initialized to some sane value. Otherwise, if the 
104450   ** malloc in allocateIndexInfo() fails and this function returns leaving
104451   ** wsFlags in an uninitialized state, the caller may behave unpredictably.
104452   */
104453   memset(pCost, 0, sizeof(*pCost));
104454   pCost->plan.wsFlags = WHERE_VIRTUALTABLE;
104455
104456   /* If the sqlcipher3_index_info structure has not been previously
104457   ** allocated and initialized, then allocate and initialize it now.
104458   */
104459   pIdxInfo = *ppIdxInfo;
104460   if( pIdxInfo==0 ){
104461     *ppIdxInfo = pIdxInfo = allocateIndexInfo(pParse, pWC, pSrc, pOrderBy);
104462   }
104463   if( pIdxInfo==0 ){
104464     return;
104465   }
104466
104467   /* At this point, the sqlcipher3_index_info structure that pIdxInfo points
104468   ** to will have been initialized, either during the current invocation or
104469   ** during some prior invocation.  Now we just have to customize the
104470   ** details of pIdxInfo for the current invocation and pass it to
104471   ** xBestIndex.
104472   */
104473
104474   /* The module name must be defined. Also, by this point there must
104475   ** be a pointer to an sqlcipher3_vtab structure. Otherwise
104476   ** sqlcipher3ViewGetColumnNames() would have picked up the error. 
104477   */
104478   assert( pTab->azModuleArg && pTab->azModuleArg[0] );
104479   assert( sqlcipher3GetVTable(pParse->db, pTab) );
104480
104481   /* Set the aConstraint[].usable fields and initialize all 
104482   ** output variables to zero.
104483   **
104484   ** aConstraint[].usable is true for constraints where the right-hand
104485   ** side contains only references to tables to the left of the current
104486   ** table.  In other words, if the constraint is of the form:
104487   **
104488   **           column = expr
104489   **
104490   ** and we are evaluating a join, then the constraint on column is 
104491   ** only valid if all tables referenced in expr occur to the left
104492   ** of the table containing column.
104493   **
104494   ** The aConstraints[] array contains entries for all constraints
104495   ** on the current table.  That way we only have to compute it once
104496   ** even though we might try to pick the best index multiple times.
104497   ** For each attempt at picking an index, the order of tables in the
104498   ** join might be different so we have to recompute the usable flag
104499   ** each time.
104500   */
104501   pIdxCons = *(struct sqlcipher3_index_constraint**)&pIdxInfo->aConstraint;
104502   pUsage = pIdxInfo->aConstraintUsage;
104503   for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){
104504     j = pIdxCons->iTermOffset;
104505     pTerm = &pWC->a[j];
104506     pIdxCons->usable = (pTerm->prereqRight&notReady) ? 0 : 1;
104507   }
104508   memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint);
104509   if( pIdxInfo->needToFreeIdxStr ){
104510     sqlcipher3_free(pIdxInfo->idxStr);
104511   }
104512   pIdxInfo->idxStr = 0;
104513   pIdxInfo->idxNum = 0;
104514   pIdxInfo->needToFreeIdxStr = 0;
104515   pIdxInfo->orderByConsumed = 0;
104516   /* ((double)2) In case of SQLCIPHER_OMIT_FLOATING_POINT... */
104517   pIdxInfo->estimatedCost = SQLCIPHER_BIG_DBL / ((double)2);
104518   nOrderBy = pIdxInfo->nOrderBy;
104519   if( !pOrderBy ){
104520     pIdxInfo->nOrderBy = 0;
104521   }
104522
104523   if( vtabBestIndex(pParse, pTab, pIdxInfo) ){
104524     return;
104525   }
104526
104527   pIdxCons = *(struct sqlcipher3_index_constraint**)&pIdxInfo->aConstraint;
104528   for(i=0; i<pIdxInfo->nConstraint; i++){
104529     if( pUsage[i].argvIndex>0 ){
104530       pCost->used |= pWC->a[pIdxCons[i].iTermOffset].prereqRight;
104531     }
104532   }
104533
104534   /* If there is an ORDER BY clause, and the selected virtual table index
104535   ** does not satisfy it, increase the cost of the scan accordingly. This
104536   ** matches the processing for non-virtual tables in bestBtreeIndex().
104537   */
104538   rCost = pIdxInfo->estimatedCost;
104539   if( pOrderBy && pIdxInfo->orderByConsumed==0 ){
104540     rCost += estLog(rCost)*rCost;
104541   }
104542
104543   /* The cost is not allowed to be larger than SQLCIPHER_BIG_DBL (the
104544   ** inital value of lowestCost in this loop. If it is, then the
104545   ** (cost<lowestCost) test below will never be true.
104546   ** 
104547   ** Use "(double)2" instead of "2.0" in case OMIT_FLOATING_POINT 
104548   ** is defined.
104549   */
104550   if( (SQLCIPHER_BIG_DBL/((double)2))<rCost ){
104551     pCost->rCost = (SQLCIPHER_BIG_DBL/((double)2));
104552   }else{
104553     pCost->rCost = rCost;
104554   }
104555   pCost->plan.u.pVtabIdx = pIdxInfo;
104556   if( pIdxInfo->orderByConsumed ){
104557     pCost->plan.wsFlags |= WHERE_ORDERBY;
104558   }
104559   pCost->plan.nEq = 0;
104560   pIdxInfo->nOrderBy = nOrderBy;
104561
104562   /* Try to find a more efficient access pattern by using multiple indexes
104563   ** to optimize an OR expression within the WHERE clause. 
104564   */
104565   bestOrClauseIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
104566 }
104567 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
104568
104569 #ifdef SQLCIPHER_ENABLE_STAT3
104570 /*
104571 ** Estimate the location of a particular key among all keys in an
104572 ** index.  Store the results in aStat as follows:
104573 **
104574 **    aStat[0]      Est. number of rows less than pVal
104575 **    aStat[1]      Est. number of rows equal to pVal
104576 **
104577 ** Return SQLCIPHER_OK on success.
104578 */
104579 static int whereKeyStats(
104580   Parse *pParse,              /* Database connection */
104581   Index *pIdx,                /* Index to consider domain of */
104582   sqlcipher3_value *pVal,        /* Value to consider */
104583   int roundUp,                /* Round up if true.  Round down if false */
104584   tRowcnt *aStat              /* OUT: stats written here */
104585 ){
104586   tRowcnt n;
104587   IndexSample *aSample;
104588   int i, eType;
104589   int isEq = 0;
104590   i64 v;
104591   double r, rS;
104592
104593   assert( roundUp==0 || roundUp==1 );
104594   assert( pIdx->nSample>0 );
104595   if( pVal==0 ) return SQLCIPHER_ERROR;
104596   n = pIdx->aiRowEst[0];
104597   aSample = pIdx->aSample;
104598   eType = sqlcipher3_value_type(pVal);
104599
104600   if( eType==SQLCIPHER_INTEGER ){
104601     v = sqlcipher3_value_int64(pVal);
104602     r = (i64)v;
104603     for(i=0; i<pIdx->nSample; i++){
104604       if( aSample[i].eType==SQLCIPHER_NULL ) continue;
104605       if( aSample[i].eType>=SQLCIPHER_TEXT ) break;
104606       if( aSample[i].eType==SQLCIPHER_INTEGER ){
104607         if( aSample[i].u.i>=v ){
104608           isEq = aSample[i].u.i==v;
104609           break;
104610         }
104611       }else{
104612         assert( aSample[i].eType==SQLCIPHER_FLOAT );
104613         if( aSample[i].u.r>=r ){
104614           isEq = aSample[i].u.r==r;
104615           break;
104616         }
104617       }
104618     }
104619   }else if( eType==SQLCIPHER_FLOAT ){
104620     r = sqlcipher3_value_double(pVal);
104621     for(i=0; i<pIdx->nSample; i++){
104622       if( aSample[i].eType==SQLCIPHER_NULL ) continue;
104623       if( aSample[i].eType>=SQLCIPHER_TEXT ) break;
104624       if( aSample[i].eType==SQLCIPHER_FLOAT ){
104625         rS = aSample[i].u.r;
104626       }else{
104627         rS = aSample[i].u.i;
104628       }
104629       if( rS>=r ){
104630         isEq = rS==r;
104631         break;
104632       }
104633     }
104634   }else if( eType==SQLCIPHER_NULL ){
104635     i = 0;
104636     if( aSample[0].eType==SQLCIPHER_NULL ) isEq = 1;
104637   }else{
104638     assert( eType==SQLCIPHER_TEXT || eType==SQLCIPHER_BLOB );
104639     for(i=0; i<pIdx->nSample; i++){
104640       if( aSample[i].eType==SQLCIPHER_TEXT || aSample[i].eType==SQLCIPHER_BLOB ){
104641         break;
104642       }
104643     }
104644     if( i<pIdx->nSample ){      
104645       sqlcipher3 *db = pParse->db;
104646       CollSeq *pColl;
104647       const u8 *z;
104648       if( eType==SQLCIPHER_BLOB ){
104649         z = (const u8 *)sqlcipher3_value_blob(pVal);
104650         pColl = db->pDfltColl;
104651         assert( pColl->enc==SQLCIPHER_UTF8 );
104652       }else{
104653         pColl = sqlcipher3GetCollSeq(db, SQLCIPHER_UTF8, 0, *pIdx->azColl);
104654         if( pColl==0 ){
104655           sqlcipher3ErrorMsg(pParse, "no such collation sequence: %s",
104656                           *pIdx->azColl);
104657           return SQLCIPHER_ERROR;
104658         }
104659         z = (const u8 *)sqlcipher3ValueText(pVal, pColl->enc);
104660         if( !z ){
104661           return SQLCIPHER_NOMEM;
104662         }
104663         assert( z && pColl && pColl->xCmp );
104664       }
104665       n = sqlcipher3ValueBytes(pVal, pColl->enc);
104666   
104667       for(; i<pIdx->nSample; i++){
104668         int c;
104669         int eSampletype = aSample[i].eType;
104670         if( eSampletype<eType ) continue;
104671         if( eSampletype!=eType ) break;
104672 #ifndef SQLCIPHER_OMIT_UTF16
104673         if( pColl->enc!=SQLCIPHER_UTF8 ){
104674           int nSample;
104675           char *zSample = sqlcipher3Utf8to16(
104676               db, pColl->enc, aSample[i].u.z, aSample[i].nByte, &nSample
104677           );
104678           if( !zSample ){
104679             assert( db->mallocFailed );
104680             return SQLCIPHER_NOMEM;
104681           }
104682           c = pColl->xCmp(pColl->pUser, nSample, zSample, n, z);
104683           sqlcipher3DbFree(db, zSample);
104684         }else
104685 #endif
104686         {
104687           c = pColl->xCmp(pColl->pUser, aSample[i].nByte, aSample[i].u.z, n, z);
104688         }
104689         if( c>=0 ){
104690           if( c==0 ) isEq = 1;
104691           break;
104692         }
104693       }
104694     }
104695   }
104696
104697   /* At this point, aSample[i] is the first sample that is greater than
104698   ** or equal to pVal.  Or if i==pIdx->nSample, then all samples are less
104699   ** than pVal.  If aSample[i]==pVal, then isEq==1.
104700   */
104701   if( isEq ){
104702     assert( i<pIdx->nSample );
104703     aStat[0] = aSample[i].nLt;
104704     aStat[1] = aSample[i].nEq;
104705   }else{
104706     tRowcnt iLower, iUpper, iGap;
104707     if( i==0 ){
104708       iLower = 0;
104709       iUpper = aSample[0].nLt;
104710     }else{
104711       iUpper = i>=pIdx->nSample ? n : aSample[i].nLt;
104712       iLower = aSample[i-1].nEq + aSample[i-1].nLt;
104713     }
104714     aStat[1] = pIdx->avgEq;
104715     if( iLower>=iUpper ){
104716       iGap = 0;
104717     }else{
104718       iGap = iUpper - iLower;
104719     }
104720     if( roundUp ){
104721       iGap = (iGap*2)/3;
104722     }else{
104723       iGap = iGap/3;
104724     }
104725     aStat[0] = iLower + iGap;
104726   }
104727   return SQLCIPHER_OK;
104728 }
104729 #endif /* SQLCIPHER_ENABLE_STAT3 */
104730
104731 /*
104732 ** If expression pExpr represents a literal value, set *pp to point to
104733 ** an sqlcipher3_value structure containing the same value, with affinity
104734 ** aff applied to it, before returning. It is the responsibility of the 
104735 ** caller to eventually release this structure by passing it to 
104736 ** sqlcipher3ValueFree().
104737 **
104738 ** If the current parse is a recompile (sqlcipher3Reprepare()) and pExpr
104739 ** is an SQL variable that currently has a non-NULL value bound to it,
104740 ** create an sqlcipher3_value structure containing this value, again with
104741 ** affinity aff applied to it, instead.
104742 **
104743 ** If neither of the above apply, set *pp to NULL.
104744 **
104745 ** If an error occurs, return an error code. Otherwise, SQLCIPHER_OK.
104746 */
104747 #ifdef SQLCIPHER_ENABLE_STAT3
104748 static int valueFromExpr(
104749   Parse *pParse, 
104750   Expr *pExpr, 
104751   u8 aff, 
104752   sqlcipher3_value **pp
104753 ){
104754   if( pExpr->op==TK_VARIABLE
104755    || (pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
104756   ){
104757     int iVar = pExpr->iColumn;
104758     sqlcipher3VdbeSetVarmask(pParse->pVdbe, iVar);
104759     *pp = sqlcipher3VdbeGetValue(pParse->pReprepare, iVar, aff);
104760     return SQLCIPHER_OK;
104761   }
104762   return sqlcipher3ValueFromExpr(pParse->db, pExpr, SQLCIPHER_UTF8, aff, pp);
104763 }
104764 #endif
104765
104766 /*
104767 ** This function is used to estimate the number of rows that will be visited
104768 ** by scanning an index for a range of values. The range may have an upper
104769 ** bound, a lower bound, or both. The WHERE clause terms that set the upper
104770 ** and lower bounds are represented by pLower and pUpper respectively. For
104771 ** example, assuming that index p is on t1(a):
104772 **
104773 **   ... FROM t1 WHERE a > ? AND a < ? ...
104774 **                    |_____|   |_____|
104775 **                       |         |
104776 **                     pLower    pUpper
104777 **
104778 ** If either of the upper or lower bound is not present, then NULL is passed in
104779 ** place of the corresponding WhereTerm.
104780 **
104781 ** The nEq parameter is passed the index of the index column subject to the
104782 ** range constraint. Or, equivalently, the number of equality constraints
104783 ** optimized by the proposed index scan. For example, assuming index p is
104784 ** on t1(a, b), and the SQL query is:
104785 **
104786 **   ... FROM t1 WHERE a = ? AND b > ? AND b < ? ...
104787 **
104788 ** then nEq should be passed the value 1 (as the range restricted column,
104789 ** b, is the second left-most column of the index). Or, if the query is:
104790 **
104791 **   ... FROM t1 WHERE a > ? AND a < ? ...
104792 **
104793 ** then nEq should be passed 0.
104794 **
104795 ** The returned value is an integer divisor to reduce the estimated
104796 ** search space.  A return value of 1 means that range constraints are
104797 ** no help at all.  A return value of 2 means range constraints are
104798 ** expected to reduce the search space by half.  And so forth...
104799 **
104800 ** In the absence of sqlcipher_stat3 ANALYZE data, each range inequality
104801 ** reduces the search space by a factor of 4.  Hence a single constraint (x>?)
104802 ** results in a return of 4 and a range constraint (x>? AND x<?) results
104803 ** in a return of 16.
104804 */
104805 static int whereRangeScanEst(
104806   Parse *pParse,       /* Parsing & code generating context */
104807   Index *p,            /* The index containing the range-compared column; "x" */
104808   int nEq,             /* index into p->aCol[] of the range-compared column */
104809   WhereTerm *pLower,   /* Lower bound on the range. ex: "x>123" Might be NULL */
104810   WhereTerm *pUpper,   /* Upper bound on the range. ex: "x<455" Might be NULL */
104811   double *pRangeDiv   /* OUT: Reduce search space by this divisor */
104812 ){
104813   int rc = SQLCIPHER_OK;
104814
104815 #ifdef SQLCIPHER_ENABLE_STAT3
104816
104817   if( nEq==0 && p->nSample ){
104818     sqlcipher3_value *pRangeVal;
104819     tRowcnt iLower = 0;
104820     tRowcnt iUpper = p->aiRowEst[0];
104821     tRowcnt a[2];
104822     u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
104823
104824     if( pLower ){
104825       Expr *pExpr = pLower->pExpr->pRight;
104826       rc = valueFromExpr(pParse, pExpr, aff, &pRangeVal);
104827       assert( pLower->eOperator==WO_GT || pLower->eOperator==WO_GE );
104828       if( rc==SQLCIPHER_OK
104829        && whereKeyStats(pParse, p, pRangeVal, 0, a)==SQLCIPHER_OK
104830       ){
104831         iLower = a[0];
104832         if( pLower->eOperator==WO_GT ) iLower += a[1];
104833       }
104834       sqlcipher3ValueFree(pRangeVal);
104835     }
104836     if( rc==SQLCIPHER_OK && pUpper ){
104837       Expr *pExpr = pUpper->pExpr->pRight;
104838       rc = valueFromExpr(pParse, pExpr, aff, &pRangeVal);
104839       assert( pUpper->eOperator==WO_LT || pUpper->eOperator==WO_LE );
104840       if( rc==SQLCIPHER_OK
104841        && whereKeyStats(pParse, p, pRangeVal, 1, a)==SQLCIPHER_OK
104842       ){
104843         iUpper = a[0];
104844         if( pUpper->eOperator==WO_LE ) iUpper += a[1];
104845       }
104846       sqlcipher3ValueFree(pRangeVal);
104847     }
104848     if( rc==SQLCIPHER_OK ){
104849       if( iUpper<=iLower ){
104850         *pRangeDiv = (double)p->aiRowEst[0];
104851       }else{
104852         *pRangeDiv = (double)p->aiRowEst[0]/(double)(iUpper - iLower);
104853       }
104854       WHERETRACE(("range scan regions: %u..%u  div=%g\n",
104855                   (u32)iLower, (u32)iUpper, *pRangeDiv));
104856       return SQLCIPHER_OK;
104857     }
104858   }
104859 #else
104860   UNUSED_PARAMETER(pParse);
104861   UNUSED_PARAMETER(p);
104862   UNUSED_PARAMETER(nEq);
104863 #endif
104864   assert( pLower || pUpper );
104865   *pRangeDiv = (double)1;
104866   if( pLower && (pLower->wtFlags & TERM_VNULL)==0 ) *pRangeDiv *= (double)4;
104867   if( pUpper ) *pRangeDiv *= (double)4;
104868   return rc;
104869 }
104870
104871 #ifdef SQLCIPHER_ENABLE_STAT3
104872 /*
104873 ** Estimate the number of rows that will be returned based on
104874 ** an equality constraint x=VALUE and where that VALUE occurs in
104875 ** the histogram data.  This only works when x is the left-most
104876 ** column of an index and sqlcipher_stat3 histogram data is available
104877 ** for that index.  When pExpr==NULL that means the constraint is
104878 ** "x IS NULL" instead of "x=VALUE".
104879 **
104880 ** Write the estimated row count into *pnRow and return SQLCIPHER_OK. 
104881 ** If unable to make an estimate, leave *pnRow unchanged and return
104882 ** non-zero.
104883 **
104884 ** This routine can fail if it is unable to load a collating sequence
104885 ** required for string comparison, or if unable to allocate memory
104886 ** for a UTF conversion required for comparison.  The error is stored
104887 ** in the pParse structure.
104888 */
104889 static int whereEqualScanEst(
104890   Parse *pParse,       /* Parsing & code generating context */
104891   Index *p,            /* The index whose left-most column is pTerm */
104892   Expr *pExpr,         /* Expression for VALUE in the x=VALUE constraint */
104893   double *pnRow        /* Write the revised row estimate here */
104894 ){
104895   sqlcipher3_value *pRhs = 0;  /* VALUE on right-hand side of pTerm */
104896   u8 aff;                   /* Column affinity */
104897   int rc;                   /* Subfunction return code */
104898   tRowcnt a[2];             /* Statistics */
104899
104900   assert( p->aSample!=0 );
104901   assert( p->nSample>0 );
104902   aff = p->pTable->aCol[p->aiColumn[0]].affinity;
104903   if( pExpr ){
104904     rc = valueFromExpr(pParse, pExpr, aff, &pRhs);
104905     if( rc ) goto whereEqualScanEst_cancel;
104906   }else{
104907     pRhs = sqlcipher3ValueNew(pParse->db);
104908   }
104909   if( pRhs==0 ) return SQLCIPHER_NOTFOUND;
104910   rc = whereKeyStats(pParse, p, pRhs, 0, a);
104911   if( rc==SQLCIPHER_OK ){
104912     WHERETRACE(("equality scan regions: %d\n", (int)a[1]));
104913     *pnRow = a[1];
104914   }
104915 whereEqualScanEst_cancel:
104916   sqlcipher3ValueFree(pRhs);
104917   return rc;
104918 }
104919 #endif /* defined(SQLCIPHER_ENABLE_STAT3) */
104920
104921 #ifdef SQLCIPHER_ENABLE_STAT3
104922 /*
104923 ** Estimate the number of rows that will be returned based on
104924 ** an IN constraint where the right-hand side of the IN operator
104925 ** is a list of values.  Example:
104926 **
104927 **        WHERE x IN (1,2,3,4)
104928 **
104929 ** Write the estimated row count into *pnRow and return SQLCIPHER_OK. 
104930 ** If unable to make an estimate, leave *pnRow unchanged and return
104931 ** non-zero.
104932 **
104933 ** This routine can fail if it is unable to load a collating sequence
104934 ** required for string comparison, or if unable to allocate memory
104935 ** for a UTF conversion required for comparison.  The error is stored
104936 ** in the pParse structure.
104937 */
104938 static int whereInScanEst(
104939   Parse *pParse,       /* Parsing & code generating context */
104940   Index *p,            /* The index whose left-most column is pTerm */
104941   ExprList *pList,     /* The value list on the RHS of "x IN (v1,v2,v3,...)" */
104942   double *pnRow        /* Write the revised row estimate here */
104943 ){
104944   int rc = SQLCIPHER_OK;         /* Subfunction return code */
104945   double nEst;                /* Number of rows for a single term */
104946   double nRowEst = (double)0; /* New estimate of the number of rows */
104947   int i;                      /* Loop counter */
104948
104949   assert( p->aSample!=0 );
104950   for(i=0; rc==SQLCIPHER_OK && i<pList->nExpr; i++){
104951     nEst = p->aiRowEst[0];
104952     rc = whereEqualScanEst(pParse, p, pList->a[i].pExpr, &nEst);
104953     nRowEst += nEst;
104954   }
104955   if( rc==SQLCIPHER_OK ){
104956     if( nRowEst > p->aiRowEst[0] ) nRowEst = p->aiRowEst[0];
104957     *pnRow = nRowEst;
104958     WHERETRACE(("IN row estimate: est=%g\n", nRowEst));
104959   }
104960   return rc;
104961 }
104962 #endif /* defined(SQLCIPHER_ENABLE_STAT3) */
104963
104964
104965 /*
104966 ** Find the best query plan for accessing a particular table.  Write the
104967 ** best query plan and its cost into the WhereCost object supplied as the
104968 ** last parameter.
104969 **
104970 ** The lowest cost plan wins.  The cost is an estimate of the amount of
104971 ** CPU and disk I/O needed to process the requested result.
104972 ** Factors that influence cost include:
104973 **
104974 **    *  The estimated number of rows that will be retrieved.  (The
104975 **       fewer the better.)
104976 **
104977 **    *  Whether or not sorting must occur.
104978 **
104979 **    *  Whether or not there must be separate lookups in the
104980 **       index and in the main table.
104981 **
104982 ** If there was an INDEXED BY clause (pSrc->pIndex) attached to the table in
104983 ** the SQL statement, then this function only considers plans using the 
104984 ** named index. If no such plan is found, then the returned cost is
104985 ** SQLCIPHER_BIG_DBL. If a plan is found that uses the named index, 
104986 ** then the cost is calculated in the usual way.
104987 **
104988 ** If a NOT INDEXED clause (pSrc->notIndexed!=0) was attached to the table 
104989 ** in the SELECT statement, then no indexes are considered. However, the 
104990 ** selected plan may still take advantage of the built-in rowid primary key
104991 ** index.
104992 */
104993 static void bestBtreeIndex(
104994   Parse *pParse,              /* The parsing context */
104995   WhereClause *pWC,           /* The WHERE clause */
104996   struct SrcList_item *pSrc,  /* The FROM clause term to search */
104997   Bitmask notReady,           /* Mask of cursors not available for indexing */
104998   Bitmask notValid,           /* Cursors not available for any purpose */
104999   ExprList *pOrderBy,         /* The ORDER BY clause */
105000   ExprList *pDistinct,        /* The select-list if query is DISTINCT */
105001   WhereCost *pCost            /* Lowest cost query plan */
105002 ){
105003   int iCur = pSrc->iCursor;   /* The cursor of the table to be accessed */
105004   Index *pProbe;              /* An index we are evaluating */
105005   Index *pIdx;                /* Copy of pProbe, or zero for IPK index */
105006   int eqTermMask;             /* Current mask of valid equality operators */
105007   int idxEqTermMask;          /* Index mask of valid equality operators */
105008   Index sPk;                  /* A fake index object for the primary key */
105009   tRowcnt aiRowEstPk[2];      /* The aiRowEst[] value for the sPk index */
105010   int aiColumnPk = -1;        /* The aColumn[] value for the sPk index */
105011   int wsFlagMask;             /* Allowed flags in pCost->plan.wsFlag */
105012
105013   /* Initialize the cost to a worst-case value */
105014   memset(pCost, 0, sizeof(*pCost));
105015   pCost->rCost = SQLCIPHER_BIG_DBL;
105016
105017   /* If the pSrc table is the right table of a LEFT JOIN then we may not
105018   ** use an index to satisfy IS NULL constraints on that table.  This is
105019   ** because columns might end up being NULL if the table does not match -
105020   ** a circumstance which the index cannot help us discover.  Ticket #2177.
105021   */
105022   if( pSrc->jointype & JT_LEFT ){
105023     idxEqTermMask = WO_EQ|WO_IN;
105024   }else{
105025     idxEqTermMask = WO_EQ|WO_IN|WO_ISNULL;
105026   }
105027
105028   if( pSrc->pIndex ){
105029     /* An INDEXED BY clause specifies a particular index to use */
105030     pIdx = pProbe = pSrc->pIndex;
105031     wsFlagMask = ~(WHERE_ROWID_EQ|WHERE_ROWID_RANGE);
105032     eqTermMask = idxEqTermMask;
105033   }else{
105034     /* There is no INDEXED BY clause.  Create a fake Index object in local
105035     ** variable sPk to represent the rowid primary key index.  Make this
105036     ** fake index the first in a chain of Index objects with all of the real
105037     ** indices to follow */
105038     Index *pFirst;                  /* First of real indices on the table */
105039     memset(&sPk, 0, sizeof(Index));
105040     sPk.nColumn = 1;
105041     sPk.aiColumn = &aiColumnPk;
105042     sPk.aiRowEst = aiRowEstPk;
105043     sPk.onError = OE_Replace;
105044     sPk.pTable = pSrc->pTab;
105045     aiRowEstPk[0] = pSrc->pTab->nRowEst;
105046     aiRowEstPk[1] = 1;
105047     pFirst = pSrc->pTab->pIndex;
105048     if( pSrc->notIndexed==0 ){
105049       /* The real indices of the table are only considered if the
105050       ** NOT INDEXED qualifier is omitted from the FROM clause */
105051       sPk.pNext = pFirst;
105052     }
105053     pProbe = &sPk;
105054     wsFlagMask = ~(
105055         WHERE_COLUMN_IN|WHERE_COLUMN_EQ|WHERE_COLUMN_NULL|WHERE_COLUMN_RANGE
105056     );
105057     eqTermMask = WO_EQ|WO_IN;
105058     pIdx = 0;
105059   }
105060
105061   /* Loop over all indices looking for the best one to use
105062   */
105063   for(; pProbe; pIdx=pProbe=pProbe->pNext){
105064     const tRowcnt * const aiRowEst = pProbe->aiRowEst;
105065     double cost;                /* Cost of using pProbe */
105066     double nRow;                /* Estimated number of rows in result set */
105067     double log10N = (double)1;  /* base-10 logarithm of nRow (inexact) */
105068     int rev;                    /* True to scan in reverse order */
105069     int wsFlags = 0;
105070     Bitmask used = 0;
105071
105072     /* The following variables are populated based on the properties of
105073     ** index being evaluated. They are then used to determine the expected
105074     ** cost and number of rows returned.
105075     **
105076     **  nEq: 
105077     **    Number of equality terms that can be implemented using the index.
105078     **    In other words, the number of initial fields in the index that
105079     **    are used in == or IN or NOT NULL constraints of the WHERE clause.
105080     **
105081     **  nInMul:  
105082     **    The "in-multiplier". This is an estimate of how many seek operations 
105083     **    SQLite must perform on the index in question. For example, if the 
105084     **    WHERE clause is:
105085     **
105086     **      WHERE a IN (1, 2, 3) AND b IN (4, 5, 6)
105087     **
105088     **    SQLite must perform 9 lookups on an index on (a, b), so nInMul is 
105089     **    set to 9. Given the same schema and either of the following WHERE 
105090     **    clauses:
105091     **
105092     **      WHERE a =  1
105093     **      WHERE a >= 2
105094     **
105095     **    nInMul is set to 1.
105096     **
105097     **    If there exists a WHERE term of the form "x IN (SELECT ...)", then 
105098     **    the sub-select is assumed to return 25 rows for the purposes of 
105099     **    determining nInMul.
105100     **
105101     **  bInEst:  
105102     **    Set to true if there was at least one "x IN (SELECT ...)" term used 
105103     **    in determining the value of nInMul.  Note that the RHS of the
105104     **    IN operator must be a SELECT, not a value list, for this variable
105105     **    to be true.
105106     **
105107     **  rangeDiv:
105108     **    An estimate of a divisor by which to reduce the search space due
105109     **    to inequality constraints.  In the absence of sqlcipher_stat3 ANALYZE
105110     **    data, a single inequality reduces the search space to 1/4rd its
105111     **    original size (rangeDiv==4).  Two inequalities reduce the search
105112     **    space to 1/16th of its original size (rangeDiv==16).
105113     **
105114     **  bSort:   
105115     **    Boolean. True if there is an ORDER BY clause that will require an 
105116     **    external sort (i.e. scanning the index being evaluated will not 
105117     **    correctly order records).
105118     **
105119     **  bLookup: 
105120     **    Boolean. True if a table lookup is required for each index entry
105121     **    visited.  In other words, true if this is not a covering index.
105122     **    This is always false for the rowid primary key index of a table.
105123     **    For other indexes, it is true unless all the columns of the table
105124     **    used by the SELECT statement are present in the index (such an
105125     **    index is sometimes described as a covering index).
105126     **    For example, given the index on (a, b), the second of the following 
105127     **    two queries requires table b-tree lookups in order to find the value
105128     **    of column c, but the first does not because columns a and b are
105129     **    both available in the index.
105130     **
105131     **             SELECT a, b    FROM tbl WHERE a = 1;
105132     **             SELECT a, b, c FROM tbl WHERE a = 1;
105133     */
105134     int nEq;                      /* Number of == or IN terms matching index */
105135     int bInEst = 0;               /* True if "x IN (SELECT...)" seen */
105136     int nInMul = 1;               /* Number of distinct equalities to lookup */
105137     double rangeDiv = (double)1;  /* Estimated reduction in search space */
105138     int nBound = 0;               /* Number of range constraints seen */
105139     int bSort = !!pOrderBy;       /* True if external sort required */
105140     int bDist = !!pDistinct;      /* True if index cannot help with DISTINCT */
105141     int bLookup = 0;              /* True if not a covering index */
105142     WhereTerm *pTerm;             /* A single term of the WHERE clause */
105143 #ifdef SQLCIPHER_ENABLE_STAT3
105144     WhereTerm *pFirstTerm = 0;    /* First term matching the index */
105145 #endif
105146
105147     /* Determine the values of nEq and nInMul */
105148     for(nEq=0; nEq<pProbe->nColumn; nEq++){
105149       int j = pProbe->aiColumn[nEq];
105150       pTerm = findTerm(pWC, iCur, j, notReady, eqTermMask, pIdx);
105151       if( pTerm==0 ) break;
105152       wsFlags |= (WHERE_COLUMN_EQ|WHERE_ROWID_EQ);
105153       testcase( pTerm->pWC!=pWC );
105154       if( pTerm->eOperator & WO_IN ){
105155         Expr *pExpr = pTerm->pExpr;
105156         wsFlags |= WHERE_COLUMN_IN;
105157         if( ExprHasProperty(pExpr, EP_xIsSelect) ){
105158           /* "x IN (SELECT ...)":  Assume the SELECT returns 25 rows */
105159           nInMul *= 25;
105160           bInEst = 1;
105161         }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
105162           /* "x IN (value, value, ...)" */
105163           nInMul *= pExpr->x.pList->nExpr;
105164         }
105165       }else if( pTerm->eOperator & WO_ISNULL ){
105166         wsFlags |= WHERE_COLUMN_NULL;
105167       }
105168 #ifdef SQLCIPHER_ENABLE_STAT3
105169       if( nEq==0 && pProbe->aSample ) pFirstTerm = pTerm;
105170 #endif
105171       used |= pTerm->prereqRight;
105172     }
105173
105174     /* Determine the value of rangeDiv */
105175     if( nEq<pProbe->nColumn && pProbe->bUnordered==0 ){
105176       int j = pProbe->aiColumn[nEq];
105177       if( findTerm(pWC, iCur, j, notReady, WO_LT|WO_LE|WO_GT|WO_GE, pIdx) ){
105178         WhereTerm *pTop = findTerm(pWC, iCur, j, notReady, WO_LT|WO_LE, pIdx);
105179         WhereTerm *pBtm = findTerm(pWC, iCur, j, notReady, WO_GT|WO_GE, pIdx);
105180         whereRangeScanEst(pParse, pProbe, nEq, pBtm, pTop, &rangeDiv);
105181         if( pTop ){
105182           nBound = 1;
105183           wsFlags |= WHERE_TOP_LIMIT;
105184           used |= pTop->prereqRight;
105185           testcase( pTop->pWC!=pWC );
105186         }
105187         if( pBtm ){
105188           nBound++;
105189           wsFlags |= WHERE_BTM_LIMIT;
105190           used |= pBtm->prereqRight;
105191           testcase( pBtm->pWC!=pWC );
105192         }
105193         wsFlags |= (WHERE_COLUMN_RANGE|WHERE_ROWID_RANGE);
105194       }
105195     }else if( pProbe->onError!=OE_None ){
105196       testcase( wsFlags & WHERE_COLUMN_IN );
105197       testcase( wsFlags & WHERE_COLUMN_NULL );
105198       if( (wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_NULL))==0 ){
105199         wsFlags |= WHERE_UNIQUE;
105200       }
105201     }
105202
105203     /* If there is an ORDER BY clause and the index being considered will
105204     ** naturally scan rows in the required order, set the appropriate flags
105205     ** in wsFlags. Otherwise, if there is an ORDER BY clause but the index
105206     ** will scan rows in a different order, set the bSort variable.  */
105207     if( isSortingIndex(
105208           pParse, pWC->pMaskSet, pProbe, iCur, pOrderBy, nEq, wsFlags, &rev)
105209     ){
105210       bSort = 0;
105211       wsFlags |= WHERE_ROWID_RANGE|WHERE_COLUMN_RANGE|WHERE_ORDERBY;
105212       wsFlags |= (rev ? WHERE_REVERSE : 0);
105213     }
105214
105215     /* If there is a DISTINCT qualifier and this index will scan rows in
105216     ** order of the DISTINCT expressions, clear bDist and set the appropriate
105217     ** flags in wsFlags. */
105218     if( isDistinctIndex(pParse, pWC, pProbe, iCur, pDistinct, nEq) ){
105219       bDist = 0;
105220       wsFlags |= WHERE_ROWID_RANGE|WHERE_COLUMN_RANGE|WHERE_DISTINCT;
105221     }
105222
105223     /* If currently calculating the cost of using an index (not the IPK
105224     ** index), determine if all required column data may be obtained without 
105225     ** using the main table (i.e. if the index is a covering
105226     ** index for this query). If it is, set the WHERE_IDX_ONLY flag in
105227     ** wsFlags. Otherwise, set the bLookup variable to true.  */
105228     if( pIdx && wsFlags ){
105229       Bitmask m = pSrc->colUsed;
105230       int j;
105231       for(j=0; j<pIdx->nColumn; j++){
105232         int x = pIdx->aiColumn[j];
105233         if( x<BMS-1 ){
105234           m &= ~(((Bitmask)1)<<x);
105235         }
105236       }
105237       if( m==0 ){
105238         wsFlags |= WHERE_IDX_ONLY;
105239       }else{
105240         bLookup = 1;
105241       }
105242     }
105243
105244     /*
105245     ** Estimate the number of rows of output.  For an "x IN (SELECT...)"
105246     ** constraint, do not let the estimate exceed half the rows in the table.
105247     */
105248     nRow = (double)(aiRowEst[nEq] * nInMul);
105249     if( bInEst && nRow*2>aiRowEst[0] ){
105250       nRow = aiRowEst[0]/2;
105251       nInMul = (int)(nRow / aiRowEst[nEq]);
105252     }
105253
105254 #ifdef SQLCIPHER_ENABLE_STAT3
105255     /* If the constraint is of the form x=VALUE or x IN (E1,E2,...)
105256     ** and we do not think that values of x are unique and if histogram
105257     ** data is available for column x, then it might be possible
105258     ** to get a better estimate on the number of rows based on
105259     ** VALUE and how common that value is according to the histogram.
105260     */
105261     if( nRow>(double)1 && nEq==1 && pFirstTerm!=0 && aiRowEst[1]>1 ){
105262       assert( (pFirstTerm->eOperator & (WO_EQ|WO_ISNULL|WO_IN))!=0 );
105263       if( pFirstTerm->eOperator & (WO_EQ|WO_ISNULL) ){
105264         testcase( pFirstTerm->eOperator==WO_EQ );
105265         testcase( pFirstTerm->eOperator==WO_ISNULL );
105266         whereEqualScanEst(pParse, pProbe, pFirstTerm->pExpr->pRight, &nRow);
105267       }else if( bInEst==0 ){
105268         assert( pFirstTerm->eOperator==WO_IN );
105269         whereInScanEst(pParse, pProbe, pFirstTerm->pExpr->x.pList, &nRow);
105270       }
105271     }
105272 #endif /* SQLCIPHER_ENABLE_STAT3 */
105273
105274     /* Adjust the number of output rows and downward to reflect rows
105275     ** that are excluded by range constraints.
105276     */
105277     nRow = nRow/rangeDiv;
105278     if( nRow<1 ) nRow = 1;
105279
105280     /* Experiments run on real SQLite databases show that the time needed
105281     ** to do a binary search to locate a row in a table or index is roughly
105282     ** log10(N) times the time to move from one row to the next row within
105283     ** a table or index.  The actual times can vary, with the size of
105284     ** records being an important factor.  Both moves and searches are
105285     ** slower with larger records, presumably because fewer records fit
105286     ** on one page and hence more pages have to be fetched.
105287     **
105288     ** The ANALYZE command and the sqlcipher_stat1 and sqlcipher_stat3 tables do
105289     ** not give us data on the relative sizes of table and index records.
105290     ** So this computation assumes table records are about twice as big
105291     ** as index records
105292     */
105293     if( (wsFlags & WHERE_NOT_FULLSCAN)==0 ){
105294       /* The cost of a full table scan is a number of move operations equal
105295       ** to the number of rows in the table.
105296       **
105297       ** We add an additional 4x penalty to full table scans.  This causes
105298       ** the cost function to err on the side of choosing an index over
105299       ** choosing a full scan.  This 4x full-scan penalty is an arguable
105300       ** decision and one which we expect to revisit in the future.  But
105301       ** it seems to be working well enough at the moment.
105302       */
105303       cost = aiRowEst[0]*4;
105304     }else{
105305       log10N = estLog(aiRowEst[0]);
105306       cost = nRow;
105307       if( pIdx ){
105308         if( bLookup ){
105309           /* For an index lookup followed by a table lookup:
105310           **    nInMul index searches to find the start of each index range
105311           **  + nRow steps through the index
105312           **  + nRow table searches to lookup the table entry using the rowid
105313           */
105314           cost += (nInMul + nRow)*log10N;
105315         }else{
105316           /* For a covering index:
105317           **     nInMul index searches to find the initial entry 
105318           **   + nRow steps through the index
105319           */
105320           cost += nInMul*log10N;
105321         }
105322       }else{
105323         /* For a rowid primary key lookup:
105324         **    nInMult table searches to find the initial entry for each range
105325         **  + nRow steps through the table
105326         */
105327         cost += nInMul*log10N;
105328       }
105329     }
105330
105331     /* Add in the estimated cost of sorting the result.  Actual experimental
105332     ** measurements of sorting performance in SQLite show that sorting time
105333     ** adds C*N*log10(N) to the cost, where N is the number of rows to be 
105334     ** sorted and C is a factor between 1.95 and 4.3.  We will split the
105335     ** difference and select C of 3.0.
105336     */
105337     if( bSort ){
105338       cost += nRow*estLog(nRow)*3;
105339     }
105340     if( bDist ){
105341       cost += nRow*estLog(nRow)*3;
105342     }
105343
105344     /**** Cost of using this index has now been computed ****/
105345
105346     /* If there are additional constraints on this table that cannot
105347     ** be used with the current index, but which might lower the number
105348     ** of output rows, adjust the nRow value accordingly.  This only 
105349     ** matters if the current index is the least costly, so do not bother
105350     ** with this step if we already know this index will not be chosen.
105351     ** Also, never reduce the output row count below 2 using this step.
105352     **
105353     ** It is critical that the notValid mask be used here instead of
105354     ** the notReady mask.  When computing an "optimal" index, the notReady
105355     ** mask will only have one bit set - the bit for the current table.
105356     ** The notValid mask, on the other hand, always has all bits set for
105357     ** tables that are not in outer loops.  If notReady is used here instead
105358     ** of notValid, then a optimal index that depends on inner joins loops
105359     ** might be selected even when there exists an optimal index that has
105360     ** no such dependency.
105361     */
105362     if( nRow>2 && cost<=pCost->rCost ){
105363       int k;                       /* Loop counter */
105364       int nSkipEq = nEq;           /* Number of == constraints to skip */
105365       int nSkipRange = nBound;     /* Number of < constraints to skip */
105366       Bitmask thisTab;             /* Bitmap for pSrc */
105367
105368       thisTab = getMask(pWC->pMaskSet, iCur);
105369       for(pTerm=pWC->a, k=pWC->nTerm; nRow>2 && k; k--, pTerm++){
105370         if( pTerm->wtFlags & TERM_VIRTUAL ) continue;
105371         if( (pTerm->prereqAll & notValid)!=thisTab ) continue;
105372         if( pTerm->eOperator & (WO_EQ|WO_IN|WO_ISNULL) ){
105373           if( nSkipEq ){
105374             /* Ignore the first nEq equality matches since the index
105375             ** has already accounted for these */
105376             nSkipEq--;
105377           }else{
105378             /* Assume each additional equality match reduces the result
105379             ** set size by a factor of 10 */
105380             nRow /= 10;
105381           }
105382         }else if( pTerm->eOperator & (WO_LT|WO_LE|WO_GT|WO_GE) ){
105383           if( nSkipRange ){
105384             /* Ignore the first nSkipRange range constraints since the index
105385             ** has already accounted for these */
105386             nSkipRange--;
105387           }else{
105388             /* Assume each additional range constraint reduces the result
105389             ** set size by a factor of 3.  Indexed range constraints reduce
105390             ** the search space by a larger factor: 4.  We make indexed range
105391             ** more selective intentionally because of the subjective 
105392             ** observation that indexed range constraints really are more
105393             ** selective in practice, on average. */
105394             nRow /= 3;
105395           }
105396         }else if( pTerm->eOperator!=WO_NOOP ){
105397           /* Any other expression lowers the output row count by half */
105398           nRow /= 2;
105399         }
105400       }
105401       if( nRow<2 ) nRow = 2;
105402     }
105403
105404
105405     WHERETRACE((
105406       "%s(%s): nEq=%d nInMul=%d rangeDiv=%d bSort=%d bLookup=%d wsFlags=0x%x\n"
105407       "         notReady=0x%llx log10N=%.1f nRow=%.1f cost=%.1f used=0x%llx\n",
105408       pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk"), 
105409       nEq, nInMul, (int)rangeDiv, bSort, bLookup, wsFlags,
105410       notReady, log10N, nRow, cost, used
105411     ));
105412
105413     /* If this index is the best we have seen so far, then record this
105414     ** index and its cost in the pCost structure.
105415     */
105416     if( (!pIdx || wsFlags)
105417      && (cost<pCost->rCost || (cost<=pCost->rCost && nRow<pCost->plan.nRow))
105418     ){
105419       pCost->rCost = cost;
105420       pCost->used = used;
105421       pCost->plan.nRow = nRow;
105422       pCost->plan.wsFlags = (wsFlags&wsFlagMask);
105423       pCost->plan.nEq = nEq;
105424       pCost->plan.u.pIdx = pIdx;
105425     }
105426
105427     /* If there was an INDEXED BY clause, then only that one index is
105428     ** considered. */
105429     if( pSrc->pIndex ) break;
105430
105431     /* Reset masks for the next index in the loop */
105432     wsFlagMask = ~(WHERE_ROWID_EQ|WHERE_ROWID_RANGE);
105433     eqTermMask = idxEqTermMask;
105434   }
105435
105436   /* If there is no ORDER BY clause and the SQLCIPHER_ReverseOrder flag
105437   ** is set, then reverse the order that the index will be scanned
105438   ** in. This is used for application testing, to help find cases
105439   ** where application behaviour depends on the (undefined) order that
105440   ** SQLite outputs rows in in the absence of an ORDER BY clause.  */
105441   if( !pOrderBy && pParse->db->flags & SQLCIPHER_ReverseOrder ){
105442     pCost->plan.wsFlags |= WHERE_REVERSE;
105443   }
105444
105445   assert( pOrderBy || (pCost->plan.wsFlags&WHERE_ORDERBY)==0 );
105446   assert( pCost->plan.u.pIdx==0 || (pCost->plan.wsFlags&WHERE_ROWID_EQ)==0 );
105447   assert( pSrc->pIndex==0 
105448        || pCost->plan.u.pIdx==0 
105449        || pCost->plan.u.pIdx==pSrc->pIndex 
105450   );
105451
105452   WHERETRACE(("best index is: %s\n", 
105453     ((pCost->plan.wsFlags & WHERE_NOT_FULLSCAN)==0 ? "none" : 
105454          pCost->plan.u.pIdx ? pCost->plan.u.pIdx->zName : "ipk")
105455   ));
105456   
105457   bestOrClauseIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
105458   bestAutomaticIndex(pParse, pWC, pSrc, notReady, pCost);
105459   pCost->plan.wsFlags |= eqTermMask;
105460 }
105461
105462 /*
105463 ** Find the query plan for accessing table pSrc->pTab. Write the
105464 ** best query plan and its cost into the WhereCost object supplied 
105465 ** as the last parameter. This function may calculate the cost of
105466 ** both real and virtual table scans.
105467 */
105468 static void bestIndex(
105469   Parse *pParse,              /* The parsing context */
105470   WhereClause *pWC,           /* The WHERE clause */
105471   struct SrcList_item *pSrc,  /* The FROM clause term to search */
105472   Bitmask notReady,           /* Mask of cursors not available for indexing */
105473   Bitmask notValid,           /* Cursors not available for any purpose */
105474   ExprList *pOrderBy,         /* The ORDER BY clause */
105475   WhereCost *pCost            /* Lowest cost query plan */
105476 ){
105477 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
105478   if( IsVirtual(pSrc->pTab) ){
105479     sqlcipher3_index_info *p = 0;
105480     bestVirtualIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost,&p);
105481     if( p->needToFreeIdxStr ){
105482       sqlcipher3_free(p->idxStr);
105483     }
105484     sqlcipher3DbFree(pParse->db, p);
105485   }else
105486 #endif
105487   {
105488     bestBtreeIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, 0, pCost);
105489   }
105490 }
105491
105492 /*
105493 ** Disable a term in the WHERE clause.  Except, do not disable the term
105494 ** if it controls a LEFT OUTER JOIN and it did not originate in the ON
105495 ** or USING clause of that join.
105496 **
105497 ** Consider the term t2.z='ok' in the following queries:
105498 **
105499 **   (1)  SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok'
105500 **   (2)  SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok'
105501 **   (3)  SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok'
105502 **
105503 ** The t2.z='ok' is disabled in the in (2) because it originates
105504 ** in the ON clause.  The term is disabled in (3) because it is not part
105505 ** of a LEFT OUTER JOIN.  In (1), the term is not disabled.
105506 **
105507 ** IMPLEMENTATION-OF: R-24597-58655 No tests are done for terms that are
105508 ** completely satisfied by indices.
105509 **
105510 ** Disabling a term causes that term to not be tested in the inner loop
105511 ** of the join.  Disabling is an optimization.  When terms are satisfied
105512 ** by indices, we disable them to prevent redundant tests in the inner
105513 ** loop.  We would get the correct results if nothing were ever disabled,
105514 ** but joins might run a little slower.  The trick is to disable as much
105515 ** as we can without disabling too much.  If we disabled in (1), we'd get
105516 ** the wrong answer.  See ticket #813.
105517 */
105518 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
105519   if( pTerm
105520       && (pTerm->wtFlags & TERM_CODED)==0
105521       && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
105522   ){
105523     pTerm->wtFlags |= TERM_CODED;
105524     if( pTerm->iParent>=0 ){
105525       WhereTerm *pOther = &pTerm->pWC->a[pTerm->iParent];
105526       if( (--pOther->nChild)==0 ){
105527         disableTerm(pLevel, pOther);
105528       }
105529     }
105530   }
105531 }
105532
105533 /*
105534 ** Code an OP_Affinity opcode to apply the column affinity string zAff
105535 ** to the n registers starting at base. 
105536 **
105537 ** As an optimization, SQLCIPHER_AFF_NONE entries (which are no-ops) at the
105538 ** beginning and end of zAff are ignored.  If all entries in zAff are
105539 ** SQLCIPHER_AFF_NONE, then no code gets generated.
105540 **
105541 ** This routine makes its own copy of zAff so that the caller is free
105542 ** to modify zAff after this routine returns.
105543 */
105544 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
105545   Vdbe *v = pParse->pVdbe;
105546   if( zAff==0 ){
105547     assert( pParse->db->mallocFailed );
105548     return;
105549   }
105550   assert( v!=0 );
105551
105552   /* Adjust base and n to skip over SQLCIPHER_AFF_NONE entries at the beginning
105553   ** and end of the affinity string.
105554   */
105555   while( n>0 && zAff[0]==SQLCIPHER_AFF_NONE ){
105556     n--;
105557     base++;
105558     zAff++;
105559   }
105560   while( n>1 && zAff[n-1]==SQLCIPHER_AFF_NONE ){
105561     n--;
105562   }
105563
105564   /* Code the OP_Affinity opcode if there is anything left to do. */
105565   if( n>0 ){
105566     sqlcipher3VdbeAddOp2(v, OP_Affinity, base, n);
105567     sqlcipher3VdbeChangeP4(v, -1, zAff, n);
105568     sqlcipher3ExprCacheAffinityChange(pParse, base, n);
105569   }
105570 }
105571
105572
105573 /*
105574 ** Generate code for a single equality term of the WHERE clause.  An equality
105575 ** term can be either X=expr or X IN (...).   pTerm is the term to be 
105576 ** coded.
105577 **
105578 ** The current value for the constraint is left in register iReg.
105579 **
105580 ** For a constraint of the form X=expr, the expression is evaluated and its
105581 ** result is left on the stack.  For constraints of the form X IN (...)
105582 ** this routine sets up a loop that will iterate over all values of X.
105583 */
105584 static int codeEqualityTerm(
105585   Parse *pParse,      /* The parsing context */
105586   WhereTerm *pTerm,   /* The term of the WHERE clause to be coded */
105587   WhereLevel *pLevel, /* When level of the FROM clause we are working on */
105588   int iTarget         /* Attempt to leave results in this register */
105589 ){
105590   Expr *pX = pTerm->pExpr;
105591   Vdbe *v = pParse->pVdbe;
105592   int iReg;                  /* Register holding results */
105593
105594   assert( iTarget>0 );
105595   if( pX->op==TK_EQ ){
105596     iReg = sqlcipher3ExprCodeTarget(pParse, pX->pRight, iTarget);
105597   }else if( pX->op==TK_ISNULL ){
105598     iReg = iTarget;
105599     sqlcipher3VdbeAddOp2(v, OP_Null, 0, iReg);
105600 #ifndef SQLCIPHER_OMIT_SUBQUERY
105601   }else{
105602     int eType;
105603     int iTab;
105604     struct InLoop *pIn;
105605
105606     assert( pX->op==TK_IN );
105607     iReg = iTarget;
105608     eType = sqlcipher3FindInIndex(pParse, pX, 0);
105609     iTab = pX->iTable;
105610     sqlcipher3VdbeAddOp2(v, OP_Rewind, iTab, 0);
105611     assert( pLevel->plan.wsFlags & WHERE_IN_ABLE );
105612     if( pLevel->u.in.nIn==0 ){
105613       pLevel->addrNxt = sqlcipher3VdbeMakeLabel(v);
105614     }
105615     pLevel->u.in.nIn++;
105616     pLevel->u.in.aInLoop =
105617        sqlcipher3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
105618                               sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
105619     pIn = pLevel->u.in.aInLoop;
105620     if( pIn ){
105621       pIn += pLevel->u.in.nIn - 1;
105622       pIn->iCur = iTab;
105623       if( eType==IN_INDEX_ROWID ){
105624         pIn->addrInTop = sqlcipher3VdbeAddOp2(v, OP_Rowid, iTab, iReg);
105625       }else{
105626         pIn->addrInTop = sqlcipher3VdbeAddOp3(v, OP_Column, iTab, 0, iReg);
105627       }
105628       sqlcipher3VdbeAddOp1(v, OP_IsNull, iReg);
105629     }else{
105630       pLevel->u.in.nIn = 0;
105631     }
105632 #endif
105633   }
105634   disableTerm(pLevel, pTerm);
105635   return iReg;
105636 }
105637
105638 /*
105639 ** Generate code that will evaluate all == and IN constraints for an
105640 ** index.
105641 **
105642 ** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c).
105643 ** Suppose the WHERE clause is this:  a==5 AND b IN (1,2,3) AND c>5 AND c<10
105644 ** The index has as many as three equality constraints, but in this
105645 ** example, the third "c" value is an inequality.  So only two 
105646 ** constraints are coded.  This routine will generate code to evaluate
105647 ** a==5 and b IN (1,2,3).  The current values for a and b will be stored
105648 ** in consecutive registers and the index of the first register is returned.
105649 **
105650 ** In the example above nEq==2.  But this subroutine works for any value
105651 ** of nEq including 0.  If nEq==0, this routine is nearly a no-op.
105652 ** The only thing it does is allocate the pLevel->iMem memory cell and
105653 ** compute the affinity string.
105654 **
105655 ** This routine always allocates at least one memory cell and returns
105656 ** the index of that memory cell. The code that
105657 ** calls this routine will use that memory cell to store the termination
105658 ** key value of the loop.  If one or more IN operators appear, then
105659 ** this routine allocates an additional nEq memory cells for internal
105660 ** use.
105661 **
105662 ** Before returning, *pzAff is set to point to a buffer containing a
105663 ** copy of the column affinity string of the index allocated using
105664 ** sqlcipher3DbMalloc(). Except, entries in the copy of the string associated
105665 ** with equality constraints that use NONE affinity are set to
105666 ** SQLCIPHER_AFF_NONE. This is to deal with SQL such as the following:
105667 **
105668 **   CREATE TABLE t1(a TEXT PRIMARY KEY, b);
105669 **   SELECT ... FROM t1 AS t2, t1 WHERE t1.a = t2.b;
105670 **
105671 ** In the example above, the index on t1(a) has TEXT affinity. But since
105672 ** the right hand side of the equality constraint (t2.b) has NONE affinity,
105673 ** no conversion should be attempted before using a t2.b value as part of
105674 ** a key to search the index. Hence the first byte in the returned affinity
105675 ** string in this example would be set to SQLCIPHER_AFF_NONE.
105676 */
105677 static int codeAllEqualityTerms(
105678   Parse *pParse,        /* Parsing context */
105679   WhereLevel *pLevel,   /* Which nested loop of the FROM we are coding */
105680   WhereClause *pWC,     /* The WHERE clause */
105681   Bitmask notReady,     /* Which parts of FROM have not yet been coded */
105682   int nExtraReg,        /* Number of extra registers to allocate */
105683   char **pzAff          /* OUT: Set to point to affinity string */
105684 ){
105685   int nEq = pLevel->plan.nEq;   /* The number of == or IN constraints to code */
105686   Vdbe *v = pParse->pVdbe;      /* The vm under construction */
105687   Index *pIdx;                  /* The index being used for this loop */
105688   int iCur = pLevel->iTabCur;   /* The cursor of the table */
105689   WhereTerm *pTerm;             /* A single constraint term */
105690   int j;                        /* Loop counter */
105691   int regBase;                  /* Base register */
105692   int nReg;                     /* Number of registers to allocate */
105693   char *zAff;                   /* Affinity string to return */
105694
105695   /* This module is only called on query plans that use an index. */
105696   assert( pLevel->plan.wsFlags & WHERE_INDEXED );
105697   pIdx = pLevel->plan.u.pIdx;
105698
105699   /* Figure out how many memory cells we will need then allocate them.
105700   */
105701   regBase = pParse->nMem + 1;
105702   nReg = pLevel->plan.nEq + nExtraReg;
105703   pParse->nMem += nReg;
105704
105705   zAff = sqlcipher3DbStrDup(pParse->db, sqlcipher3IndexAffinityStr(v, pIdx));
105706   if( !zAff ){
105707     pParse->db->mallocFailed = 1;
105708   }
105709
105710   /* Evaluate the equality constraints
105711   */
105712   assert( pIdx->nColumn>=nEq );
105713   for(j=0; j<nEq; j++){
105714     int r1;
105715     int k = pIdx->aiColumn[j];
105716     pTerm = findTerm(pWC, iCur, k, notReady, pLevel->plan.wsFlags, pIdx);
105717     if( NEVER(pTerm==0) ) break;
105718     /* The following true for indices with redundant columns. 
105719     ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */
105720     testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
105721     testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
105722     r1 = codeEqualityTerm(pParse, pTerm, pLevel, regBase+j);
105723     if( r1!=regBase+j ){
105724       if( nReg==1 ){
105725         sqlcipher3ReleaseTempReg(pParse, regBase);
105726         regBase = r1;
105727       }else{
105728         sqlcipher3VdbeAddOp2(v, OP_SCopy, r1, regBase+j);
105729       }
105730     }
105731     testcase( pTerm->eOperator & WO_ISNULL );
105732     testcase( pTerm->eOperator & WO_IN );
105733     if( (pTerm->eOperator & (WO_ISNULL|WO_IN))==0 ){
105734       Expr *pRight = pTerm->pExpr->pRight;
105735       sqlcipher3ExprCodeIsNullJump(v, pRight, regBase+j, pLevel->addrBrk);
105736       if( zAff ){
105737         if( sqlcipher3CompareAffinity(pRight, zAff[j])==SQLCIPHER_AFF_NONE ){
105738           zAff[j] = SQLCIPHER_AFF_NONE;
105739         }
105740         if( sqlcipher3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){
105741           zAff[j] = SQLCIPHER_AFF_NONE;
105742         }
105743       }
105744     }
105745   }
105746   *pzAff = zAff;
105747   return regBase;
105748 }
105749
105750 #ifndef SQLCIPHER_OMIT_EXPLAIN
105751 /*
105752 ** This routine is a helper for explainIndexRange() below
105753 **
105754 ** pStr holds the text of an expression that we are building up one term
105755 ** at a time.  This routine adds a new term to the end of the expression.
105756 ** Terms are separated by AND so add the "AND" text for second and subsequent
105757 ** terms only.
105758 */
105759 static void explainAppendTerm(
105760   StrAccum *pStr,             /* The text expression being built */
105761   int iTerm,                  /* Index of this term.  First is zero */
105762   const char *zColumn,        /* Name of the column */
105763   const char *zOp             /* Name of the operator */
105764 ){
105765   if( iTerm ) sqlcipher3StrAccumAppend(pStr, " AND ", 5);
105766   sqlcipher3StrAccumAppend(pStr, zColumn, -1);
105767   sqlcipher3StrAccumAppend(pStr, zOp, 1);
105768   sqlcipher3StrAccumAppend(pStr, "?", 1);
105769 }
105770
105771 /*
105772 ** Argument pLevel describes a strategy for scanning table pTab. This 
105773 ** function returns a pointer to a string buffer containing a description
105774 ** of the subset of table rows scanned by the strategy in the form of an
105775 ** SQL expression. Or, if all rows are scanned, NULL is returned.
105776 **
105777 ** For example, if the query:
105778 **
105779 **   SELECT * FROM t1 WHERE a=1 AND b>2;
105780 **
105781 ** is run and there is an index on (a, b), then this function returns a
105782 ** string similar to:
105783 **
105784 **   "a=? AND b>?"
105785 **
105786 ** The returned pointer points to memory obtained from sqlcipher3DbMalloc().
105787 ** It is the responsibility of the caller to free the buffer when it is
105788 ** no longer required.
105789 */
105790 static char *explainIndexRange(sqlcipher3 *db, WhereLevel *pLevel, Table *pTab){
105791   WherePlan *pPlan = &pLevel->plan;
105792   Index *pIndex = pPlan->u.pIdx;
105793   int nEq = pPlan->nEq;
105794   int i, j;
105795   Column *aCol = pTab->aCol;
105796   int *aiColumn = pIndex->aiColumn;
105797   StrAccum txt;
105798
105799   if( nEq==0 && (pPlan->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ){
105800     return 0;
105801   }
105802   sqlcipher3StrAccumInit(&txt, 0, 0, SQLCIPHER_MAX_LENGTH);
105803   txt.db = db;
105804   sqlcipher3StrAccumAppend(&txt, " (", 2);
105805   for(i=0; i<nEq; i++){
105806     explainAppendTerm(&txt, i, aCol[aiColumn[i]].zName, "=");
105807   }
105808
105809   j = i;
105810   if( pPlan->wsFlags&WHERE_BTM_LIMIT ){
105811     explainAppendTerm(&txt, i++, aCol[aiColumn[j]].zName, ">");
105812   }
105813   if( pPlan->wsFlags&WHERE_TOP_LIMIT ){
105814     explainAppendTerm(&txt, i, aCol[aiColumn[j]].zName, "<");
105815   }
105816   sqlcipher3StrAccumAppend(&txt, ")", 1);
105817   return sqlcipher3StrAccumFinish(&txt);
105818 }
105819
105820 /*
105821 ** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN
105822 ** command. If the query being compiled is an EXPLAIN QUERY PLAN, a single
105823 ** record is added to the output to describe the table scan strategy in 
105824 ** pLevel.
105825 */
105826 static void explainOneScan(
105827   Parse *pParse,                  /* Parse context */
105828   SrcList *pTabList,              /* Table list this loop refers to */
105829   WhereLevel *pLevel,             /* Scan to write OP_Explain opcode for */
105830   int iLevel,                     /* Value for "level" column of output */
105831   int iFrom,                      /* Value for "from" column of output */
105832   u16 wctrlFlags                  /* Flags passed to sqlcipher3WhereBegin() */
105833 ){
105834   if( pParse->explain==2 ){
105835     u32 flags = pLevel->plan.wsFlags;
105836     struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
105837     Vdbe *v = pParse->pVdbe;      /* VM being constructed */
105838     sqlcipher3 *db = pParse->db;     /* Database handle */
105839     char *zMsg;                   /* Text to add to EQP output */
105840     sqlcipher3_int64 nRow;           /* Expected number of rows visited by scan */
105841     int iId = pParse->iSelectId;  /* Select id (left-most output column) */
105842     int isSearch;                 /* True for a SEARCH. False for SCAN. */
105843
105844     if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_ONETABLE_ONLY) ) return;
105845
105846     isSearch = (pLevel->plan.nEq>0)
105847              || (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0
105848              || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX));
105849
105850     zMsg = sqlcipher3MPrintf(db, "%s", isSearch?"SEARCH":"SCAN");
105851     if( pItem->pSelect ){
105852       zMsg = sqlcipher3MAppendf(db, zMsg, "%s SUBQUERY %d", zMsg,pItem->iSelectId);
105853     }else{
105854       zMsg = sqlcipher3MAppendf(db, zMsg, "%s TABLE %s", zMsg, pItem->zName);
105855     }
105856
105857     if( pItem->zAlias ){
105858       zMsg = sqlcipher3MAppendf(db, zMsg, "%s AS %s", zMsg, pItem->zAlias);
105859     }
105860     if( (flags & WHERE_INDEXED)!=0 ){
105861       char *zWhere = explainIndexRange(db, pLevel, pItem->pTab);
105862       zMsg = sqlcipher3MAppendf(db, zMsg, "%s USING %s%sINDEX%s%s%s", zMsg, 
105863           ((flags & WHERE_TEMP_INDEX)?"AUTOMATIC ":""),
105864           ((flags & WHERE_IDX_ONLY)?"COVERING ":""),
105865           ((flags & WHERE_TEMP_INDEX)?"":" "),
105866           ((flags & WHERE_TEMP_INDEX)?"": pLevel->plan.u.pIdx->zName),
105867           zWhere
105868       );
105869       sqlcipher3DbFree(db, zWhere);
105870     }else if( flags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
105871       zMsg = sqlcipher3MAppendf(db, zMsg, "%s USING INTEGER PRIMARY KEY", zMsg);
105872
105873       if( flags&WHERE_ROWID_EQ ){
105874         zMsg = sqlcipher3MAppendf(db, zMsg, "%s (rowid=?)", zMsg);
105875       }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){
105876         zMsg = sqlcipher3MAppendf(db, zMsg, "%s (rowid>? AND rowid<?)", zMsg);
105877       }else if( flags&WHERE_BTM_LIMIT ){
105878         zMsg = sqlcipher3MAppendf(db, zMsg, "%s (rowid>?)", zMsg);
105879       }else if( flags&WHERE_TOP_LIMIT ){
105880         zMsg = sqlcipher3MAppendf(db, zMsg, "%s (rowid<?)", zMsg);
105881       }
105882     }
105883 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
105884     else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
105885       sqlcipher3_index_info *pVtabIdx = pLevel->plan.u.pVtabIdx;
105886       zMsg = sqlcipher3MAppendf(db, zMsg, "%s VIRTUAL TABLE INDEX %d:%s", zMsg,
105887                   pVtabIdx->idxNum, pVtabIdx->idxStr);
105888     }
105889 #endif
105890     if( wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX) ){
105891       testcase( wctrlFlags & WHERE_ORDERBY_MIN );
105892       nRow = 1;
105893     }else{
105894       nRow = (sqlcipher3_int64)pLevel->plan.nRow;
105895     }
105896     zMsg = sqlcipher3MAppendf(db, zMsg, "%s (~%lld rows)", zMsg, nRow);
105897     sqlcipher3VdbeAddOp4(v, OP_Explain, iId, iLevel, iFrom, zMsg, P4_DYNAMIC);
105898   }
105899 }
105900 #else
105901 # define explainOneScan(u,v,w,x,y,z)
105902 #endif /* SQLCIPHER_OMIT_EXPLAIN */
105903
105904
105905 /*
105906 ** Generate code for the start of the iLevel-th loop in the WHERE clause
105907 ** implementation described by pWInfo.
105908 */
105909 static Bitmask codeOneLoopStart(
105910   WhereInfo *pWInfo,   /* Complete information about the WHERE clause */
105911   int iLevel,          /* Which level of pWInfo->a[] should be coded */
105912   u16 wctrlFlags,      /* One of the WHERE_* flags defined in sqlcipherInt.h */
105913   Bitmask notReady,    /* Which tables are currently available */
105914   Expr *pWhere         /* Complete WHERE clause */
105915 ){
105916   int j, k;            /* Loop counters */
105917   int iCur;            /* The VDBE cursor for the table */
105918   int addrNxt;         /* Where to jump to continue with the next IN case */
105919   int omitTable;       /* True if we use the index only */
105920   int bRev;            /* True if we need to scan in reverse order */
105921   WhereLevel *pLevel;  /* The where level to be coded */
105922   WhereClause *pWC;    /* Decomposition of the entire WHERE clause */
105923   WhereTerm *pTerm;               /* A WHERE clause term */
105924   Parse *pParse;                  /* Parsing context */
105925   Vdbe *v;                        /* The prepared stmt under constructions */
105926   struct SrcList_item *pTabItem;  /* FROM clause term being coded */
105927   int addrBrk;                    /* Jump here to break out of the loop */
105928   int addrCont;                   /* Jump here to continue with next cycle */
105929   int iRowidReg = 0;        /* Rowid is stored in this register, if not zero */
105930   int iReleaseReg = 0;      /* Temp register to free before returning */
105931
105932   pParse = pWInfo->pParse;
105933   v = pParse->pVdbe;
105934   pWC = pWInfo->pWC;
105935   pLevel = &pWInfo->a[iLevel];
105936   pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
105937   iCur = pTabItem->iCursor;
105938   bRev = (pLevel->plan.wsFlags & WHERE_REVERSE)!=0;
105939   omitTable = (pLevel->plan.wsFlags & WHERE_IDX_ONLY)!=0 
105940            && (wctrlFlags & WHERE_FORCE_TABLE)==0;
105941
105942   /* Create labels for the "break" and "continue" instructions
105943   ** for the current loop.  Jump to addrBrk to break out of a loop.
105944   ** Jump to cont to go immediately to the next iteration of the
105945   ** loop.
105946   **
105947   ** When there is an IN operator, we also have a "addrNxt" label that
105948   ** means to continue with the next IN value combination.  When
105949   ** there are no IN operators in the constraints, the "addrNxt" label
105950   ** is the same as "addrBrk".
105951   */
105952   addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlcipher3VdbeMakeLabel(v);
105953   addrCont = pLevel->addrCont = sqlcipher3VdbeMakeLabel(v);
105954
105955   /* If this is the right table of a LEFT OUTER JOIN, allocate and
105956   ** initialize a memory cell that records if this table matches any
105957   ** row of the left table of the join.
105958   */
105959   if( pLevel->iFrom>0 && (pTabItem[0].jointype & JT_LEFT)!=0 ){
105960     pLevel->iLeftJoin = ++pParse->nMem;
105961     sqlcipher3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
105962     VdbeComment((v, "init LEFT JOIN no-match flag"));
105963   }
105964
105965 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
105966   if(  (pLevel->plan.wsFlags & WHERE_VIRTUALTABLE)!=0 ){
105967     /* Case 0:  The table is a virtual-table.  Use the VFilter and VNext
105968     **          to access the data.
105969     */
105970     int iReg;   /* P3 Value for OP_VFilter */
105971     sqlcipher3_index_info *pVtabIdx = pLevel->plan.u.pVtabIdx;
105972     int nConstraint = pVtabIdx->nConstraint;
105973     struct sqlcipher3_index_constraint_usage *aUsage =
105974                                                 pVtabIdx->aConstraintUsage;
105975     const struct sqlcipher3_index_constraint *aConstraint =
105976                                                 pVtabIdx->aConstraint;
105977
105978     sqlcipher3ExprCachePush(pParse);
105979     iReg = sqlcipher3GetTempRange(pParse, nConstraint+2);
105980     for(j=1; j<=nConstraint; j++){
105981       for(k=0; k<nConstraint; k++){
105982         if( aUsage[k].argvIndex==j ){
105983           int iTerm = aConstraint[k].iTermOffset;
105984           sqlcipher3ExprCode(pParse, pWC->a[iTerm].pExpr->pRight, iReg+j+1);
105985           break;
105986         }
105987       }
105988       if( k==nConstraint ) break;
105989     }
105990     sqlcipher3VdbeAddOp2(v, OP_Integer, pVtabIdx->idxNum, iReg);
105991     sqlcipher3VdbeAddOp2(v, OP_Integer, j-1, iReg+1);
105992     sqlcipher3VdbeAddOp4(v, OP_VFilter, iCur, addrBrk, iReg, pVtabIdx->idxStr,
105993                       pVtabIdx->needToFreeIdxStr ? P4_MPRINTF : P4_STATIC);
105994     pVtabIdx->needToFreeIdxStr = 0;
105995     for(j=0; j<nConstraint; j++){
105996       if( aUsage[j].omit ){
105997         int iTerm = aConstraint[j].iTermOffset;
105998         disableTerm(pLevel, &pWC->a[iTerm]);
105999       }
106000     }
106001     pLevel->op = OP_VNext;
106002     pLevel->p1 = iCur;
106003     pLevel->p2 = sqlcipher3VdbeCurrentAddr(v);
106004     sqlcipher3ReleaseTempRange(pParse, iReg, nConstraint+2);
106005     sqlcipher3ExprCachePop(pParse, 1);
106006   }else
106007 #endif /* SQLCIPHER_OMIT_VIRTUALTABLE */
106008
106009   if( pLevel->plan.wsFlags & WHERE_ROWID_EQ ){
106010     /* Case 1:  We can directly reference a single row using an
106011     **          equality comparison against the ROWID field.  Or
106012     **          we reference multiple rows using a "rowid IN (...)"
106013     **          construct.
106014     */
106015     iReleaseReg = sqlcipher3GetTempReg(pParse);
106016     pTerm = findTerm(pWC, iCur, -1, notReady, WO_EQ|WO_IN, 0);
106017     assert( pTerm!=0 );
106018     assert( pTerm->pExpr!=0 );
106019     assert( pTerm->leftCursor==iCur );
106020     assert( omitTable==0 );
106021     testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106022     iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, iReleaseReg);
106023     addrNxt = pLevel->addrNxt;
106024     sqlcipher3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt);
106025     sqlcipher3VdbeAddOp3(v, OP_NotExists, iCur, addrNxt, iRowidReg);
106026     sqlcipher3ExprCacheStore(pParse, iCur, -1, iRowidReg);
106027     VdbeComment((v, "pk"));
106028     pLevel->op = OP_Noop;
106029   }else if( pLevel->plan.wsFlags & WHERE_ROWID_RANGE ){
106030     /* Case 2:  We have an inequality comparison against the ROWID field.
106031     */
106032     int testOp = OP_Noop;
106033     int start;
106034     int memEndValue = 0;
106035     WhereTerm *pStart, *pEnd;
106036
106037     assert( omitTable==0 );
106038     pStart = findTerm(pWC, iCur, -1, notReady, WO_GT|WO_GE, 0);
106039     pEnd = findTerm(pWC, iCur, -1, notReady, WO_LT|WO_LE, 0);
106040     if( bRev ){
106041       pTerm = pStart;
106042       pStart = pEnd;
106043       pEnd = pTerm;
106044     }
106045     if( pStart ){
106046       Expr *pX;             /* The expression that defines the start bound */
106047       int r1, rTemp;        /* Registers for holding the start boundary */
106048
106049       /* The following constant maps TK_xx codes into corresponding 
106050       ** seek opcodes.  It depends on a particular ordering of TK_xx
106051       */
106052       const u8 aMoveOp[] = {
106053            /* TK_GT */  OP_SeekGt,
106054            /* TK_LE */  OP_SeekLe,
106055            /* TK_LT */  OP_SeekLt,
106056            /* TK_GE */  OP_SeekGe
106057       };
106058       assert( TK_LE==TK_GT+1 );      /* Make sure the ordering.. */
106059       assert( TK_LT==TK_GT+2 );      /*  ... of the TK_xx values... */
106060       assert( TK_GE==TK_GT+3 );      /*  ... is correcct. */
106061
106062       testcase( pStart->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106063       pX = pStart->pExpr;
106064       assert( pX!=0 );
106065       assert( pStart->leftCursor==iCur );
106066       r1 = sqlcipher3ExprCodeTemp(pParse, pX->pRight, &rTemp);
106067       sqlcipher3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1);
106068       VdbeComment((v, "pk"));
106069       sqlcipher3ExprCacheAffinityChange(pParse, r1, 1);
106070       sqlcipher3ReleaseTempReg(pParse, rTemp);
106071       disableTerm(pLevel, pStart);
106072     }else{
106073       sqlcipher3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk);
106074     }
106075     if( pEnd ){
106076       Expr *pX;
106077       pX = pEnd->pExpr;
106078       assert( pX!=0 );
106079       assert( pEnd->leftCursor==iCur );
106080       testcase( pEnd->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106081       memEndValue = ++pParse->nMem;
106082       sqlcipher3ExprCode(pParse, pX->pRight, memEndValue);
106083       if( pX->op==TK_LT || pX->op==TK_GT ){
106084         testOp = bRev ? OP_Le : OP_Ge;
106085       }else{
106086         testOp = bRev ? OP_Lt : OP_Gt;
106087       }
106088       disableTerm(pLevel, pEnd);
106089     }
106090     start = sqlcipher3VdbeCurrentAddr(v);
106091     pLevel->op = bRev ? OP_Prev : OP_Next;
106092     pLevel->p1 = iCur;
106093     pLevel->p2 = start;
106094     if( pStart==0 && pEnd==0 ){
106095       pLevel->p5 = SQLCIPHER_STMTSTATUS_FULLSCAN_STEP;
106096     }else{
106097       assert( pLevel->p5==0 );
106098     }
106099     if( testOp!=OP_Noop ){
106100       iRowidReg = iReleaseReg = sqlcipher3GetTempReg(pParse);
106101       sqlcipher3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
106102       sqlcipher3ExprCacheStore(pParse, iCur, -1, iRowidReg);
106103       sqlcipher3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg);
106104       sqlcipher3VdbeChangeP5(v, SQLCIPHER_AFF_NUMERIC | SQLCIPHER_JUMPIFNULL);
106105     }
106106   }else if( pLevel->plan.wsFlags & (WHERE_COLUMN_RANGE|WHERE_COLUMN_EQ) ){
106107     /* Case 3: A scan using an index.
106108     **
106109     **         The WHERE clause may contain zero or more equality 
106110     **         terms ("==" or "IN" operators) that refer to the N
106111     **         left-most columns of the index. It may also contain
106112     **         inequality constraints (>, <, >= or <=) on the indexed
106113     **         column that immediately follows the N equalities. Only 
106114     **         the right-most column can be an inequality - the rest must
106115     **         use the "==" and "IN" operators. For example, if the 
106116     **         index is on (x,y,z), then the following clauses are all 
106117     **         optimized:
106118     **
106119     **            x=5
106120     **            x=5 AND y=10
106121     **            x=5 AND y<10
106122     **            x=5 AND y>5 AND y<10
106123     **            x=5 AND y=5 AND z<=10
106124     **
106125     **         The z<10 term of the following cannot be used, only
106126     **         the x=5 term:
106127     **
106128     **            x=5 AND z<10
106129     **
106130     **         N may be zero if there are inequality constraints.
106131     **         If there are no inequality constraints, then N is at
106132     **         least one.
106133     **
106134     **         This case is also used when there are no WHERE clause
106135     **         constraints but an index is selected anyway, in order
106136     **         to force the output order to conform to an ORDER BY.
106137     */  
106138     static const u8 aStartOp[] = {
106139       0,
106140       0,
106141       OP_Rewind,           /* 2: (!start_constraints && startEq &&  !bRev) */
106142       OP_Last,             /* 3: (!start_constraints && startEq &&   bRev) */
106143       OP_SeekGt,           /* 4: (start_constraints  && !startEq && !bRev) */
106144       OP_SeekLt,           /* 5: (start_constraints  && !startEq &&  bRev) */
106145       OP_SeekGe,           /* 6: (start_constraints  &&  startEq && !bRev) */
106146       OP_SeekLe            /* 7: (start_constraints  &&  startEq &&  bRev) */
106147     };
106148     static const u8 aEndOp[] = {
106149       OP_Noop,             /* 0: (!end_constraints) */
106150       OP_IdxGE,            /* 1: (end_constraints && !bRev) */
106151       OP_IdxLT             /* 2: (end_constraints && bRev) */
106152     };
106153     int nEq = pLevel->plan.nEq;  /* Number of == or IN terms */
106154     int isMinQuery = 0;          /* If this is an optimized SELECT min(x).. */
106155     int regBase;                 /* Base register holding constraint values */
106156     int r1;                      /* Temp register */
106157     WhereTerm *pRangeStart = 0;  /* Inequality constraint at range start */
106158     WhereTerm *pRangeEnd = 0;    /* Inequality constraint at range end */
106159     int startEq;                 /* True if range start uses ==, >= or <= */
106160     int endEq;                   /* True if range end uses ==, >= or <= */
106161     int start_constraints;       /* Start of range is constrained */
106162     int nConstraint;             /* Number of constraint terms */
106163     Index *pIdx;                 /* The index we will be using */
106164     int iIdxCur;                 /* The VDBE cursor for the index */
106165     int nExtraReg = 0;           /* Number of extra registers needed */
106166     int op;                      /* Instruction opcode */
106167     char *zStartAff;             /* Affinity for start of range constraint */
106168     char *zEndAff;               /* Affinity for end of range constraint */
106169
106170     pIdx = pLevel->plan.u.pIdx;
106171     iIdxCur = pLevel->iIdxCur;
106172     k = pIdx->aiColumn[nEq];     /* Column for inequality constraints */
106173
106174     /* If this loop satisfies a sort order (pOrderBy) request that 
106175     ** was passed to this function to implement a "SELECT min(x) ..." 
106176     ** query, then the caller will only allow the loop to run for
106177     ** a single iteration. This means that the first row returned
106178     ** should not have a NULL value stored in 'x'. If column 'x' is
106179     ** the first one after the nEq equality constraints in the index,
106180     ** this requires some special handling.
106181     */
106182     if( (wctrlFlags&WHERE_ORDERBY_MIN)!=0
106183      && (pLevel->plan.wsFlags&WHERE_ORDERBY)
106184      && (pIdx->nColumn>nEq)
106185     ){
106186       /* assert( pOrderBy->nExpr==1 ); */
106187       /* assert( pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq] ); */
106188       isMinQuery = 1;
106189       nExtraReg = 1;
106190     }
106191
106192     /* Find any inequality constraint terms for the start and end 
106193     ** of the range. 
106194     */
106195     if( pLevel->plan.wsFlags & WHERE_TOP_LIMIT ){
106196       pRangeEnd = findTerm(pWC, iCur, k, notReady, (WO_LT|WO_LE), pIdx);
106197       nExtraReg = 1;
106198     }
106199     if( pLevel->plan.wsFlags & WHERE_BTM_LIMIT ){
106200       pRangeStart = findTerm(pWC, iCur, k, notReady, (WO_GT|WO_GE), pIdx);
106201       nExtraReg = 1;
106202     }
106203
106204     /* Generate code to evaluate all constraint terms using == or IN
106205     ** and store the values of those terms in an array of registers
106206     ** starting at regBase.
106207     */
106208     regBase = codeAllEqualityTerms(
106209         pParse, pLevel, pWC, notReady, nExtraReg, &zStartAff
106210     );
106211     zEndAff = sqlcipher3DbStrDup(pParse->db, zStartAff);
106212     addrNxt = pLevel->addrNxt;
106213
106214     /* If we are doing a reverse order scan on an ascending index, or
106215     ** a forward order scan on a descending index, interchange the 
106216     ** start and end terms (pRangeStart and pRangeEnd).
106217     */
106218     if( nEq<pIdx->nColumn && bRev==(pIdx->aSortOrder[nEq]==SQLCIPHER_SO_ASC) ){
106219       SWAP(WhereTerm *, pRangeEnd, pRangeStart);
106220     }
106221
106222     testcase( pRangeStart && pRangeStart->eOperator & WO_LE );
106223     testcase( pRangeStart && pRangeStart->eOperator & WO_GE );
106224     testcase( pRangeEnd && pRangeEnd->eOperator & WO_LE );
106225     testcase( pRangeEnd && pRangeEnd->eOperator & WO_GE );
106226     startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE);
106227     endEq =   !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE);
106228     start_constraints = pRangeStart || nEq>0;
106229
106230     /* Seek the index cursor to the start of the range. */
106231     nConstraint = nEq;
106232     if( pRangeStart ){
106233       Expr *pRight = pRangeStart->pExpr->pRight;
106234       sqlcipher3ExprCode(pParse, pRight, regBase+nEq);
106235       if( (pRangeStart->wtFlags & TERM_VNULL)==0 ){
106236         sqlcipher3ExprCodeIsNullJump(v, pRight, regBase+nEq, addrNxt);
106237       }
106238       if( zStartAff ){
106239         if( sqlcipher3CompareAffinity(pRight, zStartAff[nEq])==SQLCIPHER_AFF_NONE){
106240           /* Since the comparison is to be performed with no conversions
106241           ** applied to the operands, set the affinity to apply to pRight to 
106242           ** SQLCIPHER_AFF_NONE.  */
106243           zStartAff[nEq] = SQLCIPHER_AFF_NONE;
106244         }
106245         if( sqlcipher3ExprNeedsNoAffinityChange(pRight, zStartAff[nEq]) ){
106246           zStartAff[nEq] = SQLCIPHER_AFF_NONE;
106247         }
106248       }  
106249       nConstraint++;
106250       testcase( pRangeStart->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106251     }else if( isMinQuery ){
106252       sqlcipher3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
106253       nConstraint++;
106254       startEq = 0;
106255       start_constraints = 1;
106256     }
106257     codeApplyAffinity(pParse, regBase, nConstraint, zStartAff);
106258     op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
106259     assert( op!=0 );
106260     testcase( op==OP_Rewind );
106261     testcase( op==OP_Last );
106262     testcase( op==OP_SeekGt );
106263     testcase( op==OP_SeekGe );
106264     testcase( op==OP_SeekLe );
106265     testcase( op==OP_SeekLt );
106266     sqlcipher3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
106267
106268     /* Load the value for the inequality constraint at the end of the
106269     ** range (if any).
106270     */
106271     nConstraint = nEq;
106272     if( pRangeEnd ){
106273       Expr *pRight = pRangeEnd->pExpr->pRight;
106274       sqlcipher3ExprCacheRemove(pParse, regBase+nEq, 1);
106275       sqlcipher3ExprCode(pParse, pRight, regBase+nEq);
106276       if( (pRangeEnd->wtFlags & TERM_VNULL)==0 ){
106277         sqlcipher3ExprCodeIsNullJump(v, pRight, regBase+nEq, addrNxt);
106278       }
106279       if( zEndAff ){
106280         if( sqlcipher3CompareAffinity(pRight, zEndAff[nEq])==SQLCIPHER_AFF_NONE){
106281           /* Since the comparison is to be performed with no conversions
106282           ** applied to the operands, set the affinity to apply to pRight to 
106283           ** SQLCIPHER_AFF_NONE.  */
106284           zEndAff[nEq] = SQLCIPHER_AFF_NONE;
106285         }
106286         if( sqlcipher3ExprNeedsNoAffinityChange(pRight, zEndAff[nEq]) ){
106287           zEndAff[nEq] = SQLCIPHER_AFF_NONE;
106288         }
106289       }  
106290       codeApplyAffinity(pParse, regBase, nEq+1, zEndAff);
106291       nConstraint++;
106292       testcase( pRangeEnd->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106293     }
106294     sqlcipher3DbFree(pParse->db, zStartAff);
106295     sqlcipher3DbFree(pParse->db, zEndAff);
106296
106297     /* Top of the loop body */
106298     pLevel->p2 = sqlcipher3VdbeCurrentAddr(v);
106299
106300     /* Check if the index cursor is past the end of the range. */
106301     op = aEndOp[(pRangeEnd || nEq) * (1 + bRev)];
106302     testcase( op==OP_Noop );
106303     testcase( op==OP_IdxGE );
106304     testcase( op==OP_IdxLT );
106305     if( op!=OP_Noop ){
106306       sqlcipher3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
106307       sqlcipher3VdbeChangeP5(v, endEq!=bRev ?1:0);
106308     }
106309
106310     /* If there are inequality constraints, check that the value
106311     ** of the table column that the inequality contrains is not NULL.
106312     ** If it is, jump to the next iteration of the loop.
106313     */
106314     r1 = sqlcipher3GetTempReg(pParse);
106315     testcase( pLevel->plan.wsFlags & WHERE_BTM_LIMIT );
106316     testcase( pLevel->plan.wsFlags & WHERE_TOP_LIMIT );
106317     if( (pLevel->plan.wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 ){
106318       sqlcipher3VdbeAddOp3(v, OP_Column, iIdxCur, nEq, r1);
106319       sqlcipher3VdbeAddOp2(v, OP_IsNull, r1, addrCont);
106320     }
106321     sqlcipher3ReleaseTempReg(pParse, r1);
106322
106323     /* Seek the table cursor, if required */
106324     disableTerm(pLevel, pRangeStart);
106325     disableTerm(pLevel, pRangeEnd);
106326     if( !omitTable ){
106327       iRowidReg = iReleaseReg = sqlcipher3GetTempReg(pParse);
106328       sqlcipher3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
106329       sqlcipher3ExprCacheStore(pParse, iCur, -1, iRowidReg);
106330       sqlcipher3VdbeAddOp2(v, OP_Seek, iCur, iRowidReg);  /* Deferred seek */
106331     }
106332
106333     /* Record the instruction used to terminate the loop. Disable 
106334     ** WHERE clause terms made redundant by the index range scan.
106335     */
106336     if( pLevel->plan.wsFlags & WHERE_UNIQUE ){
106337       pLevel->op = OP_Noop;
106338     }else if( bRev ){
106339       pLevel->op = OP_Prev;
106340     }else{
106341       pLevel->op = OP_Next;
106342     }
106343     pLevel->p1 = iIdxCur;
106344   }else
106345
106346 #ifndef SQLCIPHER_OMIT_OR_OPTIMIZATION
106347   if( pLevel->plan.wsFlags & WHERE_MULTI_OR ){
106348     /* Case 4:  Two or more separately indexed terms connected by OR
106349     **
106350     ** Example:
106351     **
106352     **   CREATE TABLE t1(a,b,c,d);
106353     **   CREATE INDEX i1 ON t1(a);
106354     **   CREATE INDEX i2 ON t1(b);
106355     **   CREATE INDEX i3 ON t1(c);
106356     **
106357     **   SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13)
106358     **
106359     ** In the example, there are three indexed terms connected by OR.
106360     ** The top of the loop looks like this:
106361     **
106362     **          Null       1                # Zero the rowset in reg 1
106363     **
106364     ** Then, for each indexed term, the following. The arguments to
106365     ** RowSetTest are such that the rowid of the current row is inserted
106366     ** into the RowSet. If it is already present, control skips the
106367     ** Gosub opcode and jumps straight to the code generated by WhereEnd().
106368     **
106369     **        sqlcipher3WhereBegin(<term>)
106370     **          RowSetTest                  # Insert rowid into rowset
106371     **          Gosub      2 A
106372     **        sqlcipher3WhereEnd()
106373     **
106374     ** Following the above, code to terminate the loop. Label A, the target
106375     ** of the Gosub above, jumps to the instruction right after the Goto.
106376     **
106377     **          Null       1                # Zero the rowset in reg 1
106378     **          Goto       B                # The loop is finished.
106379     **
106380     **       A: <loop body>                 # Return data, whatever.
106381     **
106382     **          Return     2                # Jump back to the Gosub
106383     **
106384     **       B: <after the loop>
106385     **
106386     */
106387     WhereClause *pOrWc;    /* The OR-clause broken out into subterms */
106388     SrcList *pOrTab;       /* Shortened table list or OR-clause generation */
106389
106390     int regReturn = ++pParse->nMem;           /* Register used with OP_Gosub */
106391     int regRowset = 0;                        /* Register for RowSet object */
106392     int regRowid = 0;                         /* Register holding rowid */
106393     int iLoopBody = sqlcipher3VdbeMakeLabel(v);  /* Start of loop body */
106394     int iRetInit;                             /* Address of regReturn init */
106395     int untestedTerms = 0;             /* Some terms not completely tested */
106396     int ii;                            /* Loop counter */
106397     Expr *pAndExpr = 0;                /* An ".. AND (...)" expression */
106398    
106399     pTerm = pLevel->plan.u.pTerm;
106400     assert( pTerm!=0 );
106401     assert( pTerm->eOperator==WO_OR );
106402     assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
106403     pOrWc = &pTerm->u.pOrInfo->wc;
106404     pLevel->op = OP_Return;
106405     pLevel->p1 = regReturn;
106406
106407     /* Set up a new SrcList ni pOrTab containing the table being scanned
106408     ** by this loop in the a[0] slot and all notReady tables in a[1..] slots.
106409     ** This becomes the SrcList in the recursive call to sqlcipher3WhereBegin().
106410     */
106411     if( pWInfo->nLevel>1 ){
106412       int nNotReady;                 /* The number of notReady tables */
106413       struct SrcList_item *origSrc;     /* Original list of tables */
106414       nNotReady = pWInfo->nLevel - iLevel - 1;
106415       pOrTab = sqlcipher3StackAllocRaw(pParse->db,
106416                             sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0]));
106417       if( pOrTab==0 ) return notReady;
106418       pOrTab->nAlloc = (i16)(nNotReady + 1);
106419       pOrTab->nSrc = pOrTab->nAlloc;
106420       memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem));
106421       origSrc = pWInfo->pTabList->a;
106422       for(k=1; k<=nNotReady; k++){
106423         memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k]));
106424       }
106425     }else{
106426       pOrTab = pWInfo->pTabList;
106427     }
106428
106429     /* Initialize the rowset register to contain NULL. An SQL NULL is 
106430     ** equivalent to an empty rowset.
106431     **
106432     ** Also initialize regReturn to contain the address of the instruction 
106433     ** immediately following the OP_Return at the bottom of the loop. This
106434     ** is required in a few obscure LEFT JOIN cases where control jumps
106435     ** over the top of the loop into the body of it. In this case the 
106436     ** correct response for the end-of-loop code (the OP_Return) is to 
106437     ** fall through to the next instruction, just as an OP_Next does if
106438     ** called on an uninitialized cursor.
106439     */
106440     if( (wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
106441       regRowset = ++pParse->nMem;
106442       regRowid = ++pParse->nMem;
106443       sqlcipher3VdbeAddOp2(v, OP_Null, 0, regRowset);
106444     }
106445     iRetInit = sqlcipher3VdbeAddOp2(v, OP_Integer, 0, regReturn);
106446
106447     /* If the original WHERE clause is z of the form:  (x1 OR x2 OR ...) AND y
106448     ** Then for every term xN, evaluate as the subexpression: xN AND z
106449     ** That way, terms in y that are factored into the disjunction will
106450     ** be picked up by the recursive calls to sqlcipher3WhereBegin() below.
106451     */
106452     if( pWC->nTerm>1 ){
106453       pAndExpr = sqlcipher3ExprAlloc(pParse->db, TK_AND, 0, 0);
106454       pAndExpr->pRight = pWhere;
106455     }
106456
106457     for(ii=0; ii<pOrWc->nTerm; ii++){
106458       WhereTerm *pOrTerm = &pOrWc->a[ii];
106459       if( pOrTerm->leftCursor==iCur || pOrTerm->eOperator==WO_AND ){
106460         WhereInfo *pSubWInfo;          /* Info for single OR-term scan */
106461         Expr *pOrExpr = pOrTerm->pExpr;
106462         if( pAndExpr ){
106463           pAndExpr->pLeft = pOrExpr;
106464           pOrExpr = pAndExpr;
106465         }
106466         /* Loop through table entries that match term pOrTerm. */
106467         pSubWInfo = sqlcipher3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
106468                         WHERE_OMIT_OPEN_CLOSE | WHERE_AND_ONLY |
106469                         WHERE_FORCE_TABLE | WHERE_ONETABLE_ONLY);
106470         if( pSubWInfo ){
106471           explainOneScan(
106472               pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0
106473           );
106474           if( (wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
106475             int iSet = ((ii==pOrWc->nTerm-1)?-1:ii);
106476             int r;
106477             r = sqlcipher3ExprCodeGetColumn(pParse, pTabItem->pTab, -1, iCur, 
106478                                          regRowid);
106479             sqlcipher3VdbeAddOp4Int(v, OP_RowSetTest, regRowset,
106480                                  sqlcipher3VdbeCurrentAddr(v)+2, r, iSet);
106481           }
106482           sqlcipher3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody);
106483
106484           /* The pSubWInfo->untestedTerms flag means that this OR term
106485           ** contained one or more AND term from a notReady table.  The
106486           ** terms from the notReady table could not be tested and will
106487           ** need to be tested later.
106488           */
106489           if( pSubWInfo->untestedTerms ) untestedTerms = 1;
106490
106491           /* Finish the loop through table entries that match term pOrTerm. */
106492           sqlcipher3WhereEnd(pSubWInfo);
106493         }
106494       }
106495     }
106496     sqlcipher3DbFree(pParse->db, pAndExpr);
106497     sqlcipher3VdbeChangeP1(v, iRetInit, sqlcipher3VdbeCurrentAddr(v));
106498     sqlcipher3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrBrk);
106499     sqlcipher3VdbeResolveLabel(v, iLoopBody);
106500
106501     if( pWInfo->nLevel>1 ) sqlcipher3StackFree(pParse->db, pOrTab);
106502     if( !untestedTerms ) disableTerm(pLevel, pTerm);
106503   }else
106504 #endif /* SQLCIPHER_OMIT_OR_OPTIMIZATION */
106505
106506   {
106507     /* Case 5:  There is no usable index.  We must do a complete
106508     **          scan of the entire table.
106509     */
106510     static const u8 aStep[] = { OP_Next, OP_Prev };
106511     static const u8 aStart[] = { OP_Rewind, OP_Last };
106512     assert( bRev==0 || bRev==1 );
106513     assert( omitTable==0 );
106514     pLevel->op = aStep[bRev];
106515     pLevel->p1 = iCur;
106516     pLevel->p2 = 1 + sqlcipher3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
106517     pLevel->p5 = SQLCIPHER_STMTSTATUS_FULLSCAN_STEP;
106518   }
106519   notReady &= ~getMask(pWC->pMaskSet, iCur);
106520
106521   /* Insert code to test every subexpression that can be completely
106522   ** computed using the current set of tables.
106523   **
106524   ** IMPLEMENTATION-OF: R-49525-50935 Terms that cannot be satisfied through
106525   ** the use of indices become tests that are evaluated against each row of
106526   ** the relevant input tables.
106527   */
106528   for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
106529     Expr *pE;
106530     testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* IMP: R-30575-11662 */
106531     testcase( pTerm->wtFlags & TERM_CODED );
106532     if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
106533     if( (pTerm->prereqAll & notReady)!=0 ){
106534       testcase( pWInfo->untestedTerms==0
106535                && (pWInfo->wctrlFlags & WHERE_ONETABLE_ONLY)!=0 );
106536       pWInfo->untestedTerms = 1;
106537       continue;
106538     }
106539     pE = pTerm->pExpr;
106540     assert( pE!=0 );
106541     if( pLevel->iLeftJoin && !ExprHasProperty(pE, EP_FromJoin) ){
106542       continue;
106543     }
106544     sqlcipher3ExprIfFalse(pParse, pE, addrCont, SQLCIPHER_JUMPIFNULL);
106545     pTerm->wtFlags |= TERM_CODED;
106546   }
106547
106548   /* For a LEFT OUTER JOIN, generate code that will record the fact that
106549   ** at least one row of the right table has matched the left table.  
106550   */
106551   if( pLevel->iLeftJoin ){
106552     pLevel->addrFirst = sqlcipher3VdbeCurrentAddr(v);
106553     sqlcipher3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
106554     VdbeComment((v, "record LEFT JOIN hit"));
106555     sqlcipher3ExprCacheClear(pParse);
106556     for(pTerm=pWC->a, j=0; j<pWC->nTerm; j++, pTerm++){
106557       testcase( pTerm->wtFlags & TERM_VIRTUAL );  /* IMP: R-30575-11662 */
106558       testcase( pTerm->wtFlags & TERM_CODED );
106559       if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
106560       if( (pTerm->prereqAll & notReady)!=0 ){
106561         assert( pWInfo->untestedTerms );
106562         continue;
106563       }
106564       assert( pTerm->pExpr );
106565       sqlcipher3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLCIPHER_JUMPIFNULL);
106566       pTerm->wtFlags |= TERM_CODED;
106567     }
106568   }
106569   sqlcipher3ReleaseTempReg(pParse, iReleaseReg);
106570
106571   return notReady;
106572 }
106573
106574 #if defined(SQLCIPHER_TEST)
106575 /*
106576 ** The following variable holds a text description of query plan generated
106577 ** by the most recent call to sqlcipher3WhereBegin().  Each call to WhereBegin
106578 ** overwrites the previous.  This information is used for testing and
106579 ** analysis only.
106580 */
106581 SQLCIPHER_API char sqlcipher3_query_plan[BMS*2*40];  /* Text of the join */
106582 static int nQPlan = 0;              /* Next free slow in _query_plan[] */
106583
106584 #endif /* SQLCIPHER_TEST */
106585
106586
106587 /*
106588 ** Free a WhereInfo structure
106589 */
106590 static void whereInfoFree(sqlcipher3 *db, WhereInfo *pWInfo){
106591   if( ALWAYS(pWInfo) ){
106592     int i;
106593     for(i=0; i<pWInfo->nLevel; i++){
106594       sqlcipher3_index_info *pInfo = pWInfo->a[i].pIdxInfo;
106595       if( pInfo ){
106596         /* assert( pInfo->needToFreeIdxStr==0 || db->mallocFailed ); */
106597         if( pInfo->needToFreeIdxStr ){
106598           sqlcipher3_free(pInfo->idxStr);
106599         }
106600         sqlcipher3DbFree(db, pInfo);
106601       }
106602       if( pWInfo->a[i].plan.wsFlags & WHERE_TEMP_INDEX ){
106603         Index *pIdx = pWInfo->a[i].plan.u.pIdx;
106604         if( pIdx ){
106605           sqlcipher3DbFree(db, pIdx->zColAff);
106606           sqlcipher3DbFree(db, pIdx);
106607         }
106608       }
106609     }
106610     whereClauseClear(pWInfo->pWC);
106611     sqlcipher3DbFree(db, pWInfo);
106612   }
106613 }
106614
106615
106616 /*
106617 ** Generate the beginning of the loop used for WHERE clause processing.
106618 ** The return value is a pointer to an opaque structure that contains
106619 ** information needed to terminate the loop.  Later, the calling routine
106620 ** should invoke sqlcipher3WhereEnd() with the return value of this function
106621 ** in order to complete the WHERE clause processing.
106622 **
106623 ** If an error occurs, this routine returns NULL.
106624 **
106625 ** The basic idea is to do a nested loop, one loop for each table in
106626 ** the FROM clause of a select.  (INSERT and UPDATE statements are the
106627 ** same as a SELECT with only a single table in the FROM clause.)  For
106628 ** example, if the SQL is this:
106629 **
106630 **       SELECT * FROM t1, t2, t3 WHERE ...;
106631 **
106632 ** Then the code generated is conceptually like the following:
106633 **
106634 **      foreach row1 in t1 do       \    Code generated
106635 **        foreach row2 in t2 do      |-- by sqlcipher3WhereBegin()
106636 **          foreach row3 in t3 do   /
106637 **            ...
106638 **          end                     \    Code generated
106639 **        end                        |-- by sqlcipher3WhereEnd()
106640 **      end                         /
106641 **
106642 ** Note that the loops might not be nested in the order in which they
106643 ** appear in the FROM clause if a different order is better able to make
106644 ** use of indices.  Note also that when the IN operator appears in
106645 ** the WHERE clause, it might result in additional nested loops for
106646 ** scanning through all values on the right-hand side of the IN.
106647 **
106648 ** There are Btree cursors associated with each table.  t1 uses cursor
106649 ** number pTabList->a[0].iCursor.  t2 uses the cursor pTabList->a[1].iCursor.
106650 ** And so forth.  This routine generates code to open those VDBE cursors
106651 ** and sqlcipher3WhereEnd() generates the code to close them.
106652 **
106653 ** The code that sqlcipher3WhereBegin() generates leaves the cursors named
106654 ** in pTabList pointing at their appropriate entries.  The [...] code
106655 ** can use OP_Column and OP_Rowid opcodes on these cursors to extract
106656 ** data from the various tables of the loop.
106657 **
106658 ** If the WHERE clause is empty, the foreach loops must each scan their
106659 ** entire tables.  Thus a three-way join is an O(N^3) operation.  But if
106660 ** the tables have indices and there are terms in the WHERE clause that
106661 ** refer to those indices, a complete table scan can be avoided and the
106662 ** code will run much faster.  Most of the work of this routine is checking
106663 ** to see if there are indices that can be used to speed up the loop.
106664 **
106665 ** Terms of the WHERE clause are also used to limit which rows actually
106666 ** make it to the "..." in the middle of the loop.  After each "foreach",
106667 ** terms of the WHERE clause that use only terms in that loop and outer
106668 ** loops are evaluated and if false a jump is made around all subsequent
106669 ** inner loops (or around the "..." if the test occurs within the inner-
106670 ** most loop)
106671 **
106672 ** OUTER JOINS
106673 **
106674 ** An outer join of tables t1 and t2 is conceptally coded as follows:
106675 **
106676 **    foreach row1 in t1 do
106677 **      flag = 0
106678 **      foreach row2 in t2 do
106679 **        start:
106680 **          ...
106681 **          flag = 1
106682 **      end
106683 **      if flag==0 then
106684 **        move the row2 cursor to a null row
106685 **        goto start
106686 **      fi
106687 **    end
106688 **
106689 ** ORDER BY CLAUSE PROCESSING
106690 **
106691 ** *ppOrderBy is a pointer to the ORDER BY clause of a SELECT statement,
106692 ** if there is one.  If there is no ORDER BY clause or if this routine
106693 ** is called from an UPDATE or DELETE statement, then ppOrderBy is NULL.
106694 **
106695 ** If an index can be used so that the natural output order of the table
106696 ** scan is correct for the ORDER BY clause, then that index is used and
106697 ** *ppOrderBy is set to NULL.  This is an optimization that prevents an
106698 ** unnecessary sort of the result set if an index appropriate for the
106699 ** ORDER BY clause already exists.
106700 **
106701 ** If the where clause loops cannot be arranged to provide the correct
106702 ** output order, then the *ppOrderBy is unchanged.
106703 */
106704 SQLCIPHER_PRIVATE WhereInfo *sqlcipher3WhereBegin(
106705   Parse *pParse,        /* The parser context */
106706   SrcList *pTabList,    /* A list of all tables to be scanned */
106707   Expr *pWhere,         /* The WHERE clause */
106708   ExprList **ppOrderBy, /* An ORDER BY clause, or NULL */
106709   ExprList *pDistinct,  /* The select-list for DISTINCT queries - or NULL */
106710   u16 wctrlFlags        /* One of the WHERE_* flags defined in sqlcipherInt.h */
106711 ){
106712   int i;                     /* Loop counter */
106713   int nByteWInfo;            /* Num. bytes allocated for WhereInfo struct */
106714   int nTabList;              /* Number of elements in pTabList */
106715   WhereInfo *pWInfo;         /* Will become the return value of this function */
106716   Vdbe *v = pParse->pVdbe;   /* The virtual database engine */
106717   Bitmask notReady;          /* Cursors that are not yet positioned */
106718   WhereMaskSet *pMaskSet;    /* The expression mask set */
106719   WhereClause *pWC;               /* Decomposition of the WHERE clause */
106720   struct SrcList_item *pTabItem;  /* A single entry from pTabList */
106721   WhereLevel *pLevel;             /* A single level in the pWInfo list */
106722   int iFrom;                      /* First unused FROM clause element */
106723   int andFlags;              /* AND-ed combination of all pWC->a[].wtFlags */
106724   sqlcipher3 *db;               /* Database connection */
106725
106726   /* The number of tables in the FROM clause is limited by the number of
106727   ** bits in a Bitmask 
106728   */
106729   testcase( pTabList->nSrc==BMS );
106730   if( pTabList->nSrc>BMS ){
106731     sqlcipher3ErrorMsg(pParse, "at most %d tables in a join", BMS);
106732     return 0;
106733   }
106734
106735   /* This function normally generates a nested loop for all tables in 
106736   ** pTabList.  But if the WHERE_ONETABLE_ONLY flag is set, then we should
106737   ** only generate code for the first table in pTabList and assume that
106738   ** any cursors associated with subsequent tables are uninitialized.
106739   */
106740   nTabList = (wctrlFlags & WHERE_ONETABLE_ONLY) ? 1 : pTabList->nSrc;
106741
106742   /* Allocate and initialize the WhereInfo structure that will become the
106743   ** return value. A single allocation is used to store the WhereInfo
106744   ** struct, the contents of WhereInfo.a[], the WhereClause structure
106745   ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
106746   ** field (type Bitmask) it must be aligned on an 8-byte boundary on
106747   ** some architectures. Hence the ROUND8() below.
106748   */
106749   db = pParse->db;
106750   nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel));
106751   pWInfo = sqlcipher3DbMallocZero(db, 
106752       nByteWInfo + 
106753       sizeof(WhereClause) +
106754       sizeof(WhereMaskSet)
106755   );
106756   if( db->mallocFailed ){
106757     sqlcipher3DbFree(db, pWInfo);
106758     pWInfo = 0;
106759     goto whereBeginError;
106760   }
106761   pWInfo->nLevel = nTabList;
106762   pWInfo->pParse = pParse;
106763   pWInfo->pTabList = pTabList;
106764   pWInfo->iBreak = sqlcipher3VdbeMakeLabel(v);
106765   pWInfo->pWC = pWC = (WhereClause *)&((u8 *)pWInfo)[nByteWInfo];
106766   pWInfo->wctrlFlags = wctrlFlags;
106767   pWInfo->savedNQueryLoop = pParse->nQueryLoop;
106768   pMaskSet = (WhereMaskSet*)&pWC[1];
106769
106770   /* Disable the DISTINCT optimization if SQLCIPHER_DistinctOpt is set via
106771   ** sqlcipher3_test_ctrl(SQLCIPHER_TESTCTRL_OPTIMIZATIONS,...) */
106772   if( db->flags & SQLCIPHER_DistinctOpt ) pDistinct = 0;
106773
106774   /* Split the WHERE clause into separate subexpressions where each
106775   ** subexpression is separated by an AND operator.
106776   */
106777   initMaskSet(pMaskSet);
106778   whereClauseInit(pWC, pParse, pMaskSet, wctrlFlags);
106779   sqlcipher3ExprCodeConstants(pParse, pWhere);
106780   whereSplit(pWC, pWhere, TK_AND);   /* IMP: R-15842-53296 */
106781     
106782   /* Special case: a WHERE clause that is constant.  Evaluate the
106783   ** expression and either jump over all of the code or fall thru.
106784   */
106785   if( pWhere && (nTabList==0 || sqlcipher3ExprIsConstantNotJoin(pWhere)) ){
106786     sqlcipher3ExprIfFalse(pParse, pWhere, pWInfo->iBreak, SQLCIPHER_JUMPIFNULL);
106787     pWhere = 0;
106788   }
106789
106790   /* Assign a bit from the bitmask to every term in the FROM clause.
106791   **
106792   ** When assigning bitmask values to FROM clause cursors, it must be
106793   ** the case that if X is the bitmask for the N-th FROM clause term then
106794   ** the bitmask for all FROM clause terms to the left of the N-th term
106795   ** is (X-1).   An expression from the ON clause of a LEFT JOIN can use
106796   ** its Expr.iRightJoinTable value to find the bitmask of the right table
106797   ** of the join.  Subtracting one from the right table bitmask gives a
106798   ** bitmask for all tables to the left of the join.  Knowing the bitmask
106799   ** for all tables to the left of a left join is important.  Ticket #3015.
106800   **
106801   ** Configure the WhereClause.vmask variable so that bits that correspond
106802   ** to virtual table cursors are set. This is used to selectively disable 
106803   ** the OR-to-IN transformation in exprAnalyzeOrTerm(). It is not helpful 
106804   ** with virtual tables.
106805   **
106806   ** Note that bitmasks are created for all pTabList->nSrc tables in
106807   ** pTabList, not just the first nTabList tables.  nTabList is normally
106808   ** equal to pTabList->nSrc but might be shortened to 1 if the
106809   ** WHERE_ONETABLE_ONLY flag is set.
106810   */
106811   assert( pWC->vmask==0 && pMaskSet->n==0 );
106812   for(i=0; i<pTabList->nSrc; i++){
106813     createMask(pMaskSet, pTabList->a[i].iCursor);
106814 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
106815     if( ALWAYS(pTabList->a[i].pTab) && IsVirtual(pTabList->a[i].pTab) ){
106816       pWC->vmask |= ((Bitmask)1 << i);
106817     }
106818 #endif
106819   }
106820 #ifndef NDEBUG
106821   {
106822     Bitmask toTheLeft = 0;
106823     for(i=0; i<pTabList->nSrc; i++){
106824       Bitmask m = getMask(pMaskSet, pTabList->a[i].iCursor);
106825       assert( (m-1)==toTheLeft );
106826       toTheLeft |= m;
106827     }
106828   }
106829 #endif
106830
106831   /* Analyze all of the subexpressions.  Note that exprAnalyze() might
106832   ** add new virtual terms onto the end of the WHERE clause.  We do not
106833   ** want to analyze these virtual terms, so start analyzing at the end
106834   ** and work forward so that the added virtual terms are never processed.
106835   */
106836   exprAnalyzeAll(pTabList, pWC);
106837   if( db->mallocFailed ){
106838     goto whereBeginError;
106839   }
106840
106841   /* Check if the DISTINCT qualifier, if there is one, is redundant. 
106842   ** If it is, then set pDistinct to NULL and WhereInfo.eDistinct to
106843   ** WHERE_DISTINCT_UNIQUE to tell the caller to ignore the DISTINCT.
106844   */
106845   if( pDistinct && isDistinctRedundant(pParse, pTabList, pWC, pDistinct) ){
106846     pDistinct = 0;
106847     pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
106848   }
106849
106850   /* Chose the best index to use for each table in the FROM clause.
106851   **
106852   ** This loop fills in the following fields:
106853   **
106854   **   pWInfo->a[].pIdx      The index to use for this level of the loop.
106855   **   pWInfo->a[].wsFlags   WHERE_xxx flags associated with pIdx
106856   **   pWInfo->a[].nEq       The number of == and IN constraints
106857   **   pWInfo->a[].iFrom     Which term of the FROM clause is being coded
106858   **   pWInfo->a[].iTabCur   The VDBE cursor for the database table
106859   **   pWInfo->a[].iIdxCur   The VDBE cursor for the index
106860   **   pWInfo->a[].pTerm     When wsFlags==WO_OR, the OR-clause term
106861   **
106862   ** This loop also figures out the nesting order of tables in the FROM
106863   ** clause.
106864   */
106865   notReady = ~(Bitmask)0;
106866   andFlags = ~0;
106867   WHERETRACE(("*** Optimizer Start ***\n"));
106868   for(i=iFrom=0, pLevel=pWInfo->a; i<nTabList; i++, pLevel++){
106869     WhereCost bestPlan;         /* Most efficient plan seen so far */
106870     Index *pIdx;                /* Index for FROM table at pTabItem */
106871     int j;                      /* For looping over FROM tables */
106872     int bestJ = -1;             /* The value of j */
106873     Bitmask m;                  /* Bitmask value for j or bestJ */
106874     int isOptimal;              /* Iterator for optimal/non-optimal search */
106875     int nUnconstrained;         /* Number tables without INDEXED BY */
106876     Bitmask notIndexed;         /* Mask of tables that cannot use an index */
106877
106878     memset(&bestPlan, 0, sizeof(bestPlan));
106879     bestPlan.rCost = SQLCIPHER_BIG_DBL;
106880     WHERETRACE(("*** Begin search for loop %d ***\n", i));
106881
106882     /* Loop through the remaining entries in the FROM clause to find the
106883     ** next nested loop. The loop tests all FROM clause entries
106884     ** either once or twice. 
106885     **
106886     ** The first test is always performed if there are two or more entries
106887     ** remaining and never performed if there is only one FROM clause entry
106888     ** to choose from.  The first test looks for an "optimal" scan.  In
106889     ** this context an optimal scan is one that uses the same strategy
106890     ** for the given FROM clause entry as would be selected if the entry
106891     ** were used as the innermost nested loop.  In other words, a table
106892     ** is chosen such that the cost of running that table cannot be reduced
106893     ** by waiting for other tables to run first.  This "optimal" test works
106894     ** by first assuming that the FROM clause is on the inner loop and finding
106895     ** its query plan, then checking to see if that query plan uses any
106896     ** other FROM clause terms that are notReady.  If no notReady terms are
106897     ** used then the "optimal" query plan works.
106898     **
106899     ** Note that the WhereCost.nRow parameter for an optimal scan might
106900     ** not be as small as it would be if the table really were the innermost
106901     ** join.  The nRow value can be reduced by WHERE clause constraints
106902     ** that do not use indices.  But this nRow reduction only happens if the
106903     ** table really is the innermost join.  
106904     **
106905     ** The second loop iteration is only performed if no optimal scan
106906     ** strategies were found by the first iteration. This second iteration
106907     ** is used to search for the lowest cost scan overall.
106908     **
106909     ** Previous versions of SQLite performed only the second iteration -
106910     ** the next outermost loop was always that with the lowest overall
106911     ** cost. However, this meant that SQLite could select the wrong plan
106912     ** for scripts such as the following:
106913     **   
106914     **   CREATE TABLE t1(a, b); 
106915     **   CREATE TABLE t2(c, d);
106916     **   SELECT * FROM t2, t1 WHERE t2.rowid = t1.a;
106917     **
106918     ** The best strategy is to iterate through table t1 first. However it
106919     ** is not possible to determine this with a simple greedy algorithm.
106920     ** Since the cost of a linear scan through table t2 is the same 
106921     ** as the cost of a linear scan through table t1, a simple greedy 
106922     ** algorithm may choose to use t2 for the outer loop, which is a much
106923     ** costlier approach.
106924     */
106925     nUnconstrained = 0;
106926     notIndexed = 0;
106927     for(isOptimal=(iFrom<nTabList-1); isOptimal>=0 && bestJ<0; isOptimal--){
106928       Bitmask mask;             /* Mask of tables not yet ready */
106929       for(j=iFrom, pTabItem=&pTabList->a[j]; j<nTabList; j++, pTabItem++){
106930         int doNotReorder;    /* True if this table should not be reordered */
106931         WhereCost sCost;     /* Cost information from best[Virtual]Index() */
106932         ExprList *pOrderBy;  /* ORDER BY clause for index to optimize */
106933         ExprList *pDist;     /* DISTINCT clause for index to optimize */
106934   
106935         doNotReorder =  (pTabItem->jointype & (JT_LEFT|JT_CROSS))!=0;
106936         if( j!=iFrom && doNotReorder ) break;
106937         m = getMask(pMaskSet, pTabItem->iCursor);
106938         if( (m & notReady)==0 ){
106939           if( j==iFrom ) iFrom++;
106940           continue;
106941         }
106942         mask = (isOptimal ? m : notReady);
106943         pOrderBy = ((i==0 && ppOrderBy )?*ppOrderBy:0);
106944         pDist = (i==0 ? pDistinct : 0);
106945         if( pTabItem->pIndex==0 ) nUnconstrained++;
106946   
106947         WHERETRACE(("=== trying table %d with isOptimal=%d ===\n",
106948                     j, isOptimal));
106949         assert( pTabItem->pTab );
106950 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
106951         if( IsVirtual(pTabItem->pTab) ){
106952           sqlcipher3_index_info **pp = &pWInfo->a[j].pIdxInfo;
106953           bestVirtualIndex(pParse, pWC, pTabItem, mask, notReady, pOrderBy,
106954                            &sCost, pp);
106955         }else 
106956 #endif
106957         {
106958           bestBtreeIndex(pParse, pWC, pTabItem, mask, notReady, pOrderBy,
106959               pDist, &sCost);
106960         }
106961         assert( isOptimal || (sCost.used&notReady)==0 );
106962
106963         /* If an INDEXED BY clause is present, then the plan must use that
106964         ** index if it uses any index at all */
106965         assert( pTabItem->pIndex==0 
106966                   || (sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)==0
106967                   || sCost.plan.u.pIdx==pTabItem->pIndex );
106968
106969         if( isOptimal && (sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)==0 ){
106970           notIndexed |= m;
106971         }
106972
106973         /* Conditions under which this table becomes the best so far:
106974         **
106975         **   (1) The table must not depend on other tables that have not
106976         **       yet run.
106977         **
106978         **   (2) A full-table-scan plan cannot supercede indexed plan unless
106979         **       the full-table-scan is an "optimal" plan as defined above.
106980         **
106981         **   (3) All tables have an INDEXED BY clause or this table lacks an
106982         **       INDEXED BY clause or this table uses the specific
106983         **       index specified by its INDEXED BY clause.  This rule ensures
106984         **       that a best-so-far is always selected even if an impossible
106985         **       combination of INDEXED BY clauses are given.  The error
106986         **       will be detected and relayed back to the application later.
106987         **       The NEVER() comes about because rule (2) above prevents
106988         **       An indexable full-table-scan from reaching rule (3).
106989         **
106990         **   (4) The plan cost must be lower than prior plans or else the
106991         **       cost must be the same and the number of rows must be lower.
106992         */
106993         if( (sCost.used&notReady)==0                       /* (1) */
106994             && (bestJ<0 || (notIndexed&m)!=0               /* (2) */
106995                 || (bestPlan.plan.wsFlags & WHERE_NOT_FULLSCAN)==0
106996                 || (sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)!=0)
106997             && (nUnconstrained==0 || pTabItem->pIndex==0   /* (3) */
106998                 || NEVER((sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)!=0))
106999             && (bestJ<0 || sCost.rCost<bestPlan.rCost      /* (4) */
107000                 || (sCost.rCost<=bestPlan.rCost 
107001                  && sCost.plan.nRow<bestPlan.plan.nRow))
107002         ){
107003           WHERETRACE(("=== table %d is best so far"
107004                       " with cost=%g and nRow=%g\n",
107005                       j, sCost.rCost, sCost.plan.nRow));
107006           bestPlan = sCost;
107007           bestJ = j;
107008         }
107009         if( doNotReorder ) break;
107010       }
107011     }
107012     assert( bestJ>=0 );
107013     assert( notReady & getMask(pMaskSet, pTabList->a[bestJ].iCursor) );
107014     WHERETRACE(("*** Optimizer selects table %d for loop %d"
107015                 " with cost=%g and nRow=%g\n",
107016                 bestJ, pLevel-pWInfo->a, bestPlan.rCost, bestPlan.plan.nRow));
107017     /* The ALWAYS() that follows was added to hush up clang scan-build */
107018     if( (bestPlan.plan.wsFlags & WHERE_ORDERBY)!=0 && ALWAYS(ppOrderBy) ){
107019       *ppOrderBy = 0;
107020     }
107021     if( (bestPlan.plan.wsFlags & WHERE_DISTINCT)!=0 ){
107022       assert( pWInfo->eDistinct==0 );
107023       pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
107024     }
107025     andFlags &= bestPlan.plan.wsFlags;
107026     pLevel->plan = bestPlan.plan;
107027     testcase( bestPlan.plan.wsFlags & WHERE_INDEXED );
107028     testcase( bestPlan.plan.wsFlags & WHERE_TEMP_INDEX );
107029     if( bestPlan.plan.wsFlags & (WHERE_INDEXED|WHERE_TEMP_INDEX) ){
107030       pLevel->iIdxCur = pParse->nTab++;
107031     }else{
107032       pLevel->iIdxCur = -1;
107033     }
107034     notReady &= ~getMask(pMaskSet, pTabList->a[bestJ].iCursor);
107035     pLevel->iFrom = (u8)bestJ;
107036     if( bestPlan.plan.nRow>=(double)1 ){
107037       pParse->nQueryLoop *= bestPlan.plan.nRow;
107038     }
107039
107040     /* Check that if the table scanned by this loop iteration had an
107041     ** INDEXED BY clause attached to it, that the named index is being
107042     ** used for the scan. If not, then query compilation has failed.
107043     ** Return an error.
107044     */
107045     pIdx = pTabList->a[bestJ].pIndex;
107046     if( pIdx ){
107047       if( (bestPlan.plan.wsFlags & WHERE_INDEXED)==0 ){
107048         sqlcipher3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName);
107049         goto whereBeginError;
107050       }else{
107051         /* If an INDEXED BY clause is used, the bestIndex() function is
107052         ** guaranteed to find the index specified in the INDEXED BY clause
107053         ** if it find an index at all. */
107054         assert( bestPlan.plan.u.pIdx==pIdx );
107055       }
107056     }
107057   }
107058   WHERETRACE(("*** Optimizer Finished ***\n"));
107059   if( pParse->nErr || db->mallocFailed ){
107060     goto whereBeginError;
107061   }
107062
107063   /* If the total query only selects a single row, then the ORDER BY
107064   ** clause is irrelevant.
107065   */
107066   if( (andFlags & WHERE_UNIQUE)!=0 && ppOrderBy ){
107067     *ppOrderBy = 0;
107068   }
107069
107070   /* If the caller is an UPDATE or DELETE statement that is requesting
107071   ** to use a one-pass algorithm, determine if this is appropriate.
107072   ** The one-pass algorithm only works if the WHERE clause constraints
107073   ** the statement to update a single row.
107074   */
107075   assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
107076   if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 && (andFlags & WHERE_UNIQUE)!=0 ){
107077     pWInfo->okOnePass = 1;
107078     pWInfo->a[0].plan.wsFlags &= ~WHERE_IDX_ONLY;
107079   }
107080
107081   /* Open all tables in the pTabList and any indices selected for
107082   ** searching those tables.
107083   */
107084   sqlcipher3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */
107085   notReady = ~(Bitmask)0;
107086   pWInfo->nRowOut = (double)1;
107087   for(i=0, pLevel=pWInfo->a; i<nTabList; i++, pLevel++){
107088     Table *pTab;     /* Table to open */
107089     int iDb;         /* Index of database containing table/index */
107090
107091     pTabItem = &pTabList->a[pLevel->iFrom];
107092     pTab = pTabItem->pTab;
107093     pLevel->iTabCur = pTabItem->iCursor;
107094     pWInfo->nRowOut *= pLevel->plan.nRow;
107095     iDb = sqlcipher3SchemaToIndex(db, pTab->pSchema);
107096     if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){
107097       /* Do nothing */
107098     }else
107099 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
107100     if( (pLevel->plan.wsFlags & WHERE_VIRTUALTABLE)!=0 ){
107101       const char *pVTab = (const char *)sqlcipher3GetVTable(db, pTab);
107102       int iCur = pTabItem->iCursor;
107103       sqlcipher3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB);
107104     }else
107105 #endif
107106     if( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107107          && (wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 ){
107108       int op = pWInfo->okOnePass ? OP_OpenWrite : OP_OpenRead;
107109       sqlcipher3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
107110       testcase( pTab->nCol==BMS-1 );
107111       testcase( pTab->nCol==BMS );
107112       if( !pWInfo->okOnePass && pTab->nCol<BMS ){
107113         Bitmask b = pTabItem->colUsed;
107114         int n = 0;
107115         for(; b; b=b>>1, n++){}
107116         sqlcipher3VdbeChangeP4(v, sqlcipher3VdbeCurrentAddr(v)-1, 
107117                             SQLCIPHER_INT_TO_PTR(n), P4_INT32);
107118         assert( n<=pTab->nCol );
107119       }
107120     }else{
107121       sqlcipher3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
107122     }
107123 #ifndef SQLCIPHER_OMIT_AUTOMATIC_INDEX
107124     if( (pLevel->plan.wsFlags & WHERE_TEMP_INDEX)!=0 ){
107125       constructAutomaticIndex(pParse, pWC, pTabItem, notReady, pLevel);
107126     }else
107127 #endif
107128     if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 ){
107129       Index *pIx = pLevel->plan.u.pIdx;
107130       KeyInfo *pKey = sqlcipher3IndexKeyinfo(pParse, pIx);
107131       int iIdxCur = pLevel->iIdxCur;
107132       assert( pIx->pSchema==pTab->pSchema );
107133       assert( iIdxCur>=0 );
107134       sqlcipher3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIx->tnum, iDb,
107135                         (char*)pKey, P4_KEYINFO_HANDOFF);
107136       VdbeComment((v, "%s", pIx->zName));
107137     }
107138     sqlcipher3CodeVerifySchema(pParse, iDb);
107139     notReady &= ~getMask(pWC->pMaskSet, pTabItem->iCursor);
107140   }
107141   pWInfo->iTop = sqlcipher3VdbeCurrentAddr(v);
107142   if( db->mallocFailed ) goto whereBeginError;
107143
107144   /* Generate the code to do the search.  Each iteration of the for
107145   ** loop below generates code for a single nested loop of the VM
107146   ** program.
107147   */
107148   notReady = ~(Bitmask)0;
107149   for(i=0; i<nTabList; i++){
107150     pLevel = &pWInfo->a[i];
107151     explainOneScan(pParse, pTabList, pLevel, i, pLevel->iFrom, wctrlFlags);
107152     notReady = codeOneLoopStart(pWInfo, i, wctrlFlags, notReady, pWhere);
107153     pWInfo->iContinue = pLevel->addrCont;
107154   }
107155
107156 #ifdef SQLCIPHER_TEST  /* For testing and debugging use only */
107157   /* Record in the query plan information about the current table
107158   ** and the index used to access it (if any).  If the table itself
107159   ** is not used, its name is just '{}'.  If no index is used
107160   ** the index is listed as "{}".  If the primary key is used the
107161   ** index name is '*'.
107162   */
107163   for(i=0; i<nTabList; i++){
107164     char *z;
107165     int n;
107166     pLevel = &pWInfo->a[i];
107167     pTabItem = &pTabList->a[pLevel->iFrom];
107168     z = pTabItem->zAlias;
107169     if( z==0 ) z = pTabItem->pTab->zName;
107170     n = sqlcipher3Strlen30(z);
107171     if( n+nQPlan < sizeof(sqlcipher3_query_plan)-10 ){
107172       if( pLevel->plan.wsFlags & WHERE_IDX_ONLY ){
107173         memcpy(&sqlcipher3_query_plan[nQPlan], "{}", 2);
107174         nQPlan += 2;
107175       }else{
107176         memcpy(&sqlcipher3_query_plan[nQPlan], z, n);
107177         nQPlan += n;
107178       }
107179       sqlcipher3_query_plan[nQPlan++] = ' ';
107180     }
107181     testcase( pLevel->plan.wsFlags & WHERE_ROWID_EQ );
107182     testcase( pLevel->plan.wsFlags & WHERE_ROWID_RANGE );
107183     if( pLevel->plan.wsFlags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
107184       memcpy(&sqlcipher3_query_plan[nQPlan], "* ", 2);
107185       nQPlan += 2;
107186     }else if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 ){
107187       n = sqlcipher3Strlen30(pLevel->plan.u.pIdx->zName);
107188       if( n+nQPlan < sizeof(sqlcipher3_query_plan)-2 ){
107189         memcpy(&sqlcipher3_query_plan[nQPlan], pLevel->plan.u.pIdx->zName, n);
107190         nQPlan += n;
107191         sqlcipher3_query_plan[nQPlan++] = ' ';
107192       }
107193     }else{
107194       memcpy(&sqlcipher3_query_plan[nQPlan], "{} ", 3);
107195       nQPlan += 3;
107196     }
107197   }
107198   while( nQPlan>0 && sqlcipher3_query_plan[nQPlan-1]==' ' ){
107199     sqlcipher3_query_plan[--nQPlan] = 0;
107200   }
107201   sqlcipher3_query_plan[nQPlan] = 0;
107202   nQPlan = 0;
107203 #endif /* SQLCIPHER_TEST // Testing and debugging use only */
107204
107205   /* Record the continuation address in the WhereInfo structure.  Then
107206   ** clean up and return.
107207   */
107208   return pWInfo;
107209
107210   /* Jump here if malloc fails */
107211 whereBeginError:
107212   if( pWInfo ){
107213     pParse->nQueryLoop = pWInfo->savedNQueryLoop;
107214     whereInfoFree(db, pWInfo);
107215   }
107216   return 0;
107217 }
107218
107219 /*
107220 ** Generate the end of the WHERE loop.  See comments on 
107221 ** sqlcipher3WhereBegin() for additional information.
107222 */
107223 SQLCIPHER_PRIVATE void sqlcipher3WhereEnd(WhereInfo *pWInfo){
107224   Parse *pParse = pWInfo->pParse;
107225   Vdbe *v = pParse->pVdbe;
107226   int i;
107227   WhereLevel *pLevel;
107228   SrcList *pTabList = pWInfo->pTabList;
107229   sqlcipher3 *db = pParse->db;
107230
107231   /* Generate loop termination code.
107232   */
107233   sqlcipher3ExprCacheClear(pParse);
107234   for(i=pWInfo->nLevel-1; i>=0; i--){
107235     pLevel = &pWInfo->a[i];
107236     sqlcipher3VdbeResolveLabel(v, pLevel->addrCont);
107237     if( pLevel->op!=OP_Noop ){
107238       sqlcipher3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
107239       sqlcipher3VdbeChangeP5(v, pLevel->p5);
107240     }
107241     if( pLevel->plan.wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){
107242       struct InLoop *pIn;
107243       int j;
107244       sqlcipher3VdbeResolveLabel(v, pLevel->addrNxt);
107245       for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
107246         sqlcipher3VdbeJumpHere(v, pIn->addrInTop+1);
107247         sqlcipher3VdbeAddOp2(v, OP_Next, pIn->iCur, pIn->addrInTop);
107248         sqlcipher3VdbeJumpHere(v, pIn->addrInTop-1);
107249       }
107250       sqlcipher3DbFree(db, pLevel->u.in.aInLoop);
107251     }
107252     sqlcipher3VdbeResolveLabel(v, pLevel->addrBrk);
107253     if( pLevel->iLeftJoin ){
107254       int addr;
107255       addr = sqlcipher3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin);
107256       assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107257            || (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 );
107258       if( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0 ){
107259         sqlcipher3VdbeAddOp1(v, OP_NullRow, pTabList->a[i].iCursor);
107260       }
107261       if( pLevel->iIdxCur>=0 ){
107262         sqlcipher3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
107263       }
107264       if( pLevel->op==OP_Return ){
107265         sqlcipher3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst);
107266       }else{
107267         sqlcipher3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrFirst);
107268       }
107269       sqlcipher3VdbeJumpHere(v, addr);
107270     }
107271   }
107272
107273   /* The "break" point is here, just past the end of the outer loop.
107274   ** Set it.
107275   */
107276   sqlcipher3VdbeResolveLabel(v, pWInfo->iBreak);
107277
107278   /* Close all of the cursors that were opened by sqlcipher3WhereBegin.
107279   */
107280   assert( pWInfo->nLevel==1 || pWInfo->nLevel==pTabList->nSrc );
107281   for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
107282     struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
107283     Table *pTab = pTabItem->pTab;
107284     assert( pTab!=0 );
107285     if( (pTab->tabFlags & TF_Ephemeral)==0
107286      && pTab->pSelect==0
107287      && (pWInfo->wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0
107288     ){
107289       int ws = pLevel->plan.wsFlags;
107290       if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){
107291         sqlcipher3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
107292       }
107293       if( (ws & WHERE_INDEXED)!=0 && (ws & WHERE_TEMP_INDEX)==0 ){
107294         sqlcipher3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
107295       }
107296     }
107297
107298     /* If this scan uses an index, make code substitutions to read data
107299     ** from the index in preference to the table. Sometimes, this means
107300     ** the table need never be read from. This is a performance boost,
107301     ** as the vdbe level waits until the table is read before actually
107302     ** seeking the table cursor to the record corresponding to the current
107303     ** position in the index.
107304     ** 
107305     ** Calls to the code generator in between sqlcipher3WhereBegin and
107306     ** sqlcipher3WhereEnd will have created code that references the table
107307     ** directly.  This loop scans all that code looking for opcodes
107308     ** that reference the table and converts them into opcodes that
107309     ** reference the index.
107310     */
107311     if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 && !db->mallocFailed){
107312       int k, j, last;
107313       VdbeOp *pOp;
107314       Index *pIdx = pLevel->plan.u.pIdx;
107315
107316       assert( pIdx!=0 );
107317       pOp = sqlcipher3VdbeGetOp(v, pWInfo->iTop);
107318       last = sqlcipher3VdbeCurrentAddr(v);
107319       for(k=pWInfo->iTop; k<last; k++, pOp++){
107320         if( pOp->p1!=pLevel->iTabCur ) continue;
107321         if( pOp->opcode==OP_Column ){
107322           for(j=0; j<pIdx->nColumn; j++){
107323             if( pOp->p2==pIdx->aiColumn[j] ){
107324               pOp->p2 = j;
107325               pOp->p1 = pLevel->iIdxCur;
107326               break;
107327             }
107328           }
107329           assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107330                || j<pIdx->nColumn );
107331         }else if( pOp->opcode==OP_Rowid ){
107332           pOp->p1 = pLevel->iIdxCur;
107333           pOp->opcode = OP_IdxRowid;
107334         }
107335       }
107336     }
107337   }
107338
107339   /* Final cleanup
107340   */
107341   pParse->nQueryLoop = pWInfo->savedNQueryLoop;
107342   whereInfoFree(db, pWInfo);
107343   return;
107344 }
107345
107346 /************** End of where.c ***********************************************/
107347 /************** Begin file parse.c *******************************************/
107348 /* Driver template for the LEMON parser generator.
107349 ** The author disclaims copyright to this source code.
107350 **
107351 ** This version of "lempar.c" is modified, slightly, for use by SQLite.
107352 ** The only modifications are the addition of a couple of NEVER()
107353 ** macros to disable tests that are needed in the case of a general
107354 ** LALR(1) grammar but which are always false in the
107355 ** specific grammar used by SQLite.
107356 */
107357 /* First off, code is included that follows the "include" declaration
107358 ** in the input grammar file. */
107359 /* #include <stdio.h> */
107360
107361
107362 /*
107363 ** Disable all error recovery processing in the parser push-down
107364 ** automaton.
107365 */
107366 #define YYNOERRORRECOVERY 1
107367
107368 /*
107369 ** Make yytestcase() the same as testcase()
107370 */
107371 #define yytestcase(X) testcase(X)
107372
107373 /*
107374 ** An instance of this structure holds information about the
107375 ** LIMIT clause of a SELECT statement.
107376 */
107377 struct LimitVal {
107378   Expr *pLimit;    /* The LIMIT expression.  NULL if there is no limit */
107379   Expr *pOffset;   /* The OFFSET expression.  NULL if there is none */
107380 };
107381
107382 /*
107383 ** An instance of this structure is used to store the LIKE,
107384 ** GLOB, NOT LIKE, and NOT GLOB operators.
107385 */
107386 struct LikeOp {
107387   Token eOperator;  /* "like" or "glob" or "regexp" */
107388   int not;         /* True if the NOT keyword is present */
107389 };
107390
107391 /*
107392 ** An instance of the following structure describes the event of a
107393 ** TRIGGER.  "a" is the event type, one of TK_UPDATE, TK_INSERT,
107394 ** TK_DELETE, or TK_INSTEAD.  If the event is of the form
107395 **
107396 **      UPDATE ON (a,b,c)
107397 **
107398 ** Then the "b" IdList records the list "a,b,c".
107399 */
107400 struct TrigEvent { int a; IdList * b; };
107401
107402 /*
107403 ** An instance of this structure holds the ATTACH key and the key type.
107404 */
107405 struct AttachKey { int type;  Token key; };
107406
107407
107408   /* This is a utility routine used to set the ExprSpan.zStart and
107409   ** ExprSpan.zEnd values of pOut so that the span covers the complete
107410   ** range of text beginning with pStart and going to the end of pEnd.
107411   */
107412   static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
107413     pOut->zStart = pStart->z;
107414     pOut->zEnd = &pEnd->z[pEnd->n];
107415   }
107416
107417   /* Construct a new Expr object from a single identifier.  Use the
107418   ** new Expr to populate pOut.  Set the span of pOut to be the identifier
107419   ** that created the expression.
107420   */
107421   static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
107422     pOut->pExpr = sqlcipher3PExpr(pParse, op, 0, 0, pValue);
107423     pOut->zStart = pValue->z;
107424     pOut->zEnd = &pValue->z[pValue->n];
107425   }
107426
107427   /* This routine constructs a binary expression node out of two ExprSpan
107428   ** objects and uses the result to populate a new ExprSpan object.
107429   */
107430   static void spanBinaryExpr(
107431     ExprSpan *pOut,     /* Write the result here */
107432     Parse *pParse,      /* The parsing context.  Errors accumulate here */
107433     int op,             /* The binary operation */
107434     ExprSpan *pLeft,    /* The left operand */
107435     ExprSpan *pRight    /* The right operand */
107436   ){
107437     pOut->pExpr = sqlcipher3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
107438     pOut->zStart = pLeft->zStart;
107439     pOut->zEnd = pRight->zEnd;
107440   }
107441
107442   /* Construct an expression node for a unary postfix operator
107443   */
107444   static void spanUnaryPostfix(
107445     ExprSpan *pOut,        /* Write the new expression node here */
107446     Parse *pParse,         /* Parsing context to record errors */
107447     int op,                /* The operator */
107448     ExprSpan *pOperand,    /* The operand */
107449     Token *pPostOp         /* The operand token for setting the span */
107450   ){
107451     pOut->pExpr = sqlcipher3PExpr(pParse, op, pOperand->pExpr, 0, 0);
107452     pOut->zStart = pOperand->zStart;
107453     pOut->zEnd = &pPostOp->z[pPostOp->n];
107454   }                           
107455
107456   /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
107457   ** unary TK_ISNULL or TK_NOTNULL expression. */
107458   static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
107459     sqlcipher3 *db = pParse->db;
107460     if( db->mallocFailed==0 && pY->op==TK_NULL ){
107461       pA->op = (u8)op;
107462       sqlcipher3ExprDelete(db, pA->pRight);
107463       pA->pRight = 0;
107464     }
107465   }
107466
107467   /* Construct an expression node for a unary prefix operator
107468   */
107469   static void spanUnaryPrefix(
107470     ExprSpan *pOut,        /* Write the new expression node here */
107471     Parse *pParse,         /* Parsing context to record errors */
107472     int op,                /* The operator */
107473     ExprSpan *pOperand,    /* The operand */
107474     Token *pPreOp         /* The operand token for setting the span */
107475   ){
107476     pOut->pExpr = sqlcipher3PExpr(pParse, op, pOperand->pExpr, 0, 0);
107477     pOut->zStart = pPreOp->z;
107478     pOut->zEnd = pOperand->zEnd;
107479   }
107480 /* Next is all token values, in a form suitable for use by makeheaders.
107481 ** This section will be null unless lemon is run with the -m switch.
107482 */
107483 /* 
107484 ** These constants (all generated automatically by the parser generator)
107485 ** specify the various kinds of tokens (terminals) that the parser
107486 ** understands. 
107487 **
107488 ** Each symbol here is a terminal symbol in the grammar.
107489 */
107490 /* Make sure the INTERFACE macro is defined.
107491 */
107492 #ifndef INTERFACE
107493 # define INTERFACE 1
107494 #endif
107495 /* The next thing included is series of defines which control
107496 ** various aspects of the generated parser.
107497 **    YYCODETYPE         is the data type used for storing terminal
107498 **                       and nonterminal numbers.  "unsigned char" is
107499 **                       used if there are fewer than 250 terminals
107500 **                       and nonterminals.  "int" is used otherwise.
107501 **    YYNOCODE           is a number of type YYCODETYPE which corresponds
107502 **                       to no legal terminal or nonterminal number.  This
107503 **                       number is used to fill in empty slots of the hash 
107504 **                       table.
107505 **    YYFALLBACK         If defined, this indicates that one or more tokens
107506 **                       have fall-back values which should be used if the
107507 **                       original value of the token will not parse.
107508 **    YYACTIONTYPE       is the data type used for storing terminal
107509 **                       and nonterminal numbers.  "unsigned char" is
107510 **                       used if there are fewer than 250 rules and
107511 **                       states combined.  "int" is used otherwise.
107512 **    sqlcipher3ParserTOKENTYPE     is the data type used for minor tokens given 
107513 **                       directly to the parser from the tokenizer.
107514 **    YYMINORTYPE        is the data type used for all minor tokens.
107515 **                       This is typically a union of many types, one of
107516 **                       which is sqlcipher3ParserTOKENTYPE.  The entry in the union
107517 **                       for base tokens is called "yy0".
107518 **    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
107519 **                       zero the stack is dynamically sized using realloc()
107520 **    sqlcipher3ParserARG_SDECL     A static variable declaration for the %extra_argument
107521 **    sqlcipher3ParserARG_PDECL     A parameter declaration for the %extra_argument
107522 **    sqlcipher3ParserARG_STORE     Code to store %extra_argument into yypParser
107523 **    sqlcipher3ParserARG_FETCH     Code to extract %extra_argument from yypParser
107524 **    YYNSTATE           the combined number of states.
107525 **    YYNRULE            the number of rules in the grammar
107526 **    YYERRORSYMBOL      is the code number of the error symbol.  If not
107527 **                       defined, then do no error processing.
107528 */
107529 #define YYCODETYPE unsigned char
107530 #define YYNOCODE 253
107531 #define YYACTIONTYPE unsigned short int
107532 #define YYWILDCARD 67
107533 #define sqlcipher3ParserTOKENTYPE Token
107534 typedef union {
107535   int yyinit;
107536   sqlcipher3ParserTOKENTYPE yy0;
107537   int yy4;
107538   struct TrigEvent yy90;
107539   ExprSpan yy118;
107540   TriggerStep* yy203;
107541   u8 yy210;
107542   struct {int value; int mask;} yy215;
107543   SrcList* yy259;
107544   struct LimitVal yy292;
107545   Expr* yy314;
107546   ExprList* yy322;
107547   struct LikeOp yy342;
107548   IdList* yy384;
107549   Select* yy387;
107550 } YYMINORTYPE;
107551 #ifndef YYSTACKDEPTH
107552 #define YYSTACKDEPTH 100
107553 #endif
107554 #define sqlcipher3ParserARG_SDECL Parse *pParse;
107555 #define sqlcipher3ParserARG_PDECL ,Parse *pParse
107556 #define sqlcipher3ParserARG_FETCH Parse *pParse = yypParser->pParse
107557 #define sqlcipher3ParserARG_STORE yypParser->pParse = pParse
107558 #define YYNSTATE 630
107559 #define YYNRULE 329
107560 #define YYFALLBACK 1
107561 #define YY_NO_ACTION      (YYNSTATE+YYNRULE+2)
107562 #define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)
107563 #define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)
107564
107565 /* The yyzerominor constant is used to initialize instances of
107566 ** YYMINORTYPE objects to zero. */
107567 static const YYMINORTYPE yyzerominor = { 0 };
107568
107569 /* Define the yytestcase() macro to be a no-op if is not already defined
107570 ** otherwise.
107571 **
107572 ** Applications can choose to define yytestcase() in the %include section
107573 ** to a macro that can assist in verifying code coverage.  For production
107574 ** code the yytestcase() macro should be turned off.  But it is useful
107575 ** for testing.
107576 */
107577 #ifndef yytestcase
107578 # define yytestcase(X)
107579 #endif
107580
107581
107582 /* Next are the tables used to determine what action to take based on the
107583 ** current state and lookahead token.  These tables are used to implement
107584 ** functions that take a state number and lookahead value and return an
107585 ** action integer.  
107586 **
107587 ** Suppose the action integer is N.  Then the action is determined as
107588 ** follows
107589 **
107590 **   0 <= N < YYNSTATE                  Shift N.  That is, push the lookahead
107591 **                                      token onto the stack and goto state N.
107592 **
107593 **   YYNSTATE <= N < YYNSTATE+YYNRULE   Reduce by rule N-YYNSTATE.
107594 **
107595 **   N == YYNSTATE+YYNRULE              A syntax error has occurred.
107596 **
107597 **   N == YYNSTATE+YYNRULE+1            The parser accepts its input.
107598 **
107599 **   N == YYNSTATE+YYNRULE+2            No such action.  Denotes unused
107600 **                                      slots in the yy_action[] table.
107601 **
107602 ** The action table is constructed as a single large table named yy_action[].
107603 ** Given state S and lookahead X, the action is computed as
107604 **
107605 **      yy_action[ yy_shift_ofst[S] + X ]
107606 **
107607 ** If the index value yy_shift_ofst[S]+X is out of range or if the value
107608 ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
107609 ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
107610 ** and that yy_default[S] should be used instead.  
107611 **
107612 ** The formula above is for computing the action when the lookahead is
107613 ** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
107614 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
107615 ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
107616 ** YY_SHIFT_USE_DFLT.
107617 **
107618 ** The following are the tables generated in this section:
107619 **
107620 **  yy_action[]        A single table containing all actions.
107621 **  yy_lookahead[]     A table containing the lookahead for each entry in
107622 **                     yy_action.  Used to detect hash collisions.
107623 **  yy_shift_ofst[]    For each state, the offset into yy_action for
107624 **                     shifting terminals.
107625 **  yy_reduce_ofst[]   For each state, the offset into yy_action for
107626 **                     shifting non-terminals after a reduce.
107627 **  yy_default[]       Default action for each state.
107628 */
107629 #define YY_ACTTAB_COUNT (1557)
107630 static const YYACTIONTYPE yy_action[] = {
107631  /*     0 */   313,  960,  186,  419,    2,  172,  627,  597,   55,   55,
107632  /*    10 */    55,   55,   48,   53,   53,   53,   53,   52,   52,   51,
107633  /*    20 */    51,   51,   50,  238,  302,  283,  623,  622,  516,  515,
107634  /*    30 */   590,  584,   55,   55,   55,   55,  282,   53,   53,   53,
107635  /*    40 */    53,   52,   52,   51,   51,   51,   50,  238,    6,   56,
107636  /*    50 */    57,   47,  582,  581,  583,  583,   54,   54,   55,   55,
107637  /*    60 */    55,   55,  608,   53,   53,   53,   53,   52,   52,   51,
107638  /*    70 */    51,   51,   50,  238,  313,  597,  409,  330,  579,  579,
107639  /*    80 */    32,   53,   53,   53,   53,   52,   52,   51,   51,   51,
107640  /*    90 */    50,  238,  330,  217,  620,  619,  166,  411,  624,  382,
107641  /*   100 */   379,  378,    7,  491,  590,  584,  200,  199,  198,   58,
107642  /*   110 */   377,  300,  414,  621,  481,   66,  623,  622,  621,  580,
107643  /*   120 */   254,  601,   94,   56,   57,   47,  582,  581,  583,  583,
107644  /*   130 */    54,   54,   55,   55,   55,   55,  671,   53,   53,   53,
107645  /*   140 */    53,   52,   52,   51,   51,   51,   50,  238,  313,  532,
107646  /*   150 */   226,  506,  507,  133,  177,  139,  284,  385,  279,  384,
107647  /*   160 */   169,  197,  342,  398,  251,  226,  253,  275,  388,  167,
107648  /*   170 */   139,  284,  385,  279,  384,  169,  570,  236,  590,  584,
107649  /*   180 */   672,  240,  275,  157,  620,  619,  554,  437,   51,   51,
107650  /*   190 */    51,   50,  238,  343,  439,  553,  438,   56,   57,   47,
107651  /*   200 */   582,  581,  583,  583,   54,   54,   55,   55,   55,   55,
107652  /*   210 */   465,   53,   53,   53,   53,   52,   52,   51,   51,   51,
107653  /*   220 */    50,  238,  313,  390,   52,   52,   51,   51,   51,   50,
107654  /*   230 */   238,  391,  166,  491,  566,  382,  379,  378,  409,  440,
107655  /*   240 */   579,  579,  252,  440,  607,   66,  377,  513,  621,   49,
107656  /*   250 */    46,  147,  590,  584,  621,   16,  466,  189,  621,  441,
107657  /*   260 */   442,  673,  526,  441,  340,  577,  595,   64,  194,  482,
107658  /*   270 */   434,   56,   57,   47,  582,  581,  583,  583,   54,   54,
107659  /*   280 */    55,   55,   55,   55,   30,   53,   53,   53,   53,   52,
107660  /*   290 */    52,   51,   51,   51,   50,  238,  313,  593,  593,  593,
107661  /*   300 */   387,  578,  606,  493,  259,  351,  258,  411,    1,  623,
107662  /*   310 */   622,  496,  623,  622,   65,  240,  623,  622,  597,  443,
107663  /*   320 */   237,  239,  414,  341,  237,  602,  590,  584,   18,  603,
107664  /*   330 */   166,  601,   87,  382,  379,  378,   67,  623,  622,   38,
107665  /*   340 */   623,  622,  176,  270,  377,   56,   57,   47,  582,  581,
107666  /*   350 */   583,  583,   54,   54,   55,   55,   55,   55,  175,   53,
107667  /*   360 */    53,   53,   53,   52,   52,   51,   51,   51,   50,  238,
107668  /*   370 */   313,  396,  233,  411,  531,  565,  317,  620,  619,   44,
107669  /*   380 */   620,  619,  240,  206,  620,  619,  597,  266,  414,  268,
107670  /*   390 */   409,  597,  579,  579,  352,  184,  505,  601,   73,  533,
107671  /*   400 */   590,  584,  466,  548,  190,  620,  619,  576,  620,  619,
107672  /*   410 */   547,  383,  551,   35,  332,  575,  574,  600,  504,   56,
107673  /*   420 */    57,   47,  582,  581,  583,  583,   54,   54,   55,   55,
107674  /*   430 */    55,   55,  567,   53,   53,   53,   53,   52,   52,   51,
107675  /*   440 */    51,   51,   50,  238,  313,  411,  561,  561,  528,  364,
107676  /*   450 */   259,  351,  258,  183,  361,  549,  524,  374,  411,  597,
107677  /*   460 */   414,  240,  560,  560,  409,  604,  579,  579,  328,  601,
107678  /*   470 */    93,  623,  622,  414,  590,  584,  237,  564,  559,  559,
107679  /*   480 */   520,  402,  601,   87,  409,  210,  579,  579,  168,  421,
107680  /*   490 */   950,  519,  950,   56,   57,   47,  582,  581,  583,  583,
107681  /*   500 */    54,   54,   55,   55,   55,   55,  192,   53,   53,   53,
107682  /*   510 */    53,   52,   52,   51,   51,   51,   50,  238,  313,  600,
107683  /*   520 */   293,  563,  511,  234,  357,  146,  475,  475,  367,  411,
107684  /*   530 */   562,  411,  358,  542,  425,  171,  411,  215,  144,  620,
107685  /*   540 */   619,  544,  318,  353,  414,  203,  414,  275,  590,  584,
107686  /*   550 */   549,  414,  174,  601,   94,  601,   79,  558,  471,   61,
107687  /*   560 */   601,   79,  421,  949,  350,  949,   34,   56,   57,   47,
107688  /*   570 */   582,  581,  583,  583,   54,   54,   55,   55,   55,   55,
107689  /*   580 */   535,   53,   53,   53,   53,   52,   52,   51,   51,   51,
107690  /*   590 */    50,  238,  313,  307,  424,  394,  272,   49,   46,  147,
107691  /*   600 */   349,  322,    4,  411,  491,  312,  321,  425,  568,  492,
107692  /*   610 */   216,  264,  407,  575,  574,  429,   66,  549,  414,  621,
107693  /*   620 */   540,  602,  590,  584,   13,  603,  621,  601,   72,   12,
107694  /*   630 */   618,  617,  616,  202,  210,  621,  546,  469,  422,  319,
107695  /*   640 */   148,   56,   57,   47,  582,  581,  583,  583,   54,   54,
107696  /*   650 */    55,   55,   55,   55,  338,   53,   53,   53,   53,   52,
107697  /*   660 */    52,   51,   51,   51,   50,  238,  313,  600,  600,  411,
107698  /*   670 */    39,   21,   37,  170,  237,  875,  411,  572,  572,  201,
107699  /*   680 */   144,  473,  538,  331,  414,  474,  143,  146,  630,  628,
107700  /*   690 */   334,  414,  353,  601,   68,  168,  590,  584,  132,  365,
107701  /*   700 */   601,   96,  307,  423,  530,  336,   49,   46,  147,  568,
107702  /*   710 */   406,  216,  549,  360,  529,   56,   57,   47,  582,  581,
107703  /*   720 */   583,  583,   54,   54,   55,   55,   55,   55,  411,   53,
107704  /*   730 */    53,   53,   53,   52,   52,   51,   51,   51,   50,  238,
107705  /*   740 */   313,  411,  605,  414,  484,  510,  172,  422,  597,  318,
107706  /*   750 */   496,  485,  601,   99,  411,  142,  414,  411,  231,  411,
107707  /*   760 */   540,  411,  359,  629,    2,  601,   97,  426,  308,  414,
107708  /*   770 */   590,  584,  414,   20,  414,  621,  414,  621,  601,  106,
107709  /*   780 */   503,  601,  105,  601,  108,  601,  109,  204,   28,   56,
107710  /*   790 */    57,   47,  582,  581,  583,  583,   54,   54,   55,   55,
107711  /*   800 */    55,   55,  411,   53,   53,   53,   53,   52,   52,   51,
107712  /*   810 */    51,   51,   50,  238,  313,  411,  597,  414,  411,  276,
107713  /*   820 */   214,  600,  411,  366,  213,  381,  601,  134,  274,  500,
107714  /*   830 */   414,  167,  130,  414,  621,  411,  354,  414,  376,  601,
107715  /*   840 */   135,  129,  601,  100,  590,  584,  601,  104,  522,  521,
107716  /*   850 */   414,  621,  224,  273,  600,  167,  327,  282,  600,  601,
107717  /*   860 */   103,  468,  521,   56,   57,   47,  582,  581,  583,  583,
107718  /*   870 */    54,   54,   55,   55,   55,   55,  411,   53,   53,   53,
107719  /*   880 */    53,   52,   52,   51,   51,   51,   50,  238,  313,  411,
107720  /*   890 */    27,  414,  411,  375,  276,  167,  359,  544,   50,  238,
107721  /*   900 */   601,   95,  128,  223,  414,  411,  165,  414,  411,  621,
107722  /*   910 */   411,  621,  612,  601,  102,  372,  601,   76,  590,  584,
107723  /*   920 */   414,  570,  236,  414,  470,  414,  167,  621,  188,  601,
107724  /*   930 */    98,  225,  601,  138,  601,  137,  232,   56,   45,   47,
107725  /*   940 */   582,  581,  583,  583,   54,   54,   55,   55,   55,   55,
107726  /*   950 */   411,   53,   53,   53,   53,   52,   52,   51,   51,   51,
107727  /*   960 */    50,  238,  313,  276,  276,  414,  411,  276,  544,  459,
107728  /*   970 */   359,  171,  209,  479,  601,  136,  628,  334,  621,  621,
107729  /*   980 */   125,  414,  621,  368,  411,  621,  257,  540,  589,  588,
107730  /*   990 */   601,   75,  590,  584,  458,  446,   23,   23,  124,  414,
107731  /*  1000 */   326,  325,  621,  427,  324,  309,  600,  288,  601,   92,
107732  /*  1010 */   586,  585,   57,   47,  582,  581,  583,  583,   54,   54,
107733  /*  1020 */    55,   55,   55,   55,  411,   53,   53,   53,   53,   52,
107734  /*  1030 */    52,   51,   51,   51,   50,  238,  313,  587,  411,  414,
107735  /*  1040 */   411,  207,  611,  476,  171,  472,  160,  123,  601,   91,
107736  /*  1050 */   323,  261,   15,  414,  464,  414,  411,  621,  411,  354,
107737  /*  1060 */   222,  411,  601,   74,  601,   90,  590,  584,  159,  264,
107738  /*  1070 */   158,  414,  461,  414,  621,  600,  414,  121,  120,   25,
107739  /*  1080 */   601,   89,  601,  101,  621,  601,   88,   47,  582,  581,
107740  /*  1090 */   583,  583,   54,   54,   55,   55,   55,   55,  544,   53,
107741  /*  1100 */    53,   53,   53,   52,   52,   51,   51,   51,   50,  238,
107742  /*  1110 */    43,  405,  263,    3,  610,  264,  140,  415,  622,   24,
107743  /*  1120 */   410,   11,  456,  594,  118,  155,  219,  452,  408,  621,
107744  /*  1130 */   621,  621,  156,   43,  405,  621,    3,  286,  621,  113,
107745  /*  1140 */   415,  622,  111,  445,  411,  400,  557,  403,  545,   10,
107746  /*  1150 */   411,  408,  264,  110,  205,  436,  541,  566,  453,  414,
107747  /*  1160 */   621,  621,   63,  621,  435,  414,  411,  621,  601,   94,
107748  /*  1170 */   403,  621,  411,  337,  601,   86,  150,   40,   41,  534,
107749  /*  1180 */   566,  414,  242,  264,   42,  413,  412,  414,  600,  595,
107750  /*  1190 */   601,   85,  191,  333,  107,  451,  601,   84,  621,  539,
107751  /*  1200 */    40,   41,  420,  230,  411,  149,  316,   42,  413,  412,
107752  /*  1210 */   398,  127,  595,  315,  621,  399,  278,  625,  181,  414,
107753  /*  1220 */   593,  593,  593,  592,  591,   14,  450,  411,  601,   71,
107754  /*  1230 */   240,  621,   43,  405,  264,    3,  615,  180,  264,  415,
107755  /*  1240 */   622,  614,  414,  593,  593,  593,  592,  591,   14,  621,
107756  /*  1250 */   408,  601,   70,  621,  417,   33,  405,  613,    3,  411,
107757  /*  1260 */   264,  411,  415,  622,  418,  626,  178,  509,    8,  403,
107758  /*  1270 */   241,  416,  126,  408,  414,  621,  414,  449,  208,  566,
107759  /*  1280 */   240,  221,  621,  601,   83,  601,   82,  599,  297,  277,
107760  /*  1290 */   296,   30,  403,   31,  395,  264,  295,  397,  489,   40,
107761  /*  1300 */    41,  411,  566,  220,  621,  294,   42,  413,  412,  271,
107762  /*  1310 */   621,  595,  600,  621,   59,   60,  414,  269,  267,  623,
107763  /*  1320 */   622,   36,   40,   41,  621,  601,   81,  598,  235,   42,
107764  /*  1330 */   413,  412,  621,  621,  595,  265,  344,  411,  248,  556,
107765  /*  1340 */   173,  185,  593,  593,  593,  592,  591,   14,  218,   29,
107766  /*  1350 */   621,  543,  414,  305,  304,  303,  179,  301,  411,  566,
107767  /*  1360 */   454,  601,   80,  289,  335,  593,  593,  593,  592,  591,
107768  /*  1370 */    14,  411,  287,  414,  151,  392,  246,  260,  411,  196,
107769  /*  1380 */   195,  523,  601,   69,  411,  245,  414,  526,  537,  285,
107770  /*  1390 */   389,  595,  621,  414,  536,  601,   17,  362,  153,  414,
107771  /*  1400 */   466,  463,  601,   78,  154,  414,  462,  152,  601,   77,
107772  /*  1410 */   355,  255,  621,  455,  601,    9,  621,  386,  444,  517,
107773  /*  1420 */   247,  621,  593,  593,  593,  621,  621,  244,  621,  243,
107774  /*  1430 */   430,  518,  292,  621,  329,  621,  145,  393,  280,  513,
107775  /*  1440 */   291,  131,  621,  514,  621,  621,  311,  621,  259,  346,
107776  /*  1450 */   249,  621,  621,  229,  314,  621,  228,  512,  227,  240,
107777  /*  1460 */   494,  488,  310,  164,  487,  486,  373,  480,  163,  262,
107778  /*  1470 */   369,  371,  162,   26,  212,  478,  477,  161,  141,  363,
107779  /*  1480 */   467,  122,  339,  187,  119,  348,  347,  117,  116,  115,
107780  /*  1490 */   114,  112,  182,  457,  320,   22,  433,  432,  448,   19,
107781  /*  1500 */   609,  431,  428,   62,  193,  596,  573,  298,  555,  552,
107782  /*  1510 */   571,  404,  290,  380,  498,  510,  495,  306,  281,  499,
107783  /*  1520 */   250,    5,  497,  460,  345,  447,  569,  550,  238,  299,
107784  /*  1530 */   527,  525,  508,  961,  502,  501,  961,  401,  961,  211,
107785  /*  1540 */   490,  356,  256,  961,  483,  961,  961,  961,  961,  961,
107786  /*  1550 */   961,  961,  961,  961,  961,  961,  370,
107787 };
107788 static const YYCODETYPE yy_lookahead[] = {
107789  /*     0 */    19,  142,  143,  144,  145,   24,    1,   26,   77,   78,
107790  /*    10 */    79,   80,   81,   82,   83,   84,   85,   86,   87,   88,
107791  /*    20 */    89,   90,   91,   92,   15,   98,   26,   27,    7,    8,
107792  /*    30 */    49,   50,   77,   78,   79,   80,  109,   82,   83,   84,
107793  /*    40 */    85,   86,   87,   88,   89,   90,   91,   92,   22,   68,
107794  /*    50 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
107795  /*    60 */    79,   80,   23,   82,   83,   84,   85,   86,   87,   88,
107796  /*    70 */    89,   90,   91,   92,   19,   94,  112,   19,  114,  115,
107797  /*    80 */    25,   82,   83,   84,   85,   86,   87,   88,   89,   90,
107798  /*    90 */    91,   92,   19,   22,   94,   95,   96,  150,  150,   99,
107799  /*   100 */   100,  101,   76,  150,   49,   50,  105,  106,  107,   54,
107800  /*   110 */   110,  158,  165,  165,  161,  162,   26,   27,  165,  113,
107801  /*   120 */    16,  174,  175,   68,   69,   70,   71,   72,   73,   74,
107802  /*   130 */    75,   76,   77,   78,   79,   80,  118,   82,   83,   84,
107803  /*   140 */    85,   86,   87,   88,   89,   90,   91,   92,   19,   23,
107804  /*   150 */    92,   97,   98,   24,   96,   97,   98,   99,  100,  101,
107805  /*   160 */   102,   25,   97,  216,   60,   92,   62,  109,  221,   25,
107806  /*   170 */    97,   98,   99,  100,  101,  102,   86,   87,   49,   50,
107807  /*   180 */   118,  116,  109,   25,   94,   95,   32,   97,   88,   89,
107808  /*   190 */    90,   91,   92,  128,  104,   41,  106,   68,   69,   70,
107809  /*   200 */    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
107810  /*   210 */    11,   82,   83,   84,   85,   86,   87,   88,   89,   90,
107811  /*   220 */    91,   92,   19,   19,   86,   87,   88,   89,   90,   91,
107812  /*   230 */    92,   27,   96,  150,   66,   99,  100,  101,  112,  150,
107813  /*   240 */   114,  115,  138,  150,  161,  162,  110,  103,  165,  222,
107814  /*   250 */   223,  224,   49,   50,  165,   22,   57,   24,  165,  170,
107815  /*   260 */   171,  118,   94,  170,  171,   23,   98,   25,  185,  186,
107816  /*   270 */   243,   68,   69,   70,   71,   72,   73,   74,   75,   76,
107817  /*   280 */    77,   78,   79,   80,  126,   82,   83,   84,   85,   86,
107818  /*   290 */    87,   88,   89,   90,   91,   92,   19,  129,  130,  131,
107819  /*   300 */    88,   23,  172,  173,  105,  106,  107,  150,   22,   26,
107820  /*   310 */    27,  181,   26,   27,   22,  116,   26,   27,   26,  230,
107821  /*   320 */   231,  197,  165,  230,  231,  113,   49,   50,  204,  117,
107822  /*   330 */    96,  174,  175,   99,  100,  101,   22,   26,   27,  136,
107823  /*   340 */    26,   27,  118,   16,  110,   68,   69,   70,   71,   72,
107824  /*   350 */    73,   74,   75,   76,   77,   78,   79,   80,  118,   82,
107825  /*   360 */    83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
107826  /*   370 */    19,  214,  215,  150,   23,   23,  155,   94,   95,   22,
107827  /*   380 */    94,   95,  116,  160,   94,   95,   94,   60,  165,   62,
107828  /*   390 */   112,   26,  114,  115,  128,   23,   36,  174,  175,   88,
107829  /*   400 */    49,   50,   57,  120,   22,   94,   95,   23,   94,   95,
107830  /*   410 */   120,   51,   25,  136,  169,  170,  171,  194,   58,   68,
107831  /*   420 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
107832  /*   430 */    79,   80,   23,   82,   83,   84,   85,   86,   87,   88,
107833  /*   440 */    89,   90,   91,   92,   19,  150,   12,   12,   23,  228,
107834  /*   450 */   105,  106,  107,   23,  233,   25,  165,   19,  150,   94,
107835  /*   460 */   165,  116,   28,   28,  112,  174,  114,  115,  108,  174,
107836  /*   470 */   175,   26,   27,  165,   49,   50,  231,   11,   44,   44,
107837  /*   480 */    46,   46,  174,  175,  112,  160,  114,  115,   50,   22,
107838  /*   490 */    23,   57,   25,   68,   69,   70,   71,   72,   73,   74,
107839  /*   500 */    75,   76,   77,   78,   79,   80,  119,   82,   83,   84,
107840  /*   510 */    85,   86,   87,   88,   89,   90,   91,   92,   19,  194,
107841  /*   520 */   225,   23,   23,  215,   19,   95,  105,  106,  107,  150,
107842  /*   530 */    23,  150,   27,   23,   67,   25,  150,  206,  207,   94,
107843  /*   540 */    95,  166,  104,  218,  165,   22,  165,  109,   49,   50,
107844  /*   550 */   120,  165,   25,  174,  175,  174,  175,   23,   21,  234,
107845  /*   560 */   174,  175,   22,   23,  239,   25,   25,   68,   69,   70,
107846  /*   570 */    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
107847  /*   580 */   205,   82,   83,   84,   85,   86,   87,   88,   89,   90,
107848  /*   590 */    91,   92,   19,   22,   23,  216,   23,  222,  223,  224,
107849  /*   600 */    63,  220,   35,  150,  150,  163,  220,   67,  166,  167,
107850  /*   610 */   168,  150,  169,  170,  171,  161,  162,   25,  165,  165,
107851  /*   620 */   150,  113,   49,   50,   25,  117,  165,  174,  175,   35,
107852  /*   630 */     7,    8,    9,  160,  160,  165,  120,  100,   67,  247,
107853  /*   640 */   248,   68,   69,   70,   71,   72,   73,   74,   75,   76,
107854  /*   650 */    77,   78,   79,   80,  193,   82,   83,   84,   85,   86,
107855  /*   660 */    87,   88,   89,   90,   91,   92,   19,  194,  194,  150,
107856  /*   670 */   135,   24,  137,   35,  231,  138,  150,  129,  130,  206,
107857  /*   680 */   207,   30,   27,  213,  165,   34,  118,   95,    0,    1,
107858  /*   690 */     2,  165,  218,  174,  175,   50,   49,   50,   22,   48,
107859  /*   700 */   174,  175,   22,   23,   23,  244,  222,  223,  224,  166,
107860  /*   710 */   167,  168,  120,  239,   23,   68,   69,   70,   71,   72,
107861  /*   720 */    73,   74,   75,   76,   77,   78,   79,   80,  150,   82,
107862  /*   730 */    83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
107863  /*   740 */    19,  150,  173,  165,  181,  182,   24,   67,   26,  104,
107864  /*   750 */   181,  188,  174,  175,  150,   39,  165,  150,   52,  150,
107865  /*   760 */   150,  150,  150,  144,  145,  174,  175,  249,  250,  165,
107866  /*   770 */    49,   50,  165,   52,  165,  165,  165,  165,  174,  175,
107867  /*   780 */    29,  174,  175,  174,  175,  174,  175,  160,   22,   68,
107868  /*   790 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
107869  /*   800 */    79,   80,  150,   82,   83,   84,   85,   86,   87,   88,
107870  /*   810 */    89,   90,   91,   92,   19,  150,   94,  165,  150,  150,
107871  /*   820 */   160,  194,  150,  213,  160,   52,  174,  175,   23,   23,
107872  /*   830 */   165,   25,   22,  165,  165,  150,  150,  165,   52,  174,
107873  /*   840 */   175,   22,  174,  175,   49,   50,  174,  175,  190,  191,
107874  /*   850 */   165,  165,  240,   23,  194,   25,  187,  109,  194,  174,
107875  /*   860 */   175,  190,  191,   68,   69,   70,   71,   72,   73,   74,
107876  /*   870 */    75,   76,   77,   78,   79,   80,  150,   82,   83,   84,
107877  /*   880 */    85,   86,   87,   88,   89,   90,   91,   92,   19,  150,
107878  /*   890 */    22,  165,  150,   23,  150,   25,  150,  166,   91,   92,
107879  /*   900 */   174,  175,   22,  217,  165,  150,  102,  165,  150,  165,
107880  /*   910 */   150,  165,  150,  174,  175,   19,  174,  175,   49,   50,
107881  /*   920 */   165,   86,   87,  165,   23,  165,   25,  165,   24,  174,
107882  /*   930 */   175,  187,  174,  175,  174,  175,  205,   68,   69,   70,
107883  /*   940 */    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
107884  /*   950 */   150,   82,   83,   84,   85,   86,   87,   88,   89,   90,
107885  /*   960 */    91,   92,   19,  150,  150,  165,  150,  150,  166,   23,
107886  /*   970 */   150,   25,  160,   20,  174,  175,    1,    2,  165,  165,
107887  /*   980 */   104,  165,  165,   43,  150,  165,  240,  150,   49,   50,
107888  /*   990 */   174,  175,   49,   50,   23,   23,   25,   25,   53,  165,
107889  /*  1000 */   187,  187,  165,   23,  187,   25,  194,  205,  174,  175,
107890  /*  1010 */    71,   72,   69,   70,   71,   72,   73,   74,   75,   76,
107891  /*  1020 */    77,   78,   79,   80,  150,   82,   83,   84,   85,   86,
107892  /*  1030 */    87,   88,   89,   90,   91,   92,   19,   98,  150,  165,
107893  /*  1040 */   150,  160,  150,   59,   25,   53,  104,   22,  174,  175,
107894  /*  1050 */   213,  138,    5,  165,    1,  165,  150,  165,  150,  150,
107895  /*  1060 */   240,  150,  174,  175,  174,  175,   49,   50,  118,  150,
107896  /*  1070 */    35,  165,   27,  165,  165,  194,  165,  108,  127,   76,
107897  /*  1080 */   174,  175,  174,  175,  165,  174,  175,   70,   71,   72,
107898  /*  1090 */    73,   74,   75,   76,   77,   78,   79,   80,  166,   82,
107899  /*  1100 */    83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
107900  /*  1110 */    19,   20,  193,   22,  150,  150,  150,   26,   27,   76,
107901  /*  1120 */   150,   22,    1,  150,  119,  121,  217,   20,   37,  165,
107902  /*  1130 */   165,  165,   16,   19,   20,  165,   22,  205,  165,  119,
107903  /*  1140 */    26,   27,  108,  128,  150,  150,  150,   56,  150,   22,
107904  /*  1150 */   150,   37,  150,  127,  160,   23,  150,   66,  193,  165,
107905  /*  1160 */   165,  165,   16,  165,   23,  165,  150,  165,  174,  175,
107906  /*  1170 */    56,  165,  150,   65,  174,  175,   15,   86,   87,   88,
107907  /*  1180 */    66,  165,  140,  150,   93,   94,   95,  165,  194,   98,
107908  /*  1190 */   174,  175,   22,    3,  164,  193,  174,  175,  165,  150,
107909  /*  1200 */    86,   87,    4,  180,  150,  248,  251,   93,   94,   95,
107910  /*  1210 */   216,  180,   98,  251,  165,  221,  150,  149,    6,  165,
107911  /*  1220 */   129,  130,  131,  132,  133,  134,  193,  150,  174,  175,
107912  /*  1230 */   116,  165,   19,   20,  150,   22,  149,  151,  150,   26,
107913  /*  1240 */    27,  149,  165,  129,  130,  131,  132,  133,  134,  165,
107914  /*  1250 */    37,  174,  175,  165,  149,   19,   20,   13,   22,  150,
107915  /*  1260 */   150,  150,   26,   27,  146,  147,  151,  150,   25,   56,
107916  /*  1270 */   152,  159,  154,   37,  165,  165,  165,  193,  160,   66,
107917  /*  1280 */   116,  193,  165,  174,  175,  174,  175,  194,  199,  150,
107918  /*  1290 */   200,  126,   56,  124,  123,  150,  201,  122,  150,   86,
107919  /*  1300 */    87,  150,   66,  193,  165,  202,   93,   94,   95,  150,
107920  /*  1310 */   165,   98,  194,  165,  125,   22,  165,  150,  150,   26,
107921  /*  1320 */    27,  135,   86,   87,  165,  174,  175,  203,  226,   93,
107922  /*  1330 */    94,   95,  165,  165,   98,  150,  218,  150,  193,  157,
107923  /*  1340 */   118,  157,  129,  130,  131,  132,  133,  134,    5,  104,
107924  /*  1350 */   165,  211,  165,   10,   11,   12,   13,   14,  150,   66,
107925  /*  1360 */    17,  174,  175,  210,  246,  129,  130,  131,  132,  133,
107926  /*  1370 */   134,  150,  210,  165,   31,  121,   33,  150,  150,   86,
107927  /*  1380 */    87,  176,  174,  175,  150,   42,  165,   94,  211,  210,
107928  /*  1390 */   150,   98,  165,  165,  211,  174,  175,  150,   55,  165,
107929  /*  1400 */    57,  150,  174,  175,   61,  165,  150,   64,  174,  175,
107930  /*  1410 */   150,  150,  165,  150,  174,  175,  165,  104,  150,  184,
107931  /*  1420 */   150,  165,  129,  130,  131,  165,  165,  150,  165,  150,
107932  /*  1430 */   150,  176,  150,  165,   47,  165,  150,  150,  176,  103,
107933  /*  1440 */   150,   22,  165,  178,  165,  165,  179,  165,  105,  106,
107934  /*  1450 */   107,  165,  165,  229,  111,  165,   92,  176,  229,  116,
107935  /*  1460 */   184,  176,  179,  156,  176,  176,   18,  157,  156,  237,
107936  /*  1470 */    45,  157,  156,  135,  157,  157,  238,  156,   68,  157,
107937  /*  1480 */   189,  189,  139,  219,   22,  157,   18,  192,  192,  192,
107938  /*  1490 */   192,  189,  219,  199,  157,  242,   40,  157,  199,  242,
107939  /*  1500 */   153,  157,   38,  245,  196,  166,  232,  198,  177,  177,
107940  /*  1510 */   232,  227,  209,  178,  166,  182,  166,  148,  177,  177,
107941  /*  1520 */   209,  196,  177,  199,  209,  199,  166,  208,   92,  195,
107942  /*  1530 */   174,  174,  183,  252,  183,  183,  252,  191,  252,  235,
107943  /*  1540 */   186,  241,  241,  252,  186,  252,  252,  252,  252,  252,
107944  /*  1550 */   252,  252,  252,  252,  252,  252,  236,
107945 };
107946 #define YY_SHIFT_USE_DFLT (-74)
107947 #define YY_SHIFT_COUNT (418)
107948 #define YY_SHIFT_MIN   (-73)
107949 #define YY_SHIFT_MAX   (1468)
107950 static const short yy_shift_ofst[] = {
107951  /*     0 */   975, 1114, 1343, 1114, 1213, 1213,   90,   90,    0,  -19,
107952  /*    10 */  1213, 1213, 1213, 1213, 1213,  345,  445,  721, 1091, 1213,
107953  /*    20 */  1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
107954  /*    30 */  1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
107955  /*    40 */  1213, 1213, 1213, 1213, 1213, 1213, 1213, 1236, 1213, 1213,
107956  /*    50 */  1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
107957  /*    60 */  1213,  199,  445,  445,  835,  835,  365, 1164,   55,  647,
107958  /*    70 */   573,  499,  425,  351,  277,  203,  129,  795,  795,  795,
107959  /*    80 */   795,  795,  795,  795,  795,  795,  795,  795,  795,  795,
107960  /*    90 */   795,  795,  795,  795,  795,  869,  795,  943, 1017, 1017,
107961  /*   100 */   -69,  -45,  -45,  -45,  -45,  -45,   -1,   58,  138,  100,
107962  /*   110 */   445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
107963  /*   120 */   445,  445,  445,  445,  445,  445,  537,  438,  445,  445,
107964  /*   130 */   445,  445,  445,  365,  807, 1436,  -74,  -74,  -74, 1293,
107965  /*   140 */    73,  434,  434,  311,  314,  290,  283,  286,  540,  467,
107966  /*   150 */   445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
107967  /*   160 */   445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
107968  /*   170 */   445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
107969  /*   180 */   445,  445,   65,  722,  722,  722,  688,  266, 1164, 1164,
107970  /*   190 */  1164,  -74,  -74,  -74,  136,  168,  168,  234,  360,  360,
107971  /*   200 */   360,  430,  372,  435,  352,  278,  126,  -36,  -36,  -36,
107972  /*   210 */   -36,  421,  651,  -36,  -36,  592,  292,  212,  623,  158,
107973  /*   220 */   204,  204,  505,  158,  505,  144,  365,  154,  365,  154,
107974  /*   230 */   645,  154,  204,  154,  154,  535,  548,  548,  365,  387,
107975  /*   240 */   508,  233, 1464, 1222, 1222, 1456, 1456, 1222, 1462, 1410,
107976  /*   250 */  1165, 1468, 1468, 1468, 1468, 1222, 1165, 1462, 1410, 1410,
107977  /*   260 */  1222, 1448, 1338, 1425, 1222, 1222, 1448, 1222, 1448, 1222,
107978  /*   270 */  1448, 1419, 1313, 1313, 1313, 1387, 1364, 1364, 1419, 1313,
107979  /*   280 */  1336, 1313, 1387, 1313, 1313, 1254, 1245, 1254, 1245, 1254,
107980  /*   290 */  1245, 1222, 1222, 1186, 1189, 1175, 1169, 1171, 1165, 1164,
107981  /*   300 */  1243, 1244, 1244, 1212, 1212, 1212, 1212,  -74,  -74,  -74,
107982  /*   310 */   -74,  -74,  -74,  939,  104,  680,  571,  327,    1,  980,
107983  /*   320 */    26,  972,  971,  946,  901,  870,  830,  806,   54,   21,
107984  /*   330 */   -73,  510,  242, 1198, 1190, 1170, 1042, 1161, 1108, 1146,
107985  /*   340 */  1141, 1132, 1015, 1127, 1026, 1034, 1020, 1107, 1004, 1116,
107986  /*   350 */  1121, 1005, 1099,  951, 1043, 1003,  969, 1045, 1035,  950,
107987  /*   360 */  1053, 1047, 1025,  942,  913,  992, 1019,  945,  984,  940,
107988  /*   370 */   876,  904,  953,  896,  748,  804,  880,  786,  868,  819,
107989  /*   380 */   805,  810,  773,  751,  766,  706,  716,  691,  681,  568,
107990  /*   390 */   655,  638,  676,  516,  541,  594,  599,  567,  541,  534,
107991  /*   400 */   507,  527,  498,  523,  466,  382,  409,  384,  357,    6,
107992  /*   410 */   240,  224,  143,   62,   18,   71,   39,    9,    5,
107993 };
107994 #define YY_REDUCE_USE_DFLT (-142)
107995 #define YY_REDUCE_COUNT (312)
107996 #define YY_REDUCE_MIN   (-141)
107997 #define YY_REDUCE_MAX   (1369)
107998 static const short yy_reduce_ofst[] = {
107999  /*     0 */  -141,  994, 1118,  223,  157,  -53,   93,   89,   83,  375,
108000  /*    10 */   386,  381,  379,  308,  295,  325,  -47,   27, 1240, 1234,
108001  /*    20 */  1228, 1221, 1208, 1187, 1151, 1111, 1109, 1077, 1054, 1022,
108002  /*    30 */  1016, 1000,  911,  908,  906,  890,  888,  874,  834,  816,
108003  /*    40 */   800,  760,  758,  755,  742,  739,  726,  685,  672,  668,
108004  /*    50 */   665,  652,  611,  609,  607,  604,  591,  578,  526,  519,
108005  /*    60 */   453,  474,  454,  461,  443,  245,  442,  473,  484,  484,
108006  /*    70 */   484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
108007  /*    80 */   484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
108008  /*    90 */   484,  484,  484,  484,  484,  484,  484,  484,  484,  484,
108009  /*   100 */   484,  484,  484,  484,  484,  484,  484,  130,  484,  484,
108010  /*   110 */  1145,  909, 1110, 1088, 1084, 1033, 1002,  965,  820,  837,
108011  /*   120 */   746,  686,  612,  817,  610,  919,  221,  563,  814,  813,
108012  /*   130 */   744,  669,  470,  543,  484,  484,  484,  484,  484,  291,
108013  /*   140 */   569,  671,  658,  970, 1290, 1287, 1286, 1282,  518,  518,
108014  /*   150 */  1280, 1279, 1277, 1270, 1268, 1263, 1261, 1260, 1256, 1251,
108015  /*   160 */  1247, 1227, 1185, 1168, 1167, 1159, 1148, 1139, 1117, 1066,
108016  /*   170 */  1049, 1006,  998,  996,  995,  973,  970,  966,  964,  892,
108017  /*   180 */   762,  -52,  881,  932,  802,  731,  619,  812,  664,  660,
108018  /*   190 */   627,  392,  331,  124, 1358, 1357, 1356, 1354, 1352, 1351,
108019  /*   200 */  1349, 1319, 1334, 1346, 1334, 1334, 1334, 1334, 1334, 1334,
108020  /*   210 */  1334, 1320, 1304, 1334, 1334, 1319, 1360, 1325, 1369, 1326,
108021  /*   220 */  1315, 1311, 1301, 1324, 1300, 1335, 1350, 1345, 1348, 1342,
108022  /*   230 */  1333, 1341, 1303, 1332, 1331, 1284, 1278, 1274, 1339, 1309,
108023  /*   240 */  1308, 1347, 1258, 1344, 1340, 1257, 1253, 1337, 1273, 1302,
108024  /*   250 */  1299, 1298, 1297, 1296, 1295, 1328, 1294, 1264, 1292, 1291,
108025  /*   260 */  1322, 1321, 1238, 1232, 1318, 1317, 1316, 1314, 1312, 1310,
108026  /*   270 */  1307, 1283, 1289, 1288, 1285, 1276, 1229, 1224, 1267, 1281,
108027  /*   280 */  1265, 1262, 1235, 1255, 1205, 1183, 1179, 1177, 1162, 1140,
108028  /*   290 */  1153, 1184, 1182, 1102, 1124, 1103, 1095, 1090, 1089, 1093,
108029  /*   300 */  1112, 1115, 1086, 1105, 1092, 1087, 1068,  962,  955,  957,
108030  /*   310 */  1031, 1023, 1030,
108031 };
108032 static const YYACTIONTYPE yy_default[] = {
108033  /*     0 */   635,  870,  959,  959,  959,  870,  899,  899,  959,  759,
108034  /*    10 */   959,  959,  959,  959,  868,  959,  959,  933,  959,  959,
108035  /*    20 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108036  /*    30 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108037  /*    40 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108038  /*    50 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108039  /*    60 */   959,  959,  959,  959,  899,  899,  674,  763,  794,  959,
108040  /*    70 */   959,  959,  959,  959,  959,  959,  959,  932,  934,  809,
108041  /*    80 */   808,  802,  801,  912,  774,  799,  792,  785,  796,  871,
108042  /*    90 */   864,  865,  863,  867,  872,  959,  795,  831,  848,  830,
108043  /*   100 */   842,  847,  854,  846,  843,  833,  832,  666,  834,  835,
108044  /*   110 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108045  /*   120 */   959,  959,  959,  959,  959,  959,  661,  728,  959,  959,
108046  /*   130 */   959,  959,  959,  959,  836,  837,  851,  850,  849,  959,
108047  /*   140 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108048  /*   150 */   959,  939,  937,  959,  883,  959,  959,  959,  959,  959,
108049  /*   160 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108050  /*   170 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108051  /*   180 */   959,  641,  959,  759,  759,  759,  635,  959,  959,  959,
108052  /*   190 */   959,  951,  763,  753,  719,  959,  959,  959,  959,  959,
108053  /*   200 */   959,  959,  959,  959,  959,  959,  959,  804,  742,  922,
108054  /*   210 */   924,  959,  905,  740,  663,  761,  676,  751,  643,  798,
108055  /*   220 */   776,  776,  917,  798,  917,  700,  959,  788,  959,  788,
108056  /*   230 */   697,  788,  776,  788,  788,  866,  959,  959,  959,  760,
108057  /*   240 */   751,  959,  944,  767,  767,  936,  936,  767,  810,  732,
108058  /*   250 */   798,  739,  739,  739,  739,  767,  798,  810,  732,  732,
108059  /*   260 */   767,  658,  911,  909,  767,  767,  658,  767,  658,  767,
108060  /*   270 */   658,  876,  730,  730,  730,  715,  880,  880,  876,  730,
108061  /*   280 */   700,  730,  715,  730,  730,  780,  775,  780,  775,  780,
108062  /*   290 */   775,  767,  767,  959,  793,  781,  791,  789,  798,  959,
108063  /*   300 */   718,  651,  651,  640,  640,  640,  640,  956,  956,  951,
108064  /*   310 */   702,  702,  684,  959,  959,  959,  959,  959,  959,  959,
108065  /*   320 */   885,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108066  /*   330 */   959,  959,  959,  959,  636,  946,  959,  959,  943,  959,
108067  /*   340 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108068  /*   350 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  915,
108069  /*   360 */   959,  959,  959,  959,  959,  959,  908,  907,  959,  959,
108070  /*   370 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108071  /*   380 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  959,
108072  /*   390 */   959,  959,  959,  959,  790,  959,  782,  959,  869,  959,
108073  /*   400 */   959,  959,  959,  959,  959,  959,  959,  959,  959,  745,
108074  /*   410 */   819,  959,  818,  822,  817,  668,  959,  649,  959,  632,
108075  /*   420 */   637,  955,  958,  957,  954,  953,  952,  947,  945,  942,
108076  /*   430 */   941,  940,  938,  935,  931,  889,  887,  894,  893,  892,
108077  /*   440 */   891,  890,  888,  886,  884,  805,  803,  800,  797,  930,
108078  /*   450 */   882,  741,  738,  737,  657,  948,  914,  923,  921,  811,
108079  /*   460 */   920,  919,  918,  916,  913,  900,  807,  806,  733,  874,
108080  /*   470 */   873,  660,  904,  903,  902,  906,  910,  901,  769,  659,
108081  /*   480 */   656,  665,  722,  721,  729,  727,  726,  725,  724,  723,
108082  /*   490 */   720,  667,  675,  686,  714,  699,  698,  879,  881,  878,
108083  /*   500 */   877,  707,  706,  712,  711,  710,  709,  708,  705,  704,
108084  /*   510 */   703,  696,  695,  701,  694,  717,  716,  713,  693,  736,
108085  /*   520 */   735,  734,  731,  692,  691,  690,  822,  689,  688,  828,
108086  /*   530 */   827,  815,  858,  756,  755,  754,  766,  765,  778,  777,
108087  /*   540 */   813,  812,  779,  764,  758,  757,  773,  772,  771,  770,
108088  /*   550 */   762,  752,  784,  787,  786,  783,  860,  768,  857,  929,
108089  /*   560 */   928,  927,  926,  925,  862,  861,  829,  826,  679,  680,
108090  /*   570 */   898,  896,  897,  895,  682,  681,  678,  677,  859,  747,
108091  /*   580 */   746,  855,  852,  844,  840,  856,  853,  845,  841,  839,
108092  /*   590 */   838,  824,  823,  821,  820,  816,  825,  670,  748,  744,
108093  /*   600 */   743,  814,  750,  749,  687,  685,  683,  664,  662,  655,
108094  /*   610 */   653,  652,  654,  650,  648,  647,  646,  645,  644,  673,
108095  /*   620 */   672,  671,  669,  668,  642,  639,  638,  634,  633,  631,
108096 };
108097
108098 /* The next table maps tokens into fallback tokens.  If a construct
108099 ** like the following:
108100 ** 
108101 **      %fallback ID X Y Z.
108102 **
108103 ** appears in the grammar, then ID becomes a fallback token for X, Y,
108104 ** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
108105 ** but it does not parse, the type of the token is changed to ID and
108106 ** the parse is retried before an error is thrown.
108107 */
108108 #ifdef YYFALLBACK
108109 static const YYCODETYPE yyFallback[] = {
108110     0,  /*          $ => nothing */
108111     0,  /*       SEMI => nothing */
108112    26,  /*    EXPLAIN => ID */
108113    26,  /*      QUERY => ID */
108114    26,  /*       PLAN => ID */
108115    26,  /*      BEGIN => ID */
108116     0,  /* TRANSACTION => nothing */
108117    26,  /*   DEFERRED => ID */
108118    26,  /*  IMMEDIATE => ID */
108119    26,  /*  EXCLUSIVE => ID */
108120     0,  /*     COMMIT => nothing */
108121    26,  /*        END => ID */
108122    26,  /*   ROLLBACK => ID */
108123    26,  /*  SAVEPOINT => ID */
108124    26,  /*    RELEASE => ID */
108125     0,  /*         TO => nothing */
108126     0,  /*      TABLE => nothing */
108127     0,  /*     CREATE => nothing */
108128    26,  /*         IF => ID */
108129     0,  /*        NOT => nothing */
108130     0,  /*     EXISTS => nothing */
108131    26,  /*       TEMP => ID */
108132     0,  /*         LP => nothing */
108133     0,  /*         RP => nothing */
108134     0,  /*         AS => nothing */
108135     0,  /*      COMMA => nothing */
108136     0,  /*         ID => nothing */
108137     0,  /*    INDEXED => nothing */
108138    26,  /*      ABORT => ID */
108139    26,  /*     ACTION => ID */
108140    26,  /*      AFTER => ID */
108141    26,  /*    ANALYZE => ID */
108142    26,  /*        ASC => ID */
108143    26,  /*     ATTACH => ID */
108144    26,  /*     BEFORE => ID */
108145    26,  /*         BY => ID */
108146    26,  /*    CASCADE => ID */
108147    26,  /*       CAST => ID */
108148    26,  /*   COLUMNKW => ID */
108149    26,  /*   CONFLICT => ID */
108150    26,  /*   DATABASE => ID */
108151    26,  /*       DESC => ID */
108152    26,  /*     DETACH => ID */
108153    26,  /*       EACH => ID */
108154    26,  /*       FAIL => ID */
108155    26,  /*        FOR => ID */
108156    26,  /*     IGNORE => ID */
108157    26,  /*  INITIALLY => ID */
108158    26,  /*    INSTEAD => ID */
108159    26,  /*    LIKE_KW => ID */
108160    26,  /*      MATCH => ID */
108161    26,  /*         NO => ID */
108162    26,  /*        KEY => ID */
108163    26,  /*         OF => ID */
108164    26,  /*     OFFSET => ID */
108165    26,  /*     PRAGMA => ID */
108166    26,  /*      RAISE => ID */
108167    26,  /*    REPLACE => ID */
108168    26,  /*   RESTRICT => ID */
108169    26,  /*        ROW => ID */
108170    26,  /*    TRIGGER => ID */
108171    26,  /*     VACUUM => ID */
108172    26,  /*       VIEW => ID */
108173    26,  /*    VIRTUAL => ID */
108174    26,  /*    REINDEX => ID */
108175    26,  /*     RENAME => ID */
108176    26,  /*   CTIME_KW => ID */
108177 };
108178 #endif /* YYFALLBACK */
108179
108180 /* The following structure represents a single element of the
108181 ** parser's stack.  Information stored includes:
108182 **
108183 **   +  The state number for the parser at this level of the stack.
108184 **
108185 **   +  The value of the token stored at this level of the stack.
108186 **      (In other words, the "major" token.)
108187 **
108188 **   +  The semantic value stored at this level of the stack.  This is
108189 **      the information used by the action routines in the grammar.
108190 **      It is sometimes called the "minor" token.
108191 */
108192 struct yyStackEntry {
108193   YYACTIONTYPE stateno;  /* The state-number */
108194   YYCODETYPE major;      /* The major token value.  This is the code
108195                          ** number for the token at this stack level */
108196   YYMINORTYPE minor;     /* The user-supplied minor token value.  This
108197                          ** is the value of the token  */
108198 };
108199 typedef struct yyStackEntry yyStackEntry;
108200
108201 /* The state of the parser is completely contained in an instance of
108202 ** the following structure */
108203 struct yyParser {
108204   int yyidx;                    /* Index of top element in stack */
108205 #ifdef YYTRACKMAXSTACKDEPTH
108206   int yyidxMax;                 /* Maximum value of yyidx */
108207 #endif
108208   int yyerrcnt;                 /* Shifts left before out of the error */
108209   sqlcipher3ParserARG_SDECL                /* A place to hold %extra_argument */
108210 #if YYSTACKDEPTH<=0
108211   int yystksz;                  /* Current side of the stack */
108212   yyStackEntry *yystack;        /* The parser's stack */
108213 #else
108214   yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
108215 #endif
108216 };
108217 typedef struct yyParser yyParser;
108218
108219 #ifndef NDEBUG
108220 /* #include <stdio.h> */
108221 static FILE *yyTraceFILE = 0;
108222 static char *yyTracePrompt = 0;
108223 #endif /* NDEBUG */
108224
108225 #ifndef NDEBUG
108226 /* 
108227 ** Turn parser tracing on by giving a stream to which to write the trace
108228 ** and a prompt to preface each trace message.  Tracing is turned off
108229 ** by making either argument NULL 
108230 **
108231 ** Inputs:
108232 ** <ul>
108233 ** <li> A FILE* to which trace output should be written.
108234 **      If NULL, then tracing is turned off.
108235 ** <li> A prefix string written at the beginning of every
108236 **      line of trace output.  If NULL, then tracing is
108237 **      turned off.
108238 ** </ul>
108239 **
108240 ** Outputs:
108241 ** None.
108242 */
108243 SQLCIPHER_PRIVATE void sqlcipher3ParserTrace(FILE *TraceFILE, char *zTracePrompt){
108244   yyTraceFILE = TraceFILE;
108245   yyTracePrompt = zTracePrompt;
108246   if( yyTraceFILE==0 ) yyTracePrompt = 0;
108247   else if( yyTracePrompt==0 ) yyTraceFILE = 0;
108248 }
108249 #endif /* NDEBUG */
108250
108251 #ifndef NDEBUG
108252 /* For tracing shifts, the names of all terminals and nonterminals
108253 ** are required.  The following table supplies these names */
108254 static const char *const yyTokenName[] = { 
108255   "$",             "SEMI",          "EXPLAIN",       "QUERY",       
108256   "PLAN",          "BEGIN",         "TRANSACTION",   "DEFERRED",    
108257   "IMMEDIATE",     "EXCLUSIVE",     "COMMIT",        "END",         
108258   "ROLLBACK",      "SAVEPOINT",     "RELEASE",       "TO",          
108259   "TABLE",         "CREATE",        "IF",            "NOT",         
108260   "EXISTS",        "TEMP",          "LP",            "RP",          
108261   "AS",            "COMMA",         "ID",            "INDEXED",     
108262   "ABORT",         "ACTION",        "AFTER",         "ANALYZE",     
108263   "ASC",           "ATTACH",        "BEFORE",        "BY",          
108264   "CASCADE",       "CAST",          "COLUMNKW",      "CONFLICT",    
108265   "DATABASE",      "DESC",          "DETACH",        "EACH",        
108266   "FAIL",          "FOR",           "IGNORE",        "INITIALLY",   
108267   "INSTEAD",       "LIKE_KW",       "MATCH",         "NO",          
108268   "KEY",           "OF",            "OFFSET",        "PRAGMA",      
108269   "RAISE",         "REPLACE",       "RESTRICT",      "ROW",         
108270   "TRIGGER",       "VACUUM",        "VIEW",          "VIRTUAL",     
108271   "REINDEX",       "RENAME",        "CTIME_KW",      "ANY",         
108272   "OR",            "AND",           "IS",            "BETWEEN",     
108273   "IN",            "ISNULL",        "NOTNULL",       "NE",          
108274   "EQ",            "GT",            "LE",            "LT",          
108275   "GE",            "ESCAPE",        "BITAND",        "BITOR",       
108276   "LSHIFT",        "RSHIFT",        "PLUS",          "MINUS",       
108277   "STAR",          "SLASH",         "REM",           "CONCAT",      
108278   "COLLATE",       "BITNOT",        "STRING",        "JOIN_KW",     
108279   "CONSTRAINT",    "DEFAULT",       "NULL",          "PRIMARY",     
108280   "UNIQUE",        "CHECK",         "REFERENCES",    "AUTOINCR",    
108281   "ON",            "INSERT",        "DELETE",        "UPDATE",      
108282   "SET",           "DEFERRABLE",    "FOREIGN",       "DROP",        
108283   "UNION",         "ALL",           "EXCEPT",        "INTERSECT",   
108284   "SELECT",        "DISTINCT",      "DOT",           "FROM",        
108285   "JOIN",          "USING",         "ORDER",         "GROUP",       
108286   "HAVING",        "LIMIT",         "WHERE",         "INTO",        
108287   "VALUES",        "INTEGER",       "FLOAT",         "BLOB",        
108288   "REGISTER",      "VARIABLE",      "CASE",          "WHEN",        
108289   "THEN",          "ELSE",          "INDEX",         "ALTER",       
108290   "ADD",           "error",         "input",         "cmdlist",     
108291   "ecmd",          "explain",       "cmdx",          "cmd",         
108292   "transtype",     "trans_opt",     "nm",            "savepoint_opt",
108293   "create_table",  "create_table_args",  "createkw",      "temp",        
108294   "ifnotexists",   "dbnm",          "columnlist",    "conslist_opt",
108295   "select",        "column",        "columnid",      "type",        
108296   "carglist",      "id",            "ids",           "typetoken",   
108297   "typename",      "signed",        "plus_num",      "minus_num",   
108298   "carg",          "ccons",         "term",          "expr",        
108299   "onconf",        "sortorder",     "autoinc",       "idxlist_opt", 
108300   "refargs",       "defer_subclause",  "refarg",        "refact",      
108301   "init_deferred_pred_opt",  "conslist",      "tcons",         "idxlist",     
108302   "defer_subclause_opt",  "orconf",        "resolvetype",   "raisetype",   
108303   "ifexists",      "fullname",      "oneselect",     "multiselect_op",
108304   "distinct",      "selcollist",    "from",          "where_opt",   
108305   "groupby_opt",   "having_opt",    "orderby_opt",   "limit_opt",   
108306   "sclp",          "as",            "seltablist",    "stl_prefix",  
108307   "joinop",        "indexed_opt",   "on_opt",        "using_opt",   
108308   "joinop2",       "inscollist",    "sortlist",      "sortitem",    
108309   "nexprlist",     "setlist",       "insert_cmd",    "inscollist_opt",
108310   "itemlist",      "exprlist",      "likeop",        "between_op",  
108311   "in_op",         "case_operand",  "case_exprlist",  "case_else",   
108312   "uniqueflag",    "collate",       "nmnum",         "plus_opt",    
108313   "number",        "trigger_decl",  "trigger_cmd_list",  "trigger_time",
108314   "trigger_event",  "foreach_clause",  "when_clause",   "trigger_cmd", 
108315   "trnm",          "tridxby",       "database_kw_opt",  "key_opt",     
108316   "add_column_fullname",  "kwcolumn_opt",  "create_vtab",   "vtabarglist", 
108317   "vtabarg",       "vtabargtoken",  "lp",            "anylist",     
108318 };
108319 #endif /* NDEBUG */
108320
108321 #ifndef NDEBUG
108322 /* For tracing reduce actions, the names of all rules are required.
108323 */
108324 static const char *const yyRuleName[] = {
108325  /*   0 */ "input ::= cmdlist",
108326  /*   1 */ "cmdlist ::= cmdlist ecmd",
108327  /*   2 */ "cmdlist ::= ecmd",
108328  /*   3 */ "ecmd ::= SEMI",
108329  /*   4 */ "ecmd ::= explain cmdx SEMI",
108330  /*   5 */ "explain ::=",
108331  /*   6 */ "explain ::= EXPLAIN",
108332  /*   7 */ "explain ::= EXPLAIN QUERY PLAN",
108333  /*   8 */ "cmdx ::= cmd",
108334  /*   9 */ "cmd ::= BEGIN transtype trans_opt",
108335  /*  10 */ "trans_opt ::=",
108336  /*  11 */ "trans_opt ::= TRANSACTION",
108337  /*  12 */ "trans_opt ::= TRANSACTION nm",
108338  /*  13 */ "transtype ::=",
108339  /*  14 */ "transtype ::= DEFERRED",
108340  /*  15 */ "transtype ::= IMMEDIATE",
108341  /*  16 */ "transtype ::= EXCLUSIVE",
108342  /*  17 */ "cmd ::= COMMIT trans_opt",
108343  /*  18 */ "cmd ::= END trans_opt",
108344  /*  19 */ "cmd ::= ROLLBACK trans_opt",
108345  /*  20 */ "savepoint_opt ::= SAVEPOINT",
108346  /*  21 */ "savepoint_opt ::=",
108347  /*  22 */ "cmd ::= SAVEPOINT nm",
108348  /*  23 */ "cmd ::= RELEASE savepoint_opt nm",
108349  /*  24 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm",
108350  /*  25 */ "cmd ::= create_table create_table_args",
108351  /*  26 */ "create_table ::= createkw temp TABLE ifnotexists nm dbnm",
108352  /*  27 */ "createkw ::= CREATE",
108353  /*  28 */ "ifnotexists ::=",
108354  /*  29 */ "ifnotexists ::= IF NOT EXISTS",
108355  /*  30 */ "temp ::= TEMP",
108356  /*  31 */ "temp ::=",
108357  /*  32 */ "create_table_args ::= LP columnlist conslist_opt RP",
108358  /*  33 */ "create_table_args ::= AS select",
108359  /*  34 */ "columnlist ::= columnlist COMMA column",
108360  /*  35 */ "columnlist ::= column",
108361  /*  36 */ "column ::= columnid type carglist",
108362  /*  37 */ "columnid ::= nm",
108363  /*  38 */ "id ::= ID",
108364  /*  39 */ "id ::= INDEXED",
108365  /*  40 */ "ids ::= ID|STRING",
108366  /*  41 */ "nm ::= id",
108367  /*  42 */ "nm ::= STRING",
108368  /*  43 */ "nm ::= JOIN_KW",
108369  /*  44 */ "type ::=",
108370  /*  45 */ "type ::= typetoken",
108371  /*  46 */ "typetoken ::= typename",
108372  /*  47 */ "typetoken ::= typename LP signed RP",
108373  /*  48 */ "typetoken ::= typename LP signed COMMA signed RP",
108374  /*  49 */ "typename ::= ids",
108375  /*  50 */ "typename ::= typename ids",
108376  /*  51 */ "signed ::= plus_num",
108377  /*  52 */ "signed ::= minus_num",
108378  /*  53 */ "carglist ::= carglist carg",
108379  /*  54 */ "carglist ::=",
108380  /*  55 */ "carg ::= CONSTRAINT nm ccons",
108381  /*  56 */ "carg ::= ccons",
108382  /*  57 */ "ccons ::= DEFAULT term",
108383  /*  58 */ "ccons ::= DEFAULT LP expr RP",
108384  /*  59 */ "ccons ::= DEFAULT PLUS term",
108385  /*  60 */ "ccons ::= DEFAULT MINUS term",
108386  /*  61 */ "ccons ::= DEFAULT id",
108387  /*  62 */ "ccons ::= NULL onconf",
108388  /*  63 */ "ccons ::= NOT NULL onconf",
108389  /*  64 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
108390  /*  65 */ "ccons ::= UNIQUE onconf",
108391  /*  66 */ "ccons ::= CHECK LP expr RP",
108392  /*  67 */ "ccons ::= REFERENCES nm idxlist_opt refargs",
108393  /*  68 */ "ccons ::= defer_subclause",
108394  /*  69 */ "ccons ::= COLLATE ids",
108395  /*  70 */ "autoinc ::=",
108396  /*  71 */ "autoinc ::= AUTOINCR",
108397  /*  72 */ "refargs ::=",
108398  /*  73 */ "refargs ::= refargs refarg",
108399  /*  74 */ "refarg ::= MATCH nm",
108400  /*  75 */ "refarg ::= ON INSERT refact",
108401  /*  76 */ "refarg ::= ON DELETE refact",
108402  /*  77 */ "refarg ::= ON UPDATE refact",
108403  /*  78 */ "refact ::= SET NULL",
108404  /*  79 */ "refact ::= SET DEFAULT",
108405  /*  80 */ "refact ::= CASCADE",
108406  /*  81 */ "refact ::= RESTRICT",
108407  /*  82 */ "refact ::= NO ACTION",
108408  /*  83 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
108409  /*  84 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
108410  /*  85 */ "init_deferred_pred_opt ::=",
108411  /*  86 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
108412  /*  87 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
108413  /*  88 */ "conslist_opt ::=",
108414  /*  89 */ "conslist_opt ::= COMMA conslist",
108415  /*  90 */ "conslist ::= conslist COMMA tcons",
108416  /*  91 */ "conslist ::= conslist tcons",
108417  /*  92 */ "conslist ::= tcons",
108418  /*  93 */ "tcons ::= CONSTRAINT nm",
108419  /*  94 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf",
108420  /*  95 */ "tcons ::= UNIQUE LP idxlist RP onconf",
108421  /*  96 */ "tcons ::= CHECK LP expr RP onconf",
108422  /*  97 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt",
108423  /*  98 */ "defer_subclause_opt ::=",
108424  /*  99 */ "defer_subclause_opt ::= defer_subclause",
108425  /* 100 */ "onconf ::=",
108426  /* 101 */ "onconf ::= ON CONFLICT resolvetype",
108427  /* 102 */ "orconf ::=",
108428  /* 103 */ "orconf ::= OR resolvetype",
108429  /* 104 */ "resolvetype ::= raisetype",
108430  /* 105 */ "resolvetype ::= IGNORE",
108431  /* 106 */ "resolvetype ::= REPLACE",
108432  /* 107 */ "cmd ::= DROP TABLE ifexists fullname",
108433  /* 108 */ "ifexists ::= IF EXISTS",
108434  /* 109 */ "ifexists ::=",
108435  /* 110 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select",
108436  /* 111 */ "cmd ::= DROP VIEW ifexists fullname",
108437  /* 112 */ "cmd ::= select",
108438  /* 113 */ "select ::= oneselect",
108439  /* 114 */ "select ::= select multiselect_op oneselect",
108440  /* 115 */ "multiselect_op ::= UNION",
108441  /* 116 */ "multiselect_op ::= UNION ALL",
108442  /* 117 */ "multiselect_op ::= EXCEPT|INTERSECT",
108443  /* 118 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
108444  /* 119 */ "distinct ::= DISTINCT",
108445  /* 120 */ "distinct ::= ALL",
108446  /* 121 */ "distinct ::=",
108447  /* 122 */ "sclp ::= selcollist COMMA",
108448  /* 123 */ "sclp ::=",
108449  /* 124 */ "selcollist ::= sclp expr as",
108450  /* 125 */ "selcollist ::= sclp STAR",
108451  /* 126 */ "selcollist ::= sclp nm DOT STAR",
108452  /* 127 */ "as ::= AS nm",
108453  /* 128 */ "as ::= ids",
108454  /* 129 */ "as ::=",
108455  /* 130 */ "from ::=",
108456  /* 131 */ "from ::= FROM seltablist",
108457  /* 132 */ "stl_prefix ::= seltablist joinop",
108458  /* 133 */ "stl_prefix ::=",
108459  /* 134 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt",
108460  /* 135 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
108461  /* 136 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
108462  /* 137 */ "dbnm ::=",
108463  /* 138 */ "dbnm ::= DOT nm",
108464  /* 139 */ "fullname ::= nm dbnm",
108465  /* 140 */ "joinop ::= COMMA|JOIN",
108466  /* 141 */ "joinop ::= JOIN_KW JOIN",
108467  /* 142 */ "joinop ::= JOIN_KW nm JOIN",
108468  /* 143 */ "joinop ::= JOIN_KW nm nm JOIN",
108469  /* 144 */ "on_opt ::= ON expr",
108470  /* 145 */ "on_opt ::=",
108471  /* 146 */ "indexed_opt ::=",
108472  /* 147 */ "indexed_opt ::= INDEXED BY nm",
108473  /* 148 */ "indexed_opt ::= NOT INDEXED",
108474  /* 149 */ "using_opt ::= USING LP inscollist RP",
108475  /* 150 */ "using_opt ::=",
108476  /* 151 */ "orderby_opt ::=",
108477  /* 152 */ "orderby_opt ::= ORDER BY sortlist",
108478  /* 153 */ "sortlist ::= sortlist COMMA sortitem sortorder",
108479  /* 154 */ "sortlist ::= sortitem sortorder",
108480  /* 155 */ "sortitem ::= expr",
108481  /* 156 */ "sortorder ::= ASC",
108482  /* 157 */ "sortorder ::= DESC",
108483  /* 158 */ "sortorder ::=",
108484  /* 159 */ "groupby_opt ::=",
108485  /* 160 */ "groupby_opt ::= GROUP BY nexprlist",
108486  /* 161 */ "having_opt ::=",
108487  /* 162 */ "having_opt ::= HAVING expr",
108488  /* 163 */ "limit_opt ::=",
108489  /* 164 */ "limit_opt ::= LIMIT expr",
108490  /* 165 */ "limit_opt ::= LIMIT expr OFFSET expr",
108491  /* 166 */ "limit_opt ::= LIMIT expr COMMA expr",
108492  /* 167 */ "cmd ::= DELETE FROM fullname indexed_opt where_opt",
108493  /* 168 */ "where_opt ::=",
108494  /* 169 */ "where_opt ::= WHERE expr",
108495  /* 170 */ "cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt",
108496  /* 171 */ "setlist ::= setlist COMMA nm EQ expr",
108497  /* 172 */ "setlist ::= nm EQ expr",
108498  /* 173 */ "cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP",
108499  /* 174 */ "cmd ::= insert_cmd INTO fullname inscollist_opt select",
108500  /* 175 */ "cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES",
108501  /* 176 */ "insert_cmd ::= INSERT orconf",
108502  /* 177 */ "insert_cmd ::= REPLACE",
108503  /* 178 */ "itemlist ::= itemlist COMMA expr",
108504  /* 179 */ "itemlist ::= expr",
108505  /* 180 */ "inscollist_opt ::=",
108506  /* 181 */ "inscollist_opt ::= LP inscollist RP",
108507  /* 182 */ "inscollist ::= inscollist COMMA nm",
108508  /* 183 */ "inscollist ::= nm",
108509  /* 184 */ "expr ::= term",
108510  /* 185 */ "expr ::= LP expr RP",
108511  /* 186 */ "term ::= NULL",
108512  /* 187 */ "expr ::= id",
108513  /* 188 */ "expr ::= JOIN_KW",
108514  /* 189 */ "expr ::= nm DOT nm",
108515  /* 190 */ "expr ::= nm DOT nm DOT nm",
108516  /* 191 */ "term ::= INTEGER|FLOAT|BLOB",
108517  /* 192 */ "term ::= STRING",
108518  /* 193 */ "expr ::= REGISTER",
108519  /* 194 */ "expr ::= VARIABLE",
108520  /* 195 */ "expr ::= expr COLLATE ids",
108521  /* 196 */ "expr ::= CAST LP expr AS typetoken RP",
108522  /* 197 */ "expr ::= ID LP distinct exprlist RP",
108523  /* 198 */ "expr ::= ID LP STAR RP",
108524  /* 199 */ "term ::= CTIME_KW",
108525  /* 200 */ "expr ::= expr AND expr",
108526  /* 201 */ "expr ::= expr OR expr",
108527  /* 202 */ "expr ::= expr LT|GT|GE|LE expr",
108528  /* 203 */ "expr ::= expr EQ|NE expr",
108529  /* 204 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
108530  /* 205 */ "expr ::= expr PLUS|MINUS expr",
108531  /* 206 */ "expr ::= expr STAR|SLASH|REM expr",
108532  /* 207 */ "expr ::= expr CONCAT expr",
108533  /* 208 */ "likeop ::= LIKE_KW",
108534  /* 209 */ "likeop ::= NOT LIKE_KW",
108535  /* 210 */ "likeop ::= MATCH",
108536  /* 211 */ "likeop ::= NOT MATCH",
108537  /* 212 */ "expr ::= expr likeop expr",
108538  /* 213 */ "expr ::= expr likeop expr ESCAPE expr",
108539  /* 214 */ "expr ::= expr ISNULL|NOTNULL",
108540  /* 215 */ "expr ::= expr NOT NULL",
108541  /* 216 */ "expr ::= expr IS expr",
108542  /* 217 */ "expr ::= expr IS NOT expr",
108543  /* 218 */ "expr ::= NOT expr",
108544  /* 219 */ "expr ::= BITNOT expr",
108545  /* 220 */ "expr ::= MINUS expr",
108546  /* 221 */ "expr ::= PLUS expr",
108547  /* 222 */ "between_op ::= BETWEEN",
108548  /* 223 */ "between_op ::= NOT BETWEEN",
108549  /* 224 */ "expr ::= expr between_op expr AND expr",
108550  /* 225 */ "in_op ::= IN",
108551  /* 226 */ "in_op ::= NOT IN",
108552  /* 227 */ "expr ::= expr in_op LP exprlist RP",
108553  /* 228 */ "expr ::= LP select RP",
108554  /* 229 */ "expr ::= expr in_op LP select RP",
108555  /* 230 */ "expr ::= expr in_op nm dbnm",
108556  /* 231 */ "expr ::= EXISTS LP select RP",
108557  /* 232 */ "expr ::= CASE case_operand case_exprlist case_else END",
108558  /* 233 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
108559  /* 234 */ "case_exprlist ::= WHEN expr THEN expr",
108560  /* 235 */ "case_else ::= ELSE expr",
108561  /* 236 */ "case_else ::=",
108562  /* 237 */ "case_operand ::= expr",
108563  /* 238 */ "case_operand ::=",
108564  /* 239 */ "exprlist ::= nexprlist",
108565  /* 240 */ "exprlist ::=",
108566  /* 241 */ "nexprlist ::= nexprlist COMMA expr",
108567  /* 242 */ "nexprlist ::= expr",
108568  /* 243 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP",
108569  /* 244 */ "uniqueflag ::= UNIQUE",
108570  /* 245 */ "uniqueflag ::=",
108571  /* 246 */ "idxlist_opt ::=",
108572  /* 247 */ "idxlist_opt ::= LP idxlist RP",
108573  /* 248 */ "idxlist ::= idxlist COMMA nm collate sortorder",
108574  /* 249 */ "idxlist ::= nm collate sortorder",
108575  /* 250 */ "collate ::=",
108576  /* 251 */ "collate ::= COLLATE ids",
108577  /* 252 */ "cmd ::= DROP INDEX ifexists fullname",
108578  /* 253 */ "cmd ::= VACUUM",
108579  /* 254 */ "cmd ::= VACUUM nm",
108580  /* 255 */ "cmd ::= PRAGMA nm dbnm",
108581  /* 256 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
108582  /* 257 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
108583  /* 258 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
108584  /* 259 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
108585  /* 260 */ "nmnum ::= plus_num",
108586  /* 261 */ "nmnum ::= nm",
108587  /* 262 */ "nmnum ::= ON",
108588  /* 263 */ "nmnum ::= DELETE",
108589  /* 264 */ "nmnum ::= DEFAULT",
108590  /* 265 */ "plus_num ::= plus_opt number",
108591  /* 266 */ "minus_num ::= MINUS number",
108592  /* 267 */ "number ::= INTEGER|FLOAT",
108593  /* 268 */ "plus_opt ::= PLUS",
108594  /* 269 */ "plus_opt ::=",
108595  /* 270 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
108596  /* 271 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
108597  /* 272 */ "trigger_time ::= BEFORE",
108598  /* 273 */ "trigger_time ::= AFTER",
108599  /* 274 */ "trigger_time ::= INSTEAD OF",
108600  /* 275 */ "trigger_time ::=",
108601  /* 276 */ "trigger_event ::= DELETE|INSERT",
108602  /* 277 */ "trigger_event ::= UPDATE",
108603  /* 278 */ "trigger_event ::= UPDATE OF inscollist",
108604  /* 279 */ "foreach_clause ::=",
108605  /* 280 */ "foreach_clause ::= FOR EACH ROW",
108606  /* 281 */ "when_clause ::=",
108607  /* 282 */ "when_clause ::= WHEN expr",
108608  /* 283 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
108609  /* 284 */ "trigger_cmd_list ::= trigger_cmd SEMI",
108610  /* 285 */ "trnm ::= nm",
108611  /* 286 */ "trnm ::= nm DOT nm",
108612  /* 287 */ "tridxby ::=",
108613  /* 288 */ "tridxby ::= INDEXED BY nm",
108614  /* 289 */ "tridxby ::= NOT INDEXED",
108615  /* 290 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
108616  /* 291 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP",
108617  /* 292 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
108618  /* 293 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
108619  /* 294 */ "trigger_cmd ::= select",
108620  /* 295 */ "expr ::= RAISE LP IGNORE RP",
108621  /* 296 */ "expr ::= RAISE LP raisetype COMMA nm RP",
108622  /* 297 */ "raisetype ::= ROLLBACK",
108623  /* 298 */ "raisetype ::= ABORT",
108624  /* 299 */ "raisetype ::= FAIL",
108625  /* 300 */ "cmd ::= DROP TRIGGER ifexists fullname",
108626  /* 301 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
108627  /* 302 */ "cmd ::= DETACH database_kw_opt expr",
108628  /* 303 */ "key_opt ::=",
108629  /* 304 */ "key_opt ::= KEY expr",
108630  /* 305 */ "database_kw_opt ::= DATABASE",
108631  /* 306 */ "database_kw_opt ::=",
108632  /* 307 */ "cmd ::= REINDEX",
108633  /* 308 */ "cmd ::= REINDEX nm dbnm",
108634  /* 309 */ "cmd ::= ANALYZE",
108635  /* 310 */ "cmd ::= ANALYZE nm dbnm",
108636  /* 311 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
108637  /* 312 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
108638  /* 313 */ "add_column_fullname ::= fullname",
108639  /* 314 */ "kwcolumn_opt ::=",
108640  /* 315 */ "kwcolumn_opt ::= COLUMNKW",
108641  /* 316 */ "cmd ::= create_vtab",
108642  /* 317 */ "cmd ::= create_vtab LP vtabarglist RP",
108643  /* 318 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
108644  /* 319 */ "vtabarglist ::= vtabarg",
108645  /* 320 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
108646  /* 321 */ "vtabarg ::=",
108647  /* 322 */ "vtabarg ::= vtabarg vtabargtoken",
108648  /* 323 */ "vtabargtoken ::= ANY",
108649  /* 324 */ "vtabargtoken ::= lp anylist RP",
108650  /* 325 */ "lp ::= LP",
108651  /* 326 */ "anylist ::=",
108652  /* 327 */ "anylist ::= anylist LP anylist RP",
108653  /* 328 */ "anylist ::= anylist ANY",
108654 };
108655 #endif /* NDEBUG */
108656
108657
108658 #if YYSTACKDEPTH<=0
108659 /*
108660 ** Try to increase the size of the parser stack.
108661 */
108662 static void yyGrowStack(yyParser *p){
108663   int newSize;
108664   yyStackEntry *pNew;
108665
108666   newSize = p->yystksz*2 + 100;
108667   pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
108668   if( pNew ){
108669     p->yystack = pNew;
108670     p->yystksz = newSize;
108671 #ifndef NDEBUG
108672     if( yyTraceFILE ){
108673       fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
108674               yyTracePrompt, p->yystksz);
108675     }
108676 #endif
108677   }
108678 }
108679 #endif
108680
108681 /* 
108682 ** This function allocates a new parser.
108683 ** The only argument is a pointer to a function which works like
108684 ** malloc.
108685 **
108686 ** Inputs:
108687 ** A pointer to the function used to allocate memory.
108688 **
108689 ** Outputs:
108690 ** A pointer to a parser.  This pointer is used in subsequent calls
108691 ** to sqlcipher3Parser and sqlcipher3ParserFree.
108692 */
108693 SQLCIPHER_PRIVATE void *sqlcipher3ParserAlloc(void *(*mallocProc)(size_t)){
108694   yyParser *pParser;
108695   pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
108696   if( pParser ){
108697     pParser->yyidx = -1;
108698 #ifdef YYTRACKMAXSTACKDEPTH
108699     pParser->yyidxMax = 0;
108700 #endif
108701 #if YYSTACKDEPTH<=0
108702     pParser->yystack = NULL;
108703     pParser->yystksz = 0;
108704     yyGrowStack(pParser);
108705 #endif
108706   }
108707   return pParser;
108708 }
108709
108710 /* The following function deletes the value associated with a
108711 ** symbol.  The symbol can be either a terminal or nonterminal.
108712 ** "yymajor" is the symbol code, and "yypminor" is a pointer to
108713 ** the value.
108714 */
108715 static void yy_destructor(
108716   yyParser *yypParser,    /* The parser */
108717   YYCODETYPE yymajor,     /* Type code for object to destroy */
108718   YYMINORTYPE *yypminor   /* The object to be destroyed */
108719 ){
108720   sqlcipher3ParserARG_FETCH;
108721   switch( yymajor ){
108722     /* Here is inserted the actions which take place when a
108723     ** terminal or non-terminal is destroyed.  This can happen
108724     ** when the symbol is popped from the stack during a
108725     ** reduce or during error processing or when a parser is 
108726     ** being destroyed before it is finished parsing.
108727     **
108728     ** Note: during a reduce, the only symbols destroyed are those
108729     ** which appear on the RHS of the rule, but which are not used
108730     ** inside the C code.
108731     */
108732     case 160: /* select */
108733     case 194: /* oneselect */
108734 {
108735 sqlcipher3SelectDelete(pParse->db, (yypminor->yy387));
108736 }
108737       break;
108738     case 174: /* term */
108739     case 175: /* expr */
108740 {
108741 sqlcipher3ExprDelete(pParse->db, (yypminor->yy118).pExpr);
108742 }
108743       break;
108744     case 179: /* idxlist_opt */
108745     case 187: /* idxlist */
108746     case 197: /* selcollist */
108747     case 200: /* groupby_opt */
108748     case 202: /* orderby_opt */
108749     case 204: /* sclp */
108750     case 214: /* sortlist */
108751     case 216: /* nexprlist */
108752     case 217: /* setlist */
108753     case 220: /* itemlist */
108754     case 221: /* exprlist */
108755     case 226: /* case_exprlist */
108756 {
108757 sqlcipher3ExprListDelete(pParse->db, (yypminor->yy322));
108758 }
108759       break;
108760     case 193: /* fullname */
108761     case 198: /* from */
108762     case 206: /* seltablist */
108763     case 207: /* stl_prefix */
108764 {
108765 sqlcipher3SrcListDelete(pParse->db, (yypminor->yy259));
108766 }
108767       break;
108768     case 199: /* where_opt */
108769     case 201: /* having_opt */
108770     case 210: /* on_opt */
108771     case 215: /* sortitem */
108772     case 225: /* case_operand */
108773     case 227: /* case_else */
108774     case 238: /* when_clause */
108775     case 243: /* key_opt */
108776 {
108777 sqlcipher3ExprDelete(pParse->db, (yypminor->yy314));
108778 }
108779       break;
108780     case 211: /* using_opt */
108781     case 213: /* inscollist */
108782     case 219: /* inscollist_opt */
108783 {
108784 sqlcipher3IdListDelete(pParse->db, (yypminor->yy384));
108785 }
108786       break;
108787     case 234: /* trigger_cmd_list */
108788     case 239: /* trigger_cmd */
108789 {
108790 sqlcipher3DeleteTriggerStep(pParse->db, (yypminor->yy203));
108791 }
108792       break;
108793     case 236: /* trigger_event */
108794 {
108795 sqlcipher3IdListDelete(pParse->db, (yypminor->yy90).b);
108796 }
108797       break;
108798     default:  break;   /* If no destructor action specified: do nothing */
108799   }
108800 }
108801
108802 /*
108803 ** Pop the parser's stack once.
108804 **
108805 ** If there is a destructor routine associated with the token which
108806 ** is popped from the stack, then call it.
108807 **
108808 ** Return the major token number for the symbol popped.
108809 */
108810 static int yy_pop_parser_stack(yyParser *pParser){
108811   YYCODETYPE yymajor;
108812   yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
108813
108814   /* There is no mechanism by which the parser stack can be popped below
108815   ** empty in SQLite.  */
108816   if( NEVER(pParser->yyidx<0) ) return 0;
108817 #ifndef NDEBUG
108818   if( yyTraceFILE && pParser->yyidx>=0 ){
108819     fprintf(yyTraceFILE,"%sPopping %s\n",
108820       yyTracePrompt,
108821       yyTokenName[yytos->major]);
108822   }
108823 #endif
108824   yymajor = yytos->major;
108825   yy_destructor(pParser, yymajor, &yytos->minor);
108826   pParser->yyidx--;
108827   return yymajor;
108828 }
108829
108830 /* 
108831 ** Deallocate and destroy a parser.  Destructors are all called for
108832 ** all stack elements before shutting the parser down.
108833 **
108834 ** Inputs:
108835 ** <ul>
108836 ** <li>  A pointer to the parser.  This should be a pointer
108837 **       obtained from sqlcipher3ParserAlloc.
108838 ** <li>  A pointer to a function used to reclaim memory obtained
108839 **       from malloc.
108840 ** </ul>
108841 */
108842 SQLCIPHER_PRIVATE void sqlcipher3ParserFree(
108843   void *p,                    /* The parser to be deleted */
108844   void (*freeProc)(void*)     /* Function used to reclaim memory */
108845 ){
108846   yyParser *pParser = (yyParser*)p;
108847   /* In SQLite, we never try to destroy a parser that was not successfully
108848   ** created in the first place. */
108849   if( NEVER(pParser==0) ) return;
108850   while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
108851 #if YYSTACKDEPTH<=0
108852   free(pParser->yystack);
108853 #endif
108854   (*freeProc)((void*)pParser);
108855 }
108856
108857 /*
108858 ** Return the peak depth of the stack for a parser.
108859 */
108860 #ifdef YYTRACKMAXSTACKDEPTH
108861 SQLCIPHER_PRIVATE int sqlcipher3ParserStackPeak(void *p){
108862   yyParser *pParser = (yyParser*)p;
108863   return pParser->yyidxMax;
108864 }
108865 #endif
108866
108867 /*
108868 ** Find the appropriate action for a parser given the terminal
108869 ** look-ahead token iLookAhead.
108870 **
108871 ** If the look-ahead token is YYNOCODE, then check to see if the action is
108872 ** independent of the look-ahead.  If it is, return the action, otherwise
108873 ** return YY_NO_ACTION.
108874 */
108875 static int yy_find_shift_action(
108876   yyParser *pParser,        /* The parser */
108877   YYCODETYPE iLookAhead     /* The look-ahead token */
108878 ){
108879   int i;
108880   int stateno = pParser->yystack[pParser->yyidx].stateno;
108881  
108882   if( stateno>YY_SHIFT_COUNT
108883    || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
108884     return yy_default[stateno];
108885   }
108886   assert( iLookAhead!=YYNOCODE );
108887   i += iLookAhead;
108888   if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
108889     if( iLookAhead>0 ){
108890 #ifdef YYFALLBACK
108891       YYCODETYPE iFallback;            /* Fallback token */
108892       if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
108893              && (iFallback = yyFallback[iLookAhead])!=0 ){
108894 #ifndef NDEBUG
108895         if( yyTraceFILE ){
108896           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
108897              yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
108898         }
108899 #endif
108900         return yy_find_shift_action(pParser, iFallback);
108901       }
108902 #endif
108903 #ifdef YYWILDCARD
108904       {
108905         int j = i - iLookAhead + YYWILDCARD;
108906         if( 
108907 #if YY_SHIFT_MIN+YYWILDCARD<0
108908           j>=0 &&
108909 #endif
108910 #if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
108911           j<YY_ACTTAB_COUNT &&
108912 #endif
108913           yy_lookahead[j]==YYWILDCARD
108914         ){
108915 #ifndef NDEBUG
108916           if( yyTraceFILE ){
108917             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
108918                yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
108919           }
108920 #endif /* NDEBUG */
108921           return yy_action[j];
108922         }
108923       }
108924 #endif /* YYWILDCARD */
108925     }
108926     return yy_default[stateno];
108927   }else{
108928     return yy_action[i];
108929   }
108930 }
108931
108932 /*
108933 ** Find the appropriate action for a parser given the non-terminal
108934 ** look-ahead token iLookAhead.
108935 **
108936 ** If the look-ahead token is YYNOCODE, then check to see if the action is
108937 ** independent of the look-ahead.  If it is, return the action, otherwise
108938 ** return YY_NO_ACTION.
108939 */
108940 static int yy_find_reduce_action(
108941   int stateno,              /* Current state number */
108942   YYCODETYPE iLookAhead     /* The look-ahead token */
108943 ){
108944   int i;
108945 #ifdef YYERRORSYMBOL
108946   if( stateno>YY_REDUCE_COUNT ){
108947     return yy_default[stateno];
108948   }
108949 #else
108950   assert( stateno<=YY_REDUCE_COUNT );
108951 #endif
108952   i = yy_reduce_ofst[stateno];
108953   assert( i!=YY_REDUCE_USE_DFLT );
108954   assert( iLookAhead!=YYNOCODE );
108955   i += iLookAhead;
108956 #ifdef YYERRORSYMBOL
108957   if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
108958     return yy_default[stateno];
108959   }
108960 #else
108961   assert( i>=0 && i<YY_ACTTAB_COUNT );
108962   assert( yy_lookahead[i]==iLookAhead );
108963 #endif
108964   return yy_action[i];
108965 }
108966
108967 /*
108968 ** The following routine is called if the stack overflows.
108969 */
108970 static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
108971    sqlcipher3ParserARG_FETCH;
108972    yypParser->yyidx--;
108973 #ifndef NDEBUG
108974    if( yyTraceFILE ){
108975      fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
108976    }
108977 #endif
108978    while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
108979    /* Here code is inserted which will execute if the parser
108980    ** stack every overflows */
108981
108982   UNUSED_PARAMETER(yypMinor); /* Silence some compiler warnings */
108983   sqlcipher3ErrorMsg(pParse, "parser stack overflow");
108984   pParse->parseError = 1;
108985    sqlcipher3ParserARG_STORE; /* Suppress warning about unused %extra_argument var */
108986 }
108987
108988 /*
108989 ** Perform a shift action.
108990 */
108991 static void yy_shift(
108992   yyParser *yypParser,          /* The parser to be shifted */
108993   int yyNewState,               /* The new state to shift in */
108994   int yyMajor,                  /* The major token to shift in */
108995   YYMINORTYPE *yypMinor         /* Pointer to the minor token to shift in */
108996 ){
108997   yyStackEntry *yytos;
108998   yypParser->yyidx++;
108999 #ifdef YYTRACKMAXSTACKDEPTH
109000   if( yypParser->yyidx>yypParser->yyidxMax ){
109001     yypParser->yyidxMax = yypParser->yyidx;
109002   }
109003 #endif
109004 #if YYSTACKDEPTH>0 
109005   if( yypParser->yyidx>=YYSTACKDEPTH ){
109006     yyStackOverflow(yypParser, yypMinor);
109007     return;
109008   }
109009 #else
109010   if( yypParser->yyidx>=yypParser->yystksz ){
109011     yyGrowStack(yypParser);
109012     if( yypParser->yyidx>=yypParser->yystksz ){
109013       yyStackOverflow(yypParser, yypMinor);
109014       return;
109015     }
109016   }
109017 #endif
109018   yytos = &yypParser->yystack[yypParser->yyidx];
109019   yytos->stateno = (YYACTIONTYPE)yyNewState;
109020   yytos->major = (YYCODETYPE)yyMajor;
109021   yytos->minor = *yypMinor;
109022 #ifndef NDEBUG
109023   if( yyTraceFILE && yypParser->yyidx>0 ){
109024     int i;
109025     fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
109026     fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
109027     for(i=1; i<=yypParser->yyidx; i++)
109028       fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
109029     fprintf(yyTraceFILE,"\n");
109030   }
109031 #endif
109032 }
109033
109034 /* The following table contains information about every rule that
109035 ** is used during the reduce.
109036 */
109037 static const struct {
109038   YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
109039   unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
109040 } yyRuleInfo[] = {
109041   { 142, 1 },
109042   { 143, 2 },
109043   { 143, 1 },
109044   { 144, 1 },
109045   { 144, 3 },
109046   { 145, 0 },
109047   { 145, 1 },
109048   { 145, 3 },
109049   { 146, 1 },
109050   { 147, 3 },
109051   { 149, 0 },
109052   { 149, 1 },
109053   { 149, 2 },
109054   { 148, 0 },
109055   { 148, 1 },
109056   { 148, 1 },
109057   { 148, 1 },
109058   { 147, 2 },
109059   { 147, 2 },
109060   { 147, 2 },
109061   { 151, 1 },
109062   { 151, 0 },
109063   { 147, 2 },
109064   { 147, 3 },
109065   { 147, 5 },
109066   { 147, 2 },
109067   { 152, 6 },
109068   { 154, 1 },
109069   { 156, 0 },
109070   { 156, 3 },
109071   { 155, 1 },
109072   { 155, 0 },
109073   { 153, 4 },
109074   { 153, 2 },
109075   { 158, 3 },
109076   { 158, 1 },
109077   { 161, 3 },
109078   { 162, 1 },
109079   { 165, 1 },
109080   { 165, 1 },
109081   { 166, 1 },
109082   { 150, 1 },
109083   { 150, 1 },
109084   { 150, 1 },
109085   { 163, 0 },
109086   { 163, 1 },
109087   { 167, 1 },
109088   { 167, 4 },
109089   { 167, 6 },
109090   { 168, 1 },
109091   { 168, 2 },
109092   { 169, 1 },
109093   { 169, 1 },
109094   { 164, 2 },
109095   { 164, 0 },
109096   { 172, 3 },
109097   { 172, 1 },
109098   { 173, 2 },
109099   { 173, 4 },
109100   { 173, 3 },
109101   { 173, 3 },
109102   { 173, 2 },
109103   { 173, 2 },
109104   { 173, 3 },
109105   { 173, 5 },
109106   { 173, 2 },
109107   { 173, 4 },
109108   { 173, 4 },
109109   { 173, 1 },
109110   { 173, 2 },
109111   { 178, 0 },
109112   { 178, 1 },
109113   { 180, 0 },
109114   { 180, 2 },
109115   { 182, 2 },
109116   { 182, 3 },
109117   { 182, 3 },
109118   { 182, 3 },
109119   { 183, 2 },
109120   { 183, 2 },
109121   { 183, 1 },
109122   { 183, 1 },
109123   { 183, 2 },
109124   { 181, 3 },
109125   { 181, 2 },
109126   { 184, 0 },
109127   { 184, 2 },
109128   { 184, 2 },
109129   { 159, 0 },
109130   { 159, 2 },
109131   { 185, 3 },
109132   { 185, 2 },
109133   { 185, 1 },
109134   { 186, 2 },
109135   { 186, 7 },
109136   { 186, 5 },
109137   { 186, 5 },
109138   { 186, 10 },
109139   { 188, 0 },
109140   { 188, 1 },
109141   { 176, 0 },
109142   { 176, 3 },
109143   { 189, 0 },
109144   { 189, 2 },
109145   { 190, 1 },
109146   { 190, 1 },
109147   { 190, 1 },
109148   { 147, 4 },
109149   { 192, 2 },
109150   { 192, 0 },
109151   { 147, 8 },
109152   { 147, 4 },
109153   { 147, 1 },
109154   { 160, 1 },
109155   { 160, 3 },
109156   { 195, 1 },
109157   { 195, 2 },
109158   { 195, 1 },
109159   { 194, 9 },
109160   { 196, 1 },
109161   { 196, 1 },
109162   { 196, 0 },
109163   { 204, 2 },
109164   { 204, 0 },
109165   { 197, 3 },
109166   { 197, 2 },
109167   { 197, 4 },
109168   { 205, 2 },
109169   { 205, 1 },
109170   { 205, 0 },
109171   { 198, 0 },
109172   { 198, 2 },
109173   { 207, 2 },
109174   { 207, 0 },
109175   { 206, 7 },
109176   { 206, 7 },
109177   { 206, 7 },
109178   { 157, 0 },
109179   { 157, 2 },
109180   { 193, 2 },
109181   { 208, 1 },
109182   { 208, 2 },
109183   { 208, 3 },
109184   { 208, 4 },
109185   { 210, 2 },
109186   { 210, 0 },
109187   { 209, 0 },
109188   { 209, 3 },
109189   { 209, 2 },
109190   { 211, 4 },
109191   { 211, 0 },
109192   { 202, 0 },
109193   { 202, 3 },
109194   { 214, 4 },
109195   { 214, 2 },
109196   { 215, 1 },
109197   { 177, 1 },
109198   { 177, 1 },
109199   { 177, 0 },
109200   { 200, 0 },
109201   { 200, 3 },
109202   { 201, 0 },
109203   { 201, 2 },
109204   { 203, 0 },
109205   { 203, 2 },
109206   { 203, 4 },
109207   { 203, 4 },
109208   { 147, 5 },
109209   { 199, 0 },
109210   { 199, 2 },
109211   { 147, 7 },
109212   { 217, 5 },
109213   { 217, 3 },
109214   { 147, 8 },
109215   { 147, 5 },
109216   { 147, 6 },
109217   { 218, 2 },
109218   { 218, 1 },
109219   { 220, 3 },
109220   { 220, 1 },
109221   { 219, 0 },
109222   { 219, 3 },
109223   { 213, 3 },
109224   { 213, 1 },
109225   { 175, 1 },
109226   { 175, 3 },
109227   { 174, 1 },
109228   { 175, 1 },
109229   { 175, 1 },
109230   { 175, 3 },
109231   { 175, 5 },
109232   { 174, 1 },
109233   { 174, 1 },
109234   { 175, 1 },
109235   { 175, 1 },
109236   { 175, 3 },
109237   { 175, 6 },
109238   { 175, 5 },
109239   { 175, 4 },
109240   { 174, 1 },
109241   { 175, 3 },
109242   { 175, 3 },
109243   { 175, 3 },
109244   { 175, 3 },
109245   { 175, 3 },
109246   { 175, 3 },
109247   { 175, 3 },
109248   { 175, 3 },
109249   { 222, 1 },
109250   { 222, 2 },
109251   { 222, 1 },
109252   { 222, 2 },
109253   { 175, 3 },
109254   { 175, 5 },
109255   { 175, 2 },
109256   { 175, 3 },
109257   { 175, 3 },
109258   { 175, 4 },
109259   { 175, 2 },
109260   { 175, 2 },
109261   { 175, 2 },
109262   { 175, 2 },
109263   { 223, 1 },
109264   { 223, 2 },
109265   { 175, 5 },
109266   { 224, 1 },
109267   { 224, 2 },
109268   { 175, 5 },
109269   { 175, 3 },
109270   { 175, 5 },
109271   { 175, 4 },
109272   { 175, 4 },
109273   { 175, 5 },
109274   { 226, 5 },
109275   { 226, 4 },
109276   { 227, 2 },
109277   { 227, 0 },
109278   { 225, 1 },
109279   { 225, 0 },
109280   { 221, 1 },
109281   { 221, 0 },
109282   { 216, 3 },
109283   { 216, 1 },
109284   { 147, 11 },
109285   { 228, 1 },
109286   { 228, 0 },
109287   { 179, 0 },
109288   { 179, 3 },
109289   { 187, 5 },
109290   { 187, 3 },
109291   { 229, 0 },
109292   { 229, 2 },
109293   { 147, 4 },
109294   { 147, 1 },
109295   { 147, 2 },
109296   { 147, 3 },
109297   { 147, 5 },
109298   { 147, 6 },
109299   { 147, 5 },
109300   { 147, 6 },
109301   { 230, 1 },
109302   { 230, 1 },
109303   { 230, 1 },
109304   { 230, 1 },
109305   { 230, 1 },
109306   { 170, 2 },
109307   { 171, 2 },
109308   { 232, 1 },
109309   { 231, 1 },
109310   { 231, 0 },
109311   { 147, 5 },
109312   { 233, 11 },
109313   { 235, 1 },
109314   { 235, 1 },
109315   { 235, 2 },
109316   { 235, 0 },
109317   { 236, 1 },
109318   { 236, 1 },
109319   { 236, 3 },
109320   { 237, 0 },
109321   { 237, 3 },
109322   { 238, 0 },
109323   { 238, 2 },
109324   { 234, 3 },
109325   { 234, 2 },
109326   { 240, 1 },
109327   { 240, 3 },
109328   { 241, 0 },
109329   { 241, 3 },
109330   { 241, 2 },
109331   { 239, 7 },
109332   { 239, 8 },
109333   { 239, 5 },
109334   { 239, 5 },
109335   { 239, 1 },
109336   { 175, 4 },
109337   { 175, 6 },
109338   { 191, 1 },
109339   { 191, 1 },
109340   { 191, 1 },
109341   { 147, 4 },
109342   { 147, 6 },
109343   { 147, 3 },
109344   { 243, 0 },
109345   { 243, 2 },
109346   { 242, 1 },
109347   { 242, 0 },
109348   { 147, 1 },
109349   { 147, 3 },
109350   { 147, 1 },
109351   { 147, 3 },
109352   { 147, 6 },
109353   { 147, 6 },
109354   { 244, 1 },
109355   { 245, 0 },
109356   { 245, 1 },
109357   { 147, 1 },
109358   { 147, 4 },
109359   { 246, 7 },
109360   { 247, 1 },
109361   { 247, 3 },
109362   { 248, 0 },
109363   { 248, 2 },
109364   { 249, 1 },
109365   { 249, 3 },
109366   { 250, 1 },
109367   { 251, 0 },
109368   { 251, 4 },
109369   { 251, 2 },
109370 };
109371
109372 static void yy_accept(yyParser*);  /* Forward Declaration */
109373
109374 /*
109375 ** Perform a reduce action and the shift that must immediately
109376 ** follow the reduce.
109377 */
109378 static void yy_reduce(
109379   yyParser *yypParser,         /* The parser */
109380   int yyruleno                 /* Number of the rule by which to reduce */
109381 ){
109382   int yygoto;                     /* The next state */
109383   int yyact;                      /* The next action */
109384   YYMINORTYPE yygotominor;        /* The LHS of the rule reduced */
109385   yyStackEntry *yymsp;            /* The top of the parser's stack */
109386   int yysize;                     /* Amount to pop the stack */
109387   sqlcipher3ParserARG_FETCH;
109388   yymsp = &yypParser->yystack[yypParser->yyidx];
109389 #ifndef NDEBUG
109390   if( yyTraceFILE && yyruleno>=0 
109391         && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
109392     fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
109393       yyRuleName[yyruleno]);
109394   }
109395 #endif /* NDEBUG */
109396
109397   /* Silence complaints from purify about yygotominor being uninitialized
109398   ** in some cases when it is copied into the stack after the following
109399   ** switch.  yygotominor is uninitialized when a rule reduces that does
109400   ** not set the value of its left-hand side nonterminal.  Leaving the
109401   ** value of the nonterminal uninitialized is utterly harmless as long
109402   ** as the value is never used.  So really the only thing this code
109403   ** accomplishes is to quieten purify.  
109404   **
109405   ** 2007-01-16:  The wireshark project (www.wireshark.org) reports that
109406   ** without this code, their parser segfaults.  I'm not sure what there
109407   ** parser is doing to make this happen.  This is the second bug report
109408   ** from wireshark this week.  Clearly they are stressing Lemon in ways
109409   ** that it has not been previously stressed...  (SQLite ticket #2172)
109410   */
109411   /*memset(&yygotominor, 0, sizeof(yygotominor));*/
109412   yygotominor = yyzerominor;
109413
109414
109415   switch( yyruleno ){
109416   /* Beginning here are the reduction cases.  A typical example
109417   ** follows:
109418   **   case 0:
109419   **  #line <lineno> <grammarfile>
109420   **     { ... }           // User supplied code
109421   **  #line <lineno> <thisfile>
109422   **     break;
109423   */
109424       case 5: /* explain ::= */
109425 { sqlcipher3BeginParse(pParse, 0); }
109426         break;
109427       case 6: /* explain ::= EXPLAIN */
109428 { sqlcipher3BeginParse(pParse, 1); }
109429         break;
109430       case 7: /* explain ::= EXPLAIN QUERY PLAN */
109431 { sqlcipher3BeginParse(pParse, 2); }
109432         break;
109433       case 8: /* cmdx ::= cmd */
109434 { sqlcipher3FinishCoding(pParse); }
109435         break;
109436       case 9: /* cmd ::= BEGIN transtype trans_opt */
109437 {sqlcipher3BeginTransaction(pParse, yymsp[-1].minor.yy4);}
109438         break;
109439       case 13: /* transtype ::= */
109440 {yygotominor.yy4 = TK_DEFERRED;}
109441         break;
109442       case 14: /* transtype ::= DEFERRED */
109443       case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15);
109444       case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16);
109445       case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115);
109446       case 117: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==117);
109447 {yygotominor.yy4 = yymsp[0].major;}
109448         break;
109449       case 17: /* cmd ::= COMMIT trans_opt */
109450       case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);
109451 {sqlcipher3CommitTransaction(pParse);}
109452         break;
109453       case 19: /* cmd ::= ROLLBACK trans_opt */
109454 {sqlcipher3RollbackTransaction(pParse);}
109455         break;
109456       case 22: /* cmd ::= SAVEPOINT nm */
109457 {
109458   sqlcipher3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
109459 }
109460         break;
109461       case 23: /* cmd ::= RELEASE savepoint_opt nm */
109462 {
109463   sqlcipher3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
109464 }
109465         break;
109466       case 24: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
109467 {
109468   sqlcipher3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
109469 }
109470         break;
109471       case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
109472 {
109473    sqlcipher3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy4,0,0,yymsp[-2].minor.yy4);
109474 }
109475         break;
109476       case 27: /* createkw ::= CREATE */
109477 {
109478   pParse->db->lookaside.bEnabled = 0;
109479   yygotominor.yy0 = yymsp[0].minor.yy0;
109480 }
109481         break;
109482       case 28: /* ifnotexists ::= */
109483       case 31: /* temp ::= */ yytestcase(yyruleno==31);
109484       case 70: /* autoinc ::= */ yytestcase(yyruleno==70);
109485       case 83: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ yytestcase(yyruleno==83);
109486       case 85: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==85);
109487       case 87: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==87);
109488       case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
109489       case 109: /* ifexists ::= */ yytestcase(yyruleno==109);
109490       case 120: /* distinct ::= ALL */ yytestcase(yyruleno==120);
109491       case 121: /* distinct ::= */ yytestcase(yyruleno==121);
109492       case 222: /* between_op ::= BETWEEN */ yytestcase(yyruleno==222);
109493       case 225: /* in_op ::= IN */ yytestcase(yyruleno==225);
109494 {yygotominor.yy4 = 0;}
109495         break;
109496       case 29: /* ifnotexists ::= IF NOT EXISTS */
109497       case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30);
109498       case 71: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==71);
109499       case 86: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==86);
109500       case 108: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==108);
109501       case 119: /* distinct ::= DISTINCT */ yytestcase(yyruleno==119);
109502       case 223: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==223);
109503       case 226: /* in_op ::= NOT IN */ yytestcase(yyruleno==226);
109504 {yygotominor.yy4 = 1;}
109505         break;
109506       case 32: /* create_table_args ::= LP columnlist conslist_opt RP */
109507 {
109508   sqlcipher3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
109509 }
109510         break;
109511       case 33: /* create_table_args ::= AS select */
109512 {
109513   sqlcipher3EndTable(pParse,0,0,yymsp[0].minor.yy387);
109514   sqlcipher3SelectDelete(pParse->db, yymsp[0].minor.yy387);
109515 }
109516         break;
109517       case 36: /* column ::= columnid type carglist */
109518 {
109519   yygotominor.yy0.z = yymsp[-2].minor.yy0.z;
109520   yygotominor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-2].minor.yy0.z) + pParse->sLastToken.n;
109521 }
109522         break;
109523       case 37: /* columnid ::= nm */
109524 {
109525   sqlcipher3AddColumn(pParse,&yymsp[0].minor.yy0);
109526   yygotominor.yy0 = yymsp[0].minor.yy0;
109527 }
109528         break;
109529       case 38: /* id ::= ID */
109530       case 39: /* id ::= INDEXED */ yytestcase(yyruleno==39);
109531       case 40: /* ids ::= ID|STRING */ yytestcase(yyruleno==40);
109532       case 41: /* nm ::= id */ yytestcase(yyruleno==41);
109533       case 42: /* nm ::= STRING */ yytestcase(yyruleno==42);
109534       case 43: /* nm ::= JOIN_KW */ yytestcase(yyruleno==43);
109535       case 46: /* typetoken ::= typename */ yytestcase(yyruleno==46);
109536       case 49: /* typename ::= ids */ yytestcase(yyruleno==49);
109537       case 127: /* as ::= AS nm */ yytestcase(yyruleno==127);
109538       case 128: /* as ::= ids */ yytestcase(yyruleno==128);
109539       case 138: /* dbnm ::= DOT nm */ yytestcase(yyruleno==138);
109540       case 147: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==147);
109541       case 251: /* collate ::= COLLATE ids */ yytestcase(yyruleno==251);
109542       case 260: /* nmnum ::= plus_num */ yytestcase(yyruleno==260);
109543       case 261: /* nmnum ::= nm */ yytestcase(yyruleno==261);
109544       case 262: /* nmnum ::= ON */ yytestcase(yyruleno==262);
109545       case 263: /* nmnum ::= DELETE */ yytestcase(yyruleno==263);
109546       case 264: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==264);
109547       case 265: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==265);
109548       case 266: /* minus_num ::= MINUS number */ yytestcase(yyruleno==266);
109549       case 267: /* number ::= INTEGER|FLOAT */ yytestcase(yyruleno==267);
109550       case 285: /* trnm ::= nm */ yytestcase(yyruleno==285);
109551 {yygotominor.yy0 = yymsp[0].minor.yy0;}
109552         break;
109553       case 45: /* type ::= typetoken */
109554 {sqlcipher3AddColumnType(pParse,&yymsp[0].minor.yy0);}
109555         break;
109556       case 47: /* typetoken ::= typename LP signed RP */
109557 {
109558   yygotominor.yy0.z = yymsp[-3].minor.yy0.z;
109559   yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
109560 }
109561         break;
109562       case 48: /* typetoken ::= typename LP signed COMMA signed RP */
109563 {
109564   yygotominor.yy0.z = yymsp[-5].minor.yy0.z;
109565   yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
109566 }
109567         break;
109568       case 50: /* typename ::= typename ids */
109569 {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);}
109570         break;
109571       case 57: /* ccons ::= DEFAULT term */
109572       case 59: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==59);
109573 {sqlcipher3AddDefaultValue(pParse,&yymsp[0].minor.yy118);}
109574         break;
109575       case 58: /* ccons ::= DEFAULT LP expr RP */
109576 {sqlcipher3AddDefaultValue(pParse,&yymsp[-1].minor.yy118);}
109577         break;
109578       case 60: /* ccons ::= DEFAULT MINUS term */
109579 {
109580   ExprSpan v;
109581   v.pExpr = sqlcipher3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy118.pExpr, 0, 0);
109582   v.zStart = yymsp[-1].minor.yy0.z;
109583   v.zEnd = yymsp[0].minor.yy118.zEnd;
109584   sqlcipher3AddDefaultValue(pParse,&v);
109585 }
109586         break;
109587       case 61: /* ccons ::= DEFAULT id */
109588 {
109589   ExprSpan v;
109590   spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
109591   sqlcipher3AddDefaultValue(pParse,&v);
109592 }
109593         break;
109594       case 63: /* ccons ::= NOT NULL onconf */
109595 {sqlcipher3AddNotNull(pParse, yymsp[0].minor.yy4);}
109596         break;
109597       case 64: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
109598 {sqlcipher3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy4,yymsp[0].minor.yy4,yymsp[-2].minor.yy4);}
109599         break;
109600       case 65: /* ccons ::= UNIQUE onconf */
109601 {sqlcipher3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy4,0,0,0,0);}
109602         break;
109603       case 66: /* ccons ::= CHECK LP expr RP */
109604 {sqlcipher3AddCheckConstraint(pParse,yymsp[-1].minor.yy118.pExpr);}
109605         break;
109606       case 67: /* ccons ::= REFERENCES nm idxlist_opt refargs */
109607 {sqlcipher3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy4);}
109608         break;
109609       case 68: /* ccons ::= defer_subclause */
109610 {sqlcipher3DeferForeignKey(pParse,yymsp[0].minor.yy4);}
109611         break;
109612       case 69: /* ccons ::= COLLATE ids */
109613 {sqlcipher3AddCollateType(pParse, &yymsp[0].minor.yy0);}
109614         break;
109615       case 72: /* refargs ::= */
109616 { yygotominor.yy4 = OE_None*0x0101; /* EV: R-19803-45884 */}
109617         break;
109618       case 73: /* refargs ::= refargs refarg */
109619 { yygotominor.yy4 = (yymsp[-1].minor.yy4 & ~yymsp[0].minor.yy215.mask) | yymsp[0].minor.yy215.value; }
109620         break;
109621       case 74: /* refarg ::= MATCH nm */
109622       case 75: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==75);
109623 { yygotominor.yy215.value = 0;     yygotominor.yy215.mask = 0x000000; }
109624         break;
109625       case 76: /* refarg ::= ON DELETE refact */
109626 { yygotominor.yy215.value = yymsp[0].minor.yy4;     yygotominor.yy215.mask = 0x0000ff; }
109627         break;
109628       case 77: /* refarg ::= ON UPDATE refact */
109629 { yygotominor.yy215.value = yymsp[0].minor.yy4<<8;  yygotominor.yy215.mask = 0x00ff00; }
109630         break;
109631       case 78: /* refact ::= SET NULL */
109632 { yygotominor.yy4 = OE_SetNull;  /* EV: R-33326-45252 */}
109633         break;
109634       case 79: /* refact ::= SET DEFAULT */
109635 { yygotominor.yy4 = OE_SetDflt;  /* EV: R-33326-45252 */}
109636         break;
109637       case 80: /* refact ::= CASCADE */
109638 { yygotominor.yy4 = OE_Cascade;  /* EV: R-33326-45252 */}
109639         break;
109640       case 81: /* refact ::= RESTRICT */
109641 { yygotominor.yy4 = OE_Restrict; /* EV: R-33326-45252 */}
109642         break;
109643       case 82: /* refact ::= NO ACTION */
109644 { yygotominor.yy4 = OE_None;     /* EV: R-33326-45252 */}
109645         break;
109646       case 84: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
109647       case 99: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==99);
109648       case 101: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==101);
109649       case 104: /* resolvetype ::= raisetype */ yytestcase(yyruleno==104);
109650 {yygotominor.yy4 = yymsp[0].minor.yy4;}
109651         break;
109652       case 88: /* conslist_opt ::= */
109653 {yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;}
109654         break;
109655       case 89: /* conslist_opt ::= COMMA conslist */
109656 {yygotominor.yy0 = yymsp[-1].minor.yy0;}
109657         break;
109658       case 94: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
109659 {sqlcipher3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy4,yymsp[-2].minor.yy4,0);}
109660         break;
109661       case 95: /* tcons ::= UNIQUE LP idxlist RP onconf */
109662 {sqlcipher3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy4,0,0,0,0);}
109663         break;
109664       case 96: /* tcons ::= CHECK LP expr RP onconf */
109665 {sqlcipher3AddCheckConstraint(pParse,yymsp[-2].minor.yy118.pExpr);}
109666         break;
109667       case 97: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
109668 {
109669     sqlcipher3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy4);
109670     sqlcipher3DeferForeignKey(pParse, yymsp[0].minor.yy4);
109671 }
109672         break;
109673       case 100: /* onconf ::= */
109674 {yygotominor.yy4 = OE_Default;}
109675         break;
109676       case 102: /* orconf ::= */
109677 {yygotominor.yy210 = OE_Default;}
109678         break;
109679       case 103: /* orconf ::= OR resolvetype */
109680 {yygotominor.yy210 = (u8)yymsp[0].minor.yy4;}
109681         break;
109682       case 105: /* resolvetype ::= IGNORE */
109683 {yygotominor.yy4 = OE_Ignore;}
109684         break;
109685       case 106: /* resolvetype ::= REPLACE */
109686 {yygotominor.yy4 = OE_Replace;}
109687         break;
109688       case 107: /* cmd ::= DROP TABLE ifexists fullname */
109689 {
109690   sqlcipher3DropTable(pParse, yymsp[0].minor.yy259, 0, yymsp[-1].minor.yy4);
109691 }
109692         break;
109693       case 110: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
109694 {
109695   sqlcipher3CreateView(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);
109696 }
109697         break;
109698       case 111: /* cmd ::= DROP VIEW ifexists fullname */
109699 {
109700   sqlcipher3DropTable(pParse, yymsp[0].minor.yy259, 1, yymsp[-1].minor.yy4);
109701 }
109702         break;
109703       case 112: /* cmd ::= select */
109704 {
109705   SelectDest dest = {SRT_Output, 0, 0, 0, 0};
109706   sqlcipher3Select(pParse, yymsp[0].minor.yy387, &dest);
109707   sqlcipher3SelectDelete(pParse->db, yymsp[0].minor.yy387);
109708 }
109709         break;
109710       case 113: /* select ::= oneselect */
109711 {yygotominor.yy387 = yymsp[0].minor.yy387;}
109712         break;
109713       case 114: /* select ::= select multiselect_op oneselect */
109714 {
109715   if( yymsp[0].minor.yy387 ){
109716     yymsp[0].minor.yy387->op = (u8)yymsp[-1].minor.yy4;
109717     yymsp[0].minor.yy387->pPrior = yymsp[-2].minor.yy387;
109718   }else{
109719     sqlcipher3SelectDelete(pParse->db, yymsp[-2].minor.yy387);
109720   }
109721   yygotominor.yy387 = yymsp[0].minor.yy387;
109722 }
109723         break;
109724       case 116: /* multiselect_op ::= UNION ALL */
109725 {yygotominor.yy4 = TK_ALL;}
109726         break;
109727       case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
109728 {
109729   yygotominor.yy387 = sqlcipher3SelectNew(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);
109730 }
109731         break;
109732       case 122: /* sclp ::= selcollist COMMA */
109733       case 247: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==247);
109734 {yygotominor.yy322 = yymsp[-1].minor.yy322;}
109735         break;
109736       case 123: /* sclp ::= */
109737       case 151: /* orderby_opt ::= */ yytestcase(yyruleno==151);
109738       case 159: /* groupby_opt ::= */ yytestcase(yyruleno==159);
109739       case 240: /* exprlist ::= */ yytestcase(yyruleno==240);
109740       case 246: /* idxlist_opt ::= */ yytestcase(yyruleno==246);
109741 {yygotominor.yy322 = 0;}
109742         break;
109743       case 124: /* selcollist ::= sclp expr as */
109744 {
109745    yygotominor.yy322 = sqlcipher3ExprListAppend(pParse, yymsp[-2].minor.yy322, yymsp[-1].minor.yy118.pExpr);
109746    if( yymsp[0].minor.yy0.n>0 ) sqlcipher3ExprListSetName(pParse, yygotominor.yy322, &yymsp[0].minor.yy0, 1);
109747    sqlcipher3ExprListSetSpan(pParse,yygotominor.yy322,&yymsp[-1].minor.yy118);
109748 }
109749         break;
109750       case 125: /* selcollist ::= sclp STAR */
109751 {
109752   Expr *p = sqlcipher3Expr(pParse->db, TK_ALL, 0);
109753   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse, yymsp[-1].minor.yy322, p);
109754 }
109755         break;
109756       case 126: /* selcollist ::= sclp nm DOT STAR */
109757 {
109758   Expr *pRight = sqlcipher3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
109759   Expr *pLeft = sqlcipher3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
109760   Expr *pDot = sqlcipher3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
109761   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yymsp[-3].minor.yy322, pDot);
109762 }
109763         break;
109764       case 129: /* as ::= */
109765 {yygotominor.yy0.n = 0;}
109766         break;
109767       case 130: /* from ::= */
109768 {yygotominor.yy259 = sqlcipher3DbMallocZero(pParse->db, sizeof(*yygotominor.yy259));}
109769         break;
109770       case 131: /* from ::= FROM seltablist */
109771 {
109772   yygotominor.yy259 = yymsp[0].minor.yy259;
109773   sqlcipher3SrcListShiftJoinType(yygotominor.yy259);
109774 }
109775         break;
109776       case 132: /* stl_prefix ::= seltablist joinop */
109777 {
109778    yygotominor.yy259 = yymsp[-1].minor.yy259;
109779    if( ALWAYS(yygotominor.yy259 && yygotominor.yy259->nSrc>0) ) yygotominor.yy259->a[yygotominor.yy259->nSrc-1].jointype = (u8)yymsp[0].minor.yy4;
109780 }
109781         break;
109782       case 133: /* stl_prefix ::= */
109783 {yygotominor.yy259 = 0;}
109784         break;
109785       case 134: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
109786 {
109787   yygotominor.yy259 = sqlcipher3SrcListAppendFromTerm(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);
109788   sqlcipher3SrcListIndexedBy(pParse, yygotominor.yy259, &yymsp[-2].minor.yy0);
109789 }
109790         break;
109791       case 135: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
109792 {
109793     yygotominor.yy259 = sqlcipher3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy387,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
109794   }
109795         break;
109796       case 136: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
109797 {
109798     if( yymsp[-6].minor.yy259==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy314==0 && yymsp[0].minor.yy384==0 ){
109799       yygotominor.yy259 = yymsp[-4].minor.yy259;
109800     }else{
109801       Select *pSubquery;
109802       sqlcipher3SrcListShiftJoinType(yymsp[-4].minor.yy259);
109803       pSubquery = sqlcipher3SelectNew(pParse,0,yymsp[-4].minor.yy259,0,0,0,0,0,0,0);
109804       yygotominor.yy259 = sqlcipher3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
109805     }
109806   }
109807         break;
109808       case 137: /* dbnm ::= */
109809       case 146: /* indexed_opt ::= */ yytestcase(yyruleno==146);
109810 {yygotominor.yy0.z=0; yygotominor.yy0.n=0;}
109811         break;
109812       case 139: /* fullname ::= nm dbnm */
109813 {yygotominor.yy259 = sqlcipher3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
109814         break;
109815       case 140: /* joinop ::= COMMA|JOIN */
109816 { yygotominor.yy4 = JT_INNER; }
109817         break;
109818       case 141: /* joinop ::= JOIN_KW JOIN */
109819 { yygotominor.yy4 = sqlcipher3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
109820         break;
109821       case 142: /* joinop ::= JOIN_KW nm JOIN */
109822 { yygotominor.yy4 = sqlcipher3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
109823         break;
109824       case 143: /* joinop ::= JOIN_KW nm nm JOIN */
109825 { yygotominor.yy4 = sqlcipher3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
109826         break;
109827       case 144: /* on_opt ::= ON expr */
109828       case 155: /* sortitem ::= expr */ yytestcase(yyruleno==155);
109829       case 162: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==162);
109830       case 169: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==169);
109831       case 235: /* case_else ::= ELSE expr */ yytestcase(yyruleno==235);
109832       case 237: /* case_operand ::= expr */ yytestcase(yyruleno==237);
109833 {yygotominor.yy314 = yymsp[0].minor.yy118.pExpr;}
109834         break;
109835       case 145: /* on_opt ::= */
109836       case 161: /* having_opt ::= */ yytestcase(yyruleno==161);
109837       case 168: /* where_opt ::= */ yytestcase(yyruleno==168);
109838       case 236: /* case_else ::= */ yytestcase(yyruleno==236);
109839       case 238: /* case_operand ::= */ yytestcase(yyruleno==238);
109840 {yygotominor.yy314 = 0;}
109841         break;
109842       case 148: /* indexed_opt ::= NOT INDEXED */
109843 {yygotominor.yy0.z=0; yygotominor.yy0.n=1;}
109844         break;
109845       case 149: /* using_opt ::= USING LP inscollist RP */
109846       case 181: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==181);
109847 {yygotominor.yy384 = yymsp[-1].minor.yy384;}
109848         break;
109849       case 150: /* using_opt ::= */
109850       case 180: /* inscollist_opt ::= */ yytestcase(yyruleno==180);
109851 {yygotominor.yy384 = 0;}
109852         break;
109853       case 152: /* orderby_opt ::= ORDER BY sortlist */
109854       case 160: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==160);
109855       case 239: /* exprlist ::= nexprlist */ yytestcase(yyruleno==239);
109856 {yygotominor.yy322 = yymsp[0].minor.yy322;}
109857         break;
109858       case 153: /* sortlist ::= sortlist COMMA sortitem sortorder */
109859 {
109860   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yymsp[-3].minor.yy322,yymsp[-1].minor.yy314);
109861   if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
109862 }
109863         break;
109864       case 154: /* sortlist ::= sortitem sortorder */
109865 {
109866   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,0,yymsp[-1].minor.yy314);
109867   if( yygotominor.yy322 && ALWAYS(yygotominor.yy322->a) ) yygotominor.yy322->a[0].sortOrder = (u8)yymsp[0].minor.yy4;
109868 }
109869         break;
109870       case 156: /* sortorder ::= ASC */
109871       case 158: /* sortorder ::= */ yytestcase(yyruleno==158);
109872 {yygotominor.yy4 = SQLCIPHER_SO_ASC;}
109873         break;
109874       case 157: /* sortorder ::= DESC */
109875 {yygotominor.yy4 = SQLCIPHER_SO_DESC;}
109876         break;
109877       case 163: /* limit_opt ::= */
109878 {yygotominor.yy292.pLimit = 0; yygotominor.yy292.pOffset = 0;}
109879         break;
109880       case 164: /* limit_opt ::= LIMIT expr */
109881 {yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr; yygotominor.yy292.pOffset = 0;}
109882         break;
109883       case 165: /* limit_opt ::= LIMIT expr OFFSET expr */
109884 {yygotominor.yy292.pLimit = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pOffset = yymsp[0].minor.yy118.pExpr;}
109885         break;
109886       case 166: /* limit_opt ::= LIMIT expr COMMA expr */
109887 {yygotominor.yy292.pOffset = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr;}
109888         break;
109889       case 167: /* cmd ::= DELETE FROM fullname indexed_opt where_opt */
109890 {
109891   sqlcipher3SrcListIndexedBy(pParse, yymsp[-2].minor.yy259, &yymsp[-1].minor.yy0);
109892   sqlcipher3DeleteFrom(pParse,yymsp[-2].minor.yy259,yymsp[0].minor.yy314);
109893 }
109894         break;
109895       case 170: /* cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt */
109896 {
109897   sqlcipher3SrcListIndexedBy(pParse, yymsp[-4].minor.yy259, &yymsp[-3].minor.yy0);
109898   sqlcipher3ExprListCheckLength(pParse,yymsp[-1].minor.yy322,"set list"); 
109899   sqlcipher3Update(pParse,yymsp[-4].minor.yy259,yymsp[-1].minor.yy322,yymsp[0].minor.yy314,yymsp[-5].minor.yy210);
109900 }
109901         break;
109902       case 171: /* setlist ::= setlist COMMA nm EQ expr */
109903 {
109904   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy118.pExpr);
109905   sqlcipher3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
109906 }
109907         break;
109908       case 172: /* setlist ::= nm EQ expr */
109909 {
109910   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse, 0, yymsp[0].minor.yy118.pExpr);
109911   sqlcipher3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
109912 }
109913         break;
109914       case 173: /* cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP */
109915 {sqlcipher3Insert(pParse, yymsp[-5].minor.yy259, yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy384, yymsp[-7].minor.yy210);}
109916         break;
109917       case 174: /* cmd ::= insert_cmd INTO fullname inscollist_opt select */
109918 {sqlcipher3Insert(pParse, yymsp[-2].minor.yy259, 0, yymsp[0].minor.yy387, yymsp[-1].minor.yy384, yymsp[-4].minor.yy210);}
109919         break;
109920       case 175: /* cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
109921 {sqlcipher3Insert(pParse, yymsp[-3].minor.yy259, 0, 0, yymsp[-2].minor.yy384, yymsp[-5].minor.yy210);}
109922         break;
109923       case 176: /* insert_cmd ::= INSERT orconf */
109924 {yygotominor.yy210 = yymsp[0].minor.yy210;}
109925         break;
109926       case 177: /* insert_cmd ::= REPLACE */
109927 {yygotominor.yy210 = OE_Replace;}
109928         break;
109929       case 178: /* itemlist ::= itemlist COMMA expr */
109930       case 241: /* nexprlist ::= nexprlist COMMA expr */ yytestcase(yyruleno==241);
109931 {yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy118.pExpr);}
109932         break;
109933       case 179: /* itemlist ::= expr */
109934       case 242: /* nexprlist ::= expr */ yytestcase(yyruleno==242);
109935 {yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,0,yymsp[0].minor.yy118.pExpr);}
109936         break;
109937       case 182: /* inscollist ::= inscollist COMMA nm */
109938 {yygotominor.yy384 = sqlcipher3IdListAppend(pParse->db,yymsp[-2].minor.yy384,&yymsp[0].minor.yy0);}
109939         break;
109940       case 183: /* inscollist ::= nm */
109941 {yygotominor.yy384 = sqlcipher3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
109942         break;
109943       case 184: /* expr ::= term */
109944 {yygotominor.yy118 = yymsp[0].minor.yy118;}
109945         break;
109946       case 185: /* expr ::= LP expr RP */
109947 {yygotominor.yy118.pExpr = yymsp[-1].minor.yy118.pExpr; spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
109948         break;
109949       case 186: /* term ::= NULL */
109950       case 191: /* term ::= INTEGER|FLOAT|BLOB */ yytestcase(yyruleno==191);
109951       case 192: /* term ::= STRING */ yytestcase(yyruleno==192);
109952 {spanExpr(&yygotominor.yy118, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
109953         break;
109954       case 187: /* expr ::= id */
109955       case 188: /* expr ::= JOIN_KW */ yytestcase(yyruleno==188);
109956 {spanExpr(&yygotominor.yy118, pParse, TK_ID, &yymsp[0].minor.yy0);}
109957         break;
109958       case 189: /* expr ::= nm DOT nm */
109959 {
109960   Expr *temp1 = sqlcipher3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
109961   Expr *temp2 = sqlcipher3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
109962   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_DOT, temp1, temp2, 0);
109963   spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
109964 }
109965         break;
109966       case 190: /* expr ::= nm DOT nm DOT nm */
109967 {
109968   Expr *temp1 = sqlcipher3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
109969   Expr *temp2 = sqlcipher3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
109970   Expr *temp3 = sqlcipher3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
109971   Expr *temp4 = sqlcipher3PExpr(pParse, TK_DOT, temp2, temp3, 0);
109972   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_DOT, temp1, temp4, 0);
109973   spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
109974 }
109975         break;
109976       case 193: /* expr ::= REGISTER */
109977 {
109978   /* When doing a nested parse, one can include terms in an expression
109979   ** that look like this:   #1 #2 ...  These terms refer to registers
109980   ** in the virtual machine.  #N is the N-th register. */
109981   if( pParse->nested==0 ){
109982     sqlcipher3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
109983     yygotominor.yy118.pExpr = 0;
109984   }else{
109985     yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
109986     if( yygotominor.yy118.pExpr ) sqlcipher3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy118.pExpr->iTable);
109987   }
109988   spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
109989 }
109990         break;
109991       case 194: /* expr ::= VARIABLE */
109992 {
109993   spanExpr(&yygotominor.yy118, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
109994   sqlcipher3ExprAssignVarNumber(pParse, yygotominor.yy118.pExpr);
109995   spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
109996 }
109997         break;
109998       case 195: /* expr ::= expr COLLATE ids */
109999 {
110000   yygotominor.yy118.pExpr = sqlcipher3ExprSetCollByToken(pParse, yymsp[-2].minor.yy118.pExpr, &yymsp[0].minor.yy0);
110001   yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
110002   yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110003 }
110004         break;
110005       case 196: /* expr ::= CAST LP expr AS typetoken RP */
110006 {
110007   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy118.pExpr, 0, &yymsp[-1].minor.yy0);
110008   spanSet(&yygotominor.yy118,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
110009 }
110010         break;
110011       case 197: /* expr ::= ID LP distinct exprlist RP */
110012 {
110013   if( yymsp[-1].minor.yy322 && yymsp[-1].minor.yy322->nExpr>pParse->db->aLimit[SQLCIPHER_LIMIT_FUNCTION_ARG] ){
110014     sqlcipher3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
110015   }
110016   yygotominor.yy118.pExpr = sqlcipher3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
110017   spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
110018   if( yymsp[-2].minor.yy4 && yygotominor.yy118.pExpr ){
110019     yygotominor.yy118.pExpr->flags |= EP_Distinct;
110020   }
110021 }
110022         break;
110023       case 198: /* expr ::= ID LP STAR RP */
110024 {
110025   yygotominor.yy118.pExpr = sqlcipher3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
110026   spanSet(&yygotominor.yy118,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
110027 }
110028         break;
110029       case 199: /* term ::= CTIME_KW */
110030 {
110031   /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
110032   ** treated as functions that return constants */
110033   yygotominor.yy118.pExpr = sqlcipher3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
110034   if( yygotominor.yy118.pExpr ){
110035     yygotominor.yy118.pExpr->op = TK_CONST_FUNC;  
110036   }
110037   spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
110038 }
110039         break;
110040       case 200: /* expr ::= expr AND expr */
110041       case 201: /* expr ::= expr OR expr */ yytestcase(yyruleno==201);
110042       case 202: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==202);
110043       case 203: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==203);
110044       case 204: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==204);
110045       case 205: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==205);
110046       case 206: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==206);
110047       case 207: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==207);
110048 {spanBinaryExpr(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);}
110049         break;
110050       case 208: /* likeop ::= LIKE_KW */
110051       case 210: /* likeop ::= MATCH */ yytestcase(yyruleno==210);
110052 {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 0;}
110053         break;
110054       case 209: /* likeop ::= NOT LIKE_KW */
110055       case 211: /* likeop ::= NOT MATCH */ yytestcase(yyruleno==211);
110056 {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 1;}
110057         break;
110058       case 212: /* expr ::= expr likeop expr */
110059 {
110060   ExprList *pList;
110061   pList = sqlcipher3ExprListAppend(pParse,0, yymsp[0].minor.yy118.pExpr);
110062   pList = sqlcipher3ExprListAppend(pParse,pList, yymsp[-2].minor.yy118.pExpr);
110063   yygotominor.yy118.pExpr = sqlcipher3ExprFunction(pParse, pList, &yymsp[-1].minor.yy342.eOperator);
110064   if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110065   yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
110066   yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
110067   if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags |= EP_InfixFunc;
110068 }
110069         break;
110070       case 213: /* expr ::= expr likeop expr ESCAPE expr */
110071 {
110072   ExprList *pList;
110073   pList = sqlcipher3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
110074   pList = sqlcipher3ExprListAppend(pParse,pList, yymsp[-4].minor.yy118.pExpr);
110075   pList = sqlcipher3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
110076   yygotominor.yy118.pExpr = sqlcipher3ExprFunction(pParse, pList, &yymsp[-3].minor.yy342.eOperator);
110077   if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110078   yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110079   yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
110080   if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags |= EP_InfixFunc;
110081 }
110082         break;
110083       case 214: /* expr ::= expr ISNULL|NOTNULL */
110084 {spanUnaryPostfix(&yygotominor.yy118,pParse,yymsp[0].major,&yymsp[-1].minor.yy118,&yymsp[0].minor.yy0);}
110085         break;
110086       case 215: /* expr ::= expr NOT NULL */
110087 {spanUnaryPostfix(&yygotominor.yy118,pParse,TK_NOTNULL,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy0);}
110088         break;
110089       case 216: /* expr ::= expr IS expr */
110090 {
110091   spanBinaryExpr(&yygotominor.yy118,pParse,TK_IS,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);
110092   binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_ISNULL);
110093 }
110094         break;
110095       case 217: /* expr ::= expr IS NOT expr */
110096 {
110097   spanBinaryExpr(&yygotominor.yy118,pParse,TK_ISNOT,&yymsp[-3].minor.yy118,&yymsp[0].minor.yy118);
110098   binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_NOTNULL);
110099 }
110100         break;
110101       case 218: /* expr ::= NOT expr */
110102       case 219: /* expr ::= BITNOT expr */ yytestcase(yyruleno==219);
110103 {spanUnaryPrefix(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
110104         break;
110105       case 220: /* expr ::= MINUS expr */
110106 {spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UMINUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
110107         break;
110108       case 221: /* expr ::= PLUS expr */
110109 {spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UPLUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
110110         break;
110111       case 224: /* expr ::= expr between_op expr AND expr */
110112 {
110113   ExprList *pList = sqlcipher3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
110114   pList = sqlcipher3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
110115   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy118.pExpr, 0, 0);
110116   if( yygotominor.yy118.pExpr ){
110117     yygotominor.yy118.pExpr->x.pList = pList;
110118   }else{
110119     sqlcipher3ExprListDelete(pParse->db, pList);
110120   } 
110121   if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110122   yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110123   yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
110124 }
110125         break;
110126       case 227: /* expr ::= expr in_op LP exprlist RP */
110127 {
110128     if( yymsp[-1].minor.yy322==0 ){
110129       /* Expressions of the form
110130       **
110131       **      expr1 IN ()
110132       **      expr1 NOT IN ()
110133       **
110134       ** simplify to constants 0 (false) and 1 (true), respectively,
110135       ** regardless of the value of expr1.
110136       */
110137       yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_INTEGER, 0, 0, &sqlcipher3IntTokens[yymsp[-3].minor.yy4]);
110138       sqlcipher3ExprDelete(pParse->db, yymsp[-4].minor.yy118.pExpr);
110139     }else{
110140       yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
110141       if( yygotominor.yy118.pExpr ){
110142         yygotominor.yy118.pExpr->x.pList = yymsp[-1].minor.yy322;
110143         sqlcipher3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110144       }else{
110145         sqlcipher3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
110146       }
110147       if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110148     }
110149     yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110150     yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110151   }
110152         break;
110153       case 228: /* expr ::= LP select RP */
110154 {
110155     yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_SELECT, 0, 0, 0);
110156     if( yygotominor.yy118.pExpr ){
110157       yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
110158       ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
110159       sqlcipher3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110160     }else{
110161       sqlcipher3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
110162     }
110163     yygotominor.yy118.zStart = yymsp[-2].minor.yy0.z;
110164     yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110165   }
110166         break;
110167       case 229: /* expr ::= expr in_op LP select RP */
110168 {
110169     yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
110170     if( yygotominor.yy118.pExpr ){
110171       yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
110172       ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
110173       sqlcipher3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110174     }else{
110175       sqlcipher3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
110176     }
110177     if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110178     yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110179     yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110180   }
110181         break;
110182       case 230: /* expr ::= expr in_op nm dbnm */
110183 {
110184     SrcList *pSrc = sqlcipher3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
110185     yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_IN, yymsp[-3].minor.yy118.pExpr, 0, 0);
110186     if( yygotominor.yy118.pExpr ){
110187       yygotominor.yy118.pExpr->x.pSelect = sqlcipher3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
110188       ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
110189       sqlcipher3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110190     }else{
110191       sqlcipher3SrcListDelete(pParse->db, pSrc);
110192     }
110193     if( yymsp[-2].minor.yy4 ) yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110194     yygotominor.yy118.zStart = yymsp[-3].minor.yy118.zStart;
110195     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];
110196   }
110197         break;
110198       case 231: /* expr ::= EXISTS LP select RP */
110199 {
110200     Expr *p = yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_EXISTS, 0, 0, 0);
110201     if( p ){
110202       p->x.pSelect = yymsp[-1].minor.yy387;
110203       ExprSetProperty(p, EP_xIsSelect);
110204       sqlcipher3ExprSetHeight(pParse, p);
110205     }else{
110206       sqlcipher3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
110207     }
110208     yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
110209     yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110210   }
110211         break;
110212       case 232: /* expr ::= CASE case_operand case_exprlist case_else END */
110213 {
110214   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy314, yymsp[-1].minor.yy314, 0);
110215   if( yygotominor.yy118.pExpr ){
110216     yygotominor.yy118.pExpr->x.pList = yymsp[-2].minor.yy322;
110217     sqlcipher3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110218   }else{
110219     sqlcipher3ExprListDelete(pParse->db, yymsp[-2].minor.yy322);
110220   }
110221   yygotominor.yy118.zStart = yymsp[-4].minor.yy0.z;
110222   yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110223 }
110224         break;
110225       case 233: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
110226 {
110227   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy118.pExpr);
110228   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
110229 }
110230         break;
110231       case 234: /* case_exprlist ::= WHEN expr THEN expr */
110232 {
110233   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
110234   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
110235 }
110236         break;
110237       case 243: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP */
110238 {
110239   sqlcipher3CreateIndex(pParse, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0, 
110240                      sqlcipher3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy322, yymsp[-9].minor.yy4,
110241                       &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLCIPHER_SO_ASC, yymsp[-7].minor.yy4);
110242 }
110243         break;
110244       case 244: /* uniqueflag ::= UNIQUE */
110245       case 298: /* raisetype ::= ABORT */ yytestcase(yyruleno==298);
110246 {yygotominor.yy4 = OE_Abort;}
110247         break;
110248       case 245: /* uniqueflag ::= */
110249 {yygotominor.yy4 = OE_None;}
110250         break;
110251       case 248: /* idxlist ::= idxlist COMMA nm collate sortorder */
110252 {
110253   Expr *p = 0;
110254   if( yymsp[-1].minor.yy0.n>0 ){
110255     p = sqlcipher3Expr(pParse->db, TK_COLUMN, 0);
110256     sqlcipher3ExprSetCollByToken(pParse, p, &yymsp[-1].minor.yy0);
110257   }
110258   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,yymsp[-4].minor.yy322, p);
110259   sqlcipher3ExprListSetName(pParse,yygotominor.yy322,&yymsp[-2].minor.yy0,1);
110260   sqlcipher3ExprListCheckLength(pParse, yygotominor.yy322, "index");
110261   if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
110262 }
110263         break;
110264       case 249: /* idxlist ::= nm collate sortorder */
110265 {
110266   Expr *p = 0;
110267   if( yymsp[-1].minor.yy0.n>0 ){
110268     p = sqlcipher3PExpr(pParse, TK_COLUMN, 0, 0, 0);
110269     sqlcipher3ExprSetCollByToken(pParse, p, &yymsp[-1].minor.yy0);
110270   }
110271   yygotominor.yy322 = sqlcipher3ExprListAppend(pParse,0, p);
110272   sqlcipher3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
110273   sqlcipher3ExprListCheckLength(pParse, yygotominor.yy322, "index");
110274   if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
110275 }
110276         break;
110277       case 250: /* collate ::= */
110278 {yygotominor.yy0.z = 0; yygotominor.yy0.n = 0;}
110279         break;
110280       case 252: /* cmd ::= DROP INDEX ifexists fullname */
110281 {sqlcipher3DropIndex(pParse, yymsp[0].minor.yy259, yymsp[-1].minor.yy4);}
110282         break;
110283       case 253: /* cmd ::= VACUUM */
110284       case 254: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==254);
110285 {sqlcipher3Vacuum(pParse);}
110286         break;
110287       case 255: /* cmd ::= PRAGMA nm dbnm */
110288 {sqlcipher3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
110289         break;
110290       case 256: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
110291 {sqlcipher3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
110292         break;
110293       case 257: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
110294 {sqlcipher3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
110295         break;
110296       case 258: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
110297 {sqlcipher3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
110298         break;
110299       case 259: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
110300 {sqlcipher3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
110301         break;
110302       case 270: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
110303 {
110304   Token all;
110305   all.z = yymsp[-3].minor.yy0.z;
110306   all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
110307   sqlcipher3FinishTrigger(pParse, yymsp[-1].minor.yy203, &all);
110308 }
110309         break;
110310       case 271: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
110311 {
110312   sqlcipher3BeginTrigger(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);
110313   yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
110314 }
110315         break;
110316       case 272: /* trigger_time ::= BEFORE */
110317       case 275: /* trigger_time ::= */ yytestcase(yyruleno==275);
110318 { yygotominor.yy4 = TK_BEFORE; }
110319         break;
110320       case 273: /* trigger_time ::= AFTER */
110321 { yygotominor.yy4 = TK_AFTER;  }
110322         break;
110323       case 274: /* trigger_time ::= INSTEAD OF */
110324 { yygotominor.yy4 = TK_INSTEAD;}
110325         break;
110326       case 276: /* trigger_event ::= DELETE|INSERT */
110327       case 277: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==277);
110328 {yygotominor.yy90.a = yymsp[0].major; yygotominor.yy90.b = 0;}
110329         break;
110330       case 278: /* trigger_event ::= UPDATE OF inscollist */
110331 {yygotominor.yy90.a = TK_UPDATE; yygotominor.yy90.b = yymsp[0].minor.yy384;}
110332         break;
110333       case 281: /* when_clause ::= */
110334       case 303: /* key_opt ::= */ yytestcase(yyruleno==303);
110335 { yygotominor.yy314 = 0; }
110336         break;
110337       case 282: /* when_clause ::= WHEN expr */
110338       case 304: /* key_opt ::= KEY expr */ yytestcase(yyruleno==304);
110339 { yygotominor.yy314 = yymsp[0].minor.yy118.pExpr; }
110340         break;
110341       case 283: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
110342 {
110343   assert( yymsp[-2].minor.yy203!=0 );
110344   yymsp[-2].minor.yy203->pLast->pNext = yymsp[-1].minor.yy203;
110345   yymsp[-2].minor.yy203->pLast = yymsp[-1].minor.yy203;
110346   yygotominor.yy203 = yymsp[-2].minor.yy203;
110347 }
110348         break;
110349       case 284: /* trigger_cmd_list ::= trigger_cmd SEMI */
110350
110351   assert( yymsp[-1].minor.yy203!=0 );
110352   yymsp[-1].minor.yy203->pLast = yymsp[-1].minor.yy203;
110353   yygotominor.yy203 = yymsp[-1].minor.yy203;
110354 }
110355         break;
110356       case 286: /* trnm ::= nm DOT nm */
110357 {
110358   yygotominor.yy0 = yymsp[0].minor.yy0;
110359   sqlcipher3ErrorMsg(pParse, 
110360         "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
110361         "statements within triggers");
110362 }
110363         break;
110364       case 288: /* tridxby ::= INDEXED BY nm */
110365 {
110366   sqlcipher3ErrorMsg(pParse,
110367         "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
110368         "within triggers");
110369 }
110370         break;
110371       case 289: /* tridxby ::= NOT INDEXED */
110372 {
110373   sqlcipher3ErrorMsg(pParse,
110374         "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
110375         "within triggers");
110376 }
110377         break;
110378       case 290: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
110379 { yygotominor.yy203 = sqlcipher3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy322, yymsp[0].minor.yy314, yymsp[-5].minor.yy210); }
110380         break;
110381       case 291: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP */
110382 {yygotominor.yy203 = sqlcipher3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy384, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy210);}
110383         break;
110384       case 292: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
110385 {yygotominor.yy203 = sqlcipher3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy384, 0, yymsp[0].minor.yy387, yymsp[-4].minor.yy210);}
110386         break;
110387       case 293: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
110388 {yygotominor.yy203 = sqlcipher3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy314);}
110389         break;
110390       case 294: /* trigger_cmd ::= select */
110391 {yygotominor.yy203 = sqlcipher3TriggerSelectStep(pParse->db, yymsp[0].minor.yy387); }
110392         break;
110393       case 295: /* expr ::= RAISE LP IGNORE RP */
110394 {
110395   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_RAISE, 0, 0, 0); 
110396   if( yygotominor.yy118.pExpr ){
110397     yygotominor.yy118.pExpr->affinity = OE_Ignore;
110398   }
110399   yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
110400   yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110401 }
110402         break;
110403       case 296: /* expr ::= RAISE LP raisetype COMMA nm RP */
110404 {
110405   yygotominor.yy118.pExpr = sqlcipher3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0); 
110406   if( yygotominor.yy118.pExpr ) {
110407     yygotominor.yy118.pExpr->affinity = (char)yymsp[-3].minor.yy4;
110408   }
110409   yygotominor.yy118.zStart = yymsp[-5].minor.yy0.z;
110410   yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110411 }
110412         break;
110413       case 297: /* raisetype ::= ROLLBACK */
110414 {yygotominor.yy4 = OE_Rollback;}
110415         break;
110416       case 299: /* raisetype ::= FAIL */
110417 {yygotominor.yy4 = OE_Fail;}
110418         break;
110419       case 300: /* cmd ::= DROP TRIGGER ifexists fullname */
110420 {
110421   sqlcipher3DropTrigger(pParse,yymsp[0].minor.yy259,yymsp[-1].minor.yy4);
110422 }
110423         break;
110424       case 301: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
110425 {
110426   sqlcipher3Attach(pParse, yymsp[-3].minor.yy118.pExpr, yymsp[-1].minor.yy118.pExpr, yymsp[0].minor.yy314);
110427 }
110428         break;
110429       case 302: /* cmd ::= DETACH database_kw_opt expr */
110430 {
110431   sqlcipher3Detach(pParse, yymsp[0].minor.yy118.pExpr);
110432 }
110433         break;
110434       case 307: /* cmd ::= REINDEX */
110435 {sqlcipher3Reindex(pParse, 0, 0);}
110436         break;
110437       case 308: /* cmd ::= REINDEX nm dbnm */
110438 {sqlcipher3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
110439         break;
110440       case 309: /* cmd ::= ANALYZE */
110441 {sqlcipher3Analyze(pParse, 0, 0);}
110442         break;
110443       case 310: /* cmd ::= ANALYZE nm dbnm */
110444 {sqlcipher3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
110445         break;
110446       case 311: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
110447 {
110448   sqlcipher3AlterRenameTable(pParse,yymsp[-3].minor.yy259,&yymsp[0].minor.yy0);
110449 }
110450         break;
110451       case 312: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
110452 {
110453   sqlcipher3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
110454 }
110455         break;
110456       case 313: /* add_column_fullname ::= fullname */
110457 {
110458   pParse->db->lookaside.bEnabled = 0;
110459   sqlcipher3AlterBeginAddColumn(pParse, yymsp[0].minor.yy259);
110460 }
110461         break;
110462       case 316: /* cmd ::= create_vtab */
110463 {sqlcipher3VtabFinishParse(pParse,0);}
110464         break;
110465       case 317: /* cmd ::= create_vtab LP vtabarglist RP */
110466 {sqlcipher3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
110467         break;
110468       case 318: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
110469 {
110470     sqlcipher3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
110471 }
110472         break;
110473       case 321: /* vtabarg ::= */
110474 {sqlcipher3VtabArgInit(pParse);}
110475         break;
110476       case 323: /* vtabargtoken ::= ANY */
110477       case 324: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==324);
110478       case 325: /* lp ::= LP */ yytestcase(yyruleno==325);
110479 {sqlcipher3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
110480         break;
110481       default:
110482       /* (0) input ::= cmdlist */ yytestcase(yyruleno==0);
110483       /* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1);
110484       /* (2) cmdlist ::= ecmd */ yytestcase(yyruleno==2);
110485       /* (3) ecmd ::= SEMI */ yytestcase(yyruleno==3);
110486       /* (4) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==4);
110487       /* (10) trans_opt ::= */ yytestcase(yyruleno==10);
110488       /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11);
110489       /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12);
110490       /* (20) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==20);
110491       /* (21) savepoint_opt ::= */ yytestcase(yyruleno==21);
110492       /* (25) cmd ::= create_table create_table_args */ yytestcase(yyruleno==25);
110493       /* (34) columnlist ::= columnlist COMMA column */ yytestcase(yyruleno==34);
110494       /* (35) columnlist ::= column */ yytestcase(yyruleno==35);
110495       /* (44) type ::= */ yytestcase(yyruleno==44);
110496       /* (51) signed ::= plus_num */ yytestcase(yyruleno==51);
110497       /* (52) signed ::= minus_num */ yytestcase(yyruleno==52);
110498       /* (53) carglist ::= carglist carg */ yytestcase(yyruleno==53);
110499       /* (54) carglist ::= */ yytestcase(yyruleno==54);
110500       /* (55) carg ::= CONSTRAINT nm ccons */ yytestcase(yyruleno==55);
110501       /* (56) carg ::= ccons */ yytestcase(yyruleno==56);
110502       /* (62) ccons ::= NULL onconf */ yytestcase(yyruleno==62);
110503       /* (90) conslist ::= conslist COMMA tcons */ yytestcase(yyruleno==90);
110504       /* (91) conslist ::= conslist tcons */ yytestcase(yyruleno==91);
110505       /* (92) conslist ::= tcons */ yytestcase(yyruleno==92);
110506       /* (93) tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==93);
110507       /* (268) plus_opt ::= PLUS */ yytestcase(yyruleno==268);
110508       /* (269) plus_opt ::= */ yytestcase(yyruleno==269);
110509       /* (279) foreach_clause ::= */ yytestcase(yyruleno==279);
110510       /* (280) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==280);
110511       /* (287) tridxby ::= */ yytestcase(yyruleno==287);
110512       /* (305) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==305);
110513       /* (306) database_kw_opt ::= */ yytestcase(yyruleno==306);
110514       /* (314) kwcolumn_opt ::= */ yytestcase(yyruleno==314);
110515       /* (315) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==315);
110516       /* (319) vtabarglist ::= vtabarg */ yytestcase(yyruleno==319);
110517       /* (320) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==320);
110518       /* (322) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==322);
110519       /* (326) anylist ::= */ yytestcase(yyruleno==326);
110520       /* (327) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==327);
110521       /* (328) anylist ::= anylist ANY */ yytestcase(yyruleno==328);
110522         break;
110523   };
110524   yygoto = yyRuleInfo[yyruleno].lhs;
110525   yysize = yyRuleInfo[yyruleno].nrhs;
110526   yypParser->yyidx -= yysize;
110527   yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
110528   if( yyact < YYNSTATE ){
110529 #ifdef NDEBUG
110530     /* If we are not debugging and the reduce action popped at least
110531     ** one element off the stack, then we can push the new element back
110532     ** onto the stack here, and skip the stack overflow test in yy_shift().
110533     ** That gives a significant speed improvement. */
110534     if( yysize ){
110535       yypParser->yyidx++;
110536       yymsp -= yysize-1;
110537       yymsp->stateno = (YYACTIONTYPE)yyact;
110538       yymsp->major = (YYCODETYPE)yygoto;
110539       yymsp->minor = yygotominor;
110540     }else
110541 #endif
110542     {
110543       yy_shift(yypParser,yyact,yygoto,&yygotominor);
110544     }
110545   }else{
110546     assert( yyact == YYNSTATE + YYNRULE + 1 );
110547     yy_accept(yypParser);
110548   }
110549 }
110550
110551 /*
110552 ** The following code executes when the parse fails
110553 */
110554 #ifndef YYNOERRORRECOVERY
110555 static void yy_parse_failed(
110556   yyParser *yypParser           /* The parser */
110557 ){
110558   sqlcipher3ParserARG_FETCH;
110559 #ifndef NDEBUG
110560   if( yyTraceFILE ){
110561     fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
110562   }
110563 #endif
110564   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
110565   /* Here code is inserted which will be executed whenever the
110566   ** parser fails */
110567   sqlcipher3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
110568 }
110569 #endif /* YYNOERRORRECOVERY */
110570
110571 /*
110572 ** The following code executes when a syntax error first occurs.
110573 */
110574 static void yy_syntax_error(
110575   yyParser *yypParser,           /* The parser */
110576   int yymajor,                   /* The major type of the error token */
110577   YYMINORTYPE yyminor            /* The minor type of the error token */
110578 ){
110579   sqlcipher3ParserARG_FETCH;
110580 #define TOKEN (yyminor.yy0)
110581
110582   UNUSED_PARAMETER(yymajor);  /* Silence some compiler warnings */
110583   assert( TOKEN.z[0] );  /* The tokenizer always gives us a token */
110584   sqlcipher3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
110585   pParse->parseError = 1;
110586   sqlcipher3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
110587 }
110588
110589 /*
110590 ** The following is executed when the parser accepts
110591 */
110592 static void yy_accept(
110593   yyParser *yypParser           /* The parser */
110594 ){
110595   sqlcipher3ParserARG_FETCH;
110596 #ifndef NDEBUG
110597   if( yyTraceFILE ){
110598     fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
110599   }
110600 #endif
110601   while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
110602   /* Here code is inserted which will be executed whenever the
110603   ** parser accepts */
110604   sqlcipher3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
110605 }
110606
110607 /* The main parser program.
110608 ** The first argument is a pointer to a structure obtained from
110609 ** "sqlcipher3ParserAlloc" which describes the current state of the parser.
110610 ** The second argument is the major token number.  The third is
110611 ** the minor token.  The fourth optional argument is whatever the
110612 ** user wants (and specified in the grammar) and is available for
110613 ** use by the action routines.
110614 **
110615 ** Inputs:
110616 ** <ul>
110617 ** <li> A pointer to the parser (an opaque structure.)
110618 ** <li> The major token number.
110619 ** <li> The minor token number.
110620 ** <li> An option argument of a grammar-specified type.
110621 ** </ul>
110622 **
110623 ** Outputs:
110624 ** None.
110625 */
110626 SQLCIPHER_PRIVATE void sqlcipher3Parser(
110627   void *yyp,                   /* The parser */
110628   int yymajor,                 /* The major token code number */
110629   sqlcipher3ParserTOKENTYPE yyminor       /* The value for the token */
110630   sqlcipher3ParserARG_PDECL               /* Optional %extra_argument parameter */
110631 ){
110632   YYMINORTYPE yyminorunion;
110633   int yyact;            /* The parser action. */
110634 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
110635   int yyendofinput;     /* True if we are at the end of input */
110636 #endif
110637 #ifdef YYERRORSYMBOL
110638   int yyerrorhit = 0;   /* True if yymajor has invoked an error */
110639 #endif
110640   yyParser *yypParser;  /* The parser */
110641
110642   /* (re)initialize the parser, if necessary */
110643   yypParser = (yyParser*)yyp;
110644   if( yypParser->yyidx<0 ){
110645 #if YYSTACKDEPTH<=0
110646     if( yypParser->yystksz <=0 ){
110647       /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
110648       yyminorunion = yyzerominor;
110649       yyStackOverflow(yypParser, &yyminorunion);
110650       return;
110651     }
110652 #endif
110653     yypParser->yyidx = 0;
110654     yypParser->yyerrcnt = -1;
110655     yypParser->yystack[0].stateno = 0;
110656     yypParser->yystack[0].major = 0;
110657   }
110658   yyminorunion.yy0 = yyminor;
110659 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
110660   yyendofinput = (yymajor==0);
110661 #endif
110662   sqlcipher3ParserARG_STORE;
110663
110664 #ifndef NDEBUG
110665   if( yyTraceFILE ){
110666     fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
110667   }
110668 #endif
110669
110670   do{
110671     yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
110672     if( yyact<YYNSTATE ){
110673       yy_shift(yypParser,yyact,yymajor,&yyminorunion);
110674       yypParser->yyerrcnt--;
110675       yymajor = YYNOCODE;
110676     }else if( yyact < YYNSTATE + YYNRULE ){
110677       yy_reduce(yypParser,yyact-YYNSTATE);
110678     }else{
110679       assert( yyact == YY_ERROR_ACTION );
110680 #ifdef YYERRORSYMBOL
110681       int yymx;
110682 #endif
110683 #ifndef NDEBUG
110684       if( yyTraceFILE ){
110685         fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
110686       }
110687 #endif
110688 #ifdef YYERRORSYMBOL
110689       /* A syntax error has occurred.
110690       ** The response to an error depends upon whether or not the
110691       ** grammar defines an error token "ERROR".  
110692       **
110693       ** This is what we do if the grammar does define ERROR:
110694       **
110695       **  * Call the %syntax_error function.
110696       **
110697       **  * Begin popping the stack until we enter a state where
110698       **    it is legal to shift the error symbol, then shift
110699       **    the error symbol.
110700       **
110701       **  * Set the error count to three.
110702       **
110703       **  * Begin accepting and shifting new tokens.  No new error
110704       **    processing will occur until three tokens have been
110705       **    shifted successfully.
110706       **
110707       */
110708       if( yypParser->yyerrcnt<0 ){
110709         yy_syntax_error(yypParser,yymajor,yyminorunion);
110710       }
110711       yymx = yypParser->yystack[yypParser->yyidx].major;
110712       if( yymx==YYERRORSYMBOL || yyerrorhit ){
110713 #ifndef NDEBUG
110714         if( yyTraceFILE ){
110715           fprintf(yyTraceFILE,"%sDiscard input token %s\n",
110716              yyTracePrompt,yyTokenName[yymajor]);
110717         }
110718 #endif
110719         yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
110720         yymajor = YYNOCODE;
110721       }else{
110722          while(
110723           yypParser->yyidx >= 0 &&
110724           yymx != YYERRORSYMBOL &&
110725           (yyact = yy_find_reduce_action(
110726                         yypParser->yystack[yypParser->yyidx].stateno,
110727                         YYERRORSYMBOL)) >= YYNSTATE
110728         ){
110729           yy_pop_parser_stack(yypParser);
110730         }
110731         if( yypParser->yyidx < 0 || yymajor==0 ){
110732           yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
110733           yy_parse_failed(yypParser);
110734           yymajor = YYNOCODE;
110735         }else if( yymx!=YYERRORSYMBOL ){
110736           YYMINORTYPE u2;
110737           u2.YYERRSYMDT = 0;
110738           yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
110739         }
110740       }
110741       yypParser->yyerrcnt = 3;
110742       yyerrorhit = 1;
110743 #elif defined(YYNOERRORRECOVERY)
110744       /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
110745       ** do any kind of error recovery.  Instead, simply invoke the syntax
110746       ** error routine and continue going as if nothing had happened.
110747       **
110748       ** Applications can set this macro (for example inside %include) if
110749       ** they intend to abandon the parse upon the first syntax error seen.
110750       */
110751       yy_syntax_error(yypParser,yymajor,yyminorunion);
110752       yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
110753       yymajor = YYNOCODE;
110754       
110755 #else  /* YYERRORSYMBOL is not defined */
110756       /* This is what we do if the grammar does not define ERROR:
110757       **
110758       **  * Report an error message, and throw away the input token.
110759       **
110760       **  * If the input token is $, then fail the parse.
110761       **
110762       ** As before, subsequent error messages are suppressed until
110763       ** three input tokens have been successfully shifted.
110764       */
110765       if( yypParser->yyerrcnt<=0 ){
110766         yy_syntax_error(yypParser,yymajor,yyminorunion);
110767       }
110768       yypParser->yyerrcnt = 3;
110769       yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
110770       if( yyendofinput ){
110771         yy_parse_failed(yypParser);
110772       }
110773       yymajor = YYNOCODE;
110774 #endif
110775     }
110776   }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
110777   return;
110778 }
110779
110780 /************** End of parse.c ***********************************************/
110781 /************** Begin file tokenize.c ****************************************/
110782 /*
110783 ** 2001 September 15
110784 **
110785 ** The author disclaims copyright to this source code.  In place of
110786 ** a legal notice, here is a blessing:
110787 **
110788 **    May you do good and not evil.
110789 **    May you find forgiveness for yourself and forgive others.
110790 **    May you share freely, never taking more than you give.
110791 **
110792 *************************************************************************
110793 ** An tokenizer for SQL
110794 **
110795 ** This file contains C code that splits an SQL input string up into
110796 ** individual tokens and sends those tokens one-by-one over to the
110797 ** parser for analysis.
110798 */
110799 /* #include <stdlib.h> */
110800
110801 /*
110802 ** The charMap() macro maps alphabetic characters into their
110803 ** lower-case ASCII equivalent.  On ASCII machines, this is just
110804 ** an upper-to-lower case map.  On EBCDIC machines we also need
110805 ** to adjust the encoding.  Only alphabetic characters and underscores
110806 ** need to be translated.
110807 */
110808 #ifdef SQLCIPHER_ASCII
110809 # define charMap(X) sqlcipher3UpperToLower[(unsigned char)X]
110810 #endif
110811 #ifdef SQLCIPHER_EBCDIC
110812 # define charMap(X) ebcdicToAscii[(unsigned char)X]
110813 const unsigned char ebcdicToAscii[] = {
110814 /* 0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */
110815    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 0x */
110816    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 1x */
110817    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 2x */
110818    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 3x */
110819    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 4x */
110820    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 5x */
110821    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 95,  0,  0,  /* 6x */
110822    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* 7x */
110823    0, 97, 98, 99,100,101,102,103,104,105,  0,  0,  0,  0,  0,  0,  /* 8x */
110824    0,106,107,108,109,110,111,112,113,114,  0,  0,  0,  0,  0,  0,  /* 9x */
110825    0,  0,115,116,117,118,119,120,121,122,  0,  0,  0,  0,  0,  0,  /* Ax */
110826    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* Bx */
110827    0, 97, 98, 99,100,101,102,103,104,105,  0,  0,  0,  0,  0,  0,  /* Cx */
110828    0,106,107,108,109,110,111,112,113,114,  0,  0,  0,  0,  0,  0,  /* Dx */
110829    0,  0,115,116,117,118,119,120,121,122,  0,  0,  0,  0,  0,  0,  /* Ex */
110830    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  /* Fx */
110831 };
110832 #endif
110833
110834 /*
110835 ** The sqlcipher3KeywordCode function looks up an identifier to determine if
110836 ** it is a keyword.  If it is a keyword, the token code of that keyword is 
110837 ** returned.  If the input is not a keyword, TK_ID is returned.
110838 **
110839 ** The implementation of this routine was generated by a program,
110840 ** mkkeywordhash.h, located in the tool subdirectory of the distribution.
110841 ** The output of the mkkeywordhash.c program is written into a file
110842 ** named keywordhash.h and then included into this source file by
110843 ** the #include below.
110844 */
110845 /************** Include keywordhash.h in the middle of tokenize.c ************/
110846 /************** Begin file keywordhash.h *************************************/
110847 /***** This file contains automatically generated code ******
110848 **
110849 ** The code in this file has been automatically generated by
110850 **
110851 **   sqlcipher/tool/mkkeywordhash.c
110852 **
110853 ** The code in this file implements a function that determines whether
110854 ** or not a given identifier is really an SQL keyword.  The same thing
110855 ** might be implemented more directly using a hand-written hash table.
110856 ** But by using this automatically generated code, the size of the code
110857 ** is substantially reduced.  This is important for embedded applications
110858 ** on platforms with limited memory.
110859 */
110860 /* Hash score: 175 */
110861 static int keywordCode(const char *z, int n){
110862   /* zText[] encodes 811 bytes of keywords in 541 bytes */
110863   /*   REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT       */
110864   /*   ABLEFTHENDEFERRABLELSEXCEPTRANSACTIONATURALTERAISEXCLUSIVE         */
110865   /*   XISTSAVEPOINTERSECTRIGGEREFERENCESCONSTRAINTOFFSETEMPORARY         */
110866   /*   UNIQUERYATTACHAVINGROUPDATEBEGINNERELEASEBETWEENOTNULLIKE          */
110867   /*   CASCADELETECASECOLLATECREATECURRENT_DATEDETACHIMMEDIATEJOIN        */
110868   /*   SERTMATCHPLANALYZEPRAGMABORTVALUESVIRTUALIMITWHENWHERENAME         */
110869   /*   AFTEREPLACEANDEFAULTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICTCROSS     */
110870   /*   CURRENT_TIMESTAMPRIMARYDEFERREDISTINCTDROPFAILFROMFULLGLOBYIF      */
110871   /*   ISNULLORDERESTRICTOUTERIGHTROLLBACKROWUNIONUSINGVACUUMVIEW         */
110872   /*   INITIALLY                                                          */
110873   static const char zText[540] = {
110874     'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H',
110875     'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G',
110876     'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A',
110877     'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F',
110878     'E','R','R','A','B','L','E','L','S','E','X','C','E','P','T','R','A','N',
110879     'S','A','C','T','I','O','N','A','T','U','R','A','L','T','E','R','A','I',
110880     'S','E','X','C','L','U','S','I','V','E','X','I','S','T','S','A','V','E',
110881     'P','O','I','N','T','E','R','S','E','C','T','R','I','G','G','E','R','E',
110882     'F','E','R','E','N','C','E','S','C','O','N','S','T','R','A','I','N','T',
110883     'O','F','F','S','E','T','E','M','P','O','R','A','R','Y','U','N','I','Q',
110884     'U','E','R','Y','A','T','T','A','C','H','A','V','I','N','G','R','O','U',
110885     'P','D','A','T','E','B','E','G','I','N','N','E','R','E','L','E','A','S',
110886     'E','B','E','T','W','E','E','N','O','T','N','U','L','L','I','K','E','C',
110887     'A','S','C','A','D','E','L','E','T','E','C','A','S','E','C','O','L','L',
110888     'A','T','E','C','R','E','A','T','E','C','U','R','R','E','N','T','_','D',
110889     'A','T','E','D','E','T','A','C','H','I','M','M','E','D','I','A','T','E',
110890     'J','O','I','N','S','E','R','T','M','A','T','C','H','P','L','A','N','A',
110891     'L','Y','Z','E','P','R','A','G','M','A','B','O','R','T','V','A','L','U',
110892     'E','S','V','I','R','T','U','A','L','I','M','I','T','W','H','E','N','W',
110893     'H','E','R','E','N','A','M','E','A','F','T','E','R','E','P','L','A','C',
110894     'E','A','N','D','E','F','A','U','L','T','A','U','T','O','I','N','C','R',
110895     'E','M','E','N','T','C','A','S','T','C','O','L','U','M','N','C','O','M',
110896     'M','I','T','C','O','N','F','L','I','C','T','C','R','O','S','S','C','U',
110897     'R','R','E','N','T','_','T','I','M','E','S','T','A','M','P','R','I','M',
110898     'A','R','Y','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T',
110899     'D','R','O','P','F','A','I','L','F','R','O','M','F','U','L','L','G','L',
110900     'O','B','Y','I','F','I','S','N','U','L','L','O','R','D','E','R','E','S',
110901     'T','R','I','C','T','O','U','T','E','R','I','G','H','T','R','O','L','L',
110902     'B','A','C','K','R','O','W','U','N','I','O','N','U','S','I','N','G','V',
110903     'A','C','U','U','M','V','I','E','W','I','N','I','T','I','A','L','L','Y',
110904   };
110905   static const unsigned char aHash[127] = {
110906       72, 101, 114,  70,   0,  45,   0,   0,  78,   0,  73,   0,   0,
110907       42,  12,  74,  15,   0, 113,  81,  50, 108,   0,  19,   0,   0,
110908      118,   0, 116, 111,   0,  22,  89,   0,   9,   0,   0,  66,  67,
110909        0,  65,   6,   0,  48,  86,  98,   0, 115,  97,   0,   0,  44,
110910        0,  99,  24,   0,  17,   0, 119,  49,  23,   0,   5, 106,  25,
110911       92,   0,   0, 121, 102,  56, 120,  53,  28,  51,   0,  87,   0,
110912       96,  26,   0,  95,   0,   0,   0,  91,  88,  93,  84, 105,  14,
110913       39, 104,   0,  77,   0,  18,  85, 107,  32,   0, 117,  76, 109,
110914       58,  46,  80,   0,   0,  90,  40,   0, 112,   0,  36,   0,   0,
110915       29,   0,  82,  59,  60,   0,  20,  57,   0,  52,
110916   };
110917   static const unsigned char aNext[121] = {
110918        0,   0,   0,   0,   4,   0,   0,   0,   0,   0,   0,   0,   0,
110919        0,   2,   0,   0,   0,   0,   0,   0,  13,   0,   0,   0,   0,
110920        0,   7,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
110921        0,   0,   0,   0,  33,   0,  21,   0,   0,   0,  43,   3,  47,
110922        0,   0,   0,   0,  30,   0,  54,   0,  38,   0,   0,   0,   1,
110923       62,   0,   0,  63,   0,  41,   0,   0,   0,   0,   0,   0,   0,
110924       61,   0,   0,   0,   0,  31,  55,  16,  34,  10,   0,   0,   0,
110925        0,   0,   0,   0,  11,  68,  75,   0,   8,   0, 100,  94,   0,
110926      103,   0,  83,   0,  71,   0,   0, 110,  27,  37,  69,  79,   0,
110927       35,  64,   0,   0,
110928   };
110929   static const unsigned char aLen[121] = {
110930        7,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
110931        7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   6,
110932       11,   6,   2,   7,   5,   5,   9,   6,   9,   9,   7,  10,  10,
110933        4,   6,   2,   3,   9,   4,   2,   6,   5,   6,   6,   5,   6,
110934        5,   5,   7,   7,   7,   3,   2,   4,   4,   7,   3,   6,   4,
110935        7,   6,  12,   6,   9,   4,   6,   5,   4,   7,   6,   5,   6,
110936        7,   5,   4,   5,   6,   5,   7,   3,   7,  13,   2,   2,   4,
110937        6,   6,   8,   5,  17,  12,   7,   8,   8,   2,   4,   4,   4,
110938        4,   4,   2,   2,   6,   5,   8,   5,   5,   8,   3,   5,   5,
110939        6,   4,   9,   3,
110940   };
110941   static const unsigned short int aOffset[121] = {
110942        0,   2,   2,   8,   9,  14,  16,  20,  23,  25,  25,  29,  33,
110943       36,  41,  46,  48,  53,  54,  59,  62,  65,  67,  69,  78,  81,
110944       86,  91,  95,  96, 101, 105, 109, 117, 122, 128, 136, 142, 152,
110945      159, 162, 162, 165, 167, 167, 171, 176, 179, 184, 189, 194, 197,
110946      203, 206, 210, 217, 223, 223, 223, 226, 229, 233, 234, 238, 244,
110947      248, 255, 261, 273, 279, 288, 290, 296, 301, 303, 310, 315, 320,
110948      326, 332, 337, 341, 344, 350, 354, 361, 363, 370, 372, 374, 383,
110949      387, 393, 399, 407, 412, 412, 428, 435, 442, 443, 450, 454, 458,
110950      462, 466, 469, 471, 473, 479, 483, 491, 495, 500, 508, 511, 516,
110951      521, 527, 531, 536,
110952   };
110953   static const unsigned char aCode[121] = {
110954     TK_REINDEX,    TK_INDEXED,    TK_INDEX,      TK_DESC,       TK_ESCAPE,     
110955     TK_EACH,       TK_CHECK,      TK_KEY,        TK_BEFORE,     TK_FOREIGN,    
110956     TK_FOR,        TK_IGNORE,     TK_LIKE_KW,    TK_EXPLAIN,    TK_INSTEAD,    
110957     TK_ADD,        TK_DATABASE,   TK_AS,         TK_SELECT,     TK_TABLE,      
110958     TK_JOIN_KW,    TK_THEN,       TK_END,        TK_DEFERRABLE, TK_ELSE,       
110959     TK_EXCEPT,     TK_TRANSACTION,TK_ACTION,     TK_ON,         TK_JOIN_KW,    
110960     TK_ALTER,      TK_RAISE,      TK_EXCLUSIVE,  TK_EXISTS,     TK_SAVEPOINT,  
110961     TK_INTERSECT,  TK_TRIGGER,    TK_REFERENCES, TK_CONSTRAINT, TK_INTO,       
110962     TK_OFFSET,     TK_OF,         TK_SET,        TK_TEMP,       TK_TEMP,       
110963     TK_OR,         TK_UNIQUE,     TK_QUERY,      TK_ATTACH,     TK_HAVING,     
110964     TK_GROUP,      TK_UPDATE,     TK_BEGIN,      TK_JOIN_KW,    TK_RELEASE,    
110965     TK_BETWEEN,    TK_NOTNULL,    TK_NOT,        TK_NO,         TK_NULL,       
110966     TK_LIKE_KW,    TK_CASCADE,    TK_ASC,        TK_DELETE,     TK_CASE,       
110967     TK_COLLATE,    TK_CREATE,     TK_CTIME_KW,   TK_DETACH,     TK_IMMEDIATE,  
110968     TK_JOIN,       TK_INSERT,     TK_MATCH,      TK_PLAN,       TK_ANALYZE,    
110969     TK_PRAGMA,     TK_ABORT,      TK_VALUES,     TK_VIRTUAL,    TK_LIMIT,      
110970     TK_WHEN,       TK_WHERE,      TK_RENAME,     TK_AFTER,      TK_REPLACE,    
110971     TK_AND,        TK_DEFAULT,    TK_AUTOINCR,   TK_TO,         TK_IN,         
110972     TK_CAST,       TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,    
110973     TK_CTIME_KW,   TK_CTIME_KW,   TK_PRIMARY,    TK_DEFERRED,   TK_DISTINCT,   
110974     TK_IS,         TK_DROP,       TK_FAIL,       TK_FROM,       TK_JOIN_KW,    
110975     TK_LIKE_KW,    TK_BY,         TK_IF,         TK_ISNULL,     TK_ORDER,      
110976     TK_RESTRICT,   TK_JOIN_KW,    TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,        
110977     TK_UNION,      TK_USING,      TK_VACUUM,     TK_VIEW,       TK_INITIALLY,  
110978     TK_ALL,        
110979   };
110980   int h, i;
110981   if( n<2 ) return TK_ID;
110982   h = ((charMap(z[0])*4) ^
110983       (charMap(z[n-1])*3) ^
110984       n) % 127;
110985   for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){
110986     if( aLen[i]==n && sqlcipher3StrNICmp(&zText[aOffset[i]],z,n)==0 ){
110987       testcase( i==0 ); /* REINDEX */
110988       testcase( i==1 ); /* INDEXED */
110989       testcase( i==2 ); /* INDEX */
110990       testcase( i==3 ); /* DESC */
110991       testcase( i==4 ); /* ESCAPE */
110992       testcase( i==5 ); /* EACH */
110993       testcase( i==6 ); /* CHECK */
110994       testcase( i==7 ); /* KEY */
110995       testcase( i==8 ); /* BEFORE */
110996       testcase( i==9 ); /* FOREIGN */
110997       testcase( i==10 ); /* FOR */
110998       testcase( i==11 ); /* IGNORE */
110999       testcase( i==12 ); /* REGEXP */
111000       testcase( i==13 ); /* EXPLAIN */
111001       testcase( i==14 ); /* INSTEAD */
111002       testcase( i==15 ); /* ADD */
111003       testcase( i==16 ); /* DATABASE */
111004       testcase( i==17 ); /* AS */
111005       testcase( i==18 ); /* SELECT */
111006       testcase( i==19 ); /* TABLE */
111007       testcase( i==20 ); /* LEFT */
111008       testcase( i==21 ); /* THEN */
111009       testcase( i==22 ); /* END */
111010       testcase( i==23 ); /* DEFERRABLE */
111011       testcase( i==24 ); /* ELSE */
111012       testcase( i==25 ); /* EXCEPT */
111013       testcase( i==26 ); /* TRANSACTION */
111014       testcase( i==27 ); /* ACTION */
111015       testcase( i==28 ); /* ON */
111016       testcase( i==29 ); /* NATURAL */
111017       testcase( i==30 ); /* ALTER */
111018       testcase( i==31 ); /* RAISE */
111019       testcase( i==32 ); /* EXCLUSIVE */
111020       testcase( i==33 ); /* EXISTS */
111021       testcase( i==34 ); /* SAVEPOINT */
111022       testcase( i==35 ); /* INTERSECT */
111023       testcase( i==36 ); /* TRIGGER */
111024       testcase( i==37 ); /* REFERENCES */
111025       testcase( i==38 ); /* CONSTRAINT */
111026       testcase( i==39 ); /* INTO */
111027       testcase( i==40 ); /* OFFSET */
111028       testcase( i==41 ); /* OF */
111029       testcase( i==42 ); /* SET */
111030       testcase( i==43 ); /* TEMPORARY */
111031       testcase( i==44 ); /* TEMP */
111032       testcase( i==45 ); /* OR */
111033       testcase( i==46 ); /* UNIQUE */
111034       testcase( i==47 ); /* QUERY */
111035       testcase( i==48 ); /* ATTACH */
111036       testcase( i==49 ); /* HAVING */
111037       testcase( i==50 ); /* GROUP */
111038       testcase( i==51 ); /* UPDATE */
111039       testcase( i==52 ); /* BEGIN */
111040       testcase( i==53 ); /* INNER */
111041       testcase( i==54 ); /* RELEASE */
111042       testcase( i==55 ); /* BETWEEN */
111043       testcase( i==56 ); /* NOTNULL */
111044       testcase( i==57 ); /* NOT */
111045       testcase( i==58 ); /* NO */
111046       testcase( i==59 ); /* NULL */
111047       testcase( i==60 ); /* LIKE */
111048       testcase( i==61 ); /* CASCADE */
111049       testcase( i==62 ); /* ASC */
111050       testcase( i==63 ); /* DELETE */
111051       testcase( i==64 ); /* CASE */
111052       testcase( i==65 ); /* COLLATE */
111053       testcase( i==66 ); /* CREATE */
111054       testcase( i==67 ); /* CURRENT_DATE */
111055       testcase( i==68 ); /* DETACH */
111056       testcase( i==69 ); /* IMMEDIATE */
111057       testcase( i==70 ); /* JOIN */
111058       testcase( i==71 ); /* INSERT */
111059       testcase( i==72 ); /* MATCH */
111060       testcase( i==73 ); /* PLAN */
111061       testcase( i==74 ); /* ANALYZE */
111062       testcase( i==75 ); /* PRAGMA */
111063       testcase( i==76 ); /* ABORT */
111064       testcase( i==77 ); /* VALUES */
111065       testcase( i==78 ); /* VIRTUAL */
111066       testcase( i==79 ); /* LIMIT */
111067       testcase( i==80 ); /* WHEN */
111068       testcase( i==81 ); /* WHERE */
111069       testcase( i==82 ); /* RENAME */
111070       testcase( i==83 ); /* AFTER */
111071       testcase( i==84 ); /* REPLACE */
111072       testcase( i==85 ); /* AND */
111073       testcase( i==86 ); /* DEFAULT */
111074       testcase( i==87 ); /* AUTOINCREMENT */
111075       testcase( i==88 ); /* TO */
111076       testcase( i==89 ); /* IN */
111077       testcase( i==90 ); /* CAST */
111078       testcase( i==91 ); /* COLUMN */
111079       testcase( i==92 ); /* COMMIT */
111080       testcase( i==93 ); /* CONFLICT */
111081       testcase( i==94 ); /* CROSS */
111082       testcase( i==95 ); /* CURRENT_TIMESTAMP */
111083       testcase( i==96 ); /* CURRENT_TIME */
111084       testcase( i==97 ); /* PRIMARY */
111085       testcase( i==98 ); /* DEFERRED */
111086       testcase( i==99 ); /* DISTINCT */
111087       testcase( i==100 ); /* IS */
111088       testcase( i==101 ); /* DROP */
111089       testcase( i==102 ); /* FAIL */
111090       testcase( i==103 ); /* FROM */
111091       testcase( i==104 ); /* FULL */
111092       testcase( i==105 ); /* GLOB */
111093       testcase( i==106 ); /* BY */
111094       testcase( i==107 ); /* IF */
111095       testcase( i==108 ); /* ISNULL */
111096       testcase( i==109 ); /* ORDER */
111097       testcase( i==110 ); /* RESTRICT */
111098       testcase( i==111 ); /* OUTER */
111099       testcase( i==112 ); /* RIGHT */
111100       testcase( i==113 ); /* ROLLBACK */
111101       testcase( i==114 ); /* ROW */
111102       testcase( i==115 ); /* UNION */
111103       testcase( i==116 ); /* USING */
111104       testcase( i==117 ); /* VACUUM */
111105       testcase( i==118 ); /* VIEW */
111106       testcase( i==119 ); /* INITIALLY */
111107       testcase( i==120 ); /* ALL */
111108       return aCode[i];
111109     }
111110   }
111111   return TK_ID;
111112 }
111113 SQLCIPHER_PRIVATE int sqlcipher3KeywordCode(const unsigned char *z, int n){
111114   return keywordCode((char*)z, n);
111115 }
111116 #define SQLCIPHER_N_KEYWORD 121
111117
111118 /************** End of keywordhash.h *****************************************/
111119 /************** Continuing where we left off in tokenize.c *******************/
111120
111121
111122 /*
111123 ** If X is a character that can be used in an identifier then
111124 ** IdChar(X) will be true.  Otherwise it is false.
111125 **
111126 ** For ASCII, any character with the high-order bit set is
111127 ** allowed in an identifier.  For 7-bit characters, 
111128 ** sqlcipher3IsIdChar[X] must be 1.
111129 **
111130 ** For EBCDIC, the rules are more complex but have the same
111131 ** end result.
111132 **
111133 ** Ticket #1066.  the SQL standard does not allow '$' in the
111134 ** middle of identfiers.  But many SQL implementations do. 
111135 ** SQLite will allow '$' in identifiers for compatibility.
111136 ** But the feature is undocumented.
111137 */
111138 #ifdef SQLCIPHER_ASCII
111139 #define IdChar(C)  ((sqlcipher3CtypeMap[(unsigned char)C]&0x46)!=0)
111140 #endif
111141 #ifdef SQLCIPHER_EBCDIC
111142 SQLCIPHER_PRIVATE const char sqlcipher3IsEbcdicIdChar[] = {
111143 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
111144     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 4x */
111145     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0,  /* 5x */
111146     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,  /* 6x */
111147     0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,  /* 7x */
111148     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,  /* 8x */
111149     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,  /* 9x */
111150     1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,  /* Ax */
111151     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* Bx */
111152     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Cx */
111153     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Dx */
111154     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,  /* Ex */
111155     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0,  /* Fx */
111156 };
111157 #define IdChar(C)  (((c=C)>=0x42 && sqlcipher3IsEbcdicIdChar[c-0x40]))
111158 #endif
111159
111160
111161 /*
111162 ** Return the length of the token that begins at z[0]. 
111163 ** Store the token type in *tokenType before returning.
111164 */
111165 SQLCIPHER_PRIVATE int sqlcipher3GetToken(const unsigned char *z, int *tokenType){
111166   int i, c;
111167   switch( *z ){
111168     case ' ': case '\t': case '\n': case '\f': case '\r': {
111169       testcase( z[0]==' ' );
111170       testcase( z[0]=='\t' );
111171       testcase( z[0]=='\n' );
111172       testcase( z[0]=='\f' );
111173       testcase( z[0]=='\r' );
111174       for(i=1; sqlcipher3Isspace(z[i]); i++){}
111175       *tokenType = TK_SPACE;
111176       return i;
111177     }
111178     case '-': {
111179       if( z[1]=='-' ){
111180         /* IMP: R-15891-05542 -- syntax diagram for comments */
111181         for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
111182         *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
111183         return i;
111184       }
111185       *tokenType = TK_MINUS;
111186       return 1;
111187     }
111188     case '(': {
111189       *tokenType = TK_LP;
111190       return 1;
111191     }
111192     case ')': {
111193       *tokenType = TK_RP;
111194       return 1;
111195     }
111196     case ';': {
111197       *tokenType = TK_SEMI;
111198       return 1;
111199     }
111200     case '+': {
111201       *tokenType = TK_PLUS;
111202       return 1;
111203     }
111204     case '*': {
111205       *tokenType = TK_STAR;
111206       return 1;
111207     }
111208     case '/': {
111209       if( z[1]!='*' || z[2]==0 ){
111210         *tokenType = TK_SLASH;
111211         return 1;
111212       }
111213       /* IMP: R-15891-05542 -- syntax diagram for comments */
111214       for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
111215       if( c ) i++;
111216       *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
111217       return i;
111218     }
111219     case '%': {
111220       *tokenType = TK_REM;
111221       return 1;
111222     }
111223     case '=': {
111224       *tokenType = TK_EQ;
111225       return 1 + (z[1]=='=');
111226     }
111227     case '<': {
111228       if( (c=z[1])=='=' ){
111229         *tokenType = TK_LE;
111230         return 2;
111231       }else if( c=='>' ){
111232         *tokenType = TK_NE;
111233         return 2;
111234       }else if( c=='<' ){
111235         *tokenType = TK_LSHIFT;
111236         return 2;
111237       }else{
111238         *tokenType = TK_LT;
111239         return 1;
111240       }
111241     }
111242     case '>': {
111243       if( (c=z[1])=='=' ){
111244         *tokenType = TK_GE;
111245         return 2;
111246       }else if( c=='>' ){
111247         *tokenType = TK_RSHIFT;
111248         return 2;
111249       }else{
111250         *tokenType = TK_GT;
111251         return 1;
111252       }
111253     }
111254     case '!': {
111255       if( z[1]!='=' ){
111256         *tokenType = TK_ILLEGAL;
111257         return 2;
111258       }else{
111259         *tokenType = TK_NE;
111260         return 2;
111261       }
111262     }
111263     case '|': {
111264       if( z[1]!='|' ){
111265         *tokenType = TK_BITOR;
111266         return 1;
111267       }else{
111268         *tokenType = TK_CONCAT;
111269         return 2;
111270       }
111271     }
111272     case ',': {
111273       *tokenType = TK_COMMA;
111274       return 1;
111275     }
111276     case '&': {
111277       *tokenType = TK_BITAND;
111278       return 1;
111279     }
111280     case '~': {
111281       *tokenType = TK_BITNOT;
111282       return 1;
111283     }
111284     case '`':
111285     case '\'':
111286     case '"': {
111287       int delim = z[0];
111288       testcase( delim=='`' );
111289       testcase( delim=='\'' );
111290       testcase( delim=='"' );
111291       for(i=1; (c=z[i])!=0; i++){
111292         if( c==delim ){
111293           if( z[i+1]==delim ){
111294             i++;
111295           }else{
111296             break;
111297           }
111298         }
111299       }
111300       if( c=='\'' ){
111301         *tokenType = TK_STRING;
111302         return i+1;
111303       }else if( c!=0 ){
111304         *tokenType = TK_ID;
111305         return i+1;
111306       }else{
111307         *tokenType = TK_ILLEGAL;
111308         return i;
111309       }
111310     }
111311     case '.': {
111312 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
111313       if( !sqlcipher3Isdigit(z[1]) )
111314 #endif
111315       {
111316         *tokenType = TK_DOT;
111317         return 1;
111318       }
111319       /* If the next character is a digit, this is a floating point
111320       ** number that begins with ".".  Fall thru into the next case */
111321     }
111322     case '0': case '1': case '2': case '3': case '4':
111323     case '5': case '6': case '7': case '8': case '9': {
111324       testcase( z[0]=='0' );  testcase( z[0]=='1' );  testcase( z[0]=='2' );
111325       testcase( z[0]=='3' );  testcase( z[0]=='4' );  testcase( z[0]=='5' );
111326       testcase( z[0]=='6' );  testcase( z[0]=='7' );  testcase( z[0]=='8' );
111327       testcase( z[0]=='9' );
111328       *tokenType = TK_INTEGER;
111329       for(i=0; sqlcipher3Isdigit(z[i]); i++){}
111330 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
111331       if( z[i]=='.' ){
111332         i++;
111333         while( sqlcipher3Isdigit(z[i]) ){ i++; }
111334         *tokenType = TK_FLOAT;
111335       }
111336       if( (z[i]=='e' || z[i]=='E') &&
111337            ( sqlcipher3Isdigit(z[i+1]) 
111338             || ((z[i+1]=='+' || z[i+1]=='-') && sqlcipher3Isdigit(z[i+2]))
111339            )
111340       ){
111341         i += 2;
111342         while( sqlcipher3Isdigit(z[i]) ){ i++; }
111343         *tokenType = TK_FLOAT;
111344       }
111345 #endif
111346       while( IdChar(z[i]) ){
111347         *tokenType = TK_ILLEGAL;
111348         i++;
111349       }
111350       return i;
111351     }
111352     case '[': {
111353       for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
111354       *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
111355       return i;
111356     }
111357     case '?': {
111358       *tokenType = TK_VARIABLE;
111359       for(i=1; sqlcipher3Isdigit(z[i]); i++){}
111360       return i;
111361     }
111362     case '#': {
111363       for(i=1; sqlcipher3Isdigit(z[i]); i++){}
111364       if( i>1 ){
111365         /* Parameters of the form #NNN (where NNN is a number) are used
111366         ** internally by sqlcipher3NestedParse.  */
111367         *tokenType = TK_REGISTER;
111368         return i;
111369       }
111370       /* Fall through into the next case if the '#' is not followed by
111371       ** a digit. Try to match #AAAA where AAAA is a parameter name. */
111372     }
111373 #ifndef SQLCIPHER_OMIT_TCL_VARIABLE
111374     case '$':
111375 #endif
111376     case '@':  /* For compatibility with MS SQL Server */
111377     case ':': {
111378       int n = 0;
111379       testcase( z[0]=='$' );  testcase( z[0]=='@' );  testcase( z[0]==':' );
111380       *tokenType = TK_VARIABLE;
111381       for(i=1; (c=z[i])!=0; i++){
111382         if( IdChar(c) ){
111383           n++;
111384 #ifndef SQLCIPHER_OMIT_TCL_VARIABLE
111385         }else if( c=='(' && n>0 ){
111386           do{
111387             i++;
111388           }while( (c=z[i])!=0 && !sqlcipher3Isspace(c) && c!=')' );
111389           if( c==')' ){
111390             i++;
111391           }else{
111392             *tokenType = TK_ILLEGAL;
111393           }
111394           break;
111395         }else if( c==':' && z[i+1]==':' ){
111396           i++;
111397 #endif
111398         }else{
111399           break;
111400         }
111401       }
111402       if( n==0 ) *tokenType = TK_ILLEGAL;
111403       return i;
111404     }
111405 #ifndef SQLCIPHER_OMIT_BLOB_LITERAL
111406     case 'x': case 'X': {
111407       testcase( z[0]=='x' ); testcase( z[0]=='X' );
111408       if( z[1]=='\'' ){
111409         *tokenType = TK_BLOB;
111410         for(i=2; sqlcipher3Isxdigit(z[i]); i++){}
111411         if( z[i]!='\'' || i%2 ){
111412           *tokenType = TK_ILLEGAL;
111413           while( z[i] && z[i]!='\'' ){ i++; }
111414         }
111415         if( z[i] ) i++;
111416         return i;
111417       }
111418       /* Otherwise fall through to the next case */
111419     }
111420 #endif
111421     default: {
111422       if( !IdChar(*z) ){
111423         break;
111424       }
111425       for(i=1; IdChar(z[i]); i++){}
111426       *tokenType = keywordCode((char*)z, i);
111427       return i;
111428     }
111429   }
111430   *tokenType = TK_ILLEGAL;
111431   return 1;
111432 }
111433
111434 /*
111435 ** Run the parser on the given SQL string.  The parser structure is
111436 ** passed in.  An SQLCIPHER_ status code is returned.  If an error occurs
111437 ** then an and attempt is made to write an error message into 
111438 ** memory obtained from sqlcipher3_malloc() and to make *pzErrMsg point to that
111439 ** error message.
111440 */
111441 SQLCIPHER_PRIVATE int sqlcipher3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
111442   int nErr = 0;                   /* Number of errors encountered */
111443   int i;                          /* Loop counter */
111444   void *pEngine;                  /* The LEMON-generated LALR(1) parser */
111445   int tokenType;                  /* type of the next token */
111446   int lastTokenParsed = -1;       /* type of the previous token */
111447   u8 enableLookaside;             /* Saved value of db->lookaside.bEnabled */
111448   sqlcipher3 *db = pParse->db;       /* The database connection */
111449   int mxSqlLen;                   /* Max length of an SQL string */
111450
111451
111452   mxSqlLen = db->aLimit[SQLCIPHER_LIMIT_SQL_LENGTH];
111453   if( db->activeVdbeCnt==0 ){
111454     db->u1.isInterrupted = 0;
111455   }
111456   pParse->rc = SQLCIPHER_OK;
111457   pParse->zTail = zSql;
111458   i = 0;
111459   assert( pzErrMsg!=0 );
111460   pEngine = sqlcipher3ParserAlloc((void*(*)(size_t))sqlcipher3Malloc);
111461   if( pEngine==0 ){
111462     db->mallocFailed = 1;
111463     return SQLCIPHER_NOMEM;
111464   }
111465   assert( pParse->pNewTable==0 );
111466   assert( pParse->pNewTrigger==0 );
111467   assert( pParse->nVar==0 );
111468   assert( pParse->nzVar==0 );
111469   assert( pParse->azVar==0 );
111470   enableLookaside = db->lookaside.bEnabled;
111471   if( db->lookaside.pStart ) db->lookaside.bEnabled = 1;
111472   while( !db->mallocFailed && zSql[i]!=0 ){
111473     assert( i>=0 );
111474     pParse->sLastToken.z = &zSql[i];
111475     pParse->sLastToken.n = sqlcipher3GetToken((unsigned char*)&zSql[i],&tokenType);
111476     i += pParse->sLastToken.n;
111477     if( i>mxSqlLen ){
111478       pParse->rc = SQLCIPHER_TOOBIG;
111479       break;
111480     }
111481     switch( tokenType ){
111482       case TK_SPACE: {
111483         if( db->u1.isInterrupted ){
111484           sqlcipher3ErrorMsg(pParse, "interrupt");
111485           pParse->rc = SQLCIPHER_INTERRUPT;
111486           goto abort_parse;
111487         }
111488         break;
111489       }
111490       case TK_ILLEGAL: {
111491         sqlcipher3DbFree(db, *pzErrMsg);
111492         *pzErrMsg = sqlcipher3MPrintf(db, "unrecognized token: \"%T\"",
111493                         &pParse->sLastToken);
111494         nErr++;
111495         goto abort_parse;
111496       }
111497       case TK_SEMI: {
111498         pParse->zTail = &zSql[i];
111499         /* Fall thru into the default case */
111500       }
111501       default: {
111502         sqlcipher3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
111503         lastTokenParsed = tokenType;
111504         if( pParse->rc!=SQLCIPHER_OK ){
111505           goto abort_parse;
111506         }
111507         break;
111508       }
111509     }
111510   }
111511 abort_parse:
111512   if( zSql[i]==0 && nErr==0 && pParse->rc==SQLCIPHER_OK ){
111513     if( lastTokenParsed!=TK_SEMI ){
111514       sqlcipher3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
111515       pParse->zTail = &zSql[i];
111516     }
111517     sqlcipher3Parser(pEngine, 0, pParse->sLastToken, pParse);
111518   }
111519 #ifdef YYTRACKMAXSTACKDEPTH
111520   sqlcipher3StatusSet(SQLCIPHER_STATUS_PARSER_STACK,
111521       sqlcipher3ParserStackPeak(pEngine)
111522   );
111523 #endif /* YYDEBUG */
111524   sqlcipher3ParserFree(pEngine, sqlcipher3_free);
111525   db->lookaside.bEnabled = enableLookaside;
111526   if( db->mallocFailed ){
111527     pParse->rc = SQLCIPHER_NOMEM;
111528   }
111529   if( pParse->rc!=SQLCIPHER_OK && pParse->rc!=SQLCIPHER_DONE && pParse->zErrMsg==0 ){
111530     sqlcipher3SetString(&pParse->zErrMsg, db, "%s", sqlcipher3ErrStr(pParse->rc));
111531   }
111532   assert( pzErrMsg!=0 );
111533   if( pParse->zErrMsg ){
111534     *pzErrMsg = pParse->zErrMsg;
111535     sqlcipher3_log(pParse->rc, "%s", *pzErrMsg);
111536     pParse->zErrMsg = 0;
111537     nErr++;
111538   }
111539   if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
111540     sqlcipher3VdbeDelete(pParse->pVdbe);
111541     pParse->pVdbe = 0;
111542   }
111543 #ifndef SQLCIPHER_OMIT_SHARED_CACHE
111544   if( pParse->nested==0 ){
111545     sqlcipher3DbFree(db, pParse->aTableLock);
111546     pParse->aTableLock = 0;
111547     pParse->nTableLock = 0;
111548   }
111549 #endif
111550 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
111551   sqlcipher3_free(pParse->apVtabLock);
111552 #endif
111553
111554   if( !IN_DECLARE_VTAB ){
111555     /* If the pParse->declareVtab flag is set, do not delete any table 
111556     ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
111557     ** will take responsibility for freeing the Table structure.
111558     */
111559     sqlcipher3DeleteTable(db, pParse->pNewTable);
111560   }
111561
111562   sqlcipher3DeleteTrigger(db, pParse->pNewTrigger);
111563   for(i=pParse->nzVar-1; i>=0; i--) sqlcipher3DbFree(db, pParse->azVar[i]);
111564   sqlcipher3DbFree(db, pParse->azVar);
111565   sqlcipher3DbFree(db, pParse->aAlias);
111566   while( pParse->pAinc ){
111567     AutoincInfo *p = pParse->pAinc;
111568     pParse->pAinc = p->pNext;
111569     sqlcipher3DbFree(db, p);
111570   }
111571   while( pParse->pZombieTab ){
111572     Table *p = pParse->pZombieTab;
111573     pParse->pZombieTab = p->pNextZombie;
111574     sqlcipher3DeleteTable(db, p);
111575   }
111576   if( nErr>0 && pParse->rc==SQLCIPHER_OK ){
111577     pParse->rc = SQLCIPHER_ERROR;
111578   }
111579   return nErr;
111580 }
111581
111582 /************** End of tokenize.c ********************************************/
111583 /************** Begin file complete.c ****************************************/
111584 /*
111585 ** 2001 September 15
111586 **
111587 ** The author disclaims copyright to this source code.  In place of
111588 ** a legal notice, here is a blessing:
111589 **
111590 **    May you do good and not evil.
111591 **    May you find forgiveness for yourself and forgive others.
111592 **    May you share freely, never taking more than you give.
111593 **
111594 *************************************************************************
111595 ** An tokenizer for SQL
111596 **
111597 ** This file contains C code that implements the sqlcipher3_complete() API.
111598 ** This code used to be part of the tokenizer.c source file.  But by
111599 ** separating it out, the code will be automatically omitted from
111600 ** static links that do not use it.
111601 */
111602 #ifndef SQLCIPHER_OMIT_COMPLETE
111603
111604 /*
111605 ** This is defined in tokenize.c.  We just have to import the definition.
111606 */
111607 #ifndef SQLCIPHER_AMALGAMATION
111608 #ifdef SQLCIPHER_ASCII
111609 #define IdChar(C)  ((sqlcipher3CtypeMap[(unsigned char)C]&0x46)!=0)
111610 #endif
111611 #ifdef SQLCIPHER_EBCDIC
111612 SQLCIPHER_PRIVATE const char sqlcipher3IsEbcdicIdChar[];
111613 #define IdChar(C)  (((c=C)>=0x42 && sqlcipher3IsEbcdicIdChar[c-0x40]))
111614 #endif
111615 #endif /* SQLCIPHER_AMALGAMATION */
111616
111617
111618 /*
111619 ** Token types used by the sqlcipher3_complete() routine.  See the header
111620 ** comments on that procedure for additional information.
111621 */
111622 #define tkSEMI    0
111623 #define tkWS      1
111624 #define tkOTHER   2
111625 #ifndef SQLCIPHER_OMIT_TRIGGER
111626 #define tkEXPLAIN 3
111627 #define tkCREATE  4
111628 #define tkTEMP    5
111629 #define tkTRIGGER 6
111630 #define tkEND     7
111631 #endif
111632
111633 /*
111634 ** Return TRUE if the given SQL string ends in a semicolon.
111635 **
111636 ** Special handling is require for CREATE TRIGGER statements.
111637 ** Whenever the CREATE TRIGGER keywords are seen, the statement
111638 ** must end with ";END;".
111639 **
111640 ** This implementation uses a state machine with 8 states:
111641 **
111642 **   (0) INVALID   We have not yet seen a non-whitespace character.
111643 **
111644 **   (1) START     At the beginning or end of an SQL statement.  This routine
111645 **                 returns 1 if it ends in the START state and 0 if it ends
111646 **                 in any other state.
111647 **
111648 **   (2) NORMAL    We are in the middle of statement which ends with a single
111649 **                 semicolon.
111650 **
111651 **   (3) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of 
111652 **                 a statement.
111653 **
111654 **   (4) CREATE    The keyword CREATE has been seen at the beginning of a
111655 **                 statement, possibly preceeded by EXPLAIN and/or followed by
111656 **                 TEMP or TEMPORARY
111657 **
111658 **   (5) TRIGGER   We are in the middle of a trigger definition that must be
111659 **                 ended by a semicolon, the keyword END, and another semicolon.
111660 **
111661 **   (6) SEMI      We've seen the first semicolon in the ";END;" that occurs at
111662 **                 the end of a trigger definition.
111663 **
111664 **   (7) END       We've seen the ";END" of the ";END;" that occurs at the end
111665 **                 of a trigger difinition.
111666 **
111667 ** Transitions between states above are determined by tokens extracted
111668 ** from the input.  The following tokens are significant:
111669 **
111670 **   (0) tkSEMI      A semicolon.
111671 **   (1) tkWS        Whitespace.
111672 **   (2) tkOTHER     Any other SQL token.
111673 **   (3) tkEXPLAIN   The "explain" keyword.
111674 **   (4) tkCREATE    The "create" keyword.
111675 **   (5) tkTEMP      The "temp" or "temporary" keyword.
111676 **   (6) tkTRIGGER   The "trigger" keyword.
111677 **   (7) tkEND       The "end" keyword.
111678 **
111679 ** Whitespace never causes a state transition and is always ignored.
111680 ** This means that a SQL string of all whitespace is invalid.
111681 **
111682 ** If we compile with SQLCIPHER_OMIT_TRIGGER, all of the computation needed
111683 ** to recognize the end of a trigger can be omitted.  All we have to do
111684 ** is look for a semicolon that is not part of an string or comment.
111685 */
111686 SQLCIPHER_API int sqlcipher3_complete(const char *zSql){
111687   u8 state = 0;   /* Current state, using numbers defined in header comment */
111688   u8 token;       /* Value of the next token */
111689
111690 #ifndef SQLCIPHER_OMIT_TRIGGER
111691   /* A complex statement machine used to detect the end of a CREATE TRIGGER
111692   ** statement.  This is the normal case.
111693   */
111694   static const u8 trans[8][8] = {
111695                      /* Token:                                                */
111696      /* State:       **  SEMI  WS  OTHER  EXPLAIN  CREATE  TEMP  TRIGGER  END */
111697      /* 0 INVALID: */ {    1,  0,     2,       3,      4,    2,       2,   2, },
111698      /* 1   START: */ {    1,  1,     2,       3,      4,    2,       2,   2, },
111699      /* 2  NORMAL: */ {    1,  2,     2,       2,      2,    2,       2,   2, },
111700      /* 3 EXPLAIN: */ {    1,  3,     3,       2,      4,    2,       2,   2, },
111701      /* 4  CREATE: */ {    1,  4,     2,       2,      2,    4,       5,   2, },
111702      /* 5 TRIGGER: */ {    6,  5,     5,       5,      5,    5,       5,   5, },
111703      /* 6    SEMI: */ {    6,  6,     5,       5,      5,    5,       5,   7, },
111704      /* 7     END: */ {    1,  7,     5,       5,      5,    5,       5,   5, },
111705   };
111706 #else
111707   /* If triggers are not supported by this compile then the statement machine
111708   ** used to detect the end of a statement is much simplier
111709   */
111710   static const u8 trans[3][3] = {
111711                      /* Token:           */
111712      /* State:       **  SEMI  WS  OTHER */
111713      /* 0 INVALID: */ {    1,  0,     2, },
111714      /* 1   START: */ {    1,  1,     2, },
111715      /* 2  NORMAL: */ {    1,  2,     2, },
111716   };
111717 #endif /* SQLCIPHER_OMIT_TRIGGER */
111718
111719   while( *zSql ){
111720     switch( *zSql ){
111721       case ';': {  /* A semicolon */
111722         token = tkSEMI;
111723         break;
111724       }
111725       case ' ':
111726       case '\r':
111727       case '\t':
111728       case '\n':
111729       case '\f': {  /* White space is ignored */
111730         token = tkWS;
111731         break;
111732       }
111733       case '/': {   /* C-style comments */
111734         if( zSql[1]!='*' ){
111735           token = tkOTHER;
111736           break;
111737         }
111738         zSql += 2;
111739         while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
111740         if( zSql[0]==0 ) return 0;
111741         zSql++;
111742         token = tkWS;
111743         break;
111744       }
111745       case '-': {   /* SQL-style comments from "--" to end of line */
111746         if( zSql[1]!='-' ){
111747           token = tkOTHER;
111748           break;
111749         }
111750         while( *zSql && *zSql!='\n' ){ zSql++; }
111751         if( *zSql==0 ) return state==1;
111752         token = tkWS;
111753         break;
111754       }
111755       case '[': {   /* Microsoft-style identifiers in [...] */
111756         zSql++;
111757         while( *zSql && *zSql!=']' ){ zSql++; }
111758         if( *zSql==0 ) return 0;
111759         token = tkOTHER;
111760         break;
111761       }
111762       case '`':     /* Grave-accent quoted symbols used by MySQL */
111763       case '"':     /* single- and double-quoted strings */
111764       case '\'': {
111765         int c = *zSql;
111766         zSql++;
111767         while( *zSql && *zSql!=c ){ zSql++; }
111768         if( *zSql==0 ) return 0;
111769         token = tkOTHER;
111770         break;
111771       }
111772       default: {
111773 #ifdef SQLCIPHER_EBCDIC
111774         unsigned char c;
111775 #endif
111776         if( IdChar((u8)*zSql) ){
111777           /* Keywords and unquoted identifiers */
111778           int nId;
111779           for(nId=1; IdChar(zSql[nId]); nId++){}
111780 #ifdef SQLCIPHER_OMIT_TRIGGER
111781           token = tkOTHER;
111782 #else
111783           switch( *zSql ){
111784             case 'c': case 'C': {
111785               if( nId==6 && sqlcipher3StrNICmp(zSql, "create", 6)==0 ){
111786                 token = tkCREATE;
111787               }else{
111788                 token = tkOTHER;
111789               }
111790               break;
111791             }
111792             case 't': case 'T': {
111793               if( nId==7 && sqlcipher3StrNICmp(zSql, "trigger", 7)==0 ){
111794                 token = tkTRIGGER;
111795               }else if( nId==4 && sqlcipher3StrNICmp(zSql, "temp", 4)==0 ){
111796                 token = tkTEMP;
111797               }else if( nId==9 && sqlcipher3StrNICmp(zSql, "temporary", 9)==0 ){
111798                 token = tkTEMP;
111799               }else{
111800                 token = tkOTHER;
111801               }
111802               break;
111803             }
111804             case 'e':  case 'E': {
111805               if( nId==3 && sqlcipher3StrNICmp(zSql, "end", 3)==0 ){
111806                 token = tkEND;
111807               }else
111808 #ifndef SQLCIPHER_OMIT_EXPLAIN
111809               if( nId==7 && sqlcipher3StrNICmp(zSql, "explain", 7)==0 ){
111810                 token = tkEXPLAIN;
111811               }else
111812 #endif
111813               {
111814                 token = tkOTHER;
111815               }
111816               break;
111817             }
111818             default: {
111819               token = tkOTHER;
111820               break;
111821             }
111822           }
111823 #endif /* SQLCIPHER_OMIT_TRIGGER */
111824           zSql += nId-1;
111825         }else{
111826           /* Operators and special symbols */
111827           token = tkOTHER;
111828         }
111829         break;
111830       }
111831     }
111832     state = trans[state][token];
111833     zSql++;
111834   }
111835   return state==1;
111836 }
111837
111838 #ifndef SQLCIPHER_OMIT_UTF16
111839 /*
111840 ** This routine is the same as the sqlcipher3_complete() routine described
111841 ** above, except that the parameter is required to be UTF-16 encoded, not
111842 ** UTF-8.
111843 */
111844 SQLCIPHER_API int sqlcipher3_complete16(const void *zSql){
111845   sqlcipher3_value *pVal;
111846   char const *zSql8;
111847   int rc = SQLCIPHER_NOMEM;
111848
111849 #ifndef SQLCIPHER_OMIT_AUTOINIT
111850   rc = sqlcipher3_initialize();
111851   if( rc ) return rc;
111852 #endif
111853   pVal = sqlcipher3ValueNew(0);
111854   sqlcipher3ValueSetStr(pVal, -1, zSql, SQLCIPHER_UTF16NATIVE, SQLCIPHER_STATIC);
111855   zSql8 = sqlcipher3ValueText(pVal, SQLCIPHER_UTF8);
111856   if( zSql8 ){
111857     rc = sqlcipher3_complete(zSql8);
111858   }else{
111859     rc = SQLCIPHER_NOMEM;
111860   }
111861   sqlcipher3ValueFree(pVal);
111862   return sqlcipher3ApiExit(0, rc);
111863 }
111864 #endif /* SQLCIPHER_OMIT_UTF16 */
111865 #endif /* SQLCIPHER_OMIT_COMPLETE */
111866
111867 /************** End of complete.c ********************************************/
111868 /************** Begin file main.c ********************************************/
111869 /*
111870 ** 2001 September 15
111871 **
111872 ** The author disclaims copyright to this source code.  In place of
111873 ** a legal notice, here is a blessing:
111874 **
111875 **    May you do good and not evil.
111876 **    May you find forgiveness for yourself and forgive others.
111877 **    May you share freely, never taking more than you give.
111878 **
111879 *************************************************************************
111880 ** Main file for the SQLite library.  The routines in this file
111881 ** implement the programmer interface to the library.  Routines in
111882 ** other files are for internal use by SQLite and should not be
111883 ** accessed by users of the library.
111884 */
111885
111886 #ifdef SQLCIPHER_ENABLE_FTS3
111887 /************** Include fts3.h in the middle of main.c ***********************/
111888 /************** Begin file fts3.h ********************************************/
111889 /*
111890 ** 2006 Oct 10
111891 **
111892 ** The author disclaims copyright to this source code.  In place of
111893 ** a legal notice, here is a blessing:
111894 **
111895 **    May you do good and not evil.
111896 **    May you find forgiveness for yourself and forgive others.
111897 **    May you share freely, never taking more than you give.
111898 **
111899 ******************************************************************************
111900 **
111901 ** This header file is used by programs that want to link against the
111902 ** FTS3 library.  All it does is declare the sqlcipher3Fts3Init() interface.
111903 */
111904
111905 #if 0
111906 extern "C" {
111907 #endif  /* __cplusplus */
111908
111909 SQLCIPHER_PRIVATE int sqlcipher3Fts3Init(sqlcipher3 *db);
111910
111911 #if 0
111912 }  /* extern "C" */
111913 #endif  /* __cplusplus */
111914
111915 /************** End of fts3.h ************************************************/
111916 /************** Continuing where we left off in main.c ***********************/
111917 #endif
111918 #ifdef SQLCIPHER_ENABLE_RTREE
111919 /************** Include rtree.h in the middle of main.c **********************/
111920 /************** Begin file rtree.h *******************************************/
111921 /*
111922 ** 2008 May 26
111923 **
111924 ** The author disclaims copyright to this source code.  In place of
111925 ** a legal notice, here is a blessing:
111926 **
111927 **    May you do good and not evil.
111928 **    May you find forgiveness for yourself and forgive others.
111929 **    May you share freely, never taking more than you give.
111930 **
111931 ******************************************************************************
111932 **
111933 ** This header file is used by programs that want to link against the
111934 ** RTREE library.  All it does is declare the sqlcipher3RtreeInit() interface.
111935 */
111936
111937 #if 0
111938 extern "C" {
111939 #endif  /* __cplusplus */
111940
111941 SQLCIPHER_PRIVATE int sqlcipher3RtreeInit(sqlcipher3 *db);
111942
111943 #if 0
111944 }  /* extern "C" */
111945 #endif  /* __cplusplus */
111946
111947 /************** End of rtree.h ***********************************************/
111948 /************** Continuing where we left off in main.c ***********************/
111949 #endif
111950 #ifdef SQLCIPHER_ENABLE_ICU
111951 /************** Include sqlciphericu.h in the middle of main.c ******************/
111952 /************** Begin file sqlciphericu.h ***************************************/
111953 /*
111954 ** 2008 May 26
111955 **
111956 ** The author disclaims copyright to this source code.  In place of
111957 ** a legal notice, here is a blessing:
111958 **
111959 **    May you do good and not evil.
111960 **    May you find forgiveness for yourself and forgive others.
111961 **    May you share freely, never taking more than you give.
111962 **
111963 ******************************************************************************
111964 **
111965 ** This header file is used by programs that want to link against the
111966 ** ICU extension.  All it does is declare the sqlcipher3IcuInit() interface.
111967 */
111968
111969 #if 0
111970 extern "C" {
111971 #endif  /* __cplusplus */
111972
111973 SQLCIPHER_PRIVATE int sqlcipher3IcuInit(sqlcipher3 *db);
111974
111975 #if 0
111976 }  /* extern "C" */
111977 #endif  /* __cplusplus */
111978
111979
111980 /************** End of sqlciphericu.h *******************************************/
111981 /************** Continuing where we left off in main.c ***********************/
111982 #endif
111983
111984 #ifndef SQLCIPHER_AMALGAMATION
111985 /* IMPLEMENTATION-OF: R-46656-45156 The sqlcipher3_version[] string constant
111986 ** contains the text of SQLCIPHER_VERSION macro. 
111987 */
111988 SQLCIPHER_API const char sqlcipher3_version[] = SQLCIPHER_VERSION;
111989 #endif
111990
111991 /* IMPLEMENTATION-OF: R-53536-42575 The sqlcipher3_libversion() function returns
111992 ** a pointer to the to the sqlcipher3_version[] string constant. 
111993 */
111994 SQLCIPHER_API const char *sqlcipher3_libversion(void){ return sqlcipher3_version; }
111995
111996 /* IMPLEMENTATION-OF: R-63124-39300 The sqlcipher3_sourceid() function returns a
111997 ** pointer to a string constant whose value is the same as the
111998 ** SQLCIPHER_SOURCE_ID C preprocessor macro. 
111999 */
112000 SQLCIPHER_API const char *sqlcipher3_sourceid(void){ return SQLCIPHER_SOURCE_ID; }
112001
112002 /* IMPLEMENTATION-OF: R-35210-63508 The sqlcipher3_libversion_number() function
112003 ** returns an integer equal to SQLCIPHER_VERSION_NUMBER.
112004 */
112005 SQLCIPHER_API int sqlcipher3_libversion_number(void){ return SQLCIPHER_VERSION_NUMBER; }
112006
112007 /* IMPLEMENTATION-OF: R-54823-41343 The sqlcipher3_threadsafe() function returns
112008 ** zero if and only if SQLite was compiled mutexing code omitted due to
112009 ** the SQLCIPHER_THREADSAFE compile-time option being set to 0.
112010 */
112011 SQLCIPHER_API int sqlcipher3_threadsafe(void){ return SQLCIPHER_THREADSAFE; }
112012
112013 #if !defined(SQLCIPHER_OMIT_TRACE) && defined(SQLCIPHER_ENABLE_IOTRACE)
112014 /*
112015 ** If the following function pointer is not NULL and if
112016 ** SQLCIPHER_ENABLE_IOTRACE is enabled, then messages describing
112017 ** I/O active are written using this function.  These messages
112018 ** are intended for debugging activity only.
112019 */
112020 SQLCIPHER_PRIVATE void (*sqlcipher3IoTrace)(const char*, ...) = 0;
112021 #endif
112022
112023 /*
112024 ** If the following global variable points to a string which is the
112025 ** name of a directory, then that directory will be used to store
112026 ** temporary files.
112027 **
112028 ** See also the "PRAGMA temp_store_directory" SQL command.
112029 */
112030 SQLCIPHER_API char *sqlcipher3_temp_directory = 0;
112031
112032 /*
112033 ** Initialize SQLite.  
112034 **
112035 ** This routine must be called to initialize the memory allocation,
112036 ** VFS, and mutex subsystems prior to doing any serious work with
112037 ** SQLite.  But as long as you do not compile with SQLCIPHER_OMIT_AUTOINIT
112038 ** this routine will be called automatically by key routines such as
112039 ** sqlcipher3_open().  
112040 **
112041 ** This routine is a no-op except on its very first call for the process,
112042 ** or for the first call after a call to sqlcipher3_shutdown.
112043 **
112044 ** The first thread to call this routine runs the initialization to
112045 ** completion.  If subsequent threads call this routine before the first
112046 ** thread has finished the initialization process, then the subsequent
112047 ** threads must block until the first thread finishes with the initialization.
112048 **
112049 ** The first thread might call this routine recursively.  Recursive
112050 ** calls to this routine should not block, of course.  Otherwise the
112051 ** initialization process would never complete.
112052 **
112053 ** Let X be the first thread to enter this routine.  Let Y be some other
112054 ** thread.  Then while the initial invocation of this routine by X is
112055 ** incomplete, it is required that:
112056 **
112057 **    *  Calls to this routine from Y must block until the outer-most
112058 **       call by X completes.
112059 **
112060 **    *  Recursive calls to this routine from thread X return immediately
112061 **       without blocking.
112062 */
112063 SQLCIPHER_API int sqlcipher3_initialize(void){
112064   MUTEX_LOGIC( sqlcipher3_mutex *pMaster; )       /* The main static mutex */
112065   int rc;                                      /* Result code */
112066
112067 #ifdef SQLCIPHER_OMIT_WSD
112068   rc = sqlcipher3_wsd_init(4096, 24);
112069   if( rc!=SQLCIPHER_OK ){
112070     return rc;
112071   }
112072 #endif
112073
112074   /* If SQLite is already completely initialized, then this call
112075   ** to sqlcipher3_initialize() should be a no-op.  But the initialization
112076   ** must be complete.  So isInit must not be set until the very end
112077   ** of this routine.
112078   */
112079   if( sqlcipher3GlobalConfig.isInit ) return SQLCIPHER_OK;
112080
112081   /* Make sure the mutex subsystem is initialized.  If unable to 
112082   ** initialize the mutex subsystem, return early with the error.
112083   ** If the system is so sick that we are unable to allocate a mutex,
112084   ** there is not much SQLite is going to be able to do.
112085   **
112086   ** The mutex subsystem must take care of serializing its own
112087   ** initialization.
112088   */
112089   rc = sqlcipher3MutexInit();
112090   if( rc ) return rc;
112091
112092   /* Initialize the malloc() system and the recursive pInitMutex mutex.
112093   ** This operation is protected by the STATIC_MASTER mutex.  Note that
112094   ** MutexAlloc() is called for a static mutex prior to initializing the
112095   ** malloc subsystem - this implies that the allocation of a static
112096   ** mutex must not require support from the malloc subsystem.
112097   */
112098   MUTEX_LOGIC( pMaster = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER); )
112099   sqlcipher3_mutex_enter(pMaster);
112100   sqlcipher3GlobalConfig.isMutexInit = 1;
112101   if( !sqlcipher3GlobalConfig.isMallocInit ){
112102     rc = sqlcipher3MallocInit();
112103   }
112104   if( rc==SQLCIPHER_OK ){
112105     sqlcipher3GlobalConfig.isMallocInit = 1;
112106     if( !sqlcipher3GlobalConfig.pInitMutex ){
112107       sqlcipher3GlobalConfig.pInitMutex =
112108            sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_RECURSIVE);
112109       if( sqlcipher3GlobalConfig.bCoreMutex && !sqlcipher3GlobalConfig.pInitMutex ){
112110         rc = SQLCIPHER_NOMEM;
112111       }
112112     }
112113   }
112114   if( rc==SQLCIPHER_OK ){
112115     sqlcipher3GlobalConfig.nRefInitMutex++;
112116   }
112117   sqlcipher3_mutex_leave(pMaster);
112118
112119   /* If rc is not SQLCIPHER_OK at this point, then either the malloc
112120   ** subsystem could not be initialized or the system failed to allocate
112121   ** the pInitMutex mutex. Return an error in either case.  */
112122   if( rc!=SQLCIPHER_OK ){
112123     return rc;
112124   }
112125
112126   /* Do the rest of the initialization under the recursive mutex so
112127   ** that we will be able to handle recursive calls into
112128   ** sqlcipher3_initialize().  The recursive calls normally come through
112129   ** sqlcipher3_os_init() when it invokes sqlcipher3_vfs_register(), but other
112130   ** recursive calls might also be possible.
112131   **
112132   ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
112133   ** to the xInit method, so the xInit method need not be threadsafe.
112134   **
112135   ** The following mutex is what serializes access to the appdef pcache xInit
112136   ** methods.  The sqlcipher3_pcache_methods.xInit() all is embedded in the
112137   ** call to sqlcipher3PcacheInitialize().
112138   */
112139   sqlcipher3_mutex_enter(sqlcipher3GlobalConfig.pInitMutex);
112140   if( sqlcipher3GlobalConfig.isInit==0 && sqlcipher3GlobalConfig.inProgress==0 ){
112141     FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlcipher3GlobalFunctions);
112142     sqlcipher3GlobalConfig.inProgress = 1;
112143     memset(pHash, 0, sizeof(sqlcipher3GlobalFunctions));
112144     sqlcipher3RegisterGlobalFunctions();
112145     if( sqlcipher3GlobalConfig.isPCacheInit==0 ){
112146       rc = sqlcipher3PcacheInitialize();
112147     }
112148     if( rc==SQLCIPHER_OK ){
112149       sqlcipher3GlobalConfig.isPCacheInit = 1;
112150       rc = sqlcipher3OsInit();
112151     }
112152     if( rc==SQLCIPHER_OK ){
112153       sqlcipher3PCacheBufferSetup( sqlcipher3GlobalConfig.pPage, 
112154           sqlcipher3GlobalConfig.szPage, sqlcipher3GlobalConfig.nPage);
112155       sqlcipher3GlobalConfig.isInit = 1;
112156     }
112157     sqlcipher3GlobalConfig.inProgress = 0;
112158   }
112159   sqlcipher3_mutex_leave(sqlcipher3GlobalConfig.pInitMutex);
112160
112161   /* Go back under the static mutex and clean up the recursive
112162   ** mutex to prevent a resource leak.
112163   */
112164   sqlcipher3_mutex_enter(pMaster);
112165   sqlcipher3GlobalConfig.nRefInitMutex--;
112166   if( sqlcipher3GlobalConfig.nRefInitMutex<=0 ){
112167     assert( sqlcipher3GlobalConfig.nRefInitMutex==0 );
112168     sqlcipher3_mutex_free(sqlcipher3GlobalConfig.pInitMutex);
112169     sqlcipher3GlobalConfig.pInitMutex = 0;
112170   }
112171   sqlcipher3_mutex_leave(pMaster);
112172
112173   /* The following is just a sanity check to make sure SQLite has
112174   ** been compiled correctly.  It is important to run this code, but
112175   ** we don't want to run it too often and soak up CPU cycles for no
112176   ** reason.  So we run it once during initialization.
112177   */
112178 #ifndef NDEBUG
112179 #ifndef SQLCIPHER_OMIT_FLOATING_POINT
112180   /* This section of code's only "output" is via assert() statements. */
112181   if ( rc==SQLCIPHER_OK ){
112182     u64 x = (((u64)1)<<63)-1;
112183     double y;
112184     assert(sizeof(x)==8);
112185     assert(sizeof(x)==sizeof(y));
112186     memcpy(&y, &x, 8);
112187     assert( sqlcipher3IsNaN(y) );
112188   }
112189 #endif
112190 #endif
112191
112192   /* Do extra initialization steps requested by the SQLCIPHER_EXTRA_INIT
112193   ** compile-time option.
112194   */
112195 #ifdef SQLCIPHER_EXTRA_INIT
112196   if( rc==SQLCIPHER_OK && sqlcipher3GlobalConfig.isInit ){
112197     int SQLCIPHER_EXTRA_INIT(void);
112198     rc = SQLCIPHER_EXTRA_INIT();
112199   }
112200 #endif
112201
112202   return rc;
112203 }
112204
112205 /*
112206 ** Undo the effects of sqlcipher3_initialize().  Must not be called while
112207 ** there are outstanding database connections or memory allocations or
112208 ** while any part of SQLite is otherwise in use in any thread.  This
112209 ** routine is not threadsafe.  But it is safe to invoke this routine
112210 ** on when SQLite is already shut down.  If SQLite is already shut down
112211 ** when this routine is invoked, then this routine is a harmless no-op.
112212 */
112213 SQLCIPHER_API int sqlcipher3_shutdown(void){
112214   if( sqlcipher3GlobalConfig.isInit ){
112215     sqlcipher3_os_end();
112216     sqlcipher3_reset_auto_extension();
112217     sqlcipher3GlobalConfig.isInit = 0;
112218   }
112219   if( sqlcipher3GlobalConfig.isPCacheInit ){
112220     sqlcipher3PcacheShutdown();
112221     sqlcipher3GlobalConfig.isPCacheInit = 0;
112222   }
112223   if( sqlcipher3GlobalConfig.isMallocInit ){
112224     sqlcipher3MallocEnd();
112225     sqlcipher3GlobalConfig.isMallocInit = 0;
112226   }
112227   if( sqlcipher3GlobalConfig.isMutexInit ){
112228     sqlcipher3MutexEnd();
112229     sqlcipher3GlobalConfig.isMutexInit = 0;
112230   }
112231
112232   return SQLCIPHER_OK;
112233 }
112234
112235 /*
112236 ** This API allows applications to modify the global configuration of
112237 ** the SQLite library at run-time.
112238 **
112239 ** This routine should only be called when there are no outstanding
112240 ** database connections or memory allocations.  This routine is not
112241 ** threadsafe.  Failure to heed these warnings can lead to unpredictable
112242 ** behavior.
112243 */
112244 SQLCIPHER_API int sqlcipher3_config(int op, ...){
112245   va_list ap;
112246   int rc = SQLCIPHER_OK;
112247
112248   /* sqlcipher3_config() shall return SQLCIPHER_MISUSE if it is invoked while
112249   ** the SQLite library is in use. */
112250   if( sqlcipher3GlobalConfig.isInit ) return SQLCIPHER_MISUSE_BKPT;
112251
112252   va_start(ap, op);
112253   switch( op ){
112254
112255     /* Mutex configuration options are only available in a threadsafe
112256     ** compile. 
112257     */
112258 #if defined(SQLCIPHER_THREADSAFE) && SQLCIPHER_THREADSAFE>0
112259     case SQLCIPHER_CONFIG_SINGLETHREAD: {
112260       /* Disable all mutexing */
112261       sqlcipher3GlobalConfig.bCoreMutex = 0;
112262       sqlcipher3GlobalConfig.bFullMutex = 0;
112263       break;
112264     }
112265     case SQLCIPHER_CONFIG_MULTITHREAD: {
112266       /* Disable mutexing of database connections */
112267       /* Enable mutexing of core data structures */
112268       sqlcipher3GlobalConfig.bCoreMutex = 1;
112269       sqlcipher3GlobalConfig.bFullMutex = 0;
112270       break;
112271     }
112272     case SQLCIPHER_CONFIG_SERIALIZED: {
112273       /* Enable all mutexing */
112274       sqlcipher3GlobalConfig.bCoreMutex = 1;
112275       sqlcipher3GlobalConfig.bFullMutex = 1;
112276       break;
112277     }
112278     case SQLCIPHER_CONFIG_MUTEX: {
112279       /* Specify an alternative mutex implementation */
112280       sqlcipher3GlobalConfig.mutex = *va_arg(ap, sqlcipher3_mutex_methods*);
112281       break;
112282     }
112283     case SQLCIPHER_CONFIG_GETMUTEX: {
112284       /* Retrieve the current mutex implementation */
112285       *va_arg(ap, sqlcipher3_mutex_methods*) = sqlcipher3GlobalConfig.mutex;
112286       break;
112287     }
112288 #endif
112289
112290
112291     case SQLCIPHER_CONFIG_MALLOC: {
112292       /* Specify an alternative malloc implementation */
112293       sqlcipher3GlobalConfig.m = *va_arg(ap, sqlcipher3_mem_methods*);
112294       break;
112295     }
112296     case SQLCIPHER_CONFIG_GETMALLOC: {
112297       /* Retrieve the current malloc() implementation */
112298       if( sqlcipher3GlobalConfig.m.xMalloc==0 ) sqlcipher3MemSetDefault();
112299       *va_arg(ap, sqlcipher3_mem_methods*) = sqlcipher3GlobalConfig.m;
112300       break;
112301     }
112302     case SQLCIPHER_CONFIG_MEMSTATUS: {
112303       /* Enable or disable the malloc status collection */
112304       sqlcipher3GlobalConfig.bMemstat = va_arg(ap, int);
112305       break;
112306     }
112307     case SQLCIPHER_CONFIG_SCRATCH: {
112308       /* Designate a buffer for scratch memory space */
112309       sqlcipher3GlobalConfig.pScratch = va_arg(ap, void*);
112310       sqlcipher3GlobalConfig.szScratch = va_arg(ap, int);
112311       sqlcipher3GlobalConfig.nScratch = va_arg(ap, int);
112312       break;
112313     }
112314     case SQLCIPHER_CONFIG_PAGECACHE: {
112315       /* Designate a buffer for page cache memory space */
112316       sqlcipher3GlobalConfig.pPage = va_arg(ap, void*);
112317       sqlcipher3GlobalConfig.szPage = va_arg(ap, int);
112318       sqlcipher3GlobalConfig.nPage = va_arg(ap, int);
112319       break;
112320     }
112321
112322     case SQLCIPHER_CONFIG_PCACHE: {
112323       /* Specify an alternative page cache implementation */
112324       sqlcipher3GlobalConfig.pcache = *va_arg(ap, sqlcipher3_pcache_methods*);
112325       break;
112326     }
112327
112328     case SQLCIPHER_CONFIG_GETPCACHE: {
112329       if( sqlcipher3GlobalConfig.pcache.xInit==0 ){
112330         sqlcipher3PCacheSetDefault();
112331       }
112332       *va_arg(ap, sqlcipher3_pcache_methods*) = sqlcipher3GlobalConfig.pcache;
112333       break;
112334     }
112335
112336 #if defined(SQLCIPHER_ENABLE_MEMSYS3) || defined(SQLCIPHER_ENABLE_MEMSYS5)
112337     case SQLCIPHER_CONFIG_HEAP: {
112338       /* Designate a buffer for heap memory space */
112339       sqlcipher3GlobalConfig.pHeap = va_arg(ap, void*);
112340       sqlcipher3GlobalConfig.nHeap = va_arg(ap, int);
112341       sqlcipher3GlobalConfig.mnReq = va_arg(ap, int);
112342
112343       if( sqlcipher3GlobalConfig.mnReq<1 ){
112344         sqlcipher3GlobalConfig.mnReq = 1;
112345       }else if( sqlcipher3GlobalConfig.mnReq>(1<<12) ){
112346         /* cap min request size at 2^12 */
112347         sqlcipher3GlobalConfig.mnReq = (1<<12);
112348       }
112349
112350       if( sqlcipher3GlobalConfig.pHeap==0 ){
112351         /* If the heap pointer is NULL, then restore the malloc implementation
112352         ** back to NULL pointers too.  This will cause the malloc to go
112353         ** back to its default implementation when sqlcipher3_initialize() is
112354         ** run.
112355         */
112356         memset(&sqlcipher3GlobalConfig.m, 0, sizeof(sqlcipher3GlobalConfig.m));
112357       }else{
112358         /* The heap pointer is not NULL, then install one of the
112359         ** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor
112360         ** ENABLE_MEMSYS5 is defined, return an error.
112361         */
112362 #ifdef SQLCIPHER_ENABLE_MEMSYS3
112363         sqlcipher3GlobalConfig.m = *sqlcipher3MemGetMemsys3();
112364 #endif
112365 #ifdef SQLCIPHER_ENABLE_MEMSYS5
112366         sqlcipher3GlobalConfig.m = *sqlcipher3MemGetMemsys5();
112367 #endif
112368       }
112369       break;
112370     }
112371 #endif
112372
112373     case SQLCIPHER_CONFIG_LOOKASIDE: {
112374       sqlcipher3GlobalConfig.szLookaside = va_arg(ap, int);
112375       sqlcipher3GlobalConfig.nLookaside = va_arg(ap, int);
112376       break;
112377     }
112378     
112379     /* Record a pointer to the logger funcction and its first argument.
112380     ** The default is NULL.  Logging is disabled if the function pointer is
112381     ** NULL.
112382     */
112383     case SQLCIPHER_CONFIG_LOG: {
112384       /* MSVC is picky about pulling func ptrs from va lists.
112385       ** http://support.microsoft.com/kb/47961
112386       ** sqlcipher3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
112387       */
112388       typedef void(*LOGFUNC_t)(void*,int,const char*);
112389       sqlcipher3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
112390       sqlcipher3GlobalConfig.pLogArg = va_arg(ap, void*);
112391       break;
112392     }
112393
112394     case SQLCIPHER_CONFIG_URI: {
112395       sqlcipher3GlobalConfig.bOpenUri = va_arg(ap, int);
112396       break;
112397     }
112398
112399     default: {
112400       rc = SQLCIPHER_ERROR;
112401       break;
112402     }
112403   }
112404   va_end(ap);
112405   return rc;
112406 }
112407
112408 /*
112409 ** Set up the lookaside buffers for a database connection.
112410 ** Return SQLCIPHER_OK on success.  
112411 ** If lookaside is already active, return SQLCIPHER_BUSY.
112412 **
112413 ** The sz parameter is the number of bytes in each lookaside slot.
112414 ** The cnt parameter is the number of slots.  If pStart is NULL the
112415 ** space for the lookaside memory is obtained from sqlcipher3_malloc().
112416 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
112417 ** the lookaside memory.
112418 */
112419 static int setupLookaside(sqlcipher3 *db, void *pBuf, int sz, int cnt){
112420   void *pStart;
112421   if( db->lookaside.nOut ){
112422     return SQLCIPHER_BUSY;
112423   }
112424   /* Free any existing lookaside buffer for this handle before
112425   ** allocating a new one so we don't have to have space for 
112426   ** both at the same time.
112427   */
112428   if( db->lookaside.bMalloced ){
112429     sqlcipher3_free(db->lookaside.pStart);
112430   }
112431   /* The size of a lookaside slot needs to be larger than a pointer
112432   ** to be useful.
112433   */
112434   if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
112435   if( cnt<0 ) cnt = 0;
112436   if( sz==0 || cnt==0 ){
112437     sz = 0;
112438     pStart = 0;
112439   }else if( pBuf==0 ){
112440     sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */
112441     sqlcipher3BeginBenignMalloc();
112442     pStart = sqlcipher3Malloc( sz*cnt );  /* IMP: R-61949-35727 */
112443     sqlcipher3EndBenignMalloc();
112444   }else{
112445     sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */
112446     pStart = pBuf;
112447   }
112448   db->lookaside.pStart = pStart;
112449   db->lookaside.pFree = 0;
112450   db->lookaside.sz = (u16)sz;
112451   if( pStart ){
112452     int i;
112453     LookasideSlot *p;
112454     assert( sz > (int)sizeof(LookasideSlot*) );
112455     p = (LookasideSlot*)pStart;
112456     for(i=cnt-1; i>=0; i--){
112457       p->pNext = db->lookaside.pFree;
112458       db->lookaside.pFree = p;
112459       p = (LookasideSlot*)&((u8*)p)[sz];
112460     }
112461     db->lookaside.pEnd = p;
112462     db->lookaside.bEnabled = 1;
112463     db->lookaside.bMalloced = pBuf==0 ?1:0;
112464   }else{
112465     db->lookaside.pEnd = 0;
112466     db->lookaside.bEnabled = 0;
112467     db->lookaside.bMalloced = 0;
112468   }
112469   return SQLCIPHER_OK;
112470 }
112471
112472 /*
112473 ** Return the mutex associated with a database connection.
112474 */
112475 SQLCIPHER_API sqlcipher3_mutex *sqlcipher3_db_mutex(sqlcipher3 *db){
112476   return db->mutex;
112477 }
112478
112479 /*
112480 ** Configuration settings for an individual database connection
112481 */
112482 SQLCIPHER_API int sqlcipher3_db_config(sqlcipher3 *db, int op, ...){
112483   va_list ap;
112484   int rc;
112485   va_start(ap, op);
112486   switch( op ){
112487     case SQLCIPHER_DBCONFIG_LOOKASIDE: {
112488       void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
112489       int sz = va_arg(ap, int);       /* IMP: R-47871-25994 */
112490       int cnt = va_arg(ap, int);      /* IMP: R-04460-53386 */
112491       rc = setupLookaside(db, pBuf, sz, cnt);
112492       break;
112493     }
112494     default: {
112495       static const struct {
112496         int op;      /* The opcode */
112497         u32 mask;    /* Mask of the bit in sqlcipher3.flags to set/clear */
112498       } aFlagOp[] = {
112499         { SQLCIPHER_DBCONFIG_ENABLE_FKEY,    SQLCIPHER_ForeignKeys    },
112500         { SQLCIPHER_DBCONFIG_ENABLE_TRIGGER, SQLCIPHER_EnableTrigger  },
112501       };
112502       unsigned int i;
112503       rc = SQLCIPHER_ERROR; /* IMP: R-42790-23372 */
112504       for(i=0; i<ArraySize(aFlagOp); i++){
112505         if( aFlagOp[i].op==op ){
112506           int onoff = va_arg(ap, int);
112507           int *pRes = va_arg(ap, int*);
112508           int oldFlags = db->flags;
112509           if( onoff>0 ){
112510             db->flags |= aFlagOp[i].mask;
112511           }else if( onoff==0 ){
112512             db->flags &= ~aFlagOp[i].mask;
112513           }
112514           if( oldFlags!=db->flags ){
112515             sqlcipher3ExpirePreparedStatements(db);
112516           }
112517           if( pRes ){
112518             *pRes = (db->flags & aFlagOp[i].mask)!=0;
112519           }
112520           rc = SQLCIPHER_OK;
112521           break;
112522         }
112523       }
112524       break;
112525     }
112526   }
112527   va_end(ap);
112528   return rc;
112529 }
112530
112531
112532 /*
112533 ** Return true if the buffer z[0..n-1] contains all spaces.
112534 */
112535 static int allSpaces(const char *z, int n){
112536   while( n>0 && z[n-1]==' ' ){ n--; }
112537   return n==0;
112538 }
112539
112540 /*
112541 ** This is the default collating function named "BINARY" which is always
112542 ** available.
112543 **
112544 ** If the padFlag argument is not NULL then space padding at the end
112545 ** of strings is ignored.  This implements the RTRIM collation.
112546 */
112547 static int binCollFunc(
112548   void *padFlag,
112549   int nKey1, const void *pKey1,
112550   int nKey2, const void *pKey2
112551 ){
112552   int rc, n;
112553   n = nKey1<nKey2 ? nKey1 : nKey2;
112554   rc = memcmp(pKey1, pKey2, n);
112555   if( rc==0 ){
112556     if( padFlag
112557      && allSpaces(((char*)pKey1)+n, nKey1-n)
112558      && allSpaces(((char*)pKey2)+n, nKey2-n)
112559     ){
112560       /* Leave rc unchanged at 0 */
112561     }else{
112562       rc = nKey1 - nKey2;
112563     }
112564   }
112565   return rc;
112566 }
112567
112568 /*
112569 ** Another built-in collating sequence: NOCASE. 
112570 **
112571 ** This collating sequence is intended to be used for "case independant
112572 ** comparison". SQLite's knowledge of upper and lower case equivalents
112573 ** extends only to the 26 characters used in the English language.
112574 **
112575 ** At the moment there is only a UTF-8 implementation.
112576 */
112577 static int nocaseCollatingFunc(
112578   void *NotUsed,
112579   int nKey1, const void *pKey1,
112580   int nKey2, const void *pKey2
112581 ){
112582   int r = sqlcipher3StrNICmp(
112583       (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
112584   UNUSED_PARAMETER(NotUsed);
112585   if( 0==r ){
112586     r = nKey1-nKey2;
112587   }
112588   return r;
112589 }
112590
112591 /*
112592 ** Return the ROWID of the most recent insert
112593 */
112594 SQLCIPHER_API sqlcipher_int64 sqlcipher3_last_insert_rowid(sqlcipher3 *db){
112595   return db->lastRowid;
112596 }
112597
112598 /*
112599 ** Return the number of changes in the most recent call to sqlcipher3_exec().
112600 */
112601 SQLCIPHER_API int sqlcipher3_changes(sqlcipher3 *db){
112602   return db->nChange;
112603 }
112604
112605 /*
112606 ** Return the number of changes since the database handle was opened.
112607 */
112608 SQLCIPHER_API int sqlcipher3_total_changes(sqlcipher3 *db){
112609   return db->nTotalChange;
112610 }
112611
112612 /*
112613 ** Close all open savepoints. This function only manipulates fields of the
112614 ** database handle object, it does not close any savepoints that may be open
112615 ** at the b-tree/pager level.
112616 */
112617 SQLCIPHER_PRIVATE void sqlcipher3CloseSavepoints(sqlcipher3 *db){
112618   while( db->pSavepoint ){
112619     Savepoint *pTmp = db->pSavepoint;
112620     db->pSavepoint = pTmp->pNext;
112621     sqlcipher3DbFree(db, pTmp);
112622   }
112623   db->nSavepoint = 0;
112624   db->nStatement = 0;
112625   db->isTransactionSavepoint = 0;
112626 }
112627
112628 /*
112629 ** Invoke the destructor function associated with FuncDef p, if any. Except,
112630 ** if this is not the last copy of the function, do not invoke it. Multiple
112631 ** copies of a single function are created when create_function() is called
112632 ** with SQLCIPHER_ANY as the encoding.
112633 */
112634 static void functionDestroy(sqlcipher3 *db, FuncDef *p){
112635   FuncDestructor *pDestructor = p->pDestructor;
112636   if( pDestructor ){
112637     pDestructor->nRef--;
112638     if( pDestructor->nRef==0 ){
112639       pDestructor->xDestroy(pDestructor->pUserData);
112640       sqlcipher3DbFree(db, pDestructor);
112641     }
112642   }
112643 }
112644
112645 /*
112646 ** Close an existing SQLite database
112647 */
112648 SQLCIPHER_API int sqlcipher3_close(sqlcipher3 *db){
112649   HashElem *i;                    /* Hash table iterator */
112650   int j;
112651
112652   if( !db ){
112653     return SQLCIPHER_OK;
112654   }
112655   if( !sqlcipher3SafetyCheckSickOrOk(db) ){
112656     return SQLCIPHER_MISUSE_BKPT;
112657   }
112658   sqlcipher3_mutex_enter(db->mutex);
112659
112660   /* Force xDestroy calls on all virtual tables */
112661   sqlcipher3ResetInternalSchema(db, -1);
112662
112663   /* If a transaction is open, the ResetInternalSchema() call above
112664   ** will not have called the xDisconnect() method on any virtual
112665   ** tables in the db->aVTrans[] array. The following sqlcipher3VtabRollback()
112666   ** call will do so. We need to do this before the check for active
112667   ** SQL statements below, as the v-table implementation may be storing
112668   ** some prepared statements internally.
112669   */
112670   sqlcipher3VtabRollback(db);
112671
112672   /* If there are any outstanding VMs, return SQLCIPHER_BUSY. */
112673   if( db->pVdbe ){
112674     sqlcipher3Error(db, SQLCIPHER_BUSY, 
112675         "unable to close due to unfinalised statements");
112676     sqlcipher3_mutex_leave(db->mutex);
112677     return SQLCIPHER_BUSY;
112678   }
112679   assert( sqlcipher3SafetyCheckSickOrOk(db) );
112680
112681   for(j=0; j<db->nDb; j++){
112682     Btree *pBt = db->aDb[j].pBt;
112683     if( pBt && sqlcipher3BtreeIsInBackup(pBt) ){
112684       sqlcipher3Error(db, SQLCIPHER_BUSY, 
112685           "unable to close due to unfinished backup operation");
112686       sqlcipher3_mutex_leave(db->mutex);
112687       return SQLCIPHER_BUSY;
112688     }
112689   }
112690
112691   /* Free any outstanding Savepoint structures. */
112692   sqlcipher3CloseSavepoints(db);
112693
112694   for(j=0; j<db->nDb; j++){
112695     struct Db *pDb = &db->aDb[j];
112696     if( pDb->pBt ){
112697       sqlcipher3BtreeClose(pDb->pBt);
112698       pDb->pBt = 0;
112699       if( j!=1 ){
112700         pDb->pSchema = 0;
112701       }
112702     }
112703   }
112704   sqlcipher3ResetInternalSchema(db, -1);
112705
112706   /* Tell the code in notify.c that the connection no longer holds any
112707   ** locks and does not require any further unlock-notify callbacks.
112708   */
112709   sqlcipher3ConnectionClosed(db);
112710
112711   assert( db->nDb<=2 );
112712   assert( db->aDb==db->aDbStatic );
112713   for(j=0; j<ArraySize(db->aFunc.a); j++){
112714     FuncDef *pNext, *pHash, *p;
112715     for(p=db->aFunc.a[j]; p; p=pHash){
112716       pHash = p->pHash;
112717       while( p ){
112718         functionDestroy(db, p);
112719         pNext = p->pNext;
112720         sqlcipher3DbFree(db, p);
112721         p = pNext;
112722       }
112723     }
112724   }
112725   for(i=sqlcipherHashFirst(&db->aCollSeq); i; i=sqlcipherHashNext(i)){
112726     CollSeq *pColl = (CollSeq *)sqlcipherHashData(i);
112727     /* Invoke any destructors registered for collation sequence user data. */
112728     for(j=0; j<3; j++){
112729       if( pColl[j].xDel ){
112730         pColl[j].xDel(pColl[j].pUser);
112731       }
112732     }
112733     sqlcipher3DbFree(db, pColl);
112734   }
112735   sqlcipher3HashClear(&db->aCollSeq);
112736 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
112737   for(i=sqlcipherHashFirst(&db->aModule); i; i=sqlcipherHashNext(i)){
112738     Module *pMod = (Module *)sqlcipherHashData(i);
112739     if( pMod->xDestroy ){
112740       pMod->xDestroy(pMod->pAux);
112741     }
112742     sqlcipher3DbFree(db, pMod);
112743   }
112744   sqlcipher3HashClear(&db->aModule);
112745 #endif
112746
112747   sqlcipher3Error(db, SQLCIPHER_OK, 0); /* Deallocates any cached error strings. */
112748   if( db->pErr ){
112749     sqlcipher3ValueFree(db->pErr);
112750   }
112751   sqlcipher3CloseExtensions(db);
112752
112753   db->magic = SQLCIPHER_MAGIC_ERROR;
112754
112755   /* The temp-database schema is allocated differently from the other schema
112756   ** objects (using sqlcipherMalloc() directly, instead of sqlcipher3BtreeSchema()).
112757   ** So it needs to be freed here. Todo: Why not roll the temp schema into
112758   ** the same sqlcipherMalloc() as the one that allocates the database 
112759   ** structure?
112760   */
112761   sqlcipher3DbFree(db, db->aDb[1].pSchema);
112762   sqlcipher3_mutex_leave(db->mutex);
112763   db->magic = SQLCIPHER_MAGIC_CLOSED;
112764   sqlcipher3_mutex_free(db->mutex);
112765   assert( db->lookaside.nOut==0 );  /* Fails on a lookaside memory leak */
112766   if( db->lookaside.bMalloced ){
112767     sqlcipher3_free(db->lookaside.pStart);
112768   }
112769   sqlcipher3_free(db);
112770   return SQLCIPHER_OK;
112771 }
112772
112773 /*
112774 ** Rollback all database files.
112775 */
112776 SQLCIPHER_PRIVATE void sqlcipher3RollbackAll(sqlcipher3 *db){
112777   int i;
112778   int inTrans = 0;
112779   assert( sqlcipher3_mutex_held(db->mutex) );
112780   sqlcipher3BeginBenignMalloc();
112781   for(i=0; i<db->nDb; i++){
112782     if( db->aDb[i].pBt ){
112783       if( sqlcipher3BtreeIsInTrans(db->aDb[i].pBt) ){
112784         inTrans = 1;
112785       }
112786       sqlcipher3BtreeRollback(db->aDb[i].pBt);
112787       db->aDb[i].inTrans = 0;
112788     }
112789   }
112790   sqlcipher3VtabRollback(db);
112791   sqlcipher3EndBenignMalloc();
112792
112793   if( db->flags&SQLCIPHER_InternChanges ){
112794     sqlcipher3ExpirePreparedStatements(db);
112795     sqlcipher3ResetInternalSchema(db, -1);
112796   }
112797
112798   /* Any deferred constraint violations have now been resolved. */
112799   db->nDeferredCons = 0;
112800
112801   /* If one has been configured, invoke the rollback-hook callback */
112802   if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
112803     db->xRollbackCallback(db->pRollbackArg);
112804   }
112805 }
112806
112807 /*
112808 ** Return a static string that describes the kind of error specified in the
112809 ** argument.
112810 */
112811 SQLCIPHER_PRIVATE const char *sqlcipher3ErrStr(int rc){
112812   static const char* const aMsg[] = {
112813     /* SQLCIPHER_OK          */ "not an error",
112814     /* SQLCIPHER_ERROR       */ "SQL logic error or missing database",
112815     /* SQLCIPHER_INTERNAL    */ 0,
112816     /* SQLCIPHER_PERM        */ "access permission denied",
112817     /* SQLCIPHER_ABORT       */ "callback requested query abort",
112818     /* SQLCIPHER_BUSY        */ "database is locked",
112819     /* SQLCIPHER_LOCKED      */ "database table is locked",
112820     /* SQLCIPHER_NOMEM       */ "out of memory",
112821     /* SQLCIPHER_READONLY    */ "attempt to write a readonly database",
112822     /* SQLCIPHER_INTERRUPT   */ "interrupted",
112823     /* SQLCIPHER_IOERR       */ "disk I/O error",
112824     /* SQLCIPHER_CORRUPT     */ "database disk image is malformed",
112825     /* SQLCIPHER_NOTFOUND    */ "unknown operation",
112826     /* SQLCIPHER_FULL        */ "database or disk is full",
112827     /* SQLCIPHER_CANTOPEN    */ "unable to open database file",
112828     /* SQLCIPHER_PROTOCOL    */ "locking protocol",
112829     /* SQLCIPHER_EMPTY       */ "table contains no data",
112830     /* SQLCIPHER_SCHEMA      */ "database schema has changed",
112831     /* SQLCIPHER_TOOBIG      */ "string or blob too big",
112832     /* SQLCIPHER_CONSTRAINT  */ "constraint failed",
112833     /* SQLCIPHER_MISMATCH    */ "datatype mismatch",
112834     /* SQLCIPHER_MISUSE      */ "library routine called out of sequence",
112835     /* SQLCIPHER_NOLFS       */ "large file support is disabled",
112836     /* SQLCIPHER_AUTH        */ "authorization denied",
112837     /* SQLCIPHER_FORMAT      */ "auxiliary database format error",
112838     /* SQLCIPHER_RANGE       */ "bind or column index out of range",
112839     /* SQLCIPHER_NOTADB      */ "file is encrypted or is not a database",
112840   };
112841   rc &= 0xff;
112842   if( ALWAYS(rc>=0) && rc<(int)(sizeof(aMsg)/sizeof(aMsg[0])) && aMsg[rc]!=0 ){
112843     return aMsg[rc];
112844   }else{
112845     return "unknown error";
112846   }
112847 }
112848
112849 /*
112850 ** This routine implements a busy callback that sleeps and tries
112851 ** again until a timeout value is reached.  The timeout value is
112852 ** an integer number of milliseconds passed in as the first
112853 ** argument.
112854 */
112855 static int sqlcipherDefaultBusyCallback(
112856  void *ptr,               /* Database connection */
112857  int count                /* Number of times table has been busy */
112858 ){
112859 #if SQLCIPHER_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
112860   static const u8 delays[] =
112861      { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
112862   static const u8 totals[] =
112863      { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
112864 # define NDELAY ArraySize(delays)
112865   sqlcipher3 *db = (sqlcipher3 *)ptr;
112866   int timeout = db->busyTimeout;
112867   int delay, prior;
112868
112869   assert( count>=0 );
112870   if( count < NDELAY ){
112871     delay = delays[count];
112872     prior = totals[count];
112873   }else{
112874     delay = delays[NDELAY-1];
112875     prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
112876   }
112877   if( prior + delay > timeout ){
112878     delay = timeout - prior;
112879     if( delay<=0 ) return 0;
112880   }
112881   sqlcipher3OsSleep(db->pVfs, delay*1000);
112882   return 1;
112883 #else
112884   sqlcipher3 *db = (sqlcipher3 *)ptr;
112885   int timeout = ((sqlcipher3 *)ptr)->busyTimeout;
112886   if( (count+1)*1000 > timeout ){
112887     return 0;
112888   }
112889   sqlcipher3OsSleep(db->pVfs, 1000000);
112890   return 1;
112891 #endif
112892 }
112893
112894 /*
112895 ** Invoke the given busy handler.
112896 **
112897 ** This routine is called when an operation failed with a lock.
112898 ** If this routine returns non-zero, the lock is retried.  If it
112899 ** returns 0, the operation aborts with an SQLCIPHER_BUSY error.
112900 */
112901 SQLCIPHER_PRIVATE int sqlcipher3InvokeBusyHandler(BusyHandler *p){
112902   int rc;
112903   if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
112904   rc = p->xFunc(p->pArg, p->nBusy);
112905   if( rc==0 ){
112906     p->nBusy = -1;
112907   }else{
112908     p->nBusy++;
112909   }
112910   return rc; 
112911 }
112912
112913 /*
112914 ** This routine sets the busy callback for an Sqlite database to the
112915 ** given callback function with the given argument.
112916 */
112917 SQLCIPHER_API int sqlcipher3_busy_handler(
112918   sqlcipher3 *db,
112919   int (*xBusy)(void*,int),
112920   void *pArg
112921 ){
112922   sqlcipher3_mutex_enter(db->mutex);
112923   db->busyHandler.xFunc = xBusy;
112924   db->busyHandler.pArg = pArg;
112925   db->busyHandler.nBusy = 0;
112926   sqlcipher3_mutex_leave(db->mutex);
112927   return SQLCIPHER_OK;
112928 }
112929
112930 #ifndef SQLCIPHER_OMIT_PROGRESS_CALLBACK
112931 /*
112932 ** This routine sets the progress callback for an Sqlite database to the
112933 ** given callback function with the given argument. The progress callback will
112934 ** be invoked every nOps opcodes.
112935 */
112936 SQLCIPHER_API void sqlcipher3_progress_handler(
112937   sqlcipher3 *db, 
112938   int nOps,
112939   int (*xProgress)(void*), 
112940   void *pArg
112941 ){
112942   sqlcipher3_mutex_enter(db->mutex);
112943   if( nOps>0 ){
112944     db->xProgress = xProgress;
112945     db->nProgressOps = nOps;
112946     db->pProgressArg = pArg;
112947   }else{
112948     db->xProgress = 0;
112949     db->nProgressOps = 0;
112950     db->pProgressArg = 0;
112951   }
112952   sqlcipher3_mutex_leave(db->mutex);
112953 }
112954 #endif
112955
112956
112957 /*
112958 ** This routine installs a default busy handler that waits for the
112959 ** specified number of milliseconds before returning 0.
112960 */
112961 SQLCIPHER_API int sqlcipher3_busy_timeout(sqlcipher3 *db, int ms){
112962   if( ms>0 ){
112963     db->busyTimeout = ms;
112964     sqlcipher3_busy_handler(db, sqlcipherDefaultBusyCallback, (void*)db);
112965   }else{
112966     sqlcipher3_busy_handler(db, 0, 0);
112967   }
112968   return SQLCIPHER_OK;
112969 }
112970
112971 /*
112972 ** Cause any pending operation to stop at its earliest opportunity.
112973 */
112974 SQLCIPHER_API void sqlcipher3_interrupt(sqlcipher3 *db){
112975   db->u1.isInterrupted = 1;
112976 }
112977
112978
112979 /*
112980 ** This function is exactly the same as sqlcipher3_create_function(), except
112981 ** that it is designed to be called by internal code. The difference is
112982 ** that if a malloc() fails in sqlcipher3_create_function(), an error code
112983 ** is returned and the mallocFailed flag cleared. 
112984 */
112985 SQLCIPHER_PRIVATE int sqlcipher3CreateFunc(
112986   sqlcipher3 *db,
112987   const char *zFunctionName,
112988   int nArg,
112989   int enc,
112990   void *pUserData,
112991   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value **),
112992   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value **),
112993   void (*xFinal)(sqlcipher3_context*),
112994   FuncDestructor *pDestructor
112995 ){
112996   FuncDef *p;
112997   int nName;
112998
112999   assert( sqlcipher3_mutex_held(db->mutex) );
113000   if( zFunctionName==0 ||
113001       (xFunc && (xFinal || xStep)) || 
113002       (!xFunc && (xFinal && !xStep)) ||
113003       (!xFunc && (!xFinal && xStep)) ||
113004       (nArg<-1 || nArg>SQLCIPHER_MAX_FUNCTION_ARG) ||
113005       (255<(nName = sqlcipher3Strlen30( zFunctionName))) ){
113006     return SQLCIPHER_MISUSE_BKPT;
113007   }
113008   
113009 #ifndef SQLCIPHER_OMIT_UTF16
113010   /* If SQLCIPHER_UTF16 is specified as the encoding type, transform this
113011   ** to one of SQLCIPHER_UTF16LE or SQLCIPHER_UTF16BE using the
113012   ** SQLCIPHER_UTF16NATIVE macro. SQLCIPHER_UTF16 is not used internally.
113013   **
113014   ** If SQLCIPHER_ANY is specified, add three versions of the function
113015   ** to the hash table.
113016   */
113017   if( enc==SQLCIPHER_UTF16 ){
113018     enc = SQLCIPHER_UTF16NATIVE;
113019   }else if( enc==SQLCIPHER_ANY ){
113020     int rc;
113021     rc = sqlcipher3CreateFunc(db, zFunctionName, nArg, SQLCIPHER_UTF8,
113022          pUserData, xFunc, xStep, xFinal, pDestructor);
113023     if( rc==SQLCIPHER_OK ){
113024       rc = sqlcipher3CreateFunc(db, zFunctionName, nArg, SQLCIPHER_UTF16LE,
113025           pUserData, xFunc, xStep, xFinal, pDestructor);
113026     }
113027     if( rc!=SQLCIPHER_OK ){
113028       return rc;
113029     }
113030     enc = SQLCIPHER_UTF16BE;
113031   }
113032 #else
113033   enc = SQLCIPHER_UTF8;
113034 #endif
113035   
113036   /* Check if an existing function is being overridden or deleted. If so,
113037   ** and there are active VMs, then return SQLCIPHER_BUSY. If a function
113038   ** is being overridden/deleted but there are no active VMs, allow the
113039   ** operation to continue but invalidate all precompiled statements.
113040   */
113041   p = sqlcipher3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
113042   if( p && p->iPrefEnc==enc && p->nArg==nArg ){
113043     if( db->activeVdbeCnt ){
113044       sqlcipher3Error(db, SQLCIPHER_BUSY, 
113045         "unable to delete/modify user-function due to active statements");
113046       assert( !db->mallocFailed );
113047       return SQLCIPHER_BUSY;
113048     }else{
113049       sqlcipher3ExpirePreparedStatements(db);
113050     }
113051   }
113052
113053   p = sqlcipher3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1);
113054   assert(p || db->mallocFailed);
113055   if( !p ){
113056     return SQLCIPHER_NOMEM;
113057   }
113058
113059   /* If an older version of the function with a configured destructor is
113060   ** being replaced invoke the destructor function here. */
113061   functionDestroy(db, p);
113062
113063   if( pDestructor ){
113064     pDestructor->nRef++;
113065   }
113066   p->pDestructor = pDestructor;
113067   p->flags = 0;
113068   p->xFunc = xFunc;
113069   p->xStep = xStep;
113070   p->xFinalize = xFinal;
113071   p->pUserData = pUserData;
113072   p->nArg = (u16)nArg;
113073   return SQLCIPHER_OK;
113074 }
113075
113076 /*
113077 ** Create new user functions.
113078 */
113079 SQLCIPHER_API int sqlcipher3_create_function(
113080   sqlcipher3 *db,
113081   const char *zFunc,
113082   int nArg,
113083   int enc,
113084   void *p,
113085   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value **),
113086   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value **),
113087   void (*xFinal)(sqlcipher3_context*)
113088 ){
113089   return sqlcipher3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
113090                                     xFinal, 0);
113091 }
113092
113093 SQLCIPHER_API int sqlcipher3_create_function_v2(
113094   sqlcipher3 *db,
113095   const char *zFunc,
113096   int nArg,
113097   int enc,
113098   void *p,
113099   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value **),
113100   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value **),
113101   void (*xFinal)(sqlcipher3_context*),
113102   void (*xDestroy)(void *)
113103 ){
113104   int rc = SQLCIPHER_ERROR;
113105   FuncDestructor *pArg = 0;
113106   sqlcipher3_mutex_enter(db->mutex);
113107   if( xDestroy ){
113108     pArg = (FuncDestructor *)sqlcipher3DbMallocZero(db, sizeof(FuncDestructor));
113109     if( !pArg ){
113110       xDestroy(p);
113111       goto out;
113112     }
113113     pArg->xDestroy = xDestroy;
113114     pArg->pUserData = p;
113115   }
113116   rc = sqlcipher3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
113117   if( pArg && pArg->nRef==0 ){
113118     assert( rc!=SQLCIPHER_OK );
113119     xDestroy(p);
113120     sqlcipher3DbFree(db, pArg);
113121   }
113122
113123  out:
113124   rc = sqlcipher3ApiExit(db, rc);
113125   sqlcipher3_mutex_leave(db->mutex);
113126   return rc;
113127 }
113128
113129 #ifndef SQLCIPHER_OMIT_UTF16
113130 SQLCIPHER_API int sqlcipher3_create_function16(
113131   sqlcipher3 *db,
113132   const void *zFunctionName,
113133   int nArg,
113134   int eTextRep,
113135   void *p,
113136   void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**),
113137   void (*xStep)(sqlcipher3_context*,int,sqlcipher3_value**),
113138   void (*xFinal)(sqlcipher3_context*)
113139 ){
113140   int rc;
113141   char *zFunc8;
113142   sqlcipher3_mutex_enter(db->mutex);
113143   assert( !db->mallocFailed );
113144   zFunc8 = sqlcipher3Utf16to8(db, zFunctionName, -1, SQLCIPHER_UTF16NATIVE);
113145   rc = sqlcipher3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
113146   sqlcipher3DbFree(db, zFunc8);
113147   rc = sqlcipher3ApiExit(db, rc);
113148   sqlcipher3_mutex_leave(db->mutex);
113149   return rc;
113150 }
113151 #endif
113152
113153
113154 /*
113155 ** Declare that a function has been overloaded by a virtual table.
113156 **
113157 ** If the function already exists as a regular global function, then
113158 ** this routine is a no-op.  If the function does not exist, then create
113159 ** a new one that always throws a run-time error.  
113160 **
113161 ** When virtual tables intend to provide an overloaded function, they
113162 ** should call this routine to make sure the global function exists.
113163 ** A global function must exist in order for name resolution to work
113164 ** properly.
113165 */
113166 SQLCIPHER_API int sqlcipher3_overload_function(
113167   sqlcipher3 *db,
113168   const char *zName,
113169   int nArg
113170 ){
113171   int nName = sqlcipher3Strlen30(zName);
113172   int rc = SQLCIPHER_OK;
113173   sqlcipher3_mutex_enter(db->mutex);
113174   if( sqlcipher3FindFunction(db, zName, nName, nArg, SQLCIPHER_UTF8, 0)==0 ){
113175     rc = sqlcipher3CreateFunc(db, zName, nArg, SQLCIPHER_UTF8,
113176                            0, sqlcipher3InvalidFunction, 0, 0, 0);
113177   }
113178   rc = sqlcipher3ApiExit(db, rc);
113179   sqlcipher3_mutex_leave(db->mutex);
113180   return rc;
113181 }
113182
113183 #ifndef SQLCIPHER_OMIT_TRACE
113184 /*
113185 ** Register a trace function.  The pArg from the previously registered trace
113186 ** is returned.  
113187 **
113188 ** A NULL trace function means that no tracing is executes.  A non-NULL
113189 ** trace is a pointer to a function that is invoked at the start of each
113190 ** SQL statement.
113191 */
113192 SQLCIPHER_API void *sqlcipher3_trace(sqlcipher3 *db, void (*xTrace)(void*,const char*), void *pArg){
113193   void *pOld;
113194   sqlcipher3_mutex_enter(db->mutex);
113195   pOld = db->pTraceArg;
113196   db->xTrace = xTrace;
113197   db->pTraceArg = pArg;
113198   sqlcipher3_mutex_leave(db->mutex);
113199   return pOld;
113200 }
113201 /*
113202 ** Register a profile function.  The pArg from the previously registered 
113203 ** profile function is returned.  
113204 **
113205 ** A NULL profile function means that no profiling is executes.  A non-NULL
113206 ** profile is a pointer to a function that is invoked at the conclusion of
113207 ** each SQL statement that is run.
113208 */
113209 SQLCIPHER_API void *sqlcipher3_profile(
113210   sqlcipher3 *db,
113211   void (*xProfile)(void*,const char*,sqlcipher_uint64),
113212   void *pArg
113213 ){
113214   void *pOld;
113215   sqlcipher3_mutex_enter(db->mutex);
113216   pOld = db->pProfileArg;
113217   db->xProfile = xProfile;
113218   db->pProfileArg = pArg;
113219   sqlcipher3_mutex_leave(db->mutex);
113220   return pOld;
113221 }
113222 #endif /* SQLCIPHER_OMIT_TRACE */
113223
113224 /*** EXPERIMENTAL ***
113225 **
113226 ** Register a function to be invoked when a transaction comments.
113227 ** If the invoked function returns non-zero, then the commit becomes a
113228 ** rollback.
113229 */
113230 SQLCIPHER_API void *sqlcipher3_commit_hook(
113231   sqlcipher3 *db,              /* Attach the hook to this database */
113232   int (*xCallback)(void*),  /* Function to invoke on each commit */
113233   void *pArg                /* Argument to the function */
113234 ){
113235   void *pOld;
113236   sqlcipher3_mutex_enter(db->mutex);
113237   pOld = db->pCommitArg;
113238   db->xCommitCallback = xCallback;
113239   db->pCommitArg = pArg;
113240   sqlcipher3_mutex_leave(db->mutex);
113241   return pOld;
113242 }
113243
113244 /*
113245 ** Register a callback to be invoked each time a row is updated,
113246 ** inserted or deleted using this database connection.
113247 */
113248 SQLCIPHER_API void *sqlcipher3_update_hook(
113249   sqlcipher3 *db,              /* Attach the hook to this database */
113250   void (*xCallback)(void*,int,char const *,char const *,sqlcipher_int64),
113251   void *pArg                /* Argument to the function */
113252 ){
113253   void *pRet;
113254   sqlcipher3_mutex_enter(db->mutex);
113255   pRet = db->pUpdateArg;
113256   db->xUpdateCallback = xCallback;
113257   db->pUpdateArg = pArg;
113258   sqlcipher3_mutex_leave(db->mutex);
113259   return pRet;
113260 }
113261
113262 /*
113263 ** Register a callback to be invoked each time a transaction is rolled
113264 ** back by this database connection.
113265 */
113266 SQLCIPHER_API void *sqlcipher3_rollback_hook(
113267   sqlcipher3 *db,              /* Attach the hook to this database */
113268   void (*xCallback)(void*), /* Callback function */
113269   void *pArg                /* Argument to the function */
113270 ){
113271   void *pRet;
113272   sqlcipher3_mutex_enter(db->mutex);
113273   pRet = db->pRollbackArg;
113274   db->xRollbackCallback = xCallback;
113275   db->pRollbackArg = pArg;
113276   sqlcipher3_mutex_leave(db->mutex);
113277   return pRet;
113278 }
113279
113280 #ifndef SQLCIPHER_OMIT_WAL
113281 /*
113282 ** The sqlcipher3_wal_hook() callback registered by sqlcipher3_wal_autocheckpoint().
113283 ** Invoke sqlcipher3_wal_checkpoint if the number of frames in the log file
113284 ** is greater than sqlcipher3.pWalArg cast to an integer (the value configured by
113285 ** wal_autocheckpoint()).
113286 */ 
113287 SQLCIPHER_PRIVATE int sqlcipher3WalDefaultHook(
113288   void *pClientData,     /* Argument */
113289   sqlcipher3 *db,           /* Connection */
113290   const char *zDb,       /* Database */
113291   int nFrame             /* Size of WAL */
113292 ){
113293   if( nFrame>=SQLCIPHER_PTR_TO_INT(pClientData) ){
113294     sqlcipher3BeginBenignMalloc();
113295     sqlcipher3_wal_checkpoint(db, zDb);
113296     sqlcipher3EndBenignMalloc();
113297   }
113298   return SQLCIPHER_OK;
113299 }
113300 #endif /* SQLCIPHER_OMIT_WAL */
113301
113302 /*
113303 ** Configure an sqlcipher3_wal_hook() callback to automatically checkpoint
113304 ** a database after committing a transaction if there are nFrame or
113305 ** more frames in the log file. Passing zero or a negative value as the
113306 ** nFrame parameter disables automatic checkpoints entirely.
113307 **
113308 ** The callback registered by this function replaces any existing callback
113309 ** registered using sqlcipher3_wal_hook(). Likewise, registering a callback
113310 ** using sqlcipher3_wal_hook() disables the automatic checkpoint mechanism
113311 ** configured by this function.
113312 */
113313 SQLCIPHER_API int sqlcipher3_wal_autocheckpoint(sqlcipher3 *db, int nFrame){
113314 #ifdef SQLCIPHER_OMIT_WAL
113315   UNUSED_PARAMETER(db);
113316   UNUSED_PARAMETER(nFrame);
113317 #else
113318   if( nFrame>0 ){
113319     sqlcipher3_wal_hook(db, sqlcipher3WalDefaultHook, SQLCIPHER_INT_TO_PTR(nFrame));
113320   }else{
113321     sqlcipher3_wal_hook(db, 0, 0);
113322   }
113323 #endif
113324   return SQLCIPHER_OK;
113325 }
113326
113327 /*
113328 ** Register a callback to be invoked each time a transaction is written
113329 ** into the write-ahead-log by this database connection.
113330 */
113331 SQLCIPHER_API void *sqlcipher3_wal_hook(
113332   sqlcipher3 *db,                    /* Attach the hook to this db handle */
113333   int(*xCallback)(void *, sqlcipher3*, const char*, int),
113334   void *pArg                      /* First argument passed to xCallback() */
113335 ){
113336 #ifndef SQLCIPHER_OMIT_WAL
113337   void *pRet;
113338   sqlcipher3_mutex_enter(db->mutex);
113339   pRet = db->pWalArg;
113340   db->xWalCallback = xCallback;
113341   db->pWalArg = pArg;
113342   sqlcipher3_mutex_leave(db->mutex);
113343   return pRet;
113344 #else
113345   return 0;
113346 #endif
113347 }
113348
113349 /*
113350 ** Checkpoint database zDb.
113351 */
113352 SQLCIPHER_API int sqlcipher3_wal_checkpoint_v2(
113353   sqlcipher3 *db,                    /* Database handle */
113354   const char *zDb,                /* Name of attached database (or NULL) */
113355   int eMode,                      /* SQLCIPHER_CHECKPOINT_* value */
113356   int *pnLog,                     /* OUT: Size of WAL log in frames */
113357   int *pnCkpt                     /* OUT: Total number of frames checkpointed */
113358 ){
113359 #ifdef SQLCIPHER_OMIT_WAL
113360   return SQLCIPHER_OK;
113361 #else
113362   int rc;                         /* Return code */
113363   int iDb = SQLCIPHER_MAX_ATTACHED;  /* sqlcipher3.aDb[] index of db to checkpoint */
113364
113365   /* Initialize the output variables to -1 in case an error occurs. */
113366   if( pnLog ) *pnLog = -1;
113367   if( pnCkpt ) *pnCkpt = -1;
113368
113369   assert( SQLCIPHER_CHECKPOINT_FULL>SQLCIPHER_CHECKPOINT_PASSIVE );
113370   assert( SQLCIPHER_CHECKPOINT_FULL<SQLCIPHER_CHECKPOINT_RESTART );
113371   assert( SQLCIPHER_CHECKPOINT_PASSIVE+2==SQLCIPHER_CHECKPOINT_RESTART );
113372   if( eMode<SQLCIPHER_CHECKPOINT_PASSIVE || eMode>SQLCIPHER_CHECKPOINT_RESTART ){
113373     return SQLCIPHER_MISUSE;
113374   }
113375
113376   sqlcipher3_mutex_enter(db->mutex);
113377   if( zDb && zDb[0] ){
113378     iDb = sqlcipher3FindDbName(db, zDb);
113379   }
113380   if( iDb<0 ){
113381     rc = SQLCIPHER_ERROR;
113382     sqlcipher3Error(db, SQLCIPHER_ERROR, "unknown database: %s", zDb);
113383   }else{
113384     rc = sqlcipher3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
113385     sqlcipher3Error(db, rc, 0);
113386   }
113387   rc = sqlcipher3ApiExit(db, rc);
113388   sqlcipher3_mutex_leave(db->mutex);
113389   return rc;
113390 #endif
113391 }
113392
113393
113394 /*
113395 ** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
113396 ** to contains a zero-length string, all attached databases are 
113397 ** checkpointed.
113398 */
113399 SQLCIPHER_API int sqlcipher3_wal_checkpoint(sqlcipher3 *db, const char *zDb){
113400   return sqlcipher3_wal_checkpoint_v2(db, zDb, SQLCIPHER_CHECKPOINT_PASSIVE, 0, 0);
113401 }
113402
113403 #ifndef SQLCIPHER_OMIT_WAL
113404 /*
113405 ** Run a checkpoint on database iDb. This is a no-op if database iDb is
113406 ** not currently open in WAL mode.
113407 **
113408 ** If a transaction is open on the database being checkpointed, this 
113409 ** function returns SQLCIPHER_LOCKED and a checkpoint is not attempted. If 
113410 ** an error occurs while running the checkpoint, an SQLite error code is 
113411 ** returned (i.e. SQLCIPHER_IOERR). Otherwise, SQLCIPHER_OK.
113412 **
113413 ** The mutex on database handle db should be held by the caller. The mutex
113414 ** associated with the specific b-tree being checkpointed is taken by
113415 ** this function while the checkpoint is running.
113416 **
113417 ** If iDb is passed SQLCIPHER_MAX_ATTACHED, then all attached databases are
113418 ** checkpointed. If an error is encountered it is returned immediately -
113419 ** no attempt is made to checkpoint any remaining databases.
113420 **
113421 ** Parameter eMode is one of SQLCIPHER_CHECKPOINT_PASSIVE, FULL or RESTART.
113422 */
113423 SQLCIPHER_PRIVATE int sqlcipher3Checkpoint(sqlcipher3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
113424   int rc = SQLCIPHER_OK;             /* Return code */
113425   int i;                          /* Used to iterate through attached dbs */
113426   int bBusy = 0;                  /* True if SQLCIPHER_BUSY has been encountered */
113427
113428   assert( sqlcipher3_mutex_held(db->mutex) );
113429   assert( !pnLog || *pnLog==-1 );
113430   assert( !pnCkpt || *pnCkpt==-1 );
113431
113432   for(i=0; i<db->nDb && rc==SQLCIPHER_OK; i++){
113433     if( i==iDb || iDb==SQLCIPHER_MAX_ATTACHED ){
113434       rc = sqlcipher3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
113435       pnLog = 0;
113436       pnCkpt = 0;
113437       if( rc==SQLCIPHER_BUSY ){
113438         bBusy = 1;
113439         rc = SQLCIPHER_OK;
113440       }
113441     }
113442   }
113443
113444   return (rc==SQLCIPHER_OK && bBusy) ? SQLCIPHER_BUSY : rc;
113445 }
113446 #endif /* SQLCIPHER_OMIT_WAL */
113447
113448 /*
113449 ** This function returns true if main-memory should be used instead of
113450 ** a temporary file for transient pager files and statement journals.
113451 ** The value returned depends on the value of db->temp_store (runtime
113452 ** parameter) and the compile time value of SQLCIPHER_TEMP_STORE. The
113453 ** following table describes the relationship between these two values
113454 ** and this functions return value.
113455 **
113456 **   SQLCIPHER_TEMP_STORE     db->temp_store     Location of temporary database
113457 **   -----------------     --------------     ------------------------------
113458 **   0                     any                file      (return 0)
113459 **   1                     1                  file      (return 0)
113460 **   1                     2                  memory    (return 1)
113461 **   1                     0                  file      (return 0)
113462 **   2                     1                  file      (return 0)
113463 **   2                     2                  memory    (return 1)
113464 **   2                     0                  memory    (return 1)
113465 **   3                     any                memory    (return 1)
113466 */
113467 SQLCIPHER_PRIVATE int sqlcipher3TempInMemory(const sqlcipher3 *db){
113468 #if SQLCIPHER_TEMP_STORE==1
113469   return ( db->temp_store==2 );
113470 #endif
113471 #if SQLCIPHER_TEMP_STORE==2
113472   return ( db->temp_store!=1 );
113473 #endif
113474 #if SQLCIPHER_TEMP_STORE==3
113475   return 1;
113476 #endif
113477 #if SQLCIPHER_TEMP_STORE<1 || SQLCIPHER_TEMP_STORE>3
113478   return 0;
113479 #endif
113480 }
113481
113482 /*
113483 ** Return UTF-8 encoded English language explanation of the most recent
113484 ** error.
113485 */
113486 SQLCIPHER_API const char *sqlcipher3_errmsg(sqlcipher3 *db){
113487   const char *z;
113488   if( !db ){
113489     return sqlcipher3ErrStr(SQLCIPHER_NOMEM);
113490   }
113491   if( !sqlcipher3SafetyCheckSickOrOk(db) ){
113492     return sqlcipher3ErrStr(SQLCIPHER_MISUSE_BKPT);
113493   }
113494   sqlcipher3_mutex_enter(db->mutex);
113495   if( db->mallocFailed ){
113496     z = sqlcipher3ErrStr(SQLCIPHER_NOMEM);
113497   }else{
113498     z = (char*)sqlcipher3_value_text(db->pErr);
113499     assert( !db->mallocFailed );
113500     if( z==0 ){
113501       z = sqlcipher3ErrStr(db->errCode);
113502     }
113503   }
113504   sqlcipher3_mutex_leave(db->mutex);
113505   return z;
113506 }
113507
113508 #ifndef SQLCIPHER_OMIT_UTF16
113509 /*
113510 ** Return UTF-16 encoded English language explanation of the most recent
113511 ** error.
113512 */
113513 SQLCIPHER_API const void *sqlcipher3_errmsg16(sqlcipher3 *db){
113514   static const u16 outOfMem[] = {
113515     'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
113516   };
113517   static const u16 misuse[] = {
113518     'l', 'i', 'b', 'r', 'a', 'r', 'y', ' ', 
113519     'r', 'o', 'u', 't', 'i', 'n', 'e', ' ', 
113520     'c', 'a', 'l', 'l', 'e', 'd', ' ', 
113521     'o', 'u', 't', ' ', 
113522     'o', 'f', ' ', 
113523     's', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0
113524   };
113525
113526   const void *z;
113527   if( !db ){
113528     return (void *)outOfMem;
113529   }
113530   if( !sqlcipher3SafetyCheckSickOrOk(db) ){
113531     return (void *)misuse;
113532   }
113533   sqlcipher3_mutex_enter(db->mutex);
113534   if( db->mallocFailed ){
113535     z = (void *)outOfMem;
113536   }else{
113537     z = sqlcipher3_value_text16(db->pErr);
113538     if( z==0 ){
113539       sqlcipher3ValueSetStr(db->pErr, -1, sqlcipher3ErrStr(db->errCode),
113540            SQLCIPHER_UTF8, SQLCIPHER_STATIC);
113541       z = sqlcipher3_value_text16(db->pErr);
113542     }
113543     /* A malloc() may have failed within the call to sqlcipher3_value_text16()
113544     ** above. If this is the case, then the db->mallocFailed flag needs to
113545     ** be cleared before returning. Do this directly, instead of via
113546     ** sqlcipher3ApiExit(), to avoid setting the database handle error message.
113547     */
113548     db->mallocFailed = 0;
113549   }
113550   sqlcipher3_mutex_leave(db->mutex);
113551   return z;
113552 }
113553 #endif /* SQLCIPHER_OMIT_UTF16 */
113554
113555 /*
113556 ** Return the most recent error code generated by an SQLite routine. If NULL is
113557 ** passed to this function, we assume a malloc() failed during sqlcipher3_open().
113558 */
113559 SQLCIPHER_API int sqlcipher3_errcode(sqlcipher3 *db){
113560   if( db && !sqlcipher3SafetyCheckSickOrOk(db) ){
113561     return SQLCIPHER_MISUSE_BKPT;
113562   }
113563   if( !db || db->mallocFailed ){
113564     return SQLCIPHER_NOMEM;
113565   }
113566   return db->errCode & db->errMask;
113567 }
113568 SQLCIPHER_API int sqlcipher3_extended_errcode(sqlcipher3 *db){
113569   if( db && !sqlcipher3SafetyCheckSickOrOk(db) ){
113570     return SQLCIPHER_MISUSE_BKPT;
113571   }
113572   if( !db || db->mallocFailed ){
113573     return SQLCIPHER_NOMEM;
113574   }
113575   return db->errCode;
113576 }
113577
113578 /*
113579 ** Create a new collating function for database "db".  The name is zName
113580 ** and the encoding is enc.
113581 */
113582 static int createCollation(
113583   sqlcipher3* db,
113584   const char *zName, 
113585   u8 enc,
113586   u8 collType,
113587   void* pCtx,
113588   int(*xCompare)(void*,int,const void*,int,const void*),
113589   void(*xDel)(void*)
113590 ){
113591   CollSeq *pColl;
113592   int enc2;
113593   int nName = sqlcipher3Strlen30(zName);
113594   
113595   assert( sqlcipher3_mutex_held(db->mutex) );
113596
113597   /* If SQLCIPHER_UTF16 is specified as the encoding type, transform this
113598   ** to one of SQLCIPHER_UTF16LE or SQLCIPHER_UTF16BE using the
113599   ** SQLCIPHER_UTF16NATIVE macro. SQLCIPHER_UTF16 is not used internally.
113600   */
113601   enc2 = enc;
113602   testcase( enc2==SQLCIPHER_UTF16 );
113603   testcase( enc2==SQLCIPHER_UTF16_ALIGNED );
113604   if( enc2==SQLCIPHER_UTF16 || enc2==SQLCIPHER_UTF16_ALIGNED ){
113605     enc2 = SQLCIPHER_UTF16NATIVE;
113606   }
113607   if( enc2<SQLCIPHER_UTF8 || enc2>SQLCIPHER_UTF16BE ){
113608     return SQLCIPHER_MISUSE_BKPT;
113609   }
113610
113611   /* Check if this call is removing or replacing an existing collation 
113612   ** sequence. If so, and there are active VMs, return busy. If there
113613   ** are no active VMs, invalidate any pre-compiled statements.
113614   */
113615   pColl = sqlcipher3FindCollSeq(db, (u8)enc2, zName, 0);
113616   if( pColl && pColl->xCmp ){
113617     if( db->activeVdbeCnt ){
113618       sqlcipher3Error(db, SQLCIPHER_BUSY, 
113619         "unable to delete/modify collation sequence due to active statements");
113620       return SQLCIPHER_BUSY;
113621     }
113622     sqlcipher3ExpirePreparedStatements(db);
113623
113624     /* If collation sequence pColl was created directly by a call to
113625     ** sqlcipher3_create_collation, and not generated by synthCollSeq(),
113626     ** then any copies made by synthCollSeq() need to be invalidated.
113627     ** Also, collation destructor - CollSeq.xDel() - function may need
113628     ** to be called.
113629     */ 
113630     if( (pColl->enc & ~SQLCIPHER_UTF16_ALIGNED)==enc2 ){
113631       CollSeq *aColl = sqlcipher3HashFind(&db->aCollSeq, zName, nName);
113632       int j;
113633       for(j=0; j<3; j++){
113634         CollSeq *p = &aColl[j];
113635         if( p->enc==pColl->enc ){
113636           if( p->xDel ){
113637             p->xDel(p->pUser);
113638           }
113639           p->xCmp = 0;
113640         }
113641       }
113642     }
113643   }
113644
113645   pColl = sqlcipher3FindCollSeq(db, (u8)enc2, zName, 1);
113646   if( pColl==0 ) return SQLCIPHER_NOMEM;
113647   pColl->xCmp = xCompare;
113648   pColl->pUser = pCtx;
113649   pColl->xDel = xDel;
113650   pColl->enc = (u8)(enc2 | (enc & SQLCIPHER_UTF16_ALIGNED));
113651   pColl->type = collType;
113652   sqlcipher3Error(db, SQLCIPHER_OK, 0);
113653   return SQLCIPHER_OK;
113654 }
113655
113656
113657 /*
113658 ** This array defines hard upper bounds on limit values.  The
113659 ** initializer must be kept in sync with the SQLCIPHER_LIMIT_*
113660 ** #defines in sqlcipher3.h.
113661 */
113662 static const int aHardLimit[] = {
113663   SQLCIPHER_MAX_LENGTH,
113664   SQLCIPHER_MAX_SQL_LENGTH,
113665   SQLCIPHER_MAX_COLUMN,
113666   SQLCIPHER_MAX_EXPR_DEPTH,
113667   SQLCIPHER_MAX_COMPOUND_SELECT,
113668   SQLCIPHER_MAX_VDBE_OP,
113669   SQLCIPHER_MAX_FUNCTION_ARG,
113670   SQLCIPHER_MAX_ATTACHED,
113671   SQLCIPHER_MAX_LIKE_PATTERN_LENGTH,
113672   SQLCIPHER_MAX_VARIABLE_NUMBER,
113673   SQLCIPHER_MAX_TRIGGER_DEPTH,
113674 };
113675
113676 /*
113677 ** Make sure the hard limits are set to reasonable values
113678 */
113679 #if SQLCIPHER_MAX_LENGTH<100
113680 # error SQLCIPHER_MAX_LENGTH must be at least 100
113681 #endif
113682 #if SQLCIPHER_MAX_SQL_LENGTH<100
113683 # error SQLCIPHER_MAX_SQL_LENGTH must be at least 100
113684 #endif
113685 #if SQLCIPHER_MAX_SQL_LENGTH>SQLCIPHER_MAX_LENGTH
113686 # error SQLCIPHER_MAX_SQL_LENGTH must not be greater than SQLCIPHER_MAX_LENGTH
113687 #endif
113688 #if SQLCIPHER_MAX_COMPOUND_SELECT<2
113689 # error SQLCIPHER_MAX_COMPOUND_SELECT must be at least 2
113690 #endif
113691 #if SQLCIPHER_MAX_VDBE_OP<40
113692 # error SQLCIPHER_MAX_VDBE_OP must be at least 40
113693 #endif
113694 #if SQLCIPHER_MAX_FUNCTION_ARG<0 || SQLCIPHER_MAX_FUNCTION_ARG>1000
113695 # error SQLCIPHER_MAX_FUNCTION_ARG must be between 0 and 1000
113696 #endif
113697 #if SQLCIPHER_MAX_ATTACHED<0 || SQLCIPHER_MAX_ATTACHED>62
113698 # error SQLCIPHER_MAX_ATTACHED must be between 0 and 62
113699 #endif
113700 #if SQLCIPHER_MAX_LIKE_PATTERN_LENGTH<1
113701 # error SQLCIPHER_MAX_LIKE_PATTERN_LENGTH must be at least 1
113702 #endif
113703 #if SQLCIPHER_MAX_COLUMN>32767
113704 # error SQLCIPHER_MAX_COLUMN must not exceed 32767
113705 #endif
113706 #if SQLCIPHER_MAX_TRIGGER_DEPTH<1
113707 # error SQLCIPHER_MAX_TRIGGER_DEPTH must be at least 1
113708 #endif
113709
113710
113711 /*
113712 ** Change the value of a limit.  Report the old value.
113713 ** If an invalid limit index is supplied, report -1.
113714 ** Make no changes but still report the old value if the
113715 ** new limit is negative.
113716 **
113717 ** A new lower limit does not shrink existing constructs.
113718 ** It merely prevents new constructs that exceed the limit
113719 ** from forming.
113720 */
113721 SQLCIPHER_API int sqlcipher3_limit(sqlcipher3 *db, int limitId, int newLimit){
113722   int oldLimit;
113723
113724
113725   /* EVIDENCE-OF: R-30189-54097 For each limit category SQLCIPHER_LIMIT_NAME
113726   ** there is a hard upper bound set at compile-time by a C preprocessor
113727   ** macro called SQLCIPHER_MAX_NAME. (The "_LIMIT_" in the name is changed to
113728   ** "_MAX_".)
113729   */
113730   assert( aHardLimit[SQLCIPHER_LIMIT_LENGTH]==SQLCIPHER_MAX_LENGTH );
113731   assert( aHardLimit[SQLCIPHER_LIMIT_SQL_LENGTH]==SQLCIPHER_MAX_SQL_LENGTH );
113732   assert( aHardLimit[SQLCIPHER_LIMIT_COLUMN]==SQLCIPHER_MAX_COLUMN );
113733   assert( aHardLimit[SQLCIPHER_LIMIT_EXPR_DEPTH]==SQLCIPHER_MAX_EXPR_DEPTH );
113734   assert( aHardLimit[SQLCIPHER_LIMIT_COMPOUND_SELECT]==SQLCIPHER_MAX_COMPOUND_SELECT);
113735   assert( aHardLimit[SQLCIPHER_LIMIT_VDBE_OP]==SQLCIPHER_MAX_VDBE_OP );
113736   assert( aHardLimit[SQLCIPHER_LIMIT_FUNCTION_ARG]==SQLCIPHER_MAX_FUNCTION_ARG );
113737   assert( aHardLimit[SQLCIPHER_LIMIT_ATTACHED]==SQLCIPHER_MAX_ATTACHED );
113738   assert( aHardLimit[SQLCIPHER_LIMIT_LIKE_PATTERN_LENGTH]==
113739                                                SQLCIPHER_MAX_LIKE_PATTERN_LENGTH );
113740   assert( aHardLimit[SQLCIPHER_LIMIT_VARIABLE_NUMBER]==SQLCIPHER_MAX_VARIABLE_NUMBER);
113741   assert( aHardLimit[SQLCIPHER_LIMIT_TRIGGER_DEPTH]==SQLCIPHER_MAX_TRIGGER_DEPTH );
113742   assert( SQLCIPHER_LIMIT_TRIGGER_DEPTH==(SQLCIPHER_N_LIMIT-1) );
113743
113744
113745   if( limitId<0 || limitId>=SQLCIPHER_N_LIMIT ){
113746     return -1;
113747   }
113748   oldLimit = db->aLimit[limitId];
113749   if( newLimit>=0 ){                   /* IMP: R-52476-28732 */
113750     if( newLimit>aHardLimit[limitId] ){
113751       newLimit = aHardLimit[limitId];  /* IMP: R-51463-25634 */
113752     }
113753     db->aLimit[limitId] = newLimit;
113754   }
113755   return oldLimit;                     /* IMP: R-53341-35419 */
113756 }
113757
113758 /*
113759 ** This function is used to parse both URIs and non-URI filenames passed by the
113760 ** user to API functions sqlcipher3_open() or sqlcipher3_open_v2(), and for database
113761 ** URIs specified as part of ATTACH statements.
113762 **
113763 ** The first argument to this function is the name of the VFS to use (or
113764 ** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
113765 ** query parameter. The second argument contains the URI (or non-URI filename)
113766 ** itself. When this function is called the *pFlags variable should contain
113767 ** the default flags to open the database handle with. The value stored in
113768 ** *pFlags may be updated before returning if the URI filename contains 
113769 ** "cache=xxx" or "mode=xxx" query parameters.
113770 **
113771 ** If successful, SQLCIPHER_OK is returned. In this case *ppVfs is set to point to
113772 ** the VFS that should be used to open the database file. *pzFile is set to
113773 ** point to a buffer containing the name of the file to open. It is the 
113774 ** responsibility of the caller to eventually call sqlcipher3_free() to release
113775 ** this buffer.
113776 **
113777 ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
113778 ** may be set to point to a buffer containing an English language error 
113779 ** message. It is the responsibility of the caller to eventually release
113780 ** this buffer by calling sqlcipher3_free().
113781 */
113782 SQLCIPHER_PRIVATE int sqlcipher3ParseUri(
113783   const char *zDefaultVfs,        /* VFS to use if no "vfs=xxx" query option */
113784   const char *zUri,               /* Nul-terminated URI to parse */
113785   unsigned int *pFlags,           /* IN/OUT: SQLCIPHER_OPEN_XXX flags */
113786   sqlcipher3_vfs **ppVfs,            /* OUT: VFS to use */ 
113787   char **pzFile,                  /* OUT: Filename component of URI */
113788   char **pzErrMsg                 /* OUT: Error message (if rc!=SQLCIPHER_OK) */
113789 ){
113790   int rc = SQLCIPHER_OK;
113791   unsigned int flags = *pFlags;
113792   const char *zVfs = zDefaultVfs;
113793   char *zFile;
113794   char c;
113795   int nUri = sqlcipher3Strlen30(zUri);
113796
113797   assert( *pzErrMsg==0 );
113798
113799   if( ((flags & SQLCIPHER_OPEN_URI) || sqlcipher3GlobalConfig.bOpenUri) 
113800    && nUri>=5 && memcmp(zUri, "file:", 5)==0 
113801   ){
113802     char *zOpt;
113803     int eState;                   /* Parser state when parsing URI */
113804     int iIn;                      /* Input character index */
113805     int iOut = 0;                 /* Output character index */
113806     int nByte = nUri+2;           /* Bytes of space to allocate */
113807
113808     /* Make sure the SQLCIPHER_OPEN_URI flag is set to indicate to the VFS xOpen 
113809     ** method that there may be extra parameters following the file-name.  */
113810     flags |= SQLCIPHER_OPEN_URI;
113811
113812     for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
113813     zFile = sqlcipher3_malloc(nByte);
113814     if( !zFile ) return SQLCIPHER_NOMEM;
113815
113816     /* Discard the scheme and authority segments of the URI. */
113817     if( zUri[5]=='/' && zUri[6]=='/' ){
113818       iIn = 7;
113819       while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
113820
113821       if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
113822         *pzErrMsg = sqlcipher3_mprintf("invalid uri authority: %.*s", 
113823             iIn-7, &zUri[7]);
113824         rc = SQLCIPHER_ERROR;
113825         goto parse_uri_out;
113826       }
113827     }else{
113828       iIn = 5;
113829     }
113830
113831     /* Copy the filename and any query parameters into the zFile buffer. 
113832     ** Decode %HH escape codes along the way. 
113833     **
113834     ** Within this loop, variable eState may be set to 0, 1 or 2, depending
113835     ** on the parsing context. As follows:
113836     **
113837     **   0: Parsing file-name.
113838     **   1: Parsing name section of a name=value query parameter.
113839     **   2: Parsing value section of a name=value query parameter.
113840     */
113841     eState = 0;
113842     while( (c = zUri[iIn])!=0 && c!='#' ){
113843       iIn++;
113844       if( c=='%' 
113845        && sqlcipher3Isxdigit(zUri[iIn]) 
113846        && sqlcipher3Isxdigit(zUri[iIn+1]) 
113847       ){
113848         int octet = (sqlcipher3HexToInt(zUri[iIn++]) << 4);
113849         octet += sqlcipher3HexToInt(zUri[iIn++]);
113850
113851         assert( octet>=0 && octet<256 );
113852         if( octet==0 ){
113853           /* This branch is taken when "%00" appears within the URI. In this
113854           ** case we ignore all text in the remainder of the path, name or
113855           ** value currently being parsed. So ignore the current character
113856           ** and skip to the next "?", "=" or "&", as appropriate. */
113857           while( (c = zUri[iIn])!=0 && c!='#' 
113858               && (eState!=0 || c!='?')
113859               && (eState!=1 || (c!='=' && c!='&'))
113860               && (eState!=2 || c!='&')
113861           ){
113862             iIn++;
113863           }
113864           continue;
113865         }
113866         c = octet;
113867       }else if( eState==1 && (c=='&' || c=='=') ){
113868         if( zFile[iOut-1]==0 ){
113869           /* An empty option name. Ignore this option altogether. */
113870           while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
113871           continue;
113872         }
113873         if( c=='&' ){
113874           zFile[iOut++] = '\0';
113875         }else{
113876           eState = 2;
113877         }
113878         c = 0;
113879       }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
113880         c = 0;
113881         eState = 1;
113882       }
113883       zFile[iOut++] = c;
113884     }
113885     if( eState==1 ) zFile[iOut++] = '\0';
113886     zFile[iOut++] = '\0';
113887     zFile[iOut++] = '\0';
113888
113889     /* Check if there were any options specified that should be interpreted 
113890     ** here. Options that are interpreted here include "vfs" and those that
113891     ** correspond to flags that may be passed to the sqlcipher3_open_v2()
113892     ** method. */
113893     zOpt = &zFile[sqlcipher3Strlen30(zFile)+1];
113894     while( zOpt[0] ){
113895       int nOpt = sqlcipher3Strlen30(zOpt);
113896       char *zVal = &zOpt[nOpt+1];
113897       int nVal = sqlcipher3Strlen30(zVal);
113898
113899       if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
113900         zVfs = zVal;
113901       }else{
113902         struct OpenMode {
113903           const char *z;
113904           int mode;
113905         } *aMode = 0;
113906         char *zModeType = 0;
113907         int mask = 0;
113908         int limit = 0;
113909
113910         if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
113911           static struct OpenMode aCacheMode[] = {
113912             { "shared",  SQLCIPHER_OPEN_SHAREDCACHE },
113913             { "private", SQLCIPHER_OPEN_PRIVATECACHE },
113914             { 0, 0 }
113915           };
113916
113917           mask = SQLCIPHER_OPEN_SHAREDCACHE|SQLCIPHER_OPEN_PRIVATECACHE;
113918           aMode = aCacheMode;
113919           limit = mask;
113920           zModeType = "cache";
113921         }
113922         if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
113923           static struct OpenMode aOpenMode[] = {
113924             { "ro",  SQLCIPHER_OPEN_READONLY },
113925             { "rw",  SQLCIPHER_OPEN_READWRITE }, 
113926             { "rwc", SQLCIPHER_OPEN_READWRITE | SQLCIPHER_OPEN_CREATE },
113927             { 0, 0 }
113928           };
113929
113930           mask = SQLCIPHER_OPEN_READONLY|SQLCIPHER_OPEN_READWRITE|SQLCIPHER_OPEN_CREATE;
113931           aMode = aOpenMode;
113932           limit = mask & flags;
113933           zModeType = "access";
113934         }
113935
113936         if( aMode ){
113937           int i;
113938           int mode = 0;
113939           for(i=0; aMode[i].z; i++){
113940             const char *z = aMode[i].z;
113941             if( nVal==sqlcipher3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
113942               mode = aMode[i].mode;
113943               break;
113944             }
113945           }
113946           if( mode==0 ){
113947             *pzErrMsg = sqlcipher3_mprintf("no such %s mode: %s", zModeType, zVal);
113948             rc = SQLCIPHER_ERROR;
113949             goto parse_uri_out;
113950           }
113951           if( mode>limit ){
113952             *pzErrMsg = sqlcipher3_mprintf("%s mode not allowed: %s",
113953                                         zModeType, zVal);
113954             rc = SQLCIPHER_PERM;
113955             goto parse_uri_out;
113956           }
113957           flags = (flags & ~mask) | mode;
113958         }
113959       }
113960
113961       zOpt = &zVal[nVal+1];
113962     }
113963
113964   }else{
113965     zFile = sqlcipher3_malloc(nUri+2);
113966     if( !zFile ) return SQLCIPHER_NOMEM;
113967     memcpy(zFile, zUri, nUri);
113968     zFile[nUri] = '\0';
113969     zFile[nUri+1] = '\0';
113970   }
113971
113972   *ppVfs = sqlcipher3_vfs_find(zVfs);
113973   if( *ppVfs==0 ){
113974     *pzErrMsg = sqlcipher3_mprintf("no such vfs: %s", zVfs);
113975     rc = SQLCIPHER_ERROR;
113976   }
113977  parse_uri_out:
113978   if( rc!=SQLCIPHER_OK ){
113979     sqlcipher3_free(zFile);
113980     zFile = 0;
113981   }
113982   *pFlags = flags;
113983   *pzFile = zFile;
113984   return rc;
113985 }
113986
113987
113988 /*
113989 ** This routine does the work of opening a database on behalf of
113990 ** sqlcipher3_open() and sqlcipher3_open16(). The database filename "zFilename"  
113991 ** is UTF-8 encoded.
113992 */
113993 static int openDatabase(
113994   const char *zFilename, /* Database filename UTF-8 encoded */
113995   sqlcipher3 **ppDb,        /* OUT: Returned database handle */
113996   unsigned int flags,    /* Operational flags */
113997   const char *zVfs       /* Name of the VFS to use */
113998 ){
113999   sqlcipher3 *db;                    /* Store allocated handle here */
114000   int rc;                         /* Return code */
114001   int isThreadsafe;               /* True for threadsafe connections */
114002   char *zOpen = 0;                /* Filename argument to pass to BtreeOpen() */
114003   char *zErrMsg = 0;              /* Error message from sqlcipher3ParseUri() */
114004
114005   *ppDb = 0;
114006 #ifndef SQLCIPHER_OMIT_AUTOINIT
114007   rc = sqlcipher3_initialize();
114008   if( rc ) return rc;
114009 #endif
114010
114011   /* Only allow sensible combinations of bits in the flags argument.  
114012   ** Throw an error if any non-sense combination is used.  If we
114013   ** do not block illegal combinations here, it could trigger
114014   ** assert() statements in deeper layers.  Sensible combinations
114015   ** are:
114016   **
114017   **  1:  SQLCIPHER_OPEN_READONLY
114018   **  2:  SQLCIPHER_OPEN_READWRITE
114019   **  6:  SQLCIPHER_OPEN_READWRITE | SQLCIPHER_OPEN_CREATE
114020   */
114021   assert( SQLCIPHER_OPEN_READONLY  == 0x01 );
114022   assert( SQLCIPHER_OPEN_READWRITE == 0x02 );
114023   assert( SQLCIPHER_OPEN_CREATE    == 0x04 );
114024   testcase( (1<<(flags&7))==0x02 ); /* READONLY */
114025   testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
114026   testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
114027   if( ((1<<(flags&7)) & 0x46)==0 ) return SQLCIPHER_MISUSE_BKPT;
114028
114029   if( sqlcipher3GlobalConfig.bCoreMutex==0 ){
114030     isThreadsafe = 0;
114031   }else if( flags & SQLCIPHER_OPEN_NOMUTEX ){
114032     isThreadsafe = 0;
114033   }else if( flags & SQLCIPHER_OPEN_FULLMUTEX ){
114034     isThreadsafe = 1;
114035   }else{
114036     isThreadsafe = sqlcipher3GlobalConfig.bFullMutex;
114037   }
114038   if( flags & SQLCIPHER_OPEN_PRIVATECACHE ){
114039     flags &= ~SQLCIPHER_OPEN_SHAREDCACHE;
114040   }else if( sqlcipher3GlobalConfig.sharedCacheEnabled ){
114041     flags |= SQLCIPHER_OPEN_SHAREDCACHE;
114042   }
114043
114044   /* Remove harmful bits from the flags parameter
114045   **
114046   ** The SQLCIPHER_OPEN_NOMUTEX and SQLCIPHER_OPEN_FULLMUTEX flags were
114047   ** dealt with in the previous code block.  Besides these, the only
114048   ** valid input flags for sqlcipher3_open_v2() are SQLCIPHER_OPEN_READONLY,
114049   ** SQLCIPHER_OPEN_READWRITE, SQLCIPHER_OPEN_CREATE, SQLCIPHER_OPEN_SHAREDCACHE,
114050   ** SQLCIPHER_OPEN_PRIVATECACHE, and some reserved bits.  Silently mask
114051   ** off all other flags.
114052   */
114053   flags &=  ~( SQLCIPHER_OPEN_DELETEONCLOSE |
114054                SQLCIPHER_OPEN_EXCLUSIVE |
114055                SQLCIPHER_OPEN_MAIN_DB |
114056                SQLCIPHER_OPEN_TEMP_DB | 
114057                SQLCIPHER_OPEN_TRANSIENT_DB | 
114058                SQLCIPHER_OPEN_MAIN_JOURNAL | 
114059                SQLCIPHER_OPEN_TEMP_JOURNAL | 
114060                SQLCIPHER_OPEN_SUBJOURNAL | 
114061                SQLCIPHER_OPEN_MASTER_JOURNAL |
114062                SQLCIPHER_OPEN_NOMUTEX |
114063                SQLCIPHER_OPEN_FULLMUTEX |
114064                SQLCIPHER_OPEN_WAL
114065              );
114066
114067   /* Allocate the sqlcipher data structure */
114068   db = sqlcipher3MallocZero( sizeof(sqlcipher3) );
114069   if( db==0 ) goto opendb_out;
114070   if( isThreadsafe ){
114071     db->mutex = sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_RECURSIVE);
114072     if( db->mutex==0 ){
114073       sqlcipher3_free(db);
114074       db = 0;
114075       goto opendb_out;
114076     }
114077   }
114078   sqlcipher3_mutex_enter(db->mutex);
114079   db->errMask = 0xff;
114080   db->nDb = 2;
114081   db->magic = SQLCIPHER_MAGIC_BUSY;
114082   db->aDb = db->aDbStatic;
114083
114084   assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
114085   memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
114086   db->autoCommit = 1;
114087   db->nextAutovac = -1;
114088   db->nextPagesize = 0;
114089   db->flags |= SQLCIPHER_ShortColNames | SQLCIPHER_AutoIndex | SQLCIPHER_EnableTrigger
114090 #if SQLCIPHER_DEFAULT_FILE_FORMAT<4
114091                  | SQLCIPHER_LegacyFileFmt
114092 #endif
114093 #ifdef SQLCIPHER_ENABLE_LOAD_EXTENSION
114094                  | SQLCIPHER_LoadExtension
114095 #endif
114096 #if SQLCIPHER_DEFAULT_RECURSIVE_TRIGGERS
114097                  | SQLCIPHER_RecTriggers
114098 #endif
114099 #if defined(SQLCIPHER_DEFAULT_FOREIGN_KEYS) && SQLCIPHER_DEFAULT_FOREIGN_KEYS
114100                  | SQLCIPHER_ForeignKeys
114101 #endif
114102       ;
114103   sqlcipher3HashInit(&db->aCollSeq);
114104 #ifndef SQLCIPHER_OMIT_VIRTUALTABLE
114105   sqlcipher3HashInit(&db->aModule);
114106 #endif
114107
114108   /* Add the default collation sequence BINARY. BINARY works for both UTF-8
114109   ** and UTF-16, so add a version for each to avoid any unnecessary
114110   ** conversions. The only error that can occur here is a malloc() failure.
114111   */
114112   createCollation(db, "BINARY", SQLCIPHER_UTF8, SQLCIPHER_COLL_BINARY, 0,
114113                   binCollFunc, 0);
114114   createCollation(db, "BINARY", SQLCIPHER_UTF16BE, SQLCIPHER_COLL_BINARY, 0,
114115                   binCollFunc, 0);
114116   createCollation(db, "BINARY", SQLCIPHER_UTF16LE, SQLCIPHER_COLL_BINARY, 0,
114117                   binCollFunc, 0);
114118   createCollation(db, "RTRIM", SQLCIPHER_UTF8, SQLCIPHER_COLL_USER, (void*)1,
114119                   binCollFunc, 0);
114120   if( db->mallocFailed ){
114121     goto opendb_out;
114122   }
114123   db->pDfltColl = sqlcipher3FindCollSeq(db, SQLCIPHER_UTF8, "BINARY", 0);
114124   assert( db->pDfltColl!=0 );
114125
114126   /* Also add a UTF-8 case-insensitive collation sequence. */
114127   createCollation(db, "NOCASE", SQLCIPHER_UTF8, SQLCIPHER_COLL_NOCASE, 0,
114128                   nocaseCollatingFunc, 0);
114129
114130   /* Parse the filename/URI argument. */
114131   db->openFlags = flags;
114132   rc = sqlcipher3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
114133   if( rc!=SQLCIPHER_OK ){
114134     if( rc==SQLCIPHER_NOMEM ) db->mallocFailed = 1;
114135     sqlcipher3Error(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
114136     sqlcipher3_free(zErrMsg);
114137     goto opendb_out;
114138   }
114139
114140   /* Open the backend database driver */
114141   rc = sqlcipher3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
114142                         flags | SQLCIPHER_OPEN_MAIN_DB);
114143   if( rc!=SQLCIPHER_OK ){
114144     if( rc==SQLCIPHER_IOERR_NOMEM ){
114145       rc = SQLCIPHER_NOMEM;
114146     }
114147     sqlcipher3Error(db, rc, 0);
114148     goto opendb_out;
114149   }
114150   db->aDb[0].pSchema = sqlcipher3SchemaGet(db, db->aDb[0].pBt);
114151   db->aDb[1].pSchema = sqlcipher3SchemaGet(db, 0);
114152
114153
114154   /* The default safety_level for the main database is 'full'; for the temp
114155   ** database it is 'NONE'. This matches the pager layer defaults.  
114156   */
114157   db->aDb[0].zName = "main";
114158   db->aDb[0].safety_level = 3;
114159   db->aDb[1].zName = "temp";
114160   db->aDb[1].safety_level = 1;
114161
114162   db->magic = SQLCIPHER_MAGIC_OPEN;
114163   if( db->mallocFailed ){
114164     goto opendb_out;
114165   }
114166
114167   /* Register all built-in functions, but do not attempt to read the
114168   ** database schema yet. This is delayed until the first time the database
114169   ** is accessed.
114170   */
114171   sqlcipher3Error(db, SQLCIPHER_OK, 0);
114172   sqlcipher3RegisterBuiltinFunctions(db);
114173
114174   /* Load automatic extensions - extensions that have been registered
114175   ** using the sqlcipher3_automatic_extension() API.
114176   */
114177   sqlcipher3AutoLoadExtensions(db);
114178   rc = sqlcipher3_errcode(db);
114179   if( rc!=SQLCIPHER_OK ){
114180     goto opendb_out;
114181   }
114182
114183 #ifdef SQLCIPHER_ENABLE_FTS1
114184   if( !db->mallocFailed ){
114185     extern int sqlcipher3Fts1Init(sqlcipher3*);
114186     rc = sqlcipher3Fts1Init(db);
114187   }
114188 #endif
114189
114190 #ifdef SQLCIPHER_ENABLE_FTS2
114191   if( !db->mallocFailed && rc==SQLCIPHER_OK ){
114192     extern int sqlcipher3Fts2Init(sqlcipher3*);
114193     rc = sqlcipher3Fts2Init(db);
114194   }
114195 #endif
114196
114197 #ifdef SQLCIPHER_ENABLE_FTS3
114198   if( !db->mallocFailed && rc==SQLCIPHER_OK ){
114199     rc = sqlcipher3Fts3Init(db);
114200   }
114201 #endif
114202
114203 #ifdef SQLCIPHER_ENABLE_ICU
114204   if( !db->mallocFailed && rc==SQLCIPHER_OK ){
114205     rc = sqlcipher3IcuInit(db);
114206   }
114207 #endif
114208
114209 #ifdef SQLCIPHER_ENABLE_RTREE
114210   if( !db->mallocFailed && rc==SQLCIPHER_OK){
114211     rc = sqlcipher3RtreeInit(db);
114212   }
114213 #endif
114214
114215   sqlcipher3Error(db, rc, 0);
114216
114217   /* -DSQLCIPHER_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
114218   ** mode.  -DSQLCIPHER_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
114219   ** mode.  Doing nothing at all also makes NORMAL the default.
114220   */
114221 #ifdef SQLCIPHER_DEFAULT_LOCKING_MODE
114222   db->dfltLockMode = SQLCIPHER_DEFAULT_LOCKING_MODE;
114223   sqlcipher3PagerLockingMode(sqlcipher3BtreePager(db->aDb[0].pBt),
114224                           SQLCIPHER_DEFAULT_LOCKING_MODE);
114225 #endif
114226
114227   /* Enable the lookaside-malloc subsystem */
114228   setupLookaside(db, 0, sqlcipher3GlobalConfig.szLookaside,
114229                         sqlcipher3GlobalConfig.nLookaside);
114230
114231   sqlcipher3_wal_autocheckpoint(db, SQLCIPHER_DEFAULT_WAL_AUTOCHECKPOINT);
114232
114233 opendb_out:
114234   sqlcipher3_free(zOpen);
114235   if( db ){
114236     assert( db->mutex!=0 || isThreadsafe==0 || sqlcipher3GlobalConfig.bFullMutex==0 );
114237     sqlcipher3_mutex_leave(db->mutex);
114238   }
114239   rc = sqlcipher3_errcode(db);
114240   assert( db!=0 || rc==SQLCIPHER_NOMEM );
114241   if( rc==SQLCIPHER_NOMEM ){
114242     sqlcipher3_close(db);
114243     db = 0;
114244   }else if( rc!=SQLCIPHER_OK ){
114245     db->magic = SQLCIPHER_MAGIC_SICK;
114246   }
114247   *ppDb = db;
114248   return sqlcipher3ApiExit(0, rc);
114249 }
114250
114251 /*
114252 ** Open a new database handle.
114253 */
114254 SQLCIPHER_API int sqlcipher3_open(
114255   const char *zFilename, 
114256   sqlcipher3 **ppDb 
114257 ){
114258   return openDatabase(zFilename, ppDb,
114259                       SQLCIPHER_OPEN_READWRITE | SQLCIPHER_OPEN_CREATE, 0);
114260 }
114261 SQLCIPHER_API int sqlcipher3_open_v2(
114262   const char *filename,   /* Database filename (UTF-8) */
114263   sqlcipher3 **ppDb,         /* OUT: SQLite db handle */
114264   int flags,              /* Flags */
114265   const char *zVfs        /* Name of VFS module to use */
114266 ){
114267   return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
114268 }
114269
114270 #ifndef SQLCIPHER_OMIT_UTF16
114271 /*
114272 ** Open a new database handle.
114273 */
114274 SQLCIPHER_API int sqlcipher3_open16(
114275   const void *zFilename, 
114276   sqlcipher3 **ppDb
114277 ){
114278   char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */
114279   sqlcipher3_value *pVal;
114280   int rc;
114281
114282   assert( zFilename );
114283   assert( ppDb );
114284   *ppDb = 0;
114285 #ifndef SQLCIPHER_OMIT_AUTOINIT
114286   rc = sqlcipher3_initialize();
114287   if( rc ) return rc;
114288 #endif
114289   pVal = sqlcipher3ValueNew(0);
114290   sqlcipher3ValueSetStr(pVal, -1, zFilename, SQLCIPHER_UTF16NATIVE, SQLCIPHER_STATIC);
114291   zFilename8 = sqlcipher3ValueText(pVal, SQLCIPHER_UTF8);
114292   if( zFilename8 ){
114293     rc = openDatabase(zFilename8, ppDb,
114294                       SQLCIPHER_OPEN_READWRITE | SQLCIPHER_OPEN_CREATE, 0);
114295     assert( *ppDb || rc==SQLCIPHER_NOMEM );
114296     if( rc==SQLCIPHER_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
114297       ENC(*ppDb) = SQLCIPHER_UTF16NATIVE;
114298     }
114299   }else{
114300     rc = SQLCIPHER_NOMEM;
114301   }
114302   sqlcipher3ValueFree(pVal);
114303
114304   return sqlcipher3ApiExit(0, rc);
114305 }
114306 #endif /* SQLCIPHER_OMIT_UTF16 */
114307
114308 /*
114309 ** Register a new collation sequence with the database handle db.
114310 */
114311 SQLCIPHER_API int sqlcipher3_create_collation(
114312   sqlcipher3* db, 
114313   const char *zName, 
114314   int enc, 
114315   void* pCtx,
114316   int(*xCompare)(void*,int,const void*,int,const void*)
114317 ){
114318   int rc;
114319   sqlcipher3_mutex_enter(db->mutex);
114320   assert( !db->mallocFailed );
114321   rc = createCollation(db, zName, (u8)enc, SQLCIPHER_COLL_USER, pCtx, xCompare, 0);
114322   rc = sqlcipher3ApiExit(db, rc);
114323   sqlcipher3_mutex_leave(db->mutex);
114324   return rc;
114325 }
114326
114327 /*
114328 ** Register a new collation sequence with the database handle db.
114329 */
114330 SQLCIPHER_API int sqlcipher3_create_collation_v2(
114331   sqlcipher3* db, 
114332   const char *zName, 
114333   int enc, 
114334   void* pCtx,
114335   int(*xCompare)(void*,int,const void*,int,const void*),
114336   void(*xDel)(void*)
114337 ){
114338   int rc;
114339   sqlcipher3_mutex_enter(db->mutex);
114340   assert( !db->mallocFailed );
114341   rc = createCollation(db, zName, (u8)enc, SQLCIPHER_COLL_USER, pCtx, xCompare, xDel);
114342   rc = sqlcipher3ApiExit(db, rc);
114343   sqlcipher3_mutex_leave(db->mutex);
114344   return rc;
114345 }
114346
114347 #ifndef SQLCIPHER_OMIT_UTF16
114348 /*
114349 ** Register a new collation sequence with the database handle db.
114350 */
114351 SQLCIPHER_API int sqlcipher3_create_collation16(
114352   sqlcipher3* db, 
114353   const void *zName,
114354   int enc, 
114355   void* pCtx,
114356   int(*xCompare)(void*,int,const void*,int,const void*)
114357 ){
114358   int rc = SQLCIPHER_OK;
114359   char *zName8;
114360   sqlcipher3_mutex_enter(db->mutex);
114361   assert( !db->mallocFailed );
114362   zName8 = sqlcipher3Utf16to8(db, zName, -1, SQLCIPHER_UTF16NATIVE);
114363   if( zName8 ){
114364     rc = createCollation(db, zName8, (u8)enc, SQLCIPHER_COLL_USER, pCtx, xCompare, 0);
114365     sqlcipher3DbFree(db, zName8);
114366   }
114367   rc = sqlcipher3ApiExit(db, rc);
114368   sqlcipher3_mutex_leave(db->mutex);
114369   return rc;
114370 }
114371 #endif /* SQLCIPHER_OMIT_UTF16 */
114372
114373 /*
114374 ** Register a collation sequence factory callback with the database handle
114375 ** db. Replace any previously installed collation sequence factory.
114376 */
114377 SQLCIPHER_API int sqlcipher3_collation_needed(
114378   sqlcipher3 *db, 
114379   void *pCollNeededArg, 
114380   void(*xCollNeeded)(void*,sqlcipher3*,int eTextRep,const char*)
114381 ){
114382   sqlcipher3_mutex_enter(db->mutex);
114383   db->xCollNeeded = xCollNeeded;
114384   db->xCollNeeded16 = 0;
114385   db->pCollNeededArg = pCollNeededArg;
114386   sqlcipher3_mutex_leave(db->mutex);
114387   return SQLCIPHER_OK;
114388 }
114389
114390 #ifndef SQLCIPHER_OMIT_UTF16
114391 /*
114392 ** Register a collation sequence factory callback with the database handle
114393 ** db. Replace any previously installed collation sequence factory.
114394 */
114395 SQLCIPHER_API int sqlcipher3_collation_needed16(
114396   sqlcipher3 *db, 
114397   void *pCollNeededArg, 
114398   void(*xCollNeeded16)(void*,sqlcipher3*,int eTextRep,const void*)
114399 ){
114400   sqlcipher3_mutex_enter(db->mutex);
114401   db->xCollNeeded = 0;
114402   db->xCollNeeded16 = xCollNeeded16;
114403   db->pCollNeededArg = pCollNeededArg;
114404   sqlcipher3_mutex_leave(db->mutex);
114405   return SQLCIPHER_OK;
114406 }
114407 #endif /* SQLCIPHER_OMIT_UTF16 */
114408
114409 #ifndef SQLCIPHER_OMIT_DEPRECATED
114410 /*
114411 ** This function is now an anachronism. It used to be used to recover from a
114412 ** malloc() failure, but SQLite now does this automatically.
114413 */
114414 SQLCIPHER_API int sqlcipher3_global_recover(void){
114415   return SQLCIPHER_OK;
114416 }
114417 #endif
114418
114419 /*
114420 ** Test to see whether or not the database connection is in autocommit
114421 ** mode.  Return TRUE if it is and FALSE if not.  Autocommit mode is on
114422 ** by default.  Autocommit is disabled by a BEGIN statement and reenabled
114423 ** by the next COMMIT or ROLLBACK.
114424 **
114425 ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
114426 */
114427 SQLCIPHER_API int sqlcipher3_get_autocommit(sqlcipher3 *db){
114428   return db->autoCommit;
114429 }
114430
114431 /*
114432 ** The following routines are subtitutes for constants SQLCIPHER_CORRUPT,
114433 ** SQLCIPHER_MISUSE, SQLCIPHER_CANTOPEN, SQLCIPHER_IOERR and possibly other error
114434 ** constants.  They server two purposes:
114435 **
114436 **   1.  Serve as a convenient place to set a breakpoint in a debugger
114437 **       to detect when version error conditions occurs.
114438 **
114439 **   2.  Invoke sqlcipher3_log() to provide the source code location where
114440 **       a low-level error is first detected.
114441 */
114442 SQLCIPHER_PRIVATE int sqlcipher3CorruptError(int lineno){
114443   testcase( sqlcipher3GlobalConfig.xLog!=0 );
114444   sqlcipher3_log(SQLCIPHER_CORRUPT,
114445               "database corruption at line %d of [%.10s]",
114446               lineno, 20+sqlcipher3_sourceid());
114447   return SQLCIPHER_CORRUPT;
114448 }
114449 SQLCIPHER_PRIVATE int sqlcipher3MisuseError(int lineno){
114450   testcase( sqlcipher3GlobalConfig.xLog!=0 );
114451   sqlcipher3_log(SQLCIPHER_MISUSE, 
114452               "misuse at line %d of [%.10s]",
114453               lineno, 20+sqlcipher3_sourceid());
114454   return SQLCIPHER_MISUSE;
114455 }
114456 SQLCIPHER_PRIVATE int sqlcipher3CantopenError(int lineno){
114457   testcase( sqlcipher3GlobalConfig.xLog!=0 );
114458   sqlcipher3_log(SQLCIPHER_CANTOPEN, 
114459               "cannot open file at line %d of [%.10s]",
114460               lineno, 20+sqlcipher3_sourceid());
114461   return SQLCIPHER_CANTOPEN;
114462 }
114463
114464
114465 #ifndef SQLCIPHER_OMIT_DEPRECATED
114466 /*
114467 ** This is a convenience routine that makes sure that all thread-specific
114468 ** data for this thread has been deallocated.
114469 **
114470 ** SQLite no longer uses thread-specific data so this routine is now a
114471 ** no-op.  It is retained for historical compatibility.
114472 */
114473 SQLCIPHER_API void sqlcipher3_thread_cleanup(void){
114474 }
114475 #endif
114476
114477 /*
114478 ** Return meta information about a specific column of a database table.
114479 ** See comment in sqlcipher3.h (sqlcipher.h.in) for details.
114480 */
114481 #ifdef SQLCIPHER_ENABLE_COLUMN_METADATA
114482 SQLCIPHER_API int sqlcipher3_table_column_metadata(
114483   sqlcipher3 *db,                /* Connection handle */
114484   const char *zDbName,        /* Database name or NULL */
114485   const char *zTableName,     /* Table name */
114486   const char *zColumnName,    /* Column name */
114487   char const **pzDataType,    /* OUTPUT: Declared data type */
114488   char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
114489   int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
114490   int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
114491   int *pAutoinc               /* OUTPUT: True if column is auto-increment */
114492 ){
114493   int rc;
114494   char *zErrMsg = 0;
114495   Table *pTab = 0;
114496   Column *pCol = 0;
114497   int iCol;
114498
114499   char const *zDataType = 0;
114500   char const *zCollSeq = 0;
114501   int notnull = 0;
114502   int primarykey = 0;
114503   int autoinc = 0;
114504
114505   /* Ensure the database schema has been loaded */
114506   sqlcipher3_mutex_enter(db->mutex);
114507   sqlcipher3BtreeEnterAll(db);
114508   rc = sqlcipher3Init(db, &zErrMsg);
114509   if( SQLCIPHER_OK!=rc ){
114510     goto error_out;
114511   }
114512
114513   /* Locate the table in question */
114514   pTab = sqlcipher3FindTable(db, zTableName, zDbName);
114515   if( !pTab || pTab->pSelect ){
114516     pTab = 0;
114517     goto error_out;
114518   }
114519
114520   /* Find the column for which info is requested */
114521   if( sqlcipher3IsRowid(zColumnName) ){
114522     iCol = pTab->iPKey;
114523     if( iCol>=0 ){
114524       pCol = &pTab->aCol[iCol];
114525     }
114526   }else{
114527     for(iCol=0; iCol<pTab->nCol; iCol++){
114528       pCol = &pTab->aCol[iCol];
114529       if( 0==sqlcipher3StrICmp(pCol->zName, zColumnName) ){
114530         break;
114531       }
114532     }
114533     if( iCol==pTab->nCol ){
114534       pTab = 0;
114535       goto error_out;
114536     }
114537   }
114538
114539   /* The following block stores the meta information that will be returned
114540   ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
114541   ** and autoinc. At this point there are two possibilities:
114542   ** 
114543   **     1. The specified column name was rowid", "oid" or "_rowid_" 
114544   **        and there is no explicitly declared IPK column. 
114545   **
114546   **     2. The table is not a view and the column name identified an 
114547   **        explicitly declared column. Copy meta information from *pCol.
114548   */ 
114549   if( pCol ){
114550     zDataType = pCol->zType;
114551     zCollSeq = pCol->zColl;
114552     notnull = pCol->notNull!=0;
114553     primarykey  = pCol->isPrimKey!=0;
114554     autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
114555   }else{
114556     zDataType = "INTEGER";
114557     primarykey = 1;
114558   }
114559   if( !zCollSeq ){
114560     zCollSeq = "BINARY";
114561   }
114562
114563 error_out:
114564   sqlcipher3BtreeLeaveAll(db);
114565
114566   /* Whether the function call succeeded or failed, set the output parameters
114567   ** to whatever their local counterparts contain. If an error did occur,
114568   ** this has the effect of zeroing all output parameters.
114569   */
114570   if( pzDataType ) *pzDataType = zDataType;
114571   if( pzCollSeq ) *pzCollSeq = zCollSeq;
114572   if( pNotNull ) *pNotNull = notnull;
114573   if( pPrimaryKey ) *pPrimaryKey = primarykey;
114574   if( pAutoinc ) *pAutoinc = autoinc;
114575
114576   if( SQLCIPHER_OK==rc && !pTab ){
114577     sqlcipher3DbFree(db, zErrMsg);
114578     zErrMsg = sqlcipher3MPrintf(db, "no such table column: %s.%s", zTableName,
114579         zColumnName);
114580     rc = SQLCIPHER_ERROR;
114581   }
114582   sqlcipher3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
114583   sqlcipher3DbFree(db, zErrMsg);
114584   rc = sqlcipher3ApiExit(db, rc);
114585   sqlcipher3_mutex_leave(db->mutex);
114586   return rc;
114587 }
114588 #endif
114589
114590 /*
114591 ** Sleep for a little while.  Return the amount of time slept.
114592 */
114593 SQLCIPHER_API int sqlcipher3_sleep(int ms){
114594   sqlcipher3_vfs *pVfs;
114595   int rc;
114596   pVfs = sqlcipher3_vfs_find(0);
114597   if( pVfs==0 ) return 0;
114598
114599   /* This function works in milliseconds, but the underlying OsSleep() 
114600   ** API uses microseconds. Hence the 1000's.
114601   */
114602   rc = (sqlcipher3OsSleep(pVfs, 1000*ms)/1000);
114603   return rc;
114604 }
114605
114606 /*
114607 ** Enable or disable the extended result codes.
114608 */
114609 SQLCIPHER_API int sqlcipher3_extended_result_codes(sqlcipher3 *db, int onoff){
114610   sqlcipher3_mutex_enter(db->mutex);
114611   db->errMask = onoff ? 0xffffffff : 0xff;
114612   sqlcipher3_mutex_leave(db->mutex);
114613   return SQLCIPHER_OK;
114614 }
114615
114616 /*
114617 ** Invoke the xFileControl method on a particular database.
114618 */
114619 SQLCIPHER_API int sqlcipher3_file_control(sqlcipher3 *db, const char *zDbName, int op, void *pArg){
114620   int rc = SQLCIPHER_ERROR;
114621   int iDb;
114622   sqlcipher3_mutex_enter(db->mutex);
114623   if( zDbName==0 ){
114624     iDb = 0;
114625   }else{
114626     for(iDb=0; iDb<db->nDb; iDb++){
114627       if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
114628     }
114629   }
114630   if( iDb<db->nDb ){
114631     Btree *pBtree = db->aDb[iDb].pBt;
114632     if( pBtree ){
114633       Pager *pPager;
114634       sqlcipher3_file *fd;
114635       sqlcipher3BtreeEnter(pBtree);
114636       pPager = sqlcipher3BtreePager(pBtree);
114637       assert( pPager!=0 );
114638       fd = sqlcipher3PagerFile(pPager);
114639       assert( fd!=0 );
114640       if( op==SQLCIPHER_FCNTL_FILE_POINTER ){
114641         *(sqlcipher3_file**)pArg = fd;
114642         rc = SQLCIPHER_OK;
114643       }else if( fd->pMethods ){
114644         rc = sqlcipher3OsFileControl(fd, op, pArg);
114645       }else{
114646         rc = SQLCIPHER_NOTFOUND;
114647       }
114648       sqlcipher3BtreeLeave(pBtree);
114649     }
114650   }
114651   sqlcipher3_mutex_leave(db->mutex);
114652   return rc;   
114653 }
114654
114655 /*
114656 ** Interface to the testing logic.
114657 */
114658 SQLCIPHER_API int sqlcipher3_test_control(int op, ...){
114659   int rc = 0;
114660 #ifndef SQLCIPHER_OMIT_BUILTIN_TEST
114661   va_list ap;
114662   va_start(ap, op);
114663   switch( op ){
114664
114665     /*
114666     ** Save the current state of the PRNG.
114667     */
114668     case SQLCIPHER_TESTCTRL_PRNG_SAVE: {
114669       sqlcipher3PrngSaveState();
114670       break;
114671     }
114672
114673     /*
114674     ** Restore the state of the PRNG to the last state saved using
114675     ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
114676     ** this verb acts like PRNG_RESET.
114677     */
114678     case SQLCIPHER_TESTCTRL_PRNG_RESTORE: {
114679       sqlcipher3PrngRestoreState();
114680       break;
114681     }
114682
114683     /*
114684     ** Reset the PRNG back to its uninitialized state.  The next call
114685     ** to sqlcipher3_randomness() will reseed the PRNG using a single call
114686     ** to the xRandomness method of the default VFS.
114687     */
114688     case SQLCIPHER_TESTCTRL_PRNG_RESET: {
114689       sqlcipher3PrngResetState();
114690       break;
114691     }
114692
114693     /*
114694     **  sqlcipher3_test_control(BITVEC_TEST, size, program)
114695     **
114696     ** Run a test against a Bitvec object of size.  The program argument
114697     ** is an array of integers that defines the test.  Return -1 on a
114698     ** memory allocation error, 0 on success, or non-zero for an error.
114699     ** See the sqlcipher3BitvecBuiltinTest() for additional information.
114700     */
114701     case SQLCIPHER_TESTCTRL_BITVEC_TEST: {
114702       int sz = va_arg(ap, int);
114703       int *aProg = va_arg(ap, int*);
114704       rc = sqlcipher3BitvecBuiltinTest(sz, aProg);
114705       break;
114706     }
114707
114708     /*
114709     **  sqlcipher3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
114710     **
114711     ** Register hooks to call to indicate which malloc() failures 
114712     ** are benign.
114713     */
114714     case SQLCIPHER_TESTCTRL_BENIGN_MALLOC_HOOKS: {
114715       typedef void (*void_function)(void);
114716       void_function xBenignBegin;
114717       void_function xBenignEnd;
114718       xBenignBegin = va_arg(ap, void_function);
114719       xBenignEnd = va_arg(ap, void_function);
114720       sqlcipher3BenignMallocHooks(xBenignBegin, xBenignEnd);
114721       break;
114722     }
114723
114724     /*
114725     **  sqlcipher3_test_control(SQLCIPHER_TESTCTRL_PENDING_BYTE, unsigned int X)
114726     **
114727     ** Set the PENDING byte to the value in the argument, if X>0.
114728     ** Make no changes if X==0.  Return the value of the pending byte
114729     ** as it existing before this routine was called.
114730     **
114731     ** IMPORTANT:  Changing the PENDING byte from 0x40000000 results in
114732     ** an incompatible database file format.  Changing the PENDING byte
114733     ** while any database connection is open results in undefined and
114734     ** dileterious behavior.
114735     */
114736     case SQLCIPHER_TESTCTRL_PENDING_BYTE: {
114737       rc = PENDING_BYTE;
114738 #ifndef SQLCIPHER_OMIT_WSD
114739       {
114740         unsigned int newVal = va_arg(ap, unsigned int);
114741         if( newVal ) sqlcipher3PendingByte = newVal;
114742       }
114743 #endif
114744       break;
114745     }
114746
114747     /*
114748     **  sqlcipher3_test_control(SQLCIPHER_TESTCTRL_ASSERT, int X)
114749     **
114750     ** This action provides a run-time test to see whether or not
114751     ** assert() was enabled at compile-time.  If X is true and assert()
114752     ** is enabled, then the return value is true.  If X is true and
114753     ** assert() is disabled, then the return value is zero.  If X is
114754     ** false and assert() is enabled, then the assertion fires and the
114755     ** process aborts.  If X is false and assert() is disabled, then the
114756     ** return value is zero.
114757     */
114758     case SQLCIPHER_TESTCTRL_ASSERT: {
114759       volatile int x = 0;
114760       assert( (x = va_arg(ap,int))!=0 );
114761       rc = x;
114762       break;
114763     }
114764
114765
114766     /*
114767     **  sqlcipher3_test_control(SQLCIPHER_TESTCTRL_ALWAYS, int X)
114768     **
114769     ** This action provides a run-time test to see how the ALWAYS and
114770     ** NEVER macros were defined at compile-time.
114771     **
114772     ** The return value is ALWAYS(X).  
114773     **
114774     ** The recommended test is X==2.  If the return value is 2, that means
114775     ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
114776     ** default setting.  If the return value is 1, then ALWAYS() is either
114777     ** hard-coded to true or else it asserts if its argument is false.
114778     ** The first behavior (hard-coded to true) is the case if
114779     ** SQLCIPHER_TESTCTRL_ASSERT shows that assert() is disabled and the second
114780     ** behavior (assert if the argument to ALWAYS() is false) is the case if
114781     ** SQLCIPHER_TESTCTRL_ASSERT shows that assert() is enabled.
114782     **
114783     ** The run-time test procedure might look something like this:
114784     **
114785     **    if( sqlcipher3_test_control(SQLCIPHER_TESTCTRL_ALWAYS, 2)==2 ){
114786     **      // ALWAYS() and NEVER() are no-op pass-through macros
114787     **    }else if( sqlcipher3_test_control(SQLCIPHER_TESTCTRL_ASSERT, 1) ){
114788     **      // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
114789     **    }else{
114790     **      // ALWAYS(x) is a constant 1.  NEVER(x) is a constant 0.
114791     **    }
114792     */
114793     case SQLCIPHER_TESTCTRL_ALWAYS: {
114794       int x = va_arg(ap,int);
114795       rc = ALWAYS(x);
114796       break;
114797     }
114798
114799     /*   sqlcipher3_test_control(SQLCIPHER_TESTCTRL_RESERVE, sqlcipher3 *db, int N)
114800     **
114801     ** Set the nReserve size to N for the main database on the database
114802     ** connection db.
114803     */
114804     case SQLCIPHER_TESTCTRL_RESERVE: {
114805       sqlcipher3 *db = va_arg(ap, sqlcipher3*);
114806       int x = va_arg(ap,int);
114807       sqlcipher3_mutex_enter(db->mutex);
114808       sqlcipher3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
114809       sqlcipher3_mutex_leave(db->mutex);
114810       break;
114811     }
114812
114813     /*  sqlcipher3_test_control(SQLCIPHER_TESTCTRL_OPTIMIZATIONS, sqlcipher3 *db, int N)
114814     **
114815     ** Enable or disable various optimizations for testing purposes.  The 
114816     ** argument N is a bitmask of optimizations to be disabled.  For normal
114817     ** operation N should be 0.  The idea is that a test program (like the
114818     ** SQL Logic Test or SLT test module) can run the same SQL multiple times
114819     ** with various optimizations disabled to verify that the same answer
114820     ** is obtained in every case.
114821     */
114822     case SQLCIPHER_TESTCTRL_OPTIMIZATIONS: {
114823       sqlcipher3 *db = va_arg(ap, sqlcipher3*);
114824       int x = va_arg(ap,int);
114825       db->flags = (x & SQLCIPHER_OptMask) | (db->flags & ~SQLCIPHER_OptMask);
114826       break;
114827     }
114828
114829 #ifdef SQLCIPHER_N_KEYWORD
114830     /* sqlcipher3_test_control(SQLCIPHER_TESTCTRL_ISKEYWORD, const char *zWord)
114831     **
114832     ** If zWord is a keyword recognized by the parser, then return the
114833     ** number of keywords.  Or if zWord is not a keyword, return 0.
114834     ** 
114835     ** This test feature is only available in the amalgamation since
114836     ** the SQLCIPHER_N_KEYWORD macro is not defined in this file if SQLite
114837     ** is built using separate source files.
114838     */
114839     case SQLCIPHER_TESTCTRL_ISKEYWORD: {
114840       const char *zWord = va_arg(ap, const char*);
114841       int n = sqlcipher3Strlen30(zWord);
114842       rc = (sqlcipher3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLCIPHER_N_KEYWORD : 0;
114843       break;
114844     }
114845 #endif 
114846
114847     /* sqlcipher3_test_control(SQLCIPHER_TESTCTRL_PGHDRSZ)
114848     **
114849     ** Return the size of a pcache header in bytes.
114850     */
114851     case SQLCIPHER_TESTCTRL_PGHDRSZ: {
114852       rc = sizeof(PgHdr);
114853       break;
114854     }
114855
114856     /* sqlcipher3_test_control(SQLCIPHER_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
114857     **
114858     ** Pass pFree into sqlcipher3ScratchFree(). 
114859     ** If sz>0 then allocate a scratch buffer into pNew.  
114860     */
114861     case SQLCIPHER_TESTCTRL_SCRATCHMALLOC: {
114862       void *pFree, **ppNew;
114863       int sz;
114864       sz = va_arg(ap, int);
114865       ppNew = va_arg(ap, void**);
114866       pFree = va_arg(ap, void*);
114867       if( sz ) *ppNew = sqlcipher3ScratchMalloc(sz);
114868       sqlcipher3ScratchFree(pFree);
114869       break;
114870     }
114871
114872     /*   sqlcipher3_test_control(SQLCIPHER_TESTCTRL_LOCALTIME_FAULT, int onoff);
114873     **
114874     ** If parameter onoff is non-zero, configure the wrappers so that all
114875     ** subsequent calls to localtime() and variants fail. If onoff is zero,
114876     ** undo this setting.
114877     */
114878     case SQLCIPHER_TESTCTRL_LOCALTIME_FAULT: {
114879       sqlcipher3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
114880       break;
114881     }
114882
114883   }
114884   va_end(ap);
114885 #endif /* SQLCIPHER_OMIT_BUILTIN_TEST */
114886   return rc;
114887 }
114888
114889 /*
114890 ** This is a utility routine, useful to VFS implementations, that checks
114891 ** to see if a database file was a URI that contained a specific query 
114892 ** parameter, and if so obtains the value of the query parameter.
114893 **
114894 ** The zFilename argument is the filename pointer passed into the xOpen()
114895 ** method of a VFS implementation.  The zParam argument is the name of the
114896 ** query parameter we seek.  This routine returns the value of the zParam
114897 ** parameter if it exists.  If the parameter does not exist, this routine
114898 ** returns a NULL pointer.
114899 */
114900 SQLCIPHER_API const char *sqlcipher3_uri_parameter(const char *zFilename, const char *zParam){
114901   zFilename += sqlcipher3Strlen30(zFilename) + 1;
114902   while( zFilename[0] ){
114903     int x = strcmp(zFilename, zParam);
114904     zFilename += sqlcipher3Strlen30(zFilename) + 1;
114905     if( x==0 ) return zFilename;
114906     zFilename += sqlcipher3Strlen30(zFilename) + 1;
114907   }
114908   return 0;
114909 }
114910
114911 /************** End of main.c ************************************************/
114912 /************** Begin file notify.c ******************************************/
114913 /*
114914 ** 2009 March 3
114915 **
114916 ** The author disclaims copyright to this source code.  In place of
114917 ** a legal notice, here is a blessing:
114918 **
114919 **    May you do good and not evil.
114920 **    May you find forgiveness for yourself and forgive others.
114921 **    May you share freely, never taking more than you give.
114922 **
114923 *************************************************************************
114924 **
114925 ** This file contains the implementation of the sqlcipher3_unlock_notify()
114926 ** API method and its associated functionality.
114927 */
114928
114929 /* Omit this entire file if SQLCIPHER_ENABLE_UNLOCK_NOTIFY is not defined. */
114930 #ifdef SQLCIPHER_ENABLE_UNLOCK_NOTIFY
114931
114932 /*
114933 ** Public interfaces:
114934 **
114935 **   sqlcipher3ConnectionBlocked()
114936 **   sqlcipher3ConnectionUnlocked()
114937 **   sqlcipher3ConnectionClosed()
114938 **   sqlcipher3_unlock_notify()
114939 */
114940
114941 #define assertMutexHeld() \
114942   assert( sqlcipher3_mutex_held(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER)) )
114943
114944 /*
114945 ** Head of a linked list of all sqlcipher3 objects created by this process
114946 ** for which either sqlcipher3.pBlockingConnection or sqlcipher3.pUnlockConnection
114947 ** is not NULL. This variable may only accessed while the STATIC_MASTER
114948 ** mutex is held.
114949 */
114950 static sqlcipher3 *SQLCIPHER_WSD sqlcipher3BlockedList = 0;
114951
114952 #ifndef NDEBUG
114953 /*
114954 ** This function is a complex assert() that verifies the following 
114955 ** properties of the blocked connections list:
114956 **
114957 **   1) Each entry in the list has a non-NULL value for either 
114958 **      pUnlockConnection or pBlockingConnection, or both.
114959 **
114960 **   2) All entries in the list that share a common value for 
114961 **      xUnlockNotify are grouped together.
114962 **
114963 **   3) If the argument db is not NULL, then none of the entries in the
114964 **      blocked connections list have pUnlockConnection or pBlockingConnection
114965 **      set to db. This is used when closing connection db.
114966 */
114967 static void checkListProperties(sqlcipher3 *db){
114968   sqlcipher3 *p;
114969   for(p=sqlcipher3BlockedList; p; p=p->pNextBlocked){
114970     int seen = 0;
114971     sqlcipher3 *p2;
114972
114973     /* Verify property (1) */
114974     assert( p->pUnlockConnection || p->pBlockingConnection );
114975
114976     /* Verify property (2) */
114977     for(p2=sqlcipher3BlockedList; p2!=p; p2=p2->pNextBlocked){
114978       if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
114979       assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
114980       assert( db==0 || p->pUnlockConnection!=db );
114981       assert( db==0 || p->pBlockingConnection!=db );
114982     }
114983   }
114984 }
114985 #else
114986 # define checkListProperties(x)
114987 #endif
114988
114989 /*
114990 ** Remove connection db from the blocked connections list. If connection
114991 ** db is not currently a part of the list, this function is a no-op.
114992 */
114993 static void removeFromBlockedList(sqlcipher3 *db){
114994   sqlcipher3 **pp;
114995   assertMutexHeld();
114996   for(pp=&sqlcipher3BlockedList; *pp; pp = &(*pp)->pNextBlocked){
114997     if( *pp==db ){
114998       *pp = (*pp)->pNextBlocked;
114999       break;
115000     }
115001   }
115002 }
115003
115004 /*
115005 ** Add connection db to the blocked connections list. It is assumed
115006 ** that it is not already a part of the list.
115007 */
115008 static void addToBlockedList(sqlcipher3 *db){
115009   sqlcipher3 **pp;
115010   assertMutexHeld();
115011   for(
115012     pp=&sqlcipher3BlockedList; 
115013     *pp && (*pp)->xUnlockNotify!=db->xUnlockNotify; 
115014     pp=&(*pp)->pNextBlocked
115015   );
115016   db->pNextBlocked = *pp;
115017   *pp = db;
115018 }
115019
115020 /*
115021 ** Obtain the STATIC_MASTER mutex.
115022 */
115023 static void enterMutex(void){
115024   sqlcipher3_mutex_enter(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
115025   checkListProperties(0);
115026 }
115027
115028 /*
115029 ** Release the STATIC_MASTER mutex.
115030 */
115031 static void leaveMutex(void){
115032   assertMutexHeld();
115033   checkListProperties(0);
115034   sqlcipher3_mutex_leave(sqlcipher3MutexAlloc(SQLCIPHER_MUTEX_STATIC_MASTER));
115035 }
115036
115037 /*
115038 ** Register an unlock-notify callback.
115039 **
115040 ** This is called after connection "db" has attempted some operation
115041 ** but has received an SQLCIPHER_LOCKED error because another connection
115042 ** (call it pOther) in the same process was busy using the same shared
115043 ** cache.  pOther is found by looking at db->pBlockingConnection.
115044 **
115045 ** If there is no blocking connection, the callback is invoked immediately,
115046 ** before this routine returns.
115047 **
115048 ** If pOther is already blocked on db, then report SQLCIPHER_LOCKED, to indicate
115049 ** a deadlock.
115050 **
115051 ** Otherwise, make arrangements to invoke xNotify when pOther drops
115052 ** its locks.
115053 **
115054 ** Each call to this routine overrides any prior callbacks registered
115055 ** on the same "db".  If xNotify==0 then any prior callbacks are immediately
115056 ** cancelled.
115057 */
115058 SQLCIPHER_API int sqlcipher3_unlock_notify(
115059   sqlcipher3 *db,
115060   void (*xNotify)(void **, int),
115061   void *pArg
115062 ){
115063   int rc = SQLCIPHER_OK;
115064
115065   sqlcipher3_mutex_enter(db->mutex);
115066   enterMutex();
115067
115068   if( xNotify==0 ){
115069     removeFromBlockedList(db);
115070     db->pBlockingConnection = 0;
115071     db->pUnlockConnection = 0;
115072     db->xUnlockNotify = 0;
115073     db->pUnlockArg = 0;
115074   }else if( 0==db->pBlockingConnection ){
115075     /* The blocking transaction has been concluded. Or there never was a 
115076     ** blocking transaction. In either case, invoke the notify callback
115077     ** immediately. 
115078     */
115079     xNotify(&pArg, 1);
115080   }else{
115081     sqlcipher3 *p;
115082
115083     for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){}
115084     if( p ){
115085       rc = SQLCIPHER_LOCKED;              /* Deadlock detected. */
115086     }else{
115087       db->pUnlockConnection = db->pBlockingConnection;
115088       db->xUnlockNotify = xNotify;
115089       db->pUnlockArg = pArg;
115090       removeFromBlockedList(db);
115091       addToBlockedList(db);
115092     }
115093   }
115094
115095   leaveMutex();
115096   assert( !db->mallocFailed );
115097   sqlcipher3Error(db, rc, (rc?"database is deadlocked":0));
115098   sqlcipher3_mutex_leave(db->mutex);
115099   return rc;
115100 }
115101
115102 /*
115103 ** This function is called while stepping or preparing a statement 
115104 ** associated with connection db. The operation will return SQLCIPHER_LOCKED
115105 ** to the user because it requires a lock that will not be available
115106 ** until connection pBlocker concludes its current transaction.
115107 */
115108 SQLCIPHER_PRIVATE void sqlcipher3ConnectionBlocked(sqlcipher3 *db, sqlcipher3 *pBlocker){
115109   enterMutex();
115110   if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){
115111     addToBlockedList(db);
115112   }
115113   db->pBlockingConnection = pBlocker;
115114   leaveMutex();
115115 }
115116
115117 /*
115118 ** This function is called when
115119 ** the transaction opened by database db has just finished. Locks held 
115120 ** by database connection db have been released.
115121 **
115122 ** This function loops through each entry in the blocked connections
115123 ** list and does the following:
115124 **
115125 **   1) If the sqlcipher3.pBlockingConnection member of a list entry is
115126 **      set to db, then set pBlockingConnection=0.
115127 **
115128 **   2) If the sqlcipher3.pUnlockConnection member of a list entry is
115129 **      set to db, then invoke the configured unlock-notify callback and
115130 **      set pUnlockConnection=0.
115131 **
115132 **   3) If the two steps above mean that pBlockingConnection==0 and
115133 **      pUnlockConnection==0, remove the entry from the blocked connections
115134 **      list.
115135 */
115136 SQLCIPHER_PRIVATE void sqlcipher3ConnectionUnlocked(sqlcipher3 *db){
115137   void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */
115138   int nArg = 0;                            /* Number of entries in aArg[] */
115139   sqlcipher3 **pp;                            /* Iterator variable */
115140   void **aArg;               /* Arguments to the unlock callback */
115141   void **aDyn = 0;           /* Dynamically allocated space for aArg[] */
115142   void *aStatic[16];         /* Starter space for aArg[].  No malloc required */
115143
115144   aArg = aStatic;
115145   enterMutex();         /* Enter STATIC_MASTER mutex */
115146
115147   /* This loop runs once for each entry in the blocked-connections list. */
115148   for(pp=&sqlcipher3BlockedList; *pp; /* no-op */ ){
115149     sqlcipher3 *p = *pp;
115150
115151     /* Step 1. */
115152     if( p->pBlockingConnection==db ){
115153       p->pBlockingConnection = 0;
115154     }
115155
115156     /* Step 2. */
115157     if( p->pUnlockConnection==db ){
115158       assert( p->xUnlockNotify );
115159       if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){
115160         xUnlockNotify(aArg, nArg);
115161         nArg = 0;
115162       }
115163
115164       sqlcipher3BeginBenignMalloc();
115165       assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
115166       assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
115167       if( (!aDyn && nArg==(int)ArraySize(aStatic))
115168        || (aDyn && nArg==(int)(sqlcipher3MallocSize(aDyn)/sizeof(void*)))
115169       ){
115170         /* The aArg[] array needs to grow. */
115171         void **pNew = (void **)sqlcipher3Malloc(nArg*sizeof(void *)*2);
115172         if( pNew ){
115173           memcpy(pNew, aArg, nArg*sizeof(void *));
115174           sqlcipher3_free(aDyn);
115175           aDyn = aArg = pNew;
115176         }else{
115177           /* This occurs when the array of context pointers that need to
115178           ** be passed to the unlock-notify callback is larger than the
115179           ** aStatic[] array allocated on the stack and the attempt to 
115180           ** allocate a larger array from the heap has failed.
115181           **
115182           ** This is a difficult situation to handle. Returning an error
115183           ** code to the caller is insufficient, as even if an error code
115184           ** is returned the transaction on connection db will still be
115185           ** closed and the unlock-notify callbacks on blocked connections
115186           ** will go unissued. This might cause the application to wait
115187           ** indefinitely for an unlock-notify callback that will never 
115188           ** arrive.
115189           **
115190           ** Instead, invoke the unlock-notify callback with the context
115191           ** array already accumulated. We can then clear the array and
115192           ** begin accumulating any further context pointers without 
115193           ** requiring any dynamic allocation. This is sub-optimal because
115194           ** it means that instead of one callback with a large array of
115195           ** context pointers the application will receive two or more
115196           ** callbacks with smaller arrays of context pointers, which will
115197           ** reduce the applications ability to prioritize multiple 
115198           ** connections. But it is the best that can be done under the
115199           ** circumstances.
115200           */
115201           xUnlockNotify(aArg, nArg);
115202           nArg = 0;
115203         }
115204       }
115205       sqlcipher3EndBenignMalloc();
115206
115207       aArg[nArg++] = p->pUnlockArg;
115208       xUnlockNotify = p->xUnlockNotify;
115209       p->pUnlockConnection = 0;
115210       p->xUnlockNotify = 0;
115211       p->pUnlockArg = 0;
115212     }
115213
115214     /* Step 3. */
115215     if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){
115216       /* Remove connection p from the blocked connections list. */
115217       *pp = p->pNextBlocked;
115218       p->pNextBlocked = 0;
115219     }else{
115220       pp = &p->pNextBlocked;
115221     }
115222   }
115223
115224   if( nArg!=0 ){
115225     xUnlockNotify(aArg, nArg);
115226   }
115227   sqlcipher3_free(aDyn);
115228   leaveMutex();         /* Leave STATIC_MASTER mutex */
115229 }
115230
115231 /*
115232 ** This is called when the database connection passed as an argument is 
115233 ** being closed. The connection is removed from the blocked list.
115234 */
115235 SQLCIPHER_PRIVATE void sqlcipher3ConnectionClosed(sqlcipher3 *db){
115236   sqlcipher3ConnectionUnlocked(db);
115237   enterMutex();
115238   removeFromBlockedList(db);
115239   checkListProperties(db);
115240   leaveMutex();
115241 }
115242 #endif
115243
115244 /************** End of notify.c **********************************************/
115245 /************** Begin file fts3.c ********************************************/
115246 /*
115247 ** 2006 Oct 10
115248 **
115249 ** The author disclaims copyright to this source code.  In place of
115250 ** a legal notice, here is a blessing:
115251 **
115252 **    May you do good and not evil.
115253 **    May you find forgiveness for yourself and forgive others.
115254 **    May you share freely, never taking more than you give.
115255 **
115256 ******************************************************************************
115257 **
115258 ** This is an SQLite module implementing full-text search.
115259 */
115260
115261 /*
115262 ** The code in this file is only compiled if:
115263 **
115264 **     * The FTS3 module is being built as an extension
115265 **       (in which case SQLCIPHER_CORE is not defined), or
115266 **
115267 **     * The FTS3 module is being built into the core of
115268 **       SQLite (in which case SQLCIPHER_ENABLE_FTS3 is defined).
115269 */
115270
115271 /* The full-text index is stored in a series of b+tree (-like)
115272 ** structures called segments which map terms to doclists.  The
115273 ** structures are like b+trees in layout, but are constructed from the
115274 ** bottom up in optimal fashion and are not updatable.  Since trees
115275 ** are built from the bottom up, things will be described from the
115276 ** bottom up.
115277 **
115278 **
115279 **** Varints ****
115280 ** The basic unit of encoding is a variable-length integer called a
115281 ** varint.  We encode variable-length integers in little-endian order
115282 ** using seven bits * per byte as follows:
115283 **
115284 ** KEY:
115285 **         A = 0xxxxxxx    7 bits of data and one flag bit
115286 **         B = 1xxxxxxx    7 bits of data and one flag bit
115287 **
115288 **  7 bits - A
115289 ** 14 bits - BA
115290 ** 21 bits - BBA
115291 ** and so on.
115292 **
115293 ** This is similar in concept to how sqlcipher encodes "varints" but
115294 ** the encoding is not the same.  SQLite varints are big-endian
115295 ** are are limited to 9 bytes in length whereas FTS3 varints are
115296 ** little-endian and can be up to 10 bytes in length (in theory).
115297 **
115298 ** Example encodings:
115299 **
115300 **     1:    0x01
115301 **   127:    0x7f
115302 **   128:    0x81 0x00
115303 **
115304 **
115305 **** Document lists ****
115306 ** A doclist (document list) holds a docid-sorted list of hits for a
115307 ** given term.  Doclists hold docids and associated token positions.
115308 ** A docid is the unique integer identifier for a single document.
115309 ** A position is the index of a word within the document.  The first 
115310 ** word of the document has a position of 0.
115311 **
115312 ** FTS3 used to optionally store character offsets using a compile-time
115313 ** option.  But that functionality is no longer supported.
115314 **
115315 ** A doclist is stored like this:
115316 **
115317 ** array {
115318 **   varint docid;
115319 **   array {                (position list for column 0)
115320 **     varint position;     (2 more than the delta from previous position)
115321 **   }
115322 **   array {
115323 **     varint POS_COLUMN;   (marks start of position list for new column)
115324 **     varint column;       (index of new column)
115325 **     array {
115326 **       varint position;   (2 more than the delta from previous position)
115327 **     }
115328 **   }
115329 **   varint POS_END;        (marks end of positions for this document.
115330 ** }
115331 **
115332 ** Here, array { X } means zero or more occurrences of X, adjacent in
115333 ** memory.  A "position" is an index of a token in the token stream
115334 ** generated by the tokenizer. Note that POS_END and POS_COLUMN occur 
115335 ** in the same logical place as the position element, and act as sentinals
115336 ** ending a position list array.  POS_END is 0.  POS_COLUMN is 1.
115337 ** The positions numbers are not stored literally but rather as two more
115338 ** than the difference from the prior position, or the just the position plus
115339 ** 2 for the first position.  Example:
115340 **
115341 **   label:       A B C D E  F  G H   I  J K
115342 **   value:     123 5 9 1 1 14 35 0 234 72 0
115343 **
115344 ** The 123 value is the first docid.  For column zero in this document
115345 ** there are two matches at positions 3 and 10 (5-2 and 9-2+3).  The 1
115346 ** at D signals the start of a new column; the 1 at E indicates that the
115347 ** new column is column number 1.  There are two positions at 12 and 45
115348 ** (14-2 and 35-2+12).  The 0 at H indicate the end-of-document.  The
115349 ** 234 at I is the next docid.  It has one position 72 (72-2) and then
115350 ** terminates with the 0 at K.
115351 **
115352 ** A "position-list" is the list of positions for multiple columns for
115353 ** a single docid.  A "column-list" is the set of positions for a single
115354 ** column.  Hence, a position-list consists of one or more column-lists,
115355 ** a document record consists of a docid followed by a position-list and
115356 ** a doclist consists of one or more document records.
115357 **
115358 ** A bare doclist omits the position information, becoming an 
115359 ** array of varint-encoded docids.
115360 **
115361 **** Segment leaf nodes ****
115362 ** Segment leaf nodes store terms and doclists, ordered by term.  Leaf
115363 ** nodes are written using LeafWriter, and read using LeafReader (to
115364 ** iterate through a single leaf node's data) and LeavesReader (to
115365 ** iterate through a segment's entire leaf layer).  Leaf nodes have
115366 ** the format:
115367 **
115368 ** varint iHeight;             (height from leaf level, always 0)
115369 ** varint nTerm;               (length of first term)
115370 ** char pTerm[nTerm];          (content of first term)
115371 ** varint nDoclist;            (length of term's associated doclist)
115372 ** char pDoclist[nDoclist];    (content of doclist)
115373 ** array {
115374 **                             (further terms are delta-encoded)
115375 **   varint nPrefix;           (length of prefix shared with previous term)
115376 **   varint nSuffix;           (length of unshared suffix)
115377 **   char pTermSuffix[nSuffix];(unshared suffix of next term)
115378 **   varint nDoclist;          (length of term's associated doclist)
115379 **   char pDoclist[nDoclist];  (content of doclist)
115380 ** }
115381 **
115382 ** Here, array { X } means zero or more occurrences of X, adjacent in
115383 ** memory.
115384 **
115385 ** Leaf nodes are broken into blocks which are stored contiguously in
115386 ** the %_segments table in sorted order.  This means that when the end
115387 ** of a node is reached, the next term is in the node with the next
115388 ** greater node id.
115389 **
115390 ** New data is spilled to a new leaf node when the current node
115391 ** exceeds LEAF_MAX bytes (default 2048).  New data which itself is
115392 ** larger than STANDALONE_MIN (default 1024) is placed in a standalone
115393 ** node (a leaf node with a single term and doclist).  The goal of
115394 ** these settings is to pack together groups of small doclists while
115395 ** making it efficient to directly access large doclists.  The
115396 ** assumption is that large doclists represent terms which are more
115397 ** likely to be query targets.
115398 **
115399 ** TODO(shess) It may be useful for blocking decisions to be more
115400 ** dynamic.  For instance, it may make more sense to have a 2.5k leaf
115401 ** node rather than splitting into 2k and .5k nodes.  My intuition is
115402 ** that this might extend through 2x or 4x the pagesize.
115403 **
115404 **
115405 **** Segment interior nodes ****
115406 ** Segment interior nodes store blockids for subtree nodes and terms
115407 ** to describe what data is stored by the each subtree.  Interior
115408 ** nodes are written using InteriorWriter, and read using
115409 ** InteriorReader.  InteriorWriters are created as needed when
115410 ** SegmentWriter creates new leaf nodes, or when an interior node
115411 ** itself grows too big and must be split.  The format of interior
115412 ** nodes:
115413 **
115414 ** varint iHeight;           (height from leaf level, always >0)
115415 ** varint iBlockid;          (block id of node's leftmost subtree)
115416 ** optional {
115417 **   varint nTerm;           (length of first term)
115418 **   char pTerm[nTerm];      (content of first term)
115419 **   array {
115420 **                                (further terms are delta-encoded)
115421 **     varint nPrefix;            (length of shared prefix with previous term)
115422 **     varint nSuffix;            (length of unshared suffix)
115423 **     char pTermSuffix[nSuffix]; (unshared suffix of next term)
115424 **   }
115425 ** }
115426 **
115427 ** Here, optional { X } means an optional element, while array { X }
115428 ** means zero or more occurrences of X, adjacent in memory.
115429 **
115430 ** An interior node encodes n terms separating n+1 subtrees.  The
115431 ** subtree blocks are contiguous, so only the first subtree's blockid
115432 ** is encoded.  The subtree at iBlockid will contain all terms less
115433 ** than the first term encoded (or all terms if no term is encoded).
115434 ** Otherwise, for terms greater than or equal to pTerm[i] but less
115435 ** than pTerm[i+1], the subtree for that term will be rooted at
115436 ** iBlockid+i.  Interior nodes only store enough term data to
115437 ** distinguish adjacent children (if the rightmost term of the left
115438 ** child is "something", and the leftmost term of the right child is
115439 ** "wicked", only "w" is stored).
115440 **
115441 ** New data is spilled to a new interior node at the same height when
115442 ** the current node exceeds INTERIOR_MAX bytes (default 2048).
115443 ** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing
115444 ** interior nodes and making the tree too skinny.  The interior nodes
115445 ** at a given height are naturally tracked by interior nodes at
115446 ** height+1, and so on.
115447 **
115448 **
115449 **** Segment directory ****
115450 ** The segment directory in table %_segdir stores meta-information for
115451 ** merging and deleting segments, and also the root node of the
115452 ** segment's tree.
115453 **
115454 ** The root node is the top node of the segment's tree after encoding
115455 ** the entire segment, restricted to ROOT_MAX bytes (default 1024).
115456 ** This could be either a leaf node or an interior node.  If the top
115457 ** node requires more than ROOT_MAX bytes, it is flushed to %_segments
115458 ** and a new root interior node is generated (which should always fit
115459 ** within ROOT_MAX because it only needs space for 2 varints, the
115460 ** height and the blockid of the previous root).
115461 **
115462 ** The meta-information in the segment directory is:
115463 **   level               - segment level (see below)
115464 **   idx                 - index within level
115465 **                       - (level,idx uniquely identify a segment)
115466 **   start_block         - first leaf node
115467 **   leaves_end_block    - last leaf node
115468 **   end_block           - last block (including interior nodes)
115469 **   root                - contents of root node
115470 **
115471 ** If the root node is a leaf node, then start_block,
115472 ** leaves_end_block, and end_block are all 0.
115473 **
115474 **
115475 **** Segment merging ****
115476 ** To amortize update costs, segments are grouped into levels and
115477 ** merged in batches.  Each increase in level represents exponentially
115478 ** more documents.
115479 **
115480 ** New documents (actually, document updates) are tokenized and
115481 ** written individually (using LeafWriter) to a level 0 segment, with
115482 ** incrementing idx.  When idx reaches MERGE_COUNT (default 16), all
115483 ** level 0 segments are merged into a single level 1 segment.  Level 1
115484 ** is populated like level 0, and eventually MERGE_COUNT level 1
115485 ** segments are merged to a single level 2 segment (representing
115486 ** MERGE_COUNT^2 updates), and so on.
115487 **
115488 ** A segment merge traverses all segments at a given level in
115489 ** parallel, performing a straightforward sorted merge.  Since segment
115490 ** leaf nodes are written in to the %_segments table in order, this
115491 ** merge traverses the underlying sqlcipher disk structures efficiently.
115492 ** After the merge, all segment blocks from the merged level are
115493 ** deleted.
115494 **
115495 ** MERGE_COUNT controls how often we merge segments.  16 seems to be
115496 ** somewhat of a sweet spot for insertion performance.  32 and 64 show
115497 ** very similar performance numbers to 16 on insertion, though they're
115498 ** a tiny bit slower (perhaps due to more overhead in merge-time
115499 ** sorting).  8 is about 20% slower than 16, 4 about 50% slower than
115500 ** 16, 2 about 66% slower than 16.
115501 **
115502 ** At query time, high MERGE_COUNT increases the number of segments
115503 ** which need to be scanned and merged.  For instance, with 100k docs
115504 ** inserted:
115505 **
115506 **    MERGE_COUNT   segments
115507 **       16           25
115508 **        8           12
115509 **        4           10
115510 **        2            6
115511 **
115512 ** This appears to have only a moderate impact on queries for very
115513 ** frequent terms (which are somewhat dominated by segment merge
115514 ** costs), and infrequent and non-existent terms still seem to be fast
115515 ** even with many segments.
115516 **
115517 ** TODO(shess) That said, it would be nice to have a better query-side
115518 ** argument for MERGE_COUNT of 16.  Also, it is possible/likely that
115519 ** optimizations to things like doclist merging will swing the sweet
115520 ** spot around.
115521 **
115522 **
115523 **
115524 **** Handling of deletions and updates ****
115525 ** Since we're using a segmented structure, with no docid-oriented
115526 ** index into the term index, we clearly cannot simply update the term
115527 ** index when a document is deleted or updated.  For deletions, we
115528 ** write an empty doclist (varint(docid) varint(POS_END)), for updates
115529 ** we simply write the new doclist.  Segment merges overwrite older
115530 ** data for a particular docid with newer data, so deletes or updates
115531 ** will eventually overtake the earlier data and knock it out.  The
115532 ** query logic likewise merges doclists so that newer data knocks out
115533 ** older data.
115534 **
115535 ** TODO(shess) Provide a VACUUM type operation to clear out all
115536 ** deletions and duplications.  This would basically be a forced merge
115537 ** into a single segment.
115538 */
115539
115540 /************** Include fts3Int.h in the middle of fts3.c ********************/
115541 /************** Begin file fts3Int.h *****************************************/
115542 /*
115543 ** 2009 Nov 12
115544 **
115545 ** The author disclaims copyright to this source code.  In place of
115546 ** a legal notice, here is a blessing:
115547 **
115548 **    May you do good and not evil.
115549 **    May you find forgiveness for yourself and forgive others.
115550 **    May you share freely, never taking more than you give.
115551 **
115552 ******************************************************************************
115553 **
115554 */
115555 #ifndef _FTSINT_H
115556 #define _FTSINT_H
115557
115558 #if !defined(NDEBUG) && !defined(SQLCIPHER_DEBUG) 
115559 # define NDEBUG 1
115560 #endif
115561
115562 /*
115563 ** FTS4 is really an extension for FTS3.  It is enabled using the
115564 ** SQLCIPHER_ENABLE_FTS3 macro.  But to avoid confusion we also all
115565 ** the SQLCIPHER_ENABLE_FTS4 macro to serve as an alisse for SQLCIPHER_ENABLE_FTS3.
115566 */
115567 #if defined(SQLCIPHER_ENABLE_FTS4) && !defined(SQLCIPHER_ENABLE_FTS3)
115568 # define SQLCIPHER_ENABLE_FTS3
115569 #endif
115570
115571 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
115572
115573 /* If not building as part of the core, include sqlcipher3ext.h. */
115574 #ifndef SQLCIPHER_CORE
115575 SQLCIPHER_API extern const sqlcipher3_api_routines *sqlcipher3_api;
115576 #endif
115577
115578 /************** Include fts3_tokenizer.h in the middle of fts3Int.h **********/
115579 /************** Begin file fts3_tokenizer.h **********************************/
115580 /*
115581 ** 2006 July 10
115582 **
115583 ** The author disclaims copyright to this source code.
115584 **
115585 *************************************************************************
115586 ** Defines the interface to tokenizers used by fulltext-search.  There
115587 ** are three basic components:
115588 **
115589 ** sqlcipher3_tokenizer_module is a singleton defining the tokenizer
115590 ** interface functions.  This is essentially the class structure for
115591 ** tokenizers.
115592 **
115593 ** sqlcipher3_tokenizer is used to define a particular tokenizer, perhaps
115594 ** including customization information defined at creation time.
115595 **
115596 ** sqlcipher3_tokenizer_cursor is generated by a tokenizer to generate
115597 ** tokens from a particular input.
115598 */
115599 #ifndef _FTS3_TOKENIZER_H_
115600 #define _FTS3_TOKENIZER_H_
115601
115602 /* TODO(shess) Only used for SQLCIPHER_OK and SQLCIPHER_DONE at this time.
115603 ** If tokenizers are to be allowed to call sqlcipher3_*() functions, then
115604 ** we will need a way to register the API consistently.
115605 */
115606
115607 /*
115608 ** Structures used by the tokenizer interface. When a new tokenizer
115609 ** implementation is registered, the caller provides a pointer to
115610 ** an sqlcipher3_tokenizer_module containing pointers to the callback
115611 ** functions that make up an implementation.
115612 **
115613 ** When an fts3 table is created, it passes any arguments passed to
115614 ** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the
115615 ** sqlcipher3_tokenizer_module.xCreate() function of the requested tokenizer
115616 ** implementation. The xCreate() function in turn returns an 
115617 ** sqlcipher3_tokenizer structure representing the specific tokenizer to
115618 ** be used for the fts3 table (customized by the tokenizer clause arguments).
115619 **
115620 ** To tokenize an input buffer, the sqlcipher3_tokenizer_module.xOpen()
115621 ** method is called. It returns an sqlcipher3_tokenizer_cursor object
115622 ** that may be used to tokenize a specific input buffer based on
115623 ** the tokenization rules supplied by a specific sqlcipher3_tokenizer
115624 ** object.
115625 */
115626 typedef struct sqlcipher3_tokenizer_module sqlcipher3_tokenizer_module;
115627 typedef struct sqlcipher3_tokenizer sqlcipher3_tokenizer;
115628 typedef struct sqlcipher3_tokenizer_cursor sqlcipher3_tokenizer_cursor;
115629
115630 struct sqlcipher3_tokenizer_module {
115631
115632   /*
115633   ** Structure version. Should always be set to 0.
115634   */
115635   int iVersion;
115636
115637   /*
115638   ** Create a new tokenizer. The values in the argv[] array are the
115639   ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL
115640   ** TABLE statement that created the fts3 table. For example, if
115641   ** the following SQL is executed:
115642   **
115643   **   CREATE .. USING fts3( ... , tokenizer <tokenizer-name> arg1 arg2)
115644   **
115645   ** then argc is set to 2, and the argv[] array contains pointers
115646   ** to the strings "arg1" and "arg2".
115647   **
115648   ** This method should return either SQLCIPHER_OK (0), or an SQLite error 
115649   ** code. If SQLCIPHER_OK is returned, then *ppTokenizer should be set
115650   ** to point at the newly created tokenizer structure. The generic
115651   ** sqlcipher3_tokenizer.pModule variable should not be initialised by
115652   ** this callback. The caller will do so.
115653   */
115654   int (*xCreate)(
115655     int argc,                           /* Size of argv array */
115656     const char *const*argv,             /* Tokenizer argument strings */
115657     sqlcipher3_tokenizer **ppTokenizer     /* OUT: Created tokenizer */
115658   );
115659
115660   /*
115661   ** Destroy an existing tokenizer. The fts3 module calls this method
115662   ** exactly once for each successful call to xCreate().
115663   */
115664   int (*xDestroy)(sqlcipher3_tokenizer *pTokenizer);
115665
115666   /*
115667   ** Create a tokenizer cursor to tokenize an input buffer. The caller
115668   ** is responsible for ensuring that the input buffer remains valid
115669   ** until the cursor is closed (using the xClose() method). 
115670   */
115671   int (*xOpen)(
115672     sqlcipher3_tokenizer *pTokenizer,       /* Tokenizer object */
115673     const char *pInput, int nBytes,      /* Input buffer */
115674     sqlcipher3_tokenizer_cursor **ppCursor  /* OUT: Created tokenizer cursor */
115675   );
115676
115677   /*
115678   ** Destroy an existing tokenizer cursor. The fts3 module calls this 
115679   ** method exactly once for each successful call to xOpen().
115680   */
115681   int (*xClose)(sqlcipher3_tokenizer_cursor *pCursor);
115682
115683   /*
115684   ** Retrieve the next token from the tokenizer cursor pCursor. This
115685   ** method should either return SQLCIPHER_OK and set the values of the
115686   ** "OUT" variables identified below, or SQLCIPHER_DONE to indicate that
115687   ** the end of the buffer has been reached, or an SQLite error code.
115688   **
115689   ** *ppToken should be set to point at a buffer containing the 
115690   ** normalized version of the token (i.e. after any case-folding and/or
115691   ** stemming has been performed). *pnBytes should be set to the length
115692   ** of this buffer in bytes. The input text that generated the token is
115693   ** identified by the byte offsets returned in *piStartOffset and
115694   ** *piEndOffset. *piStartOffset should be set to the index of the first
115695   ** byte of the token in the input buffer. *piEndOffset should be set
115696   ** to the index of the first byte just past the end of the token in
115697   ** the input buffer.
115698   **
115699   ** The buffer *ppToken is set to point at is managed by the tokenizer
115700   ** implementation. It is only required to be valid until the next call
115701   ** to xNext() or xClose(). 
115702   */
115703   /* TODO(shess) current implementation requires pInput to be
115704   ** nul-terminated.  This should either be fixed, or pInput/nBytes
115705   ** should be converted to zInput.
115706   */
115707   int (*xNext)(
115708     sqlcipher3_tokenizer_cursor *pCursor,   /* Tokenizer cursor */
115709     const char **ppToken, int *pnBytes,  /* OUT: Normalized text for token */
115710     int *piStartOffset,  /* OUT: Byte offset of token in input buffer */
115711     int *piEndOffset,    /* OUT: Byte offset of end of token in input buffer */
115712     int *piPosition      /* OUT: Number of tokens returned before this one */
115713   );
115714 };
115715
115716 struct sqlcipher3_tokenizer {
115717   const sqlcipher3_tokenizer_module *pModule;  /* The module for this tokenizer */
115718   /* Tokenizer implementations will typically add additional fields */
115719 };
115720
115721 struct sqlcipher3_tokenizer_cursor {
115722   sqlcipher3_tokenizer *pTokenizer;       /* Tokenizer for this cursor. */
115723   /* Tokenizer implementations will typically add additional fields */
115724 };
115725
115726 int fts3_global_term_cnt(int iTerm, int iCol);
115727 int fts3_term_cnt(int iTerm, int iCol);
115728
115729
115730 #endif /* _FTS3_TOKENIZER_H_ */
115731
115732 /************** End of fts3_tokenizer.h **************************************/
115733 /************** Continuing where we left off in fts3Int.h ********************/
115734 /************** Include fts3_hash.h in the middle of fts3Int.h ***************/
115735 /************** Begin file fts3_hash.h ***************************************/
115736 /*
115737 ** 2001 September 22
115738 **
115739 ** The author disclaims copyright to this source code.  In place of
115740 ** a legal notice, here is a blessing:
115741 **
115742 **    May you do good and not evil.
115743 **    May you find forgiveness for yourself and forgive others.
115744 **    May you share freely, never taking more than you give.
115745 **
115746 *************************************************************************
115747 ** This is the header file for the generic hash-table implemenation
115748 ** used in SQLite.  We've modified it slightly to serve as a standalone
115749 ** hash table implementation for the full-text indexing module.
115750 **
115751 */
115752 #ifndef _FTS3_HASH_H_
115753 #define _FTS3_HASH_H_
115754
115755 /* Forward declarations of structures. */
115756 typedef struct Fts3Hash Fts3Hash;
115757 typedef struct Fts3HashElem Fts3HashElem;
115758
115759 /* A complete hash table is an instance of the following structure.
115760 ** The internals of this structure are intended to be opaque -- client
115761 ** code should not attempt to access or modify the fields of this structure
115762 ** directly.  Change this structure only by using the routines below.
115763 ** However, many of the "procedures" and "functions" for modifying and
115764 ** accessing this structure are really macros, so we can't really make
115765 ** this structure opaque.
115766 */
115767 struct Fts3Hash {
115768   char keyClass;          /* HASH_INT, _POINTER, _STRING, _BINARY */
115769   char copyKey;           /* True if copy of key made on insert */
115770   int count;              /* Number of entries in this table */
115771   Fts3HashElem *first;    /* The first element of the array */
115772   int htsize;             /* Number of buckets in the hash table */
115773   struct _fts3ht {        /* the hash table */
115774     int count;               /* Number of entries with this hash */
115775     Fts3HashElem *chain;     /* Pointer to first entry with this hash */
115776   } *ht;
115777 };
115778
115779 /* Each element in the hash table is an instance of the following 
115780 ** structure.  All elements are stored on a single doubly-linked list.
115781 **
115782 ** Again, this structure is intended to be opaque, but it can't really
115783 ** be opaque because it is used by macros.
115784 */
115785 struct Fts3HashElem {
115786   Fts3HashElem *next, *prev; /* Next and previous elements in the table */
115787   void *data;                /* Data associated with this element */
115788   void *pKey; int nKey;      /* Key associated with this element */
115789 };
115790
115791 /*
115792 ** There are 2 different modes of operation for a hash table:
115793 **
115794 **   FTS3_HASH_STRING        pKey points to a string that is nKey bytes long
115795 **                           (including the null-terminator, if any).  Case
115796 **                           is respected in comparisons.
115797 **
115798 **   FTS3_HASH_BINARY        pKey points to binary data nKey bytes long. 
115799 **                           memcmp() is used to compare keys.
115800 **
115801 ** A copy of the key is made if the copyKey parameter to fts3HashInit is 1.  
115802 */
115803 #define FTS3_HASH_STRING    1
115804 #define FTS3_HASH_BINARY    2
115805
115806 /*
115807 ** Access routines.  To delete, insert a NULL pointer.
115808 */
115809 SQLCIPHER_PRIVATE void sqlcipher3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
115810 SQLCIPHER_PRIVATE void *sqlcipher3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
115811 SQLCIPHER_PRIVATE void *sqlcipher3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
115812 SQLCIPHER_PRIVATE void sqlcipher3Fts3HashClear(Fts3Hash*);
115813 SQLCIPHER_PRIVATE Fts3HashElem *sqlcipher3Fts3HashFindElem(const Fts3Hash *, const void *, int);
115814
115815 /*
115816 ** Shorthand for the functions above
115817 */
115818 #define fts3HashInit     sqlcipher3Fts3HashInit
115819 #define fts3HashInsert   sqlcipher3Fts3HashInsert
115820 #define fts3HashFind     sqlcipher3Fts3HashFind
115821 #define fts3HashClear    sqlcipher3Fts3HashClear
115822 #define fts3HashFindElem sqlcipher3Fts3HashFindElem
115823
115824 /*
115825 ** Macros for looping over all elements of a hash table.  The idiom is
115826 ** like this:
115827 **
115828 **   Fts3Hash h;
115829 **   Fts3HashElem *p;
115830 **   ...
115831 **   for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){
115832 **     SomeStructure *pData = fts3HashData(p);
115833 **     // do something with pData
115834 **   }
115835 */
115836 #define fts3HashFirst(H)  ((H)->first)
115837 #define fts3HashNext(E)   ((E)->next)
115838 #define fts3HashData(E)   ((E)->data)
115839 #define fts3HashKey(E)    ((E)->pKey)
115840 #define fts3HashKeysize(E) ((E)->nKey)
115841
115842 /*
115843 ** Number of entries in a hash table
115844 */
115845 #define fts3HashCount(H)  ((H)->count)
115846
115847 #endif /* _FTS3_HASH_H_ */
115848
115849 /************** End of fts3_hash.h *******************************************/
115850 /************** Continuing where we left off in fts3Int.h ********************/
115851
115852 /*
115853 ** This constant controls how often segments are merged. Once there are
115854 ** FTS3_MERGE_COUNT segments of level N, they are merged into a single
115855 ** segment of level N+1.
115856 */
115857 #define FTS3_MERGE_COUNT 16
115858
115859 /*
115860 ** This is the maximum amount of data (in bytes) to store in the 
115861 ** Fts3Table.pendingTerms hash table. Normally, the hash table is
115862 ** populated as documents are inserted/updated/deleted in a transaction
115863 ** and used to create a new segment when the transaction is committed.
115864 ** However if this limit is reached midway through a transaction, a new 
115865 ** segment is created and the hash table cleared immediately.
115866 */
115867 #define FTS3_MAX_PENDING_DATA (1*1024*1024)
115868
115869 /*
115870 ** Macro to return the number of elements in an array. SQLite has a
115871 ** similar macro called ArraySize(). Use a different name to avoid
115872 ** a collision when building an amalgamation with built-in FTS3.
115873 */
115874 #define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0])))
115875
115876
115877 #ifndef MIN
115878 # define MIN(x,y) ((x)<(y)?(x):(y))
115879 #endif
115880
115881 /*
115882 ** Maximum length of a varint encoded integer. The varint format is different
115883 ** from that used by SQLite, so the maximum length is 10, not 9.
115884 */
115885 #define FTS3_VARINT_MAX 10
115886
115887 /*
115888 ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
115889 ** in the document set and zero or more prefix indexes. All indexes are stored
115890 ** as one or more b+-trees in the %_segments and %_segdir tables. 
115891 **
115892 ** It is possible to determine which index a b+-tree belongs to based on the
115893 ** value stored in the "%_segdir.level" column. Given this value L, the index
115894 ** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with
115895 ** level values between 0 and 1023 (inclusive) belong to index 0, all levels
115896 ** between 1024 and 2047 to index 1, and so on.
115897 **
115898 ** It is considered impossible for an index to use more than 1024 levels. In 
115899 ** theory though this may happen, but only after at least 
115900 ** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables.
115901 */
115902 #define FTS3_SEGDIR_MAXLEVEL      1024
115903 #define FTS3_SEGDIR_MAXLEVEL_STR "1024"
115904
115905 /*
115906 ** The testcase() macro is only used by the amalgamation.  If undefined,
115907 ** make it a no-op.
115908 */
115909 #ifndef testcase
115910 # define testcase(X)
115911 #endif
115912
115913 /*
115914 ** Terminator values for position-lists and column-lists.
115915 */
115916 #define POS_COLUMN  (1)     /* Column-list terminator */
115917 #define POS_END     (0)     /* Position-list terminator */ 
115918
115919 /*
115920 ** This section provides definitions to allow the
115921 ** FTS3 extension to be compiled outside of the 
115922 ** amalgamation.
115923 */
115924 #ifndef SQLCIPHER_AMALGAMATION
115925 /*
115926 ** Macros indicating that conditional expressions are always true or
115927 ** false.
115928 */
115929 #ifdef SQLCIPHER_COVERAGE_TEST
115930 # define ALWAYS(x) (1)
115931 # define NEVER(X)  (0)
115932 #else
115933 # define ALWAYS(x) (x)
115934 # define NEVER(X)  (x)
115935 #endif
115936
115937 /*
115938 ** Internal types used by SQLite.
115939 */
115940 typedef unsigned char u8;         /* 1-byte (or larger) unsigned integer */
115941 typedef short int i16;            /* 2-byte (or larger) signed integer */
115942 typedef unsigned int u32;         /* 4-byte unsigned integer */
115943 typedef sqlcipher3_uint64 u64;       /* 8-byte unsigned integer */
115944
115945 /*
115946 ** Macro used to suppress compiler warnings for unused parameters.
115947 */
115948 #define UNUSED_PARAMETER(x) (void)(x)
115949
115950 /*
115951 ** Activate assert() only if SQLCIPHER_TEST is enabled.
115952 */
115953 #if !defined(NDEBUG) && !defined(SQLCIPHER_DEBUG) 
115954 # define NDEBUG 1
115955 #endif
115956
115957 /*
115958 ** The TESTONLY macro is used to enclose variable declarations or
115959 ** other bits of code that are needed to support the arguments
115960 ** within testcase() and assert() macros.
115961 */
115962 #if defined(SQLCIPHER_DEBUG) || defined(SQLCIPHER_COVERAGE_TEST)
115963 # define TESTONLY(X)  X
115964 #else
115965 # define TESTONLY(X)
115966 #endif
115967
115968 #endif /* SQLCIPHER_AMALGAMATION */
115969
115970 #ifdef SQLCIPHER_DEBUG
115971 SQLCIPHER_PRIVATE int sqlcipher3Fts3Corrupt(void);
115972 # define FTS_CORRUPT_VTAB sqlcipher3Fts3Corrupt()
115973 #else
115974 # define FTS_CORRUPT_VTAB SQLCIPHER_CORRUPT_VTAB
115975 #endif
115976
115977 typedef struct Fts3Table Fts3Table;
115978 typedef struct Fts3Cursor Fts3Cursor;
115979 typedef struct Fts3Expr Fts3Expr;
115980 typedef struct Fts3Phrase Fts3Phrase;
115981 typedef struct Fts3PhraseToken Fts3PhraseToken;
115982
115983 typedef struct Fts3Doclist Fts3Doclist;
115984 typedef struct Fts3SegFilter Fts3SegFilter;
115985 typedef struct Fts3DeferredToken Fts3DeferredToken;
115986 typedef struct Fts3SegReader Fts3SegReader;
115987 typedef struct Fts3MultiSegReader Fts3MultiSegReader;
115988
115989 /*
115990 ** A connection to a fulltext index is an instance of the following
115991 ** structure. The xCreate and xConnect methods create an instance
115992 ** of this structure and xDestroy and xDisconnect free that instance.
115993 ** All other methods receive a pointer to the structure as one of their
115994 ** arguments.
115995 */
115996 struct Fts3Table {
115997   sqlcipher3_vtab base;              /* Base class used by SQLite core */
115998   sqlcipher3 *db;                    /* The database connection */
115999   const char *zDb;                /* logical database name */
116000   const char *zName;              /* virtual table name */
116001   int nColumn;                    /* number of named columns in virtual table */
116002   char **azColumn;                /* column names.  malloced */
116003   sqlcipher3_tokenizer *pTokenizer;  /* tokenizer for inserts and queries */
116004   char *zContentTbl;              /* content=xxx option, or NULL */
116005
116006   /* Precompiled statements used by the implementation. Each of these 
116007   ** statements is run and reset within a single virtual table API call. 
116008   */
116009   sqlcipher3_stmt *aStmt[27];
116010
116011   char *zReadExprlist;
116012   char *zWriteExprlist;
116013
116014   int nNodeSize;                  /* Soft limit for node size */
116015   u8 bHasStat;                    /* True if %_stat table exists */
116016   u8 bHasDocsize;                 /* True if %_docsize table exists */
116017   u8 bDescIdx;                    /* True if doclists are in reverse order */
116018   int nPgsz;                      /* Page size for host database */
116019   char *zSegmentsTbl;             /* Name of %_segments table */
116020   sqlcipher3_blob *pSegments;        /* Blob handle open on %_segments table */
116021
116022   /* TODO: Fix the first paragraph of this comment.
116023   **
116024   ** The following hash table is used to buffer pending index updates during
116025   ** transactions. Variable nPendingData estimates the memory size of the 
116026   ** pending data, including hash table overhead, but not malloc overhead. 
116027   ** When nPendingData exceeds nMaxPendingData, the buffer is flushed 
116028   ** automatically. Variable iPrevDocid is the docid of the most recently
116029   ** inserted record.
116030   **
116031   ** A single FTS4 table may have multiple full-text indexes. For each index
116032   ** there is an entry in the aIndex[] array. Index 0 is an index of all the
116033   ** terms that appear in the document set. Each subsequent index in aIndex[]
116034   ** is an index of prefixes of a specific length.
116035   */
116036   int nIndex;                     /* Size of aIndex[] */
116037   struct Fts3Index {
116038     int nPrefix;                  /* Prefix length (0 for main terms index) */
116039     Fts3Hash hPending;            /* Pending terms table for this index */
116040   } *aIndex;
116041   int nMaxPendingData;            /* Max pending data before flush to disk */
116042   int nPendingData;               /* Current bytes of pending data */
116043   sqlcipher_int64 iPrevDocid;        /* Docid of most recently inserted document */
116044
116045 #if defined(SQLCIPHER_DEBUG) || defined(SQLCIPHER_COVERAGE_TEST)
116046   /* State variables used for validating that the transaction control
116047   ** methods of the virtual table are called at appropriate times.  These
116048   ** values do not contribution to the FTS computation; they are used for
116049   ** verifying the SQLite core.
116050   */
116051   int inTransaction;     /* True after xBegin but before xCommit/xRollback */
116052   int mxSavepoint;       /* Largest valid xSavepoint integer */
116053 #endif
116054 };
116055
116056 /*
116057 ** When the core wants to read from the virtual table, it creates a
116058 ** virtual table cursor (an instance of the following structure) using
116059 ** the xOpen method. Cursors are destroyed using the xClose method.
116060 */
116061 struct Fts3Cursor {
116062   sqlcipher3_vtab_cursor base;       /* Base class used by SQLite core */
116063   i16 eSearch;                    /* Search strategy (see below) */
116064   u8 isEof;                       /* True if at End Of Results */
116065   u8 isRequireSeek;               /* True if must seek pStmt to %_content row */
116066   sqlcipher3_stmt *pStmt;            /* Prepared statement in use by the cursor */
116067   Fts3Expr *pExpr;                /* Parsed MATCH query string */
116068   int nPhrase;                    /* Number of matchable phrases in query */
116069   Fts3DeferredToken *pDeferred;   /* Deferred search tokens, if any */
116070   sqlcipher3_int64 iPrevId;          /* Previous id read from aDoclist */
116071   char *pNextId;                  /* Pointer into the body of aDoclist */
116072   char *aDoclist;                 /* List of docids for full-text queries */
116073   int nDoclist;                   /* Size of buffer at aDoclist */
116074   u8 bDesc;                       /* True to sort in descending order */
116075   int eEvalmode;                  /* An FTS3_EVAL_XX constant */
116076   int nRowAvg;                    /* Average size of database rows, in pages */
116077   sqlcipher3_int64 nDoc;             /* Documents in table */
116078
116079   int isMatchinfoNeeded;          /* True when aMatchinfo[] needs filling in */
116080   u32 *aMatchinfo;                /* Information about most recent match */
116081   int nMatchinfo;                 /* Number of elements in aMatchinfo[] */
116082   char *zMatchinfo;               /* Matchinfo specification */
116083 };
116084
116085 #define FTS3_EVAL_FILTER    0
116086 #define FTS3_EVAL_NEXT      1
116087 #define FTS3_EVAL_MATCHINFO 2
116088
116089 /*
116090 ** The Fts3Cursor.eSearch member is always set to one of the following.
116091 ** Actualy, Fts3Cursor.eSearch can be greater than or equal to
116092 ** FTS3_FULLTEXT_SEARCH.  If so, then Fts3Cursor.eSearch - 2 is the index
116093 ** of the column to be searched.  For example, in
116094 **
116095 **     CREATE VIRTUAL TABLE ex1 USING fts3(a,b,c,d);
116096 **     SELECT docid FROM ex1 WHERE b MATCH 'one two three';
116097 ** 
116098 ** Because the LHS of the MATCH operator is 2nd column "b",
116099 ** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1.  (+0 for a,
116100 ** +1 for b, +2 for c, +3 for d.)  If the LHS of MATCH were "ex1" 
116101 ** indicating that all columns should be searched,
116102 ** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
116103 */
116104 #define FTS3_FULLSCAN_SEARCH 0    /* Linear scan of %_content table */
116105 #define FTS3_DOCID_SEARCH    1    /* Lookup by rowid on %_content table */
116106 #define FTS3_FULLTEXT_SEARCH 2    /* Full-text index search */
116107
116108
116109 struct Fts3Doclist {
116110   char *aAll;                    /* Array containing doclist (or NULL) */
116111   int nAll;                      /* Size of a[] in bytes */
116112   char *pNextDocid;              /* Pointer to next docid */
116113
116114   sqlcipher3_int64 iDocid;          /* Current docid (if pList!=0) */
116115   int bFreeList;                 /* True if pList should be sqlcipher3_free()d */
116116   char *pList;                   /* Pointer to position list following iDocid */
116117   int nList;                     /* Length of position list */
116118 };
116119
116120 /*
116121 ** A "phrase" is a sequence of one or more tokens that must match in
116122 ** sequence.  A single token is the base case and the most common case.
116123 ** For a sequence of tokens contained in double-quotes (i.e. "one two three")
116124 ** nToken will be the number of tokens in the string.
116125 */
116126 struct Fts3PhraseToken {
116127   char *z;                        /* Text of the token */
116128   int n;                          /* Number of bytes in buffer z */
116129   int isPrefix;                   /* True if token ends with a "*" character */
116130   int bFirst;                     /* True if token must appear at position 0 */
116131
116132   /* Variables above this point are populated when the expression is
116133   ** parsed (by code in fts3_expr.c). Below this point the variables are
116134   ** used when evaluating the expression. */
116135   Fts3DeferredToken *pDeferred;   /* Deferred token object for this token */
116136   Fts3MultiSegReader *pSegcsr;    /* Segment-reader for this token */
116137 };
116138
116139 struct Fts3Phrase {
116140   /* Cache of doclist for this phrase. */
116141   Fts3Doclist doclist;
116142   int bIncr;                 /* True if doclist is loaded incrementally */
116143   int iDoclistToken;
116144
116145   /* Variables below this point are populated by fts3_expr.c when parsing 
116146   ** a MATCH expression. Everything above is part of the evaluation phase. 
116147   */
116148   int nToken;                /* Number of tokens in the phrase */
116149   int iColumn;               /* Index of column this phrase must match */
116150   Fts3PhraseToken aToken[1]; /* One entry for each token in the phrase */
116151 };
116152
116153 /*
116154 ** A tree of these objects forms the RHS of a MATCH operator.
116155 **
116156 ** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist 
116157 ** points to a malloced buffer, size nDoclist bytes, containing the results 
116158 ** of this phrase query in FTS3 doclist format. As usual, the initial 
116159 ** "Length" field found in doclists stored on disk is omitted from this 
116160 ** buffer.
116161 **
116162 ** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global
116163 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
116164 ** where nCol is the number of columns in the queried FTS table. The array
116165 ** is populated as follows:
116166 **
116167 **   aMI[iCol*3 + 0] = Undefined
116168 **   aMI[iCol*3 + 1] = Number of occurrences
116169 **   aMI[iCol*3 + 2] = Number of rows containing at least one instance
116170 **
116171 ** The aMI array is allocated using sqlcipher3_malloc(). It should be freed 
116172 ** when the expression node is.
116173 */
116174 struct Fts3Expr {
116175   int eType;                 /* One of the FTSQUERY_XXX values defined below */
116176   int nNear;                 /* Valid if eType==FTSQUERY_NEAR */
116177   Fts3Expr *pParent;         /* pParent->pLeft==this or pParent->pRight==this */
116178   Fts3Expr *pLeft;           /* Left operand */
116179   Fts3Expr *pRight;          /* Right operand */
116180   Fts3Phrase *pPhrase;       /* Valid if eType==FTSQUERY_PHRASE */
116181
116182   /* The following are used by the fts3_eval.c module. */
116183   sqlcipher3_int64 iDocid;      /* Current docid */
116184   u8 bEof;                   /* True this expression is at EOF already */
116185   u8 bStart;                 /* True if iDocid is valid */
116186   u8 bDeferred;              /* True if this expression is entirely deferred */
116187
116188   u32 *aMI;
116189 };
116190
116191 /*
116192 ** Candidate values for Fts3Query.eType. Note that the order of the first
116193 ** four values is in order of precedence when parsing expressions. For 
116194 ** example, the following:
116195 **
116196 **   "a OR b AND c NOT d NEAR e"
116197 **
116198 ** is equivalent to:
116199 **
116200 **   "a OR (b AND (c NOT (d NEAR e)))"
116201 */
116202 #define FTSQUERY_NEAR   1
116203 #define FTSQUERY_NOT    2
116204 #define FTSQUERY_AND    3
116205 #define FTSQUERY_OR     4
116206 #define FTSQUERY_PHRASE 5
116207
116208
116209 /* fts3_write.c */
116210 SQLCIPHER_PRIVATE int sqlcipher3Fts3UpdateMethod(sqlcipher3_vtab*,int,sqlcipher3_value**,sqlcipher3_int64*);
116211 SQLCIPHER_PRIVATE int sqlcipher3Fts3PendingTermsFlush(Fts3Table *);
116212 SQLCIPHER_PRIVATE void sqlcipher3Fts3PendingTermsClear(Fts3Table *);
116213 SQLCIPHER_PRIVATE int sqlcipher3Fts3Optimize(Fts3Table *);
116214 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderNew(int, sqlcipher3_int64,
116215   sqlcipher3_int64, sqlcipher3_int64, const char *, int, Fts3SegReader**);
116216 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderPending(
116217   Fts3Table*,int,const char*,int,int,Fts3SegReader**);
116218 SQLCIPHER_PRIVATE void sqlcipher3Fts3SegReaderFree(Fts3SegReader *);
116219 SQLCIPHER_PRIVATE int sqlcipher3Fts3AllSegdirs(Fts3Table*, int, int, sqlcipher3_stmt **);
116220 SQLCIPHER_PRIVATE int sqlcipher3Fts3ReadLock(Fts3Table *);
116221 SQLCIPHER_PRIVATE int sqlcipher3Fts3ReadBlock(Fts3Table*, sqlcipher3_int64, char **, int*, int*);
116222
116223 SQLCIPHER_PRIVATE int sqlcipher3Fts3SelectDoctotal(Fts3Table *, sqlcipher3_stmt **);
116224 SQLCIPHER_PRIVATE int sqlcipher3Fts3SelectDocsize(Fts3Table *, sqlcipher3_int64, sqlcipher3_stmt **);
116225
116226 SQLCIPHER_PRIVATE void sqlcipher3Fts3FreeDeferredTokens(Fts3Cursor *);
116227 SQLCIPHER_PRIVATE int sqlcipher3Fts3DeferToken(Fts3Cursor *, Fts3PhraseToken *, int);
116228 SQLCIPHER_PRIVATE int sqlcipher3Fts3CacheDeferredDoclists(Fts3Cursor *);
116229 SQLCIPHER_PRIVATE void sqlcipher3Fts3FreeDeferredDoclists(Fts3Cursor *);
116230 SQLCIPHER_PRIVATE void sqlcipher3Fts3SegmentsClose(Fts3Table *);
116231
116232 /* Special values interpreted by sqlcipher3SegReaderCursor() */
116233 #define FTS3_SEGCURSOR_PENDING        -1
116234 #define FTS3_SEGCURSOR_ALL            -2
116235
116236 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderStart(Fts3Table*, Fts3MultiSegReader*, Fts3SegFilter*);
116237 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderStep(Fts3Table *, Fts3MultiSegReader *);
116238 SQLCIPHER_PRIVATE void sqlcipher3Fts3SegReaderFinish(Fts3MultiSegReader *);
116239
116240 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderCursor(
116241     Fts3Table *, int, int, const char *, int, int, int, Fts3MultiSegReader *);
116242
116243 /* Flags allowed as part of the 4th argument to SegmentReaderIterate() */
116244 #define FTS3_SEGMENT_REQUIRE_POS   0x00000001
116245 #define FTS3_SEGMENT_IGNORE_EMPTY  0x00000002
116246 #define FTS3_SEGMENT_COLUMN_FILTER 0x00000004
116247 #define FTS3_SEGMENT_PREFIX        0x00000008
116248 #define FTS3_SEGMENT_SCAN          0x00000010
116249 #define FTS3_SEGMENT_FIRST         0x00000020
116250
116251 /* Type passed as 4th argument to SegmentReaderIterate() */
116252 struct Fts3SegFilter {
116253   const char *zTerm;
116254   int nTerm;
116255   int iCol;
116256   int flags;
116257 };
116258
116259 struct Fts3MultiSegReader {
116260   /* Used internally by sqlcipher3Fts3SegReaderXXX() calls */
116261   Fts3SegReader **apSegment;      /* Array of Fts3SegReader objects */
116262   int nSegment;                   /* Size of apSegment array */
116263   int nAdvance;                   /* How many seg-readers to advance */
116264   Fts3SegFilter *pFilter;         /* Pointer to filter object */
116265   char *aBuffer;                  /* Buffer to merge doclists in */
116266   int nBuffer;                    /* Allocated size of aBuffer[] in bytes */
116267
116268   int iColFilter;                 /* If >=0, filter for this column */
116269   int bRestart;
116270
116271   /* Used by fts3.c only. */
116272   int nCost;                      /* Cost of running iterator */
116273   int bLookup;                    /* True if a lookup of a single entry. */
116274
116275   /* Output values. Valid only after Fts3SegReaderStep() returns SQLCIPHER_ROW. */
116276   char *zTerm;                    /* Pointer to term buffer */
116277   int nTerm;                      /* Size of zTerm in bytes */
116278   char *aDoclist;                 /* Pointer to doclist buffer */
116279   int nDoclist;                   /* Size of aDoclist[] in bytes */
116280 };
116281
116282 /* fts3.c */
116283 SQLCIPHER_PRIVATE int sqlcipher3Fts3PutVarint(char *, sqlcipher3_int64);
116284 SQLCIPHER_PRIVATE int sqlcipher3Fts3GetVarint(const char *, sqlcipher_int64 *);
116285 SQLCIPHER_PRIVATE int sqlcipher3Fts3GetVarint32(const char *, int *);
116286 SQLCIPHER_PRIVATE int sqlcipher3Fts3VarintLen(sqlcipher3_uint64);
116287 SQLCIPHER_PRIVATE void sqlcipher3Fts3Dequote(char *);
116288 SQLCIPHER_PRIVATE void sqlcipher3Fts3DoclistPrev(int,char*,int,char**,sqlcipher3_int64*,int*,u8*);
116289 SQLCIPHER_PRIVATE int sqlcipher3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *);
116290 SQLCIPHER_PRIVATE int sqlcipher3Fts3FirstFilter(sqlcipher3_int64, char *, int, char *);
116291
116292 /* fts3_tokenizer.c */
116293 SQLCIPHER_PRIVATE const char *sqlcipher3Fts3NextToken(const char *, int *);
116294 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitHashTable(sqlcipher3 *, Fts3Hash *, const char *);
116295 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitTokenizer(Fts3Hash *pHash, const char *, 
116296     sqlcipher3_tokenizer **, char **
116297 );
116298 SQLCIPHER_PRIVATE int sqlcipher3Fts3IsIdChar(char);
116299
116300 /* fts3_snippet.c */
116301 SQLCIPHER_PRIVATE void sqlcipher3Fts3Offsets(sqlcipher3_context*, Fts3Cursor*);
116302 SQLCIPHER_PRIVATE void sqlcipher3Fts3Snippet(sqlcipher3_context *, Fts3Cursor *, const char *,
116303   const char *, const char *, int, int
116304 );
116305 SQLCIPHER_PRIVATE void sqlcipher3Fts3Matchinfo(sqlcipher3_context *, Fts3Cursor *, const char *);
116306
116307 /* fts3_expr.c */
116308 SQLCIPHER_PRIVATE int sqlcipher3Fts3ExprParse(sqlcipher3_tokenizer *, 
116309   char **, int, int, int, const char *, int, Fts3Expr **
116310 );
116311 SQLCIPHER_PRIVATE void sqlcipher3Fts3ExprFree(Fts3Expr *);
116312 #ifdef SQLCIPHER_TEST
116313 SQLCIPHER_PRIVATE int sqlcipher3Fts3ExprInitTestInterface(sqlcipher3 *db);
116314 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitTerm(sqlcipher3 *db);
116315 #endif
116316
116317 /* fts3_aux.c */
116318 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitAux(sqlcipher3 *db);
116319
116320 SQLCIPHER_PRIVATE void sqlcipher3Fts3EvalPhraseCleanup(Fts3Phrase *);
116321
116322 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrIncrStart(
116323     Fts3Table*, Fts3MultiSegReader*, int, const char*, int);
116324 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrIncrNext(
116325     Fts3Table *, Fts3MultiSegReader *, sqlcipher3_int64 *, char **, int *);
116326 SQLCIPHER_PRIVATE char *sqlcipher3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol); 
116327 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *);
116328 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
116329
116330 SQLCIPHER_PRIVATE int sqlcipher3Fts3DeferredTokenList(Fts3DeferredToken *, char **, int *);
116331
116332 #endif /* !SQLCIPHER_CORE || SQLCIPHER_ENABLE_FTS3 */
116333 #endif /* _FTSINT_H */
116334
116335 /************** End of fts3Int.h *********************************************/
116336 /************** Continuing where we left off in fts3.c ***********************/
116337 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
116338
116339 #if defined(SQLCIPHER_ENABLE_FTS3) && !defined(SQLCIPHER_CORE)
116340 # define SQLCIPHER_CORE 1
116341 #endif
116342
116343 /* #include <assert.h> */
116344 /* #include <stdlib.h> */
116345 /* #include <stddef.h> */
116346 /* #include <stdio.h> */
116347 /* #include <string.h> */
116348 /* #include <stdarg.h> */
116349
116350 #ifndef SQLCIPHER_CORE 
116351   SQLCIPHER_EXTENSION_INIT1
116352 #endif
116353
116354 static int fts3EvalNext(Fts3Cursor *pCsr);
116355 static int fts3EvalStart(Fts3Cursor *pCsr);
116356 static int fts3TermSegReaderCursor(
116357     Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **);
116358
116359 /* 
116360 ** Write a 64-bit variable-length integer to memory starting at p[0].
116361 ** The length of data written will be between 1 and FTS3_VARINT_MAX bytes.
116362 ** The number of bytes written is returned.
116363 */
116364 SQLCIPHER_PRIVATE int sqlcipher3Fts3PutVarint(char *p, sqlcipher_int64 v){
116365   unsigned char *q = (unsigned char *) p;
116366   sqlcipher_uint64 vu = v;
116367   do{
116368     *q++ = (unsigned char) ((vu & 0x7f) | 0x80);
116369     vu >>= 7;
116370   }while( vu!=0 );
116371   q[-1] &= 0x7f;  /* turn off high bit in final byte */
116372   assert( q - (unsigned char *)p <= FTS3_VARINT_MAX );
116373   return (int) (q - (unsigned char *)p);
116374 }
116375
116376 /* 
116377 ** Read a 64-bit variable-length integer from memory starting at p[0].
116378 ** Return the number of bytes read, or 0 on error.
116379 ** The value is stored in *v.
116380 */
116381 SQLCIPHER_PRIVATE int sqlcipher3Fts3GetVarint(const char *p, sqlcipher_int64 *v){
116382   const unsigned char *q = (const unsigned char *) p;
116383   sqlcipher_uint64 x = 0, y = 1;
116384   while( (*q&0x80)==0x80 && q-(unsigned char *)p<FTS3_VARINT_MAX ){
116385     x += y * (*q++ & 0x7f);
116386     y <<= 7;
116387   }
116388   x += y * (*q++);
116389   *v = (sqlcipher_int64) x;
116390   return (int) (q - (unsigned char *)p);
116391 }
116392
116393 /*
116394 ** Similar to sqlcipher3Fts3GetVarint(), except that the output is truncated to a
116395 ** 32-bit integer before it is returned.
116396 */
116397 SQLCIPHER_PRIVATE int sqlcipher3Fts3GetVarint32(const char *p, int *pi){
116398  sqlcipher_int64 i;
116399  int ret = sqlcipher3Fts3GetVarint(p, &i);
116400  *pi = (int) i;
116401  return ret;
116402 }
116403
116404 /*
116405 ** Return the number of bytes required to encode v as a varint
116406 */
116407 SQLCIPHER_PRIVATE int sqlcipher3Fts3VarintLen(sqlcipher3_uint64 v){
116408   int i = 0;
116409   do{
116410     i++;
116411     v >>= 7;
116412   }while( v!=0 );
116413   return i;
116414 }
116415
116416 /*
116417 ** Convert an SQL-style quoted string into a normal string by removing
116418 ** the quote characters.  The conversion is done in-place.  If the
116419 ** input does not begin with a quote character, then this routine
116420 ** is a no-op.
116421 **
116422 ** Examples:
116423 **
116424 **     "abc"   becomes   abc
116425 **     'xyz'   becomes   xyz
116426 **     [pqr]   becomes   pqr
116427 **     `mno`   becomes   mno
116428 **
116429 */
116430 SQLCIPHER_PRIVATE void sqlcipher3Fts3Dequote(char *z){
116431   char quote;                     /* Quote character (if any ) */
116432
116433   quote = z[0];
116434   if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){
116435     int iIn = 1;                  /* Index of next byte to read from input */
116436     int iOut = 0;                 /* Index of next byte to write to output */
116437
116438     /* If the first byte was a '[', then the close-quote character is a ']' */
116439     if( quote=='[' ) quote = ']';  
116440
116441     while( ALWAYS(z[iIn]) ){
116442       if( z[iIn]==quote ){
116443         if( z[iIn+1]!=quote ) break;
116444         z[iOut++] = quote;
116445         iIn += 2;
116446       }else{
116447         z[iOut++] = z[iIn++];
116448       }
116449     }
116450     z[iOut] = '\0';
116451   }
116452 }
116453
116454 /*
116455 ** Read a single varint from the doclist at *pp and advance *pp to point
116456 ** to the first byte past the end of the varint.  Add the value of the varint
116457 ** to *pVal.
116458 */
116459 static void fts3GetDeltaVarint(char **pp, sqlcipher3_int64 *pVal){
116460   sqlcipher3_int64 iVal;
116461   *pp += sqlcipher3Fts3GetVarint(*pp, &iVal);
116462   *pVal += iVal;
116463 }
116464
116465 /*
116466 ** When this function is called, *pp points to the first byte following a
116467 ** varint that is part of a doclist (or position-list, or any other list
116468 ** of varints). This function moves *pp to point to the start of that varint,
116469 ** and sets *pVal by the varint value.
116470 **
116471 ** Argument pStart points to the first byte of the doclist that the
116472 ** varint is part of.
116473 */
116474 static void fts3GetReverseVarint(
116475   char **pp, 
116476   char *pStart, 
116477   sqlcipher3_int64 *pVal
116478 ){
116479   sqlcipher3_int64 iVal;
116480   char *p;
116481
116482   /* Pointer p now points at the first byte past the varint we are 
116483   ** interested in. So, unless the doclist is corrupt, the 0x80 bit is
116484   ** clear on character p[-1]. */
116485   for(p = (*pp)-2; p>=pStart && *p&0x80; p--);
116486   p++;
116487   *pp = p;
116488
116489   sqlcipher3Fts3GetVarint(p, &iVal);
116490   *pVal = iVal;
116491 }
116492
116493 /*
116494 ** The xDisconnect() virtual table method.
116495 */
116496 static int fts3DisconnectMethod(sqlcipher3_vtab *pVtab){
116497   Fts3Table *p = (Fts3Table *)pVtab;
116498   int i;
116499
116500   assert( p->nPendingData==0 );
116501   assert( p->pSegments==0 );
116502
116503   /* Free any prepared statements held */
116504   for(i=0; i<SizeofArray(p->aStmt); i++){
116505     sqlcipher3_finalize(p->aStmt[i]);
116506   }
116507   sqlcipher3_free(p->zSegmentsTbl);
116508   sqlcipher3_free(p->zReadExprlist);
116509   sqlcipher3_free(p->zWriteExprlist);
116510   sqlcipher3_free(p->zContentTbl);
116511
116512   /* Invoke the tokenizer destructor to free the tokenizer. */
116513   p->pTokenizer->pModule->xDestroy(p->pTokenizer);
116514
116515   sqlcipher3_free(p);
116516   return SQLCIPHER_OK;
116517 }
116518
116519 /*
116520 ** Construct one or more SQL statements from the format string given
116521 ** and then evaluate those statements. The success code is written
116522 ** into *pRc.
116523 **
116524 ** If *pRc is initially non-zero then this routine is a no-op.
116525 */
116526 static void fts3DbExec(
116527   int *pRc,              /* Success code */
116528   sqlcipher3 *db,           /* Database in which to run SQL */
116529   const char *zFormat,   /* Format string for SQL */
116530   ...                    /* Arguments to the format string */
116531 ){
116532   va_list ap;
116533   char *zSql;
116534   if( *pRc ) return;
116535   va_start(ap, zFormat);
116536   zSql = sqlcipher3_vmprintf(zFormat, ap);
116537   va_end(ap);
116538   if( zSql==0 ){
116539     *pRc = SQLCIPHER_NOMEM;
116540   }else{
116541     *pRc = sqlcipher3_exec(db, zSql, 0, 0, 0);
116542     sqlcipher3_free(zSql);
116543   }
116544 }
116545
116546 /*
116547 ** The xDestroy() virtual table method.
116548 */
116549 static int fts3DestroyMethod(sqlcipher3_vtab *pVtab){
116550   Fts3Table *p = (Fts3Table *)pVtab;
116551   int rc = SQLCIPHER_OK;              /* Return code */
116552   const char *zDb = p->zDb;        /* Name of database (e.g. "main", "temp") */
116553   sqlcipher3 *db = p->db;             /* Database handle */
116554
116555   /* Drop the shadow tables */
116556   if( p->zContentTbl==0 ){
116557     fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
116558   }
116559   fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
116560   fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
116561   fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
116562   fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
116563
116564   /* If everything has worked, invoke fts3DisconnectMethod() to free the
116565   ** memory associated with the Fts3Table structure and return SQLCIPHER_OK.
116566   ** Otherwise, return an SQLite error code.
116567   */
116568   return (rc==SQLCIPHER_OK ? fts3DisconnectMethod(pVtab) : rc);
116569 }
116570
116571
116572 /*
116573 ** Invoke sqlcipher3_declare_vtab() to declare the schema for the FTS3 table
116574 ** passed as the first argument. This is done as part of the xConnect()
116575 ** and xCreate() methods.
116576 **
116577 ** If *pRc is non-zero when this function is called, it is a no-op. 
116578 ** Otherwise, if an error occurs, an SQLite error code is stored in *pRc
116579 ** before returning.
116580 */
116581 static void fts3DeclareVtab(int *pRc, Fts3Table *p){
116582   if( *pRc==SQLCIPHER_OK ){
116583     int i;                        /* Iterator variable */
116584     int rc;                       /* Return code */
116585     char *zSql;                   /* SQL statement passed to declare_vtab() */
116586     char *zCols;                  /* List of user defined columns */
116587
116588     sqlcipher3_vtab_config(p->db, SQLCIPHER_VTAB_CONSTRAINT_SUPPORT, 1);
116589
116590     /* Create a list of user columns for the virtual table */
116591     zCols = sqlcipher3_mprintf("%Q, ", p->azColumn[0]);
116592     for(i=1; zCols && i<p->nColumn; i++){
116593       zCols = sqlcipher3_mprintf("%z%Q, ", zCols, p->azColumn[i]);
116594     }
116595
116596     /* Create the whole "CREATE TABLE" statement to pass to SQLite */
116597     zSql = sqlcipher3_mprintf(
116598         "CREATE TABLE x(%s %Q HIDDEN, docid HIDDEN)", zCols, p->zName
116599     );
116600     if( !zCols || !zSql ){
116601       rc = SQLCIPHER_NOMEM;
116602     }else{
116603       rc = sqlcipher3_declare_vtab(p->db, zSql);
116604     }
116605
116606     sqlcipher3_free(zSql);
116607     sqlcipher3_free(zCols);
116608     *pRc = rc;
116609   }
116610 }
116611
116612 /*
116613 ** Create the backing store tables (%_content, %_segments and %_segdir)
116614 ** required by the FTS3 table passed as the only argument. This is done
116615 ** as part of the vtab xCreate() method.
116616 **
116617 ** If the p->bHasDocsize boolean is true (indicating that this is an
116618 ** FTS4 table, not an FTS3 table) then also create the %_docsize and
116619 ** %_stat tables required by FTS4.
116620 */
116621 static int fts3CreateTables(Fts3Table *p){
116622   int rc = SQLCIPHER_OK;             /* Return code */
116623   int i;                          /* Iterator variable */
116624   sqlcipher3 *db = p->db;            /* The database connection */
116625
116626   if( p->zContentTbl==0 ){
116627     char *zContentCols;           /* Columns of %_content table */
116628
116629     /* Create a list of user columns for the content table */
116630     zContentCols = sqlcipher3_mprintf("docid INTEGER PRIMARY KEY");
116631     for(i=0; zContentCols && i<p->nColumn; i++){
116632       char *z = p->azColumn[i];
116633       zContentCols = sqlcipher3_mprintf("%z, 'c%d%q'", zContentCols, i, z);
116634     }
116635     if( zContentCols==0 ) rc = SQLCIPHER_NOMEM;
116636   
116637     /* Create the content table */
116638     fts3DbExec(&rc, db, 
116639        "CREATE TABLE %Q.'%q_content'(%s)",
116640        p->zDb, p->zName, zContentCols
116641     );
116642     sqlcipher3_free(zContentCols);
116643   }
116644
116645   /* Create other tables */
116646   fts3DbExec(&rc, db, 
116647       "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);",
116648       p->zDb, p->zName
116649   );
116650   fts3DbExec(&rc, db, 
116651       "CREATE TABLE %Q.'%q_segdir'("
116652         "level INTEGER,"
116653         "idx INTEGER,"
116654         "start_block INTEGER,"
116655         "leaves_end_block INTEGER,"
116656         "end_block INTEGER,"
116657         "root BLOB,"
116658         "PRIMARY KEY(level, idx)"
116659       ");",
116660       p->zDb, p->zName
116661   );
116662   if( p->bHasDocsize ){
116663     fts3DbExec(&rc, db, 
116664         "CREATE TABLE %Q.'%q_docsize'(docid INTEGER PRIMARY KEY, size BLOB);",
116665         p->zDb, p->zName
116666     );
116667   }
116668   if( p->bHasStat ){
116669     fts3DbExec(&rc, db, 
116670         "CREATE TABLE %Q.'%q_stat'(id INTEGER PRIMARY KEY, value BLOB);",
116671         p->zDb, p->zName
116672     );
116673   }
116674   return rc;
116675 }
116676
116677 /*
116678 ** Store the current database page-size in bytes in p->nPgsz.
116679 **
116680 ** If *pRc is non-zero when this function is called, it is a no-op. 
116681 ** Otherwise, if an error occurs, an SQLite error code is stored in *pRc
116682 ** before returning.
116683 */
116684 static void fts3DatabasePageSize(int *pRc, Fts3Table *p){
116685   if( *pRc==SQLCIPHER_OK ){
116686     int rc;                       /* Return code */
116687     char *zSql;                   /* SQL text "PRAGMA %Q.page_size" */
116688     sqlcipher3_stmt *pStmt;          /* Compiled "PRAGMA %Q.page_size" statement */
116689   
116690     zSql = sqlcipher3_mprintf("PRAGMA %Q.page_size", p->zDb);
116691     if( !zSql ){
116692       rc = SQLCIPHER_NOMEM;
116693     }else{
116694       rc = sqlcipher3_prepare(p->db, zSql, -1, &pStmt, 0);
116695       if( rc==SQLCIPHER_OK ){
116696         sqlcipher3_step(pStmt);
116697         p->nPgsz = sqlcipher3_column_int(pStmt, 0);
116698         rc = sqlcipher3_finalize(pStmt);
116699       }else if( rc==SQLCIPHER_AUTH ){
116700         p->nPgsz = 1024;
116701         rc = SQLCIPHER_OK;
116702       }
116703     }
116704     assert( p->nPgsz>0 || rc!=SQLCIPHER_OK );
116705     sqlcipher3_free(zSql);
116706     *pRc = rc;
116707   }
116708 }
116709
116710 /*
116711 ** "Special" FTS4 arguments are column specifications of the following form:
116712 **
116713 **   <key> = <value>
116714 **
116715 ** There may not be whitespace surrounding the "=" character. The <value> 
116716 ** term may be quoted, but the <key> may not.
116717 */
116718 static int fts3IsSpecialColumn(
116719   const char *z, 
116720   int *pnKey,
116721   char **pzValue
116722 ){
116723   char *zValue;
116724   const char *zCsr = z;
116725
116726   while( *zCsr!='=' ){
116727     if( *zCsr=='\0' ) return 0;
116728     zCsr++;
116729   }
116730
116731   *pnKey = (int)(zCsr-z);
116732   zValue = sqlcipher3_mprintf("%s", &zCsr[1]);
116733   if( zValue ){
116734     sqlcipher3Fts3Dequote(zValue);
116735   }
116736   *pzValue = zValue;
116737   return 1;
116738 }
116739
116740 /*
116741 ** Append the output of a printf() style formatting to an existing string.
116742 */
116743 static void fts3Appendf(
116744   int *pRc,                       /* IN/OUT: Error code */
116745   char **pz,                      /* IN/OUT: Pointer to string buffer */
116746   const char *zFormat,            /* Printf format string to append */
116747   ...                             /* Arguments for printf format string */
116748 ){
116749   if( *pRc==SQLCIPHER_OK ){
116750     va_list ap;
116751     char *z;
116752     va_start(ap, zFormat);
116753     z = sqlcipher3_vmprintf(zFormat, ap);
116754     if( z && *pz ){
116755       char *z2 = sqlcipher3_mprintf("%s%s", *pz, z);
116756       sqlcipher3_free(z);
116757       z = z2;
116758     }
116759     if( z==0 ) *pRc = SQLCIPHER_NOMEM;
116760     sqlcipher3_free(*pz);
116761     *pz = z;
116762   }
116763 }
116764
116765 /*
116766 ** Return a copy of input string zInput enclosed in double-quotes (") and
116767 ** with all double quote characters escaped. For example:
116768 **
116769 **     fts3QuoteId("un \"zip\"")   ->    "un \"\"zip\"\""
116770 **
116771 ** The pointer returned points to memory obtained from sqlcipher3_malloc(). It
116772 ** is the callers responsibility to call sqlcipher3_free() to release this
116773 ** memory.
116774 */
116775 static char *fts3QuoteId(char const *zInput){
116776   int nRet;
116777   char *zRet;
116778   nRet = 2 + strlen(zInput)*2 + 1;
116779   zRet = sqlcipher3_malloc(nRet);
116780   if( zRet ){
116781     int i;
116782     char *z = zRet;
116783     *(z++) = '"';
116784     for(i=0; zInput[i]; i++){
116785       if( zInput[i]=='"' ) *(z++) = '"';
116786       *(z++) = zInput[i];
116787     }
116788     *(z++) = '"';
116789     *(z++) = '\0';
116790   }
116791   return zRet;
116792 }
116793
116794 /*
116795 ** Return a list of comma separated SQL expressions and a FROM clause that 
116796 ** could be used in a SELECT statement such as the following:
116797 **
116798 **     SELECT <list of expressions> FROM %_content AS x ...
116799 **
116800 ** to return the docid, followed by each column of text data in order
116801 ** from left to write. If parameter zFunc is not NULL, then instead of
116802 ** being returned directly each column of text data is passed to an SQL
116803 ** function named zFunc first. For example, if zFunc is "unzip" and the
116804 ** table has the three user-defined columns "a", "b", and "c", the following
116805 ** string is returned:
116806 **
116807 **     "docid, unzip(x.'a'), unzip(x.'b'), unzip(x.'c') FROM %_content AS x"
116808 **
116809 ** The pointer returned points to a buffer allocated by sqlcipher3_malloc(). It
116810 ** is the responsibility of the caller to eventually free it.
116811 **
116812 ** If *pRc is not SQLCIPHER_OK when this function is called, it is a no-op (and
116813 ** a NULL pointer is returned). Otherwise, if an OOM error is encountered
116814 ** by this function, NULL is returned and *pRc is set to SQLCIPHER_NOMEM. If
116815 ** no error occurs, *pRc is left unmodified.
116816 */
116817 static char *fts3ReadExprList(Fts3Table *p, const char *zFunc, int *pRc){
116818   char *zRet = 0;
116819   char *zFree = 0;
116820   char *zFunction;
116821   int i;
116822
116823   if( p->zContentTbl==0 ){
116824     if( !zFunc ){
116825       zFunction = "";
116826     }else{
116827       zFree = zFunction = fts3QuoteId(zFunc);
116828     }
116829     fts3Appendf(pRc, &zRet, "docid");
116830     for(i=0; i<p->nColumn; i++){
116831       fts3Appendf(pRc, &zRet, ",%s(x.'c%d%q')", zFunction, i, p->azColumn[i]);
116832     }
116833     sqlcipher3_free(zFree);
116834   }else{
116835     fts3Appendf(pRc, &zRet, "rowid");
116836     for(i=0; i<p->nColumn; i++){
116837       fts3Appendf(pRc, &zRet, ", x.'%q'", p->azColumn[i]);
116838     }
116839   }
116840   fts3Appendf(pRc, &zRet, "FROM '%q'.'%q%s' AS x", 
116841       p->zDb,
116842       (p->zContentTbl ? p->zContentTbl : p->zName),
116843       (p->zContentTbl ? "" : "_content")
116844   );
116845   return zRet;
116846 }
116847
116848 /*
116849 ** Return a list of N comma separated question marks, where N is the number
116850 ** of columns in the %_content table (one for the docid plus one for each
116851 ** user-defined text column).
116852 **
116853 ** If argument zFunc is not NULL, then all but the first question mark
116854 ** is preceded by zFunc and an open bracket, and followed by a closed
116855 ** bracket. For example, if zFunc is "zip" and the FTS3 table has three 
116856 ** user-defined text columns, the following string is returned:
116857 **
116858 **     "?, zip(?), zip(?), zip(?)"
116859 **
116860 ** The pointer returned points to a buffer allocated by sqlcipher3_malloc(). It
116861 ** is the responsibility of the caller to eventually free it.
116862 **
116863 ** If *pRc is not SQLCIPHER_OK when this function is called, it is a no-op (and
116864 ** a NULL pointer is returned). Otherwise, if an OOM error is encountered
116865 ** by this function, NULL is returned and *pRc is set to SQLCIPHER_NOMEM. If
116866 ** no error occurs, *pRc is left unmodified.
116867 */
116868 static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){
116869   char *zRet = 0;
116870   char *zFree = 0;
116871   char *zFunction;
116872   int i;
116873
116874   if( !zFunc ){
116875     zFunction = "";
116876   }else{
116877     zFree = zFunction = fts3QuoteId(zFunc);
116878   }
116879   fts3Appendf(pRc, &zRet, "?");
116880   for(i=0; i<p->nColumn; i++){
116881     fts3Appendf(pRc, &zRet, ",%s(?)", zFunction);
116882   }
116883   sqlcipher3_free(zFree);
116884   return zRet;
116885 }
116886
116887 /*
116888 ** This function interprets the string at (*pp) as a non-negative integer
116889 ** value. It reads the integer and sets *pnOut to the value read, then 
116890 ** sets *pp to point to the byte immediately following the last byte of
116891 ** the integer value.
116892 **
116893 ** Only decimal digits ('0'..'9') may be part of an integer value. 
116894 **
116895 ** If *pp does not being with a decimal digit SQLCIPHER_ERROR is returned and
116896 ** the output value undefined. Otherwise SQLCIPHER_OK is returned.
116897 **
116898 ** This function is used when parsing the "prefix=" FTS4 parameter.
116899 */
116900 static int fts3GobbleInt(const char **pp, int *pnOut){
116901   const char *p;                  /* Iterator pointer */
116902   int nInt = 0;                   /* Output value */
116903
116904   for(p=*pp; p[0]>='0' && p[0]<='9'; p++){
116905     nInt = nInt * 10 + (p[0] - '0');
116906   }
116907   if( p==*pp ) return SQLCIPHER_ERROR;
116908   *pnOut = nInt;
116909   *pp = p;
116910   return SQLCIPHER_OK;
116911 }
116912
116913 /*
116914 ** This function is called to allocate an array of Fts3Index structures
116915 ** representing the indexes maintained by the current FTS table. FTS tables
116916 ** always maintain the main "terms" index, but may also maintain one or
116917 ** more "prefix" indexes, depending on the value of the "prefix=" parameter
116918 ** (if any) specified as part of the CREATE VIRTUAL TABLE statement.
116919 **
116920 ** Argument zParam is passed the value of the "prefix=" option if one was
116921 ** specified, or NULL otherwise.
116922 **
116923 ** If no error occurs, SQLCIPHER_OK is returned and *apIndex set to point to
116924 ** the allocated array. *pnIndex is set to the number of elements in the
116925 ** array. If an error does occur, an SQLite error code is returned.
116926 **
116927 ** Regardless of whether or not an error is returned, it is the responsibility
116928 ** of the caller to call sqlcipher3_free() on the output array to free it.
116929 */
116930 static int fts3PrefixParameter(
116931   const char *zParam,             /* ABC in prefix=ABC parameter to parse */
116932   int *pnIndex,                   /* OUT: size of *apIndex[] array */
116933   struct Fts3Index **apIndex      /* OUT: Array of indexes for this table */
116934 ){
116935   struct Fts3Index *aIndex;       /* Allocated array */
116936   int nIndex = 1;                 /* Number of entries in array */
116937
116938   if( zParam && zParam[0] ){
116939     const char *p;
116940     nIndex++;
116941     for(p=zParam; *p; p++){
116942       if( *p==',' ) nIndex++;
116943     }
116944   }
116945
116946   aIndex = sqlcipher3_malloc(sizeof(struct Fts3Index) * nIndex);
116947   *apIndex = aIndex;
116948   *pnIndex = nIndex;
116949   if( !aIndex ){
116950     return SQLCIPHER_NOMEM;
116951   }
116952
116953   memset(aIndex, 0, sizeof(struct Fts3Index) * nIndex);
116954   if( zParam ){
116955     const char *p = zParam;
116956     int i;
116957     for(i=1; i<nIndex; i++){
116958       int nPrefix;
116959       if( fts3GobbleInt(&p, &nPrefix) ) return SQLCIPHER_ERROR;
116960       aIndex[i].nPrefix = nPrefix;
116961       p++;
116962     }
116963   }
116964
116965   return SQLCIPHER_OK;
116966 }
116967
116968 /*
116969 ** This function is called when initializing an FTS4 table that uses the
116970 ** content=xxx option. It determines the number of and names of the columns
116971 ** of the new FTS4 table.
116972 **
116973 ** The third argument passed to this function is the value passed to the
116974 ** config=xxx option (i.e. "xxx"). This function queries the database for
116975 ** a table of that name. If found, the output variables are populated
116976 ** as follows:
116977 **
116978 **   *pnCol:   Set to the number of columns table xxx has,
116979 **
116980 **   *pnStr:   Set to the total amount of space required to store a copy
116981 **             of each columns name, including the nul-terminator.
116982 **
116983 **   *pazCol:  Set to point to an array of *pnCol strings. Each string is
116984 **             the name of the corresponding column in table xxx. The array
116985 **             and its contents are allocated using a single allocation. It
116986 **             is the responsibility of the caller to free this allocation
116987 **             by eventually passing the *pazCol value to sqlcipher3_free().
116988 **
116989 ** If the table cannot be found, an error code is returned and the output
116990 ** variables are undefined. Or, if an OOM is encountered, SQLCIPHER_NOMEM is
116991 ** returned (and the output variables are undefined).
116992 */
116993 static int fts3ContentColumns(
116994   sqlcipher3 *db,                    /* Database handle */
116995   const char *zDb,                /* Name of db (i.e. "main", "temp" etc.) */
116996   const char *zTbl,               /* Name of content table */
116997   const char ***pazCol,           /* OUT: Malloc'd array of column names */
116998   int *pnCol,                     /* OUT: Size of array *pazCol */
116999   int *pnStr                      /* OUT: Bytes of string content */
117000 ){
117001   int rc = SQLCIPHER_OK;             /* Return code */
117002   char *zSql;                     /* "SELECT *" statement on zTbl */  
117003   sqlcipher3_stmt *pStmt = 0;        /* Compiled version of zSql */
117004
117005   zSql = sqlcipher3_mprintf("SELECT * FROM %Q.%Q", zDb, zTbl);
117006   if( !zSql ){
117007     rc = SQLCIPHER_NOMEM;
117008   }else{
117009     rc = sqlcipher3_prepare(db, zSql, -1, &pStmt, 0);
117010   }
117011   sqlcipher3_free(zSql);
117012
117013   if( rc==SQLCIPHER_OK ){
117014     const char **azCol;           /* Output array */
117015     int nStr = 0;                 /* Size of all column names (incl. 0x00) */
117016     int nCol;                     /* Number of table columns */
117017     int i;                        /* Used to iterate through columns */
117018
117019     /* Loop through the returned columns. Set nStr to the number of bytes of
117020     ** space required to store a copy of each column name, including the
117021     ** nul-terminator byte.  */
117022     nCol = sqlcipher3_column_count(pStmt);
117023     for(i=0; i<nCol; i++){
117024       const char *zCol = sqlcipher3_column_name(pStmt, i);
117025       nStr += strlen(zCol) + 1;
117026     }
117027
117028     /* Allocate and populate the array to return. */
117029     azCol = (const char **)sqlcipher3_malloc(sizeof(char *) * nCol + nStr);
117030     if( azCol==0 ){
117031       rc = SQLCIPHER_NOMEM;
117032     }else{
117033       char *p = (char *)&azCol[nCol];
117034       for(i=0; i<nCol; i++){
117035         const char *zCol = sqlcipher3_column_name(pStmt, i);
117036         int n = strlen(zCol)+1;
117037         memcpy(p, zCol, n);
117038         azCol[i] = p;
117039         p += n;
117040       }
117041     }
117042     sqlcipher3_finalize(pStmt);
117043
117044     /* Set the output variables. */
117045     *pnCol = nCol;
117046     *pnStr = nStr;
117047     *pazCol = azCol;
117048   }
117049
117050   return rc;
117051 }
117052
117053 /*
117054 ** This function is the implementation of both the xConnect and xCreate
117055 ** methods of the FTS3 virtual table.
117056 **
117057 ** The argv[] array contains the following:
117058 **
117059 **   argv[0]   -> module name  ("fts3" or "fts4")
117060 **   argv[1]   -> database name
117061 **   argv[2]   -> table name
117062 **   argv[...] -> "column name" and other module argument fields.
117063 */
117064 static int fts3InitVtab(
117065   int isCreate,                   /* True for xCreate, false for xConnect */
117066   sqlcipher3 *db,                    /* The SQLite database connection */
117067   void *pAux,                     /* Hash table containing tokenizers */
117068   int argc,                       /* Number of elements in argv array */
117069   const char * const *argv,       /* xCreate/xConnect argument array */
117070   sqlcipher3_vtab **ppVTab,          /* Write the resulting vtab structure here */
117071   char **pzErr                    /* Write any error message here */
117072 ){
117073   Fts3Hash *pHash = (Fts3Hash *)pAux;
117074   Fts3Table *p = 0;               /* Pointer to allocated vtab */
117075   int rc = SQLCIPHER_OK;             /* Return code */
117076   int i;                          /* Iterator variable */
117077   int nByte;                      /* Size of allocation used for *p */
117078   int iCol;                       /* Column index */
117079   int nString = 0;                /* Bytes required to hold all column names */
117080   int nCol = 0;                   /* Number of columns in the FTS table */
117081   char *zCsr;                     /* Space for holding column names */
117082   int nDb;                        /* Bytes required to hold database name */
117083   int nName;                      /* Bytes required to hold table name */
117084   int isFts4 = (argv[0][3]=='4'); /* True for FTS4, false for FTS3 */
117085   const char **aCol;              /* Array of column names */
117086   sqlcipher3_tokenizer *pTokenizer = 0;        /* Tokenizer for this table */
117087
117088   int nIndex;                     /* Size of aIndex[] array */
117089   struct Fts3Index *aIndex = 0;   /* Array of indexes for this table */
117090
117091   /* The results of parsing supported FTS4 key=value options: */
117092   int bNoDocsize = 0;             /* True to omit %_docsize table */
117093   int bDescIdx = 0;               /* True to store descending indexes */
117094   char *zPrefix = 0;              /* Prefix parameter value (or NULL) */
117095   char *zCompress = 0;            /* compress=? parameter (or NULL) */
117096   char *zUncompress = 0;          /* uncompress=? parameter (or NULL) */
117097   char *zContent = 0;             /* content=? parameter (or NULL) */
117098
117099   assert( strlen(argv[0])==4 );
117100   assert( (sqlcipher3_strnicmp(argv[0], "fts4", 4)==0 && isFts4)
117101        || (sqlcipher3_strnicmp(argv[0], "fts3", 4)==0 && !isFts4)
117102   );
117103
117104   nDb = (int)strlen(argv[1]) + 1;
117105   nName = (int)strlen(argv[2]) + 1;
117106
117107   aCol = (const char **)sqlcipher3_malloc(sizeof(const char *) * (argc-2) );
117108   if( !aCol ) return SQLCIPHER_NOMEM;
117109   memset((void *)aCol, 0, sizeof(const char *) * (argc-2));
117110
117111   /* Loop through all of the arguments passed by the user to the FTS3/4
117112   ** module (i.e. all the column names and special arguments). This loop
117113   ** does the following:
117114   **
117115   **   + Figures out the number of columns the FTSX table will have, and
117116   **     the number of bytes of space that must be allocated to store copies
117117   **     of the column names.
117118   **
117119   **   + If there is a tokenizer specification included in the arguments,
117120   **     initializes the tokenizer pTokenizer.
117121   */
117122   for(i=3; rc==SQLCIPHER_OK && i<argc; i++){
117123     char const *z = argv[i];
117124     int nKey;
117125     char *zVal;
117126
117127     /* Check if this is a tokenizer specification */
117128     if( !pTokenizer 
117129      && strlen(z)>8
117130      && 0==sqlcipher3_strnicmp(z, "tokenize", 8) 
117131      && 0==sqlcipher3Fts3IsIdChar(z[8])
117132     ){
117133       rc = sqlcipher3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr);
117134     }
117135
117136     /* Check if it is an FTS4 special argument. */
117137     else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
117138       struct Fts4Option {
117139         const char *zOpt;
117140         int nOpt;
117141       } aFts4Opt[] = {
117142         { "matchinfo",   9 },     /* 0 -> MATCHINFO */
117143         { "prefix",      6 },     /* 1 -> PREFIX */
117144         { "compress",    8 },     /* 2 -> COMPRESS */
117145         { "uncompress", 10 },     /* 3 -> UNCOMPRESS */
117146         { "order",       5 },     /* 4 -> ORDER */
117147         { "content",     7 }      /* 5 -> CONTENT */
117148       };
117149
117150       int iOpt;
117151       if( !zVal ){
117152         rc = SQLCIPHER_NOMEM;
117153       }else{
117154         for(iOpt=0; iOpt<SizeofArray(aFts4Opt); iOpt++){
117155           struct Fts4Option *pOp = &aFts4Opt[iOpt];
117156           if( nKey==pOp->nOpt && !sqlcipher3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){
117157             break;
117158           }
117159         }
117160         if( iOpt==SizeofArray(aFts4Opt) ){
117161           *pzErr = sqlcipher3_mprintf("unrecognized parameter: %s", z);
117162           rc = SQLCIPHER_ERROR;
117163         }else{
117164           switch( iOpt ){
117165             case 0:               /* MATCHINFO */
117166               if( strlen(zVal)!=4 || sqlcipher3_strnicmp(zVal, "fts3", 4) ){
117167                 *pzErr = sqlcipher3_mprintf("unrecognized matchinfo: %s", zVal);
117168                 rc = SQLCIPHER_ERROR;
117169               }
117170               bNoDocsize = 1;
117171               break;
117172
117173             case 1:               /* PREFIX */
117174               sqlcipher3_free(zPrefix);
117175               zPrefix = zVal;
117176               zVal = 0;
117177               break;
117178
117179             case 2:               /* COMPRESS */
117180               sqlcipher3_free(zCompress);
117181               zCompress = zVal;
117182               zVal = 0;
117183               break;
117184
117185             case 3:               /* UNCOMPRESS */
117186               sqlcipher3_free(zUncompress);
117187               zUncompress = zVal;
117188               zVal = 0;
117189               break;
117190
117191             case 4:               /* ORDER */
117192               if( (strlen(zVal)!=3 || sqlcipher3_strnicmp(zVal, "asc", 3)) 
117193                && (strlen(zVal)!=4 || sqlcipher3_strnicmp(zVal, "desc", 4)) 
117194               ){
117195                 *pzErr = sqlcipher3_mprintf("unrecognized order: %s", zVal);
117196                 rc = SQLCIPHER_ERROR;
117197               }
117198               bDescIdx = (zVal[0]=='d' || zVal[0]=='D');
117199               break;
117200
117201             default:              /* CONTENT */
117202               assert( iOpt==5 );
117203               sqlcipher3_free(zUncompress);
117204               zContent = zVal;
117205               zVal = 0;
117206               break;
117207           }
117208         }
117209         sqlcipher3_free(zVal);
117210       }
117211     }
117212
117213     /* Otherwise, the argument is a column name. */
117214     else {
117215       nString += (int)(strlen(z) + 1);
117216       aCol[nCol++] = z;
117217     }
117218   }
117219
117220   /* If a content=xxx option was specified, the following:
117221   **
117222   **   1. Ignore any compress= and uncompress= options.
117223   **
117224   **   2. If no column names were specified as part of the CREATE VIRTUAL
117225   **      TABLE statement, use all columns from the content table.
117226   */
117227   if( rc==SQLCIPHER_OK && zContent ){
117228     sqlcipher3_free(zCompress); 
117229     sqlcipher3_free(zUncompress); 
117230     zCompress = 0;
117231     zUncompress = 0;
117232     if( nCol==0 ){
117233       sqlcipher3_free((void*)aCol); 
117234       aCol = 0;
117235       rc = fts3ContentColumns(db, argv[1], zContent, &aCol, &nCol, &nString);
117236     }
117237     assert( rc!=SQLCIPHER_OK || nCol>0 );
117238   }
117239   if( rc!=SQLCIPHER_OK ) goto fts3_init_out;
117240
117241   if( nCol==0 ){
117242     assert( nString==0 );
117243     aCol[0] = "content";
117244     nString = 8;
117245     nCol = 1;
117246   }
117247
117248   if( pTokenizer==0 ){
117249     rc = sqlcipher3Fts3InitTokenizer(pHash, "simple", &pTokenizer, pzErr);
117250     if( rc!=SQLCIPHER_OK ) goto fts3_init_out;
117251   }
117252   assert( pTokenizer );
117253
117254   rc = fts3PrefixParameter(zPrefix, &nIndex, &aIndex);
117255   if( rc==SQLCIPHER_ERROR ){
117256     assert( zPrefix );
117257     *pzErr = sqlcipher3_mprintf("error parsing prefix parameter: %s", zPrefix);
117258   }
117259   if( rc!=SQLCIPHER_OK ) goto fts3_init_out;
117260
117261   /* Allocate and populate the Fts3Table structure. */
117262   nByte = sizeof(Fts3Table) +                  /* Fts3Table */
117263           nCol * sizeof(char *) +              /* azColumn */
117264           nIndex * sizeof(struct Fts3Index) +  /* aIndex */
117265           nName +                              /* zName */
117266           nDb +                                /* zDb */
117267           nString;                             /* Space for azColumn strings */
117268   p = (Fts3Table*)sqlcipher3_malloc(nByte);
117269   if( p==0 ){
117270     rc = SQLCIPHER_NOMEM;
117271     goto fts3_init_out;
117272   }
117273   memset(p, 0, nByte);
117274   p->db = db;
117275   p->nColumn = nCol;
117276   p->nPendingData = 0;
117277   p->azColumn = (char **)&p[1];
117278   p->pTokenizer = pTokenizer;
117279   p->nMaxPendingData = FTS3_MAX_PENDING_DATA;
117280   p->bHasDocsize = (isFts4 && bNoDocsize==0);
117281   p->bHasStat = isFts4;
117282   p->bDescIdx = bDescIdx;
117283   p->zContentTbl = zContent;
117284   zContent = 0;
117285   TESTONLY( p->inTransaction = -1 );
117286   TESTONLY( p->mxSavepoint = -1 );
117287
117288   p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
117289   memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex);
117290   p->nIndex = nIndex;
117291   for(i=0; i<nIndex; i++){
117292     fts3HashInit(&p->aIndex[i].hPending, FTS3_HASH_STRING, 1);
117293   }
117294
117295   /* Fill in the zName and zDb fields of the vtab structure. */
117296   zCsr = (char *)&p->aIndex[nIndex];
117297   p->zName = zCsr;
117298   memcpy(zCsr, argv[2], nName);
117299   zCsr += nName;
117300   p->zDb = zCsr;
117301   memcpy(zCsr, argv[1], nDb);
117302   zCsr += nDb;
117303
117304   /* Fill in the azColumn array */
117305   for(iCol=0; iCol<nCol; iCol++){
117306     char *z; 
117307     int n = 0;
117308     z = (char *)sqlcipher3Fts3NextToken(aCol[iCol], &n);
117309     memcpy(zCsr, z, n);
117310     zCsr[n] = '\0';
117311     sqlcipher3Fts3Dequote(zCsr);
117312     p->azColumn[iCol] = zCsr;
117313     zCsr += n+1;
117314     assert( zCsr <= &((char *)p)[nByte] );
117315   }
117316
117317   if( (zCompress==0)!=(zUncompress==0) ){
117318     char const *zMiss = (zCompress==0 ? "compress" : "uncompress");
117319     rc = SQLCIPHER_ERROR;
117320     *pzErr = sqlcipher3_mprintf("missing %s parameter in fts4 constructor", zMiss);
117321   }
117322   p->zReadExprlist = fts3ReadExprList(p, zUncompress, &rc);
117323   p->zWriteExprlist = fts3WriteExprList(p, zCompress, &rc);
117324   if( rc!=SQLCIPHER_OK ) goto fts3_init_out;
117325
117326   /* If this is an xCreate call, create the underlying tables in the 
117327   ** database. TODO: For xConnect(), it could verify that said tables exist.
117328   */
117329   if( isCreate ){
117330     rc = fts3CreateTables(p);
117331   }
117332
117333   /* Figure out the page-size for the database. This is required in order to
117334   ** estimate the cost of loading large doclists from the database.  */
117335   fts3DatabasePageSize(&rc, p);
117336   p->nNodeSize = p->nPgsz-35;
117337
117338   /* Declare the table schema to SQLite. */
117339   fts3DeclareVtab(&rc, p);
117340
117341 fts3_init_out:
117342   sqlcipher3_free(zPrefix);
117343   sqlcipher3_free(aIndex);
117344   sqlcipher3_free(zCompress);
117345   sqlcipher3_free(zUncompress);
117346   sqlcipher3_free(zContent);
117347   sqlcipher3_free((void *)aCol);
117348   if( rc!=SQLCIPHER_OK ){
117349     if( p ){
117350       fts3DisconnectMethod((sqlcipher3_vtab *)p);
117351     }else if( pTokenizer ){
117352       pTokenizer->pModule->xDestroy(pTokenizer);
117353     }
117354   }else{
117355     assert( p->pSegments==0 );
117356     *ppVTab = &p->base;
117357   }
117358   return rc;
117359 }
117360
117361 /*
117362 ** The xConnect() and xCreate() methods for the virtual table. All the
117363 ** work is done in function fts3InitVtab().
117364 */
117365 static int fts3ConnectMethod(
117366   sqlcipher3 *db,                    /* Database connection */
117367   void *pAux,                     /* Pointer to tokenizer hash table */
117368   int argc,                       /* Number of elements in argv array */
117369   const char * const *argv,       /* xCreate/xConnect argument array */
117370   sqlcipher3_vtab **ppVtab,          /* OUT: New sqlcipher3_vtab object */
117371   char **pzErr                    /* OUT: sqlcipher3_malloc'd error message */
117372 ){
117373   return fts3InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr);
117374 }
117375 static int fts3CreateMethod(
117376   sqlcipher3 *db,                    /* Database connection */
117377   void *pAux,                     /* Pointer to tokenizer hash table */
117378   int argc,                       /* Number of elements in argv array */
117379   const char * const *argv,       /* xCreate/xConnect argument array */
117380   sqlcipher3_vtab **ppVtab,          /* OUT: New sqlcipher3_vtab object */
117381   char **pzErr                    /* OUT: sqlcipher3_malloc'd error message */
117382 ){
117383   return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr);
117384 }
117385
117386 /* 
117387 ** Implementation of the xBestIndex method for FTS3 tables. There
117388 ** are three possible strategies, in order of preference:
117389 **
117390 **   1. Direct lookup by rowid or docid. 
117391 **   2. Full-text search using a MATCH operator on a non-docid column.
117392 **   3. Linear scan of %_content table.
117393 */
117394 static int fts3BestIndexMethod(sqlcipher3_vtab *pVTab, sqlcipher3_index_info *pInfo){
117395   Fts3Table *p = (Fts3Table *)pVTab;
117396   int i;                          /* Iterator variable */
117397   int iCons = -1;                 /* Index of constraint to use */
117398
117399   /* By default use a full table scan. This is an expensive option,
117400   ** so search through the constraints to see if a more efficient 
117401   ** strategy is possible.
117402   */
117403   pInfo->idxNum = FTS3_FULLSCAN_SEARCH;
117404   pInfo->estimatedCost = 500000;
117405   for(i=0; i<pInfo->nConstraint; i++){
117406     struct sqlcipher3_index_constraint *pCons = &pInfo->aConstraint[i];
117407     if( pCons->usable==0 ) continue;
117408
117409     /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */
117410     if( pCons->op==SQLCIPHER_INDEX_CONSTRAINT_EQ 
117411      && (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1 )
117412     ){
117413       pInfo->idxNum = FTS3_DOCID_SEARCH;
117414       pInfo->estimatedCost = 1.0;
117415       iCons = i;
117416     }
117417
117418     /* A MATCH constraint. Use a full-text search.
117419     **
117420     ** If there is more than one MATCH constraint available, use the first
117421     ** one encountered. If there is both a MATCH constraint and a direct
117422     ** rowid/docid lookup, prefer the MATCH strategy. This is done even 
117423     ** though the rowid/docid lookup is faster than a MATCH query, selecting
117424     ** it would lead to an "unable to use function MATCH in the requested 
117425     ** context" error.
117426     */
117427     if( pCons->op==SQLCIPHER_INDEX_CONSTRAINT_MATCH 
117428      && pCons->iColumn>=0 && pCons->iColumn<=p->nColumn
117429     ){
117430       pInfo->idxNum = FTS3_FULLTEXT_SEARCH + pCons->iColumn;
117431       pInfo->estimatedCost = 2.0;
117432       iCons = i;
117433       break;
117434     }
117435   }
117436
117437   if( iCons>=0 ){
117438     pInfo->aConstraintUsage[iCons].argvIndex = 1;
117439     pInfo->aConstraintUsage[iCons].omit = 1;
117440   } 
117441
117442   /* Regardless of the strategy selected, FTS can deliver rows in rowid (or
117443   ** docid) order. Both ascending and descending are possible. 
117444   */
117445   if( pInfo->nOrderBy==1 ){
117446     struct sqlcipher3_index_orderby *pOrder = &pInfo->aOrderBy[0];
117447     if( pOrder->iColumn<0 || pOrder->iColumn==p->nColumn+1 ){
117448       if( pOrder->desc ){
117449         pInfo->idxStr = "DESC";
117450       }else{
117451         pInfo->idxStr = "ASC";
117452       }
117453       pInfo->orderByConsumed = 1;
117454     }
117455   }
117456
117457   assert( p->pSegments==0 );
117458   return SQLCIPHER_OK;
117459 }
117460
117461 /*
117462 ** Implementation of xOpen method.
117463 */
117464 static int fts3OpenMethod(sqlcipher3_vtab *pVTab, sqlcipher3_vtab_cursor **ppCsr){
117465   sqlcipher3_vtab_cursor *pCsr;               /* Allocated cursor */
117466
117467   UNUSED_PARAMETER(pVTab);
117468
117469   /* Allocate a buffer large enough for an Fts3Cursor structure. If the
117470   ** allocation succeeds, zero it and return SQLCIPHER_OK. Otherwise, 
117471   ** if the allocation fails, return SQLCIPHER_NOMEM.
117472   */
117473   *ppCsr = pCsr = (sqlcipher3_vtab_cursor *)sqlcipher3_malloc(sizeof(Fts3Cursor));
117474   if( !pCsr ){
117475     return SQLCIPHER_NOMEM;
117476   }
117477   memset(pCsr, 0, sizeof(Fts3Cursor));
117478   return SQLCIPHER_OK;
117479 }
117480
117481 /*
117482 ** Close the cursor.  For additional information see the documentation
117483 ** on the xClose method of the virtual table interface.
117484 */
117485 static int fts3CloseMethod(sqlcipher3_vtab_cursor *pCursor){
117486   Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
117487   assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
117488   sqlcipher3_finalize(pCsr->pStmt);
117489   sqlcipher3Fts3ExprFree(pCsr->pExpr);
117490   sqlcipher3Fts3FreeDeferredTokens(pCsr);
117491   sqlcipher3_free(pCsr->aDoclist);
117492   sqlcipher3_free(pCsr->aMatchinfo);
117493   assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
117494   sqlcipher3_free(pCsr);
117495   return SQLCIPHER_OK;
117496 }
117497
117498 /*
117499 ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
117500 ** compose and prepare an SQL statement of the form:
117501 **
117502 **    "SELECT <columns> FROM %_content WHERE rowid = ?"
117503 **
117504 ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
117505 ** it. If an error occurs, return an SQLite error code.
117506 **
117507 ** Otherwise, set *ppStmt to point to pCsr->pStmt and return SQLCIPHER_OK.
117508 */
117509 static int fts3CursorSeekStmt(Fts3Cursor *pCsr, sqlcipher3_stmt **ppStmt){
117510   int rc = SQLCIPHER_OK;
117511   if( pCsr->pStmt==0 ){
117512     Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
117513     char *zSql;
117514     zSql = sqlcipher3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist);
117515     if( !zSql ) return SQLCIPHER_NOMEM;
117516     rc = sqlcipher3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
117517     sqlcipher3_free(zSql);
117518   }
117519   *ppStmt = pCsr->pStmt;
117520   return rc;
117521 }
117522
117523 /*
117524 ** Position the pCsr->pStmt statement so that it is on the row
117525 ** of the %_content table that contains the last match.  Return
117526 ** SQLCIPHER_OK on success.  
117527 */
117528 static int fts3CursorSeek(sqlcipher3_context *pContext, Fts3Cursor *pCsr){
117529   int rc = SQLCIPHER_OK;
117530   if( pCsr->isRequireSeek ){
117531     sqlcipher3_stmt *pStmt = 0;
117532
117533     rc = fts3CursorSeekStmt(pCsr, &pStmt);
117534     if( rc==SQLCIPHER_OK ){
117535       sqlcipher3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
117536       pCsr->isRequireSeek = 0;
117537       if( SQLCIPHER_ROW==sqlcipher3_step(pCsr->pStmt) ){
117538         return SQLCIPHER_OK;
117539       }else{
117540         rc = sqlcipher3_reset(pCsr->pStmt);
117541         if( rc==SQLCIPHER_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
117542           /* If no row was found and no error has occured, then the %_content
117543           ** table is missing a row that is present in the full-text index.
117544           ** The data structures are corrupt.  */
117545           rc = FTS_CORRUPT_VTAB;
117546           pCsr->isEof = 1;
117547         }
117548       }
117549     }
117550   }
117551
117552   if( rc!=SQLCIPHER_OK && pContext ){
117553     sqlcipher3_result_error_code(pContext, rc);
117554   }
117555   return rc;
117556 }
117557
117558 /*
117559 ** This function is used to process a single interior node when searching
117560 ** a b-tree for a term or term prefix. The node data is passed to this 
117561 ** function via the zNode/nNode parameters. The term to search for is
117562 ** passed in zTerm/nTerm.
117563 **
117564 ** If piFirst is not NULL, then this function sets *piFirst to the blockid
117565 ** of the child node that heads the sub-tree that may contain the term.
117566 **
117567 ** If piLast is not NULL, then *piLast is set to the right-most child node
117568 ** that heads a sub-tree that may contain a term for which zTerm/nTerm is
117569 ** a prefix.
117570 **
117571 ** If an OOM error occurs, SQLCIPHER_NOMEM is returned. Otherwise, SQLCIPHER_OK.
117572 */
117573 static int fts3ScanInteriorNode(
117574   const char *zTerm,              /* Term to select leaves for */
117575   int nTerm,                      /* Size of term zTerm in bytes */
117576   const char *zNode,              /* Buffer containing segment interior node */
117577   int nNode,                      /* Size of buffer at zNode */
117578   sqlcipher3_int64 *piFirst,         /* OUT: Selected child node */
117579   sqlcipher3_int64 *piLast           /* OUT: Selected child node */
117580 ){
117581   int rc = SQLCIPHER_OK;             /* Return code */
117582   const char *zCsr = zNode;       /* Cursor to iterate through node */
117583   const char *zEnd = &zCsr[nNode];/* End of interior node buffer */
117584   char *zBuffer = 0;              /* Buffer to load terms into */
117585   int nAlloc = 0;                 /* Size of allocated buffer */
117586   int isFirstTerm = 1;            /* True when processing first term on page */
117587   sqlcipher3_int64 iChild;           /* Block id of child node to descend to */
117588
117589   /* Skip over the 'height' varint that occurs at the start of every 
117590   ** interior node. Then load the blockid of the left-child of the b-tree
117591   ** node into variable iChild.  
117592   **
117593   ** Even if the data structure on disk is corrupted, this (reading two
117594   ** varints from the buffer) does not risk an overread. If zNode is a
117595   ** root node, then the buffer comes from a SELECT statement. SQLite does
117596   ** not make this guarantee explicitly, but in practice there are always
117597   ** either more than 20 bytes of allocated space following the nNode bytes of
117598   ** contents, or two zero bytes. Or, if the node is read from the %_segments
117599   ** table, then there are always 20 bytes of zeroed padding following the
117600   ** nNode bytes of content (see sqlcipher3Fts3ReadBlock() for details).
117601   */
117602   zCsr += sqlcipher3Fts3GetVarint(zCsr, &iChild);
117603   zCsr += sqlcipher3Fts3GetVarint(zCsr, &iChild);
117604   if( zCsr>zEnd ){
117605     return FTS_CORRUPT_VTAB;
117606   }
117607   
117608   while( zCsr<zEnd && (piFirst || piLast) ){
117609     int cmp;                      /* memcmp() result */
117610     int nSuffix;                  /* Size of term suffix */
117611     int nPrefix = 0;              /* Size of term prefix */
117612     int nBuffer;                  /* Total term size */
117613   
117614     /* Load the next term on the node into zBuffer. Use realloc() to expand
117615     ** the size of zBuffer if required.  */
117616     if( !isFirstTerm ){
117617       zCsr += sqlcipher3Fts3GetVarint32(zCsr, &nPrefix);
117618     }
117619     isFirstTerm = 0;
117620     zCsr += sqlcipher3Fts3GetVarint32(zCsr, &nSuffix);
117621     
117622     if( nPrefix<0 || nSuffix<0 || &zCsr[nSuffix]>zEnd ){
117623       rc = FTS_CORRUPT_VTAB;
117624       goto finish_scan;
117625     }
117626     if( nPrefix+nSuffix>nAlloc ){
117627       char *zNew;
117628       nAlloc = (nPrefix+nSuffix) * 2;
117629       zNew = (char *)sqlcipher3_realloc(zBuffer, nAlloc);
117630       if( !zNew ){
117631         rc = SQLCIPHER_NOMEM;
117632         goto finish_scan;
117633       }
117634       zBuffer = zNew;
117635     }
117636     assert( zBuffer );
117637     memcpy(&zBuffer[nPrefix], zCsr, nSuffix);
117638     nBuffer = nPrefix + nSuffix;
117639     zCsr += nSuffix;
117640
117641     /* Compare the term we are searching for with the term just loaded from
117642     ** the interior node. If the specified term is greater than or equal
117643     ** to the term from the interior node, then all terms on the sub-tree 
117644     ** headed by node iChild are smaller than zTerm. No need to search 
117645     ** iChild.
117646     **
117647     ** If the interior node term is larger than the specified term, then
117648     ** the tree headed by iChild may contain the specified term.
117649     */
117650     cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer));
117651     if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){
117652       *piFirst = iChild;
117653       piFirst = 0;
117654     }
117655
117656     if( piLast && cmp<0 ){
117657       *piLast = iChild;
117658       piLast = 0;
117659     }
117660
117661     iChild++;
117662   };
117663
117664   if( piFirst ) *piFirst = iChild;
117665   if( piLast ) *piLast = iChild;
117666
117667  finish_scan:
117668   sqlcipher3_free(zBuffer);
117669   return rc;
117670 }
117671
117672
117673 /*
117674 ** The buffer pointed to by argument zNode (size nNode bytes) contains an
117675 ** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes)
117676 ** contains a term. This function searches the sub-tree headed by the zNode
117677 ** node for the range of leaf nodes that may contain the specified term
117678 ** or terms for which the specified term is a prefix.
117679 **
117680 ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the 
117681 ** left-most leaf node in the tree that may contain the specified term.
117682 ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
117683 ** right-most leaf node that may contain a term for which the specified
117684 ** term is a prefix.
117685 **
117686 ** It is possible that the range of returned leaf nodes does not contain 
117687 ** the specified term or any terms for which it is a prefix. However, if the 
117688 ** segment does contain any such terms, they are stored within the identified
117689 ** range. Because this function only inspects interior segment nodes (and
117690 ** never loads leaf nodes into memory), it is not possible to be sure.
117691 **
117692 ** If an error occurs, an error code other than SQLCIPHER_OK is returned.
117693 */ 
117694 static int fts3SelectLeaf(
117695   Fts3Table *p,                   /* Virtual table handle */
117696   const char *zTerm,              /* Term to select leaves for */
117697   int nTerm,                      /* Size of term zTerm in bytes */
117698   const char *zNode,              /* Buffer containing segment interior node */
117699   int nNode,                      /* Size of buffer at zNode */
117700   sqlcipher3_int64 *piLeaf,          /* Selected leaf node */
117701   sqlcipher3_int64 *piLeaf2          /* Selected leaf node */
117702 ){
117703   int rc;                         /* Return code */
117704   int iHeight;                    /* Height of this node in tree */
117705
117706   assert( piLeaf || piLeaf2 );
117707
117708   sqlcipher3Fts3GetVarint32(zNode, &iHeight);
117709   rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2);
117710   assert( !piLeaf2 || !piLeaf || rc!=SQLCIPHER_OK || (*piLeaf<=*piLeaf2) );
117711
117712   if( rc==SQLCIPHER_OK && iHeight>1 ){
117713     char *zBlob = 0;              /* Blob read from %_segments table */
117714     int nBlob;                    /* Size of zBlob in bytes */
117715
117716     if( piLeaf && piLeaf2 && (*piLeaf!=*piLeaf2) ){
117717       rc = sqlcipher3Fts3ReadBlock(p, *piLeaf, &zBlob, &nBlob, 0);
117718       if( rc==SQLCIPHER_OK ){
117719         rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0);
117720       }
117721       sqlcipher3_free(zBlob);
117722       piLeaf = 0;
117723       zBlob = 0;
117724     }
117725
117726     if( rc==SQLCIPHER_OK ){
117727       rc = sqlcipher3Fts3ReadBlock(p, piLeaf?*piLeaf:*piLeaf2, &zBlob, &nBlob, 0);
117728     }
117729     if( rc==SQLCIPHER_OK ){
117730       rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2);
117731     }
117732     sqlcipher3_free(zBlob);
117733   }
117734
117735   return rc;
117736 }
117737
117738 /*
117739 ** This function is used to create delta-encoded serialized lists of FTS3 
117740 ** varints. Each call to this function appends a single varint to a list.
117741 */
117742 static void fts3PutDeltaVarint(
117743   char **pp,                      /* IN/OUT: Output pointer */
117744   sqlcipher3_int64 *piPrev,          /* IN/OUT: Previous value written to list */
117745   sqlcipher3_int64 iVal              /* Write this value to the list */
117746 ){
117747   assert( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) );
117748   *pp += sqlcipher3Fts3PutVarint(*pp, iVal-*piPrev);
117749   *piPrev = iVal;
117750 }
117751
117752 /*
117753 ** When this function is called, *ppPoslist is assumed to point to the 
117754 ** start of a position-list. After it returns, *ppPoslist points to the
117755 ** first byte after the position-list.
117756 **
117757 ** A position list is list of positions (delta encoded) and columns for 
117758 ** a single document record of a doclist.  So, in other words, this
117759 ** routine advances *ppPoslist so that it points to the next docid in
117760 ** the doclist, or to the first byte past the end of the doclist.
117761 **
117762 ** If pp is not NULL, then the contents of the position list are copied
117763 ** to *pp. *pp is set to point to the first byte past the last byte copied
117764 ** before this function returns.
117765 */
117766 static void fts3PoslistCopy(char **pp, char **ppPoslist){
117767   char *pEnd = *ppPoslist;
117768   char c = 0;
117769
117770   /* The end of a position list is marked by a zero encoded as an FTS3 
117771   ** varint. A single POS_END (0) byte. Except, if the 0 byte is preceded by
117772   ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
117773   ** of some other, multi-byte, value.
117774   **
117775   ** The following while-loop moves pEnd to point to the first byte that is not 
117776   ** immediately preceded by a byte with the 0x80 bit set. Then increments
117777   ** pEnd once more so that it points to the byte immediately following the
117778   ** last byte in the position-list.
117779   */
117780   while( *pEnd | c ){
117781     c = *pEnd++ & 0x80;
117782     testcase( c!=0 && (*pEnd)==0 );
117783   }
117784   pEnd++;  /* Advance past the POS_END terminator byte */
117785
117786   if( pp ){
117787     int n = (int)(pEnd - *ppPoslist);
117788     char *p = *pp;
117789     memcpy(p, *ppPoslist, n);
117790     p += n;
117791     *pp = p;
117792   }
117793   *ppPoslist = pEnd;
117794 }
117795
117796 /*
117797 ** When this function is called, *ppPoslist is assumed to point to the 
117798 ** start of a column-list. After it returns, *ppPoslist points to the
117799 ** to the terminator (POS_COLUMN or POS_END) byte of the column-list.
117800 **
117801 ** A column-list is list of delta-encoded positions for a single column
117802 ** within a single document within a doclist.
117803 **
117804 ** The column-list is terminated either by a POS_COLUMN varint (1) or
117805 ** a POS_END varint (0).  This routine leaves *ppPoslist pointing to
117806 ** the POS_COLUMN or POS_END that terminates the column-list.
117807 **
117808 ** If pp is not NULL, then the contents of the column-list are copied
117809 ** to *pp. *pp is set to point to the first byte past the last byte copied
117810 ** before this function returns.  The POS_COLUMN or POS_END terminator
117811 ** is not copied into *pp.
117812 */
117813 static void fts3ColumnlistCopy(char **pp, char **ppPoslist){
117814   char *pEnd = *ppPoslist;
117815   char c = 0;
117816
117817   /* A column-list is terminated by either a 0x01 or 0x00 byte that is
117818   ** not part of a multi-byte varint.
117819   */
117820   while( 0xFE & (*pEnd | c) ){
117821     c = *pEnd++ & 0x80;
117822     testcase( c!=0 && ((*pEnd)&0xfe)==0 );
117823   }
117824   if( pp ){
117825     int n = (int)(pEnd - *ppPoslist);
117826     char *p = *pp;
117827     memcpy(p, *ppPoslist, n);
117828     p += n;
117829     *pp = p;
117830   }
117831   *ppPoslist = pEnd;
117832 }
117833
117834 /*
117835 ** Value used to signify the end of an position-list. This is safe because
117836 ** it is not possible to have a document with 2^31 terms.
117837 */
117838 #define POSITION_LIST_END 0x7fffffff
117839
117840 /*
117841 ** This function is used to help parse position-lists. When this function is
117842 ** called, *pp may point to the start of the next varint in the position-list
117843 ** being parsed, or it may point to 1 byte past the end of the position-list
117844 ** (in which case **pp will be a terminator bytes POS_END (0) or
117845 ** (1)).
117846 **
117847 ** If *pp points past the end of the current position-list, set *pi to 
117848 ** POSITION_LIST_END and return. Otherwise, read the next varint from *pp,
117849 ** increment the current value of *pi by the value read, and set *pp to
117850 ** point to the next value before returning.
117851 **
117852 ** Before calling this routine *pi must be initialized to the value of
117853 ** the previous position, or zero if we are reading the first position
117854 ** in the position-list.  Because positions are delta-encoded, the value
117855 ** of the previous position is needed in order to compute the value of
117856 ** the next position.
117857 */
117858 static void fts3ReadNextPos(
117859   char **pp,                    /* IN/OUT: Pointer into position-list buffer */
117860   sqlcipher3_int64 *pi             /* IN/OUT: Value read from position-list */
117861 ){
117862   if( (**pp)&0xFE ){
117863     fts3GetDeltaVarint(pp, pi);
117864     *pi -= 2;
117865   }else{
117866     *pi = POSITION_LIST_END;
117867   }
117868 }
117869
117870 /*
117871 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
117872 ** the value of iCol encoded as a varint to *pp.   This will start a new
117873 ** column list.
117874 **
117875 ** Set *pp to point to the byte just after the last byte written before 
117876 ** returning (do not modify it if iCol==0). Return the total number of bytes
117877 ** written (0 if iCol==0).
117878 */
117879 static int fts3PutColNumber(char **pp, int iCol){
117880   int n = 0;                      /* Number of bytes written */
117881   if( iCol ){
117882     char *p = *pp;                /* Output pointer */
117883     n = 1 + sqlcipher3Fts3PutVarint(&p[1], iCol);
117884     *p = 0x01;
117885     *pp = &p[n];
117886   }
117887   return n;
117888 }
117889
117890 /*
117891 ** Compute the union of two position lists.  The output written
117892 ** into *pp contains all positions of both *pp1 and *pp2 in sorted
117893 ** order and with any duplicates removed.  All pointers are
117894 ** updated appropriately.   The caller is responsible for insuring
117895 ** that there is enough space in *pp to hold the complete output.
117896 */
117897 static void fts3PoslistMerge(
117898   char **pp,                      /* Output buffer */
117899   char **pp1,                     /* Left input list */
117900   char **pp2                      /* Right input list */
117901 ){
117902   char *p = *pp;
117903   char *p1 = *pp1;
117904   char *p2 = *pp2;
117905
117906   while( *p1 || *p2 ){
117907     int iCol1;         /* The current column index in pp1 */
117908     int iCol2;         /* The current column index in pp2 */
117909
117910     if( *p1==POS_COLUMN ) sqlcipher3Fts3GetVarint32(&p1[1], &iCol1);
117911     else if( *p1==POS_END ) iCol1 = POSITION_LIST_END;
117912     else iCol1 = 0;
117913
117914     if( *p2==POS_COLUMN ) sqlcipher3Fts3GetVarint32(&p2[1], &iCol2);
117915     else if( *p2==POS_END ) iCol2 = POSITION_LIST_END;
117916     else iCol2 = 0;
117917
117918     if( iCol1==iCol2 ){
117919       sqlcipher3_int64 i1 = 0;       /* Last position from pp1 */
117920       sqlcipher3_int64 i2 = 0;       /* Last position from pp2 */
117921       sqlcipher3_int64 iPrev = 0;
117922       int n = fts3PutColNumber(&p, iCol1);
117923       p1 += n;
117924       p2 += n;
117925
117926       /* At this point, both p1 and p2 point to the start of column-lists
117927       ** for the same column (the column with index iCol1 and iCol2).
117928       ** A column-list is a list of non-negative delta-encoded varints, each 
117929       ** incremented by 2 before being stored. Each list is terminated by a
117930       ** POS_END (0) or POS_COLUMN (1). The following block merges the two lists
117931       ** and writes the results to buffer p. p is left pointing to the byte
117932       ** after the list written. No terminator (POS_END or POS_COLUMN) is
117933       ** written to the output.
117934       */
117935       fts3GetDeltaVarint(&p1, &i1);
117936       fts3GetDeltaVarint(&p2, &i2);
117937       do {
117938         fts3PutDeltaVarint(&p, &iPrev, (i1<i2) ? i1 : i2); 
117939         iPrev -= 2;
117940         if( i1==i2 ){
117941           fts3ReadNextPos(&p1, &i1);
117942           fts3ReadNextPos(&p2, &i2);
117943         }else if( i1<i2 ){
117944           fts3ReadNextPos(&p1, &i1);
117945         }else{
117946           fts3ReadNextPos(&p2, &i2);
117947         }
117948       }while( i1!=POSITION_LIST_END || i2!=POSITION_LIST_END );
117949     }else if( iCol1<iCol2 ){
117950       p1 += fts3PutColNumber(&p, iCol1);
117951       fts3ColumnlistCopy(&p, &p1);
117952     }else{
117953       p2 += fts3PutColNumber(&p, iCol2);
117954       fts3ColumnlistCopy(&p, &p2);
117955     }
117956   }
117957
117958   *p++ = POS_END;
117959   *pp = p;
117960   *pp1 = p1 + 1;
117961   *pp2 = p2 + 1;
117962 }
117963
117964 /*
117965 ** This function is used to merge two position lists into one. When it is
117966 ** called, *pp1 and *pp2 must both point to position lists. A position-list is
117967 ** the part of a doclist that follows each document id. For example, if a row
117968 ** contains:
117969 **
117970 **     'a b c'|'x y z'|'a b b a'
117971 **
117972 ** Then the position list for this row for token 'b' would consist of:
117973 **
117974 **     0x02 0x01 0x02 0x03 0x03 0x00
117975 **
117976 ** When this function returns, both *pp1 and *pp2 are left pointing to the
117977 ** byte following the 0x00 terminator of their respective position lists.
117978 **
117979 ** If isSaveLeft is 0, an entry is added to the output position list for 
117980 ** each position in *pp2 for which there exists one or more positions in
117981 ** *pp1 so that (pos(*pp2)>pos(*pp1) && pos(*pp2)-pos(*pp1)<=nToken). i.e.
117982 ** when the *pp1 token appears before the *pp2 token, but not more than nToken
117983 ** slots before it.
117984 **
117985 ** e.g. nToken==1 searches for adjacent positions.
117986 */
117987 static int fts3PoslistPhraseMerge(
117988   char **pp,                      /* IN/OUT: Preallocated output buffer */
117989   int nToken,                     /* Maximum difference in token positions */
117990   int isSaveLeft,                 /* Save the left position */
117991   int isExact,                    /* If *pp1 is exactly nTokens before *pp2 */
117992   char **pp1,                     /* IN/OUT: Left input list */
117993   char **pp2                      /* IN/OUT: Right input list */
117994 ){
117995   char *p = *pp;
117996   char *p1 = *pp1;
117997   char *p2 = *pp2;
117998   int iCol1 = 0;
117999   int iCol2 = 0;
118000
118001   /* Never set both isSaveLeft and isExact for the same invocation. */
118002   assert( isSaveLeft==0 || isExact==0 );
118003
118004   assert( p!=0 && *p1!=0 && *p2!=0 );
118005   if( *p1==POS_COLUMN ){ 
118006     p1++;
118007     p1 += sqlcipher3Fts3GetVarint32(p1, &iCol1);
118008   }
118009   if( *p2==POS_COLUMN ){ 
118010     p2++;
118011     p2 += sqlcipher3Fts3GetVarint32(p2, &iCol2);
118012   }
118013
118014   while( 1 ){
118015     if( iCol1==iCol2 ){
118016       char *pSave = p;
118017       sqlcipher3_int64 iPrev = 0;
118018       sqlcipher3_int64 iPos1 = 0;
118019       sqlcipher3_int64 iPos2 = 0;
118020
118021       if( iCol1 ){
118022         *p++ = POS_COLUMN;
118023         p += sqlcipher3Fts3PutVarint(p, iCol1);
118024       }
118025
118026       assert( *p1!=POS_END && *p1!=POS_COLUMN );
118027       assert( *p2!=POS_END && *p2!=POS_COLUMN );
118028       fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2;
118029       fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118030
118031       while( 1 ){
118032         if( iPos2==iPos1+nToken 
118033          || (isExact==0 && iPos2>iPos1 && iPos2<=iPos1+nToken) 
118034         ){
118035           sqlcipher3_int64 iSave;
118036           iSave = isSaveLeft ? iPos1 : iPos2;
118037           fts3PutDeltaVarint(&p, &iPrev, iSave+2); iPrev -= 2;
118038           pSave = 0;
118039           assert( p );
118040         }
118041         if( (!isSaveLeft && iPos2<=(iPos1+nToken)) || iPos2<=iPos1 ){
118042           if( (*p2&0xFE)==0 ) break;
118043           fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118044         }else{
118045           if( (*p1&0xFE)==0 ) break;
118046           fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2;
118047         }
118048       }
118049
118050       if( pSave ){
118051         assert( pp && p );
118052         p = pSave;
118053       }
118054
118055       fts3ColumnlistCopy(0, &p1);
118056       fts3ColumnlistCopy(0, &p2);
118057       assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
118058       if( 0==*p1 || 0==*p2 ) break;
118059
118060       p1++;
118061       p1 += sqlcipher3Fts3GetVarint32(p1, &iCol1);
118062       p2++;
118063       p2 += sqlcipher3Fts3GetVarint32(p2, &iCol2);
118064     }
118065
118066     /* Advance pointer p1 or p2 (whichever corresponds to the smaller of
118067     ** iCol1 and iCol2) so that it points to either the 0x00 that marks the
118068     ** end of the position list, or the 0x01 that precedes the next 
118069     ** column-number in the position list. 
118070     */
118071     else if( iCol1<iCol2 ){
118072       fts3ColumnlistCopy(0, &p1);
118073       if( 0==*p1 ) break;
118074       p1++;
118075       p1 += sqlcipher3Fts3GetVarint32(p1, &iCol1);
118076     }else{
118077       fts3ColumnlistCopy(0, &p2);
118078       if( 0==*p2 ) break;
118079       p2++;
118080       p2 += sqlcipher3Fts3GetVarint32(p2, &iCol2);
118081     }
118082   }
118083
118084   fts3PoslistCopy(0, &p2);
118085   fts3PoslistCopy(0, &p1);
118086   *pp1 = p1;
118087   *pp2 = p2;
118088   if( *pp==p ){
118089     return 0;
118090   }
118091   *p++ = 0x00;
118092   *pp = p;
118093   return 1;
118094 }
118095
118096 /*
118097 ** Merge two position-lists as required by the NEAR operator. The argument
118098 ** position lists correspond to the left and right phrases of an expression 
118099 ** like:
118100 **
118101 **     "phrase 1" NEAR "phrase number 2"
118102 **
118103 ** Position list *pp1 corresponds to the left-hand side of the NEAR 
118104 ** expression and *pp2 to the right. As usual, the indexes in the position 
118105 ** lists are the offsets of the last token in each phrase (tokens "1" and "2" 
118106 ** in the example above).
118107 **
118108 ** The output position list - written to *pp - is a copy of *pp2 with those
118109 ** entries that are not sufficiently NEAR entries in *pp1 removed.
118110 */
118111 static int fts3PoslistNearMerge(
118112   char **pp,                      /* Output buffer */
118113   char *aTmp,                     /* Temporary buffer space */
118114   int nRight,                     /* Maximum difference in token positions */
118115   int nLeft,                      /* Maximum difference in token positions */
118116   char **pp1,                     /* IN/OUT: Left input list */
118117   char **pp2                      /* IN/OUT: Right input list */
118118 ){
118119   char *p1 = *pp1;
118120   char *p2 = *pp2;
118121
118122   char *pTmp1 = aTmp;
118123   char *pTmp2;
118124   char *aTmp2;
118125   int res = 1;
118126
118127   fts3PoslistPhraseMerge(&pTmp1, nRight, 0, 0, pp1, pp2);
118128   aTmp2 = pTmp2 = pTmp1;
118129   *pp1 = p1;
118130   *pp2 = p2;
118131   fts3PoslistPhraseMerge(&pTmp2, nLeft, 1, 0, pp2, pp1);
118132   if( pTmp1!=aTmp && pTmp2!=aTmp2 ){
118133     fts3PoslistMerge(pp, &aTmp, &aTmp2);
118134   }else if( pTmp1!=aTmp ){
118135     fts3PoslistCopy(pp, &aTmp);
118136   }else if( pTmp2!=aTmp2 ){
118137     fts3PoslistCopy(pp, &aTmp2);
118138   }else{
118139     res = 0;
118140   }
118141
118142   return res;
118143 }
118144
118145 /* 
118146 ** An instance of this function is used to merge together the (potentially
118147 ** large number of) doclists for each term that matches a prefix query.
118148 ** See function fts3TermSelectMerge() for details.
118149 */
118150 typedef struct TermSelect TermSelect;
118151 struct TermSelect {
118152   char *aaOutput[16];             /* Malloc'd output buffers */
118153   int anOutput[16];               /* Size each output buffer in bytes */
118154 };
118155
118156 /*
118157 ** This function is used to read a single varint from a buffer. Parameter
118158 ** pEnd points 1 byte past the end of the buffer. When this function is
118159 ** called, if *pp points to pEnd or greater, then the end of the buffer
118160 ** has been reached. In this case *pp is set to 0 and the function returns.
118161 **
118162 ** If *pp does not point to or past pEnd, then a single varint is read
118163 ** from *pp. *pp is then set to point 1 byte past the end of the read varint.
118164 **
118165 ** If bDescIdx is false, the value read is added to *pVal before returning.
118166 ** If it is true, the value read is subtracted from *pVal before this 
118167 ** function returns.
118168 */
118169 static void fts3GetDeltaVarint3(
118170   char **pp,                      /* IN/OUT: Point to read varint from */
118171   char *pEnd,                     /* End of buffer */
118172   int bDescIdx,                   /* True if docids are descending */
118173   sqlcipher3_int64 *pVal             /* IN/OUT: Integer value */
118174 ){
118175   if( *pp>=pEnd ){
118176     *pp = 0;
118177   }else{
118178     sqlcipher3_int64 iVal;
118179     *pp += sqlcipher3Fts3GetVarint(*pp, &iVal);
118180     if( bDescIdx ){
118181       *pVal -= iVal;
118182     }else{
118183       *pVal += iVal;
118184     }
118185   }
118186 }
118187
118188 /*
118189 ** This function is used to write a single varint to a buffer. The varint
118190 ** is written to *pp. Before returning, *pp is set to point 1 byte past the
118191 ** end of the value written.
118192 **
118193 ** If *pbFirst is zero when this function is called, the value written to
118194 ** the buffer is that of parameter iVal. 
118195 **
118196 ** If *pbFirst is non-zero when this function is called, then the value 
118197 ** written is either (iVal-*piPrev) (if bDescIdx is zero) or (*piPrev-iVal)
118198 ** (if bDescIdx is non-zero).
118199 **
118200 ** Before returning, this function always sets *pbFirst to 1 and *piPrev
118201 ** to the value of parameter iVal.
118202 */
118203 static void fts3PutDeltaVarint3(
118204   char **pp,                      /* IN/OUT: Output pointer */
118205   int bDescIdx,                   /* True for descending docids */
118206   sqlcipher3_int64 *piPrev,          /* IN/OUT: Previous value written to list */
118207   int *pbFirst,                   /* IN/OUT: True after first int written */
118208   sqlcipher3_int64 iVal              /* Write this value to the list */
118209 ){
118210   sqlcipher3_int64 iWrite;
118211   if( bDescIdx==0 || *pbFirst==0 ){
118212     iWrite = iVal - *piPrev;
118213   }else{
118214     iWrite = *piPrev - iVal;
118215   }
118216   assert( *pbFirst || *piPrev==0 );
118217   assert( *pbFirst==0 || iWrite>0 );
118218   *pp += sqlcipher3Fts3PutVarint(*pp, iWrite);
118219   *piPrev = iVal;
118220   *pbFirst = 1;
118221 }
118222
118223
118224 /*
118225 ** This macro is used by various functions that merge doclists. The two
118226 ** arguments are 64-bit docid values. If the value of the stack variable
118227 ** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2). 
118228 ** Otherwise, (i2-i1).
118229 **
118230 ** Using this makes it easier to write code that can merge doclists that are
118231 ** sorted in either ascending or descending order.
118232 */
118233 #define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i1-i2))
118234
118235 /*
118236 ** This function does an "OR" merge of two doclists (output contains all
118237 ** positions contained in either argument doclist). If the docids in the 
118238 ** input doclists are sorted in ascending order, parameter bDescDoclist
118239 ** should be false. If they are sorted in ascending order, it should be
118240 ** passed a non-zero value.
118241 **
118242 ** If no error occurs, *paOut is set to point at an sqlcipher3_malloc'd buffer
118243 ** containing the output doclist and SQLCIPHER_OK is returned. In this case
118244 ** *pnOut is set to the number of bytes in the output doclist.
118245 **
118246 ** If an error occurs, an SQLite error code is returned. The output values
118247 ** are undefined in this case.
118248 */
118249 static int fts3DoclistOrMerge(
118250   int bDescDoclist,               /* True if arguments are desc */
118251   char *a1, int n1,               /* First doclist */
118252   char *a2, int n2,               /* Second doclist */
118253   char **paOut, int *pnOut        /* OUT: Malloc'd doclist */
118254 ){
118255   sqlcipher3_int64 i1 = 0;
118256   sqlcipher3_int64 i2 = 0;
118257   sqlcipher3_int64 iPrev = 0;
118258   char *pEnd1 = &a1[n1];
118259   char *pEnd2 = &a2[n2];
118260   char *p1 = a1;
118261   char *p2 = a2;
118262   char *p;
118263   char *aOut;
118264   int bFirstOut = 0;
118265
118266   *paOut = 0;
118267   *pnOut = 0;
118268
118269   /* Allocate space for the output. Both the input and output doclists
118270   ** are delta encoded. If they are in ascending order (bDescDoclist==0),
118271   ** then the first docid in each list is simply encoded as a varint. For
118272   ** each subsequent docid, the varint stored is the difference between the
118273   ** current and previous docid (a positive number - since the list is in
118274   ** ascending order).
118275   **
118276   ** The first docid written to the output is therefore encoded using the 
118277   ** same number of bytes as it is in whichever of the input lists it is
118278   ** read from. And each subsequent docid read from the same input list 
118279   ** consumes either the same or less bytes as it did in the input (since
118280   ** the difference between it and the previous value in the output must
118281   ** be a positive value less than or equal to the delta value read from 
118282   ** the input list). The same argument applies to all but the first docid
118283   ** read from the 'other' list. And to the contents of all position lists
118284   ** that will be copied and merged from the input to the output.
118285   **
118286   ** However, if the first docid copied to the output is a negative number,
118287   ** then the encoding of the first docid from the 'other' input list may
118288   ** be larger in the output than it was in the input (since the delta value
118289   ** may be a larger positive integer than the actual docid).
118290   **
118291   ** The space required to store the output is therefore the sum of the
118292   ** sizes of the two inputs, plus enough space for exactly one of the input
118293   ** docids to grow. 
118294   **
118295   ** A symetric argument may be made if the doclists are in descending 
118296   ** order.
118297   */
118298   aOut = sqlcipher3_malloc(n1+n2+FTS3_VARINT_MAX-1);
118299   if( !aOut ) return SQLCIPHER_NOMEM;
118300
118301   p = aOut;
118302   fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1);
118303   fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
118304   while( p1 || p2 ){
118305     sqlcipher3_int64 iDiff = DOCID_CMP(i1, i2);
118306
118307     if( p2 && p1 && iDiff==0 ){
118308       fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
118309       fts3PoslistMerge(&p, &p1, &p2);
118310       fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118311       fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118312     }else if( !p2 || (p1 && iDiff<0) ){
118313       fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
118314       fts3PoslistCopy(&p, &p1);
118315       fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118316     }else{
118317       fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i2);
118318       fts3PoslistCopy(&p, &p2);
118319       fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118320     }
118321   }
118322
118323   *paOut = aOut;
118324   *pnOut = (p-aOut);
118325   assert( *pnOut<=n1+n2+FTS3_VARINT_MAX-1 );
118326   return SQLCIPHER_OK;
118327 }
118328
118329 /*
118330 ** This function does a "phrase" merge of two doclists. In a phrase merge,
118331 ** the output contains a copy of each position from the right-hand input
118332 ** doclist for which there is a position in the left-hand input doclist
118333 ** exactly nDist tokens before it.
118334 **
118335 ** If the docids in the input doclists are sorted in ascending order,
118336 ** parameter bDescDoclist should be false. If they are sorted in ascending 
118337 ** order, it should be passed a non-zero value.
118338 **
118339 ** The right-hand input doclist is overwritten by this function.
118340 */
118341 static void fts3DoclistPhraseMerge(
118342   int bDescDoclist,               /* True if arguments are desc */
118343   int nDist,                      /* Distance from left to right (1=adjacent) */
118344   char *aLeft, int nLeft,         /* Left doclist */
118345   char *aRight, int *pnRight      /* IN/OUT: Right/output doclist */
118346 ){
118347   sqlcipher3_int64 i1 = 0;
118348   sqlcipher3_int64 i2 = 0;
118349   sqlcipher3_int64 iPrev = 0;
118350   char *pEnd1 = &aLeft[nLeft];
118351   char *pEnd2 = &aRight[*pnRight];
118352   char *p1 = aLeft;
118353   char *p2 = aRight;
118354   char *p;
118355   int bFirstOut = 0;
118356   char *aOut = aRight;
118357
118358   assert( nDist>0 );
118359
118360   p = aOut;
118361   fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1);
118362   fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
118363
118364   while( p1 && p2 ){
118365     sqlcipher3_int64 iDiff = DOCID_CMP(i1, i2);
118366     if( iDiff==0 ){
118367       char *pSave = p;
118368       sqlcipher3_int64 iPrevSave = iPrev;
118369       int bFirstOutSave = bFirstOut;
118370
118371       fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
118372       if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){
118373         p = pSave;
118374         iPrev = iPrevSave;
118375         bFirstOut = bFirstOutSave;
118376       }
118377       fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118378       fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118379     }else if( iDiff<0 ){
118380       fts3PoslistCopy(0, &p1);
118381       fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118382     }else{
118383       fts3PoslistCopy(0, &p2);
118384       fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118385     }
118386   }
118387
118388   *pnRight = p - aOut;
118389 }
118390
118391 /*
118392 ** Argument pList points to a position list nList bytes in size. This
118393 ** function checks to see if the position list contains any entries for
118394 ** a token in position 0 (of any column). If so, it writes argument iDelta
118395 ** to the output buffer pOut, followed by a position list consisting only
118396 ** of the entries from pList at position 0, and terminated by an 0x00 byte.
118397 ** The value returned is the number of bytes written to pOut (if any).
118398 */
118399 SQLCIPHER_PRIVATE int sqlcipher3Fts3FirstFilter(
118400   sqlcipher3_int64 iDelta,           /* Varint that may be written to pOut */
118401   char *pList,                    /* Position list (no 0x00 term) */
118402   int nList,                      /* Size of pList in bytes */
118403   char *pOut                      /* Write output here */
118404 ){
118405   int nOut = 0;
118406   int bWritten = 0;               /* True once iDelta has been written */
118407   char *p = pList;
118408   char *pEnd = &pList[nList];
118409
118410   if( *p!=0x01 ){
118411     if( *p==0x02 ){
118412       nOut += sqlcipher3Fts3PutVarint(&pOut[nOut], iDelta);
118413       pOut[nOut++] = 0x02;
118414       bWritten = 1;
118415     }
118416     fts3ColumnlistCopy(0, &p);
118417   }
118418
118419   while( p<pEnd && *p==0x01 ){
118420     sqlcipher3_int64 iCol;
118421     p++;
118422     p += sqlcipher3Fts3GetVarint(p, &iCol);
118423     if( *p==0x02 ){
118424       if( bWritten==0 ){
118425         nOut += sqlcipher3Fts3PutVarint(&pOut[nOut], iDelta);
118426         bWritten = 1;
118427       }
118428       pOut[nOut++] = 0x01;
118429       nOut += sqlcipher3Fts3PutVarint(&pOut[nOut], iCol);
118430       pOut[nOut++] = 0x02;
118431     }
118432     fts3ColumnlistCopy(0, &p);
118433   }
118434   if( bWritten ){
118435     pOut[nOut++] = 0x00;
118436   }
118437
118438   return nOut;
118439 }
118440
118441
118442 /*
118443 ** Merge all doclists in the TermSelect.aaOutput[] array into a single
118444 ** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
118445 ** other doclists (except the aaOutput[0] one) and return SQLCIPHER_OK.
118446 **
118447 ** If an OOM error occurs, return SQLCIPHER_NOMEM. In this case it is
118448 ** the responsibility of the caller to free any doclists left in the
118449 ** TermSelect.aaOutput[] array.
118450 */
118451 static int fts3TermSelectFinishMerge(Fts3Table *p, TermSelect *pTS){
118452   char *aOut = 0;
118453   int nOut = 0;
118454   int i;
118455
118456   /* Loop through the doclists in the aaOutput[] array. Merge them all
118457   ** into a single doclist.
118458   */
118459   for(i=0; i<SizeofArray(pTS->aaOutput); i++){
118460     if( pTS->aaOutput[i] ){
118461       if( !aOut ){
118462         aOut = pTS->aaOutput[i];
118463         nOut = pTS->anOutput[i];
118464         pTS->aaOutput[i] = 0;
118465       }else{
118466         int nNew;
118467         char *aNew;
118468
118469         int rc = fts3DoclistOrMerge(p->bDescIdx, 
118470             pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
118471         );
118472         if( rc!=SQLCIPHER_OK ){
118473           sqlcipher3_free(aOut);
118474           return rc;
118475         }
118476
118477         sqlcipher3_free(pTS->aaOutput[i]);
118478         sqlcipher3_free(aOut);
118479         pTS->aaOutput[i] = 0;
118480         aOut = aNew;
118481         nOut = nNew;
118482       }
118483     }
118484   }
118485
118486   pTS->aaOutput[0] = aOut;
118487   pTS->anOutput[0] = nOut;
118488   return SQLCIPHER_OK;
118489 }
118490
118491 /*
118492 ** Merge the doclist aDoclist/nDoclist into the TermSelect object passed
118493 ** as the first argument. The merge is an "OR" merge (see function
118494 ** fts3DoclistOrMerge() for details).
118495 **
118496 ** This function is called with the doclist for each term that matches
118497 ** a queried prefix. It merges all these doclists into one, the doclist
118498 ** for the specified prefix. Since there can be a very large number of
118499 ** doclists to merge, the merging is done pair-wise using the TermSelect
118500 ** object.
118501 **
118502 ** This function returns SQLCIPHER_OK if the merge is successful, or an
118503 ** SQLite error code (SQLCIPHER_NOMEM) if an error occurs.
118504 */
118505 static int fts3TermSelectMerge(
118506   Fts3Table *p,                   /* FTS table handle */
118507   TermSelect *pTS,                /* TermSelect object to merge into */
118508   char *aDoclist,                 /* Pointer to doclist */
118509   int nDoclist                    /* Size of aDoclist in bytes */
118510 ){
118511   if( pTS->aaOutput[0]==0 ){
118512     /* If this is the first term selected, copy the doclist to the output
118513     ** buffer using memcpy(). */
118514     pTS->aaOutput[0] = sqlcipher3_malloc(nDoclist);
118515     pTS->anOutput[0] = nDoclist;
118516     if( pTS->aaOutput[0] ){
118517       memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
118518     }else{
118519       return SQLCIPHER_NOMEM;
118520     }
118521   }else{
118522     char *aMerge = aDoclist;
118523     int nMerge = nDoclist;
118524     int iOut;
118525
118526     for(iOut=0; iOut<SizeofArray(pTS->aaOutput); iOut++){
118527       if( pTS->aaOutput[iOut]==0 ){
118528         assert( iOut>0 );
118529         pTS->aaOutput[iOut] = aMerge;
118530         pTS->anOutput[iOut] = nMerge;
118531         break;
118532       }else{
118533         char *aNew;
118534         int nNew;
118535
118536         int rc = fts3DoclistOrMerge(p->bDescIdx, aMerge, nMerge, 
118537             pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
118538         );
118539         if( rc!=SQLCIPHER_OK ){
118540           if( aMerge!=aDoclist ) sqlcipher3_free(aMerge);
118541           return rc;
118542         }
118543
118544         if( aMerge!=aDoclist ) sqlcipher3_free(aMerge);
118545         sqlcipher3_free(pTS->aaOutput[iOut]);
118546         pTS->aaOutput[iOut] = 0;
118547   
118548         aMerge = aNew;
118549         nMerge = nNew;
118550         if( (iOut+1)==SizeofArray(pTS->aaOutput) ){
118551           pTS->aaOutput[iOut] = aMerge;
118552           pTS->anOutput[iOut] = nMerge;
118553         }
118554       }
118555     }
118556   }
118557   return SQLCIPHER_OK;
118558 }
118559
118560 /*
118561 ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
118562 */
118563 static int fts3SegReaderCursorAppend(
118564   Fts3MultiSegReader *pCsr, 
118565   Fts3SegReader *pNew
118566 ){
118567   if( (pCsr->nSegment%16)==0 ){
118568     Fts3SegReader **apNew;
118569     int nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
118570     apNew = (Fts3SegReader **)sqlcipher3_realloc(pCsr->apSegment, nByte);
118571     if( !apNew ){
118572       sqlcipher3Fts3SegReaderFree(pNew);
118573       return SQLCIPHER_NOMEM;
118574     }
118575     pCsr->apSegment = apNew;
118576   }
118577   pCsr->apSegment[pCsr->nSegment++] = pNew;
118578   return SQLCIPHER_OK;
118579 }
118580
118581 /*
118582 ** Add seg-reader objects to the Fts3MultiSegReader object passed as the
118583 ** 8th argument.
118584 **
118585 ** This function returns SQLCIPHER_OK if successful, or an SQLite error code
118586 ** otherwise.
118587 */
118588 static int fts3SegReaderCursor(
118589   Fts3Table *p,                   /* FTS3 table handle */
118590   int iIndex,                     /* Index to search (from 0 to p->nIndex-1) */
118591   int iLevel,                     /* Level of segments to scan */
118592   const char *zTerm,              /* Term to query for */
118593   int nTerm,                      /* Size of zTerm in bytes */
118594   int isPrefix,                   /* True for a prefix search */
118595   int isScan,                     /* True to scan from zTerm to EOF */
118596   Fts3MultiSegReader *pCsr        /* Cursor object to populate */
118597 ){
118598   int rc = SQLCIPHER_OK;             /* Error code */
118599   sqlcipher3_stmt *pStmt = 0;        /* Statement to iterate through segments */
118600   int rc2;                        /* Result of sqlcipher3_reset() */
118601
118602   /* If iLevel is less than 0 and this is not a scan, include a seg-reader 
118603   ** for the pending-terms. If this is a scan, then this call must be being
118604   ** made by an fts4aux module, not an FTS table. In this case calling
118605   ** Fts3SegReaderPending might segfault, as the data structures used by 
118606   ** fts4aux are not completely populated. So it's easiest to filter these
118607   ** calls out here.  */
118608   if( iLevel<0 && p->aIndex ){
118609     Fts3SegReader *pSeg = 0;
118610     rc = sqlcipher3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix, &pSeg);
118611     if( rc==SQLCIPHER_OK && pSeg ){
118612       rc = fts3SegReaderCursorAppend(pCsr, pSeg);
118613     }
118614   }
118615
118616   if( iLevel!=FTS3_SEGCURSOR_PENDING ){
118617     if( rc==SQLCIPHER_OK ){
118618       rc = sqlcipher3Fts3AllSegdirs(p, iIndex, iLevel, &pStmt);
118619     }
118620
118621     while( rc==SQLCIPHER_OK && SQLCIPHER_ROW==(rc = sqlcipher3_step(pStmt)) ){
118622       Fts3SegReader *pSeg = 0;
118623
118624       /* Read the values returned by the SELECT into local variables. */
118625       sqlcipher3_int64 iStartBlock = sqlcipher3_column_int64(pStmt, 1);
118626       sqlcipher3_int64 iLeavesEndBlock = sqlcipher3_column_int64(pStmt, 2);
118627       sqlcipher3_int64 iEndBlock = sqlcipher3_column_int64(pStmt, 3);
118628       int nRoot = sqlcipher3_column_bytes(pStmt, 4);
118629       char const *zRoot = sqlcipher3_column_blob(pStmt, 4);
118630
118631       /* If zTerm is not NULL, and this segment is not stored entirely on its
118632       ** root node, the range of leaves scanned can be reduced. Do this. */
118633       if( iStartBlock && zTerm ){
118634         sqlcipher3_int64 *pi = (isPrefix ? &iLeavesEndBlock : 0);
118635         rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi);
118636         if( rc!=SQLCIPHER_OK ) goto finished;
118637         if( isPrefix==0 && isScan==0 ) iLeavesEndBlock = iStartBlock;
118638       }
118639  
118640       rc = sqlcipher3Fts3SegReaderNew(pCsr->nSegment+1, 
118641           iStartBlock, iLeavesEndBlock, iEndBlock, zRoot, nRoot, &pSeg
118642       );
118643       if( rc!=SQLCIPHER_OK ) goto finished;
118644       rc = fts3SegReaderCursorAppend(pCsr, pSeg);
118645     }
118646   }
118647
118648  finished:
118649   rc2 = sqlcipher3_reset(pStmt);
118650   if( rc==SQLCIPHER_DONE ) rc = rc2;
118651
118652   return rc;
118653 }
118654
118655 /*
118656 ** Set up a cursor object for iterating through a full-text index or a 
118657 ** single level therein.
118658 */
118659 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderCursor(
118660   Fts3Table *p,                   /* FTS3 table handle */
118661   int iIndex,                     /* Index to search (from 0 to p->nIndex-1) */
118662   int iLevel,                     /* Level of segments to scan */
118663   const char *zTerm,              /* Term to query for */
118664   int nTerm,                      /* Size of zTerm in bytes */
118665   int isPrefix,                   /* True for a prefix search */
118666   int isScan,                     /* True to scan from zTerm to EOF */
118667   Fts3MultiSegReader *pCsr       /* Cursor object to populate */
118668 ){
118669   assert( iIndex>=0 && iIndex<p->nIndex );
118670   assert( iLevel==FTS3_SEGCURSOR_ALL
118671       ||  iLevel==FTS3_SEGCURSOR_PENDING 
118672       ||  iLevel>=0
118673   );
118674   assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
118675   assert( FTS3_SEGCURSOR_ALL<0 && FTS3_SEGCURSOR_PENDING<0 );
118676   assert( isPrefix==0 || isScan==0 );
118677
118678   /* "isScan" is only set to true by the ft4aux module, an ordinary
118679   ** full-text tables. */
118680   assert( isScan==0 || p->aIndex==0 );
118681
118682   memset(pCsr, 0, sizeof(Fts3MultiSegReader));
118683
118684   return fts3SegReaderCursor(
118685       p, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
118686   );
118687 }
118688
118689 /*
118690 ** In addition to its current configuration, have the Fts3MultiSegReader
118691 ** passed as the 4th argument also scan the doclist for term zTerm/nTerm.
118692 **
118693 ** SQLCIPHER_OK is returned if no error occurs, otherwise an SQLite error code.
118694 */
118695 static int fts3SegReaderCursorAddZero(
118696   Fts3Table *p,                   /* FTS virtual table handle */
118697   const char *zTerm,              /* Term to scan doclist of */
118698   int nTerm,                      /* Number of bytes in zTerm */
118699   Fts3MultiSegReader *pCsr        /* Fts3MultiSegReader to modify */
118700 ){
118701   return fts3SegReaderCursor(p, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr);
118702 }
118703
118704 /*
118705 ** Open an Fts3MultiSegReader to scan the doclist for term zTerm/nTerm. Or,
118706 ** if isPrefix is true, to scan the doclist for all terms for which 
118707 ** zTerm/nTerm is a prefix. If successful, return SQLCIPHER_OK and write
118708 ** a pointer to the new Fts3MultiSegReader to *ppSegcsr. Otherwise, return
118709 ** an SQLite error code.
118710 **
118711 ** It is the responsibility of the caller to free this object by eventually
118712 ** passing it to fts3SegReaderCursorFree() 
118713 **
118714 ** SQLCIPHER_OK is returned if no error occurs, otherwise an SQLite error code.
118715 ** Output parameter *ppSegcsr is set to 0 if an error occurs.
118716 */
118717 static int fts3TermSegReaderCursor(
118718   Fts3Cursor *pCsr,               /* Virtual table cursor handle */
118719   const char *zTerm,              /* Term to query for */
118720   int nTerm,                      /* Size of zTerm in bytes */
118721   int isPrefix,                   /* True for a prefix search */
118722   Fts3MultiSegReader **ppSegcsr   /* OUT: Allocated seg-reader cursor */
118723 ){
118724   Fts3MultiSegReader *pSegcsr;    /* Object to allocate and return */
118725   int rc = SQLCIPHER_NOMEM;          /* Return code */
118726
118727   pSegcsr = sqlcipher3_malloc(sizeof(Fts3MultiSegReader));
118728   if( pSegcsr ){
118729     int i;
118730     int bFound = 0;               /* True once an index has been found */
118731     Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
118732
118733     if( isPrefix ){
118734       for(i=1; bFound==0 && i<p->nIndex; i++){
118735         if( p->aIndex[i].nPrefix==nTerm ){
118736           bFound = 1;
118737           rc = sqlcipher3Fts3SegReaderCursor(
118738               p, i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0, pSegcsr);
118739           pSegcsr->bLookup = 1;
118740         }
118741       }
118742
118743       for(i=1; bFound==0 && i<p->nIndex; i++){
118744         if( p->aIndex[i].nPrefix==nTerm+1 ){
118745           bFound = 1;
118746           rc = sqlcipher3Fts3SegReaderCursor(
118747               p, i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 1, 0, pSegcsr
118748           );
118749           if( rc==SQLCIPHER_OK ){
118750             rc = fts3SegReaderCursorAddZero(p, zTerm, nTerm, pSegcsr);
118751           }
118752         }
118753       }
118754     }
118755
118756     if( bFound==0 ){
118757       rc = sqlcipher3Fts3SegReaderCursor(
118758           p, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, isPrefix, 0, pSegcsr
118759       );
118760       pSegcsr->bLookup = !isPrefix;
118761     }
118762   }
118763
118764   *ppSegcsr = pSegcsr;
118765   return rc;
118766 }
118767
118768 /*
118769 ** Free an Fts3MultiSegReader allocated by fts3TermSegReaderCursor().
118770 */
118771 static void fts3SegReaderCursorFree(Fts3MultiSegReader *pSegcsr){
118772   sqlcipher3Fts3SegReaderFinish(pSegcsr);
118773   sqlcipher3_free(pSegcsr);
118774 }
118775
118776 /*
118777 ** This function retreives the doclist for the specified term (or term
118778 ** prefix) from the database.
118779 */
118780 static int fts3TermSelect(
118781   Fts3Table *p,                   /* Virtual table handle */
118782   Fts3PhraseToken *pTok,          /* Token to query for */
118783   int iColumn,                    /* Column to query (or -ve for all columns) */
118784   int *pnOut,                     /* OUT: Size of buffer at *ppOut */
118785   char **ppOut                    /* OUT: Malloced result buffer */
118786 ){
118787   int rc;                         /* Return code */
118788   Fts3MultiSegReader *pSegcsr;    /* Seg-reader cursor for this term */
118789   TermSelect tsc;                 /* Object for pair-wise doclist merging */
118790   Fts3SegFilter filter;           /* Segment term filter configuration */
118791
118792   pSegcsr = pTok->pSegcsr;
118793   memset(&tsc, 0, sizeof(TermSelect));
118794
118795   filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS
118796         | (pTok->isPrefix ? FTS3_SEGMENT_PREFIX : 0)
118797         | (pTok->bFirst ? FTS3_SEGMENT_FIRST : 0)
118798         | (iColumn<p->nColumn ? FTS3_SEGMENT_COLUMN_FILTER : 0);
118799   filter.iCol = iColumn;
118800   filter.zTerm = pTok->z;
118801   filter.nTerm = pTok->n;
118802
118803   rc = sqlcipher3Fts3SegReaderStart(p, pSegcsr, &filter);
118804   while( SQLCIPHER_OK==rc
118805       && SQLCIPHER_ROW==(rc = sqlcipher3Fts3SegReaderStep(p, pSegcsr)) 
118806   ){
118807     rc = fts3TermSelectMerge(p, &tsc, pSegcsr->aDoclist, pSegcsr->nDoclist);
118808   }
118809
118810   if( rc==SQLCIPHER_OK ){
118811     rc = fts3TermSelectFinishMerge(p, &tsc);
118812   }
118813   if( rc==SQLCIPHER_OK ){
118814     *ppOut = tsc.aaOutput[0];
118815     *pnOut = tsc.anOutput[0];
118816   }else{
118817     int i;
118818     for(i=0; i<SizeofArray(tsc.aaOutput); i++){
118819       sqlcipher3_free(tsc.aaOutput[i]);
118820     }
118821   }
118822
118823   fts3SegReaderCursorFree(pSegcsr);
118824   pTok->pSegcsr = 0;
118825   return rc;
118826 }
118827
118828 /*
118829 ** This function counts the total number of docids in the doclist stored
118830 ** in buffer aList[], size nList bytes.
118831 **
118832 ** If the isPoslist argument is true, then it is assumed that the doclist
118833 ** contains a position-list following each docid. Otherwise, it is assumed
118834 ** that the doclist is simply a list of docids stored as delta encoded 
118835 ** varints.
118836 */
118837 static int fts3DoclistCountDocids(char *aList, int nList){
118838   int nDoc = 0;                   /* Return value */
118839   if( aList ){
118840     char *aEnd = &aList[nList];   /* Pointer to one byte after EOF */
118841     char *p = aList;              /* Cursor */
118842     while( p<aEnd ){
118843       nDoc++;
118844       while( (*p++)&0x80 );     /* Skip docid varint */
118845       fts3PoslistCopy(0, &p);   /* Skip over position list */
118846     }
118847   }
118848
118849   return nDoc;
118850 }
118851
118852 /*
118853 ** Advance the cursor to the next row in the %_content table that
118854 ** matches the search criteria.  For a MATCH search, this will be
118855 ** the next row that matches. For a full-table scan, this will be
118856 ** simply the next row in the %_content table.  For a docid lookup,
118857 ** this routine simply sets the EOF flag.
118858 **
118859 ** Return SQLCIPHER_OK if nothing goes wrong.  SQLCIPHER_OK is returned
118860 ** even if we reach end-of-file.  The fts3EofMethod() will be called
118861 ** subsequently to determine whether or not an EOF was hit.
118862 */
118863 static int fts3NextMethod(sqlcipher3_vtab_cursor *pCursor){
118864   int rc;
118865   Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
118866   if( pCsr->eSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){
118867     if( SQLCIPHER_ROW!=sqlcipher3_step(pCsr->pStmt) ){
118868       pCsr->isEof = 1;
118869       rc = sqlcipher3_reset(pCsr->pStmt);
118870     }else{
118871       pCsr->iPrevId = sqlcipher3_column_int64(pCsr->pStmt, 0);
118872       rc = SQLCIPHER_OK;
118873     }
118874   }else{
118875     rc = fts3EvalNext((Fts3Cursor *)pCursor);
118876   }
118877   assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
118878   return rc;
118879 }
118880
118881 /*
118882 ** This is the xFilter interface for the virtual table.  See
118883 ** the virtual table xFilter method documentation for additional
118884 ** information.
118885 **
118886 ** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against
118887 ** the %_content table.
118888 **
118889 ** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry
118890 ** in the %_content table.
118891 **
118892 ** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index.  The
118893 ** column on the left-hand side of the MATCH operator is column
118894 ** number idxNum-FTS3_FULLTEXT_SEARCH, 0 indexed.  argv[0] is the right-hand
118895 ** side of the MATCH operator.
118896 */
118897 static int fts3FilterMethod(
118898   sqlcipher3_vtab_cursor *pCursor,   /* The cursor used for this query */
118899   int idxNum,                     /* Strategy index */
118900   const char *idxStr,             /* Unused */
118901   int nVal,                       /* Number of elements in apVal */
118902   sqlcipher3_value **apVal           /* Arguments for the indexing scheme */
118903 ){
118904   int rc;
118905   char *zSql;                     /* SQL statement used to access %_content */
118906   Fts3Table *p = (Fts3Table *)pCursor->pVtab;
118907   Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
118908
118909   UNUSED_PARAMETER(idxStr);
118910   UNUSED_PARAMETER(nVal);
118911
118912   assert( idxNum>=0 && idxNum<=(FTS3_FULLTEXT_SEARCH+p->nColumn) );
118913   assert( nVal==0 || nVal==1 );
118914   assert( (nVal==0)==(idxNum==FTS3_FULLSCAN_SEARCH) );
118915   assert( p->pSegments==0 );
118916
118917   /* In case the cursor has been used before, clear it now. */
118918   sqlcipher3_finalize(pCsr->pStmt);
118919   sqlcipher3_free(pCsr->aDoclist);
118920   sqlcipher3Fts3ExprFree(pCsr->pExpr);
118921   memset(&pCursor[1], 0, sizeof(Fts3Cursor)-sizeof(sqlcipher3_vtab_cursor));
118922
118923   if( idxStr ){
118924     pCsr->bDesc = (idxStr[0]=='D');
118925   }else{
118926     pCsr->bDesc = p->bDescIdx;
118927   }
118928   pCsr->eSearch = (i16)idxNum;
118929
118930   if( idxNum!=FTS3_DOCID_SEARCH && idxNum!=FTS3_FULLSCAN_SEARCH ){
118931     int iCol = idxNum-FTS3_FULLTEXT_SEARCH;
118932     const char *zQuery = (const char *)sqlcipher3_value_text(apVal[0]);
118933
118934     if( zQuery==0 && sqlcipher3_value_type(apVal[0])!=SQLCIPHER_NULL ){
118935       return SQLCIPHER_NOMEM;
118936     }
118937
118938     rc = sqlcipher3Fts3ExprParse(p->pTokenizer, p->azColumn, p->bHasStat, 
118939         p->nColumn, iCol, zQuery, -1, &pCsr->pExpr
118940     );
118941     if( rc!=SQLCIPHER_OK ){
118942       if( rc==SQLCIPHER_ERROR ){
118943         static const char *zErr = "malformed MATCH expression: [%s]";
118944         p->base.zErrMsg = sqlcipher3_mprintf(zErr, zQuery);
118945       }
118946       return rc;
118947     }
118948
118949     rc = sqlcipher3Fts3ReadLock(p);
118950     if( rc!=SQLCIPHER_OK ) return rc;
118951
118952     rc = fts3EvalStart(pCsr);
118953
118954     sqlcipher3Fts3SegmentsClose(p);
118955     if( rc!=SQLCIPHER_OK ) return rc;
118956     pCsr->pNextId = pCsr->aDoclist;
118957     pCsr->iPrevId = 0;
118958   }
118959
118960   /* Compile a SELECT statement for this cursor. For a full-table-scan, the
118961   ** statement loops through all rows of the %_content table. For a
118962   ** full-text query or docid lookup, the statement retrieves a single
118963   ** row by docid.
118964   */
118965   if( idxNum==FTS3_FULLSCAN_SEARCH ){
118966     zSql = sqlcipher3_mprintf(
118967         "SELECT %s ORDER BY rowid %s",
118968         p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
118969     );
118970     if( zSql ){
118971       rc = sqlcipher3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
118972       sqlcipher3_free(zSql);
118973     }else{
118974       rc = SQLCIPHER_NOMEM;
118975     }
118976   }else if( idxNum==FTS3_DOCID_SEARCH ){
118977     rc = fts3CursorSeekStmt(pCsr, &pCsr->pStmt);
118978     if( rc==SQLCIPHER_OK ){
118979       rc = sqlcipher3_bind_value(pCsr->pStmt, 1, apVal[0]);
118980     }
118981   }
118982   if( rc!=SQLCIPHER_OK ) return rc;
118983
118984   return fts3NextMethod(pCursor);
118985 }
118986
118987 /* 
118988 ** This is the xEof method of the virtual table. SQLite calls this 
118989 ** routine to find out if it has reached the end of a result set.
118990 */
118991 static int fts3EofMethod(sqlcipher3_vtab_cursor *pCursor){
118992   return ((Fts3Cursor *)pCursor)->isEof;
118993 }
118994
118995 /* 
118996 ** This is the xRowid method. The SQLite core calls this routine to
118997 ** retrieve the rowid for the current row of the result set. fts3
118998 ** exposes %_content.docid as the rowid for the virtual table. The
118999 ** rowid should be written to *pRowid.
119000 */
119001 static int fts3RowidMethod(sqlcipher3_vtab_cursor *pCursor, sqlcipher_int64 *pRowid){
119002   Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
119003   *pRowid = pCsr->iPrevId;
119004   return SQLCIPHER_OK;
119005 }
119006
119007 /* 
119008 ** This is the xColumn method, called by SQLite to request a value from
119009 ** the row that the supplied cursor currently points to.
119010 */
119011 static int fts3ColumnMethod(
119012   sqlcipher3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
119013   sqlcipher3_context *pContext,      /* Context for sqlcipher3_result_xxx() calls */
119014   int iCol                        /* Index of column to read value from */
119015 ){
119016   int rc = SQLCIPHER_OK;             /* Return Code */
119017   Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
119018   Fts3Table *p = (Fts3Table *)pCursor->pVtab;
119019
119020   /* The column value supplied by SQLite must be in range. */
119021   assert( iCol>=0 && iCol<=p->nColumn+1 );
119022
119023   if( iCol==p->nColumn+1 ){
119024     /* This call is a request for the "docid" column. Since "docid" is an 
119025     ** alias for "rowid", use the xRowid() method to obtain the value.
119026     */
119027     sqlcipher3_result_int64(pContext, pCsr->iPrevId);
119028   }else if( iCol==p->nColumn ){
119029     /* The extra column whose name is the same as the table.
119030     ** Return a blob which is a pointer to the cursor.
119031     */
119032     sqlcipher3_result_blob(pContext, &pCsr, sizeof(pCsr), SQLCIPHER_TRANSIENT);
119033   }else{
119034     rc = fts3CursorSeek(0, pCsr);
119035     if( rc==SQLCIPHER_OK && sqlcipher3_data_count(pCsr->pStmt)>(iCol+1) ){
119036       sqlcipher3_result_value(pContext, sqlcipher3_column_value(pCsr->pStmt, iCol+1));
119037     }
119038   }
119039
119040   assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
119041   return rc;
119042 }
119043
119044 /* 
119045 ** This function is the implementation of the xUpdate callback used by 
119046 ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
119047 ** inserted, updated or deleted.
119048 */
119049 static int fts3UpdateMethod(
119050   sqlcipher3_vtab *pVtab,            /* Virtual table handle */
119051   int nArg,                       /* Size of argument array */
119052   sqlcipher3_value **apVal,          /* Array of arguments */
119053   sqlcipher_int64 *pRowid            /* OUT: The affected (or effected) rowid */
119054 ){
119055   return sqlcipher3Fts3UpdateMethod(pVtab, nArg, apVal, pRowid);
119056 }
119057
119058 /*
119059 ** Implementation of xSync() method. Flush the contents of the pending-terms
119060 ** hash-table to the database.
119061 */
119062 static int fts3SyncMethod(sqlcipher3_vtab *pVtab){
119063   int rc = sqlcipher3Fts3PendingTermsFlush((Fts3Table *)pVtab);
119064   sqlcipher3Fts3SegmentsClose((Fts3Table *)pVtab);
119065   return rc;
119066 }
119067
119068 /*
119069 ** Implementation of xBegin() method. This is a no-op.
119070 */
119071 static int fts3BeginMethod(sqlcipher3_vtab *pVtab){
119072   TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
119073   UNUSED_PARAMETER(pVtab);
119074   assert( p->pSegments==0 );
119075   assert( p->nPendingData==0 );
119076   assert( p->inTransaction!=1 );
119077   TESTONLY( p->inTransaction = 1 );
119078   TESTONLY( p->mxSavepoint = -1; );
119079   return SQLCIPHER_OK;
119080 }
119081
119082 /*
119083 ** Implementation of xCommit() method. This is a no-op. The contents of
119084 ** the pending-terms hash-table have already been flushed into the database
119085 ** by fts3SyncMethod().
119086 */
119087 static int fts3CommitMethod(sqlcipher3_vtab *pVtab){
119088   TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
119089   UNUSED_PARAMETER(pVtab);
119090   assert( p->nPendingData==0 );
119091   assert( p->inTransaction!=0 );
119092   assert( p->pSegments==0 );
119093   TESTONLY( p->inTransaction = 0 );
119094   TESTONLY( p->mxSavepoint = -1; );
119095   return SQLCIPHER_OK;
119096 }
119097
119098 /*
119099 ** Implementation of xRollback(). Discard the contents of the pending-terms
119100 ** hash-table. Any changes made to the database are reverted by SQLite.
119101 */
119102 static int fts3RollbackMethod(sqlcipher3_vtab *pVtab){
119103   Fts3Table *p = (Fts3Table*)pVtab;
119104   sqlcipher3Fts3PendingTermsClear(p);
119105   assert( p->inTransaction!=0 );
119106   TESTONLY( p->inTransaction = 0 );
119107   TESTONLY( p->mxSavepoint = -1; );
119108   return SQLCIPHER_OK;
119109 }
119110
119111 /*
119112 ** When called, *ppPoslist must point to the byte immediately following the
119113 ** end of a position-list. i.e. ( (*ppPoslist)[-1]==POS_END ). This function
119114 ** moves *ppPoslist so that it instead points to the first byte of the
119115 ** same position list.
119116 */
119117 static void fts3ReversePoslist(char *pStart, char **ppPoslist){
119118   char *p = &(*ppPoslist)[-2];
119119   char c = 0;
119120
119121   while( p>pStart && (c=*p--)==0 );
119122   while( p>pStart && (*p & 0x80) | c ){ 
119123     c = *p--; 
119124   }
119125   if( p>pStart ){ p = &p[2]; }
119126   while( *p++&0x80 );
119127   *ppPoslist = p;
119128 }
119129
119130 /*
119131 ** Helper function used by the implementation of the overloaded snippet(),
119132 ** offsets() and optimize() SQL functions.
119133 **
119134 ** If the value passed as the third argument is a blob of size
119135 ** sizeof(Fts3Cursor*), then the blob contents are copied to the 
119136 ** output variable *ppCsr and SQLCIPHER_OK is returned. Otherwise, an error
119137 ** message is written to context pContext and SQLCIPHER_ERROR returned. The
119138 ** string passed via zFunc is used as part of the error message.
119139 */
119140 static int fts3FunctionArg(
119141   sqlcipher3_context *pContext,      /* SQL function call context */
119142   const char *zFunc,              /* Function name */
119143   sqlcipher3_value *pVal,            /* argv[0] passed to function */
119144   Fts3Cursor **ppCsr              /* OUT: Store cursor handle here */
119145 ){
119146   Fts3Cursor *pRet;
119147   if( sqlcipher3_value_type(pVal)!=SQLCIPHER_BLOB 
119148    || sqlcipher3_value_bytes(pVal)!=sizeof(Fts3Cursor *)
119149   ){
119150     char *zErr = sqlcipher3_mprintf("illegal first argument to %s", zFunc);
119151     sqlcipher3_result_error(pContext, zErr, -1);
119152     sqlcipher3_free(zErr);
119153     return SQLCIPHER_ERROR;
119154   }
119155   memcpy(&pRet, sqlcipher3_value_blob(pVal), sizeof(Fts3Cursor *));
119156   *ppCsr = pRet;
119157   return SQLCIPHER_OK;
119158 }
119159
119160 /*
119161 ** Implementation of the snippet() function for FTS3
119162 */
119163 static void fts3SnippetFunc(
119164   sqlcipher3_context *pContext,      /* SQLite function call context */
119165   int nVal,                       /* Size of apVal[] array */
119166   sqlcipher3_value **apVal           /* Array of arguments */
119167 ){
119168   Fts3Cursor *pCsr;               /* Cursor handle passed through apVal[0] */
119169   const char *zStart = "<b>";
119170   const char *zEnd = "</b>";
119171   const char *zEllipsis = "<b>...</b>";
119172   int iCol = -1;
119173   int nToken = 15;                /* Default number of tokens in snippet */
119174
119175   /* There must be at least one argument passed to this function (otherwise
119176   ** the non-overloaded version would have been called instead of this one).
119177   */
119178   assert( nVal>=1 );
119179
119180   if( nVal>6 ){
119181     sqlcipher3_result_error(pContext, 
119182         "wrong number of arguments to function snippet()", -1);
119183     return;
119184   }
119185   if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return;
119186
119187   switch( nVal ){
119188     case 6: nToken = sqlcipher3_value_int(apVal[5]);
119189     case 5: iCol = sqlcipher3_value_int(apVal[4]);
119190     case 4: zEllipsis = (const char*)sqlcipher3_value_text(apVal[3]);
119191     case 3: zEnd = (const char*)sqlcipher3_value_text(apVal[2]);
119192     case 2: zStart = (const char*)sqlcipher3_value_text(apVal[1]);
119193   }
119194   if( !zEllipsis || !zEnd || !zStart ){
119195     sqlcipher3_result_error_nomem(pContext);
119196   }else if( SQLCIPHER_OK==fts3CursorSeek(pContext, pCsr) ){
119197     sqlcipher3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
119198   }
119199 }
119200
119201 /*
119202 ** Implementation of the offsets() function for FTS3
119203 */
119204 static void fts3OffsetsFunc(
119205   sqlcipher3_context *pContext,      /* SQLite function call context */
119206   int nVal,                       /* Size of argument array */
119207   sqlcipher3_value **apVal           /* Array of arguments */
119208 ){
119209   Fts3Cursor *pCsr;               /* Cursor handle passed through apVal[0] */
119210
119211   UNUSED_PARAMETER(nVal);
119212
119213   assert( nVal==1 );
119214   if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return;
119215   assert( pCsr );
119216   if( SQLCIPHER_OK==fts3CursorSeek(pContext, pCsr) ){
119217     sqlcipher3Fts3Offsets(pContext, pCsr);
119218   }
119219 }
119220
119221 /* 
119222 ** Implementation of the special optimize() function for FTS3. This 
119223 ** function merges all segments in the database to a single segment.
119224 ** Example usage is:
119225 **
119226 **   SELECT optimize(t) FROM t LIMIT 1;
119227 **
119228 ** where 't' is the name of an FTS3 table.
119229 */
119230 static void fts3OptimizeFunc(
119231   sqlcipher3_context *pContext,      /* SQLite function call context */
119232   int nVal,                       /* Size of argument array */
119233   sqlcipher3_value **apVal           /* Array of arguments */
119234 ){
119235   int rc;                         /* Return code */
119236   Fts3Table *p;                   /* Virtual table handle */
119237   Fts3Cursor *pCursor;            /* Cursor handle passed through apVal[0] */
119238
119239   UNUSED_PARAMETER(nVal);
119240
119241   assert( nVal==1 );
119242   if( fts3FunctionArg(pContext, "optimize", apVal[0], &pCursor) ) return;
119243   p = (Fts3Table *)pCursor->base.pVtab;
119244   assert( p );
119245
119246   rc = sqlcipher3Fts3Optimize(p);
119247
119248   switch( rc ){
119249     case SQLCIPHER_OK:
119250       sqlcipher3_result_text(pContext, "Index optimized", -1, SQLCIPHER_STATIC);
119251       break;
119252     case SQLCIPHER_DONE:
119253       sqlcipher3_result_text(pContext, "Index already optimal", -1, SQLCIPHER_STATIC);
119254       break;
119255     default:
119256       sqlcipher3_result_error_code(pContext, rc);
119257       break;
119258   }
119259 }
119260
119261 /*
119262 ** Implementation of the matchinfo() function for FTS3
119263 */
119264 static void fts3MatchinfoFunc(
119265   sqlcipher3_context *pContext,      /* SQLite function call context */
119266   int nVal,                       /* Size of argument array */
119267   sqlcipher3_value **apVal           /* Array of arguments */
119268 ){
119269   Fts3Cursor *pCsr;               /* Cursor handle passed through apVal[0] */
119270   assert( nVal==1 || nVal==2 );
119271   if( SQLCIPHER_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
119272     const char *zArg = 0;
119273     if( nVal>1 ){
119274       zArg = (const char *)sqlcipher3_value_text(apVal[1]);
119275     }
119276     sqlcipher3Fts3Matchinfo(pContext, pCsr, zArg);
119277   }
119278 }
119279
119280 /*
119281 ** This routine implements the xFindFunction method for the FTS3
119282 ** virtual table.
119283 */
119284 static int fts3FindFunctionMethod(
119285   sqlcipher3_vtab *pVtab,            /* Virtual table handle */
119286   int nArg,                       /* Number of SQL function arguments */
119287   const char *zName,              /* Name of SQL function */
119288   void (**pxFunc)(sqlcipher3_context*,int,sqlcipher3_value**), /* OUT: Result */
119289   void **ppArg                    /* Unused */
119290 ){
119291   struct Overloaded {
119292     const char *zName;
119293     void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**);
119294   } aOverload[] = {
119295     { "snippet", fts3SnippetFunc },
119296     { "offsets", fts3OffsetsFunc },
119297     { "optimize", fts3OptimizeFunc },
119298     { "matchinfo", fts3MatchinfoFunc },
119299   };
119300   int i;                          /* Iterator variable */
119301
119302   UNUSED_PARAMETER(pVtab);
119303   UNUSED_PARAMETER(nArg);
119304   UNUSED_PARAMETER(ppArg);
119305
119306   for(i=0; i<SizeofArray(aOverload); i++){
119307     if( strcmp(zName, aOverload[i].zName)==0 ){
119308       *pxFunc = aOverload[i].xFunc;
119309       return 1;
119310     }
119311   }
119312
119313   /* No function of the specified name was found. Return 0. */
119314   return 0;
119315 }
119316
119317 /*
119318 ** Implementation of FTS3 xRename method. Rename an fts3 table.
119319 */
119320 static int fts3RenameMethod(
119321   sqlcipher3_vtab *pVtab,            /* Virtual table handle */
119322   const char *zName               /* New name of table */
119323 ){
119324   Fts3Table *p = (Fts3Table *)pVtab;
119325   sqlcipher3 *db = p->db;            /* Database connection */
119326   int rc;                         /* Return Code */
119327
119328   /* As it happens, the pending terms table is always empty here. This is
119329   ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction 
119330   ** always opens a savepoint transaction. And the xSavepoint() method 
119331   ** flushes the pending terms table. But leave the (no-op) call to
119332   ** PendingTermsFlush() in in case that changes.
119333   */
119334   assert( p->nPendingData==0 );
119335   rc = sqlcipher3Fts3PendingTermsFlush(p);
119336
119337   if( p->zContentTbl==0 ){
119338     fts3DbExec(&rc, db,
119339       "ALTER TABLE %Q.'%q_content'  RENAME TO '%q_content';",
119340       p->zDb, p->zName, zName
119341     );
119342   }
119343
119344   if( p->bHasDocsize ){
119345     fts3DbExec(&rc, db,
119346       "ALTER TABLE %Q.'%q_docsize'  RENAME TO '%q_docsize';",
119347       p->zDb, p->zName, zName
119348     );
119349   }
119350   if( p->bHasStat ){
119351     fts3DbExec(&rc, db,
119352       "ALTER TABLE %Q.'%q_stat'  RENAME TO '%q_stat';",
119353       p->zDb, p->zName, zName
119354     );
119355   }
119356   fts3DbExec(&rc, db,
119357     "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';",
119358     p->zDb, p->zName, zName
119359   );
119360   fts3DbExec(&rc, db,
119361     "ALTER TABLE %Q.'%q_segdir'   RENAME TO '%q_segdir';",
119362     p->zDb, p->zName, zName
119363   );
119364   return rc;
119365 }
119366
119367 /*
119368 ** The xSavepoint() method.
119369 **
119370 ** Flush the contents of the pending-terms table to disk.
119371 */
119372 static int fts3SavepointMethod(sqlcipher3_vtab *pVtab, int iSavepoint){
119373   UNUSED_PARAMETER(iSavepoint);
119374   assert( ((Fts3Table *)pVtab)->inTransaction );
119375   assert( ((Fts3Table *)pVtab)->mxSavepoint < iSavepoint );
119376   TESTONLY( ((Fts3Table *)pVtab)->mxSavepoint = iSavepoint );
119377   return fts3SyncMethod(pVtab);
119378 }
119379
119380 /*
119381 ** The xRelease() method.
119382 **
119383 ** This is a no-op.
119384 */
119385 static int fts3ReleaseMethod(sqlcipher3_vtab *pVtab, int iSavepoint){
119386   TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
119387   UNUSED_PARAMETER(iSavepoint);
119388   UNUSED_PARAMETER(pVtab);
119389   assert( p->inTransaction );
119390   assert( p->mxSavepoint >= iSavepoint );
119391   TESTONLY( p->mxSavepoint = iSavepoint-1 );
119392   return SQLCIPHER_OK;
119393 }
119394
119395 /*
119396 ** The xRollbackTo() method.
119397 **
119398 ** Discard the contents of the pending terms table.
119399 */
119400 static int fts3RollbackToMethod(sqlcipher3_vtab *pVtab, int iSavepoint){
119401   Fts3Table *p = (Fts3Table*)pVtab;
119402   UNUSED_PARAMETER(iSavepoint);
119403   assert( p->inTransaction );
119404   assert( p->mxSavepoint >= iSavepoint );
119405   TESTONLY( p->mxSavepoint = iSavepoint );
119406   sqlcipher3Fts3PendingTermsClear(p);
119407   return SQLCIPHER_OK;
119408 }
119409
119410 static const sqlcipher3_module fts3Module = {
119411   /* iVersion      */ 2,
119412   /* xCreate       */ fts3CreateMethod,
119413   /* xConnect      */ fts3ConnectMethod,
119414   /* xBestIndex    */ fts3BestIndexMethod,
119415   /* xDisconnect   */ fts3DisconnectMethod,
119416   /* xDestroy      */ fts3DestroyMethod,
119417   /* xOpen         */ fts3OpenMethod,
119418   /* xClose        */ fts3CloseMethod,
119419   /* xFilter       */ fts3FilterMethod,
119420   /* xNext         */ fts3NextMethod,
119421   /* xEof          */ fts3EofMethod,
119422   /* xColumn       */ fts3ColumnMethod,
119423   /* xRowid        */ fts3RowidMethod,
119424   /* xUpdate       */ fts3UpdateMethod,
119425   /* xBegin        */ fts3BeginMethod,
119426   /* xSync         */ fts3SyncMethod,
119427   /* xCommit       */ fts3CommitMethod,
119428   /* xRollback     */ fts3RollbackMethod,
119429   /* xFindFunction */ fts3FindFunctionMethod,
119430   /* xRename */       fts3RenameMethod,
119431   /* xSavepoint    */ fts3SavepointMethod,
119432   /* xRelease      */ fts3ReleaseMethod,
119433   /* xRollbackTo   */ fts3RollbackToMethod,
119434 };
119435
119436 /*
119437 ** This function is registered as the module destructor (called when an
119438 ** FTS3 enabled database connection is closed). It frees the memory
119439 ** allocated for the tokenizer hash table.
119440 */
119441 static void hashDestroy(void *p){
119442   Fts3Hash *pHash = (Fts3Hash *)p;
119443   sqlcipher3Fts3HashClear(pHash);
119444   sqlcipher3_free(pHash);
119445 }
119446
119447 /*
119448 ** The fts3 built-in tokenizers - "simple", "porter" and "icu"- are 
119449 ** implemented in files fts3_tokenizer1.c, fts3_porter.c and fts3_icu.c
119450 ** respectively. The following three forward declarations are for functions
119451 ** declared in these files used to retrieve the respective implementations.
119452 **
119453 ** Calling sqlcipher3Fts3SimpleTokenizerModule() sets the value pointed
119454 ** to by the argument to point to the "simple" tokenizer implementation.
119455 ** And so on.
119456 */
119457 SQLCIPHER_PRIVATE void sqlcipher3Fts3SimpleTokenizerModule(sqlcipher3_tokenizer_module const**ppModule);
119458 SQLCIPHER_PRIVATE void sqlcipher3Fts3PorterTokenizerModule(sqlcipher3_tokenizer_module const**ppModule);
119459 #ifdef SQLCIPHER_ENABLE_ICU
119460 SQLCIPHER_PRIVATE void sqlcipher3Fts3IcuTokenizerModule(sqlcipher3_tokenizer_module const**ppModule);
119461 #endif
119462
119463 /*
119464 ** Initialise the fts3 extension. If this extension is built as part
119465 ** of the sqlcipher library, then this function is called directly by
119466 ** SQLite. If fts3 is built as a dynamically loadable extension, this
119467 ** function is called by the sqlcipher3_extension_init() entry point.
119468 */
119469 SQLCIPHER_PRIVATE int sqlcipher3Fts3Init(sqlcipher3 *db){
119470   int rc = SQLCIPHER_OK;
119471   Fts3Hash *pHash = 0;
119472   const sqlcipher3_tokenizer_module *pSimple = 0;
119473   const sqlcipher3_tokenizer_module *pPorter = 0;
119474
119475 #ifdef SQLCIPHER_ENABLE_ICU
119476   const sqlcipher3_tokenizer_module *pIcu = 0;
119477   sqlcipher3Fts3IcuTokenizerModule(&pIcu);
119478 #endif
119479
119480 #ifdef SQLCIPHER_TEST
119481   rc = sqlcipher3Fts3InitTerm(db);
119482   if( rc!=SQLCIPHER_OK ) return rc;
119483 #endif
119484
119485   rc = sqlcipher3Fts3InitAux(db);
119486   if( rc!=SQLCIPHER_OK ) return rc;
119487
119488   sqlcipher3Fts3SimpleTokenizerModule(&pSimple);
119489   sqlcipher3Fts3PorterTokenizerModule(&pPorter);
119490
119491   /* Allocate and initialise the hash-table used to store tokenizers. */
119492   pHash = sqlcipher3_malloc(sizeof(Fts3Hash));
119493   if( !pHash ){
119494     rc = SQLCIPHER_NOMEM;
119495   }else{
119496     sqlcipher3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
119497   }
119498
119499   /* Load the built-in tokenizers into the hash table */
119500   if( rc==SQLCIPHER_OK ){
119501     if( sqlcipher3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple)
119502      || sqlcipher3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter) 
119503 #ifdef SQLCIPHER_ENABLE_ICU
119504      || (pIcu && sqlcipher3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu))
119505 #endif
119506     ){
119507       rc = SQLCIPHER_NOMEM;
119508     }
119509   }
119510
119511 #ifdef SQLCIPHER_TEST
119512   if( rc==SQLCIPHER_OK ){
119513     rc = sqlcipher3Fts3ExprInitTestInterface(db);
119514   }
119515 #endif
119516
119517   /* Create the virtual table wrapper around the hash-table and overload 
119518   ** the two scalar functions. If this is successful, register the
119519   ** module with sqlcipher.
119520   */
119521   if( SQLCIPHER_OK==rc 
119522    && SQLCIPHER_OK==(rc = sqlcipher3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
119523    && SQLCIPHER_OK==(rc = sqlcipher3_overload_function(db, "snippet", -1))
119524    && SQLCIPHER_OK==(rc = sqlcipher3_overload_function(db, "offsets", 1))
119525    && SQLCIPHER_OK==(rc = sqlcipher3_overload_function(db, "matchinfo", 1))
119526    && SQLCIPHER_OK==(rc = sqlcipher3_overload_function(db, "matchinfo", 2))
119527    && SQLCIPHER_OK==(rc = sqlcipher3_overload_function(db, "optimize", 1))
119528   ){
119529     rc = sqlcipher3_create_module_v2(
119530         db, "fts3", &fts3Module, (void *)pHash, hashDestroy
119531     );
119532     if( rc==SQLCIPHER_OK ){
119533       rc = sqlcipher3_create_module_v2(
119534           db, "fts4", &fts3Module, (void *)pHash, 0
119535       );
119536     }
119537     return rc;
119538   }
119539
119540   /* An error has occurred. Delete the hash table and return the error code. */
119541   assert( rc!=SQLCIPHER_OK );
119542   if( pHash ){
119543     sqlcipher3Fts3HashClear(pHash);
119544     sqlcipher3_free(pHash);
119545   }
119546   return rc;
119547 }
119548
119549 /*
119550 ** Allocate an Fts3MultiSegReader for each token in the expression headed
119551 ** by pExpr. 
119552 **
119553 ** An Fts3SegReader object is a cursor that can seek or scan a range of
119554 ** entries within a single segment b-tree. An Fts3MultiSegReader uses multiple
119555 ** Fts3SegReader objects internally to provide an interface to seek or scan
119556 ** within the union of all segments of a b-tree. Hence the name.
119557 **
119558 ** If the allocated Fts3MultiSegReader just seeks to a single entry in a
119559 ** segment b-tree (if the term is not a prefix or it is a prefix for which
119560 ** there exists prefix b-tree of the right length) then it may be traversed
119561 ** and merged incrementally. Otherwise, it has to be merged into an in-memory 
119562 ** doclist and then traversed.
119563 */
119564 static void fts3EvalAllocateReaders(
119565   Fts3Cursor *pCsr,               /* FTS cursor handle */
119566   Fts3Expr *pExpr,                /* Allocate readers for this expression */
119567   int *pnToken,                   /* OUT: Total number of tokens in phrase. */
119568   int *pnOr,                      /* OUT: Total number of OR nodes in expr. */
119569   int *pRc                        /* IN/OUT: Error code */
119570 ){
119571   if( pExpr && SQLCIPHER_OK==*pRc ){
119572     if( pExpr->eType==FTSQUERY_PHRASE ){
119573       int i;
119574       int nToken = pExpr->pPhrase->nToken;
119575       *pnToken += nToken;
119576       for(i=0; i<nToken; i++){
119577         Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
119578         int rc = fts3TermSegReaderCursor(pCsr, 
119579             pToken->z, pToken->n, pToken->isPrefix, &pToken->pSegcsr
119580         );
119581         if( rc!=SQLCIPHER_OK ){
119582           *pRc = rc;
119583           return;
119584         }
119585       }
119586       assert( pExpr->pPhrase->iDoclistToken==0 );
119587       pExpr->pPhrase->iDoclistToken = -1;
119588     }else{
119589       *pnOr += (pExpr->eType==FTSQUERY_OR);
119590       fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
119591       fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
119592     }
119593   }
119594 }
119595
119596 /*
119597 ** Arguments pList/nList contain the doclist for token iToken of phrase p.
119598 ** It is merged into the main doclist stored in p->doclist.aAll/nAll.
119599 **
119600 ** This function assumes that pList points to a buffer allocated using
119601 ** sqlcipher3_malloc(). This function takes responsibility for eventually
119602 ** freeing the buffer.
119603 */
119604 static void fts3EvalPhraseMergeToken(
119605   Fts3Table *pTab,                /* FTS Table pointer */
119606   Fts3Phrase *p,                  /* Phrase to merge pList/nList into */
119607   int iToken,                     /* Token pList/nList corresponds to */
119608   char *pList,                    /* Pointer to doclist */
119609   int nList                       /* Number of bytes in pList */
119610 ){
119611   assert( iToken!=p->iDoclistToken );
119612
119613   if( pList==0 ){
119614     sqlcipher3_free(p->doclist.aAll);
119615     p->doclist.aAll = 0;
119616     p->doclist.nAll = 0;
119617   }
119618
119619   else if( p->iDoclistToken<0 ){
119620     p->doclist.aAll = pList;
119621     p->doclist.nAll = nList;
119622   }
119623
119624   else if( p->doclist.aAll==0 ){
119625     sqlcipher3_free(pList);
119626   }
119627
119628   else {
119629     char *pLeft;
119630     char *pRight;
119631     int nLeft;
119632     int nRight;
119633     int nDiff;
119634
119635     if( p->iDoclistToken<iToken ){
119636       pLeft = p->doclist.aAll;
119637       nLeft = p->doclist.nAll;
119638       pRight = pList;
119639       nRight = nList;
119640       nDiff = iToken - p->iDoclistToken;
119641     }else{
119642       pRight = p->doclist.aAll;
119643       nRight = p->doclist.nAll;
119644       pLeft = pList;
119645       nLeft = nList;
119646       nDiff = p->iDoclistToken - iToken;
119647     }
119648
119649     fts3DoclistPhraseMerge(pTab->bDescIdx, nDiff, pLeft, nLeft, pRight,&nRight);
119650     sqlcipher3_free(pLeft);
119651     p->doclist.aAll = pRight;
119652     p->doclist.nAll = nRight;
119653   }
119654
119655   if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken;
119656 }
119657
119658 /*
119659 ** Load the doclist for phrase p into p->doclist.aAll/nAll. The loaded doclist
119660 ** does not take deferred tokens into account.
119661 **
119662 ** SQLCIPHER_OK is returned if no error occurs, otherwise an SQLite error code.
119663 */
119664 static int fts3EvalPhraseLoad(
119665   Fts3Cursor *pCsr,               /* FTS Cursor handle */
119666   Fts3Phrase *p                   /* Phrase object */
119667 ){
119668   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
119669   int iToken;
119670   int rc = SQLCIPHER_OK;
119671
119672   for(iToken=0; rc==SQLCIPHER_OK && iToken<p->nToken; iToken++){
119673     Fts3PhraseToken *pToken = &p->aToken[iToken];
119674     assert( pToken->pDeferred==0 || pToken->pSegcsr==0 );
119675
119676     if( pToken->pSegcsr ){
119677       int nThis = 0;
119678       char *pThis = 0;
119679       rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
119680       if( rc==SQLCIPHER_OK ){
119681         fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
119682       }
119683     }
119684     assert( pToken->pSegcsr==0 );
119685   }
119686
119687   return rc;
119688 }
119689
119690 /*
119691 ** This function is called on each phrase after the position lists for
119692 ** any deferred tokens have been loaded into memory. It updates the phrases
119693 ** current position list to include only those positions that are really
119694 ** instances of the phrase (after considering deferred tokens). If this
119695 ** means that the phrase does not appear in the current row, doclist.pList
119696 ** and doclist.nList are both zeroed.
119697 **
119698 ** SQLCIPHER_OK is returned if no error occurs, otherwise an SQLite error code.
119699 */
119700 static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
119701   int iToken;                     /* Used to iterate through phrase tokens */
119702   char *aPoslist = 0;             /* Position list for deferred tokens */
119703   int nPoslist = 0;               /* Number of bytes in aPoslist */
119704   int iPrev = -1;                 /* Token number of previous deferred token */
119705
119706   assert( pPhrase->doclist.bFreeList==0 );
119707
119708   for(iToken=0; iToken<pPhrase->nToken; iToken++){
119709     Fts3PhraseToken *pToken = &pPhrase->aToken[iToken];
119710     Fts3DeferredToken *pDeferred = pToken->pDeferred;
119711
119712     if( pDeferred ){
119713       char *pList;
119714       int nList;
119715       int rc = sqlcipher3Fts3DeferredTokenList(pDeferred, &pList, &nList);
119716       if( rc!=SQLCIPHER_OK ) return rc;
119717
119718       if( pList==0 ){
119719         sqlcipher3_free(aPoslist);
119720         pPhrase->doclist.pList = 0;
119721         pPhrase->doclist.nList = 0;
119722         return SQLCIPHER_OK;
119723
119724       }else if( aPoslist==0 ){
119725         aPoslist = pList;
119726         nPoslist = nList;
119727
119728       }else{
119729         char *aOut = pList;
119730         char *p1 = aPoslist;
119731         char *p2 = aOut;
119732
119733         assert( iPrev>=0 );
119734         fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2);
119735         sqlcipher3_free(aPoslist);
119736         aPoslist = pList;
119737         nPoslist = aOut - aPoslist;
119738         if( nPoslist==0 ){
119739           sqlcipher3_free(aPoslist);
119740           pPhrase->doclist.pList = 0;
119741           pPhrase->doclist.nList = 0;
119742           return SQLCIPHER_OK;
119743         }
119744       }
119745       iPrev = iToken;
119746     }
119747   }
119748
119749   if( iPrev>=0 ){
119750     int nMaxUndeferred = pPhrase->iDoclistToken;
119751     if( nMaxUndeferred<0 ){
119752       pPhrase->doclist.pList = aPoslist;
119753       pPhrase->doclist.nList = nPoslist;
119754       pPhrase->doclist.iDocid = pCsr->iPrevId;
119755       pPhrase->doclist.bFreeList = 1;
119756     }else{
119757       int nDistance;
119758       char *p1;
119759       char *p2;
119760       char *aOut;
119761
119762       if( nMaxUndeferred>iPrev ){
119763         p1 = aPoslist;
119764         p2 = pPhrase->doclist.pList;
119765         nDistance = nMaxUndeferred - iPrev;
119766       }else{
119767         p1 = pPhrase->doclist.pList;
119768         p2 = aPoslist;
119769         nDistance = iPrev - nMaxUndeferred;
119770       }
119771
119772       aOut = (char *)sqlcipher3_malloc(nPoslist+8);
119773       if( !aOut ){
119774         sqlcipher3_free(aPoslist);
119775         return SQLCIPHER_NOMEM;
119776       }
119777       
119778       pPhrase->doclist.pList = aOut;
119779       if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){
119780         pPhrase->doclist.bFreeList = 1;
119781         pPhrase->doclist.nList = (aOut - pPhrase->doclist.pList);
119782       }else{
119783         sqlcipher3_free(aOut);
119784         pPhrase->doclist.pList = 0;
119785         pPhrase->doclist.nList = 0;
119786       }
119787       sqlcipher3_free(aPoslist);
119788     }
119789   }
119790
119791   return SQLCIPHER_OK;
119792 }
119793
119794 /*
119795 ** This function is called for each Fts3Phrase in a full-text query 
119796 ** expression to initialize the mechanism for returning rows. Once this
119797 ** function has been called successfully on an Fts3Phrase, it may be
119798 ** used with fts3EvalPhraseNext() to iterate through the matching docids.
119799 **
119800 ** If parameter bOptOk is true, then the phrase may (or may not) use the
119801 ** incremental loading strategy. Otherwise, the entire doclist is loaded into
119802 ** memory within this call.
119803 **
119804 ** SQLCIPHER_OK is returned if no error occurs, otherwise an SQLite error code.
119805 */
119806 static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
119807   int rc;                         /* Error code */
119808   Fts3PhraseToken *pFirst = &p->aToken[0];
119809   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
119810
119811   if( pCsr->bDesc==pTab->bDescIdx 
119812    && bOptOk==1 
119813    && p->nToken==1 
119814    && pFirst->pSegcsr 
119815    && pFirst->pSegcsr->bLookup 
119816    && pFirst->bFirst==0
119817   ){
119818     /* Use the incremental approach. */
119819     int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
119820     rc = sqlcipher3Fts3MsrIncrStart(
119821         pTab, pFirst->pSegcsr, iCol, pFirst->z, pFirst->n);
119822     p->bIncr = 1;
119823
119824   }else{
119825     /* Load the full doclist for the phrase into memory. */
119826     rc = fts3EvalPhraseLoad(pCsr, p);
119827     p->bIncr = 0;
119828   }
119829
119830   assert( rc!=SQLCIPHER_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
119831   return rc;
119832 }
119833
119834 /*
119835 ** This function is used to iterate backwards (from the end to start) 
119836 ** through doclists. It is used by this module to iterate through phrase
119837 ** doclists in reverse and by the fts3_write.c module to iterate through
119838 ** pending-terms lists when writing to databases with "order=desc".
119839 **
119840 ** The doclist may be sorted in ascending (parameter bDescIdx==0) or 
119841 ** descending (parameter bDescIdx==1) order of docid. Regardless, this
119842 ** function iterates from the end of the doclist to the beginning.
119843 */
119844 SQLCIPHER_PRIVATE void sqlcipher3Fts3DoclistPrev(
119845   int bDescIdx,                   /* True if the doclist is desc */
119846   char *aDoclist,                 /* Pointer to entire doclist */
119847   int nDoclist,                   /* Length of aDoclist in bytes */
119848   char **ppIter,                  /* IN/OUT: Iterator pointer */
119849   sqlcipher3_int64 *piDocid,         /* IN/OUT: Docid pointer */
119850   int *pnList,                    /* IN/OUT: List length pointer */
119851   u8 *pbEof                       /* OUT: End-of-file flag */
119852 ){
119853   char *p = *ppIter;
119854
119855   assert( nDoclist>0 );
119856   assert( *pbEof==0 );
119857   assert( p || *piDocid==0 );
119858   assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) );
119859
119860   if( p==0 ){
119861     sqlcipher3_int64 iDocid = 0;
119862     char *pNext = 0;
119863     char *pDocid = aDoclist;
119864     char *pEnd = &aDoclist[nDoclist];
119865     int iMul = 1;
119866
119867     while( pDocid<pEnd ){
119868       sqlcipher3_int64 iDelta;
119869       pDocid += sqlcipher3Fts3GetVarint(pDocid, &iDelta);
119870       iDocid += (iMul * iDelta);
119871       pNext = pDocid;
119872       fts3PoslistCopy(0, &pDocid);
119873       while( pDocid<pEnd && *pDocid==0 ) pDocid++;
119874       iMul = (bDescIdx ? -1 : 1);
119875     }
119876
119877     *pnList = pEnd - pNext;
119878     *ppIter = pNext;
119879     *piDocid = iDocid;
119880   }else{
119881     int iMul = (bDescIdx ? -1 : 1);
119882     sqlcipher3_int64 iDelta;
119883     fts3GetReverseVarint(&p, aDoclist, &iDelta);
119884     *piDocid -= (iMul * iDelta);
119885
119886     if( p==aDoclist ){
119887       *pbEof = 1;
119888     }else{
119889       char *pSave = p;
119890       fts3ReversePoslist(aDoclist, &p);
119891       *pnList = (pSave - p);
119892     }
119893     *ppIter = p;
119894   }
119895 }
119896
119897 /*
119898 ** Attempt to move the phrase iterator to point to the next matching docid. 
119899 ** If an error occurs, return an SQLite error code. Otherwise, return 
119900 ** SQLCIPHER_OK.
119901 **
119902 ** If there is no "next" entry and no error occurs, then *pbEof is set to
119903 ** 1 before returning. Otherwise, if no error occurs and the iterator is
119904 ** successfully advanced, *pbEof is set to 0.
119905 */
119906 static int fts3EvalPhraseNext(
119907   Fts3Cursor *pCsr,               /* FTS Cursor handle */
119908   Fts3Phrase *p,                  /* Phrase object to advance to next docid */
119909   u8 *pbEof                       /* OUT: Set to 1 if EOF */
119910 ){
119911   int rc = SQLCIPHER_OK;
119912   Fts3Doclist *pDL = &p->doclist;
119913   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
119914
119915   if( p->bIncr ){
119916     assert( p->nToken==1 );
119917     assert( pDL->pNextDocid==0 );
119918     rc = sqlcipher3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr, 
119919         &pDL->iDocid, &pDL->pList, &pDL->nList
119920     );
119921     if( rc==SQLCIPHER_OK && !pDL->pList ){
119922       *pbEof = 1;
119923     }
119924   }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
119925     sqlcipher3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll, 
119926         &pDL->pNextDocid, &pDL->iDocid, &pDL->nList, pbEof
119927     );
119928     pDL->pList = pDL->pNextDocid;
119929   }else{
119930     char *pIter;                            /* Used to iterate through aAll */
119931     char *pEnd = &pDL->aAll[pDL->nAll];     /* 1 byte past end of aAll */
119932     if( pDL->pNextDocid ){
119933       pIter = pDL->pNextDocid;
119934     }else{
119935       pIter = pDL->aAll;
119936     }
119937
119938     if( pIter>=pEnd ){
119939       /* We have already reached the end of this doclist. EOF. */
119940       *pbEof = 1;
119941     }else{
119942       sqlcipher3_int64 iDelta;
119943       pIter += sqlcipher3Fts3GetVarint(pIter, &iDelta);
119944       if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){
119945         pDL->iDocid += iDelta;
119946       }else{
119947         pDL->iDocid -= iDelta;
119948       }
119949       pDL->pList = pIter;
119950       fts3PoslistCopy(0, &pIter);
119951       pDL->nList = (pIter - pDL->pList);
119952
119953       /* pIter now points just past the 0x00 that terminates the position-
119954       ** list for document pDL->iDocid. However, if this position-list was
119955       ** edited in place by fts3EvalNearTrim(), then pIter may not actually
119956       ** point to the start of the next docid value. The following line deals
119957       ** with this case by advancing pIter past the zero-padding added by
119958       ** fts3EvalNearTrim().  */
119959       while( pIter<pEnd && *pIter==0 ) pIter++;
119960
119961       pDL->pNextDocid = pIter;
119962       assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
119963       *pbEof = 0;
119964     }
119965   }
119966
119967   return rc;
119968 }
119969
119970 /*
119971 **
119972 ** If *pRc is not SQLCIPHER_OK when this function is called, it is a no-op.
119973 ** Otherwise, fts3EvalPhraseStart() is called on all phrases within the
119974 ** expression. Also the Fts3Expr.bDeferred variable is set to true for any
119975 ** expressions for which all descendent tokens are deferred.
119976 **
119977 ** If parameter bOptOk is zero, then it is guaranteed that the
119978 ** Fts3Phrase.doclist.aAll/nAll variables contain the entire doclist for
119979 ** each phrase in the expression (subject to deferred token processing).
119980 ** Or, if bOptOk is non-zero, then one or more tokens within the expression
119981 ** may be loaded incrementally, meaning doclist.aAll/nAll is not available.
119982 **
119983 ** If an error occurs within this function, *pRc is set to an SQLite error
119984 ** code before returning.
119985 */
119986 static void fts3EvalStartReaders(
119987   Fts3Cursor *pCsr,               /* FTS Cursor handle */
119988   Fts3Expr *pExpr,                /* Expression to initialize phrases in */
119989   int bOptOk,                     /* True to enable incremental loading */
119990   int *pRc                        /* IN/OUT: Error code */
119991 ){
119992   if( pExpr && SQLCIPHER_OK==*pRc ){
119993     if( pExpr->eType==FTSQUERY_PHRASE ){
119994       int i;
119995       int nToken = pExpr->pPhrase->nToken;
119996       for(i=0; i<nToken; i++){
119997         if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
119998       }
119999       pExpr->bDeferred = (i==nToken);
120000       *pRc = fts3EvalPhraseStart(pCsr, bOptOk, pExpr->pPhrase);
120001     }else{
120002       fts3EvalStartReaders(pCsr, pExpr->pLeft, bOptOk, pRc);
120003       fts3EvalStartReaders(pCsr, pExpr->pRight, bOptOk, pRc);
120004       pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
120005     }
120006   }
120007 }
120008
120009 /*
120010 ** An array of the following structures is assembled as part of the process
120011 ** of selecting tokens to defer before the query starts executing (as part
120012 ** of the xFilter() method). There is one element in the array for each
120013 ** token in the FTS expression.
120014 **
120015 ** Tokens are divided into AND/NEAR clusters. All tokens in a cluster belong
120016 ** to phrases that are connected only by AND and NEAR operators (not OR or
120017 ** NOT). When determining tokens to defer, each AND/NEAR cluster is considered
120018 ** separately. The root of a tokens AND/NEAR cluster is stored in 
120019 ** Fts3TokenAndCost.pRoot.
120020 */
120021 typedef struct Fts3TokenAndCost Fts3TokenAndCost;
120022 struct Fts3TokenAndCost {
120023   Fts3Phrase *pPhrase;            /* The phrase the token belongs to */
120024   int iToken;                     /* Position of token in phrase */
120025   Fts3PhraseToken *pToken;        /* The token itself */
120026   Fts3Expr *pRoot;                /* Root of NEAR/AND cluster */
120027   int nOvfl;                      /* Number of overflow pages to load doclist */
120028   int iCol;                       /* The column the token must match */
120029 };
120030
120031 /*
120032 ** This function is used to populate an allocated Fts3TokenAndCost array.
120033 **
120034 ** If *pRc is not SQLCIPHER_OK when this function is called, it is a no-op.
120035 ** Otherwise, if an error occurs during execution, *pRc is set to an
120036 ** SQLite error code.
120037 */
120038 static void fts3EvalTokenCosts(
120039   Fts3Cursor *pCsr,               /* FTS Cursor handle */
120040   Fts3Expr *pRoot,                /* Root of current AND/NEAR cluster */
120041   Fts3Expr *pExpr,                /* Expression to consider */
120042   Fts3TokenAndCost **ppTC,        /* Write new entries to *(*ppTC)++ */
120043   Fts3Expr ***ppOr,               /* Write new OR root to *(*ppOr)++ */
120044   int *pRc                        /* IN/OUT: Error code */
120045 ){
120046   if( *pRc==SQLCIPHER_OK ){
120047     if( pExpr->eType==FTSQUERY_PHRASE ){
120048       Fts3Phrase *pPhrase = pExpr->pPhrase;
120049       int i;
120050       for(i=0; *pRc==SQLCIPHER_OK && i<pPhrase->nToken; i++){
120051         Fts3TokenAndCost *pTC = (*ppTC)++;
120052         pTC->pPhrase = pPhrase;
120053         pTC->iToken = i;
120054         pTC->pRoot = pRoot;
120055         pTC->pToken = &pPhrase->aToken[i];
120056         pTC->iCol = pPhrase->iColumn;
120057         *pRc = sqlcipher3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl);
120058       }
120059     }else if( pExpr->eType!=FTSQUERY_NOT ){
120060       assert( pExpr->eType==FTSQUERY_OR
120061            || pExpr->eType==FTSQUERY_AND
120062            || pExpr->eType==FTSQUERY_NEAR
120063       );
120064       assert( pExpr->pLeft && pExpr->pRight );
120065       if( pExpr->eType==FTSQUERY_OR ){
120066         pRoot = pExpr->pLeft;
120067         **ppOr = pRoot;
120068         (*ppOr)++;
120069       }
120070       fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
120071       if( pExpr->eType==FTSQUERY_OR ){
120072         pRoot = pExpr->pRight;
120073         **ppOr = pRoot;
120074         (*ppOr)++;
120075       }
120076       fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
120077     }
120078   }
120079 }
120080
120081 /*
120082 ** Determine the average document (row) size in pages. If successful,
120083 ** write this value to *pnPage and return SQLCIPHER_OK. Otherwise, return
120084 ** an SQLite error code.
120085 **
120086 ** The average document size in pages is calculated by first calculating 
120087 ** determining the average size in bytes, B. If B is less than the amount
120088 ** of data that will fit on a single leaf page of an intkey table in
120089 ** this database, then the average docsize is 1. Otherwise, it is 1 plus
120090 ** the number of overflow pages consumed by a record B bytes in size.
120091 */
120092 static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){
120093   if( pCsr->nRowAvg==0 ){
120094     /* The average document size, which is required to calculate the cost
120095     ** of each doclist, has not yet been determined. Read the required 
120096     ** data from the %_stat table to calculate it.
120097     **
120098     ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3 
120099     ** varints, where nCol is the number of columns in the FTS3 table.
120100     ** The first varint is the number of documents currently stored in
120101     ** the table. The following nCol varints contain the total amount of
120102     ** data stored in all rows of each column of the table, from left
120103     ** to right.
120104     */
120105     int rc;
120106     Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
120107     sqlcipher3_stmt *pStmt;
120108     sqlcipher3_int64 nDoc = 0;
120109     sqlcipher3_int64 nByte = 0;
120110     const char *pEnd;
120111     const char *a;
120112
120113     rc = sqlcipher3Fts3SelectDoctotal(p, &pStmt);
120114     if( rc!=SQLCIPHER_OK ) return rc;
120115     a = sqlcipher3_column_blob(pStmt, 0);
120116     assert( a );
120117
120118     pEnd = &a[sqlcipher3_column_bytes(pStmt, 0)];
120119     a += sqlcipher3Fts3GetVarint(a, &nDoc);
120120     while( a<pEnd ){
120121       a += sqlcipher3Fts3GetVarint(a, &nByte);
120122     }
120123     if( nDoc==0 || nByte==0 ){
120124       sqlcipher3_reset(pStmt);
120125       return FTS_CORRUPT_VTAB;
120126     }
120127
120128     pCsr->nDoc = nDoc;
120129     pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
120130     assert( pCsr->nRowAvg>0 ); 
120131     rc = sqlcipher3_reset(pStmt);
120132     if( rc!=SQLCIPHER_OK ) return rc;
120133   }
120134
120135   *pnPage = pCsr->nRowAvg;
120136   return SQLCIPHER_OK;
120137 }
120138
120139 /*
120140 ** This function is called to select the tokens (if any) that will be 
120141 ** deferred. The array aTC[] has already been populated when this is
120142 ** called.
120143 **
120144 ** This function is called once for each AND/NEAR cluster in the 
120145 ** expression. Each invocation determines which tokens to defer within
120146 ** the cluster with root node pRoot. See comments above the definition
120147 ** of struct Fts3TokenAndCost for more details.
120148 **
120149 ** If no error occurs, SQLCIPHER_OK is returned and sqlcipher3Fts3DeferToken()
120150 ** called on each token to defer. Otherwise, an SQLite error code is
120151 ** returned.
120152 */
120153 static int fts3EvalSelectDeferred(
120154   Fts3Cursor *pCsr,               /* FTS Cursor handle */
120155   Fts3Expr *pRoot,                /* Consider tokens with this root node */
120156   Fts3TokenAndCost *aTC,          /* Array of expression tokens and costs */
120157   int nTC                         /* Number of entries in aTC[] */
120158 ){
120159   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120160   int nDocSize = 0;               /* Number of pages per doc loaded */
120161   int rc = SQLCIPHER_OK;             /* Return code */
120162   int ii;                         /* Iterator variable for various purposes */
120163   int nOvfl = 0;                  /* Total overflow pages used by doclists */
120164   int nToken = 0;                 /* Total number of tokens in cluster */
120165
120166   int nMinEst = 0;                /* The minimum count for any phrase so far. */
120167   int nLoad4 = 1;                 /* (Phrases that will be loaded)^4. */
120168
120169   /* Tokens are never deferred for FTS tables created using the content=xxx
120170   ** option. The reason being that it is not guaranteed that the content
120171   ** table actually contains the same data as the index. To prevent this from
120172   ** causing any problems, the deferred token optimization is completely
120173   ** disabled for content=xxx tables. */
120174   if( pTab->zContentTbl ){
120175     return SQLCIPHER_OK;
120176   }
120177
120178   /* Count the tokens in this AND/NEAR cluster. If none of the doclists
120179   ** associated with the tokens spill onto overflow pages, or if there is
120180   ** only 1 token, exit early. No tokens to defer in this case. */
120181   for(ii=0; ii<nTC; ii++){
120182     if( aTC[ii].pRoot==pRoot ){
120183       nOvfl += aTC[ii].nOvfl;
120184       nToken++;
120185     }
120186   }
120187   if( nOvfl==0 || nToken<2 ) return SQLCIPHER_OK;
120188
120189   /* Obtain the average docsize (in pages). */
120190   rc = fts3EvalAverageDocsize(pCsr, &nDocSize);
120191   assert( rc!=SQLCIPHER_OK || nDocSize>0 );
120192
120193
120194   /* Iterate through all tokens in this AND/NEAR cluster, in ascending order 
120195   ** of the number of overflow pages that will be loaded by the pager layer 
120196   ** to retrieve the entire doclist for the token from the full-text index.
120197   ** Load the doclists for tokens that are either:
120198   **
120199   **   a. The cheapest token in the entire query (i.e. the one visited by the
120200   **      first iteration of this loop), or
120201   **
120202   **   b. Part of a multi-token phrase.
120203   **
120204   ** After each token doclist is loaded, merge it with the others from the
120205   ** same phrase and count the number of documents that the merged doclist
120206   ** contains. Set variable "nMinEst" to the smallest number of documents in 
120207   ** any phrase doclist for which 1 or more token doclists have been loaded.
120208   ** Let nOther be the number of other phrases for which it is certain that
120209   ** one or more tokens will not be deferred.
120210   **
120211   ** Then, for each token, defer it if loading the doclist would result in
120212   ** loading N or more overflow pages into memory, where N is computed as:
120213   **
120214   **    (nMinEst + 4^nOther - 1) / (4^nOther)
120215   */
120216   for(ii=0; ii<nToken && rc==SQLCIPHER_OK; ii++){
120217     int iTC;                      /* Used to iterate through aTC[] array. */
120218     Fts3TokenAndCost *pTC = 0;    /* Set to cheapest remaining token. */
120219
120220     /* Set pTC to point to the cheapest remaining token. */
120221     for(iTC=0; iTC<nTC; iTC++){
120222       if( aTC[iTC].pToken && aTC[iTC].pRoot==pRoot 
120223        && (!pTC || aTC[iTC].nOvfl<pTC->nOvfl) 
120224       ){
120225         pTC = &aTC[iTC];
120226       }
120227     }
120228     assert( pTC );
120229
120230     if( ii && pTC->nOvfl>=((nMinEst+(nLoad4/4)-1)/(nLoad4/4))*nDocSize ){
120231       /* The number of overflow pages to load for this (and therefore all
120232       ** subsequent) tokens is greater than the estimated number of pages 
120233       ** that will be loaded if all subsequent tokens are deferred.
120234       */
120235       Fts3PhraseToken *pToken = pTC->pToken;
120236       rc = sqlcipher3Fts3DeferToken(pCsr, pToken, pTC->iCol);
120237       fts3SegReaderCursorFree(pToken->pSegcsr);
120238       pToken->pSegcsr = 0;
120239     }else{
120240       /* Set nLoad4 to the value of (4^nOther) for the next iteration of the
120241       ** for-loop. Except, limit the value to 2^24 to prevent it from 
120242       ** overflowing the 32-bit integer it is stored in. */
120243       if( ii<12 ) nLoad4 = nLoad4*4;
120244
120245       if( ii==0 || pTC->pPhrase->nToken>1 ){
120246         /* Either this is the cheapest token in the entire query, or it is
120247         ** part of a multi-token phrase. Either way, the entire doclist will
120248         ** (eventually) be loaded into memory. It may as well be now. */
120249         Fts3PhraseToken *pToken = pTC->pToken;
120250         int nList = 0;
120251         char *pList = 0;
120252         rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
120253         assert( rc==SQLCIPHER_OK || pList==0 );
120254         if( rc==SQLCIPHER_OK ){
120255           int nCount;
120256           fts3EvalPhraseMergeToken(pTab, pTC->pPhrase, pTC->iToken,pList,nList);
120257           nCount = fts3DoclistCountDocids(
120258               pTC->pPhrase->doclist.aAll, pTC->pPhrase->doclist.nAll
120259           );
120260           if( ii==0 || nCount<nMinEst ) nMinEst = nCount;
120261         }
120262       }
120263     }
120264     pTC->pToken = 0;
120265   }
120266
120267   return rc;
120268 }
120269
120270 /*
120271 ** This function is called from within the xFilter method. It initializes
120272 ** the full-text query currently stored in pCsr->pExpr. To iterate through
120273 ** the results of a query, the caller does:
120274 **
120275 **    fts3EvalStart(pCsr);
120276 **    while( 1 ){
120277 **      fts3EvalNext(pCsr);
120278 **      if( pCsr->bEof ) break;
120279 **      ... return row pCsr->iPrevId to the caller ...
120280 **    }
120281 */
120282 static int fts3EvalStart(Fts3Cursor *pCsr){
120283   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120284   int rc = SQLCIPHER_OK;
120285   int nToken = 0;
120286   int nOr = 0;
120287
120288   /* Allocate a MultiSegReader for each token in the expression. */
120289   fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
120290
120291   /* Determine which, if any, tokens in the expression should be deferred. */
120292   if( rc==SQLCIPHER_OK && nToken>1 && pTab->bHasStat ){
120293     Fts3TokenAndCost *aTC;
120294     Fts3Expr **apOr;
120295     aTC = (Fts3TokenAndCost *)sqlcipher3_malloc(
120296         sizeof(Fts3TokenAndCost) * nToken
120297       + sizeof(Fts3Expr *) * nOr * 2
120298     );
120299     apOr = (Fts3Expr **)&aTC[nToken];
120300
120301     if( !aTC ){
120302       rc = SQLCIPHER_NOMEM;
120303     }else{
120304       int ii;
120305       Fts3TokenAndCost *pTC = aTC;
120306       Fts3Expr **ppOr = apOr;
120307
120308       fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
120309       nToken = pTC-aTC;
120310       nOr = ppOr-apOr;
120311
120312       if( rc==SQLCIPHER_OK ){
120313         rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken);
120314         for(ii=0; rc==SQLCIPHER_OK && ii<nOr; ii++){
120315           rc = fts3EvalSelectDeferred(pCsr, apOr[ii], aTC, nToken);
120316         }
120317       }
120318
120319       sqlcipher3_free(aTC);
120320     }
120321   }
120322
120323   fts3EvalStartReaders(pCsr, pCsr->pExpr, 1, &rc);
120324   return rc;
120325 }
120326
120327 /*
120328 ** Invalidate the current position list for phrase pPhrase.
120329 */
120330 static void fts3EvalInvalidatePoslist(Fts3Phrase *pPhrase){
120331   if( pPhrase->doclist.bFreeList ){
120332     sqlcipher3_free(pPhrase->doclist.pList);
120333   }
120334   pPhrase->doclist.pList = 0;
120335   pPhrase->doclist.nList = 0;
120336   pPhrase->doclist.bFreeList = 0;
120337 }
120338
120339 /*
120340 ** This function is called to edit the position list associated with
120341 ** the phrase object passed as the fifth argument according to a NEAR
120342 ** condition. For example:
120343 **
120344 **     abc NEAR/5 "def ghi"
120345 **
120346 ** Parameter nNear is passed the NEAR distance of the expression (5 in
120347 ** the example above). When this function is called, *paPoslist points to
120348 ** the position list, and *pnToken is the number of phrase tokens in, the
120349 ** phrase on the other side of the NEAR operator to pPhrase. For example,
120350 ** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to
120351 ** the position list associated with phrase "abc".
120352 **
120353 ** All positions in the pPhrase position list that are not sufficiently
120354 ** close to a position in the *paPoslist position list are removed. If this
120355 ** leaves 0 positions, zero is returned. Otherwise, non-zero.
120356 **
120357 ** Before returning, *paPoslist is set to point to the position lsit 
120358 ** associated with pPhrase. And *pnToken is set to the number of tokens in
120359 ** pPhrase.
120360 */
120361 static int fts3EvalNearTrim(
120362   int nNear,                      /* NEAR distance. As in "NEAR/nNear". */
120363   char *aTmp,                     /* Temporary space to use */
120364   char **paPoslist,               /* IN/OUT: Position list */
120365   int *pnToken,                   /* IN/OUT: Tokens in phrase of *paPoslist */
120366   Fts3Phrase *pPhrase             /* The phrase object to trim the doclist of */
120367 ){
120368   int nParam1 = nNear + pPhrase->nToken;
120369   int nParam2 = nNear + *pnToken;
120370   int nNew;
120371   char *p2; 
120372   char *pOut; 
120373   int res;
120374
120375   assert( pPhrase->doclist.pList );
120376
120377   p2 = pOut = pPhrase->doclist.pList;
120378   res = fts3PoslistNearMerge(
120379     &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
120380   );
120381   if( res ){
120382     nNew = (pOut - pPhrase->doclist.pList) - 1;
120383     assert( pPhrase->doclist.pList[nNew]=='\0' );
120384     assert( nNew<=pPhrase->doclist.nList && nNew>0 );
120385     memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
120386     pPhrase->doclist.nList = nNew;
120387     *paPoslist = pPhrase->doclist.pList;
120388     *pnToken = pPhrase->nToken;
120389   }
120390
120391   return res;
120392 }
120393
120394 /*
120395 ** This function is a no-op if *pRc is other than SQLCIPHER_OK when it is called.
120396 ** Otherwise, it advances the expression passed as the second argument to
120397 ** point to the next matching row in the database. Expressions iterate through
120398 ** matching rows in docid order. Ascending order if Fts3Cursor.bDesc is zero,
120399 ** or descending if it is non-zero.
120400 **
120401 ** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if
120402 ** successful, the following variables in pExpr are set:
120403 **
120404 **   Fts3Expr.bEof                (non-zero if EOF - there is no next row)
120405 **   Fts3Expr.iDocid              (valid if bEof==0. The docid of the next row)
120406 **
120407 ** If the expression is of type FTSQUERY_PHRASE, and the expression is not
120408 ** at EOF, then the following variables are populated with the position list
120409 ** for the phrase for the visited row:
120410 **
120411 **   FTs3Expr.pPhrase->doclist.nList        (length of pList in bytes)
120412 **   FTs3Expr.pPhrase->doclist.pList        (pointer to position list)
120413 **
120414 ** It says above that this function advances the expression to the next
120415 ** matching row. This is usually true, but there are the following exceptions:
120416 **
120417 **   1. Deferred tokens are not taken into account. If a phrase consists
120418 **      entirely of deferred tokens, it is assumed to match every row in
120419 **      the db. In this case the position-list is not populated at all. 
120420 **
120421 **      Or, if a phrase contains one or more deferred tokens and one or
120422 **      more non-deferred tokens, then the expression is advanced to the 
120423 **      next possible match, considering only non-deferred tokens. In other
120424 **      words, if the phrase is "A B C", and "B" is deferred, the expression
120425 **      is advanced to the next row that contains an instance of "A * C", 
120426 **      where "*" may match any single token. The position list in this case
120427 **      is populated as for "A * C" before returning.
120428 **
120429 **   2. NEAR is treated as AND. If the expression is "x NEAR y", it is 
120430 **      advanced to point to the next row that matches "x AND y".
120431 ** 
120432 ** See fts3EvalTestDeferredAndNear() for details on testing if a row is
120433 ** really a match, taking into account deferred tokens and NEAR operators.
120434 */
120435 static void fts3EvalNextRow(
120436   Fts3Cursor *pCsr,               /* FTS Cursor handle */
120437   Fts3Expr *pExpr,                /* Expr. to advance to next matching row */
120438   int *pRc                        /* IN/OUT: Error code */
120439 ){
120440   if( *pRc==SQLCIPHER_OK ){
120441     int bDescDoclist = pCsr->bDesc;         /* Used by DOCID_CMP() macro */
120442     assert( pExpr->bEof==0 );
120443     pExpr->bStart = 1;
120444
120445     switch( pExpr->eType ){
120446       case FTSQUERY_NEAR:
120447       case FTSQUERY_AND: {
120448         Fts3Expr *pLeft = pExpr->pLeft;
120449         Fts3Expr *pRight = pExpr->pRight;
120450         assert( !pLeft->bDeferred || !pRight->bDeferred );
120451
120452         if( pLeft->bDeferred ){
120453           /* LHS is entirely deferred. So we assume it matches every row.
120454           ** Advance the RHS iterator to find the next row visited. */
120455           fts3EvalNextRow(pCsr, pRight, pRc);
120456           pExpr->iDocid = pRight->iDocid;
120457           pExpr->bEof = pRight->bEof;
120458         }else if( pRight->bDeferred ){
120459           /* RHS is entirely deferred. So we assume it matches every row.
120460           ** Advance the LHS iterator to find the next row visited. */
120461           fts3EvalNextRow(pCsr, pLeft, pRc);
120462           pExpr->iDocid = pLeft->iDocid;
120463           pExpr->bEof = pLeft->bEof;
120464         }else{
120465           /* Neither the RHS or LHS are deferred. */
120466           fts3EvalNextRow(pCsr, pLeft, pRc);
120467           fts3EvalNextRow(pCsr, pRight, pRc);
120468           while( !pLeft->bEof && !pRight->bEof && *pRc==SQLCIPHER_OK ){
120469             sqlcipher3_int64 iDiff = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
120470             if( iDiff==0 ) break;
120471             if( iDiff<0 ){
120472               fts3EvalNextRow(pCsr, pLeft, pRc);
120473             }else{
120474               fts3EvalNextRow(pCsr, pRight, pRc);
120475             }
120476           }
120477           pExpr->iDocid = pLeft->iDocid;
120478           pExpr->bEof = (pLeft->bEof || pRight->bEof);
120479         }
120480         break;
120481       }
120482   
120483       case FTSQUERY_OR: {
120484         Fts3Expr *pLeft = pExpr->pLeft;
120485         Fts3Expr *pRight = pExpr->pRight;
120486         sqlcipher3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
120487
120488         assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
120489         assert( pRight->bStart || pLeft->iDocid==pRight->iDocid );
120490
120491         if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){
120492           fts3EvalNextRow(pCsr, pLeft, pRc);
120493         }else if( pLeft->bEof || (pRight->bEof==0 && iCmp>0) ){
120494           fts3EvalNextRow(pCsr, pRight, pRc);
120495         }else{
120496           fts3EvalNextRow(pCsr, pLeft, pRc);
120497           fts3EvalNextRow(pCsr, pRight, pRc);
120498         }
120499
120500         pExpr->bEof = (pLeft->bEof && pRight->bEof);
120501         iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
120502         if( pRight->bEof || (pLeft->bEof==0 &&  iCmp<0) ){
120503           pExpr->iDocid = pLeft->iDocid;
120504         }else{
120505           pExpr->iDocid = pRight->iDocid;
120506         }
120507
120508         break;
120509       }
120510
120511       case FTSQUERY_NOT: {
120512         Fts3Expr *pLeft = pExpr->pLeft;
120513         Fts3Expr *pRight = pExpr->pRight;
120514
120515         if( pRight->bStart==0 ){
120516           fts3EvalNextRow(pCsr, pRight, pRc);
120517           assert( *pRc!=SQLCIPHER_OK || pRight->bStart );
120518         }
120519
120520         fts3EvalNextRow(pCsr, pLeft, pRc);
120521         if( pLeft->bEof==0 ){
120522           while( !*pRc 
120523               && !pRight->bEof 
120524               && DOCID_CMP(pLeft->iDocid, pRight->iDocid)>0 
120525           ){
120526             fts3EvalNextRow(pCsr, pRight, pRc);
120527           }
120528         }
120529         pExpr->iDocid = pLeft->iDocid;
120530         pExpr->bEof = pLeft->bEof;
120531         break;
120532       }
120533
120534       default: {
120535         Fts3Phrase *pPhrase = pExpr->pPhrase;
120536         fts3EvalInvalidatePoslist(pPhrase);
120537         *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
120538         pExpr->iDocid = pPhrase->doclist.iDocid;
120539         break;
120540       }
120541     }
120542   }
120543 }
120544
120545 /*
120546 ** If *pRc is not SQLCIPHER_OK, or if pExpr is not the root node of a NEAR
120547 ** cluster, then this function returns 1 immediately.
120548 **
120549 ** Otherwise, it checks if the current row really does match the NEAR 
120550 ** expression, using the data currently stored in the position lists 
120551 ** (Fts3Expr->pPhrase.doclist.pList/nList) for each phrase in the expression. 
120552 **
120553 ** If the current row is a match, the position list associated with each
120554 ** phrase in the NEAR expression is edited in place to contain only those
120555 ** phrase instances sufficiently close to their peers to satisfy all NEAR
120556 ** constraints. In this case it returns 1. If the NEAR expression does not 
120557 ** match the current row, 0 is returned. The position lists may or may not
120558 ** be edited if 0 is returned.
120559 */
120560 static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
120561   int res = 1;
120562
120563   /* The following block runs if pExpr is the root of a NEAR query.
120564   ** For example, the query:
120565   **
120566   **         "w" NEAR "x" NEAR "y" NEAR "z"
120567   **
120568   ** which is represented in tree form as:
120569   **
120570   **                               |
120571   **                          +--NEAR--+      <-- root of NEAR query
120572   **                          |        |
120573   **                     +--NEAR--+   "z"
120574   **                     |        |
120575   **                +--NEAR--+   "y"
120576   **                |        |
120577   **               "w"      "x"
120578   **
120579   ** The right-hand child of a NEAR node is always a phrase. The 
120580   ** left-hand child may be either a phrase or a NEAR node. There are
120581   ** no exceptions to this - it's the way the parser in fts3_expr.c works.
120582   */
120583   if( *pRc==SQLCIPHER_OK 
120584    && pExpr->eType==FTSQUERY_NEAR 
120585    && pExpr->bEof==0
120586    && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
120587   ){
120588     Fts3Expr *p; 
120589     int nTmp = 0;                 /* Bytes of temp space */
120590     char *aTmp;                   /* Temp space for PoslistNearMerge() */
120591
120592     /* Allocate temporary working space. */
120593     for(p=pExpr; p->pLeft; p=p->pLeft){
120594       nTmp += p->pRight->pPhrase->doclist.nList;
120595     }
120596     nTmp += p->pPhrase->doclist.nList;
120597     aTmp = sqlcipher3_malloc(nTmp*2);
120598     if( !aTmp ){
120599       *pRc = SQLCIPHER_NOMEM;
120600       res = 0;
120601     }else{
120602       char *aPoslist = p->pPhrase->doclist.pList;
120603       int nToken = p->pPhrase->nToken;
120604
120605       for(p=p->pParent;res && p && p->eType==FTSQUERY_NEAR; p=p->pParent){
120606         Fts3Phrase *pPhrase = p->pRight->pPhrase;
120607         int nNear = p->nNear;
120608         res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase);
120609       }
120610   
120611       aPoslist = pExpr->pRight->pPhrase->doclist.pList;
120612       nToken = pExpr->pRight->pPhrase->nToken;
120613       for(p=pExpr->pLeft; p && res; p=p->pLeft){
120614         int nNear;
120615         Fts3Phrase *pPhrase;
120616         assert( p->pParent && p->pParent->pLeft==p );
120617         nNear = p->pParent->nNear;
120618         pPhrase = (
120619             p->eType==FTSQUERY_NEAR ? p->pRight->pPhrase : p->pPhrase
120620         );
120621         res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase);
120622       }
120623     }
120624
120625     sqlcipher3_free(aTmp);
120626   }
120627
120628   return res;
120629 }
120630
120631 /*
120632 ** This function is a helper function for fts3EvalTestDeferredAndNear().
120633 ** Assuming no error occurs or has occurred, It returns non-zero if the
120634 ** expression passed as the second argument matches the row that pCsr 
120635 ** currently points to, or zero if it does not.
120636 **
120637 ** If *pRc is not SQLCIPHER_OK when this function is called, it is a no-op.
120638 ** If an error occurs during execution of this function, *pRc is set to 
120639 ** the appropriate SQLite error code. In this case the returned value is 
120640 ** undefined.
120641 */
120642 static int fts3EvalTestExpr(
120643   Fts3Cursor *pCsr,               /* FTS cursor handle */
120644   Fts3Expr *pExpr,                /* Expr to test. May or may not be root. */
120645   int *pRc                        /* IN/OUT: Error code */
120646 ){
120647   int bHit = 1;                   /* Return value */
120648   if( *pRc==SQLCIPHER_OK ){
120649     switch( pExpr->eType ){
120650       case FTSQUERY_NEAR:
120651       case FTSQUERY_AND:
120652         bHit = (
120653             fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
120654          && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
120655          && fts3EvalNearTest(pExpr, pRc)
120656         );
120657
120658         /* If the NEAR expression does not match any rows, zero the doclist for 
120659         ** all phrases involved in the NEAR. This is because the snippet(),
120660         ** offsets() and matchinfo() functions are not supposed to recognize 
120661         ** any instances of phrases that are part of unmatched NEAR queries. 
120662         ** For example if this expression:
120663         **
120664         **    ... MATCH 'a OR (b NEAR c)'
120665         **
120666         ** is matched against a row containing:
120667         **
120668         **        'a b d e'
120669         **
120670         ** then any snippet() should ony highlight the "a" term, not the "b"
120671         ** (as "b" is part of a non-matching NEAR clause).
120672         */
120673         if( bHit==0 
120674          && pExpr->eType==FTSQUERY_NEAR 
120675          && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
120676         ){
120677           Fts3Expr *p;
120678           for(p=pExpr; p->pPhrase==0; p=p->pLeft){
120679             if( p->pRight->iDocid==pCsr->iPrevId ){
120680               fts3EvalInvalidatePoslist(p->pRight->pPhrase);
120681             }
120682           }
120683           if( p->iDocid==pCsr->iPrevId ){
120684             fts3EvalInvalidatePoslist(p->pPhrase);
120685           }
120686         }
120687
120688         break;
120689
120690       case FTSQUERY_OR: {
120691         int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
120692         int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
120693         bHit = bHit1 || bHit2;
120694         break;
120695       }
120696
120697       case FTSQUERY_NOT:
120698         bHit = (
120699             fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
120700          && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
120701         );
120702         break;
120703
120704       default: {
120705         if( pCsr->pDeferred 
120706          && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred)
120707         ){
120708           Fts3Phrase *pPhrase = pExpr->pPhrase;
120709           assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
120710           if( pExpr->bDeferred ){
120711             fts3EvalInvalidatePoslist(pPhrase);
120712           }
120713           *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase);
120714           bHit = (pPhrase->doclist.pList!=0);
120715           pExpr->iDocid = pCsr->iPrevId;
120716         }else{
120717           bHit = (pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId);
120718         }
120719         break;
120720       }
120721     }
120722   }
120723   return bHit;
120724 }
120725
120726 /*
120727 ** This function is called as the second part of each xNext operation when
120728 ** iterating through the results of a full-text query. At this point the
120729 ** cursor points to a row that matches the query expression, with the
120730 ** following caveats:
120731 **
120732 **   * Up until this point, "NEAR" operators in the expression have been
120733 **     treated as "AND".
120734 **
120735 **   * Deferred tokens have not yet been considered.
120736 **
120737 ** If *pRc is not SQLCIPHER_OK when this function is called, it immediately
120738 ** returns 0. Otherwise, it tests whether or not after considering NEAR
120739 ** operators and deferred tokens the current row is still a match for the
120740 ** expression. It returns 1 if both of the following are true:
120741 **
120742 **   1. *pRc is SQLCIPHER_OK when this function returns, and
120743 **
120744 **   2. After scanning the current FTS table row for the deferred tokens,
120745 **      it is determined that the row does *not* match the query.
120746 **
120747 ** Or, if no error occurs and it seems the current row does match the FTS
120748 ** query, return 0.
120749 */
120750 static int fts3EvalTestDeferredAndNear(Fts3Cursor *pCsr, int *pRc){
120751   int rc = *pRc;
120752   int bMiss = 0;
120753   if( rc==SQLCIPHER_OK ){
120754
120755     /* If there are one or more deferred tokens, load the current row into
120756     ** memory and scan it to determine the position list for each deferred
120757     ** token. Then, see if this row is really a match, considering deferred
120758     ** tokens and NEAR operators (neither of which were taken into account
120759     ** earlier, by fts3EvalNextRow()). 
120760     */
120761     if( pCsr->pDeferred ){
120762       rc = fts3CursorSeek(0, pCsr);
120763       if( rc==SQLCIPHER_OK ){
120764         rc = sqlcipher3Fts3CacheDeferredDoclists(pCsr);
120765       }
120766     }
120767     bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
120768
120769     /* Free the position-lists accumulated for each deferred token above. */
120770     sqlcipher3Fts3FreeDeferredDoclists(pCsr);
120771     *pRc = rc;
120772   }
120773   return (rc==SQLCIPHER_OK && bMiss);
120774 }
120775
120776 /*
120777 ** Advance to the next document that matches the FTS expression in
120778 ** Fts3Cursor.pExpr.
120779 */
120780 static int fts3EvalNext(Fts3Cursor *pCsr){
120781   int rc = SQLCIPHER_OK;             /* Return Code */
120782   Fts3Expr *pExpr = pCsr->pExpr;
120783   assert( pCsr->isEof==0 );
120784   if( pExpr==0 ){
120785     pCsr->isEof = 1;
120786   }else{
120787     do {
120788       if( pCsr->isRequireSeek==0 ){
120789         sqlcipher3_reset(pCsr->pStmt);
120790       }
120791       assert( sqlcipher3_data_count(pCsr->pStmt)==0 );
120792       fts3EvalNextRow(pCsr, pExpr, &rc);
120793       pCsr->isEof = pExpr->bEof;
120794       pCsr->isRequireSeek = 1;
120795       pCsr->isMatchinfoNeeded = 1;
120796       pCsr->iPrevId = pExpr->iDocid;
120797     }while( pCsr->isEof==0 && fts3EvalTestDeferredAndNear(pCsr, &rc) );
120798   }
120799   return rc;
120800 }
120801
120802 /*
120803 ** Restart interation for expression pExpr so that the next call to
120804 ** fts3EvalNext() visits the first row. Do not allow incremental 
120805 ** loading or merging of phrase doclists for this iteration.
120806 **
120807 ** If *pRc is other than SQLCIPHER_OK when this function is called, it is
120808 ** a no-op. If an error occurs within this function, *pRc is set to an
120809 ** SQLite error code before returning.
120810 */
120811 static void fts3EvalRestart(
120812   Fts3Cursor *pCsr,
120813   Fts3Expr *pExpr,
120814   int *pRc
120815 ){
120816   if( pExpr && *pRc==SQLCIPHER_OK ){
120817     Fts3Phrase *pPhrase = pExpr->pPhrase;
120818
120819     if( pPhrase ){
120820       fts3EvalInvalidatePoslist(pPhrase);
120821       if( pPhrase->bIncr ){
120822         assert( pPhrase->nToken==1 );
120823         assert( pPhrase->aToken[0].pSegcsr );
120824         sqlcipher3Fts3MsrIncrRestart(pPhrase->aToken[0].pSegcsr);
120825         *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase);
120826       }
120827
120828       pPhrase->doclist.pNextDocid = 0;
120829       pPhrase->doclist.iDocid = 0;
120830     }
120831
120832     pExpr->iDocid = 0;
120833     pExpr->bEof = 0;
120834     pExpr->bStart = 0;
120835
120836     fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
120837     fts3EvalRestart(pCsr, pExpr->pRight, pRc);
120838   }
120839 }
120840
120841 /*
120842 ** After allocating the Fts3Expr.aMI[] array for each phrase in the 
120843 ** expression rooted at pExpr, the cursor iterates through all rows matched
120844 ** by pExpr, calling this function for each row. This function increments
120845 ** the values in Fts3Expr.aMI[] according to the position-list currently
120846 ** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase 
120847 ** expression nodes.
120848 */
120849 static void fts3EvalUpdateCounts(Fts3Expr *pExpr){
120850   if( pExpr ){
120851     Fts3Phrase *pPhrase = pExpr->pPhrase;
120852     if( pPhrase && pPhrase->doclist.pList ){
120853       int iCol = 0;
120854       char *p = pPhrase->doclist.pList;
120855
120856       assert( *p );
120857       while( 1 ){
120858         u8 c = 0;
120859         int iCnt = 0;
120860         while( 0xFE & (*p | c) ){
120861           if( (c&0x80)==0 ) iCnt++;
120862           c = *p++ & 0x80;
120863         }
120864
120865         /* aMI[iCol*3 + 1] = Number of occurrences
120866         ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
120867         */
120868         pExpr->aMI[iCol*3 + 1] += iCnt;
120869         pExpr->aMI[iCol*3 + 2] += (iCnt>0);
120870         if( *p==0x00 ) break;
120871         p++;
120872         p += sqlcipher3Fts3GetVarint32(p, &iCol);
120873       }
120874     }
120875
120876     fts3EvalUpdateCounts(pExpr->pLeft);
120877     fts3EvalUpdateCounts(pExpr->pRight);
120878   }
120879 }
120880
120881 /*
120882 ** Expression pExpr must be of type FTSQUERY_PHRASE.
120883 **
120884 ** If it is not already allocated and populated, this function allocates and
120885 ** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part
120886 ** of a NEAR expression, then it also allocates and populates the same array
120887 ** for all other phrases that are part of the NEAR expression.
120888 **
120889 ** SQLCIPHER_OK is returned if the aMI[] array is successfully allocated and
120890 ** populated. Otherwise, if an error occurs, an SQLite error code is returned.
120891 */
120892 static int fts3EvalGatherStats(
120893   Fts3Cursor *pCsr,               /* Cursor object */
120894   Fts3Expr *pExpr                 /* FTSQUERY_PHRASE expression */
120895 ){
120896   int rc = SQLCIPHER_OK;             /* Return code */
120897
120898   assert( pExpr->eType==FTSQUERY_PHRASE );
120899   if( pExpr->aMI==0 ){
120900     Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120901     Fts3Expr *pRoot;                /* Root of NEAR expression */
120902     Fts3Expr *p;                    /* Iterator used for several purposes */
120903
120904     sqlcipher3_int64 iPrevId = pCsr->iPrevId;
120905     sqlcipher3_int64 iDocid;
120906     u8 bEof;
120907
120908     /* Find the root of the NEAR expression */
120909     pRoot = pExpr;
120910     while( pRoot->pParent && pRoot->pParent->eType==FTSQUERY_NEAR ){
120911       pRoot = pRoot->pParent;
120912     }
120913     iDocid = pRoot->iDocid;
120914     bEof = pRoot->bEof;
120915     assert( pRoot->bStart );
120916
120917     /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */
120918     for(p=pRoot; p; p=p->pLeft){
120919       Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight);
120920       assert( pE->aMI==0 );
120921       pE->aMI = (u32 *)sqlcipher3_malloc(pTab->nColumn * 3 * sizeof(u32));
120922       if( !pE->aMI ) return SQLCIPHER_NOMEM;
120923       memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
120924     }
120925
120926     fts3EvalRestart(pCsr, pRoot, &rc);
120927
120928     while( pCsr->isEof==0 && rc==SQLCIPHER_OK ){
120929
120930       do {
120931         /* Ensure the %_content statement is reset. */
120932         if( pCsr->isRequireSeek==0 ) sqlcipher3_reset(pCsr->pStmt);
120933         assert( sqlcipher3_data_count(pCsr->pStmt)==0 );
120934
120935         /* Advance to the next document */
120936         fts3EvalNextRow(pCsr, pRoot, &rc);
120937         pCsr->isEof = pRoot->bEof;
120938         pCsr->isRequireSeek = 1;
120939         pCsr->isMatchinfoNeeded = 1;
120940         pCsr->iPrevId = pRoot->iDocid;
120941       }while( pCsr->isEof==0 
120942            && pRoot->eType==FTSQUERY_NEAR 
120943            && fts3EvalTestDeferredAndNear(pCsr, &rc) 
120944       );
120945
120946       if( rc==SQLCIPHER_OK && pCsr->isEof==0 ){
120947         fts3EvalUpdateCounts(pRoot);
120948       }
120949     }
120950
120951     pCsr->isEof = 0;
120952     pCsr->iPrevId = iPrevId;
120953
120954     if( bEof ){
120955       pRoot->bEof = bEof;
120956     }else{
120957       /* Caution: pRoot may iterate through docids in ascending or descending
120958       ** order. For this reason, even though it seems more defensive, the 
120959       ** do loop can not be written:
120960       **
120961       **   do {...} while( pRoot->iDocid<iDocid && rc==SQLCIPHER_OK );
120962       */
120963       fts3EvalRestart(pCsr, pRoot, &rc);
120964       do {
120965         fts3EvalNextRow(pCsr, pRoot, &rc);
120966         assert( pRoot->bEof==0 );
120967       }while( pRoot->iDocid!=iDocid && rc==SQLCIPHER_OK );
120968       fts3EvalTestDeferredAndNear(pCsr, &rc);
120969     }
120970   }
120971   return rc;
120972 }
120973
120974 /*
120975 ** This function is used by the matchinfo() module to query a phrase 
120976 ** expression node for the following information:
120977 **
120978 **   1. The total number of occurrences of the phrase in each column of 
120979 **      the FTS table (considering all rows), and
120980 **
120981 **   2. For each column, the number of rows in the table for which the
120982 **      column contains at least one instance of the phrase.
120983 **
120984 ** If no error occurs, SQLCIPHER_OK is returned and the values for each column
120985 ** written into the array aiOut as follows:
120986 **
120987 **   aiOut[iCol*3 + 1] = Number of occurrences
120988 **   aiOut[iCol*3 + 2] = Number of rows containing at least one instance
120989 **
120990 ** Caveats:
120991 **
120992 **   * If a phrase consists entirely of deferred tokens, then all output 
120993 **     values are set to the number of documents in the table. In other
120994 **     words we assume that very common tokens occur exactly once in each 
120995 **     column of each row of the table.
120996 **
120997 **   * If a phrase contains some deferred tokens (and some non-deferred 
120998 **     tokens), count the potential occurrence identified by considering
120999 **     the non-deferred tokens instead of actual phrase occurrences.
121000 **
121001 **   * If the phrase is part of a NEAR expression, then only phrase instances
121002 **     that meet the NEAR constraint are included in the counts.
121003 */
121004 SQLCIPHER_PRIVATE int sqlcipher3Fts3EvalPhraseStats(
121005   Fts3Cursor *pCsr,               /* FTS cursor handle */
121006   Fts3Expr *pExpr,                /* Phrase expression */
121007   u32 *aiOut                      /* Array to write results into (see above) */
121008 ){
121009   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
121010   int rc = SQLCIPHER_OK;
121011   int iCol;
121012
121013   if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
121014     assert( pCsr->nDoc>0 );
121015     for(iCol=0; iCol<pTab->nColumn; iCol++){
121016       aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
121017       aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
121018     }
121019   }else{
121020     rc = fts3EvalGatherStats(pCsr, pExpr);
121021     if( rc==SQLCIPHER_OK ){
121022       assert( pExpr->aMI );
121023       for(iCol=0; iCol<pTab->nColumn; iCol++){
121024         aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
121025         aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
121026       }
121027     }
121028   }
121029
121030   return rc;
121031 }
121032
121033 /*
121034 ** The expression pExpr passed as the second argument to this function
121035 ** must be of type FTSQUERY_PHRASE. 
121036 **
121037 ** The returned value is either NULL or a pointer to a buffer containing
121038 ** a position-list indicating the occurrences of the phrase in column iCol
121039 ** of the current row. 
121040 **
121041 ** More specifically, the returned buffer contains 1 varint for each 
121042 ** occurence of the phrase in the column, stored using the normal (delta+2) 
121043 ** compression and is terminated by either an 0x01 or 0x00 byte. For example,
121044 ** if the requested column contains "a b X c d X X" and the position-list
121045 ** for 'X' is requested, the buffer returned may contain:
121046 **
121047 **     0x04 0x05 0x03 0x01   or   0x04 0x05 0x03 0x00
121048 **
121049 ** This function works regardless of whether or not the phrase is deferred,
121050 ** incremental, or neither.
121051 */
121052 SQLCIPHER_PRIVATE char *sqlcipher3Fts3EvalPhrasePoslist(
121053   Fts3Cursor *pCsr,               /* FTS3 cursor object */
121054   Fts3Expr *pExpr,                /* Phrase to return doclist for */
121055   int iCol                        /* Column to return position list for */
121056 ){
121057   Fts3Phrase *pPhrase = pExpr->pPhrase;
121058   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
121059   char *pIter = pPhrase->doclist.pList;
121060   int iThis;
121061
121062   assert( iCol>=0 && iCol<pTab->nColumn );
121063   if( !pIter 
121064    || pExpr->bEof 
121065    || pExpr->iDocid!=pCsr->iPrevId
121066    || (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) 
121067   ){
121068     return 0;
121069   }
121070
121071   assert( pPhrase->doclist.nList>0 );
121072   if( *pIter==0x01 ){
121073     pIter++;
121074     pIter += sqlcipher3Fts3GetVarint32(pIter, &iThis);
121075   }else{
121076     iThis = 0;
121077   }
121078   while( iThis<iCol ){
121079     fts3ColumnlistCopy(0, &pIter);
121080     if( *pIter==0x00 ) return 0;
121081     pIter++;
121082     pIter += sqlcipher3Fts3GetVarint32(pIter, &iThis);
121083   }
121084
121085   return ((iCol==iThis)?pIter:0);
121086 }
121087
121088 /*
121089 ** Free all components of the Fts3Phrase structure that were allocated by
121090 ** the eval module. Specifically, this means to free:
121091 **
121092 **   * the contents of pPhrase->doclist, and
121093 **   * any Fts3MultiSegReader objects held by phrase tokens.
121094 */
121095 SQLCIPHER_PRIVATE void sqlcipher3Fts3EvalPhraseCleanup(Fts3Phrase *pPhrase){
121096   if( pPhrase ){
121097     int i;
121098     sqlcipher3_free(pPhrase->doclist.aAll);
121099     fts3EvalInvalidatePoslist(pPhrase);
121100     memset(&pPhrase->doclist, 0, sizeof(Fts3Doclist));
121101     for(i=0; i<pPhrase->nToken; i++){
121102       fts3SegReaderCursorFree(pPhrase->aToken[i].pSegcsr);
121103       pPhrase->aToken[i].pSegcsr = 0;
121104     }
121105   }
121106 }
121107
121108 /*
121109 ** Return SQLCIPHER_CORRUPT_VTAB.
121110 */
121111 #ifdef SQLCIPHER_DEBUG
121112 SQLCIPHER_PRIVATE int sqlcipher3Fts3Corrupt(){
121113   return SQLCIPHER_CORRUPT_VTAB;
121114 }
121115 #endif
121116
121117 #if !SQLCIPHER_CORE
121118 /*
121119 ** Initialize API pointer table, if required.
121120 */
121121 SQLCIPHER_API int sqlcipher3_extension_init(
121122   sqlcipher3 *db, 
121123   char **pzErrMsg,
121124   const sqlcipher3_api_routines *pApi
121125 ){
121126   SQLCIPHER_EXTENSION_INIT2(pApi)
121127   return sqlcipher3Fts3Init(db);
121128 }
121129 #endif
121130
121131 #endif
121132
121133 /************** End of fts3.c ************************************************/
121134 /************** Begin file fts3_aux.c ****************************************/
121135 /*
121136 ** 2011 Jan 27
121137 **
121138 ** The author disclaims copyright to this source code.  In place of
121139 ** a legal notice, here is a blessing:
121140 **
121141 **    May you do good and not evil.
121142 **    May you find forgiveness for yourself and forgive others.
121143 **    May you share freely, never taking more than you give.
121144 **
121145 ******************************************************************************
121146 **
121147 */
121148 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
121149
121150 /* #include <string.h> */
121151 /* #include <assert.h> */
121152
121153 typedef struct Fts3auxTable Fts3auxTable;
121154 typedef struct Fts3auxCursor Fts3auxCursor;
121155
121156 struct Fts3auxTable {
121157   sqlcipher3_vtab base;              /* Base class used by SQLite core */
121158   Fts3Table *pFts3Tab;
121159 };
121160
121161 struct Fts3auxCursor {
121162   sqlcipher3_vtab_cursor base;       /* Base class used by SQLite core */
121163   Fts3MultiSegReader csr;        /* Must be right after "base" */
121164   Fts3SegFilter filter;
121165   char *zStop;
121166   int nStop;                      /* Byte-length of string zStop */
121167   int isEof;                      /* True if cursor is at EOF */
121168   sqlcipher3_int64 iRowid;           /* Current rowid */
121169
121170   int iCol;                       /* Current value of 'col' column */
121171   int nStat;                      /* Size of aStat[] array */
121172   struct Fts3auxColstats {
121173     sqlcipher3_int64 nDoc;           /* 'documents' values for current csr row */
121174     sqlcipher3_int64 nOcc;           /* 'occurrences' values for current csr row */
121175   } *aStat;
121176 };
121177
121178 /*
121179 ** Schema of the terms table.
121180 */
121181 #define FTS3_TERMS_SCHEMA "CREATE TABLE x(term, col, documents, occurrences)"
121182
121183 /*
121184 ** This function does all the work for both the xConnect and xCreate methods.
121185 ** These tables have no persistent representation of their own, so xConnect
121186 ** and xCreate are identical operations.
121187 */
121188 static int fts3auxConnectMethod(
121189   sqlcipher3 *db,                    /* Database connection */
121190   void *pUnused,                  /* Unused */
121191   int argc,                       /* Number of elements in argv array */
121192   const char * const *argv,       /* xCreate/xConnect argument array */
121193   sqlcipher3_vtab **ppVtab,          /* OUT: New sqlcipher3_vtab object */
121194   char **pzErr                    /* OUT: sqlcipher3_malloc'd error message */
121195 ){
121196   char const *zDb;                /* Name of database (e.g. "main") */
121197   char const *zFts3;              /* Name of fts3 table */
121198   int nDb;                        /* Result of strlen(zDb) */
121199   int nFts3;                      /* Result of strlen(zFts3) */
121200   int nByte;                      /* Bytes of space to allocate here */
121201   int rc;                         /* value returned by declare_vtab() */
121202   Fts3auxTable *p;                /* Virtual table object to return */
121203
121204   UNUSED_PARAMETER(pUnused);
121205
121206   /* The user should specify a single argument - the name of an fts3 table. */
121207   if( argc!=4 ){
121208     *pzErr = sqlcipher3_mprintf(
121209         "wrong number of arguments to fts4aux constructor"
121210     );
121211     return SQLCIPHER_ERROR;
121212   }
121213
121214   zDb = argv[1]; 
121215   nDb = strlen(zDb);
121216   zFts3 = argv[3];
121217   nFts3 = strlen(zFts3);
121218
121219   rc = sqlcipher3_declare_vtab(db, FTS3_TERMS_SCHEMA);
121220   if( rc!=SQLCIPHER_OK ) return rc;
121221
121222   nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
121223   p = (Fts3auxTable *)sqlcipher3_malloc(nByte);
121224   if( !p ) return SQLCIPHER_NOMEM;
121225   memset(p, 0, nByte);
121226
121227   p->pFts3Tab = (Fts3Table *)&p[1];
121228   p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
121229   p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
121230   p->pFts3Tab->db = db;
121231   p->pFts3Tab->nIndex = 1;
121232
121233   memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
121234   memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
121235   sqlcipher3Fts3Dequote((char *)p->pFts3Tab->zName);
121236
121237   *ppVtab = (sqlcipher3_vtab *)p;
121238   return SQLCIPHER_OK;
121239 }
121240
121241 /*
121242 ** This function does the work for both the xDisconnect and xDestroy methods.
121243 ** These tables have no persistent representation of their own, so xDisconnect
121244 ** and xDestroy are identical operations.
121245 */
121246 static int fts3auxDisconnectMethod(sqlcipher3_vtab *pVtab){
121247   Fts3auxTable *p = (Fts3auxTable *)pVtab;
121248   Fts3Table *pFts3 = p->pFts3Tab;
121249   int i;
121250
121251   /* Free any prepared statements held */
121252   for(i=0; i<SizeofArray(pFts3->aStmt); i++){
121253     sqlcipher3_finalize(pFts3->aStmt[i]);
121254   }
121255   sqlcipher3_free(pFts3->zSegmentsTbl);
121256   sqlcipher3_free(p);
121257   return SQLCIPHER_OK;
121258 }
121259
121260 #define FTS4AUX_EQ_CONSTRAINT 1
121261 #define FTS4AUX_GE_CONSTRAINT 2
121262 #define FTS4AUX_LE_CONSTRAINT 4
121263
121264 /*
121265 ** xBestIndex - Analyze a WHERE and ORDER BY clause.
121266 */
121267 static int fts3auxBestIndexMethod(
121268   sqlcipher3_vtab *pVTab, 
121269   sqlcipher3_index_info *pInfo
121270 ){
121271   int i;
121272   int iEq = -1;
121273   int iGe = -1;
121274   int iLe = -1;
121275
121276   UNUSED_PARAMETER(pVTab);
121277
121278   /* This vtab delivers always results in "ORDER BY term ASC" order. */
121279   if( pInfo->nOrderBy==1 
121280    && pInfo->aOrderBy[0].iColumn==0 
121281    && pInfo->aOrderBy[0].desc==0
121282   ){
121283     pInfo->orderByConsumed = 1;
121284   }
121285
121286   /* Search for equality and range constraints on the "term" column. */
121287   for(i=0; i<pInfo->nConstraint; i++){
121288     if( pInfo->aConstraint[i].usable && pInfo->aConstraint[i].iColumn==0 ){
121289       int op = pInfo->aConstraint[i].op;
121290       if( op==SQLCIPHER_INDEX_CONSTRAINT_EQ ) iEq = i;
121291       if( op==SQLCIPHER_INDEX_CONSTRAINT_LT ) iLe = i;
121292       if( op==SQLCIPHER_INDEX_CONSTRAINT_LE ) iLe = i;
121293       if( op==SQLCIPHER_INDEX_CONSTRAINT_GT ) iGe = i;
121294       if( op==SQLCIPHER_INDEX_CONSTRAINT_GE ) iGe = i;
121295     }
121296   }
121297
121298   if( iEq>=0 ){
121299     pInfo->idxNum = FTS4AUX_EQ_CONSTRAINT;
121300     pInfo->aConstraintUsage[iEq].argvIndex = 1;
121301     pInfo->estimatedCost = 5;
121302   }else{
121303     pInfo->idxNum = 0;
121304     pInfo->estimatedCost = 20000;
121305     if( iGe>=0 ){
121306       pInfo->idxNum += FTS4AUX_GE_CONSTRAINT;
121307       pInfo->aConstraintUsage[iGe].argvIndex = 1;
121308       pInfo->estimatedCost /= 2;
121309     }
121310     if( iLe>=0 ){
121311       pInfo->idxNum += FTS4AUX_LE_CONSTRAINT;
121312       pInfo->aConstraintUsage[iLe].argvIndex = 1 + (iGe>=0);
121313       pInfo->estimatedCost /= 2;
121314     }
121315   }
121316
121317   return SQLCIPHER_OK;
121318 }
121319
121320 /*
121321 ** xOpen - Open a cursor.
121322 */
121323 static int fts3auxOpenMethod(sqlcipher3_vtab *pVTab, sqlcipher3_vtab_cursor **ppCsr){
121324   Fts3auxCursor *pCsr;            /* Pointer to cursor object to return */
121325
121326   UNUSED_PARAMETER(pVTab);
121327
121328   pCsr = (Fts3auxCursor *)sqlcipher3_malloc(sizeof(Fts3auxCursor));
121329   if( !pCsr ) return SQLCIPHER_NOMEM;
121330   memset(pCsr, 0, sizeof(Fts3auxCursor));
121331
121332   *ppCsr = (sqlcipher3_vtab_cursor *)pCsr;
121333   return SQLCIPHER_OK;
121334 }
121335
121336 /*
121337 ** xClose - Close a cursor.
121338 */
121339 static int fts3auxCloseMethod(sqlcipher3_vtab_cursor *pCursor){
121340   Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
121341   Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121342
121343   sqlcipher3Fts3SegmentsClose(pFts3);
121344   sqlcipher3Fts3SegReaderFinish(&pCsr->csr);
121345   sqlcipher3_free((void *)pCsr->filter.zTerm);
121346   sqlcipher3_free(pCsr->zStop);
121347   sqlcipher3_free(pCsr->aStat);
121348   sqlcipher3_free(pCsr);
121349   return SQLCIPHER_OK;
121350 }
121351
121352 static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){
121353   if( nSize>pCsr->nStat ){
121354     struct Fts3auxColstats *aNew;
121355     aNew = (struct Fts3auxColstats *)sqlcipher3_realloc(pCsr->aStat, 
121356         sizeof(struct Fts3auxColstats) * nSize
121357     );
121358     if( aNew==0 ) return SQLCIPHER_NOMEM;
121359     memset(&aNew[pCsr->nStat], 0, 
121360         sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)
121361     );
121362     pCsr->aStat = aNew;
121363     pCsr->nStat = nSize;
121364   }
121365   return SQLCIPHER_OK;
121366 }
121367
121368 /*
121369 ** xNext - Advance the cursor to the next row, if any.
121370 */
121371 static int fts3auxNextMethod(sqlcipher3_vtab_cursor *pCursor){
121372   Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121373   Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
121374   int rc;
121375
121376   /* Increment our pretend rowid value. */
121377   pCsr->iRowid++;
121378
121379   for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
121380     if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLCIPHER_OK;
121381   }
121382
121383   rc = sqlcipher3Fts3SegReaderStep(pFts3, &pCsr->csr);
121384   if( rc==SQLCIPHER_ROW ){
121385     int i = 0;
121386     int nDoclist = pCsr->csr.nDoclist;
121387     char *aDoclist = pCsr->csr.aDoclist;
121388     int iCol;
121389
121390     int eState = 0;
121391
121392     if( pCsr->zStop ){
121393       int n = (pCsr->nStop<pCsr->csr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm;
121394       int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
121395       if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){
121396         pCsr->isEof = 1;
121397         return SQLCIPHER_OK;
121398       }
121399     }
121400
121401     if( fts3auxGrowStatArray(pCsr, 2) ) return SQLCIPHER_NOMEM;
121402     memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
121403     iCol = 0;
121404
121405     while( i<nDoclist ){
121406       sqlcipher3_int64 v = 0;
121407
121408       i += sqlcipher3Fts3GetVarint(&aDoclist[i], &v);
121409       switch( eState ){
121410         /* State 0. In this state the integer just read was a docid. */
121411         case 0:
121412           pCsr->aStat[0].nDoc++;
121413           eState = 1;
121414           iCol = 0;
121415           break;
121416
121417         /* State 1. In this state we are expecting either a 1, indicating
121418         ** that the following integer will be a column number, or the
121419         ** start of a position list for column 0.  
121420         ** 
121421         ** The only difference between state 1 and state 2 is that if the
121422         ** integer encountered in state 1 is not 0 or 1, then we need to
121423         ** increment the column 0 "nDoc" count for this term.
121424         */
121425         case 1:
121426           assert( iCol==0 );
121427           if( v>1 ){
121428             pCsr->aStat[1].nDoc++;
121429           }
121430           eState = 2;
121431           /* fall through */
121432
121433         case 2:
121434           if( v==0 ){       /* 0x00. Next integer will be a docid. */
121435             eState = 0;
121436           }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
121437             eState = 3;
121438           }else{            /* 2 or greater. A position. */
121439             pCsr->aStat[iCol+1].nOcc++;
121440             pCsr->aStat[0].nOcc++;
121441           }
121442           break;
121443
121444         /* State 3. The integer just read is a column number. */
121445         default: assert( eState==3 );
121446           iCol = (int)v;
121447           if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLCIPHER_NOMEM;
121448           pCsr->aStat[iCol+1].nDoc++;
121449           eState = 2;
121450           break;
121451       }
121452     }
121453
121454     pCsr->iCol = 0;
121455     rc = SQLCIPHER_OK;
121456   }else{
121457     pCsr->isEof = 1;
121458   }
121459   return rc;
121460 }
121461
121462 /*
121463 ** xFilter - Initialize a cursor to point at the start of its data.
121464 */
121465 static int fts3auxFilterMethod(
121466   sqlcipher3_vtab_cursor *pCursor,   /* The cursor used for this query */
121467   int idxNum,                     /* Strategy index */
121468   const char *idxStr,             /* Unused */
121469   int nVal,                       /* Number of elements in apVal */
121470   sqlcipher3_value **apVal           /* Arguments for the indexing scheme */
121471 ){
121472   Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121473   Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
121474   int rc;
121475   int isScan;
121476
121477   UNUSED_PARAMETER(nVal);
121478   UNUSED_PARAMETER(idxStr);
121479
121480   assert( idxStr==0 );
121481   assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0
121482        || idxNum==FTS4AUX_LE_CONSTRAINT || idxNum==FTS4AUX_GE_CONSTRAINT
121483        || idxNum==(FTS4AUX_LE_CONSTRAINT|FTS4AUX_GE_CONSTRAINT)
121484   );
121485   isScan = (idxNum!=FTS4AUX_EQ_CONSTRAINT);
121486
121487   /* In case this cursor is being reused, close and zero it. */
121488   testcase(pCsr->filter.zTerm);
121489   sqlcipher3Fts3SegReaderFinish(&pCsr->csr);
121490   sqlcipher3_free((void *)pCsr->filter.zTerm);
121491   sqlcipher3_free(pCsr->aStat);
121492   memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
121493
121494   pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
121495   if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
121496
121497   if( idxNum&(FTS4AUX_EQ_CONSTRAINT|FTS4AUX_GE_CONSTRAINT) ){
121498     const unsigned char *zStr = sqlcipher3_value_text(apVal[0]);
121499     if( zStr ){
121500       pCsr->filter.zTerm = sqlcipher3_mprintf("%s", zStr);
121501       pCsr->filter.nTerm = sqlcipher3_value_bytes(apVal[0]);
121502       if( pCsr->filter.zTerm==0 ) return SQLCIPHER_NOMEM;
121503     }
121504   }
121505   if( idxNum&FTS4AUX_LE_CONSTRAINT ){
121506     int iIdx = (idxNum&FTS4AUX_GE_CONSTRAINT) ? 1 : 0;
121507     pCsr->zStop = sqlcipher3_mprintf("%s", sqlcipher3_value_text(apVal[iIdx]));
121508     pCsr->nStop = sqlcipher3_value_bytes(apVal[iIdx]);
121509     if( pCsr->zStop==0 ) return SQLCIPHER_NOMEM;
121510   }
121511
121512   rc = sqlcipher3Fts3SegReaderCursor(pFts3, 0, FTS3_SEGCURSOR_ALL,
121513       pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
121514   );
121515   if( rc==SQLCIPHER_OK ){
121516     rc = sqlcipher3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
121517   }
121518
121519   if( rc==SQLCIPHER_OK ) rc = fts3auxNextMethod(pCursor);
121520   return rc;
121521 }
121522
121523 /*
121524 ** xEof - Return true if the cursor is at EOF, or false otherwise.
121525 */
121526 static int fts3auxEofMethod(sqlcipher3_vtab_cursor *pCursor){
121527   Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121528   return pCsr->isEof;
121529 }
121530
121531 /*
121532 ** xColumn - Return a column value.
121533 */
121534 static int fts3auxColumnMethod(
121535   sqlcipher3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
121536   sqlcipher3_context *pContext,      /* Context for sqlcipher3_result_xxx() calls */
121537   int iCol                        /* Index of column to read value from */
121538 ){
121539   Fts3auxCursor *p = (Fts3auxCursor *)pCursor;
121540
121541   assert( p->isEof==0 );
121542   if( iCol==0 ){        /* Column "term" */
121543     sqlcipher3_result_text(pContext, p->csr.zTerm, p->csr.nTerm, SQLCIPHER_TRANSIENT);
121544   }else if( iCol==1 ){  /* Column "col" */
121545     if( p->iCol ){
121546       sqlcipher3_result_int(pContext, p->iCol-1);
121547     }else{
121548       sqlcipher3_result_text(pContext, "*", -1, SQLCIPHER_STATIC);
121549     }
121550   }else if( iCol==2 ){  /* Column "documents" */
121551     sqlcipher3_result_int64(pContext, p->aStat[p->iCol].nDoc);
121552   }else{                /* Column "occurrences" */
121553     sqlcipher3_result_int64(pContext, p->aStat[p->iCol].nOcc);
121554   }
121555
121556   return SQLCIPHER_OK;
121557 }
121558
121559 /*
121560 ** xRowid - Return the current rowid for the cursor.
121561 */
121562 static int fts3auxRowidMethod(
121563   sqlcipher3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
121564   sqlcipher_int64 *pRowid            /* OUT: Rowid value */
121565 ){
121566   Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121567   *pRowid = pCsr->iRowid;
121568   return SQLCIPHER_OK;
121569 }
121570
121571 /*
121572 ** Register the fts3aux module with database connection db. Return SQLCIPHER_OK
121573 ** if successful or an error code if sqlcipher3_create_module() fails.
121574 */
121575 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitAux(sqlcipher3 *db){
121576   static const sqlcipher3_module fts3aux_module = {
121577      0,                           /* iVersion      */
121578      fts3auxConnectMethod,        /* xCreate       */
121579      fts3auxConnectMethod,        /* xConnect      */
121580      fts3auxBestIndexMethod,      /* xBestIndex    */
121581      fts3auxDisconnectMethod,     /* xDisconnect   */
121582      fts3auxDisconnectMethod,     /* xDestroy      */
121583      fts3auxOpenMethod,           /* xOpen         */
121584      fts3auxCloseMethod,          /* xClose        */
121585      fts3auxFilterMethod,         /* xFilter       */
121586      fts3auxNextMethod,           /* xNext         */
121587      fts3auxEofMethod,            /* xEof          */
121588      fts3auxColumnMethod,         /* xColumn       */
121589      fts3auxRowidMethod,          /* xRowid        */
121590      0,                           /* xUpdate       */
121591      0,                           /* xBegin        */
121592      0,                           /* xSync         */
121593      0,                           /* xCommit       */
121594      0,                           /* xRollback     */
121595      0,                           /* xFindFunction */
121596      0,                           /* xRename       */
121597      0,                           /* xSavepoint    */
121598      0,                           /* xRelease      */
121599      0                            /* xRollbackTo   */
121600   };
121601   int rc;                         /* Return code */
121602
121603   rc = sqlcipher3_create_module(db, "fts4aux", &fts3aux_module, 0);
121604   return rc;
121605 }
121606
121607 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
121608
121609 /************** End of fts3_aux.c ********************************************/
121610 /************** Begin file fts3_expr.c ***************************************/
121611 /*
121612 ** 2008 Nov 28
121613 **
121614 ** The author disclaims copyright to this source code.  In place of
121615 ** a legal notice, here is a blessing:
121616 **
121617 **    May you do good and not evil.
121618 **    May you find forgiveness for yourself and forgive others.
121619 **    May you share freely, never taking more than you give.
121620 **
121621 ******************************************************************************
121622 **
121623 ** This module contains code that implements a parser for fts3 query strings
121624 ** (the right-hand argument to the MATCH operator). Because the supported 
121625 ** syntax is relatively simple, the whole tokenizer/parser system is
121626 ** hand-coded. 
121627 */
121628 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
121629
121630 /*
121631 ** By default, this module parses the legacy syntax that has been 
121632 ** traditionally used by fts3. Or, if SQLCIPHER_ENABLE_FTS3_PARENTHESIS
121633 ** is defined, then it uses the new syntax. The differences between
121634 ** the new and the old syntaxes are:
121635 **
121636 **  a) The new syntax supports parenthesis. The old does not.
121637 **
121638 **  b) The new syntax supports the AND and NOT operators. The old does not.
121639 **
121640 **  c) The old syntax supports the "-" token qualifier. This is not 
121641 **     supported by the new syntax (it is replaced by the NOT operator).
121642 **
121643 **  d) When using the old syntax, the OR operator has a greater precedence
121644 **     than an implicit AND. When using the new, both implicity and explicit
121645 **     AND operators have a higher precedence than OR.
121646 **
121647 ** If compiled with SQLCIPHER_TEST defined, then this module exports the
121648 ** symbol "int sqlcipher3_fts3_enable_parentheses". Setting this variable
121649 ** to zero causes the module to use the old syntax. If it is set to 
121650 ** non-zero the new syntax is activated. This is so both syntaxes can
121651 ** be tested using a single build of testfixture.
121652 **
121653 ** The following describes the syntax supported by the fts3 MATCH
121654 ** operator in a similar format to that used by the lemon parser
121655 ** generator. This module does not use actually lemon, it uses a
121656 ** custom parser.
121657 **
121658 **   query ::= andexpr (OR andexpr)*.
121659 **
121660 **   andexpr ::= notexpr (AND? notexpr)*.
121661 **
121662 **   notexpr ::= nearexpr (NOT nearexpr|-TOKEN)*.
121663 **   notexpr ::= LP query RP.
121664 **
121665 **   nearexpr ::= phrase (NEAR distance_opt nearexpr)*.
121666 **
121667 **   distance_opt ::= .
121668 **   distance_opt ::= / INTEGER.
121669 **
121670 **   phrase ::= TOKEN.
121671 **   phrase ::= COLUMN:TOKEN.
121672 **   phrase ::= "TOKEN TOKEN TOKEN...".
121673 */
121674
121675 #ifdef SQLCIPHER_TEST
121676 SQLCIPHER_API int sqlcipher3_fts3_enable_parentheses = 0;
121677 #else
121678 # ifdef SQLCIPHER_ENABLE_FTS3_PARENTHESIS 
121679 #  define sqlcipher3_fts3_enable_parentheses 1
121680 # else
121681 #  define sqlcipher3_fts3_enable_parentheses 0
121682 # endif
121683 #endif
121684
121685 /*
121686 ** Default span for NEAR operators.
121687 */
121688 #define SQLCIPHER_FTS3_DEFAULT_NEAR_PARAM 10
121689
121690 /* #include <string.h> */
121691 /* #include <assert.h> */
121692
121693 /*
121694 ** isNot:
121695 **   This variable is used by function getNextNode(). When getNextNode() is
121696 **   called, it sets ParseContext.isNot to true if the 'next node' is a 
121697 **   FTSQUERY_PHRASE with a unary "-" attached to it. i.e. "mysql" in the
121698 **   FTS3 query "sqlcipher -mysql". Otherwise, ParseContext.isNot is set to
121699 **   zero.
121700 */
121701 typedef struct ParseContext ParseContext;
121702 struct ParseContext {
121703   sqlcipher3_tokenizer *pTokenizer;      /* Tokenizer module */
121704   const char **azCol;                 /* Array of column names for fts3 table */
121705   int bFts4;                          /* True to allow FTS4-only syntax */
121706   int nCol;                           /* Number of entries in azCol[] */
121707   int iDefaultCol;                    /* Default column to query */
121708   int isNot;                          /* True if getNextNode() sees a unary - */
121709   sqlcipher3_context *pCtx;              /* Write error message here */
121710   int nNest;                          /* Number of nested brackets */
121711 };
121712
121713 /*
121714 ** This function is equivalent to the standard isspace() function. 
121715 **
121716 ** The standard isspace() can be awkward to use safely, because although it
121717 ** is defined to accept an argument of type int, its behaviour when passed
121718 ** an integer that falls outside of the range of the unsigned char type
121719 ** is undefined (and sometimes, "undefined" means segfault). This wrapper
121720 ** is defined to accept an argument of type char, and always returns 0 for
121721 ** any values that fall outside of the range of the unsigned char type (i.e.
121722 ** negative values).
121723 */
121724 static int fts3isspace(char c){
121725   return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f';
121726 }
121727
121728 /*
121729 ** Allocate nByte bytes of memory using sqlcipher3_malloc(). If successful,
121730 ** zero the memory before returning a pointer to it. If unsuccessful, 
121731 ** return NULL.
121732 */
121733 static void *fts3MallocZero(int nByte){
121734   void *pRet = sqlcipher3_malloc(nByte);
121735   if( pRet ) memset(pRet, 0, nByte);
121736   return pRet;
121737 }
121738
121739
121740 /*
121741 ** Extract the next token from buffer z (length n) using the tokenizer
121742 ** and other information (column names etc.) in pParse. Create an Fts3Expr
121743 ** structure of type FTSQUERY_PHRASE containing a phrase consisting of this
121744 ** single token and set *ppExpr to point to it. If the end of the buffer is
121745 ** reached before a token is found, set *ppExpr to zero. It is the
121746 ** responsibility of the caller to eventually deallocate the allocated 
121747 ** Fts3Expr structure (if any) by passing it to sqlcipher3_free().
121748 **
121749 ** Return SQLCIPHER_OK if successful, or SQLCIPHER_NOMEM if a memory allocation
121750 ** fails.
121751 */
121752 static int getNextToken(
121753   ParseContext *pParse,                   /* fts3 query parse context */
121754   int iCol,                               /* Value for Fts3Phrase.iColumn */
121755   const char *z, int n,                   /* Input string */
121756   Fts3Expr **ppExpr,                      /* OUT: expression */
121757   int *pnConsumed                         /* OUT: Number of bytes consumed */
121758 ){
121759   sqlcipher3_tokenizer *pTokenizer = pParse->pTokenizer;
121760   sqlcipher3_tokenizer_module const *pModule = pTokenizer->pModule;
121761   int rc;
121762   sqlcipher3_tokenizer_cursor *pCursor;
121763   Fts3Expr *pRet = 0;
121764   int nConsumed = 0;
121765
121766   rc = pModule->xOpen(pTokenizer, z, n, &pCursor);
121767   if( rc==SQLCIPHER_OK ){
121768     const char *zToken;
121769     int nToken, iStart, iEnd, iPosition;
121770     int nByte;                               /* total space to allocate */
121771
121772     pCursor->pTokenizer = pTokenizer;
121773     rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition);
121774
121775     if( rc==SQLCIPHER_OK ){
121776       nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
121777       pRet = (Fts3Expr *)fts3MallocZero(nByte);
121778       if( !pRet ){
121779         rc = SQLCIPHER_NOMEM;
121780       }else{
121781         pRet->eType = FTSQUERY_PHRASE;
121782         pRet->pPhrase = (Fts3Phrase *)&pRet[1];
121783         pRet->pPhrase->nToken = 1;
121784         pRet->pPhrase->iColumn = iCol;
121785         pRet->pPhrase->aToken[0].n = nToken;
121786         pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1];
121787         memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken);
121788
121789         if( iEnd<n && z[iEnd]=='*' ){
121790           pRet->pPhrase->aToken[0].isPrefix = 1;
121791           iEnd++;
121792         }
121793
121794         while( 1 ){
121795           if( !sqlcipher3_fts3_enable_parentheses 
121796            && iStart>0 && z[iStart-1]=='-' 
121797           ){
121798             pParse->isNot = 1;
121799             iStart--;
121800           }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){
121801             pRet->pPhrase->aToken[0].bFirst = 1;
121802             iStart--;
121803           }else{
121804             break;
121805           }
121806         }
121807
121808       }
121809       nConsumed = iEnd;
121810     }
121811
121812     pModule->xClose(pCursor);
121813   }
121814   
121815   *pnConsumed = nConsumed;
121816   *ppExpr = pRet;
121817   return rc;
121818 }
121819
121820
121821 /*
121822 ** Enlarge a memory allocation.  If an out-of-memory allocation occurs,
121823 ** then free the old allocation.
121824 */
121825 static void *fts3ReallocOrFree(void *pOrig, int nNew){
121826   void *pRet = sqlcipher3_realloc(pOrig, nNew);
121827   if( !pRet ){
121828     sqlcipher3_free(pOrig);
121829   }
121830   return pRet;
121831 }
121832
121833 /*
121834 ** Buffer zInput, length nInput, contains the contents of a quoted string
121835 ** that appeared as part of an fts3 query expression. Neither quote character
121836 ** is included in the buffer. This function attempts to tokenize the entire
121837 ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE 
121838 ** containing the results.
121839 **
121840 ** If successful, SQLCIPHER_OK is returned and *ppExpr set to point at the
121841 ** allocated Fts3Expr structure. Otherwise, either SQLCIPHER_NOMEM (out of memory
121842 ** error) or SQLCIPHER_ERROR (tokenization error) is returned and *ppExpr set
121843 ** to 0.
121844 */
121845 static int getNextString(
121846   ParseContext *pParse,                   /* fts3 query parse context */
121847   const char *zInput, int nInput,         /* Input string */
121848   Fts3Expr **ppExpr                       /* OUT: expression */
121849 ){
121850   sqlcipher3_tokenizer *pTokenizer = pParse->pTokenizer;
121851   sqlcipher3_tokenizer_module const *pModule = pTokenizer->pModule;
121852   int rc;
121853   Fts3Expr *p = 0;
121854   sqlcipher3_tokenizer_cursor *pCursor = 0;
121855   char *zTemp = 0;
121856   int nTemp = 0;
121857
121858   const int nSpace = sizeof(Fts3Expr) + sizeof(Fts3Phrase);
121859   int nToken = 0;
121860
121861   /* The final Fts3Expr data structure, including the Fts3Phrase,
121862   ** Fts3PhraseToken structures token buffers are all stored as a single 
121863   ** allocation so that the expression can be freed with a single call to
121864   ** sqlcipher3_free(). Setting this up requires a two pass approach.
121865   **
121866   ** The first pass, in the block below, uses a tokenizer cursor to iterate
121867   ** through the tokens in the expression. This pass uses fts3ReallocOrFree()
121868   ** to assemble data in two dynamic buffers:
121869   **
121870   **   Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase
121871   **             structure, followed by the array of Fts3PhraseToken 
121872   **             structures. This pass only populates the Fts3PhraseToken array.
121873   **
121874   **   Buffer zTemp: Contains copies of all tokens.
121875   **
121876   ** The second pass, in the block that begins "if( rc==SQLCIPHER_DONE )" below,
121877   ** appends buffer zTemp to buffer p, and fills in the Fts3Expr and Fts3Phrase
121878   ** structures.
121879   */
121880   rc = pModule->xOpen(pTokenizer, zInput, nInput, &pCursor);
121881   if( rc==SQLCIPHER_OK ){
121882     int ii;
121883     pCursor->pTokenizer = pTokenizer;
121884     for(ii=0; rc==SQLCIPHER_OK; ii++){
121885       const char *zByte;
121886       int nByte, iBegin, iEnd, iPos;
121887       rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos);
121888       if( rc==SQLCIPHER_OK ){
121889         Fts3PhraseToken *pToken;
121890
121891         p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken));
121892         if( !p ) goto no_mem;
121893
121894         zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
121895         if( !zTemp ) goto no_mem;
121896
121897         assert( nToken==ii );
121898         pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii];
121899         memset(pToken, 0, sizeof(Fts3PhraseToken));
121900
121901         memcpy(&zTemp[nTemp], zByte, nByte);
121902         nTemp += nByte;
121903
121904         pToken->n = nByte;
121905         pToken->isPrefix = (iEnd<nInput && zInput[iEnd]=='*');
121906         pToken->bFirst = (iBegin>0 && zInput[iBegin-1]=='^');
121907         nToken = ii+1;
121908       }
121909     }
121910
121911     pModule->xClose(pCursor);
121912     pCursor = 0;
121913   }
121914
121915   if( rc==SQLCIPHER_DONE ){
121916     int jj;
121917     char *zBuf = 0;
121918
121919     p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp);
121920     if( !p ) goto no_mem;
121921     memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p);
121922     p->eType = FTSQUERY_PHRASE;
121923     p->pPhrase = (Fts3Phrase *)&p[1];
121924     p->pPhrase->iColumn = pParse->iDefaultCol;
121925     p->pPhrase->nToken = nToken;
121926
121927     zBuf = (char *)&p->pPhrase->aToken[nToken];
121928     if( zTemp ){
121929       memcpy(zBuf, zTemp, nTemp);
121930       sqlcipher3_free(zTemp);
121931     }else{
121932       assert( nTemp==0 );
121933     }
121934
121935     for(jj=0; jj<p->pPhrase->nToken; jj++){
121936       p->pPhrase->aToken[jj].z = zBuf;
121937       zBuf += p->pPhrase->aToken[jj].n;
121938     }
121939     rc = SQLCIPHER_OK;
121940   }
121941
121942   *ppExpr = p;
121943   return rc;
121944 no_mem:
121945
121946   if( pCursor ){
121947     pModule->xClose(pCursor);
121948   }
121949   sqlcipher3_free(zTemp);
121950   sqlcipher3_free(p);
121951   *ppExpr = 0;
121952   return SQLCIPHER_NOMEM;
121953 }
121954
121955 /*
121956 ** Function getNextNode(), which is called by fts3ExprParse(), may itself
121957 ** call fts3ExprParse(). So this forward declaration is required.
121958 */
121959 static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *);
121960
121961 /*
121962 ** The output variable *ppExpr is populated with an allocated Fts3Expr 
121963 ** structure, or set to 0 if the end of the input buffer is reached.
121964 **
121965 ** Returns an SQLite error code. SQLCIPHER_OK if everything works, SQLCIPHER_NOMEM
121966 ** if a malloc failure occurs, or SQLCIPHER_ERROR if a parse error is encountered.
121967 ** If SQLCIPHER_ERROR is returned, pContext is populated with an error message.
121968 */
121969 static int getNextNode(
121970   ParseContext *pParse,                   /* fts3 query parse context */
121971   const char *z, int n,                   /* Input string */
121972   Fts3Expr **ppExpr,                      /* OUT: expression */
121973   int *pnConsumed                         /* OUT: Number of bytes consumed */
121974 ){
121975   static const struct Fts3Keyword {
121976     char *z;                              /* Keyword text */
121977     unsigned char n;                      /* Length of the keyword */
121978     unsigned char parenOnly;              /* Only valid in paren mode */
121979     unsigned char eType;                  /* Keyword code */
121980   } aKeyword[] = {
121981     { "OR" ,  2, 0, FTSQUERY_OR   },
121982     { "AND",  3, 1, FTSQUERY_AND  },
121983     { "NOT",  3, 1, FTSQUERY_NOT  },
121984     { "NEAR", 4, 0, FTSQUERY_NEAR }
121985   };
121986   int ii;
121987   int iCol;
121988   int iColLen;
121989   int rc;
121990   Fts3Expr *pRet = 0;
121991
121992   const char *zInput = z;
121993   int nInput = n;
121994
121995   pParse->isNot = 0;
121996
121997   /* Skip over any whitespace before checking for a keyword, an open or
121998   ** close bracket, or a quoted string. 
121999   */
122000   while( nInput>0 && fts3isspace(*zInput) ){
122001     nInput--;
122002     zInput++;
122003   }
122004   if( nInput==0 ){
122005     return SQLCIPHER_DONE;
122006   }
122007
122008   /* See if we are dealing with a keyword. */
122009   for(ii=0; ii<(int)(sizeof(aKeyword)/sizeof(struct Fts3Keyword)); ii++){
122010     const struct Fts3Keyword *pKey = &aKeyword[ii];
122011
122012     if( (pKey->parenOnly & ~sqlcipher3_fts3_enable_parentheses)!=0 ){
122013       continue;
122014     }
122015
122016     if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){
122017       int nNear = SQLCIPHER_FTS3_DEFAULT_NEAR_PARAM;
122018       int nKey = pKey->n;
122019       char cNext;
122020
122021       /* If this is a "NEAR" keyword, check for an explicit nearness. */
122022       if( pKey->eType==FTSQUERY_NEAR ){
122023         assert( nKey==4 );
122024         if( zInput[4]=='/' && zInput[5]>='0' && zInput[5]<='9' ){
122025           nNear = 0;
122026           for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){
122027             nNear = nNear * 10 + (zInput[nKey] - '0');
122028           }
122029         }
122030       }
122031
122032       /* At this point this is probably a keyword. But for that to be true,
122033       ** the next byte must contain either whitespace, an open or close
122034       ** parenthesis, a quote character, or EOF. 
122035       */
122036       cNext = zInput[nKey];
122037       if( fts3isspace(cNext) 
122038        || cNext=='"' || cNext=='(' || cNext==')' || cNext==0
122039       ){
122040         pRet = (Fts3Expr *)fts3MallocZero(sizeof(Fts3Expr));
122041         if( !pRet ){
122042           return SQLCIPHER_NOMEM;
122043         }
122044         pRet->eType = pKey->eType;
122045         pRet->nNear = nNear;
122046         *ppExpr = pRet;
122047         *pnConsumed = (int)((zInput - z) + nKey);
122048         return SQLCIPHER_OK;
122049       }
122050
122051       /* Turns out that wasn't a keyword after all. This happens if the
122052       ** user has supplied a token such as "ORacle". Continue.
122053       */
122054     }
122055   }
122056
122057   /* Check for an open bracket. */
122058   if( sqlcipher3_fts3_enable_parentheses ){
122059     if( *zInput=='(' ){
122060       int nConsumed;
122061       pParse->nNest++;
122062       rc = fts3ExprParse(pParse, &zInput[1], nInput-1, ppExpr, &nConsumed);
122063       if( rc==SQLCIPHER_OK && !*ppExpr ){
122064         rc = SQLCIPHER_DONE;
122065       }
122066       *pnConsumed = (int)((zInput - z) + 1 + nConsumed);
122067       return rc;
122068     }
122069   
122070     /* Check for a close bracket. */
122071     if( *zInput==')' ){
122072       pParse->nNest--;
122073       *pnConsumed = (int)((zInput - z) + 1);
122074       return SQLCIPHER_DONE;
122075     }
122076   }
122077
122078   /* See if we are dealing with a quoted phrase. If this is the case, then
122079   ** search for the closing quote and pass the whole string to getNextString()
122080   ** for processing. This is easy to do, as fts3 has no syntax for escaping
122081   ** a quote character embedded in a string.
122082   */
122083   if( *zInput=='"' ){
122084     for(ii=1; ii<nInput && zInput[ii]!='"'; ii++);
122085     *pnConsumed = (int)((zInput - z) + ii + 1);
122086     if( ii==nInput ){
122087       return SQLCIPHER_ERROR;
122088     }
122089     return getNextString(pParse, &zInput[1], ii-1, ppExpr);
122090   }
122091
122092
122093   /* If control flows to this point, this must be a regular token, or 
122094   ** the end of the input. Read a regular token using the sqlcipher3_tokenizer
122095   ** interface. Before doing so, figure out if there is an explicit
122096   ** column specifier for the token. 
122097   **
122098   ** TODO: Strangely, it is not possible to associate a column specifier
122099   ** with a quoted phrase, only with a single token. Not sure if this was
122100   ** an implementation artifact or an intentional decision when fts3 was
122101   ** first implemented. Whichever it was, this module duplicates the 
122102   ** limitation.
122103   */
122104   iCol = pParse->iDefaultCol;
122105   iColLen = 0;
122106   for(ii=0; ii<pParse->nCol; ii++){
122107     const char *zStr = pParse->azCol[ii];
122108     int nStr = (int)strlen(zStr);
122109     if( nInput>nStr && zInput[nStr]==':' 
122110      && sqlcipher3_strnicmp(zStr, zInput, nStr)==0 
122111     ){
122112       iCol = ii;
122113       iColLen = (int)((zInput - z) + nStr + 1);
122114       break;
122115     }
122116   }
122117   rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
122118   *pnConsumed += iColLen;
122119   return rc;
122120 }
122121
122122 /*
122123 ** The argument is an Fts3Expr structure for a binary operator (any type
122124 ** except an FTSQUERY_PHRASE). Return an integer value representing the
122125 ** precedence of the operator. Lower values have a higher precedence (i.e.
122126 ** group more tightly). For example, in the C language, the == operator
122127 ** groups more tightly than ||, and would therefore have a higher precedence.
122128 **
122129 ** When using the new fts3 query syntax (when SQLCIPHER_ENABLE_FTS3_PARENTHESIS
122130 ** is defined), the order of the operators in precedence from highest to
122131 ** lowest is:
122132 **
122133 **   NEAR
122134 **   NOT
122135 **   AND (including implicit ANDs)
122136 **   OR
122137 **
122138 ** Note that when using the old query syntax, the OR operator has a higher
122139 ** precedence than the AND operator.
122140 */
122141 static int opPrecedence(Fts3Expr *p){
122142   assert( p->eType!=FTSQUERY_PHRASE );
122143   if( sqlcipher3_fts3_enable_parentheses ){
122144     return p->eType;
122145   }else if( p->eType==FTSQUERY_NEAR ){
122146     return 1;
122147   }else if( p->eType==FTSQUERY_OR ){
122148     return 2;
122149   }
122150   assert( p->eType==FTSQUERY_AND );
122151   return 3;
122152 }
122153
122154 /*
122155 ** Argument ppHead contains a pointer to the current head of a query 
122156 ** expression tree being parsed. pPrev is the expression node most recently
122157 ** inserted into the tree. This function adds pNew, which is always a binary
122158 ** operator node, into the expression tree based on the relative precedence
122159 ** of pNew and the existing nodes of the tree. This may result in the head
122160 ** of the tree changing, in which case *ppHead is set to the new root node.
122161 */
122162 static void insertBinaryOperator(
122163   Fts3Expr **ppHead,       /* Pointer to the root node of a tree */
122164   Fts3Expr *pPrev,         /* Node most recently inserted into the tree */
122165   Fts3Expr *pNew           /* New binary node to insert into expression tree */
122166 ){
122167   Fts3Expr *pSplit = pPrev;
122168   while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){
122169     pSplit = pSplit->pParent;
122170   }
122171
122172   if( pSplit->pParent ){
122173     assert( pSplit->pParent->pRight==pSplit );
122174     pSplit->pParent->pRight = pNew;
122175     pNew->pParent = pSplit->pParent;
122176   }else{
122177     *ppHead = pNew;
122178   }
122179   pNew->pLeft = pSplit;
122180   pSplit->pParent = pNew;
122181 }
122182
122183 /*
122184 ** Parse the fts3 query expression found in buffer z, length n. This function
122185 ** returns either when the end of the buffer is reached or an unmatched 
122186 ** closing bracket - ')' - is encountered.
122187 **
122188 ** If successful, SQLCIPHER_OK is returned, *ppExpr is set to point to the
122189 ** parsed form of the expression and *pnConsumed is set to the number of
122190 ** bytes read from buffer z. Otherwise, *ppExpr is set to 0 and SQLCIPHER_NOMEM
122191 ** (out of memory error) or SQLCIPHER_ERROR (parse error) is returned.
122192 */
122193 static int fts3ExprParse(
122194   ParseContext *pParse,                   /* fts3 query parse context */
122195   const char *z, int n,                   /* Text of MATCH query */
122196   Fts3Expr **ppExpr,                      /* OUT: Parsed query structure */
122197   int *pnConsumed                         /* OUT: Number of bytes consumed */
122198 ){
122199   Fts3Expr *pRet = 0;
122200   Fts3Expr *pPrev = 0;
122201   Fts3Expr *pNotBranch = 0;               /* Only used in legacy parse mode */
122202   int nIn = n;
122203   const char *zIn = z;
122204   int rc = SQLCIPHER_OK;
122205   int isRequirePhrase = 1;
122206
122207   while( rc==SQLCIPHER_OK ){
122208     Fts3Expr *p = 0;
122209     int nByte = 0;
122210     rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
122211     if( rc==SQLCIPHER_OK ){
122212       int isPhrase;
122213
122214       if( !sqlcipher3_fts3_enable_parentheses 
122215        && p->eType==FTSQUERY_PHRASE && pParse->isNot 
122216       ){
122217         /* Create an implicit NOT operator. */
122218         Fts3Expr *pNot = fts3MallocZero(sizeof(Fts3Expr));
122219         if( !pNot ){
122220           sqlcipher3Fts3ExprFree(p);
122221           rc = SQLCIPHER_NOMEM;
122222           goto exprparse_out;
122223         }
122224         pNot->eType = FTSQUERY_NOT;
122225         pNot->pRight = p;
122226         if( pNotBranch ){
122227           pNot->pLeft = pNotBranch;
122228         }
122229         pNotBranch = pNot;
122230         p = pPrev;
122231       }else{
122232         int eType = p->eType;
122233         isPhrase = (eType==FTSQUERY_PHRASE || p->pLeft);
122234
122235         /* The isRequirePhrase variable is set to true if a phrase or
122236         ** an expression contained in parenthesis is required. If a
122237         ** binary operator (AND, OR, NOT or NEAR) is encounted when
122238         ** isRequirePhrase is set, this is a syntax error.
122239         */
122240         if( !isPhrase && isRequirePhrase ){
122241           sqlcipher3Fts3ExprFree(p);
122242           rc = SQLCIPHER_ERROR;
122243           goto exprparse_out;
122244         }
122245   
122246         if( isPhrase && !isRequirePhrase ){
122247           /* Insert an implicit AND operator. */
122248           Fts3Expr *pAnd;
122249           assert( pRet && pPrev );
122250           pAnd = fts3MallocZero(sizeof(Fts3Expr));
122251           if( !pAnd ){
122252             sqlcipher3Fts3ExprFree(p);
122253             rc = SQLCIPHER_NOMEM;
122254             goto exprparse_out;
122255           }
122256           pAnd->eType = FTSQUERY_AND;
122257           insertBinaryOperator(&pRet, pPrev, pAnd);
122258           pPrev = pAnd;
122259         }
122260
122261         /* This test catches attempts to make either operand of a NEAR
122262         ** operator something other than a phrase. For example, either of
122263         ** the following:
122264         **
122265         **    (bracketed expression) NEAR phrase
122266         **    phrase NEAR (bracketed expression)
122267         **
122268         ** Return an error in either case.
122269         */
122270         if( pPrev && (
122271             (eType==FTSQUERY_NEAR && !isPhrase && pPrev->eType!=FTSQUERY_PHRASE)
122272          || (eType!=FTSQUERY_PHRASE && isPhrase && pPrev->eType==FTSQUERY_NEAR)
122273         )){
122274           sqlcipher3Fts3ExprFree(p);
122275           rc = SQLCIPHER_ERROR;
122276           goto exprparse_out;
122277         }
122278   
122279         if( isPhrase ){
122280           if( pRet ){
122281             assert( pPrev && pPrev->pLeft && pPrev->pRight==0 );
122282             pPrev->pRight = p;
122283             p->pParent = pPrev;
122284           }else{
122285             pRet = p;
122286           }
122287         }else{
122288           insertBinaryOperator(&pRet, pPrev, p);
122289         }
122290         isRequirePhrase = !isPhrase;
122291       }
122292       assert( nByte>0 );
122293     }
122294     assert( rc!=SQLCIPHER_OK || (nByte>0 && nByte<=nIn) );
122295     nIn -= nByte;
122296     zIn += nByte;
122297     pPrev = p;
122298   }
122299
122300   if( rc==SQLCIPHER_DONE && pRet && isRequirePhrase ){
122301     rc = SQLCIPHER_ERROR;
122302   }
122303
122304   if( rc==SQLCIPHER_DONE ){
122305     rc = SQLCIPHER_OK;
122306     if( !sqlcipher3_fts3_enable_parentheses && pNotBranch ){
122307       if( !pRet ){
122308         rc = SQLCIPHER_ERROR;
122309       }else{
122310         Fts3Expr *pIter = pNotBranch;
122311         while( pIter->pLeft ){
122312           pIter = pIter->pLeft;
122313         }
122314         pIter->pLeft = pRet;
122315         pRet = pNotBranch;
122316       }
122317     }
122318   }
122319   *pnConsumed = n - nIn;
122320
122321 exprparse_out:
122322   if( rc!=SQLCIPHER_OK ){
122323     sqlcipher3Fts3ExprFree(pRet);
122324     sqlcipher3Fts3ExprFree(pNotBranch);
122325     pRet = 0;
122326   }
122327   *ppExpr = pRet;
122328   return rc;
122329 }
122330
122331 /*
122332 ** Parameters z and n contain a pointer to and length of a buffer containing
122333 ** an fts3 query expression, respectively. This function attempts to parse the
122334 ** query expression and create a tree of Fts3Expr structures representing the
122335 ** parsed expression. If successful, *ppExpr is set to point to the head
122336 ** of the parsed expression tree and SQLCIPHER_OK is returned. If an error
122337 ** occurs, either SQLCIPHER_NOMEM (out-of-memory error) or SQLCIPHER_ERROR (parse
122338 ** error) is returned and *ppExpr is set to 0.
122339 **
122340 ** If parameter n is a negative number, then z is assumed to point to a
122341 ** nul-terminated string and the length is determined using strlen().
122342 **
122343 ** The first parameter, pTokenizer, is passed the fts3 tokenizer module to
122344 ** use to normalize query tokens while parsing the expression. The azCol[]
122345 ** array, which is assumed to contain nCol entries, should contain the names
122346 ** of each column in the target fts3 table, in order from left to right. 
122347 ** Column names must be nul-terminated strings.
122348 **
122349 ** The iDefaultCol parameter should be passed the index of the table column
122350 ** that appears on the left-hand-side of the MATCH operator (the default
122351 ** column to match against for tokens for which a column name is not explicitly
122352 ** specified as part of the query string), or -1 if tokens may by default
122353 ** match any table column.
122354 */
122355 SQLCIPHER_PRIVATE int sqlcipher3Fts3ExprParse(
122356   sqlcipher3_tokenizer *pTokenizer,      /* Tokenizer module */
122357   char **azCol,                       /* Array of column names for fts3 table */
122358   int bFts4,                          /* True to allow FTS4-only syntax */
122359   int nCol,                           /* Number of entries in azCol[] */
122360   int iDefaultCol,                    /* Default column to query */
122361   const char *z, int n,               /* Text of MATCH query */
122362   Fts3Expr **ppExpr                   /* OUT: Parsed query structure */
122363 ){
122364   int nParsed;
122365   int rc;
122366   ParseContext sParse;
122367   sParse.pTokenizer = pTokenizer;
122368   sParse.azCol = (const char **)azCol;
122369   sParse.nCol = nCol;
122370   sParse.iDefaultCol = iDefaultCol;
122371   sParse.nNest = 0;
122372   sParse.bFts4 = bFts4;
122373   if( z==0 ){
122374     *ppExpr = 0;
122375     return SQLCIPHER_OK;
122376   }
122377   if( n<0 ){
122378     n = (int)strlen(z);
122379   }
122380   rc = fts3ExprParse(&sParse, z, n, ppExpr, &nParsed);
122381
122382   /* Check for mismatched parenthesis */
122383   if( rc==SQLCIPHER_OK && sParse.nNest ){
122384     rc = SQLCIPHER_ERROR;
122385     sqlcipher3Fts3ExprFree(*ppExpr);
122386     *ppExpr = 0;
122387   }
122388
122389   return rc;
122390 }
122391
122392 /*
122393 ** Free a parsed fts3 query expression allocated by sqlcipher3Fts3ExprParse().
122394 */
122395 SQLCIPHER_PRIVATE void sqlcipher3Fts3ExprFree(Fts3Expr *p){
122396   if( p ){
122397     assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 );
122398     sqlcipher3Fts3ExprFree(p->pLeft);
122399     sqlcipher3Fts3ExprFree(p->pRight);
122400     sqlcipher3Fts3EvalPhraseCleanup(p->pPhrase);
122401     sqlcipher3_free(p->aMI);
122402     sqlcipher3_free(p);
122403   }
122404 }
122405
122406 /****************************************************************************
122407 *****************************************************************************
122408 ** Everything after this point is just test code.
122409 */
122410
122411 #ifdef SQLCIPHER_TEST
122412
122413 /* #include <stdio.h> */
122414
122415 /*
122416 ** Function to query the hash-table of tokenizers (see README.tokenizers).
122417 */
122418 static int queryTestTokenizer(
122419   sqlcipher3 *db, 
122420   const char *zName,  
122421   const sqlcipher3_tokenizer_module **pp
122422 ){
122423   int rc;
122424   sqlcipher3_stmt *pStmt;
122425   const char zSql[] = "SELECT fts3_tokenizer(?)";
122426
122427   *pp = 0;
122428   rc = sqlcipher3_prepare_v2(db, zSql, -1, &pStmt, 0);
122429   if( rc!=SQLCIPHER_OK ){
122430     return rc;
122431   }
122432
122433   sqlcipher3_bind_text(pStmt, 1, zName, -1, SQLCIPHER_STATIC);
122434   if( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
122435     if( sqlcipher3_column_type(pStmt, 0)==SQLCIPHER_BLOB ){
122436       memcpy((void *)pp, sqlcipher3_column_blob(pStmt, 0), sizeof(*pp));
122437     }
122438   }
122439
122440   return sqlcipher3_finalize(pStmt);
122441 }
122442
122443 /*
122444 ** Return a pointer to a buffer containing a text representation of the
122445 ** expression passed as the first argument. The buffer is obtained from
122446 ** sqlcipher3_malloc(). It is the responsibility of the caller to use 
122447 ** sqlcipher3_free() to release the memory. If an OOM condition is encountered,
122448 ** NULL is returned.
122449 **
122450 ** If the second argument is not NULL, then its contents are prepended to 
122451 ** the returned expression text and then freed using sqlcipher3_free().
122452 */
122453 static char *exprToString(Fts3Expr *pExpr, char *zBuf){
122454   switch( pExpr->eType ){
122455     case FTSQUERY_PHRASE: {
122456       Fts3Phrase *pPhrase = pExpr->pPhrase;
122457       int i;
122458       zBuf = sqlcipher3_mprintf(
122459           "%zPHRASE %d 0", zBuf, pPhrase->iColumn);
122460       for(i=0; zBuf && i<pPhrase->nToken; i++){
122461         zBuf = sqlcipher3_mprintf("%z %.*s%s", zBuf, 
122462             pPhrase->aToken[i].n, pPhrase->aToken[i].z,
122463             (pPhrase->aToken[i].isPrefix?"+":"")
122464         );
122465       }
122466       return zBuf;
122467     }
122468
122469     case FTSQUERY_NEAR:
122470       zBuf = sqlcipher3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
122471       break;
122472     case FTSQUERY_NOT:
122473       zBuf = sqlcipher3_mprintf("%zNOT ", zBuf);
122474       break;
122475     case FTSQUERY_AND:
122476       zBuf = sqlcipher3_mprintf("%zAND ", zBuf);
122477       break;
122478     case FTSQUERY_OR:
122479       zBuf = sqlcipher3_mprintf("%zOR ", zBuf);
122480       break;
122481   }
122482
122483   if( zBuf ) zBuf = sqlcipher3_mprintf("%z{", zBuf);
122484   if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
122485   if( zBuf ) zBuf = sqlcipher3_mprintf("%z} {", zBuf);
122486
122487   if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
122488   if( zBuf ) zBuf = sqlcipher3_mprintf("%z}", zBuf);
122489
122490   return zBuf;
122491 }
122492
122493 /*
122494 ** This is the implementation of a scalar SQL function used to test the 
122495 ** expression parser. It should be called as follows:
122496 **
122497 **   fts3_exprtest(<tokenizer>, <expr>, <column 1>, ...);
122498 **
122499 ** The first argument, <tokenizer>, is the name of the fts3 tokenizer used
122500 ** to parse the query expression (see README.tokenizers). The second argument
122501 ** is the query expression to parse. Each subsequent argument is the name
122502 ** of a column of the fts3 table that the query expression may refer to.
122503 ** For example:
122504 **
122505 **   SELECT fts3_exprtest('simple', 'Bill col2:Bloggs', 'col1', 'col2');
122506 */
122507 static void fts3ExprTest(
122508   sqlcipher3_context *context,
122509   int argc,
122510   sqlcipher3_value **argv
122511 ){
122512   sqlcipher3_tokenizer_module const *pModule = 0;
122513   sqlcipher3_tokenizer *pTokenizer = 0;
122514   int rc;
122515   char **azCol = 0;
122516   const char *zExpr;
122517   int nExpr;
122518   int nCol;
122519   int ii;
122520   Fts3Expr *pExpr;
122521   char *zBuf = 0;
122522   sqlcipher3 *db = sqlcipher3_context_db_handle(context);
122523
122524   if( argc<3 ){
122525     sqlcipher3_result_error(context, 
122526         "Usage: fts3_exprtest(tokenizer, expr, col1, ...", -1
122527     );
122528     return;
122529   }
122530
122531   rc = queryTestTokenizer(db,
122532                           (const char *)sqlcipher3_value_text(argv[0]), &pModule);
122533   if( rc==SQLCIPHER_NOMEM ){
122534     sqlcipher3_result_error_nomem(context);
122535     goto exprtest_out;
122536   }else if( !pModule ){
122537     sqlcipher3_result_error(context, "No such tokenizer module", -1);
122538     goto exprtest_out;
122539   }
122540
122541   rc = pModule->xCreate(0, 0, &pTokenizer);
122542   assert( rc==SQLCIPHER_NOMEM || rc==SQLCIPHER_OK );
122543   if( rc==SQLCIPHER_NOMEM ){
122544     sqlcipher3_result_error_nomem(context);
122545     goto exprtest_out;
122546   }
122547   pTokenizer->pModule = pModule;
122548
122549   zExpr = (const char *)sqlcipher3_value_text(argv[1]);
122550   nExpr = sqlcipher3_value_bytes(argv[1]);
122551   nCol = argc-2;
122552   azCol = (char **)sqlcipher3_malloc(nCol*sizeof(char *));
122553   if( !azCol ){
122554     sqlcipher3_result_error_nomem(context);
122555     goto exprtest_out;
122556   }
122557   for(ii=0; ii<nCol; ii++){
122558     azCol[ii] = (char *)sqlcipher3_value_text(argv[ii+2]);
122559   }
122560
122561   rc = sqlcipher3Fts3ExprParse(
122562       pTokenizer, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
122563   );
122564   if( rc!=SQLCIPHER_OK && rc!=SQLCIPHER_NOMEM ){
122565     sqlcipher3_result_error(context, "Error parsing expression", -1);
122566   }else if( rc==SQLCIPHER_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
122567     sqlcipher3_result_error_nomem(context);
122568   }else{
122569     sqlcipher3_result_text(context, zBuf, -1, SQLCIPHER_TRANSIENT);
122570     sqlcipher3_free(zBuf);
122571   }
122572
122573   sqlcipher3Fts3ExprFree(pExpr);
122574
122575 exprtest_out:
122576   if( pModule && pTokenizer ){
122577     rc = pModule->xDestroy(pTokenizer);
122578   }
122579   sqlcipher3_free(azCol);
122580 }
122581
122582 /*
122583 ** Register the query expression parser test function fts3_exprtest() 
122584 ** with database connection db. 
122585 */
122586 SQLCIPHER_PRIVATE int sqlcipher3Fts3ExprInitTestInterface(sqlcipher3* db){
122587   return sqlcipher3_create_function(
122588       db, "fts3_exprtest", -1, SQLCIPHER_UTF8, 0, fts3ExprTest, 0, 0
122589   );
122590 }
122591
122592 #endif
122593 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
122594
122595 /************** End of fts3_expr.c *******************************************/
122596 /************** Begin file fts3_hash.c ***************************************/
122597 /*
122598 ** 2001 September 22
122599 **
122600 ** The author disclaims copyright to this source code.  In place of
122601 ** a legal notice, here is a blessing:
122602 **
122603 **    May you do good and not evil.
122604 **    May you find forgiveness for yourself and forgive others.
122605 **    May you share freely, never taking more than you give.
122606 **
122607 *************************************************************************
122608 ** This is the implementation of generic hash-tables used in SQLite.
122609 ** We've modified it slightly to serve as a standalone hash table
122610 ** implementation for the full-text indexing module.
122611 */
122612
122613 /*
122614 ** The code in this file is only compiled if:
122615 **
122616 **     * The FTS3 module is being built as an extension
122617 **       (in which case SQLCIPHER_CORE is not defined), or
122618 **
122619 **     * The FTS3 module is being built into the core of
122620 **       SQLite (in which case SQLCIPHER_ENABLE_FTS3 is defined).
122621 */
122622 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
122623
122624 /* #include <assert.h> */
122625 /* #include <stdlib.h> */
122626 /* #include <string.h> */
122627
122628
122629 /*
122630 ** Malloc and Free functions
122631 */
122632 static void *fts3HashMalloc(int n){
122633   void *p = sqlcipher3_malloc(n);
122634   if( p ){
122635     memset(p, 0, n);
122636   }
122637   return p;
122638 }
122639 static void fts3HashFree(void *p){
122640   sqlcipher3_free(p);
122641 }
122642
122643 /* Turn bulk memory into a hash table object by initializing the
122644 ** fields of the Hash structure.
122645 **
122646 ** "pNew" is a pointer to the hash table that is to be initialized.
122647 ** keyClass is one of the constants 
122648 ** FTS3_HASH_BINARY or FTS3_HASH_STRING.  The value of keyClass 
122649 ** determines what kind of key the hash table will use.  "copyKey" is
122650 ** true if the hash table should make its own private copy of keys and
122651 ** false if it should just use the supplied pointer.
122652 */
122653 SQLCIPHER_PRIVATE void sqlcipher3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
122654   assert( pNew!=0 );
122655   assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
122656   pNew->keyClass = keyClass;
122657   pNew->copyKey = copyKey;
122658   pNew->first = 0;
122659   pNew->count = 0;
122660   pNew->htsize = 0;
122661   pNew->ht = 0;
122662 }
122663
122664 /* Remove all entries from a hash table.  Reclaim all memory.
122665 ** Call this routine to delete a hash table or to reset a hash table
122666 ** to the empty state.
122667 */
122668 SQLCIPHER_PRIVATE void sqlcipher3Fts3HashClear(Fts3Hash *pH){
122669   Fts3HashElem *elem;         /* For looping over all elements of the table */
122670
122671   assert( pH!=0 );
122672   elem = pH->first;
122673   pH->first = 0;
122674   fts3HashFree(pH->ht);
122675   pH->ht = 0;
122676   pH->htsize = 0;
122677   while( elem ){
122678     Fts3HashElem *next_elem = elem->next;
122679     if( pH->copyKey && elem->pKey ){
122680       fts3HashFree(elem->pKey);
122681     }
122682     fts3HashFree(elem);
122683     elem = next_elem;
122684   }
122685   pH->count = 0;
122686 }
122687
122688 /*
122689 ** Hash and comparison functions when the mode is FTS3_HASH_STRING
122690 */
122691 static int fts3StrHash(const void *pKey, int nKey){
122692   const char *z = (const char *)pKey;
122693   int h = 0;
122694   if( nKey<=0 ) nKey = (int) strlen(z);
122695   while( nKey > 0  ){
122696     h = (h<<3) ^ h ^ *z++;
122697     nKey--;
122698   }
122699   return h & 0x7fffffff;
122700 }
122701 static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
122702   if( n1!=n2 ) return 1;
122703   return strncmp((const char*)pKey1,(const char*)pKey2,n1);
122704 }
122705
122706 /*
122707 ** Hash and comparison functions when the mode is FTS3_HASH_BINARY
122708 */
122709 static int fts3BinHash(const void *pKey, int nKey){
122710   int h = 0;
122711   const char *z = (const char *)pKey;
122712   while( nKey-- > 0 ){
122713     h = (h<<3) ^ h ^ *(z++);
122714   }
122715   return h & 0x7fffffff;
122716 }
122717 static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){
122718   if( n1!=n2 ) return 1;
122719   return memcmp(pKey1,pKey2,n1);
122720 }
122721
122722 /*
122723 ** Return a pointer to the appropriate hash function given the key class.
122724 **
122725 ** The C syntax in this function definition may be unfamilar to some 
122726 ** programmers, so we provide the following additional explanation:
122727 **
122728 ** The name of the function is "ftsHashFunction".  The function takes a
122729 ** single parameter "keyClass".  The return value of ftsHashFunction()
122730 ** is a pointer to another function.  Specifically, the return value
122731 ** of ftsHashFunction() is a pointer to a function that takes two parameters
122732 ** with types "const void*" and "int" and returns an "int".
122733 */
122734 static int (*ftsHashFunction(int keyClass))(const void*,int){
122735   if( keyClass==FTS3_HASH_STRING ){
122736     return &fts3StrHash;
122737   }else{
122738     assert( keyClass==FTS3_HASH_BINARY );
122739     return &fts3BinHash;
122740   }
122741 }
122742
122743 /*
122744 ** Return a pointer to the appropriate hash function given the key class.
122745 **
122746 ** For help in interpreted the obscure C code in the function definition,
122747 ** see the header comment on the previous function.
122748 */
122749 static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){
122750   if( keyClass==FTS3_HASH_STRING ){
122751     return &fts3StrCompare;
122752   }else{
122753     assert( keyClass==FTS3_HASH_BINARY );
122754     return &fts3BinCompare;
122755   }
122756 }
122757
122758 /* Link an element into the hash table
122759 */
122760 static void fts3HashInsertElement(
122761   Fts3Hash *pH,            /* The complete hash table */
122762   struct _fts3ht *pEntry,  /* The entry into which pNew is inserted */
122763   Fts3HashElem *pNew       /* The element to be inserted */
122764 ){
122765   Fts3HashElem *pHead;     /* First element already in pEntry */
122766   pHead = pEntry->chain;
122767   if( pHead ){
122768     pNew->next = pHead;
122769     pNew->prev = pHead->prev;
122770     if( pHead->prev ){ pHead->prev->next = pNew; }
122771     else             { pH->first = pNew; }
122772     pHead->prev = pNew;
122773   }else{
122774     pNew->next = pH->first;
122775     if( pH->first ){ pH->first->prev = pNew; }
122776     pNew->prev = 0;
122777     pH->first = pNew;
122778   }
122779   pEntry->count++;
122780   pEntry->chain = pNew;
122781 }
122782
122783
122784 /* Resize the hash table so that it cantains "new_size" buckets.
122785 ** "new_size" must be a power of 2.  The hash table might fail 
122786 ** to resize if sqlcipherMalloc() fails.
122787 **
122788 ** Return non-zero if a memory allocation error occurs.
122789 */
122790 static int fts3Rehash(Fts3Hash *pH, int new_size){
122791   struct _fts3ht *new_ht;          /* The new hash table */
122792   Fts3HashElem *elem, *next_elem;  /* For looping over existing elements */
122793   int (*xHash)(const void*,int);   /* The hash function */
122794
122795   assert( (new_size & (new_size-1))==0 );
122796   new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) );
122797   if( new_ht==0 ) return 1;
122798   fts3HashFree(pH->ht);
122799   pH->ht = new_ht;
122800   pH->htsize = new_size;
122801   xHash = ftsHashFunction(pH->keyClass);
122802   for(elem=pH->first, pH->first=0; elem; elem = next_elem){
122803     int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
122804     next_elem = elem->next;
122805     fts3HashInsertElement(pH, &new_ht[h], elem);
122806   }
122807   return 0;
122808 }
122809
122810 /* This function (for internal use only) locates an element in an
122811 ** hash table that matches the given key.  The hash for this key has
122812 ** already been computed and is passed as the 4th parameter.
122813 */
122814 static Fts3HashElem *fts3FindElementByHash(
122815   const Fts3Hash *pH, /* The pH to be searched */
122816   const void *pKey,   /* The key we are searching for */
122817   int nKey,
122818   int h               /* The hash for this key. */
122819 ){
122820   Fts3HashElem *elem;            /* Used to loop thru the element list */
122821   int count;                     /* Number of elements left to test */
122822   int (*xCompare)(const void*,int,const void*,int);  /* comparison function */
122823
122824   if( pH->ht ){
122825     struct _fts3ht *pEntry = &pH->ht[h];
122826     elem = pEntry->chain;
122827     count = pEntry->count;
122828     xCompare = ftsCompareFunction(pH->keyClass);
122829     while( count-- && elem ){
122830       if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ 
122831         return elem;
122832       }
122833       elem = elem->next;
122834     }
122835   }
122836   return 0;
122837 }
122838
122839 /* Remove a single entry from the hash table given a pointer to that
122840 ** element and a hash on the element's key.
122841 */
122842 static void fts3RemoveElementByHash(
122843   Fts3Hash *pH,         /* The pH containing "elem" */
122844   Fts3HashElem* elem,   /* The element to be removed from the pH */
122845   int h                 /* Hash value for the element */
122846 ){
122847   struct _fts3ht *pEntry;
122848   if( elem->prev ){
122849     elem->prev->next = elem->next; 
122850   }else{
122851     pH->first = elem->next;
122852   }
122853   if( elem->next ){
122854     elem->next->prev = elem->prev;
122855   }
122856   pEntry = &pH->ht[h];
122857   if( pEntry->chain==elem ){
122858     pEntry->chain = elem->next;
122859   }
122860   pEntry->count--;
122861   if( pEntry->count<=0 ){
122862     pEntry->chain = 0;
122863   }
122864   if( pH->copyKey && elem->pKey ){
122865     fts3HashFree(elem->pKey);
122866   }
122867   fts3HashFree( elem );
122868   pH->count--;
122869   if( pH->count<=0 ){
122870     assert( pH->first==0 );
122871     assert( pH->count==0 );
122872     fts3HashClear(pH);
122873   }
122874 }
122875
122876 SQLCIPHER_PRIVATE Fts3HashElem *sqlcipher3Fts3HashFindElem(
122877   const Fts3Hash *pH, 
122878   const void *pKey, 
122879   int nKey
122880 ){
122881   int h;                          /* A hash on key */
122882   int (*xHash)(const void*,int);  /* The hash function */
122883
122884   if( pH==0 || pH->ht==0 ) return 0;
122885   xHash = ftsHashFunction(pH->keyClass);
122886   assert( xHash!=0 );
122887   h = (*xHash)(pKey,nKey);
122888   assert( (pH->htsize & (pH->htsize-1))==0 );
122889   return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
122890 }
122891
122892 /* 
122893 ** Attempt to locate an element of the hash table pH with a key
122894 ** that matches pKey,nKey.  Return the data for this element if it is
122895 ** found, or NULL if there is no match.
122896 */
122897 SQLCIPHER_PRIVATE void *sqlcipher3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
122898   Fts3HashElem *pElem;            /* The element that matches key (if any) */
122899
122900   pElem = sqlcipher3Fts3HashFindElem(pH, pKey, nKey);
122901   return pElem ? pElem->data : 0;
122902 }
122903
122904 /* Insert an element into the hash table pH.  The key is pKey,nKey
122905 ** and the data is "data".
122906 **
122907 ** If no element exists with a matching key, then a new
122908 ** element is created.  A copy of the key is made if the copyKey
122909 ** flag is set.  NULL is returned.
122910 **
122911 ** If another element already exists with the same key, then the
122912 ** new data replaces the old data and the old data is returned.
122913 ** The key is not copied in this instance.  If a malloc fails, then
122914 ** the new data is returned and the hash table is unchanged.
122915 **
122916 ** If the "data" parameter to this function is NULL, then the
122917 ** element corresponding to "key" is removed from the hash table.
122918 */
122919 SQLCIPHER_PRIVATE void *sqlcipher3Fts3HashInsert(
122920   Fts3Hash *pH,        /* The hash table to insert into */
122921   const void *pKey,    /* The key */
122922   int nKey,            /* Number of bytes in the key */
122923   void *data           /* The data */
122924 ){
122925   int hraw;                 /* Raw hash value of the key */
122926   int h;                    /* the hash of the key modulo hash table size */
122927   Fts3HashElem *elem;       /* Used to loop thru the element list */
122928   Fts3HashElem *new_elem;   /* New element added to the pH */
122929   int (*xHash)(const void*,int);  /* The hash function */
122930
122931   assert( pH!=0 );
122932   xHash = ftsHashFunction(pH->keyClass);
122933   assert( xHash!=0 );
122934   hraw = (*xHash)(pKey, nKey);
122935   assert( (pH->htsize & (pH->htsize-1))==0 );
122936   h = hraw & (pH->htsize-1);
122937   elem = fts3FindElementByHash(pH,pKey,nKey,h);
122938   if( elem ){
122939     void *old_data = elem->data;
122940     if( data==0 ){
122941       fts3RemoveElementByHash(pH,elem,h);
122942     }else{
122943       elem->data = data;
122944     }
122945     return old_data;
122946   }
122947   if( data==0 ) return 0;
122948   if( (pH->htsize==0 && fts3Rehash(pH,8))
122949    || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2))
122950   ){
122951     pH->count = 0;
122952     return data;
122953   }
122954   assert( pH->htsize>0 );
122955   new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) );
122956   if( new_elem==0 ) return data;
122957   if( pH->copyKey && pKey!=0 ){
122958     new_elem->pKey = fts3HashMalloc( nKey );
122959     if( new_elem->pKey==0 ){
122960       fts3HashFree(new_elem);
122961       return data;
122962     }
122963     memcpy((void*)new_elem->pKey, pKey, nKey);
122964   }else{
122965     new_elem->pKey = (void*)pKey;
122966   }
122967   new_elem->nKey = nKey;
122968   pH->count++;
122969   assert( pH->htsize>0 );
122970   assert( (pH->htsize & (pH->htsize-1))==0 );
122971   h = hraw & (pH->htsize-1);
122972   fts3HashInsertElement(pH, &pH->ht[h], new_elem);
122973   new_elem->data = data;
122974   return 0;
122975 }
122976
122977 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
122978
122979 /************** End of fts3_hash.c *******************************************/
122980 /************** Begin file fts3_porter.c *************************************/
122981 /*
122982 ** 2006 September 30
122983 **
122984 ** The author disclaims copyright to this source code.  In place of
122985 ** a legal notice, here is a blessing:
122986 **
122987 **    May you do good and not evil.
122988 **    May you find forgiveness for yourself and forgive others.
122989 **    May you share freely, never taking more than you give.
122990 **
122991 *************************************************************************
122992 ** Implementation of the full-text-search tokenizer that implements
122993 ** a Porter stemmer.
122994 */
122995
122996 /*
122997 ** The code in this file is only compiled if:
122998 **
122999 **     * The FTS3 module is being built as an extension
123000 **       (in which case SQLCIPHER_CORE is not defined), or
123001 **
123002 **     * The FTS3 module is being built into the core of
123003 **       SQLite (in which case SQLCIPHER_ENABLE_FTS3 is defined).
123004 */
123005 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
123006
123007 /* #include <assert.h> */
123008 /* #include <stdlib.h> */
123009 /* #include <stdio.h> */
123010 /* #include <string.h> */
123011
123012
123013 /*
123014 ** Class derived from sqlcipher3_tokenizer
123015 */
123016 typedef struct porter_tokenizer {
123017   sqlcipher3_tokenizer base;      /* Base class */
123018 } porter_tokenizer;
123019
123020 /*
123021 ** Class derived from sqlit3_tokenizer_cursor
123022 */
123023 typedef struct porter_tokenizer_cursor {
123024   sqlcipher3_tokenizer_cursor base;
123025   const char *zInput;          /* input we are tokenizing */
123026   int nInput;                  /* size of the input */
123027   int iOffset;                 /* current position in zInput */
123028   int iToken;                  /* index of next token to be returned */
123029   char *zToken;                /* storage for current token */
123030   int nAllocated;              /* space allocated to zToken buffer */
123031 } porter_tokenizer_cursor;
123032
123033
123034 /*
123035 ** Create a new tokenizer instance.
123036 */
123037 static int porterCreate(
123038   int argc, const char * const *argv,
123039   sqlcipher3_tokenizer **ppTokenizer
123040 ){
123041   porter_tokenizer *t;
123042
123043   UNUSED_PARAMETER(argc);
123044   UNUSED_PARAMETER(argv);
123045
123046   t = (porter_tokenizer *) sqlcipher3_malloc(sizeof(*t));
123047   if( t==NULL ) return SQLCIPHER_NOMEM;
123048   memset(t, 0, sizeof(*t));
123049   *ppTokenizer = &t->base;
123050   return SQLCIPHER_OK;
123051 }
123052
123053 /*
123054 ** Destroy a tokenizer
123055 */
123056 static int porterDestroy(sqlcipher3_tokenizer *pTokenizer){
123057   sqlcipher3_free(pTokenizer);
123058   return SQLCIPHER_OK;
123059 }
123060
123061 /*
123062 ** Prepare to begin tokenizing a particular string.  The input
123063 ** string to be tokenized is zInput[0..nInput-1].  A cursor
123064 ** used to incrementally tokenize this string is returned in 
123065 ** *ppCursor.
123066 */
123067 static int porterOpen(
123068   sqlcipher3_tokenizer *pTokenizer,         /* The tokenizer */
123069   const char *zInput, int nInput,        /* String to be tokenized */
123070   sqlcipher3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
123071 ){
123072   porter_tokenizer_cursor *c;
123073
123074   UNUSED_PARAMETER(pTokenizer);
123075
123076   c = (porter_tokenizer_cursor *) sqlcipher3_malloc(sizeof(*c));
123077   if( c==NULL ) return SQLCIPHER_NOMEM;
123078
123079   c->zInput = zInput;
123080   if( zInput==0 ){
123081     c->nInput = 0;
123082   }else if( nInput<0 ){
123083     c->nInput = (int)strlen(zInput);
123084   }else{
123085     c->nInput = nInput;
123086   }
123087   c->iOffset = 0;                 /* start tokenizing at the beginning */
123088   c->iToken = 0;
123089   c->zToken = NULL;               /* no space allocated, yet. */
123090   c->nAllocated = 0;
123091
123092   *ppCursor = &c->base;
123093   return SQLCIPHER_OK;
123094 }
123095
123096 /*
123097 ** Close a tokenization cursor previously opened by a call to
123098 ** porterOpen() above.
123099 */
123100 static int porterClose(sqlcipher3_tokenizer_cursor *pCursor){
123101   porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
123102   sqlcipher3_free(c->zToken);
123103   sqlcipher3_free(c);
123104   return SQLCIPHER_OK;
123105 }
123106 /*
123107 ** Vowel or consonant
123108 */
123109 static const char cType[] = {
123110    0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,
123111    1, 1, 1, 2, 1
123112 };
123113
123114 /*
123115 ** isConsonant() and isVowel() determine if their first character in
123116 ** the string they point to is a consonant or a vowel, according
123117 ** to Porter ruls.  
123118 **
123119 ** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'.
123120 ** 'Y' is a consonant unless it follows another consonant,
123121 ** in which case it is a vowel.
123122 **
123123 ** In these routine, the letters are in reverse order.  So the 'y' rule
123124 ** is that 'y' is a consonant unless it is followed by another
123125 ** consonent.
123126 */
123127 static int isVowel(const char*);
123128 static int isConsonant(const char *z){
123129   int j;
123130   char x = *z;
123131   if( x==0 ) return 0;
123132   assert( x>='a' && x<='z' );
123133   j = cType[x-'a'];
123134   if( j<2 ) return j;
123135   return z[1]==0 || isVowel(z + 1);
123136 }
123137 static int isVowel(const char *z){
123138   int j;
123139   char x = *z;
123140   if( x==0 ) return 0;
123141   assert( x>='a' && x<='z' );
123142   j = cType[x-'a'];
123143   if( j<2 ) return 1-j;
123144   return isConsonant(z + 1);
123145 }
123146
123147 /*
123148 ** Let any sequence of one or more vowels be represented by V and let
123149 ** C be sequence of one or more consonants.  Then every word can be
123150 ** represented as:
123151 **
123152 **           [C] (VC){m} [V]
123153 **
123154 ** In prose:  A word is an optional consonant followed by zero or
123155 ** vowel-consonant pairs followed by an optional vowel.  "m" is the
123156 ** number of vowel consonant pairs.  This routine computes the value
123157 ** of m for the first i bytes of a word.
123158 **
123159 ** Return true if the m-value for z is 1 or more.  In other words,
123160 ** return true if z contains at least one vowel that is followed
123161 ** by a consonant.
123162 **
123163 ** In this routine z[] is in reverse order.  So we are really looking
123164 ** for an instance of of a consonant followed by a vowel.
123165 */
123166 static int m_gt_0(const char *z){
123167   while( isVowel(z) ){ z++; }
123168   if( *z==0 ) return 0;
123169   while( isConsonant(z) ){ z++; }
123170   return *z!=0;
123171 }
123172
123173 /* Like mgt0 above except we are looking for a value of m which is
123174 ** exactly 1
123175 */
123176 static int m_eq_1(const char *z){
123177   while( isVowel(z) ){ z++; }
123178   if( *z==0 ) return 0;
123179   while( isConsonant(z) ){ z++; }
123180   if( *z==0 ) return 0;
123181   while( isVowel(z) ){ z++; }
123182   if( *z==0 ) return 1;
123183   while( isConsonant(z) ){ z++; }
123184   return *z==0;
123185 }
123186
123187 /* Like mgt0 above except we are looking for a value of m>1 instead
123188 ** or m>0
123189 */
123190 static int m_gt_1(const char *z){
123191   while( isVowel(z) ){ z++; }
123192   if( *z==0 ) return 0;
123193   while( isConsonant(z) ){ z++; }
123194   if( *z==0 ) return 0;
123195   while( isVowel(z) ){ z++; }
123196   if( *z==0 ) return 0;
123197   while( isConsonant(z) ){ z++; }
123198   return *z!=0;
123199 }
123200
123201 /*
123202 ** Return TRUE if there is a vowel anywhere within z[0..n-1]
123203 */
123204 static int hasVowel(const char *z){
123205   while( isConsonant(z) ){ z++; }
123206   return *z!=0;
123207 }
123208
123209 /*
123210 ** Return TRUE if the word ends in a double consonant.
123211 **
123212 ** The text is reversed here. So we are really looking at
123213 ** the first two characters of z[].
123214 */
123215 static int doubleConsonant(const char *z){
123216   return isConsonant(z) && z[0]==z[1];
123217 }
123218
123219 /*
123220 ** Return TRUE if the word ends with three letters which
123221 ** are consonant-vowel-consonent and where the final consonant
123222 ** is not 'w', 'x', or 'y'.
123223 **
123224 ** The word is reversed here.  So we are really checking the
123225 ** first three letters and the first one cannot be in [wxy].
123226 */
123227 static int star_oh(const char *z){
123228   return
123229     isConsonant(z) &&
123230     z[0]!='w' && z[0]!='x' && z[0]!='y' &&
123231     isVowel(z+1) &&
123232     isConsonant(z+2);
123233 }
123234
123235 /*
123236 ** If the word ends with zFrom and xCond() is true for the stem
123237 ** of the word that preceeds the zFrom ending, then change the 
123238 ** ending to zTo.
123239 **
123240 ** The input word *pz and zFrom are both in reverse order.  zTo
123241 ** is in normal order. 
123242 **
123243 ** Return TRUE if zFrom matches.  Return FALSE if zFrom does not
123244 ** match.  Not that TRUE is returned even if xCond() fails and
123245 ** no substitution occurs.
123246 */
123247 static int stem(
123248   char **pz,             /* The word being stemmed (Reversed) */
123249   const char *zFrom,     /* If the ending matches this... (Reversed) */
123250   const char *zTo,       /* ... change the ending to this (not reversed) */
123251   int (*xCond)(const char*)   /* Condition that must be true */
123252 ){
123253   char *z = *pz;
123254   while( *zFrom && *zFrom==*z ){ z++; zFrom++; }
123255   if( *zFrom!=0 ) return 0;
123256   if( xCond && !xCond(z) ) return 1;
123257   while( *zTo ){
123258     *(--z) = *(zTo++);
123259   }
123260   *pz = z;
123261   return 1;
123262 }
123263
123264 /*
123265 ** This is the fallback stemmer used when the porter stemmer is
123266 ** inappropriate.  The input word is copied into the output with
123267 ** US-ASCII case folding.  If the input word is too long (more
123268 ** than 20 bytes if it contains no digits or more than 6 bytes if
123269 ** it contains digits) then word is truncated to 20 or 6 bytes
123270 ** by taking 10 or 3 bytes from the beginning and end.
123271 */
123272 static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
123273   int i, mx, j;
123274   int hasDigit = 0;
123275   for(i=0; i<nIn; i++){
123276     char c = zIn[i];
123277     if( c>='A' && c<='Z' ){
123278       zOut[i] = c - 'A' + 'a';
123279     }else{
123280       if( c>='0' && c<='9' ) hasDigit = 1;
123281       zOut[i] = c;
123282     }
123283   }
123284   mx = hasDigit ? 3 : 10;
123285   if( nIn>mx*2 ){
123286     for(j=mx, i=nIn-mx; i<nIn; i++, j++){
123287       zOut[j] = zOut[i];
123288     }
123289     i = j;
123290   }
123291   zOut[i] = 0;
123292   *pnOut = i;
123293 }
123294
123295
123296 /*
123297 ** Stem the input word zIn[0..nIn-1].  Store the output in zOut.
123298 ** zOut is at least big enough to hold nIn bytes.  Write the actual
123299 ** size of the output word (exclusive of the '\0' terminator) into *pnOut.
123300 **
123301 ** Any upper-case characters in the US-ASCII character set ([A-Z])
123302 ** are converted to lower case.  Upper-case UTF characters are
123303 ** unchanged.
123304 **
123305 ** Words that are longer than about 20 bytes are stemmed by retaining
123306 ** a few bytes from the beginning and the end of the word.  If the
123307 ** word contains digits, 3 bytes are taken from the beginning and
123308 ** 3 bytes from the end.  For long words without digits, 10 bytes
123309 ** are taken from each end.  US-ASCII case folding still applies.
123310 ** 
123311 ** If the input word contains not digits but does characters not 
123312 ** in [a-zA-Z] then no stemming is attempted and this routine just 
123313 ** copies the input into the input into the output with US-ASCII
123314 ** case folding.
123315 **
123316 ** Stemming never increases the length of the word.  So there is
123317 ** no chance of overflowing the zOut buffer.
123318 */
123319 static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
123320   int i, j;
123321   char zReverse[28];
123322   char *z, *z2;
123323   if( nIn<3 || nIn>=(int)sizeof(zReverse)-7 ){
123324     /* The word is too big or too small for the porter stemmer.
123325     ** Fallback to the copy stemmer */
123326     copy_stemmer(zIn, nIn, zOut, pnOut);
123327     return;
123328   }
123329   for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
123330     char c = zIn[i];
123331     if( c>='A' && c<='Z' ){
123332       zReverse[j] = c + 'a' - 'A';
123333     }else if( c>='a' && c<='z' ){
123334       zReverse[j] = c;
123335     }else{
123336       /* The use of a character not in [a-zA-Z] means that we fallback
123337       ** to the copy stemmer */
123338       copy_stemmer(zIn, nIn, zOut, pnOut);
123339       return;
123340     }
123341   }
123342   memset(&zReverse[sizeof(zReverse)-5], 0, 5);
123343   z = &zReverse[j+1];
123344
123345
123346   /* Step 1a */
123347   if( z[0]=='s' ){
123348     if(
123349      !stem(&z, "sess", "ss", 0) &&
123350      !stem(&z, "sei", "i", 0)  &&
123351      !stem(&z, "ss", "ss", 0)
123352     ){
123353       z++;
123354     }
123355   }
123356
123357   /* Step 1b */  
123358   z2 = z;
123359   if( stem(&z, "dee", "ee", m_gt_0) ){
123360     /* Do nothing.  The work was all in the test */
123361   }else if( 
123362      (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel))
123363       && z!=z2
123364   ){
123365      if( stem(&z, "ta", "ate", 0) ||
123366          stem(&z, "lb", "ble", 0) ||
123367          stem(&z, "zi", "ize", 0) ){
123368        /* Do nothing.  The work was all in the test */
123369      }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){
123370        z++;
123371      }else if( m_eq_1(z) && star_oh(z) ){
123372        *(--z) = 'e';
123373      }
123374   }
123375
123376   /* Step 1c */
123377   if( z[0]=='y' && hasVowel(z+1) ){
123378     z[0] = 'i';
123379   }
123380
123381   /* Step 2 */
123382   switch( z[1] ){
123383    case 'a':
123384      stem(&z, "lanoita", "ate", m_gt_0) ||
123385      stem(&z, "lanoit", "tion", m_gt_0);
123386      break;
123387    case 'c':
123388      stem(&z, "icne", "ence", m_gt_0) ||
123389      stem(&z, "icna", "ance", m_gt_0);
123390      break;
123391    case 'e':
123392      stem(&z, "rezi", "ize", m_gt_0);
123393      break;
123394    case 'g':
123395      stem(&z, "igol", "log", m_gt_0);
123396      break;
123397    case 'l':
123398      stem(&z, "ilb", "ble", m_gt_0) ||
123399      stem(&z, "illa", "al", m_gt_0) ||
123400      stem(&z, "iltne", "ent", m_gt_0) ||
123401      stem(&z, "ile", "e", m_gt_0) ||
123402      stem(&z, "ilsuo", "ous", m_gt_0);
123403      break;
123404    case 'o':
123405      stem(&z, "noitazi", "ize", m_gt_0) ||
123406      stem(&z, "noita", "ate", m_gt_0) ||
123407      stem(&z, "rota", "ate", m_gt_0);
123408      break;
123409    case 's':
123410      stem(&z, "msila", "al", m_gt_0) ||
123411      stem(&z, "ssenevi", "ive", m_gt_0) ||
123412      stem(&z, "ssenluf", "ful", m_gt_0) ||
123413      stem(&z, "ssensuo", "ous", m_gt_0);
123414      break;
123415    case 't':
123416      stem(&z, "itila", "al", m_gt_0) ||
123417      stem(&z, "itivi", "ive", m_gt_0) ||
123418      stem(&z, "itilib", "ble", m_gt_0);
123419      break;
123420   }
123421
123422   /* Step 3 */
123423   switch( z[0] ){
123424    case 'e':
123425      stem(&z, "etaci", "ic", m_gt_0) ||
123426      stem(&z, "evita", "", m_gt_0)   ||
123427      stem(&z, "ezila", "al", m_gt_0);
123428      break;
123429    case 'i':
123430      stem(&z, "itici", "ic", m_gt_0);
123431      break;
123432    case 'l':
123433      stem(&z, "laci", "ic", m_gt_0) ||
123434      stem(&z, "luf", "", m_gt_0);
123435      break;
123436    case 's':
123437      stem(&z, "ssen", "", m_gt_0);
123438      break;
123439   }
123440
123441   /* Step 4 */
123442   switch( z[1] ){
123443    case 'a':
123444      if( z[0]=='l' && m_gt_1(z+2) ){
123445        z += 2;
123446      }
123447      break;
123448    case 'c':
123449      if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e')  && m_gt_1(z+4)  ){
123450        z += 4;
123451      }
123452      break;
123453    case 'e':
123454      if( z[0]=='r' && m_gt_1(z+2) ){
123455        z += 2;
123456      }
123457      break;
123458    case 'i':
123459      if( z[0]=='c' && m_gt_1(z+2) ){
123460        z += 2;
123461      }
123462      break;
123463    case 'l':
123464      if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){
123465        z += 4;
123466      }
123467      break;
123468    case 'n':
123469      if( z[0]=='t' ){
123470        if( z[2]=='a' ){
123471          if( m_gt_1(z+3) ){
123472            z += 3;
123473          }
123474        }else if( z[2]=='e' ){
123475          stem(&z, "tneme", "", m_gt_1) ||
123476          stem(&z, "tnem", "", m_gt_1) ||
123477          stem(&z, "tne", "", m_gt_1);
123478        }
123479      }
123480      break;
123481    case 'o':
123482      if( z[0]=='u' ){
123483        if( m_gt_1(z+2) ){
123484          z += 2;
123485        }
123486      }else if( z[3]=='s' || z[3]=='t' ){
123487        stem(&z, "noi", "", m_gt_1);
123488      }
123489      break;
123490    case 's':
123491      if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){
123492        z += 3;
123493      }
123494      break;
123495    case 't':
123496      stem(&z, "eta", "", m_gt_1) ||
123497      stem(&z, "iti", "", m_gt_1);
123498      break;
123499    case 'u':
123500      if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
123501        z += 3;
123502      }
123503      break;
123504    case 'v':
123505    case 'z':
123506      if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){
123507        z += 3;
123508      }
123509      break;
123510   }
123511
123512   /* Step 5a */
123513   if( z[0]=='e' ){
123514     if( m_gt_1(z+1) ){
123515       z++;
123516     }else if( m_eq_1(z+1) && !star_oh(z+1) ){
123517       z++;
123518     }
123519   }
123520
123521   /* Step 5b */
123522   if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){
123523     z++;
123524   }
123525
123526   /* z[] is now the stemmed word in reverse order.  Flip it back
123527   ** around into forward order and return.
123528   */
123529   *pnOut = i = (int)strlen(z);
123530   zOut[i] = 0;
123531   while( *z ){
123532     zOut[--i] = *(z++);
123533   }
123534 }
123535
123536 /*
123537 ** Characters that can be part of a token.  We assume any character
123538 ** whose value is greater than 0x80 (any UTF character) can be
123539 ** part of a token.  In other words, delimiters all must have
123540 ** values of 0x7f or lower.
123541 */
123542 static const char porterIdChar[] = {
123543 /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
123544     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
123545     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
123546     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
123547     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
123548     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
123549 };
123550 #define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30]))
123551
123552 /*
123553 ** Extract the next token from a tokenization cursor.  The cursor must
123554 ** have been opened by a prior call to porterOpen().
123555 */
123556 static int porterNext(
123557   sqlcipher3_tokenizer_cursor *pCursor,  /* Cursor returned by porterOpen */
123558   const char **pzToken,               /* OUT: *pzToken is the token text */
123559   int *pnBytes,                       /* OUT: Number of bytes in token */
123560   int *piStartOffset,                 /* OUT: Starting offset of token */
123561   int *piEndOffset,                   /* OUT: Ending offset of token */
123562   int *piPosition                     /* OUT: Position integer of token */
123563 ){
123564   porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
123565   const char *z = c->zInput;
123566
123567   while( c->iOffset<c->nInput ){
123568     int iStartOffset, ch;
123569
123570     /* Scan past delimiter characters */
123571     while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
123572       c->iOffset++;
123573     }
123574
123575     /* Count non-delimiter characters. */
123576     iStartOffset = c->iOffset;
123577     while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
123578       c->iOffset++;
123579     }
123580
123581     if( c->iOffset>iStartOffset ){
123582       int n = c->iOffset-iStartOffset;
123583       if( n>c->nAllocated ){
123584         char *pNew;
123585         c->nAllocated = n+20;
123586         pNew = sqlcipher3_realloc(c->zToken, c->nAllocated);
123587         if( !pNew ) return SQLCIPHER_NOMEM;
123588         c->zToken = pNew;
123589       }
123590       porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
123591       *pzToken = c->zToken;
123592       *piStartOffset = iStartOffset;
123593       *piEndOffset = c->iOffset;
123594       *piPosition = c->iToken++;
123595       return SQLCIPHER_OK;
123596     }
123597   }
123598   return SQLCIPHER_DONE;
123599 }
123600
123601 /*
123602 ** The set of routines that implement the porter-stemmer tokenizer
123603 */
123604 static const sqlcipher3_tokenizer_module porterTokenizerModule = {
123605   0,
123606   porterCreate,
123607   porterDestroy,
123608   porterOpen,
123609   porterClose,
123610   porterNext,
123611 };
123612
123613 /*
123614 ** Allocate a new porter tokenizer.  Return a pointer to the new
123615 ** tokenizer in *ppModule
123616 */
123617 SQLCIPHER_PRIVATE void sqlcipher3Fts3PorterTokenizerModule(
123618   sqlcipher3_tokenizer_module const**ppModule
123619 ){
123620   *ppModule = &porterTokenizerModule;
123621 }
123622
123623 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
123624
123625 /************** End of fts3_porter.c *****************************************/
123626 /************** Begin file fts3_tokenizer.c **********************************/
123627 /*
123628 ** 2007 June 22
123629 **
123630 ** The author disclaims copyright to this source code.  In place of
123631 ** a legal notice, here is a blessing:
123632 **
123633 **    May you do good and not evil.
123634 **    May you find forgiveness for yourself and forgive others.
123635 **    May you share freely, never taking more than you give.
123636 **
123637 ******************************************************************************
123638 **
123639 ** This is part of an SQLite module implementing full-text search.
123640 ** This particular file implements the generic tokenizer interface.
123641 */
123642
123643 /*
123644 ** The code in this file is only compiled if:
123645 **
123646 **     * The FTS3 module is being built as an extension
123647 **       (in which case SQLCIPHER_CORE is not defined), or
123648 **
123649 **     * The FTS3 module is being built into the core of
123650 **       SQLite (in which case SQLCIPHER_ENABLE_FTS3 is defined).
123651 */
123652 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
123653
123654 /* #include <assert.h> */
123655 /* #include <string.h> */
123656
123657 /*
123658 ** Implementation of the SQL scalar function for accessing the underlying 
123659 ** hash table. This function may be called as follows:
123660 **
123661 **   SELECT <function-name>(<key-name>);
123662 **   SELECT <function-name>(<key-name>, <pointer>);
123663 **
123664 ** where <function-name> is the name passed as the second argument
123665 ** to the sqlcipher3Fts3InitHashTable() function (e.g. 'fts3_tokenizer').
123666 **
123667 ** If the <pointer> argument is specified, it must be a blob value
123668 ** containing a pointer to be stored as the hash data corresponding
123669 ** to the string <key-name>. If <pointer> is not specified, then
123670 ** the string <key-name> must already exist in the has table. Otherwise,
123671 ** an error is returned.
123672 **
123673 ** Whether or not the <pointer> argument is specified, the value returned
123674 ** is a blob containing the pointer stored as the hash data corresponding
123675 ** to string <key-name> (after the hash-table is updated, if applicable).
123676 */
123677 static void scalarFunc(
123678   sqlcipher3_context *context,
123679   int argc,
123680   sqlcipher3_value **argv
123681 ){
123682   Fts3Hash *pHash;
123683   void *pPtr = 0;
123684   const unsigned char *zName;
123685   int nName;
123686
123687   assert( argc==1 || argc==2 );
123688
123689   pHash = (Fts3Hash *)sqlcipher3_user_data(context);
123690
123691   zName = sqlcipher3_value_text(argv[0]);
123692   nName = sqlcipher3_value_bytes(argv[0])+1;
123693
123694   if( argc==2 ){
123695     void *pOld;
123696     int n = sqlcipher3_value_bytes(argv[1]);
123697     if( n!=sizeof(pPtr) ){
123698       sqlcipher3_result_error(context, "argument type mismatch", -1);
123699       return;
123700     }
123701     pPtr = *(void **)sqlcipher3_value_blob(argv[1]);
123702     pOld = sqlcipher3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
123703     if( pOld==pPtr ){
123704       sqlcipher3_result_error(context, "out of memory", -1);
123705       return;
123706     }
123707   }else{
123708     pPtr = sqlcipher3Fts3HashFind(pHash, zName, nName);
123709     if( !pPtr ){
123710       char *zErr = sqlcipher3_mprintf("unknown tokenizer: %s", zName);
123711       sqlcipher3_result_error(context, zErr, -1);
123712       sqlcipher3_free(zErr);
123713       return;
123714     }
123715   }
123716
123717   sqlcipher3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLCIPHER_TRANSIENT);
123718 }
123719
123720 SQLCIPHER_PRIVATE int sqlcipher3Fts3IsIdChar(char c){
123721   static const char isFtsIdChar[] = {
123722       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 0x */
123723       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 1x */
123724       0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* 2x */
123725       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,  /* 3x */
123726       0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 4x */
123727       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,  /* 5x */
123728       0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* 6x */
123729       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,  /* 7x */
123730   };
123731   return (c&0x80 || isFtsIdChar[(int)(c)]);
123732 }
123733
123734 SQLCIPHER_PRIVATE const char *sqlcipher3Fts3NextToken(const char *zStr, int *pn){
123735   const char *z1;
123736   const char *z2 = 0;
123737
123738   /* Find the start of the next token. */
123739   z1 = zStr;
123740   while( z2==0 ){
123741     char c = *z1;
123742     switch( c ){
123743       case '\0': return 0;        /* No more tokens here */
123744       case '\'':
123745       case '"':
123746       case '`': {
123747         z2 = z1;
123748         while( *++z2 && (*z2!=c || *++z2==c) );
123749         break;
123750       }
123751       case '[':
123752         z2 = &z1[1];
123753         while( *z2 && z2[0]!=']' ) z2++;
123754         if( *z2 ) z2++;
123755         break;
123756
123757       default:
123758         if( sqlcipher3Fts3IsIdChar(*z1) ){
123759           z2 = &z1[1];
123760           while( sqlcipher3Fts3IsIdChar(*z2) ) z2++;
123761         }else{
123762           z1++;
123763         }
123764     }
123765   }
123766
123767   *pn = (int)(z2-z1);
123768   return z1;
123769 }
123770
123771 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitTokenizer(
123772   Fts3Hash *pHash,                /* Tokenizer hash table */
123773   const char *zArg,               /* Tokenizer name */
123774   sqlcipher3_tokenizer **ppTok,      /* OUT: Tokenizer (if applicable) */
123775   char **pzErr                    /* OUT: Set to malloced error message */
123776 ){
123777   int rc;
123778   char *z = (char *)zArg;
123779   int n = 0;
123780   char *zCopy;
123781   char *zEnd;                     /* Pointer to nul-term of zCopy */
123782   sqlcipher3_tokenizer_module *m;
123783
123784   zCopy = sqlcipher3_mprintf("%s", zArg);
123785   if( !zCopy ) return SQLCIPHER_NOMEM;
123786   zEnd = &zCopy[strlen(zCopy)];
123787
123788   z = (char *)sqlcipher3Fts3NextToken(zCopy, &n);
123789   z[n] = '\0';
123790   sqlcipher3Fts3Dequote(z);
123791
123792   m = (sqlcipher3_tokenizer_module *)sqlcipher3Fts3HashFind(pHash,z,(int)strlen(z)+1);
123793   if( !m ){
123794     *pzErr = sqlcipher3_mprintf("unknown tokenizer: %s", z);
123795     rc = SQLCIPHER_ERROR;
123796   }else{
123797     char const **aArg = 0;
123798     int iArg = 0;
123799     z = &z[n+1];
123800     while( z<zEnd && (NULL!=(z = (char *)sqlcipher3Fts3NextToken(z, &n))) ){
123801       int nNew = sizeof(char *)*(iArg+1);
123802       char const **aNew = (const char **)sqlcipher3_realloc((void *)aArg, nNew);
123803       if( !aNew ){
123804         sqlcipher3_free(zCopy);
123805         sqlcipher3_free((void *)aArg);
123806         return SQLCIPHER_NOMEM;
123807       }
123808       aArg = aNew;
123809       aArg[iArg++] = z;
123810       z[n] = '\0';
123811       sqlcipher3Fts3Dequote(z);
123812       z = &z[n+1];
123813     }
123814     rc = m->xCreate(iArg, aArg, ppTok);
123815     assert( rc!=SQLCIPHER_OK || *ppTok );
123816     if( rc!=SQLCIPHER_OK ){
123817       *pzErr = sqlcipher3_mprintf("unknown tokenizer");
123818     }else{
123819       (*ppTok)->pModule = m; 
123820     }
123821     sqlcipher3_free((void *)aArg);
123822   }
123823
123824   sqlcipher3_free(zCopy);
123825   return rc;
123826 }
123827
123828
123829 #ifdef SQLCIPHER_TEST
123830
123831 /* #include <tcl.h> */
123832 /* #include <string.h> */
123833
123834 /*
123835 ** Implementation of a special SQL scalar function for testing tokenizers 
123836 ** designed to be used in concert with the Tcl testing framework. This
123837 ** function must be called with two arguments:
123838 **
123839 **   SELECT <function-name>(<key-name>, <input-string>);
123840 **   SELECT <function-name>(<key-name>, <pointer>);
123841 **
123842 ** where <function-name> is the name passed as the second argument
123843 ** to the sqlcipher3Fts3InitHashTable() function (e.g. 'fts3_tokenizer')
123844 ** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test').
123845 **
123846 ** The return value is a string that may be interpreted as a Tcl
123847 ** list. For each token in the <input-string>, three elements are
123848 ** added to the returned list. The first is the token position, the 
123849 ** second is the token text (folded, stemmed, etc.) and the third is the
123850 ** substring of <input-string> associated with the token. For example, 
123851 ** using the built-in "simple" tokenizer:
123852 **
123853 **   SELECT fts_tokenizer_test('simple', 'I don't see how');
123854 **
123855 ** will return the string:
123856 **
123857 **   "{0 i I 1 dont don't 2 see see 3 how how}"
123858 **   
123859 */
123860 static void testFunc(
123861   sqlcipher3_context *context,
123862   int argc,
123863   sqlcipher3_value **argv
123864 ){
123865   Fts3Hash *pHash;
123866   sqlcipher3_tokenizer_module *p;
123867   sqlcipher3_tokenizer *pTokenizer = 0;
123868   sqlcipher3_tokenizer_cursor *pCsr = 0;
123869
123870   const char *zErr = 0;
123871
123872   const char *zName;
123873   int nName;
123874   const char *zInput;
123875   int nInput;
123876
123877   const char *zArg = 0;
123878
123879   const char *zToken;
123880   int nToken;
123881   int iStart;
123882   int iEnd;
123883   int iPos;
123884
123885   Tcl_Obj *pRet;
123886
123887   assert( argc==2 || argc==3 );
123888
123889   nName = sqlcipher3_value_bytes(argv[0]);
123890   zName = (const char *)sqlcipher3_value_text(argv[0]);
123891   nInput = sqlcipher3_value_bytes(argv[argc-1]);
123892   zInput = (const char *)sqlcipher3_value_text(argv[argc-1]);
123893
123894   if( argc==3 ){
123895     zArg = (const char *)sqlcipher3_value_text(argv[1]);
123896   }
123897
123898   pHash = (Fts3Hash *)sqlcipher3_user_data(context);
123899   p = (sqlcipher3_tokenizer_module *)sqlcipher3Fts3HashFind(pHash, zName, nName+1);
123900
123901   if( !p ){
123902     char *zErr = sqlcipher3_mprintf("unknown tokenizer: %s", zName);
123903     sqlcipher3_result_error(context, zErr, -1);
123904     sqlcipher3_free(zErr);
123905     return;
123906   }
123907
123908   pRet = Tcl_NewObj();
123909   Tcl_IncrRefCount(pRet);
123910
123911   if( SQLCIPHER_OK!=p->xCreate(zArg ? 1 : 0, &zArg, &pTokenizer) ){
123912     zErr = "error in xCreate()";
123913     goto finish;
123914   }
123915   pTokenizer->pModule = p;
123916   if( SQLCIPHER_OK!=p->xOpen(pTokenizer, zInput, nInput, &pCsr) ){
123917     zErr = "error in xOpen()";
123918     goto finish;
123919   }
123920   pCsr->pTokenizer = pTokenizer;
123921
123922   while( SQLCIPHER_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
123923     Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos));
123924     Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
123925     zToken = &zInput[iStart];
123926     nToken = iEnd-iStart;
123927     Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
123928   }
123929
123930   if( SQLCIPHER_OK!=p->xClose(pCsr) ){
123931     zErr = "error in xClose()";
123932     goto finish;
123933   }
123934   if( SQLCIPHER_OK!=p->xDestroy(pTokenizer) ){
123935     zErr = "error in xDestroy()";
123936     goto finish;
123937   }
123938
123939 finish:
123940   if( zErr ){
123941     sqlcipher3_result_error(context, zErr, -1);
123942   }else{
123943     sqlcipher3_result_text(context, Tcl_GetString(pRet), -1, SQLCIPHER_TRANSIENT);
123944   }
123945   Tcl_DecrRefCount(pRet);
123946 }
123947
123948 static
123949 int registerTokenizer(
123950   sqlcipher3 *db, 
123951   char *zName, 
123952   const sqlcipher3_tokenizer_module *p
123953 ){
123954   int rc;
123955   sqlcipher3_stmt *pStmt;
123956   const char zSql[] = "SELECT fts3_tokenizer(?, ?)";
123957
123958   rc = sqlcipher3_prepare_v2(db, zSql, -1, &pStmt, 0);
123959   if( rc!=SQLCIPHER_OK ){
123960     return rc;
123961   }
123962
123963   sqlcipher3_bind_text(pStmt, 1, zName, -1, SQLCIPHER_STATIC);
123964   sqlcipher3_bind_blob(pStmt, 2, &p, sizeof(p), SQLCIPHER_STATIC);
123965   sqlcipher3_step(pStmt);
123966
123967   return sqlcipher3_finalize(pStmt);
123968 }
123969
123970 static
123971 int queryTokenizer(
123972   sqlcipher3 *db, 
123973   char *zName,  
123974   const sqlcipher3_tokenizer_module **pp
123975 ){
123976   int rc;
123977   sqlcipher3_stmt *pStmt;
123978   const char zSql[] = "SELECT fts3_tokenizer(?)";
123979
123980   *pp = 0;
123981   rc = sqlcipher3_prepare_v2(db, zSql, -1, &pStmt, 0);
123982   if( rc!=SQLCIPHER_OK ){
123983     return rc;
123984   }
123985
123986   sqlcipher3_bind_text(pStmt, 1, zName, -1, SQLCIPHER_STATIC);
123987   if( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
123988     if( sqlcipher3_column_type(pStmt, 0)==SQLCIPHER_BLOB ){
123989       memcpy((void *)pp, sqlcipher3_column_blob(pStmt, 0), sizeof(*pp));
123990     }
123991   }
123992
123993   return sqlcipher3_finalize(pStmt);
123994 }
123995
123996 SQLCIPHER_PRIVATE void sqlcipher3Fts3SimpleTokenizerModule(sqlcipher3_tokenizer_module const**ppModule);
123997
123998 /*
123999 ** Implementation of the scalar function fts3_tokenizer_internal_test().
124000 ** This function is used for testing only, it is not included in the
124001 ** build unless SQLCIPHER_TEST is defined.
124002 **
124003 ** The purpose of this is to test that the fts3_tokenizer() function
124004 ** can be used as designed by the C-code in the queryTokenizer and
124005 ** registerTokenizer() functions above. These two functions are repeated
124006 ** in the README.tokenizer file as an example, so it is important to
124007 ** test them.
124008 **
124009 ** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar
124010 ** function with no arguments. An assert() will fail if a problem is
124011 ** detected. i.e.:
124012 **
124013 **     SELECT fts3_tokenizer_internal_test();
124014 **
124015 */
124016 static void intTestFunc(
124017   sqlcipher3_context *context,
124018   int argc,
124019   sqlcipher3_value **argv
124020 ){
124021   int rc;
124022   const sqlcipher3_tokenizer_module *p1;
124023   const sqlcipher3_tokenizer_module *p2;
124024   sqlcipher3 *db = (sqlcipher3 *)sqlcipher3_user_data(context);
124025
124026   UNUSED_PARAMETER(argc);
124027   UNUSED_PARAMETER(argv);
124028
124029   /* Test the query function */
124030   sqlcipher3Fts3SimpleTokenizerModule(&p1);
124031   rc = queryTokenizer(db, "simple", &p2);
124032   assert( rc==SQLCIPHER_OK );
124033   assert( p1==p2 );
124034   rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124035   assert( rc==SQLCIPHER_ERROR );
124036   assert( p2==0 );
124037   assert( 0==strcmp(sqlcipher3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
124038
124039   /* Test the storage function */
124040   rc = registerTokenizer(db, "nosuchtokenizer", p1);
124041   assert( rc==SQLCIPHER_OK );
124042   rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124043   assert( rc==SQLCIPHER_OK );
124044   assert( p2==p1 );
124045
124046   sqlcipher3_result_text(context, "ok", -1, SQLCIPHER_STATIC);
124047 }
124048
124049 #endif
124050
124051 /*
124052 ** Set up SQL objects in database db used to access the contents of
124053 ** the hash table pointed to by argument pHash. The hash table must
124054 ** been initialised to use string keys, and to take a private copy 
124055 ** of the key when a value is inserted. i.e. by a call similar to:
124056 **
124057 **    sqlcipher3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
124058 **
124059 ** This function adds a scalar function (see header comment above
124060 ** scalarFunc() in this file for details) and, if ENABLE_TABLE is
124061 ** defined at compilation time, a temporary virtual table (see header 
124062 ** comment above struct HashTableVtab) to the database schema. Both 
124063 ** provide read/write access to the contents of *pHash.
124064 **
124065 ** The third argument to this function, zName, is used as the name
124066 ** of both the scalar and, if created, the virtual table.
124067 */
124068 SQLCIPHER_PRIVATE int sqlcipher3Fts3InitHashTable(
124069   sqlcipher3 *db, 
124070   Fts3Hash *pHash, 
124071   const char *zName
124072 ){
124073   int rc = SQLCIPHER_OK;
124074   void *p = (void *)pHash;
124075   const int any = SQLCIPHER_ANY;
124076
124077 #ifdef SQLCIPHER_TEST
124078   char *zTest = 0;
124079   char *zTest2 = 0;
124080   void *pdb = (void *)db;
124081   zTest = sqlcipher3_mprintf("%s_test", zName);
124082   zTest2 = sqlcipher3_mprintf("%s_internal_test", zName);
124083   if( !zTest || !zTest2 ){
124084     rc = SQLCIPHER_NOMEM;
124085   }
124086 #endif
124087
124088   if( SQLCIPHER_OK==rc ){
124089     rc = sqlcipher3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0);
124090   }
124091   if( SQLCIPHER_OK==rc ){
124092     rc = sqlcipher3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0);
124093   }
124094 #ifdef SQLCIPHER_TEST
124095   if( SQLCIPHER_OK==rc ){
124096     rc = sqlcipher3_create_function(db, zTest, 2, any, p, testFunc, 0, 0);
124097   }
124098   if( SQLCIPHER_OK==rc ){
124099     rc = sqlcipher3_create_function(db, zTest, 3, any, p, testFunc, 0, 0);
124100   }
124101   if( SQLCIPHER_OK==rc ){
124102     rc = sqlcipher3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0);
124103   }
124104 #endif
124105
124106 #ifdef SQLCIPHER_TEST
124107   sqlcipher3_free(zTest);
124108   sqlcipher3_free(zTest2);
124109 #endif
124110
124111   return rc;
124112 }
124113
124114 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
124115
124116 /************** End of fts3_tokenizer.c **************************************/
124117 /************** Begin file fts3_tokenizer1.c *********************************/
124118 /*
124119 ** 2006 Oct 10
124120 **
124121 ** The author disclaims copyright to this source code.  In place of
124122 ** a legal notice, here is a blessing:
124123 **
124124 **    May you do good and not evil.
124125 **    May you find forgiveness for yourself and forgive others.
124126 **    May you share freely, never taking more than you give.
124127 **
124128 ******************************************************************************
124129 **
124130 ** Implementation of the "simple" full-text-search tokenizer.
124131 */
124132
124133 /*
124134 ** The code in this file is only compiled if:
124135 **
124136 **     * The FTS3 module is being built as an extension
124137 **       (in which case SQLCIPHER_CORE is not defined), or
124138 **
124139 **     * The FTS3 module is being built into the core of
124140 **       SQLite (in which case SQLCIPHER_ENABLE_FTS3 is defined).
124141 */
124142 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
124143
124144 /* #include <assert.h> */
124145 /* #include <stdlib.h> */
124146 /* #include <stdio.h> */
124147 /* #include <string.h> */
124148
124149
124150 typedef struct simple_tokenizer {
124151   sqlcipher3_tokenizer base;
124152   char delim[128];             /* flag ASCII delimiters */
124153 } simple_tokenizer;
124154
124155 typedef struct simple_tokenizer_cursor {
124156   sqlcipher3_tokenizer_cursor base;
124157   const char *pInput;          /* input we are tokenizing */
124158   int nBytes;                  /* size of the input */
124159   int iOffset;                 /* current position in pInput */
124160   int iToken;                  /* index of next token to be returned */
124161   char *pToken;                /* storage for current token */
124162   int nTokenAllocated;         /* space allocated to zToken buffer */
124163 } simple_tokenizer_cursor;
124164
124165
124166 static int simpleDelim(simple_tokenizer *t, unsigned char c){
124167   return c<0x80 && t->delim[c];
124168 }
124169 static int fts3_isalnum(int x){
124170   return (x>='0' && x<='9') || (x>='A' && x<='Z') || (x>='a' && x<='z');
124171 }
124172
124173 /*
124174 ** Create a new tokenizer instance.
124175 */
124176 static int simpleCreate(
124177   int argc, const char * const *argv,
124178   sqlcipher3_tokenizer **ppTokenizer
124179 ){
124180   simple_tokenizer *t;
124181
124182   t = (simple_tokenizer *) sqlcipher3_malloc(sizeof(*t));
124183   if( t==NULL ) return SQLCIPHER_NOMEM;
124184   memset(t, 0, sizeof(*t));
124185
124186   /* TODO(shess) Delimiters need to remain the same from run to run,
124187   ** else we need to reindex.  One solution would be a meta-table to
124188   ** track such information in the database, then we'd only want this
124189   ** information on the initial create.
124190   */
124191   if( argc>1 ){
124192     int i, n = (int)strlen(argv[1]);
124193     for(i=0; i<n; i++){
124194       unsigned char ch = argv[1][i];
124195       /* We explicitly don't support UTF-8 delimiters for now. */
124196       if( ch>=0x80 ){
124197         sqlcipher3_free(t);
124198         return SQLCIPHER_ERROR;
124199       }
124200       t->delim[ch] = 1;
124201     }
124202   } else {
124203     /* Mark non-alphanumeric ASCII characters as delimiters */
124204     int i;
124205     for(i=1; i<0x80; i++){
124206       t->delim[i] = !fts3_isalnum(i) ? -1 : 0;
124207     }
124208   }
124209
124210   *ppTokenizer = &t->base;
124211   return SQLCIPHER_OK;
124212 }
124213
124214 /*
124215 ** Destroy a tokenizer
124216 */
124217 static int simpleDestroy(sqlcipher3_tokenizer *pTokenizer){
124218   sqlcipher3_free(pTokenizer);
124219   return SQLCIPHER_OK;
124220 }
124221
124222 /*
124223 ** Prepare to begin tokenizing a particular string.  The input
124224 ** string to be tokenized is pInput[0..nBytes-1].  A cursor
124225 ** used to incrementally tokenize this string is returned in 
124226 ** *ppCursor.
124227 */
124228 static int simpleOpen(
124229   sqlcipher3_tokenizer *pTokenizer,         /* The tokenizer */
124230   const char *pInput, int nBytes,        /* String to be tokenized */
124231   sqlcipher3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
124232 ){
124233   simple_tokenizer_cursor *c;
124234
124235   UNUSED_PARAMETER(pTokenizer);
124236
124237   c = (simple_tokenizer_cursor *) sqlcipher3_malloc(sizeof(*c));
124238   if( c==NULL ) return SQLCIPHER_NOMEM;
124239
124240   c->pInput = pInput;
124241   if( pInput==0 ){
124242     c->nBytes = 0;
124243   }else if( nBytes<0 ){
124244     c->nBytes = (int)strlen(pInput);
124245   }else{
124246     c->nBytes = nBytes;
124247   }
124248   c->iOffset = 0;                 /* start tokenizing at the beginning */
124249   c->iToken = 0;
124250   c->pToken = NULL;               /* no space allocated, yet. */
124251   c->nTokenAllocated = 0;
124252
124253   *ppCursor = &c->base;
124254   return SQLCIPHER_OK;
124255 }
124256
124257 /*
124258 ** Close a tokenization cursor previously opened by a call to
124259 ** simpleOpen() above.
124260 */
124261 static int simpleClose(sqlcipher3_tokenizer_cursor *pCursor){
124262   simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
124263   sqlcipher3_free(c->pToken);
124264   sqlcipher3_free(c);
124265   return SQLCIPHER_OK;
124266 }
124267
124268 /*
124269 ** Extract the next token from a tokenization cursor.  The cursor must
124270 ** have been opened by a prior call to simpleOpen().
124271 */
124272 static int simpleNext(
124273   sqlcipher3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
124274   const char **ppToken,               /* OUT: *ppToken is the token text */
124275   int *pnBytes,                       /* OUT: Number of bytes in token */
124276   int *piStartOffset,                 /* OUT: Starting offset of token */
124277   int *piEndOffset,                   /* OUT: Ending offset of token */
124278   int *piPosition                     /* OUT: Position integer of token */
124279 ){
124280   simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
124281   simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
124282   unsigned char *p = (unsigned char *)c->pInput;
124283
124284   while( c->iOffset<c->nBytes ){
124285     int iStartOffset;
124286
124287     /* Scan past delimiter characters */
124288     while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
124289       c->iOffset++;
124290     }
124291
124292     /* Count non-delimiter characters. */
124293     iStartOffset = c->iOffset;
124294     while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
124295       c->iOffset++;
124296     }
124297
124298     if( c->iOffset>iStartOffset ){
124299       int i, n = c->iOffset-iStartOffset;
124300       if( n>c->nTokenAllocated ){
124301         char *pNew;
124302         c->nTokenAllocated = n+20;
124303         pNew = sqlcipher3_realloc(c->pToken, c->nTokenAllocated);
124304         if( !pNew ) return SQLCIPHER_NOMEM;
124305         c->pToken = pNew;
124306       }
124307       for(i=0; i<n; i++){
124308         /* TODO(shess) This needs expansion to handle UTF-8
124309         ** case-insensitivity.
124310         */
124311         unsigned char ch = p[iStartOffset+i];
124312         c->pToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch);
124313       }
124314       *ppToken = c->pToken;
124315       *pnBytes = n;
124316       *piStartOffset = iStartOffset;
124317       *piEndOffset = c->iOffset;
124318       *piPosition = c->iToken++;
124319
124320       return SQLCIPHER_OK;
124321     }
124322   }
124323   return SQLCIPHER_DONE;
124324 }
124325
124326 /*
124327 ** The set of routines that implement the simple tokenizer
124328 */
124329 static const sqlcipher3_tokenizer_module simpleTokenizerModule = {
124330   0,
124331   simpleCreate,
124332   simpleDestroy,
124333   simpleOpen,
124334   simpleClose,
124335   simpleNext,
124336 };
124337
124338 /*
124339 ** Allocate a new simple tokenizer.  Return a pointer to the new
124340 ** tokenizer in *ppModule
124341 */
124342 SQLCIPHER_PRIVATE void sqlcipher3Fts3SimpleTokenizerModule(
124343   sqlcipher3_tokenizer_module const**ppModule
124344 ){
124345   *ppModule = &simpleTokenizerModule;
124346 }
124347
124348 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
124349
124350 /************** End of fts3_tokenizer1.c *************************************/
124351 /************** Begin file fts3_write.c **************************************/
124352 /*
124353 ** 2009 Oct 23
124354 **
124355 ** The author disclaims copyright to this source code.  In place of
124356 ** a legal notice, here is a blessing:
124357 **
124358 **    May you do good and not evil.
124359 **    May you find forgiveness for yourself and forgive others.
124360 **    May you share freely, never taking more than you give.
124361 **
124362 ******************************************************************************
124363 **
124364 ** This file is part of the SQLite FTS3 extension module. Specifically,
124365 ** this file contains code to insert, update and delete rows from FTS3
124366 ** tables. It also contains code to merge FTS3 b-tree segments. Some
124367 ** of the sub-routines used to merge segments are also used by the query 
124368 ** code in fts3.c.
124369 */
124370
124371 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
124372
124373 /* #include <string.h> */
124374 /* #include <assert.h> */
124375 /* #include <stdlib.h> */
124376
124377 /*
124378 ** When full-text index nodes are loaded from disk, the buffer that they
124379 ** are loaded into has the following number of bytes of padding at the end 
124380 ** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer
124381 ** of 920 bytes is allocated for it.
124382 **
124383 ** This means that if we have a pointer into a buffer containing node data,
124384 ** it is always safe to read up to two varints from it without risking an
124385 ** overread, even if the node data is corrupted.
124386 */
124387 #define FTS3_NODE_PADDING (FTS3_VARINT_MAX*2)
124388
124389 /*
124390 ** Under certain circumstances, b-tree nodes (doclists) can be loaded into
124391 ** memory incrementally instead of all at once. This can be a big performance
124392 ** win (reduced IO and CPU) if SQLite stops calling the virtual table xNext()
124393 ** method before retrieving all query results (as may happen, for example,
124394 ** if a query has a LIMIT clause).
124395 **
124396 ** Incremental loading is used for b-tree nodes FTS3_NODE_CHUNK_THRESHOLD 
124397 ** bytes and larger. Nodes are loaded in chunks of FTS3_NODE_CHUNKSIZE bytes.
124398 ** The code is written so that the hard lower-limit for each of these values 
124399 ** is 1. Clearly such small values would be inefficient, but can be useful 
124400 ** for testing purposes.
124401 **
124402 ** If this module is built with SQLCIPHER_TEST defined, these constants may
124403 ** be overridden at runtime for testing purposes. File fts3_test.c contains
124404 ** a Tcl interface to read and write the values.
124405 */
124406 #ifdef SQLCIPHER_TEST
124407 int test_fts3_node_chunksize = (4*1024);
124408 int test_fts3_node_chunk_threshold = (4*1024)*4;
124409 # define FTS3_NODE_CHUNKSIZE       test_fts3_node_chunksize
124410 # define FTS3_NODE_CHUNK_THRESHOLD test_fts3_node_chunk_threshold
124411 #else
124412 # define FTS3_NODE_CHUNKSIZE (4*1024) 
124413 # define FTS3_NODE_CHUNK_THRESHOLD (FTS3_NODE_CHUNKSIZE*4)
124414 #endif
124415
124416 typedef struct PendingList PendingList;
124417 typedef struct SegmentNode SegmentNode;
124418 typedef struct SegmentWriter SegmentWriter;
124419
124420 /*
124421 ** An instance of the following data structure is used to build doclists
124422 ** incrementally. See function fts3PendingListAppend() for details.
124423 */
124424 struct PendingList {
124425   int nData;
124426   char *aData;
124427   int nSpace;
124428   sqlcipher3_int64 iLastDocid;
124429   sqlcipher3_int64 iLastCol;
124430   sqlcipher3_int64 iLastPos;
124431 };
124432
124433
124434 /*
124435 ** Each cursor has a (possibly empty) linked list of the following objects.
124436 */
124437 struct Fts3DeferredToken {
124438   Fts3PhraseToken *pToken;        /* Pointer to corresponding expr token */
124439   int iCol;                       /* Column token must occur in */
124440   Fts3DeferredToken *pNext;       /* Next in list of deferred tokens */
124441   PendingList *pList;             /* Doclist is assembled here */
124442 };
124443
124444 /*
124445 ** An instance of this structure is used to iterate through the terms on
124446 ** a contiguous set of segment b-tree leaf nodes. Although the details of
124447 ** this structure are only manipulated by code in this file, opaque handles
124448 ** of type Fts3SegReader* are also used by code in fts3.c to iterate through
124449 ** terms when querying the full-text index. See functions:
124450 **
124451 **   sqlcipher3Fts3SegReaderNew()
124452 **   sqlcipher3Fts3SegReaderFree()
124453 **   sqlcipher3Fts3SegReaderIterate()
124454 **
124455 ** Methods used to manipulate Fts3SegReader structures:
124456 **
124457 **   fts3SegReaderNext()
124458 **   fts3SegReaderFirstDocid()
124459 **   fts3SegReaderNextDocid()
124460 */
124461 struct Fts3SegReader {
124462   int iIdx;                       /* Index within level, or 0x7FFFFFFF for PT */
124463
124464   sqlcipher3_int64 iStartBlock;      /* Rowid of first leaf block to traverse */
124465   sqlcipher3_int64 iLeafEndBlock;    /* Rowid of final leaf block to traverse */
124466   sqlcipher3_int64 iEndBlock;        /* Rowid of final block in segment (or 0) */
124467   sqlcipher3_int64 iCurrentBlock;    /* Current leaf block (or 0) */
124468
124469   char *aNode;                    /* Pointer to node data (or NULL) */
124470   int nNode;                      /* Size of buffer at aNode (or 0) */
124471   int nPopulate;                  /* If >0, bytes of buffer aNode[] loaded */
124472   sqlcipher3_blob *pBlob;            /* If not NULL, blob handle to read node */
124473
124474   Fts3HashElem **ppNextElem;
124475
124476   /* Variables set by fts3SegReaderNext(). These may be read directly
124477   ** by the caller. They are valid from the time SegmentReaderNew() returns
124478   ** until SegmentReaderNext() returns something other than SQLCIPHER_OK
124479   ** (i.e. SQLCIPHER_DONE).
124480   */
124481   int nTerm;                      /* Number of bytes in current term */
124482   char *zTerm;                    /* Pointer to current term */
124483   int nTermAlloc;                 /* Allocated size of zTerm buffer */
124484   char *aDoclist;                 /* Pointer to doclist of current entry */
124485   int nDoclist;                   /* Size of doclist in current entry */
124486
124487   /* The following variables are used by fts3SegReaderNextDocid() to iterate 
124488   ** through the current doclist (aDoclist/nDoclist).
124489   */
124490   char *pOffsetList;
124491   int nOffsetList;                /* For descending pending seg-readers only */
124492   sqlcipher3_int64 iDocid;
124493 };
124494
124495 #define fts3SegReaderIsPending(p) ((p)->ppNextElem!=0)
124496 #define fts3SegReaderIsRootOnly(p) ((p)->aNode==(char *)&(p)[1])
124497
124498 /*
124499 ** An instance of this structure is used to create a segment b-tree in the
124500 ** database. The internal details of this type are only accessed by the
124501 ** following functions:
124502 **
124503 **   fts3SegWriterAdd()
124504 **   fts3SegWriterFlush()
124505 **   fts3SegWriterFree()
124506 */
124507 struct SegmentWriter {
124508   SegmentNode *pTree;             /* Pointer to interior tree structure */
124509   sqlcipher3_int64 iFirst;           /* First slot in %_segments written */
124510   sqlcipher3_int64 iFree;            /* Next free slot in %_segments */
124511   char *zTerm;                    /* Pointer to previous term buffer */
124512   int nTerm;                      /* Number of bytes in zTerm */
124513   int nMalloc;                    /* Size of malloc'd buffer at zMalloc */
124514   char *zMalloc;                  /* Malloc'd space (possibly) used for zTerm */
124515   int nSize;                      /* Size of allocation at aData */
124516   int nData;                      /* Bytes of data in aData */
124517   char *aData;                    /* Pointer to block from malloc() */
124518 };
124519
124520 /*
124521 ** Type SegmentNode is used by the following three functions to create
124522 ** the interior part of the segment b+-tree structures (everything except
124523 ** the leaf nodes). These functions and type are only ever used by code
124524 ** within the fts3SegWriterXXX() family of functions described above.
124525 **
124526 **   fts3NodeAddTerm()
124527 **   fts3NodeWrite()
124528 **   fts3NodeFree()
124529 **
124530 ** When a b+tree is written to the database (either as a result of a merge
124531 ** or the pending-terms table being flushed), leaves are written into the 
124532 ** database file as soon as they are completely populated. The interior of
124533 ** the tree is assembled in memory and written out only once all leaves have
124534 ** been populated and stored. This is Ok, as the b+-tree fanout is usually
124535 ** very large, meaning that the interior of the tree consumes relatively 
124536 ** little memory.
124537 */
124538 struct SegmentNode {
124539   SegmentNode *pParent;           /* Parent node (or NULL for root node) */
124540   SegmentNode *pRight;            /* Pointer to right-sibling */
124541   SegmentNode *pLeftmost;         /* Pointer to left-most node of this depth */
124542   int nEntry;                     /* Number of terms written to node so far */
124543   char *zTerm;                    /* Pointer to previous term buffer */
124544   int nTerm;                      /* Number of bytes in zTerm */
124545   int nMalloc;                    /* Size of malloc'd buffer at zMalloc */
124546   char *zMalloc;                  /* Malloc'd space (possibly) used for zTerm */
124547   int nData;                      /* Bytes of valid data so far */
124548   char *aData;                    /* Node data */
124549 };
124550
124551 /*
124552 ** Valid values for the second argument to fts3SqlStmt().
124553 */
124554 #define SQL_DELETE_CONTENT             0
124555 #define SQL_IS_EMPTY                   1
124556 #define SQL_DELETE_ALL_CONTENT         2 
124557 #define SQL_DELETE_ALL_SEGMENTS        3
124558 #define SQL_DELETE_ALL_SEGDIR          4
124559 #define SQL_DELETE_ALL_DOCSIZE         5
124560 #define SQL_DELETE_ALL_STAT            6
124561 #define SQL_SELECT_CONTENT_BY_ROWID    7
124562 #define SQL_NEXT_SEGMENT_INDEX         8
124563 #define SQL_INSERT_SEGMENTS            9
124564 #define SQL_NEXT_SEGMENTS_ID          10
124565 #define SQL_INSERT_SEGDIR             11
124566 #define SQL_SELECT_LEVEL              12
124567 #define SQL_SELECT_LEVEL_RANGE        13
124568 #define SQL_SELECT_LEVEL_COUNT        14
124569 #define SQL_SELECT_SEGDIR_MAX_LEVEL   15
124570 #define SQL_DELETE_SEGDIR_LEVEL       16
124571 #define SQL_DELETE_SEGMENTS_RANGE     17
124572 #define SQL_CONTENT_INSERT            18
124573 #define SQL_DELETE_DOCSIZE            19
124574 #define SQL_REPLACE_DOCSIZE           20
124575 #define SQL_SELECT_DOCSIZE            21
124576 #define SQL_SELECT_DOCTOTAL           22
124577 #define SQL_REPLACE_DOCTOTAL          23
124578
124579 #define SQL_SELECT_ALL_PREFIX_LEVEL   24
124580 #define SQL_DELETE_ALL_TERMS_SEGDIR   25
124581
124582 #define SQL_DELETE_SEGDIR_RANGE       26
124583
124584 /*
124585 ** This function is used to obtain an SQLite prepared statement handle
124586 ** for the statement identified by the second argument. If successful,
124587 ** *pp is set to the requested statement handle and SQLCIPHER_OK returned.
124588 ** Otherwise, an SQLite error code is returned and *pp is set to 0.
124589 **
124590 ** If argument apVal is not NULL, then it must point to an array with
124591 ** at least as many entries as the requested statement has bound 
124592 ** parameters. The values are bound to the statements parameters before
124593 ** returning.
124594 */
124595 static int fts3SqlStmt(
124596   Fts3Table *p,                   /* Virtual table handle */
124597   int eStmt,                      /* One of the SQL_XXX constants above */
124598   sqlcipher3_stmt **pp,              /* OUT: Statement handle */
124599   sqlcipher3_value **apVal           /* Values to bind to statement */
124600 ){
124601   const char *azSql[] = {
124602 /* 0  */  "DELETE FROM %Q.'%q_content' WHERE rowid = ?",
124603 /* 1  */  "SELECT NOT EXISTS(SELECT docid FROM %Q.'%q_content' WHERE rowid!=?)",
124604 /* 2  */  "DELETE FROM %Q.'%q_content'",
124605 /* 3  */  "DELETE FROM %Q.'%q_segments'",
124606 /* 4  */  "DELETE FROM %Q.'%q_segdir'",
124607 /* 5  */  "DELETE FROM %Q.'%q_docsize'",
124608 /* 6  */  "DELETE FROM %Q.'%q_stat'",
124609 /* 7  */  "SELECT %s WHERE rowid=?",
124610 /* 8  */  "SELECT (SELECT max(idx) FROM %Q.'%q_segdir' WHERE level = ?) + 1",
124611 /* 9  */  "INSERT INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)",
124612 /* 10 */  "SELECT coalesce((SELECT max(blockid) FROM %Q.'%q_segments') + 1, 1)",
124613 /* 11 */  "INSERT INTO %Q.'%q_segdir' VALUES(?,?,?,?,?,?)",
124614
124615           /* Return segments in order from oldest to newest.*/ 
124616 /* 12 */  "SELECT idx, start_block, leaves_end_block, end_block, root "
124617             "FROM %Q.'%q_segdir' WHERE level = ? ORDER BY idx ASC",
124618 /* 13 */  "SELECT idx, start_block, leaves_end_block, end_block, root "
124619             "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?"
124620             "ORDER BY level DESC, idx ASC",
124621
124622 /* 14 */  "SELECT count(*) FROM %Q.'%q_segdir' WHERE level = ?",
124623 /* 15 */  "SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?",
124624
124625 /* 16 */  "DELETE FROM %Q.'%q_segdir' WHERE level = ?",
124626 /* 17 */  "DELETE FROM %Q.'%q_segments' WHERE blockid BETWEEN ? AND ?",
124627 /* 18 */  "INSERT INTO %Q.'%q_content' VALUES(%s)",
124628 /* 19 */  "DELETE FROM %Q.'%q_docsize' WHERE docid = ?",
124629 /* 20 */  "REPLACE INTO %Q.'%q_docsize' VALUES(?,?)",
124630 /* 21 */  "SELECT size FROM %Q.'%q_docsize' WHERE docid=?",
124631 /* 22 */  "SELECT value FROM %Q.'%q_stat' WHERE id=0",
124632 /* 23 */  "REPLACE INTO %Q.'%q_stat' VALUES(0,?)",
124633 /* 24 */  "",
124634 /* 25 */  "",
124635
124636 /* 26 */ "DELETE FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?",
124637
124638   };
124639   int rc = SQLCIPHER_OK;
124640   sqlcipher3_stmt *pStmt;
124641
124642   assert( SizeofArray(azSql)==SizeofArray(p->aStmt) );
124643   assert( eStmt<SizeofArray(azSql) && eStmt>=0 );
124644   
124645   pStmt = p->aStmt[eStmt];
124646   if( !pStmt ){
124647     char *zSql;
124648     if( eStmt==SQL_CONTENT_INSERT ){
124649       zSql = sqlcipher3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
124650     }else if( eStmt==SQL_SELECT_CONTENT_BY_ROWID ){
124651       zSql = sqlcipher3_mprintf(azSql[eStmt], p->zReadExprlist);
124652     }else{
124653       zSql = sqlcipher3_mprintf(azSql[eStmt], p->zDb, p->zName);
124654     }
124655     if( !zSql ){
124656       rc = SQLCIPHER_NOMEM;
124657     }else{
124658       rc = sqlcipher3_prepare_v2(p->db, zSql, -1, &pStmt, NULL);
124659       sqlcipher3_free(zSql);
124660       assert( rc==SQLCIPHER_OK || pStmt==0 );
124661       p->aStmt[eStmt] = pStmt;
124662     }
124663   }
124664   if( apVal ){
124665     int i;
124666     int nParam = sqlcipher3_bind_parameter_count(pStmt);
124667     for(i=0; rc==SQLCIPHER_OK && i<nParam; i++){
124668       rc = sqlcipher3_bind_value(pStmt, i+1, apVal[i]);
124669     }
124670   }
124671   *pp = pStmt;
124672   return rc;
124673 }
124674
124675 static int fts3SelectDocsize(
124676   Fts3Table *pTab,                /* FTS3 table handle */
124677   int eStmt,                      /* Either SQL_SELECT_DOCSIZE or DOCTOTAL */
124678   sqlcipher3_int64 iDocid,           /* Docid to bind for SQL_SELECT_DOCSIZE */
124679   sqlcipher3_stmt **ppStmt           /* OUT: Statement handle */
124680 ){
124681   sqlcipher3_stmt *pStmt = 0;        /* Statement requested from fts3SqlStmt() */
124682   int rc;                         /* Return code */
124683
124684   assert( eStmt==SQL_SELECT_DOCSIZE || eStmt==SQL_SELECT_DOCTOTAL );
124685
124686   rc = fts3SqlStmt(pTab, eStmt, &pStmt, 0);
124687   if( rc==SQLCIPHER_OK ){
124688     if( eStmt==SQL_SELECT_DOCSIZE ){
124689       sqlcipher3_bind_int64(pStmt, 1, iDocid);
124690     }
124691     rc = sqlcipher3_step(pStmt);
124692     if( rc!=SQLCIPHER_ROW || sqlcipher3_column_type(pStmt, 0)!=SQLCIPHER_BLOB ){
124693       rc = sqlcipher3_reset(pStmt);
124694       if( rc==SQLCIPHER_OK ) rc = FTS_CORRUPT_VTAB;
124695       pStmt = 0;
124696     }else{
124697       rc = SQLCIPHER_OK;
124698     }
124699   }
124700
124701   *ppStmt = pStmt;
124702   return rc;
124703 }
124704
124705 SQLCIPHER_PRIVATE int sqlcipher3Fts3SelectDoctotal(
124706   Fts3Table *pTab,                /* Fts3 table handle */
124707   sqlcipher3_stmt **ppStmt           /* OUT: Statement handle */
124708 ){
124709   return fts3SelectDocsize(pTab, SQL_SELECT_DOCTOTAL, 0, ppStmt);
124710 }
124711
124712 SQLCIPHER_PRIVATE int sqlcipher3Fts3SelectDocsize(
124713   Fts3Table *pTab,                /* Fts3 table handle */
124714   sqlcipher3_int64 iDocid,           /* Docid to read size data for */
124715   sqlcipher3_stmt **ppStmt           /* OUT: Statement handle */
124716 ){
124717   return fts3SelectDocsize(pTab, SQL_SELECT_DOCSIZE, iDocid, ppStmt);
124718 }
124719
124720 /*
124721 ** Similar to fts3SqlStmt(). Except, after binding the parameters in
124722 ** array apVal[] to the SQL statement identified by eStmt, the statement
124723 ** is executed.
124724 **
124725 ** Returns SQLCIPHER_OK if the statement is successfully executed, or an
124726 ** SQLite error code otherwise.
124727 */
124728 static void fts3SqlExec(
124729   int *pRC,                /* Result code */
124730   Fts3Table *p,            /* The FTS3 table */
124731   int eStmt,               /* Index of statement to evaluate */
124732   sqlcipher3_value **apVal    /* Parameters to bind */
124733 ){
124734   sqlcipher3_stmt *pStmt;
124735   int rc;
124736   if( *pRC ) return;
124737   rc = fts3SqlStmt(p, eStmt, &pStmt, apVal); 
124738   if( rc==SQLCIPHER_OK ){
124739     sqlcipher3_step(pStmt);
124740     rc = sqlcipher3_reset(pStmt);
124741   }
124742   *pRC = rc;
124743 }
124744
124745
124746 /*
124747 ** This function ensures that the caller has obtained a shared-cache
124748 ** table-lock on the %_content table. This is required before reading
124749 ** data from the fts3 table. If this lock is not acquired first, then
124750 ** the caller may end up holding read-locks on the %_segments and %_segdir
124751 ** tables, but no read-lock on the %_content table. If this happens 
124752 ** a second connection will be able to write to the fts3 table, but
124753 ** attempting to commit those writes might return SQLCIPHER_LOCKED or
124754 ** SQLCIPHER_LOCKED_SHAREDCACHE (because the commit attempts to obtain 
124755 ** write-locks on the %_segments and %_segdir ** tables). 
124756 **
124757 ** We try to avoid this because if FTS3 returns any error when committing
124758 ** a transaction, the whole transaction will be rolled back. And this is
124759 ** not what users expect when they get SQLCIPHER_LOCKED_SHAREDCACHE. It can
124760 ** still happen if the user reads data directly from the %_segments or
124761 ** %_segdir tables instead of going through FTS3 though.
124762 **
124763 ** This reasoning does not apply to a content=xxx table.
124764 */
124765 SQLCIPHER_PRIVATE int sqlcipher3Fts3ReadLock(Fts3Table *p){
124766   int rc;                         /* Return code */
124767   sqlcipher3_stmt *pStmt;            /* Statement used to obtain lock */
124768
124769   if( p->zContentTbl==0 ){
124770     rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pStmt, 0);
124771     if( rc==SQLCIPHER_OK ){
124772       sqlcipher3_bind_null(pStmt, 1);
124773       sqlcipher3_step(pStmt);
124774       rc = sqlcipher3_reset(pStmt);
124775     }
124776   }else{
124777     rc = SQLCIPHER_OK;
124778   }
124779
124780   return rc;
124781 }
124782
124783 /*
124784 ** Set *ppStmt to a statement handle that may be used to iterate through
124785 ** all rows in the %_segdir table, from oldest to newest. If successful,
124786 ** return SQLCIPHER_OK. If an error occurs while preparing the statement, 
124787 ** return an SQLite error code.
124788 **
124789 ** There is only ever one instance of this SQL statement compiled for
124790 ** each FTS3 table.
124791 **
124792 ** The statement returns the following columns from the %_segdir table:
124793 **
124794 **   0: idx
124795 **   1: start_block
124796 **   2: leaves_end_block
124797 **   3: end_block
124798 **   4: root
124799 */
124800 SQLCIPHER_PRIVATE int sqlcipher3Fts3AllSegdirs(
124801   Fts3Table *p,                   /* FTS3 table */
124802   int iIndex,                     /* Index for p->aIndex[] */
124803   int iLevel,                     /* Level to select */
124804   sqlcipher3_stmt **ppStmt           /* OUT: Compiled statement */
124805 ){
124806   int rc;
124807   sqlcipher3_stmt *pStmt = 0;
124808
124809   assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 );
124810   assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
124811   assert( iIndex>=0 && iIndex<p->nIndex );
124812
124813   if( iLevel<0 ){
124814     /* "SELECT * FROM %_segdir WHERE level BETWEEN ? AND ? ORDER BY ..." */
124815     rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0);
124816     if( rc==SQLCIPHER_OK ){ 
124817       sqlcipher3_bind_int(pStmt, 1, iIndex*FTS3_SEGDIR_MAXLEVEL);
124818       sqlcipher3_bind_int(pStmt, 2, (iIndex+1)*FTS3_SEGDIR_MAXLEVEL-1);
124819     }
124820   }else{
124821     /* "SELECT * FROM %_segdir WHERE level = ? ORDER BY ..." */
124822     rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
124823     if( rc==SQLCIPHER_OK ){ 
124824       sqlcipher3_bind_int(pStmt, 1, iLevel+iIndex*FTS3_SEGDIR_MAXLEVEL);
124825     }
124826   }
124827   *ppStmt = pStmt;
124828   return rc;
124829 }
124830
124831
124832 /*
124833 ** Append a single varint to a PendingList buffer. SQLCIPHER_OK is returned
124834 ** if successful, or an SQLite error code otherwise.
124835 **
124836 ** This function also serves to allocate the PendingList structure itself.
124837 ** For example, to create a new PendingList structure containing two
124838 ** varints:
124839 **
124840 **   PendingList *p = 0;
124841 **   fts3PendingListAppendVarint(&p, 1);
124842 **   fts3PendingListAppendVarint(&p, 2);
124843 */
124844 static int fts3PendingListAppendVarint(
124845   PendingList **pp,               /* IN/OUT: Pointer to PendingList struct */
124846   sqlcipher3_int64 i                 /* Value to append to data */
124847 ){
124848   PendingList *p = *pp;
124849
124850   /* Allocate or grow the PendingList as required. */
124851   if( !p ){
124852     p = sqlcipher3_malloc(sizeof(*p) + 100);
124853     if( !p ){
124854       return SQLCIPHER_NOMEM;
124855     }
124856     p->nSpace = 100;
124857     p->aData = (char *)&p[1];
124858     p->nData = 0;
124859   }
124860   else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){
124861     int nNew = p->nSpace * 2;
124862     p = sqlcipher3_realloc(p, sizeof(*p) + nNew);
124863     if( !p ){
124864       sqlcipher3_free(*pp);
124865       *pp = 0;
124866       return SQLCIPHER_NOMEM;
124867     }
124868     p->nSpace = nNew;
124869     p->aData = (char *)&p[1];
124870   }
124871
124872   /* Append the new serialized varint to the end of the list. */
124873   p->nData += sqlcipher3Fts3PutVarint(&p->aData[p->nData], i);
124874   p->aData[p->nData] = '\0';
124875   *pp = p;
124876   return SQLCIPHER_OK;
124877 }
124878
124879 /*
124880 ** Add a docid/column/position entry to a PendingList structure. Non-zero
124881 ** is returned if the structure is sqlcipher3_realloced as part of adding
124882 ** the entry. Otherwise, zero.
124883 **
124884 ** If an OOM error occurs, *pRc is set to SQLCIPHER_NOMEM before returning.
124885 ** Zero is always returned in this case. Otherwise, if no OOM error occurs,
124886 ** it is set to SQLCIPHER_OK.
124887 */
124888 static int fts3PendingListAppend(
124889   PendingList **pp,               /* IN/OUT: PendingList structure */
124890   sqlcipher3_int64 iDocid,           /* Docid for entry to add */
124891   sqlcipher3_int64 iCol,             /* Column for entry to add */
124892   sqlcipher3_int64 iPos,             /* Position of term for entry to add */
124893   int *pRc                        /* OUT: Return code */
124894 ){
124895   PendingList *p = *pp;
124896   int rc = SQLCIPHER_OK;
124897
124898   assert( !p || p->iLastDocid<=iDocid );
124899
124900   if( !p || p->iLastDocid!=iDocid ){
124901     sqlcipher3_int64 iDelta = iDocid - (p ? p->iLastDocid : 0);
124902     if( p ){
124903       assert( p->nData<p->nSpace );
124904       assert( p->aData[p->nData]==0 );
124905       p->nData++;
124906     }
124907     if( SQLCIPHER_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
124908       goto pendinglistappend_out;
124909     }
124910     p->iLastCol = -1;
124911     p->iLastPos = 0;
124912     p->iLastDocid = iDocid;
124913   }
124914   if( iCol>0 && p->iLastCol!=iCol ){
124915     if( SQLCIPHER_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
124916      || SQLCIPHER_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
124917     ){
124918       goto pendinglistappend_out;
124919     }
124920     p->iLastCol = iCol;
124921     p->iLastPos = 0;
124922   }
124923   if( iCol>=0 ){
124924     assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) );
124925     rc = fts3PendingListAppendVarint(&p, 2+iPos-p->iLastPos);
124926     if( rc==SQLCIPHER_OK ){
124927       p->iLastPos = iPos;
124928     }
124929   }
124930
124931  pendinglistappend_out:
124932   *pRc = rc;
124933   if( p!=*pp ){
124934     *pp = p;
124935     return 1;
124936   }
124937   return 0;
124938 }
124939
124940 /*
124941 ** Free a PendingList object allocated by fts3PendingListAppend().
124942 */
124943 static void fts3PendingListDelete(PendingList *pList){
124944   sqlcipher3_free(pList);
124945 }
124946
124947 /*
124948 ** Add an entry to one of the pending-terms hash tables.
124949 */
124950 static int fts3PendingTermsAddOne(
124951   Fts3Table *p,
124952   int iCol,
124953   int iPos,
124954   Fts3Hash *pHash,                /* Pending terms hash table to add entry to */
124955   const char *zToken,
124956   int nToken
124957 ){
124958   PendingList *pList;
124959   int rc = SQLCIPHER_OK;
124960
124961   pList = (PendingList *)fts3HashFind(pHash, zToken, nToken);
124962   if( pList ){
124963     p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem));
124964   }
124965   if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
124966     if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){
124967       /* Malloc failed while inserting the new entry. This can only 
124968       ** happen if there was no previous entry for this token.
124969       */
124970       assert( 0==fts3HashFind(pHash, zToken, nToken) );
124971       sqlcipher3_free(pList);
124972       rc = SQLCIPHER_NOMEM;
124973     }
124974   }
124975   if( rc==SQLCIPHER_OK ){
124976     p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem));
124977   }
124978   return rc;
124979 }
124980
124981 /*
124982 ** Tokenize the nul-terminated string zText and add all tokens to the
124983 ** pending-terms hash-table. The docid used is that currently stored in
124984 ** p->iPrevDocid, and the column is specified by argument iCol.
124985 **
124986 ** If successful, SQLCIPHER_OK is returned. Otherwise, an SQLite error code.
124987 */
124988 static int fts3PendingTermsAdd(
124989   Fts3Table *p,                   /* Table into which text will be inserted */
124990   const char *zText,              /* Text of document to be inserted */
124991   int iCol,                       /* Column into which text is being inserted */
124992   u32 *pnWord                     /* OUT: Number of tokens inserted */
124993 ){
124994   int rc;
124995   int iStart;
124996   int iEnd;
124997   int iPos;
124998   int nWord = 0;
124999
125000   char const *zToken;
125001   int nToken;
125002
125003   sqlcipher3_tokenizer *pTokenizer = p->pTokenizer;
125004   sqlcipher3_tokenizer_module const *pModule = pTokenizer->pModule;
125005   sqlcipher3_tokenizer_cursor *pCsr;
125006   int (*xNext)(sqlcipher3_tokenizer_cursor *pCursor,
125007       const char**,int*,int*,int*,int*);
125008
125009   assert( pTokenizer && pModule );
125010
125011   /* If the user has inserted a NULL value, this function may be called with
125012   ** zText==0. In this case, add zero token entries to the hash table and 
125013   ** return early. */
125014   if( zText==0 ){
125015     *pnWord = 0;
125016     return SQLCIPHER_OK;
125017   }
125018
125019   rc = pModule->xOpen(pTokenizer, zText, -1, &pCsr);
125020   if( rc!=SQLCIPHER_OK ){
125021     return rc;
125022   }
125023   pCsr->pTokenizer = pTokenizer;
125024
125025   xNext = pModule->xNext;
125026   while( SQLCIPHER_OK==rc
125027       && SQLCIPHER_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
125028   ){
125029     int i;
125030     if( iPos>=nWord ) nWord = iPos+1;
125031
125032     /* Positions cannot be negative; we use -1 as a terminator internally.
125033     ** Tokens must have a non-zero length.
125034     */
125035     if( iPos<0 || !zToken || nToken<=0 ){
125036       rc = SQLCIPHER_ERROR;
125037       break;
125038     }
125039
125040     /* Add the term to the terms index */
125041     rc = fts3PendingTermsAddOne(
125042         p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
125043     );
125044     
125045     /* Add the term to each of the prefix indexes that it is not too 
125046     ** short for. */
125047     for(i=1; rc==SQLCIPHER_OK && i<p->nIndex; i++){
125048       struct Fts3Index *pIndex = &p->aIndex[i];
125049       if( nToken<pIndex->nPrefix ) continue;
125050       rc = fts3PendingTermsAddOne(
125051           p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
125052       );
125053     }
125054   }
125055
125056   pModule->xClose(pCsr);
125057   *pnWord = nWord;
125058   return (rc==SQLCIPHER_DONE ? SQLCIPHER_OK : rc);
125059 }
125060
125061 /* 
125062 ** Calling this function indicates that subsequent calls to 
125063 ** fts3PendingTermsAdd() are to add term/position-list pairs for the
125064 ** contents of the document with docid iDocid.
125065 */
125066 static int fts3PendingTermsDocid(Fts3Table *p, sqlcipher_int64 iDocid){
125067   /* TODO(shess) Explore whether partially flushing the buffer on
125068   ** forced-flush would provide better performance.  I suspect that if
125069   ** we ordered the doclists by size and flushed the largest until the
125070   ** buffer was half empty, that would let the less frequent terms
125071   ** generate longer doclists.
125072   */
125073   if( iDocid<=p->iPrevDocid || p->nPendingData>p->nMaxPendingData ){
125074     int rc = sqlcipher3Fts3PendingTermsFlush(p);
125075     if( rc!=SQLCIPHER_OK ) return rc;
125076   }
125077   p->iPrevDocid = iDocid;
125078   return SQLCIPHER_OK;
125079 }
125080
125081 /*
125082 ** Discard the contents of the pending-terms hash tables. 
125083 */
125084 SQLCIPHER_PRIVATE void sqlcipher3Fts3PendingTermsClear(Fts3Table *p){
125085   int i;
125086   for(i=0; i<p->nIndex; i++){
125087     Fts3HashElem *pElem;
125088     Fts3Hash *pHash = &p->aIndex[i].hPending;
125089     for(pElem=fts3HashFirst(pHash); pElem; pElem=fts3HashNext(pElem)){
125090       PendingList *pList = (PendingList *)fts3HashData(pElem);
125091       fts3PendingListDelete(pList);
125092     }
125093     fts3HashClear(pHash);
125094   }
125095   p->nPendingData = 0;
125096 }
125097
125098 /*
125099 ** This function is called by the xUpdate() method as part of an INSERT
125100 ** operation. It adds entries for each term in the new record to the
125101 ** pendingTerms hash table.
125102 **
125103 ** Argument apVal is the same as the similarly named argument passed to
125104 ** fts3InsertData(). Parameter iDocid is the docid of the new row.
125105 */
125106 static int fts3InsertTerms(Fts3Table *p, sqlcipher3_value **apVal, u32 *aSz){
125107   int i;                          /* Iterator variable */
125108   for(i=2; i<p->nColumn+2; i++){
125109     const char *zText = (const char *)sqlcipher3_value_text(apVal[i]);
125110     int rc = fts3PendingTermsAdd(p, zText, i-2, &aSz[i-2]);
125111     if( rc!=SQLCIPHER_OK ){
125112       return rc;
125113     }
125114     aSz[p->nColumn] += sqlcipher3_value_bytes(apVal[i]);
125115   }
125116   return SQLCIPHER_OK;
125117 }
125118
125119 /*
125120 ** This function is called by the xUpdate() method for an INSERT operation.
125121 ** The apVal parameter is passed a copy of the apVal argument passed by
125122 ** SQLite to the xUpdate() method. i.e:
125123 **
125124 **   apVal[0]                Not used for INSERT.
125125 **   apVal[1]                rowid
125126 **   apVal[2]                Left-most user-defined column
125127 **   ...
125128 **   apVal[p->nColumn+1]     Right-most user-defined column
125129 **   apVal[p->nColumn+2]     Hidden column with same name as table
125130 **   apVal[p->nColumn+3]     Hidden "docid" column (alias for rowid)
125131 */
125132 static int fts3InsertData(
125133   Fts3Table *p,                   /* Full-text table */
125134   sqlcipher3_value **apVal,          /* Array of values to insert */
125135   sqlcipher3_int64 *piDocid          /* OUT: Docid for row just inserted */
125136 ){
125137   int rc;                         /* Return code */
125138   sqlcipher3_stmt *pContentInsert;   /* INSERT INTO %_content VALUES(...) */
125139
125140   if( p->zContentTbl ){
125141     sqlcipher3_value *pRowid = apVal[p->nColumn+3];
125142     if( sqlcipher3_value_type(pRowid)==SQLCIPHER_NULL ){
125143       pRowid = apVal[1];
125144     }
125145     if( sqlcipher3_value_type(pRowid)!=SQLCIPHER_INTEGER ){
125146       return SQLCIPHER_CONSTRAINT;
125147     }
125148     *piDocid = sqlcipher3_value_int64(pRowid);
125149     return SQLCIPHER_OK;
125150   }
125151
125152   /* Locate the statement handle used to insert data into the %_content
125153   ** table. The SQL for this statement is:
125154   **
125155   **   INSERT INTO %_content VALUES(?, ?, ?, ...)
125156   **
125157   ** The statement features N '?' variables, where N is the number of user
125158   ** defined columns in the FTS3 table, plus one for the docid field.
125159   */
125160   rc = fts3SqlStmt(p, SQL_CONTENT_INSERT, &pContentInsert, &apVal[1]);
125161   if( rc!=SQLCIPHER_OK ){
125162     return rc;
125163   }
125164
125165   /* There is a quirk here. The users INSERT statement may have specified
125166   ** a value for the "rowid" field, for the "docid" field, or for both.
125167   ** Which is a problem, since "rowid" and "docid" are aliases for the
125168   ** same value. For example:
125169   **
125170   **   INSERT INTO fts3tbl(rowid, docid) VALUES(1, 2);
125171   **
125172   ** In FTS3, this is an error. It is an error to specify non-NULL values
125173   ** for both docid and some other rowid alias.
125174   */
125175   if( SQLCIPHER_NULL!=sqlcipher3_value_type(apVal[3+p->nColumn]) ){
125176     if( SQLCIPHER_NULL==sqlcipher3_value_type(apVal[0])
125177      && SQLCIPHER_NULL!=sqlcipher3_value_type(apVal[1])
125178     ){
125179       /* A rowid/docid conflict. */
125180       return SQLCIPHER_ERROR;
125181     }
125182     rc = sqlcipher3_bind_value(pContentInsert, 1, apVal[3+p->nColumn]);
125183     if( rc!=SQLCIPHER_OK ) return rc;
125184   }
125185
125186   /* Execute the statement to insert the record. Set *piDocid to the 
125187   ** new docid value. 
125188   */
125189   sqlcipher3_step(pContentInsert);
125190   rc = sqlcipher3_reset(pContentInsert);
125191
125192   *piDocid = sqlcipher3_last_insert_rowid(p->db);
125193   return rc;
125194 }
125195
125196
125197
125198 /*
125199 ** Remove all data from the FTS3 table. Clear the hash table containing
125200 ** pending terms.
125201 */
125202 static int fts3DeleteAll(Fts3Table *p, int bContent){
125203   int rc = SQLCIPHER_OK;             /* Return code */
125204
125205   /* Discard the contents of the pending-terms hash table. */
125206   sqlcipher3Fts3PendingTermsClear(p);
125207
125208   /* Delete everything from the shadow tables. Except, leave %_content as
125209   ** is if bContent is false.  */
125210   assert( p->zContentTbl==0 || bContent==0 );
125211   if( bContent ) fts3SqlExec(&rc, p, SQL_DELETE_ALL_CONTENT, 0);
125212   fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGMENTS, 0);
125213   fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGDIR, 0);
125214   if( p->bHasDocsize ){
125215     fts3SqlExec(&rc, p, SQL_DELETE_ALL_DOCSIZE, 0);
125216   }
125217   if( p->bHasStat ){
125218     fts3SqlExec(&rc, p, SQL_DELETE_ALL_STAT, 0);
125219   }
125220   return rc;
125221 }
125222
125223 /*
125224 ** The first element in the apVal[] array is assumed to contain the docid
125225 ** (an integer) of a row about to be deleted. Remove all terms from the
125226 ** full-text index.
125227 */
125228 static void fts3DeleteTerms( 
125229   int *pRC,               /* Result code */
125230   Fts3Table *p,           /* The FTS table to delete from */
125231   sqlcipher3_value *pRowid,  /* The docid to be deleted */
125232   u32 *aSz                /* Sizes of deleted document written here */
125233 ){
125234   int rc;
125235   sqlcipher3_stmt *pSelect;
125236
125237   if( *pRC ) return;
125238   rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pSelect, &pRowid);
125239   if( rc==SQLCIPHER_OK ){
125240     if( SQLCIPHER_ROW==sqlcipher3_step(pSelect) ){
125241       int i;
125242       for(i=1; i<=p->nColumn; i++){
125243         const char *zText = (const char *)sqlcipher3_column_text(pSelect, i);
125244         rc = fts3PendingTermsAdd(p, zText, -1, &aSz[i-1]);
125245         if( rc!=SQLCIPHER_OK ){
125246           sqlcipher3_reset(pSelect);
125247           *pRC = rc;
125248           return;
125249         }
125250         aSz[p->nColumn] += sqlcipher3_column_bytes(pSelect, i);
125251       }
125252     }
125253     rc = sqlcipher3_reset(pSelect);
125254   }else{
125255     sqlcipher3_reset(pSelect);
125256   }
125257   *pRC = rc;
125258 }
125259
125260 /*
125261 ** Forward declaration to account for the circular dependency between
125262 ** functions fts3SegmentMerge() and fts3AllocateSegdirIdx().
125263 */
125264 static int fts3SegmentMerge(Fts3Table *, int, int);
125265
125266 /* 
125267 ** This function allocates a new level iLevel index in the segdir table.
125268 ** Usually, indexes are allocated within a level sequentially starting
125269 ** with 0, so the allocated index is one greater than the value returned
125270 ** by:
125271 **
125272 **   SELECT max(idx) FROM %_segdir WHERE level = :iLevel
125273 **
125274 ** However, if there are already FTS3_MERGE_COUNT indexes at the requested
125275 ** level, they are merged into a single level (iLevel+1) segment and the 
125276 ** allocated index is 0.
125277 **
125278 ** If successful, *piIdx is set to the allocated index slot and SQLCIPHER_OK
125279 ** returned. Otherwise, an SQLite error code is returned.
125280 */
125281 static int fts3AllocateSegdirIdx(
125282   Fts3Table *p, 
125283   int iIndex,                     /* Index for p->aIndex */
125284   int iLevel, 
125285   int *piIdx
125286 ){
125287   int rc;                         /* Return Code */
125288   sqlcipher3_stmt *pNextIdx;         /* Query for next idx at level iLevel */
125289   int iNext = 0;                  /* Result of query pNextIdx */
125290
125291   /* Set variable iNext to the next available segdir index at level iLevel. */
125292   rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pNextIdx, 0);
125293   if( rc==SQLCIPHER_OK ){
125294     sqlcipher3_bind_int(pNextIdx, 1, iIndex*FTS3_SEGDIR_MAXLEVEL + iLevel);
125295     if( SQLCIPHER_ROW==sqlcipher3_step(pNextIdx) ){
125296       iNext = sqlcipher3_column_int(pNextIdx, 0);
125297     }
125298     rc = sqlcipher3_reset(pNextIdx);
125299   }
125300
125301   if( rc==SQLCIPHER_OK ){
125302     /* If iNext is FTS3_MERGE_COUNT, indicating that level iLevel is already
125303     ** full, merge all segments in level iLevel into a single iLevel+1
125304     ** segment and allocate (newly freed) index 0 at level iLevel. Otherwise,
125305     ** if iNext is less than FTS3_MERGE_COUNT, allocate index iNext.
125306     */
125307     if( iNext>=FTS3_MERGE_COUNT ){
125308       rc = fts3SegmentMerge(p, iIndex, iLevel);
125309       *piIdx = 0;
125310     }else{
125311       *piIdx = iNext;
125312     }
125313   }
125314
125315   return rc;
125316 }
125317
125318 /*
125319 ** The %_segments table is declared as follows:
125320 **
125321 **   CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB)
125322 **
125323 ** This function reads data from a single row of the %_segments table. The
125324 ** specific row is identified by the iBlockid parameter. If paBlob is not
125325 ** NULL, then a buffer is allocated using sqlcipher3_malloc() and populated
125326 ** with the contents of the blob stored in the "block" column of the 
125327 ** identified table row is. Whether or not paBlob is NULL, *pnBlob is set
125328 ** to the size of the blob in bytes before returning.
125329 **
125330 ** If an error occurs, or the table does not contain the specified row,
125331 ** an SQLite error code is returned. Otherwise, SQLCIPHER_OK is returned. If
125332 ** paBlob is non-NULL, then it is the responsibility of the caller to
125333 ** eventually free the returned buffer.
125334 **
125335 ** This function may leave an open sqlcipher3_blob* handle in the
125336 ** Fts3Table.pSegments variable. This handle is reused by subsequent calls
125337 ** to this function. The handle may be closed by calling the
125338 ** sqlcipher3Fts3SegmentsClose() function. Reusing a blob handle is a handy
125339 ** performance improvement, but the blob handle should always be closed
125340 ** before control is returned to the user (to prevent a lock being held
125341 ** on the database file for longer than necessary). Thus, any virtual table
125342 ** method (xFilter etc.) that may directly or indirectly call this function
125343 ** must call sqlcipher3Fts3SegmentsClose() before returning.
125344 */
125345 SQLCIPHER_PRIVATE int sqlcipher3Fts3ReadBlock(
125346   Fts3Table *p,                   /* FTS3 table handle */
125347   sqlcipher3_int64 iBlockid,         /* Access the row with blockid=$iBlockid */
125348   char **paBlob,                  /* OUT: Blob data in malloc'd buffer */
125349   int *pnBlob,                    /* OUT: Size of blob data */
125350   int *pnLoad                     /* OUT: Bytes actually loaded */
125351 ){
125352   int rc;                         /* Return code */
125353
125354   /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */
125355   assert( pnBlob);
125356
125357   if( p->pSegments ){
125358     rc = sqlcipher3_blob_reopen(p->pSegments, iBlockid);
125359   }else{
125360     if( 0==p->zSegmentsTbl ){
125361       p->zSegmentsTbl = sqlcipher3_mprintf("%s_segments", p->zName);
125362       if( 0==p->zSegmentsTbl ) return SQLCIPHER_NOMEM;
125363     }
125364     rc = sqlcipher3_blob_open(
125365        p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments
125366     );
125367   }
125368
125369   if( rc==SQLCIPHER_OK ){
125370     int nByte = sqlcipher3_blob_bytes(p->pSegments);
125371     *pnBlob = nByte;
125372     if( paBlob ){
125373       char *aByte = sqlcipher3_malloc(nByte + FTS3_NODE_PADDING);
125374       if( !aByte ){
125375         rc = SQLCIPHER_NOMEM;
125376       }else{
125377         if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){
125378           nByte = FTS3_NODE_CHUNKSIZE;
125379           *pnLoad = nByte;
125380         }
125381         rc = sqlcipher3_blob_read(p->pSegments, aByte, nByte, 0);
125382         memset(&aByte[nByte], 0, FTS3_NODE_PADDING);
125383         if( rc!=SQLCIPHER_OK ){
125384           sqlcipher3_free(aByte);
125385           aByte = 0;
125386         }
125387       }
125388       *paBlob = aByte;
125389     }
125390   }
125391
125392   return rc;
125393 }
125394
125395 /*
125396 ** Close the blob handle at p->pSegments, if it is open. See comments above
125397 ** the sqlcipher3Fts3ReadBlock() function for details.
125398 */
125399 SQLCIPHER_PRIVATE void sqlcipher3Fts3SegmentsClose(Fts3Table *p){
125400   sqlcipher3_blob_close(p->pSegments);
125401   p->pSegments = 0;
125402 }
125403     
125404 static int fts3SegReaderIncrRead(Fts3SegReader *pReader){
125405   int nRead;                      /* Number of bytes to read */
125406   int rc;                         /* Return code */
125407
125408   nRead = MIN(pReader->nNode - pReader->nPopulate, FTS3_NODE_CHUNKSIZE);
125409   rc = sqlcipher3_blob_read(
125410       pReader->pBlob, 
125411       &pReader->aNode[pReader->nPopulate],
125412       nRead,
125413       pReader->nPopulate
125414   );
125415
125416   if( rc==SQLCIPHER_OK ){
125417     pReader->nPopulate += nRead;
125418     memset(&pReader->aNode[pReader->nPopulate], 0, FTS3_NODE_PADDING);
125419     if( pReader->nPopulate==pReader->nNode ){
125420       sqlcipher3_blob_close(pReader->pBlob);
125421       pReader->pBlob = 0;
125422       pReader->nPopulate = 0;
125423     }
125424   }
125425   return rc;
125426 }
125427
125428 static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
125429   int rc = SQLCIPHER_OK;
125430   assert( !pReader->pBlob 
125431        || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode])
125432   );
125433   while( pReader->pBlob && rc==SQLCIPHER_OK 
125434      &&  (pFrom - pReader->aNode + nByte)>pReader->nPopulate
125435   ){
125436     rc = fts3SegReaderIncrRead(pReader);
125437   }
125438   return rc;
125439 }
125440
125441 /*
125442 ** Move the iterator passed as the first argument to the next term in the
125443 ** segment. If successful, SQLCIPHER_OK is returned. If there is no next term,
125444 ** SQLCIPHER_DONE. Otherwise, an SQLite error code.
125445 */
125446 static int fts3SegReaderNext(
125447   Fts3Table *p, 
125448   Fts3SegReader *pReader,
125449   int bIncr
125450 ){
125451   int rc;                         /* Return code of various sub-routines */
125452   char *pNext;                    /* Cursor variable */
125453   int nPrefix;                    /* Number of bytes in term prefix */
125454   int nSuffix;                    /* Number of bytes in term suffix */
125455
125456   if( !pReader->aDoclist ){
125457     pNext = pReader->aNode;
125458   }else{
125459     pNext = &pReader->aDoclist[pReader->nDoclist];
125460   }
125461
125462   if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
125463
125464     if( fts3SegReaderIsPending(pReader) ){
125465       Fts3HashElem *pElem = *(pReader->ppNextElem);
125466       if( pElem==0 ){
125467         pReader->aNode = 0;
125468       }else{
125469         PendingList *pList = (PendingList *)fts3HashData(pElem);
125470         pReader->zTerm = (char *)fts3HashKey(pElem);
125471         pReader->nTerm = fts3HashKeysize(pElem);
125472         pReader->nNode = pReader->nDoclist = pList->nData + 1;
125473         pReader->aNode = pReader->aDoclist = pList->aData;
125474         pReader->ppNextElem++;
125475         assert( pReader->aNode );
125476       }
125477       return SQLCIPHER_OK;
125478     }
125479
125480     if( !fts3SegReaderIsRootOnly(pReader) ){
125481       sqlcipher3_free(pReader->aNode);
125482       sqlcipher3_blob_close(pReader->pBlob);
125483       pReader->pBlob = 0;
125484     }
125485     pReader->aNode = 0;
125486
125487     /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf 
125488     ** blocks have already been traversed.  */
125489     assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock );
125490     if( pReader->iCurrentBlock>=pReader->iLeafEndBlock ){
125491       return SQLCIPHER_OK;
125492     }
125493
125494     rc = sqlcipher3Fts3ReadBlock(
125495         p, ++pReader->iCurrentBlock, &pReader->aNode, &pReader->nNode, 
125496         (bIncr ? &pReader->nPopulate : 0)
125497     );
125498     if( rc!=SQLCIPHER_OK ) return rc;
125499     assert( pReader->pBlob==0 );
125500     if( bIncr && pReader->nPopulate<pReader->nNode ){
125501       pReader->pBlob = p->pSegments;
125502       p->pSegments = 0;
125503     }
125504     pNext = pReader->aNode;
125505   }
125506
125507   assert( !fts3SegReaderIsPending(pReader) );
125508
125509   rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2);
125510   if( rc!=SQLCIPHER_OK ) return rc;
125511   
125512   /* Because of the FTS3_NODE_PADDING bytes of padding, the following is 
125513   ** safe (no risk of overread) even if the node data is corrupted. */
125514   pNext += sqlcipher3Fts3GetVarint32(pNext, &nPrefix);
125515   pNext += sqlcipher3Fts3GetVarint32(pNext, &nSuffix);
125516   if( nPrefix<0 || nSuffix<=0 
125517    || &pNext[nSuffix]>&pReader->aNode[pReader->nNode] 
125518   ){
125519     return FTS_CORRUPT_VTAB;
125520   }
125521
125522   if( nPrefix+nSuffix>pReader->nTermAlloc ){
125523     int nNew = (nPrefix+nSuffix)*2;
125524     char *zNew = sqlcipher3_realloc(pReader->zTerm, nNew);
125525     if( !zNew ){
125526       return SQLCIPHER_NOMEM;
125527     }
125528     pReader->zTerm = zNew;
125529     pReader->nTermAlloc = nNew;
125530   }
125531
125532   rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX);
125533   if( rc!=SQLCIPHER_OK ) return rc;
125534
125535   memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
125536   pReader->nTerm = nPrefix+nSuffix;
125537   pNext += nSuffix;
125538   pNext += sqlcipher3Fts3GetVarint32(pNext, &pReader->nDoclist);
125539   pReader->aDoclist = pNext;
125540   pReader->pOffsetList = 0;
125541
125542   /* Check that the doclist does not appear to extend past the end of the
125543   ** b-tree node. And that the final byte of the doclist is 0x00. If either 
125544   ** of these statements is untrue, then the data structure is corrupt.
125545   */
125546   if( &pReader->aDoclist[pReader->nDoclist]>&pReader->aNode[pReader->nNode] 
125547    || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1])
125548   ){
125549     return FTS_CORRUPT_VTAB;
125550   }
125551   return SQLCIPHER_OK;
125552 }
125553
125554 /*
125555 ** Set the SegReader to point to the first docid in the doclist associated
125556 ** with the current term.
125557 */
125558 static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){
125559   int rc = SQLCIPHER_OK;
125560   assert( pReader->aDoclist );
125561   assert( !pReader->pOffsetList );
125562   if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
125563     u8 bEof = 0;
125564     pReader->iDocid = 0;
125565     pReader->nOffsetList = 0;
125566     sqlcipher3Fts3DoclistPrev(0,
125567         pReader->aDoclist, pReader->nDoclist, &pReader->pOffsetList, 
125568         &pReader->iDocid, &pReader->nOffsetList, &bEof
125569     );
125570   }else{
125571     rc = fts3SegReaderRequire(pReader, pReader->aDoclist, FTS3_VARINT_MAX);
125572     if( rc==SQLCIPHER_OK ){
125573       int n = sqlcipher3Fts3GetVarint(pReader->aDoclist, &pReader->iDocid);
125574       pReader->pOffsetList = &pReader->aDoclist[n];
125575     }
125576   }
125577   return rc;
125578 }
125579
125580 /*
125581 ** Advance the SegReader to point to the next docid in the doclist
125582 ** associated with the current term.
125583 ** 
125584 ** If arguments ppOffsetList and pnOffsetList are not NULL, then 
125585 ** *ppOffsetList is set to point to the first column-offset list
125586 ** in the doclist entry (i.e. immediately past the docid varint).
125587 ** *pnOffsetList is set to the length of the set of column-offset
125588 ** lists, not including the nul-terminator byte. For example:
125589 */
125590 static int fts3SegReaderNextDocid(
125591   Fts3Table *pTab,
125592   Fts3SegReader *pReader,         /* Reader to advance to next docid */
125593   char **ppOffsetList,            /* OUT: Pointer to current position-list */
125594   int *pnOffsetList               /* OUT: Length of *ppOffsetList in bytes */
125595 ){
125596   int rc = SQLCIPHER_OK;
125597   char *p = pReader->pOffsetList;
125598   char c = 0;
125599
125600   assert( p );
125601
125602   if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
125603     /* A pending-terms seg-reader for an FTS4 table that uses order=desc.
125604     ** Pending-terms doclists are always built up in ascending order, so
125605     ** we have to iterate through them backwards here. */
125606     u8 bEof = 0;
125607     if( ppOffsetList ){
125608       *ppOffsetList = pReader->pOffsetList;
125609       *pnOffsetList = pReader->nOffsetList - 1;
125610     }
125611     sqlcipher3Fts3DoclistPrev(0,
125612         pReader->aDoclist, pReader->nDoclist, &p, &pReader->iDocid,
125613         &pReader->nOffsetList, &bEof
125614     );
125615     if( bEof ){
125616       pReader->pOffsetList = 0;
125617     }else{
125618       pReader->pOffsetList = p;
125619     }
125620   }else{
125621     char *pEnd = &pReader->aDoclist[pReader->nDoclist];
125622
125623     /* Pointer p currently points at the first byte of an offset list. The
125624     ** following block advances it to point one byte past the end of
125625     ** the same offset list. */
125626     while( 1 ){
125627   
125628       /* The following line of code (and the "p++" below the while() loop) is
125629       ** normally all that is required to move pointer p to the desired 
125630       ** position. The exception is if this node is being loaded from disk
125631       ** incrementally and pointer "p" now points to the first byte passed
125632       ** the populated part of pReader->aNode[].
125633       */
125634       while( *p | c ) c = *p++ & 0x80;
125635       assert( *p==0 );
125636   
125637       if( pReader->pBlob==0 || p<&pReader->aNode[pReader->nPopulate] ) break;
125638       rc = fts3SegReaderIncrRead(pReader);
125639       if( rc!=SQLCIPHER_OK ) return rc;
125640     }
125641     p++;
125642   
125643     /* If required, populate the output variables with a pointer to and the
125644     ** size of the previous offset-list.
125645     */
125646     if( ppOffsetList ){
125647       *ppOffsetList = pReader->pOffsetList;
125648       *pnOffsetList = (int)(p - pReader->pOffsetList - 1);
125649     }
125650
125651     while( p<pEnd && *p==0 ) p++;
125652   
125653     /* If there are no more entries in the doclist, set pOffsetList to
125654     ** NULL. Otherwise, set Fts3SegReader.iDocid to the next docid and
125655     ** Fts3SegReader.pOffsetList to point to the next offset list before
125656     ** returning.
125657     */
125658     if( p>=pEnd ){
125659       pReader->pOffsetList = 0;
125660     }else{
125661       rc = fts3SegReaderRequire(pReader, p, FTS3_VARINT_MAX);
125662       if( rc==SQLCIPHER_OK ){
125663         sqlcipher3_int64 iDelta;
125664         pReader->pOffsetList = p + sqlcipher3Fts3GetVarint(p, &iDelta);
125665         if( pTab->bDescIdx ){
125666           pReader->iDocid -= iDelta;
125667         }else{
125668           pReader->iDocid += iDelta;
125669         }
125670       }
125671     }
125672   }
125673
125674   return SQLCIPHER_OK;
125675 }
125676
125677
125678 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrOvfl(
125679   Fts3Cursor *pCsr, 
125680   Fts3MultiSegReader *pMsr,
125681   int *pnOvfl
125682 ){
125683   Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
125684   int nOvfl = 0;
125685   int ii;
125686   int rc = SQLCIPHER_OK;
125687   int pgsz = p->nPgsz;
125688
125689   assert( p->bHasStat );
125690   assert( pgsz>0 );
125691
125692   for(ii=0; rc==SQLCIPHER_OK && ii<pMsr->nSegment; ii++){
125693     Fts3SegReader *pReader = pMsr->apSegment[ii];
125694     if( !fts3SegReaderIsPending(pReader) 
125695      && !fts3SegReaderIsRootOnly(pReader) 
125696     ){
125697       sqlcipher3_int64 jj;
125698       for(jj=pReader->iStartBlock; jj<=pReader->iLeafEndBlock; jj++){
125699         int nBlob;
125700         rc = sqlcipher3Fts3ReadBlock(p, jj, 0, &nBlob, 0);
125701         if( rc!=SQLCIPHER_OK ) break;
125702         if( (nBlob+35)>pgsz ){
125703           nOvfl += (nBlob + 34)/pgsz;
125704         }
125705       }
125706     }
125707   }
125708   *pnOvfl = nOvfl;
125709   return rc;
125710 }
125711
125712 /*
125713 ** Free all allocations associated with the iterator passed as the 
125714 ** second argument.
125715 */
125716 SQLCIPHER_PRIVATE void sqlcipher3Fts3SegReaderFree(Fts3SegReader *pReader){
125717   if( pReader && !fts3SegReaderIsPending(pReader) ){
125718     sqlcipher3_free(pReader->zTerm);
125719     if( !fts3SegReaderIsRootOnly(pReader) ){
125720       sqlcipher3_free(pReader->aNode);
125721       sqlcipher3_blob_close(pReader->pBlob);
125722     }
125723   }
125724   sqlcipher3_free(pReader);
125725 }
125726
125727 /*
125728 ** Allocate a new SegReader object.
125729 */
125730 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderNew(
125731   int iAge,                       /* Segment "age". */
125732   sqlcipher3_int64 iStartLeaf,       /* First leaf to traverse */
125733   sqlcipher3_int64 iEndLeaf,         /* Final leaf to traverse */
125734   sqlcipher3_int64 iEndBlock,        /* Final block of segment */
125735   const char *zRoot,              /* Buffer containing root node */
125736   int nRoot,                      /* Size of buffer containing root node */
125737   Fts3SegReader **ppReader        /* OUT: Allocated Fts3SegReader */
125738 ){
125739   int rc = SQLCIPHER_OK;             /* Return code */
125740   Fts3SegReader *pReader;         /* Newly allocated SegReader object */
125741   int nExtra = 0;                 /* Bytes to allocate segment root node */
125742
125743   assert( iStartLeaf<=iEndLeaf );
125744   if( iStartLeaf==0 ){
125745     nExtra = nRoot + FTS3_NODE_PADDING;
125746   }
125747
125748   pReader = (Fts3SegReader *)sqlcipher3_malloc(sizeof(Fts3SegReader) + nExtra);
125749   if( !pReader ){
125750     return SQLCIPHER_NOMEM;
125751   }
125752   memset(pReader, 0, sizeof(Fts3SegReader));
125753   pReader->iIdx = iAge;
125754   pReader->iStartBlock = iStartLeaf;
125755   pReader->iLeafEndBlock = iEndLeaf;
125756   pReader->iEndBlock = iEndBlock;
125757
125758   if( nExtra ){
125759     /* The entire segment is stored in the root node. */
125760     pReader->aNode = (char *)&pReader[1];
125761     pReader->nNode = nRoot;
125762     memcpy(pReader->aNode, zRoot, nRoot);
125763     memset(&pReader->aNode[nRoot], 0, FTS3_NODE_PADDING);
125764   }else{
125765     pReader->iCurrentBlock = iStartLeaf-1;
125766   }
125767
125768   if( rc==SQLCIPHER_OK ){
125769     *ppReader = pReader;
125770   }else{
125771     sqlcipher3Fts3SegReaderFree(pReader);
125772   }
125773   return rc;
125774 }
125775
125776 /*
125777 ** This is a comparison function used as a qsort() callback when sorting
125778 ** an array of pending terms by term. This occurs as part of flushing
125779 ** the contents of the pending-terms hash table to the database.
125780 */
125781 static int fts3CompareElemByTerm(const void *lhs, const void *rhs){
125782   char *z1 = fts3HashKey(*(Fts3HashElem **)lhs);
125783   char *z2 = fts3HashKey(*(Fts3HashElem **)rhs);
125784   int n1 = fts3HashKeysize(*(Fts3HashElem **)lhs);
125785   int n2 = fts3HashKeysize(*(Fts3HashElem **)rhs);
125786
125787   int n = (n1<n2 ? n1 : n2);
125788   int c = memcmp(z1, z2, n);
125789   if( c==0 ){
125790     c = n1 - n2;
125791   }
125792   return c;
125793 }
125794
125795 /*
125796 ** This function is used to allocate an Fts3SegReader that iterates through
125797 ** a subset of the terms stored in the Fts3Table.pendingTerms array.
125798 **
125799 ** If the isPrefixIter parameter is zero, then the returned SegReader iterates
125800 ** through each term in the pending-terms table. Or, if isPrefixIter is
125801 ** non-zero, it iterates through each term and its prefixes. For example, if
125802 ** the pending terms hash table contains the terms "sqlcipher", "mysql" and
125803 ** "firebird", then the iterator visits the following 'terms' (in the order
125804 ** shown):
125805 **
125806 **   f fi fir fire fireb firebi firebir firebird
125807 **   m my mys mysq mysql
125808 **   s sq sql sqli sqlit sqlcipher
125809 **
125810 ** Whereas if isPrefixIter is zero, the terms visited are:
125811 **
125812 **   firebird mysql sqlcipher
125813 */
125814 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderPending(
125815   Fts3Table *p,                   /* Virtual table handle */
125816   int iIndex,                     /* Index for p->aIndex */
125817   const char *zTerm,              /* Term to search for */
125818   int nTerm,                      /* Size of buffer zTerm */
125819   int bPrefix,                    /* True for a prefix iterator */
125820   Fts3SegReader **ppReader        /* OUT: SegReader for pending-terms */
125821 ){
125822   Fts3SegReader *pReader = 0;     /* Fts3SegReader object to return */
125823   Fts3HashElem **aElem = 0;       /* Array of term hash entries to scan */
125824   int nElem = 0;                  /* Size of array at aElem */
125825   int rc = SQLCIPHER_OK;             /* Return Code */
125826   Fts3Hash *pHash;
125827
125828   pHash = &p->aIndex[iIndex].hPending;
125829   if( bPrefix ){
125830     int nAlloc = 0;               /* Size of allocated array at aElem */
125831     Fts3HashElem *pE = 0;         /* Iterator variable */
125832
125833     for(pE=fts3HashFirst(pHash); pE; pE=fts3HashNext(pE)){
125834       char *zKey = (char *)fts3HashKey(pE);
125835       int nKey = fts3HashKeysize(pE);
125836       if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
125837         if( nElem==nAlloc ){
125838           Fts3HashElem **aElem2;
125839           nAlloc += 16;
125840           aElem2 = (Fts3HashElem **)sqlcipher3_realloc(
125841               aElem, nAlloc*sizeof(Fts3HashElem *)
125842           );
125843           if( !aElem2 ){
125844             rc = SQLCIPHER_NOMEM;
125845             nElem = 0;
125846             break;
125847           }
125848           aElem = aElem2;
125849         }
125850
125851         aElem[nElem++] = pE;
125852       }
125853     }
125854
125855     /* If more than one term matches the prefix, sort the Fts3HashElem
125856     ** objects in term order using qsort(). This uses the same comparison
125857     ** callback as is used when flushing terms to disk.
125858     */
125859     if( nElem>1 ){
125860       qsort(aElem, nElem, sizeof(Fts3HashElem *), fts3CompareElemByTerm);
125861     }
125862
125863   }else{
125864     /* The query is a simple term lookup that matches at most one term in
125865     ** the index. All that is required is a straight hash-lookup. */
125866     Fts3HashElem *pE = fts3HashFindElem(pHash, zTerm, nTerm);
125867     if( pE ){
125868       aElem = &pE;
125869       nElem = 1;
125870     }
125871   }
125872
125873   if( nElem>0 ){
125874     int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
125875     pReader = (Fts3SegReader *)sqlcipher3_malloc(nByte);
125876     if( !pReader ){
125877       rc = SQLCIPHER_NOMEM;
125878     }else{
125879       memset(pReader, 0, nByte);
125880       pReader->iIdx = 0x7FFFFFFF;
125881       pReader->ppNextElem = (Fts3HashElem **)&pReader[1];
125882       memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *));
125883     }
125884   }
125885
125886   if( bPrefix ){
125887     sqlcipher3_free(aElem);
125888   }
125889   *ppReader = pReader;
125890   return rc;
125891 }
125892
125893 /*
125894 ** Compare the entries pointed to by two Fts3SegReader structures. 
125895 ** Comparison is as follows:
125896 **
125897 **   1) EOF is greater than not EOF.
125898 **
125899 **   2) The current terms (if any) are compared using memcmp(). If one
125900 **      term is a prefix of another, the longer term is considered the
125901 **      larger.
125902 **
125903 **   3) By segment age. An older segment is considered larger.
125904 */
125905 static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
125906   int rc;
125907   if( pLhs->aNode && pRhs->aNode ){
125908     int rc2 = pLhs->nTerm - pRhs->nTerm;
125909     if( rc2<0 ){
125910       rc = memcmp(pLhs->zTerm, pRhs->zTerm, pLhs->nTerm);
125911     }else{
125912       rc = memcmp(pLhs->zTerm, pRhs->zTerm, pRhs->nTerm);
125913     }
125914     if( rc==0 ){
125915       rc = rc2;
125916     }
125917   }else{
125918     rc = (pLhs->aNode==0) - (pRhs->aNode==0);
125919   }
125920   if( rc==0 ){
125921     rc = pRhs->iIdx - pLhs->iIdx;
125922   }
125923   assert( rc!=0 );
125924   return rc;
125925 }
125926
125927 /*
125928 ** A different comparison function for SegReader structures. In this
125929 ** version, it is assumed that each SegReader points to an entry in
125930 ** a doclist for identical terms. Comparison is made as follows:
125931 **
125932 **   1) EOF (end of doclist in this case) is greater than not EOF.
125933 **
125934 **   2) By current docid.
125935 **
125936 **   3) By segment age. An older segment is considered larger.
125937 */
125938 static int fts3SegReaderDoclistCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
125939   int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0);
125940   if( rc==0 ){
125941     if( pLhs->iDocid==pRhs->iDocid ){
125942       rc = pRhs->iIdx - pLhs->iIdx;
125943     }else{
125944       rc = (pLhs->iDocid > pRhs->iDocid) ? 1 : -1;
125945     }
125946   }
125947   assert( pLhs->aNode && pRhs->aNode );
125948   return rc;
125949 }
125950 static int fts3SegReaderDoclistCmpRev(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
125951   int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0);
125952   if( rc==0 ){
125953     if( pLhs->iDocid==pRhs->iDocid ){
125954       rc = pRhs->iIdx - pLhs->iIdx;
125955     }else{
125956       rc = (pLhs->iDocid < pRhs->iDocid) ? 1 : -1;
125957     }
125958   }
125959   assert( pLhs->aNode && pRhs->aNode );
125960   return rc;
125961 }
125962
125963 /*
125964 ** Compare the term that the Fts3SegReader object passed as the first argument
125965 ** points to with the term specified by arguments zTerm and nTerm. 
125966 **
125967 ** If the pSeg iterator is already at EOF, return 0. Otherwise, return
125968 ** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are
125969 ** equal, or +ve if the pSeg term is greater than zTerm/nTerm.
125970 */
125971 static int fts3SegReaderTermCmp(
125972   Fts3SegReader *pSeg,            /* Segment reader object */
125973   const char *zTerm,              /* Term to compare to */
125974   int nTerm                       /* Size of term zTerm in bytes */
125975 ){
125976   int res = 0;
125977   if( pSeg->aNode ){
125978     if( pSeg->nTerm>nTerm ){
125979       res = memcmp(pSeg->zTerm, zTerm, nTerm);
125980     }else{
125981       res = memcmp(pSeg->zTerm, zTerm, pSeg->nTerm);
125982     }
125983     if( res==0 ){
125984       res = pSeg->nTerm-nTerm;
125985     }
125986   }
125987   return res;
125988 }
125989
125990 /*
125991 ** Argument apSegment is an array of nSegment elements. It is known that
125992 ** the final (nSegment-nSuspect) members are already in sorted order
125993 ** (according to the comparison function provided). This function shuffles
125994 ** the array around until all entries are in sorted order.
125995 */
125996 static void fts3SegReaderSort(
125997   Fts3SegReader **apSegment,                     /* Array to sort entries of */
125998   int nSegment,                                  /* Size of apSegment array */
125999   int nSuspect,                                  /* Unsorted entry count */
126000   int (*xCmp)(Fts3SegReader *, Fts3SegReader *)  /* Comparison function */
126001 ){
126002   int i;                          /* Iterator variable */
126003
126004   assert( nSuspect<=nSegment );
126005
126006   if( nSuspect==nSegment ) nSuspect--;
126007   for(i=nSuspect-1; i>=0; i--){
126008     int j;
126009     for(j=i; j<(nSegment-1); j++){
126010       Fts3SegReader *pTmp;
126011       if( xCmp(apSegment[j], apSegment[j+1])<0 ) break;
126012       pTmp = apSegment[j+1];
126013       apSegment[j+1] = apSegment[j];
126014       apSegment[j] = pTmp;
126015     }
126016   }
126017
126018 #ifndef NDEBUG
126019   /* Check that the list really is sorted now. */
126020   for(i=0; i<(nSuspect-1); i++){
126021     assert( xCmp(apSegment[i], apSegment[i+1])<0 );
126022   }
126023 #endif
126024 }
126025
126026 /* 
126027 ** Insert a record into the %_segments table.
126028 */
126029 static int fts3WriteSegment(
126030   Fts3Table *p,                   /* Virtual table handle */
126031   sqlcipher3_int64 iBlock,           /* Block id for new block */
126032   char *z,                        /* Pointer to buffer containing block data */
126033   int n                           /* Size of buffer z in bytes */
126034 ){
126035   sqlcipher3_stmt *pStmt;
126036   int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0);
126037   if( rc==SQLCIPHER_OK ){
126038     sqlcipher3_bind_int64(pStmt, 1, iBlock);
126039     sqlcipher3_bind_blob(pStmt, 2, z, n, SQLCIPHER_STATIC);
126040     sqlcipher3_step(pStmt);
126041     rc = sqlcipher3_reset(pStmt);
126042   }
126043   return rc;
126044 }
126045
126046 /* 
126047 ** Insert a record into the %_segdir table.
126048 */
126049 static int fts3WriteSegdir(
126050   Fts3Table *p,                   /* Virtual table handle */
126051   int iLevel,                     /* Value for "level" field */
126052   int iIdx,                       /* Value for "idx" field */
126053   sqlcipher3_int64 iStartBlock,      /* Value for "start_block" field */
126054   sqlcipher3_int64 iLeafEndBlock,    /* Value for "leaves_end_block" field */
126055   sqlcipher3_int64 iEndBlock,        /* Value for "end_block" field */
126056   char *zRoot,                    /* Blob value for "root" field */
126057   int nRoot                       /* Number of bytes in buffer zRoot */
126058 ){
126059   sqlcipher3_stmt *pStmt;
126060   int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0);
126061   if( rc==SQLCIPHER_OK ){
126062     sqlcipher3_bind_int(pStmt, 1, iLevel);
126063     sqlcipher3_bind_int(pStmt, 2, iIdx);
126064     sqlcipher3_bind_int64(pStmt, 3, iStartBlock);
126065     sqlcipher3_bind_int64(pStmt, 4, iLeafEndBlock);
126066     sqlcipher3_bind_int64(pStmt, 5, iEndBlock);
126067     sqlcipher3_bind_blob(pStmt, 6, zRoot, nRoot, SQLCIPHER_STATIC);
126068     sqlcipher3_step(pStmt);
126069     rc = sqlcipher3_reset(pStmt);
126070   }
126071   return rc;
126072 }
126073
126074 /*
126075 ** Return the size of the common prefix (if any) shared by zPrev and
126076 ** zNext, in bytes. For example, 
126077 **
126078 **   fts3PrefixCompress("abc", 3, "abcdef", 6)   // returns 3
126079 **   fts3PrefixCompress("abX", 3, "abcdef", 6)   // returns 2
126080 **   fts3PrefixCompress("abX", 3, "Xbcdef", 6)   // returns 0
126081 */
126082 static int fts3PrefixCompress(
126083   const char *zPrev,              /* Buffer containing previous term */
126084   int nPrev,                      /* Size of buffer zPrev in bytes */
126085   const char *zNext,              /* Buffer containing next term */
126086   int nNext                       /* Size of buffer zNext in bytes */
126087 ){
126088   int n;
126089   UNUSED_PARAMETER(nNext);
126090   for(n=0; n<nPrev && zPrev[n]==zNext[n]; n++);
126091   return n;
126092 }
126093
126094 /*
126095 ** Add term zTerm to the SegmentNode. It is guaranteed that zTerm is larger
126096 ** (according to memcmp) than the previous term.
126097 */
126098 static int fts3NodeAddTerm(
126099   Fts3Table *p,                   /* Virtual table handle */
126100   SegmentNode **ppTree,           /* IN/OUT: SegmentNode handle */ 
126101   int isCopyTerm,                 /* True if zTerm/nTerm is transient */
126102   const char *zTerm,              /* Pointer to buffer containing term */
126103   int nTerm                       /* Size of term in bytes */
126104 ){
126105   SegmentNode *pTree = *ppTree;
126106   int rc;
126107   SegmentNode *pNew;
126108
126109   /* First try to append the term to the current node. Return early if 
126110   ** this is possible.
126111   */
126112   if( pTree ){
126113     int nData = pTree->nData;     /* Current size of node in bytes */
126114     int nReq = nData;             /* Required space after adding zTerm */
126115     int nPrefix;                  /* Number of bytes of prefix compression */
126116     int nSuffix;                  /* Suffix length */
126117
126118     nPrefix = fts3PrefixCompress(pTree->zTerm, pTree->nTerm, zTerm, nTerm);
126119     nSuffix = nTerm-nPrefix;
126120
126121     nReq += sqlcipher3Fts3VarintLen(nPrefix)+sqlcipher3Fts3VarintLen(nSuffix)+nSuffix;
126122     if( nReq<=p->nNodeSize || !pTree->zTerm ){
126123
126124       if( nReq>p->nNodeSize ){
126125         /* An unusual case: this is the first term to be added to the node
126126         ** and the static node buffer (p->nNodeSize bytes) is not large
126127         ** enough. Use a separately malloced buffer instead This wastes
126128         ** p->nNodeSize bytes, but since this scenario only comes about when
126129         ** the database contain two terms that share a prefix of almost 2KB, 
126130         ** this is not expected to be a serious problem. 
126131         */
126132         assert( pTree->aData==(char *)&pTree[1] );
126133         pTree->aData = (char *)sqlcipher3_malloc(nReq);
126134         if( !pTree->aData ){
126135           return SQLCIPHER_NOMEM;
126136         }
126137       }
126138
126139       if( pTree->zTerm ){
126140         /* There is no prefix-length field for first term in a node */
126141         nData += sqlcipher3Fts3PutVarint(&pTree->aData[nData], nPrefix);
126142       }
126143
126144       nData += sqlcipher3Fts3PutVarint(&pTree->aData[nData], nSuffix);
126145       memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix);
126146       pTree->nData = nData + nSuffix;
126147       pTree->nEntry++;
126148
126149       if( isCopyTerm ){
126150         if( pTree->nMalloc<nTerm ){
126151           char *zNew = sqlcipher3_realloc(pTree->zMalloc, nTerm*2);
126152           if( !zNew ){
126153             return SQLCIPHER_NOMEM;
126154           }
126155           pTree->nMalloc = nTerm*2;
126156           pTree->zMalloc = zNew;
126157         }
126158         pTree->zTerm = pTree->zMalloc;
126159         memcpy(pTree->zTerm, zTerm, nTerm);
126160         pTree->nTerm = nTerm;
126161       }else{
126162         pTree->zTerm = (char *)zTerm;
126163         pTree->nTerm = nTerm;
126164       }
126165       return SQLCIPHER_OK;
126166     }
126167   }
126168
126169   /* If control flows to here, it was not possible to append zTerm to the
126170   ** current node. Create a new node (a right-sibling of the current node).
126171   ** If this is the first node in the tree, the term is added to it.
126172   **
126173   ** Otherwise, the term is not added to the new node, it is left empty for
126174   ** now. Instead, the term is inserted into the parent of pTree. If pTree 
126175   ** has no parent, one is created here.
126176   */
126177   pNew = (SegmentNode *)sqlcipher3_malloc(sizeof(SegmentNode) + p->nNodeSize);
126178   if( !pNew ){
126179     return SQLCIPHER_NOMEM;
126180   }
126181   memset(pNew, 0, sizeof(SegmentNode));
126182   pNew->nData = 1 + FTS3_VARINT_MAX;
126183   pNew->aData = (char *)&pNew[1];
126184
126185   if( pTree ){
126186     SegmentNode *pParent = pTree->pParent;
126187     rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm);
126188     if( pTree->pParent==0 ){
126189       pTree->pParent = pParent;
126190     }
126191     pTree->pRight = pNew;
126192     pNew->pLeftmost = pTree->pLeftmost;
126193     pNew->pParent = pParent;
126194     pNew->zMalloc = pTree->zMalloc;
126195     pNew->nMalloc = pTree->nMalloc;
126196     pTree->zMalloc = 0;
126197   }else{
126198     pNew->pLeftmost = pNew;
126199     rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm); 
126200   }
126201
126202   *ppTree = pNew;
126203   return rc;
126204 }
126205
126206 /*
126207 ** Helper function for fts3NodeWrite().
126208 */
126209 static int fts3TreeFinishNode(
126210   SegmentNode *pTree, 
126211   int iHeight, 
126212   sqlcipher3_int64 iLeftChild
126213 ){
126214   int nStart;
126215   assert( iHeight>=1 && iHeight<128 );
126216   nStart = FTS3_VARINT_MAX - sqlcipher3Fts3VarintLen(iLeftChild);
126217   pTree->aData[nStart] = (char)iHeight;
126218   sqlcipher3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild);
126219   return nStart;
126220 }
126221
126222 /*
126223 ** Write the buffer for the segment node pTree and all of its peers to the
126224 ** database. Then call this function recursively to write the parent of 
126225 ** pTree and its peers to the database. 
126226 **
126227 ** Except, if pTree is a root node, do not write it to the database. Instead,
126228 ** set output variables *paRoot and *pnRoot to contain the root node.
126229 **
126230 ** If successful, SQLCIPHER_OK is returned and output variable *piLast is
126231 ** set to the largest blockid written to the database (or zero if no
126232 ** blocks were written to the db). Otherwise, an SQLite error code is 
126233 ** returned.
126234 */
126235 static int fts3NodeWrite(
126236   Fts3Table *p,                   /* Virtual table handle */
126237   SegmentNode *pTree,             /* SegmentNode handle */
126238   int iHeight,                    /* Height of this node in tree */
126239   sqlcipher3_int64 iLeaf,            /* Block id of first leaf node */
126240   sqlcipher3_int64 iFree,            /* Block id of next free slot in %_segments */
126241   sqlcipher3_int64 *piLast,          /* OUT: Block id of last entry written */
126242   char **paRoot,                  /* OUT: Data for root node */
126243   int *pnRoot                     /* OUT: Size of root node in bytes */
126244 ){
126245   int rc = SQLCIPHER_OK;
126246
126247   if( !pTree->pParent ){
126248     /* Root node of the tree. */
126249     int nStart = fts3TreeFinishNode(pTree, iHeight, iLeaf);
126250     *piLast = iFree-1;
126251     *pnRoot = pTree->nData - nStart;
126252     *paRoot = &pTree->aData[nStart];
126253   }else{
126254     SegmentNode *pIter;
126255     sqlcipher3_int64 iNextFree = iFree;
126256     sqlcipher3_int64 iNextLeaf = iLeaf;
126257     for(pIter=pTree->pLeftmost; pIter && rc==SQLCIPHER_OK; pIter=pIter->pRight){
126258       int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
126259       int nWrite = pIter->nData - nStart;
126260   
126261       rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
126262       iNextFree++;
126263       iNextLeaf += (pIter->nEntry+1);
126264     }
126265     if( rc==SQLCIPHER_OK ){
126266       assert( iNextLeaf==iFree );
126267       rc = fts3NodeWrite(
126268           p, pTree->pParent, iHeight+1, iFree, iNextFree, piLast, paRoot, pnRoot
126269       );
126270     }
126271   }
126272
126273   return rc;
126274 }
126275
126276 /*
126277 ** Free all memory allocations associated with the tree pTree.
126278 */
126279 static void fts3NodeFree(SegmentNode *pTree){
126280   if( pTree ){
126281     SegmentNode *p = pTree->pLeftmost;
126282     fts3NodeFree(p->pParent);
126283     while( p ){
126284       SegmentNode *pRight = p->pRight;
126285       if( p->aData!=(char *)&p[1] ){
126286         sqlcipher3_free(p->aData);
126287       }
126288       assert( pRight==0 || p->zMalloc==0 );
126289       sqlcipher3_free(p->zMalloc);
126290       sqlcipher3_free(p);
126291       p = pRight;
126292     }
126293   }
126294 }
126295
126296 /*
126297 ** Add a term to the segment being constructed by the SegmentWriter object
126298 ** *ppWriter. When adding the first term to a segment, *ppWriter should
126299 ** be passed NULL. This function will allocate a new SegmentWriter object
126300 ** and return it via the input/output variable *ppWriter in this case.
126301 **
126302 ** If successful, SQLCIPHER_OK is returned. Otherwise, an SQLite error code.
126303 */
126304 static int fts3SegWriterAdd(
126305   Fts3Table *p,                   /* Virtual table handle */
126306   SegmentWriter **ppWriter,       /* IN/OUT: SegmentWriter handle */ 
126307   int isCopyTerm,                 /* True if buffer zTerm must be copied */
126308   const char *zTerm,              /* Pointer to buffer containing term */
126309   int nTerm,                      /* Size of term in bytes */
126310   const char *aDoclist,           /* Pointer to buffer containing doclist */
126311   int nDoclist                    /* Size of doclist in bytes */
126312 ){
126313   int nPrefix;                    /* Size of term prefix in bytes */
126314   int nSuffix;                    /* Size of term suffix in bytes */
126315   int nReq;                       /* Number of bytes required on leaf page */
126316   int nData;
126317   SegmentWriter *pWriter = *ppWriter;
126318
126319   if( !pWriter ){
126320     int rc;
126321     sqlcipher3_stmt *pStmt;
126322
126323     /* Allocate the SegmentWriter structure */
126324     pWriter = (SegmentWriter *)sqlcipher3_malloc(sizeof(SegmentWriter));
126325     if( !pWriter ) return SQLCIPHER_NOMEM;
126326     memset(pWriter, 0, sizeof(SegmentWriter));
126327     *ppWriter = pWriter;
126328
126329     /* Allocate a buffer in which to accumulate data */
126330     pWriter->aData = (char *)sqlcipher3_malloc(p->nNodeSize);
126331     if( !pWriter->aData ) return SQLCIPHER_NOMEM;
126332     pWriter->nSize = p->nNodeSize;
126333
126334     /* Find the next free blockid in the %_segments table */
126335     rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0);
126336     if( rc!=SQLCIPHER_OK ) return rc;
126337     if( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
126338       pWriter->iFree = sqlcipher3_column_int64(pStmt, 0);
126339       pWriter->iFirst = pWriter->iFree;
126340     }
126341     rc = sqlcipher3_reset(pStmt);
126342     if( rc!=SQLCIPHER_OK ) return rc;
126343   }
126344   nData = pWriter->nData;
126345
126346   nPrefix = fts3PrefixCompress(pWriter->zTerm, pWriter->nTerm, zTerm, nTerm);
126347   nSuffix = nTerm-nPrefix;
126348
126349   /* Figure out how many bytes are required by this new entry */
126350   nReq = sqlcipher3Fts3VarintLen(nPrefix) +    /* varint containing prefix size */
126351     sqlcipher3Fts3VarintLen(nSuffix) +         /* varint containing suffix size */
126352     nSuffix +                               /* Term suffix */
126353     sqlcipher3Fts3VarintLen(nDoclist) +        /* Size of doclist */
126354     nDoclist;                               /* Doclist data */
126355
126356   if( nData>0 && nData+nReq>p->nNodeSize ){
126357     int rc;
126358
126359     /* The current leaf node is full. Write it out to the database. */
126360     rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData);
126361     if( rc!=SQLCIPHER_OK ) return rc;
126362
126363     /* Add the current term to the interior node tree. The term added to
126364     ** the interior tree must:
126365     **
126366     **   a) be greater than the largest term on the leaf node just written
126367     **      to the database (still available in pWriter->zTerm), and
126368     **
126369     **   b) be less than or equal to the term about to be added to the new
126370     **      leaf node (zTerm/nTerm).
126371     **
126372     ** In other words, it must be the prefix of zTerm 1 byte longer than
126373     ** the common prefix (if any) of zTerm and pWriter->zTerm.
126374     */
126375     assert( nPrefix<nTerm );
126376     rc = fts3NodeAddTerm(p, &pWriter->pTree, isCopyTerm, zTerm, nPrefix+1);
126377     if( rc!=SQLCIPHER_OK ) return rc;
126378
126379     nData = 0;
126380     pWriter->nTerm = 0;
126381
126382     nPrefix = 0;
126383     nSuffix = nTerm;
126384     nReq = 1 +                              /* varint containing prefix size */
126385       sqlcipher3Fts3VarintLen(nTerm) +         /* varint containing suffix size */
126386       nTerm +                               /* Term suffix */
126387       sqlcipher3Fts3VarintLen(nDoclist) +      /* Size of doclist */
126388       nDoclist;                             /* Doclist data */
126389   }
126390
126391   /* If the buffer currently allocated is too small for this entry, realloc
126392   ** the buffer to make it large enough.
126393   */
126394   if( nReq>pWriter->nSize ){
126395     char *aNew = sqlcipher3_realloc(pWriter->aData, nReq);
126396     if( !aNew ) return SQLCIPHER_NOMEM;
126397     pWriter->aData = aNew;
126398     pWriter->nSize = nReq;
126399   }
126400   assert( nData+nReq<=pWriter->nSize );
126401
126402   /* Append the prefix-compressed term and doclist to the buffer. */
126403   nData += sqlcipher3Fts3PutVarint(&pWriter->aData[nData], nPrefix);
126404   nData += sqlcipher3Fts3PutVarint(&pWriter->aData[nData], nSuffix);
126405   memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix);
126406   nData += nSuffix;
126407   nData += sqlcipher3Fts3PutVarint(&pWriter->aData[nData], nDoclist);
126408   memcpy(&pWriter->aData[nData], aDoclist, nDoclist);
126409   pWriter->nData = nData + nDoclist;
126410
126411   /* Save the current term so that it can be used to prefix-compress the next.
126412   ** If the isCopyTerm parameter is true, then the buffer pointed to by
126413   ** zTerm is transient, so take a copy of the term data. Otherwise, just
126414   ** store a copy of the pointer.
126415   */
126416   if( isCopyTerm ){
126417     if( nTerm>pWriter->nMalloc ){
126418       char *zNew = sqlcipher3_realloc(pWriter->zMalloc, nTerm*2);
126419       if( !zNew ){
126420         return SQLCIPHER_NOMEM;
126421       }
126422       pWriter->nMalloc = nTerm*2;
126423       pWriter->zMalloc = zNew;
126424       pWriter->zTerm = zNew;
126425     }
126426     assert( pWriter->zTerm==pWriter->zMalloc );
126427     memcpy(pWriter->zTerm, zTerm, nTerm);
126428   }else{
126429     pWriter->zTerm = (char *)zTerm;
126430   }
126431   pWriter->nTerm = nTerm;
126432
126433   return SQLCIPHER_OK;
126434 }
126435
126436 /*
126437 ** Flush all data associated with the SegmentWriter object pWriter to the
126438 ** database. This function must be called after all terms have been added
126439 ** to the segment using fts3SegWriterAdd(). If successful, SQLCIPHER_OK is
126440 ** returned. Otherwise, an SQLite error code.
126441 */
126442 static int fts3SegWriterFlush(
126443   Fts3Table *p,                   /* Virtual table handle */
126444   SegmentWriter *pWriter,         /* SegmentWriter to flush to the db */
126445   int iLevel,                     /* Value for 'level' column of %_segdir */
126446   int iIdx                        /* Value for 'idx' column of %_segdir */
126447 ){
126448   int rc;                         /* Return code */
126449   if( pWriter->pTree ){
126450     sqlcipher3_int64 iLast = 0;      /* Largest block id written to database */
126451     sqlcipher3_int64 iLastLeaf;      /* Largest leaf block id written to db */
126452     char *zRoot = NULL;           /* Pointer to buffer containing root node */
126453     int nRoot = 0;                /* Size of buffer zRoot */
126454
126455     iLastLeaf = pWriter->iFree;
126456     rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData);
126457     if( rc==SQLCIPHER_OK ){
126458       rc = fts3NodeWrite(p, pWriter->pTree, 1,
126459           pWriter->iFirst, pWriter->iFree, &iLast, &zRoot, &nRoot);
126460     }
126461     if( rc==SQLCIPHER_OK ){
126462       rc = fts3WriteSegdir(
126463           p, iLevel, iIdx, pWriter->iFirst, iLastLeaf, iLast, zRoot, nRoot);
126464     }
126465   }else{
126466     /* The entire tree fits on the root node. Write it to the segdir table. */
126467     rc = fts3WriteSegdir(
126468         p, iLevel, iIdx, 0, 0, 0, pWriter->aData, pWriter->nData);
126469   }
126470   return rc;
126471 }
126472
126473 /*
126474 ** Release all memory held by the SegmentWriter object passed as the 
126475 ** first argument.
126476 */
126477 static void fts3SegWriterFree(SegmentWriter *pWriter){
126478   if( pWriter ){
126479     sqlcipher3_free(pWriter->aData);
126480     sqlcipher3_free(pWriter->zMalloc);
126481     fts3NodeFree(pWriter->pTree);
126482     sqlcipher3_free(pWriter);
126483   }
126484 }
126485
126486 /*
126487 ** The first value in the apVal[] array is assumed to contain an integer.
126488 ** This function tests if there exist any documents with docid values that
126489 ** are different from that integer. i.e. if deleting the document with docid
126490 ** pRowid would mean the FTS3 table were empty.
126491 **
126492 ** If successful, *pisEmpty is set to true if the table is empty except for
126493 ** document pRowid, or false otherwise, and SQLCIPHER_OK is returned. If an
126494 ** error occurs, an SQLite error code is returned.
126495 */
126496 static int fts3IsEmpty(Fts3Table *p, sqlcipher3_value *pRowid, int *pisEmpty){
126497   sqlcipher3_stmt *pStmt;
126498   int rc;
126499   if( p->zContentTbl ){
126500     /* If using the content=xxx option, assume the table is never empty */
126501     *pisEmpty = 0;
126502     rc = SQLCIPHER_OK;
126503   }else{
126504     rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid);
126505     if( rc==SQLCIPHER_OK ){
126506       if( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
126507         *pisEmpty = sqlcipher3_column_int(pStmt, 0);
126508       }
126509       rc = sqlcipher3_reset(pStmt);
126510     }
126511   }
126512   return rc;
126513 }
126514
126515 /*
126516 ** Set *pnMax to the largest segment level in the database for the index
126517 ** iIndex.
126518 **
126519 ** Segment levels are stored in the 'level' column of the %_segdir table.
126520 **
126521 ** Return SQLCIPHER_OK if successful, or an SQLite error code if not.
126522 */
126523 static int fts3SegmentMaxLevel(Fts3Table *p, int iIndex, int *pnMax){
126524   sqlcipher3_stmt *pStmt;
126525   int rc;
126526   assert( iIndex>=0 && iIndex<p->nIndex );
126527
126528   /* Set pStmt to the compiled version of:
126529   **
126530   **   SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?
126531   **
126532   ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR).
126533   */
126534   rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
126535   if( rc!=SQLCIPHER_OK ) return rc;
126536   sqlcipher3_bind_int(pStmt, 1, iIndex*FTS3_SEGDIR_MAXLEVEL);
126537   sqlcipher3_bind_int(pStmt, 2, (iIndex+1)*FTS3_SEGDIR_MAXLEVEL - 1);
126538   if( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
126539     *pnMax = sqlcipher3_column_int(pStmt, 0);
126540   }
126541   return sqlcipher3_reset(pStmt);
126542 }
126543
126544 /*
126545 ** This function is used after merging multiple segments into a single large
126546 ** segment to delete the old, now redundant, segment b-trees. Specifically,
126547 ** it:
126548 ** 
126549 **   1) Deletes all %_segments entries for the segments associated with 
126550 **      each of the SegReader objects in the array passed as the third 
126551 **      argument, and
126552 **
126553 **   2) deletes all %_segdir entries with level iLevel, or all %_segdir
126554 **      entries regardless of level if (iLevel<0).
126555 **
126556 ** SQLCIPHER_OK is returned if successful, otherwise an SQLite error code.
126557 */
126558 static int fts3DeleteSegdir(
126559   Fts3Table *p,                   /* Virtual table handle */
126560   int iIndex,                     /* Index for p->aIndex */
126561   int iLevel,                     /* Level of %_segdir entries to delete */
126562   Fts3SegReader **apSegment,      /* Array of SegReader objects */
126563   int nReader                     /* Size of array apSegment */
126564 ){
126565   int rc;                         /* Return Code */
126566   int i;                          /* Iterator variable */
126567   sqlcipher3_stmt *pDelete;          /* SQL statement to delete rows */
126568
126569   rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDelete, 0);
126570   for(i=0; rc==SQLCIPHER_OK && i<nReader; i++){
126571     Fts3SegReader *pSegment = apSegment[i];
126572     if( pSegment->iStartBlock ){
126573       sqlcipher3_bind_int64(pDelete, 1, pSegment->iStartBlock);
126574       sqlcipher3_bind_int64(pDelete, 2, pSegment->iEndBlock);
126575       sqlcipher3_step(pDelete);
126576       rc = sqlcipher3_reset(pDelete);
126577     }
126578   }
126579   if( rc!=SQLCIPHER_OK ){
126580     return rc;
126581   }
126582
126583   assert( iLevel>=0 || iLevel==FTS3_SEGCURSOR_ALL );
126584   if( iLevel==FTS3_SEGCURSOR_ALL ){
126585     rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_RANGE, &pDelete, 0);
126586     if( rc==SQLCIPHER_OK ){
126587       sqlcipher3_bind_int(pDelete, 1, iIndex*FTS3_SEGDIR_MAXLEVEL);
126588       sqlcipher3_bind_int(pDelete, 2, (iIndex+1) * FTS3_SEGDIR_MAXLEVEL - 1);
126589     }
126590   }else{
126591     rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pDelete, 0);
126592     if( rc==SQLCIPHER_OK ){
126593       sqlcipher3_bind_int(pDelete, 1, iIndex*FTS3_SEGDIR_MAXLEVEL + iLevel);
126594     }
126595   }
126596
126597   if( rc==SQLCIPHER_OK ){
126598     sqlcipher3_step(pDelete);
126599     rc = sqlcipher3_reset(pDelete);
126600   }
126601
126602   return rc;
126603 }
126604
126605 /*
126606 ** When this function is called, buffer *ppList (size *pnList bytes) contains 
126607 ** a position list that may (or may not) feature multiple columns. This
126608 ** function adjusts the pointer *ppList and the length *pnList so that they
126609 ** identify the subset of the position list that corresponds to column iCol.
126610 **
126611 ** If there are no entries in the input position list for column iCol, then
126612 ** *pnList is set to zero before returning.
126613 */
126614 static void fts3ColumnFilter(
126615   int iCol,                       /* Column to filter on */
126616   char **ppList,                  /* IN/OUT: Pointer to position list */
126617   int *pnList                     /* IN/OUT: Size of buffer *ppList in bytes */
126618 ){
126619   char *pList = *ppList;
126620   int nList = *pnList;
126621   char *pEnd = &pList[nList];
126622   int iCurrent = 0;
126623   char *p = pList;
126624
126625   assert( iCol>=0 );
126626   while( 1 ){
126627     char c = 0;
126628     while( p<pEnd && (c | *p)&0xFE ) c = *p++ & 0x80;
126629   
126630     if( iCol==iCurrent ){
126631       nList = (int)(p - pList);
126632       break;
126633     }
126634
126635     nList -= (int)(p - pList);
126636     pList = p;
126637     if( nList==0 ){
126638       break;
126639     }
126640     p = &pList[1];
126641     p += sqlcipher3Fts3GetVarint32(p, &iCurrent);
126642   }
126643
126644   *ppList = pList;
126645   *pnList = nList;
126646 }
126647
126648 /*
126649 ** Cache data in the Fts3MultiSegReader.aBuffer[] buffer (overwriting any
126650 ** existing data). Grow the buffer if required.
126651 **
126652 ** If successful, return SQLCIPHER_OK. Otherwise, if an OOM error is encountered
126653 ** trying to resize the buffer, return SQLCIPHER_NOMEM.
126654 */
126655 static int fts3MsrBufferData(
126656   Fts3MultiSegReader *pMsr,       /* Multi-segment-reader handle */
126657   char *pList,
126658   int nList
126659 ){
126660   if( nList>pMsr->nBuffer ){
126661     char *pNew;
126662     pMsr->nBuffer = nList*2;
126663     pNew = (char *)sqlcipher3_realloc(pMsr->aBuffer, pMsr->nBuffer);
126664     if( !pNew ) return SQLCIPHER_NOMEM;
126665     pMsr->aBuffer = pNew;
126666   }
126667
126668   memcpy(pMsr->aBuffer, pList, nList);
126669   return SQLCIPHER_OK;
126670 }
126671
126672 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrIncrNext(
126673   Fts3Table *p,                   /* Virtual table handle */
126674   Fts3MultiSegReader *pMsr,       /* Multi-segment-reader handle */
126675   sqlcipher3_int64 *piDocid,         /* OUT: Docid value */
126676   char **paPoslist,               /* OUT: Pointer to position list */
126677   int *pnPoslist                  /* OUT: Size of position list in bytes */
126678 ){
126679   int nMerge = pMsr->nAdvance;
126680   Fts3SegReader **apSegment = pMsr->apSegment;
126681   int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = (
126682     p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
126683   );
126684
126685   if( nMerge==0 ){
126686     *paPoslist = 0;
126687     return SQLCIPHER_OK;
126688   }
126689
126690   while( 1 ){
126691     Fts3SegReader *pSeg;
126692     pSeg = pMsr->apSegment[0];
126693
126694     if( pSeg->pOffsetList==0 ){
126695       *paPoslist = 0;
126696       break;
126697     }else{
126698       int rc;
126699       char *pList;
126700       int nList;
126701       int j;
126702       sqlcipher3_int64 iDocid = apSegment[0]->iDocid;
126703
126704       rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
126705       j = 1;
126706       while( rc==SQLCIPHER_OK 
126707         && j<nMerge
126708         && apSegment[j]->pOffsetList
126709         && apSegment[j]->iDocid==iDocid
126710       ){
126711         rc = fts3SegReaderNextDocid(p, apSegment[j], 0, 0);
126712         j++;
126713       }
126714       if( rc!=SQLCIPHER_OK ) return rc;
126715       fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp);
126716
126717       if( pMsr->iColFilter>=0 ){
126718         fts3ColumnFilter(pMsr->iColFilter, &pList, &nList);
126719       }
126720
126721       if( nList>0 ){
126722         if( fts3SegReaderIsPending(apSegment[0]) ){
126723           rc = fts3MsrBufferData(pMsr, pList, nList+1);
126724           if( rc!=SQLCIPHER_OK ) return rc;
126725           *paPoslist = pMsr->aBuffer;
126726           assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 );
126727         }else{
126728           *paPoslist = pList;
126729         }
126730         *piDocid = iDocid;
126731         *pnPoslist = nList;
126732         break;
126733       }
126734     }
126735   }
126736
126737   return SQLCIPHER_OK;
126738 }
126739
126740 static int fts3SegReaderStart(
126741   Fts3Table *p,                   /* Virtual table handle */
126742   Fts3MultiSegReader *pCsr,       /* Cursor object */
126743   const char *zTerm,              /* Term searched for (or NULL) */
126744   int nTerm                       /* Length of zTerm in bytes */
126745 ){
126746   int i;
126747   int nSeg = pCsr->nSegment;
126748
126749   /* If the Fts3SegFilter defines a specific term (or term prefix) to search 
126750   ** for, then advance each segment iterator until it points to a term of
126751   ** equal or greater value than the specified term. This prevents many
126752   ** unnecessary merge/sort operations for the case where single segment
126753   ** b-tree leaf nodes contain more than one term.
126754   */
126755   for(i=0; pCsr->bRestart==0 && i<pCsr->nSegment; i++){
126756     Fts3SegReader *pSeg = pCsr->apSegment[i];
126757     do {
126758       int rc = fts3SegReaderNext(p, pSeg, 0);
126759       if( rc!=SQLCIPHER_OK ) return rc;
126760     }while( zTerm && fts3SegReaderTermCmp(pSeg, zTerm, nTerm)<0 );
126761   }
126762   fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp);
126763
126764   return SQLCIPHER_OK;
126765 }
126766
126767 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderStart(
126768   Fts3Table *p,                   /* Virtual table handle */
126769   Fts3MultiSegReader *pCsr,       /* Cursor object */
126770   Fts3SegFilter *pFilter          /* Restrictions on range of iteration */
126771 ){
126772   pCsr->pFilter = pFilter;
126773   return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
126774 }
126775
126776 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrIncrStart(
126777   Fts3Table *p,                   /* Virtual table handle */
126778   Fts3MultiSegReader *pCsr,       /* Cursor object */
126779   int iCol,                       /* Column to match on. */
126780   const char *zTerm,              /* Term to iterate through a doclist for */
126781   int nTerm                       /* Number of bytes in zTerm */
126782 ){
126783   int i;
126784   int rc;
126785   int nSegment = pCsr->nSegment;
126786   int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = (
126787     p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
126788   );
126789
126790   assert( pCsr->pFilter==0 );
126791   assert( zTerm && nTerm>0 );
126792
126793   /* Advance each segment iterator until it points to the term zTerm/nTerm. */
126794   rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
126795   if( rc!=SQLCIPHER_OK ) return rc;
126796
126797   /* Determine how many of the segments actually point to zTerm/nTerm. */
126798   for(i=0; i<nSegment; i++){
126799     Fts3SegReader *pSeg = pCsr->apSegment[i];
126800     if( !pSeg->aNode || fts3SegReaderTermCmp(pSeg, zTerm, nTerm) ){
126801       break;
126802     }
126803   }
126804   pCsr->nAdvance = i;
126805
126806   /* Advance each of the segments to point to the first docid. */
126807   for(i=0; i<pCsr->nAdvance; i++){
126808     rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
126809     if( rc!=SQLCIPHER_OK ) return rc;
126810   }
126811   fts3SegReaderSort(pCsr->apSegment, i, i, xCmp);
126812
126813   assert( iCol<0 || iCol<p->nColumn );
126814   pCsr->iColFilter = iCol;
126815
126816   return SQLCIPHER_OK;
126817 }
126818
126819 /*
126820 ** This function is called on a MultiSegReader that has been started using
126821 ** sqlcipher3Fts3MsrIncrStart(). One or more calls to MsrIncrNext() may also
126822 ** have been made. Calling this function puts the MultiSegReader in such
126823 ** a state that if the next two calls are:
126824 **
126825 **   sqlcipher3Fts3SegReaderStart()
126826 **   sqlcipher3Fts3SegReaderStep()
126827 **
126828 ** then the entire doclist for the term is available in 
126829 ** MultiSegReader.aDoclist/nDoclist.
126830 */
126831 SQLCIPHER_PRIVATE int sqlcipher3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){
126832   int i;                          /* Used to iterate through segment-readers */
126833
126834   assert( pCsr->zTerm==0 );
126835   assert( pCsr->nTerm==0 );
126836   assert( pCsr->aDoclist==0 );
126837   assert( pCsr->nDoclist==0 );
126838
126839   pCsr->nAdvance = 0;
126840   pCsr->bRestart = 1;
126841   for(i=0; i<pCsr->nSegment; i++){
126842     pCsr->apSegment[i]->pOffsetList = 0;
126843     pCsr->apSegment[i]->nOffsetList = 0;
126844     pCsr->apSegment[i]->iDocid = 0;
126845   }
126846
126847   return SQLCIPHER_OK;
126848 }
126849
126850
126851 SQLCIPHER_PRIVATE int sqlcipher3Fts3SegReaderStep(
126852   Fts3Table *p,                   /* Virtual table handle */
126853   Fts3MultiSegReader *pCsr        /* Cursor object */
126854 ){
126855   int rc = SQLCIPHER_OK;
126856
126857   int isIgnoreEmpty =  (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
126858   int isRequirePos =   (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
126859   int isColFilter =    (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
126860   int isPrefix =       (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
126861   int isScan =         (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
126862   int isFirst =        (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
126863
126864   Fts3SegReader **apSegment = pCsr->apSegment;
126865   int nSegment = pCsr->nSegment;
126866   Fts3SegFilter *pFilter = pCsr->pFilter;
126867   int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = (
126868     p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
126869   );
126870
126871   if( pCsr->nSegment==0 ) return SQLCIPHER_OK;
126872
126873   do {
126874     int nMerge;
126875     int i;
126876   
126877     /* Advance the first pCsr->nAdvance entries in the apSegment[] array
126878     ** forward. Then sort the list in order of current term again.  
126879     */
126880     for(i=0; i<pCsr->nAdvance; i++){
126881       rc = fts3SegReaderNext(p, apSegment[i], 0);
126882       if( rc!=SQLCIPHER_OK ) return rc;
126883     }
126884     fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp);
126885     pCsr->nAdvance = 0;
126886
126887     /* If all the seg-readers are at EOF, we're finished. return SQLCIPHER_OK. */
126888     assert( rc==SQLCIPHER_OK );
126889     if( apSegment[0]->aNode==0 ) break;
126890
126891     pCsr->nTerm = apSegment[0]->nTerm;
126892     pCsr->zTerm = apSegment[0]->zTerm;
126893
126894     /* If this is a prefix-search, and if the term that apSegment[0] points
126895     ** to does not share a suffix with pFilter->zTerm/nTerm, then all 
126896     ** required callbacks have been made. In this case exit early.
126897     **
126898     ** Similarly, if this is a search for an exact match, and the first term
126899     ** of segment apSegment[0] is not a match, exit early.
126900     */
126901     if( pFilter->zTerm && !isScan ){
126902       if( pCsr->nTerm<pFilter->nTerm 
126903        || (!isPrefix && pCsr->nTerm>pFilter->nTerm)
126904        || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm) 
126905       ){
126906         break;
126907       }
126908     }
126909
126910     nMerge = 1;
126911     while( nMerge<nSegment 
126912         && apSegment[nMerge]->aNode
126913         && apSegment[nMerge]->nTerm==pCsr->nTerm 
126914         && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm)
126915     ){
126916       nMerge++;
126917     }
126918
126919     assert( isIgnoreEmpty || (isRequirePos && !isColFilter) );
126920     if( nMerge==1 
126921      && !isIgnoreEmpty 
126922      && !isFirst 
126923      && (p->bDescIdx==0 || fts3SegReaderIsPending(apSegment[0])==0)
126924     ){
126925       pCsr->nDoclist = apSegment[0]->nDoclist;
126926       if( fts3SegReaderIsPending(apSegment[0]) ){
126927         rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, pCsr->nDoclist);
126928         pCsr->aDoclist = pCsr->aBuffer;
126929       }else{
126930         pCsr->aDoclist = apSegment[0]->aDoclist;
126931       }
126932       if( rc==SQLCIPHER_OK ) rc = SQLCIPHER_ROW;
126933     }else{
126934       int nDoclist = 0;           /* Size of doclist */
126935       sqlcipher3_int64 iPrev = 0;    /* Previous docid stored in doclist */
126936
126937       /* The current term of the first nMerge entries in the array
126938       ** of Fts3SegReader objects is the same. The doclists must be merged
126939       ** and a single term returned with the merged doclist.
126940       */
126941       for(i=0; i<nMerge; i++){
126942         fts3SegReaderFirstDocid(p, apSegment[i]);
126943       }
126944       fts3SegReaderSort(apSegment, nMerge, nMerge, xCmp);
126945       while( apSegment[0]->pOffsetList ){
126946         int j;                    /* Number of segments that share a docid */
126947         char *pList;
126948         int nList;
126949         int nByte;
126950         sqlcipher3_int64 iDocid = apSegment[0]->iDocid;
126951         fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
126952         j = 1;
126953         while( j<nMerge
126954             && apSegment[j]->pOffsetList
126955             && apSegment[j]->iDocid==iDocid
126956         ){
126957           fts3SegReaderNextDocid(p, apSegment[j], 0, 0);
126958           j++;
126959         }
126960
126961         if( isColFilter ){
126962           fts3ColumnFilter(pFilter->iCol, &pList, &nList);
126963         }
126964
126965         if( !isIgnoreEmpty || nList>0 ){
126966
126967           /* Calculate the 'docid' delta value to write into the merged 
126968           ** doclist. */
126969           sqlcipher3_int64 iDelta;
126970           if( p->bDescIdx && nDoclist>0 ){
126971             iDelta = iPrev - iDocid;
126972           }else{
126973             iDelta = iDocid - iPrev;
126974           }
126975           assert( iDelta>0 || (nDoclist==0 && iDelta==iDocid) );
126976           assert( nDoclist>0 || iDelta==iDocid );
126977
126978           nByte = sqlcipher3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
126979           if( nDoclist+nByte>pCsr->nBuffer ){
126980             char *aNew;
126981             pCsr->nBuffer = (nDoclist+nByte)*2;
126982             aNew = sqlcipher3_realloc(pCsr->aBuffer, pCsr->nBuffer);
126983             if( !aNew ){
126984               return SQLCIPHER_NOMEM;
126985             }
126986             pCsr->aBuffer = aNew;
126987           }
126988
126989           if( isFirst ){
126990             char *a = &pCsr->aBuffer[nDoclist];
126991             int nWrite;
126992            
126993             nWrite = sqlcipher3Fts3FirstFilter(iDelta, pList, nList, a);
126994             if( nWrite ){
126995               iPrev = iDocid;
126996               nDoclist += nWrite;
126997             }
126998           }else{
126999             nDoclist += sqlcipher3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta);
127000             iPrev = iDocid;
127001             if( isRequirePos ){
127002               memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
127003               nDoclist += nList;
127004               pCsr->aBuffer[nDoclist++] = '\0';
127005             }
127006           }
127007         }
127008
127009         fts3SegReaderSort(apSegment, nMerge, j, xCmp);
127010       }
127011       if( nDoclist>0 ){
127012         pCsr->aDoclist = pCsr->aBuffer;
127013         pCsr->nDoclist = nDoclist;
127014         rc = SQLCIPHER_ROW;
127015       }
127016     }
127017     pCsr->nAdvance = nMerge;
127018   }while( rc==SQLCIPHER_OK );
127019
127020   return rc;
127021 }
127022
127023
127024 SQLCIPHER_PRIVATE void sqlcipher3Fts3SegReaderFinish(
127025   Fts3MultiSegReader *pCsr       /* Cursor object */
127026 ){
127027   if( pCsr ){
127028     int i;
127029     for(i=0; i<pCsr->nSegment; i++){
127030       sqlcipher3Fts3SegReaderFree(pCsr->apSegment[i]);
127031     }
127032     sqlcipher3_free(pCsr->apSegment);
127033     sqlcipher3_free(pCsr->aBuffer);
127034
127035     pCsr->nSegment = 0;
127036     pCsr->apSegment = 0;
127037     pCsr->aBuffer = 0;
127038   }
127039 }
127040
127041 /*
127042 ** Merge all level iLevel segments in the database into a single 
127043 ** iLevel+1 segment. Or, if iLevel<0, merge all segments into a
127044 ** single segment with a level equal to the numerically largest level 
127045 ** currently present in the database.
127046 **
127047 ** If this function is called with iLevel<0, but there is only one
127048 ** segment in the database, SQLCIPHER_DONE is returned immediately. 
127049 ** Otherwise, if successful, SQLCIPHER_OK is returned. If an error occurs, 
127050 ** an SQLite error code is returned.
127051 */
127052 static int fts3SegmentMerge(Fts3Table *p, int iIndex, int iLevel){
127053   int rc;                         /* Return code */
127054   int iIdx = 0;                   /* Index of new segment */
127055   int iNewLevel = 0;              /* Level/index to create new segment at */
127056   SegmentWriter *pWriter = 0;     /* Used to write the new, merged, segment */
127057   Fts3SegFilter filter;           /* Segment term filter condition */
127058   Fts3MultiSegReader csr;        /* Cursor to iterate through level(s) */
127059   int bIgnoreEmpty = 0;           /* True to ignore empty segments */
127060
127061   assert( iLevel==FTS3_SEGCURSOR_ALL
127062        || iLevel==FTS3_SEGCURSOR_PENDING
127063        || iLevel>=0
127064   );
127065   assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
127066   assert( iIndex>=0 && iIndex<p->nIndex );
127067
127068   rc = sqlcipher3Fts3SegReaderCursor(p, iIndex, iLevel, 0, 0, 1, 0, &csr);
127069   if( rc!=SQLCIPHER_OK || csr.nSegment==0 ) goto finished;
127070
127071   if( iLevel==FTS3_SEGCURSOR_ALL ){
127072     /* This call is to merge all segments in the database to a single
127073     ** segment. The level of the new segment is equal to the the numerically 
127074     ** greatest segment level currently present in the database for this
127075     ** index. The idx of the new segment is always 0.  */
127076     if( csr.nSegment==1 ){
127077       rc = SQLCIPHER_DONE;
127078       goto finished;
127079     }
127080     rc = fts3SegmentMaxLevel(p, iIndex, &iNewLevel);
127081     bIgnoreEmpty = 1;
127082
127083   }else if( iLevel==FTS3_SEGCURSOR_PENDING ){
127084     iNewLevel = iIndex * FTS3_SEGDIR_MAXLEVEL; 
127085     rc = fts3AllocateSegdirIdx(p, iIndex, 0, &iIdx);
127086   }else{
127087     /* This call is to merge all segments at level iLevel. find the next
127088     ** available segment index at level iLevel+1. The call to
127089     ** fts3AllocateSegdirIdx() will merge the segments at level iLevel+1 to 
127090     ** a single iLevel+2 segment if necessary.  */
127091     rc = fts3AllocateSegdirIdx(p, iIndex, iLevel+1, &iIdx);
127092     iNewLevel = iIndex * FTS3_SEGDIR_MAXLEVEL + iLevel+1;
127093   }
127094   if( rc!=SQLCIPHER_OK ) goto finished;
127095   assert( csr.nSegment>0 );
127096   assert( iNewLevel>=(iIndex*FTS3_SEGDIR_MAXLEVEL) );
127097   assert( iNewLevel<((iIndex+1)*FTS3_SEGDIR_MAXLEVEL) );
127098
127099   memset(&filter, 0, sizeof(Fts3SegFilter));
127100   filter.flags = FTS3_SEGMENT_REQUIRE_POS;
127101   filter.flags |= (bIgnoreEmpty ? FTS3_SEGMENT_IGNORE_EMPTY : 0);
127102
127103   rc = sqlcipher3Fts3SegReaderStart(p, &csr, &filter);
127104   while( SQLCIPHER_OK==rc ){
127105     rc = sqlcipher3Fts3SegReaderStep(p, &csr);
127106     if( rc!=SQLCIPHER_ROW ) break;
127107     rc = fts3SegWriterAdd(p, &pWriter, 1, 
127108         csr.zTerm, csr.nTerm, csr.aDoclist, csr.nDoclist);
127109   }
127110   if( rc!=SQLCIPHER_OK ) goto finished;
127111   assert( pWriter );
127112
127113   if( iLevel!=FTS3_SEGCURSOR_PENDING ){
127114     rc = fts3DeleteSegdir(p, iIndex, iLevel, csr.apSegment, csr.nSegment);
127115     if( rc!=SQLCIPHER_OK ) goto finished;
127116   }
127117   rc = fts3SegWriterFlush(p, pWriter, iNewLevel, iIdx);
127118
127119  finished:
127120   fts3SegWriterFree(pWriter);
127121   sqlcipher3Fts3SegReaderFinish(&csr);
127122   return rc;
127123 }
127124
127125
127126 /* 
127127 ** Flush the contents of pendingTerms to level 0 segments.
127128 */
127129 SQLCIPHER_PRIVATE int sqlcipher3Fts3PendingTermsFlush(Fts3Table *p){
127130   int rc = SQLCIPHER_OK;
127131   int i;
127132   for(i=0; rc==SQLCIPHER_OK && i<p->nIndex; i++){
127133     rc = fts3SegmentMerge(p, i, FTS3_SEGCURSOR_PENDING);
127134     if( rc==SQLCIPHER_DONE ) rc = SQLCIPHER_OK;
127135   }
127136   sqlcipher3Fts3PendingTermsClear(p);
127137   return rc;
127138 }
127139
127140 /*
127141 ** Encode N integers as varints into a blob.
127142 */
127143 static void fts3EncodeIntArray(
127144   int N,             /* The number of integers to encode */
127145   u32 *a,            /* The integer values */
127146   char *zBuf,        /* Write the BLOB here */
127147   int *pNBuf         /* Write number of bytes if zBuf[] used here */
127148 ){
127149   int i, j;
127150   for(i=j=0; i<N; i++){
127151     j += sqlcipher3Fts3PutVarint(&zBuf[j], (sqlcipher3_int64)a[i]);
127152   }
127153   *pNBuf = j;
127154 }
127155
127156 /*
127157 ** Decode a blob of varints into N integers
127158 */
127159 static void fts3DecodeIntArray(
127160   int N,             /* The number of integers to decode */
127161   u32 *a,            /* Write the integer values */
127162   const char *zBuf,  /* The BLOB containing the varints */
127163   int nBuf           /* size of the BLOB */
127164 ){
127165   int i, j;
127166   UNUSED_PARAMETER(nBuf);
127167   for(i=j=0; i<N; i++){
127168     sqlcipher3_int64 x;
127169     j += sqlcipher3Fts3GetVarint(&zBuf[j], &x);
127170     assert(j<=nBuf);
127171     a[i] = (u32)(x & 0xffffffff);
127172   }
127173 }
127174
127175 /*
127176 ** Insert the sizes (in tokens) for each column of the document
127177 ** with docid equal to p->iPrevDocid.  The sizes are encoded as
127178 ** a blob of varints.
127179 */
127180 static void fts3InsertDocsize(
127181   int *pRC,                       /* Result code */
127182   Fts3Table *p,                   /* Table into which to insert */
127183   u32 *aSz                        /* Sizes of each column, in tokens */
127184 ){
127185   char *pBlob;             /* The BLOB encoding of the document size */
127186   int nBlob;               /* Number of bytes in the BLOB */
127187   sqlcipher3_stmt *pStmt;     /* Statement used to insert the encoding */
127188   int rc;                  /* Result code from subfunctions */
127189
127190   if( *pRC ) return;
127191   pBlob = sqlcipher3_malloc( 10*p->nColumn );
127192   if( pBlob==0 ){
127193     *pRC = SQLCIPHER_NOMEM;
127194     return;
127195   }
127196   fts3EncodeIntArray(p->nColumn, aSz, pBlob, &nBlob);
127197   rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0);
127198   if( rc ){
127199     sqlcipher3_free(pBlob);
127200     *pRC = rc;
127201     return;
127202   }
127203   sqlcipher3_bind_int64(pStmt, 1, p->iPrevDocid);
127204   sqlcipher3_bind_blob(pStmt, 2, pBlob, nBlob, sqlcipher3_free);
127205   sqlcipher3_step(pStmt);
127206   *pRC = sqlcipher3_reset(pStmt);
127207 }
127208
127209 /*
127210 ** Record 0 of the %_stat table contains a blob consisting of N varints,
127211 ** where N is the number of user defined columns in the fts3 table plus
127212 ** two. If nCol is the number of user defined columns, then values of the 
127213 ** varints are set as follows:
127214 **
127215 **   Varint 0:       Total number of rows in the table.
127216 **
127217 **   Varint 1..nCol: For each column, the total number of tokens stored in
127218 **                   the column for all rows of the table.
127219 **
127220 **   Varint 1+nCol:  The total size, in bytes, of all text values in all
127221 **                   columns of all rows of the table.
127222 **
127223 */
127224 static void fts3UpdateDocTotals(
127225   int *pRC,                       /* The result code */
127226   Fts3Table *p,                   /* Table being updated */
127227   u32 *aSzIns,                    /* Size increases */
127228   u32 *aSzDel,                    /* Size decreases */
127229   int nChng                       /* Change in the number of documents */
127230 ){
127231   char *pBlob;             /* Storage for BLOB written into %_stat */
127232   int nBlob;               /* Size of BLOB written into %_stat */
127233   u32 *a;                  /* Array of integers that becomes the BLOB */
127234   sqlcipher3_stmt *pStmt;     /* Statement for reading and writing */
127235   int i;                   /* Loop counter */
127236   int rc;                  /* Result code from subfunctions */
127237
127238   const int nStat = p->nColumn+2;
127239
127240   if( *pRC ) return;
127241   a = sqlcipher3_malloc( (sizeof(u32)+10)*nStat );
127242   if( a==0 ){
127243     *pRC = SQLCIPHER_NOMEM;
127244     return;
127245   }
127246   pBlob = (char*)&a[nStat];
127247   rc = fts3SqlStmt(p, SQL_SELECT_DOCTOTAL, &pStmt, 0);
127248   if( rc ){
127249     sqlcipher3_free(a);
127250     *pRC = rc;
127251     return;
127252   }
127253   if( sqlcipher3_step(pStmt)==SQLCIPHER_ROW ){
127254     fts3DecodeIntArray(nStat, a,
127255          sqlcipher3_column_blob(pStmt, 0),
127256          sqlcipher3_column_bytes(pStmt, 0));
127257   }else{
127258     memset(a, 0, sizeof(u32)*(nStat) );
127259   }
127260   sqlcipher3_reset(pStmt);
127261   if( nChng<0 && a[0]<(u32)(-nChng) ){
127262     a[0] = 0;
127263   }else{
127264     a[0] += nChng;
127265   }
127266   for(i=0; i<p->nColumn+1; i++){
127267     u32 x = a[i+1];
127268     if( x+aSzIns[i] < aSzDel[i] ){
127269       x = 0;
127270     }else{
127271       x = x + aSzIns[i] - aSzDel[i];
127272     }
127273     a[i+1] = x;
127274   }
127275   fts3EncodeIntArray(nStat, a, pBlob, &nBlob);
127276   rc = fts3SqlStmt(p, SQL_REPLACE_DOCTOTAL, &pStmt, 0);
127277   if( rc ){
127278     sqlcipher3_free(a);
127279     *pRC = rc;
127280     return;
127281   }
127282   sqlcipher3_bind_blob(pStmt, 1, pBlob, nBlob, SQLCIPHER_STATIC);
127283   sqlcipher3_step(pStmt);
127284   *pRC = sqlcipher3_reset(pStmt);
127285   sqlcipher3_free(a);
127286 }
127287
127288 static int fts3DoOptimize(Fts3Table *p, int bReturnDone){
127289   int i;
127290   int bSeenDone = 0;
127291   int rc = SQLCIPHER_OK;
127292   for(i=0; rc==SQLCIPHER_OK && i<p->nIndex; i++){
127293     rc = fts3SegmentMerge(p, i, FTS3_SEGCURSOR_ALL);
127294     if( rc==SQLCIPHER_DONE ){
127295       bSeenDone = 1;
127296       rc = SQLCIPHER_OK;
127297     }
127298   }
127299   sqlcipher3Fts3SegmentsClose(p);
127300   sqlcipher3Fts3PendingTermsClear(p);
127301
127302   return (rc==SQLCIPHER_OK && bReturnDone && bSeenDone) ? SQLCIPHER_DONE : rc;
127303 }
127304
127305 /*
127306 ** This function is called when the user executes the following statement:
127307 **
127308 **     INSERT INTO <tbl>(<tbl>) VALUES('rebuild');
127309 **
127310 ** The entire FTS index is discarded and rebuilt. If the table is one 
127311 ** created using the content=xxx option, then the new index is based on
127312 ** the current contents of the xxx table. Otherwise, it is rebuilt based
127313 ** on the contents of the %_content table.
127314 */
127315 static int fts3DoRebuild(Fts3Table *p){
127316   int rc;                         /* Return Code */
127317
127318   rc = fts3DeleteAll(p, 0);
127319   if( rc==SQLCIPHER_OK ){
127320     u32 *aSz = 0;
127321     u32 *aSzIns = 0;
127322     u32 *aSzDel = 0;
127323     sqlcipher3_stmt *pStmt = 0;
127324     int nEntry = 0;
127325
127326     /* Compose and prepare an SQL statement to loop through the content table */
127327     char *zSql = sqlcipher3_mprintf("SELECT %s" , p->zReadExprlist);
127328     if( !zSql ){
127329       rc = SQLCIPHER_NOMEM;
127330     }else{
127331       rc = sqlcipher3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
127332       sqlcipher3_free(zSql);
127333     }
127334
127335     if( rc==SQLCIPHER_OK ){
127336       int nByte = sizeof(u32) * (p->nColumn+1)*3;
127337       aSz = (u32 *)sqlcipher3_malloc(nByte);
127338       if( aSz==0 ){
127339         rc = SQLCIPHER_NOMEM;
127340       }else{
127341         memset(aSz, 0, nByte);
127342         aSzIns = &aSz[p->nColumn+1];
127343         aSzDel = &aSzIns[p->nColumn+1];
127344       }
127345     }
127346
127347     while( rc==SQLCIPHER_OK && SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
127348       int iCol;
127349       rc = fts3PendingTermsDocid(p, sqlcipher3_column_int64(pStmt, 0));
127350       aSz[p->nColumn] = 0;
127351       for(iCol=0; rc==SQLCIPHER_OK && iCol<p->nColumn; iCol++){
127352         const char *z = (const char *) sqlcipher3_column_text(pStmt, iCol+1);
127353         rc = fts3PendingTermsAdd(p, z, iCol, &aSz[iCol]);
127354         aSz[p->nColumn] += sqlcipher3_column_bytes(pStmt, iCol+1);
127355       }
127356       if( p->bHasDocsize ){
127357         fts3InsertDocsize(&rc, p, aSz);
127358       }
127359       if( rc!=SQLCIPHER_OK ){
127360         sqlcipher3_finalize(pStmt);
127361         pStmt = 0;
127362       }else{
127363         nEntry++;
127364         for(iCol=0; iCol<=p->nColumn; iCol++){
127365           aSzIns[iCol] += aSz[iCol];
127366         }
127367       }
127368     }
127369     if( p->bHasStat ){
127370       fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nEntry);
127371     }
127372     sqlcipher3_free(aSz);
127373
127374     if( pStmt ){
127375       int rc2 = sqlcipher3_finalize(pStmt);
127376       if( rc==SQLCIPHER_OK ){
127377         rc = rc2;
127378       }
127379     }
127380   }
127381
127382   return rc;
127383 }
127384
127385 /*
127386 ** Handle a 'special' INSERT of the form:
127387 **
127388 **   "INSERT INTO tbl(tbl) VALUES(<expr>)"
127389 **
127390 ** Argument pVal contains the result of <expr>. Currently the only 
127391 ** meaningful value to insert is the text 'optimize'.
127392 */
127393 static int fts3SpecialInsert(Fts3Table *p, sqlcipher3_value *pVal){
127394   int rc;                         /* Return Code */
127395   const char *zVal = (const char *)sqlcipher3_value_text(pVal);
127396   int nVal = sqlcipher3_value_bytes(pVal);
127397
127398   if( !zVal ){
127399     return SQLCIPHER_NOMEM;
127400   }else if( nVal==8 && 0==sqlcipher3_strnicmp(zVal, "optimize", 8) ){
127401     rc = fts3DoOptimize(p, 0);
127402   }else if( nVal==7 && 0==sqlcipher3_strnicmp(zVal, "rebuild", 7) ){
127403     rc = fts3DoRebuild(p);
127404 #ifdef SQLCIPHER_TEST
127405   }else if( nVal>9 && 0==sqlcipher3_strnicmp(zVal, "nodesize=", 9) ){
127406     p->nNodeSize = atoi(&zVal[9]);
127407     rc = SQLCIPHER_OK;
127408   }else if( nVal>11 && 0==sqlcipher3_strnicmp(zVal, "maxpending=", 9) ){
127409     p->nMaxPendingData = atoi(&zVal[11]);
127410     rc = SQLCIPHER_OK;
127411 #endif
127412   }else{
127413     rc = SQLCIPHER_ERROR;
127414   }
127415
127416   return rc;
127417 }
127418
127419 /*
127420 ** Delete all cached deferred doclists. Deferred doclists are cached
127421 ** (allocated) by the sqlcipher3Fts3CacheDeferredDoclists() function.
127422 */
127423 SQLCIPHER_PRIVATE void sqlcipher3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){
127424   Fts3DeferredToken *pDef;
127425   for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
127426     fts3PendingListDelete(pDef->pList);
127427     pDef->pList = 0;
127428   }
127429 }
127430
127431 /*
127432 ** Free all entries in the pCsr->pDeffered list. Entries are added to 
127433 ** this list using sqlcipher3Fts3DeferToken().
127434 */
127435 SQLCIPHER_PRIVATE void sqlcipher3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){
127436   Fts3DeferredToken *pDef;
127437   Fts3DeferredToken *pNext;
127438   for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
127439     pNext = pDef->pNext;
127440     fts3PendingListDelete(pDef->pList);
127441     sqlcipher3_free(pDef);
127442   }
127443   pCsr->pDeferred = 0;
127444 }
127445
127446 /*
127447 ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
127448 ** based on the row that pCsr currently points to.
127449 **
127450 ** A deferred-doclist is like any other doclist with position information
127451 ** included, except that it only contains entries for a single row of the
127452 ** table, not for all rows.
127453 */
127454 SQLCIPHER_PRIVATE int sqlcipher3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){
127455   int rc = SQLCIPHER_OK;             /* Return code */
127456   if( pCsr->pDeferred ){
127457     int i;                        /* Used to iterate through table columns */
127458     sqlcipher3_int64 iDocid;         /* Docid of the row pCsr points to */
127459     Fts3DeferredToken *pDef;      /* Used to iterate through deferred tokens */
127460   
127461     Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
127462     sqlcipher3_tokenizer *pT = p->pTokenizer;
127463     sqlcipher3_tokenizer_module const *pModule = pT->pModule;
127464    
127465     assert( pCsr->isRequireSeek==0 );
127466     iDocid = sqlcipher3_column_int64(pCsr->pStmt, 0);
127467   
127468     for(i=0; i<p->nColumn && rc==SQLCIPHER_OK; i++){
127469       const char *zText = (const char *)sqlcipher3_column_text(pCsr->pStmt, i+1);
127470       sqlcipher3_tokenizer_cursor *pTC = 0;
127471   
127472       rc = pModule->xOpen(pT, zText, -1, &pTC);
127473       while( rc==SQLCIPHER_OK ){
127474         char const *zToken;       /* Buffer containing token */
127475         int nToken;               /* Number of bytes in token */
127476         int iDum1, iDum2;         /* Dummy variables */
127477         int iPos;                 /* Position of token in zText */
127478   
127479         pTC->pTokenizer = pT;
127480         rc = pModule->xNext(pTC, &zToken, &nToken, &iDum1, &iDum2, &iPos);
127481         for(pDef=pCsr->pDeferred; pDef && rc==SQLCIPHER_OK; pDef=pDef->pNext){
127482           Fts3PhraseToken *pPT = pDef->pToken;
127483           if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
127484            && (pPT->bFirst==0 || iPos==0)
127485            && (pPT->n==nToken || (pPT->isPrefix && pPT->n<nToken))
127486            && (0==memcmp(zToken, pPT->z, pPT->n))
127487           ){
127488             fts3PendingListAppend(&pDef->pList, iDocid, i, iPos, &rc);
127489           }
127490         }
127491       }
127492       if( pTC ) pModule->xClose(pTC);
127493       if( rc==SQLCIPHER_DONE ) rc = SQLCIPHER_OK;
127494     }
127495   
127496     for(pDef=pCsr->pDeferred; pDef && rc==SQLCIPHER_OK; pDef=pDef->pNext){
127497       if( pDef->pList ){
127498         rc = fts3PendingListAppendVarint(&pDef->pList, 0);
127499       }
127500     }
127501   }
127502
127503   return rc;
127504 }
127505
127506 SQLCIPHER_PRIVATE int sqlcipher3Fts3DeferredTokenList(
127507   Fts3DeferredToken *p, 
127508   char **ppData, 
127509   int *pnData
127510 ){
127511   char *pRet;
127512   int nSkip;
127513   sqlcipher3_int64 dummy;
127514
127515   *ppData = 0;
127516   *pnData = 0;
127517
127518   if( p->pList==0 ){
127519     return SQLCIPHER_OK;
127520   }
127521
127522   pRet = (char *)sqlcipher3_malloc(p->pList->nData);
127523   if( !pRet ) return SQLCIPHER_NOMEM;
127524
127525   nSkip = sqlcipher3Fts3GetVarint(p->pList->aData, &dummy);
127526   *pnData = p->pList->nData - nSkip;
127527   *ppData = pRet;
127528   
127529   memcpy(pRet, &p->pList->aData[nSkip], *pnData);
127530   return SQLCIPHER_OK;
127531 }
127532
127533 /*
127534 ** Add an entry for token pToken to the pCsr->pDeferred list.
127535 */
127536 SQLCIPHER_PRIVATE int sqlcipher3Fts3DeferToken(
127537   Fts3Cursor *pCsr,               /* Fts3 table cursor */
127538   Fts3PhraseToken *pToken,        /* Token to defer */
127539   int iCol                        /* Column that token must appear in (or -1) */
127540 ){
127541   Fts3DeferredToken *pDeferred;
127542   pDeferred = sqlcipher3_malloc(sizeof(*pDeferred));
127543   if( !pDeferred ){
127544     return SQLCIPHER_NOMEM;
127545   }
127546   memset(pDeferred, 0, sizeof(*pDeferred));
127547   pDeferred->pToken = pToken;
127548   pDeferred->pNext = pCsr->pDeferred; 
127549   pDeferred->iCol = iCol;
127550   pCsr->pDeferred = pDeferred;
127551
127552   assert( pToken->pDeferred==0 );
127553   pToken->pDeferred = pDeferred;
127554
127555   return SQLCIPHER_OK;
127556 }
127557
127558 /*
127559 ** SQLite value pRowid contains the rowid of a row that may or may not be
127560 ** present in the FTS3 table. If it is, delete it and adjust the contents
127561 ** of subsiduary data structures accordingly.
127562 */
127563 static int fts3DeleteByRowid(
127564   Fts3Table *p, 
127565   sqlcipher3_value *pRowid, 
127566   int *pnDoc,
127567   u32 *aSzDel
127568 ){
127569   int isEmpty = 0;
127570   int rc = fts3IsEmpty(p, pRowid, &isEmpty);
127571   if( rc==SQLCIPHER_OK ){
127572     if( isEmpty ){
127573       /* Deleting this row means the whole table is empty. In this case
127574       ** delete the contents of all three tables and throw away any
127575       ** data in the pendingTerms hash table.  */
127576       rc = fts3DeleteAll(p, 1);
127577       *pnDoc = *pnDoc - 1;
127578     }else{
127579       sqlcipher3_int64 iRemove = sqlcipher3_value_int64(pRowid);
127580       rc = fts3PendingTermsDocid(p, iRemove);
127581       fts3DeleteTerms(&rc, p, pRowid, aSzDel);
127582       if( p->zContentTbl==0 ){
127583         fts3SqlExec(&rc, p, SQL_DELETE_CONTENT, &pRowid);
127584         if( sqlcipher3_changes(p->db) ) *pnDoc = *pnDoc - 1;
127585       }else{
127586         *pnDoc = *pnDoc - 1;
127587       }
127588       if( p->bHasDocsize ){
127589         fts3SqlExec(&rc, p, SQL_DELETE_DOCSIZE, &pRowid);
127590       }
127591     }
127592   }
127593
127594   return rc;
127595 }
127596
127597 /*
127598 ** This function does the work for the xUpdate method of FTS3 virtual
127599 ** tables.
127600 */
127601 SQLCIPHER_PRIVATE int sqlcipher3Fts3UpdateMethod(
127602   sqlcipher3_vtab *pVtab,            /* FTS3 vtab object */
127603   int nArg,                       /* Size of argument array */
127604   sqlcipher3_value **apVal,          /* Array of arguments */
127605   sqlcipher_int64 *pRowid            /* OUT: The affected (or effected) rowid */
127606 ){
127607   Fts3Table *p = (Fts3Table *)pVtab;
127608   int rc = SQLCIPHER_OK;             /* Return Code */
127609   int isRemove = 0;               /* True for an UPDATE or DELETE */
127610   u32 *aSzIns = 0;                /* Sizes of inserted documents */
127611   u32 *aSzDel;                    /* Sizes of deleted documents */
127612   int nChng = 0;                  /* Net change in number of documents */
127613   int bInsertDone = 0;
127614
127615   assert( p->pSegments==0 );
127616
127617   /* Check for a "special" INSERT operation. One of the form:
127618   **
127619   **   INSERT INTO xyz(xyz) VALUES('command');
127620   */
127621   if( nArg>1 
127622    && sqlcipher3_value_type(apVal[0])==SQLCIPHER_NULL 
127623    && sqlcipher3_value_type(apVal[p->nColumn+2])!=SQLCIPHER_NULL 
127624   ){
127625     rc = fts3SpecialInsert(p, apVal[p->nColumn+2]);
127626     goto update_out;
127627   }
127628
127629   /* Allocate space to hold the change in document sizes */
127630   aSzIns = sqlcipher3_malloc( sizeof(aSzIns[0])*(p->nColumn+1)*2 );
127631   if( aSzIns==0 ){
127632     rc = SQLCIPHER_NOMEM;
127633     goto update_out;
127634   }
127635   aSzDel = &aSzIns[p->nColumn+1];
127636   memset(aSzIns, 0, sizeof(aSzIns[0])*(p->nColumn+1)*2);
127637
127638   /* If this is an INSERT operation, or an UPDATE that modifies the rowid
127639   ** value, then this operation requires constraint handling.
127640   **
127641   ** If the on-conflict mode is REPLACE, this means that the existing row
127642   ** should be deleted from the database before inserting the new row. Or,
127643   ** if the on-conflict mode is other than REPLACE, then this method must
127644   ** detect the conflict and return SQLCIPHER_CONSTRAINT before beginning to
127645   ** modify the database file.
127646   */
127647   if( nArg>1 && p->zContentTbl==0 ){
127648     /* Find the value object that holds the new rowid value. */
127649     sqlcipher3_value *pNewRowid = apVal[3+p->nColumn];
127650     if( sqlcipher3_value_type(pNewRowid)==SQLCIPHER_NULL ){
127651       pNewRowid = apVal[1];
127652     }
127653
127654     if( sqlcipher3_value_type(pNewRowid)!=SQLCIPHER_NULL && ( 
127655         sqlcipher3_value_type(apVal[0])==SQLCIPHER_NULL
127656      || sqlcipher3_value_int64(apVal[0])!=sqlcipher3_value_int64(pNewRowid)
127657     )){
127658       /* The new rowid is not NULL (in this case the rowid will be
127659       ** automatically assigned and there is no chance of a conflict), and 
127660       ** the statement is either an INSERT or an UPDATE that modifies the
127661       ** rowid column. So if the conflict mode is REPLACE, then delete any
127662       ** existing row with rowid=pNewRowid. 
127663       **
127664       ** Or, if the conflict mode is not REPLACE, insert the new record into 
127665       ** the %_content table. If we hit the duplicate rowid constraint (or any
127666       ** other error) while doing so, return immediately.
127667       **
127668       ** This branch may also run if pNewRowid contains a value that cannot
127669       ** be losslessly converted to an integer. In this case, the eventual 
127670       ** call to fts3InsertData() (either just below or further on in this
127671       ** function) will return SQLCIPHER_MISMATCH. If fts3DeleteByRowid is 
127672       ** invoked, it will delete zero rows (since no row will have
127673       ** docid=$pNewRowid if $pNewRowid is not an integer value).
127674       */
127675       if( sqlcipher3_vtab_on_conflict(p->db)==SQLCIPHER_REPLACE ){
127676         rc = fts3DeleteByRowid(p, pNewRowid, &nChng, aSzDel);
127677       }else{
127678         rc = fts3InsertData(p, apVal, pRowid);
127679         bInsertDone = 1;
127680       }
127681     }
127682   }
127683   if( rc!=SQLCIPHER_OK ){
127684     goto update_out;
127685   }
127686
127687   /* If this is a DELETE or UPDATE operation, remove the old record. */
127688   if( sqlcipher3_value_type(apVal[0])!=SQLCIPHER_NULL ){
127689     assert( sqlcipher3_value_type(apVal[0])==SQLCIPHER_INTEGER );
127690     rc = fts3DeleteByRowid(p, apVal[0], &nChng, aSzDel);
127691     isRemove = 1;
127692   }
127693   
127694   /* If this is an INSERT or UPDATE operation, insert the new record. */
127695   if( nArg>1 && rc==SQLCIPHER_OK ){
127696     if( bInsertDone==0 ){
127697       rc = fts3InsertData(p, apVal, pRowid);
127698       if( rc==SQLCIPHER_CONSTRAINT && p->zContentTbl==0 ){
127699         rc = FTS_CORRUPT_VTAB;
127700       }
127701     }
127702     if( rc==SQLCIPHER_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){
127703       rc = fts3PendingTermsDocid(p, *pRowid);
127704     }
127705     if( rc==SQLCIPHER_OK ){
127706       assert( p->iPrevDocid==*pRowid );
127707       rc = fts3InsertTerms(p, apVal, aSzIns);
127708     }
127709     if( p->bHasDocsize ){
127710       fts3InsertDocsize(&rc, p, aSzIns);
127711     }
127712     nChng++;
127713   }
127714
127715   if( p->bHasStat ){
127716     fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nChng);
127717   }
127718
127719  update_out:
127720   sqlcipher3_free(aSzIns);
127721   sqlcipher3Fts3SegmentsClose(p);
127722   return rc;
127723 }
127724
127725 /* 
127726 ** Flush any data in the pending-terms hash table to disk. If successful,
127727 ** merge all segments in the database (including the new segment, if 
127728 ** there was any data to flush) into a single segment. 
127729 */
127730 SQLCIPHER_PRIVATE int sqlcipher3Fts3Optimize(Fts3Table *p){
127731   int rc;
127732   rc = sqlcipher3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0);
127733   if( rc==SQLCIPHER_OK ){
127734     rc = fts3DoOptimize(p, 1);
127735     if( rc==SQLCIPHER_OK || rc==SQLCIPHER_DONE ){
127736       int rc2 = sqlcipher3_exec(p->db, "RELEASE fts3", 0, 0, 0);
127737       if( rc2!=SQLCIPHER_OK ) rc = rc2;
127738     }else{
127739       sqlcipher3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0);
127740       sqlcipher3_exec(p->db, "RELEASE fts3", 0, 0, 0);
127741     }
127742   }
127743   sqlcipher3Fts3SegmentsClose(p);
127744   return rc;
127745 }
127746
127747 #endif
127748
127749 /************** End of fts3_write.c ******************************************/
127750 /************** Begin file fts3_snippet.c ************************************/
127751 /*
127752 ** 2009 Oct 23
127753 **
127754 ** The author disclaims copyright to this source code.  In place of
127755 ** a legal notice, here is a blessing:
127756 **
127757 **    May you do good and not evil.
127758 **    May you find forgiveness for yourself and forgive others.
127759 **    May you share freely, never taking more than you give.
127760 **
127761 ******************************************************************************
127762 */
127763
127764 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
127765
127766 /* #include <string.h> */
127767 /* #include <assert.h> */
127768
127769 /*
127770 ** Characters that may appear in the second argument to matchinfo().
127771 */
127772 #define FTS3_MATCHINFO_NPHRASE   'p'        /* 1 value */
127773 #define FTS3_MATCHINFO_NCOL      'c'        /* 1 value */
127774 #define FTS3_MATCHINFO_NDOC      'n'        /* 1 value */
127775 #define FTS3_MATCHINFO_AVGLENGTH 'a'        /* nCol values */
127776 #define FTS3_MATCHINFO_LENGTH    'l'        /* nCol values */
127777 #define FTS3_MATCHINFO_LCS       's'        /* nCol values */
127778 #define FTS3_MATCHINFO_HITS      'x'        /* 3*nCol*nPhrase values */
127779
127780 /*
127781 ** The default value for the second argument to matchinfo(). 
127782 */
127783 #define FTS3_MATCHINFO_DEFAULT   "pcx"
127784
127785
127786 /*
127787 ** Used as an fts3ExprIterate() context when loading phrase doclists to
127788 ** Fts3Expr.aDoclist[]/nDoclist.
127789 */
127790 typedef struct LoadDoclistCtx LoadDoclistCtx;
127791 struct LoadDoclistCtx {
127792   Fts3Cursor *pCsr;               /* FTS3 Cursor */
127793   int nPhrase;                    /* Number of phrases seen so far */
127794   int nToken;                     /* Number of tokens seen so far */
127795 };
127796
127797 /*
127798 ** The following types are used as part of the implementation of the 
127799 ** fts3BestSnippet() routine.
127800 */
127801 typedef struct SnippetIter SnippetIter;
127802 typedef struct SnippetPhrase SnippetPhrase;
127803 typedef struct SnippetFragment SnippetFragment;
127804
127805 struct SnippetIter {
127806   Fts3Cursor *pCsr;               /* Cursor snippet is being generated from */
127807   int iCol;                       /* Extract snippet from this column */
127808   int nSnippet;                   /* Requested snippet length (in tokens) */
127809   int nPhrase;                    /* Number of phrases in query */
127810   SnippetPhrase *aPhrase;         /* Array of size nPhrase */
127811   int iCurrent;                   /* First token of current snippet */
127812 };
127813
127814 struct SnippetPhrase {
127815   int nToken;                     /* Number of tokens in phrase */
127816   char *pList;                    /* Pointer to start of phrase position list */
127817   int iHead;                      /* Next value in position list */
127818   char *pHead;                    /* Position list data following iHead */
127819   int iTail;                      /* Next value in trailing position list */
127820   char *pTail;                    /* Position list data following iTail */
127821 };
127822
127823 struct SnippetFragment {
127824   int iCol;                       /* Column snippet is extracted from */
127825   int iPos;                       /* Index of first token in snippet */
127826   u64 covered;                    /* Mask of query phrases covered */
127827   u64 hlmask;                     /* Mask of snippet terms to highlight */
127828 };
127829
127830 /*
127831 ** This type is used as an fts3ExprIterate() context object while 
127832 ** accumulating the data returned by the matchinfo() function.
127833 */
127834 typedef struct MatchInfo MatchInfo;
127835 struct MatchInfo {
127836   Fts3Cursor *pCursor;            /* FTS3 Cursor */
127837   int nCol;                       /* Number of columns in table */
127838   int nPhrase;                    /* Number of matchable phrases in query */
127839   sqlcipher3_int64 nDoc;             /* Number of docs in database */
127840   u32 *aMatchinfo;                /* Pre-allocated buffer */
127841 };
127842
127843
127844
127845 /*
127846 ** The snippet() and offsets() functions both return text values. An instance
127847 ** of the following structure is used to accumulate those values while the
127848 ** functions are running. See fts3StringAppend() for details.
127849 */
127850 typedef struct StrBuffer StrBuffer;
127851 struct StrBuffer {
127852   char *z;                        /* Pointer to buffer containing string */
127853   int n;                          /* Length of z in bytes (excl. nul-term) */
127854   int nAlloc;                     /* Allocated size of buffer z in bytes */
127855 };
127856
127857
127858 /*
127859 ** This function is used to help iterate through a position-list. A position
127860 ** list is a list of unique integers, sorted from smallest to largest. Each
127861 ** element of the list is represented by an FTS3 varint that takes the value
127862 ** of the difference between the current element and the previous one plus
127863 ** two. For example, to store the position-list:
127864 **
127865 **     4 9 113
127866 **
127867 ** the three varints:
127868 **
127869 **     6 7 106
127870 **
127871 ** are encoded.
127872 **
127873 ** When this function is called, *pp points to the start of an element of
127874 ** the list. *piPos contains the value of the previous entry in the list.
127875 ** After it returns, *piPos contains the value of the next element of the
127876 ** list and *pp is advanced to the following varint.
127877 */
127878 static void fts3GetDeltaPosition(char **pp, int *piPos){
127879   int iVal;
127880   *pp += sqlcipher3Fts3GetVarint32(*pp, &iVal);
127881   *piPos += (iVal-2);
127882 }
127883
127884 /*
127885 ** Helper function for fts3ExprIterate() (see below).
127886 */
127887 static int fts3ExprIterate2(
127888   Fts3Expr *pExpr,                /* Expression to iterate phrases of */
127889   int *piPhrase,                  /* Pointer to phrase counter */
127890   int (*x)(Fts3Expr*,int,void*),  /* Callback function to invoke for phrases */
127891   void *pCtx                      /* Second argument to pass to callback */
127892 ){
127893   int rc;                         /* Return code */
127894   int eType = pExpr->eType;       /* Type of expression node pExpr */
127895
127896   if( eType!=FTSQUERY_PHRASE ){
127897     assert( pExpr->pLeft && pExpr->pRight );
127898     rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
127899     if( rc==SQLCIPHER_OK && eType!=FTSQUERY_NOT ){
127900       rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
127901     }
127902   }else{
127903     rc = x(pExpr, *piPhrase, pCtx);
127904     (*piPhrase)++;
127905   }
127906   return rc;
127907 }
127908
127909 /*
127910 ** Iterate through all phrase nodes in an FTS3 query, except those that
127911 ** are part of a sub-tree that is the right-hand-side of a NOT operator.
127912 ** For each phrase node found, the supplied callback function is invoked.
127913 **
127914 ** If the callback function returns anything other than SQLCIPHER_OK, 
127915 ** the iteration is abandoned and the error code returned immediately.
127916 ** Otherwise, SQLCIPHER_OK is returned after a callback has been made for
127917 ** all eligible phrase nodes.
127918 */
127919 static int fts3ExprIterate(
127920   Fts3Expr *pExpr,                /* Expression to iterate phrases of */
127921   int (*x)(Fts3Expr*,int,void*),  /* Callback function to invoke for phrases */
127922   void *pCtx                      /* Second argument to pass to callback */
127923 ){
127924   int iPhrase = 0;                /* Variable used as the phrase counter */
127925   return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
127926 }
127927
127928 /*
127929 ** This is an fts3ExprIterate() callback used while loading the doclists
127930 ** for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also
127931 ** fts3ExprLoadDoclists().
127932 */
127933 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
127934   int rc = SQLCIPHER_OK;
127935   Fts3Phrase *pPhrase = pExpr->pPhrase;
127936   LoadDoclistCtx *p = (LoadDoclistCtx *)ctx;
127937
127938   UNUSED_PARAMETER(iPhrase);
127939
127940   p->nPhrase++;
127941   p->nToken += pPhrase->nToken;
127942
127943   return rc;
127944 }
127945
127946 /*
127947 ** Load the doclists for each phrase in the query associated with FTS3 cursor
127948 ** pCsr. 
127949 **
127950 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable 
127951 ** phrases in the expression (all phrases except those directly or 
127952 ** indirectly descended from the right-hand-side of a NOT operator). If 
127953 ** pnToken is not NULL, then it is set to the number of tokens in all
127954 ** matchable phrases of the expression.
127955 */
127956 static int fts3ExprLoadDoclists(
127957   Fts3Cursor *pCsr,               /* Fts3 cursor for current query */
127958   int *pnPhrase,                  /* OUT: Number of phrases in query */
127959   int *pnToken                    /* OUT: Number of tokens in query */
127960 ){
127961   int rc;                         /* Return Code */
127962   LoadDoclistCtx sCtx = {0,0,0};  /* Context for fts3ExprIterate() */
127963   sCtx.pCsr = pCsr;
127964   rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
127965   if( pnPhrase ) *pnPhrase = sCtx.nPhrase;
127966   if( pnToken ) *pnToken = sCtx.nToken;
127967   return rc;
127968 }
127969
127970 static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
127971   (*(int *)ctx)++;
127972   UNUSED_PARAMETER(pExpr);
127973   UNUSED_PARAMETER(iPhrase);
127974   return SQLCIPHER_OK;
127975 }
127976 static int fts3ExprPhraseCount(Fts3Expr *pExpr){
127977   int nPhrase = 0;
127978   (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
127979   return nPhrase;
127980 }
127981
127982 /*
127983 ** Advance the position list iterator specified by the first two 
127984 ** arguments so that it points to the first element with a value greater
127985 ** than or equal to parameter iNext.
127986 */
127987 static void fts3SnippetAdvance(char **ppIter, int *piIter, int iNext){
127988   char *pIter = *ppIter;
127989   if( pIter ){
127990     int iIter = *piIter;
127991
127992     while( iIter<iNext ){
127993       if( 0==(*pIter & 0xFE) ){
127994         iIter = -1;
127995         pIter = 0;
127996         break;
127997       }
127998       fts3GetDeltaPosition(&pIter, &iIter);
127999     }
128000
128001     *piIter = iIter;
128002     *ppIter = pIter;
128003   }
128004 }
128005
128006 /*
128007 ** Advance the snippet iterator to the next candidate snippet.
128008 */
128009 static int fts3SnippetNextCandidate(SnippetIter *pIter){
128010   int i;                          /* Loop counter */
128011
128012   if( pIter->iCurrent<0 ){
128013     /* The SnippetIter object has just been initialized. The first snippet
128014     ** candidate always starts at offset 0 (even if this candidate has a
128015     ** score of 0.0).
128016     */
128017     pIter->iCurrent = 0;
128018
128019     /* Advance the 'head' iterator of each phrase to the first offset that
128020     ** is greater than or equal to (iNext+nSnippet).
128021     */
128022     for(i=0; i<pIter->nPhrase; i++){
128023       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128024       fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
128025     }
128026   }else{
128027     int iStart;
128028     int iEnd = 0x7FFFFFFF;
128029
128030     for(i=0; i<pIter->nPhrase; i++){
128031       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128032       if( pPhrase->pHead && pPhrase->iHead<iEnd ){
128033         iEnd = pPhrase->iHead;
128034       }
128035     }
128036     if( iEnd==0x7FFFFFFF ){
128037       return 1;
128038     }
128039
128040     pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
128041     for(i=0; i<pIter->nPhrase; i++){
128042       SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128043       fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, iEnd+1);
128044       fts3SnippetAdvance(&pPhrase->pTail, &pPhrase->iTail, iStart);
128045     }
128046   }
128047
128048   return 0;
128049 }
128050
128051 /*
128052 ** Retrieve information about the current candidate snippet of snippet 
128053 ** iterator pIter.
128054 */
128055 static void fts3SnippetDetails(
128056   SnippetIter *pIter,             /* Snippet iterator */
128057   u64 mCovered,                   /* Bitmask of phrases already covered */
128058   int *piToken,                   /* OUT: First token of proposed snippet */
128059   int *piScore,                   /* OUT: "Score" for this snippet */
128060   u64 *pmCover,                   /* OUT: Bitmask of phrases covered */
128061   u64 *pmHighlight                /* OUT: Bitmask of terms to highlight */
128062 ){
128063   int iStart = pIter->iCurrent;   /* First token of snippet */
128064   int iScore = 0;                 /* Score of this snippet */
128065   int i;                          /* Loop counter */
128066   u64 mCover = 0;                 /* Mask of phrases covered by this snippet */
128067   u64 mHighlight = 0;             /* Mask of tokens to highlight in snippet */
128068
128069   for(i=0; i<pIter->nPhrase; i++){
128070     SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128071     if( pPhrase->pTail ){
128072       char *pCsr = pPhrase->pTail;
128073       int iCsr = pPhrase->iTail;
128074
128075       while( iCsr<(iStart+pIter->nSnippet) ){
128076         int j;
128077         u64 mPhrase = (u64)1 << i;
128078         u64 mPos = (u64)1 << (iCsr - iStart);
128079         assert( iCsr>=iStart );
128080         if( (mCover|mCovered)&mPhrase ){
128081           iScore++;
128082         }else{
128083           iScore += 1000;
128084         }
128085         mCover |= mPhrase;
128086
128087         for(j=0; j<pPhrase->nToken; j++){
128088           mHighlight |= (mPos>>j);
128089         }
128090
128091         if( 0==(*pCsr & 0x0FE) ) break;
128092         fts3GetDeltaPosition(&pCsr, &iCsr);
128093       }
128094     }
128095   }
128096
128097   /* Set the output variables before returning. */
128098   *piToken = iStart;
128099   *piScore = iScore;
128100   *pmCover = mCover;
128101   *pmHighlight = mHighlight;
128102 }
128103
128104 /*
128105 ** This function is an fts3ExprIterate() callback used by fts3BestSnippet().
128106 ** Each invocation populates an element of the SnippetIter.aPhrase[] array.
128107 */
128108 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
128109   SnippetIter *p = (SnippetIter *)ctx;
128110   SnippetPhrase *pPhrase = &p->aPhrase[iPhrase];
128111   char *pCsr;
128112
128113   pPhrase->nToken = pExpr->pPhrase->nToken;
128114
128115   pCsr = sqlcipher3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
128116   if( pCsr ){
128117     int iFirst = 0;
128118     pPhrase->pList = pCsr;
128119     fts3GetDeltaPosition(&pCsr, &iFirst);
128120     assert( iFirst>=0 );
128121     pPhrase->pHead = pCsr;
128122     pPhrase->pTail = pCsr;
128123     pPhrase->iHead = iFirst;
128124     pPhrase->iTail = iFirst;
128125   }else{
128126     assert( pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0 );
128127   }
128128
128129   return SQLCIPHER_OK;
128130 }
128131
128132 /*
128133 ** Select the fragment of text consisting of nFragment contiguous tokens 
128134 ** from column iCol that represent the "best" snippet. The best snippet
128135 ** is the snippet with the highest score, where scores are calculated
128136 ** by adding:
128137 **
128138 **   (a) +1 point for each occurence of a matchable phrase in the snippet.
128139 **
128140 **   (b) +1000 points for the first occurence of each matchable phrase in 
128141 **       the snippet for which the corresponding mCovered bit is not set.
128142 **
128143 ** The selected snippet parameters are stored in structure *pFragment before
128144 ** returning. The score of the selected snippet is stored in *piScore
128145 ** before returning.
128146 */
128147 static int fts3BestSnippet(
128148   int nSnippet,                   /* Desired snippet length */
128149   Fts3Cursor *pCsr,               /* Cursor to create snippet for */
128150   int iCol,                       /* Index of column to create snippet from */
128151   u64 mCovered,                   /* Mask of phrases already covered */
128152   u64 *pmSeen,                    /* IN/OUT: Mask of phrases seen */
128153   SnippetFragment *pFragment,     /* OUT: Best snippet found */
128154   int *piScore                    /* OUT: Score of snippet pFragment */
128155 ){
128156   int rc;                         /* Return Code */
128157   int nList;                      /* Number of phrases in expression */
128158   SnippetIter sIter;              /* Iterates through snippet candidates */
128159   int nByte;                      /* Number of bytes of space to allocate */
128160   int iBestScore = -1;            /* Best snippet score found so far */
128161   int i;                          /* Loop counter */
128162
128163   memset(&sIter, 0, sizeof(sIter));
128164
128165   /* Iterate through the phrases in the expression to count them. The same
128166   ** callback makes sure the doclists are loaded for each phrase.
128167   */
128168   rc = fts3ExprLoadDoclists(pCsr, &nList, 0);
128169   if( rc!=SQLCIPHER_OK ){
128170     return rc;
128171   }
128172
128173   /* Now that it is known how many phrases there are, allocate and zero
128174   ** the required space using malloc().
128175   */
128176   nByte = sizeof(SnippetPhrase) * nList;
128177   sIter.aPhrase = (SnippetPhrase *)sqlcipher3_malloc(nByte);
128178   if( !sIter.aPhrase ){
128179     return SQLCIPHER_NOMEM;
128180   }
128181   memset(sIter.aPhrase, 0, nByte);
128182
128183   /* Initialize the contents of the SnippetIter object. Then iterate through
128184   ** the set of phrases in the expression to populate the aPhrase[] array.
128185   */
128186   sIter.pCsr = pCsr;
128187   sIter.iCol = iCol;
128188   sIter.nSnippet = nSnippet;
128189   sIter.nPhrase = nList;
128190   sIter.iCurrent = -1;
128191   (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sIter);
128192
128193   /* Set the *pmSeen output variable. */
128194   for(i=0; i<nList; i++){
128195     if( sIter.aPhrase[i].pHead ){
128196       *pmSeen |= (u64)1 << i;
128197     }
128198   }
128199
128200   /* Loop through all candidate snippets. Store the best snippet in 
128201   ** *pFragment. Store its associated 'score' in iBestScore.
128202   */
128203   pFragment->iCol = iCol;
128204   while( !fts3SnippetNextCandidate(&sIter) ){
128205     int iPos;
128206     int iScore;
128207     u64 mCover;
128208     u64 mHighlight;
128209     fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover, &mHighlight);
128210     assert( iScore>=0 );
128211     if( iScore>iBestScore ){
128212       pFragment->iPos = iPos;
128213       pFragment->hlmask = mHighlight;
128214       pFragment->covered = mCover;
128215       iBestScore = iScore;
128216     }
128217   }
128218
128219   sqlcipher3_free(sIter.aPhrase);
128220   *piScore = iBestScore;
128221   return SQLCIPHER_OK;
128222 }
128223
128224
128225 /*
128226 ** Append a string to the string-buffer passed as the first argument.
128227 **
128228 ** If nAppend is negative, then the length of the string zAppend is
128229 ** determined using strlen().
128230 */
128231 static int fts3StringAppend(
128232   StrBuffer *pStr,                /* Buffer to append to */
128233   const char *zAppend,            /* Pointer to data to append to buffer */
128234   int nAppend                     /* Size of zAppend in bytes (or -1) */
128235 ){
128236   if( nAppend<0 ){
128237     nAppend = (int)strlen(zAppend);
128238   }
128239
128240   /* If there is insufficient space allocated at StrBuffer.z, use realloc()
128241   ** to grow the buffer until so that it is big enough to accomadate the
128242   ** appended data.
128243   */
128244   if( pStr->n+nAppend+1>=pStr->nAlloc ){
128245     int nAlloc = pStr->nAlloc+nAppend+100;
128246     char *zNew = sqlcipher3_realloc(pStr->z, nAlloc);
128247     if( !zNew ){
128248       return SQLCIPHER_NOMEM;
128249     }
128250     pStr->z = zNew;
128251     pStr->nAlloc = nAlloc;
128252   }
128253
128254   /* Append the data to the string buffer. */
128255   memcpy(&pStr->z[pStr->n], zAppend, nAppend);
128256   pStr->n += nAppend;
128257   pStr->z[pStr->n] = '\0';
128258
128259   return SQLCIPHER_OK;
128260 }
128261
128262 /*
128263 ** The fts3BestSnippet() function often selects snippets that end with a
128264 ** query term. That is, the final term of the snippet is always a term
128265 ** that requires highlighting. For example, if 'X' is a highlighted term
128266 ** and '.' is a non-highlighted term, BestSnippet() may select:
128267 **
128268 **     ........X.....X
128269 **
128270 ** This function "shifts" the beginning of the snippet forward in the 
128271 ** document so that there are approximately the same number of 
128272 ** non-highlighted terms to the right of the final highlighted term as there
128273 ** are to the left of the first highlighted term. For example, to this:
128274 **
128275 **     ....X.....X....
128276 **
128277 ** This is done as part of extracting the snippet text, not when selecting
128278 ** the snippet. Snippet selection is done based on doclists only, so there
128279 ** is no way for fts3BestSnippet() to know whether or not the document 
128280 ** actually contains terms that follow the final highlighted term. 
128281 */
128282 static int fts3SnippetShift(
128283   Fts3Table *pTab,                /* FTS3 table snippet comes from */
128284   int nSnippet,                   /* Number of tokens desired for snippet */
128285   const char *zDoc,               /* Document text to extract snippet from */
128286   int nDoc,                       /* Size of buffer zDoc in bytes */
128287   int *piPos,                     /* IN/OUT: First token of snippet */
128288   u64 *pHlmask                    /* IN/OUT: Mask of tokens to highlight */
128289 ){
128290   u64 hlmask = *pHlmask;          /* Local copy of initial highlight-mask */
128291
128292   if( hlmask ){
128293     int nLeft;                    /* Tokens to the left of first highlight */
128294     int nRight;                   /* Tokens to the right of last highlight */
128295     int nDesired;                 /* Ideal number of tokens to shift forward */
128296
128297     for(nLeft=0; !(hlmask & ((u64)1 << nLeft)); nLeft++);
128298     for(nRight=0; !(hlmask & ((u64)1 << (nSnippet-1-nRight))); nRight++);
128299     nDesired = (nLeft-nRight)/2;
128300
128301     /* Ideally, the start of the snippet should be pushed forward in the
128302     ** document nDesired tokens. This block checks if there are actually
128303     ** nDesired tokens to the right of the snippet. If so, *piPos and
128304     ** *pHlMask are updated to shift the snippet nDesired tokens to the
128305     ** right. Otherwise, the snippet is shifted by the number of tokens
128306     ** available.
128307     */
128308     if( nDesired>0 ){
128309       int nShift;                 /* Number of tokens to shift snippet by */
128310       int iCurrent = 0;           /* Token counter */
128311       int rc;                     /* Return Code */
128312       sqlcipher3_tokenizer_module *pMod;
128313       sqlcipher3_tokenizer_cursor *pC;
128314       pMod = (sqlcipher3_tokenizer_module *)pTab->pTokenizer->pModule;
128315
128316       /* Open a cursor on zDoc/nDoc. Check if there are (nSnippet+nDesired)
128317       ** or more tokens in zDoc/nDoc.
128318       */
128319       rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
128320       if( rc!=SQLCIPHER_OK ){
128321         return rc;
128322       }
128323       pC->pTokenizer = pTab->pTokenizer;
128324       while( rc==SQLCIPHER_OK && iCurrent<(nSnippet+nDesired) ){
128325         const char *ZDUMMY; int DUMMY1, DUMMY2, DUMMY3;
128326         rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
128327       }
128328       pMod->xClose(pC);
128329       if( rc!=SQLCIPHER_OK && rc!=SQLCIPHER_DONE ){ return rc; }
128330
128331       nShift = (rc==SQLCIPHER_DONE)+iCurrent-nSnippet;
128332       assert( nShift<=nDesired );
128333       if( nShift>0 ){
128334         *piPos += nShift;
128335         *pHlmask = hlmask >> nShift;
128336       }
128337     }
128338   }
128339   return SQLCIPHER_OK;
128340 }
128341
128342 /*
128343 ** Extract the snippet text for fragment pFragment from cursor pCsr and
128344 ** append it to string buffer pOut.
128345 */
128346 static int fts3SnippetText(
128347   Fts3Cursor *pCsr,               /* FTS3 Cursor */
128348   SnippetFragment *pFragment,     /* Snippet to extract */
128349   int iFragment,                  /* Fragment number */
128350   int isLast,                     /* True for final fragment in snippet */
128351   int nSnippet,                   /* Number of tokens in extracted snippet */
128352   const char *zOpen,              /* String inserted before highlighted term */
128353   const char *zClose,             /* String inserted after highlighted term */
128354   const char *zEllipsis,          /* String inserted between snippets */
128355   StrBuffer *pOut                 /* Write output here */
128356 ){
128357   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
128358   int rc;                         /* Return code */
128359   const char *zDoc;               /* Document text to extract snippet from */
128360   int nDoc;                       /* Size of zDoc in bytes */
128361   int iCurrent = 0;               /* Current token number of document */
128362   int iEnd = 0;                   /* Byte offset of end of current token */
128363   int isShiftDone = 0;            /* True after snippet is shifted */
128364   int iPos = pFragment->iPos;     /* First token of snippet */
128365   u64 hlmask = pFragment->hlmask; /* Highlight-mask for snippet */
128366   int iCol = pFragment->iCol+1;   /* Query column to extract text from */
128367   sqlcipher3_tokenizer_module *pMod; /* Tokenizer module methods object */
128368   sqlcipher3_tokenizer_cursor *pC;   /* Tokenizer cursor open on zDoc/nDoc */
128369   const char *ZDUMMY;             /* Dummy argument used with tokenizer */
128370   int DUMMY1;                     /* Dummy argument used with tokenizer */
128371   
128372   zDoc = (const char *)sqlcipher3_column_text(pCsr->pStmt, iCol);
128373   if( zDoc==0 ){
128374     if( sqlcipher3_column_type(pCsr->pStmt, iCol)!=SQLCIPHER_NULL ){
128375       return SQLCIPHER_NOMEM;
128376     }
128377     return SQLCIPHER_OK;
128378   }
128379   nDoc = sqlcipher3_column_bytes(pCsr->pStmt, iCol);
128380
128381   /* Open a token cursor on the document. */
128382   pMod = (sqlcipher3_tokenizer_module *)pTab->pTokenizer->pModule;
128383   rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
128384   if( rc!=SQLCIPHER_OK ){
128385     return rc;
128386   }
128387   pC->pTokenizer = pTab->pTokenizer;
128388
128389   while( rc==SQLCIPHER_OK ){
128390     int iBegin;                   /* Offset in zDoc of start of token */
128391     int iFin;                     /* Offset in zDoc of end of token */
128392     int isHighlight;              /* True for highlighted terms */
128393
128394     rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
128395     if( rc!=SQLCIPHER_OK ){
128396       if( rc==SQLCIPHER_DONE ){
128397         /* Special case - the last token of the snippet is also the last token
128398         ** of the column. Append any punctuation that occurred between the end
128399         ** of the previous token and the end of the document to the output. 
128400         ** Then break out of the loop. */
128401         rc = fts3StringAppend(pOut, &zDoc[iEnd], -1);
128402       }
128403       break;
128404     }
128405     if( iCurrent<iPos ){ continue; }
128406
128407     if( !isShiftDone ){
128408       int n = nDoc - iBegin;
128409       rc = fts3SnippetShift(pTab, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask);
128410       isShiftDone = 1;
128411
128412       /* Now that the shift has been done, check if the initial "..." are
128413       ** required. They are required if (a) this is not the first fragment,
128414       ** or (b) this fragment does not begin at position 0 of its column. 
128415       */
128416       if( rc==SQLCIPHER_OK && (iPos>0 || iFragment>0) ){
128417         rc = fts3StringAppend(pOut, zEllipsis, -1);
128418       }
128419       if( rc!=SQLCIPHER_OK || iCurrent<iPos ) continue;
128420     }
128421
128422     if( iCurrent>=(iPos+nSnippet) ){
128423       if( isLast ){
128424         rc = fts3StringAppend(pOut, zEllipsis, -1);
128425       }
128426       break;
128427     }
128428
128429     /* Set isHighlight to true if this term should be highlighted. */
128430     isHighlight = (hlmask & ((u64)1 << (iCurrent-iPos)))!=0;
128431
128432     if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd);
128433     if( rc==SQLCIPHER_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
128434     if( rc==SQLCIPHER_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
128435     if( rc==SQLCIPHER_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
128436
128437     iEnd = iFin;
128438   }
128439
128440   pMod->xClose(pC);
128441   return rc;
128442 }
128443
128444
128445 /*
128446 ** This function is used to count the entries in a column-list (a 
128447 ** delta-encoded list of term offsets within a single column of a single 
128448 ** row). When this function is called, *ppCollist should point to the
128449 ** beginning of the first varint in the column-list (the varint that
128450 ** contains the position of the first matching term in the column data).
128451 ** Before returning, *ppCollist is set to point to the first byte after
128452 ** the last varint in the column-list (either the 0x00 signifying the end
128453 ** of the position-list, or the 0x01 that precedes the column number of
128454 ** the next column in the position-list).
128455 **
128456 ** The number of elements in the column-list is returned.
128457 */
128458 static int fts3ColumnlistCount(char **ppCollist){
128459   char *pEnd = *ppCollist;
128460   char c = 0;
128461   int nEntry = 0;
128462
128463   /* A column-list is terminated by either a 0x01 or 0x00. */
128464   while( 0xFE & (*pEnd | c) ){
128465     c = *pEnd++ & 0x80;
128466     if( !c ) nEntry++;
128467   }
128468
128469   *ppCollist = pEnd;
128470   return nEntry;
128471 }
128472
128473 /*
128474 ** fts3ExprIterate() callback used to collect the "global" matchinfo stats
128475 ** for a single query. 
128476 **
128477 ** fts3ExprIterate() callback to load the 'global' elements of a
128478 ** FTS3_MATCHINFO_HITS matchinfo array. The global stats are those elements 
128479 ** of the matchinfo array that are constant for all rows returned by the 
128480 ** current query.
128481 **
128482 ** Argument pCtx is actually a pointer to a struct of type MatchInfo. This
128483 ** function populates Matchinfo.aMatchinfo[] as follows:
128484 **
128485 **   for(iCol=0; iCol<nCol; iCol++){
128486 **     aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
128487 **     aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
128488 **   }
128489 **
128490 ** where X is the number of matches for phrase iPhrase is column iCol of all
128491 ** rows of the table. Y is the number of rows for which column iCol contains
128492 ** at least one instance of phrase iPhrase.
128493 **
128494 ** If the phrase pExpr consists entirely of deferred tokens, then all X and
128495 ** Y values are set to nDoc, where nDoc is the number of documents in the 
128496 ** file system. This is done because the full-text index doclist is required
128497 ** to calculate these values properly, and the full-text index doclist is
128498 ** not available for deferred tokens.
128499 */
128500 static int fts3ExprGlobalHitsCb(
128501   Fts3Expr *pExpr,                /* Phrase expression node */
128502   int iPhrase,                    /* Phrase number (numbered from zero) */
128503   void *pCtx                      /* Pointer to MatchInfo structure */
128504 ){
128505   MatchInfo *p = (MatchInfo *)pCtx;
128506   return sqlcipher3Fts3EvalPhraseStats(
128507       p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
128508   );
128509 }
128510
128511 /*
128512 ** fts3ExprIterate() callback used to collect the "local" part of the
128513 ** FTS3_MATCHINFO_HITS array. The local stats are those elements of the 
128514 ** array that are different for each row returned by the query.
128515 */
128516 static int fts3ExprLocalHitsCb(
128517   Fts3Expr *pExpr,                /* Phrase expression node */
128518   int iPhrase,                    /* Phrase number */
128519   void *pCtx                      /* Pointer to MatchInfo structure */
128520 ){
128521   MatchInfo *p = (MatchInfo *)pCtx;
128522   int iStart = iPhrase * p->nCol * 3;
128523   int i;
128524
128525   for(i=0; i<p->nCol; i++){
128526     char *pCsr;
128527     pCsr = sqlcipher3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i);
128528     if( pCsr ){
128529       p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr);
128530     }else{
128531       p->aMatchinfo[iStart+i*3] = 0;
128532     }
128533   }
128534
128535   return SQLCIPHER_OK;
128536 }
128537
128538 static int fts3MatchinfoCheck(
128539   Fts3Table *pTab, 
128540   char cArg,
128541   char **pzErr
128542 ){
128543   if( (cArg==FTS3_MATCHINFO_NPHRASE)
128544    || (cArg==FTS3_MATCHINFO_NCOL)
128545    || (cArg==FTS3_MATCHINFO_NDOC && pTab->bHasStat)
128546    || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bHasStat)
128547    || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize)
128548    || (cArg==FTS3_MATCHINFO_LCS)
128549    || (cArg==FTS3_MATCHINFO_HITS)
128550   ){
128551     return SQLCIPHER_OK;
128552   }
128553   *pzErr = sqlcipher3_mprintf("unrecognized matchinfo request: %c", cArg);
128554   return SQLCIPHER_ERROR;
128555 }
128556
128557 static int fts3MatchinfoSize(MatchInfo *pInfo, char cArg){
128558   int nVal;                       /* Number of integers output by cArg */
128559
128560   switch( cArg ){
128561     case FTS3_MATCHINFO_NDOC:
128562     case FTS3_MATCHINFO_NPHRASE: 
128563     case FTS3_MATCHINFO_NCOL: 
128564       nVal = 1;
128565       break;
128566
128567     case FTS3_MATCHINFO_AVGLENGTH:
128568     case FTS3_MATCHINFO_LENGTH:
128569     case FTS3_MATCHINFO_LCS:
128570       nVal = pInfo->nCol;
128571       break;
128572
128573     default:
128574       assert( cArg==FTS3_MATCHINFO_HITS );
128575       nVal = pInfo->nCol * pInfo->nPhrase * 3;
128576       break;
128577   }
128578
128579   return nVal;
128580 }
128581
128582 static int fts3MatchinfoSelectDoctotal(
128583   Fts3Table *pTab,
128584   sqlcipher3_stmt **ppStmt,
128585   sqlcipher3_int64 *pnDoc,
128586   const char **paLen
128587 ){
128588   sqlcipher3_stmt *pStmt;
128589   const char *a;
128590   sqlcipher3_int64 nDoc;
128591
128592   if( !*ppStmt ){
128593     int rc = sqlcipher3Fts3SelectDoctotal(pTab, ppStmt);
128594     if( rc!=SQLCIPHER_OK ) return rc;
128595   }
128596   pStmt = *ppStmt;
128597   assert( sqlcipher3_data_count(pStmt)==1 );
128598
128599   a = sqlcipher3_column_blob(pStmt, 0);
128600   a += sqlcipher3Fts3GetVarint(a, &nDoc);
128601   if( nDoc==0 ) return FTS_CORRUPT_VTAB;
128602   *pnDoc = (u32)nDoc;
128603
128604   if( paLen ) *paLen = a;
128605   return SQLCIPHER_OK;
128606 }
128607
128608 /*
128609 ** An instance of the following structure is used to store state while 
128610 ** iterating through a multi-column position-list corresponding to the
128611 ** hits for a single phrase on a single row in order to calculate the
128612 ** values for a matchinfo() FTS3_MATCHINFO_LCS request.
128613 */
128614 typedef struct LcsIterator LcsIterator;
128615 struct LcsIterator {
128616   Fts3Expr *pExpr;                /* Pointer to phrase expression */
128617   int iPosOffset;                 /* Tokens count up to end of this phrase */
128618   char *pRead;                    /* Cursor used to iterate through aDoclist */
128619   int iPos;                       /* Current position */
128620 };
128621
128622 /* 
128623 ** If LcsIterator.iCol is set to the following value, the iterator has
128624 ** finished iterating through all offsets for all columns.
128625 */
128626 #define LCS_ITERATOR_FINISHED 0x7FFFFFFF;
128627
128628 static int fts3MatchinfoLcsCb(
128629   Fts3Expr *pExpr,                /* Phrase expression node */
128630   int iPhrase,                    /* Phrase number (numbered from zero) */
128631   void *pCtx                      /* Pointer to MatchInfo structure */
128632 ){
128633   LcsIterator *aIter = (LcsIterator *)pCtx;
128634   aIter[iPhrase].pExpr = pExpr;
128635   return SQLCIPHER_OK;
128636 }
128637
128638 /*
128639 ** Advance the iterator passed as an argument to the next position. Return
128640 ** 1 if the iterator is at EOF or if it now points to the start of the
128641 ** position list for the next column.
128642 */
128643 static int fts3LcsIteratorAdvance(LcsIterator *pIter){
128644   char *pRead = pIter->pRead;
128645   sqlcipher3_int64 iRead;
128646   int rc = 0;
128647
128648   pRead += sqlcipher3Fts3GetVarint(pRead, &iRead);
128649   if( iRead==0 || iRead==1 ){
128650     pRead = 0;
128651     rc = 1;
128652   }else{
128653     pIter->iPos += (int)(iRead-2);
128654   }
128655
128656   pIter->pRead = pRead;
128657   return rc;
128658 }
128659   
128660 /*
128661 ** This function implements the FTS3_MATCHINFO_LCS matchinfo() flag. 
128662 **
128663 ** If the call is successful, the longest-common-substring lengths for each
128664 ** column are written into the first nCol elements of the pInfo->aMatchinfo[] 
128665 ** array before returning. SQLCIPHER_OK is returned in this case.
128666 **
128667 ** Otherwise, if an error occurs, an SQLite error code is returned and the
128668 ** data written to the first nCol elements of pInfo->aMatchinfo[] is 
128669 ** undefined.
128670 */
128671 static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
128672   LcsIterator *aIter;
128673   int i;
128674   int iCol;
128675   int nToken = 0;
128676
128677   /* Allocate and populate the array of LcsIterator objects. The array
128678   ** contains one element for each matchable phrase in the query.
128679   **/
128680   aIter = sqlcipher3_malloc(sizeof(LcsIterator) * pCsr->nPhrase);
128681   if( !aIter ) return SQLCIPHER_NOMEM;
128682   memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase);
128683   (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
128684
128685   for(i=0; i<pInfo->nPhrase; i++){
128686     LcsIterator *pIter = &aIter[i];
128687     nToken -= pIter->pExpr->pPhrase->nToken;
128688     pIter->iPosOffset = nToken;
128689   }
128690
128691   for(iCol=0; iCol<pInfo->nCol; iCol++){
128692     int nLcs = 0;                 /* LCS value for this column */
128693     int nLive = 0;                /* Number of iterators in aIter not at EOF */
128694
128695     for(i=0; i<pInfo->nPhrase; i++){
128696       LcsIterator *pIt = &aIter[i];
128697       pIt->pRead = sqlcipher3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol);
128698       if( pIt->pRead ){
128699         pIt->iPos = pIt->iPosOffset;
128700         fts3LcsIteratorAdvance(&aIter[i]);
128701         nLive++;
128702       }
128703     }
128704
128705     while( nLive>0 ){
128706       LcsIterator *pAdv = 0;      /* The iterator to advance by one position */
128707       int nThisLcs = 0;           /* LCS for the current iterator positions */
128708
128709       for(i=0; i<pInfo->nPhrase; i++){
128710         LcsIterator *pIter = &aIter[i];
128711         if( pIter->pRead==0 ){
128712           /* This iterator is already at EOF for this column. */
128713           nThisLcs = 0;
128714         }else{
128715           if( pAdv==0 || pIter->iPos<pAdv->iPos ){
128716             pAdv = pIter;
128717           }
128718           if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
128719             nThisLcs++;
128720           }else{
128721             nThisLcs = 1;
128722           }
128723           if( nThisLcs>nLcs ) nLcs = nThisLcs;
128724         }
128725       }
128726       if( fts3LcsIteratorAdvance(pAdv) ) nLive--;
128727     }
128728
128729     pInfo->aMatchinfo[iCol] = nLcs;
128730   }
128731
128732   sqlcipher3_free(aIter);
128733   return SQLCIPHER_OK;
128734 }
128735
128736 /*
128737 ** Populate the buffer pInfo->aMatchinfo[] with an array of integers to
128738 ** be returned by the matchinfo() function. Argument zArg contains the 
128739 ** format string passed as the second argument to matchinfo (or the
128740 ** default value "pcx" if no second argument was specified). The format
128741 ** string has already been validated and the pInfo->aMatchinfo[] array
128742 ** is guaranteed to be large enough for the output.
128743 **
128744 ** If bGlobal is true, then populate all fields of the matchinfo() output.
128745 ** If it is false, then assume that those fields that do not change between
128746 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
128747 ** have already been populated.
128748 **
128749 ** Return SQLCIPHER_OK if successful, or an SQLite error code if an error 
128750 ** occurs. If a value other than SQLCIPHER_OK is returned, the state the
128751 ** pInfo->aMatchinfo[] buffer is left in is undefined.
128752 */
128753 static int fts3MatchinfoValues(
128754   Fts3Cursor *pCsr,               /* FTS3 cursor object */
128755   int bGlobal,                    /* True to grab the global stats */
128756   MatchInfo *pInfo,               /* Matchinfo context object */
128757   const char *zArg                /* Matchinfo format string */
128758 ){
128759   int rc = SQLCIPHER_OK;
128760   int i;
128761   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
128762   sqlcipher3_stmt *pSelect = 0;
128763
128764   for(i=0; rc==SQLCIPHER_OK && zArg[i]; i++){
128765
128766     switch( zArg[i] ){
128767       case FTS3_MATCHINFO_NPHRASE:
128768         if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nPhrase;
128769         break;
128770
128771       case FTS3_MATCHINFO_NCOL:
128772         if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
128773         break;
128774         
128775       case FTS3_MATCHINFO_NDOC:
128776         if( bGlobal ){
128777           sqlcipher3_int64 nDoc = 0;
128778           rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0);
128779           pInfo->aMatchinfo[0] = (u32)nDoc;
128780         }
128781         break;
128782
128783       case FTS3_MATCHINFO_AVGLENGTH: 
128784         if( bGlobal ){
128785           sqlcipher3_int64 nDoc;     /* Number of rows in table */
128786           const char *a;          /* Aggregate column length array */
128787
128788           rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a);
128789           if( rc==SQLCIPHER_OK ){
128790             int iCol;
128791             for(iCol=0; iCol<pInfo->nCol; iCol++){
128792               u32 iVal;
128793               sqlcipher3_int64 nToken;
128794               a += sqlcipher3Fts3GetVarint(a, &nToken);
128795               iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc);
128796               pInfo->aMatchinfo[iCol] = iVal;
128797             }
128798           }
128799         }
128800         break;
128801
128802       case FTS3_MATCHINFO_LENGTH: {
128803         sqlcipher3_stmt *pSelectDocsize = 0;
128804         rc = sqlcipher3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
128805         if( rc==SQLCIPHER_OK ){
128806           int iCol;
128807           const char *a = sqlcipher3_column_blob(pSelectDocsize, 0);
128808           for(iCol=0; iCol<pInfo->nCol; iCol++){
128809             sqlcipher3_int64 nToken;
128810             a += sqlcipher3Fts3GetVarint(a, &nToken);
128811             pInfo->aMatchinfo[iCol] = (u32)nToken;
128812           }
128813         }
128814         sqlcipher3_reset(pSelectDocsize);
128815         break;
128816       }
128817
128818       case FTS3_MATCHINFO_LCS:
128819         rc = fts3ExprLoadDoclists(pCsr, 0, 0);
128820         if( rc==SQLCIPHER_OK ){
128821           rc = fts3MatchinfoLcs(pCsr, pInfo);
128822         }
128823         break;
128824
128825       default: {
128826         Fts3Expr *pExpr;
128827         assert( zArg[i]==FTS3_MATCHINFO_HITS );
128828         pExpr = pCsr->pExpr;
128829         rc = fts3ExprLoadDoclists(pCsr, 0, 0);
128830         if( rc!=SQLCIPHER_OK ) break;
128831         if( bGlobal ){
128832           if( pCsr->pDeferred ){
128833             rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc, 0);
128834             if( rc!=SQLCIPHER_OK ) break;
128835           }
128836           rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
128837           if( rc!=SQLCIPHER_OK ) break;
128838         }
128839         (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
128840         break;
128841       }
128842     }
128843
128844     pInfo->aMatchinfo += fts3MatchinfoSize(pInfo, zArg[i]);
128845   }
128846
128847   sqlcipher3_reset(pSelect);
128848   return rc;
128849 }
128850
128851
128852 /*
128853 ** Populate pCsr->aMatchinfo[] with data for the current row. The 
128854 ** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32).
128855 */
128856 static int fts3GetMatchinfo(
128857   Fts3Cursor *pCsr,               /* FTS3 Cursor object */
128858   const char *zArg                /* Second argument to matchinfo() function */
128859 ){
128860   MatchInfo sInfo;
128861   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
128862   int rc = SQLCIPHER_OK;
128863   int bGlobal = 0;                /* Collect 'global' stats as well as local */
128864
128865   memset(&sInfo, 0, sizeof(MatchInfo));
128866   sInfo.pCursor = pCsr;
128867   sInfo.nCol = pTab->nColumn;
128868
128869   /* If there is cached matchinfo() data, but the format string for the 
128870   ** cache does not match the format string for this request, discard 
128871   ** the cached data. */
128872   if( pCsr->zMatchinfo && strcmp(pCsr->zMatchinfo, zArg) ){
128873     assert( pCsr->aMatchinfo );
128874     sqlcipher3_free(pCsr->aMatchinfo);
128875     pCsr->zMatchinfo = 0;
128876     pCsr->aMatchinfo = 0;
128877   }
128878
128879   /* If Fts3Cursor.aMatchinfo[] is NULL, then this is the first time the
128880   ** matchinfo function has been called for this query. In this case 
128881   ** allocate the array used to accumulate the matchinfo data and
128882   ** initialize those elements that are constant for every row.
128883   */
128884   if( pCsr->aMatchinfo==0 ){
128885     int nMatchinfo = 0;           /* Number of u32 elements in match-info */
128886     int nArg;                     /* Bytes in zArg */
128887     int i;                        /* Used to iterate through zArg */
128888
128889     /* Determine the number of phrases in the query */
128890     pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
128891     sInfo.nPhrase = pCsr->nPhrase;
128892
128893     /* Determine the number of integers in the buffer returned by this call. */
128894     for(i=0; zArg[i]; i++){
128895       nMatchinfo += fts3MatchinfoSize(&sInfo, zArg[i]);
128896     }
128897
128898     /* Allocate space for Fts3Cursor.aMatchinfo[] and Fts3Cursor.zMatchinfo. */
128899     nArg = (int)strlen(zArg);
128900     pCsr->aMatchinfo = (u32 *)sqlcipher3_malloc(sizeof(u32)*nMatchinfo + nArg + 1);
128901     if( !pCsr->aMatchinfo ) return SQLCIPHER_NOMEM;
128902
128903     pCsr->zMatchinfo = (char *)&pCsr->aMatchinfo[nMatchinfo];
128904     pCsr->nMatchinfo = nMatchinfo;
128905     memcpy(pCsr->zMatchinfo, zArg, nArg+1);
128906     memset(pCsr->aMatchinfo, 0, sizeof(u32)*nMatchinfo);
128907     pCsr->isMatchinfoNeeded = 1;
128908     bGlobal = 1;
128909   }
128910
128911   sInfo.aMatchinfo = pCsr->aMatchinfo;
128912   sInfo.nPhrase = pCsr->nPhrase;
128913   if( pCsr->isMatchinfoNeeded ){
128914     rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg);
128915     pCsr->isMatchinfoNeeded = 0;
128916   }
128917
128918   return rc;
128919 }
128920
128921 /*
128922 ** Implementation of snippet() function.
128923 */
128924 SQLCIPHER_PRIVATE void sqlcipher3Fts3Snippet(
128925   sqlcipher3_context *pCtx,          /* SQLite function call context */
128926   Fts3Cursor *pCsr,               /* Cursor object */
128927   const char *zStart,             /* Snippet start text - "<b>" */
128928   const char *zEnd,               /* Snippet end text - "</b>" */
128929   const char *zEllipsis,          /* Snippet ellipsis text - "<b>...</b>" */
128930   int iCol,                       /* Extract snippet from this column */
128931   int nToken                      /* Approximate number of tokens in snippet */
128932 ){
128933   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
128934   int rc = SQLCIPHER_OK;
128935   int i;
128936   StrBuffer res = {0, 0, 0};
128937
128938   /* The returned text includes up to four fragments of text extracted from
128939   ** the data in the current row. The first iteration of the for(...) loop
128940   ** below attempts to locate a single fragment of text nToken tokens in 
128941   ** size that contains at least one instance of all phrases in the query
128942   ** expression that appear in the current row. If such a fragment of text
128943   ** cannot be found, the second iteration of the loop attempts to locate
128944   ** a pair of fragments, and so on.
128945   */
128946   int nSnippet = 0;               /* Number of fragments in this snippet */
128947   SnippetFragment aSnippet[4];    /* Maximum of 4 fragments per snippet */
128948   int nFToken = -1;               /* Number of tokens in each fragment */
128949
128950   if( !pCsr->pExpr ){
128951     sqlcipher3_result_text(pCtx, "", 0, SQLCIPHER_STATIC);
128952     return;
128953   }
128954
128955   for(nSnippet=1; 1; nSnippet++){
128956
128957     int iSnip;                    /* Loop counter 0..nSnippet-1 */
128958     u64 mCovered = 0;             /* Bitmask of phrases covered by snippet */
128959     u64 mSeen = 0;                /* Bitmask of phrases seen by BestSnippet() */
128960
128961     if( nToken>=0 ){
128962       nFToken = (nToken+nSnippet-1) / nSnippet;
128963     }else{
128964       nFToken = -1 * nToken;
128965     }
128966
128967     for(iSnip=0; iSnip<nSnippet; iSnip++){
128968       int iBestScore = -1;        /* Best score of columns checked so far */
128969       int iRead;                  /* Used to iterate through columns */
128970       SnippetFragment *pFragment = &aSnippet[iSnip];
128971
128972       memset(pFragment, 0, sizeof(*pFragment));
128973
128974       /* Loop through all columns of the table being considered for snippets.
128975       ** If the iCol argument to this function was negative, this means all
128976       ** columns of the FTS3 table. Otherwise, only column iCol is considered.
128977       */
128978       for(iRead=0; iRead<pTab->nColumn; iRead++){
128979         SnippetFragment sF = {0, 0, 0, 0};
128980         int iS;
128981         if( iCol>=0 && iRead!=iCol ) continue;
128982
128983         /* Find the best snippet of nFToken tokens in column iRead. */
128984         rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS);
128985         if( rc!=SQLCIPHER_OK ){
128986           goto snippet_out;
128987         }
128988         if( iS>iBestScore ){
128989           *pFragment = sF;
128990           iBestScore = iS;
128991         }
128992       }
128993
128994       mCovered |= pFragment->covered;
128995     }
128996
128997     /* If all query phrases seen by fts3BestSnippet() are present in at least
128998     ** one of the nSnippet snippet fragments, break out of the loop.
128999     */
129000     assert( (mCovered&mSeen)==mCovered );
129001     if( mSeen==mCovered || nSnippet==SizeofArray(aSnippet) ) break;
129002   }
129003
129004   assert( nFToken>0 );
129005
129006   for(i=0; i<nSnippet && rc==SQLCIPHER_OK; i++){
129007     rc = fts3SnippetText(pCsr, &aSnippet[i], 
129008         i, (i==nSnippet-1), nFToken, zStart, zEnd, zEllipsis, &res
129009     );
129010   }
129011
129012  snippet_out:
129013   sqlcipher3Fts3SegmentsClose(pTab);
129014   if( rc!=SQLCIPHER_OK ){
129015     sqlcipher3_result_error_code(pCtx, rc);
129016     sqlcipher3_free(res.z);
129017   }else{
129018     sqlcipher3_result_text(pCtx, res.z, -1, sqlcipher3_free);
129019   }
129020 }
129021
129022
129023 typedef struct TermOffset TermOffset;
129024 typedef struct TermOffsetCtx TermOffsetCtx;
129025
129026 struct TermOffset {
129027   char *pList;                    /* Position-list */
129028   int iPos;                       /* Position just read from pList */
129029   int iOff;                       /* Offset of this term from read positions */
129030 };
129031
129032 struct TermOffsetCtx {
129033   Fts3Cursor *pCsr;
129034   int iCol;                       /* Column of table to populate aTerm for */
129035   int iTerm;
129036   sqlcipher3_int64 iDocid;
129037   TermOffset *aTerm;
129038 };
129039
129040 /*
129041 ** This function is an fts3ExprIterate() callback used by sqlcipher3Fts3Offsets().
129042 */
129043 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
129044   TermOffsetCtx *p = (TermOffsetCtx *)ctx;
129045   int nTerm;                      /* Number of tokens in phrase */
129046   int iTerm;                      /* For looping through nTerm phrase terms */
129047   char *pList;                    /* Pointer to position list for phrase */
129048   int iPos = 0;                   /* First position in position-list */
129049
129050   UNUSED_PARAMETER(iPhrase);
129051   pList = sqlcipher3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
129052   nTerm = pExpr->pPhrase->nToken;
129053   if( pList ){
129054     fts3GetDeltaPosition(&pList, &iPos);
129055     assert( iPos>=0 );
129056   }
129057
129058   for(iTerm=0; iTerm<nTerm; iTerm++){
129059     TermOffset *pT = &p->aTerm[p->iTerm++];
129060     pT->iOff = nTerm-iTerm-1;
129061     pT->pList = pList;
129062     pT->iPos = iPos;
129063   }
129064
129065   return SQLCIPHER_OK;
129066 }
129067
129068 /*
129069 ** Implementation of offsets() function.
129070 */
129071 SQLCIPHER_PRIVATE void sqlcipher3Fts3Offsets(
129072   sqlcipher3_context *pCtx,          /* SQLite function call context */
129073   Fts3Cursor *pCsr                /* Cursor object */
129074 ){
129075   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129076   sqlcipher3_tokenizer_module const *pMod = pTab->pTokenizer->pModule;
129077   const char *ZDUMMY;             /* Dummy argument used with xNext() */
129078   int NDUMMY;                     /* Dummy argument used with xNext() */
129079   int rc;                         /* Return Code */
129080   int nToken;                     /* Number of tokens in query */
129081   int iCol;                       /* Column currently being processed */
129082   StrBuffer res = {0, 0, 0};      /* Result string */
129083   TermOffsetCtx sCtx;             /* Context for fts3ExprTermOffsetInit() */
129084
129085   if( !pCsr->pExpr ){
129086     sqlcipher3_result_text(pCtx, "", 0, SQLCIPHER_STATIC);
129087     return;
129088   }
129089
129090   memset(&sCtx, 0, sizeof(sCtx));
129091   assert( pCsr->isRequireSeek==0 );
129092
129093   /* Count the number of terms in the query */
129094   rc = fts3ExprLoadDoclists(pCsr, 0, &nToken);
129095   if( rc!=SQLCIPHER_OK ) goto offsets_out;
129096
129097   /* Allocate the array of TermOffset iterators. */
129098   sCtx.aTerm = (TermOffset *)sqlcipher3_malloc(sizeof(TermOffset)*nToken);
129099   if( 0==sCtx.aTerm ){
129100     rc = SQLCIPHER_NOMEM;
129101     goto offsets_out;
129102   }
129103   sCtx.iDocid = pCsr->iPrevId;
129104   sCtx.pCsr = pCsr;
129105
129106   /* Loop through the table columns, appending offset information to 
129107   ** string-buffer res for each column.
129108   */
129109   for(iCol=0; iCol<pTab->nColumn; iCol++){
129110     sqlcipher3_tokenizer_cursor *pC; /* Tokenizer cursor */
129111     int iStart;
129112     int iEnd;
129113     int iCurrent;
129114     const char *zDoc;
129115     int nDoc;
129116
129117     /* Initialize the contents of sCtx.aTerm[] for column iCol. There is 
129118     ** no way that this operation can fail, so the return code from
129119     ** fts3ExprIterate() can be discarded.
129120     */
129121     sCtx.iCol = iCol;
129122     sCtx.iTerm = 0;
129123     (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void *)&sCtx);
129124
129125     /* Retreive the text stored in column iCol. If an SQL NULL is stored 
129126     ** in column iCol, jump immediately to the next iteration of the loop.
129127     ** If an OOM occurs while retrieving the data (this can happen if SQLite
129128     ** needs to transform the data from utf-16 to utf-8), return SQLCIPHER_NOMEM 
129129     ** to the caller. 
129130     */
129131     zDoc = (const char *)sqlcipher3_column_text(pCsr->pStmt, iCol+1);
129132     nDoc = sqlcipher3_column_bytes(pCsr->pStmt, iCol+1);
129133     if( zDoc==0 ){
129134       if( sqlcipher3_column_type(pCsr->pStmt, iCol+1)==SQLCIPHER_NULL ){
129135         continue;
129136       }
129137       rc = SQLCIPHER_NOMEM;
129138       goto offsets_out;
129139     }
129140
129141     /* Initialize a tokenizer iterator to iterate through column iCol. */
129142     rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
129143     if( rc!=SQLCIPHER_OK ) goto offsets_out;
129144     pC->pTokenizer = pTab->pTokenizer;
129145
129146     rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
129147     while( rc==SQLCIPHER_OK ){
129148       int i;                      /* Used to loop through terms */
129149       int iMinPos = 0x7FFFFFFF;   /* Position of next token */
129150       TermOffset *pTerm = 0;      /* TermOffset associated with next token */
129151
129152       for(i=0; i<nToken; i++){
129153         TermOffset *pT = &sCtx.aTerm[i];
129154         if( pT->pList && (pT->iPos-pT->iOff)<iMinPos ){
129155           iMinPos = pT->iPos-pT->iOff;
129156           pTerm = pT;
129157         }
129158       }
129159
129160       if( !pTerm ){
129161         /* All offsets for this column have been gathered. */
129162         rc = SQLCIPHER_DONE;
129163       }else{
129164         assert( iCurrent<=iMinPos );
129165         if( 0==(0xFE&*pTerm->pList) ){
129166           pTerm->pList = 0;
129167         }else{
129168           fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos);
129169         }
129170         while( rc==SQLCIPHER_OK && iCurrent<iMinPos ){
129171           rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
129172         }
129173         if( rc==SQLCIPHER_OK ){
129174           char aBuffer[64];
129175           sqlcipher3_snprintf(sizeof(aBuffer), aBuffer, 
129176               "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
129177           );
129178           rc = fts3StringAppend(&res, aBuffer, -1);
129179         }else if( rc==SQLCIPHER_DONE && pTab->zContentTbl==0 ){
129180           rc = FTS_CORRUPT_VTAB;
129181         }
129182       }
129183     }
129184     if( rc==SQLCIPHER_DONE ){
129185       rc = SQLCIPHER_OK;
129186     }
129187
129188     pMod->xClose(pC);
129189     if( rc!=SQLCIPHER_OK ) goto offsets_out;
129190   }
129191
129192  offsets_out:
129193   sqlcipher3_free(sCtx.aTerm);
129194   assert( rc!=SQLCIPHER_DONE );
129195   sqlcipher3Fts3SegmentsClose(pTab);
129196   if( rc!=SQLCIPHER_OK ){
129197     sqlcipher3_result_error_code(pCtx,  rc);
129198     sqlcipher3_free(res.z);
129199   }else{
129200     sqlcipher3_result_text(pCtx, res.z, res.n-1, sqlcipher3_free);
129201   }
129202   return;
129203 }
129204
129205 /*
129206 ** Implementation of matchinfo() function.
129207 */
129208 SQLCIPHER_PRIVATE void sqlcipher3Fts3Matchinfo(
129209   sqlcipher3_context *pContext,      /* Function call context */
129210   Fts3Cursor *pCsr,               /* FTS3 table cursor */
129211   const char *zArg                /* Second arg to matchinfo() function */
129212 ){
129213   Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129214   int rc;
129215   int i;
129216   const char *zFormat;
129217
129218   if( zArg ){
129219     for(i=0; zArg[i]; i++){
129220       char *zErr = 0;
129221       if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){
129222         sqlcipher3_result_error(pContext, zErr, -1);
129223         sqlcipher3_free(zErr);
129224         return;
129225       }
129226     }
129227     zFormat = zArg;
129228   }else{
129229     zFormat = FTS3_MATCHINFO_DEFAULT;
129230   }
129231
129232   if( !pCsr->pExpr ){
129233     sqlcipher3_result_blob(pContext, "", 0, SQLCIPHER_STATIC);
129234     return;
129235   }
129236
129237   /* Retrieve matchinfo() data. */
129238   rc = fts3GetMatchinfo(pCsr, zFormat);
129239   sqlcipher3Fts3SegmentsClose(pTab);
129240
129241   if( rc!=SQLCIPHER_OK ){
129242     sqlcipher3_result_error_code(pContext, rc);
129243   }else{
129244     int n = pCsr->nMatchinfo * sizeof(u32);
129245     sqlcipher3_result_blob(pContext, pCsr->aMatchinfo, n, SQLCIPHER_TRANSIENT);
129246   }
129247 }
129248
129249 #endif
129250
129251 /************** End of fts3_snippet.c ****************************************/
129252 /************** Begin file rtree.c *******************************************/
129253 /*
129254 ** 2001 September 15
129255 **
129256 ** The author disclaims copyright to this source code.  In place of
129257 ** a legal notice, here is a blessing:
129258 **
129259 **    May you do good and not evil.
129260 **    May you find forgiveness for yourself and forgive others.
129261 **    May you share freely, never taking more than you give.
129262 **
129263 *************************************************************************
129264 ** This file contains code for implementations of the r-tree and r*-tree
129265 ** algorithms packaged as an SQLite virtual table module.
129266 */
129267
129268 /*
129269 ** Database Format of R-Tree Tables
129270 ** --------------------------------
129271 **
129272 ** The data structure for a single virtual r-tree table is stored in three 
129273 ** native SQLite tables declared as follows. In each case, the '%' character
129274 ** in the table name is replaced with the user-supplied name of the r-tree
129275 ** table.
129276 **
129277 **   CREATE TABLE %_node(nodeno INTEGER PRIMARY KEY, data BLOB)
129278 **   CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER)
129279 **   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER)
129280 **
129281 ** The data for each node of the r-tree structure is stored in the %_node
129282 ** table. For each node that is not the root node of the r-tree, there is
129283 ** an entry in the %_parent table associating the node with its parent.
129284 ** And for each row of data in the table, there is an entry in the %_rowid
129285 ** table that maps from the entries rowid to the id of the node that it
129286 ** is stored on.
129287 **
129288 ** The root node of an r-tree always exists, even if the r-tree table is
129289 ** empty. The nodeno of the root node is always 1. All other nodes in the
129290 ** table must be the same size as the root node. The content of each node
129291 ** is formatted as follows:
129292 **
129293 **   1. If the node is the root node (node 1), then the first 2 bytes
129294 **      of the node contain the tree depth as a big-endian integer.
129295 **      For non-root nodes, the first 2 bytes are left unused.
129296 **
129297 **   2. The next 2 bytes contain the number of entries currently 
129298 **      stored in the node.
129299 **
129300 **   3. The remainder of the node contains the node entries. Each entry
129301 **      consists of a single 8-byte integer followed by an even number
129302 **      of 4-byte coordinates. For leaf nodes the integer is the rowid
129303 **      of a record. For internal nodes it is the node number of a
129304 **      child page.
129305 */
129306
129307 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_RTREE)
129308
129309 /*
129310 ** This file contains an implementation of a couple of different variants
129311 ** of the r-tree algorithm. See the README file for further details. The 
129312 ** same data-structure is used for all, but the algorithms for insert and
129313 ** delete operations vary. The variants used are selected at compile time 
129314 ** by defining the following symbols:
129315 */
129316
129317 /* Either, both or none of the following may be set to activate 
129318 ** r*tree variant algorithms.
129319 */
129320 #define VARIANT_RSTARTREE_CHOOSESUBTREE 0
129321 #define VARIANT_RSTARTREE_REINSERT      1
129322
129323 /* 
129324 ** Exactly one of the following must be set to 1.
129325 */
129326 #define VARIANT_GUTTMAN_QUADRATIC_SPLIT 0
129327 #define VARIANT_GUTTMAN_LINEAR_SPLIT    0
129328 #define VARIANT_RSTARTREE_SPLIT         1
129329
129330 #define VARIANT_GUTTMAN_SPLIT \
129331         (VARIANT_GUTTMAN_LINEAR_SPLIT||VARIANT_GUTTMAN_QUADRATIC_SPLIT)
129332
129333 #if VARIANT_GUTTMAN_QUADRATIC_SPLIT
129334   #define PickNext QuadraticPickNext
129335   #define PickSeeds QuadraticPickSeeds
129336   #define AssignCells splitNodeGuttman
129337 #endif
129338 #if VARIANT_GUTTMAN_LINEAR_SPLIT
129339   #define PickNext LinearPickNext
129340   #define PickSeeds LinearPickSeeds
129341   #define AssignCells splitNodeGuttman
129342 #endif
129343 #if VARIANT_RSTARTREE_SPLIT
129344   #define AssignCells splitNodeStartree
129345 #endif
129346
129347 #if !defined(NDEBUG) && !defined(SQLCIPHER_DEBUG) 
129348 # define NDEBUG 1
129349 #endif
129350
129351 #ifndef SQLCIPHER_CORE
129352   SQLCIPHER_EXTENSION_INIT1
129353 #else
129354 #endif
129355
129356 /* #include <string.h> */
129357 /* #include <assert.h> */
129358
129359 #ifndef SQLCIPHER_AMALGAMATION
129360 #include "sqlcipher3rtree.h"
129361 typedef sqlcipher3_int64 i64;
129362 typedef unsigned char u8;
129363 typedef unsigned int u32;
129364 #endif
129365
129366 /*  The following macro is used to suppress compiler warnings.
129367 */
129368 #ifndef UNUSED_PARAMETER
129369 # define UNUSED_PARAMETER(x) (void)(x)
129370 #endif
129371
129372 typedef struct Rtree Rtree;
129373 typedef struct RtreeCursor RtreeCursor;
129374 typedef struct RtreeNode RtreeNode;
129375 typedef struct RtreeCell RtreeCell;
129376 typedef struct RtreeConstraint RtreeConstraint;
129377 typedef struct RtreeMatchArg RtreeMatchArg;
129378 typedef struct RtreeGeomCallback RtreeGeomCallback;
129379 typedef union RtreeCoord RtreeCoord;
129380
129381 /* The rtree may have between 1 and RTREE_MAX_DIMENSIONS dimensions. */
129382 #define RTREE_MAX_DIMENSIONS 5
129383
129384 /* Size of hash table Rtree.aHash. This hash table is not expected to
129385 ** ever contain very many entries, so a fixed number of buckets is 
129386 ** used.
129387 */
129388 #define HASHSIZE 128
129389
129390 /* 
129391 ** An rtree virtual-table object.
129392 */
129393 struct Rtree {
129394   sqlcipher3_vtab base;
129395   sqlcipher3 *db;                /* Host database connection */
129396   int iNodeSize;              /* Size in bytes of each node in the node table */
129397   int nDim;                   /* Number of dimensions */
129398   int nBytesPerCell;          /* Bytes consumed per cell */
129399   int iDepth;                 /* Current depth of the r-tree structure */
129400   char *zDb;                  /* Name of database containing r-tree table */
129401   char *zName;                /* Name of r-tree table */ 
129402   RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */ 
129403   int nBusy;                  /* Current number of users of this structure */
129404
129405   /* List of nodes removed during a CondenseTree operation. List is
129406   ** linked together via the pointer normally used for hash chains -
129407   ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree 
129408   ** headed by the node (leaf nodes have RtreeNode.iNode==0).
129409   */
129410   RtreeNode *pDeleted;
129411   int iReinsertHeight;        /* Height of sub-trees Reinsert() has run on */
129412
129413   /* Statements to read/write/delete a record from xxx_node */
129414   sqlcipher3_stmt *pReadNode;
129415   sqlcipher3_stmt *pWriteNode;
129416   sqlcipher3_stmt *pDeleteNode;
129417
129418   /* Statements to read/write/delete a record from xxx_rowid */
129419   sqlcipher3_stmt *pReadRowid;
129420   sqlcipher3_stmt *pWriteRowid;
129421   sqlcipher3_stmt *pDeleteRowid;
129422
129423   /* Statements to read/write/delete a record from xxx_parent */
129424   sqlcipher3_stmt *pReadParent;
129425   sqlcipher3_stmt *pWriteParent;
129426   sqlcipher3_stmt *pDeleteParent;
129427
129428   int eCoordType;
129429 };
129430
129431 /* Possible values for eCoordType: */
129432 #define RTREE_COORD_REAL32 0
129433 #define RTREE_COORD_INT32  1
129434
129435 /*
129436 ** The minimum number of cells allowed for a node is a third of the 
129437 ** maximum. In Gutman's notation:
129438 **
129439 **     m = M/3
129440 **
129441 ** If an R*-tree "Reinsert" operation is required, the same number of
129442 ** cells are removed from the overfull node and reinserted into the tree.
129443 */
129444 #define RTREE_MINCELLS(p) ((((p)->iNodeSize-4)/(p)->nBytesPerCell)/3)
129445 #define RTREE_REINSERT(p) RTREE_MINCELLS(p)
129446 #define RTREE_MAXCELLS 51
129447
129448 /*
129449 ** The smallest possible node-size is (512-64)==448 bytes. And the largest
129450 ** supported cell size is 48 bytes (8 byte rowid + ten 4 byte coordinates).
129451 ** Therefore all non-root nodes must contain at least 3 entries. Since 
129452 ** 2^40 is greater than 2^64, an r-tree structure always has a depth of
129453 ** 40 or less.
129454 */
129455 #define RTREE_MAX_DEPTH 40
129456
129457 /* 
129458 ** An rtree cursor object.
129459 */
129460 struct RtreeCursor {
129461   sqlcipher3_vtab_cursor base;
129462   RtreeNode *pNode;                 /* Node cursor is currently pointing at */
129463   int iCell;                        /* Index of current cell in pNode */
129464   int iStrategy;                    /* Copy of idxNum search parameter */
129465   int nConstraint;                  /* Number of entries in aConstraint */
129466   RtreeConstraint *aConstraint;     /* Search constraints. */
129467 };
129468
129469 union RtreeCoord {
129470   float f;
129471   int i;
129472 };
129473
129474 /*
129475 ** The argument is an RtreeCoord. Return the value stored within the RtreeCoord
129476 ** formatted as a double. This macro assumes that local variable pRtree points
129477 ** to the Rtree structure associated with the RtreeCoord.
129478 */
129479 #define DCOORD(coord) (                           \
129480   (pRtree->eCoordType==RTREE_COORD_REAL32) ?      \
129481     ((double)coord.f) :                           \
129482     ((double)coord.i)                             \
129483 )
129484
129485 /*
129486 ** A search constraint.
129487 */
129488 struct RtreeConstraint {
129489   int iCoord;                     /* Index of constrained coordinate */
129490   int op;                         /* Constraining operation */
129491   double rValue;                  /* Constraint value. */
129492   int (*xGeom)(sqlcipher3_rtree_geometry *, int, double *, int *);
129493   sqlcipher3_rtree_geometry *pGeom;  /* Constraint callback argument for a MATCH */
129494 };
129495
129496 /* Possible values for RtreeConstraint.op */
129497 #define RTREE_EQ    0x41
129498 #define RTREE_LE    0x42
129499 #define RTREE_LT    0x43
129500 #define RTREE_GE    0x44
129501 #define RTREE_GT    0x45
129502 #define RTREE_MATCH 0x46
129503
129504 /* 
129505 ** An rtree structure node.
129506 */
129507 struct RtreeNode {
129508   RtreeNode *pParent;               /* Parent node */
129509   i64 iNode;
129510   int nRef;
129511   int isDirty;
129512   u8 *zData;
129513   RtreeNode *pNext;                 /* Next node in this hash chain */
129514 };
129515 #define NCELL(pNode) readInt16(&(pNode)->zData[2])
129516
129517 /* 
129518 ** Structure to store a deserialized rtree record.
129519 */
129520 struct RtreeCell {
129521   i64 iRowid;
129522   RtreeCoord aCoord[RTREE_MAX_DIMENSIONS*2];
129523 };
129524
129525
129526 /*
129527 ** Value for the first field of every RtreeMatchArg object. The MATCH
129528 ** operator tests that the first field of a blob operand matches this
129529 ** value to avoid operating on invalid blobs (which could cause a segfault).
129530 */
129531 #define RTREE_GEOMETRY_MAGIC 0x891245AB
129532
129533 /*
129534 ** An instance of this structure must be supplied as a blob argument to
129535 ** the right-hand-side of an SQL MATCH operator used to constrain an
129536 ** r-tree query.
129537 */
129538 struct RtreeMatchArg {
129539   u32 magic;                      /* Always RTREE_GEOMETRY_MAGIC */
129540   int (*xGeom)(sqlcipher3_rtree_geometry *, int, double *, int *);
129541   void *pContext;
129542   int nParam;
129543   double aParam[1];
129544 };
129545
129546 /*
129547 ** When a geometry callback is created (see sqlcipher3_rtree_geometry_callback),
129548 ** a single instance of the following structure is allocated. It is used
129549 ** as the context for the user-function created by by s_r_g_c(). The object
129550 ** is eventually deleted by the destructor mechanism provided by
129551 ** sqlcipher3_create_function_v2() (which is called by s_r_g_c() to create
129552 ** the geometry callback function).
129553 */
129554 struct RtreeGeomCallback {
129555   int (*xGeom)(sqlcipher3_rtree_geometry *, int, double *, int *);
129556   void *pContext;
129557 };
129558
129559 #ifndef MAX
129560 # define MAX(x,y) ((x) < (y) ? (y) : (x))
129561 #endif
129562 #ifndef MIN
129563 # define MIN(x,y) ((x) > (y) ? (y) : (x))
129564 #endif
129565
129566 /*
129567 ** Functions to deserialize a 16 bit integer, 32 bit real number and
129568 ** 64 bit integer. The deserialized value is returned.
129569 */
129570 static int readInt16(u8 *p){
129571   return (p[0]<<8) + p[1];
129572 }
129573 static void readCoord(u8 *p, RtreeCoord *pCoord){
129574   u32 i = (
129575     (((u32)p[0]) << 24) + 
129576     (((u32)p[1]) << 16) + 
129577     (((u32)p[2]) <<  8) + 
129578     (((u32)p[3]) <<  0)
129579   );
129580   *(u32 *)pCoord = i;
129581 }
129582 static i64 readInt64(u8 *p){
129583   return (
129584     (((i64)p[0]) << 56) + 
129585     (((i64)p[1]) << 48) + 
129586     (((i64)p[2]) << 40) + 
129587     (((i64)p[3]) << 32) + 
129588     (((i64)p[4]) << 24) + 
129589     (((i64)p[5]) << 16) + 
129590     (((i64)p[6]) <<  8) + 
129591     (((i64)p[7]) <<  0)
129592   );
129593 }
129594
129595 /*
129596 ** Functions to serialize a 16 bit integer, 32 bit real number and
129597 ** 64 bit integer. The value returned is the number of bytes written
129598 ** to the argument buffer (always 2, 4 and 8 respectively).
129599 */
129600 static int writeInt16(u8 *p, int i){
129601   p[0] = (i>> 8)&0xFF;
129602   p[1] = (i>> 0)&0xFF;
129603   return 2;
129604 }
129605 static int writeCoord(u8 *p, RtreeCoord *pCoord){
129606   u32 i;
129607   assert( sizeof(RtreeCoord)==4 );
129608   assert( sizeof(u32)==4 );
129609   i = *(u32 *)pCoord;
129610   p[0] = (i>>24)&0xFF;
129611   p[1] = (i>>16)&0xFF;
129612   p[2] = (i>> 8)&0xFF;
129613   p[3] = (i>> 0)&0xFF;
129614   return 4;
129615 }
129616 static int writeInt64(u8 *p, i64 i){
129617   p[0] = (i>>56)&0xFF;
129618   p[1] = (i>>48)&0xFF;
129619   p[2] = (i>>40)&0xFF;
129620   p[3] = (i>>32)&0xFF;
129621   p[4] = (i>>24)&0xFF;
129622   p[5] = (i>>16)&0xFF;
129623   p[6] = (i>> 8)&0xFF;
129624   p[7] = (i>> 0)&0xFF;
129625   return 8;
129626 }
129627
129628 /*
129629 ** Increment the reference count of node p.
129630 */
129631 static void nodeReference(RtreeNode *p){
129632   if( p ){
129633     p->nRef++;
129634   }
129635 }
129636
129637 /*
129638 ** Clear the content of node p (set all bytes to 0x00).
129639 */
129640 static void nodeZero(Rtree *pRtree, RtreeNode *p){
129641   memset(&p->zData[2], 0, pRtree->iNodeSize-2);
129642   p->isDirty = 1;
129643 }
129644
129645 /*
129646 ** Given a node number iNode, return the corresponding key to use
129647 ** in the Rtree.aHash table.
129648 */
129649 static int nodeHash(i64 iNode){
129650   return (
129651     (iNode>>56) ^ (iNode>>48) ^ (iNode>>40) ^ (iNode>>32) ^ 
129652     (iNode>>24) ^ (iNode>>16) ^ (iNode>> 8) ^ (iNode>> 0)
129653   ) % HASHSIZE;
129654 }
129655
129656 /*
129657 ** Search the node hash table for node iNode. If found, return a pointer
129658 ** to it. Otherwise, return 0.
129659 */
129660 static RtreeNode *nodeHashLookup(Rtree *pRtree, i64 iNode){
129661   RtreeNode *p;
129662   for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
129663   return p;
129664 }
129665
129666 /*
129667 ** Add node pNode to the node hash table.
129668 */
129669 static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){
129670   int iHash;
129671   assert( pNode->pNext==0 );
129672   iHash = nodeHash(pNode->iNode);
129673   pNode->pNext = pRtree->aHash[iHash];
129674   pRtree->aHash[iHash] = pNode;
129675 }
129676
129677 /*
129678 ** Remove node pNode from the node hash table.
129679 */
129680 static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
129681   RtreeNode **pp;
129682   if( pNode->iNode!=0 ){
129683     pp = &pRtree->aHash[nodeHash(pNode->iNode)];
129684     for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
129685     *pp = pNode->pNext;
129686     pNode->pNext = 0;
129687   }
129688 }
129689
129690 /*
129691 ** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0),
129692 ** indicating that node has not yet been assigned a node number. It is
129693 ** assigned a node number when nodeWrite() is called to write the
129694 ** node contents out to the database.
129695 */
129696 static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){
129697   RtreeNode *pNode;
129698   pNode = (RtreeNode *)sqlcipher3_malloc(sizeof(RtreeNode) + pRtree->iNodeSize);
129699   if( pNode ){
129700     memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize);
129701     pNode->zData = (u8 *)&pNode[1];
129702     pNode->nRef = 1;
129703     pNode->pParent = pParent;
129704     pNode->isDirty = 1;
129705     nodeReference(pParent);
129706   }
129707   return pNode;
129708 }
129709
129710 /*
129711 ** Obtain a reference to an r-tree node.
129712 */
129713 static int
129714 nodeAcquire(
129715   Rtree *pRtree,             /* R-tree structure */
129716   i64 iNode,                 /* Node number to load */
129717   RtreeNode *pParent,        /* Either the parent node or NULL */
129718   RtreeNode **ppNode         /* OUT: Acquired node */
129719 ){
129720   int rc;
129721   int rc2 = SQLCIPHER_OK;
129722   RtreeNode *pNode;
129723
129724   /* Check if the requested node is already in the hash table. If so,
129725   ** increase its reference count and return it.
129726   */
129727   if( (pNode = nodeHashLookup(pRtree, iNode)) ){
129728     assert( !pParent || !pNode->pParent || pNode->pParent==pParent );
129729     if( pParent && !pNode->pParent ){
129730       nodeReference(pParent);
129731       pNode->pParent = pParent;
129732     }
129733     pNode->nRef++;
129734     *ppNode = pNode;
129735     return SQLCIPHER_OK;
129736   }
129737
129738   sqlcipher3_bind_int64(pRtree->pReadNode, 1, iNode);
129739   rc = sqlcipher3_step(pRtree->pReadNode);
129740   if( rc==SQLCIPHER_ROW ){
129741     const u8 *zBlob = sqlcipher3_column_blob(pRtree->pReadNode, 0);
129742     if( pRtree->iNodeSize==sqlcipher3_column_bytes(pRtree->pReadNode, 0) ){
129743       pNode = (RtreeNode *)sqlcipher3_malloc(sizeof(RtreeNode)+pRtree->iNodeSize);
129744       if( !pNode ){
129745         rc2 = SQLCIPHER_NOMEM;
129746       }else{
129747         pNode->pParent = pParent;
129748         pNode->zData = (u8 *)&pNode[1];
129749         pNode->nRef = 1;
129750         pNode->iNode = iNode;
129751         pNode->isDirty = 0;
129752         pNode->pNext = 0;
129753         memcpy(pNode->zData, zBlob, pRtree->iNodeSize);
129754         nodeReference(pParent);
129755       }
129756     }
129757   }
129758   rc = sqlcipher3_reset(pRtree->pReadNode);
129759   if( rc==SQLCIPHER_OK ) rc = rc2;
129760
129761   /* If the root node was just loaded, set pRtree->iDepth to the height
129762   ** of the r-tree structure. A height of zero means all data is stored on
129763   ** the root node. A height of one means the children of the root node
129764   ** are the leaves, and so on. If the depth as specified on the root node
129765   ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
129766   */
129767   if( pNode && iNode==1 ){
129768     pRtree->iDepth = readInt16(pNode->zData);
129769     if( pRtree->iDepth>RTREE_MAX_DEPTH ){
129770       rc = SQLCIPHER_CORRUPT_VTAB;
129771     }
129772   }
129773
129774   /* If no error has occurred so far, check if the "number of entries"
129775   ** field on the node is too large. If so, set the return code to 
129776   ** SQLCIPHER_CORRUPT_VTAB.
129777   */
129778   if( pNode && rc==SQLCIPHER_OK ){
129779     if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){
129780       rc = SQLCIPHER_CORRUPT_VTAB;
129781     }
129782   }
129783
129784   if( rc==SQLCIPHER_OK ){
129785     if( pNode!=0 ){
129786       nodeHashInsert(pRtree, pNode);
129787     }else{
129788       rc = SQLCIPHER_CORRUPT_VTAB;
129789     }
129790     *ppNode = pNode;
129791   }else{
129792     sqlcipher3_free(pNode);
129793     *ppNode = 0;
129794   }
129795
129796   return rc;
129797 }
129798
129799 /*
129800 ** Overwrite cell iCell of node pNode with the contents of pCell.
129801 */
129802 static void nodeOverwriteCell(
129803   Rtree *pRtree, 
129804   RtreeNode *pNode,  
129805   RtreeCell *pCell, 
129806   int iCell
129807 ){
129808   int ii;
129809   u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
129810   p += writeInt64(p, pCell->iRowid);
129811   for(ii=0; ii<(pRtree->nDim*2); ii++){
129812     p += writeCoord(p, &pCell->aCoord[ii]);
129813   }
129814   pNode->isDirty = 1;
129815 }
129816
129817 /*
129818 ** Remove cell the cell with index iCell from node pNode.
129819 */
129820 static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){
129821   u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
129822   u8 *pSrc = &pDst[pRtree->nBytesPerCell];
129823   int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
129824   memmove(pDst, pSrc, nByte);
129825   writeInt16(&pNode->zData[2], NCELL(pNode)-1);
129826   pNode->isDirty = 1;
129827 }
129828
129829 /*
129830 ** Insert the contents of cell pCell into node pNode. If the insert
129831 ** is successful, return SQLCIPHER_OK.
129832 **
129833 ** If there is not enough free space in pNode, return SQLCIPHER_FULL.
129834 */
129835 static int
129836 nodeInsertCell(
129837   Rtree *pRtree, 
129838   RtreeNode *pNode, 
129839   RtreeCell *pCell 
129840 ){
129841   int nCell;                    /* Current number of cells in pNode */
129842   int nMaxCell;                 /* Maximum number of cells for pNode */
129843
129844   nMaxCell = (pRtree->iNodeSize-4)/pRtree->nBytesPerCell;
129845   nCell = NCELL(pNode);
129846
129847   assert( nCell<=nMaxCell );
129848   if( nCell<nMaxCell ){
129849     nodeOverwriteCell(pRtree, pNode, pCell, nCell);
129850     writeInt16(&pNode->zData[2], nCell+1);
129851     pNode->isDirty = 1;
129852   }
129853
129854   return (nCell==nMaxCell);
129855 }
129856
129857 /*
129858 ** If the node is dirty, write it out to the database.
129859 */
129860 static int
129861 nodeWrite(Rtree *pRtree, RtreeNode *pNode){
129862   int rc = SQLCIPHER_OK;
129863   if( pNode->isDirty ){
129864     sqlcipher3_stmt *p = pRtree->pWriteNode;
129865     if( pNode->iNode ){
129866       sqlcipher3_bind_int64(p, 1, pNode->iNode);
129867     }else{
129868       sqlcipher3_bind_null(p, 1);
129869     }
129870     sqlcipher3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLCIPHER_STATIC);
129871     sqlcipher3_step(p);
129872     pNode->isDirty = 0;
129873     rc = sqlcipher3_reset(p);
129874     if( pNode->iNode==0 && rc==SQLCIPHER_OK ){
129875       pNode->iNode = sqlcipher3_last_insert_rowid(pRtree->db);
129876       nodeHashInsert(pRtree, pNode);
129877     }
129878   }
129879   return rc;
129880 }
129881
129882 /*
129883 ** Release a reference to a node. If the node is dirty and the reference
129884 ** count drops to zero, the node data is written to the database.
129885 */
129886 static int
129887 nodeRelease(Rtree *pRtree, RtreeNode *pNode){
129888   int rc = SQLCIPHER_OK;
129889   if( pNode ){
129890     assert( pNode->nRef>0 );
129891     pNode->nRef--;
129892     if( pNode->nRef==0 ){
129893       if( pNode->iNode==1 ){
129894         pRtree->iDepth = -1;
129895       }
129896       if( pNode->pParent ){
129897         rc = nodeRelease(pRtree, pNode->pParent);
129898       }
129899       if( rc==SQLCIPHER_OK ){
129900         rc = nodeWrite(pRtree, pNode);
129901       }
129902       nodeHashDelete(pRtree, pNode);
129903       sqlcipher3_free(pNode);
129904     }
129905   }
129906   return rc;
129907 }
129908
129909 /*
129910 ** Return the 64-bit integer value associated with cell iCell of
129911 ** node pNode. If pNode is a leaf node, this is a rowid. If it is
129912 ** an internal node, then the 64-bit integer is a child page number.
129913 */
129914 static i64 nodeGetRowid(
129915   Rtree *pRtree, 
129916   RtreeNode *pNode, 
129917   int iCell
129918 ){
129919   assert( iCell<NCELL(pNode) );
129920   return readInt64(&pNode->zData[4 + pRtree->nBytesPerCell*iCell]);
129921 }
129922
129923 /*
129924 ** Return coordinate iCoord from cell iCell in node pNode.
129925 */
129926 static void nodeGetCoord(
129927   Rtree *pRtree, 
129928   RtreeNode *pNode, 
129929   int iCell,
129930   int iCoord,
129931   RtreeCoord *pCoord           /* Space to write result to */
129932 ){
129933   readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord);
129934 }
129935
129936 /*
129937 ** Deserialize cell iCell of node pNode. Populate the structure pointed
129938 ** to by pCell with the results.
129939 */
129940 static void nodeGetCell(
129941   Rtree *pRtree, 
129942   RtreeNode *pNode, 
129943   int iCell,
129944   RtreeCell *pCell
129945 ){
129946   int ii;
129947   pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
129948   for(ii=0; ii<pRtree->nDim*2; ii++){
129949     nodeGetCoord(pRtree, pNode, iCell, ii, &pCell->aCoord[ii]);
129950   }
129951 }
129952
129953
129954 /* Forward declaration for the function that does the work of
129955 ** the virtual table module xCreate() and xConnect() methods.
129956 */
129957 static int rtreeInit(
129958   sqlcipher3 *, void *, int, const char *const*, sqlcipher3_vtab **, char **, int
129959 );
129960
129961 /* 
129962 ** Rtree virtual table module xCreate method.
129963 */
129964 static int rtreeCreate(
129965   sqlcipher3 *db,
129966   void *pAux,
129967   int argc, const char *const*argv,
129968   sqlcipher3_vtab **ppVtab,
129969   char **pzErr
129970 ){
129971   return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 1);
129972 }
129973
129974 /* 
129975 ** Rtree virtual table module xConnect method.
129976 */
129977 static int rtreeConnect(
129978   sqlcipher3 *db,
129979   void *pAux,
129980   int argc, const char *const*argv,
129981   sqlcipher3_vtab **ppVtab,
129982   char **pzErr
129983 ){
129984   return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 0);
129985 }
129986
129987 /*
129988 ** Increment the r-tree reference count.
129989 */
129990 static void rtreeReference(Rtree *pRtree){
129991   pRtree->nBusy++;
129992 }
129993
129994 /*
129995 ** Decrement the r-tree reference count. When the reference count reaches
129996 ** zero the structure is deleted.
129997 */
129998 static void rtreeRelease(Rtree *pRtree){
129999   pRtree->nBusy--;
130000   if( pRtree->nBusy==0 ){
130001     sqlcipher3_finalize(pRtree->pReadNode);
130002     sqlcipher3_finalize(pRtree->pWriteNode);
130003     sqlcipher3_finalize(pRtree->pDeleteNode);
130004     sqlcipher3_finalize(pRtree->pReadRowid);
130005     sqlcipher3_finalize(pRtree->pWriteRowid);
130006     sqlcipher3_finalize(pRtree->pDeleteRowid);
130007     sqlcipher3_finalize(pRtree->pReadParent);
130008     sqlcipher3_finalize(pRtree->pWriteParent);
130009     sqlcipher3_finalize(pRtree->pDeleteParent);
130010     sqlcipher3_free(pRtree);
130011   }
130012 }
130013
130014 /* 
130015 ** Rtree virtual table module xDisconnect method.
130016 */
130017 static int rtreeDisconnect(sqlcipher3_vtab *pVtab){
130018   rtreeRelease((Rtree *)pVtab);
130019   return SQLCIPHER_OK;
130020 }
130021
130022 /* 
130023 ** Rtree virtual table module xDestroy method.
130024 */
130025 static int rtreeDestroy(sqlcipher3_vtab *pVtab){
130026   Rtree *pRtree = (Rtree *)pVtab;
130027   int rc;
130028   char *zCreate = sqlcipher3_mprintf(
130029     "DROP TABLE '%q'.'%q_node';"
130030     "DROP TABLE '%q'.'%q_rowid';"
130031     "DROP TABLE '%q'.'%q_parent';",
130032     pRtree->zDb, pRtree->zName, 
130033     pRtree->zDb, pRtree->zName,
130034     pRtree->zDb, pRtree->zName
130035   );
130036   if( !zCreate ){
130037     rc = SQLCIPHER_NOMEM;
130038   }else{
130039     rc = sqlcipher3_exec(pRtree->db, zCreate, 0, 0, 0);
130040     sqlcipher3_free(zCreate);
130041   }
130042   if( rc==SQLCIPHER_OK ){
130043     rtreeRelease(pRtree);
130044   }
130045
130046   return rc;
130047 }
130048
130049 /* 
130050 ** Rtree virtual table module xOpen method.
130051 */
130052 static int rtreeOpen(sqlcipher3_vtab *pVTab, sqlcipher3_vtab_cursor **ppCursor){
130053   int rc = SQLCIPHER_NOMEM;
130054   RtreeCursor *pCsr;
130055
130056   pCsr = (RtreeCursor *)sqlcipher3_malloc(sizeof(RtreeCursor));
130057   if( pCsr ){
130058     memset(pCsr, 0, sizeof(RtreeCursor));
130059     pCsr->base.pVtab = pVTab;
130060     rc = SQLCIPHER_OK;
130061   }
130062   *ppCursor = (sqlcipher3_vtab_cursor *)pCsr;
130063
130064   return rc;
130065 }
130066
130067
130068 /*
130069 ** Free the RtreeCursor.aConstraint[] array and its contents.
130070 */
130071 static void freeCursorConstraints(RtreeCursor *pCsr){
130072   if( pCsr->aConstraint ){
130073     int i;                        /* Used to iterate through constraint array */
130074     for(i=0; i<pCsr->nConstraint; i++){
130075       sqlcipher3_rtree_geometry *pGeom = pCsr->aConstraint[i].pGeom;
130076       if( pGeom ){
130077         if( pGeom->xDelUser ) pGeom->xDelUser(pGeom->pUser);
130078         sqlcipher3_free(pGeom);
130079       }
130080     }
130081     sqlcipher3_free(pCsr->aConstraint);
130082     pCsr->aConstraint = 0;
130083   }
130084 }
130085
130086 /* 
130087 ** Rtree virtual table module xClose method.
130088 */
130089 static int rtreeClose(sqlcipher3_vtab_cursor *cur){
130090   Rtree *pRtree = (Rtree *)(cur->pVtab);
130091   int rc;
130092   RtreeCursor *pCsr = (RtreeCursor *)cur;
130093   freeCursorConstraints(pCsr);
130094   rc = nodeRelease(pRtree, pCsr->pNode);
130095   sqlcipher3_free(pCsr);
130096   return rc;
130097 }
130098
130099 /*
130100 ** Rtree virtual table module xEof method.
130101 **
130102 ** Return non-zero if the cursor does not currently point to a valid 
130103 ** record (i.e if the scan has finished), or zero otherwise.
130104 */
130105 static int rtreeEof(sqlcipher3_vtab_cursor *cur){
130106   RtreeCursor *pCsr = (RtreeCursor *)cur;
130107   return (pCsr->pNode==0);
130108 }
130109
130110 /*
130111 ** The r-tree constraint passed as the second argument to this function is
130112 ** guaranteed to be a MATCH constraint.
130113 */
130114 static int testRtreeGeom(
130115   Rtree *pRtree,                  /* R-Tree object */
130116   RtreeConstraint *pConstraint,   /* MATCH constraint to test */
130117   RtreeCell *pCell,               /* Cell to test */
130118   int *pbRes                      /* OUT: Test result */
130119 ){
130120   int i;
130121   double aCoord[RTREE_MAX_DIMENSIONS*2];
130122   int nCoord = pRtree->nDim*2;
130123
130124   assert( pConstraint->op==RTREE_MATCH );
130125   assert( pConstraint->pGeom );
130126
130127   for(i=0; i<nCoord; i++){
130128     aCoord[i] = DCOORD(pCell->aCoord[i]);
130129   }
130130   return pConstraint->xGeom(pConstraint->pGeom, nCoord, aCoord, pbRes);
130131 }
130132
130133 /* 
130134 ** Cursor pCursor currently points to a cell in a non-leaf page.
130135 ** Set *pbEof to true if the sub-tree headed by the cell is filtered
130136 ** (excluded) by the constraints in the pCursor->aConstraint[] 
130137 ** array, or false otherwise.
130138 **
130139 ** Return SQLCIPHER_OK if successful or an SQLite error code if an error
130140 ** occurs within a geometry callback.
130141 */
130142 static int testRtreeCell(Rtree *pRtree, RtreeCursor *pCursor, int *pbEof){
130143   RtreeCell cell;
130144   int ii;
130145   int bRes = 0;
130146   int rc = SQLCIPHER_OK;
130147
130148   nodeGetCell(pRtree, pCursor->pNode, pCursor->iCell, &cell);
130149   for(ii=0; bRes==0 && ii<pCursor->nConstraint; ii++){
130150     RtreeConstraint *p = &pCursor->aConstraint[ii];
130151     double cell_min = DCOORD(cell.aCoord[(p->iCoord>>1)*2]);
130152     double cell_max = DCOORD(cell.aCoord[(p->iCoord>>1)*2+1]);
130153
130154     assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE 
130155         || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_MATCH
130156     );
130157
130158     switch( p->op ){
130159       case RTREE_LE: case RTREE_LT: 
130160         bRes = p->rValue<cell_min; 
130161         break;
130162
130163       case RTREE_GE: case RTREE_GT: 
130164         bRes = p->rValue>cell_max; 
130165         break;
130166
130167       case RTREE_EQ:
130168         bRes = (p->rValue>cell_max || p->rValue<cell_min);
130169         break;
130170
130171       default: {
130172         assert( p->op==RTREE_MATCH );
130173         rc = testRtreeGeom(pRtree, p, &cell, &bRes);
130174         bRes = !bRes;
130175         break;
130176       }
130177     }
130178   }
130179
130180   *pbEof = bRes;
130181   return rc;
130182 }
130183
130184 /* 
130185 ** Test if the cell that cursor pCursor currently points to
130186 ** would be filtered (excluded) by the constraints in the 
130187 ** pCursor->aConstraint[] array. If so, set *pbEof to true before
130188 ** returning. If the cell is not filtered (excluded) by the constraints,
130189 ** set pbEof to zero.
130190 **
130191 ** Return SQLCIPHER_OK if successful or an SQLite error code if an error
130192 ** occurs within a geometry callback.
130193 **
130194 ** This function assumes that the cell is part of a leaf node.
130195 */
130196 static int testRtreeEntry(Rtree *pRtree, RtreeCursor *pCursor, int *pbEof){
130197   RtreeCell cell;
130198   int ii;
130199   *pbEof = 0;
130200
130201   nodeGetCell(pRtree, pCursor->pNode, pCursor->iCell, &cell);
130202   for(ii=0; ii<pCursor->nConstraint; ii++){
130203     RtreeConstraint *p = &pCursor->aConstraint[ii];
130204     double coord = DCOORD(cell.aCoord[p->iCoord]);
130205     int res;
130206     assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE 
130207         || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_MATCH
130208     );
130209     switch( p->op ){
130210       case RTREE_LE: res = (coord<=p->rValue); break;
130211       case RTREE_LT: res = (coord<p->rValue);  break;
130212       case RTREE_GE: res = (coord>=p->rValue); break;
130213       case RTREE_GT: res = (coord>p->rValue);  break;
130214       case RTREE_EQ: res = (coord==p->rValue); break;
130215       default: {
130216         int rc;
130217         assert( p->op==RTREE_MATCH );
130218         rc = testRtreeGeom(pRtree, p, &cell, &res);
130219         if( rc!=SQLCIPHER_OK ){
130220           return rc;
130221         }
130222         break;
130223       }
130224     }
130225
130226     if( !res ){
130227       *pbEof = 1;
130228       return SQLCIPHER_OK;
130229     }
130230   }
130231
130232   return SQLCIPHER_OK;
130233 }
130234
130235 /*
130236 ** Cursor pCursor currently points at a node that heads a sub-tree of
130237 ** height iHeight (if iHeight==0, then the node is a leaf). Descend
130238 ** to point to the left-most cell of the sub-tree that matches the 
130239 ** configured constraints.
130240 */
130241 static int descendToCell(
130242   Rtree *pRtree, 
130243   RtreeCursor *pCursor, 
130244   int iHeight,
130245   int *pEof                 /* OUT: Set to true if cannot descend */
130246 ){
130247   int isEof;
130248   int rc;
130249   int ii;
130250   RtreeNode *pChild;
130251   sqlcipher3_int64 iRowid;
130252
130253   RtreeNode *pSavedNode = pCursor->pNode;
130254   int iSavedCell = pCursor->iCell;
130255
130256   assert( iHeight>=0 );
130257
130258   if( iHeight==0 ){
130259     rc = testRtreeEntry(pRtree, pCursor, &isEof);
130260   }else{
130261     rc = testRtreeCell(pRtree, pCursor, &isEof);
130262   }
130263   if( rc!=SQLCIPHER_OK || isEof || iHeight==0 ){
130264     goto descend_to_cell_out;
130265   }
130266
130267   iRowid = nodeGetRowid(pRtree, pCursor->pNode, pCursor->iCell);
130268   rc = nodeAcquire(pRtree, iRowid, pCursor->pNode, &pChild);
130269   if( rc!=SQLCIPHER_OK ){
130270     goto descend_to_cell_out;
130271   }
130272
130273   nodeRelease(pRtree, pCursor->pNode);
130274   pCursor->pNode = pChild;
130275   isEof = 1;
130276   for(ii=0; isEof && ii<NCELL(pChild); ii++){
130277     pCursor->iCell = ii;
130278     rc = descendToCell(pRtree, pCursor, iHeight-1, &isEof);
130279     if( rc!=SQLCIPHER_OK ){
130280       goto descend_to_cell_out;
130281     }
130282   }
130283
130284   if( isEof ){
130285     assert( pCursor->pNode==pChild );
130286     nodeReference(pSavedNode);
130287     nodeRelease(pRtree, pChild);
130288     pCursor->pNode = pSavedNode;
130289     pCursor->iCell = iSavedCell;
130290   }
130291
130292 descend_to_cell_out:
130293   *pEof = isEof;
130294   return rc;
130295 }
130296
130297 /*
130298 ** One of the cells in node pNode is guaranteed to have a 64-bit 
130299 ** integer value equal to iRowid. Return the index of this cell.
130300 */
130301 static int nodeRowidIndex(
130302   Rtree *pRtree, 
130303   RtreeNode *pNode, 
130304   i64 iRowid,
130305   int *piIndex
130306 ){
130307   int ii;
130308   int nCell = NCELL(pNode);
130309   for(ii=0; ii<nCell; ii++){
130310     if( nodeGetRowid(pRtree, pNode, ii)==iRowid ){
130311       *piIndex = ii;
130312       return SQLCIPHER_OK;
130313     }
130314   }
130315   return SQLCIPHER_CORRUPT_VTAB;
130316 }
130317
130318 /*
130319 ** Return the index of the cell containing a pointer to node pNode
130320 ** in its parent. If pNode is the root node, return -1.
130321 */
130322 static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){
130323   RtreeNode *pParent = pNode->pParent;
130324   if( pParent ){
130325     return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex);
130326   }
130327   *piIndex = -1;
130328   return SQLCIPHER_OK;
130329 }
130330
130331 /* 
130332 ** Rtree virtual table module xNext method.
130333 */
130334 static int rtreeNext(sqlcipher3_vtab_cursor *pVtabCursor){
130335   Rtree *pRtree = (Rtree *)(pVtabCursor->pVtab);
130336   RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
130337   int rc = SQLCIPHER_OK;
130338
130339   /* RtreeCursor.pNode must not be NULL. If is is NULL, then this cursor is
130340   ** already at EOF. It is against the rules to call the xNext() method of
130341   ** a cursor that has already reached EOF.
130342   */
130343   assert( pCsr->pNode );
130344
130345   if( pCsr->iStrategy==1 ){
130346     /* This "scan" is a direct lookup by rowid. There is no next entry. */
130347     nodeRelease(pRtree, pCsr->pNode);
130348     pCsr->pNode = 0;
130349   }else{
130350     /* Move to the next entry that matches the configured constraints. */
130351     int iHeight = 0;
130352     while( pCsr->pNode ){
130353       RtreeNode *pNode = pCsr->pNode;
130354       int nCell = NCELL(pNode);
130355       for(pCsr->iCell++; pCsr->iCell<nCell; pCsr->iCell++){
130356         int isEof;
130357         rc = descendToCell(pRtree, pCsr, iHeight, &isEof);
130358         if( rc!=SQLCIPHER_OK || !isEof ){
130359           return rc;
130360         }
130361       }
130362       pCsr->pNode = pNode->pParent;
130363       rc = nodeParentIndex(pRtree, pNode, &pCsr->iCell);
130364       if( rc!=SQLCIPHER_OK ){
130365         return rc;
130366       }
130367       nodeReference(pCsr->pNode);
130368       nodeRelease(pRtree, pNode);
130369       iHeight++;
130370     }
130371   }
130372
130373   return rc;
130374 }
130375
130376 /* 
130377 ** Rtree virtual table module xRowid method.
130378 */
130379 static int rtreeRowid(sqlcipher3_vtab_cursor *pVtabCursor, sqlcipher_int64 *pRowid){
130380   Rtree *pRtree = (Rtree *)pVtabCursor->pVtab;
130381   RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
130382
130383   assert(pCsr->pNode);
130384   *pRowid = nodeGetRowid(pRtree, pCsr->pNode, pCsr->iCell);
130385
130386   return SQLCIPHER_OK;
130387 }
130388
130389 /* 
130390 ** Rtree virtual table module xColumn method.
130391 */
130392 static int rtreeColumn(sqlcipher3_vtab_cursor *cur, sqlcipher3_context *ctx, int i){
130393   Rtree *pRtree = (Rtree *)cur->pVtab;
130394   RtreeCursor *pCsr = (RtreeCursor *)cur;
130395
130396   if( i==0 ){
130397     i64 iRowid = nodeGetRowid(pRtree, pCsr->pNode, pCsr->iCell);
130398     sqlcipher3_result_int64(ctx, iRowid);
130399   }else{
130400     RtreeCoord c;
130401     nodeGetCoord(pRtree, pCsr->pNode, pCsr->iCell, i-1, &c);
130402     if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
130403       sqlcipher3_result_double(ctx, c.f);
130404     }else{
130405       assert( pRtree->eCoordType==RTREE_COORD_INT32 );
130406       sqlcipher3_result_int(ctx, c.i);
130407     }
130408   }
130409
130410   return SQLCIPHER_OK;
130411 }
130412
130413 /* 
130414 ** Use nodeAcquire() to obtain the leaf node containing the record with 
130415 ** rowid iRowid. If successful, set *ppLeaf to point to the node and
130416 ** return SQLCIPHER_OK. If there is no such record in the table, set
130417 ** *ppLeaf to 0 and return SQLCIPHER_OK. If an error occurs, set *ppLeaf
130418 ** to zero and return an SQLite error code.
130419 */
130420 static int findLeafNode(Rtree *pRtree, i64 iRowid, RtreeNode **ppLeaf){
130421   int rc;
130422   *ppLeaf = 0;
130423   sqlcipher3_bind_int64(pRtree->pReadRowid, 1, iRowid);
130424   if( sqlcipher3_step(pRtree->pReadRowid)==SQLCIPHER_ROW ){
130425     i64 iNode = sqlcipher3_column_int64(pRtree->pReadRowid, 0);
130426     rc = nodeAcquire(pRtree, iNode, 0, ppLeaf);
130427     sqlcipher3_reset(pRtree->pReadRowid);
130428   }else{
130429     rc = sqlcipher3_reset(pRtree->pReadRowid);
130430   }
130431   return rc;
130432 }
130433
130434 /*
130435 ** This function is called to configure the RtreeConstraint object passed
130436 ** as the second argument for a MATCH constraint. The value passed as the
130437 ** first argument to this function is the right-hand operand to the MATCH
130438 ** operator.
130439 */
130440 static int deserializeGeometry(sqlcipher3_value *pValue, RtreeConstraint *pCons){
130441   RtreeMatchArg *p;
130442   sqlcipher3_rtree_geometry *pGeom;
130443   int nBlob;
130444
130445   /* Check that value is actually a blob. */
130446   if( !sqlcipher3_value_type(pValue)==SQLCIPHER_BLOB ) return SQLCIPHER_ERROR;
130447
130448   /* Check that the blob is roughly the right size. */
130449   nBlob = sqlcipher3_value_bytes(pValue);
130450   if( nBlob<(int)sizeof(RtreeMatchArg) 
130451    || ((nBlob-sizeof(RtreeMatchArg))%sizeof(double))!=0
130452   ){
130453     return SQLCIPHER_ERROR;
130454   }
130455
130456   pGeom = (sqlcipher3_rtree_geometry *)sqlcipher3_malloc(
130457       sizeof(sqlcipher3_rtree_geometry) + nBlob
130458   );
130459   if( !pGeom ) return SQLCIPHER_NOMEM;
130460   memset(pGeom, 0, sizeof(sqlcipher3_rtree_geometry));
130461   p = (RtreeMatchArg *)&pGeom[1];
130462
130463   memcpy(p, sqlcipher3_value_blob(pValue), nBlob);
130464   if( p->magic!=RTREE_GEOMETRY_MAGIC 
130465    || nBlob!=(int)(sizeof(RtreeMatchArg) + (p->nParam-1)*sizeof(double))
130466   ){
130467     sqlcipher3_free(pGeom);
130468     return SQLCIPHER_ERROR;
130469   }
130470
130471   pGeom->pContext = p->pContext;
130472   pGeom->nParam = p->nParam;
130473   pGeom->aParam = p->aParam;
130474
130475   pCons->xGeom = p->xGeom;
130476   pCons->pGeom = pGeom;
130477   return SQLCIPHER_OK;
130478 }
130479
130480 /* 
130481 ** Rtree virtual table module xFilter method.
130482 */
130483 static int rtreeFilter(
130484   sqlcipher3_vtab_cursor *pVtabCursor, 
130485   int idxNum, const char *idxStr,
130486   int argc, sqlcipher3_value **argv
130487 ){
130488   Rtree *pRtree = (Rtree *)pVtabCursor->pVtab;
130489   RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
130490
130491   RtreeNode *pRoot = 0;
130492   int ii;
130493   int rc = SQLCIPHER_OK;
130494
130495   rtreeReference(pRtree);
130496
130497   freeCursorConstraints(pCsr);
130498   pCsr->iStrategy = idxNum;
130499
130500   if( idxNum==1 ){
130501     /* Special case - lookup by rowid. */
130502     RtreeNode *pLeaf;        /* Leaf on which the required cell resides */
130503     i64 iRowid = sqlcipher3_value_int64(argv[0]);
130504     rc = findLeafNode(pRtree, iRowid, &pLeaf);
130505     pCsr->pNode = pLeaf; 
130506     if( pLeaf ){
130507       assert( rc==SQLCIPHER_OK );
130508       rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &pCsr->iCell);
130509     }
130510   }else{
130511     /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array 
130512     ** with the configured constraints. 
130513     */
130514     if( argc>0 ){
130515       pCsr->aConstraint = sqlcipher3_malloc(sizeof(RtreeConstraint)*argc);
130516       pCsr->nConstraint = argc;
130517       if( !pCsr->aConstraint ){
130518         rc = SQLCIPHER_NOMEM;
130519       }else{
130520         memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc);
130521         assert( (idxStr==0 && argc==0)
130522                 || (idxStr && (int)strlen(idxStr)==argc*2) );
130523         for(ii=0; ii<argc; ii++){
130524           RtreeConstraint *p = &pCsr->aConstraint[ii];
130525           p->op = idxStr[ii*2];
130526           p->iCoord = idxStr[ii*2+1]-'a';
130527           if( p->op==RTREE_MATCH ){
130528             /* A MATCH operator. The right-hand-side must be a blob that
130529             ** can be cast into an RtreeMatchArg object. One created using
130530             ** an sqlcipher3_rtree_geometry_callback() SQL user function.
130531             */
130532             rc = deserializeGeometry(argv[ii], p);
130533             if( rc!=SQLCIPHER_OK ){
130534               break;
130535             }
130536           }else{
130537             p->rValue = sqlcipher3_value_double(argv[ii]);
130538           }
130539         }
130540       }
130541     }
130542   
130543     if( rc==SQLCIPHER_OK ){
130544       pCsr->pNode = 0;
130545       rc = nodeAcquire(pRtree, 1, 0, &pRoot);
130546     }
130547     if( rc==SQLCIPHER_OK ){
130548       int isEof = 1;
130549       int nCell = NCELL(pRoot);
130550       pCsr->pNode = pRoot;
130551       for(pCsr->iCell=0; rc==SQLCIPHER_OK && pCsr->iCell<nCell; pCsr->iCell++){
130552         assert( pCsr->pNode==pRoot );
130553         rc = descendToCell(pRtree, pCsr, pRtree->iDepth, &isEof);
130554         if( !isEof ){
130555           break;
130556         }
130557       }
130558       if( rc==SQLCIPHER_OK && isEof ){
130559         assert( pCsr->pNode==pRoot );
130560         nodeRelease(pRtree, pRoot);
130561         pCsr->pNode = 0;
130562       }
130563       assert( rc!=SQLCIPHER_OK || !pCsr->pNode || pCsr->iCell<NCELL(pCsr->pNode) );
130564     }
130565   }
130566
130567   rtreeRelease(pRtree);
130568   return rc;
130569 }
130570
130571 /*
130572 ** Rtree virtual table module xBestIndex method. There are three
130573 ** table scan strategies to choose from (in order from most to 
130574 ** least desirable):
130575 **
130576 **   idxNum     idxStr        Strategy
130577 **   ------------------------------------------------
130578 **     1        Unused        Direct lookup by rowid.
130579 **     2        See below     R-tree query or full-table scan.
130580 **   ------------------------------------------------
130581 **
130582 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
130583 ** 2 is used, idxStr is formatted to contain 2 bytes for each 
130584 ** constraint used. The first two bytes of idxStr correspond to 
130585 ** the constraint in sqlcipher3_index_info.aConstraintUsage[] with
130586 ** (argvIndex==1) etc.
130587 **
130588 ** The first of each pair of bytes in idxStr identifies the constraint
130589 ** operator as follows:
130590 **
130591 **   Operator    Byte Value
130592 **   ----------------------
130593 **      =        0x41 ('A')
130594 **     <=        0x42 ('B')
130595 **      <        0x43 ('C')
130596 **     >=        0x44 ('D')
130597 **      >        0x45 ('E')
130598 **   MATCH       0x46 ('F')
130599 **   ----------------------
130600 **
130601 ** The second of each pair of bytes identifies the coordinate column
130602 ** to which the constraint applies. The leftmost coordinate column
130603 ** is 'a', the second from the left 'b' etc.
130604 */
130605 static int rtreeBestIndex(sqlcipher3_vtab *tab, sqlcipher3_index_info *pIdxInfo){
130606   int rc = SQLCIPHER_OK;
130607   int ii;
130608
130609   int iIdx = 0;
130610   char zIdxStr[RTREE_MAX_DIMENSIONS*8+1];
130611   memset(zIdxStr, 0, sizeof(zIdxStr));
130612   UNUSED_PARAMETER(tab);
130613
130614   assert( pIdxInfo->idxStr==0 );
130615   for(ii=0; ii<pIdxInfo->nConstraint && iIdx<(int)(sizeof(zIdxStr)-1); ii++){
130616     struct sqlcipher3_index_constraint *p = &pIdxInfo->aConstraint[ii];
130617
130618     if( p->usable && p->iColumn==0 && p->op==SQLCIPHER_INDEX_CONSTRAINT_EQ ){
130619       /* We have an equality constraint on the rowid. Use strategy 1. */
130620       int jj;
130621       for(jj=0; jj<ii; jj++){
130622         pIdxInfo->aConstraintUsage[jj].argvIndex = 0;
130623         pIdxInfo->aConstraintUsage[jj].omit = 0;
130624       }
130625       pIdxInfo->idxNum = 1;
130626       pIdxInfo->aConstraintUsage[ii].argvIndex = 1;
130627       pIdxInfo->aConstraintUsage[jj].omit = 1;
130628
130629       /* This strategy involves a two rowid lookups on an B-Tree structures
130630       ** and then a linear search of an R-Tree node. This should be 
130631       ** considered almost as quick as a direct rowid lookup (for which 
130632       ** sqlcipher uses an internal cost of 0.0).
130633       */ 
130634       pIdxInfo->estimatedCost = 10.0;
130635       return SQLCIPHER_OK;
130636     }
130637
130638     if( p->usable && (p->iColumn>0 || p->op==SQLCIPHER_INDEX_CONSTRAINT_MATCH) ){
130639       u8 op;
130640       switch( p->op ){
130641         case SQLCIPHER_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break;
130642         case SQLCIPHER_INDEX_CONSTRAINT_GT: op = RTREE_GT; break;
130643         case SQLCIPHER_INDEX_CONSTRAINT_LE: op = RTREE_LE; break;
130644         case SQLCIPHER_INDEX_CONSTRAINT_LT: op = RTREE_LT; break;
130645         case SQLCIPHER_INDEX_CONSTRAINT_GE: op = RTREE_GE; break;
130646         default:
130647           assert( p->op==SQLCIPHER_INDEX_CONSTRAINT_MATCH );
130648           op = RTREE_MATCH; 
130649           break;
130650       }
130651       zIdxStr[iIdx++] = op;
130652       zIdxStr[iIdx++] = p->iColumn - 1 + 'a';
130653       pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2);
130654       pIdxInfo->aConstraintUsage[ii].omit = 1;
130655     }
130656   }
130657
130658   pIdxInfo->idxNum = 2;
130659   pIdxInfo->needToFreeIdxStr = 1;
130660   if( iIdx>0 && 0==(pIdxInfo->idxStr = sqlcipher3_mprintf("%s", zIdxStr)) ){
130661     return SQLCIPHER_NOMEM;
130662   }
130663   assert( iIdx>=0 );
130664   pIdxInfo->estimatedCost = (2000000.0 / (double)(iIdx + 1));
130665   return rc;
130666 }
130667
130668 /*
130669 ** Return the N-dimensional volumn of the cell stored in *p.
130670 */
130671 static float cellArea(Rtree *pRtree, RtreeCell *p){
130672   float area = 1.0;
130673   int ii;
130674   for(ii=0; ii<(pRtree->nDim*2); ii+=2){
130675     area = (float)(area * (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii])));
130676   }
130677   return area;
130678 }
130679
130680 /*
130681 ** Return the margin length of cell p. The margin length is the sum
130682 ** of the objects size in each dimension.
130683 */
130684 static float cellMargin(Rtree *pRtree, RtreeCell *p){
130685   float margin = 0.0;
130686   int ii;
130687   for(ii=0; ii<(pRtree->nDim*2); ii+=2){
130688     margin += (float)(DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii]));
130689   }
130690   return margin;
130691 }
130692
130693 /*
130694 ** Store the union of cells p1 and p2 in p1.
130695 */
130696 static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
130697   int ii;
130698   if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
130699     for(ii=0; ii<(pRtree->nDim*2); ii+=2){
130700       p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f);
130701       p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f);
130702     }
130703   }else{
130704     for(ii=0; ii<(pRtree->nDim*2); ii+=2){
130705       p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i);
130706       p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i);
130707     }
130708   }
130709 }
130710
130711 /*
130712 ** Return true if the area covered by p2 is a subset of the area covered
130713 ** by p1. False otherwise.
130714 */
130715 static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
130716   int ii;
130717   int isInt = (pRtree->eCoordType==RTREE_COORD_INT32);
130718   for(ii=0; ii<(pRtree->nDim*2); ii+=2){
130719     RtreeCoord *a1 = &p1->aCoord[ii];
130720     RtreeCoord *a2 = &p2->aCoord[ii];
130721     if( (!isInt && (a2[0].f<a1[0].f || a2[1].f>a1[1].f)) 
130722      || ( isInt && (a2[0].i<a1[0].i || a2[1].i>a1[1].i)) 
130723     ){
130724       return 0;
130725     }
130726   }
130727   return 1;
130728 }
130729
130730 /*
130731 ** Return the amount cell p would grow by if it were unioned with pCell.
130732 */
130733 static float cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
130734   float area;
130735   RtreeCell cell;
130736   memcpy(&cell, p, sizeof(RtreeCell));
130737   area = cellArea(pRtree, &cell);
130738   cellUnion(pRtree, &cell, pCell);
130739   return (cellArea(pRtree, &cell)-area);
130740 }
130741
130742 #if VARIANT_RSTARTREE_CHOOSESUBTREE || VARIANT_RSTARTREE_SPLIT
130743 static float cellOverlap(
130744   Rtree *pRtree, 
130745   RtreeCell *p, 
130746   RtreeCell *aCell, 
130747   int nCell, 
130748   int iExclude
130749 ){
130750   int ii;
130751   float overlap = 0.0;
130752   for(ii=0; ii<nCell; ii++){
130753 #if VARIANT_RSTARTREE_CHOOSESUBTREE
130754     if( ii!=iExclude )
130755 #else
130756     assert( iExclude==-1 );
130757     UNUSED_PARAMETER(iExclude);
130758 #endif
130759     {
130760       int jj;
130761       float o = 1.0;
130762       for(jj=0; jj<(pRtree->nDim*2); jj+=2){
130763         double x1;
130764         double x2;
130765
130766         x1 = MAX(DCOORD(p->aCoord[jj]), DCOORD(aCell[ii].aCoord[jj]));
130767         x2 = MIN(DCOORD(p->aCoord[jj+1]), DCOORD(aCell[ii].aCoord[jj+1]));
130768
130769         if( x2<x1 ){
130770           o = 0.0;
130771           break;
130772         }else{
130773           o = o * (float)(x2-x1);
130774         }
130775       }
130776       overlap += o;
130777     }
130778   }
130779   return overlap;
130780 }
130781 #endif
130782
130783 #if VARIANT_RSTARTREE_CHOOSESUBTREE
130784 static float cellOverlapEnlargement(
130785   Rtree *pRtree, 
130786   RtreeCell *p, 
130787   RtreeCell *pInsert, 
130788   RtreeCell *aCell, 
130789   int nCell, 
130790   int iExclude
130791 ){
130792   double before;
130793   double after;
130794   before = cellOverlap(pRtree, p, aCell, nCell, iExclude);
130795   cellUnion(pRtree, p, pInsert);
130796   after = cellOverlap(pRtree, p, aCell, nCell, iExclude);
130797   return (float)(after-before);
130798 }
130799 #endif
130800
130801
130802 /*
130803 ** This function implements the ChooseLeaf algorithm from Gutman[84].
130804 ** ChooseSubTree in r*tree terminology.
130805 */
130806 static int ChooseLeaf(
130807   Rtree *pRtree,               /* Rtree table */
130808   RtreeCell *pCell,            /* Cell to insert into rtree */
130809   int iHeight,                 /* Height of sub-tree rooted at pCell */
130810   RtreeNode **ppLeaf           /* OUT: Selected leaf page */
130811 ){
130812   int rc;
130813   int ii;
130814   RtreeNode *pNode;
130815   rc = nodeAcquire(pRtree, 1, 0, &pNode);
130816
130817   for(ii=0; rc==SQLCIPHER_OK && ii<(pRtree->iDepth-iHeight); ii++){
130818     int iCell;
130819     sqlcipher3_int64 iBest = 0;
130820
130821     float fMinGrowth = 0.0;
130822     float fMinArea = 0.0;
130823 #if VARIANT_RSTARTREE_CHOOSESUBTREE
130824     float fMinOverlap = 0.0;
130825     float overlap;
130826 #endif
130827
130828     int nCell = NCELL(pNode);
130829     RtreeCell cell;
130830     RtreeNode *pChild;
130831
130832     RtreeCell *aCell = 0;
130833
130834 #if VARIANT_RSTARTREE_CHOOSESUBTREE
130835     if( ii==(pRtree->iDepth-1) ){
130836       int jj;
130837       aCell = sqlcipher3_malloc(sizeof(RtreeCell)*nCell);
130838       if( !aCell ){
130839         rc = SQLCIPHER_NOMEM;
130840         nodeRelease(pRtree, pNode);
130841         pNode = 0;
130842         continue;
130843       }
130844       for(jj=0; jj<nCell; jj++){
130845         nodeGetCell(pRtree, pNode, jj, &aCell[jj]);
130846       }
130847     }
130848 #endif
130849
130850     /* Select the child node which will be enlarged the least if pCell
130851     ** is inserted into it. Resolve ties by choosing the entry with
130852     ** the smallest area.
130853     */
130854     for(iCell=0; iCell<nCell; iCell++){
130855       int bBest = 0;
130856       float growth;
130857       float area;
130858       nodeGetCell(pRtree, pNode, iCell, &cell);
130859       growth = cellGrowth(pRtree, &cell, pCell);
130860       area = cellArea(pRtree, &cell);
130861
130862 #if VARIANT_RSTARTREE_CHOOSESUBTREE
130863       if( ii==(pRtree->iDepth-1) ){
130864         overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
130865       }else{
130866         overlap = 0.0;
130867       }
130868       if( (iCell==0) 
130869        || (overlap<fMinOverlap) 
130870        || (overlap==fMinOverlap && growth<fMinGrowth)
130871        || (overlap==fMinOverlap && growth==fMinGrowth && area<fMinArea)
130872       ){
130873         bBest = 1;
130874         fMinOverlap = overlap;
130875       }
130876 #else
130877       if( iCell==0||growth<fMinGrowth||(growth==fMinGrowth && area<fMinArea) ){
130878         bBest = 1;
130879       }
130880 #endif
130881       if( bBest ){
130882         fMinGrowth = growth;
130883         fMinArea = area;
130884         iBest = cell.iRowid;
130885       }
130886     }
130887
130888     sqlcipher3_free(aCell);
130889     rc = nodeAcquire(pRtree, iBest, pNode, &pChild);
130890     nodeRelease(pRtree, pNode);
130891     pNode = pChild;
130892   }
130893
130894   *ppLeaf = pNode;
130895   return rc;
130896 }
130897
130898 /*
130899 ** A cell with the same content as pCell has just been inserted into
130900 ** the node pNode. This function updates the bounding box cells in
130901 ** all ancestor elements.
130902 */
130903 static int AdjustTree(
130904   Rtree *pRtree,                    /* Rtree table */
130905   RtreeNode *pNode,                 /* Adjust ancestry of this node. */
130906   RtreeCell *pCell                  /* This cell was just inserted */
130907 ){
130908   RtreeNode *p = pNode;
130909   while( p->pParent ){
130910     RtreeNode *pParent = p->pParent;
130911     RtreeCell cell;
130912     int iCell;
130913
130914     if( nodeParentIndex(pRtree, p, &iCell) ){
130915       return SQLCIPHER_CORRUPT_VTAB;
130916     }
130917
130918     nodeGetCell(pRtree, pParent, iCell, &cell);
130919     if( !cellContains(pRtree, &cell, pCell) ){
130920       cellUnion(pRtree, &cell, pCell);
130921       nodeOverwriteCell(pRtree, pParent, &cell, iCell);
130922     }
130923  
130924     p = pParent;
130925   }
130926   return SQLCIPHER_OK;
130927 }
130928
130929 /*
130930 ** Write mapping (iRowid->iNode) to the <rtree>_rowid table.
130931 */
130932 static int rowidWrite(Rtree *pRtree, sqlcipher3_int64 iRowid, sqlcipher3_int64 iNode){
130933   sqlcipher3_bind_int64(pRtree->pWriteRowid, 1, iRowid);
130934   sqlcipher3_bind_int64(pRtree->pWriteRowid, 2, iNode);
130935   sqlcipher3_step(pRtree->pWriteRowid);
130936   return sqlcipher3_reset(pRtree->pWriteRowid);
130937 }
130938
130939 /*
130940 ** Write mapping (iNode->iPar) to the <rtree>_parent table.
130941 */
130942 static int parentWrite(Rtree *pRtree, sqlcipher3_int64 iNode, sqlcipher3_int64 iPar){
130943   sqlcipher3_bind_int64(pRtree->pWriteParent, 1, iNode);
130944   sqlcipher3_bind_int64(pRtree->pWriteParent, 2, iPar);
130945   sqlcipher3_step(pRtree->pWriteParent);
130946   return sqlcipher3_reset(pRtree->pWriteParent);
130947 }
130948
130949 static int rtreeInsertCell(Rtree *, RtreeNode *, RtreeCell *, int);
130950
130951 #if VARIANT_GUTTMAN_LINEAR_SPLIT
130952 /*
130953 ** Implementation of the linear variant of the PickNext() function from
130954 ** Guttman[84].
130955 */
130956 static RtreeCell *LinearPickNext(
130957   Rtree *pRtree,
130958   RtreeCell *aCell, 
130959   int nCell, 
130960   RtreeCell *pLeftBox, 
130961   RtreeCell *pRightBox,
130962   int *aiUsed
130963 ){
130964   int ii;
130965   for(ii=0; aiUsed[ii]; ii++);
130966   aiUsed[ii] = 1;
130967   return &aCell[ii];
130968 }
130969
130970 /*
130971 ** Implementation of the linear variant of the PickSeeds() function from
130972 ** Guttman[84].
130973 */
130974 static void LinearPickSeeds(
130975   Rtree *pRtree,
130976   RtreeCell *aCell, 
130977   int nCell, 
130978   int *piLeftSeed, 
130979   int *piRightSeed
130980 ){
130981   int i;
130982   int iLeftSeed = 0;
130983   int iRightSeed = 1;
130984   float maxNormalInnerWidth = 0.0;
130985
130986   /* Pick two "seed" cells from the array of cells. The algorithm used
130987   ** here is the LinearPickSeeds algorithm from Gutman[1984]. The 
130988   ** indices of the two seed cells in the array are stored in local
130989   ** variables iLeftSeek and iRightSeed.
130990   */
130991   for(i=0; i<pRtree->nDim; i++){
130992     float x1 = DCOORD(aCell[0].aCoord[i*2]);
130993     float x2 = DCOORD(aCell[0].aCoord[i*2+1]);
130994     float x3 = x1;
130995     float x4 = x2;
130996     int jj;
130997
130998     int iCellLeft = 0;
130999     int iCellRight = 0;
131000
131001     for(jj=1; jj<nCell; jj++){
131002       float left = DCOORD(aCell[jj].aCoord[i*2]);
131003       float right = DCOORD(aCell[jj].aCoord[i*2+1]);
131004
131005       if( left<x1 ) x1 = left;
131006       if( right>x4 ) x4 = right;
131007       if( left>x3 ){
131008         x3 = left;
131009         iCellRight = jj;
131010       }
131011       if( right<x2 ){
131012         x2 = right;
131013         iCellLeft = jj;
131014       }
131015     }
131016
131017     if( x4!=x1 ){
131018       float normalwidth = (x3 - x2) / (x4 - x1);
131019       if( normalwidth>maxNormalInnerWidth ){
131020         iLeftSeed = iCellLeft;
131021         iRightSeed = iCellRight;
131022       }
131023     }
131024   }
131025
131026   *piLeftSeed = iLeftSeed;
131027   *piRightSeed = iRightSeed;
131028 }
131029 #endif /* VARIANT_GUTTMAN_LINEAR_SPLIT */
131030
131031 #if VARIANT_GUTTMAN_QUADRATIC_SPLIT
131032 /*
131033 ** Implementation of the quadratic variant of the PickNext() function from
131034 ** Guttman[84].
131035 */
131036 static RtreeCell *QuadraticPickNext(
131037   Rtree *pRtree,
131038   RtreeCell *aCell, 
131039   int nCell, 
131040   RtreeCell *pLeftBox, 
131041   RtreeCell *pRightBox,
131042   int *aiUsed
131043 ){
131044   #define FABS(a) ((a)<0.0?-1.0*(a):(a))
131045
131046   int iSelect = -1;
131047   float fDiff;
131048   int ii;
131049   for(ii=0; ii<nCell; ii++){
131050     if( aiUsed[ii]==0 ){
131051       float left = cellGrowth(pRtree, pLeftBox, &aCell[ii]);
131052       float right = cellGrowth(pRtree, pLeftBox, &aCell[ii]);
131053       float diff = FABS(right-left);
131054       if( iSelect<0 || diff>fDiff ){
131055         fDiff = diff;
131056         iSelect = ii;
131057       }
131058     }
131059   }
131060   aiUsed[iSelect] = 1;
131061   return &aCell[iSelect];
131062 }
131063
131064 /*
131065 ** Implementation of the quadratic variant of the PickSeeds() function from
131066 ** Guttman[84].
131067 */
131068 static void QuadraticPickSeeds(
131069   Rtree *pRtree,
131070   RtreeCell *aCell, 
131071   int nCell, 
131072   int *piLeftSeed, 
131073   int *piRightSeed
131074 ){
131075   int ii;
131076   int jj;
131077
131078   int iLeftSeed = 0;
131079   int iRightSeed = 1;
131080   float fWaste = 0.0;
131081
131082   for(ii=0; ii<nCell; ii++){
131083     for(jj=ii+1; jj<nCell; jj++){
131084       float right = cellArea(pRtree, &aCell[jj]);
131085       float growth = cellGrowth(pRtree, &aCell[ii], &aCell[jj]);
131086       float waste = growth - right;
131087
131088       if( waste>fWaste ){
131089         iLeftSeed = ii;
131090         iRightSeed = jj;
131091         fWaste = waste;
131092       }
131093     }
131094   }
131095
131096   *piLeftSeed = iLeftSeed;
131097   *piRightSeed = iRightSeed;
131098 }
131099 #endif /* VARIANT_GUTTMAN_QUADRATIC_SPLIT */
131100
131101 /*
131102 ** Arguments aIdx, aDistance and aSpare all point to arrays of size
131103 ** nIdx. The aIdx array contains the set of integers from 0 to 
131104 ** (nIdx-1) in no particular order. This function sorts the values
131105 ** in aIdx according to the indexed values in aDistance. For
131106 ** example, assuming the inputs:
131107 **
131108 **   aIdx      = { 0,   1,   2,   3 }
131109 **   aDistance = { 5.0, 2.0, 7.0, 6.0 }
131110 **
131111 ** this function sets the aIdx array to contain:
131112 **
131113 **   aIdx      = { 0,   1,   2,   3 }
131114 **
131115 ** The aSpare array is used as temporary working space by the
131116 ** sorting algorithm.
131117 */
131118 static void SortByDistance(
131119   int *aIdx, 
131120   int nIdx, 
131121   float *aDistance, 
131122   int *aSpare
131123 ){
131124   if( nIdx>1 ){
131125     int iLeft = 0;
131126     int iRight = 0;
131127
131128     int nLeft = nIdx/2;
131129     int nRight = nIdx-nLeft;
131130     int *aLeft = aIdx;
131131     int *aRight = &aIdx[nLeft];
131132
131133     SortByDistance(aLeft, nLeft, aDistance, aSpare);
131134     SortByDistance(aRight, nRight, aDistance, aSpare);
131135
131136     memcpy(aSpare, aLeft, sizeof(int)*nLeft);
131137     aLeft = aSpare;
131138
131139     while( iLeft<nLeft || iRight<nRight ){
131140       if( iLeft==nLeft ){
131141         aIdx[iLeft+iRight] = aRight[iRight];
131142         iRight++;
131143       }else if( iRight==nRight ){
131144         aIdx[iLeft+iRight] = aLeft[iLeft];
131145         iLeft++;
131146       }else{
131147         float fLeft = aDistance[aLeft[iLeft]];
131148         float fRight = aDistance[aRight[iRight]];
131149         if( fLeft<fRight ){
131150           aIdx[iLeft+iRight] = aLeft[iLeft];
131151           iLeft++;
131152         }else{
131153           aIdx[iLeft+iRight] = aRight[iRight];
131154           iRight++;
131155         }
131156       }
131157     }
131158
131159 #if 0
131160     /* Check that the sort worked */
131161     {
131162       int jj;
131163       for(jj=1; jj<nIdx; jj++){
131164         float left = aDistance[aIdx[jj-1]];
131165         float right = aDistance[aIdx[jj]];
131166         assert( left<=right );
131167       }
131168     }
131169 #endif
131170   }
131171 }
131172
131173 /*
131174 ** Arguments aIdx, aCell and aSpare all point to arrays of size
131175 ** nIdx. The aIdx array contains the set of integers from 0 to 
131176 ** (nIdx-1) in no particular order. This function sorts the values
131177 ** in aIdx according to dimension iDim of the cells in aCell. The
131178 ** minimum value of dimension iDim is considered first, the
131179 ** maximum used to break ties.
131180 **
131181 ** The aSpare array is used as temporary working space by the
131182 ** sorting algorithm.
131183 */
131184 static void SortByDimension(
131185   Rtree *pRtree,
131186   int *aIdx, 
131187   int nIdx, 
131188   int iDim, 
131189   RtreeCell *aCell, 
131190   int *aSpare
131191 ){
131192   if( nIdx>1 ){
131193
131194     int iLeft = 0;
131195     int iRight = 0;
131196
131197     int nLeft = nIdx/2;
131198     int nRight = nIdx-nLeft;
131199     int *aLeft = aIdx;
131200     int *aRight = &aIdx[nLeft];
131201
131202     SortByDimension(pRtree, aLeft, nLeft, iDim, aCell, aSpare);
131203     SortByDimension(pRtree, aRight, nRight, iDim, aCell, aSpare);
131204
131205     memcpy(aSpare, aLeft, sizeof(int)*nLeft);
131206     aLeft = aSpare;
131207     while( iLeft<nLeft || iRight<nRight ){
131208       double xleft1 = DCOORD(aCell[aLeft[iLeft]].aCoord[iDim*2]);
131209       double xleft2 = DCOORD(aCell[aLeft[iLeft]].aCoord[iDim*2+1]);
131210       double xright1 = DCOORD(aCell[aRight[iRight]].aCoord[iDim*2]);
131211       double xright2 = DCOORD(aCell[aRight[iRight]].aCoord[iDim*2+1]);
131212       if( (iLeft!=nLeft) && ((iRight==nRight)
131213        || (xleft1<xright1)
131214        || (xleft1==xright1 && xleft2<xright2)
131215       )){
131216         aIdx[iLeft+iRight] = aLeft[iLeft];
131217         iLeft++;
131218       }else{
131219         aIdx[iLeft+iRight] = aRight[iRight];
131220         iRight++;
131221       }
131222     }
131223
131224 #if 0
131225     /* Check that the sort worked */
131226     {
131227       int jj;
131228       for(jj=1; jj<nIdx; jj++){
131229         float xleft1 = aCell[aIdx[jj-1]].aCoord[iDim*2];
131230         float xleft2 = aCell[aIdx[jj-1]].aCoord[iDim*2+1];
131231         float xright1 = aCell[aIdx[jj]].aCoord[iDim*2];
131232         float xright2 = aCell[aIdx[jj]].aCoord[iDim*2+1];
131233         assert( xleft1<=xright1 && (xleft1<xright1 || xleft2<=xright2) );
131234       }
131235     }
131236 #endif
131237   }
131238 }
131239
131240 #if VARIANT_RSTARTREE_SPLIT
131241 /*
131242 ** Implementation of the R*-tree variant of SplitNode from Beckman[1990].
131243 */
131244 static int splitNodeStartree(
131245   Rtree *pRtree,
131246   RtreeCell *aCell,
131247   int nCell,
131248   RtreeNode *pLeft,
131249   RtreeNode *pRight,
131250   RtreeCell *pBboxLeft,
131251   RtreeCell *pBboxRight
131252 ){
131253   int **aaSorted;
131254   int *aSpare;
131255   int ii;
131256
131257   int iBestDim = 0;
131258   int iBestSplit = 0;
131259   float fBestMargin = 0.0;
131260
131261   int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
131262
131263   aaSorted = (int **)sqlcipher3_malloc(nByte);
131264   if( !aaSorted ){
131265     return SQLCIPHER_NOMEM;
131266   }
131267
131268   aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell];
131269   memset(aaSorted, 0, nByte);
131270   for(ii=0; ii<pRtree->nDim; ii++){
131271     int jj;
131272     aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell];
131273     for(jj=0; jj<nCell; jj++){
131274       aaSorted[ii][jj] = jj;
131275     }
131276     SortByDimension(pRtree, aaSorted[ii], nCell, ii, aCell, aSpare);
131277   }
131278
131279   for(ii=0; ii<pRtree->nDim; ii++){
131280     float margin = 0.0;
131281     float fBestOverlap = 0.0;
131282     float fBestArea = 0.0;
131283     int iBestLeft = 0;
131284     int nLeft;
131285
131286     for(
131287       nLeft=RTREE_MINCELLS(pRtree); 
131288       nLeft<=(nCell-RTREE_MINCELLS(pRtree)); 
131289       nLeft++
131290     ){
131291       RtreeCell left;
131292       RtreeCell right;
131293       int kk;
131294       float overlap;
131295       float area;
131296
131297       memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell));
131298       memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
131299       for(kk=1; kk<(nCell-1); kk++){
131300         if( kk<nLeft ){
131301           cellUnion(pRtree, &left, &aCell[aaSorted[ii][kk]]);
131302         }else{
131303           cellUnion(pRtree, &right, &aCell[aaSorted[ii][kk]]);
131304         }
131305       }
131306       margin += cellMargin(pRtree, &left);
131307       margin += cellMargin(pRtree, &right);
131308       overlap = cellOverlap(pRtree, &left, &right, 1, -1);
131309       area = cellArea(pRtree, &left) + cellArea(pRtree, &right);
131310       if( (nLeft==RTREE_MINCELLS(pRtree))
131311        || (overlap<fBestOverlap)
131312        || (overlap==fBestOverlap && area<fBestArea)
131313       ){
131314         iBestLeft = nLeft;
131315         fBestOverlap = overlap;
131316         fBestArea = area;
131317       }
131318     }
131319
131320     if( ii==0 || margin<fBestMargin ){
131321       iBestDim = ii;
131322       fBestMargin = margin;
131323       iBestSplit = iBestLeft;
131324     }
131325   }
131326
131327   memcpy(pBboxLeft, &aCell[aaSorted[iBestDim][0]], sizeof(RtreeCell));
131328   memcpy(pBboxRight, &aCell[aaSorted[iBestDim][iBestSplit]], sizeof(RtreeCell));
131329   for(ii=0; ii<nCell; ii++){
131330     RtreeNode *pTarget = (ii<iBestSplit)?pLeft:pRight;
131331     RtreeCell *pBbox = (ii<iBestSplit)?pBboxLeft:pBboxRight;
131332     RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
131333     nodeInsertCell(pRtree, pTarget, pCell);
131334     cellUnion(pRtree, pBbox, pCell);
131335   }
131336
131337   sqlcipher3_free(aaSorted);
131338   return SQLCIPHER_OK;
131339 }
131340 #endif
131341
131342 #if VARIANT_GUTTMAN_SPLIT
131343 /*
131344 ** Implementation of the regular R-tree SplitNode from Guttman[1984].
131345 */
131346 static int splitNodeGuttman(
131347   Rtree *pRtree,
131348   RtreeCell *aCell,
131349   int nCell,
131350   RtreeNode *pLeft,
131351   RtreeNode *pRight,
131352   RtreeCell *pBboxLeft,
131353   RtreeCell *pBboxRight
131354 ){
131355   int iLeftSeed = 0;
131356   int iRightSeed = 1;
131357   int *aiUsed;
131358   int i;
131359
131360   aiUsed = sqlcipher3_malloc(sizeof(int)*nCell);
131361   if( !aiUsed ){
131362     return SQLCIPHER_NOMEM;
131363   }
131364   memset(aiUsed, 0, sizeof(int)*nCell);
131365
131366   PickSeeds(pRtree, aCell, nCell, &iLeftSeed, &iRightSeed);
131367
131368   memcpy(pBboxLeft, &aCell[iLeftSeed], sizeof(RtreeCell));
131369   memcpy(pBboxRight, &aCell[iRightSeed], sizeof(RtreeCell));
131370   nodeInsertCell(pRtree, pLeft, &aCell[iLeftSeed]);
131371   nodeInsertCell(pRtree, pRight, &aCell[iRightSeed]);
131372   aiUsed[iLeftSeed] = 1;
131373   aiUsed[iRightSeed] = 1;
131374
131375   for(i=nCell-2; i>0; i--){
131376     RtreeCell *pNext;
131377     pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
131378     float diff =  
131379       cellGrowth(pRtree, pBboxLeft, pNext) - 
131380       cellGrowth(pRtree, pBboxRight, pNext)
131381     ;
131382     if( (RTREE_MINCELLS(pRtree)-NCELL(pRight)==i)
131383      || (diff>0.0 && (RTREE_MINCELLS(pRtree)-NCELL(pLeft)!=i))
131384     ){
131385       nodeInsertCell(pRtree, pRight, pNext);
131386       cellUnion(pRtree, pBboxRight, pNext);
131387     }else{
131388       nodeInsertCell(pRtree, pLeft, pNext);
131389       cellUnion(pRtree, pBboxLeft, pNext);
131390     }
131391   }
131392
131393   sqlcipher3_free(aiUsed);
131394   return SQLCIPHER_OK;
131395 }
131396 #endif
131397
131398 static int updateMapping(
131399   Rtree *pRtree, 
131400   i64 iRowid, 
131401   RtreeNode *pNode, 
131402   int iHeight
131403 ){
131404   int (*xSetMapping)(Rtree *, sqlcipher3_int64, sqlcipher3_int64);
131405   xSetMapping = ((iHeight==0)?rowidWrite:parentWrite);
131406   if( iHeight>0 ){
131407     RtreeNode *pChild = nodeHashLookup(pRtree, iRowid);
131408     if( pChild ){
131409       nodeRelease(pRtree, pChild->pParent);
131410       nodeReference(pNode);
131411       pChild->pParent = pNode;
131412     }
131413   }
131414   return xSetMapping(pRtree, iRowid, pNode->iNode);
131415 }
131416
131417 static int SplitNode(
131418   Rtree *pRtree,
131419   RtreeNode *pNode,
131420   RtreeCell *pCell,
131421   int iHeight
131422 ){
131423   int i;
131424   int newCellIsRight = 0;
131425
131426   int rc = SQLCIPHER_OK;
131427   int nCell = NCELL(pNode);
131428   RtreeCell *aCell;
131429   int *aiUsed;
131430
131431   RtreeNode *pLeft = 0;
131432   RtreeNode *pRight = 0;
131433
131434   RtreeCell leftbbox;
131435   RtreeCell rightbbox;
131436
131437   /* Allocate an array and populate it with a copy of pCell and 
131438   ** all cells from node pLeft. Then zero the original node.
131439   */
131440   aCell = sqlcipher3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
131441   if( !aCell ){
131442     rc = SQLCIPHER_NOMEM;
131443     goto splitnode_out;
131444   }
131445   aiUsed = (int *)&aCell[nCell+1];
131446   memset(aiUsed, 0, sizeof(int)*(nCell+1));
131447   for(i=0; i<nCell; i++){
131448     nodeGetCell(pRtree, pNode, i, &aCell[i]);
131449   }
131450   nodeZero(pRtree, pNode);
131451   memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
131452   nCell++;
131453
131454   if( pNode->iNode==1 ){
131455     pRight = nodeNew(pRtree, pNode);
131456     pLeft = nodeNew(pRtree, pNode);
131457     pRtree->iDepth++;
131458     pNode->isDirty = 1;
131459     writeInt16(pNode->zData, pRtree->iDepth);
131460   }else{
131461     pLeft = pNode;
131462     pRight = nodeNew(pRtree, pLeft->pParent);
131463     nodeReference(pLeft);
131464   }
131465
131466   if( !pLeft || !pRight ){
131467     rc = SQLCIPHER_NOMEM;
131468     goto splitnode_out;
131469   }
131470
131471   memset(pLeft->zData, 0, pRtree->iNodeSize);
131472   memset(pRight->zData, 0, pRtree->iNodeSize);
131473
131474   rc = AssignCells(pRtree, aCell, nCell, pLeft, pRight, &leftbbox, &rightbbox);
131475   if( rc!=SQLCIPHER_OK ){
131476     goto splitnode_out;
131477   }
131478
131479   /* Ensure both child nodes have node numbers assigned to them by calling
131480   ** nodeWrite(). Node pRight always needs a node number, as it was created
131481   ** by nodeNew() above. But node pLeft sometimes already has a node number.
131482   ** In this case avoid the all to nodeWrite().
131483   */
131484   if( SQLCIPHER_OK!=(rc = nodeWrite(pRtree, pRight))
131485    || (0==pLeft->iNode && SQLCIPHER_OK!=(rc = nodeWrite(pRtree, pLeft)))
131486   ){
131487     goto splitnode_out;
131488   }
131489
131490   rightbbox.iRowid = pRight->iNode;
131491   leftbbox.iRowid = pLeft->iNode;
131492
131493   if( pNode->iNode==1 ){
131494     rc = rtreeInsertCell(pRtree, pLeft->pParent, &leftbbox, iHeight+1);
131495     if( rc!=SQLCIPHER_OK ){
131496       goto splitnode_out;
131497     }
131498   }else{
131499     RtreeNode *pParent = pLeft->pParent;
131500     int iCell;
131501     rc = nodeParentIndex(pRtree, pLeft, &iCell);
131502     if( rc==SQLCIPHER_OK ){
131503       nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell);
131504       rc = AdjustTree(pRtree, pParent, &leftbbox);
131505     }
131506     if( rc!=SQLCIPHER_OK ){
131507       goto splitnode_out;
131508     }
131509   }
131510   if( (rc = rtreeInsertCell(pRtree, pRight->pParent, &rightbbox, iHeight+1)) ){
131511     goto splitnode_out;
131512   }
131513
131514   for(i=0; i<NCELL(pRight); i++){
131515     i64 iRowid = nodeGetRowid(pRtree, pRight, i);
131516     rc = updateMapping(pRtree, iRowid, pRight, iHeight);
131517     if( iRowid==pCell->iRowid ){
131518       newCellIsRight = 1;
131519     }
131520     if( rc!=SQLCIPHER_OK ){
131521       goto splitnode_out;
131522     }
131523   }
131524   if( pNode->iNode==1 ){
131525     for(i=0; i<NCELL(pLeft); i++){
131526       i64 iRowid = nodeGetRowid(pRtree, pLeft, i);
131527       rc = updateMapping(pRtree, iRowid, pLeft, iHeight);
131528       if( rc!=SQLCIPHER_OK ){
131529         goto splitnode_out;
131530       }
131531     }
131532   }else if( newCellIsRight==0 ){
131533     rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
131534   }
131535
131536   if( rc==SQLCIPHER_OK ){
131537     rc = nodeRelease(pRtree, pRight);
131538     pRight = 0;
131539   }
131540   if( rc==SQLCIPHER_OK ){
131541     rc = nodeRelease(pRtree, pLeft);
131542     pLeft = 0;
131543   }
131544
131545 splitnode_out:
131546   nodeRelease(pRtree, pRight);
131547   nodeRelease(pRtree, pLeft);
131548   sqlcipher3_free(aCell);
131549   return rc;
131550 }
131551
131552 /*
131553 ** If node pLeaf is not the root of the r-tree and its pParent pointer is 
131554 ** still NULL, load all ancestor nodes of pLeaf into memory and populate
131555 ** the pLeaf->pParent chain all the way up to the root node.
131556 **
131557 ** This operation is required when a row is deleted (or updated - an update
131558 ** is implemented as a delete followed by an insert). SQLite provides the
131559 ** rowid of the row to delete, which can be used to find the leaf on which
131560 ** the entry resides (argument pLeaf). Once the leaf is located, this 
131561 ** function is called to determine its ancestry.
131562 */
131563 static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){
131564   int rc = SQLCIPHER_OK;
131565   RtreeNode *pChild = pLeaf;
131566   while( rc==SQLCIPHER_OK && pChild->iNode!=1 && pChild->pParent==0 ){
131567     int rc2 = SQLCIPHER_OK;          /* sqlcipher3_reset() return code */
131568     sqlcipher3_bind_int64(pRtree->pReadParent, 1, pChild->iNode);
131569     rc = sqlcipher3_step(pRtree->pReadParent);
131570     if( rc==SQLCIPHER_ROW ){
131571       RtreeNode *pTest;           /* Used to test for reference loops */
131572       i64 iNode;                  /* Node number of parent node */
131573
131574       /* Before setting pChild->pParent, test that we are not creating a
131575       ** loop of references (as we would if, say, pChild==pParent). We don't
131576       ** want to do this as it leads to a memory leak when trying to delete
131577       ** the referenced counted node structures.
131578       */
131579       iNode = sqlcipher3_column_int64(pRtree->pReadParent, 0);
131580       for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent);
131581       if( !pTest ){
131582         rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent);
131583       }
131584     }
131585     rc = sqlcipher3_reset(pRtree->pReadParent);
131586     if( rc==SQLCIPHER_OK ) rc = rc2;
131587     if( rc==SQLCIPHER_OK && !pChild->pParent ) rc = SQLCIPHER_CORRUPT_VTAB;
131588     pChild = pChild->pParent;
131589   }
131590   return rc;
131591 }
131592
131593 static int deleteCell(Rtree *, RtreeNode *, int, int);
131594
131595 static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){
131596   int rc;
131597   int rc2;
131598   RtreeNode *pParent = 0;
131599   int iCell;
131600
131601   assert( pNode->nRef==1 );
131602
131603   /* Remove the entry in the parent cell. */
131604   rc = nodeParentIndex(pRtree, pNode, &iCell);
131605   if( rc==SQLCIPHER_OK ){
131606     pParent = pNode->pParent;
131607     pNode->pParent = 0;
131608     rc = deleteCell(pRtree, pParent, iCell, iHeight+1);
131609   }
131610   rc2 = nodeRelease(pRtree, pParent);
131611   if( rc==SQLCIPHER_OK ){
131612     rc = rc2;
131613   }
131614   if( rc!=SQLCIPHER_OK ){
131615     return rc;
131616   }
131617
131618   /* Remove the xxx_node entry. */
131619   sqlcipher3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode);
131620   sqlcipher3_step(pRtree->pDeleteNode);
131621   if( SQLCIPHER_OK!=(rc = sqlcipher3_reset(pRtree->pDeleteNode)) ){
131622     return rc;
131623   }
131624
131625   /* Remove the xxx_parent entry. */
131626   sqlcipher3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode);
131627   sqlcipher3_step(pRtree->pDeleteParent);
131628   if( SQLCIPHER_OK!=(rc = sqlcipher3_reset(pRtree->pDeleteParent)) ){
131629     return rc;
131630   }
131631   
131632   /* Remove the node from the in-memory hash table and link it into
131633   ** the Rtree.pDeleted list. Its contents will be re-inserted later on.
131634   */
131635   nodeHashDelete(pRtree, pNode);
131636   pNode->iNode = iHeight;
131637   pNode->pNext = pRtree->pDeleted;
131638   pNode->nRef++;
131639   pRtree->pDeleted = pNode;
131640
131641   return SQLCIPHER_OK;
131642 }
131643
131644 static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){
131645   RtreeNode *pParent = pNode->pParent;
131646   int rc = SQLCIPHER_OK; 
131647   if( pParent ){
131648     int ii; 
131649     int nCell = NCELL(pNode);
131650     RtreeCell box;                            /* Bounding box for pNode */
131651     nodeGetCell(pRtree, pNode, 0, &box);
131652     for(ii=1; ii<nCell; ii++){
131653       RtreeCell cell;
131654       nodeGetCell(pRtree, pNode, ii, &cell);
131655       cellUnion(pRtree, &box, &cell);
131656     }
131657     box.iRowid = pNode->iNode;
131658     rc = nodeParentIndex(pRtree, pNode, &ii);
131659     if( rc==SQLCIPHER_OK ){
131660       nodeOverwriteCell(pRtree, pParent, &box, ii);
131661       rc = fixBoundingBox(pRtree, pParent);
131662     }
131663   }
131664   return rc;
131665 }
131666
131667 /*
131668 ** Delete the cell at index iCell of node pNode. After removing the
131669 ** cell, adjust the r-tree data structure if required.
131670 */
131671 static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){
131672   RtreeNode *pParent;
131673   int rc;
131674
131675   if( SQLCIPHER_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
131676     return rc;
131677   }
131678
131679   /* Remove the cell from the node. This call just moves bytes around
131680   ** the in-memory node image, so it cannot fail.
131681   */
131682   nodeDeleteCell(pRtree, pNode, iCell);
131683
131684   /* If the node is not the tree root and now has less than the minimum
131685   ** number of cells, remove it from the tree. Otherwise, update the
131686   ** cell in the parent node so that it tightly contains the updated
131687   ** node.
131688   */
131689   pParent = pNode->pParent;
131690   assert( pParent || pNode->iNode==1 );
131691   if( pParent ){
131692     if( NCELL(pNode)<RTREE_MINCELLS(pRtree) ){
131693       rc = removeNode(pRtree, pNode, iHeight);
131694     }else{
131695       rc = fixBoundingBox(pRtree, pNode);
131696     }
131697   }
131698
131699   return rc;
131700 }
131701
131702 static int Reinsert(
131703   Rtree *pRtree, 
131704   RtreeNode *pNode, 
131705   RtreeCell *pCell, 
131706   int iHeight
131707 ){
131708   int *aOrder;
131709   int *aSpare;
131710   RtreeCell *aCell;
131711   float *aDistance;
131712   int nCell;
131713   float aCenterCoord[RTREE_MAX_DIMENSIONS];
131714   int iDim;
131715   int ii;
131716   int rc = SQLCIPHER_OK;
131717
131718   memset(aCenterCoord, 0, sizeof(float)*RTREE_MAX_DIMENSIONS);
131719
131720   nCell = NCELL(pNode)+1;
131721
131722   /* Allocate the buffers used by this operation. The allocation is
131723   ** relinquished before this function returns.
131724   */
131725   aCell = (RtreeCell *)sqlcipher3_malloc(nCell * (
131726     sizeof(RtreeCell) +         /* aCell array */
131727     sizeof(int)       +         /* aOrder array */
131728     sizeof(int)       +         /* aSpare array */
131729     sizeof(float)               /* aDistance array */
131730   ));
131731   if( !aCell ){
131732     return SQLCIPHER_NOMEM;
131733   }
131734   aOrder    = (int *)&aCell[nCell];
131735   aSpare    = (int *)&aOrder[nCell];
131736   aDistance = (float *)&aSpare[nCell];
131737
131738   for(ii=0; ii<nCell; ii++){
131739     if( ii==(nCell-1) ){
131740       memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
131741     }else{
131742       nodeGetCell(pRtree, pNode, ii, &aCell[ii]);
131743     }
131744     aOrder[ii] = ii;
131745     for(iDim=0; iDim<pRtree->nDim; iDim++){
131746       aCenterCoord[iDim] += (float)DCOORD(aCell[ii].aCoord[iDim*2]);
131747       aCenterCoord[iDim] += (float)DCOORD(aCell[ii].aCoord[iDim*2+1]);
131748     }
131749   }
131750   for(iDim=0; iDim<pRtree->nDim; iDim++){
131751     aCenterCoord[iDim] = (float)(aCenterCoord[iDim]/((float)nCell*2.0));
131752   }
131753
131754   for(ii=0; ii<nCell; ii++){
131755     aDistance[ii] = 0.0;
131756     for(iDim=0; iDim<pRtree->nDim; iDim++){
131757       float coord = (float)(DCOORD(aCell[ii].aCoord[iDim*2+1]) - 
131758           DCOORD(aCell[ii].aCoord[iDim*2]));
131759       aDistance[ii] += (coord-aCenterCoord[iDim])*(coord-aCenterCoord[iDim]);
131760     }
131761   }
131762
131763   SortByDistance(aOrder, nCell, aDistance, aSpare);
131764   nodeZero(pRtree, pNode);
131765
131766   for(ii=0; rc==SQLCIPHER_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
131767     RtreeCell *p = &aCell[aOrder[ii]];
131768     nodeInsertCell(pRtree, pNode, p);
131769     if( p->iRowid==pCell->iRowid ){
131770       if( iHeight==0 ){
131771         rc = rowidWrite(pRtree, p->iRowid, pNode->iNode);
131772       }else{
131773         rc = parentWrite(pRtree, p->iRowid, pNode->iNode);
131774       }
131775     }
131776   }
131777   if( rc==SQLCIPHER_OK ){
131778     rc = fixBoundingBox(pRtree, pNode);
131779   }
131780   for(; rc==SQLCIPHER_OK && ii<nCell; ii++){
131781     /* Find a node to store this cell in. pNode->iNode currently contains
131782     ** the height of the sub-tree headed by the cell.
131783     */
131784     RtreeNode *pInsert;
131785     RtreeCell *p = &aCell[aOrder[ii]];
131786     rc = ChooseLeaf(pRtree, p, iHeight, &pInsert);
131787     if( rc==SQLCIPHER_OK ){
131788       int rc2;
131789       rc = rtreeInsertCell(pRtree, pInsert, p, iHeight);
131790       rc2 = nodeRelease(pRtree, pInsert);
131791       if( rc==SQLCIPHER_OK ){
131792         rc = rc2;
131793       }
131794     }
131795   }
131796
131797   sqlcipher3_free(aCell);
131798   return rc;
131799 }
131800
131801 /*
131802 ** Insert cell pCell into node pNode. Node pNode is the head of a 
131803 ** subtree iHeight high (leaf nodes have iHeight==0).
131804 */
131805 static int rtreeInsertCell(
131806   Rtree *pRtree,
131807   RtreeNode *pNode,
131808   RtreeCell *pCell,
131809   int iHeight
131810 ){
131811   int rc = SQLCIPHER_OK;
131812   if( iHeight>0 ){
131813     RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
131814     if( pChild ){
131815       nodeRelease(pRtree, pChild->pParent);
131816       nodeReference(pNode);
131817       pChild->pParent = pNode;
131818     }
131819   }
131820   if( nodeInsertCell(pRtree, pNode, pCell) ){
131821 #if VARIANT_RSTARTREE_REINSERT
131822     if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){
131823       rc = SplitNode(pRtree, pNode, pCell, iHeight);
131824     }else{
131825       pRtree->iReinsertHeight = iHeight;
131826       rc = Reinsert(pRtree, pNode, pCell, iHeight);
131827     }
131828 #else
131829     rc = SplitNode(pRtree, pNode, pCell, iHeight);
131830 #endif
131831   }else{
131832     rc = AdjustTree(pRtree, pNode, pCell);
131833     if( rc==SQLCIPHER_OK ){
131834       if( iHeight==0 ){
131835         rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
131836       }else{
131837         rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
131838       }
131839     }
131840   }
131841   return rc;
131842 }
131843
131844 static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){
131845   int ii;
131846   int rc = SQLCIPHER_OK;
131847   int nCell = NCELL(pNode);
131848
131849   for(ii=0; rc==SQLCIPHER_OK && ii<nCell; ii++){
131850     RtreeNode *pInsert;
131851     RtreeCell cell;
131852     nodeGetCell(pRtree, pNode, ii, &cell);
131853
131854     /* Find a node to store this cell in. pNode->iNode currently contains
131855     ** the height of the sub-tree headed by the cell.
131856     */
131857     rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert);
131858     if( rc==SQLCIPHER_OK ){
131859       int rc2;
131860       rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode);
131861       rc2 = nodeRelease(pRtree, pInsert);
131862       if( rc==SQLCIPHER_OK ){
131863         rc = rc2;
131864       }
131865     }
131866   }
131867   return rc;
131868 }
131869
131870 /*
131871 ** Select a currently unused rowid for a new r-tree record.
131872 */
131873 static int newRowid(Rtree *pRtree, i64 *piRowid){
131874   int rc;
131875   sqlcipher3_bind_null(pRtree->pWriteRowid, 1);
131876   sqlcipher3_bind_null(pRtree->pWriteRowid, 2);
131877   sqlcipher3_step(pRtree->pWriteRowid);
131878   rc = sqlcipher3_reset(pRtree->pWriteRowid);
131879   *piRowid = sqlcipher3_last_insert_rowid(pRtree->db);
131880   return rc;
131881 }
131882
131883 /*
131884 ** Remove the entry with rowid=iDelete from the r-tree structure.
131885 */
131886 static int rtreeDeleteRowid(Rtree *pRtree, sqlcipher3_int64 iDelete){
131887   int rc;                         /* Return code */
131888   RtreeNode *pLeaf;               /* Leaf node containing record iDelete */
131889   int iCell;                      /* Index of iDelete cell in pLeaf */
131890   RtreeNode *pRoot;               /* Root node of rtree structure */
131891
131892
131893   /* Obtain a reference to the root node to initialise Rtree.iDepth */
131894   rc = nodeAcquire(pRtree, 1, 0, &pRoot);
131895
131896   /* Obtain a reference to the leaf node that contains the entry 
131897   ** about to be deleted. 
131898   */
131899   if( rc==SQLCIPHER_OK ){
131900     rc = findLeafNode(pRtree, iDelete, &pLeaf);
131901   }
131902
131903   /* Delete the cell in question from the leaf node. */
131904   if( rc==SQLCIPHER_OK ){
131905     int rc2;
131906     rc = nodeRowidIndex(pRtree, pLeaf, iDelete, &iCell);
131907     if( rc==SQLCIPHER_OK ){
131908       rc = deleteCell(pRtree, pLeaf, iCell, 0);
131909     }
131910     rc2 = nodeRelease(pRtree, pLeaf);
131911     if( rc==SQLCIPHER_OK ){
131912       rc = rc2;
131913     }
131914   }
131915
131916   /* Delete the corresponding entry in the <rtree>_rowid table. */
131917   if( rc==SQLCIPHER_OK ){
131918     sqlcipher3_bind_int64(pRtree->pDeleteRowid, 1, iDelete);
131919     sqlcipher3_step(pRtree->pDeleteRowid);
131920     rc = sqlcipher3_reset(pRtree->pDeleteRowid);
131921   }
131922
131923   /* Check if the root node now has exactly one child. If so, remove
131924   ** it, schedule the contents of the child for reinsertion and 
131925   ** reduce the tree height by one.
131926   **
131927   ** This is equivalent to copying the contents of the child into
131928   ** the root node (the operation that Gutman's paper says to perform 
131929   ** in this scenario).
131930   */
131931   if( rc==SQLCIPHER_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
131932     int rc2;
131933     RtreeNode *pChild;
131934     i64 iChild = nodeGetRowid(pRtree, pRoot, 0);
131935     rc = nodeAcquire(pRtree, iChild, pRoot, &pChild);
131936     if( rc==SQLCIPHER_OK ){
131937       rc = removeNode(pRtree, pChild, pRtree->iDepth-1);
131938     }
131939     rc2 = nodeRelease(pRtree, pChild);
131940     if( rc==SQLCIPHER_OK ) rc = rc2;
131941     if( rc==SQLCIPHER_OK ){
131942       pRtree->iDepth--;
131943       writeInt16(pRoot->zData, pRtree->iDepth);
131944       pRoot->isDirty = 1;
131945     }
131946   }
131947
131948   /* Re-insert the contents of any underfull nodes removed from the tree. */
131949   for(pLeaf=pRtree->pDeleted; pLeaf; pLeaf=pRtree->pDeleted){
131950     if( rc==SQLCIPHER_OK ){
131951       rc = reinsertNodeContent(pRtree, pLeaf);
131952     }
131953     pRtree->pDeleted = pLeaf->pNext;
131954     sqlcipher3_free(pLeaf);
131955   }
131956
131957   /* Release the reference to the root node. */
131958   if( rc==SQLCIPHER_OK ){
131959     rc = nodeRelease(pRtree, pRoot);
131960   }else{
131961     nodeRelease(pRtree, pRoot);
131962   }
131963
131964   return rc;
131965 }
131966
131967 /*
131968 ** The xUpdate method for rtree module virtual tables.
131969 */
131970 static int rtreeUpdate(
131971   sqlcipher3_vtab *pVtab, 
131972   int nData, 
131973   sqlcipher3_value **azData, 
131974   sqlcipher_int64 *pRowid
131975 ){
131976   Rtree *pRtree = (Rtree *)pVtab;
131977   int rc = SQLCIPHER_OK;
131978   RtreeCell cell;                 /* New cell to insert if nData>1 */
131979   int bHaveRowid = 0;             /* Set to 1 after new rowid is determined */
131980
131981   rtreeReference(pRtree);
131982   assert(nData>=1);
131983
131984   /* Constraint handling. A write operation on an r-tree table may return
131985   ** SQLCIPHER_CONSTRAINT for two reasons:
131986   **
131987   **   1. A duplicate rowid value, or
131988   **   2. The supplied data violates the "x2>=x1" constraint.
131989   **
131990   ** In the first case, if the conflict-handling mode is REPLACE, then
131991   ** the conflicting row can be removed before proceeding. In the second
131992   ** case, SQLCIPHER_CONSTRAINT must be returned regardless of the
131993   ** conflict-handling mode specified by the user.
131994   */
131995   if( nData>1 ){
131996     int ii;
131997
131998     /* Populate the cell.aCoord[] array. The first coordinate is azData[3]. */
131999     assert( nData==(pRtree->nDim*2 + 3) );
132000     if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
132001       for(ii=0; ii<(pRtree->nDim*2); ii+=2){
132002         cell.aCoord[ii].f = (float)sqlcipher3_value_double(azData[ii+3]);
132003         cell.aCoord[ii+1].f = (float)sqlcipher3_value_double(azData[ii+4]);
132004         if( cell.aCoord[ii].f>cell.aCoord[ii+1].f ){
132005           rc = SQLCIPHER_CONSTRAINT;
132006           goto constraint;
132007         }
132008       }
132009     }else{
132010       for(ii=0; ii<(pRtree->nDim*2); ii+=2){
132011         cell.aCoord[ii].i = sqlcipher3_value_int(azData[ii+3]);
132012         cell.aCoord[ii+1].i = sqlcipher3_value_int(azData[ii+4]);
132013         if( cell.aCoord[ii].i>cell.aCoord[ii+1].i ){
132014           rc = SQLCIPHER_CONSTRAINT;
132015           goto constraint;
132016         }
132017       }
132018     }
132019
132020     /* If a rowid value was supplied, check if it is already present in 
132021     ** the table. If so, the constraint has failed. */
132022     if( sqlcipher3_value_type(azData[2])!=SQLCIPHER_NULL ){
132023       cell.iRowid = sqlcipher3_value_int64(azData[2]);
132024       if( sqlcipher3_value_type(azData[0])==SQLCIPHER_NULL
132025        || sqlcipher3_value_int64(azData[0])!=cell.iRowid
132026       ){
132027         int steprc;
132028         sqlcipher3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid);
132029         steprc = sqlcipher3_step(pRtree->pReadRowid);
132030         rc = sqlcipher3_reset(pRtree->pReadRowid);
132031         if( SQLCIPHER_ROW==steprc ){
132032           if( sqlcipher3_vtab_on_conflict(pRtree->db)==SQLCIPHER_REPLACE ){
132033             rc = rtreeDeleteRowid(pRtree, cell.iRowid);
132034           }else{
132035             rc = SQLCIPHER_CONSTRAINT;
132036             goto constraint;
132037           }
132038         }
132039       }
132040       bHaveRowid = 1;
132041     }
132042   }
132043
132044   /* If azData[0] is not an SQL NULL value, it is the rowid of a
132045   ** record to delete from the r-tree table. The following block does
132046   ** just that.
132047   */
132048   if( sqlcipher3_value_type(azData[0])!=SQLCIPHER_NULL ){
132049     rc = rtreeDeleteRowid(pRtree, sqlcipher3_value_int64(azData[0]));
132050   }
132051
132052   /* If the azData[] array contains more than one element, elements
132053   ** (azData[2]..azData[argc-1]) contain a new record to insert into
132054   ** the r-tree structure.
132055   */
132056   if( rc==SQLCIPHER_OK && nData>1 ){
132057     /* Insert the new record into the r-tree */
132058     RtreeNode *pLeaf;
132059
132060     /* Figure out the rowid of the new row. */
132061     if( bHaveRowid==0 ){
132062       rc = newRowid(pRtree, &cell.iRowid);
132063     }
132064     *pRowid = cell.iRowid;
132065
132066     if( rc==SQLCIPHER_OK ){
132067       rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf);
132068     }
132069     if( rc==SQLCIPHER_OK ){
132070       int rc2;
132071       pRtree->iReinsertHeight = -1;
132072       rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0);
132073       rc2 = nodeRelease(pRtree, pLeaf);
132074       if( rc==SQLCIPHER_OK ){
132075         rc = rc2;
132076       }
132077     }
132078   }
132079
132080 constraint:
132081   rtreeRelease(pRtree);
132082   return rc;
132083 }
132084
132085 /*
132086 ** The xRename method for rtree module virtual tables.
132087 */
132088 static int rtreeRename(sqlcipher3_vtab *pVtab, const char *zNewName){
132089   Rtree *pRtree = (Rtree *)pVtab;
132090   int rc = SQLCIPHER_NOMEM;
132091   char *zSql = sqlcipher3_mprintf(
132092     "ALTER TABLE %Q.'%q_node'   RENAME TO \"%w_node\";"
132093     "ALTER TABLE %Q.'%q_parent' RENAME TO \"%w_parent\";"
132094     "ALTER TABLE %Q.'%q_rowid'  RENAME TO \"%w_rowid\";"
132095     , pRtree->zDb, pRtree->zName, zNewName 
132096     , pRtree->zDb, pRtree->zName, zNewName 
132097     , pRtree->zDb, pRtree->zName, zNewName
132098   );
132099   if( zSql ){
132100     rc = sqlcipher3_exec(pRtree->db, zSql, 0, 0, 0);
132101     sqlcipher3_free(zSql);
132102   }
132103   return rc;
132104 }
132105
132106 static sqlcipher3_module rtreeModule = {
132107   0,                          /* iVersion */
132108   rtreeCreate,                /* xCreate - create a table */
132109   rtreeConnect,               /* xConnect - connect to an existing table */
132110   rtreeBestIndex,             /* xBestIndex - Determine search strategy */
132111   rtreeDisconnect,            /* xDisconnect - Disconnect from a table */
132112   rtreeDestroy,               /* xDestroy - Drop a table */
132113   rtreeOpen,                  /* xOpen - open a cursor */
132114   rtreeClose,                 /* xClose - close a cursor */
132115   rtreeFilter,                /* xFilter - configure scan constraints */
132116   rtreeNext,                  /* xNext - advance a cursor */
132117   rtreeEof,                   /* xEof */
132118   rtreeColumn,                /* xColumn - read data */
132119   rtreeRowid,                 /* xRowid - read data */
132120   rtreeUpdate,                /* xUpdate - write data */
132121   0,                          /* xBegin - begin transaction */
132122   0,                          /* xSync - sync transaction */
132123   0,                          /* xCommit - commit transaction */
132124   0,                          /* xRollback - rollback transaction */
132125   0,                          /* xFindFunction - function overloading */
132126   rtreeRename,                /* xRename - rename the table */
132127   0,                          /* xSavepoint */
132128   0,                          /* xRelease */
132129   0                           /* xRollbackTo */
132130 };
132131
132132 static int rtreeSqlInit(
132133   Rtree *pRtree, 
132134   sqlcipher3 *db, 
132135   const char *zDb, 
132136   const char *zPrefix, 
132137   int isCreate
132138 ){
132139   int rc = SQLCIPHER_OK;
132140
132141   #define N_STATEMENT 9
132142   static const char *azSql[N_STATEMENT] = {
132143     /* Read and write the xxx_node table */
132144     "SELECT data FROM '%q'.'%q_node' WHERE nodeno = :1",
132145     "INSERT OR REPLACE INTO '%q'.'%q_node' VALUES(:1, :2)",
132146     "DELETE FROM '%q'.'%q_node' WHERE nodeno = :1",
132147
132148     /* Read and write the xxx_rowid table */
132149     "SELECT nodeno FROM '%q'.'%q_rowid' WHERE rowid = :1",
132150     "INSERT OR REPLACE INTO '%q'.'%q_rowid' VALUES(:1, :2)",
132151     "DELETE FROM '%q'.'%q_rowid' WHERE rowid = :1",
132152
132153     /* Read and write the xxx_parent table */
132154     "SELECT parentnode FROM '%q'.'%q_parent' WHERE nodeno = :1",
132155     "INSERT OR REPLACE INTO '%q'.'%q_parent' VALUES(:1, :2)",
132156     "DELETE FROM '%q'.'%q_parent' WHERE nodeno = :1"
132157   };
132158   sqlcipher3_stmt **appStmt[N_STATEMENT];
132159   int i;
132160
132161   pRtree->db = db;
132162
132163   if( isCreate ){
132164     char *zCreate = sqlcipher3_mprintf(
132165 "CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY, data BLOB);"
132166 "CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY, nodeno INTEGER);"
132167 "CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY, parentnode INTEGER);"
132168 "INSERT INTO '%q'.'%q_node' VALUES(1, zeroblob(%d))",
132169       zDb, zPrefix, zDb, zPrefix, zDb, zPrefix, zDb, zPrefix, pRtree->iNodeSize
132170     );
132171     if( !zCreate ){
132172       return SQLCIPHER_NOMEM;
132173     }
132174     rc = sqlcipher3_exec(db, zCreate, 0, 0, 0);
132175     sqlcipher3_free(zCreate);
132176     if( rc!=SQLCIPHER_OK ){
132177       return rc;
132178     }
132179   }
132180
132181   appStmt[0] = &pRtree->pReadNode;
132182   appStmt[1] = &pRtree->pWriteNode;
132183   appStmt[2] = &pRtree->pDeleteNode;
132184   appStmt[3] = &pRtree->pReadRowid;
132185   appStmt[4] = &pRtree->pWriteRowid;
132186   appStmt[5] = &pRtree->pDeleteRowid;
132187   appStmt[6] = &pRtree->pReadParent;
132188   appStmt[7] = &pRtree->pWriteParent;
132189   appStmt[8] = &pRtree->pDeleteParent;
132190
132191   for(i=0; i<N_STATEMENT && rc==SQLCIPHER_OK; i++){
132192     char *zSql = sqlcipher3_mprintf(azSql[i], zDb, zPrefix);
132193     if( zSql ){
132194       rc = sqlcipher3_prepare_v2(db, zSql, -1, appStmt[i], 0); 
132195     }else{
132196       rc = SQLCIPHER_NOMEM;
132197     }
132198     sqlcipher3_free(zSql);
132199   }
132200
132201   return rc;
132202 }
132203
132204 /*
132205 ** The second argument to this function contains the text of an SQL statement
132206 ** that returns a single integer value. The statement is compiled and executed
132207 ** using database connection db. If successful, the integer value returned
132208 ** is written to *piVal and SQLCIPHER_OK returned. Otherwise, an SQLite error
132209 ** code is returned and the value of *piVal after returning is not defined.
132210 */
132211 static int getIntFromStmt(sqlcipher3 *db, const char *zSql, int *piVal){
132212   int rc = SQLCIPHER_NOMEM;
132213   if( zSql ){
132214     sqlcipher3_stmt *pStmt = 0;
132215     rc = sqlcipher3_prepare_v2(db, zSql, -1, &pStmt, 0);
132216     if( rc==SQLCIPHER_OK ){
132217       if( SQLCIPHER_ROW==sqlcipher3_step(pStmt) ){
132218         *piVal = sqlcipher3_column_int(pStmt, 0);
132219       }
132220       rc = sqlcipher3_finalize(pStmt);
132221     }
132222   }
132223   return rc;
132224 }
132225
132226 /*
132227 ** This function is called from within the xConnect() or xCreate() method to
132228 ** determine the node-size used by the rtree table being created or connected
132229 ** to. If successful, pRtree->iNodeSize is populated and SQLCIPHER_OK returned.
132230 ** Otherwise, an SQLite error code is returned.
132231 **
132232 ** If this function is being called as part of an xConnect(), then the rtree
132233 ** table already exists. In this case the node-size is determined by inspecting
132234 ** the root node of the tree.
132235 **
132236 ** Otherwise, for an xCreate(), use 64 bytes less than the database page-size. 
132237 ** This ensures that each node is stored on a single database page. If the 
132238 ** database page-size is so large that more than RTREE_MAXCELLS entries 
132239 ** would fit in a single node, use a smaller node-size.
132240 */
132241 static int getNodeSize(
132242   sqlcipher3 *db,                    /* Database handle */
132243   Rtree *pRtree,                  /* Rtree handle */
132244   int isCreate                    /* True for xCreate, false for xConnect */
132245 ){
132246   int rc;
132247   char *zSql;
132248   if( isCreate ){
132249     int iPageSize = 0;
132250     zSql = sqlcipher3_mprintf("PRAGMA %Q.page_size", pRtree->zDb);
132251     rc = getIntFromStmt(db, zSql, &iPageSize);
132252     if( rc==SQLCIPHER_OK ){
132253       pRtree->iNodeSize = iPageSize-64;
132254       if( (4+pRtree->nBytesPerCell*RTREE_MAXCELLS)<pRtree->iNodeSize ){
132255         pRtree->iNodeSize = 4+pRtree->nBytesPerCell*RTREE_MAXCELLS;
132256       }
132257     }
132258   }else{
132259     zSql = sqlcipher3_mprintf(
132260         "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1",
132261         pRtree->zDb, pRtree->zName
132262     );
132263     rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize);
132264   }
132265
132266   sqlcipher3_free(zSql);
132267   return rc;
132268 }
132269
132270 /* 
132271 ** This function is the implementation of both the xConnect and xCreate
132272 ** methods of the r-tree virtual table.
132273 **
132274 **   argv[0]   -> module name
132275 **   argv[1]   -> database name
132276 **   argv[2]   -> table name
132277 **   argv[...] -> column names...
132278 */
132279 static int rtreeInit(
132280   sqlcipher3 *db,                        /* Database connection */
132281   void *pAux,                         /* One of the RTREE_COORD_* constants */
132282   int argc, const char *const*argv,   /* Parameters to CREATE TABLE statement */
132283   sqlcipher3_vtab **ppVtab,              /* OUT: New virtual table */
132284   char **pzErr,                       /* OUT: Error message, if any */
132285   int isCreate                        /* True for xCreate, false for xConnect */
132286 ){
132287   int rc = SQLCIPHER_OK;
132288   Rtree *pRtree;
132289   int nDb;              /* Length of string argv[1] */
132290   int nName;            /* Length of string argv[2] */
132291   int eCoordType = (pAux ? RTREE_COORD_INT32 : RTREE_COORD_REAL32);
132292
132293   const char *aErrMsg[] = {
132294     0,                                                    /* 0 */
132295     "Wrong number of columns for an rtree table",         /* 1 */
132296     "Too few columns for an rtree table",                 /* 2 */
132297     "Too many columns for an rtree table"                 /* 3 */
132298   };
132299
132300   int iErr = (argc<6) ? 2 : argc>(RTREE_MAX_DIMENSIONS*2+4) ? 3 : argc%2;
132301   if( aErrMsg[iErr] ){
132302     *pzErr = sqlcipher3_mprintf("%s", aErrMsg[iErr]);
132303     return SQLCIPHER_ERROR;
132304   }
132305
132306   sqlcipher3_vtab_config(db, SQLCIPHER_VTAB_CONSTRAINT_SUPPORT, 1);
132307
132308   /* Allocate the sqlcipher3_vtab structure */
132309   nDb = strlen(argv[1]);
132310   nName = strlen(argv[2]);
132311   pRtree = (Rtree *)sqlcipher3_malloc(sizeof(Rtree)+nDb+nName+2);
132312   if( !pRtree ){
132313     return SQLCIPHER_NOMEM;
132314   }
132315   memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2);
132316   pRtree->nBusy = 1;
132317   pRtree->base.pModule = &rtreeModule;
132318   pRtree->zDb = (char *)&pRtree[1];
132319   pRtree->zName = &pRtree->zDb[nDb+1];
132320   pRtree->nDim = (argc-4)/2;
132321   pRtree->nBytesPerCell = 8 + pRtree->nDim*4*2;
132322   pRtree->eCoordType = eCoordType;
132323   memcpy(pRtree->zDb, argv[1], nDb);
132324   memcpy(pRtree->zName, argv[2], nName);
132325
132326   /* Figure out the node size to use. */
132327   rc = getNodeSize(db, pRtree, isCreate);
132328
132329   /* Create/Connect to the underlying relational database schema. If
132330   ** that is successful, call sqlcipher3_declare_vtab() to configure
132331   ** the r-tree table schema.
132332   */
132333   if( rc==SQLCIPHER_OK ){
132334     if( (rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate)) ){
132335       *pzErr = sqlcipher3_mprintf("%s", sqlcipher3_errmsg(db));
132336     }else{
132337       char *zSql = sqlcipher3_mprintf("CREATE TABLE x(%s", argv[3]);
132338       char *zTmp;
132339       int ii;
132340       for(ii=4; zSql && ii<argc; ii++){
132341         zTmp = zSql;
132342         zSql = sqlcipher3_mprintf("%s, %s", zTmp, argv[ii]);
132343         sqlcipher3_free(zTmp);
132344       }
132345       if( zSql ){
132346         zTmp = zSql;
132347         zSql = sqlcipher3_mprintf("%s);", zTmp);
132348         sqlcipher3_free(zTmp);
132349       }
132350       if( !zSql ){
132351         rc = SQLCIPHER_NOMEM;
132352       }else if( SQLCIPHER_OK!=(rc = sqlcipher3_declare_vtab(db, zSql)) ){
132353         *pzErr = sqlcipher3_mprintf("%s", sqlcipher3_errmsg(db));
132354       }
132355       sqlcipher3_free(zSql);
132356     }
132357   }
132358
132359   if( rc==SQLCIPHER_OK ){
132360     *ppVtab = (sqlcipher3_vtab *)pRtree;
132361   }else{
132362     rtreeRelease(pRtree);
132363   }
132364   return rc;
132365 }
132366
132367
132368 /*
132369 ** Implementation of a scalar function that decodes r-tree nodes to
132370 ** human readable strings. This can be used for debugging and analysis.
132371 **
132372 ** The scalar function takes two arguments, a blob of data containing
132373 ** an r-tree node, and the number of dimensions the r-tree indexes.
132374 ** For a two-dimensional r-tree structure called "rt", to deserialize
132375 ** all nodes, a statement like:
132376 **
132377 **   SELECT rtreenode(2, data) FROM rt_node;
132378 **
132379 ** The human readable string takes the form of a Tcl list with one
132380 ** entry for each cell in the r-tree node. Each entry is itself a
132381 ** list, containing the 8-byte rowid/pageno followed by the 
132382 ** <num-dimension>*2 coordinates.
132383 */
132384 static void rtreenode(sqlcipher3_context *ctx, int nArg, sqlcipher3_value **apArg){
132385   char *zText = 0;
132386   RtreeNode node;
132387   Rtree tree;
132388   int ii;
132389
132390   UNUSED_PARAMETER(nArg);
132391   memset(&node, 0, sizeof(RtreeNode));
132392   memset(&tree, 0, sizeof(Rtree));
132393   tree.nDim = sqlcipher3_value_int(apArg[0]);
132394   tree.nBytesPerCell = 8 + 8 * tree.nDim;
132395   node.zData = (u8 *)sqlcipher3_value_blob(apArg[1]);
132396
132397   for(ii=0; ii<NCELL(&node); ii++){
132398     char zCell[512];
132399     int nCell = 0;
132400     RtreeCell cell;
132401     int jj;
132402
132403     nodeGetCell(&tree, &node, ii, &cell);
132404     sqlcipher3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
132405     nCell = strlen(zCell);
132406     for(jj=0; jj<tree.nDim*2; jj++){
132407       sqlcipher3_snprintf(512-nCell,&zCell[nCell]," %f",(double)cell.aCoord[jj].f);
132408       nCell = strlen(zCell);
132409     }
132410
132411     if( zText ){
132412       char *zTextNew = sqlcipher3_mprintf("%s {%s}", zText, zCell);
132413       sqlcipher3_free(zText);
132414       zText = zTextNew;
132415     }else{
132416       zText = sqlcipher3_mprintf("{%s}", zCell);
132417     }
132418   }
132419   
132420   sqlcipher3_result_text(ctx, zText, -1, sqlcipher3_free);
132421 }
132422
132423 static void rtreedepth(sqlcipher3_context *ctx, int nArg, sqlcipher3_value **apArg){
132424   UNUSED_PARAMETER(nArg);
132425   if( sqlcipher3_value_type(apArg[0])!=SQLCIPHER_BLOB 
132426    || sqlcipher3_value_bytes(apArg[0])<2
132427   ){
132428     sqlcipher3_result_error(ctx, "Invalid argument to rtreedepth()", -1); 
132429   }else{
132430     u8 *zBlob = (u8 *)sqlcipher3_value_blob(apArg[0]);
132431     sqlcipher3_result_int(ctx, readInt16(zBlob));
132432   }
132433 }
132434
132435 /*
132436 ** Register the r-tree module with database handle db. This creates the
132437 ** virtual table module "rtree" and the debugging/analysis scalar 
132438 ** function "rtreenode".
132439 */
132440 SQLCIPHER_PRIVATE int sqlcipher3RtreeInit(sqlcipher3 *db){
132441   const int utf8 = SQLCIPHER_UTF8;
132442   int rc;
132443
132444   rc = sqlcipher3_create_function(db, "rtreenode", 2, utf8, 0, rtreenode, 0, 0);
132445   if( rc==SQLCIPHER_OK ){
132446     rc = sqlcipher3_create_function(db, "rtreedepth", 1, utf8, 0,rtreedepth, 0, 0);
132447   }
132448   if( rc==SQLCIPHER_OK ){
132449     void *c = (void *)RTREE_COORD_REAL32;
132450     rc = sqlcipher3_create_module_v2(db, "rtree", &rtreeModule, c, 0);
132451   }
132452   if( rc==SQLCIPHER_OK ){
132453     void *c = (void *)RTREE_COORD_INT32;
132454     rc = sqlcipher3_create_module_v2(db, "rtree_i32", &rtreeModule, c, 0);
132455   }
132456
132457   return rc;
132458 }
132459
132460 /*
132461 ** A version of sqlcipher3_free() that can be used as a callback. This is used
132462 ** in two places - as the destructor for the blob value returned by the
132463 ** invocation of a geometry function, and as the destructor for the geometry
132464 ** functions themselves.
132465 */
132466 static void doSqlite3Free(void *p){
132467   sqlcipher3_free(p);
132468 }
132469
132470 /*
132471 ** Each call to sqlcipher3_rtree_geometry_callback() creates an ordinary SQLite
132472 ** scalar user function. This C function is the callback used for all such
132473 ** registered SQL functions.
132474 **
132475 ** The scalar user functions return a blob that is interpreted by r-tree
132476 ** table MATCH operators.
132477 */
132478 static void geomCallback(sqlcipher3_context *ctx, int nArg, sqlcipher3_value **aArg){
132479   RtreeGeomCallback *pGeomCtx = (RtreeGeomCallback *)sqlcipher3_user_data(ctx);
132480   RtreeMatchArg *pBlob;
132481   int nBlob;
132482
132483   nBlob = sizeof(RtreeMatchArg) + (nArg-1)*sizeof(double);
132484   pBlob = (RtreeMatchArg *)sqlcipher3_malloc(nBlob);
132485   if( !pBlob ){
132486     sqlcipher3_result_error_nomem(ctx);
132487   }else{
132488     int i;
132489     pBlob->magic = RTREE_GEOMETRY_MAGIC;
132490     pBlob->xGeom = pGeomCtx->xGeom;
132491     pBlob->pContext = pGeomCtx->pContext;
132492     pBlob->nParam = nArg;
132493     for(i=0; i<nArg; i++){
132494       pBlob->aParam[i] = sqlcipher3_value_double(aArg[i]);
132495     }
132496     sqlcipher3_result_blob(ctx, pBlob, nBlob, doSqlite3Free);
132497   }
132498 }
132499
132500 /*
132501 ** Register a new geometry function for use with the r-tree MATCH operator.
132502 */
132503 SQLCIPHER_API int sqlcipher3_rtree_geometry_callback(
132504   sqlcipher3 *db,
132505   const char *zGeom,
132506   int (*xGeom)(sqlcipher3_rtree_geometry *, int, double *, int *),
132507   void *pContext
132508 ){
132509   RtreeGeomCallback *pGeomCtx;      /* Context object for new user-function */
132510
132511   /* Allocate and populate the context object. */
132512   pGeomCtx = (RtreeGeomCallback *)sqlcipher3_malloc(sizeof(RtreeGeomCallback));
132513   if( !pGeomCtx ) return SQLCIPHER_NOMEM;
132514   pGeomCtx->xGeom = xGeom;
132515   pGeomCtx->pContext = pContext;
132516
132517   /* Create the new user-function. Register a destructor function to delete
132518   ** the context object when it is no longer required.  */
132519   return sqlcipher3_create_function_v2(db, zGeom, -1, SQLCIPHER_ANY, 
132520       (void *)pGeomCtx, geomCallback, 0, 0, doSqlite3Free
132521   );
132522 }
132523
132524 #if !SQLCIPHER_CORE
132525 SQLCIPHER_API int sqlcipher3_extension_init(
132526   sqlcipher3 *db,
132527   char **pzErrMsg,
132528   const sqlcipher3_api_routines *pApi
132529 ){
132530   SQLCIPHER_EXTENSION_INIT2(pApi)
132531   return sqlcipher3RtreeInit(db);
132532 }
132533 #endif
132534
132535 #endif
132536
132537 /************** End of rtree.c ***********************************************/
132538 /************** Begin file icu.c *********************************************/
132539 /*
132540 ** 2007 May 6
132541 **
132542 ** The author disclaims copyright to this source code.  In place of
132543 ** a legal notice, here is a blessing:
132544 **
132545 **    May you do good and not evil.
132546 **    May you find forgiveness for yourself and forgive others.
132547 **    May you share freely, never taking more than you give.
132548 **
132549 *************************************************************************
132550 ** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $
132551 **
132552 ** This file implements an integration between the ICU library 
132553 ** ("International Components for Unicode", an open-source library 
132554 ** for handling unicode data) and SQLite. The integration uses 
132555 ** ICU to provide the following to SQLite:
132556 **
132557 **   * An implementation of the SQL regexp() function (and hence REGEXP
132558 **     operator) using the ICU uregex_XX() APIs.
132559 **
132560 **   * Implementations of the SQL scalar upper() and lower() functions
132561 **     for case mapping.
132562 **
132563 **   * Integration of ICU and SQLite collation seqences.
132564 **
132565 **   * An implementation of the LIKE operator that uses ICU to 
132566 **     provide case-independent matching.
132567 */
132568
132569 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_ICU)
132570
132571 /* Include ICU headers */
132572 #include <unicode/utypes.h>
132573 #include <unicode/uregex.h>
132574 #include <unicode/ustring.h>
132575 #include <unicode/ucol.h>
132576
132577 /* #include <assert.h> */
132578
132579 #ifndef SQLCIPHER_CORE
132580   SQLCIPHER_EXTENSION_INIT1
132581 #else
132582 #endif
132583
132584 /*
132585 ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
132586 ** operator.
132587 */
132588 #ifndef SQLCIPHER_MAX_LIKE_PATTERN_LENGTH
132589 # define SQLCIPHER_MAX_LIKE_PATTERN_LENGTH 50000
132590 #endif
132591
132592 /*
132593 ** Version of sqlcipher3_free() that is always a function, never a macro.
132594 */
132595 static void xFree(void *p){
132596   sqlcipher3_free(p);
132597 }
132598
132599 /*
132600 ** Compare two UTF-8 strings for equality where the first string is
132601 ** a "LIKE" expression. Return true (1) if they are the same and 
132602 ** false (0) if they are different.
132603 */
132604 static int icuLikeCompare(
132605   const uint8_t *zPattern,   /* LIKE pattern */
132606   const uint8_t *zString,    /* The UTF-8 string to compare against */
132607   const UChar32 uEsc         /* The escape character */
132608 ){
132609   static const int MATCH_ONE = (UChar32)'_';
132610   static const int MATCH_ALL = (UChar32)'%';
132611
132612   int iPattern = 0;       /* Current byte index in zPattern */
132613   int iString = 0;        /* Current byte index in zString */
132614
132615   int prevEscape = 0;     /* True if the previous character was uEsc */
132616
132617   while( zPattern[iPattern]!=0 ){
132618
132619     /* Read (and consume) the next character from the input pattern. */
132620     UChar32 uPattern;
132621     U8_NEXT_UNSAFE(zPattern, iPattern, uPattern);
132622     assert(uPattern!=0);
132623
132624     /* There are now 4 possibilities:
132625     **
132626     **     1. uPattern is an unescaped match-all character "%",
132627     **     2. uPattern is an unescaped match-one character "_",
132628     **     3. uPattern is an unescaped escape character, or
132629     **     4. uPattern is to be handled as an ordinary character
132630     */
132631     if( !prevEscape && uPattern==MATCH_ALL ){
132632       /* Case 1. */
132633       uint8_t c;
132634
132635       /* Skip any MATCH_ALL or MATCH_ONE characters that follow a
132636       ** MATCH_ALL. For each MATCH_ONE, skip one character in the 
132637       ** test string.
132638       */
132639       while( (c=zPattern[iPattern]) == MATCH_ALL || c == MATCH_ONE ){
132640         if( c==MATCH_ONE ){
132641           if( zString[iString]==0 ) return 0;
132642           U8_FWD_1_UNSAFE(zString, iString);
132643         }
132644         iPattern++;
132645       }
132646
132647       if( zPattern[iPattern]==0 ) return 1;
132648
132649       while( zString[iString] ){
132650         if( icuLikeCompare(&zPattern[iPattern], &zString[iString], uEsc) ){
132651           return 1;
132652         }
132653         U8_FWD_1_UNSAFE(zString, iString);
132654       }
132655       return 0;
132656
132657     }else if( !prevEscape && uPattern==MATCH_ONE ){
132658       /* Case 2. */
132659       if( zString[iString]==0 ) return 0;
132660       U8_FWD_1_UNSAFE(zString, iString);
132661
132662     }else if( !prevEscape && uPattern==uEsc){
132663       /* Case 3. */
132664       prevEscape = 1;
132665
132666     }else{
132667       /* Case 4. */
132668       UChar32 uString;
132669       U8_NEXT_UNSAFE(zString, iString, uString);
132670       uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT);
132671       uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT);
132672       if( uString!=uPattern ){
132673         return 0;
132674       }
132675       prevEscape = 0;
132676     }
132677   }
132678
132679   return zString[iString]==0;
132680 }
132681
132682 /*
132683 ** Implementation of the like() SQL function.  This function implements
132684 ** the build-in LIKE operator.  The first argument to the function is the
132685 ** pattern and the second argument is the string.  So, the SQL statements:
132686 **
132687 **       A LIKE B
132688 **
132689 ** is implemented as like(B, A). If there is an escape character E, 
132690 **
132691 **       A LIKE B ESCAPE E
132692 **
132693 ** is mapped to like(B, A, E).
132694 */
132695 static void icuLikeFunc(
132696   sqlcipher3_context *context, 
132697   int argc, 
132698   sqlcipher3_value **argv
132699 ){
132700   const unsigned char *zA = sqlcipher3_value_text(argv[0]);
132701   const unsigned char *zB = sqlcipher3_value_text(argv[1]);
132702   UChar32 uEsc = 0;
132703
132704   /* Limit the length of the LIKE or GLOB pattern to avoid problems
132705   ** of deep recursion and N*N behavior in patternCompare().
132706   */
132707   if( sqlcipher3_value_bytes(argv[0])>SQLCIPHER_MAX_LIKE_PATTERN_LENGTH ){
132708     sqlcipher3_result_error(context, "LIKE or GLOB pattern too complex", -1);
132709     return;
132710   }
132711
132712
132713   if( argc==3 ){
132714     /* The escape character string must consist of a single UTF-8 character.
132715     ** Otherwise, return an error.
132716     */
132717     int nE= sqlcipher3_value_bytes(argv[2]);
132718     const unsigned char *zE = sqlcipher3_value_text(argv[2]);
132719     int i = 0;
132720     if( zE==0 ) return;
132721     U8_NEXT(zE, i, nE, uEsc);
132722     if( i!=nE){
132723       sqlcipher3_result_error(context, 
132724           "ESCAPE expression must be a single character", -1);
132725       return;
132726     }
132727   }
132728
132729   if( zA && zB ){
132730     sqlcipher3_result_int(context, icuLikeCompare(zA, zB, uEsc));
132731   }
132732 }
132733
132734 /*
132735 ** This function is called when an ICU function called from within
132736 ** the implementation of an SQL scalar function returns an error.
132737 **
132738 ** The scalar function context passed as the first argument is 
132739 ** loaded with an error message based on the following two args.
132740 */
132741 static void icuFunctionError(
132742   sqlcipher3_context *pCtx,       /* SQLite scalar function context */
132743   const char *zName,           /* Name of ICU function that failed */
132744   UErrorCode e                 /* Error code returned by ICU function */
132745 ){
132746   char zBuf[128];
132747   sqlcipher3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
132748   zBuf[127] = '\0';
132749   sqlcipher3_result_error(pCtx, zBuf, -1);
132750 }
132751
132752 /*
132753 ** Function to delete compiled regexp objects. Registered as
132754 ** a destructor function with sqlcipher3_set_auxdata().
132755 */
132756 static void icuRegexpDelete(void *p){
132757   URegularExpression *pExpr = (URegularExpression *)p;
132758   uregex_close(pExpr);
132759 }
132760
132761 /*
132762 ** Implementation of SQLite REGEXP operator. This scalar function takes
132763 ** two arguments. The first is a regular expression pattern to compile
132764 ** the second is a string to match against that pattern. If either 
132765 ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
132766 ** is 1 if the string matches the pattern, or 0 otherwise.
132767 **
132768 ** SQLite maps the regexp() function to the regexp() operator such
132769 ** that the following two are equivalent:
132770 **
132771 **     zString REGEXP zPattern
132772 **     regexp(zPattern, zString)
132773 **
132774 ** Uses the following ICU regexp APIs:
132775 **
132776 **     uregex_open()
132777 **     uregex_matches()
132778 **     uregex_close()
132779 */
132780 static void icuRegexpFunc(sqlcipher3_context *p, int nArg, sqlcipher3_value **apArg){
132781   UErrorCode status = U_ZERO_ERROR;
132782   URegularExpression *pExpr;
132783   UBool res;
132784   const UChar *zString = sqlcipher3_value_text16(apArg[1]);
132785
132786   (void)nArg;  /* Unused parameter */
132787
132788   /* If the left hand side of the regexp operator is NULL, 
132789   ** then the result is also NULL. 
132790   */
132791   if( !zString ){
132792     return;
132793   }
132794
132795   pExpr = sqlcipher3_get_auxdata(p, 0);
132796   if( !pExpr ){
132797     const UChar *zPattern = sqlcipher3_value_text16(apArg[0]);
132798     if( !zPattern ){
132799       return;
132800     }
132801     pExpr = uregex_open(zPattern, -1, 0, 0, &status);
132802
132803     if( U_SUCCESS(status) ){
132804       sqlcipher3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
132805     }else{
132806       assert(!pExpr);
132807       icuFunctionError(p, "uregex_open", status);
132808       return;
132809     }
132810   }
132811
132812   /* Configure the text that the regular expression operates on. */
132813   uregex_setText(pExpr, zString, -1, &status);
132814   if( !U_SUCCESS(status) ){
132815     icuFunctionError(p, "uregex_setText", status);
132816     return;
132817   }
132818
132819   /* Attempt the match */
132820   res = uregex_matches(pExpr, 0, &status);
132821   if( !U_SUCCESS(status) ){
132822     icuFunctionError(p, "uregex_matches", status);
132823     return;
132824   }
132825
132826   /* Set the text that the regular expression operates on to a NULL
132827   ** pointer. This is not really necessary, but it is tidier than 
132828   ** leaving the regular expression object configured with an invalid
132829   ** pointer after this function returns.
132830   */
132831   uregex_setText(pExpr, 0, 0, &status);
132832
132833   /* Return 1 or 0. */
132834   sqlcipher3_result_int(p, res ? 1 : 0);
132835 }
132836
132837 /*
132838 ** Implementations of scalar functions for case mapping - upper() and 
132839 ** lower(). Function upper() converts its input to upper-case (ABC).
132840 ** Function lower() converts to lower-case (abc).
132841 **
132842 ** ICU provides two types of case mapping, "general" case mapping and
132843 ** "language specific". Refer to ICU documentation for the differences
132844 ** between the two.
132845 **
132846 ** To utilise "general" case mapping, the upper() or lower() scalar 
132847 ** functions are invoked with one argument:
132848 **
132849 **     upper('ABC') -> 'abc'
132850 **     lower('abc') -> 'ABC'
132851 **
132852 ** To access ICU "language specific" case mapping, upper() or lower()
132853 ** should be invoked with two arguments. The second argument is the name
132854 ** of the locale to use. Passing an empty string ("") or SQL NULL value
132855 ** as the second argument is the same as invoking the 1 argument version
132856 ** of upper() or lower().
132857 **
132858 **     lower('I', 'en_us') -> 'i'
132859 **     lower('I', 'tr_tr') -> 'ı' (small dotless i)
132860 **
132861 ** http://www.icu-project.org/userguide/posix.html#case_mappings
132862 */
132863 static void icuCaseFunc16(sqlcipher3_context *p, int nArg, sqlcipher3_value **apArg){
132864   const UChar *zInput;
132865   UChar *zOutput;
132866   int nInput;
132867   int nOutput;
132868
132869   UErrorCode status = U_ZERO_ERROR;
132870   const char *zLocale = 0;
132871
132872   assert(nArg==1 || nArg==2);
132873   if( nArg==2 ){
132874     zLocale = (const char *)sqlcipher3_value_text(apArg[1]);
132875   }
132876
132877   zInput = sqlcipher3_value_text16(apArg[0]);
132878   if( !zInput ){
132879     return;
132880   }
132881   nInput = sqlcipher3_value_bytes16(apArg[0]);
132882
132883   nOutput = nInput * 2 + 2;
132884   zOutput = sqlcipher3_malloc(nOutput);
132885   if( !zOutput ){
132886     return;
132887   }
132888
132889   if( sqlcipher3_user_data(p) ){
132890     u_strToUpper(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
132891   }else{
132892     u_strToLower(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
132893   }
132894
132895   if( !U_SUCCESS(status) ){
132896     icuFunctionError(p, "u_strToLower()/u_strToUpper", status);
132897     return;
132898   }
132899
132900   sqlcipher3_result_text16(p, zOutput, -1, xFree);
132901 }
132902
132903 /*
132904 ** Collation sequence destructor function. The pCtx argument points to
132905 ** a UCollator structure previously allocated using ucol_open().
132906 */
132907 static void icuCollationDel(void *pCtx){
132908   UCollator *p = (UCollator *)pCtx;
132909   ucol_close(p);
132910 }
132911
132912 /*
132913 ** Collation sequence comparison function. The pCtx argument points to
132914 ** a UCollator structure previously allocated using ucol_open().
132915 */
132916 static int icuCollationColl(
132917   void *pCtx,
132918   int nLeft,
132919   const void *zLeft,
132920   int nRight,
132921   const void *zRight
132922 ){
132923   UCollationResult res;
132924   UCollator *p = (UCollator *)pCtx;
132925   res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);
132926   switch( res ){
132927     case UCOL_LESS:    return -1;
132928     case UCOL_GREATER: return +1;
132929     case UCOL_EQUAL:   return 0;
132930   }
132931   assert(!"Unexpected return value from ucol_strcoll()");
132932   return 0;
132933 }
132934
132935 /*
132936 ** Implementation of the scalar function icu_load_collation().
132937 **
132938 ** This scalar function is used to add ICU collation based collation 
132939 ** types to an SQLite database connection. It is intended to be called
132940 ** as follows:
132941 **
132942 **     SELECT icu_load_collation(<locale>, <collation-name>);
132943 **
132944 ** Where <locale> is a string containing an ICU locale identifier (i.e.
132945 ** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the
132946 ** collation sequence to create.
132947 */
132948 static void icuLoadCollation(
132949   sqlcipher3_context *p, 
132950   int nArg, 
132951   sqlcipher3_value **apArg
132952 ){
132953   sqlcipher3 *db = (sqlcipher3 *)sqlcipher3_user_data(p);
132954   UErrorCode status = U_ZERO_ERROR;
132955   const char *zLocale;      /* Locale identifier - (eg. "jp_JP") */
132956   const char *zName;        /* SQL Collation sequence name (eg. "japanese") */
132957   UCollator *pUCollator;    /* ICU library collation object */
132958   int rc;                   /* Return code from sqlcipher3_create_collation_x() */
132959
132960   assert(nArg==2);
132961   zLocale = (const char *)sqlcipher3_value_text(apArg[0]);
132962   zName = (const char *)sqlcipher3_value_text(apArg[1]);
132963
132964   if( !zLocale || !zName ){
132965     return;
132966   }
132967
132968   pUCollator = ucol_open(zLocale, &status);
132969   if( !U_SUCCESS(status) ){
132970     icuFunctionError(p, "ucol_open", status);
132971     return;
132972   }
132973   assert(p);
132974
132975   rc = sqlcipher3_create_collation_v2(db, zName, SQLCIPHER_UTF16, (void *)pUCollator, 
132976       icuCollationColl, icuCollationDel
132977   );
132978   if( rc!=SQLCIPHER_OK ){
132979     ucol_close(pUCollator);
132980     sqlcipher3_result_error(p, "Error registering collation function", -1);
132981   }
132982 }
132983
132984 /*
132985 ** Register the ICU extension functions with database db.
132986 */
132987 SQLCIPHER_PRIVATE int sqlcipher3IcuInit(sqlcipher3 *db){
132988   struct IcuScalar {
132989     const char *zName;                        /* Function name */
132990     int nArg;                                 /* Number of arguments */
132991     int enc;                                  /* Optimal text encoding */
132992     void *pContext;                           /* sqlcipher3_user_data() context */
132993     void (*xFunc)(sqlcipher3_context*,int,sqlcipher3_value**);
132994   } scalars[] = {
132995     {"regexp", 2, SQLCIPHER_ANY,          0, icuRegexpFunc},
132996
132997     {"lower",  1, SQLCIPHER_UTF16,        0, icuCaseFunc16},
132998     {"lower",  2, SQLCIPHER_UTF16,        0, icuCaseFunc16},
132999     {"upper",  1, SQLCIPHER_UTF16, (void*)1, icuCaseFunc16},
133000     {"upper",  2, SQLCIPHER_UTF16, (void*)1, icuCaseFunc16},
133001
133002     {"lower",  1, SQLCIPHER_UTF8,         0, icuCaseFunc16},
133003     {"lower",  2, SQLCIPHER_UTF8,         0, icuCaseFunc16},
133004     {"upper",  1, SQLCIPHER_UTF8,  (void*)1, icuCaseFunc16},
133005     {"upper",  2, SQLCIPHER_UTF8,  (void*)1, icuCaseFunc16},
133006
133007     {"like",   2, SQLCIPHER_UTF8,         0, icuLikeFunc},
133008     {"like",   3, SQLCIPHER_UTF8,         0, icuLikeFunc},
133009
133010     {"icu_load_collation",  2, SQLCIPHER_UTF8, (void*)db, icuLoadCollation},
133011   };
133012
133013   int rc = SQLCIPHER_OK;
133014   int i;
133015
133016   for(i=0; rc==SQLCIPHER_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
133017     struct IcuScalar *p = &scalars[i];
133018     rc = sqlcipher3_create_function(
133019         db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
133020     );
133021   }
133022
133023   return rc;
133024 }
133025
133026 #if !SQLCIPHER_CORE
133027 SQLCIPHER_API int sqlcipher3_extension_init(
133028   sqlcipher3 *db, 
133029   char **pzErrMsg,
133030   const sqlcipher3_api_routines *pApi
133031 ){
133032   SQLCIPHER_EXTENSION_INIT2(pApi)
133033   return sqlcipher3IcuInit(db);
133034 }
133035 #endif
133036
133037 #endif
133038
133039 /************** End of icu.c *************************************************/
133040 /************** Begin file fts3_icu.c ****************************************/
133041 /*
133042 ** 2007 June 22
133043 **
133044 ** The author disclaims copyright to this source code.  In place of
133045 ** a legal notice, here is a blessing:
133046 **
133047 **    May you do good and not evil.
133048 **    May you find forgiveness for yourself and forgive others.
133049 **    May you share freely, never taking more than you give.
133050 **
133051 *************************************************************************
133052 ** This file implements a tokenizer for fts3 based on the ICU library.
133053 */
133054 #if !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3)
133055 #ifdef SQLCIPHER_ENABLE_ICU
133056
133057 /* #include <assert.h> */
133058 /* #include <string.h> */
133059
133060 #include <unicode/ubrk.h>
133061 /* #include <unicode/ucol.h> */
133062 /* #include <unicode/ustring.h> */
133063 #include <unicode/utf16.h>
133064
133065 typedef struct IcuTokenizer IcuTokenizer;
133066 typedef struct IcuCursor IcuCursor;
133067
133068 struct IcuTokenizer {
133069   sqlcipher3_tokenizer base;
133070   char *zLocale;
133071 };
133072
133073 struct IcuCursor {
133074   sqlcipher3_tokenizer_cursor base;
133075
133076   UBreakIterator *pIter;      /* ICU break-iterator object */
133077   int nChar;                  /* Number of UChar elements in pInput */
133078   UChar *aChar;               /* Copy of input using utf-16 encoding */
133079   int *aOffset;               /* Offsets of each character in utf-8 input */
133080
133081   int nBuffer;
133082   char *zBuffer;
133083
133084   int iToken;
133085 };
133086
133087 /*
133088 ** Create a new tokenizer instance.
133089 */
133090 static int icuCreate(
133091   int argc,                            /* Number of entries in argv[] */
133092   const char * const *argv,            /* Tokenizer creation arguments */
133093   sqlcipher3_tokenizer **ppTokenizer      /* OUT: Created tokenizer */
133094 ){
133095   IcuTokenizer *p;
133096   int n = 0;
133097
133098   if( argc>0 ){
133099     n = strlen(argv[0])+1;
133100   }
133101   p = (IcuTokenizer *)sqlcipher3_malloc(sizeof(IcuTokenizer)+n);
133102   if( !p ){
133103     return SQLCIPHER_NOMEM;
133104   }
133105   memset(p, 0, sizeof(IcuTokenizer));
133106
133107   if( n ){
133108     p->zLocale = (char *)&p[1];
133109     memcpy(p->zLocale, argv[0], n);
133110   }
133111
133112   *ppTokenizer = (sqlcipher3_tokenizer *)p;
133113
133114   return SQLCIPHER_OK;
133115 }
133116
133117 /*
133118 ** Destroy a tokenizer
133119 */
133120 static int icuDestroy(sqlcipher3_tokenizer *pTokenizer){
133121   IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
133122   sqlcipher3_free(p);
133123   return SQLCIPHER_OK;
133124 }
133125
133126 /*
133127 ** Prepare to begin tokenizing a particular string.  The input
133128 ** string to be tokenized is pInput[0..nBytes-1].  A cursor
133129 ** used to incrementally tokenize this string is returned in 
133130 ** *ppCursor.
133131 */
133132 static int icuOpen(
133133   sqlcipher3_tokenizer *pTokenizer,         /* The tokenizer */
133134   const char *zInput,                    /* Input string */
133135   int nInput,                            /* Length of zInput in bytes */
133136   sqlcipher3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
133137 ){
133138   IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
133139   IcuCursor *pCsr;
133140
133141   const int32_t opt = U_FOLD_CASE_DEFAULT;
133142   UErrorCode status = U_ZERO_ERROR;
133143   int nChar;
133144
133145   UChar32 c;
133146   int iInput = 0;
133147   int iOut = 0;
133148
133149   *ppCursor = 0;
133150
133151   if( nInput<0 ){
133152     nInput = strlen(zInput);
133153   }
133154   nChar = nInput+1;
133155   pCsr = (IcuCursor *)sqlcipher3_malloc(
133156       sizeof(IcuCursor) +                /* IcuCursor */
133157       nChar * sizeof(UChar) +            /* IcuCursor.aChar[] */
133158       (nChar+1) * sizeof(int)            /* IcuCursor.aOffset[] */
133159   );
133160   if( !pCsr ){
133161     return SQLCIPHER_NOMEM;
133162   }
133163   memset(pCsr, 0, sizeof(IcuCursor));
133164   pCsr->aChar = (UChar *)&pCsr[1];
133165   pCsr->aOffset = (int *)&pCsr->aChar[nChar];
133166
133167   pCsr->aOffset[iOut] = iInput;
133168   U8_NEXT(zInput, iInput, nInput, c); 
133169   while( c>0 ){
133170     int isError = 0;
133171     c = u_foldCase(c, opt);
133172     U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
133173     if( isError ){
133174       sqlcipher3_free(pCsr);
133175       return SQLCIPHER_ERROR;
133176     }
133177     pCsr->aOffset[iOut] = iInput;
133178
133179     if( iInput<nInput ){
133180       U8_NEXT(zInput, iInput, nInput, c);
133181     }else{
133182       c = 0;
133183     }
133184   }
133185
133186   pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
133187   if( !U_SUCCESS(status) ){
133188     sqlcipher3_free(pCsr);
133189     return SQLCIPHER_ERROR;
133190   }
133191   pCsr->nChar = iOut;
133192
133193   ubrk_first(pCsr->pIter);
133194   *ppCursor = (sqlcipher3_tokenizer_cursor *)pCsr;
133195   return SQLCIPHER_OK;
133196 }
133197
133198 /*
133199 ** Close a tokenization cursor previously opened by a call to icuOpen().
133200 */
133201 static int icuClose(sqlcipher3_tokenizer_cursor *pCursor){
133202   IcuCursor *pCsr = (IcuCursor *)pCursor;
133203   ubrk_close(pCsr->pIter);
133204   sqlcipher3_free(pCsr->zBuffer);
133205   sqlcipher3_free(pCsr);
133206   return SQLCIPHER_OK;
133207 }
133208
133209 /*
133210 ** Extract the next token from a tokenization cursor.
133211 */
133212 static int icuNext(
133213   sqlcipher3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
133214   const char **ppToken,               /* OUT: *ppToken is the token text */
133215   int *pnBytes,                       /* OUT: Number of bytes in token */
133216   int *piStartOffset,                 /* OUT: Starting offset of token */
133217   int *piEndOffset,                   /* OUT: Ending offset of token */
133218   int *piPosition                     /* OUT: Position integer of token */
133219 ){
133220   IcuCursor *pCsr = (IcuCursor *)pCursor;
133221
133222   int iStart = 0;
133223   int iEnd = 0;
133224   int nByte = 0;
133225
133226   while( iStart==iEnd ){
133227     UChar32 c;
133228
133229     iStart = ubrk_current(pCsr->pIter);
133230     iEnd = ubrk_next(pCsr->pIter);
133231     if( iEnd==UBRK_DONE ){
133232       return SQLCIPHER_DONE;
133233     }
133234
133235     while( iStart<iEnd ){
133236       int iWhite = iStart;
133237       U8_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
133238       if( u_isspace(c) ){
133239         iStart = iWhite;
133240       }else{
133241         break;
133242       }
133243     }
133244     assert(iStart<=iEnd);
133245   }
133246
133247   do {
133248     UErrorCode status = U_ZERO_ERROR;
133249     if( nByte ){
133250       char *zNew = sqlcipher3_realloc(pCsr->zBuffer, nByte);
133251       if( !zNew ){
133252         return SQLCIPHER_NOMEM;
133253       }
133254       pCsr->zBuffer = zNew;
133255       pCsr->nBuffer = nByte;
133256     }
133257
133258     u_strToUTF8(
133259         pCsr->zBuffer, pCsr->nBuffer, &nByte,    /* Output vars */
133260         &pCsr->aChar[iStart], iEnd-iStart,       /* Input vars */
133261         &status                                  /* Output success/failure */
133262     );
133263   } while( nByte>pCsr->nBuffer );
133264
133265   *ppToken = pCsr->zBuffer;
133266   *pnBytes = nByte;
133267   *piStartOffset = pCsr->aOffset[iStart];
133268   *piEndOffset = pCsr->aOffset[iEnd];
133269   *piPosition = pCsr->iToken++;
133270
133271   return SQLCIPHER_OK;
133272 }
133273
133274 /*
133275 ** The set of routines that implement the simple tokenizer
133276 */
133277 static const sqlcipher3_tokenizer_module icuTokenizerModule = {
133278   0,                           /* iVersion */
133279   icuCreate,                   /* xCreate  */
133280   icuDestroy,                  /* xCreate  */
133281   icuOpen,                     /* xOpen    */
133282   icuClose,                    /* xClose   */
133283   icuNext,                     /* xNext    */
133284 };
133285
133286 /*
133287 ** Set *ppModule to point at the implementation of the ICU tokenizer.
133288 */
133289 SQLCIPHER_PRIVATE void sqlcipher3Fts3IcuTokenizerModule(
133290   sqlcipher3_tokenizer_module const**ppModule
133291 ){
133292   *ppModule = &icuTokenizerModule;
133293 }
133294
133295 #endif /* defined(SQLCIPHER_ENABLE_ICU) */
133296 #endif /* !defined(SQLCIPHER_CORE) || defined(SQLCIPHER_ENABLE_FTS3) */
133297
133298 #pragma GCC diagnostic pop
133299 /************** End of fts3_icu.c ********************************************/