SQLite

/*
** Show available command line options
*/
static const char zOptions[] = 
  "   -bail                stop after hitting an error\n"
  "   -batch               force batch I/O\n"
  "   -column              set output mode to 'column'\n"
  "   -cmd COMMIT          run \"COMMAND\" before reading stdin\n"
  "   -csv                 set output mode to 'csv'\n"
  "   -echo                print commands before execution\n"
  "   -init filename       read/process named file\n"
  "   -[no]header          turn headers on or off\n"
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
  "   -heap SIZE           Size of heap for memsys3 or memsys5\n"
#endif
  "   -help                show this message\n"
  "   -html                set output mode to HTML\n"
  "   -interactive         force interactive I/O\n"
  "   -line                set output mode to 'line'\n"
  "   -list                set output mode to 'list'\n"
#ifdef SQLITE_ENABLE_MULTIPLEX
  "   -multiplex           enable the multiplexor VFS\n"
#endif
  "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
  "   -separator SEP       set output field separator. Default: '|'\n"
  "   -stats               print memory stats before each finalize\n"
  "   -version             show SQLite version\n"
  "   -vfs NAME            use NAME as the default VFS\n"
#ifdef SQLITE_ENABLE_VFSTRACE
  "   -vfstrace            enable tracing of all VFS calls\n"
#endif
;

  data->showHeader = 0;
  sqlite3_config(SQLITE_CONFIG_URI, 1);
  sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
  sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
  sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
}

/*
** Get the argument to an --option.  Throw an error and die if no argument
** is available.
*/
static char *cmdline_option_value(int argc, char **argv, int i){
  if( i==argc ){
    fprintf(stderr, "%s: Error: missing argument to %s\n",
            argv[0], argv[argc-1]);
    exit(1);
  }
  return argv[i];
}

