third_party/sqlite/sqlite-src-3080704/src/vdbeblob.c

   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   int iCol;               /* Table column this handle is open on */
  30   BtCursor *pCsr;         /* Cursor pointing at blob row */
  31   sqlite3_stmt *pStmt;    /* Statement holding cursor open */
  32   sqlite3 *db;            /* The associated database */
  33 };
  34
  35
  36 /*
  37 ** This function is used by both blob_open() and blob_reopen(). It seeks
  38 ** the b-tree cursor associated with blob handle p to point to row iRow.
  39 ** If successful, SQLITE_OK is returned and subsequent calls to
  40 ** sqlite3_blob_read() or sqlite3_blob_write() access the specified row.
  41 **
  42 ** If an error occurs, or if the specified row does not exist or does not
  43 ** contain a value of type TEXT or BLOB in the column nominated when the
  44 ** blob handle was opened, then an error code is returned and *pzErr may
  45 ** be set to point to a buffer containing an error message. It is the
  46 ** responsibility of the caller to free the error message buffer using
  47 ** sqlite3DbFree().
  48 **
  49 ** If an error does occur, then the b-tree cursor is closed. All subsequent
  50 ** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will
  51 ** immediately return SQLITE_ABORT.
  52 */
  53 static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){
  54   int rc;                         /* Error code */
  55   char *zErr = 0;                 /* Error message */
  56   Vdbe *v = (Vdbe *)p->pStmt;
  57
  58   /* Set the value of the SQL statements only variable to integer iRow.
  59   ** This is done directly instead of using sqlite3_bind_int64() to avoid
  60   ** triggering asserts related to mutexes.
  61   */
  62   assert( v->aVar[0].flags&MEM_Int );
  63   v->aVar[0].u.i = iRow;
  64
  65   rc = sqlite3_step(p->pStmt);
  66   if( rc==SQLITE_ROW ){
  67     VdbeCursor *pC = v->apCsr[0];
  68     u32 type = pC->aType[p->iCol];
  69     if( type<12 ){
  70       zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
  71           type==0?"null": type==7?"real": "integer"
  72       );
  73       rc = SQLITE_ERROR;
  74       sqlite3_finalize(p->pStmt);
  75       p->pStmt = 0;
  76     }else{
  77       p->iOffset = pC->aType[p->iCol + pC->nField];
  78       p->nByte = sqlite3VdbeSerialTypeLen(type);
  79       p->pCsr =  pC->pCursor;
  80       sqlite3BtreeIncrblobCursor(p->pCsr);
  81     }
  82   }
  83
  84   if( rc==SQLITE_ROW ){
  85     rc = SQLITE_OK;
  86   }else if( p->pStmt ){
  87     rc = sqlite3_finalize(p->pStmt);
  88     p->pStmt = 0;
  89     if( rc==SQLITE_OK ){
  90       zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
  91       rc = SQLITE_ERROR;
  92     }else{
  93       zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
  94     }
  95   }
  96
  97   assert( rc!=SQLITE_OK || zErr==0 );
  98   assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
  99
 100   *pzErr = zErr;
 101   return rc;
 102 }
 103
 104 /*
 105 ** Open a blob handle.
 106 */
 107 int sqlite3_blob_open(
 108   sqlite3* db,            /* The database connection */
 109   const char *zDb,        /* The attached database containing the blob */
 110   const char *zTable,     /* The table containing the blob */
 111   const char *zColumn,    /* The column containing the blob */
 112   sqlite_int64 iRow,      /* The row containing the glob */
 113   int flags,              /* True -> read/write access, false -> read-only */
 114   sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */
 115 ){
 116   int nAttempt = 0;
 117   int iCol;               /* Index of zColumn in row-record */
 118
 119   /* This VDBE program seeks a btree cursor to the identified
 120   ** db/table/row entry. The reason for using a vdbe program instead
 121   ** of writing code to use the b-tree layer directly is that the
 122   ** vdbe program will take advantage of the various transaction,
 123   ** locking and error handling infrastructure built into the vdbe.
 124   **
 125   ** After seeking the cursor, the vdbe executes an OP_ResultRow.
 126   ** Code external to the Vdbe then "borrows" the b-tree cursor and
 127   ** uses it to implement the blob_read(), blob_write() and
 128   ** blob_bytes() functions.
 129   **
 130   ** The sqlite3_blob_close() function finalizes the vdbe program,
 131   ** which closes the b-tree cursor and (possibly) commits the
 132   ** transaction.
 133   */
 134   static const int iLn = VDBE_OFFSET_LINENO(4);
 135   static const VdbeOpList openBlob[] = {
 136     /* {OP_Transaction, 0, 0, 0},  // 0: Inserted separately */
 137     {OP_TableLock, 0, 0, 0},       /* 1: Acquire a read or write lock */
 138     /* One of the following two instructions is replaced by an OP_Noop. */
 139     {OP_OpenRead, 0, 0, 0},        /* 2: Open cursor 0 for reading */
 140     {OP_OpenWrite, 0, 0, 0},       /* 3: Open cursor 0 for read/write */
 141     {OP_Variable, 1, 1, 1},        /* 4: Push the rowid to the stack */
 142     {OP_NotExists, 0, 10, 1},      /* 5: Seek the cursor */
 143     {OP_Column, 0, 0, 1},          /* 6  */
 144     {OP_ResultRow, 1, 0, 0},       /* 7  */
 145     {OP_Goto, 0, 4, 0},            /* 8  */
 146     {OP_Close, 0, 0, 0},           /* 9  */
 147     {OP_Halt, 0, 0, 0},            /* 10 */
 148   };
 149
 150   int rc = SQLITE_OK;
 151   char *zErr = 0;
 152   Table *pTab;
 153   Parse *pParse = 0;
 154   Incrblob *pBlob = 0;
 155
 156   flags = !!flags;                /* flags = (flags ? 1 : 0); */
 157   *ppBlob = 0;
 158
 159   sqlite3_mutex_enter(db->mutex);
 160
 161   pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
 162   if( !pBlob ) goto blob_open_out;
 163   pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
 164   if( !pParse ) goto blob_open_out;
 165
 166   do {
 167     memset(pParse, 0, sizeof(Parse));
 168     pParse->db = db;
 169     sqlite3DbFree(db, zErr);
 170     zErr = 0;
 171
 172     sqlite3BtreeEnterAll(db);
 173     pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
 174     if( pTab && IsVirtual(pTab) ){
 175       pTab = 0;
 176       sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
 177     }
 178     if( pTab && !HasRowid(pTab) ){
 179       pTab = 0;
 180       sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
 181     }
 182 #ifndef SQLITE_OMIT_VIEW
 183     if( pTab && pTab->pSelect ){
 184       pTab = 0;
 185       sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
 186     }
 187 #endif
 188     if( !pTab ){
 189       if( pParse->zErrMsg ){
 190         sqlite3DbFree(db, zErr);
 191         zErr = pParse->zErrMsg;
 192         pParse->zErrMsg = 0;
 193       }
 194       rc = SQLITE_ERROR;
 195       sqlite3BtreeLeaveAll(db);
 196       goto blob_open_out;
 197     }
 198
 199     /* Now search pTab for the exact column. */
 200     for(iCol=0; iCol<pTab->nCol; iCol++) {
 201       if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
 202         break;
 203       }
 204     }
 205     if( iCol==pTab->nCol ){
 206       sqlite3DbFree(db, zErr);
 207       zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
 208       rc = SQLITE_ERROR;
 209       sqlite3BtreeLeaveAll(db);
 210       goto blob_open_out;
 211     }
 212
 213     /* If the value is being opened for writing, check that the
 214     ** column is not indexed, and that it is not part of a foreign key.
 215     ** It is against the rules to open a column to which either of these
 216     ** descriptions applies for writing.  */
 217     if( flags ){
 218       const char *zFault = 0;
 219       Index *pIdx;
 220 #ifndef SQLITE_OMIT_FOREIGN_KEY
 221       if( db->flags&SQLITE_ForeignKeys ){
 222         /* Check that the column is not part of an FK child key definition. It
 223         ** is not necessary to check if it is part of a parent key, as parent
 224         ** key columns must be indexed. The check below will pick up this
 225         ** case.  */
 226         FKey *pFKey;
 227         for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
 228           int j;
 229           for(j=0; j<pFKey->nCol; j++){
 230             if( pFKey->aCol[j].iFrom==iCol ){
 231               zFault = "foreign key";
 232             }
 233           }
 234         }
 235       }
 236 #endif
 237       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
 238         int j;
 239         for(j=0; j<pIdx->nKeyCol; j++){
 240           if( pIdx->aiColumn[j]==iCol ){
 241             zFault = "indexed";
 242           }
 243         }
 244       }
 245       if( zFault ){
 246         sqlite3DbFree(db, zErr);
 247         zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
 248         rc = SQLITE_ERROR;
 249         sqlite3BtreeLeaveAll(db);
 250         goto blob_open_out;
 251       }
 252     }
 253
 254     pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
 255     assert( pBlob->pStmt || db->mallocFailed );
 256     if( pBlob->pStmt ){
 257       Vdbe *v = (Vdbe *)pBlob->pStmt;
 258       int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
 259
 260
 261       sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags,
 262                            pTab->pSchema->schema_cookie,
 263                            pTab->pSchema->iGeneration);
 264       sqlite3VdbeChangeP5(v, 1);
 265       sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
 266
 267       /* Make sure a mutex is held on the table to be accessed */
 268       sqlite3VdbeUsesBtree(v, iDb);
 269
 270       /* Configure the OP_TableLock instruction */
 271 #ifdef SQLITE_OMIT_SHARED_CACHE
 272       sqlite3VdbeChangeToNoop(v, 1);
 273 #else
 274       sqlite3VdbeChangeP1(v, 1, iDb);
 275       sqlite3VdbeChangeP2(v, 1, pTab->tnum);
 276       sqlite3VdbeChangeP3(v, 1, flags);
 277       sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
 278 #endif
 279
 280       /* Remove either the OP_OpenWrite or OpenRead. Set the P2
 281       ** parameter of the other to pTab->tnum.  */
 282       sqlite3VdbeChangeToNoop(v, 3 - flags);
 283       sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
 284       sqlite3VdbeChangeP3(v, 2 + flags, iDb);
 285
 286       /* Configure the number of columns. Configure the cursor to
 287       ** think that the table has one more column than it really
 288       ** does. An OP_Column to retrieve this imaginary column will
 289       ** always return an SQL NULL. This is useful because it means
 290       ** we can invoke OP_Column to fill in the vdbe cursors type
 291       ** and offset cache without causing any IO.
 292       */
 293       sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
 294       sqlite3VdbeChangeP2(v, 6, pTab->nCol);
 295       if( !db->mallocFailed ){
 296         pParse->nVar = 1;
 297         pParse->nMem = 1;
 298         pParse->nTab = 1;
 299         sqlite3VdbeMakeReady(v, pParse);
 300       }
 301     }
 302
 303     pBlob->flags = flags;
 304     pBlob->iCol = iCol;
 305     pBlob->db = db;
 306     sqlite3BtreeLeaveAll(db);
 307     if( db->mallocFailed ){
 308       goto blob_open_out;
 309     }
 310     sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
 311     rc = blobSeekToRow(pBlob, iRow, &zErr);
 312   } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
 313
 314 blob_open_out:
 315   if( rc==SQLITE_OK && db->mallocFailed==0 ){
 316     *ppBlob = (sqlite3_blob *)pBlob;
 317   }else{
 318     if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
 319     sqlite3DbFree(db, pBlob);
 320   }
 321   sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
 322   sqlite3DbFree(db, zErr);
 323   sqlite3ParserReset(pParse);
 324   sqlite3StackFree(db, pParse);
 325   rc = sqlite3ApiExit(db, rc);
 326   sqlite3_mutex_leave(db->mutex);
 327   return rc;
 328 }
 329
 330 /*
 331 ** Close a blob handle that was previously created using
 332 ** sqlite3_blob_open().
 333 */
 334 int sqlite3_blob_close(sqlite3_blob *pBlob){
 335   Incrblob *p = (Incrblob *)pBlob;
 336   int rc;
 337   sqlite3 *db;
 338
 339   if( p ){
 340     db = p->db;
 341     sqlite3_mutex_enter(db->mutex);
 342     rc = sqlite3_finalize(p->pStmt);
 343     sqlite3DbFree(db, p);
 344     sqlite3_mutex_leave(db->mutex);
 345   }else{
 346     rc = SQLITE_OK;
 347   }
 348   return rc;
 349 }
 350
 351 /*
 352 ** Perform a read or write operation on a blob
 353 */
 354 static int blobReadWrite(
 355   sqlite3_blob *pBlob,
 356   void *z,
 357   int n,
 358   int iOffset,
 359   int (*xCall)(BtCursor*, u32, u32, void*)
 360 ){
 361   int rc;
 362   Incrblob *p = (Incrblob *)pBlob;
 363   Vdbe *v;
 364   sqlite3 *db;
 365
 366   if( p==0 ) return SQLITE_MISUSE_BKPT;
 367   db = p->db;
 368   sqlite3_mutex_enter(db->mutex);
 369   v = (Vdbe*)p->pStmt;
 370
 371   if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
 372     /* Request is out of range. Return a transient error. */
 373     rc = SQLITE_ERROR;
 374     sqlite3Error(db, SQLITE_ERROR);
 375   }else if( v==0 ){
 376     /* If there is no statement handle, then the blob-handle has
 377     ** already been invalidated. Return SQLITE_ABORT in this case.
 378     */
 379     rc = SQLITE_ABORT;
 380   }else{
 381     /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
 382     ** returned, clean-up the statement handle.
 383     */
 384     assert( db == v->db );
 385     sqlite3BtreeEnterCursor(p->pCsr);
 386     rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
 387     sqlite3BtreeLeaveCursor(p->pCsr);
 388     if( rc==SQLITE_ABORT ){
 389       sqlite3VdbeFinalize(v);
 390       p->pStmt = 0;
 391     }else{
 392       db->errCode = rc;
 393       v->rc = rc;
 394     }
 395   }
 396   rc = sqlite3ApiExit(db, rc);
 397   sqlite3_mutex_leave(db->mutex);
 398   return rc;
 399 }
 400
 401 /*
 402 ** Read data from a blob handle.
 403 */
 404 int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
 405   return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
 406 }
 407
 408 /*
 409 ** Write data to a blob handle.
 410 */
 411 int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
 412   return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
 413 }
 414
 415 /*
 416 ** Query a blob handle for the size of the data.
 417 **
 418 ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
 419 ** so no mutex is required for access.
 420 */
 421 int sqlite3_blob_bytes(sqlite3_blob *pBlob){
 422   Incrblob *p = (Incrblob *)pBlob;
 423   return (p && p->pStmt) ? p->nByte : 0;
 424 }
 425
 426 /*
 427 ** Move an existing blob handle to point to a different row of the same
 428 ** database table.
 429 **
 430 ** If an error occurs, or if the specified row does not exist or does not
 431 ** contain a blob or text value, then an error code is returned and the
 432 ** database handle error code and message set. If this happens, then all
 433 ** subsequent calls to sqlite3_blob_xxx() functions (except blob_close())
 434 ** immediately return SQLITE_ABORT.
 435 */
 436 int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
 437   int rc;
 438   Incrblob *p = (Incrblob *)pBlob;
 439   sqlite3 *db;
 440
 441   if( p==0 ) return SQLITE_MISUSE_BKPT;
 442   db = p->db;
 443   sqlite3_mutex_enter(db->mutex);
 444
 445   if( p->pStmt==0 ){
 446     /* If there is no statement handle, then the blob-handle has
 447     ** already been invalidated. Return SQLITE_ABORT in this case.
 448     */
 449     rc = SQLITE_ABORT;
 450   }else{
 451     char *zErr;
 452     rc = blobSeekToRow(p, iRow, &zErr);
 453     if( rc!=SQLITE_OK ){
 454       sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
 455       sqlite3DbFree(db, zErr);
 456     }
 457     assert( rc!=SQLITE_SCHEMA );
 458   }
 459
 460   rc = sqlite3ApiExit(db, rc);
 461   assert( rc==SQLITE_OK || p->pStmt==0 );
 462   sqlite3_mutex_leave(db->mutex);
 463   return rc;
 464 }
 465
 466 #endif /* #ifndef SQLITE_OMIT_INCRBLOB */