/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 
/* vim: set ts=2 et sw=2 tw=80: */
/*
** Copyright (c) 2013 D. Richard Hipp
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the Simplified BSD License (also
** known as the "2-Clause License" or "FreeBSD License".)
**
** This program is distributed in the hope that it will be useful,
** but without any warranty; without even the implied warranty of
** merchantability or fitness for a particular purpose.
**
** Author contact information:
**   drh@hwaci.com
**   http://www.hwaci.com/drh/
**
*******************************************************************************
** This file houses the db-related v2 APIs.
*/
#include "fossil/fossil.h"
#include "fsl_internal.h"
#include <assert.h>
#include <stddef.h> /* NULL on linux */
#include <time.h> /* time() */

#if defined(_WIN32)
# include <windows.h>
#else
# include <unistd.h> /* F_OK */
#endif

/* Only for debugging */
#define MARKER(pfexp)                                               \
  do{ printf("MARKER: %s:%d:%s():\t",__FILE__,__LINE__,__func__);   \
    printf pfexp;                                                   \
  } while(0)

static int fsl_cx_uplift_db_error( fsl_cx * f, fsl_db * db ){
  assert(f);
  if(!db) db = &f->dbMain;
  fsl_error_move( &db->error, &f->error );
  return f->error.code;
}


/*
** Resets db->error state based on the given code and the current
** error string from the driver.  Returns FSL_RC_DB on success, some
** other non-0 value on error (most likely FSL_RC_OOM while allocating
** the error string).
*/
static int fsl_err_from_db( fsl_db * db, int dbCode ){
  int rc;
  assert(db && db->dbh);
  db->error.msg.used =0 ;
  rc = fsl_buffer_appendf(&db->error.msg, "Db error #%d: %s",
                          dbCode, sqlite3_errmsg(db->dbh));
  return rc ? rc : FSL_RC_DB;
}

char const * fsl_db_filename(fsl_db const * db, fsl_size_t * len){
  if(!db || !db->dbh) return NULL;
  else{
    if(len) *len = db->filename.used;
    return (char const *)db->filename.mem;
  }
}

int fsl_db_close( fsl_db * db ){
  if(!db) return FSL_RC_MISUSE;
  else{
    void const * allocStamp = db->allocStamp;
    fsl_cx * f = db->f;
    if(0!=db->openStatementCount){
      MARKER(("WARNING: %d open statement(s) left on db [%.*s].\n",
              (int)db->openStatementCount, (int)db->filename.used,
              db->filename.mem));
    }
    if(db->dbh){
      sqlite3_close(db->dbh)
        /* ignoring result in the style of
           "destructors may not throw".
        */;
    }
    fsl_error_clean(&db->error);
    fsl_buffer_reserve(&db->filename, 0);
    *db = fsl_db_empty;
    if(&fsl_db_empty == allocStamp){
      fsl_free( db );
    }else{
      db->allocStamp = allocStamp;
      db->f = f;
    }
    return 0;
  }
}


int fsl_db_attach(fsl_db * db, const char *zDbName, const char *zLabel){
  return (db && db->dbh && zDbName && *zDbName && zLabel && *zLabel)
    ? fsl_db_exec(db, "ATTACH DATABASE %Q AS %s", zDbName, zLabel)
    : FSL_RC_MISUSE;
}

int fsl_db_detach(fsl_db * db, const char *zLabel){
  return (db && db->dbh && zLabel && *zLabel)
    ? fsl_db_exec(db, "DETACH DATABASE %s", zLabel)
    : FSL_RC_MISUSE;
}

/**
 ** Returns the db name for the given role.
 */
const char * fsl_db_role_label(int r){
  switch(r){
    case FSL_DB_ROLE_CONFIG:
      return "cfg";
    case FSL_DB_ROLE_REPO:
      return "repo";
    case FSL_DB_ROLE_CHECKOUT:
      return "ckout";
    case FSL_DB_ROLE_MAIN:
      return "main";
    case FSL_DB_ROLE_NONE:
    default:
      assert(!"cannot happen/not legal");
      return NULL;
  }
}

/**
 ** Returns one of f->file{Config,Repo,Ckout}, or f->dbMain.filename,
 ** or NULL.
 */
static fsl_buffer * fsl_cx_file_for_db_role(fsl_cx * f, fsl_db_role_t r){
  fsl_buffer * nameBuf = NULL;
  switch(r){
    case FSL_DB_ROLE_CONFIG:
      nameBuf = &f->fileConfig;
      break;
    case FSL_DB_ROLE_REPO:
      nameBuf = &f->fileRepo;
      break;
    case FSL_DB_ROLE_CHECKOUT:
      nameBuf = &f->fileCkout;
      break;
    case FSL_DB_ROLE_MAIN:
      nameBuf = &f->dbMain.filename;
    case FSL_DB_ROLE_NONE:
    default:
      break;
  }
  return nameBuf;
}

static int fsl_db_attach_role(fsl_cx * f, const char *zDbName, fsl_db_role_t r){
  char const * label = fsl_db_role_label(r);
  /* fsl_db * db = fsl_cx_db_for_role(f, r); */
  fsl_buffer * nameBuf = fsl_cx_file_for_db_role(f, r);
  int rc;
  if(!nameBuf) return FSL_RC_RANGE;
  /* assert(db); */
  assert(label);
  switch(r){
    case FSL_DB_ROLE_CONFIG:
    case FSL_DB_ROLE_REPO:
    case FSL_DB_ROLE_CHECKOUT:
      break;
    case FSL_DB_ROLE_MAIN:
    case FSL_DB_ROLE_NONE:
    default:
      assert(!"cannot happen/not legal");
      return FSL_RC_RANGE;
  }
  rc = fsl_db_attach(&f->dbMain, zDbName, label);
  if(rc){
    fsl_cx_uplift_db_error(f, NULL);
  }else{
    f->dbMain.role |= r;
    nameBuf->used = 0;
    fsl_buffer_append(nameBuf, zDbName, -1);
  }
  return rc;
}


static int fsl_db_detach_role(fsl_cx * f, fsl_db_role_t r){
  if(!f) return FSL_RC_MISUSE;
  else{
    fsl_buffer * fn = fsl_cx_file_for_db_role(f,r);
    if(!fn) return FSL_RC_RANGE;
    fsl_buffer_reserve(fn, 0);
    f->dbMain.role &= ~r;
    return fsl_db_detach( &f->dbMain, fsl_db_role_label(r) );
  }
}

int fsl_cx_repo_close( fsl_cx * f ){
  return fsl_db_detach_role(f, FSL_DB_ROLE_REPO);
}

int fsl_cx_config_close( fsl_cx * f ){
  return fsl_db_detach_role(f, FSL_DB_ROLE_CONFIG);
}

