Fossil

  Th_register_commands( interp, aCommand );
}

#endif
/* end TH_USE_ARGV */

#ifdef TH_USE_SQLITE
#ifndef INTERFACE
#include "blob.h"
#endif

/*
** TH Syntax:
**
** query_prepare SQL
**
** Returns an opaque statement identifier.

  void *p, 
  int argc, 
  const char **argv, 
  int *argl
){
  sqlite3_stmt * pStmt = NULL;
  char const * val;

  int rc = 0;
  int index = -1;
  if( argc!=3 ){
    return Th_WrongNumArgs2(interp,
                            argv[0], argl[0],
                            "StmtHandle Index");
  }
  queryStmtIndexArgs(interp, argc, argv, argl, &pStmt, &index);
  if(index < 0){
    assert(NULL==pStmt);


    return TH_ERROR;
  }
  assert(NULL!=pStmt);
  val = sqlite3_column_name( pStmt, index );
  if(NULL==val){
    Th_ErrorMessage(interp, "Column index out of bounds(?):", argv[2], -1);
    return TH_ERROR;
  }else{
    Th_SetResult( interp, val, strlen( val ) );
    return TH_OK;
  }
}

static int queryColTimeCmd(
  Th_Interp *interp,
  void *ctx, 
  int argc, 
  const char **argv, 
  int *argl
){
  sqlite3_stmt * pStmt = NULL;
  char const * val;
  char * fval;
  int i, rc = 0;
  int index = -1;
  char const * fmt;
  Blob sql = empty_blob;
  if( argc<4 ){
    return Th_WrongNumArgs2(interp,
                            argv[0], argl[0],
                            "StmtHandle Index Format");
  }
  queryStmtIndexArgs(interp, argc, argv, argl, &pStmt, &index);
  if(index < 0){
    assert(NULL==pStmt);
    return TH_ERROR;
  }
  val = sqlite3_column_text( pStmt, index );
  fmt = argv[3];
  assert(NULL!=pStmt);
  blob_appendf(&sql,"SELECT strftime(%Q,%Q",
               fmt, val);
  if(argc>4){
    for(i = 4; i < argc; ++i ){
      blob_appendf(&sql, ",%Q", argv[i]);
    }
  }
  blob_append(&sql, ")", 1);
  fval = db_text(NULL,"%s", sql.aData);
  
  blob_reset(&sql);
  Th_SetResult( interp, fval, fval ? strlen(fval) : 0 );
  fossil_free(fval);
  return 0;
}

static int queryStrftimeCmd(
  Th_Interp *interp,
  void *ctx, 
  int argc, 
  const char **argv, 
  int *argl
){
  sqlite3_stmt * pStmt = NULL;
  char const * val;
  char * fval;
  int i, rc = 0;
  int index = -1;
  char const * fmt;
  Blob sql = empty_blob;
  if( argc<3 ){
    return Th_WrongNumArgs2(interp,
                            argv[0], argl[0],
                            "Format Value ?Modifiers...?");
  }
  fmt = argv[1];
  val = argv[2];
  blob_appendf(&sql,"SELECT strftime(%Q,%Q",
               fmt, val);
  if(argc>3){
    for(i = 3; i < argc; ++i ){
      blob_appendf(&sql, ",%Q", argv[i]);
    }
  }
  blob_append(&sql, ")", 1);
  fval = db_text(NULL,"%s", sql.aData);
  blob_reset(&sql);
  Th_SetResult( interp, fval, fval ? strlen(fval) : 0 );
  fossil_free(fval);
  return 0;
}


/*
** TH Syntax:
**
** query_bind_null stmtId Index
**
** Binds a value to the given 1-based parameter index.

  static Th_SubCommand aSub[] = {
    {"count",   queryColCountCmd},
    {"is_null", queryColIsNullCmd},
    {"name",    queryColNameCmd},
    {"double",  queryColDoubleCmd},
    {"int",     queryColIntCmd},
    {"string",  queryColStringCmd},
    {"time",    queryColTimeCmd},
    {"type",    queryColTypeCmd},
    {0, 0}
  };
  Th_CallSubCommand2( interp, ctx, argc, argv, argl, aSub );
}


static int queryTopLevelCmd(
  Th_Interp *interp,
  void *ctx, 
  int argc, 
  const char **argv, 
  int *argl
){
  static Th_SubCommand aSub[] = {
    {"bind",        queryBindTopLevelCmd},
    {"col",         queryColTopLevelCmd},
    {"step",        queryStepCmd},
    {"finalize",    queryFinalizeCmd},
    {"prepare",     queryPrepareCmd},
    {"strftime",    queryStrftimeCmd},
    {0, 0}
  };
  Th_CallSubCommand2( interp, ctx, argc, argv, argl, aSub );
}


int th_register_sqlite(Th_Interp *interp){
  enum { BufLen = 100 };
  char buf[BufLen];
  int i, l;
#define SET(K) l = snprintf(buf, BufLen, "%d", K);      \
  Th_SetVar( interp, #K, strlen(#K), buf, l );

<nowiki><pre>
for {} {0 &lt; [query step $stmt]} {} {
   puts [query col string $stmt 0] "\n"
}
</pre></nowiki>


<h2>strftime</h2>

This works like <tt>col time</tt> (described below) but takes its
value from an arbitrary source specified by the 3rd argument.

<nowiki><pre>
query strftime %s 1319211587 unixepoch
query strftime {%Y%m%d @ %H:%M:%S} [query col string $stmt 2] {+10 years}]
</pre></nowiki>


<h2>bind xxx</h2>

The <tt>bind xxx</tt> family of subcommands attach values to queries
before stepping through them. The subcommands include:

   *  <tt>bind int StmtId Index Value</tt>

values and metadata from result rows.

   *  <tt>col count StmtId</tt> Returns the number of result columns in the statement.
   *  <tt>col is_null StmtId Index</tt> Returns non-0 if the given column contains an SQL NULL value.
   *  <tt>col double StmtId Index</tt>
   *  <tt>col int StmtId Index</tt>
   *  <tt>col string StmtId Index</tt>
   *  <tt>col string StmtId Index Format Modifiers</tt> See below.
   *  <tt>col type StmtId Index</tt> Return value corresponds to one of the <tt>SQLITE_TYPENAME</tt> family of constants.

Achtung: the col API uses 0-based indexes, just like SQL does.

<h3>col time</h3>

This function is a proxy for sqlite3's
<tt>[http://www.sqlite.org/lang_datefunc.html|strftime()]</tt> function. It is used like this:


<nowiki><pre>
query col time $stmt $index {%Y%m%d @ %H:%M:%S}
</pre></nowiki>

Any remaining arguments are treated as "modifiers" and passed as-is to strfmtime. For example:

<nowiki><pre>
query col time $stmt $index {%Y%m%d @ %H:%M:%S} {+5 years}
query col time $stmt $index %s unixepoch
</pre></nowiki>