/*

** 2007 May 1

**

** The author disclaims copyright to this source code.  In place of

** a legal notice, here is a blessing:

**

**    May you do good and not evil.

**    May you find forgiveness for yourself and forgive others.

**    May you share freely, never taking more than you give.

**

*************************************************************************

**

** This file contains code used to implement incremental BLOB I/O.

**

** $Id$

*/

#include "sqliteInt.h"

#include "vdbeInt.h"

#ifndef SQLITE_OMIT_INCRBLOB

/*

** Valid sqlite3_blob* handles point to Incrblob structures.

*/

typedef struct Incrblob Incrblob;

struct Incrblob {

  int flags;              /* Copy of "flags" passed to sqlite3_blob_open() */

  int nByte;              /* Size of open blob, in bytes */

  int iOffset;            /* Byte offset of blob in cursor data */

  BtCursor *pCsr;         /* Cursor pointing at blob row */

  sqlite3_stmt *pStmt;    /* Statement holding cursor open */

  sqlite3 *db;            /* The associated database */

};

/*

** Open a blob handle.

*/

int sqlite3_blob_open(

  sqlite3* db,            /* The database connection */

  const char *zDb,        /* The attached database containing the blob */

  const char *zTable,     /* The table containing the blob */

  const char *zColumn,    /* The column containing the blob */

  sqlite_int64 iRow,      /* The row containing the glob */

  int flags,              /* True -> read/write access, false -> read-only */

  sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */

){

  int nAttempt = 0;

  int iCol;               /* Index of zColumn in row-record */

  /* This VDBE program seeks a btree cursor to the identified 

  ** db/table/row entry. The reason for using a vdbe program instead

  ** of writing code to use the b-tree layer directly is that the

  ** vdbe program will take advantage of the various transaction,

  ** locking and error handling infrastructure built into the vdbe.

  **

  ** After seeking the cursor, the vdbe executes an OP_Callback.

  ** Code external to the Vdbe then "borrows" the b-tree cursor and

  ** uses it to implement the blob_read(), blob_write() and 

  ** blob_bytes() functions.

  **

  ** The sqlite3_blob_close() function finalizes the vdbe program,

  ** which closes the b-tree cursor and (possibly) commits the 

  ** transaction.

  */

  static const VdbeOpList openBlob[] = {

    {OP_Transaction, 0, 0, 0},     /* 0: Start a transaction */

    {OP_VerifyCookie, 0, 0, 0},    /* 1: Check the schema cookie */

    {OP_Integer, 0, 0, 0},         /* 2: Database number */

    /* One of the following two instructions is replaced by an

    ** OP_Noop before exection.

    */

    {OP_OpenRead, 0, 0, 0},        /* 3: Open cursor 0 for reading */

    {OP_OpenWrite, 0, 0, 0},       /* 4: Open cursor 0 for read/write */

    {OP_SetNumColumns, 0, 0, 0},   /* 5: Num cols for cursor */

    {OP_Variable, 1, 0, 0},        /* 6: Push the rowid to the stack */

    {OP_NotExists, 0, 10, 0},      /* 7: Seek the cursor */

    {OP_Column, 0, 0, 0},          /* 8  */

    {OP_Callback, 0, 0, 0},        /* 9  */

    {OP_Close, 0, 0, 0},           /* 10 */

    {OP_Halt, 0, 0, 0},            /* 11 */

  };

  Vdbe *v = 0;

  int rc = SQLITE_OK;

  char zErr[128];

  zErr[0] = 0;

  sqlite3_mutex_enter(db->mutex);

  do {

    Parse sParse;

    Table *pTab;

    memset(&sParse, 0, sizeof(Parse));

    sParse.db = db;

    rc = sqlite3SafetyOn(db);

    if( rc!=SQLITE_OK ){

      sqlite3_mutex_leave(db->mutex);

      return rc;

    }

    sqlite3BtreeEnterAll(db);

    pTab = sqlite3LocateTable(&sParse, zTable, zDb);

    if( !pTab ){

      if( sParse.zErrMsg ){

        sqlite3_snprintf(sizeof(zErr), zErr, "%s", sParse.zErrMsg);

      }

      sqlite3_free(sParse.zErrMsg);

      rc = SQLITE_ERROR;

      sqlite3SafetyOff(db);

      sqlite3BtreeLeaveAll(db);

      goto blob_open_out;

    }

    /* Now search pTab for the exact column. */

    for(iCol=0; iCol < pTab->nCol; iCol++) {

      if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){

        break;

      }

    }

    if( iCol==pTab->nCol ){

      sqlite3_snprintf(sizeof(zErr), zErr, "no such column: \"%s\"", zColumn);

      rc = SQLITE_ERROR;

      sqlite3SafetyOff(db);

      sqlite3BtreeLeaveAll(db);

      goto blob_open_out;

    }

    /* If the value is being opened for writing, check that the

    ** column is not indexed. It is against the rules to open an

    ** indexed column for writing.

    */

    if( flags ){

      Index *pIdx;

      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){

        int j;

        for(j=0; j<pIdx->nColumn; j++){

          if( pIdx->aiColumn[j]==iCol ){

            sqlite3_snprintf(sizeof(zErr), zErr,

                             "cannot open indexed column for writing");

            rc = SQLITE_ERROR;

            sqlite3SafetyOff(db);

            sqlite3BtreeLeaveAll(db);

            goto blob_open_out;

          }

        }

      }

    }

    v = sqlite3VdbeCreate(db);

    if( v ){

      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);

      sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);

      /* Configure the OP_Transaction */

      sqlite3VdbeChangeP1(v, 0, iDb);

      sqlite3VdbeChangeP2(v, 0, (flags ? 1 : 0));

      /* Configure the OP_VerifyCookie */

      sqlite3VdbeChangeP1(v, 1, iDb);

      sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);

      /* Make sure a mutex is held on the table to be accessed */

      sqlite3VdbeUsesBtree(v, iDb); 

      /* Configure the db number pushed onto the stack */

      sqlite3VdbeChangeP1(v, 2, iDb);

      /* Remove either the OP_OpenWrite or OpenRead. Set the P2 

      ** parameter of the other to pTab->tnum. 

      */

      sqlite3VdbeChangeToNoop(v, (flags ? 3 : 4), 1);

      sqlite3VdbeChangeP2(v, (flags ? 4 : 3), pTab->tnum);

      /* Configure the OP_SetNumColumns. Configure the cursor to

      ** think that the table has one more column than it really

      ** does. An OP_Column to retrieve this imaginary column will

      ** always return an SQL NULL. This is useful because it means

      ** we can invoke OP_Column to fill in the vdbe cursors type 

      ** and offset cache without causing any IO.

      */

      sqlite3VdbeChangeP2(v, 5, pTab->nCol+1);

      if( !db->mallocFailed ){

        sqlite3VdbeMakeReady(v, 1, 0, 1, 0);

      }

    }

    sqlite3BtreeLeaveAll(db);

    rc = sqlite3SafetyOff(db);

    if( rc!=SQLITE_OK || db->mallocFailed ){

      goto blob_open_out;

    }

    sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);

    rc = sqlite3_step((sqlite3_stmt *)v);

    if( rc!=SQLITE_ROW ){

      nAttempt++;

      rc = sqlite3_finalize((sqlite3_stmt *)v);

      sqlite3_snprintf(sizeof(zErr), zErr, sqlite3_errmsg(db));

      v = 0;

    }

  } while( nAttempt<5 && rc==SQLITE_SCHEMA );

  if( rc==SQLITE_ROW ){

    /* The row-record has been opened successfully. Check that the

    ** column in question contains text or a blob. If it contains

    ** text, it is up to the caller to get the encoding right.

    */

    Incrblob *pBlob;

    u32 type = v->apCsr[0]->aType[iCol];

    if( type<12 ){

      sqlite3_snprintf(sizeof(zErr), zErr, "cannot open value of type %s",

          type==0?"null": type==7?"real": "integer"

      );

      rc = SQLITE_ERROR;

      goto blob_open_out;

    }

    pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));

    if( db->mallocFailed ){

      sqlite3_free(pBlob);

      goto blob_open_out;

    }

    pBlob->flags = flags;

    pBlob->pCsr =  v->apCsr[0]->pCursor;

    sqlite3BtreeEnterCursor(pBlob->pCsr);

    sqlite3BtreeCacheOverflow(pBlob->pCsr);

    sqlite3BtreeLeaveCursor(pBlob->pCsr);

    pBlob->pStmt = (sqlite3_stmt *)v;

    pBlob->iOffset = v->apCsr[0]->aOffset[iCol];

    pBlob->nByte = sqlite3VdbeSerialTypeLen(type);

    pBlob->db = db;

    *ppBlob = (sqlite3_blob *)pBlob;

    rc = SQLITE_OK;

  }else if( rc==SQLITE_OK ){

    sqlite3_snprintf(sizeof(zErr), zErr, "no such rowid: %lld", iRow);

    rc = SQLITE_ERROR;

  }