int fsl_cx_checkout_close( fsl_cx * f, char alsoCloseRepo ){
  if(!f) return FSL_RC_MISUSE;
  else if(!f->fileCkout.used) return FSL_RC_NOT_A_CHECKOUT;
  else{
    int rc;
    if(!alsoCloseRepo) fsl_cx_repo_close(f)
      /* Ignore error - it might not be opened. */
      ;
    fsl_buffer_reserve(&f->fileCkout, 0);
    rc = fsl_db_detach_role(f, FSL_DB_ROLE_CHECKOUT);
    return rc;
  }
}

/*
** This file contains the fsl_db_xxx() and fsl_stmt_xxx()
** parts of the API.
*/
int fsl_stmt_preparev( fsl_db *db, fsl_stmt * tgt, char const * sql, va_list args ){
  if(!db || !db->dbh || !tgt || !sql) return FSL_RC_MISUSE;
  else if(!*sql) return FSL_RC_RANGE;
  else if(tgt->stmt) return FSL_RC_ALREADY_EXISTS;
  else{
    int rc;
    fsl_buffer buf = fsl_buffer_empty;
    fsl_stmt_t * liteStmt = NULL;
    rc = fsl_buffer_appendfv( &buf, sql, args );
    if(!rc){
      sql = fsl_buffer_cstr(&buf);
      rc = sqlite3_prepare_v2(db->dbh, sql, (int)buf.used,
                              &liteStmt, 0);
      if(rc){
        rc = fsl_error_set(&db->error, FSL_RC_DB,
                           "Db statement preparation failed. "
                           "Error #%d: %s. SQL: %.*s",
                           rc, sqlite3_errmsg(db->dbh),
                           (int)buf.used, (char const *)buf.mem);
      }
    }
    if(!rc){
      ++db->openStatementCount;
      tgt->stmt = liteStmt;
      tgt->db = db;
      tgt->sql = buf /*transfer ownership*/;
      tgt->colCount = sqlite3_column_count(tgt->stmt);
      tgt->paramCount = sqlite3_bind_parameter_count(tgt->stmt);
    }else{
      assert(!liteStmt);
      fsl_buffer_reserve(&buf, 0);
    }
    return rc;
  }
}

int fsl_stmt_prepare( fsl_db *db, fsl_stmt * tgt, char const * sql, ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_stmt_preparev( db, tgt, sql, args );
  va_end(args);
  return rc;
}

int fsl_cx_prepare( fsl_cx *f, fsl_stmt * tgt, char const * sql,
                      ... ){
  if(!f) return FSL_RC_MISUSE;
  else{
    int rc;
    va_list args;
    va_start(args,sql);
    rc = fsl_stmt_preparev( &f->dbMain, tgt, sql, args );
    va_end(args);
    return rc;
  }
}

int fsl_cx_preparev( fsl_cx *f, fsl_stmt * tgt, char const * sql,
                       va_list args ){
  return (f && tgt)
    ? fsl_stmt_preparev(&f->dbMain, tgt, sql, args)
    : FSL_RC_MISUSE;
}


int fsl_stmt_finalize( fsl_stmt * stmt ){
  if(!stmt) return FSL_RC_MISUSE;
  else if(!stmt->stmt){
    assert(!stmt->sql.mem);
    return FSL_RC_MISUSE;
  }
  else{
    void const * allocStamp = stmt->allocStamp;
    assert(stmt->stmt);
    assert(stmt->db);
    fsl_buffer_reserve(&stmt->sql, 0);
    --stmt->db->openStatementCount;
    sqlite3_finalize( stmt->stmt );
    *stmt = fsl_stmt_empty;
    if(&fsl_stmt_empty==allocStamp){
      fsl_free(stmt);
    }else{
      stmt->allocStamp = allocStamp;
    }
    return 0;
  }
}

int fsl_stmt_step( fsl_stmt * stmt ){
  if(!stmt || !stmt->stmt) return FSL_RC_MISUSE;
  else{
    int const rc = sqlite3_step(stmt->stmt);
    assert(stmt->db);
    switch( rc ){
      case SQLITE_ROW:
        return FSL_RC_STEP_ROW;
      case SQLITE_DONE:
        return FSL_RC_STEP_DONE;
      default:
        fsl_error_set(&stmt->db->error, FSL_RC_STEP_ERROR,
                      "Db error #%d: %s",
                      rc, sqlite3_errmsg(stmt->db->dbh));
        return FSL_RC_STEP_ERROR;
    }
  }
}

int fsl_db_eachv( fsl_db * db, fsl_stmt_each_f callback,
                  void * callbackState, char const * sql, va_list args ){
  if(!db || !db->dbh || !callback || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(!rc){
      rc = fsl_stmt_each( &st, callback, callbackState );
      fsl_stmt_finalize( &st );
    }
    return rc;
  }
}

int fsl_db_each( fsl_db * db, fsl_stmt_each_f callback,
                 void * callbackState, char const * sql, ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_eachv( db, callback, callbackState, sql, args );
  va_end(args);
  return rc;
}

int fsl_stmt_each( fsl_stmt * stmt, fsl_stmt_each_f callback,
                   void * callbackState ){
  if(!stmt || !callback) return FSL_RC_MISUSE;
  else{
    int strc;
    int rc = 0;
    char doBreak = 0;
    while( !doBreak && (FSL_RC_STEP_ROW == (strc=fsl_stmt_step(stmt)))){
      rc = callback( stmt, callbackState );
      switch(rc){
        case 0: continue;
        case FSL_RC_BREAK:
          rc = 0;
          /* fall through */
        default:
          doBreak = 1;
          break;
      }
    }
    return rc
      ? rc
      : ((FSL_RC_STEP_ERROR==strc)
         ? FSL_RC_DB
         : 0);
  }
}

int fsl_stmt_reset( fsl_stmt * stmt ){
  if(!stmt || !stmt->stmt) return FSL_RC_MISUSE;
  else{
    int const rc = sqlite3_reset(stmt->stmt);
    assert(stmt->db);
    return rc
      ? fsl_err_from_db(stmt->db, rc)
      : 0;
  }
}

int fsl_stmt_col_count( fsl_stmt const * stmt ){
  return (!stmt || !stmt->stmt)
    ? -1
    : stmt->colCount
    ;
}

char const * fsl_stmt_col_name(fsl_stmt * stmt, int index){
  return (stmt && stmt->stmt && (index>=0 && index<stmt->colCount))
    ? sqlite3_column_name(stmt->stmt, index)
    : NULL;
}

int fsl_stmt_param_count( fsl_stmt const * stmt ){
  return (!stmt || !stmt->stmt)
    ? -1
    : stmt->paramCount;
}

