/*
      _______                           __  __    __    __                 
      \      \    ____   __ __ _______ |__||  |  |  |  |__|  ____    ____  
      /   |   \ _/ __ \ |  |  \\_  __ \|  ||  |  |  |  |  | /  _ \  /    \ 
     /    |    \\  ___/ |  |  / |  | \/|  ||  |__|  |__|  |(  <_> )|   |  \
     \____|__  / \___  >|____/  |__|   |__||____/|____/|__| \____/ |___|  /
    =========\/======\/=================================================\/==
  v0.01 04/JUL/2007 (C) Copyright 2007-2007 Scott D. Yelich SOME RIGHTS RESERVED
 .,-*~'`^`'~*-,._.,-*~'`^`'~*-,._.,-*~'`^`'~*-,._.-*~'`^`'~*-,._.,-*~'`^`'~*-,. 


  LICENSE:  Creative Commons Attribution 3.0 License.
  SEE:      http://creativecommons.org/licenses/by/3.0/


  Mon Aug 20 22:10:24 EDT 2007, v0.01 sdy

*/

/* g++ 5minutes_2.c -o 5minutes_2 -lsqlite3 */
/* g++ -Wall -O2 -static 5minutes_2.c -o 5minutes_2 -lsqlite3 */

/* SOURCE:  http://www.sqlite.org/quickstart.html */

//  C++

#include <iostream>

//  SQLITE3

#include <sqlite3.h>


  /*  http://www.sqlite.org/capi3ref.html#sqlite3_column_int

    Results Values From A Query:

    const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
    int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
    int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
    double sqlite3_column_double(sqlite3_stmt*, int iCol);
    int sqlite3_column_int(sqlite3_stmt*, int iCol);
    sqlite_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
    const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
    const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
    int sqlite3_column_type(sqlite3_stmt*, int iCol);
    sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);

    These routines return information about the information in a single
    column of the current result row of a query. In every case the first
    argument is a pointer to the SQL statement that is being evaluate (the
    sqlite_stmt* that was returned from sqlite3_prepare_v2() or one of its
    variants) and the second argument is the index of the column for which
    information should be returned. The left-most column has an index of 0.

    If the SQL statement is not currently point to a valid row, or if the
    the column index is out of range, the result is undefined.

    The sqlite3_column_type() routine returns datatype code for the
    initial data type of the result column. The returned value is one of
    SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, or
    SQLITE_NULL.

*/

bool headers = true; //  GLOBAL VARIABLE, YAY!

static int
process_row(sqlite3_stmt *stmt,   char sep = '|' )
{
  int ncols = sqlite3_column_count(stmt);
  int i;

  //  headers is a global var. 
  //  If this were an object, we could use an instance var.
  if ( headers ) { //  global! yay.
    // std::cout << ncols << std::endl;  //  can be deduced 
    for(i=0; i<ncols-1; i++){
      std::cout << (char *)sqlite3_column_name(stmt, i);
      std::cout << sep;
    }
    std::cout << (char *)sqlite3_column_name(stmt, i);
    std::cout << std::endl;
    headers = false;
  }

  for(i=0; i<ncols-1; i++){
    std::cout << (char *)sqlite3_column_text(stmt, i);
    std::cout << sep;
  }

  std::cout << (char *)sqlite3_column_text(stmt, i);
  std::cout << std::endl;
  return 0;
}

