sqllogictest

# Run the tests
#
set totalerr 0
set totaltest 0
set totalrun 0
foreach tx [lsort [array names tcase]] {
  foreach opt {0 0xfff} {
    set opt "integrity_check;optimizer=[expr {$opt+0}]"
    catch {
      exec $BIN -verify -parameter $opt $tx
    } res
    puts $res
    if {[regexp {(\d+) errors out of (\d+) tests} $res all nerr ntst]} {
      incr totalerr $nerr
      incr totaltest $ntst
    } else {
      error "test did not complete: $BIN -verify -parameter optimizer=$opt $tx"

**
** Use this interface as a model for other database engine interfaces.
*/
#include "sqlite3.h"
#include <ctype.h>
#include <stdio.h>

/*
** The SQLite database connection object
*/
typedef struct SQLiteConn SQLiteConn;
struct SQLiteConn {
  sqlite3 *db;            /* The database connection */
  unsigned flags;         /* Various flags */
};

/*
** Allowed values for SQLiteConn.flags
*/
#define FG_INTEGRITY_CHECK  0x0001    /* Run PRAGMA integrity_check */


/*
** Skip forward over whitespace in a string.
*/
static const char *skipWhitespace(const char *z){
  while( isspace(*z) ){ z++; }
  return z;

*/
static int sqliteConnect(
  void *NotUsed,              /* Argument from DbEngine object.  Not used */
  const char *zConnectStr,    /* Connection string */
  void **ppConn,              /* Write completed connection here */
  const char *zParam          /* Value of the -parameters command-line option */
){

  int rc;
  SQLiteConn *p;

  /* If the database filename is defined and the database already exists,
  ** then delete the database before we start, thus resetting it to an
  ** empty database.
  */
  if( zConnectStr==0 ) zConnectStr = "test.db";
  if( zConnectStr && zConnectStr[0] ){
#ifndef WIN32
    unlink(zConnectStr);
#else
    _unlink(zConnectStr);
#endif
  }

  p = sqlite3_malloc( sizeof(*p) );
  if( p==0 ){
    return 1;
  }
  memset(p, 0, sizeof(*p));

  /* Open a connection to the new database.
  */
  rc = sqlite3_open(zConnectStr, &p->db);
  if( rc!=SQLITE_OK ){
    sqlite3_free(p);
    return 1;
  }
  if( zParam ){
    zParam = skipWhitespace(zParam);
    while( zParam[0] ){
      if( strncmp(zParam, "optimizer=", 10)==0 ){
        int x = atoi(&zParam[10]);
        sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, p->db, x);
      }else if( strncmp(zParam, "integrity_check", 15)==0 ){
        p->flags |= FG_INTEGRITY_CHECK;
      }else{
        fprintf(stderr, "unknown parameter: [%s]\n", zParam);
        exit(1);
      }
      zParam = skipToNextParameter(zParam);
    }
  }
  sqlite3_exec(p->db, "PRAGMA synchronous=OFF", 0, 0, 0);
  *ppConn = (void*)p;
  return 0;  
}

/*
** Evaluate the single SQL statement given in zSql.  Return 0 on success.
** return non-zero if any error occurs.
*/
static int sqliteStatement(
  void *pConn,                /* Connection created by xConnect */
  const char *zSql,           /* SQL statement to evaluate */
  int bQuiet                  /* True to suppress printing errors. */
){
  int rc;
  SQLiteConn *p;
  

  p = (SQLiteConn*)pConn;
  rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
  if( rc==SQLITE_OK && (p->flags & FG_INTEGRITY_CHECK)!=0 ){
    sqlite3_stmt *pStmt;
    rc = sqlite3_prepare_v2(p->db, "PRAGMA integrity_check;", -1, &pStmt, 0);
    if( rc!=SQLITE_OK ){
      fprintf(stderr, "cannot prepare integrity_check\n");
      rc = 1;
    }else{
      char *z;
      if( sqlite3_step(pStmt)!=SQLITE_ROW ){
        fprintf(stderr, "cannot run integrity_check\n");
        rc = 1;
      }else if( (z = (char*)sqlite3_column_text(pStmt,0))==0
            || strcmp(z,"ok")!=0
      ){
        fprintf(stderr, "integrity_check returns: %s\n", z);
        rc = 1;
      }else{
        rc = 0;
      }
      sqlite3_finalize(pStmt);
    }
  }
  return rc!=SQLITE_OK;
}

/*
** Structure used to accumulate a result set.
*/
typedef struct ResAccum ResAccum;

  char ***pazResult,          /* RETURN:  Array of result values */
  int *pnResult               /* RETURN:  Number of result values */
){
  sqlite3 *db;                /* The database connection */
  sqlite3_stmt *pStmt;        /* Prepared statement */
  int rc;                     /* Result code from subroutine calls */
  ResAccum res;               /* query result accumulator */
  SQLiteConn *p;              /* The database connection */
  char zBuffer[200];          /* Buffer to render numbers */

  memset(&res, 0, sizeof(res));
  p = (SQLiteConn*)pConn;
  db = p->db;
  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
  if( rc!=SQLITE_OK ){
    sqlite3_finalize(pStmt);
    return 1;
  }
  if( strlen(zType)!=sqlite3_column_count(pStmt) ){
    fprintf(stderr, "wrong number of result columns: expected %d but got %d\n",

** database files.  If the database is deleted here, that is one approach.
** The other approach is to delete left-over databases in the xConnect
** method.  The SQLite interface takes the latter approach.
*/
static int sqliteDisconnect(
  void *pConn                 /* Connection created by xConnect */
){
  SQLiteConn *p = (SQLiteConn*)pConn;
  int rc;
  rc = sqlite3_close(p->db);
  sqlite3_free(p);
  if( sqlite3_memory_used()>0 ){
    fprintf(stderr, "memory leak after connection close\n");
    rc = 1;
  }
  return rc;
}

/*
** This routine is called to return the name of the DB engine
** used by the connection pConn.  This name may or may not
** be the same as specified in the DbEngine structure.
**

  apEngine[nEngine-1] = (DbEngine *)p;
}

/*
** Print a usage comment and die
*/
static void usage(const char *argv0){

  fprintf(stdout, "Usage: %s [options] script\n", argv0);



  fprintf(stdout,
    "Options:\n"
    "  --connection STR       The connection string\n"
    "  --engine DBENGINE      The engine name (ex: SQLite, ODBC3)\n"
    "  --halt                 Stop when first error is seen\n"
    "  --ht NUM               Check results by hash if numbe of lines > NUM\n"
    "  --odbc STR             Shorthand for \"--engine ODBC3 --connection STR\"\n"
    "  --parameters TXT       Extra parameters to the connection string\n"
    "  --trace                Enable tracing of SQL to standard output\n"
    "  --verify               Use \"verify MODE\"\n"
  );

  exit(1);
}

/*
** A structure to keep track of the state of scanning the input script.
*/
typedef struct Script Script;

/*
** This is the main routine.  This routine runs first.  It processes
** command-line arguments then runs the test.
*/
int main(int argc, char **argv){
  int verifyMode = 0;                  /* True if in -verify mode */
  int haltOnError = 0;                 /* Stop on first error if true */
  int enableTrace = 0;                 /* Trace SQL statements if true */
  const char *zScriptFile = 0;         /* Input script filename */
  const char *zDbEngine = "SQLite";    /* Name of database engine */
  const char *zConnection = 0;         /* Connection string on DB engine */
  const DbEngine *pEngine = 0;         /* Pointer to DbEngine object */
  int i;                               /* Loop counter */
  char *zScript;                       /* Content of the script */
  long nScript;                        /* Size of the script in bytes */

  /* Scan the command-line and process arguments
  */
  for(i=1; i<argc; i++){
    int n;
    const char *z = argv[i];
    if( z[0]=='-' && z[1]=='-' ) z++;
    n = (int)strlen(z);
    if( strncmp(z, "-connection",n)==0 ){
      zConnection = argv[++i];
    }else if( strncmp(z, "-engine",n)==0 ){
      zDbEngine = argv[++i];
    }else if( strncmp(z, "-halt",n)==0 ){
      haltOnError = 1;
    }else if( strncmp(z, "-ht",n)==0 ){
      hashThreshold = atoi(argv[++i]);
      bHt = -1;
    }else if( strncmp(z, "-odbc",n)==0 ){
      zDbEngine = "ODBC3";
      zConnection = argv[++i];
    }else if( strncmp(z, "-parameters",n)==0 ){
      zParam = argv[++i];
    }else if( strncmp(z, "-trace",n)==0 ){
      enableTrace = 1;
    }else if( strncmp(z, "-verify",n)==0 ){
      verifyMode = 1;
    }else if( zScriptFile==0 ){
      zScriptFile = z;
    }else{
      fprintf(stderr, "%s: unknown argument: %s\n", argv[0], argv[i]);
      usage(argv[0]);
    }
  }

  rc = pEngine->xGetEngineName(pConn, &zDbEngine);
  if( rc ){
    fprintf(stderr, "%s: unable to get DB name from connection\n", argv[0]);
    exit(1);
  }

  /* Loop over all records in the file */
  while( (nErr==0 || !haltOnError) && findStartOfNextRecord(&sScript) ){
    int bSkip = 0; /* True if we should skip the current record. */

    /* Tokenizer the first line of the record.  This also records the
    ** line number of the first record in sScript.startLine */
    tokenizeLine(&sScript);

    bSkip = 0;

      bExpectOk = strcmp(sScript.azToken[1],"ok")==0;
      bExpectError = strcmp(sScript.azToken[1],"error")==0;

      /* Run the statement.  Remember the results 
      ** If we're expecting an error, pass true to suppress
      ** printing of any errors. 
      */
      if( enableTrace ) printf("%s;\n", zScript);
      rc = pEngine->xStatement(pConn, zScript, bExpectError);
      nCmd++;

      /* Check to see if we are expecting success or failure */
      if( bExpectOk ){
        /* do nothing if we expect success */
      }else if( bExpectError ){

        k += sScript.len;
      }
      zScript[k] = 0;

      /* Run the query */
      nResult = 0;
      azResult = 0;
      if( enableTrace ) printf("%s;\n", zScript);
      rc = pEngine->xQuery(pConn, zScript, sScript.azToken[1],
                           &azResult, &nResult);
      nCmd++;
      if( rc ){
        fprintf(stderr, "%s:%d: query failed\n",
                zScriptFile, sScript.startLine);
        pEngine->xFreeResults(pConn, azResult, nResult);