#define BIND_PARAM_CHECK \
  if(!stmt || !stmt->stmt || !stmt->db) return FSL_RC_MISUSE; else
int fsl_stmt_bind_null( fsl_stmt * stmt, int ndx ){
  BIND_PARAM_CHECK {
    int const rc = sqlite3_bind_null( stmt->stmt, ndx );
    return rc ? fsl_err_from_db(stmt->db, rc) : 0;
  }
}

int fsl_stmt_bind_int32( fsl_stmt * stmt, int ndx, fsl_int32_t v ){
  BIND_PARAM_CHECK {
    int const rc = sqlite3_bind_int( stmt->stmt, ndx, (int)v );
    return rc ? fsl_err_from_db(stmt->db, rc) : 0;
  }
}

int fsl_stmt_bind_int64( fsl_stmt * stmt, int ndx, fsl_int64_t v ){
  BIND_PARAM_CHECK {
    int const rc = sqlite3_bind_int64( stmt->stmt, ndx, (sqlite3_int64)v );
    return rc ? fsl_err_from_db(stmt->db, rc) : 0;
  }
}

int fsl_stmt_bind_double( fsl_stmt * stmt, int ndx, fsl_double_t v ){
  BIND_PARAM_CHECK {
    int const rc = sqlite3_bind_double( stmt->stmt, ndx, (double)v );
    return rc ? fsl_err_from_db(stmt->db, rc) : 0;
  }
}

int fsl_stmt_bind_blob( fsl_stmt * stmt, int ndx, void const * src,
                        fsl_int_t len, char makeCopy ){
  BIND_PARAM_CHECK {
    int rc;
    if(len<0) len = fsl_strlen((char const *)src);
    rc = sqlite3_bind_blob( stmt->stmt, ndx, src, len,
                            makeCopy ? SQLITE_TRANSIENT : SQLITE_STATIC );
    return rc ? fsl_err_from_db(stmt->db, rc) : 0;
  }
}

int fsl_stmt_bind_text( fsl_stmt * stmt, int ndx, char const * src,
                        fsl_int_t len, char makeCopy ){
  BIND_PARAM_CHECK {
    int rc;
    if(len<0) len = fsl_strlen((char const *)src);
    rc = sqlite3_bind_text( stmt->stmt, ndx, src, len,
                            makeCopy ? SQLITE_TRANSIENT : SQLITE_STATIC );
    return rc ? fsl_err_from_db(stmt->db, rc) : 0;
  }
}

#undef BIND_PARAM_CHECK

#define GET_CHECK if(!stmt || !stmt->colCount) return FSL_RC_MISUSE; \
  else if((ndx<0) || (ndx>=stmt->colCount)) return FSL_RC_RANGE; else

int fsl_stmt_get_int32( fsl_stmt * stmt, int ndx, fsl_int32_t * v ){
  GET_CHECK {
    if(v) *v = (fsl_int32_t)sqlite3_column_int(stmt->stmt, ndx);
    return 0;
  }
}
int fsl_stmt_get_int64( fsl_stmt * stmt, int ndx, fsl_int64_t * v ){
  GET_CHECK {
    if(v) *v = (fsl_int64_t)sqlite3_column_int64(stmt->stmt, ndx);
    return 0;
  }
}

int fsl_stmt_get_double( fsl_stmt * stmt, int ndx, fsl_double_t * v ){
  GET_CHECK {
    if(v) *v = (fsl_double_t)sqlite3_column_double(stmt->stmt, ndx);
    return 0;
  }
}

int fsl_stmt_get_text( fsl_stmt * stmt, int ndx, char const **out,
                       fsl_int_t * outLen ){
  GET_CHECK {
    unsigned char const * t = (out || outLen)
      ? sqlite3_column_text(stmt->stmt, ndx)
      : NULL;
    if(out) *out = (char const *)t;
    if(outLen) *outLen = t ? sqlite3_column_bytes(stmt->stmt, ndx) : 0;
    return 0;
  }
}

int fsl_stmt_get_blob( fsl_stmt * stmt, int ndx, void const **out,
                       fsl_int_t * outLen ){
  GET_CHECK {
    void const * t = (out || outLen)
      ? sqlite3_column_blob(stmt->stmt, ndx)
      : NULL;
    if(out) *out = (char const *)t;
    if(outLen) *outLen = t ? sqlite3_column_bytes(stmt->stmt, ndx) : 0;
    return 0;
  }
}

#undef GET_CHECK

static void fsl_db_sql_trace(void *fslCtx, const char *zSql){
  int const n = fsl_strlen(zSql);
  static int counter = 0;
  /* FIXME: in v1 this uses fossil_trace(), but don't have
     that functionality here yet. */
  fsl_outputf((fsl_cx*)fslCtx,
              "SQL TRACE #%d: %s%s\n", ++counter,
              zSql, (n>0 && zSql[n-1]==';') ? "" : ";");
}

/*
** SQL functions for debugging.
**
** The print() function writes its arguments to fsl_output(), but only
** if the -sqlprint command-line option is turned on.
*/
static void fsl_db_sql_print(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  fsl_cx * f = (fsl_cx*)sqlite3_user_data(context);
  assert(f);
  if( f->config.sqlPrint ){
    int i;
    for(i=0; i<argc; i++){
      char c = i==argc-1 ? '\n' : ' ';
      fsl_outputf(f, "%s%c", sqlite3_value_text(argv[i]), c);
    }
  }
}

/*
** Function to return the number of seconds since 1970.  This is
** the same as strftime('%s','now') but is more compact.
*/
static void fsl_db_now_function(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  sqlite3_result_int64(context, (sqlite3_int64)time(0));
}

/*
** Function to return the check-in time for a file.
*/
static void fsl_db_checkin_mtime_function(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
#if 0
  /* TODO, once we can parse manifests. */
  fsl_time_t mtime;
  int rc = mtime_of_manifest_file(sqlite3_value_int(argv[0]),
                                  sqlite3_value_int(argv[1]), &mtime);
  if( rc==0 ){
    sqlite3_result_int64(context, (sqlite_int64)mtime);
  }
#endif
}

/*
** Implement the user() SQL function.  user() takes no arguments and
** returns the user ID of the current user.
*/
static void fsl_db_sql_user(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
#if 0
  if( g.zLogin!=0 ){
    sqlite3_result_text(context, g.zLogin, -1, SQLITE_STATIC);
  }
#else
  sqlite3_result_text(context, "FIXME: missing g.zLogin info", -1, SQLITE_STATIC);
#endif
}

