sl@0: /*
sl@0: ** 2007 May 1
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: **
sl@0: ** This file contains code used to implement incremental BLOB I/O.
sl@0: **
sl@0: ** $Id: vdbeblob.c,v 1.26 2008/10/02 14:49:02 danielk1977 Exp $
sl@0: */
sl@0: 
sl@0: #include "sqliteInt.h"
sl@0: #include "vdbeInt.h"
sl@0: 
sl@0: #ifndef SQLITE_OMIT_INCRBLOB
sl@0: 
sl@0: /*
sl@0: ** Valid sqlite3_blob* handles point to Incrblob structures.
sl@0: */
sl@0: typedef struct Incrblob Incrblob;
sl@0: struct Incrblob {
sl@0:   int flags;              /* Copy of "flags" passed to sqlite3_blob_open() */
sl@0:   int nByte;              /* Size of open blob, in bytes */
sl@0:   int iOffset;            /* Byte offset of blob in cursor data */
sl@0:   BtCursor *pCsr;         /* Cursor pointing at blob row */
sl@0:   sqlite3_stmt *pStmt;    /* Statement holding cursor open */
sl@0:   sqlite3 *db;            /* The associated database */
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** Open a blob handle.
sl@0: */
sl@0: int sqlite3_blob_open(
sl@0:   sqlite3* db,            /* The database connection */
sl@0:   const char *zDb,        /* The attached database containing the blob */
sl@0:   const char *zTable,     /* The table containing the blob */
sl@0:   const char *zColumn,    /* The column containing the blob */
sl@0:   sqlite_int64 iRow,      /* The row containing the glob */
sl@0:   int flags,              /* True -> read/write access, false -> read-only */
sl@0:   sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */
sl@0: ){
sl@0:   int nAttempt = 0;
sl@0:   int iCol;               /* Index of zColumn in row-record */
sl@0: 
sl@0:   /* This VDBE program seeks a btree cursor to the identified 
sl@0:   ** db/table/row entry. The reason for using a vdbe program instead
sl@0:   ** of writing code to use the b-tree layer directly is that the
sl@0:   ** vdbe program will take advantage of the various transaction,
sl@0:   ** locking and error handling infrastructure built into the vdbe.
sl@0:   **
sl@0:   ** After seeking the cursor, the vdbe executes an OP_ResultRow.
sl@0:   ** Code external to the Vdbe then "borrows" the b-tree cursor and
sl@0:   ** uses it to implement the blob_read(), blob_write() and 
sl@0:   ** blob_bytes() functions.
sl@0:   **
sl@0:   ** The sqlite3_blob_close() function finalizes the vdbe program,
sl@0:   ** which closes the b-tree cursor and (possibly) commits the 
sl@0:   ** transaction.
sl@0:   */
sl@0:   static const VdbeOpList openBlob[] = {
sl@0:     {OP_Transaction, 0, 0, 0},     /* 0: Start a transaction */
sl@0:     {OP_VerifyCookie, 0, 0, 0},    /* 1: Check the schema cookie */
sl@0: 
sl@0:     /* One of the following two instructions is replaced by an
sl@0:     ** OP_Noop before exection.
sl@0:     */
sl@0:     {OP_SetNumColumns, 0, 0, 0},   /* 2: Num cols for cursor */
sl@0:     {OP_OpenRead, 0, 0, 0},        /* 3: Open cursor 0 for reading */
sl@0:     {OP_SetNumColumns, 0, 0, 0},   /* 4: Num cols for cursor */
sl@0:     {OP_OpenWrite, 0, 0, 0},       /* 5: Open cursor 0 for read/write */
sl@0: 
sl@0:     {OP_Variable, 1, 1, 0},        /* 6: Push the rowid to the stack */
sl@0:     {OP_NotExists, 0, 10, 1},      /* 7: Seek the cursor */
sl@0:     {OP_Column, 0, 0, 1},          /* 8  */
sl@0:     {OP_ResultRow, 1, 0, 0},       /* 9  */
sl@0:     {OP_Close, 0, 0, 0},           /* 10  */
sl@0:     {OP_Halt, 0, 0, 0},            /* 11 */
sl@0:   };
sl@0: 
sl@0:   Vdbe *v = 0;
sl@0:   int rc = SQLITE_OK;
sl@0:   char zErr[128];
sl@0: 
sl@0:   zErr[0] = 0;
sl@0:   sqlite3_mutex_enter(db->mutex);
sl@0:   do {
sl@0:     Parse sParse;
sl@0:     Table *pTab;
sl@0: 
sl@0:     memset(&sParse, 0, sizeof(Parse));
sl@0:     sParse.db = db;
sl@0: 
sl@0:     if( sqlite3SafetyOn(db) ){
sl@0:       sqlite3_mutex_leave(db->mutex);
sl@0:       return SQLITE_MISUSE;
sl@0:     }
sl@0: 
sl@0:     sqlite3BtreeEnterAll(db);
sl@0:     pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
sl@0:     if( pTab && IsVirtual(pTab) ){
sl@0:       pTab = 0;
sl@0:       sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable);
sl@0:     }
sl@0: #ifndef SQLITE_OMIT_VIEW
sl@0:     if( pTab && pTab->pSelect ){
sl@0:       pTab = 0;
sl@0:       sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
sl@0:     }
sl@0: #endif
sl@0:     if( !pTab ){
sl@0:       if( sParse.zErrMsg ){
sl@0:         sqlite3_snprintf(sizeof(zErr), zErr, "%s", sParse.zErrMsg);
sl@0:       }
sl@0:       sqlite3DbFree(db, sParse.zErrMsg);
sl@0:       rc = SQLITE_ERROR;
sl@0:       (void)sqlite3SafetyOff(db);
sl@0:       sqlite3BtreeLeaveAll(db);
sl@0:       goto blob_open_out;
sl@0:     }
sl@0: 
sl@0:     /* Now search pTab for the exact column. */
sl@0:     for(iCol=0; iCol < pTab->nCol; iCol++) {
sl@0:       if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
sl@0:         break;
sl@0:       }
sl@0:     }
sl@0:     if( iCol==pTab->nCol ){
sl@0:       sqlite3_snprintf(sizeof(zErr), zErr, "no such column: \"%s\"", zColumn);
sl@0:       rc = SQLITE_ERROR;
sl@0:       (void)sqlite3SafetyOff(db);
sl@0:       sqlite3BtreeLeaveAll(db);
sl@0:       goto blob_open_out;
sl@0:     }
sl@0: 
sl@0:     /* If the value is being opened for writing, check that the
sl@0:     ** column is not indexed. It is against the rules to open an
sl@0:     ** indexed column for writing.
sl@0:     */
sl@0:     if( flags ){
sl@0:       Index *pIdx;
sl@0:       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
sl@0:         int j;
sl@0:         for(j=0; j<pIdx->nColumn; j++){
sl@0:           if( pIdx->aiColumn[j]==iCol ){
sl@0:             sqlite3_snprintf(sizeof(zErr), zErr,
sl@0:                              "cannot open indexed column for writing");
sl@0:             rc = SQLITE_ERROR;
sl@0:             (void)sqlite3SafetyOff(db);
sl@0:             sqlite3BtreeLeaveAll(db);
sl@0:             goto blob_open_out;
sl@0:           }
sl@0:         }
sl@0:       }
sl@0:     }
sl@0: 
sl@0:     v = sqlite3VdbeCreate(db);
sl@0:     if( v ){
sl@0:       int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
sl@0:       sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
sl@0: 
sl@0:       /* Configure the OP_Transaction */
sl@0:       sqlite3VdbeChangeP1(v, 0, iDb);
sl@0:       sqlite3VdbeChangeP2(v, 0, (flags ? 1 : 0));
sl@0: 
sl@0:       /* Configure the OP_VerifyCookie */
sl@0:       sqlite3VdbeChangeP1(v, 1, iDb);
sl@0:       sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
sl@0: 
sl@0:       /* Make sure a mutex is held on the table to be accessed */
sl@0:       sqlite3VdbeUsesBtree(v, iDb); 
sl@0: 
sl@0:       /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
sl@0:       ** parameter of the other to pTab->tnum. 
sl@0:       */
sl@0:       sqlite3VdbeChangeToNoop(v, (flags ? 3 : 5), 1);
sl@0:       sqlite3VdbeChangeP2(v, (flags ? 5 : 3), pTab->tnum);
sl@0:       sqlite3VdbeChangeP3(v, (flags ? 5 : 3), iDb);
sl@0: 
sl@0:       /* Configure the OP_SetNumColumns. Configure the cursor to
sl@0:       ** think that the table has one more column than it really
sl@0:       ** does. An OP_Column to retrieve this imaginary column will
sl@0:       ** always return an SQL NULL. This is useful because it means
sl@0:       ** we can invoke OP_Column to fill in the vdbe cursors type 
sl@0:       ** and offset cache without causing any IO.
sl@0:       */
sl@0:       sqlite3VdbeChangeP2(v, flags ? 4 : 2, pTab->nCol+1);
sl@0:       sqlite3VdbeChangeP2(v, 8, pTab->nCol);
sl@0:       if( !db->mallocFailed ){
sl@0:         sqlite3VdbeMakeReady(v, 1, 1, 1, 0);
sl@0:       }
sl@0:     }
sl@0:    
sl@0:     sqlite3BtreeLeaveAll(db);
sl@0:     rc = sqlite3SafetyOff(db);
sl@0:     if( rc!=SQLITE_OK || db->mallocFailed ){
sl@0:       goto blob_open_out;
sl@0:     }
sl@0: 
sl@0:     sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);
sl@0:     rc = sqlite3_step((sqlite3_stmt *)v);
sl@0:     if( rc!=SQLITE_ROW ){
sl@0:       nAttempt++;
sl@0:       rc = sqlite3_finalize((sqlite3_stmt *)v);
sl@0:       sqlite3_snprintf(sizeof(zErr), zErr, sqlite3_errmsg(db));
sl@0:       v = 0;
sl@0:     }
sl@0:   } while( nAttempt<5 && rc==SQLITE_SCHEMA );
sl@0: 
sl@0:   if( rc==SQLITE_ROW ){
sl@0:     /* The row-record has been opened successfully. Check that the
sl@0:     ** column in question contains text or a blob. If it contains
sl@0:     ** text, it is up to the caller to get the encoding right.
sl@0:     */
sl@0:     Incrblob *pBlob;
sl@0:     u32 type = v->apCsr[0]->aType[iCol];
sl@0: 
sl@0:     if( type<12 ){
sl@0:       sqlite3_snprintf(sizeof(zErr), zErr, "cannot open value of type %s",
sl@0:           type==0?"null": type==7?"real": "integer"
sl@0:       );
sl@0:       rc = SQLITE_ERROR;
sl@0:       goto blob_open_out;
sl@0:     }
sl@0:     pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
sl@0:     if( db->mallocFailed ){
sl@0:       sqlite3DbFree(db, pBlob);
sl@0:       goto blob_open_out;
sl@0:     }
sl@0:     pBlob->flags = flags;
sl@0:     pBlob->pCsr =  v->apCsr[0]->pCursor;
sl@0:     sqlite3BtreeEnterCursor(pBlob->pCsr);
sl@0:     sqlite3BtreeCacheOverflow(pBlob->pCsr);
sl@0:     sqlite3BtreeLeaveCursor(pBlob->pCsr);
sl@0:     pBlob->pStmt = (sqlite3_stmt *)v;
sl@0:     pBlob->iOffset = v->apCsr[0]->aOffset[iCol];
sl@0:     pBlob->nByte = sqlite3VdbeSerialTypeLen(type);
sl@0:     pBlob->db = db;
sl@0:     *ppBlob = (sqlite3_blob *)pBlob;
sl@0:     rc = SQLITE_OK;
sl@0:   }else if( rc==SQLITE_OK ){
sl@0:     sqlite3_snprintf(sizeof(zErr), zErr, "no such rowid: %lld", iRow);
sl@0:     rc = SQLITE_ERROR;
sl@0:   }
sl@0: 
sl@0: blob_open_out:
sl@0:   zErr[sizeof(zErr)-1] = '\0';
sl@0:   if( rc!=SQLITE_OK || db->mallocFailed ){
sl@0:     sqlite3_finalize((sqlite3_stmt *)v);
sl@0:   }
sl@0:   sqlite3Error(db, rc, (rc==SQLITE_OK?0:zErr));
sl@0:   rc = sqlite3ApiExit(db, rc);
sl@0:   sqlite3_mutex_leave(db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Close a blob handle that was previously created using
sl@0: ** sqlite3_blob_open().
sl@0: */
sl@0: int sqlite3_blob_close(sqlite3_blob *pBlob){
sl@0:   Incrblob *p = (Incrblob *)pBlob;
sl@0:   int rc;
sl@0: 
sl@0:   rc = sqlite3_finalize(p->pStmt);
sl@0:   sqlite3DbFree(p->db, p);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Perform a read or write operation on a blob
sl@0: */
sl@0: static int blobReadWrite(
sl@0:   sqlite3_blob *pBlob, 
sl@0:   void *z, 
sl@0:   int n, 
sl@0:   int iOffset, 
sl@0:   int (*xCall)(BtCursor*, u32, u32, void*)
sl@0: ){
sl@0:   int rc;
sl@0:   Incrblob *p = (Incrblob *)pBlob;
sl@0:   Vdbe *v;
sl@0:   sqlite3 *db = p->db;  
sl@0: 
sl@0:   sqlite3_mutex_enter(db->mutex);
sl@0:   v = (Vdbe*)p->pStmt;
sl@0: 
sl@0:   if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
sl@0:     /* Request is out of range. Return a transient error. */
sl@0:     rc = SQLITE_ERROR;
sl@0:     sqlite3Error(db, SQLITE_ERROR, 0);
sl@0:   } else if( v==0 ){
sl@0:     /* If there is no statement handle, then the blob-handle has
sl@0:     ** already been invalidated. Return SQLITE_ABORT in this case.
sl@0:     */
sl@0:     rc = SQLITE_ABORT;
sl@0:   }else{
sl@0:     /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
sl@0:     ** returned, clean-up the statement handle.
sl@0:     */
sl@0:     assert( db == v->db );
sl@0:     sqlite3BtreeEnterCursor(p->pCsr);
sl@0:     rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
sl@0:     sqlite3BtreeLeaveCursor(p->pCsr);
sl@0:     if( rc==SQLITE_ABORT ){
sl@0:       sqlite3VdbeFinalize(v);
sl@0:       p->pStmt = 0;
sl@0:     }else{
sl@0:       db->errCode = rc;
sl@0:       v->rc = rc;
sl@0:     }
sl@0:   }
sl@0:   rc = sqlite3ApiExit(db, rc);
sl@0:   sqlite3_mutex_leave(db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Read data from a blob handle.
sl@0: */
sl@0: int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
sl@0:   return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Write data to a blob handle.
sl@0: */
sl@0: int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
sl@0:   return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Query a blob handle for the size of the data.
sl@0: **
sl@0: ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
sl@0: ** so no mutex is required for access.
sl@0: */
sl@0: int sqlite3_blob_bytes(sqlite3_blob *pBlob){
sl@0:   Incrblob *p = (Incrblob *)pBlob;
sl@0:   return p->nByte;
sl@0: }
sl@0: 
sl@0: #endif /* #ifndef SQLITE_OMIT_INCRBLOB */