int
main(int argc, char **argv)
{
  sqlite3 *db;
  char *zErrMsg = 0;
  int rc;

  if (argc != 4) {
    std::cout << "Usage: " << argv[0] << " DATABASE table-name col-a-value" << std::endl; 
    exit(1);
  }

  rc = sqlite3_open(argv[1], &db);
  if (rc) {
    std::cout << "Can't open database: " << sqlite3_errmsg(db) << std::endl;
    sqlite3_close(db);
    exit(1);
  }

  //  _exec usage now deprecated? 19/AUG/2007
  //  rc = sqlite3_exec(db, argv[2], callback, 0, &zErrMsg);

  /*  From: http://www.sqlite.org/capi3ref.html#sqlite3_stmt

    The life of a statement object goes something like this:

    (1)  Create the object using sqlite3_prepare_v2() or a related function. 
    (2)  Bind values to host parameters using sqlite3_bind_* interfaces. 
    (3)  Run the SQL by calling sqlite3_step() one or more times. 
    (4)  Reset the statement using sqlite3_reset() then go back to step 2. Do this zero or more times. 
    (5)  Destroy the object using sqlite3_finalize().

  */

  sqlite3_stmt *stmt;

  std::string sql;

  sql = "SELECT rowid,* FROM `";
  sql.append(argv[2],strlen(argv[2])); //  can't bind a table name! argh.
  sql += "` WHERE `a` = ?";

  //  NULL is normally a ptr to the next sql statement ... but this 
  //  interface is only going to do a single statement.a
  //  rc = sqlite3_prepare(db, argv[2], strlen(argv[2], &stmt, NULL); // LEGACY INTERFACE
  rc = sqlite3_prepare_v2(db, sql.c_str(), strlen(sql.c_str()), &stmt, NULL);
  //if (SQLITE_OK != rc) throw "Cannot prepare sql";

  // argh, bind starts at 1!
//  sqlite3_bind_text(stmt, 1, argv[2], strlen(argv[2]), SQLITE_STATIC); // can't bind a table name, argh!

  // argh, bind starts at 1!
  sqlite3_bind_text(stmt, 1, argv[3], strlen(argv[3]), SQLITE_STATIC);

  /*  From:  http://www.sqlite.org/capi3ref.html#sqlite3_step

    The details of the behavior of this sqlite3_step() interface depend on
    whether the statement was prepared using the newer "v2" interface
    sqlite3_prepare_v2() and sqlite3_prepare16_v2() or the older legacy
    interface sqlite3_prepare() and sqlite3_prepare16(). The use of the
    new "v2" interface is recommended for new applications but the legacy
    interface will continue to be supported.

    In the lagacy interface, the return value will be either SQLITE_BUSY,
    SQLITE_DONE, SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE. With the "v2"
    interface, any of the other result code or extended result code might
    be returned as well.

    SQLITE_BUSY means that the database engine was unable to acquire the
    database locks it needs to do its job. If the statement is a COMMIT or
    occurs outside of an explicit transaction, then you can retry the
    statement. If the statement is not a COMMIT and occurs within a
    explicit transaction then you should rollback the transaction before
    continuing.

    SQLITE_DONE means that the statement has finished executing
    successfully. sqlite3_step() should not be called again on this
    virtual machine without first calling sqlite3_reset() to reset the
    virtual machine back to its initial state.

    If the SQL statement being executed returns any data, then SQLITE_ROW
    is returned each time a new row of data is ready for processing by the
    caller. The values may be accessed using the column access
    functions. sqlite3_step() is called again to retrieve the next row of
    data.

    SQLITE_ERROR means that a run-time error (such as a constraint
    violation) has occurred. sqlite3_step() should not be called again on
    the VM. More information may be found by calling
    sqlite3_errmsg(). With the legacy interface, a more specific error
    code (example: SQLITE_INTERRUPT, SQLITE_SCHEMA, SQLITE_CORRUPT, and so
    forth) can be obtained by calling sqlite3_reset() on the prepared
    statement. In the "v2" interface, the more specific error code is
    returned directly by sqlite3_step().

    SQLITE_MISUSE means that the this routine was called
    inappropriately. Perhaps it was called on a prepared statement that
    has already been finalized or on one that had previously returned
    SQLITE_ERROR or SQLITE_DONE. Or it could be the case that the same
    database connection is being used by two or more threads at the same
    moment in time.

  */

  bool process = true;
  while (process) {

    rc = sqlite3_step(stmt); // Execute the statement.

     switch (rc) {
       case SQLITE_DONE:
         process = false;
         break;
       case SQLITE_ROW:
         process_row(stmt);
         break;
       default:
         //  SQLITE_BUSY:  reset? to try again?
         std::cout << "sqlite_* error in switch: " << sqlite3_errmsg(db) << std::endl;
         process = false;
         break;
     }

  }

  rc = sqlite3_finalize(stmt);
  rc = sqlite3_close(db);

}