ext/rbu/rbu.c

   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 ** This file contains a command-line application that uses the RBU
  14 ** extension. See the usage() function below for an explanation.
  15 */
  16
  17 #include "sqlite3rbu.h"
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 /*
  23 ** Print a usage message and exit.
  24 */
  25 void usage(const char *zArgv0){
  26   fprintf(stderr,
  27 "Usage: %s ?OPTIONS? TARGET-DB RBU-DB\n"
  28 "\n"
  29 "Where options are:\n"
  30 "\n"
  31 "    -step NSTEP\n"
  32 "    -statstep NSTATSTEP\n"
  33 "    -vacuum\n"
  34 "    -presql SQL\n"
  35 "\n"
  36 "  If the -vacuum switch is not present, argument RBU-DB must be an RBU\n"
  37 "  database containing an update suitable for target database TARGET-DB.\n"
  38 "  Or, if -vacuum is specified, then TARGET-DB is a database to vacuum using\n"
  39 "  RBU, and RBU-DB is used as the state database for the vacuum (refer to\n"
  40 "  API documentation for details).\n"
  41 "\n"
  42 "  If NSTEP is set to less than or equal to zero (the default value), this \n"
  43 "  program attempts to perform the entire update or vacuum operation before\n"
  44 "  exiting\n"
  45 "\n"
  46 "  If NSTEP is greater than zero, then a maximum of NSTEP calls are made\n"
  47 "  to sqlite3rbu_step(). If the RBU update has not been completely applied\n"
  48 "  after the NSTEP'th call is made, the state is saved in the database RBU-DB\n"
  49 "  and the program exits. Subsequent invocations of this (or any other RBU)\n"
  50 "  application will use this state to resume applying the RBU update to the\n"
  51 "  target db.\n"
  52 "\n"
  53 , zArgv0);
  54   exit(1);
  55 }
  56
  57 void report_default_vfs(){
  58   sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
  59   fprintf(stdout, "default vfs is \"%s\"\n", pVfs ? pVfs->zName : "NULL");
  60 }
  61
  62 void report_rbu_vfs(sqlite3rbu *pRbu){
  63   sqlite3 *db = sqlite3rbu_db(pRbu, 0);
  64   if( db ){
  65     char *zName = 0;
  66     sqlite3_file_control(db, "main", SQLITE_FCNTL_VFSNAME, &zName);
  67     if( zName ){
  68       fprintf(stdout, "using vfs \"%s\"\n", zName);
  69     }else{
  70       fprintf(stdout, "vfs name not available\n");
  71     }
  72     sqlite3_free(zName);
  73   }
  74 }
  75
  76 int main(int argc, char **argv){
  77   int i;
  78   const char *zTarget;            /* Target database to apply RBU to */
  79   const char *zRbu;               /* Database containing RBU */
  80   char zBuf[200];                 /* Buffer for printf() */
  81   char *zErrmsg = 0;              /* Error message, if any */
  82   sqlite3rbu *pRbu;               /* RBU handle */
  83   int nStep = 0;                  /* Maximum number of step() calls */
  84   int nStatStep = 0;              /* Report stats after this many step calls */
  85   int bVacuum = 0;
  86   const char *zPreSql = 0;
  87   int rc = SQLITE_OK;
  88   sqlite3_int64 nProgress = 0;
  89   int nArgc = argc-2;
  90
  91   if( argc<3 ) usage(argv[0]);
  92   for(i=1; i<nArgc; i++){
  93     const char *zArg = argv[i];
  94     int nArg = strlen(zArg);
  95     if( nArg>1 && nArg<=8 && 0==memcmp(zArg, "-vacuum", nArg) ){
  96       bVacuum = 1;
  97     }else if( nArg>1 && nArg<=7
  98            && 0==memcmp(zArg, "-presql", nArg) && i<nArg-1 ){
  99       i++;
 100       zPreSql = argv[i];
 101     }else if( nArg>1 && nArg<=5 && 0==memcmp(zArg, "-step", nArg) && i<nArg-1 ){
 102       i++;
 103       nStep = atoi(argv[i]);
 104     }else if( nArg>1 && nArg<=9
 105            && 0==memcmp(zArg, "-statstep", nArg) && i<nArg-1
 106     ){
 107       i++;
 108       nStatStep = atoi(argv[i]);
 109     }else{
 110       usage(argv[0]);
 111     }
 112   }
 113
 114   zTarget = argv[argc-2];
 115   zRbu = argv[argc-1];
 116
 117   report_default_vfs();
 118
 119   /* Open an RBU handle. A vacuum handle if -vacuum was specified, or a
 120   ** regular RBU update handle otherwise.  */
 121   if( bVacuum ){
 122     pRbu = sqlite3rbu_vacuum(zTarget, zRbu);
 123   }else{
 124     pRbu = sqlite3rbu_open(zTarget, zRbu, 0);
 125   }
 126   report_rbu_vfs(pRbu);
 127
 128   if( zPreSql && pRbu ){
 129     sqlite3 *dbMain = sqlite3rbu_db(pRbu, 0);
 130     rc = sqlite3_exec(dbMain, zPreSql, 0, 0, 0);
 131     if( rc==SQLITE_OK ){
 132       sqlite3 *dbRbu = sqlite3rbu_db(pRbu, 1);
 133       rc = sqlite3_exec(dbRbu, zPreSql, 0, 0, 0);
 134     }
 135   }
 136
 137   /* If nStep is less than or equal to zero, call
 138   ** sqlite3rbu_step() until either the RBU has been completely applied
 139   ** or an error occurs. Or, if nStep is greater than zero, call
 140   ** sqlite3rbu_step() a maximum of nStep times.  */
 141   if( rc==SQLITE_OK ){
 142     for(i=0; (nStep<=0 || i<nStep) && sqlite3rbu_step(pRbu)==SQLITE_OK; i++){
 143       if( nStatStep>0 && (i % nStatStep)==0 ){
 144         sqlite3_int64 nUsed;
 145         sqlite3_int64 nHighwater;
 146         sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &nUsed, &nHighwater, 0);
 147         fprintf(stdout, "memory used=%lld highwater=%lld", nUsed, nHighwater);
 148         if( bVacuum==0 ){
 149           int one;
 150           int two;
 151           sqlite3rbu_bp_progress(pRbu, &one, &two);
 152           fprintf(stdout, "  progress=%d/%d\n", one, two);
 153         }else{
 154           fprintf(stdout, "\n");
 155         }
 156         fflush(stdout);
 157       }
 158     }
 159     nProgress = sqlite3rbu_progress(pRbu);
 160     rc = sqlite3rbu_close(pRbu, &zErrmsg);
 161   }
 162
 163   /* Let the user know what happened. */
 164   switch( rc ){
 165     case SQLITE_OK:
 166       sqlite3_snprintf(sizeof(zBuf), zBuf,
 167           "SQLITE_OK: rbu update incomplete (%lld operations so far)\n",
 168           nProgress
 169       );
 170       fprintf(stdout, "%s", zBuf);
 171       break;
 172
 173     case SQLITE_DONE:
 174       sqlite3_snprintf(sizeof(zBuf), zBuf,
 175           "SQLITE_DONE: rbu update completed (%lld operations)\n",
 176           nProgress
 177       );
 178       fprintf(stdout, "%s", zBuf);
 179       break;
 180
 181     default:
 182       fprintf(stderr, "error=%d: %s\n", rc, zErrmsg);
 183       break;
 184   }
 185
 186   if( nStatStep>0 ){
 187     sqlite3_int64 nUsed;
 188     sqlite3_int64 nHighwater;
 189     sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &nUsed, &nHighwater, 0);
 190     fprintf(stdout, "memory used=%lld highwater=%lld\n", nUsed, nHighwater);
 191   }
 192
 193   sqlite3_free(zErrmsg);
 194   return (rc==SQLITE_OK || rc==SQLITE_DONE) ? 0 : 1;
 195 }