/*
** Returns non-0 (true) if the given SQL would result
** in at least one result row, else 0 (false).
*/
char fsl_db_val_exists( fsl_db * db, char const * sql, ...){
  fsl_stmt st = fsl_stmt_empty;
  int rc;
  va_list args;
  if(!db || !sql) return 0;
  va_start(args,sql);
  rc = fsl_stmt_preparev( db, &st, sql, args );
  va_end(args);
  if(rc) return 0;
  else{
    rc = (FSL_RC_STEP_ROW == fsl_stmt_step(&st)) ? 1 : 0;
    fsl_stmt_finalize( &st );
    return rc;
  }
}

/*
** Return TRUE if the schema is out-of-date
*/
int fsl_db_schema_is_outofdate(fsl_db *db){
  return fsl_db_val_exists(db, "SELECT 1 FROM config "
                           "WHERE name='aux-schema' "
                           "AND value<>'%s'",
                           FSL_AUX_SCHEMA);
}


/*
** Returns - if db appears to be a current repository,
** 1 if it appears to have an out of date schema, and
** -1 if it appears to not be a repository.
*/
int fsl_cx_repo_verify_schema(fsl_db * db){
  if(fsl_db_schema_is_outofdate(db)) return 1;
  else return fsl_db_val_exists(db,
                                "SELECT 1 FROM config "
                                "WHERE name='project-code'")
    ? 0 : -1;
}

fsl_db * fsl_db_malloc(){
  fsl_db * rc = (fsl_db *)fsl_malloc(sizeof(fsl_db));
  if(rc){
    *rc = fsl_db_empty;
    rc->allocStamp = &fsl_db_empty;
  }
  return rc;
}

fsl_stmt * fsl_stmt_malloc(){
  fsl_stmt * rc = (fsl_stmt *)fsl_malloc(sizeof(fsl_stmt));
  if(rc){
    *rc = fsl_stmt_empty;
    rc->allocStamp = &fsl_stmt_empty;
  }
  return rc;
}


/*
** Analog to v1's db_open_or_attach().
**
** This function is still very much up for reconsideration. i'm not
** terribly happy with the "db roles" here - i'd prefer to have
** them each in their own struct, but understand that the roles may
** play a part in query generation, so i haven't yet ruled
** them out.
**
**
** Opens or attaches the given db file. zDbName is the
** file name of the DB. role is the role of that db
** in the framework (that determines its db name in SQL).
**
** The first time this is called, f->dbMain is set to point
** to fsl_cx_db_for_role(f, role).
**
** If f->dbMain is already set then the db is attached using a
** role-dependent name.
**
** If f->dbMain is not opened then it is opened here and its
** role is set to the given role.
**
** the given db zDbName is the name of a database file.  If f->dbMain is not opened
** then that db is assigned to the given db file, otherwise
** attach attach zDbName using the name zLabel.
**
** If pWasAttached is not NULL then it is set to a true value if the
** db gets attached, else a false value. It is only modified on success.
**
** It is an error to open the same db role more than once, and trying
** to do so results in a FSL_RC_ACCESS error (f's error state is
** updated).
*/
#if 0
static
int fsl_cx_db_main_open_or_attach( fsl_cx * f,
                                   const char *zDbName,
                                   /* const char *zLabel, */
                                   fsl_db_role_t role,
                                   int *pWasAttached){
  int rc;
  int wasAttached = 0;
  fsl_db * db;
  assert(f);
  assert(zDbName && *zDbName);
  assert((FSL_DB_ROLE_CONFIG==role)
         || (FSL_DB_ROLE_CHECKOUT==role)
         || (FSL_DB_ROLE_REPO==role));
  if(!f || !zDbName) return FSL_RC_MISUSE;
  else if((FSL_DB_ROLE_NONE==role) || !*zDbName) return FSL_RC_RANGE;
  db = fsl_cx_db_for_role(f, role);
  assert(db);
  try_again:
  if(!f->dbMain) {
    assert( FSL_DB_ROLE_NONE==db->role );
    assert( NULL==db->dbh );
    f->dbMain = db;
    db->f = f;
    db->role = role;
    rc = fsl_db_open( db, zDbName, FSL_OPEN_F_RW );
    /* g.db = fsl_db_open(zDbName); */
    /* g.zMainDbType = zLabel; */
    /* f->mainDbType = zLabel; */
    /* f->dbMain.role = FSL_DB_ROLE_MAIN; */
  }else{
    assert( FSL_DB_ROLE_NONE!=db->role );
    assert( f == db->f );
    if(NULL == f->dbMain->dbh){
      /* It was closed in the meantime. Re-assign dbMain... */
      MARKER(("Untested: re-assigning f->dbMain after it has been closed.\n"));
      f->dbMain = NULL;
      goto try_again;
    }
    if(role == db->role){
      return fsl_cx_err_set(f, FSL_RC_ACCESS,
                            "Cannot open/attach db role "
                            "#%d (%s) more than once.",
                            role, fsl_db_role_label(role));
    }
    rc = fsl_db_attach_role(f, zDbName,
                            fsl_db_role_label(role) );
    wasAttached = 1;
  }
  if(!rc){
    if(pWasAttached) *pWasAttached = wasAttached;
  }else if(db->error.code){
    /* Uplift db's error state into f so we don't lose it
       when we close the db here...
    */
    fsl_error_move(&db->error, &f->error);
    fsl_db_close(db);
    assert(!f->dbMain->dbh);
    f->dbMain = NULL;
  }
  return rc;
}
#endif

const char *fsl_cx_main_db_name(fsl_cx const * f){
  return (f && f->dbMain.dbh)
    ? fsl_db_role_label(f->dbMain.role)
    : NULL;
}