blob_open_out:

  zErr[sizeof(zErr)-1] = '\0';

  if( rc!=SQLITE_OK || db->mallocFailed ){

    sqlite3_finalize((sqlite3_stmt *)v);

  }

  sqlite3Error(db, rc, (rc==SQLITE_OK?0:zErr));

  rc = sqlite3ApiExit(db, rc);

  sqlite3_mutex_leave(db->mutex);

  return rc;

}

/*

** Close a blob handle that was previously created using

** sqlite3_blob_open().

*/

int sqlite3_blob_close(sqlite3_blob *pBlob){

  Incrblob *p = (Incrblob *)pBlob;

  int rc;

  rc = sqlite3_finalize(p->pStmt);

  sqlite3_free(p);

  return rc;

}

/*

** Perform a read or write operation on a blob

*/

static int blobReadWrite(

  sqlite3_blob *pBlob, 

  void *z, 

  int n, 

  int iOffset, 

  int (*xCall)(BtCursor*, u32, u32, void*)

){

  int rc;

  Incrblob *p = (Incrblob *)pBlob;

  Vdbe *v;

  sqlite3 *db = p->db;  

  /* Request is out of range. Return a transient error. */

  if( (iOffset+n)>p->nByte ){

    return SQLITE_ERROR;

  }

  sqlite3_mutex_enter(db->mutex);

  /* If there is no statement handle, then the blob-handle has

  ** already been invalidated. Return SQLITE_ABORT in this case.

  */

  v = (Vdbe*)p->pStmt;

  if( v==0 ){

    rc = SQLITE_ABORT;

  }else{

    /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is

    ** returned, clean-up the statement handle.

    */

    assert( db == v->db );

    sqlite3BtreeEnterCursor(p->pCsr);

    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);

    sqlite3BtreeLeaveCursor(p->pCsr);

    if( rc==SQLITE_ABORT ){

      sqlite3VdbeFinalize(v);

      p->pStmt = 0;

    }else{

      db->errCode = rc;

      v->rc = rc;

    }

  }

  rc = sqlite3ApiExit(db, rc);

  sqlite3_mutex_leave(db->mutex);

  return rc;

}

/*

** Read data from a blob handle.

*/

int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){

  return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);

}

/*

** Write data to a blob handle.

*/

int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){

  return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);

}

/*

** Query a blob handle for the size of the data.

**

** The Incrblob.nByte field is fixed for the lifetime of the Incrblob

** so no mutex is required for access.

*/

int sqlite3_blob_bytes(sqlite3_blob *pBlob){

  Incrblob *p = (Incrblob *)pBlob;

  return p->nByte;

}

#endif /* #ifndef SQLITE_OMIT_INCRBLOB */