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