/*
* If zDbName is a valid local database file, open it and return
** 0.  If it is not a valid local database file, return a non-0
** code.
*/
static int fsl_cx_is_valid_checkout_db(fsl_cx * f, const char *zDbName){
  fsl_int64_t lsize;
  /* char *zVFileDef; */
  int rc;
  lsize = fsl_file_size(zDbName);
  if( lsize < 0  ){
    return FSL_RC_NOT_FOUND /* FSL_RC_ACCESS? */;
  }
  if( lsize%1024!=0 || lsize<4096 ) return FSL_RC_RANGE;
#if 1
  rc = fsl_db_attach_role(f, zDbName, FSL_DB_ROLE_CHECKOUT);
#else
  rc = fsl_cx_db_main_open_or_attach(f, zDbName,
                                     FSL_DB_ROLE_CHECKOUT,
                                     NULL);
#endif
  if(rc){
    fsl_cx_uplift_db_error(f, NULL);
  }
  return rc;
#if 0
  /* Historical bits: no longer needed(?). */

  zVFileDef = fsl_db_text(0, "SELECT sql FROM %s.sqlite_master"
                          " WHERE name=='vfile'",
                          fsl_cx_db_name("localdb")); /* ==> "ckout" */
  if( zVFileDef==0 ) return 0;

  /* If the "isexe" column is missing from the vfile table, then
  ** add it now.   This code added on 2010-03-06.  After all users have
  ** upgraded, this code can be safely deleted.
  */
  if( !fsl_str_glob("* isexe *", zVFileDef) ){
    fsl_db_multi_exec("ALTER TABLE vfile ADD COLUMN isexe BOOLEAN DEFAULT 0");
  }

  /* If "islink"/"isLink" columns are missing from tables, then
  ** add them now.   This code added on 2011-01-17 and 2011-08-27.
  ** After all users have upgraded, this code can be safely deleted.
  */
  if( !fsl_str_glob("* islink *", zVFileDef) ){
    db_multi_exec("ALTER TABLE vfile ADD COLUMN islink BOOLEAN DEFAULT 0");
    if( db_local_table_exists_but_lacks_column("stashfile", "isLink") ){
      db_multi_exec("ALTER TABLE stashfile ADD COLUMN isLink BOOL DEFAULT 0");
    }
    if( db_local_table_exists_but_lacks_column("undo", "isLink") ){
      db_multi_exec("ALTER TABLE undo ADD COLUMN isLink BOOLEAN DEFAULT 0");
    }
    if( db_local_table_exists_but_lacks_column("undo_vfile", "islink") ){
      db_multi_exec("ALTER TABLE undo_vfile ADD COLUMN islink BOOL DEFAULT 0");
    }
  }
#endif
  return 0;
}

int fsl_db_open( fsl_db * db, char const * dbFile,
                 int openFlags ){
  int rc;
  fsl_dbh_t * dbh = NULL;
  if(!db || !dbFile || !*dbFile) return FSL_RC_MISUSE;
  else if(db->dbh) return FSL_RC_MISUSE;
  else if(!(FSL_OPEN_F_NOT_FOUND_OK & openFlags)
          && !(FSL_OPEN_F_CREATE & openFlags)
          && fsl_file_access(dbFile, 0)){
    /* MARKER(("Error msg: %s\n", (char const *)db->error.msg.mem)); */
    return FSL_RC_NOT_FOUND;
  }
  else{
    int sOpenFlags = 0;
    if(FSL_OPEN_F_RW & openFlags){
      sOpenFlags |= SQLITE_OPEN_READWRITE;
    }
    if(FSL_OPEN_F_CREATE & openFlags){
      sOpenFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
    }
    if(!sOpenFlags) sOpenFlags = SQLITE_OPEN_READONLY;
    if(0==fsl_strcmp(dbFile,":memory:")){
      sOpenFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
    }
    rc = sqlite3_open_v2( dbFile, &dbh, sOpenFlags, NULL );
    if(rc){
      if(dbh){
        /* By some complete coincidence, FSL_RC_DB==SQLITE_CANTOPEN. */
        rc = fsl_error_set(&db->error, FSL_RC_DB,
                           "Opening db file [%s] failed with "
                           "sqlite code #%d: %s",
                           dbFile, rc, sqlite3_errmsg(dbh));
      }else{
        rc = fsl_error_set(&db->error, FSL_RC_DB,
                           "Opening db file [%s] failed with "
                           "sqlite code #%d",
                           dbFile, rc);
      }
      /* MARKER(("Error msg: %s\n", (char const *)db->error.msg.mem)); */
      goto end;
    }else{
      assert(0==db->filename.used);
      rc = (':'==*dbFile)/* assume ":memory:" or some such: don't canonicalize it. */
        ? fsl_buffer_append(&db->filename, dbFile, -1)
        : fsl_file_canonical_name(dbFile, &db->filename, 0);
      if(rc){
        assert((FSL_RC_OOM==rc) && "That's the only logical explanation.");
        goto end;
      }
    }
    db->dbh = dbh;
    if(FSL_OPEN_F_SCHEMA_VALIDATE & openFlags){
      int check;
      check = fsl_cx_repo_verify_schema(db);
      if(0 != check){
        rc = (check<0)
          ? fsl_error_set(&db->error, FSL_RC_NOT_A_REPO,
                            "DB file [%s] does not appear to be "
                          "a repository.", dbFile)
          : fsl_error_set(&db->error, FSL_RC_REPO_NEEDS_REBUILD,
                          "DB file [%s] appears to be a fossil "
                          "repsitory, but is out-of-date and needs "
                          "a rebuild.",
                          dbFile)
          ;
        assert(rc == db->error.code);
        goto end;
      }
    }
    if(db->f){
      fsl_cx * f = db->f;
      if( f->config.traceSql ){
        sqlite3_trace(dbh, fsl_db_sql_trace, f);
      }
#if 0
      if(FSL_DB_ROLE_NONE!=db->role){
        rc = fsl_buffer_append(&db->name, fsl_db_role_label(db->role), -1);
        if(rc) goto end;
      }
#endif
      /* This all comes from db.c:db_open()... */
      /* FIXME: check result codes here. */
      sqlite3_busy_timeout(dbh, 5000 /* historical value */);
      sqlite3_wal_autocheckpoint(dbh, 1);  /* Set to checkpoint frequently */
      sqlite3_exec(dbh, "PRAGMA foreign_keys=OFF;", 0, 0, 0);
      sqlite3_create_function(dbh, "now", 0, SQLITE_ANY, 0,
                              fsl_db_now_function, 0, 0);
      sqlite3_create_function(dbh, "checkin_mtime", 2, SQLITE_ANY, f,
                              fsl_db_checkin_mtime_function, 0, 0);
      sqlite3_create_function(dbh, "user", 0, SQLITE_ANY, f,
                              fsl_db_sql_user, 0, 0);
      sqlite3_create_function(dbh, "print", -1, SQLITE_UTF8, f,
                              fsl_db_sql_print,0,0);
#if 0
      /* functions registered in v1 by db.c:db_open(). */
      /* porting cgi() requires access to the HTTP/CGI layer. i.e. this belongs
         downstream. */
      sqlite3_create_function(dbh, "cgi", 1, SQLITE_ANY, 0, db_sql_cgi, 0, 0);
      sqlite3_create_function(dbh, "cgi", 2, SQLITE_ANY, 0, db_sql_cgi, 0, 0);
    
      /*
        i[sf]_selected() both require access to the array of file
        names being considered for commit: g.aCommitFile[]
      */
      sqlite3_create_function(dbh, "is_selected", 1, SQLITE_UTF8, f,
                              file_is_selected,0,0 );
      sqlite3_create_function(dbh, "if_selected", 3, SQLITE_UTF8, f,
                              file_is_selected,0,0 );
      re_add_sql_func(db) /* Requires the regex bits. */;
#endif
    }/*if(db->f)*/
    end:
    if(rc){
#if 0
      assert(db->error.code);
      if(db->f && !db->f->error.code && db->error.code){
        /* VERY ARGUABLE: Adopt db's error state as f's. */
        fsl_error_move(&db->error, &db->f->error);
      }
#endif
      /* fsl_db_close(db); */
    }

  }
#if 1
  {
    fsl_buffer can = fsl_buffer_empty;
    fsl_file_canonical_name( dbFile, &can, 0 );
    /* MARKER(("Canonical name: [%s] => [%s]\n", dbFile, fsl_buffer_cstr(&can))); */
    fsl_buffer_reserve(&can, 0);
  }
#endif
  assert(db->dbh);
  return rc;
}