int main(int argc, char **argv){
  char *zErrMsg = 0;
  struct callback_data data;
  const char *zInitFile = 0;
  char *zFirstCmd = 0;
  int i;

#endif

  /* Do an initial pass through the command-line argument to locate
  ** the name of the database file, the name of the initialization file,
  ** the size of the alternative malloc heap,
  ** and the first command to execute.
  */
  for(i=1; i<argc; i++){
    char *z;

    z = argv[i];
    if( z[0]!='-' ){
      if( data.zDbFilename==0 ){
        data.zDbFilename = z;
        continue;
      }
      if( zFirstCmd==0 ){
        zFirstCmd = z;
        continue;
      }
      fprintf(stderr,"%s: Error: too many options: \"%s\"\n", Argv0, argv[i]);
      fprintf(stderr,"Use -help for a list of options.\n");
      return 1;
    }
    if( z[1]=='-' ) z++;
    if( strcmp(z,"-separator")==0
     || strcmp(z,"-nullvalue")==0
     || strcmp(z,"-cmd")==0
    ){
      (void)cmdline_option_value(argc, argv, ++i);
    }else if( strcmp(z,"-init")==0 ){

      zInitFile = cmdline_option_value(argc, argv, ++i);
    }else if( strcmp(z,"-batch")==0 ){
      /* Need to check for batch mode here to so we can avoid printing
      ** informational messages (like from process_sqliterc) before 
      ** we do the actual processing of arguments later in a second pass.
      */

      stdin_is_interactive = 0;
    }else if( strcmp(z,"-heap")==0 ){
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
      int j, c;
      const char *zSize;
      sqlite3_int64 szHeap;

      zSize = cmdline_option_value(argc, argv, ++i);
      szHeap = atoi(zSize);
      for(j=0; (c = zSize[j])!=0; j++){
        if( c=='M' ){ szHeap *= 1000000; break; }
        if( c=='K' ){ szHeap *= 1000; break; }
        if( c=='G' ){ szHeap *= 1000000000; break; }
      }
      if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;

    }else if( strcmp(z,"-multiplex")==0 ){
      extern int sqlite3_multiple_initialize(const char*,int);
      sqlite3_multiplex_initialize(0, 1);
#endif
#ifdef SQLITE_ENABLE_SSDSIM
    }else if( strcmp(z, "-ssdsim")==0 ){
      extern int ssdsim_register(const char*,const char*,int);
      ssdsim_register(0, cmdline_option_value(argc,argv,++i), 1);
#endif
    }else if( strcmp(z,"-vfs")==0 ){
      sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
      if( pVfs ){
        sqlite3_vfs_register(pVfs, 1);
      }else{
        fprintf(stderr, "no such VFS: \"%s\"\n", argv[i]);
        exit(1);
      }
    }
  }

  if( data.zDbFilename==0 ){

#ifndef SQLITE_OMIT_MEMORYDB
    data.zDbFilename = ":memory:";
#else







    fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);

    return 1;
#endif
  }
  data.out = stdout;








  /* Go ahead and open the database file if it already exists.  If the
  ** file does not exist, delay opening it.  This prevents empty database
  ** files from being created if a user mistypes the database name argument
  ** to the sqlite command-line tool.
  */
  if( access(data.zDbFilename, 0)==0 ){

  }

  /* Make a second pass through the command-line argument and set
  ** options.  This second pass is delayed until after the initialization
  ** file is processed so that the command-line arguments will override
  ** settings in the initialization file.
  */
  for(i=1; i<argc; i++){
    char *z = argv[i];
    if( z[0]!='-' ) continue;
    if( z[1]=='-' ){ z++; }
    if( strcmp(z,"-init")==0 ){
      i++;
    }else if( strcmp(z,"-html")==0 ){
      data.mode = MODE_Html;
    }else if( strcmp(z,"-list")==0 ){
      data.mode = MODE_List;
    }else if( strcmp(z,"-line")==0 ){
      data.mode = MODE_Line;
    }else if( strcmp(z,"-column")==0 ){
      data.mode = MODE_Column;
    }else if( strcmp(z,"-csv")==0 ){
      data.mode = MODE_Csv;
      memcpy(data.separator,",",2);
    }else if( strcmp(z,"-separator")==0 ){







      sqlite3_snprintf(sizeof(data.separator), data.separator,

                       "%s",cmdline_option_value(argc,argv,++i));
    }else if( strcmp(z,"-nullvalue")==0 ){







      sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,
                       "%s",cmdline_option_value(argc,argv,++i));
    }else if( strcmp(z,"-header")==0 ){
      data.showHeader = 1;
    }else if( strcmp(z,"-noheader")==0 ){
      data.showHeader = 0;
    }else if( strcmp(z,"-echo")==0 ){
      data.echoOn = 1;
    }else if( strcmp(z,"-stats")==0 ){

    }else if( strcmp(z,"-ssdsim")==0 ){
      i++;
#endif
    }else if( strcmp(z,"-help")==0 ){
      usage(1);
    }else if( strcmp(z,"-cmd")==0 ){
      if( i==argc-1 ) break;

      z = cmdline_option_value(argc,argv,++i);
      if( z[0]=='.' ){
        rc = do_meta_command(z, &data);
        if( rc && bail_on_error ) return rc;
      }else{
        open_db(&data);
        rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
        if( zErrMsg!=0 ){

  g.aDealloc = 0;
  g.nDealloc = 0;
  g.mxAlloc = 0;
  g.nPage = 0;
}

/*
** Initialize the ssdsim system.  Return non-zero if there is an error.
*/
static int ssdsimInit(void){
  int nPage;
  if( g.nPage ) return 0;
  if( g.szPage==0 ) g.szPage = 4096;
  if( g.szEBlock==0 ) g.szEBlock = 262144;
  if( g.szDisk==0 ) g.szDisk = 67108864;
  g.nPage = g.szDisk/g.szPage;
  g.nEBlock = g.szDisk/g.szEBlock;
  sqlite3_free(g.apPage);
  g.apPage = sqlite3_malloc( sizeof(g.apPage[0])*g.nPage );
  if( g.apPage==0 ){ ssdsimShutdown(); return 1; }
  memset(g.apPage, 0, sizeof(g.apPage[0])*g.nPage);
  g.aDealloc = sqlite3_malloc( sizeof(g.aDealloc[0])*g.nPage );
  if( g.aDealloc==0 ){ ssdsimShutdown(); return 1; }
  g.nDealloc = 0;
  g.mxAlloc = 0;
  g.nHostWrite = 0;
  g.nNANDWrite = 0;
  return 0;
}

/*
** Allocate a new, unused logical page number
*/
static int ssdsimCoreLpnAlloc(void){
  if( g.nDealloc ){

      pInode->nShmRegion = 0;
    }
  }
  return SQLITE_OK;
}

static const sqlite3_io_methods ssdsim_io_methods = {
  /* iVersion               */ 3,
  /* xClose                 */ ssdsimClose,
  /* xRead                  */ ssdsimRead,
  /* xWrite                 */ ssdsimWrite,
  /* xTruncate              */ ssdsimTruncate,
  /* xSync                  */ ssdsimSync,
  /* xFileSize              */ ssdsimFileSize,
  /* xLock                  */ ssdsimLock,

  const char *zName,
  sqlite3_file *pFile,
  int flags,
  int *pOutFlags
){
  int rc;
  ssdsim_file *p = (ssdsim_file *)pFile;
  ssdsim_inode *pInode;
  char zTempname[100];

  if( ssdsimInit() ) return SQLITE_CANTOPEN;
  if( zName==0 ){
    sqlite3_uint64 r;
    sqlite3_randomness(sizeof(r), &r);
    sqlite3_snprintf(sizeof(zTempname), zTempname, "/tmp%llx", r);
    zName = zTempname;
  }
  pInode = ssdsimFindInode(zName);
  if( pInode==0 ){
    int n = (int)strlen(zName);
    pInode = sqlite3_malloc( sizeof(*pInode) + n + 1 );
    if( pInode==0 ) return SQLITE_NOMEM;
    memset(pInode, 0, sizeof(*pInode));
    pInode->pNext = g.pInode;
    g.pInode = pInode;

/*
** Delete the file located at zPath. If the dirSync argument is true,
** ensure the file-system modifications are synced to disk before
** returning.
*/
static int ssdsimDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
  ssdsim_inode *pInode;

  if( ssdsimInit() ) return SQLITE_CANTOPEN;
  pInode = ssdsimFindInode(zPath);
  if( pInode==0 ) return SQLITE_NOTFOUND;
  ssdsimDeleteInode(pInode);
  return SQLITE_OK;
}

/*
** Test for access permissions. Return true if the requested permission
** is available, or false otherwise.
*/
static int ssdsimAccess(
  sqlite3_vfs *pVfs, 
  const char *zPath, 
  int flags, 
  int *pResOut
){
  ssdsim_inode *pInode;
  if( ssdsimInit() ) return SQLITE_CANTOPEN;
  pInode = ssdsimFindInode(zPath);
  *pResOut = pInode!=0;
  return SQLITE_OK;
}

/*
** Populate buffer zOut with the full canonical pathname corresponding
** to the pathname in zPath. zOut is guaranteed to point to a buffer

do_test shell1-1.14.2 {
  catchcmd "-separator x test.db" "" 
} {0 {}}
do_test shell1-1.14.3 {
  set res [catchcmd "-separator" ""]
  set rc [lindex $res 0]
  list $rc \
       [regexp {Error: missing argument to -separator} $res]
} {1 1}

# -stats               print memory stats before each finalize
do_test shell1-1.14b.1 {
  catchcmd "-stats test.db" "" 
} {0 {}}

# -nullvalue 'text'    set text string for NULL values
do_test shell1-1.15.1 {
  catchcmd "-nullvalue 'x' test.db" ""
} {0 {}}
do_test shell1-1.15.2 {
  catchcmd "-nullvalue x test.db" ""
} {0 {}}
do_test shell1-1.15.3 {
  set res [catchcmd "-nullvalue" ""]
  set rc [lindex $res 0]
  list $rc \
       [regexp {Error: missing argument to -nullvalue} $res]
} {1 1}

# -version             show SQLite version
do_test shell1-1.16.1 {
  set x [catchcmd "-version test.db" ""]
} {/3.[0-9.]+ 20\d\d-[01]\d-\d\d \d\d:\d\d:\d\d [0-9a-f]+/}