1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/SQLite/vdbeblob.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,348 @@
1.4 +/*
1.5 +** 2007 May 1
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +**
1.16 +** This file contains code used to implement incremental BLOB I/O.
1.17 +**
1.18 +** $Id: vdbeblob.c,v 1.26 2008/10/02 14:49:02 danielk1977 Exp $
1.19 +*/
1.20 +
1.21 +#include "sqliteInt.h"
1.22 +#include "vdbeInt.h"
1.23 +
1.24 +#ifndef SQLITE_OMIT_INCRBLOB
1.25 +
1.26 +/*
1.27 +** Valid sqlite3_blob* handles point to Incrblob structures.
1.28 +*/
1.29 +typedef struct Incrblob Incrblob;
1.30 +struct Incrblob {
1.31 + int flags; /* Copy of "flags" passed to sqlite3_blob_open() */
1.32 + int nByte; /* Size of open blob, in bytes */
1.33 + int iOffset; /* Byte offset of blob in cursor data */
1.34 + BtCursor *pCsr; /* Cursor pointing at blob row */
1.35 + sqlite3_stmt *pStmt; /* Statement holding cursor open */
1.36 + sqlite3 *db; /* The associated database */
1.37 +};
1.38 +
1.39 +/*
1.40 +** Open a blob handle.
1.41 +*/
1.42 +SQLITE_EXPORT int sqlite3_blob_open(
1.43 + sqlite3* db, /* The database connection */
1.44 + const char *zDb, /* The attached database containing the blob */
1.45 + const char *zTable, /* The table containing the blob */
1.46 + const char *zColumn, /* The column containing the blob */
1.47 + sqlite_int64 iRow, /* The row containing the glob */
1.48 + int flags, /* True -> read/write access, false -> read-only */
1.49 + sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
1.50 +){
1.51 + int nAttempt = 0;
1.52 + int iCol; /* Index of zColumn in row-record */
1.53 +
1.54 + /* This VDBE program seeks a btree cursor to the identified
1.55 + ** db/table/row entry. The reason for using a vdbe program instead
1.56 + ** of writing code to use the b-tree layer directly is that the
1.57 + ** vdbe program will take advantage of the various transaction,
1.58 + ** locking and error handling infrastructure built into the vdbe.
1.59 + **
1.60 + ** After seeking the cursor, the vdbe executes an OP_ResultRow.
1.61 + ** Code external to the Vdbe then "borrows" the b-tree cursor and
1.62 + ** uses it to implement the blob_read(), blob_write() and
1.63 + ** blob_bytes() functions.
1.64 + **
1.65 + ** The sqlite3_blob_close() function finalizes the vdbe program,
1.66 + ** which closes the b-tree cursor and (possibly) commits the
1.67 + ** transaction.
1.68 + */
1.69 + static const VdbeOpList openBlob[] = {
1.70 + {OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */
1.71 + {OP_VerifyCookie, 0, 0, 0}, /* 1: Check the schema cookie */
1.72 +
1.73 + /* One of the following two instructions is replaced by an
1.74 + ** OP_Noop before exection.
1.75 + */
1.76 + {OP_SetNumColumns, 0, 0, 0}, /* 2: Num cols for cursor */
1.77 + {OP_OpenRead, 0, 0, 0}, /* 3: Open cursor 0 for reading */
1.78 + {OP_SetNumColumns, 0, 0, 0}, /* 4: Num cols for cursor */
1.79 + {OP_OpenWrite, 0, 0, 0}, /* 5: Open cursor 0 for read/write */
1.80 +
1.81 + {OP_Variable, 1, 1, 0}, /* 6: Push the rowid to the stack */
1.82 + {OP_NotExists, 0, 10, 1}, /* 7: Seek the cursor */
1.83 + {OP_Column, 0, 0, 1}, /* 8 */
1.84 + {OP_ResultRow, 1, 0, 0}, /* 9 */
1.85 + {OP_Close, 0, 0, 0}, /* 10 */
1.86 + {OP_Halt, 0, 0, 0}, /* 11 */
1.87 + };
1.88 +
1.89 + Vdbe *v = 0;
1.90 + int rc = SQLITE_OK;
1.91 + char zErr[128];
1.92 +
1.93 + zErr[0] = 0;
1.94 + sqlite3_mutex_enter(db->mutex);
1.95 + do {
1.96 + Parse sParse;
1.97 + Table *pTab;
1.98 +
1.99 + memset(&sParse, 0, sizeof(Parse));
1.100 + sParse.db = db;
1.101 +
1.102 + if( sqlite3SafetyOn(db) ){
1.103 + sqlite3_mutex_leave(db->mutex);
1.104 + return SQLITE_MISUSE;
1.105 + }
1.106 +
1.107 + sqlite3BtreeEnterAll(db);
1.108 + pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
1.109 + if( pTab && IsVirtual(pTab) ){
1.110 + pTab = 0;
1.111 + sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable);
1.112 + }
1.113 +#ifndef SQLITE_OMIT_VIEW
1.114 + if( pTab && pTab->pSelect ){
1.115 + pTab = 0;
1.116 + sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
1.117 + }
1.118 +#endif
1.119 + if( !pTab ){
1.120 + if( sParse.zErrMsg ){
1.121 + sqlite3_snprintf(sizeof(zErr), zErr, "%s", sParse.zErrMsg);
1.122 + }
1.123 + sqlite3DbFree(db, sParse.zErrMsg);
1.124 + rc = SQLITE_ERROR;
1.125 + (void)sqlite3SafetyOff(db);
1.126 + sqlite3BtreeLeaveAll(db);
1.127 + goto blob_open_out;
1.128 + }
1.129 +
1.130 + /* Now search pTab for the exact column. */
1.131 + for(iCol=0; iCol < pTab->nCol; iCol++) {
1.132 + if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
1.133 + break;
1.134 + }
1.135 + }
1.136 + if( iCol==pTab->nCol ){
1.137 + sqlite3_snprintf(sizeof(zErr), zErr, "no such column: \"%s\"", zColumn);
1.138 + rc = SQLITE_ERROR;
1.139 + (void)sqlite3SafetyOff(db);
1.140 + sqlite3BtreeLeaveAll(db);
1.141 + goto blob_open_out;
1.142 + }
1.143 +
1.144 + /* If the value is being opened for writing, check that the
1.145 + ** column is not indexed. It is against the rules to open an
1.146 + ** indexed column for writing.
1.147 + */
1.148 + if( flags ){
1.149 + Index *pIdx;
1.150 + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1.151 + int j;
1.152 + for(j=0; j<pIdx->nColumn; j++){
1.153 + if( pIdx->aiColumn[j]==iCol ){
1.154 + sqlite3_snprintf(sizeof(zErr), zErr,
1.155 + "cannot open indexed column for writing");
1.156 + rc = SQLITE_ERROR;
1.157 + (void)sqlite3SafetyOff(db);
1.158 + sqlite3BtreeLeaveAll(db);
1.159 + goto blob_open_out;
1.160 + }
1.161 + }
1.162 + }
1.163 + }
1.164 +
1.165 + v = sqlite3VdbeCreate(db);
1.166 + if( v ){
1.167 + int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
1.168 + sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
1.169 +
1.170 + /* Configure the OP_Transaction */
1.171 + sqlite3VdbeChangeP1(v, 0, iDb);
1.172 + sqlite3VdbeChangeP2(v, 0, (flags ? 1 : 0));
1.173 +
1.174 + /* Configure the OP_VerifyCookie */
1.175 + sqlite3VdbeChangeP1(v, 1, iDb);
1.176 + sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
1.177 +
1.178 + /* Make sure a mutex is held on the table to be accessed */
1.179 + sqlite3VdbeUsesBtree(v, iDb);
1.180 +
1.181 + /* Remove either the OP_OpenWrite or OpenRead. Set the P2
1.182 + ** parameter of the other to pTab->tnum.
1.183 + */
1.184 + sqlite3VdbeChangeToNoop(v, (flags ? 3 : 5), 1);
1.185 + sqlite3VdbeChangeP2(v, (flags ? 5 : 3), pTab->tnum);
1.186 + sqlite3VdbeChangeP3(v, (flags ? 5 : 3), iDb);
1.187 +
1.188 + /* Configure the OP_SetNumColumns. Configure the cursor to
1.189 + ** think that the table has one more column than it really
1.190 + ** does. An OP_Column to retrieve this imaginary column will
1.191 + ** always return an SQL NULL. This is useful because it means
1.192 + ** we can invoke OP_Column to fill in the vdbe cursors type
1.193 + ** and offset cache without causing any IO.
1.194 + */
1.195 + sqlite3VdbeChangeP2(v, flags ? 4 : 2, pTab->nCol+1);
1.196 + sqlite3VdbeChangeP2(v, 8, pTab->nCol);
1.197 + if( !db->mallocFailed ){
1.198 + sqlite3VdbeMakeReady(v, 1, 1, 1, 0);
1.199 + }
1.200 + }
1.201 +
1.202 + sqlite3BtreeLeaveAll(db);
1.203 + rc = sqlite3SafetyOff(db);
1.204 + if( rc!=SQLITE_OK || db->mallocFailed ){
1.205 + goto blob_open_out;
1.206 + }
1.207 +
1.208 + sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);
1.209 + rc = sqlite3_step((sqlite3_stmt *)v);
1.210 + if( rc!=SQLITE_ROW ){
1.211 + nAttempt++;
1.212 + rc = sqlite3_finalize((sqlite3_stmt *)v);
1.213 + sqlite3_snprintf(sizeof(zErr), zErr, sqlite3_errmsg(db));
1.214 + v = 0;
1.215 + }
1.216 + } while( nAttempt<5 && rc==SQLITE_SCHEMA );
1.217 +
1.218 + if( rc==SQLITE_ROW ){
1.219 + /* The row-record has been opened successfully. Check that the
1.220 + ** column in question contains text or a blob. If it contains
1.221 + ** text, it is up to the caller to get the encoding right.
1.222 + */
1.223 + Incrblob *pBlob;
1.224 + u32 type = v->apCsr[0]->aType[iCol];
1.225 +
1.226 + if( type<12 ){
1.227 + sqlite3_snprintf(sizeof(zErr), zErr, "cannot open value of type %s",
1.228 + type==0?"null": type==7?"real": "integer"
1.229 + );
1.230 + rc = SQLITE_ERROR;
1.231 + goto blob_open_out;
1.232 + }
1.233 + pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
1.234 + if( db->mallocFailed ){
1.235 + sqlite3DbFree(db, pBlob);
1.236 + goto blob_open_out;
1.237 + }
1.238 + pBlob->flags = flags;
1.239 + pBlob->pCsr = v->apCsr[0]->pCursor;
1.240 + sqlite3BtreeEnterCursor(pBlob->pCsr);
1.241 + sqlite3BtreeCacheOverflow(pBlob->pCsr);
1.242 + sqlite3BtreeLeaveCursor(pBlob->pCsr);
1.243 + pBlob->pStmt = (sqlite3_stmt *)v;
1.244 + pBlob->iOffset = v->apCsr[0]->aOffset[iCol];
1.245 + pBlob->nByte = sqlite3VdbeSerialTypeLen(type);
1.246 + pBlob->db = db;
1.247 + *ppBlob = (sqlite3_blob *)pBlob;
1.248 + rc = SQLITE_OK;
1.249 + }else if( rc==SQLITE_OK ){
1.250 + sqlite3_snprintf(sizeof(zErr), zErr, "no such rowid: %lld", iRow);
1.251 + rc = SQLITE_ERROR;
1.252 + }
1.253 +
1.254 +blob_open_out:
1.255 + zErr[sizeof(zErr)-1] = '\0';
1.256 + if( rc!=SQLITE_OK || db->mallocFailed ){
1.257 + sqlite3_finalize((sqlite3_stmt *)v);
1.258 + }
1.259 + sqlite3Error(db, rc, (rc==SQLITE_OK?0:zErr));
1.260 + rc = sqlite3ApiExit(db, rc);
1.261 + sqlite3_mutex_leave(db->mutex);
1.262 + return rc;
1.263 +}
1.264 +
1.265 +/*
1.266 +** Close a blob handle that was previously created using
1.267 +** sqlite3_blob_open().
1.268 +*/
1.269 +SQLITE_EXPORT int sqlite3_blob_close(sqlite3_blob *pBlob){
1.270 + Incrblob *p = (Incrblob *)pBlob;
1.271 + int rc;
1.272 +
1.273 + rc = sqlite3_finalize(p->pStmt);
1.274 + sqlite3DbFree(p->db, p);
1.275 + return rc;
1.276 +}
1.277 +
1.278 +/*
1.279 +** Perform a read or write operation on a blob
1.280 +*/
1.281 +static int blobReadWrite(
1.282 + sqlite3_blob *pBlob,
1.283 + void *z,
1.284 + int n,
1.285 + int iOffset,
1.286 + int (*xCall)(BtCursor*, u32, u32, void*)
1.287 +){
1.288 + int rc;
1.289 + Incrblob *p = (Incrblob *)pBlob;
1.290 + Vdbe *v;
1.291 + sqlite3 *db = p->db;
1.292 +
1.293 + sqlite3_mutex_enter(db->mutex);
1.294 + v = (Vdbe*)p->pStmt;
1.295 +
1.296 + if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
1.297 + /* Request is out of range. Return a transient error. */
1.298 + rc = SQLITE_ERROR;
1.299 + sqlite3Error(db, SQLITE_ERROR, 0);
1.300 + } else if( v==0 ){
1.301 + /* If there is no statement handle, then the blob-handle has
1.302 + ** already been invalidated. Return SQLITE_ABORT in this case.
1.303 + */
1.304 + rc = SQLITE_ABORT;
1.305 + }else{
1.306 + /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
1.307 + ** returned, clean-up the statement handle.
1.308 + */
1.309 + assert( db == v->db );
1.310 + sqlite3BtreeEnterCursor(p->pCsr);
1.311 + rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
1.312 + sqlite3BtreeLeaveCursor(p->pCsr);
1.313 + if( rc==SQLITE_ABORT ){
1.314 + sqlite3VdbeFinalize(v);
1.315 + p->pStmt = 0;
1.316 + }else{
1.317 + db->errCode = rc;
1.318 + v->rc = rc;
1.319 + }
1.320 + }
1.321 + rc = sqlite3ApiExit(db, rc);
1.322 + sqlite3_mutex_leave(db->mutex);
1.323 + return rc;
1.324 +}
1.325 +
1.326 +/*
1.327 +** Read data from a blob handle.
1.328 +*/
1.329 +SQLITE_EXPORT int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
1.330 + return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
1.331 +}
1.332 +
1.333 +/*
1.334 +** Write data to a blob handle.
1.335 +*/
1.336 +SQLITE_EXPORT int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
1.337 + return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
1.338 +}
1.339 +
1.340 +/*
1.341 +** Query a blob handle for the size of the data.
1.342 +**
1.343 +** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
1.344 +** so no mutex is required for access.
1.345 +*/
1.346 +SQLITE_EXPORT int sqlite3_blob_bytes(sqlite3_blob *pBlob){
1.347 + Incrblob *p = (Incrblob *)pBlob;
1.348 + return p->nByte;
1.349 +}
1.350 +
1.351 +#endif /* #ifndef SQLITE_OMIT_INCRBLOB */