int fsl_db_exec_multiv( fsl_db * db, const char * sql, va_list args){
  if(!db || !db->dbh || !sql) return FSL_RC_MISUSE;
  else{
    fsl_buffer buf = fsl_buffer_empty;
    int rc = 0;
    char const * z;
    char const * zEnd = NULL;
    rc = fsl_buffer_appendfv( &buf, sql, args );
    if(rc) return rc;
    z = fsl_buffer_cstr(&buf);
    while( (SQLITE_OK==rc) && *z ){
      fsl_stmt_t * pStmt = NULL;
      rc = sqlite3_prepare_v2(db->dbh, z, buf.used, &pStmt, &zEnd);
      if( SQLITE_OK != rc ) break;
      if(pStmt){
        while( SQLITE_ROW == sqlite3_step(pStmt) ){}
        rc = sqlite3_finalize(pStmt);
        if(rc) rc = fsl_err_from_db(db, rc);
      }
      buf.used -= (zEnd-z);
      z = zEnd;
    }
    fsl_buffer_reserve(&buf, 0);
    return rc;
  }
}

int fsl_db_exec_multi( fsl_db * db, const char * sql, ...){
  if(!db || !db->dbh || !sql) return FSL_RC_MISUSE;
  else{
    int rc;
    va_list args;
    va_start(args,sql);
    rc = fsl_db_exec_multiv( db, sql, args );
    va_end(args);
    return rc;
  }
}

int fsl_db_execv( fsl_db * db, const char * sql, va_list args){
  if(!db || !db->dbh || !sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    /* rc = fsl_stmt_step( &st ); */
    while(FSL_RC_STEP_ROW == (rc=fsl_stmt_step(&st))){}
    fsl_stmt_finalize(&st);
    return (FSL_RC_STEP_ERROR==rc)
      ? FSL_RC_DB
      : 0;
  }
}

int fsl_db_exec( fsl_db * db, const char * sql, ...){
  if(!db || !db->dbh || !sql) return FSL_RC_MISUSE;
  else{
    int rc;
    va_list args;
    va_start(args,sql);
    rc = fsl_db_execv( db, sql, args );
    va_end(args);
    return rc;
  }
}


