1 /* 2 ** 2007 May 1 3 ** 4 ** The author disclaims copyright to this source code. In place of 5 ** a legal notice, here is a blessing: 6 ** 7 ** May you do good and not evil. 8 ** May you find forgiveness for yourself and forgive others. 9 ** May you share freely, never taking more than you give. 10 ** 11 ************************************************************************* 12 ** 13 ** This file contains code used to implement incremental BLOB I/O. 14 */ 15 16 #include "sqliteInt.h" 17 #include "vdbeInt.h" 18 19 #ifndef SQLITE_OMIT_INCRBLOB 20 21 /* 22 ** Valid sqlite3_blob* handles point to Incrblob structures. 23 */ 24 typedef struct Incrblob Incrblob; 25 struct Incrblob { 26 int flags; /* Copy of "flags" passed to sqlite3_blob_open() */ 27 int nByte; /* Size of open blob, in bytes */ 28 int iOffset; /* Byte offset of blob in cursor data */ 29 BtCursor *pCsr; /* Cursor pointing at blob row */ 30 sqlite3_stmt *pStmt; /* Statement holding cursor open */ 31 sqlite3 *db; /* The associated database */ 32 }; 33 34 /* 35 ** Open a blob handle. 36 */ 37 int sqlite3_blob_open( 38 sqlite3* db, /* The database connection */ 39 const char *zDb, /* The attached database containing the blob */ 40 const char *zTable, /* The table containing the blob */ 41 const char *zColumn, /* The column containing the blob */ 42 sqlite_int64 iRow, /* The row containing the glob */ 43 int flags, /* True -> read/write access, false -> read-only */ 44 sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */ 45 ){ 46 int nAttempt = 0; 47 int iCol; /* Index of zColumn in row-record */ 48 49 /* This VDBE program seeks a btree cursor to the identified 50 ** db/table/row entry. The reason for using a vdbe program instead 51 ** of writing code to use the b-tree layer directly is that the 52 ** vdbe program will take advantage of the various transaction, 53 ** locking and error handling infrastructure built into the vdbe. 54 ** 55 ** After seeking the cursor, the vdbe executes an OP_ResultRow. 56 ** Code external to the Vdbe then "borrows" the b-tree cursor and 57 ** uses it to implement the blob_read(), blob_write() and 58 ** blob_bytes() functions. 59 ** 60 ** The sqlite3_blob_close() function finalizes the vdbe program, 61 ** which closes the b-tree cursor and (possibly) commits the 62 ** transaction. 63 */ 64 static const VdbeOpList openBlob[] = { 65 {OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */ 66 {OP_VerifyCookie, 0, 0, 0}, /* 1: Check the schema cookie */ 67 {OP_TableLock, 0, 0, 0}, /* 2: Acquire a read or write lock */ 68 69 /* One of the following two instructions is replaced by an OP_Noop. */ 70 {OP_OpenRead, 0, 0, 0}, /* 3: Open cursor 0 for reading */ 71 {OP_OpenWrite, 0, 0, 0}, /* 4: Open cursor 0 for read/write */ 72 73 {OP_Variable, 1, 1, 1}, /* 5: Push the rowid to the stack */ 74 {OP_NotExists, 0, 9, 1}, /* 6: Seek the cursor */ 75 {OP_Column, 0, 0, 1}, /* 7 */ 76 {OP_ResultRow, 1, 0, 0}, /* 8 */ 77 {OP_Close, 0, 0, 0}, /* 9 */ 78 {OP_Halt, 0, 0, 0}, /* 10 */ 79 }; 80 81 Vdbe *v = 0; 82 int rc = SQLITE_OK; 83 char *zErr = 0; 84 Table *pTab; 85 Parse *pParse; 86 87 *ppBlob = 0; 88 sqlite3_mutex_enter(db->mutex); 89 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse)); 90 if( pParse==0 ){ 91 rc = SQLITE_NOMEM; 92 goto blob_open_out; 93 } 94 do { 95 memset(pParse, 0, sizeof(Parse)); 96 pParse->db = db; 97 98 sqlite3BtreeEnterAll(db); 99 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb); 100 if( pTab && IsVirtual(pTab) ){ 101 pTab = 0; 102 sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable); 103 } 104 #ifndef SQLITE_OMIT_VIEW 105 if( pTab && pTab->pSelect ){ 106 pTab = 0; 107 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable); 108 } 109 #endif 110 if( !pTab ){ 111 if( pParse->zErrMsg ){ 112 sqlite3DbFree(db, zErr); 113 zErr = pParse->zErrMsg; 114 pParse->zErrMsg = 0; 115 } 116 rc = SQLITE_ERROR; 117 sqlite3BtreeLeaveAll(db); 118 goto blob_open_out; 119 } 120 121 /* Now search pTab for the exact column. */ 122 for(iCol=0; iCol < pTab->nCol; iCol++) { 123 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){ 124 break; 125 } 126 } 127 if( iCol==pTab->nCol ){ 128 sqlite3DbFree(db, zErr); 129 zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn); 130 rc = SQLITE_ERROR; 131 sqlite3BtreeLeaveAll(db); 132 goto blob_open_out; 133 } 134 135 /* If the value is being opened for writing, check that the 136 ** column is not indexed, and that it is not part of a foreign key. 137 ** It is against the rules to open a column to which either of these 138 ** descriptions applies for writing. */ 139 if( flags ){ 140 const char *zFault = 0; 141 Index *pIdx; 142 #ifndef SQLITE_OMIT_FOREIGN_KEY 143 if( db->flags&SQLITE_ForeignKeys ){ 144 /* Check that the column is not part of an FK child key definition. It 145 ** is not necessary to check if it is part of a parent key, as parent 146 ** key columns must be indexed. The check below will pick up this 147 ** case. */ 148 FKey *pFKey; 149 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){ 150 int j; 151 for(j=0; j<pFKey->nCol; j++){ 152 if( pFKey->aCol[j].iFrom==iCol ){ 153 zFault = "foreign key"; 154 } 155 } 156 } 157 } 158 #endif 159 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ 160 int j; 161 for(j=0; j<pIdx->nColumn; j++){ 162 if( pIdx->aiColumn[j]==iCol ){ 163 zFault = "indexed"; 164 } 165 } 166 } 167 if( zFault ){ 168 sqlite3DbFree(db, zErr); 169 zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault); 170 rc = SQLITE_ERROR; 171 sqlite3BtreeLeaveAll(db); 172 goto blob_open_out; 173 } 174 } 175 176 v = sqlite3VdbeCreate(db); 177 if( v ){ 178 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); 179 sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob); 180 flags = !!flags; /* flags = (flags ? 1 : 0); */ 181 182 /* Configure the OP_Transaction */ 183 sqlite3VdbeChangeP1(v, 0, iDb); 184 sqlite3VdbeChangeP2(v, 0, flags); 185 186 /* Configure the OP_VerifyCookie */ 187 sqlite3VdbeChangeP1(v, 1, iDb); 188 sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie); 189 190 /* Make sure a mutex is held on the table to be accessed */ 191 sqlite3VdbeUsesBtree(v, iDb); 192 193 /* Configure the OP_TableLock instruction */ 194 #ifdef SQLITE_OMIT_SHARED_CACHE 195 sqlite3VdbeChangeToNoop(v, 2, 1); 196 #else 197 sqlite3VdbeChangeP1(v, 2, iDb); 198 sqlite3VdbeChangeP2(v, 2, pTab->tnum); 199 sqlite3VdbeChangeP3(v, 2, flags); 200 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT); 201 #endif 202 203 /* Remove either the OP_OpenWrite or OpenRead. Set the P2 204 ** parameter of the other to pTab->tnum. */ 205 sqlite3VdbeChangeToNoop(v, 4 - flags, 1); 206 sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum); 207 sqlite3VdbeChangeP3(v, 3 + flags, iDb); 208 209 /* Configure the number of columns. Configure the cursor to 210 ** think that the table has one more column than it really 211 ** does. An OP_Column to retrieve this imaginary column will 212 ** always return an SQL NULL. This is useful because it means 213 ** we can invoke OP_Column to fill in the vdbe cursors type 214 ** and offset cache without causing any IO. 215 */ 216 sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32); 217 sqlite3VdbeChangeP2(v, 7, pTab->nCol); 218 if( !db->mallocFailed ){ 219 sqlite3VdbeMakeReady(v, 1, 1, 1, 0, 0, 0); 220 } 221 } 222 223 sqlite3BtreeLeaveAll(db); 224 if( db->mallocFailed ){ 225 goto blob_open_out; 226 } 227 228 sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow); 229 rc = sqlite3_step((sqlite3_stmt *)v); 230 if( rc!=SQLITE_ROW ){ 231 nAttempt++; 232 rc = sqlite3_finalize((sqlite3_stmt *)v); 233 sqlite3DbFree(db, zErr); 234 zErr = sqlite3MPrintf(db, sqlite3_errmsg(db)); 235 v = 0; 236 } 237 } while( nAttempt<5 && rc==SQLITE_SCHEMA ); 238 239 if( rc==SQLITE_ROW ){ 240 /* The row-record has been opened successfully. Check that the 241 ** column in question contains text or a blob. If it contains 242 ** text, it is up to the caller to get the encoding right. 243 */ 244 Incrblob *pBlob; 245 u32 type = v->apCsr[0]->aType[iCol]; 246 247 if( type<12 ){ 248 sqlite3DbFree(db, zErr); 249 zErr = sqlite3MPrintf(db, "cannot open value of type %s", 250 type==0?"null": type==7?"real": "integer" 251 ); 252 rc = SQLITE_ERROR; 253 goto blob_open_out; 254 } 255 pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob)); 256 if( db->mallocFailed ){ 257 sqlite3DbFree(db, pBlob); 258 goto blob_open_out; 259 } 260 pBlob->flags = flags; 261 pBlob->pCsr = v->apCsr[0]->pCursor; 262 sqlite3BtreeEnterCursor(pBlob->pCsr); 263 sqlite3BtreeCacheOverflow(pBlob->pCsr); 264 sqlite3BtreeLeaveCursor(pBlob->pCsr); 265 pBlob->pStmt = (sqlite3_stmt *)v; 266 pBlob->iOffset = v->apCsr[0]->aOffset[iCol]; 267 pBlob->nByte = sqlite3VdbeSerialTypeLen(type); 268 pBlob->db = db; 269 *ppBlob = (sqlite3_blob *)pBlob; 270 rc = SQLITE_OK; 271 }else if( rc==SQLITE_OK ){ 272 sqlite3DbFree(db, zErr); 273 zErr = sqlite3MPrintf(db, "no such rowid: %lld", iRow); 274 rc = SQLITE_ERROR; 275 } 276 277 blob_open_out: 278 if( v && (rc!=SQLITE_OK || db->mallocFailed) ){ 279 sqlite3VdbeFinalize(v); 280 } 281 sqlite3Error(db, rc, zErr); 282 sqlite3DbFree(db, zErr); 283 sqlite3StackFree(db, pParse); 284 rc = sqlite3ApiExit(db, rc); 285 sqlite3_mutex_leave(db->mutex); 286 return rc; 287 } 288 289 /* 290 ** Close a blob handle that was previously created using 291 ** sqlite3_blob_open(). 292 */ 293 int sqlite3_blob_close(sqlite3_blob *pBlob){ 294 Incrblob *p = (Incrblob *)pBlob; 295 int rc; 296 sqlite3 *db; 297 298 if( p ){ 299 db = p->db; 300 sqlite3_mutex_enter(db->mutex); 301 rc = sqlite3_finalize(p->pStmt); 302 sqlite3DbFree(db, p); 303 sqlite3_mutex_leave(db->mutex); 304 }else{ 305 rc = SQLITE_OK; 306 } 307 return rc; 308 } 309 310 /* 311 ** Perform a read or write operation on a blob 312 */ 313 static int blobReadWrite( 314 sqlite3_blob *pBlob, 315 void *z, 316 int n, 317 int iOffset, 318 int (*xCall)(BtCursor*, u32, u32, void*) 319 ){ 320 int rc; 321 Incrblob *p = (Incrblob *)pBlob; 322 Vdbe *v; 323 sqlite3 *db; 324 325 if( p==0 ) return SQLITE_MISUSE_BKPT; 326 db = p->db; 327 sqlite3_mutex_enter(db->mutex); 328 v = (Vdbe*)p->pStmt; 329 330 if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){ 331 /* Request is out of range. Return a transient error. */ 332 rc = SQLITE_ERROR; 333 sqlite3Error(db, SQLITE_ERROR, 0); 334 } else if( v==0 ){ 335 /* If there is no statement handle, then the blob-handle has 336 ** already been invalidated. Return SQLITE_ABORT in this case. 337 */ 338 rc = SQLITE_ABORT; 339 }else{ 340 /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is 341 ** returned, clean-up the statement handle. 342 */ 343 assert( db == v->db ); 344 sqlite3BtreeEnterCursor(p->pCsr); 345 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z); 346 sqlite3BtreeLeaveCursor(p->pCsr); 347 if( rc==SQLITE_ABORT ){ 348 sqlite3VdbeFinalize(v); 349 p->pStmt = 0; 350 }else{ 351 db->errCode = rc; 352 v->rc = rc; 353 } 354 } 355 rc = sqlite3ApiExit(db, rc); 356 sqlite3_mutex_leave(db->mutex); 357 return rc; 358 } 359 360 /* 361 ** Read data from a blob handle. 362 */ 363 int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){ 364 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData); 365 } 366 367 /* 368 ** Write data to a blob handle. 369 */ 370 int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){ 371 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData); 372 } 373 374 /* 375 ** Query a blob handle for the size of the data. 376 ** 377 ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob 378 ** so no mutex is required for access. 379 */ 380 int sqlite3_blob_bytes(sqlite3_blob *pBlob){ 381 Incrblob *p = (Incrblob *)pBlob; 382 return p ? p->nByte : 0; 383 } 384 385 #endif /* #ifndef SQLITE_OMIT_INCRBLOB */ 386