1/*
2** 2014 August 30
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12**
13**
14** OVERVIEW
15**
16** The RBU extension requires that the RBU update be packaged as an
17** SQLite database. The tables it expects to find are described in
18** sqlite3rbu.h. Essentially, for each table xyz in the target database
19** that the user wishes to write to, a corresponding data_xyz table is
20** created in the RBU database and populated with one row for each row to
21** update, insert or delete from the target table.
22**
23** The update proceeds in three stages:
24**
25** 1) The database is updated. The modified database pages are written
26** to a *-oal file. A *-oal file is just like a *-wal file, except
27** that it is named "<database>-oal" instead of "<database>-wal".
28** Because regular SQLite clients do not look for file named
29** "<database>-oal", they go on using the original database in
30** rollback mode while the *-oal file is being generated.
31**
32** During this stage RBU does not update the database by writing
33** directly to the target tables. Instead it creates "imposter"
34** tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses
35** to update each b-tree individually. All updates required by each
36** b-tree are completed before moving on to the next, and all
37** updates are done in sorted key order.
38**
39** 2) The "<database>-oal" file is moved to the equivalent "<database>-wal"
40** location using a call to rename(2). Before doing this the RBU
41** module takes an EXCLUSIVE lock on the database file, ensuring
42** that there are no other active readers.
43**
44** Once the EXCLUSIVE lock is released, any other database readers
45** detect the new *-wal file and read the database in wal mode. At
46** this point they see the new version of the database - including
47** the updates made as part of the RBU update.
48**
49** 3) The new *-wal file is checkpointed. This proceeds in the same way
50** as a regular database checkpoint, except that a single frame is
51** checkpointed each time sqlite3rbu_step() is called. If the RBU
52** handle is closed before the entire *-wal file is checkpointed,
53** the checkpoint progress is saved in the RBU database and the
54** checkpoint can be resumed by another RBU client at some point in
55** the future.
56**
57** POTENTIAL PROBLEMS
58**
59** The rename() call might not be portable. And RBU is not currently
60** syncing the directory after renaming the file.
61**
62** When state is saved, any commit to the *-oal file and the commit to
63** the RBU update database are not atomic. So if the power fails at the
64** wrong moment they might get out of sync. As the main database will be
65** committed before the RBU update database this will likely either just
66** pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE
67** constraint violations).
68**
69** If some client does modify the target database mid RBU update, or some
70** other error occurs, the RBU extension will keep throwing errors. It's
71** not really clear how to get out of this state. The system could just
72** by delete the RBU update database and *-oal file and have the device
73** download the update again and start over.
74**
75** At present, for an UPDATE, both the new.* and old.* records are
76** collected in the rbu_xyz table. And for both UPDATEs and DELETEs all
77** fields are collected. This means we're probably writing a lot more
78** data to disk when saving the state of an ongoing update to the RBU
79** update database than is strictly necessary.
80**
81*/
82
83#include <assert.h>
84#include <string.h>
85#include <stdio.h>
86
87#include "sqlite3.h"
88
89#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
90#include "sqlite3rbu.h"
91
92#if defined(_WIN32_WCE)
93#include "windows.h"
94#endif
95
96/* Maximum number of prepared UPDATE statements held by this module */
97#define SQLITE_RBU_UPDATE_CACHESIZE 16
98
99/* Delta checksums disabled by default. Compile with -DRBU_ENABLE_DELTA_CKSUM
100** to enable checksum verification.
101*/
102#ifndef RBU_ENABLE_DELTA_CKSUM
103# define RBU_ENABLE_DELTA_CKSUM 0
104#endif
105
106/*
107** Swap two objects of type TYPE.
108*/
109#if !defined(SQLITE_AMALGAMATION)
110# define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
111#endif
112
113/*
114** Name of the URI option that causes RBU to take an exclusive lock as
115** part of the incremental checkpoint operation.
116*/
117#define RBU_EXCLUSIVE_CHECKPOINT "rbu_exclusive_checkpoint"
118
119
120/*
121** The rbu_state table is used to save the state of a partially applied
122** update so that it can be resumed later. The table consists of integer
123** keys mapped to values as follows:
124**
125** RBU_STATE_STAGE:
126** May be set to integer values 1, 2, 4 or 5. As follows:
127** 1: the *-rbu file is currently under construction.
128** 2: the *-rbu file has been constructed, but not yet moved
129** to the *-wal path.
130** 4: the checkpoint is underway.
131** 5: the rbu update has been checkpointed.
132**
133** RBU_STATE_TBL:
134** Only valid if STAGE==1. The target database name of the table
135** currently being written.
136**
137** RBU_STATE_IDX:
138** Only valid if STAGE==1. The target database name of the index
139** currently being written, or NULL if the main table is currently being
140** updated.
141**
142** RBU_STATE_ROW:
143** Only valid if STAGE==1. Number of rows already processed for the current
144** table/index.
145**
146** RBU_STATE_PROGRESS:
147** Trbul number of sqlite3rbu_step() calls made so far as part of this
148** rbu update.
149**
150** RBU_STATE_CKPT:
151** Valid if STAGE==4. The 64-bit checksum associated with the wal-index
152** header created by recovering the *-wal file. This is used to detect
153** cases when another client appends frames to the *-wal file in the
154** middle of an incremental checkpoint (an incremental checkpoint cannot
155** be continued if this happens).
156**
157** RBU_STATE_COOKIE:
158** Valid if STAGE==1. The current change-counter cookie value in the
159** target db file.
160**
161** RBU_STATE_OALSZ:
162** Valid if STAGE==1. The size in bytes of the *-oal file.
163**
164** RBU_STATE_DATATBL:
165** Only valid if STAGE==1. The RBU database name of the table
166** currently being read.
167*/
168#define RBU_STATE_STAGE 1
169#define RBU_STATE_TBL 2
170#define RBU_STATE_IDX 3
171#define RBU_STATE_ROW 4
172#define RBU_STATE_PROGRESS 5
173#define RBU_STATE_CKPT 6
174#define RBU_STATE_COOKIE 7
175#define RBU_STATE_OALSZ 8
176#define RBU_STATE_PHASEONESTEP 9
177#define RBU_STATE_DATATBL 10
178
179#define RBU_STAGE_OAL 1
180#define RBU_STAGE_MOVE 2
181#define RBU_STAGE_CAPTURE 3
182#define RBU_STAGE_CKPT 4
183#define RBU_STAGE_DONE 5
184
185
186#define RBU_CREATE_STATE \
187 "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)"
188
189typedef struct RbuFrame RbuFrame;
190typedef struct RbuObjIter RbuObjIter;
191typedef struct RbuState RbuState;
192typedef struct RbuSpan RbuSpan;
193typedef struct rbu_vfs rbu_vfs;
194typedef struct rbu_file rbu_file;
195typedef struct RbuUpdateStmt RbuUpdateStmt;
196
197#if !defined(SQLITE_AMALGAMATION)
198typedef unsigned int u32;
199typedef unsigned short u16;
200typedef unsigned char u8;
201typedef sqlite3_int64 i64;
202#endif
203
204/*
205** These values must match the values defined in wal.c for the equivalent
206** locks. These are not magic numbers as they are part of the SQLite file
207** format.
208*/
209#define WAL_LOCK_WRITE 0
210#define WAL_LOCK_CKPT 1
211#define WAL_LOCK_READ0 3
212
213#define SQLITE_FCNTL_RBUCNT 5149216
214
215/*
216** A structure to store values read from the rbu_state table in memory.
217*/
218struct RbuState {
219 int eStage;
220 char *zTbl;
221 char *zDataTbl;
222 char *zIdx;
223 i64 iWalCksum;
224 int nRow;
225 i64 nProgress;
226 u32 iCookie;
227 i64 iOalSz;
228 i64 nPhaseOneStep;
229};
230
231struct RbuUpdateStmt {
232 char *zMask; /* Copy of update mask used with pUpdate */
233 sqlite3_stmt *pUpdate; /* Last update statement (or NULL) */
234 RbuUpdateStmt *pNext;
235};
236
237struct RbuSpan {
238 const char *zSpan;
239 int nSpan;
240};
241
242/*
243** An iterator of this type is used to iterate through all objects in
244** the target database that require updating. For each such table, the
245** iterator visits, in order:
246**
247** * the table itself,
248** * each index of the table (zero or more points to visit), and
249** * a special "cleanup table" state.
250**
251** abIndexed:
252** If the table has no indexes on it, abIndexed is set to NULL. Otherwise,
253** it points to an array of flags nTblCol elements in size. The flag is
254** set for each column that is either a part of the PK or a part of an
255** index. Or clear otherwise.
256**
257** If there are one or more partial indexes on the table, all fields of
258** this array set set to 1. This is because in that case, the module has
259** no way to tell which fields will be required to add and remove entries
260** from the partial indexes.
261**
262*/
263struct RbuObjIter {
264 sqlite3_stmt *pTblIter; /* Iterate through tables */
265 sqlite3_stmt *pIdxIter; /* Index iterator */
266 int nTblCol; /* Size of azTblCol[] array */
267 char **azTblCol; /* Array of unquoted target column names */
268 char **azTblType; /* Array of target column types */
269 int *aiSrcOrder; /* src table col -> target table col */
270 u8 *abTblPk; /* Array of flags, set on target PK columns */
271 u8 *abNotNull; /* Array of flags, set on NOT NULL columns */
272 u8 *abIndexed; /* Array of flags, set on indexed & PK cols */
273 int eType; /* Table type - an RBU_PK_XXX value */
274
275 /* Output variables. zTbl==0 implies EOF. */
276 int bCleanup; /* True in "cleanup" state */
277 const char *zTbl; /* Name of target db table */
278 const char *zDataTbl; /* Name of rbu db table (or null) */
279 const char *zIdx; /* Name of target db index (or null) */
280 int iTnum; /* Root page of current object */
281 int iPkTnum; /* If eType==EXTERNAL, root of PK index */
282 int bUnique; /* Current index is unique */
283 int nIndex; /* Number of aux. indexes on table zTbl */
284
285 /* Statements created by rbuObjIterPrepareAll() */
286 int nCol; /* Number of columns in current object */
287 sqlite3_stmt *pSelect; /* Source data */
288 sqlite3_stmt *pInsert; /* Statement for INSERT operations */
289 sqlite3_stmt *pDelete; /* Statement for DELETE ops */
290 sqlite3_stmt *pTmpInsert; /* Insert into rbu_tmp_$zDataTbl */
291 int nIdxCol;
292 RbuSpan *aIdxCol;
293 char *zIdxSql;
294
295 /* Last UPDATE used (for PK b-tree updates only), or NULL. */
296 RbuUpdateStmt *pRbuUpdate;
297};
298
299/*
300** Values for RbuObjIter.eType
301**
302** 0: Table does not exist (error)
303** 1: Table has an implicit rowid.
304** 2: Table has an explicit IPK column.
305** 3: Table has an external PK index.
306** 4: Table is WITHOUT ROWID.
307** 5: Table is a virtual table.
308*/
309#define RBU_PK_NOTABLE 0
310#define RBU_PK_NONE 1
311#define RBU_PK_IPK 2
312#define RBU_PK_EXTERNAL 3
313#define RBU_PK_WITHOUT_ROWID 4
314#define RBU_PK_VTAB 5
315
316
317/*
318** Within the RBU_STAGE_OAL stage, each call to sqlite3rbu_step() performs
319** one of the following operations.
320*/
321#define RBU_INSERT 1 /* Insert on a main table b-tree */
322#define RBU_DELETE 2 /* Delete a row from a main table b-tree */
323#define RBU_REPLACE 3 /* Delete and then insert a row */
324#define RBU_IDX_DELETE 4 /* Delete a row from an aux. index b-tree */
325#define RBU_IDX_INSERT 5 /* Insert on an aux. index b-tree */
326
327#define RBU_UPDATE 6 /* Update a row in a main table b-tree */
328
329/*
330** A single step of an incremental checkpoint - frame iWalFrame of the wal
331** file should be copied to page iDbPage of the database file.
332*/
333struct RbuFrame {
334 u32 iDbPage;
335 u32 iWalFrame;
336};
337
338/*
339** RBU handle.
340**
341** nPhaseOneStep:
342** If the RBU database contains an rbu_count table, this value is set to
343** a running estimate of the number of b-tree operations required to
344** finish populating the *-oal file. This allows the sqlite3_bp_progress()
345** API to calculate the permyriadage progress of populating the *-oal file
346** using the formula:
347**
348** permyriadage = (10000 * nProgress) / nPhaseOneStep
349**
350** nPhaseOneStep is initialized to the sum of:
351**
352** nRow * (nIndex + 1)
353**
354** for all source tables in the RBU database, where nRow is the number
355** of rows in the source table and nIndex the number of indexes on the
356** corresponding target database table.
357**
358** This estimate is accurate if the RBU update consists entirely of
359** INSERT operations. However, it is inaccurate if:
360**
361** * the RBU update contains any UPDATE operations. If the PK specified
362** for an UPDATE operation does not exist in the target table, then
363** no b-tree operations are required on index b-trees. Or if the
364** specified PK does exist, then (nIndex*2) such operations are
365** required (one delete and one insert on each index b-tree).
366**
367** * the RBU update contains any DELETE operations for which the specified
368** PK does not exist. In this case no operations are required on index
369** b-trees.
370**
371** * the RBU update contains REPLACE operations. These are similar to
372** UPDATE operations.
373**
374** nPhaseOneStep is updated to account for the conditions above during the
375** first pass of each source table. The updated nPhaseOneStep value is
376** stored in the rbu_state table if the RBU update is suspended.
377*/
378struct sqlite3rbu {
379 int eStage; /* Value of RBU_STATE_STAGE field */
380 sqlite3 *dbMain; /* target database handle */
381 sqlite3 *dbRbu; /* rbu database handle */
382 char *zTarget; /* Path to target db */
383 char *zRbu; /* Path to rbu db */
384 char *zState; /* Path to state db (or NULL if zRbu) */
385 char zStateDb[5]; /* Db name for state ("stat" or "main") */
386 int rc; /* Value returned by last rbu_step() call */
387 char *zErrmsg; /* Error message if rc!=SQLITE_OK */
388 int nStep; /* Rows processed for current object */
389 int nProgress; /* Rows processed for all objects */
390 RbuObjIter objiter; /* Iterator for skipping through tbl/idx */
391 const char *zVfsName; /* Name of automatically created rbu vfs */
392 rbu_file *pTargetFd; /* File handle open on target db */
393 int nPagePerSector; /* Pages per sector for pTargetFd */
394 i64 iOalSz;
395 i64 nPhaseOneStep;
396 void *pRenameArg;
397 int (*xRename)(void*, const char*, const char*);
398
399 /* The following state variables are used as part of the incremental
400 ** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding
401 ** function rbuSetupCheckpoint() for details. */
402 u32 iMaxFrame; /* Largest iWalFrame value in aFrame[] */
403 u32 mLock;
404 int nFrame; /* Entries in aFrame[] array */
405 int nFrameAlloc; /* Allocated size of aFrame[] array */
406 RbuFrame *aFrame;
407 int pgsz;
408 u8 *aBuf;
409 i64 iWalCksum;
410 i64 szTemp; /* Current size of all temp files in use */
411 i64 szTempLimit; /* Total size limit for temp files */
412
413 /* Used in RBU vacuum mode only */
414 int nRbu; /* Number of RBU VFS in the stack */
415 rbu_file *pRbuFd; /* Fd for main db of dbRbu */
416};
417
418/*
419** An rbu VFS is implemented using an instance of this structure.
420**
421** Variable pRbu is only non-NULL for automatically created RBU VFS objects.
422** It is NULL for RBU VFS objects created explicitly using
423** sqlite3rbu_create_vfs(). It is used to track the total amount of temp
424** space used by the RBU handle.
425*/
426struct rbu_vfs {
427 sqlite3_vfs base; /* rbu VFS shim methods */
428 sqlite3_vfs *pRealVfs; /* Underlying VFS */
429 sqlite3_mutex *mutex; /* Mutex to protect pMain */
430 sqlite3rbu *pRbu; /* Owner RBU object */
431 rbu_file *pMain; /* List of main db files */
432 rbu_file *pMainRbu; /* List of main db files with pRbu!=0 */
433};
434
435/*
436** Each file opened by an rbu VFS is represented by an instance of
437** the following structure.
438**
439** If this is a temporary file (pRbu!=0 && flags&DELETE_ON_CLOSE), variable
440** "sz" is set to the current size of the database file.
441*/
442struct rbu_file {
443 sqlite3_file base; /* sqlite3_file methods */
444 sqlite3_file *pReal; /* Underlying file handle */
445 rbu_vfs *pRbuVfs; /* Pointer to the rbu_vfs object */
446 sqlite3rbu *pRbu; /* Pointer to rbu object (rbu target only) */
447 i64 sz; /* Size of file in bytes (temp only) */
448
449 int openFlags; /* Flags this file was opened with */
450 u32 iCookie; /* Cookie value for main db files */
451 u8 iWriteVer; /* "write-version" value for main db files */
452 u8 bNolock; /* True to fail EXCLUSIVE locks */
453
454 int nShm; /* Number of entries in apShm[] array */
455 char **apShm; /* Array of mmap'd *-shm regions */
456 char *zDel; /* Delete this when closing file */
457
458 const char *zWal; /* Wal filename for this main db file */
459 rbu_file *pWalFd; /* Wal file descriptor for this main db */
460 rbu_file *pMainNext; /* Next MAIN_DB file */
461 rbu_file *pMainRbuNext; /* Next MAIN_DB file with pRbu!=0 */
462};
463
464/*
465** True for an RBU vacuum handle, or false otherwise.
466*/
467#define rbuIsVacuum(p) ((p)->zTarget==0)
468
469
470/*************************************************************************
471** The following three functions, found below:
472**
473** rbuDeltaGetInt()
474** rbuDeltaChecksum()
475** rbuDeltaApply()
476**
477** are lifted from the fossil source code (http://fossil-scm.org). They
478** are used to implement the scalar SQL function rbu_fossil_delta().
479*/
480
481/*
482** Read bytes from *pz and convert them into a positive integer. When
483** finished, leave *pz pointing to the first character past the end of
484** the integer. The *pLen parameter holds the length of the string
485** in *pz and is decremented once for each character in the integer.
486*/
487static unsigned int rbuDeltaGetInt(const char **pz, int *pLen){
488 static const signed char zValue[] = {
489 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
490 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
491 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
492 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
493 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
494 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, 36,
495 -1, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
496 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, -1, -1, 63, -1,
497 };
498 unsigned int v = 0;
499 int c;
500 unsigned char *z = (unsigned char*)*pz;
501 unsigned char *zStart = z;
502 while( (c = zValue[0x7f&*(z++)])>=0 ){
503 v = (v<<6) + c;
504 }
505 z--;
506 *pLen -= z - zStart;
507 *pz = (char*)z;
508 return v;
509}
510
511#if RBU_ENABLE_DELTA_CKSUM
512/*
513** Compute a 32-bit checksum on the N-byte buffer. Return the result.
514*/
515static unsigned int rbuDeltaChecksum(const char *zIn, size_t N){
516 const unsigned char *z = (const unsigned char *)zIn;
517 unsigned sum0 = 0;
518 unsigned sum1 = 0;
519 unsigned sum2 = 0;
520 unsigned sum3 = 0;
521 while(N >= 16){
522 sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]);
523 sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]);
524 sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]);
525 sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]);
526 z += 16;
527 N -= 16;
528 }
529 while(N >= 4){
530 sum0 += z[0];
531 sum1 += z[1];
532 sum2 += z[2];
533 sum3 += z[3];
534 z += 4;
535 N -= 4;
536 }
537 sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24);
538 switch(N){
539 case 3: sum3 += (z[2] << 8);
540 case 2: sum3 += (z[1] << 16);
541 case 1: sum3 += (z[0] << 24);
542 default: ;
543 }
544 return sum3;
545}
546#endif
547
548/*
549** Apply a delta.
550**
551** The output buffer should be big enough to hold the whole output
552** file and a NUL terminator at the end. The delta_output_size()
553** routine will determine this size for you.
554**
555** The delta string should be null-terminated. But the delta string
556** may contain embedded NUL characters (if the input and output are
557** binary files) so we also have to pass in the length of the delta in
558** the lenDelta parameter.
559**
560** This function returns the size of the output file in bytes (excluding
561** the final NUL terminator character). Except, if the delta string is
562** malformed or intended for use with a source file other than zSrc,
563** then this routine returns -1.
564**
565** Refer to the delta_create() documentation above for a description
566** of the delta file format.
567*/
568static int rbuDeltaApply(
569 const char *zSrc, /* The source or pattern file */
570 int lenSrc, /* Length of the source file */
571 const char *zDelta, /* Delta to apply to the pattern */
572 int lenDelta, /* Length of the delta */
573 char *zOut /* Write the output into this preallocated buffer */
574){
575 unsigned int limit;
576 unsigned int total = 0;
577#if RBU_ENABLE_DELTA_CKSUM
578 char *zOrigOut = zOut;
579#endif
580
581 limit = rbuDeltaGetInt(&zDelta, &lenDelta);
582 if( *zDelta!='\n' ){
583 /* ERROR: size integer not terminated by "\n" */
584 return -1;
585 }
586 zDelta++; lenDelta--;
587 while( *zDelta && lenDelta>0 ){
588 unsigned int cnt, ofst;
589 cnt = rbuDeltaGetInt(&zDelta, &lenDelta);
590 switch( zDelta[0] ){
591 case '@': {
592 zDelta++; lenDelta--;
593 ofst = rbuDeltaGetInt(&zDelta, &lenDelta);
594 if( lenDelta>0 && zDelta[0]!=',' ){
595 /* ERROR: copy command not terminated by ',' */
596 return -1;
597 }
598 zDelta++; lenDelta--;
599 total += cnt;
600 if( total>limit ){
601 /* ERROR: copy exceeds output file size */
602 return -1;
603 }
604 if( (int)(ofst+cnt) > lenSrc ){
605 /* ERROR: copy extends past end of input */
606 return -1;
607 }
608 memcpy(zOut, &zSrc[ofst], cnt);
609 zOut += cnt;
610 break;
611 }
612 case ':': {
613 zDelta++; lenDelta--;
614 total += cnt;
615 if( total>limit ){
616 /* ERROR: insert command gives an output larger than predicted */
617 return -1;
618 }
619 if( (int)cnt>lenDelta ){
620 /* ERROR: insert count exceeds size of delta */
621 return -1;
622 }
623 memcpy(zOut, zDelta, cnt);
624 zOut += cnt;
625 zDelta += cnt;
626 lenDelta -= cnt;
627 break;
628 }
629 case ';': {
630 zDelta++; lenDelta--;
631 zOut[0] = 0;
632#if RBU_ENABLE_DELTA_CKSUM
633 if( cnt!=rbuDeltaChecksum(zOrigOut, total) ){
634 /* ERROR: bad checksum */
635 return -1;
636 }
637#endif
638 if( total!=limit ){
639 /* ERROR: generated size does not match predicted size */
640 return -1;
641 }
642 return total;
643 }
644 default: {
645 /* ERROR: unknown delta operator */
646 return -1;
647 }
648 }
649 }
650 /* ERROR: unterminated delta */
651 return -1;
652}
653
654static int rbuDeltaOutputSize(const char *zDelta, int lenDelta){
655 int size;
656 size = rbuDeltaGetInt(&zDelta, &lenDelta);
657 if( *zDelta!='\n' ){
658 /* ERROR: size integer not terminated by "\n" */
659 return -1;
660 }
661 return size;
662}
663
664/*
665** End of code taken from fossil.
666*************************************************************************/
667
668/*
669** Implementation of SQL scalar function rbu_fossil_delta().
670**
671** This function applies a fossil delta patch to a blob. Exactly two
672** arguments must be passed to this function. The first is the blob to
673** patch and the second the patch to apply. If no error occurs, this
674** function returns the patched blob.
675*/
676static void rbuFossilDeltaFunc(
677 sqlite3_context *context,
678 int argc,
679 sqlite3_value **argv
680){
681 const char *aDelta;
682 int nDelta;
683 const char *aOrig;
684 int nOrig;
685
686 int nOut;
687 int nOut2;
688 char *aOut;
689
690 assert( argc==2 );
691
692 nOrig = sqlite3_value_bytes(argv[0]);
693 aOrig = (const char*)sqlite3_value_blob(argv[0]);
694 nDelta = sqlite3_value_bytes(argv[1]);
695 aDelta = (const char*)sqlite3_value_blob(argv[1]);
696
697 /* Figure out the size of the output */
698 nOut = rbuDeltaOutputSize(aDelta, nDelta);
699 if( nOut<0 ){
700 sqlite3_result_error(context, "corrupt fossil delta", -1);
701 return;
702 }
703
704 aOut = sqlite3_malloc(nOut+1);
705 if( aOut==0 ){
706 sqlite3_result_error_nomem(context);
707 }else{
708 nOut2 = rbuDeltaApply(aOrig, nOrig, aDelta, nDelta, aOut);
709 if( nOut2!=nOut ){
710 sqlite3_free(aOut);
711 sqlite3_result_error(context, "corrupt fossil delta", -1);
712 }else{
713 sqlite3_result_blob(context, aOut, nOut, sqlite3_free);
714 }
715 }
716}
717
718
719/*
720** Prepare the SQL statement in buffer zSql against database handle db.
721** If successful, set *ppStmt to point to the new statement and return
722** SQLITE_OK.
723**
724** Otherwise, if an error does occur, set *ppStmt to NULL and return
725** an SQLite error code. Additionally, set output variable *pzErrmsg to
726** point to a buffer containing an error message. It is the responsibility
727** of the caller to (eventually) free this buffer using sqlite3_free().
728*/
729static int prepareAndCollectError(
730 sqlite3 *db,
731 sqlite3_stmt **ppStmt,
732 char **pzErrmsg,
733 const char *zSql
734){
735 int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
736 if( rc!=SQLITE_OK ){
737 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
738 *ppStmt = 0;
739 }
740 return rc;
741}
742
743/*
744** Reset the SQL statement passed as the first argument. Return a copy
745** of the value returned by sqlite3_reset().
746**
747** If an error has occurred, then set *pzErrmsg to point to a buffer
748** containing an error message. It is the responsibility of the caller
749** to eventually free this buffer using sqlite3_free().
750*/
751static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){
752 int rc = sqlite3_reset(pStmt);
753 if( rc!=SQLITE_OK ){
754 *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt)));
755 }
756 return rc;
757}
758
759/*
760** Unless it is NULL, argument zSql points to a buffer allocated using
761** sqlite3_malloc containing an SQL statement. This function prepares the SQL
762** statement against database db and frees the buffer. If statement
763** compilation is successful, *ppStmt is set to point to the new statement
764** handle and SQLITE_OK is returned.
765**
766** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code
767** returned. In this case, *pzErrmsg may also be set to point to an error
768** message. It is the responsibility of the caller to free this error message
769** buffer using sqlite3_free().
770**
771** If argument zSql is NULL, this function assumes that an OOM has occurred.
772** In this case SQLITE_NOMEM is returned and *ppStmt set to NULL.
773*/
774static int prepareFreeAndCollectError(
775 sqlite3 *db,
776 sqlite3_stmt **ppStmt,
777 char **pzErrmsg,
778 char *zSql
779){
780 int rc;
781 assert( *pzErrmsg==0 );
782 if( zSql==0 ){
783 rc = SQLITE_NOMEM;
784 *ppStmt = 0;
785 }else{
786 rc = prepareAndCollectError(db, ppStmt, pzErrmsg, zSql);
787 sqlite3_free(zSql);
788 }
789 return rc;
790}
791
792/*
793** Free the RbuObjIter.azTblCol[] and RbuObjIter.abTblPk[] arrays allocated
794** by an earlier call to rbuObjIterCacheTableInfo().
795*/
796static void rbuObjIterFreeCols(RbuObjIter *pIter){
797 int i;
798 for(i=0; i<pIter->nTblCol; i++){
799 sqlite3_free(pIter->azTblCol[i]);
800 sqlite3_free(pIter->azTblType[i]);
801 }
802 sqlite3_free(pIter->azTblCol);
803 pIter->azTblCol = 0;
804 pIter->azTblType = 0;
805 pIter->aiSrcOrder = 0;
806 pIter->abTblPk = 0;
807 pIter->abNotNull = 0;
808 pIter->nTblCol = 0;
809 pIter->eType = 0; /* Invalid value */
810}
811
812/*
813** Finalize all statements and free all allocations that are specific to
814** the current object (table/index pair).
815*/
816static void rbuObjIterClearStatements(RbuObjIter *pIter){
817 RbuUpdateStmt *pUp;
818
819 sqlite3_finalize(pIter->pSelect);
820 sqlite3_finalize(pIter->pInsert);
821 sqlite3_finalize(pIter->pDelete);
822 sqlite3_finalize(pIter->pTmpInsert);
823 pUp = pIter->pRbuUpdate;
824 while( pUp ){
825 RbuUpdateStmt *pTmp = pUp->pNext;
826 sqlite3_finalize(pUp->pUpdate);
827 sqlite3_free(pUp);
828 pUp = pTmp;
829 }
830 sqlite3_free(pIter->aIdxCol);
831 sqlite3_free(pIter->zIdxSql);
832
833 pIter->pSelect = 0;
834 pIter->pInsert = 0;
835 pIter->pDelete = 0;
836 pIter->pRbuUpdate = 0;
837 pIter->pTmpInsert = 0;
838 pIter->nCol = 0;
839 pIter->nIdxCol = 0;
840 pIter->aIdxCol = 0;
841 pIter->zIdxSql = 0;
842}
843
844/*
845** Clean up any resources allocated as part of the iterator object passed
846** as the only argument.
847*/
848static void rbuObjIterFinalize(RbuObjIter *pIter){
849 rbuObjIterClearStatements(pIter);
850 sqlite3_finalize(pIter->pTblIter);
851 sqlite3_finalize(pIter->pIdxIter);
852 rbuObjIterFreeCols(pIter);
853 memset(pIter, 0, sizeof(RbuObjIter));
854}
855
856/*
857** Advance the iterator to the next position.
858**
859** If no error occurs, SQLITE_OK is returned and the iterator is left
860** pointing to the next entry. Otherwise, an error code and message is
861** left in the RBU handle passed as the first argument. A copy of the
862** error code is returned.
863*/
864static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
865 int rc = p->rc;
866 if( rc==SQLITE_OK ){
867
868 /* Free any SQLite statements used while processing the previous object */
869 rbuObjIterClearStatements(pIter);
870 if( pIter->zIdx==0 ){
871 rc = sqlite3_exec(p->dbMain,
872 "DROP TRIGGER IF EXISTS temp.rbu_insert_tr;"
873 "DROP TRIGGER IF EXISTS temp.rbu_update1_tr;"
874 "DROP TRIGGER IF EXISTS temp.rbu_update2_tr;"
875 "DROP TRIGGER IF EXISTS temp.rbu_delete_tr;"
876 , 0, 0, &p->zErrmsg
877 );
878 }
879
880 if( rc==SQLITE_OK ){
881 if( pIter->bCleanup ){
882 rbuObjIterFreeCols(pIter);
883 pIter->bCleanup = 0;
884 rc = sqlite3_step(pIter->pTblIter);
885 if( rc!=SQLITE_ROW ){
886 rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
887 pIter->zTbl = 0;
888 }else{
889 pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
890 pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
891 rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
892 }
893 }else{
894 if( pIter->zIdx==0 ){
895 sqlite3_stmt *pIdx = pIter->pIdxIter;
896 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
897 }
898 if( rc==SQLITE_OK ){
899 rc = sqlite3_step(pIter->pIdxIter);
900 if( rc!=SQLITE_ROW ){
901 rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
902 pIter->bCleanup = 1;
903 pIter->zIdx = 0;
904 }else{
905 pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
906 pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
907 pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
908 rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
909 }
910 }
911 }
912 }
913 }
914
915 if( rc!=SQLITE_OK ){
916 rbuObjIterFinalize(pIter);
917 p->rc = rc;
918 }
919 return rc;
920}
921
922
923/*
924** The implementation of the rbu_target_name() SQL function. This function
925** accepts one or two arguments. The first argument is the name of a table -
926** the name of a table in the RBU database. The second, if it is present, is 1
927** for a view or 0 for a table.
928**
929** For a non-vacuum RBU handle, if the table name matches the pattern:
930**
931** data[0-9]_<name>
932**
933** where <name> is any sequence of 1 or more characters, <name> is returned.
934** Otherwise, if the only argument does not match the above pattern, an SQL
935** NULL is returned.
936**
937** "data_t1" -> "t1"
938** "data0123_t2" -> "t2"
939** "dataAB_t3" -> NULL
940**
941** For an rbu vacuum handle, a copy of the first argument is returned if
942** the second argument is either missing or 0 (not a view).
943*/
944static void rbuTargetNameFunc(
945 sqlite3_context *pCtx,
946 int argc,
947 sqlite3_value **argv
948){
949 sqlite3rbu *p = sqlite3_user_data(pCtx);
950 const char *zIn;
951 assert( argc==1 || argc==2 );
952
953 zIn = (const char*)sqlite3_value_text(argv[0]);
954 if( zIn ){
955 if( rbuIsVacuum(p) ){
956 assert( argc==2 || argc==1 );
957 if( argc==1 || 0==sqlite3_value_int(argv[1]) ){
958 sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC);
959 }
960 }else{
961 if( strlen(zIn)>4 && memcmp("data", zIn, 4)==0 ){
962 int i;
963 for(i=4; zIn[i]>='0' && zIn[i]<='9'; i++);
964 if( zIn[i]=='_' && zIn[i+1] ){
965 sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC);
966 }
967 }
968 }
969 }
970}
971
972/*
973** Initialize the iterator structure passed as the second argument.
974**
975** If no error occurs, SQLITE_OK is returned and the iterator is left
976** pointing to the first entry. Otherwise, an error code and message is
977** left in the RBU handle passed as the first argument. A copy of the
978** error code is returned.
979*/
980static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
981 int rc;
982 memset(pIter, 0, sizeof(RbuObjIter));
983
984 rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
985 sqlite3_mprintf(
986 "SELECT rbu_target_name(name, type='view') AS target, name "
987 "FROM sqlite_schema "
988 "WHERE type IN ('table', 'view') AND target IS NOT NULL "
989 " %s "
990 "ORDER BY name"
991 , rbuIsVacuum(p) ? "AND rootpage!=0 AND rootpage IS NOT NULL" : ""));
992
993 if( rc==SQLITE_OK ){
994 rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
995 "SELECT name, rootpage, sql IS NULL OR substr(8, 6)=='UNIQUE' "
996 " FROM main.sqlite_schema "
997 " WHERE type='index' AND tbl_name = ?"
998 );
999 }
1000
1001 pIter->bCleanup = 1;
1002 p->rc = rc;
1003 return rbuObjIterNext(p, pIter);
1004}
1005
1006/*
1007** This is a wrapper around "sqlite3_mprintf(zFmt, ...)". If an OOM occurs,
1008** an error code is stored in the RBU handle passed as the first argument.
1009**
1010** If an error has already occurred (p->rc is already set to something other
1011** than SQLITE_OK), then this function returns NULL without modifying the
1012** stored error code. In this case it still calls sqlite3_free() on any
1013** printf() parameters associated with %z conversions.
1014*/
1015static char *rbuMPrintf(sqlite3rbu *p, const char *zFmt, ...){
1016 char *zSql = 0;
1017 va_list ap;
1018 va_start(ap, zFmt);
1019 zSql = sqlite3_vmprintf(zFmt, ap);
1020 if( p->rc==SQLITE_OK ){
1021 if( zSql==0 ) p->rc = SQLITE_NOMEM;
1022 }else{
1023 sqlite3_free(zSql);
1024 zSql = 0;
1025 }
1026 va_end(ap);
1027 return zSql;
1028}
1029
1030/*
1031** Argument zFmt is a sqlite3_mprintf() style format string. The trailing
1032** arguments are the usual subsitution values. This function performs
1033** the printf() style substitutions and executes the result as an SQL
1034** statement on the RBU handles database.
1035**
1036** If an error occurs, an error code and error message is stored in the
1037** RBU handle. If an error has already occurred when this function is
1038** called, it is a no-op.
1039*/
1040static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){
1041 va_list ap;
1042 char *zSql;
1043 va_start(ap, zFmt);
1044 zSql = sqlite3_vmprintf(zFmt, ap);
1045 if( p->rc==SQLITE_OK ){
1046 if( zSql==0 ){
1047 p->rc = SQLITE_NOMEM;
1048 }else{
1049 p->rc = sqlite3_exec(db, zSql, 0, 0, &p->zErrmsg);
1050 }
1051 }
1052 sqlite3_free(zSql);
1053 va_end(ap);
1054 return p->rc;
1055}
1056
1057/*
1058** Attempt to allocate and return a pointer to a zeroed block of nByte
1059** bytes.
1060**
1061** If an error (i.e. an OOM condition) occurs, return NULL and leave an
1062** error code in the rbu handle passed as the first argument. Or, if an
1063** error has already occurred when this function is called, return NULL
1064** immediately without attempting the allocation or modifying the stored
1065** error code.
1066*/
1067static void *rbuMalloc(sqlite3rbu *p, sqlite3_int64 nByte){
1068 void *pRet = 0;
1069 if( p->rc==SQLITE_OK ){
1070 assert( nByte>0 );
1071 pRet = sqlite3_malloc64(nByte);
1072 if( pRet==0 ){
1073 p->rc = SQLITE_NOMEM;
1074 }else{
1075 memset(pRet, 0, nByte);
1076 }
1077 }
1078 return pRet;
1079}
1080
1081
1082/*
1083** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that
1084** there is room for at least nCol elements. If an OOM occurs, store an
1085** error code in the RBU handle passed as the first argument.
1086*/
1087static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
1088 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
1089 char **azNew;
1090
1091 azNew = (char**)rbuMalloc(p, nByte);
1092 if( azNew ){
1093 pIter->azTblCol = azNew;
1094 pIter->azTblType = &azNew[nCol];
1095 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
1096 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
1097 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
1098 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
1099 }
1100}
1101
1102/*
1103** The first argument must be a nul-terminated string. This function
1104** returns a copy of the string in memory obtained from sqlite3_malloc().
1105** It is the responsibility of the caller to eventually free this memory
1106** using sqlite3_free().
1107**
1108** If an OOM condition is encountered when attempting to allocate memory,
1109** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise,
1110** if the allocation succeeds, (*pRc) is left unchanged.
1111*/
1112static char *rbuStrndup(const char *zStr, int *pRc){
1113 char *zRet = 0;
1114
1115 if( *pRc==SQLITE_OK ){
1116 if( zStr ){
1117 size_t nCopy = strlen(zStr) + 1;
1118 zRet = (char*)sqlite3_malloc64(nCopy);
1119 if( zRet ){
1120 memcpy(zRet, zStr, nCopy);
1121 }else{
1122 *pRc = SQLITE_NOMEM;
1123 }
1124 }
1125 }
1126
1127 return zRet;
1128}
1129
1130/*
1131** Finalize the statement passed as the second argument.
1132**
1133** If the sqlite3_finalize() call indicates that an error occurs, and the
1134** rbu handle error code is not already set, set the error code and error
1135** message accordingly.
1136*/
1137static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){
1138 sqlite3 *db = sqlite3_db_handle(pStmt);
1139 int rc = sqlite3_finalize(pStmt);
1140 if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){
1141 p->rc = rc;
1142 p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
1143 }
1144}
1145
1146/* Determine the type of a table.
1147**
1148** peType is of type (int*), a pointer to an output parameter of type
1149** (int). This call sets the output parameter as follows, depending
1150** on the type of the table specified by parameters dbName and zTbl.
1151**
1152** RBU_PK_NOTABLE: No such table.
1153** RBU_PK_NONE: Table has an implicit rowid.
1154** RBU_PK_IPK: Table has an explicit IPK column.
1155** RBU_PK_EXTERNAL: Table has an external PK index.
1156** RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID.
1157** RBU_PK_VTAB: Table is a virtual table.
1158**
1159** Argument *piPk is also of type (int*), and also points to an output
1160** parameter. Unless the table has an external primary key index
1161** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or,
1162** if the table does have an external primary key index, then *piPk
1163** is set to the root page number of the primary key index before
1164** returning.
1165**
1166** ALGORITHM:
1167**
1168** if( no entry exists in sqlite_schema ){
1169** return RBU_PK_NOTABLE
1170** }else if( sql for the entry starts with "CREATE VIRTUAL" ){
1171** return RBU_PK_VTAB
1172** }else if( "PRAGMA index_list()" for the table contains a "pk" index ){
1173** if( the index that is the pk exists in sqlite_schema ){
1174** *piPK = rootpage of that index.
1175** return RBU_PK_EXTERNAL
1176** }else{
1177** return RBU_PK_WITHOUT_ROWID
1178** }
1179** }else if( "PRAGMA table_info()" lists one or more "pk" columns ){
1180** return RBU_PK_IPK
1181** }else{
1182** return RBU_PK_NONE
1183** }
1184*/
1185static void rbuTableType(
1186 sqlite3rbu *p,
1187 const char *zTab,
1188 int *peType,
1189 int *piTnum,
1190 int *piPk
1191){
1192 /*
1193 ** 0) SELECT count(*) FROM sqlite_schema where name=%Q AND IsVirtual(%Q)
1194 ** 1) PRAGMA index_list = ?
1195 ** 2) SELECT count(*) FROM sqlite_schema where name=%Q
1196 ** 3) PRAGMA table_info = ?
1197 */
1198 sqlite3_stmt *aStmt[4] = {0, 0, 0, 0};
1199
1200 *peType = RBU_PK_NOTABLE;
1201 *piPk = 0;
1202
1203 assert( p->rc==SQLITE_OK );
1204 p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg,
1205 sqlite3_mprintf(
1206 "SELECT "
1207 " (sql COLLATE nocase BETWEEN 'CREATE VIRTUAL' AND 'CREATE VIRTUAM'),"
1208 " rootpage"
1209 " FROM sqlite_schema"
1210 " WHERE name=%Q", zTab
1211 ));
1212 if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){
1213 /* Either an error, or no such table. */
1214 goto rbuTableType_end;
1215 }
1216 if( sqlite3_column_int(aStmt[0], 0) ){
1217 *peType = RBU_PK_VTAB; /* virtual table */
1218 goto rbuTableType_end;
1219 }
1220 *piTnum = sqlite3_column_int(aStmt[0], 1);
1221
1222 p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[1], &p->zErrmsg,
1223 sqlite3_mprintf("PRAGMA index_list=%Q",zTab)
1224 );
1225 if( p->rc ) goto rbuTableType_end;
1226 while( sqlite3_step(aStmt[1])==SQLITE_ROW ){
1227 const u8 *zOrig = sqlite3_column_text(aStmt[1], 3);
1228 const u8 *zIdx = sqlite3_column_text(aStmt[1], 1);
1229 if( zOrig && zIdx && zOrig[0]=='p' ){
1230 p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[2], &p->zErrmsg,
1231 sqlite3_mprintf(
1232 "SELECT rootpage FROM sqlite_schema WHERE name = %Q", zIdx
1233 ));
1234 if( p->rc==SQLITE_OK ){
1235 if( sqlite3_step(aStmt[2])==SQLITE_ROW ){
1236 *piPk = sqlite3_column_int(aStmt[2], 0);
1237 *peType = RBU_PK_EXTERNAL;
1238 }else{
1239 *peType = RBU_PK_WITHOUT_ROWID;
1240 }
1241 }
1242 goto rbuTableType_end;
1243 }
1244 }
1245
1246 p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[3], &p->zErrmsg,
1247 sqlite3_mprintf("PRAGMA table_info=%Q",zTab)
1248 );
1249 if( p->rc==SQLITE_OK ){
1250 while( sqlite3_step(aStmt[3])==SQLITE_ROW ){
1251 if( sqlite3_column_int(aStmt[3],5)>0 ){
1252 *peType = RBU_PK_IPK; /* explicit IPK column */
1253 goto rbuTableType_end;
1254 }
1255 }
1256 *peType = RBU_PK_NONE;
1257 }
1258
1259rbuTableType_end: {
1260 unsigned int i;
1261 for(i=0; i<sizeof(aStmt)/sizeof(aStmt[0]); i++){
1262 rbuFinalize(p, aStmt[i]);
1263 }
1264 }
1265}
1266
1267/*
1268** This is a helper function for rbuObjIterCacheTableInfo(). It populates
1269** the pIter->abIndexed[] array.
1270*/
1271static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
1272 sqlite3_stmt *pList = 0;
1273 int bIndex = 0;
1274
1275 if( p->rc==SQLITE_OK ){
1276 memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
1277 p->rc = prepareFreeAndCollectError(p->dbMain, &pList, &p->zErrmsg,
1278 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
1279 );
1280 }
1281
1282 pIter->nIndex = 0;
1283 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){
1284 const char *zIdx = (const char*)sqlite3_column_text(pList, 1);
1285 int bPartial = sqlite3_column_int(pList, 4);
1286 sqlite3_stmt *pXInfo = 0;
1287 if( zIdx==0 ) break;
1288 if( bPartial ){
1289 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
1290 }
1291 p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
1292 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
1293 );
1294 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
1295 int iCid = sqlite3_column_int(pXInfo, 1);
1296 if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
1297 if( iCid==-2 ){
1298 memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
1299 }
1300 }
1301 rbuFinalize(p, pXInfo);
1302 bIndex = 1;
1303 pIter->nIndex++;
1304 }
1305
1306 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
1307 /* "PRAGMA index_list" includes the main PK b-tree */
1308 pIter->nIndex--;
1309 }
1310
1311 rbuFinalize(p, pList);
1312 if( bIndex==0 ) pIter->abIndexed = 0;
1313}
1314
1315
1316/*
1317** If they are not already populated, populate the pIter->azTblCol[],
1318** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to
1319** the table (not index) that the iterator currently points to.
1320**
1321** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
1322** an error does occur, an error code and error message are also left in
1323** the RBU handle.
1324*/
1325static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
1326 if( pIter->azTblCol==0 ){
1327 sqlite3_stmt *pStmt = 0;
1328 int nCol = 0;
1329 int i; /* for() loop iterator variable */
1330 int bRbuRowid = 0; /* If input table has column "rbu_rowid" */
1331 int iOrder = 0;
1332 int iTnum = 0;
1333
1334 /* Figure out the type of table this step will deal with. */
1335 assert( pIter->eType==0 );
1336 rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
1337 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
1338 p->rc = SQLITE_ERROR;
1339 p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
1340 }
1341 if( p->rc ) return p->rc;
1342 if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
1343
1344 assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
1345 || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
1346 || pIter->eType==RBU_PK_VTAB
1347 );
1348
1349 /* Populate the azTblCol[] and nTblCol variables based on the columns
1350 ** of the input table. Ignore any input table columns that begin with
1351 ** "rbu_". */
1352 p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
1353 sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
1354 );
1355 if( p->rc==SQLITE_OK ){
1356 nCol = sqlite3_column_count(pStmt);
1357 rbuAllocateIterArrays(p, pIter, nCol);
1358 }
1359 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
1360 const char *zName = (const char*)sqlite3_column_name(pStmt, i);
1361 if( sqlite3_strnicmp("rbu_", zName, 4) ){
1362 char *zCopy = rbuStrndup(zName, &p->rc);
1363 pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
1364 pIter->azTblCol[pIter->nTblCol++] = zCopy;
1365 }
1366 else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
1367 bRbuRowid = 1;
1368 }
1369 }
1370 sqlite3_finalize(pStmt);
1371 pStmt = 0;
1372
1373 if( p->rc==SQLITE_OK
1374 && rbuIsVacuum(p)==0
1375 && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
1376 ){
1377 p->rc = SQLITE_ERROR;
1378 p->zErrmsg = sqlite3_mprintf(
1379 "table %q %s rbu_rowid column", pIter->zDataTbl,
1380 (bRbuRowid ? "may not have" : "requires")
1381 );
1382 }
1383
1384 /* Check that all non-HIDDEN columns in the destination table are also
1385 ** present in the input table. Populate the abTblPk[], azTblType[] and
1386 ** aiTblOrder[] arrays at the same time. */
1387 if( p->rc==SQLITE_OK ){
1388 p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
1389 sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
1390 );
1391 }
1392 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
1393 const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
1394 if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
1395 for(i=iOrder; i<pIter->nTblCol; i++){
1396 if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
1397 }
1398 if( i==pIter->nTblCol ){
1399 p->rc = SQLITE_ERROR;
1400 p->zErrmsg = sqlite3_mprintf("column missing from %q: %s",
1401 pIter->zDataTbl, zName
1402 );
1403 }else{
1404 int iPk = sqlite3_column_int(pStmt, 5);
1405 int bNotNull = sqlite3_column_int(pStmt, 3);
1406 const char *zType = (const char*)sqlite3_column_text(pStmt, 2);
1407
1408 if( i!=iOrder ){
1409 SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
1410 SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
1411 }
1412
1413 pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
1414 assert( iPk>=0 );
1415 pIter->abTblPk[iOrder] = (u8)iPk;
1416 pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
1417 iOrder++;
1418 }
1419 }
1420
1421 rbuFinalize(p, pStmt);
1422 rbuObjIterCacheIndexedCols(p, pIter);
1423 assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
1424 assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
1425 }
1426
1427 return p->rc;
1428}
1429
1430/*
1431** This function constructs and returns a pointer to a nul-terminated
1432** string containing some SQL clause or list based on one or more of the
1433** column names currently stored in the pIter->azTblCol[] array.
1434*/
1435static char *rbuObjIterGetCollist(
1436 sqlite3rbu *p, /* RBU object */
1437 RbuObjIter *pIter /* Object iterator for column names */
1438){
1439 char *zList = 0;
1440 const char *zSep = "";
1441 int i;
1442 for(i=0; i<pIter->nTblCol; i++){
1443 const char *z = pIter->azTblCol[i];
1444 zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z);
1445 zSep = ", ";
1446 }
1447 return zList;
1448}
1449
1450/*
1451** Return a comma separated list of the quoted PRIMARY KEY column names,
1452** in order, for the current table. Before each column name, add the text
1453** zPre. After each column name, add the zPost text. Use zSeparator as
1454** the separator text (usually ", ").
1455*/
1456static char *rbuObjIterGetPkList(
1457 sqlite3rbu *p, /* RBU object */
1458 RbuObjIter *pIter, /* Object iterator for column names */
1459 const char *zPre, /* Before each quoted column name */
1460 const char *zSeparator, /* Separator to use between columns */
1461 const char *zPost /* After each quoted column name */
1462){
1463 int iPk = 1;
1464 char *zRet = 0;
1465 const char *zSep = "";
1466 while( 1 ){
1467 int i;
1468 for(i=0; i<pIter->nTblCol; i++){
1469 if( (int)pIter->abTblPk[i]==iPk ){
1470 const char *zCol = pIter->azTblCol[i];
1471 zRet = rbuMPrintf(p, "%z%s%s\"%w\"%s", zRet, zSep, zPre, zCol, zPost);
1472 zSep = zSeparator;
1473 break;
1474 }
1475 }
1476 if( i==pIter->nTblCol ) break;
1477 iPk++;
1478 }
1479 return zRet;
1480}
1481
1482/*
1483** This function is called as part of restarting an RBU vacuum within
1484** stage 1 of the process (while the *-oal file is being built) while
1485** updating a table (not an index). The table may be a rowid table or
1486** a WITHOUT ROWID table. It queries the target database to find the
1487** largest key that has already been written to the target table and
1488** constructs a WHERE clause that can be used to extract the remaining
1489** rows from the source table. For a rowid table, the WHERE clause
1490** is of the form:
1491**
1492** "WHERE _rowid_ > ?"
1493**
1494** and for WITHOUT ROWID tables:
1495**
1496** "WHERE (key1, key2) > (?, ?)"
1497**
1498** Instead of "?" placeholders, the actual WHERE clauses created by
1499** this function contain literal SQL values.
1500*/
1501static char *rbuVacuumTableStart(
1502 sqlite3rbu *p, /* RBU handle */
1503 RbuObjIter *pIter, /* RBU iterator object */
1504 int bRowid, /* True for a rowid table */
1505 const char *zWrite /* Target table name prefix */
1506){
1507 sqlite3_stmt *pMax = 0;
1508 char *zRet = 0;
1509 if( bRowid ){
1510 p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg,
1511 sqlite3_mprintf(
1512 "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
1513 )
1514 );
1515 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
1516 sqlite3_int64 iMax = sqlite3_column_int64(pMax, 0);
1517 zRet = rbuMPrintf(p, " WHERE _rowid_ > %lld ", iMax);
1518 }
1519 rbuFinalize(p, pMax);
1520 }else{
1521 char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
1522 char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
1523 char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
1524
1525 if( p->rc==SQLITE_OK ){
1526 p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg,
1527 sqlite3_mprintf(
1528 "SELECT %s FROM \"%s%w\" ORDER BY %s LIMIT 1",
1529 zSelect, zWrite, pIter->zTbl, zOrder
1530 )
1531 );
1532 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
1533 const char *zVal = (const char*)sqlite3_column_text(pMax, 0);
1534 zRet = rbuMPrintf(p, " WHERE (%s) > (%s) ", zList, zVal);
1535 }
1536 rbuFinalize(p, pMax);
1537 }
1538
1539 sqlite3_free(zOrder);
1540 sqlite3_free(zSelect);
1541 sqlite3_free(zList);
1542 }
1543 return zRet;
1544}
1545
1546/*
1547** This function is called as part of restating an RBU vacuum when the
1548** current operation is writing content to an index. If possible, it
1549** queries the target index b-tree for the largest key already written to
1550** it, then composes and returns an expression that can be used in a WHERE
1551** clause to select the remaining required rows from the source table.
1552** It is only possible to return such an expression if:
1553**
1554** * The index contains no DESC columns, and
1555** * The last key written to the index before the operation was
1556** suspended does not contain any NULL values.
1557**
1558** The expression is of the form:
1559**
1560** (index-field1, index-field2, ...) > (?, ?, ...)
1561**
1562** except that the "?" placeholders are replaced with literal values.
1563**
1564** If the expression cannot be created, NULL is returned. In this case,
1565** the caller has to use an OFFSET clause to extract only the required
1566** rows from the sourct table, just as it does for an RBU update operation.
1567*/
1568static char *rbuVacuumIndexStart(
1569 sqlite3rbu *p, /* RBU handle */
1570 RbuObjIter *pIter /* RBU iterator object */
1571){
1572 char *zOrder = 0;
1573 char *zLhs = 0;
1574 char *zSelect = 0;
1575 char *zVector = 0;
1576 char *zRet = 0;
1577 int bFailed = 0;
1578 const char *zSep = "";
1579 int iCol = 0;
1580 sqlite3_stmt *pXInfo = 0;
1581
1582 p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
1583 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
1584 );
1585 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
1586 int iCid = sqlite3_column_int(pXInfo, 1);
1587 const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
1588 const char *zCol;
1589 if( sqlite3_column_int(pXInfo, 3) ){
1590 bFailed = 1;
1591 break;
1592 }
1593
1594 if( iCid<0 ){
1595 if( pIter->eType==RBU_PK_IPK ){
1596 int i;
1597 for(i=0; pIter->abTblPk[i]==0; i++);
1598 assert( i<pIter->nTblCol );
1599 zCol = pIter->azTblCol[i];
1600 }else{
1601 zCol = "_rowid_";
1602 }
1603 }else{
1604 zCol = pIter->azTblCol[iCid];
1605 }
1606
1607 zLhs = rbuMPrintf(p, "%z%s \"%w\" COLLATE %Q",
1608 zLhs, zSep, zCol, zCollate
1609 );
1610 zOrder = rbuMPrintf(p, "%z%s \"rbu_imp_%d%w\" COLLATE %Q DESC",
1611 zOrder, zSep, iCol, zCol, zCollate
1612 );
1613 zSelect = rbuMPrintf(p, "%z%s quote(\"rbu_imp_%d%w\")",
1614 zSelect, zSep, iCol, zCol
1615 );
1616 zSep = ", ";
1617 iCol++;
1618 }
1619 rbuFinalize(p, pXInfo);
1620 if( bFailed ) goto index_start_out;
1621
1622 if( p->rc==SQLITE_OK ){
1623 sqlite3_stmt *pSel = 0;
1624
1625 p->rc = prepareFreeAndCollectError(p->dbMain, &pSel, &p->zErrmsg,
1626 sqlite3_mprintf("SELECT %s FROM \"rbu_imp_%w\" ORDER BY %s LIMIT 1",
1627 zSelect, pIter->zTbl, zOrder
1628 )
1629 );
1630 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){
1631 zSep = "";
1632 for(iCol=0; iCol<pIter->nCol; iCol++){
1633 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
1634 if( zQuoted==0 ){
1635 p->rc = SQLITE_NOMEM;
1636 }else if( zQuoted[0]=='N' ){
1637 bFailed = 1;
1638 break;
1639 }
1640 zVector = rbuMPrintf(p, "%z%s%s", zVector, zSep, zQuoted);
1641 zSep = ", ";
1642 }
1643
1644 if( !bFailed ){
1645 zRet = rbuMPrintf(p, "(%s) > (%s)", zLhs, zVector);
1646 }
1647 }
1648 rbuFinalize(p, pSel);
1649 }
1650
1651 index_start_out:
1652 sqlite3_free(zOrder);
1653 sqlite3_free(zSelect);
1654 sqlite3_free(zVector);
1655 sqlite3_free(zLhs);
1656 return zRet;
1657}
1658
1659/*
1660** This function is used to create a SELECT list (the list of SQL
1661** expressions that follows a SELECT keyword) for a SELECT statement
1662** used to read from an data_xxx or rbu_tmp_xxx table while updating the
1663** index object currently indicated by the iterator object passed as the
1664** second argument. A "PRAGMA index_xinfo = <idxname>" statement is used
1665** to obtain the required information.
1666**
1667** If the index is of the following form:
1668**
1669** CREATE INDEX i1 ON t1(c, b COLLATE nocase);
1670**
1671** and "t1" is a table with an explicit INTEGER PRIMARY KEY column
1672** "ipk", the returned string is:
1673**
1674** "`c` COLLATE 'BINARY', `b` COLLATE 'NOCASE', `ipk` COLLATE 'BINARY'"
1675**
1676** As well as the returned string, three other malloc'd strings are
1677** returned via output parameters. As follows:
1678**
1679** pzImposterCols: ...
1680** pzImposterPk: ...
1681** pzWhere: ...
1682*/
1683static char *rbuObjIterGetIndexCols(
1684 sqlite3rbu *p, /* RBU object */
1685 RbuObjIter *pIter, /* Object iterator for column names */
1686 char **pzImposterCols, /* OUT: Columns for imposter table */
1687 char **pzImposterPk, /* OUT: Imposter PK clause */
1688 char **pzWhere, /* OUT: WHERE clause */
1689 int *pnBind /* OUT: Trbul number of columns */
1690){
1691 int rc = p->rc; /* Error code */
1692 int rc2; /* sqlite3_finalize() return code */
1693 char *zRet = 0; /* String to return */
1694 char *zImpCols = 0; /* String to return via *pzImposterCols */
1695 char *zImpPK = 0; /* String to return via *pzImposterPK */
1696 char *zWhere = 0; /* String to return via *pzWhere */
1697 int nBind = 0; /* Value to return via *pnBind */
1698 const char *zCom = ""; /* Set to ", " later on */
1699 const char *zAnd = ""; /* Set to " AND " later on */
1700 sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = ? */
1701
1702 if( rc==SQLITE_OK ){
1703 assert( p->zErrmsg==0 );
1704 rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
1705 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
1706 );
1707 }
1708
1709 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
1710 int iCid = sqlite3_column_int(pXInfo, 1);
1711 int bDesc = sqlite3_column_int(pXInfo, 3);
1712 const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
1713 const char *zCol = 0;
1714 const char *zType;
1715
1716 if( iCid==-2 ){
1717 int iSeq = sqlite3_column_int(pXInfo, 0);
1718 zRet = sqlite3_mprintf("%z%s(%.*s) COLLATE %Q", zRet, zCom,
1719 pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate
1720 );
1721 zType = "";
1722 }else {
1723 if( iCid<0 ){
1724 /* An integer primary key. If the table has an explicit IPK, use
1725 ** its name. Otherwise, use "rbu_rowid". */
1726 if( pIter->eType==RBU_PK_IPK ){
1727 int i;
1728 for(i=0; pIter->abTblPk[i]==0; i++);
1729 assert( i<pIter->nTblCol );
1730 zCol = pIter->azTblCol[i];
1731 }else if( rbuIsVacuum(p) ){
1732 zCol = "_rowid_";
1733 }else{
1734 zCol = "rbu_rowid";
1735 }
1736 zType = "INTEGER";
1737 }else{
1738 zCol = pIter->azTblCol[iCid];
1739 zType = pIter->azTblType[iCid];
1740 }
1741 zRet = sqlite3_mprintf("%z%s\"%w\" COLLATE %Q", zRet, zCom,zCol,zCollate);
1742 }
1743
1744 if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
1745 const char *zOrder = (bDesc ? " DESC" : "");
1746 zImpPK = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\"%s",
1747 zImpPK, zCom, nBind, zCol, zOrder
1748 );
1749 }
1750 zImpCols = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\" %s COLLATE %Q",
1751 zImpCols, zCom, nBind, zCol, zType, zCollate
1752 );
1753 zWhere = sqlite3_mprintf(
1754 "%z%s\"rbu_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol
1755 );
1756 if( zRet==0 || zImpPK==0 || zImpCols==0 || zWhere==0 ) rc = SQLITE_NOMEM;
1757 zCom = ", ";
1758 zAnd = " AND ";
1759 nBind++;
1760 }
1761
1762 rc2 = sqlite3_finalize(pXInfo);
1763 if( rc==SQLITE_OK ) rc = rc2;
1764
1765 if( rc!=SQLITE_OK ){
1766 sqlite3_free(zRet);
1767 sqlite3_free(zImpCols);
1768 sqlite3_free(zImpPK);
1769 sqlite3_free(zWhere);
1770 zRet = 0;
1771 zImpCols = 0;
1772 zImpPK = 0;
1773 zWhere = 0;
1774 p->rc = rc;
1775 }
1776
1777 *pzImposterCols = zImpCols;
1778 *pzImposterPk = zImpPK;
1779 *pzWhere = zWhere;
1780 *pnBind = nBind;
1781 return zRet;
1782}
1783
1784/*
1785** Assuming the current table columns are "a", "b" and "c", and the zObj
1786** paramter is passed "old", return a string of the form:
1787**
1788** "old.a, old.b, old.b"
1789**
1790** With the column names escaped.
1791**
1792** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append
1793** the text ", old._rowid_" to the returned value.
1794*/
1795static char *rbuObjIterGetOldlist(
1796 sqlite3rbu *p,
1797 RbuObjIter *pIter,
1798 const char *zObj
1799){
1800 char *zList = 0;
1801 if( p->rc==SQLITE_OK && pIter->abIndexed ){
1802 const char *zS = "";
1803 int i;
1804 for(i=0; i<pIter->nTblCol; i++){
1805 if( pIter->abIndexed[i] ){
1806 const char *zCol = pIter->azTblCol[i];
1807 zList = sqlite3_mprintf("%z%s%s.\"%w\"", zList, zS, zObj, zCol);
1808 }else{
1809 zList = sqlite3_mprintf("%z%sNULL", zList, zS);
1810 }
1811 zS = ", ";
1812 if( zList==0 ){
1813 p->rc = SQLITE_NOMEM;
1814 break;
1815 }
1816 }
1817
1818 /* For a table with implicit rowids, append "old._rowid_" to the list. */
1819 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
1820 zList = rbuMPrintf(p, "%z, %s._rowid_", zList, zObj);
1821 }
1822 }
1823 return zList;
1824}
1825
1826/*
1827** Return an expression that can be used in a WHERE clause to match the
1828** primary key of the current table. For example, if the table is:
1829**
1830** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, c));
1831**
1832** Return the string:
1833**
1834** "b = ?1 AND c = ?2"
1835*/
1836static char *rbuObjIterGetWhere(
1837 sqlite3rbu *p,
1838 RbuObjIter *pIter
1839){
1840 char *zList = 0;
1841 if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
1842 zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
1843 }else if( pIter->eType==RBU_PK_EXTERNAL ){
1844 const char *zSep = "";
1845 int i;
1846 for(i=0; i<pIter->nTblCol; i++){
1847 if( pIter->abTblPk[i] ){
1848 zList = rbuMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1);
1849 zSep = " AND ";
1850 }
1851 }
1852 zList = rbuMPrintf(p,
1853 "_rowid_ = (SELECT id FROM rbu_imposter2 WHERE %z)", zList
1854 );
1855
1856 }else{
1857 const char *zSep = "";
1858 int i;
1859 for(i=0; i<pIter->nTblCol; i++){
1860 if( pIter->abTblPk[i] ){
1861 const char *zCol = pIter->azTblCol[i];
1862 zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1);
1863 zSep = " AND ";
1864 }
1865 }
1866 }
1867 return zList;
1868}
1869
1870/*
1871** The SELECT statement iterating through the keys for the current object
1872** (p->objiter.pSelect) currently points to a valid row. However, there
1873** is something wrong with the rbu_control value in the rbu_control value
1874** stored in the (p->nCol+1)'th column. Set the error code and error message
1875** of the RBU handle to something reflecting this.
1876*/
1877static void rbuBadControlError(sqlite3rbu *p){
1878 p->rc = SQLITE_ERROR;
1879 p->zErrmsg = sqlite3_mprintf("invalid rbu_control value");
1880}
1881
1882
1883/*
1884** Return a nul-terminated string containing the comma separated list of
1885** assignments that should be included following the "SET" keyword of
1886** an UPDATE statement used to update the table object that the iterator
1887** passed as the second argument currently points to if the rbu_control
1888** column of the data_xxx table entry is set to zMask.
1889**
1890** The memory for the returned string is obtained from sqlite3_malloc().
1891** It is the responsibility of the caller to eventually free it using
1892** sqlite3_free().
1893**
1894** If an OOM error is encountered when allocating space for the new
1895** string, an error code is left in the rbu handle passed as the first
1896** argument and NULL is returned. Or, if an error has already occurred
1897** when this function is called, NULL is returned immediately, without
1898** attempting the allocation or modifying the stored error code.
1899*/
1900static char *rbuObjIterGetSetlist(
1901 sqlite3rbu *p,
1902 RbuObjIter *pIter,
1903 const char *zMask
1904){
1905 char *zList = 0;
1906 if( p->rc==SQLITE_OK ){
1907 int i;
1908
1909 if( (int)strlen(zMask)!=pIter->nTblCol ){
1910 rbuBadControlError(p);
1911 }else{
1912 const char *zSep = "";
1913 for(i=0; i<pIter->nTblCol; i++){
1914 char c = zMask[pIter->aiSrcOrder[i]];
1915 if( c=='x' ){
1916 zList = rbuMPrintf(p, "%z%s\"%w\"=?%d",
1917 zList, zSep, pIter->azTblCol[i], i+1
1918 );
1919 zSep = ", ";
1920 }
1921 else if( c=='d' ){
1922 zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_delta(\"%w\", ?%d)",
1923 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
1924 );
1925 zSep = ", ";
1926 }
1927 else if( c=='f' ){
1928 zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_fossil_delta(\"%w\", ?%d)",
1929 zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
1930 );
1931 zSep = ", ";
1932 }
1933 }
1934 }
1935 }
1936 return zList;
1937}
1938
1939/*
1940** Return a nul-terminated string consisting of nByte comma separated
1941** "?" expressions. For example, if nByte is 3, return a pointer to
1942** a buffer containing the string "?,?,?".
1943**
1944** The memory for the returned string is obtained from sqlite3_malloc().
1945** It is the responsibility of the caller to eventually free it using
1946** sqlite3_free().
1947**
1948** If an OOM error is encountered when allocating space for the new
1949** string, an error code is left in the rbu handle passed as the first
1950** argument and NULL is returned. Or, if an error has already occurred
1951** when this function is called, NULL is returned immediately, without
1952** attempting the allocation or modifying the stored error code.
1953*/
1954static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){
1955 char *zRet = 0;
1956 sqlite3_int64 nByte = 2*(sqlite3_int64)nBind + 1;
1957
1958 zRet = (char*)rbuMalloc(p, nByte);
1959 if( zRet ){
1960 int i;
1961 for(i=0; i<nBind; i++){
1962 zRet[i*2] = '?';
1963 zRet[i*2+1] = (i+1==nBind) ? '\0' : ',';
1964 }
1965 }
1966 return zRet;
1967}
1968
1969/*
1970** The iterator currently points to a table (not index) of type
1971** RBU_PK_WITHOUT_ROWID. This function creates the PRIMARY KEY
1972** declaration for the corresponding imposter table. For example,
1973** if the iterator points to a table created as:
1974**
1975** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, a DESC)) WITHOUT ROWID
1976**
1977** this function returns:
1978**
1979** PRIMARY KEY("b", "a" DESC)
1980*/
1981static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
1982 char *z = 0;
1983 assert( pIter->zIdx==0 );
1984 if( p->rc==SQLITE_OK ){
1985 const char *zSep = "PRIMARY KEY(";
1986 sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */
1987 sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = <pk-index> */
1988
1989 p->rc = prepareFreeAndCollectError(p->dbMain, &pXList, &p->zErrmsg,
1990 sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
1991 );
1992 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){
1993 const char *zOrig = (const char*)sqlite3_column_text(pXList,3);
1994 if( zOrig && strcmp(zOrig, "pk")==0 ){
1995 const char *zIdx = (const char*)sqlite3_column_text(pXList,1);
1996 if( zIdx ){
1997 p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
1998 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
1999 );
2000 }
2001 break;
2002 }
2003 }
2004 rbuFinalize(p, pXList);
2005
2006 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
2007 if( sqlite3_column_int(pXInfo, 5) ){
2008 /* int iCid = sqlite3_column_int(pXInfo, 0); */
2009 const char *zCol = (const char*)sqlite3_column_text(pXInfo, 2);
2010 const char *zDesc = sqlite3_column_int(pXInfo, 3) ? " DESC" : "";
2011 z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc);
2012 zSep = ", ";
2013 }
2014 }
2015 z = rbuMPrintf(p, "%z)", z);
2016 rbuFinalize(p, pXInfo);
2017 }
2018 return z;
2019}
2020
2021/*
2022** This function creates the second imposter table used when writing to
2023** a table b-tree where the table has an external primary key. If the
2024** iterator passed as the second argument does not currently point to
2025** a table (not index) with an external primary key, this function is a
2026** no-op.
2027**
2028** Assuming the iterator does point to a table with an external PK, this
2029** function creates a WITHOUT ROWID imposter table named "rbu_imposter2"
2030** used to access that PK index. For example, if the target table is
2031** declared as follows:
2032**
2033** CREATE TABLE t1(a, b TEXT, c REAL, PRIMARY KEY(b, c));
2034**
2035** then the imposter table schema is:
2036**
2037** CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID;
2038**
2039*/
2040static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
2041 if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
2042 int tnum = pIter->iPkTnum; /* Root page of PK index */
2043 sqlite3_stmt *pQuery = 0; /* SELECT name ... WHERE rootpage = $tnum */
2044 const char *zIdx = 0; /* Name of PK index */
2045 sqlite3_stmt *pXInfo = 0; /* PRAGMA main.index_xinfo = $zIdx */
2046 const char *zComma = "";
2047 char *zCols = 0; /* Used to build up list of table cols */
2048 char *zPk = 0; /* Used to build up table PK declaration */
2049
2050 /* Figure out the name of the primary key index for the current table.
2051 ** This is needed for the argument to "PRAGMA index_xinfo". Set
2052 ** zIdx to point to a nul-terminated string containing this name. */
2053 p->rc = prepareAndCollectError(p->dbMain, &pQuery, &p->zErrmsg,
2054 "SELECT name FROM sqlite_schema WHERE rootpage = ?"
2055 );
2056 if( p->rc==SQLITE_OK ){
2057 sqlite3_bind_int(pQuery, 1, tnum);
2058 if( SQLITE_ROW==sqlite3_step(pQuery) ){
2059 zIdx = (const char*)sqlite3_column_text(pQuery, 0);
2060 }
2061 }
2062 if( zIdx ){
2063 p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
2064 sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
2065 );
2066 }
2067 rbuFinalize(p, pQuery);
2068
2069 while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
2070 int bKey = sqlite3_column_int(pXInfo, 5);
2071 if( bKey ){
2072 int iCid = sqlite3_column_int(pXInfo, 1);
2073 int bDesc = sqlite3_column_int(pXInfo, 3);
2074 const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
2075 zCols = rbuMPrintf(p, "%z%sc%d %s COLLATE %Q", zCols, zComma,
2076 iCid, pIter->azTblType[iCid], zCollate
2077 );
2078 zPk = rbuMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":"");
2079 zComma = ", ";
2080 }
2081 }
2082 zCols = rbuMPrintf(p, "%z, id INTEGER", zCols);
2083 rbuFinalize(p, pXInfo);
2084
2085 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum);
2086 rbuMPrintfExec(p, p->dbMain,
2087 "CREATE TABLE rbu_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID",
2088 zCols, zPk
2089 );
2090 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
2091 }
2092}
2093
2094/*
2095** If an error has already occurred when this function is called, it
2096** immediately returns zero (without doing any work). Or, if an error
2097** occurs during the execution of this function, it sets the error code
2098** in the sqlite3rbu object indicated by the first argument and returns
2099** zero.
2100**
2101** The iterator passed as the second argument is guaranteed to point to
2102** a table (not an index) when this function is called. This function
2103** attempts to create any imposter table required to write to the main
2104** table b-tree of the table before returning. Non-zero is returned if
2105** an imposter table are created, or zero otherwise.
2106**
2107** An imposter table is required in all cases except RBU_PK_VTAB. Only
2108** virtual tables are written to directly. The imposter table has the
2109** same schema as the actual target table (less any UNIQUE constraints).
2110** More precisely, the "same schema" means the same columns, types,
2111** collation sequences. For tables that do not have an external PRIMARY
2112** KEY, it also means the same PRIMARY KEY declaration.
2113*/
2114static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
2115 if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
2116 int tnum = pIter->iTnum;
2117 const char *zComma = "";
2118 char *zSql = 0;
2119 int iCol;
2120 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1);
2121
2122 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
2123 const char *zPk = "";
2124 const char *zCol = pIter->azTblCol[iCol];
2125 const char *zColl = 0;
2126
2127 p->rc = sqlite3_table_column_metadata(
2128 p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
2129 );
2130
2131 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
2132 /* If the target table column is an "INTEGER PRIMARY KEY", add
2133 ** "PRIMARY KEY" to the imposter table column declaration. */
2134 zPk = "PRIMARY KEY ";
2135 }
2136 zSql = rbuMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %Q%s",
2137 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
2138 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
2139 );
2140 zComma = ", ";
2141 }
2142
2143 if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
2144 char *zPk = rbuWithoutRowidPK(p, pIter);
2145 if( zPk ){
2146 zSql = rbuMPrintf(p, "%z, %z", zSql, zPk);
2147 }
2148 }
2149
2150 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum);
2151 rbuMPrintfExec(p, p->dbMain, "CREATE TABLE \"rbu_imp_%w\"(%z)%s",
2152 pIter->zTbl, zSql,
2153 (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
2154 );
2155 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
2156 }
2157}
2158
2159/*
2160** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table.
2161** Specifically a statement of the form:
2162**
2163** INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...);
2164**
2165** The number of bound variables is equal to the number of columns in
2166** the target table, plus one (for the rbu_control column), plus one more
2167** (for the rbu_rowid column) if the target table is an implicit IPK or
2168** virtual table.
2169*/
2170static void rbuObjIterPrepareTmpInsert(
2171 sqlite3rbu *p,
2172 RbuObjIter *pIter,
2173 const char *zCollist,
2174 const char *zRbuRowid
2175){
2176 int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
2177 char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
2178 if( zBind ){
2179 assert( pIter->pTmpInsert==0 );
2180 p->rc = prepareFreeAndCollectError(
2181 p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
2182 "INSERT INTO %s.'rbu_tmp_%q'(rbu_control,%s%s) VALUES(%z)",
2183 p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
2184 ));
2185 }
2186}
2187
2188static void rbuTmpInsertFunc(
2189 sqlite3_context *pCtx,
2190 int nVal,
2191 sqlite3_value **apVal
2192){
2193 sqlite3rbu *p = sqlite3_user_data(pCtx);
2194 int rc = SQLITE_OK;
2195 int i;
2196
2197 assert( sqlite3_value_int(apVal[0])!=0
2198 || p->objiter.eType==RBU_PK_EXTERNAL
2199 || p->objiter.eType==RBU_PK_NONE
2200 );
2201 if( sqlite3_value_int(apVal[0])!=0 ){
2202 p->nPhaseOneStep += p->objiter.nIndex;
2203 }
2204
2205 for(i=0; rc==SQLITE_OK && i<nVal; i++){
2206 rc = sqlite3_bind_value(p->objiter.pTmpInsert, i+1, apVal[i]);
2207 }
2208 if( rc==SQLITE_OK ){
2209 sqlite3_step(p->objiter.pTmpInsert);
2210 rc = sqlite3_reset(p->objiter.pTmpInsert);
2211 }
2212
2213 if( rc!=SQLITE_OK ){
2214 sqlite3_result_error_code(pCtx, rc);
2215 }
2216}
2217
2218static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
2219 sqlite3_stmt *pStmt = 0;
2220 int rc = p->rc;
2221 char *zRet = 0;
2222
2223 assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
2224
2225 if( rc==SQLITE_OK ){
2226 rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
2227 "SELECT trim(sql) FROM sqlite_schema WHERE type='index' AND name=?"
2228 );
2229 }
2230 if( rc==SQLITE_OK ){
2231 int rc2;
2232 rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
2233 if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
2234 char *zSql = (char*)sqlite3_column_text(pStmt, 0);
2235 if( zSql ){
2236 pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
2237 }
2238 if( zSql ){
2239 int nParen = 0; /* Number of open parenthesis */
2240 int i;
2241 int iIdxCol = 0;
2242 int nIdxAlloc = 0;
2243 for(i=0; zSql[i]; i++){
2244 char c = zSql[i];
2245
2246 /* If necessary, grow the pIter->aIdxCol[] array */
2247 if( iIdxCol==nIdxAlloc ){
2248 RbuSpan *aIdxCol = (RbuSpan*)sqlite3_realloc(
2249 pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan)
2250 );
2251 if( aIdxCol==0 ){
2252 rc = SQLITE_NOMEM;
2253 break;
2254 }
2255 pIter->aIdxCol = aIdxCol;
2256 nIdxAlloc += 16;
2257 }
2258
2259 if( c=='(' ){
2260 if( nParen==0 ){
2261 assert( iIdxCol==0 );
2262 pIter->aIdxCol[0].zSpan = &zSql[i+1];
2263 }
2264 nParen++;
2265 }
2266 else if( c==')' ){
2267 nParen--;
2268 if( nParen==0 ){
2269 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
2270 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
2271 i++;
2272 break;
2273 }
2274 }else if( c==',' && nParen==1 ){
2275 int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
2276 pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
2277 pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
2278 }else if( c=='"' || c=='\'' || c=='`' ){
2279 for(i++; 1; i++){
2280 if( zSql[i]==c ){
2281 if( zSql[i+1]!=c ) break;
2282 i++;
2283 }
2284 }
2285 }else if( c=='[' ){
2286 for(i++; 1; i++){
2287 if( zSql[i]==']' ) break;
2288 }
2289 }else if( c=='-' && zSql[i+1]=='-' ){
2290 for(i=i+2; zSql[i] && zSql[i]!='\n'; i++);
2291 if( zSql[i]=='\0' ) break;
2292 }else if( c=='/' && zSql[i+1]=='*' ){
2293 for(i=i+2; zSql[i] && (zSql[i]!='*' || zSql[i+1]!='/'); i++);
2294 if( zSql[i]=='\0' ) break;
2295 i++;
2296 }
2297 }
2298 if( zSql[i] ){
2299 zRet = rbuStrndup(&zSql[i], &rc);
2300 }
2301 pIter->nIdxCol = iIdxCol;
2302 }
2303 }
2304
2305 rc2 = sqlite3_finalize(pStmt);
2306 if( rc==SQLITE_OK ) rc = rc2;
2307 }
2308
2309 p->rc = rc;
2310 return zRet;
2311}
2312
2313/*
2314** Ensure that the SQLite statement handles required to update the
2315** target database object currently indicated by the iterator passed
2316** as the second argument are available.
2317*/
2318static int rbuObjIterPrepareAll(
2319 sqlite3rbu *p,
2320 RbuObjIter *pIter,
2321 int nOffset /* Add "LIMIT -1 OFFSET $nOffset" to SELECT */
2322){
2323 assert( pIter->bCleanup==0 );
2324 if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
2325 const int tnum = pIter->iTnum;
2326 char *zCollist = 0; /* List of indexed columns */
2327 char **pz = &p->zErrmsg;
2328 const char *zIdx = pIter->zIdx;
2329 char *zLimit = 0;
2330
2331 if( nOffset ){
2332 zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset);
2333 if( !zLimit ) p->rc = SQLITE_NOMEM;
2334 }
2335
2336 if( zIdx ){
2337 const char *zTbl = pIter->zTbl;
2338 char *zImposterCols = 0; /* Columns for imposter table */
2339 char *zImposterPK = 0; /* Primary key declaration for imposter */
2340 char *zWhere = 0; /* WHERE clause on PK columns */
2341 char *zBind = 0;
2342 char *zPart = 0;
2343 int nBind = 0;
2344
2345 assert( pIter->eType!=RBU_PK_VTAB );
2346 zPart = rbuObjIterGetIndexWhere(p, pIter);
2347 zCollist = rbuObjIterGetIndexCols(
2348 p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
2349 );
2350 zBind = rbuObjIterGetBindlist(p, nBind);
2351
2352 /* Create the imposter table used to write to this index. */
2353 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1);
2354 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1,tnum);
2355 rbuMPrintfExec(p, p->dbMain,
2356 "CREATE TABLE \"rbu_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID",
2357 zTbl, zImposterCols, zImposterPK
2358 );
2359 sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
2360
2361 /* Create the statement to insert index entries */
2362 pIter->nCol = nBind;
2363 if( p->rc==SQLITE_OK ){
2364 p->rc = prepareFreeAndCollectError(
2365 p->dbMain, &pIter->pInsert, &p->zErrmsg,
2366 sqlite3_mprintf("INSERT INTO \"rbu_imp_%w\" VALUES(%s)", zTbl, zBind)
2367 );
2368 }
2369
2370 /* And to delete index entries */
2371 if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
2372 p->rc = prepareFreeAndCollectError(
2373 p->dbMain, &pIter->pDelete, &p->zErrmsg,
2374 sqlite3_mprintf("DELETE FROM \"rbu_imp_%w\" WHERE %s", zTbl, zWhere)
2375 );
2376 }
2377
2378 /* Create the SELECT statement to read keys in sorted order */
2379 if( p->rc==SQLITE_OK ){
2380 char *zSql;
2381 if( rbuIsVacuum(p) ){
2382 char *zStart = 0;
2383 if( nOffset ){
2384 zStart = rbuVacuumIndexStart(p, pIter);
2385 if( zStart ){
2386 sqlite3_free(zLimit);
2387 zLimit = 0;
2388 }
2389 }
2390
2391 zSql = sqlite3_mprintf(
2392 "SELECT %s, 0 AS rbu_control FROM '%q' %s %s %s ORDER BY %s%s",
2393 zCollist,
2394 pIter->zDataTbl,
2395 zPart,
2396 (zStart ? (zPart ? "AND" : "WHERE") : ""), zStart,
2397 zCollist, zLimit
2398 );
2399 sqlite3_free(zStart);
2400 }else
2401
2402 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
2403 zSql = sqlite3_mprintf(
2404 "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s ORDER BY %s%s",
2405 zCollist, p->zStateDb, pIter->zDataTbl,
2406 zPart, zCollist, zLimit
2407 );
2408 }else{
2409 zSql = sqlite3_mprintf(
2410 "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s "
2411 "UNION ALL "
2412 "SELECT %s, rbu_control FROM '%q' "
2413 "%s %s typeof(rbu_control)='integer' AND rbu_control!=1 "
2414 "ORDER BY %s%s",
2415 zCollist, p->zStateDb, pIter->zDataTbl, zPart,
2416 zCollist, pIter->zDataTbl,
2417 zPart,
2418 (zPart ? "AND" : "WHERE"),
2419 zCollist, zLimit
2420 );
2421 }
2422 if( p->rc==SQLITE_OK ){
2423 p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
2424 }else{
2425 sqlite3_free(zSql);
2426 }
2427 }
2428
2429 sqlite3_free(zImposterCols);
2430 sqlite3_free(zImposterPK);
2431 sqlite3_free(zWhere);
2432 sqlite3_free(zBind);
2433 sqlite3_free(zPart);
2434 }else{
2435 int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
2436 ||(pIter->eType==RBU_PK_NONE)
2437 ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
2438 const char *zTbl = pIter->zTbl; /* Table this step applies to */
2439 const char *zWrite; /* Imposter table name */
2440
2441 char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
2442 char *zWhere = rbuObjIterGetWhere(p, pIter);
2443 char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
2444 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
2445
2446 zCollist = rbuObjIterGetCollist(p, pIter);
2447 pIter->nCol = pIter->nTblCol;
2448
2449 /* Create the imposter table or tables (if required). */
2450 rbuCreateImposterTable(p, pIter);
2451 rbuCreateImposterTable2(p, pIter);
2452 zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
2453
2454 /* Create the INSERT statement to write to the target PK b-tree */
2455 if( p->rc==SQLITE_OK ){
2456 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
2457 sqlite3_mprintf(
2458 "INSERT INTO \"%s%w\"(%s%s) VALUES(%s)",
2459 zWrite, zTbl, zCollist, (bRbuRowid ? ", _rowid_" : ""), zBindings
2460 )
2461 );
2462 }
2463
2464 /* Create the DELETE statement to write to the target PK b-tree.
2465 ** Because it only performs INSERT operations, this is not required for
2466 ** an rbu vacuum handle. */
2467 if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
2468 p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
2469 sqlite3_mprintf(
2470 "DELETE FROM \"%s%w\" WHERE %s", zWrite, zTbl, zWhere
2471 )
2472 );
2473 }
2474
2475 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
2476 const char *zRbuRowid = "";
2477 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
2478 zRbuRowid = ", rbu_rowid";
2479 }
2480
2481 /* Create the rbu_tmp_xxx table and the triggers to populate it. */
2482 rbuMPrintfExec(p, p->dbRbu,
2483 "CREATE TABLE IF NOT EXISTS %s.'rbu_tmp_%q' AS "
2484 "SELECT *%s FROM '%q' WHERE 0;"
2485 , p->zStateDb, pIter->zDataTbl
2486 , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
2487 , pIter->zDataTbl
2488 );
2489
2490 rbuMPrintfExec(p, p->dbMain,
2491 "CREATE TEMP TRIGGER rbu_delete_tr BEFORE DELETE ON \"%s%w\" "
2492 "BEGIN "
2493 " SELECT rbu_tmp_insert(3, %s);"
2494 "END;"
2495
2496 "CREATE TEMP TRIGGER rbu_update1_tr BEFORE UPDATE ON \"%s%w\" "
2497 "BEGIN "
2498 " SELECT rbu_tmp_insert(3, %s);"
2499 "END;"
2500
2501 "CREATE TEMP TRIGGER rbu_update2_tr AFTER UPDATE ON \"%s%w\" "
2502 "BEGIN "
2503 " SELECT rbu_tmp_insert(4, %s);"
2504 "END;",
2505 zWrite, zTbl, zOldlist,
2506 zWrite, zTbl, zOldlist,
2507 zWrite, zTbl, zNewlist
2508 );
2509
2510 if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
2511 rbuMPrintfExec(p, p->dbMain,
2512 "CREATE TEMP TRIGGER rbu_insert_tr AFTER INSERT ON \"%s%w\" "
2513 "BEGIN "
2514 " SELECT rbu_tmp_insert(0, %s);"
2515 "END;",
2516 zWrite, zTbl, zNewlist
2517 );
2518 }
2519
2520 rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
2521 }
2522
2523 /* Create the SELECT statement to read keys from data_xxx */
2524 if( p->rc==SQLITE_OK ){
2525 const char *zRbuRowid = "";
2526 char *zStart = 0;
2527 char *zOrder = 0;
2528 if( bRbuRowid ){
2529 zRbuRowid = rbuIsVacuum(p) ? ",_rowid_ " : ",rbu_rowid";
2530 }
2531
2532 if( rbuIsVacuum(p) ){
2533 if( nOffset ){
2534 zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
2535 if( zStart ){
2536 sqlite3_free(zLimit);
2537 zLimit = 0;
2538 }
2539 }
2540 if( bRbuRowid ){
2541 zOrder = rbuMPrintf(p, "_rowid_");
2542 }else{
2543 zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
2544 }
2545 }
2546
2547 if( p->rc==SQLITE_OK ){
2548 p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
2549 sqlite3_mprintf(
2550 "SELECT %s,%s rbu_control%s FROM '%q'%s %s %s %s",
2551 zCollist,
2552 (rbuIsVacuum(p) ? "0 AS " : ""),
2553 zRbuRowid,
2554 pIter->zDataTbl, (zStart ? zStart : ""),
2555 (zOrder ? "ORDER BY" : ""), zOrder,
2556 zLimit
2557 )
2558 );
2559 }
2560 sqlite3_free(zStart);
2561 sqlite3_free(zOrder);
2562 }
2563
2564 sqlite3_free(zWhere);
2565 sqlite3_free(zOldlist);
2566 sqlite3_free(zNewlist);
2567 sqlite3_free(zBindings);
2568 }
2569 sqlite3_free(zCollist);
2570 sqlite3_free(zLimit);
2571 }
2572
2573 return p->rc;
2574}
2575
2576/*
2577** Set output variable *ppStmt to point to an UPDATE statement that may
2578** be used to update the imposter table for the main table b-tree of the
2579** table object that pIter currently points to, assuming that the
2580** rbu_control column of the data_xyz table contains zMask.
2581**
2582** If the zMask string does not specify any columns to update, then this
2583** is not an error. Output variable *ppStmt is set to NULL in this case.
2584*/
2585static int rbuGetUpdateStmt(
2586 sqlite3rbu *p, /* RBU handle */
2587 RbuObjIter *pIter, /* Object iterator */
2588 const char *zMask, /* rbu_control value ('x.x.') */
2589 sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */
2590){
2591 RbuUpdateStmt **pp;
2592 RbuUpdateStmt *pUp = 0;
2593 int nUp = 0;
2594
2595 /* In case an error occurs */
2596 *ppStmt = 0;
2597
2598 /* Search for an existing statement. If one is found, shift it to the front
2599 ** of the LRU queue and return immediately. Otherwise, leave nUp pointing
2600 ** to the number of statements currently in the cache and pUp to the
2601 ** last object in the list. */
2602 for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
2603 pUp = *pp;
2604 if( strcmp(pUp->zMask, zMask)==0 ){
2605 *pp = pUp->pNext;
2606 pUp->pNext = pIter->pRbuUpdate;
2607 pIter->pRbuUpdate = pUp;
2608 *ppStmt = pUp->pUpdate;
2609 return SQLITE_OK;
2610 }
2611 nUp++;
2612 }
2613 assert( pUp==0 || pUp->pNext==0 );
2614
2615 if( nUp>=SQLITE_RBU_UPDATE_CACHESIZE ){
2616 for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
2617 *pp = 0;
2618 sqlite3_finalize(pUp->pUpdate);
2619 pUp->pUpdate = 0;
2620 }else{
2621 pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
2622 }
2623
2624 if( pUp ){
2625 char *zWhere = rbuObjIterGetWhere(p, pIter);
2626 char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
2627 char *zUpdate = 0;
2628
2629 pUp->zMask = (char*)&pUp[1];
2630 memcpy(pUp->zMask, zMask, pIter->nTblCol);
2631 pUp->pNext = pIter->pRbuUpdate;
2632 pIter->pRbuUpdate = pUp;
2633
2634 if( zSet ){
2635 const char *zPrefix = "";
2636
2637 if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
2638 zUpdate = sqlite3_mprintf("UPDATE \"%s%w\" SET %s WHERE %s",
2639 zPrefix, pIter->zTbl, zSet, zWhere
2640 );
2641 p->rc = prepareFreeAndCollectError(
2642 p->dbMain, &pUp->pUpdate, &p->zErrmsg, zUpdate
2643 );
2644 *ppStmt = pUp->pUpdate;
2645 }
2646 sqlite3_free(zWhere);
2647 sqlite3_free(zSet);
2648 }
2649
2650 return p->rc;
2651}
2652
2653static sqlite3 *rbuOpenDbhandle(
2654 sqlite3rbu *p,
2655 const char *zName,
2656 int bUseVfs
2657){
2658 sqlite3 *db = 0;
2659 if( p->rc==SQLITE_OK ){
2660 const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI;
2661 p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
2662 if( p->rc ){
2663 p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
2664 sqlite3_close(db);
2665 db = 0;
2666 }
2667 }
2668 return db;
2669}
2670
2671/*
2672** Free an RbuState object allocated by rbuLoadState().
2673*/
2674static void rbuFreeState(RbuState *p){
2675 if( p ){
2676 sqlite3_free(p->zTbl);
2677 sqlite3_free(p->zDataTbl);
2678 sqlite3_free(p->zIdx);
2679 sqlite3_free(p);
2680 }
2681}
2682
2683/*
2684** Allocate an RbuState object and load the contents of the rbu_state
2685** table into it. Return a pointer to the new object. It is the
2686** responsibility of the caller to eventually free the object using
2687** sqlite3_free().
2688**
2689** If an error occurs, leave an error code and message in the rbu handle
2690** and return NULL.
2691*/
2692static RbuState *rbuLoadState(sqlite3rbu *p){
2693 RbuState *pRet = 0;
2694 sqlite3_stmt *pStmt = 0;
2695 int rc;
2696 int rc2;
2697
2698 pRet = (RbuState*)rbuMalloc(p, sizeof(RbuState));
2699 if( pRet==0 ) return 0;
2700
2701 rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
2702 sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb)
2703 );
2704 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
2705 switch( sqlite3_column_int(pStmt, 0) ){
2706 case RBU_STATE_STAGE:
2707 pRet->eStage = sqlite3_column_int(pStmt, 1);
2708 if( pRet->eStage!=RBU_STAGE_OAL
2709 && pRet->eStage!=RBU_STAGE_MOVE
2710 && pRet->eStage!=RBU_STAGE_CKPT
2711 ){
2712 p->rc = SQLITE_CORRUPT;
2713 }
2714 break;
2715
2716 case RBU_STATE_TBL:
2717 pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
2718 break;
2719
2720 case RBU_STATE_IDX:
2721 pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
2722 break;
2723
2724 case RBU_STATE_ROW:
2725 pRet->nRow = sqlite3_column_int(pStmt, 1);
2726 break;
2727
2728 case RBU_STATE_PROGRESS:
2729 pRet->nProgress = sqlite3_column_int64(pStmt, 1);
2730 break;
2731
2732 case RBU_STATE_CKPT:
2733 pRet->iWalCksum = sqlite3_column_int64(pStmt, 1);
2734 break;
2735
2736 case RBU_STATE_COOKIE:
2737 pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1);
2738 break;
2739
2740 case RBU_STATE_OALSZ:
2741 pRet->iOalSz = sqlite3_column_int64(pStmt, 1);
2742 break;
2743
2744 case RBU_STATE_PHASEONESTEP:
2745 pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1);
2746 break;
2747
2748 case RBU_STATE_DATATBL:
2749 pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
2750 break;
2751
2752 default:
2753 rc = SQLITE_CORRUPT;
2754 break;
2755 }
2756 }
2757 rc2 = sqlite3_finalize(pStmt);
2758 if( rc==SQLITE_OK ) rc = rc2;
2759
2760 p->rc = rc;
2761 return pRet;
2762}
2763
2764
2765/*
2766** Open the database handle and attach the RBU database as "rbu". If an
2767** error occurs, leave an error code and message in the RBU handle.
2768**
2769** If argument dbMain is not NULL, then it is a database handle already
2770** open on the target database. Use this handle instead of opening a new
2771** one.
2772*/
2773static void rbuOpenDatabase(sqlite3rbu *p, sqlite3 *dbMain, int *pbRetry){
2774 assert( p->rc || (p->dbMain==0 && p->dbRbu==0) );
2775 assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 );
2776 assert( dbMain==0 || rbuIsVacuum(p)==0 );
2777
2778 /* Open the RBU database */
2779 p->dbRbu = rbuOpenDbhandle(p, p->zRbu, 1);
2780 p->dbMain = dbMain;
2781
2782 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
2783 sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p);
2784 if( p->zState==0 ){
2785 const char *zFile = sqlite3_db_filename(p->dbRbu, "main");
2786 p->zState = rbuMPrintf(p, "file:///%s-vacuum?modeof=%s", zFile, zFile);
2787 }
2788 }
2789
2790 /* If using separate RBU and state databases, attach the state database to
2791 ** the RBU db handle now. */
2792 if( p->zState ){
2793 rbuMPrintfExec(p, p->dbRbu, "ATTACH %Q AS stat", p->zState);
2794 memcpy(p->zStateDb, "stat", 4);
2795 }else{
2796 memcpy(p->zStateDb, "main", 4);
2797 }
2798
2799#if 0
2800 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
2801 p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, 0);
2802 }
2803#endif
2804
2805 /* If it has not already been created, create the rbu_state table */
2806 rbuMPrintfExec(p, p->dbRbu, RBU_CREATE_STATE, p->zStateDb);
2807
2808#if 0
2809 if( rbuIsVacuum(p) ){
2810 if( p->rc==SQLITE_OK ){
2811 int rc2;
2812 int bOk = 0;
2813 sqlite3_stmt *pCnt = 0;
2814 p->rc = prepareAndCollectError(p->dbRbu, &pCnt, &p->zErrmsg,
2815 "SELECT count(*) FROM stat.sqlite_schema"
2816 );
2817 if( p->rc==SQLITE_OK
2818 && sqlite3_step(pCnt)==SQLITE_ROW
2819 && 1==sqlite3_column_int(pCnt, 0)
2820 ){
2821 bOk = 1;
2822 }
2823 rc2 = sqlite3_finalize(pCnt);
2824 if( p->rc==SQLITE_OK ) p->rc = rc2;
2825
2826 if( p->rc==SQLITE_OK && bOk==0 ){
2827 p->rc = SQLITE_ERROR;
2828 p->zErrmsg = sqlite3_mprintf("invalid state database");
2829 }
2830
2831 if( p->rc==SQLITE_OK ){
2832 p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
2833 }
2834 }
2835 }
2836#endif
2837
2838 if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
2839 int bOpen = 0;
2840 int rc;
2841 p->nRbu = 0;
2842 p->pRbuFd = 0;
2843 rc = sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p);
2844 if( rc!=SQLITE_NOTFOUND ) p->rc = rc;
2845 if( p->eStage>=RBU_STAGE_MOVE ){
2846 bOpen = 1;
2847 }else{
2848 RbuState *pState = rbuLoadState(p);
2849 if( pState ){
2850 bOpen = (pState->eStage>=RBU_STAGE_MOVE);
2851 rbuFreeState(pState);
2852 }
2853 }
2854 if( bOpen ) p->dbMain = rbuOpenDbhandle(p, p->zRbu, p->nRbu<=1);
2855 }
2856
2857 p->eStage = 0;
2858 if( p->rc==SQLITE_OK && p->dbMain==0 ){
2859 if( !rbuIsVacuum(p) ){
2860 p->dbMain = rbuOpenDbhandle(p, p->zTarget, 1);
2861 }else if( p->pRbuFd->pWalFd ){
2862 if( pbRetry ){
2863 p->pRbuFd->bNolock = 0;
2864 sqlite3_close(p->dbRbu);
2865 sqlite3_close(p->dbMain);
2866 p->dbMain = 0;
2867 p->dbRbu = 0;
2868 *pbRetry = 1;
2869 return;
2870 }
2871 p->rc = SQLITE_ERROR;
2872 p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database");
2873 }else{
2874 char *zTarget;
2875 char *zExtra = 0;
2876 if( strlen(p->zRbu)>=5 && 0==memcmp("file:", p->zRbu, 5) ){
2877 zExtra = &p->zRbu[5];
2878 while( *zExtra ){
2879 if( *zExtra++=='?' ) break;
2880 }
2881 if( *zExtra=='\0' ) zExtra = 0;
2882 }
2883
2884 zTarget = sqlite3_mprintf("file:%s-vactmp?rbu_memory=1%s%s",
2885 sqlite3_db_filename(p->dbRbu, "main"),
2886 (zExtra==0 ? "" : "&"), (zExtra==0 ? "" : zExtra)
2887 );
2888
2889 if( zTarget==0 ){
2890 p->rc = SQLITE_NOMEM;
2891 return;
2892 }
2893 p->dbMain = rbuOpenDbhandle(p, zTarget, p->nRbu<=1);
2894 sqlite3_free(zTarget);
2895 }
2896 }
2897
2898 if( p->rc==SQLITE_OK ){
2899 p->rc = sqlite3_create_function(p->dbMain,
2900 "rbu_tmp_insert", -1, SQLITE_UTF8, (void*)p, rbuTmpInsertFunc, 0, 0
2901 );
2902 }
2903
2904 if( p->rc==SQLITE_OK ){
2905 p->rc = sqlite3_create_function(p->dbMain,
2906 "rbu_fossil_delta", 2, SQLITE_UTF8, 0, rbuFossilDeltaFunc, 0, 0
2907 );
2908 }
2909
2910 if( p->rc==SQLITE_OK ){
2911 p->rc = sqlite3_create_function(p->dbRbu,
2912 "rbu_target_name", -1, SQLITE_UTF8, (void*)p, rbuTargetNameFunc, 0, 0
2913 );
2914 }
2915
2916 if( p->rc==SQLITE_OK ){
2917 p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p);
2918 }
2919 rbuMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_schema");
2920
2921 /* Mark the database file just opened as an RBU target database. If
2922 ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use.
2923 ** This is an error. */
2924 if( p->rc==SQLITE_OK ){
2925 p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p);
2926 }
2927
2928 if( p->rc==SQLITE_NOTFOUND ){
2929 p->rc = SQLITE_ERROR;
2930 p->zErrmsg = sqlite3_mprintf("rbu vfs not found");
2931 }
2932}
2933
2934/*
2935** This routine is a copy of the sqlite3FileSuffix3() routine from the core.
2936** It is a no-op unless SQLITE_ENABLE_8_3_NAMES is defined.
2937**
2938** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
2939** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
2940** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
2941** three characters, then shorten the suffix on z[] to be the last three
2942** characters of the original suffix.
2943**
2944** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
2945** do the suffix shortening regardless of URI parameter.
2946**
2947** Examples:
2948**
2949** test.db-journal => test.nal
2950** test.db-wal => test.wal
2951** test.db-shm => test.shm
2952** test.db-mj7f3319fa => test.9fa
2953*/
2954static void rbuFileSuffix3(const char *zBase, char *z){
2955#ifdef SQLITE_ENABLE_8_3_NAMES
2956#if SQLITE_ENABLE_8_3_NAMES<2
2957 if( sqlite3_uri_boolean(zBase, "8_3_names", 0) )
2958#endif
2959 {
2960 int i, sz;
2961 sz = (int)strlen(z)&0xffffff;
2962 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
2963 if( z[i]=='.' && sz>i+4 ) memmove(&z[i+1], &z[sz-3], 4);
2964 }
2965#endif
2966}
2967
2968/*
2969** Return the current wal-index header checksum for the target database
2970** as a 64-bit integer.
2971**
2972** The checksum is store in the first page of xShmMap memory as an 8-byte
2973** blob starting at byte offset 40.
2974*/
2975static i64 rbuShmChecksum(sqlite3rbu *p){
2976 i64 iRet = 0;
2977 if( p->rc==SQLITE_OK ){
2978 sqlite3_file *pDb = p->pTargetFd->pReal;
2979 u32 volatile *ptr;
2980 p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, (void volatile**)&ptr);
2981 if( p->rc==SQLITE_OK ){
2982 iRet = ((i64)ptr[10] << 32) + ptr[11];
2983 }
2984 }
2985 return iRet;
2986}
2987
2988/*
2989** This function is called as part of initializing or reinitializing an
2990** incremental checkpoint.
2991**
2992** It populates the sqlite3rbu.aFrame[] array with the set of
2993** (wal frame -> db page) copy operations required to checkpoint the
2994** current wal file, and obtains the set of shm locks required to safely
2995** perform the copy operations directly on the file-system.
2996**
2997** If argument pState is not NULL, then the incremental checkpoint is
2998** being resumed. In this case, if the checksum of the wal-index-header
2999** following recovery is not the same as the checksum saved in the RbuState
3000** object, then the rbu handle is set to DONE state. This occurs if some
3001** other client appends a transaction to the wal file in the middle of
3002** an incremental checkpoint.
3003*/
3004static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){
3005
3006 /* If pState is NULL, then the wal file may not have been opened and
3007 ** recovered. Running a read-statement here to ensure that doing so
3008 ** does not interfere with the "capture" process below. */
3009 if( pState==0 ){
3010 p->eStage = 0;
3011 if( p->rc==SQLITE_OK ){
3012 p->rc = sqlite3_exec(p->dbMain, "SELECT * FROM sqlite_schema", 0, 0, 0);
3013 }
3014 }
3015
3016 /* Assuming no error has occurred, run a "restart" checkpoint with the
3017 ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following
3018 ** special behaviour in the rbu VFS:
3019 **
3020 ** * If the exclusive shm WRITER or READ0 lock cannot be obtained,
3021 ** the checkpoint fails with SQLITE_BUSY (normally SQLite would
3022 ** proceed with running a passive checkpoint instead of failing).
3023 **
3024 ** * Attempts to read from the *-wal file or write to the database file
3025 ** do not perform any IO. Instead, the frame/page combinations that
3026 ** would be read/written are recorded in the sqlite3rbu.aFrame[]
3027 ** array.
3028 **
3029 ** * Calls to xShmLock(UNLOCK) to release the exclusive shm WRITER,
3030 ** READ0 and CHECKPOINT locks taken as part of the checkpoint are
3031 ** no-ops. These locks will not be released until the connection
3032 ** is closed.
3033 **
3034 ** * Attempting to xSync() the database file causes an SQLITE_INTERNAL
3035 ** error.
3036 **
3037 ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the
3038 ** checkpoint below fails with SQLITE_INTERNAL, and leaves the aFrame[]
3039 ** array populated with a set of (frame -> page) mappings. Because the
3040 ** WRITER, CHECKPOINT and READ0 locks are still held, it is safe to copy
3041 ** data from the wal file into the database file according to the
3042 ** contents of aFrame[].
3043 */
3044 if( p->rc==SQLITE_OK ){
3045 int rc2;
3046 p->eStage = RBU_STAGE_CAPTURE;
3047 rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0);
3048 if( rc2!=SQLITE_INTERNAL ) p->rc = rc2;
3049 }
3050
3051 if( p->rc==SQLITE_OK && p->nFrame>0 ){
3052 p->eStage = RBU_STAGE_CKPT;
3053 p->nStep = (pState ? pState->nRow : 0);
3054 p->aBuf = rbuMalloc(p, p->pgsz);
3055 p->iWalCksum = rbuShmChecksum(p);
3056 }
3057
3058 if( p->rc==SQLITE_OK ){
3059 if( p->nFrame==0 || (pState && pState->iWalCksum!=p->iWalCksum) ){
3060 p->rc = SQLITE_DONE;
3061 p->eStage = RBU_STAGE_DONE;
3062 }else{
3063 int nSectorSize;
3064 sqlite3_file *pDb = p->pTargetFd->pReal;
3065 sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
3066 assert( p->nPagePerSector==0 );
3067 nSectorSize = pDb->pMethods->xSectorSize(pDb);
3068 if( nSectorSize>p->pgsz ){
3069 p->nPagePerSector = nSectorSize / p->pgsz;
3070 }else{
3071 p->nPagePerSector = 1;
3072 }
3073
3074 /* Call xSync() on the wal file. This causes SQLite to sync the
3075 ** directory in which the target database and the wal file reside, in
3076 ** case it has not been synced since the rename() call in
3077 ** rbuMoveOalFile(). */
3078 p->rc = pWal->pMethods->xSync(pWal, SQLITE_SYNC_NORMAL);
3079 }
3080 }
3081}
3082
3083/*
3084** Called when iAmt bytes are read from offset iOff of the wal file while
3085** the rbu object is in capture mode. Record the frame number of the frame
3086** being read in the aFrame[] array.
3087*/
3088static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){
3089 const u32 mReq = (1<<WAL_LOCK_WRITE)|(1<<WAL_LOCK_CKPT)|(1<<WAL_LOCK_READ0);
3090 u32 iFrame;
3091
3092 if( pRbu->mLock!=mReq ){
3093 pRbu->rc = SQLITE_BUSY;
3094 return SQLITE_INTERNAL;
3095 }
3096
3097 pRbu->pgsz = iAmt;
3098 if( pRbu->nFrame==pRbu->nFrameAlloc ){
3099 int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
3100 RbuFrame *aNew;
3101 aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
3102 if( aNew==0 ) return SQLITE_NOMEM;
3103 pRbu->aFrame = aNew;
3104 pRbu->nFrameAlloc = nNew;
3105 }
3106
3107 iFrame = (u32)((iOff-32) / (i64)(iAmt+24)) + 1;
3108 if( pRbu->iMaxFrame<iFrame ) pRbu->iMaxFrame = iFrame;
3109 pRbu->aFrame[pRbu->nFrame].iWalFrame = iFrame;
3110 pRbu->aFrame[pRbu->nFrame].iDbPage = 0;
3111 pRbu->nFrame++;
3112 return SQLITE_OK;
3113}
3114
3115/*
3116** Called when a page of data is written to offset iOff of the database
3117** file while the rbu handle is in capture mode. Record the page number
3118** of the page being written in the aFrame[] array.
3119*/
3120static int rbuCaptureDbWrite(sqlite3rbu *pRbu, i64 iOff){
3121 pRbu->aFrame[pRbu->nFrame-1].iDbPage = (u32)(iOff / pRbu->pgsz) + 1;
3122 return SQLITE_OK;
3123}
3124
3125/*
3126** This is called as part of an incremental checkpoint operation. Copy
3127** a single frame of data from the wal file into the database file, as
3128** indicated by the RbuFrame object.
3129*/
3130static void rbuCheckpointFrame(sqlite3rbu *p, RbuFrame *pFrame){
3131 sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
3132 sqlite3_file *pDb = p->pTargetFd->pReal;
3133 i64 iOff;
3134
3135 assert( p->rc==SQLITE_OK );
3136 iOff = (i64)(pFrame->iWalFrame-1) * (p->pgsz + 24) + 32 + 24;
3137 p->rc = pWal->pMethods->xRead(pWal, p->aBuf, p->pgsz, iOff);
3138 if( p->rc ) return;
3139
3140 iOff = (i64)(pFrame->iDbPage-1) * p->pgsz;
3141 p->rc = pDb->pMethods->xWrite(pDb, p->aBuf, p->pgsz, iOff);
3142}
3143
3144
3145/*
3146** Take an EXCLUSIVE lock on the database file. Return SQLITE_OK if
3147** successful, or an SQLite error code otherwise.
3148*/
3149static int rbuLockDatabase(sqlite3 *db){
3150 int rc = SQLITE_OK;
3151 sqlite3_file *fd = 0;
3152 sqlite3_file_control(db, "main", SQLITE_FCNTL_FILE_POINTER, &fd);
3153
3154 if( fd->pMethods ){
3155 rc = fd->pMethods->xLock(fd, SQLITE_LOCK_SHARED);
3156 if( rc==SQLITE_OK ){
3157 rc = fd->pMethods->xLock(fd, SQLITE_LOCK_EXCLUSIVE);
3158 }
3159 }
3160 return rc;
3161}
3162
3163/*
3164** Return true if the database handle passed as the only argument
3165** was opened with the rbu_exclusive_checkpoint=1 URI parameter
3166** specified. Or false otherwise.
3167*/
3168static int rbuExclusiveCheckpoint(sqlite3 *db){
3169 const char *zUri = sqlite3_db_filename(db, 0);
3170 return sqlite3_uri_boolean(zUri, RBU_EXCLUSIVE_CHECKPOINT, 0);
3171}
3172
3173#if defined(_WIN32_WCE)
3174static LPWSTR rbuWinUtf8ToUnicode(const char *zFilename){
3175 int nChar;
3176 LPWSTR zWideFilename;
3177
3178 nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
3179 if( nChar==0 ){
3180 return 0;
3181 }
3182 zWideFilename = sqlite3_malloc64( nChar*sizeof(zWideFilename[0]) );
3183 if( zWideFilename==0 ){
3184 return 0;
3185 }
3186 memset(zWideFilename, 0, nChar*sizeof(zWideFilename[0]));
3187 nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename,
3188 nChar);
3189 if( nChar==0 ){
3190 sqlite3_free(zWideFilename);
3191 zWideFilename = 0;
3192 }
3193 return zWideFilename;
3194}
3195#endif
3196
3197/*
3198** The RBU handle is currently in RBU_STAGE_OAL state, with a SHARED lock
3199** on the database file. This proc moves the *-oal file to the *-wal path,
3200** then reopens the database file (this time in vanilla, non-oal, WAL mode).
3201** If an error occurs, leave an error code and error message in the rbu
3202** handle.
3203*/
3204static void rbuMoveOalFile(sqlite3rbu *p){
3205 const char *zBase = sqlite3_db_filename(p->dbMain, "main");
3206 const char *zMove = zBase;
3207 char *zOal;
3208 char *zWal;
3209
3210 if( rbuIsVacuum(p) ){
3211 zMove = sqlite3_db_filename(p->dbRbu, "main");
3212 }
3213 zOal = sqlite3_mprintf("%s-oal", zMove);
3214 zWal = sqlite3_mprintf("%s-wal", zMove);
3215
3216 assert( p->eStage==RBU_STAGE_MOVE );
3217 assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
3218 if( zWal==0 || zOal==0 ){
3219 p->rc = SQLITE_NOMEM;
3220 }else{
3221 /* Move the *-oal file to *-wal. At this point connection p->db is
3222 ** holding a SHARED lock on the target database file (because it is
3223 ** in WAL mode). So no other connection may be writing the db.
3224 **
3225 ** In order to ensure that there are no database readers, an EXCLUSIVE
3226 ** lock is obtained here before the *-oal is moved to *-wal.
3227 */
3228 sqlite3 *dbMain = 0;
3229 rbuFileSuffix3(zBase, zWal);
3230 rbuFileSuffix3(zBase, zOal);
3231
3232 /* Re-open the databases. */
3233 rbuObjIterFinalize(&p->objiter);
3234 sqlite3_close(p->dbRbu);
3235 sqlite3_close(p->dbMain);
3236 p->dbMain = 0;
3237 p->dbRbu = 0;
3238
3239 dbMain = rbuOpenDbhandle(p, p->zTarget, 1);
3240 if( dbMain ){
3241 assert( p->rc==SQLITE_OK );
3242 p->rc = rbuLockDatabase(dbMain);
3243 }
3244
3245 if( p->rc==SQLITE_OK ){
3246 p->rc = p->xRename(p->pRenameArg, zOal, zWal);
3247 }
3248
3249 if( p->rc!=SQLITE_OK
3250 || rbuIsVacuum(p)
3251 || rbuExclusiveCheckpoint(dbMain)==0
3252 ){
3253 sqlite3_close(dbMain);
3254 dbMain = 0;
3255 }
3256
3257 if( p->rc==SQLITE_OK ){
3258 rbuOpenDatabase(p, dbMain, 0);
3259 rbuSetupCheckpoint(p, 0);
3260 }
3261 }
3262
3263 sqlite3_free(zWal);
3264 sqlite3_free(zOal);
3265}
3266
3267/*
3268** The SELECT statement iterating through the keys for the current object
3269** (p->objiter.pSelect) currently points to a valid row. This function
3270** determines the type of operation requested by this row and returns
3271** one of the following values to indicate the result:
3272**
3273** * RBU_INSERT
3274** * RBU_DELETE
3275** * RBU_IDX_DELETE
3276** * RBU_UPDATE
3277**
3278** If RBU_UPDATE is returned, then output variable *pzMask is set to
3279** point to the text value indicating the columns to update.
3280**
3281** If the rbu_control field contains an invalid value, an error code and
3282** message are left in the RBU handle and zero returned.
3283*/
3284static int rbuStepType(sqlite3rbu *p, const char **pzMask){
3285 int iCol = p->objiter.nCol; /* Index of rbu_control column */
3286 int res = 0; /* Return value */
3287
3288 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
3289 case SQLITE_INTEGER: {
3290 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
3291 switch( iVal ){
3292 case 0: res = RBU_INSERT; break;
3293 case 1: res = RBU_DELETE; break;
3294 case 2: res = RBU_REPLACE; break;
3295 case 3: res = RBU_IDX_DELETE; break;
3296 case 4: res = RBU_IDX_INSERT; break;
3297 }
3298 break;
3299 }
3300
3301 case SQLITE_TEXT: {
3302 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
3303 if( z==0 ){
3304 p->rc = SQLITE_NOMEM;
3305 }else{
3306 *pzMask = (const char*)z;
3307 }
3308 res = RBU_UPDATE;
3309
3310 break;
3311 }
3312
3313 default:
3314 break;
3315 }
3316
3317 if( res==0 ){
3318 rbuBadControlError(p);
3319 }
3320 return res;
3321}
3322
3323#ifdef SQLITE_DEBUG
3324/*
3325** Assert that column iCol of statement pStmt is named zName.
3326*/
3327static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
3328 const char *zCol = sqlite3_column_name(pStmt, iCol);
3329 assert( 0==sqlite3_stricmp(zName, zCol) );
3330}
3331#else
3332# define assertColumnName(x,y,z)
3333#endif
3334
3335/*
3336** Argument eType must be one of RBU_INSERT, RBU_DELETE, RBU_IDX_INSERT or
3337** RBU_IDX_DELETE. This function performs the work of a single
3338** sqlite3rbu_step() call for the type of operation specified by eType.
3339*/
3340static void rbuStepOneOp(sqlite3rbu *p, int eType){
3341 RbuObjIter *pIter = &p->objiter;
3342 sqlite3_value *pVal;
3343 sqlite3_stmt *pWriter;
3344 int i;
3345
3346 assert( p->rc==SQLITE_OK );
3347 assert( eType!=RBU_DELETE || pIter->zIdx==0 );
3348 assert( eType==RBU_DELETE || eType==RBU_IDX_DELETE
3349 || eType==RBU_INSERT || eType==RBU_IDX_INSERT
3350 );
3351
3352 /* If this is a delete, decrement nPhaseOneStep by nIndex. If the DELETE
3353 ** statement below does actually delete a row, nPhaseOneStep will be
3354 ** incremented by the same amount when SQL function rbu_tmp_insert()
3355 ** is invoked by the trigger. */
3356 if( eType==RBU_DELETE ){
3357 p->nPhaseOneStep -= p->objiter.nIndex;
3358 }
3359
3360 if( eType==RBU_IDX_DELETE || eType==RBU_DELETE ){
3361 pWriter = pIter->pDelete;
3362 }else{
3363 pWriter = pIter->pInsert;
3364 }
3365
3366 for(i=0; i<pIter->nCol; i++){
3367 /* If this is an INSERT into a table b-tree and the table has an
3368 ** explicit INTEGER PRIMARY KEY, check that this is not an attempt
3369 ** to write a NULL into the IPK column. That is not permitted. */
3370 if( eType==RBU_INSERT
3371 && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
3372 && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
3373 ){
3374 p->rc = SQLITE_MISMATCH;
3375 p->zErrmsg = sqlite3_mprintf("datatype mismatch");
3376 return;
3377 }
3378
3379 if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
3380 continue;
3381 }
3382
3383 pVal = sqlite3_column_value(pIter->pSelect, i);
3384 p->rc = sqlite3_bind_value(pWriter, i+1, pVal);
3385 if( p->rc ) return;
3386 }
3387 if( pIter->zIdx==0 ){
3388 if( pIter->eType==RBU_PK_VTAB
3389 || pIter->eType==RBU_PK_NONE
3390 || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
3391 ){
3392 /* For a virtual table, or a table with no primary key, the
3393 ** SELECT statement is:
3394 **
3395 ** SELECT <cols>, rbu_control, rbu_rowid FROM ....
3396 **
3397 ** Hence column_value(pIter->nCol+1).
3398 */
3399 assertColumnName(pIter->pSelect, pIter->nCol+1,
3400 rbuIsVacuum(p) ? "rowid" : "rbu_rowid"
3401 );
3402 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
3403 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
3404 }
3405 }
3406 if( p->rc==SQLITE_OK ){
3407 sqlite3_step(pWriter);
3408 p->rc = resetAndCollectError(pWriter, &p->zErrmsg);
3409 }
3410}
3411
3412/*
3413** This function does the work for an sqlite3rbu_step() call.
3414**
3415** The object-iterator (p->objiter) currently points to a valid object,
3416** and the input cursor (p->objiter.pSelect) currently points to a valid
3417** input row. Perform whatever processing is required and return.
3418**
3419** If no error occurs, SQLITE_OK is returned. Otherwise, an error code
3420** and message is left in the RBU handle and a copy of the error code
3421** returned.
3422*/
3423static int rbuStep(sqlite3rbu *p){
3424 RbuObjIter *pIter = &p->objiter;
3425 const char *zMask = 0;
3426 int eType = rbuStepType(p, &zMask);
3427
3428 if( eType ){
3429 assert( eType==RBU_INSERT || eType==RBU_DELETE
3430 || eType==RBU_REPLACE || eType==RBU_IDX_DELETE
3431 || eType==RBU_IDX_INSERT || eType==RBU_UPDATE
3432 );
3433 assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
3434
3435 if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
3436 rbuBadControlError(p);
3437 }
3438 else if( eType==RBU_REPLACE ){
3439 if( pIter->zIdx==0 ){
3440 p->nPhaseOneStep += p->objiter.nIndex;
3441 rbuStepOneOp(p, RBU_DELETE);
3442 }
3443 if( p->rc==SQLITE_OK ) rbuStepOneOp(p, RBU_INSERT);
3444 }
3445 else if( eType!=RBU_UPDATE ){
3446 rbuStepOneOp(p, eType);
3447 }
3448 else{
3449 sqlite3_value *pVal;
3450 sqlite3_stmt *pUpdate = 0;
3451 assert( eType==RBU_UPDATE );
3452 p->nPhaseOneStep -= p->objiter.nIndex;
3453 rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
3454 if( pUpdate ){
3455 int i;
3456 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
3457 char c = zMask[pIter->aiSrcOrder[i]];
3458 pVal = sqlite3_column_value(pIter->pSelect, i);
3459 if( pIter->abTblPk[i] || c!='.' ){
3460 p->rc = sqlite3_bind_value(pUpdate, i+1, pVal);
3461 }
3462 }
3463 if( p->rc==SQLITE_OK
3464 && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
3465 ){
3466 /* Bind the rbu_rowid value to column _rowid_ */
3467 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
3468 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
3469 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
3470 }
3471 if( p->rc==SQLITE_OK ){
3472 sqlite3_step(pUpdate);
3473 p->rc = resetAndCollectError(pUpdate, &p->zErrmsg);
3474 }
3475 }
3476 }
3477 }
3478 return p->rc;
3479}
3480
3481/*
3482** Increment the schema cookie of the main database opened by p->dbMain.
3483**
3484** Or, if this is an RBU vacuum, set the schema cookie of the main db
3485** opened by p->dbMain to one more than the schema cookie of the main
3486** db opened by p->dbRbu.
3487*/
3488static void rbuIncrSchemaCookie(sqlite3rbu *p){
3489 if( p->rc==SQLITE_OK ){
3490 sqlite3 *dbread = (rbuIsVacuum(p) ? p->dbRbu : p->dbMain);
3491 int iCookie = 1000000;
3492 sqlite3_stmt *pStmt;
3493
3494 p->rc = prepareAndCollectError(dbread, &pStmt, &p->zErrmsg,
3495 "PRAGMA schema_version"
3496 );
3497 if( p->rc==SQLITE_OK ){
3498 /* Coverage: it may be that this sqlite3_step() cannot fail. There
3499 ** is already a transaction open, so the prepared statement cannot
3500 ** throw an SQLITE_SCHEMA exception. The only database page the
3501 ** statement reads is page 1, which is guaranteed to be in the cache.
3502 ** And no memory allocations are required. */
3503 if( SQLITE_ROW==sqlite3_step(pStmt) ){
3504 iCookie = sqlite3_column_int(pStmt, 0);
3505 }
3506 rbuFinalize(p, pStmt);
3507 }
3508 if( p->rc==SQLITE_OK ){
3509 rbuMPrintfExec(p, p->dbMain, "PRAGMA schema_version = %d", iCookie+1);
3510 }
3511 }
3512}
3513
3514/*
3515** Update the contents of the rbu_state table within the rbu database. The
3516** value stored in the RBU_STATE_STAGE column is eStage. All other values
3517** are determined by inspecting the rbu handle passed as the first argument.
3518*/
3519static void rbuSaveState(sqlite3rbu *p, int eStage){
3520 if( p->rc==SQLITE_OK || p->rc==SQLITE_DONE ){
3521 sqlite3_stmt *pInsert = 0;
3522 rbu_file *pFd = (rbuIsVacuum(p) ? p->pRbuFd : p->pTargetFd);
3523 int rc;
3524
3525 assert( p->zErrmsg==0 );
3526 rc = prepareFreeAndCollectError(p->dbRbu, &pInsert, &p->zErrmsg,
3527 sqlite3_mprintf(
3528 "INSERT OR REPLACE INTO %s.rbu_state(k, v) VALUES "
3529 "(%d, %d), "
3530 "(%d, %Q), "
3531 "(%d, %Q), "
3532 "(%d, %d), "
3533 "(%d, %d), "
3534 "(%d, %lld), "
3535 "(%d, %lld), "
3536 "(%d, %lld), "
3537 "(%d, %lld), "
3538 "(%d, %Q) ",
3539 p->zStateDb,
3540 RBU_STATE_STAGE, eStage,
3541 RBU_STATE_TBL, p->objiter.zTbl,
3542 RBU_STATE_IDX, p->objiter.zIdx,
3543 RBU_STATE_ROW, p->nStep,
3544 RBU_STATE_PROGRESS, p->nProgress,
3545 RBU_STATE_CKPT, p->iWalCksum,
3546 RBU_STATE_COOKIE, (i64)pFd->iCookie,
3547 RBU_STATE_OALSZ, p->iOalSz,
3548 RBU_STATE_PHASEONESTEP, p->nPhaseOneStep,
3549 RBU_STATE_DATATBL, p->objiter.zDataTbl
3550 )
3551 );
3552 assert( pInsert==0 || rc==SQLITE_OK );
3553
3554 if( rc==SQLITE_OK ){
3555 sqlite3_step(pInsert);
3556 rc = sqlite3_finalize(pInsert);
3557 }
3558 if( rc!=SQLITE_OK ) p->rc = rc;
3559 }
3560}
3561
3562
3563/*
3564** The second argument passed to this function is the name of a PRAGMA
3565** setting - "page_size", "auto_vacuum", "user_version" or "application_id".
3566** This function executes the following on sqlite3rbu.dbRbu:
3567**
3568** "PRAGMA main.$zPragma"
3569**
3570** where $zPragma is the string passed as the second argument, then
3571** on sqlite3rbu.dbMain:
3572**
3573** "PRAGMA main.$zPragma = $val"
3574**
3575** where $val is the value returned by the first PRAGMA invocation.
3576**
3577** In short, it copies the value of the specified PRAGMA setting from
3578** dbRbu to dbMain.
3579*/
3580static void rbuCopyPragma(sqlite3rbu *p, const char *zPragma){
3581 if( p->rc==SQLITE_OK ){
3582 sqlite3_stmt *pPragma = 0;
3583 p->rc = prepareFreeAndCollectError(p->dbRbu, &pPragma, &p->zErrmsg,
3584 sqlite3_mprintf("PRAGMA main.%s", zPragma)
3585 );
3586 if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPragma) ){
3587 p->rc = rbuMPrintfExec(p, p->dbMain, "PRAGMA main.%s = %d",
3588 zPragma, sqlite3_column_int(pPragma, 0)
3589 );
3590 }
3591 rbuFinalize(p, pPragma);
3592 }
3593}
3594
3595/*
3596** The RBU handle passed as the only argument has just been opened and
3597** the state database is empty. If this RBU handle was opened for an
3598** RBU vacuum operation, create the schema in the target db.
3599*/
3600static void rbuCreateTargetSchema(sqlite3rbu *p){
3601 sqlite3_stmt *pSql = 0;
3602 sqlite3_stmt *pInsert = 0;
3603
3604 assert( rbuIsVacuum(p) );
3605 p->rc = sqlite3_exec(p->dbMain, "PRAGMA writable_schema=1", 0,0, &p->zErrmsg);
3606 if( p->rc==SQLITE_OK ){
3607 p->rc = prepareAndCollectError(p->dbRbu, &pSql, &p->zErrmsg,
3608 "SELECT sql FROM sqlite_schema WHERE sql!='' AND rootpage!=0"
3609 " AND name!='sqlite_sequence' "
3610 " ORDER BY type DESC"
3611 );
3612 }
3613
3614 while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
3615 const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
3616 p->rc = sqlite3_exec(p->dbMain, zSql, 0, 0, &p->zErrmsg);
3617 }
3618 rbuFinalize(p, pSql);
3619 if( p->rc!=SQLITE_OK ) return;
3620
3621 if( p->rc==SQLITE_OK ){
3622 p->rc = prepareAndCollectError(p->dbRbu, &pSql, &p->zErrmsg,
3623 "SELECT * FROM sqlite_schema WHERE rootpage=0 OR rootpage IS NULL"
3624 );
3625 }
3626
3627 if( p->rc==SQLITE_OK ){
3628 p->rc = prepareAndCollectError(p->dbMain, &pInsert, &p->zErrmsg,
3629 "INSERT INTO sqlite_schema VALUES(?,?,?,?,?)"
3630 );
3631 }
3632
3633 while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
3634 int i;
3635 for(i=0; i<5; i++){
3636 sqlite3_bind_value(pInsert, i+1, sqlite3_column_value(pSql, i));
3637 }
3638 sqlite3_step(pInsert);
3639 p->rc = sqlite3_reset(pInsert);
3640 }
3641 if( p->rc==SQLITE_OK ){
3642 p->rc = sqlite3_exec(p->dbMain, "PRAGMA writable_schema=0",0,0,&p->zErrmsg);
3643 }
3644
3645 rbuFinalize(p, pSql);
3646 rbuFinalize(p, pInsert);
3647}
3648
3649/*
3650** Step the RBU object.
3651*/
3652int sqlite3rbu_step(sqlite3rbu *p){
3653 if( p ){
3654 switch( p->eStage ){
3655 case RBU_STAGE_OAL: {
3656 RbuObjIter *pIter = &p->objiter;
3657
3658 /* If this is an RBU vacuum operation and the state table was empty
3659 ** when this handle was opened, create the target database schema. */
3660 if( rbuIsVacuum(p) && p->nProgress==0 && p->rc==SQLITE_OK ){
3661 rbuCreateTargetSchema(p);
3662 rbuCopyPragma(p, "user_version");
3663 rbuCopyPragma(p, "application_id");
3664 }
3665
3666 while( p->rc==SQLITE_OK && pIter->zTbl ){
3667
3668 if( pIter->bCleanup ){
3669 /* Clean up the rbu_tmp_xxx table for the previous table. It
3670 ** cannot be dropped as there are currently active SQL statements.
3671 ** But the contents can be deleted. */
3672 if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
3673 rbuMPrintfExec(p, p->dbRbu,
3674 "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
3675 );
3676 }
3677 }else{
3678 rbuObjIterPrepareAll(p, pIter, 0);
3679
3680 /* Advance to the next row to process. */
3681 if( p->rc==SQLITE_OK ){
3682 int rc = sqlite3_step(pIter->pSelect);
3683 if( rc==SQLITE_ROW ){
3684 p->nProgress++;
3685 p->nStep++;
3686 return rbuStep(p);
3687 }
3688 p->rc = sqlite3_reset(pIter->pSelect);
3689 p->nStep = 0;
3690 }
3691 }
3692
3693 rbuObjIterNext(p, pIter);
3694 }
3695
3696 if( p->rc==SQLITE_OK ){
3697 assert( pIter->zTbl==0 );
3698 rbuSaveState(p, RBU_STAGE_MOVE);
3699 rbuIncrSchemaCookie(p);
3700 if( p->rc==SQLITE_OK ){
3701 p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
3702 }
3703 if( p->rc==SQLITE_OK ){
3704 p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
3705 }
3706 p->eStage = RBU_STAGE_MOVE;
3707 }
3708 break;
3709 }
3710
3711 case RBU_STAGE_MOVE: {
3712 if( p->rc==SQLITE_OK ){
3713 rbuMoveOalFile(p);
3714 p->nProgress++;
3715 }
3716 break;
3717 }
3718
3719 case RBU_STAGE_CKPT: {
3720 if( p->rc==SQLITE_OK ){
3721 if( p->nStep>=p->nFrame ){
3722 sqlite3_file *pDb = p->pTargetFd->pReal;
3723
3724 /* Sync the db file */
3725 p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
3726
3727 /* Update nBackfill */
3728 if( p->rc==SQLITE_OK ){
3729 void volatile *ptr;
3730 p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, &ptr);
3731 if( p->rc==SQLITE_OK ){
3732 ((u32 volatile*)ptr)[24] = p->iMaxFrame;
3733 }
3734 }
3735
3736 if( p->rc==SQLITE_OK ){
3737 p->eStage = RBU_STAGE_DONE;
3738 p->rc = SQLITE_DONE;
3739 }
3740 }else{
3741 /* At one point the following block copied a single frame from the
3742 ** wal file to the database file. So that one call to sqlite3rbu_step()
3743 ** checkpointed a single frame.
3744 **
3745 ** However, if the sector-size is larger than the page-size, and the
3746 ** application calls sqlite3rbu_savestate() or close() immediately
3747 ** after this step, then rbu_step() again, then a power failure occurs,
3748 ** then the database page written here may be damaged. Work around
3749 ** this by checkpointing frames until the next page in the aFrame[]
3750 ** lies on a different disk sector to the current one. */
3751 u32 iSector;
3752 do{
3753 RbuFrame *pFrame = &p->aFrame[p->nStep];
3754 iSector = (pFrame->iDbPage-1) / p->nPagePerSector;
3755 rbuCheckpointFrame(p, pFrame);
3756 p->nStep++;
3757 }while( p->nStep<p->nFrame
3758 && iSector==((p->aFrame[p->nStep].iDbPage-1) / p->nPagePerSector)
3759 && p->rc==SQLITE_OK
3760 );
3761 }
3762 p->nProgress++;
3763 }
3764 break;
3765 }
3766
3767 default:
3768 break;
3769 }
3770 return p->rc;
3771 }else{
3772 return SQLITE_NOMEM;
3773 }
3774}
3775
3776/*
3777** Compare strings z1 and z2, returning 0 if they are identical, or non-zero
3778** otherwise. Either or both argument may be NULL. Two NULL values are
3779** considered equal, and NULL is considered distinct from all other values.
3780*/
3781static int rbuStrCompare(const char *z1, const char *z2){
3782 if( z1==0 && z2==0 ) return 0;
3783 if( z1==0 || z2==0 ) return 1;
3784 return (sqlite3_stricmp(z1, z2)!=0);
3785}
3786
3787/*
3788** This function is called as part of sqlite3rbu_open() when initializing
3789** an rbu handle in OAL stage. If the rbu update has not started (i.e.
3790** the rbu_state table was empty) it is a no-op. Otherwise, it arranges
3791** things so that the next call to sqlite3rbu_step() continues on from
3792** where the previous rbu handle left off.
3793**
3794** If an error occurs, an error code and error message are left in the
3795** rbu handle passed as the first argument.
3796*/
3797static void rbuSetupOal(sqlite3rbu *p, RbuState *pState){
3798 assert( p->rc==SQLITE_OK );
3799 if( pState->zTbl ){
3800 RbuObjIter *pIter = &p->objiter;
3801 int rc = SQLITE_OK;
3802
3803 while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
3804 || rbuStrCompare(pIter->zIdx, pState->zIdx)
3805 || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
3806 || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
3807 )){
3808 rc = rbuObjIterNext(p, pIter);
3809 }
3810
3811 if( rc==SQLITE_OK && !pIter->zTbl ){
3812 rc = SQLITE_ERROR;
3813 p->zErrmsg = sqlite3_mprintf("rbu_state mismatch error");
3814 }
3815
3816 if( rc==SQLITE_OK ){
3817 p->nStep = pState->nRow;
3818 rc = rbuObjIterPrepareAll(p, &p->objiter, p->nStep);
3819 }
3820
3821 p->rc = rc;
3822 }
3823}
3824
3825/*
3826** If there is a "*-oal" file in the file-system corresponding to the
3827** target database in the file-system, delete it. If an error occurs,
3828** leave an error code and error message in the rbu handle.
3829*/
3830static void rbuDeleteOalFile(sqlite3rbu *p){
3831 char *zOal = rbuMPrintf(p, "%s-oal", p->zTarget);
3832 if( zOal ){
3833 sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
3834 assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
3835 pVfs->xDelete(pVfs, zOal, 0);
3836 sqlite3_free(zOal);
3837 }
3838}
3839
3840/*
3841** Allocate a private rbu VFS for the rbu handle passed as the only
3842** argument. This VFS will be used unless the call to sqlite3rbu_open()
3843** specified a URI with a vfs=? option in place of a target database
3844** file name.
3845*/
3846static void rbuCreateVfs(sqlite3rbu *p){
3847 int rnd;
3848 char zRnd[64];
3849
3850 assert( p->rc==SQLITE_OK );
3851 sqlite3_randomness(sizeof(int), (void*)&rnd);
3852 sqlite3_snprintf(sizeof(zRnd), zRnd, "rbu_vfs_%d", rnd);
3853 p->rc = sqlite3rbu_create_vfs(zRnd, 0);
3854 if( p->rc==SQLITE_OK ){
3855 sqlite3_vfs *pVfs = sqlite3_vfs_find(zRnd);
3856 assert( pVfs );
3857 p->zVfsName = pVfs->zName;
3858 ((rbu_vfs*)pVfs)->pRbu = p;
3859 }
3860}
3861
3862/*
3863** Destroy the private VFS created for the rbu handle passed as the only
3864** argument by an earlier call to rbuCreateVfs().
3865*/
3866static void rbuDeleteVfs(sqlite3rbu *p){
3867 if( p->zVfsName ){
3868 sqlite3rbu_destroy_vfs(p->zVfsName);
3869 p->zVfsName = 0;
3870 }
3871}
3872
3873/*
3874** This user-defined SQL function is invoked with a single argument - the
3875** name of a table expected to appear in the target database. It returns
3876** the number of auxilliary indexes on the table.
3877*/
3878static void rbuIndexCntFunc(
3879 sqlite3_context *pCtx,
3880 int nVal,
3881 sqlite3_value **apVal
3882){
3883 sqlite3rbu *p = (sqlite3rbu*)sqlite3_user_data(pCtx);
3884 sqlite3_stmt *pStmt = 0;
3885 char *zErrmsg = 0;
3886 int rc;
3887 sqlite3 *db = (rbuIsVacuum(p) ? p->dbRbu : p->dbMain);
3888
3889 assert( nVal==1 );
3890
3891 rc = prepareFreeAndCollectError(db, &pStmt, &zErrmsg,
3892 sqlite3_mprintf("SELECT count(*) FROM sqlite_schema "
3893 "WHERE type='index' AND tbl_name = %Q", sqlite3_value_text(apVal[0]))
3894 );
3895 if( rc!=SQLITE_OK ){
3896 sqlite3_result_error(pCtx, zErrmsg, -1);
3897 }else{
3898 int nIndex = 0;
3899 if( SQLITE_ROW==sqlite3_step(pStmt) ){
3900 nIndex = sqlite3_column_int(pStmt, 0);
3901 }
3902 rc = sqlite3_finalize(pStmt);
3903 if( rc==SQLITE_OK ){
3904 sqlite3_result_int(pCtx, nIndex);
3905 }else{
3906 sqlite3_result_error(pCtx, sqlite3_errmsg(db), -1);
3907 }
3908 }
3909
3910 sqlite3_free(zErrmsg);
3911}
3912
3913/*
3914** If the RBU database contains the rbu_count table, use it to initialize
3915** the sqlite3rbu.nPhaseOneStep variable. The schema of the rbu_count table
3916** is assumed to contain the same columns as:
3917**
3918** CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
3919**
3920** There should be one row in the table for each data_xxx table in the
3921** database. The 'tbl' column should contain the name of a data_xxx table,
3922** and the cnt column the number of rows it contains.
3923**
3924** sqlite3rbu.nPhaseOneStep is initialized to the sum of (1 + nIndex) * cnt
3925** for all rows in the rbu_count table, where nIndex is the number of
3926** indexes on the corresponding target database table.
3927*/
3928static void rbuInitPhaseOneSteps(sqlite3rbu *p){
3929 if( p->rc==SQLITE_OK ){
3930 sqlite3_stmt *pStmt = 0;
3931 int bExists = 0; /* True if rbu_count exists */
3932
3933 p->nPhaseOneStep = -1;
3934
3935 p->rc = sqlite3_create_function(p->dbRbu,
3936 "rbu_index_cnt", 1, SQLITE_UTF8, (void*)p, rbuIndexCntFunc, 0, 0
3937 );
3938
3939 /* Check for the rbu_count table. If it does not exist, or if an error
3940 ** occurs, nPhaseOneStep will be left set to -1. */
3941 if( p->rc==SQLITE_OK ){
3942 p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
3943 "SELECT 1 FROM sqlite_schema WHERE tbl_name = 'rbu_count'"
3944 );
3945 }
3946 if( p->rc==SQLITE_OK ){
3947 if( SQLITE_ROW==sqlite3_step(pStmt) ){
3948 bExists = 1;
3949 }
3950 p->rc = sqlite3_finalize(pStmt);
3951 }
3952
3953 if( p->rc==SQLITE_OK && bExists ){
3954 p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
3955 "SELECT sum(cnt * (1 + rbu_index_cnt(rbu_target_name(tbl))))"
3956 "FROM rbu_count"
3957 );
3958 if( p->rc==SQLITE_OK ){
3959 if( SQLITE_ROW==sqlite3_step(pStmt) ){
3960 p->nPhaseOneStep = sqlite3_column_int64(pStmt, 0);
3961 }
3962 p->rc = sqlite3_finalize(pStmt);
3963 }
3964 }
3965 }
3966}
3967
3968
3969static sqlite3rbu *openRbuHandle(
3970 const char *zTarget,
3971 const char *zRbu,
3972 const char *zState
3973){
3974 sqlite3rbu *p;
3975 size_t nTarget = zTarget ? strlen(zTarget) : 0;
3976 size_t nRbu = strlen(zRbu);
3977 size_t nByte = sizeof(sqlite3rbu) + nTarget+1 + nRbu+1;
3978
3979 p = (sqlite3rbu*)sqlite3_malloc64(nByte);
3980 if( p ){
3981 RbuState *pState = 0;
3982
3983 /* Create the custom VFS. */
3984 memset(p, 0, sizeof(sqlite3rbu));
3985 sqlite3rbu_rename_handler(p, 0, 0);
3986 rbuCreateVfs(p);
3987
3988 /* Open the target, RBU and state databases */
3989 if( p->rc==SQLITE_OK ){
3990 char *pCsr = (char*)&p[1];
3991 int bRetry = 0;
3992 if( zTarget ){
3993 p->zTarget = pCsr;
3994 memcpy(p->zTarget, zTarget, nTarget+1);
3995 pCsr += nTarget+1;
3996 }
3997 p->zRbu = pCsr;
3998 memcpy(p->zRbu, zRbu, nRbu+1);
3999 pCsr += nRbu+1;
4000 if( zState ){
4001 p->zState = rbuMPrintf(p, "%s", zState);
4002 }
4003
4004 /* If the first attempt to open the database file fails and the bRetry
4005 ** flag it set, this means that the db was not opened because it seemed
4006 ** to be a wal-mode db. But, this may have happened due to an earlier
4007 ** RBU vacuum operation leaving an old wal file in the directory.
4008 ** If this is the case, it will have been checkpointed and deleted
4009 ** when the handle was closed and a second attempt to open the
4010 ** database may succeed. */
4011 rbuOpenDatabase(p, 0, &bRetry);
4012 if( bRetry ){
4013 rbuOpenDatabase(p, 0, 0);
4014 }
4015 }
4016
4017 if( p->rc==SQLITE_OK ){
4018 pState = rbuLoadState(p);
4019 assert( pState || p->rc!=SQLITE_OK );
4020 if( p->rc==SQLITE_OK ){
4021
4022 if( pState->eStage==0 ){
4023 rbuDeleteOalFile(p);
4024 rbuInitPhaseOneSteps(p);
4025 p->eStage = RBU_STAGE_OAL;
4026 }else{
4027 p->eStage = pState->eStage;
4028 p->nPhaseOneStep = pState->nPhaseOneStep;
4029 }
4030 p->nProgress = pState->nProgress;
4031 p->iOalSz = pState->iOalSz;
4032 }
4033 }
4034 assert( p->rc!=SQLITE_OK || p->eStage!=0 );
4035
4036 if( p->rc==SQLITE_OK && p->pTargetFd->pWalFd ){
4037 if( p->eStage==RBU_STAGE_OAL ){
4038 p->rc = SQLITE_ERROR;
4039 p->zErrmsg = sqlite3_mprintf("cannot update wal mode database");
4040 }else if( p->eStage==RBU_STAGE_MOVE ){
4041 p->eStage = RBU_STAGE_CKPT;
4042 p->nStep = 0;
4043 }
4044 }
4045
4046 if( p->rc==SQLITE_OK
4047 && (p->eStage==RBU_STAGE_OAL || p->eStage==RBU_STAGE_MOVE)
4048 && pState->eStage!=0
4049 ){
4050 rbu_file *pFd = (rbuIsVacuum(p) ? p->pRbuFd : p->pTargetFd);
4051 if( pFd->iCookie!=pState->iCookie ){
4052 /* At this point (pTargetFd->iCookie) contains the value of the
4053 ** change-counter cookie (the thing that gets incremented when a
4054 ** transaction is committed in rollback mode) currently stored on
4055 ** page 1 of the database file. */
4056 p->rc = SQLITE_BUSY;
4057 p->zErrmsg = sqlite3_mprintf("database modified during rbu %s",
4058 (rbuIsVacuum(p) ? "vacuum" : "update")
4059 );
4060 }
4061 }
4062
4063 if( p->rc==SQLITE_OK ){
4064 if( p->eStage==RBU_STAGE_OAL ){
4065 sqlite3 *db = p->dbMain;
4066 p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, &p->zErrmsg);
4067
4068 /* Point the object iterator at the first object */
4069 if( p->rc==SQLITE_OK ){
4070 p->rc = rbuObjIterFirst(p, &p->objiter);
4071 }
4072
4073 /* If the RBU database contains no data_xxx tables, declare the RBU
4074 ** update finished. */
4075 if( p->rc==SQLITE_OK && p->objiter.zTbl==0 ){
4076 p->rc = SQLITE_DONE;
4077 p->eStage = RBU_STAGE_DONE;
4078 }else{
4079 if( p->rc==SQLITE_OK && pState->eStage==0 && rbuIsVacuum(p) ){
4080 rbuCopyPragma(p, "page_size");
4081 rbuCopyPragma(p, "auto_vacuum");
4082 }
4083
4084 /* Open transactions both databases. The *-oal file is opened or
4085 ** created at this point. */
4086 if( p->rc==SQLITE_OK ){
4087 p->rc = sqlite3_exec(db, "BEGIN IMMEDIATE", 0, 0, &p->zErrmsg);
4088 }
4089
4090 /* Check if the main database is a zipvfs db. If it is, set the upper
4091 ** level pager to use "journal_mode=off". This prevents it from
4092 ** generating a large journal using a temp file. */
4093 if( p->rc==SQLITE_OK ){
4094 int frc = sqlite3_file_control(db, "main", SQLITE_FCNTL_ZIPVFS, 0);
4095 if( frc==SQLITE_OK ){
4096 p->rc = sqlite3_exec(
4097 db, "PRAGMA journal_mode=off",0,0,&p->zErrmsg);
4098 }
4099 }
4100
4101 if( p->rc==SQLITE_OK ){
4102 rbuSetupOal(p, pState);
4103 }
4104 }
4105 }else if( p->eStage==RBU_STAGE_MOVE ){
4106 /* no-op */
4107 }else if( p->eStage==RBU_STAGE_CKPT ){
4108 if( !rbuIsVacuum(p) && rbuExclusiveCheckpoint(p->dbMain) ){
4109 /* If the rbu_exclusive_checkpoint=1 URI parameter was specified
4110 ** and an incremental checkpoint is being resumed, attempt an
4111 ** exclusive lock on the db file. If this fails, so be it. */
4112 p->eStage = RBU_STAGE_DONE;
4113 rbuLockDatabase(p->dbMain);
4114 p->eStage = RBU_STAGE_CKPT;
4115 }
4116 rbuSetupCheckpoint(p, pState);
4117 }else if( p->eStage==RBU_STAGE_DONE ){
4118 p->rc = SQLITE_DONE;
4119 }else{
4120 p->rc = SQLITE_CORRUPT;
4121 }
4122 }
4123
4124 rbuFreeState(pState);
4125 }
4126
4127 return p;
4128}
4129
4130/*
4131** Allocate and return an RBU handle with all fields zeroed except for the
4132** error code, which is set to SQLITE_MISUSE.
4133*/
4134static sqlite3rbu *rbuMisuseError(void){
4135 sqlite3rbu *pRet;
4136 pRet = sqlite3_malloc64(sizeof(sqlite3rbu));
4137 if( pRet ){
4138 memset(pRet, 0, sizeof(sqlite3rbu));
4139 pRet->rc = SQLITE_MISUSE;
4140 }
4141 return pRet;
4142}
4143
4144/*
4145** Open and return a new RBU handle.
4146*/
4147sqlite3rbu *sqlite3rbu_open(
4148 const char *zTarget,
4149 const char *zRbu,
4150 const char *zState
4151){
4152 if( zTarget==0 || zRbu==0 ){ return rbuMisuseError(); }
4153 return openRbuHandle(zTarget, zRbu, zState);
4154}
4155
4156/*
4157** Open a handle to begin or resume an RBU VACUUM operation.
4158*/
4159sqlite3rbu *sqlite3rbu_vacuum(
4160 const char *zTarget,
4161 const char *zState
4162){
4163 if( zTarget==0 ){ return rbuMisuseError(); }
4164 if( zState ){
4165 int n = strlen(zState);
4166 if( n>=7 && 0==memcmp("-vactmp", &zState[n-7], 7) ){
4167 return rbuMisuseError();
4168 }
4169 }
4170 /* TODO: Check that both arguments are non-NULL */
4171 return openRbuHandle(0, zTarget, zState);
4172}
4173
4174/*
4175** Return the database handle used by pRbu.
4176*/
4177sqlite3 *sqlite3rbu_db(sqlite3rbu *pRbu, int bRbu){
4178 sqlite3 *db = 0;
4179 if( pRbu ){
4180 db = (bRbu ? pRbu->dbRbu : pRbu->dbMain);
4181 }
4182 return db;
4183}
4184
4185
4186/*
4187** If the error code currently stored in the RBU handle is SQLITE_CONSTRAINT,
4188** then edit any error message string so as to remove all occurrences of
4189** the pattern "rbu_imp_[0-9]*".
4190*/
4191static void rbuEditErrmsg(sqlite3rbu *p){
4192 if( p->rc==SQLITE_CONSTRAINT && p->zErrmsg ){
4193 unsigned int i;
4194 size_t nErrmsg = strlen(p->zErrmsg);
4195 for(i=0; i<(nErrmsg-8); i++){
4196 if( memcmp(&p->zErrmsg[i], "rbu_imp_", 8)==0 ){
4197 int nDel = 8;
4198 while( p->zErrmsg[i+nDel]>='0' && p->zErrmsg[i+nDel]<='9' ) nDel++;
4199 memmove(&p->zErrmsg[i], &p->zErrmsg[i+nDel], nErrmsg + 1 - i - nDel);
4200 nErrmsg -= nDel;
4201 }
4202 }
4203 }
4204}
4205
4206/*
4207** Close the RBU handle.
4208*/
4209int sqlite3rbu_close(sqlite3rbu *p, char **pzErrmsg){
4210 int rc;
4211 if( p ){
4212
4213 /* Commit the transaction to the *-oal file. */
4214 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
4215 p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
4216 }
4217
4218 /* Sync the db file if currently doing an incremental checkpoint */
4219 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
4220 sqlite3_file *pDb = p->pTargetFd->pReal;
4221 p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
4222 }
4223
4224 rbuSaveState(p, p->eStage);
4225
4226 if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
4227 p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
4228 }
4229
4230 /* Close any open statement handles. */
4231 rbuObjIterFinalize(&p->objiter);
4232
4233 /* If this is an RBU vacuum handle and the vacuum has either finished
4234 ** successfully or encountered an error, delete the contents of the
4235 ** state table. This causes the next call to sqlite3rbu_vacuum()
4236 ** specifying the current target and state databases to start a new
4237 ** vacuum from scratch. */
4238 if( rbuIsVacuum(p) && p->rc!=SQLITE_OK && p->dbRbu ){
4239 int rc2 = sqlite3_exec(p->dbRbu, "DELETE FROM stat.rbu_state", 0, 0, 0);
4240 if( p->rc==SQLITE_DONE && rc2!=SQLITE_OK ) p->rc = rc2;
4241 }
4242
4243 /* Close the open database handle and VFS object. */
4244 sqlite3_close(p->dbRbu);
4245 sqlite3_close(p->dbMain);
4246 assert( p->szTemp==0 );
4247 rbuDeleteVfs(p);
4248 sqlite3_free(p->aBuf);
4249 sqlite3_free(p->aFrame);
4250
4251 rbuEditErrmsg(p);
4252 rc = p->rc;
4253 if( pzErrmsg ){
4254 *pzErrmsg = p->zErrmsg;
4255 }else{
4256 sqlite3_free(p->zErrmsg);
4257 }
4258 sqlite3_free(p->zState);
4259 sqlite3_free(p);
4260 }else{
4261 rc = SQLITE_NOMEM;
4262 *pzErrmsg = 0;
4263 }
4264 return rc;
4265}
4266
4267/*
4268** Return the total number of key-value operations (inserts, deletes or
4269** updates) that have been performed on the target database since the
4270** current RBU update was started.
4271*/
4272sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu){
4273 return pRbu->nProgress;
4274}
4275
4276/*
4277** Return permyriadage progress indications for the two main stages of
4278** an RBU update.
4279*/
4280void sqlite3rbu_bp_progress(sqlite3rbu *p, int *pnOne, int *pnTwo){
4281 const int MAX_PROGRESS = 10000;
4282 switch( p->eStage ){
4283 case RBU_STAGE_OAL:
4284 if( p->nPhaseOneStep>0 ){
4285 *pnOne = (int)(MAX_PROGRESS * (i64)p->nProgress/(i64)p->nPhaseOneStep);
4286 }else{
4287 *pnOne = -1;
4288 }
4289 *pnTwo = 0;
4290 break;
4291
4292 case RBU_STAGE_MOVE:
4293 *pnOne = MAX_PROGRESS;
4294 *pnTwo = 0;
4295 break;
4296
4297 case RBU_STAGE_CKPT:
4298 *pnOne = MAX_PROGRESS;
4299 *pnTwo = (int)(MAX_PROGRESS * (i64)p->nStep / (i64)p->nFrame);
4300 break;
4301
4302 case RBU_STAGE_DONE:
4303 *pnOne = MAX_PROGRESS;
4304 *pnTwo = MAX_PROGRESS;
4305 break;
4306
4307 default:
4308 assert( 0 );
4309 }
4310}
4311
4312/*
4313** Return the current state of the RBU vacuum or update operation.
4314*/
4315int sqlite3rbu_state(sqlite3rbu *p){
4316 int aRes[] = {
4317 0, SQLITE_RBU_STATE_OAL, SQLITE_RBU_STATE_MOVE,
4318 0, SQLITE_RBU_STATE_CHECKPOINT, SQLITE_RBU_STATE_DONE
4319 };
4320
4321 assert( RBU_STAGE_OAL==1 );
4322 assert( RBU_STAGE_MOVE==2 );
4323 assert( RBU_STAGE_CKPT==4 );
4324 assert( RBU_STAGE_DONE==5 );
4325 assert( aRes[RBU_STAGE_OAL]==SQLITE_RBU_STATE_OAL );
4326 assert( aRes[RBU_STAGE_MOVE]==SQLITE_RBU_STATE_MOVE );
4327 assert( aRes[RBU_STAGE_CKPT]==SQLITE_RBU_STATE_CHECKPOINT );
4328 assert( aRes[RBU_STAGE_DONE]==SQLITE_RBU_STATE_DONE );
4329
4330 if( p->rc!=SQLITE_OK && p->rc!=SQLITE_DONE ){
4331 return SQLITE_RBU_STATE_ERROR;
4332 }else{
4333 assert( p->rc!=SQLITE_DONE || p->eStage==RBU_STAGE_DONE );
4334 assert( p->eStage==RBU_STAGE_OAL
4335 || p->eStage==RBU_STAGE_MOVE
4336 || p->eStage==RBU_STAGE_CKPT
4337 || p->eStage==RBU_STAGE_DONE
4338 );
4339 return aRes[p->eStage];
4340 }
4341}
4342
4343int sqlite3rbu_savestate(sqlite3rbu *p){
4344 int rc = p->rc;
4345 if( rc==SQLITE_DONE ) return SQLITE_OK;
4346
4347 assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
4348 if( p->eStage==RBU_STAGE_OAL ){
4349 assert( rc!=SQLITE_DONE );
4350 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
4351 }
4352
4353 /* Sync the db file */
4354 if( rc==SQLITE_OK && p->eStage==RBU_STAGE_CKPT ){
4355 sqlite3_file *pDb = p->pTargetFd->pReal;
4356 rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
4357 }
4358
4359 p->rc = rc;
4360 rbuSaveState(p, p->eStage);
4361 rc = p->rc;
4362
4363 if( p->eStage==RBU_STAGE_OAL ){
4364 assert( rc!=SQLITE_DONE );
4365 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
4366 if( rc==SQLITE_OK ){
4367 const char *zBegin = rbuIsVacuum(p) ? "BEGIN" : "BEGIN IMMEDIATE";
4368 rc = sqlite3_exec(p->dbRbu, zBegin, 0, 0, 0);
4369 }
4370 if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0,0);
4371 }
4372
4373 p->rc = rc;
4374 return rc;
4375}
4376
4377/*
4378** Default xRename callback for RBU.
4379*/
4380static int xDefaultRename(void *pArg, const char *zOld, const char *zNew){
4381 int rc = SQLITE_OK;
4382#if defined(_WIN32_WCE)
4383 {
4384 LPWSTR zWideOld;
4385 LPWSTR zWideNew;
4386
4387 zWideOld = rbuWinUtf8ToUnicode(zOld);
4388 if( zWideOld ){
4389 zWideNew = rbuWinUtf8ToUnicode(zNew);
4390 if( zWideNew ){
4391 if( MoveFileW(zWideOld, zWideNew) ){
4392 rc = SQLITE_OK;
4393 }else{
4394 rc = SQLITE_IOERR;
4395 }
4396 sqlite3_free(zWideNew);
4397 }else{
4398 rc = SQLITE_IOERR_NOMEM;
4399 }
4400 sqlite3_free(zWideOld);
4401 }else{
4402 rc = SQLITE_IOERR_NOMEM;
4403 }
4404 }
4405#else
4406 rc = rename(zOld, zNew) ? SQLITE_IOERR : SQLITE_OK;
4407#endif
4408 return rc;
4409}
4410
4411void sqlite3rbu_rename_handler(
4412 sqlite3rbu *pRbu,
4413 void *pArg,
4414 int (*xRename)(void *pArg, const char *zOld, const char *zNew)
4415){
4416 if( xRename ){
4417 pRbu->xRename = xRename;
4418 pRbu->pRenameArg = pArg;
4419 }else{
4420 pRbu->xRename = xDefaultRename;
4421 pRbu->pRenameArg = 0;
4422 }
4423}
4424
4425/**************************************************************************
4426** Beginning of RBU VFS shim methods. The VFS shim modifies the behaviour
4427** of a standard VFS in the following ways:
4428**
4429** 1. Whenever the first page of a main database file is read or
4430** written, the value of the change-counter cookie is stored in
4431** rbu_file.iCookie. Similarly, the value of the "write-version"
4432** database header field is stored in rbu_file.iWriteVer. This ensures
4433** that the values are always trustworthy within an open transaction.
4434**
4435** 2. Whenever an SQLITE_OPEN_WAL file is opened, the (rbu_file.pWalFd)
4436** member variable of the associated database file descriptor is set
4437** to point to the new file. A mutex protected linked list of all main
4438** db fds opened using a particular RBU VFS is maintained at
4439** rbu_vfs.pMain to facilitate this.
4440**
4441** 3. Using a new file-control "SQLITE_FCNTL_RBU", a main db rbu_file
4442** object can be marked as the target database of an RBU update. This
4443** turns on the following extra special behaviour:
4444**
4445** 3a. If xAccess() is called to check if there exists a *-wal file
4446** associated with an RBU target database currently in RBU_STAGE_OAL
4447** stage (preparing the *-oal file), the following special handling
4448** applies:
4449**
4450** * if the *-wal file does exist, return SQLITE_CANTOPEN. An RBU
4451** target database may not be in wal mode already.
4452**
4453** * if the *-wal file does not exist, set the output parameter to
4454** non-zero (to tell SQLite that it does exist) anyway.
4455**
4456** Then, when xOpen() is called to open the *-wal file associated with
4457** the RBU target in RBU_STAGE_OAL stage, instead of opening the *-wal
4458** file, the rbu vfs opens the corresponding *-oal file instead.
4459**
4460** 3b. The *-shm pages returned by xShmMap() for a target db file in
4461** RBU_STAGE_OAL mode are actually stored in heap memory. This is to
4462** avoid creating a *-shm file on disk. Additionally, xShmLock() calls
4463** are no-ops on target database files in RBU_STAGE_OAL mode. This is
4464** because assert() statements in some VFS implementations fail if
4465** xShmLock() is called before xShmMap().
4466**
4467** 3c. If an EXCLUSIVE lock is attempted on a target database file in any
4468** mode except RBU_STAGE_DONE (all work completed and checkpointed), it
4469** fails with an SQLITE_BUSY error. This is to stop RBU connections
4470** from automatically checkpointing a *-wal (or *-oal) file from within
4471** sqlite3_close().
4472**
4473** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
4474** all xWrite() calls on the target database file perform no IO.
4475** Instead the frame and page numbers that would be read and written
4476** are recorded. Additionally, successful attempts to obtain exclusive
4477** xShmLock() WRITER, CHECKPOINTER and READ0 locks on the target
4478** database file are recorded. xShmLock() calls to unlock the same
4479** locks are no-ops (so that once obtained, these locks are never
4480** relinquished). Finally, calls to xSync() on the target database
4481** file fail with SQLITE_INTERNAL errors.
4482*/
4483
4484static void rbuUnlockShm(rbu_file *p){
4485 assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
4486 if( p->pRbu ){
4487 int (*xShmLock)(sqlite3_file*,int,int,int) = p->pReal->pMethods->xShmLock;
4488 int i;
4489 for(i=0; i<SQLITE_SHM_NLOCK;i++){
4490 if( (1<<i) & p->pRbu->mLock ){
4491 xShmLock(p->pReal, i, 1, SQLITE_SHM_UNLOCK|SQLITE_SHM_EXCLUSIVE);
4492 }
4493 }
4494 p->pRbu->mLock = 0;
4495 }
4496}
4497
4498/*
4499*/
4500static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
4501 sqlite3rbu *pRbu = pFd->pRbu;
4502 i64 nDiff = nNew - pFd->sz;
4503 pRbu->szTemp += nDiff;
4504 pFd->sz = nNew;
4505 assert( pRbu->szTemp>=0 );
4506 if( pRbu->szTempLimit && pRbu->szTemp>pRbu->szTempLimit ) return SQLITE_FULL;
4507 return SQLITE_OK;
4508}
4509
4510/*
4511** Add an item to the main-db lists, if it is not already present.
4512**
4513** There are two main-db lists. One for all file descriptors, and one
4514** for all file descriptors with rbu_file.pDb!=0. If the argument has
4515** rbu_file.pDb!=0, then it is assumed to already be present on the
4516** main list and is only added to the pDb!=0 list.
4517*/
4518static void rbuMainlistAdd(rbu_file *p){
4519 rbu_vfs *pRbuVfs = p->pRbuVfs;
4520 rbu_file *pIter;
4521 assert( (p->openFlags & SQLITE_OPEN_MAIN_DB) );
4522 sqlite3_mutex_enter(pRbuVfs->mutex);
4523 if( p->pRbu==0 ){
4524 for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
4525 p->pMainNext = pRbuVfs->pMain;
4526 pRbuVfs->pMain = p;
4527 }else{
4528 for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
4529 if( pIter==0 ){
4530 p->pMainRbuNext = pRbuVfs->pMainRbu;
4531 pRbuVfs->pMainRbu = p;
4532 }
4533 }
4534 sqlite3_mutex_leave(pRbuVfs->mutex);
4535}
4536
4537/*
4538** Remove an item from the main-db lists.
4539*/
4540static void rbuMainlistRemove(rbu_file *p){
4541 rbu_file **pp;
4542 sqlite3_mutex_enter(p->pRbuVfs->mutex);
4543 for(pp=&p->pRbuVfs->pMain; *pp && *pp!=p; pp=&((*pp)->pMainNext)){}
4544 if( *pp ) *pp = p->pMainNext;
4545 p->pMainNext = 0;
4546 for(pp=&p->pRbuVfs->pMainRbu; *pp && *pp!=p; pp=&((*pp)->pMainRbuNext)){}
4547 if( *pp ) *pp = p->pMainRbuNext;
4548 p->pMainRbuNext = 0;
4549 sqlite3_mutex_leave(p->pRbuVfs->mutex);
4550}
4551
4552/*
4553** Given that zWal points to a buffer containing a wal file name passed to
4554** either the xOpen() or xAccess() VFS method, search the main-db list for
4555** a file-handle opened by the same database connection on the corresponding
4556** database file.
4557**
4558** If parameter bRbu is true, only search for file-descriptors with
4559** rbu_file.pDb!=0.
4560*/
4561static rbu_file *rbuFindMaindb(rbu_vfs *pRbuVfs, const char *zWal, int bRbu){
4562 rbu_file *pDb;
4563 sqlite3_mutex_enter(pRbuVfs->mutex);
4564 if( bRbu ){
4565 for(pDb=pRbuVfs->pMainRbu; pDb && pDb->zWal!=zWal; pDb=pDb->pMainRbuNext){}
4566 }else{
4567 for(pDb=pRbuVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext){}
4568 }
4569 sqlite3_mutex_leave(pRbuVfs->mutex);
4570 return pDb;
4571}
4572
4573/*
4574** Close an rbu file.
4575*/
4576static int rbuVfsClose(sqlite3_file *pFile){
4577 rbu_file *p = (rbu_file*)pFile;
4578 int rc;
4579 int i;
4580
4581 /* Free the contents of the apShm[] array. And the array itself. */
4582 for(i=0; i<p->nShm; i++){
4583 sqlite3_free(p->apShm[i]);
4584 }
4585 sqlite3_free(p->apShm);
4586 p->apShm = 0;
4587 sqlite3_free(p->zDel);
4588
4589 if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
4590 rbuMainlistRemove(p);
4591 rbuUnlockShm(p);
4592 p->pReal->pMethods->xShmUnmap(p->pReal, 0);
4593 }
4594 else if( (p->openFlags & SQLITE_OPEN_DELETEONCLOSE) && p->pRbu ){
4595 rbuUpdateTempSize(p, 0);
4596 }
4597 assert( p->pMainNext==0 && p->pRbuVfs->pMain!=p );
4598
4599 /* Close the underlying file handle */
4600 rc = p->pReal->pMethods->xClose(p->pReal);
4601 return rc;
4602}
4603
4604
4605/*
4606** Read and return an unsigned 32-bit big-endian integer from the buffer
4607** passed as the only argument.
4608*/
4609static u32 rbuGetU32(u8 *aBuf){
4610 return ((u32)aBuf[0] << 24)
4611 + ((u32)aBuf[1] << 16)
4612 + ((u32)aBuf[2] << 8)
4613 + ((u32)aBuf[3]);
4614}
4615
4616/*
4617** Write an unsigned 32-bit value in big-endian format to the supplied
4618** buffer.
4619*/
4620static void rbuPutU32(u8 *aBuf, u32 iVal){
4621 aBuf[0] = (iVal >> 24) & 0xFF;
4622 aBuf[1] = (iVal >> 16) & 0xFF;
4623 aBuf[2] = (iVal >> 8) & 0xFF;
4624 aBuf[3] = (iVal >> 0) & 0xFF;
4625}
4626
4627static void rbuPutU16(u8 *aBuf, u16 iVal){
4628 aBuf[0] = (iVal >> 8) & 0xFF;
4629 aBuf[1] = (iVal >> 0) & 0xFF;
4630}
4631
4632/*
4633** Read data from an rbuVfs-file.
4634*/
4635static int rbuVfsRead(
4636 sqlite3_file *pFile,
4637 void *zBuf,
4638 int iAmt,
4639 sqlite_int64 iOfst
4640){
4641 rbu_file *p = (rbu_file*)pFile;
4642 sqlite3rbu *pRbu = p->pRbu;
4643 int rc;
4644
4645 if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
4646 assert( p->openFlags & SQLITE_OPEN_WAL );
4647 rc = rbuCaptureWalRead(p->pRbu, iOfst, iAmt);
4648 }else{
4649 if( pRbu && pRbu->eStage==RBU_STAGE_OAL
4650 && (p->openFlags & SQLITE_OPEN_WAL)
4651 && iOfst>=pRbu->iOalSz
4652 ){
4653 rc = SQLITE_OK;
4654 memset(zBuf, 0, iAmt);
4655 }else{
4656 rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
4657#if 1
4658 /* If this is being called to read the first page of the target
4659 ** database as part of an rbu vacuum operation, synthesize the
4660 ** contents of the first page if it does not yet exist. Otherwise,
4661 ** SQLite will not check for a *-wal file. */
4662 if( pRbu && rbuIsVacuum(pRbu)
4663 && rc==SQLITE_IOERR_SHORT_READ && iOfst==0
4664 && (p->openFlags & SQLITE_OPEN_MAIN_DB)
4665 && pRbu->rc==SQLITE_OK
4666 ){
4667 sqlite3_file *pFd = (sqlite3_file*)pRbu->pRbuFd;
4668 rc = pFd->pMethods->xRead(pFd, zBuf, iAmt, iOfst);
4669 if( rc==SQLITE_OK ){
4670 u8 *aBuf = (u8*)zBuf;
4671 u32 iRoot = rbuGetU32(&aBuf[52]) ? 1 : 0;
4672 rbuPutU32(&aBuf[52], iRoot); /* largest root page number */
4673 rbuPutU32(&aBuf[36], 0); /* number of free pages */
4674 rbuPutU32(&aBuf[32], 0); /* first page on free list trunk */
4675 rbuPutU32(&aBuf[28], 1); /* size of db file in pages */
4676 rbuPutU32(&aBuf[24], pRbu->pRbuFd->iCookie+1); /* Change counter */
4677
4678 if( iAmt>100 ){
4679 memset(&aBuf[100], 0, iAmt-100);
4680 rbuPutU16(&aBuf[105], iAmt & 0xFFFF);
4681 aBuf[100] = 0x0D;
4682 }
4683 }
4684 }
4685#endif
4686 }
4687 if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
4688 /* These look like magic numbers. But they are stable, as they are part
4689 ** of the definition of the SQLite file format, which may not change. */
4690 u8 *pBuf = (u8*)zBuf;
4691 p->iCookie = rbuGetU32(&pBuf[24]);
4692 p->iWriteVer = pBuf[19];
4693 }
4694 }
4695 return rc;
4696}
4697
4698/*
4699** Write data to an rbuVfs-file.
4700*/
4701static int rbuVfsWrite(
4702 sqlite3_file *pFile,
4703 const void *zBuf,
4704 int iAmt,
4705 sqlite_int64 iOfst
4706){
4707 rbu_file *p = (rbu_file*)pFile;
4708 sqlite3rbu *pRbu = p->pRbu;
4709 int rc;
4710
4711 if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
4712 assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
4713 rc = rbuCaptureDbWrite(p->pRbu, iOfst);
4714 }else{
4715 if( pRbu ){
4716 if( pRbu->eStage==RBU_STAGE_OAL
4717 && (p->openFlags & SQLITE_OPEN_WAL)
4718 && iOfst>=pRbu->iOalSz
4719 ){
4720 pRbu->iOalSz = iAmt + iOfst;
4721 }else if( p->openFlags & SQLITE_OPEN_DELETEONCLOSE ){
4722 i64 szNew = iAmt+iOfst;
4723 if( szNew>p->sz ){
4724 rc = rbuUpdateTempSize(p, szNew);
4725 if( rc!=SQLITE_OK ) return rc;
4726 }
4727 }
4728 }
4729 rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
4730 if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
4731 /* These look like magic numbers. But they are stable, as they are part
4732 ** of the definition of the SQLite file format, which may not change. */
4733 u8 *pBuf = (u8*)zBuf;
4734 p->iCookie = rbuGetU32(&pBuf[24]);
4735 p->iWriteVer = pBuf[19];
4736 }
4737 }
4738 return rc;
4739}
4740
4741/*
4742** Truncate an rbuVfs-file.
4743*/
4744static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
4745 rbu_file *p = (rbu_file*)pFile;
4746 if( (p->openFlags & SQLITE_OPEN_DELETEONCLOSE) && p->pRbu ){
4747 int rc = rbuUpdateTempSize(p, size);
4748 if( rc!=SQLITE_OK ) return rc;
4749 }
4750 return p->pReal->pMethods->xTruncate(p->pReal, size);
4751}
4752
4753/*
4754** Sync an rbuVfs-file.
4755*/
4756static int rbuVfsSync(sqlite3_file *pFile, int flags){
4757 rbu_file *p = (rbu_file *)pFile;
4758 if( p->pRbu && p->pRbu->eStage==RBU_STAGE_CAPTURE ){
4759 if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
4760 return SQLITE_INTERNAL;
4761 }
4762 return SQLITE_OK;
4763 }
4764 return p->pReal->pMethods->xSync(p->pReal, flags);
4765}
4766
4767/*
4768** Return the current file-size of an rbuVfs-file.
4769*/
4770static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
4771 rbu_file *p = (rbu_file *)pFile;
4772 int rc;
4773 rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
4774
4775 /* If this is an RBU vacuum operation and this is the target database,
4776 ** pretend that it has at least one page. Otherwise, SQLite will not
4777 ** check for the existance of a *-wal file. rbuVfsRead() contains
4778 ** similar logic. */
4779 if( rc==SQLITE_OK && *pSize==0
4780 && p->pRbu && rbuIsVacuum(p->pRbu)
4781 && (p->openFlags & SQLITE_OPEN_MAIN_DB)
4782 ){
4783 *pSize = 1024;
4784 }
4785 return rc;
4786}
4787
4788/*
4789** Lock an rbuVfs-file.
4790*/
4791static int rbuVfsLock(sqlite3_file *pFile, int eLock){
4792 rbu_file *p = (rbu_file*)pFile;
4793 sqlite3rbu *pRbu = p->pRbu;
4794 int rc = SQLITE_OK;
4795
4796 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
4797 if( eLock==SQLITE_LOCK_EXCLUSIVE
4798 && (p->bNolock || (pRbu && pRbu->eStage!=RBU_STAGE_DONE))
4799 ){
4800 /* Do not allow EXCLUSIVE locks. Preventing SQLite from taking this
4801 ** prevents it from checkpointing the database from sqlite3_close(). */
4802 rc = SQLITE_BUSY;
4803 }else{
4804 rc = p->pReal->pMethods->xLock(p->pReal, eLock);
4805 }
4806
4807 return rc;
4808}
4809
4810/*
4811** Unlock an rbuVfs-file.
4812*/
4813static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
4814 rbu_file *p = (rbu_file *)pFile;
4815 return p->pReal->pMethods->xUnlock(p->pReal, eLock);
4816}
4817
4818/*
4819** Check if another file-handle holds a RESERVED lock on an rbuVfs-file.
4820*/
4821static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
4822 rbu_file *p = (rbu_file *)pFile;
4823 return p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
4824}
4825
4826/*
4827** File control method. For custom operations on an rbuVfs-file.
4828*/
4829static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
4830 rbu_file *p = (rbu_file *)pFile;
4831 int (*xControl)(sqlite3_file*,int,void*) = p->pReal->pMethods->xFileControl;
4832 int rc;
4833
4834 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB)
4835 || p->openFlags & (SQLITE_OPEN_TRANSIENT_DB|SQLITE_OPEN_TEMP_JOURNAL)
4836 );
4837 if( op==SQLITE_FCNTL_RBU ){
4838 sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
4839
4840 /* First try to find another RBU vfs lower down in the vfs stack. If
4841 ** one is found, this vfs will operate in pass-through mode. The lower
4842 ** level vfs will do the special RBU handling. */
4843 rc = xControl(p->pReal, op, pArg);
4844
4845 if( rc==SQLITE_NOTFOUND ){
4846 /* Now search for a zipvfs instance lower down in the VFS stack. If
4847 ** one is found, this is an error. */
4848 void *dummy = 0;
4849 rc = xControl(p->pReal, SQLITE_FCNTL_ZIPVFS, &dummy);
4850 if( rc==SQLITE_OK ){
4851 rc = SQLITE_ERROR;
4852 pRbu->zErrmsg = sqlite3_mprintf("rbu/zipvfs setup error");
4853 }else if( rc==SQLITE_NOTFOUND ){
4854 pRbu->pTargetFd = p;
4855 p->pRbu = pRbu;
4856 rbuMainlistAdd(p);
4857 if( p->pWalFd ) p->pWalFd->pRbu = pRbu;
4858 rc = SQLITE_OK;
4859 }
4860 }
4861 return rc;
4862 }
4863 else if( op==SQLITE_FCNTL_RBUCNT ){
4864 sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
4865 pRbu->nRbu++;
4866 pRbu->pRbuFd = p;
4867 p->bNolock = 1;
4868 }
4869
4870 rc = xControl(p->pReal, op, pArg);
4871 if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
4872 rbu_vfs *pRbuVfs = p->pRbuVfs;
4873 char *zIn = *(char**)pArg;
4874 char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
4875 *(char**)pArg = zOut;
4876 if( zOut==0 ) rc = SQLITE_NOMEM;
4877 }
4878
4879 return rc;
4880}
4881
4882/*
4883** Return the sector-size in bytes for an rbuVfs-file.
4884*/
4885static int rbuVfsSectorSize(sqlite3_file *pFile){
4886 rbu_file *p = (rbu_file *)pFile;
4887 return p->pReal->pMethods->xSectorSize(p->pReal);
4888}
4889
4890/*
4891** Return the device characteristic flags supported by an rbuVfs-file.
4892*/
4893static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
4894 rbu_file *p = (rbu_file *)pFile;
4895 return p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
4896}
4897
4898/*
4899** Take or release a shared-memory lock.
4900*/
4901static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
4902 rbu_file *p = (rbu_file*)pFile;
4903 sqlite3rbu *pRbu = p->pRbu;
4904 int rc = SQLITE_OK;
4905
4906#ifdef SQLITE_AMALGAMATION
4907 assert( WAL_CKPT_LOCK==1 );
4908#endif
4909
4910 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
4911 if( pRbu && (
4912 pRbu->eStage==RBU_STAGE_OAL
4913 || pRbu->eStage==RBU_STAGE_MOVE
4914 || pRbu->eStage==RBU_STAGE_DONE
4915 )){
4916 /* Prevent SQLite from taking a shm-lock on the target file when it
4917 ** is supplying heap memory to the upper layer in place of *-shm
4918 ** segments. */
4919 if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY;
4920 }else{
4921 int bCapture = 0;
4922 if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
4923 bCapture = 1;
4924 }
4925 if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
4926 rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
4927 if( bCapture && rc==SQLITE_OK ){
4928 pRbu->mLock |= ((1<<n) - 1) << ofst;
4929 }
4930 }
4931 }
4932
4933 return rc;
4934}
4935
4936/*
4937** Obtain a pointer to a mapping of a single 32KiB page of the *-shm file.
4938*/
4939static int rbuVfsShmMap(
4940 sqlite3_file *pFile,
4941 int iRegion,
4942 int szRegion,
4943 int isWrite,
4944 void volatile **pp
4945){
4946 rbu_file *p = (rbu_file*)pFile;
4947 int rc = SQLITE_OK;
4948 int eStage = (p->pRbu ? p->pRbu->eStage : 0);
4949
4950 /* If not in RBU_STAGE_OAL, allow this call to pass through. Or, if this
4951 ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
4952 ** instead of a file on disk. */
4953 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
4954 if( eStage==RBU_STAGE_OAL ){
4955 sqlite3_int64 nByte = (iRegion+1) * sizeof(char*);
4956 char **apNew = (char**)sqlite3_realloc64(p->apShm, nByte);
4957
4958 /* This is an RBU connection that uses its own heap memory for the
4959 ** pages of the *-shm file. Since no other process can have run
4960 ** recovery, the connection must request *-shm pages in order
4961 ** from start to finish. */
4962 assert( iRegion==p->nShm );
4963 if( apNew==0 ){
4964 rc = SQLITE_NOMEM;
4965 }else{
4966 memset(&apNew[p->nShm], 0, sizeof(char*) * (1 + iRegion - p->nShm));
4967 p->apShm = apNew;
4968 p->nShm = iRegion+1;
4969 }
4970
4971 if( rc==SQLITE_OK ){
4972 char *pNew = (char*)sqlite3_malloc64(szRegion);
4973 if( pNew==0 ){
4974 rc = SQLITE_NOMEM;
4975 }else{
4976 memset(pNew, 0, szRegion);
4977 p->apShm[iRegion] = pNew;
4978 }
4979 }
4980
4981 if( rc==SQLITE_OK ){
4982 *pp = p->apShm[iRegion];
4983 }else{
4984 *pp = 0;
4985 }
4986 }else{
4987 assert( p->apShm==0 );
4988 rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
4989 }
4990
4991 return rc;
4992}
4993
4994/*
4995** Memory barrier.
4996*/
4997static void rbuVfsShmBarrier(sqlite3_file *pFile){
4998 rbu_file *p = (rbu_file *)pFile;
4999 p->pReal->pMethods->xShmBarrier(p->pReal);
5000}
5001
5002/*
5003** The xShmUnmap method.
5004*/
5005static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
5006 rbu_file *p = (rbu_file*)pFile;
5007 int rc = SQLITE_OK;
5008 int eStage = (p->pRbu ? p->pRbu->eStage : 0);
5009
5010 assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
5011 if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
5012 /* no-op */
5013 }else{
5014 /* Release the checkpointer and writer locks */
5015 rbuUnlockShm(p);
5016 rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
5017 }
5018 return rc;
5019}
5020
5021/*
5022** Open an rbu file handle.
5023*/
5024static int rbuVfsOpen(
5025 sqlite3_vfs *pVfs,
5026 const char *zName,
5027 sqlite3_file *pFile,
5028 int flags,
5029 int *pOutFlags
5030){
5031 static sqlite3_io_methods rbuvfs_io_methods = {
5032 2, /* iVersion */
5033 rbuVfsClose, /* xClose */
5034 rbuVfsRead, /* xRead */
5035 rbuVfsWrite, /* xWrite */
5036 rbuVfsTruncate, /* xTruncate */
5037 rbuVfsSync, /* xSync */
5038 rbuVfsFileSize, /* xFileSize */
5039 rbuVfsLock, /* xLock */
5040 rbuVfsUnlock, /* xUnlock */
5041 rbuVfsCheckReservedLock, /* xCheckReservedLock */
5042 rbuVfsFileControl, /* xFileControl */
5043 rbuVfsSectorSize, /* xSectorSize */
5044 rbuVfsDeviceCharacteristics, /* xDeviceCharacteristics */
5045 rbuVfsShmMap, /* xShmMap */
5046 rbuVfsShmLock, /* xShmLock */
5047 rbuVfsShmBarrier, /* xShmBarrier */
5048 rbuVfsShmUnmap, /* xShmUnmap */
5049 0, 0 /* xFetch, xUnfetch */
5050 };
5051 rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
5052 sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
5053 rbu_file *pFd = (rbu_file *)pFile;
5054 int rc = SQLITE_OK;
5055 const char *zOpen = zName;
5056 int oflags = flags;
5057
5058 memset(pFd, 0, sizeof(rbu_file));
5059 pFd->pReal = (sqlite3_file*)&pFd[1];
5060 pFd->pRbuVfs = pRbuVfs;
5061 pFd->openFlags = flags;
5062 if( zName ){
5063 if( flags & SQLITE_OPEN_MAIN_DB ){
5064 /* A main database has just been opened. The following block sets
5065 ** (pFd->zWal) to point to a buffer owned by SQLite that contains
5066 ** the name of the *-wal file this db connection will use. SQLite
5067 ** happens to pass a pointer to this buffer when using xAccess()
5068 ** or xOpen() to operate on the *-wal file. */
5069 pFd->zWal = sqlite3_filename_wal(zName);
5070 }
5071 else if( flags & SQLITE_OPEN_WAL ){
5072 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
5073 if( pDb ){
5074 if( pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
5075 /* This call is to open a *-wal file. Intead, open the *-oal. */
5076 size_t nOpen;
5077 if( rbuIsVacuum(pDb->pRbu) ){
5078 zOpen = sqlite3_db_filename(pDb->pRbu->dbRbu, "main");
5079 zOpen = sqlite3_filename_wal(zOpen);
5080 }
5081 nOpen = strlen(zOpen);
5082 ((char*)zOpen)[nOpen-3] = 'o';
5083 pFd->pRbu = pDb->pRbu;
5084 }
5085 pDb->pWalFd = pFd;
5086 }
5087 }
5088 }else{
5089 pFd->pRbu = pRbuVfs->pRbu;
5090 }
5091
5092 if( oflags & SQLITE_OPEN_MAIN_DB
5093 && sqlite3_uri_boolean(zName, "rbu_memory", 0)
5094 ){
5095 assert( oflags & SQLITE_OPEN_MAIN_DB );
5096 oflags = SQLITE_OPEN_TEMP_DB | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
5097 SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
5098 zOpen = 0;
5099 }
5100
5101 if( rc==SQLITE_OK ){
5102 rc = pRealVfs->xOpen(pRealVfs, zOpen, pFd->pReal, oflags, pOutFlags);
5103 }
5104 if( pFd->pReal->pMethods ){
5105 /* The xOpen() operation has succeeded. Set the sqlite3_file.pMethods
5106 ** pointer and, if the file is a main database file, link it into the
5107 ** mutex protected linked list of all such files. */
5108 pFile->pMethods = &rbuvfs_io_methods;
5109 if( flags & SQLITE_OPEN_MAIN_DB ){
5110 rbuMainlistAdd(pFd);
5111 }
5112 }else{
5113 sqlite3_free(pFd->zDel);
5114 }
5115
5116 return rc;
5117}
5118
5119/*
5120** Delete the file located at zPath.
5121*/
5122static int rbuVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
5123 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5124 return pRealVfs->xDelete(pRealVfs, zPath, dirSync);
5125}
5126
5127/*
5128** Test for access permissions. Return true if the requested permission
5129** is available, or false otherwise.
5130*/
5131static int rbuVfsAccess(
5132 sqlite3_vfs *pVfs,
5133 const char *zPath,
5134 int flags,
5135 int *pResOut
5136){
5137 rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
5138 sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
5139 int rc;
5140
5141 rc = pRealVfs->xAccess(pRealVfs, zPath, flags, pResOut);
5142
5143 /* If this call is to check if a *-wal file associated with an RBU target
5144 ** database connection exists, and the RBU update is in RBU_STAGE_OAL,
5145 ** the following special handling is activated:
5146 **
5147 ** a) if the *-wal file does exist, return SQLITE_CANTOPEN. This
5148 ** ensures that the RBU extension never tries to update a database
5149 ** in wal mode, even if the first page of the database file has
5150 ** been damaged.
5151 **
5152 ** b) if the *-wal file does not exist, claim that it does anyway,
5153 ** causing SQLite to call xOpen() to open it. This call will also
5154 ** be intercepted (see the rbuVfsOpen() function) and the *-oal
5155 ** file opened instead.
5156 */
5157 if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
5158 rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath, 1);
5159 if( pDb && pDb->pRbu->eStage==RBU_STAGE_OAL ){
5160 assert( pDb->pRbu );
5161 if( *pResOut ){
5162 rc = SQLITE_CANTOPEN;
5163 }else{
5164 sqlite3_int64 sz = 0;
5165 rc = rbuVfsFileSize(&pDb->base, &sz);
5166 *pResOut = (sz>0);
5167 }
5168 }
5169 }
5170
5171 return rc;
5172}
5173
5174/*
5175** Populate buffer zOut with the full canonical pathname corresponding
5176** to the pathname in zPath. zOut is guaranteed to point to a buffer
5177** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
5178*/
5179static int rbuVfsFullPathname(
5180 sqlite3_vfs *pVfs,
5181 const char *zPath,
5182 int nOut,
5183 char *zOut
5184){
5185 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5186 return pRealVfs->xFullPathname(pRealVfs, zPath, nOut, zOut);
5187}
5188
5189#ifndef SQLITE_OMIT_LOAD_EXTENSION
5190/*
5191** Open the dynamic library located at zPath and return a handle.
5192*/
5193static void *rbuVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
5194 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5195 return pRealVfs->xDlOpen(pRealVfs, zPath);
5196}
5197
5198/*
5199** Populate the buffer zErrMsg (size nByte bytes) with a human readable
5200** utf-8 string describing the most recent error encountered associated
5201** with dynamic libraries.
5202*/
5203static void rbuVfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
5204 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5205 pRealVfs->xDlError(pRealVfs, nByte, zErrMsg);
5206}
5207
5208/*
5209** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
5210*/
5211static void (*rbuVfsDlSym(
5212 sqlite3_vfs *pVfs,
5213 void *pArg,
5214 const char *zSym
5215))(void){
5216 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5217 return pRealVfs->xDlSym(pRealVfs, pArg, zSym);
5218}
5219
5220/*
5221** Close the dynamic library handle pHandle.
5222*/
5223static void rbuVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
5224 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5225 pRealVfs->xDlClose(pRealVfs, pHandle);
5226}
5227#endif /* SQLITE_OMIT_LOAD_EXTENSION */
5228
5229/*
5230** Populate the buffer pointed to by zBufOut with nByte bytes of
5231** random data.
5232*/
5233static int rbuVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
5234 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5235 return pRealVfs->xRandomness(pRealVfs, nByte, zBufOut);
5236}
5237
5238/*
5239** Sleep for nMicro microseconds. Return the number of microseconds
5240** actually slept.
5241*/
5242static int rbuVfsSleep(sqlite3_vfs *pVfs, int nMicro){
5243 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5244 return pRealVfs->xSleep(pRealVfs, nMicro);
5245}
5246
5247/*
5248** Return the current time as a Julian Day number in *pTimeOut.
5249*/
5250static int rbuVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
5251 sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
5252 return pRealVfs->xCurrentTime(pRealVfs, pTimeOut);
5253}
5254
5255/*
5256** No-op.
5257*/
5258static int rbuVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
5259 return 0;
5260}
5261
5262/*
5263** Deregister and destroy an RBU vfs created by an earlier call to
5264** sqlite3rbu_create_vfs().
5265*/
5266void sqlite3rbu_destroy_vfs(const char *zName){
5267 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
5268 if( pVfs && pVfs->xOpen==rbuVfsOpen ){
5269 sqlite3_mutex_free(((rbu_vfs*)pVfs)->mutex);
5270 sqlite3_vfs_unregister(pVfs);
5271 sqlite3_free(pVfs);
5272 }
5273}
5274
5275/*
5276** Create an RBU VFS named zName that accesses the underlying file-system
5277** via existing VFS zParent. The new object is registered as a non-default
5278** VFS with SQLite before returning.
5279*/
5280int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
5281
5282 /* Template for VFS */
5283 static sqlite3_vfs vfs_template = {
5284 1, /* iVersion */
5285 0, /* szOsFile */
5286 0, /* mxPathname */
5287 0, /* pNext */
5288 0, /* zName */
5289 0, /* pAppData */
5290 rbuVfsOpen, /* xOpen */
5291 rbuVfsDelete, /* xDelete */
5292 rbuVfsAccess, /* xAccess */
5293 rbuVfsFullPathname, /* xFullPathname */
5294
5295#ifndef SQLITE_OMIT_LOAD_EXTENSION
5296 rbuVfsDlOpen, /* xDlOpen */
5297 rbuVfsDlError, /* xDlError */
5298 rbuVfsDlSym, /* xDlSym */
5299 rbuVfsDlClose, /* xDlClose */
5300#else
5301 0, 0, 0, 0,
5302#endif
5303
5304 rbuVfsRandomness, /* xRandomness */
5305 rbuVfsSleep, /* xSleep */
5306 rbuVfsCurrentTime, /* xCurrentTime */
5307 rbuVfsGetLastError, /* xGetLastError */
5308 0, /* xCurrentTimeInt64 (version 2) */
5309 0, 0, 0 /* Unimplemented version 3 methods */
5310 };
5311
5312 rbu_vfs *pNew = 0; /* Newly allocated VFS */
5313 int rc = SQLITE_OK;
5314 size_t nName;
5315 size_t nByte;
5316
5317 nName = strlen(zName);
5318 nByte = sizeof(rbu_vfs) + nName + 1;
5319 pNew = (rbu_vfs*)sqlite3_malloc64(nByte);
5320 if( pNew==0 ){
5321 rc = SQLITE_NOMEM;
5322 }else{
5323 sqlite3_vfs *pParent; /* Parent VFS */
5324 memset(pNew, 0, nByte);
5325 pParent = sqlite3_vfs_find(zParent);
5326 if( pParent==0 ){
5327 rc = SQLITE_NOTFOUND;
5328 }else{
5329 char *zSpace;
5330 memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
5331 pNew->base.mxPathname = pParent->mxPathname;
5332 pNew->base.szOsFile = sizeof(rbu_file) + pParent->szOsFile;
5333 pNew->pRealVfs = pParent;
5334 pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
5335 memcpy(zSpace, zName, nName);
5336
5337 /* Allocate the mutex and register the new VFS (not as the default) */
5338 pNew->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
5339 if( pNew->mutex==0 ){
5340 rc = SQLITE_NOMEM;
5341 }else{
5342 rc = sqlite3_vfs_register(&pNew->base, 0);
5343 }
5344 }
5345
5346 if( rc!=SQLITE_OK ){
5347 sqlite3_mutex_free(pNew->mutex);
5348 sqlite3_free(pNew);
5349 }
5350 }
5351
5352 return rc;
5353}
5354
5355/*
5356** Configure the aggregate temp file size limit for this RBU handle.
5357*/
5358sqlite3_int64 sqlite3rbu_temp_size_limit(sqlite3rbu *pRbu, sqlite3_int64 n){
5359 if( n>=0 ){
5360 pRbu->szTempLimit = n;
5361 }
5362 return pRbu->szTempLimit;
5363}
5364
5365sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu *pRbu){
5366 return pRbu->szTemp;
5367}
5368
5369
5370/**************************************************************************/
5371
5372#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
5373