int fsl_db_get_int32v( fsl_db * db, fsl_int32_t * rv,
                       char const * sql, va_list args){
  /* Potential fixme: the fsl_db_get_XXX() funcs are 95%
     code duplicates. We "could" replace these with a macro
     or supermacro, though the latter would be problematic
     in the context of an amalgamation build.
  */
  if(!db || !db->dbh || !rv || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    rc = fsl_stmt_step( &st );
    switch(rc){
      case FSL_RC_STEP_ROW:
        *rv = sqlite3_column_int(st.stmt, 0);
        /* Fall through */
      case FSL_RC_STEP_DONE:
        rc = 0;
        break;
      default:
        assert(FSL_RC_STEP_ERROR==rc);
        break;
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_get_int32( fsl_db * db, fsl_int32_t * rv,
                      char const * sql,
                      ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_get_int32v(db, rv, sql, args);
  va_end(args);
  return rc;
}

int fsl_db_get_int64v( fsl_db * db, fsl_int64_t * rv,
                       char const * sql, va_list args){
  if(!db || !db->dbh || !rv || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    rc = fsl_stmt_step( &st );
    switch(rc){
      case FSL_RC_STEP_ROW:
        *rv = sqlite3_column_int64(st.stmt, 0);
        /* Fall through */
      case FSL_RC_STEP_DONE:
        rc = 0;
        break;
      default:
        assert(FSL_RC_STEP_ERROR==rc);
        break;
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_get_int64( fsl_db * db, fsl_int64_t * rv,
                      char const * sql, ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_get_int64v(db, rv, sql, args);
  va_end(args);
  return rc;
}


int fsl_db_get_doublev( fsl_db * db, fsl_double_t * rv,
                       char const * sql, va_list args){
  if(!db || !db->dbh || !rv || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    rc = fsl_stmt_step( &st );
    switch(rc){
      case FSL_RC_STEP_ROW:
        *rv = sqlite3_column_double(st.stmt, 0);
        /* Fall through */
      case FSL_RC_STEP_DONE:
        rc = 0;
        break;
      default:
        assert(FSL_RC_STEP_ERROR==rc);
        break;
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_get_double( fsl_db * db, fsl_double_t * rv,
                      char const * sql,
                      ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_get_doublev(db, rv, sql, args);
  va_end(args);
  return rc;
}


int fsl_db_get_textv( fsl_db * db, char ** rv,
                      fsl_size_t *rvLen,
                      char const * sql, va_list args){
  if(!db || !db->dbh || !rv || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    rc = fsl_stmt_step( &st );
    switch(rc){
      case FSL_RC_STEP_ROW:{
        char const * str = (char const *)sqlite3_column_text(st.stmt, 0);
        int const len = sqlite3_column_bytes(st.stmt,0);
        char * x = fsl_mprintf("%.*s", len, str);
        if(!x) return FSL_RC_OOM;
        *rv = x;
        if(rvLen) *rvLen = (fsl_size_t)len;
        rc = 0;
        break;
      }
      case FSL_RC_STEP_DONE:
        rc = 0;
        break;
      default:
        assert(FSL_RC_STEP_ERROR==rc);
        break;
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_get_text( fsl_db * db, char ** rv,
                     fsl_size_t * rvLen,
                     char const * sql, ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_get_textv(db, rv, rvLen, sql, args);
  va_end(args);
  return rc;
}

int fsl_db_get_blobv( fsl_db * db, void ** rv,
                      fsl_size_t *rvLen,
                      char const * sql, va_list args){
  if(!db || !db->dbh || !rv || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    rc = fsl_stmt_step( &st );
    switch(rc){
      case FSL_RC_STEP_ROW:{
        char const * str = (char const *)sqlite3_column_blob(st.stmt, 0);
        int const len = sqlite3_column_bytes(st.stmt,0);
        char * x = fsl_mprintf("%.*s", len, str);
        if(!x) return FSL_RC_OOM;
        *rv = x;
        if(rvLen) *rvLen = (fsl_size_t)len;
        rc = 0;
        break;
      }
      case FSL_RC_STEP_DONE:
        rc = 0;
        break;
      default:
        assert(FSL_RC_STEP_ERROR==rc);
        break;
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_get_blob( fsl_db * db, void ** rv,
                     fsl_size_t * rvLen,
                     char const * sql, ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_get_blobv(db, rv, rvLen, sql, args);
  va_end(args);
  return rc;
}

int fsl_db_get_bufferv( fsl_db * db, fsl_buffer * b,
                        char asBlob, char const * sql,
                        va_list args){
  if(!db || !db->dbh || !b || !sql || !*sql) return FSL_RC_MISUSE;
  else{
    fsl_stmt st = fsl_stmt_empty;
    int rc = 0;
    rc = fsl_stmt_preparev( db, &st, sql, args );
    if(rc) return rc;
    rc = fsl_stmt_step( &st );
    switch(rc){
      case FSL_RC_STEP_ROW:{
        void const * str = asBlob
          ? sqlite3_column_blob(st.stmt, 0)
          : (void const *)sqlite3_column_text(st.stmt, 0);
        int const len = sqlite3_column_bytes(st.stmt,0);
        rc = 0;
        b->used = 0;
        rc = fsl_buffer_append( b, str, len );
        break;
      }
      case FSL_RC_STEP_DONE:
        rc = 0;
        break;
      default:
        assert(FSL_RC_STEP_ERROR==rc);
        break;
    }
    fsl_stmt_finalize(&st);
    return rc;
  }
}

int fsl_db_get_buffer( fsl_db * db, fsl_buffer * b,
                       char asBlob,
                       char const * sql, ... ){
  int rc;
  va_list args;
  va_start(args,sql);
  rc = fsl_db_get_bufferv(db, b, asBlob, sql, args);
  va_end(args);
  return rc;
}



fsl_db * fsl_cx_db_config( fsl_cx * f ){
  return (f && f->dbMain.dbh && f->fileConfig.used) ? &f->dbMain : NULL;
}
fsl_db * fsl_cx_db_repo( fsl_cx * f ){
  return (f && f->dbMain.dbh && f->fileRepo.used) ? &f->dbMain : NULL;
}
fsl_db * fsl_cx_db_checkout( fsl_cx * f ){
  return (f && f->dbMain.dbh && f->fileCkout.used) ? &f->dbMain : NULL;
}

fsl_db * fsl_cx_db( fsl_cx * f ){
  return f ? &f->dbMain : NULL;
}


int fsl_cx_config_open( fsl_cx * f, char const * openDbName ){
  int rc = 0;
  char const *zDbName = NULL;
  /* char useAttach = 0 */ /* TODO? Move this into a parameter? Do we need the v1 behaviour? */;
  fsl_buffer dbPath = fsl_buffer_empty;
  if(!f) return FSL_RC_MISUSE;
  else if(f->fileConfig.used){
    fsl_db_detach_role(f, FSL_DB_ROLE_CONFIG);
  }

  if(openDbName && *openDbName){
    zDbName = openDbName;
  }else{
    rc = fsl_find_home_dir( &dbPath, 1 );
    if(!rc){
      char const * dbName =
#if defined(_WIN32) || defined(__CYGWIN__)
        /* . filenames give some window systems problems and many apps problems */
        "_fossil"
#else
        ".fossil"
#endif
        ;
      rc = fsl_buffer_appendf(&dbPath, "/%s", dbName);
      if(rc){
        rc = fsl_cx_err_set(f, rc, "%.*s", (int)dbPath.used, fsl_buffer_cstr(&dbPath));
        fsl_buffer_reserve(&dbPath, 0);
        return rc;
      }
    }
    assert(dbPath.used);
    zDbName = fsl_buffer_cstr(&dbPath);
  }

#if 0
  if( fsl_file_size(zDbName)<1024*3 ){
    /* TODO: port in db init code. Consider doing the
       init AFTER opening it, so that we can pipe the
       input into fsl_db_multi_exec(). The v1 approach
       opens the config db twice for this case.

       We need to move away from v1's habit of holding the
       schema as a large C-string because C does not guaranty
       that unbounded sizes are legal (and fossil regularly
       exceeds that limit).

       http://stackoverflow.com/questions/11488616/why-is-max-length-of-c-string-literal-different-from-max-char
       
       http://msdn.microsoft.com/en-us/library/sx08afx2.aspx

       Says:
       
       "ANSI compatibility requires a compiler to accept up to 509
       characters in a string literal after concatenation."

       Supposedly (see first link) C99 increases that minimum to 4k.

       Instead, we can store the schema in an SQL file and compile it
       in as a static const char[].

       Or... probably simpler... we pack the SQL into

       static const char[][] = { "...", "...", "..." }

       and hope we don't hit the limit for individual chunks, e.g.
       CREATE TABLE parts?
    */
    db_init_database(zDbName, zConfigSchema, (char*)0);
  }
#endif

  
#if defined(_WIN32) || defined(__CYGWIN__)
  if( fsl_file_access(zDbName, W_OK) ){
    rc = fsl_cx_err_set(f, FSL_RC_ACCESS,
                        "Configuration database [%s] "
                        "must be writeable.", zDbName);
    fsl_buffer_reserve(&dbPath,0);
    return rc;
  }
#endif


#if 1
  rc = fsl_db_attach_role(f, zDbName, FSL_DB_ROLE_CONFIG);
#else
  if( useAttach ){
    rc = fsl_db_attach_role(f, zDbName, FSL_DB_ROLE_CONFIG);
  }else{
    rc = fsl_db_open(&f->dbConfig, zDbName, FSL_OPEN_F_RWC );
  }
#endif
  fsl_buffer_reserve(&dbPath,0);
  /* g.zConfigDbName = zDbName; */
  return rc;
}

int fsl_cx_repo_open_db( fsl_cx * f, char const * repoDbFile,
                      int openFlags ){
  if(!f || !repoDbFile || !*repoDbFile) return FSL_RC_MISUSE;
  else if(f->fileRepo.used){
    return fsl_cx_err_set(f, FSL_RC_ACCESS,
                          "Context already has an opened repository.");
  }
  else {
    int rc;
    /* fsl_db * db = &f->dbRepo; */
    /* db->f = f; */
    if(0!=fsl_file_access( repoDbFile, F_OK )){
      return fsl_cx_err_set(f, FSL_RC_NOT_FOUND,
                            "Repository db [%s] not found.",
                            repoDbFile);
    }
    if(!openFlags){
      openFlags = FSL_OPEN_F_RW | FSL_OPEN_F_SCHEMA_VALIDATE;
    }
    /* fsl_cx_err_set(f, 0, NULL); */
    /* rc = fsl_db_open( db, repoDbFile, openFlags ); */
    rc = fsl_db_attach_role(f, repoDbFile, FSL_DB_ROLE_REPO);
#if 0
    if(rc && !f->error.code && db->error.code){
      /* Adopt db's error state as our own. */
      fsl_error_move(&db->error, &f->error);
    }
#endif
    return rc;
  }
}

/**
 ** Tries to open the repository which from which the current checkout
 ** derives.  Returns 0 on success.
 */
static int fsl_cx_repo_open_for_checkout(fsl_cx * f){
  char * repoDb = NULL;
  int rc;
  fsl_buffer nameBuf = fsl_buffer_empty;
  assert(f);
  assert(f->dirCkout.used);
  rc = fsl_db_get_text(&f->dbMain, &repoDb, NULL,
                       "SELECT %B || '/' || value FROM %s.vvar "
                       "WHERE name='repository'",
                       &f->dirCkout,
                       fsl_db_role_label(FSL_DB_ROLE_CHECKOUT));

  if(rc) fsl_cx_uplift_db_error( f, NULL );
  else if(repoDb && *repoDb){
    fsl_file_canonical_name(repoDb, &nameBuf, 0);
    fsl_free(repoDb);
    repoDb = fsl_buffer_str(&nameBuf);
    assert(repoDb);
    rc = fsl_cx_repo_open_db(f, repoDb, 0);
    fsl_buffer_reserve(&nameBuf, 0);
  }
  return rc;
}

int fsl_cx_checkout_open( fsl_cx * f, char const * dirName,
                            fsl_int_t dirNameLen ){
  int rc;
  fsl_int_t dLen = 0, i;
  static const char aDbName[][10] = { "_FOSSIL_", ".fslckout" };
  fsl_buffer * buf = &f->scratch
    /*FIXME: don't use f->scratch here. Fix returns below to
      account for a local buffer. */
    ;
  enum { DbCount = 2 };
  if(fsl_cx_db_checkout(f)) return FSL_RC_ACCESS;
  buf->used = 0;
  if(dirName && (dirNameLen<0)) dirNameLen = fsl_strlen(dirName);
  if(dirName){
    if((0==dirNameLen) || !*dirName) return FSL_RC_RANGE;
    rc = fsl_buffer_append( buf, dirName, dirNameLen );
    if(rc) return fsl_cx_err_set(f, rc, NULL)
      /* Reminder: fsl_error_set() ignores the error string (does not
         allocate) if code==FSL_RC_OOM.
      */
      ;
    dLen = dirNameLen;
  }else{
    char zPwd[2000];
    fsl_size_t pwdLen = 0;
    rc = fsl_getcwd( zPwd, sizeof(zPwd)/sizeof(zPwd[0]), &pwdLen );
    if(rc){
      return fsl_cx_err_set(f, rc,
                            "Could not determine current directory. "
                            "Error code %d (%s).",
                            rc, fsl_rc_cstr(rc));
    }
    if(1 == dLen && '/'==*zPwd) *zPwd = '.'
      /* When in the root directory (or chroot) then change dir name
         name to something we can use.
      */
      ;
    rc = fsl_buffer_append(buf, zPwd, dLen);
    if(rc) return fsl_cx_err_set(f, rc, NULL);
    dLen = (fsl_int_t)pwdLen;
  }
  if(rc) return fsl_cx_err_set(f, rc, NULL);
  assert(buf->used == dLen);
  assert(buf->capacity>buf->used);
  assert(0==buf->mem[dLen]);
  while(dLen>0){
    /*
      Loop over the list in aDbName, appending each one to
      the dir name in the search for something we can use.
    */
    fsl_int_t lenMarker = dLen /* position to
                                  re-set to on each
                                  sub-iteration. */ ;
    for( i = 0; i < DbCount; ++i ){
      buf->used = (fsl_size_t)lenMarker;
      dLen = lenMarker;
      rc = fsl_buffer_appendf( buf, "/%s", aDbName[i]);
      if(rc) return fsl_cx_err_set(f, rc, NULL);
      rc = fsl_cx_is_valid_checkout_db(f, fsl_buffer_cstr(buf));
      if(rc){
        --dLen;
        while( dLen>0 && buf->mem[dLen]!='/' ){ --dLen; }
        while( dLen>0 && buf->mem[dLen-1]=='/' ){ --dLen; }
        if(dLen>lenMarker){
          buf->mem[dLen] = 0;
        }
      }
      else{
        f->dirCkout.used = 0;
        rc = fsl_buffer_append(&f->dirCkout, buf->mem, (fsl_size_t)lenMarker);
        if(rc) return fsl_cx_err_set(f, rc, NULL);
        /*
          TODO:

          // not needed:
          g.zLocalRoot = mprintf("%s/", zPwd);
          // not needed:
          g.localOpen = 1;

          // needed:
          // db_open_config(0);
          // done (more or less):
          db_open_repository(zDbName);
        */
        /* why?
           rc = fsl_cx_config_open(f, NULL);
           seems to me we don't need that at the library
           level.
        */
        rc = fsl_cx_repo_open_for_checkout(f);
        return rc;
      }
    }
  }
  buf->used = 0;
  return FSL_RC_NOT_FOUND;
}


char const * fsl_cx_db_file_for_role(fsl_cx * f,
                                     fsl_db_role_t r,
                                     fsl_size_t * len){
  char const * rc = NULL;
  fsl_buffer const * b = f ? fsl_cx_file_for_db_role(f, r) : NULL;
  if(b) rc = fsl_buffer_cstr2(b, len);
  return rc;  
}

char const * fsl_cx_config_db_file(fsl_cx const * f,
                                   fsl_size_t * len){
  char const * rc = NULL;
  if(f && f->fileConfig.used){
    rc = fsl_buffer_cstr2(&f->fileConfig, len);
  }
  return rc;
}


char const * fsl_cx_repo_db_file(fsl_cx const * f,
                                 fsl_size_t * len){
  char const * rc = NULL;
  if(f && f->fileRepo.used){
    rc = fsl_buffer_cstr2(&f->fileRepo, len);
  }
  return rc;
}

char const * fsl_cx_checkout_db_file(fsl_cx const * f,
                                     fsl_size_t * len){
  char const * rc = NULL;
  if(f && f->fileCkout.used){
    rc = fsl_buffer_cstr2(&f->fileCkout, len);
  }
  return rc;
}

char const * fsl_cx_checkout_dir_name(fsl_cx const * f,
                                      fsl_size_t * len){
  char const * rc = NULL;
  if(f && f->fileCkout.used){
    rc = fsl_buffer_cstr2(&f->dirCkout, len);
  }
  return rc;
}

#undef MARKER