blob: 0fbc1ad477e9af09bebfbe6d70bd8335633d05a1 [file] [log] [blame]
danielk1977b4e9af92007-05-01 17:49:49 +00001/*
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**
drh16a9b832007-05-05 18:39:25 +000013** This file contains code used to implement incremental BLOB I/O.
danielk1977b4e9af92007-05-01 17:49:49 +000014*/
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*/
24typedef struct Incrblob Incrblob;
danielk1977b4e9af92007-05-01 17:49:49 +000025struct 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 */
dan4e76cc32010-10-20 18:56:04 +000029 int iCol; /* Table column this handle is open on */
danielk1977b4e9af92007-05-01 17:49:49 +000030 BtCursor *pCsr; /* Cursor pointing at blob row */
31 sqlite3_stmt *pStmt; /* Statement holding cursor open */
drh605264d2007-08-21 15:13:19 +000032 sqlite3 *db; /* The associated database */
danielk1977b4e9af92007-05-01 17:49:49 +000033};
34
dan4e76cc32010-10-20 18:56:04 +000035
dane3d82a82010-10-26 11:56:57 +000036/*
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*/
dan4e76cc32010-10-20 18:56:04 +000053static 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
dane3d82a82010-10-26 11:56:57 +000058 /* 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 );
dan4e76cc32010-10-20 18:56:04 +000063 v->aVar[0].u.i = iRow;
dan4e76cc32010-10-20 18:56:04 +000064
dane3d82a82010-10-26 11:56:57 +000065 rc = sqlite3_step(p->pStmt);
dan4e76cc32010-10-20 18:56:04 +000066 if( rc==SQLITE_ROW ){
drh14da87f2013-11-20 21:51:33 +000067 VdbeCursor *pC = v->apCsr[0];
68 u32 type = pC->aType[p->iCol];
dan4e76cc32010-10-20 18:56:04 +000069 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{
drh14da87f2013-11-20 21:51:33 +000077 p->iOffset = pC->aType[p->iCol + pC->nField];
dan4e76cc32010-10-20 18:56:04 +000078 p->nByte = sqlite3VdbeSerialTypeLen(type);
drh14da87f2013-11-20 21:51:33 +000079 p->pCsr = pC->pCursor;
dan4e76cc32010-10-20 18:56:04 +000080 sqlite3BtreeEnterCursor(p->pCsr);
81 sqlite3BtreeCacheOverflow(p->pCsr);
82 sqlite3BtreeLeaveCursor(p->pCsr);
83 }
84 }
85
86 if( rc==SQLITE_ROW ){
87 rc = SQLITE_OK;
88 }else if( p->pStmt ){
89 rc = sqlite3_finalize(p->pStmt);
90 p->pStmt = 0;
91 if( rc==SQLITE_OK ){
92 zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
93 rc = SQLITE_ERROR;
94 }else{
95 zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
96 }
97 }
98
99 assert( rc!=SQLITE_OK || zErr==0 );
100 assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
101
102 *pzErr = zErr;
103 return rc;
104}
105
danielk1977b4e9af92007-05-01 17:49:49 +0000106/*
107** Open a blob handle.
108*/
109int sqlite3_blob_open(
drh16a9b832007-05-05 18:39:25 +0000110 sqlite3* db, /* The database connection */
111 const char *zDb, /* The attached database containing the blob */
112 const char *zTable, /* The table containing the blob */
113 const char *zColumn, /* The column containing the blob */
114 sqlite_int64 iRow, /* The row containing the glob */
danielk1977b4e9af92007-05-01 17:49:49 +0000115 int flags, /* True -> read/write access, false -> read-only */
drh16a9b832007-05-05 18:39:25 +0000116 sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
danielk1977b4e9af92007-05-01 17:49:49 +0000117){
danielk1977b4e9af92007-05-01 17:49:49 +0000118 int nAttempt = 0;
119 int iCol; /* Index of zColumn in row-record */
120
121 /* This VDBE program seeks a btree cursor to the identified
122 ** db/table/row entry. The reason for using a vdbe program instead
123 ** of writing code to use the b-tree layer directly is that the
124 ** vdbe program will take advantage of the various transaction,
125 ** locking and error handling infrastructure built into the vdbe.
126 **
drh2d401ab2008-01-10 23:50:11 +0000127 ** After seeking the cursor, the vdbe executes an OP_ResultRow.
danielk1977b4e9af92007-05-01 17:49:49 +0000128 ** Code external to the Vdbe then "borrows" the b-tree cursor and
129 ** uses it to implement the blob_read(), blob_write() and
130 ** blob_bytes() functions.
131 **
132 ** The sqlite3_blob_close() function finalizes the vdbe program,
133 ** which closes the b-tree cursor and (possibly) commits the
134 ** transaction.
135 */
136 static const VdbeOpList openBlob[] = {
drhb22f7c82014-02-06 23:56:27 +0000137 /* {OP_Transaction, 0, 0, 0}, // 0: Inserted separately */
138 {OP_TableLock, 0, 0, 0}, /* 1: Acquire a read or write lock */
danielk1977b4e9af92007-05-01 17:49:49 +0000139
danielk197796d48e92009-06-29 06:00:37 +0000140 /* One of the following two instructions is replaced by an OP_Noop. */
drhb22f7c82014-02-06 23:56:27 +0000141 {OP_OpenRead, 0, 0, 0}, /* 2: Open cursor 0 for reading */
142 {OP_OpenWrite, 0, 0, 0}, /* 3: Open cursor 0 for read/write */
danielk1977b4e9af92007-05-01 17:49:49 +0000143
drhb22f7c82014-02-06 23:56:27 +0000144 {OP_Variable, 1, 1, 1}, /* 4: Push the rowid to the stack */
145 {OP_NotExists, 0, 10, 1}, /* 5: Seek the cursor */
146 {OP_Column, 0, 0, 1}, /* 6 */
147 {OP_ResultRow, 1, 0, 0}, /* 7 */
148 {OP_Goto, 0, 4, 0}, /* 8 */
149 {OP_Close, 0, 0, 0}, /* 9 */
150 {OP_Halt, 0, 0, 0}, /* 10 */
danielk1977b4e9af92007-05-01 17:49:49 +0000151 };
152
danielk19778cbadb02007-05-03 16:31:26 +0000153 int rc = SQLITE_OK;
drh6ee700c2009-06-01 19:53:30 +0000154 char *zErr = 0;
155 Table *pTab;
dan61c7f592010-10-26 18:42:52 +0000156 Parse *pParse = 0;
157 Incrblob *pBlob = 0;
danielk1977b4e9af92007-05-01 17:49:49 +0000158
dan4e76cc32010-10-20 18:56:04 +0000159 flags = !!flags; /* flags = (flags ? 1 : 0); */
drh28414ee2009-05-09 15:17:47 +0000160 *ppBlob = 0;
dan4e76cc32010-10-20 18:56:04 +0000161
drh605264d2007-08-21 15:13:19 +0000162 sqlite3_mutex_enter(db->mutex);
dan4e76cc32010-10-20 18:56:04 +0000163
164 pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
dan61c7f592010-10-26 18:42:52 +0000165 if( !pBlob ) goto blob_open_out;
drh6ee700c2009-06-01 19:53:30 +0000166 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
dan61c7f592010-10-26 18:42:52 +0000167 if( !pParse ) goto blob_open_out;
dan4e76cc32010-10-20 18:56:04 +0000168
danielk1977b4e9af92007-05-01 17:49:49 +0000169 do {
drh6ee700c2009-06-01 19:53:30 +0000170 memset(pParse, 0, sizeof(Parse));
171 pParse->db = db;
dan61c7f592010-10-26 18:42:52 +0000172 sqlite3DbFree(db, zErr);
173 zErr = 0;
danielk1977b4e9af92007-05-01 17:49:49 +0000174
drhff0587c2007-08-29 17:43:19 +0000175 sqlite3BtreeEnterAll(db);
drh6ee700c2009-06-01 19:53:30 +0000176 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
danielk197736961ed2008-04-24 09:49:55 +0000177 if( pTab && IsVirtual(pTab) ){
178 pTab = 0;
drh6ee700c2009-06-01 19:53:30 +0000179 sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
danielk197736961ed2008-04-24 09:49:55 +0000180 }
drh63f0eed2013-11-02 22:09:48 +0000181 if( pTab && !HasRowid(pTab) ){
182 pTab = 0;
183 sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
184 }
danielk197736961ed2008-04-24 09:49:55 +0000185#ifndef SQLITE_OMIT_VIEW
186 if( pTab && pTab->pSelect ){
187 pTab = 0;
drh6ee700c2009-06-01 19:53:30 +0000188 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
danielk197736961ed2008-04-24 09:49:55 +0000189 }
190#endif
danielk1977b4e9af92007-05-01 17:49:49 +0000191 if( !pTab ){
drh6ee700c2009-06-01 19:53:30 +0000192 if( pParse->zErrMsg ){
193 sqlite3DbFree(db, zErr);
194 zErr = pParse->zErrMsg;
195 pParse->zErrMsg = 0;
danielk19778cbadb02007-05-03 16:31:26 +0000196 }
danielk19778cbadb02007-05-03 16:31:26 +0000197 rc = SQLITE_ERROR;
drhff0587c2007-08-29 17:43:19 +0000198 sqlite3BtreeLeaveAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000199 goto blob_open_out;
200 }
201
202 /* Now search pTab for the exact column. */
dan61c7f592010-10-26 18:42:52 +0000203 for(iCol=0; iCol<pTab->nCol; iCol++) {
danielk1977b4e9af92007-05-01 17:49:49 +0000204 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
205 break;
206 }
207 }
208 if( iCol==pTab->nCol ){
drh6ee700c2009-06-01 19:53:30 +0000209 sqlite3DbFree(db, zErr);
210 zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
danielk1977b4e9af92007-05-01 17:49:49 +0000211 rc = SQLITE_ERROR;
drhff0587c2007-08-29 17:43:19 +0000212 sqlite3BtreeLeaveAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000213 goto blob_open_out;
214 }
215
danielk1977f1819242007-05-03 18:14:10 +0000216 /* If the value is being opened for writing, check that the
dan1da40a32009-09-19 17:00:31 +0000217 ** column is not indexed, and that it is not part of a foreign key.
218 ** It is against the rules to open a column to which either of these
219 ** descriptions applies for writing. */
danielk1977f1819242007-05-03 18:14:10 +0000220 if( flags ){
dan1da40a32009-09-19 17:00:31 +0000221 const char *zFault = 0;
danielk1977f1819242007-05-03 18:14:10 +0000222 Index *pIdx;
dan1da40a32009-09-19 17:00:31 +0000223#ifndef SQLITE_OMIT_FOREIGN_KEY
224 if( db->flags&SQLITE_ForeignKeys ){
dan13167002009-10-02 06:35:06 +0000225 /* Check that the column is not part of an FK child key definition. It
226 ** is not necessary to check if it is part of a parent key, as parent
227 ** key columns must be indexed. The check below will pick up this
228 ** case. */
dan1da40a32009-09-19 17:00:31 +0000229 FKey *pFKey;
230 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
231 int j;
232 for(j=0; j<pFKey->nCol; j++){
233 if( pFKey->aCol[j].iFrom==iCol ){
234 zFault = "foreign key";
235 }
236 }
237 }
238 }
239#endif
danielk1977f1819242007-05-03 18:14:10 +0000240 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
241 int j;
drhbbbdc832013-10-22 18:01:40 +0000242 for(j=0; j<pIdx->nKeyCol; j++){
danielk1977f1819242007-05-03 18:14:10 +0000243 if( pIdx->aiColumn[j]==iCol ){
dan1da40a32009-09-19 17:00:31 +0000244 zFault = "indexed";
danielk1977f1819242007-05-03 18:14:10 +0000245 }
246 }
247 }
dan1da40a32009-09-19 17:00:31 +0000248 if( zFault ){
249 sqlite3DbFree(db, zErr);
250 zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
251 rc = SQLITE_ERROR;
dan1da40a32009-09-19 17:00:31 +0000252 sqlite3BtreeLeaveAll(db);
253 goto blob_open_out;
254 }
danielk1977f1819242007-05-03 18:14:10 +0000255 }
256
drh9ac79622013-12-18 15:11:47 +0000257 pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
dan61c7f592010-10-26 18:42:52 +0000258 assert( pBlob->pStmt || db->mallocFailed );
259 if( pBlob->pStmt ){
260 Vdbe *v = (Vdbe *)pBlob->pStmt;
danielk1977b4e9af92007-05-01 17:49:49 +0000261 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
dan61c7f592010-10-26 18:42:52 +0000262
drhb22f7c82014-02-06 23:56:27 +0000263
264 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags,
265 pTab->pSchema->schema_cookie,
266 pTab->pSchema->iGeneration);
267 sqlite3VdbeChangeP5(v, 1);
danielk1977b4e9af92007-05-01 17:49:49 +0000268 sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
269
drhff0587c2007-08-29 17:43:19 +0000270 /* Make sure a mutex is held on the table to be accessed */
drhfb982642007-08-30 01:19:59 +0000271 sqlite3VdbeUsesBtree(v, iDb);
drhff0587c2007-08-29 17:43:19 +0000272
danielk197796d48e92009-06-29 06:00:37 +0000273 /* Configure the OP_TableLock instruction */
danc548b782010-06-19 19:06:33 +0000274#ifdef SQLITE_OMIT_SHARED_CACHE
drhb22f7c82014-02-06 23:56:27 +0000275 sqlite3VdbeChangeToNoop(v, 1);
danc548b782010-06-19 19:06:33 +0000276#else
drhb22f7c82014-02-06 23:56:27 +0000277 sqlite3VdbeChangeP1(v, 1, iDb);
278 sqlite3VdbeChangeP2(v, 1, pTab->tnum);
279 sqlite3VdbeChangeP3(v, 1, flags);
280 sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
danc548b782010-06-19 19:06:33 +0000281#endif
danielk197796d48e92009-06-29 06:00:37 +0000282
danielk1977f1819242007-05-03 18:14:10 +0000283 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
danielk197796d48e92009-06-29 06:00:37 +0000284 ** parameter of the other to pTab->tnum. */
drhb22f7c82014-02-06 23:56:27 +0000285 sqlite3VdbeChangeToNoop(v, 3 - flags);
286 sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
287 sqlite3VdbeChangeP3(v, 2 + flags, iDb);
danielk1977b4e9af92007-05-01 17:49:49 +0000288
danielk1977d336e222009-02-20 10:58:41 +0000289 /* Configure the number of columns. Configure the cursor to
danielk1977b4e9af92007-05-01 17:49:49 +0000290 ** think that the table has one more column than it really
291 ** does. An OP_Column to retrieve this imaginary column will
292 ** always return an SQL NULL. This is useful because it means
293 ** we can invoke OP_Column to fill in the vdbe cursors type
294 ** and offset cache without causing any IO.
295 */
drhb22f7c82014-02-06 23:56:27 +0000296 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
297 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
drh17435752007-08-16 04:30:38 +0000298 if( !db->mallocFailed ){
drh124c0b42011-06-01 18:15:55 +0000299 pParse->nVar = 1;
300 pParse->nMem = 1;
301 pParse->nTab = 1;
302 sqlite3VdbeMakeReady(v, pParse);
danielk197792d4d7a2007-05-04 12:05:56 +0000303 }
danielk1977b4e9af92007-05-01 17:49:49 +0000304 }
drhff0587c2007-08-29 17:43:19 +0000305
danielk1977b4e9af92007-05-01 17:49:49 +0000306 pBlob->flags = flags;
dan4e76cc32010-10-20 18:56:04 +0000307 pBlob->iCol = iCol;
drh605264d2007-08-21 15:13:19 +0000308 pBlob->db = db;
dan4e76cc32010-10-20 18:56:04 +0000309 sqlite3BtreeLeaveAll(db);
dan4e76cc32010-10-20 18:56:04 +0000310 if( db->mallocFailed ){
311 goto blob_open_out;
312 }
dan4e76cc32010-10-20 18:56:04 +0000313 sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
314 rc = blobSeekToRow(pBlob, iRow, &zErr);
drh60625312013-04-06 18:06:51 +0000315 } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
danielk1977b4e9af92007-05-01 17:49:49 +0000316
317blob_open_out:
dan4e76cc32010-10-20 18:56:04 +0000318 if( rc==SQLITE_OK && db->mallocFailed==0 ){
319 *ppBlob = (sqlite3_blob *)pBlob;
320 }else{
dan4e76cc32010-10-20 18:56:04 +0000321 if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
322 sqlite3DbFree(db, pBlob);
danielk1977b4e9af92007-05-01 17:49:49 +0000323 }
dan4e76cc32010-10-20 18:56:04 +0000324 sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);
drh6ee700c2009-06-01 19:53:30 +0000325 sqlite3DbFree(db, zErr);
drhf30a9692013-11-15 01:10:18 +0000326 sqlite3ParserReset(pParse);
drh6ee700c2009-06-01 19:53:30 +0000327 sqlite3StackFree(db, pParse);
drh605264d2007-08-21 15:13:19 +0000328 rc = sqlite3ApiExit(db, rc);
329 sqlite3_mutex_leave(db->mutex);
330 return rc;
danielk1977b4e9af92007-05-01 17:49:49 +0000331}
332
333/*
drh16a9b832007-05-05 18:39:25 +0000334** Close a blob handle that was previously created using
335** sqlite3_blob_open().
danielk1977b4e9af92007-05-01 17:49:49 +0000336*/
337int sqlite3_blob_close(sqlite3_blob *pBlob){
338 Incrblob *p = (Incrblob *)pBlob;
drh605264d2007-08-21 15:13:19 +0000339 int rc;
drhd9da78a2009-03-24 15:08:09 +0000340 sqlite3 *db;
drh605264d2007-08-21 15:13:19 +0000341
drh28414ee2009-05-09 15:17:47 +0000342 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 }
drh605264d2007-08-21 15:13:19 +0000351 return rc;
danielk1977b4e9af92007-05-01 17:49:49 +0000352}
353
drh605264d2007-08-21 15:13:19 +0000354/*
355** Perform a read or write operation on a blob
356*/
drhee858132007-05-08 20:37:38 +0000357static int blobReadWrite(
danielk1977dcbb5d32007-05-04 18:36:44 +0000358 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;
drh605264d2007-08-21 15:13:19 +0000366 Vdbe *v;
drh28414ee2009-05-09 15:17:47 +0000367 sqlite3 *db;
danielk1977dcbb5d32007-05-04 18:36:44 +0000368
drh413c3d32010-02-23 20:11:56 +0000369 if( p==0 ) return SQLITE_MISUSE_BKPT;
drh28414ee2009-05-09 15:17:47 +0000370 db = p->db;
drh605264d2007-08-21 15:13:19 +0000371 sqlite3_mutex_enter(db->mutex);
drh605264d2007-08-21 15:13:19 +0000372 v = (Vdbe*)p->pStmt;
danielk1977a8b30182008-10-02 14:49:01 +0000373
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);
dan4e76cc32010-10-20 18:56:04 +0000378 }else if( v==0 ){
danielk1977a8b30182008-10-02 14:49:01 +0000379 /* If there is no statement handle, then the blob-handle has
380 ** already been invalidated. Return SQLITE_ABORT in this case.
381 */
drh605264d2007-08-21 15:13:19 +0000382 rc = SQLITE_ABORT;
danielk1977dcbb5d32007-05-04 18:36:44 +0000383 }else{
drh605264d2007-08-21 15:13:19 +0000384 /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
385 ** returned, clean-up the statement handle.
386 */
387 assert( db == v->db );
drhff0587c2007-08-29 17:43:19 +0000388 sqlite3BtreeEnterCursor(p->pCsr);
drh605264d2007-08-21 15:13:19 +0000389 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
drhff0587c2007-08-29 17:43:19 +0000390 sqlite3BtreeLeaveCursor(p->pCsr);
drh605264d2007-08-21 15:13:19 +0000391 if( rc==SQLITE_ABORT ){
392 sqlite3VdbeFinalize(v);
393 p->pStmt = 0;
394 }else{
395 db->errCode = rc;
396 v->rc = rc;
397 }
danielk1977dcbb5d32007-05-04 18:36:44 +0000398 }
drh605264d2007-08-21 15:13:19 +0000399 rc = sqlite3ApiExit(db, rc);
400 sqlite3_mutex_leave(db->mutex);
401 return rc;
danielk1977dcbb5d32007-05-04 18:36:44 +0000402}
403
danielk1977b4e9af92007-05-01 17:49:49 +0000404/*
405** Read data from a blob handle.
406*/
407int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
danielk1977dcbb5d32007-05-04 18:36:44 +0000408 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
danielk1977b4e9af92007-05-01 17:49:49 +0000409}
410
411/*
412** Write data to a blob handle.
413*/
414int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
danielk1977dcbb5d32007-05-04 18:36:44 +0000415 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
danielk1977b4e9af92007-05-01 17:49:49 +0000416}
417
418/*
419** Query a blob handle for the size of the data.
drh605264d2007-08-21 15:13:19 +0000420**
421** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
422** so no mutex is required for access.
danielk1977b4e9af92007-05-01 17:49:49 +0000423*/
424int sqlite3_blob_bytes(sqlite3_blob *pBlob){
425 Incrblob *p = (Incrblob *)pBlob;
daneefab752010-12-06 17:11:05 +0000426 return (p && p->pStmt) ? p->nByte : 0;
danielk1977b4e9af92007-05-01 17:49:49 +0000427}
428
dan4e76cc32010-10-20 18:56:04 +0000429/*
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*/
439int 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);
daneefab752010-12-06 17:11:05 +0000464 assert( rc==SQLITE_OK || p->pStmt==0 );
dan4e76cc32010-10-20 18:56:04 +0000465 sqlite3_mutex_leave(db->mutex);
466 return rc;
467}
468
danielk1977b4e9af92007-05-01 17:49:49 +0000469#endif /* #ifndef SQLITE_OMIT_INCRBLOB */