blob: f9015ad6f4b311d581abba4a263efd2facb41d54 [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);
drhc960dcb2015-11-20 19:22:01 +000079 p->pCsr = pC->uc.pCursor;
dan5a500af2014-03-11 20:33:04 +000080 sqlite3BtreeIncrblobCursor(p->pCsr);
dan4e76cc32010-10-20 18:56:04 +000081 }
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
danielk1977b4e9af92007-05-01 17:49:49 +0000104/*
105** Open a blob handle.
106*/
107int sqlite3_blob_open(
drh16a9b832007-05-05 18:39:25 +0000108 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 */
danielk1977b4e9af92007-05-01 17:49:49 +0000113 int flags, /* True -> read/write access, false -> read-only */
drh16a9b832007-05-05 18:39:25 +0000114 sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
danielk1977b4e9af92007-05-01 17:49:49 +0000115){
danielk1977b4e9af92007-05-01 17:49:49 +0000116 int nAttempt = 0;
117 int iCol; /* Index of zColumn in row-record */
danielk19778cbadb02007-05-03 16:31:26 +0000118 int rc = SQLITE_OK;
drh6ee700c2009-06-01 19:53:30 +0000119 char *zErr = 0;
120 Table *pTab;
dan61c7f592010-10-26 18:42:52 +0000121 Parse *pParse = 0;
122 Incrblob *pBlob = 0;
danielk1977b4e9af92007-05-01 17:49:49 +0000123
drh9ca95732014-10-24 00:35:58 +0000124#ifdef SQLITE_ENABLE_API_ARMOR
drhd10d18d2015-02-07 15:16:35 +0000125 if( ppBlob==0 ){
126 return SQLITE_MISUSE_BKPT;
127 }
128#endif
129 *ppBlob = 0;
130#ifdef SQLITE_ENABLE_API_ARMOR
131 if( !sqlite3SafetyCheckOk(db) || zTable==0 ){
drh9ca95732014-10-24 00:35:58 +0000132 return SQLITE_MISUSE_BKPT;
133 }
134#endif
dan4e76cc32010-10-20 18:56:04 +0000135 flags = !!flags; /* flags = (flags ? 1 : 0); */
dan4e76cc32010-10-20 18:56:04 +0000136
drh605264d2007-08-21 15:13:19 +0000137 sqlite3_mutex_enter(db->mutex);
dan4e76cc32010-10-20 18:56:04 +0000138
139 pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
dan61c7f592010-10-26 18:42:52 +0000140 if( !pBlob ) goto blob_open_out;
drh6ee700c2009-06-01 19:53:30 +0000141 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
dan61c7f592010-10-26 18:42:52 +0000142 if( !pParse ) goto blob_open_out;
dan4e76cc32010-10-20 18:56:04 +0000143
danielk1977b4e9af92007-05-01 17:49:49 +0000144 do {
drh6ee700c2009-06-01 19:53:30 +0000145 memset(pParse, 0, sizeof(Parse));
146 pParse->db = db;
dan61c7f592010-10-26 18:42:52 +0000147 sqlite3DbFree(db, zErr);
148 zErr = 0;
danielk1977b4e9af92007-05-01 17:49:49 +0000149
drhff0587c2007-08-29 17:43:19 +0000150 sqlite3BtreeEnterAll(db);
drh6ee700c2009-06-01 19:53:30 +0000151 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
danielk197736961ed2008-04-24 09:49:55 +0000152 if( pTab && IsVirtual(pTab) ){
153 pTab = 0;
drh6ee700c2009-06-01 19:53:30 +0000154 sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
danielk197736961ed2008-04-24 09:49:55 +0000155 }
drh63f0eed2013-11-02 22:09:48 +0000156 if( pTab && !HasRowid(pTab) ){
157 pTab = 0;
158 sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
159 }
danielk197736961ed2008-04-24 09:49:55 +0000160#ifndef SQLITE_OMIT_VIEW
161 if( pTab && pTab->pSelect ){
162 pTab = 0;
drh6ee700c2009-06-01 19:53:30 +0000163 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
danielk197736961ed2008-04-24 09:49:55 +0000164 }
165#endif
danielk1977b4e9af92007-05-01 17:49:49 +0000166 if( !pTab ){
drh6ee700c2009-06-01 19:53:30 +0000167 if( pParse->zErrMsg ){
168 sqlite3DbFree(db, zErr);
169 zErr = pParse->zErrMsg;
170 pParse->zErrMsg = 0;
danielk19778cbadb02007-05-03 16:31:26 +0000171 }
danielk19778cbadb02007-05-03 16:31:26 +0000172 rc = SQLITE_ERROR;
drhff0587c2007-08-29 17:43:19 +0000173 sqlite3BtreeLeaveAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000174 goto blob_open_out;
175 }
176
177 /* Now search pTab for the exact column. */
dan61c7f592010-10-26 18:42:52 +0000178 for(iCol=0; iCol<pTab->nCol; iCol++) {
danielk1977b4e9af92007-05-01 17:49:49 +0000179 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
180 break;
181 }
182 }
183 if( iCol==pTab->nCol ){
drh6ee700c2009-06-01 19:53:30 +0000184 sqlite3DbFree(db, zErr);
185 zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
danielk1977b4e9af92007-05-01 17:49:49 +0000186 rc = SQLITE_ERROR;
drhff0587c2007-08-29 17:43:19 +0000187 sqlite3BtreeLeaveAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000188 goto blob_open_out;
189 }
190
danielk1977f1819242007-05-03 18:14:10 +0000191 /* If the value is being opened for writing, check that the
dan1da40a32009-09-19 17:00:31 +0000192 ** column is not indexed, and that it is not part of a foreign key.
193 ** It is against the rules to open a column to which either of these
194 ** descriptions applies for writing. */
danielk1977f1819242007-05-03 18:14:10 +0000195 if( flags ){
dan1da40a32009-09-19 17:00:31 +0000196 const char *zFault = 0;
danielk1977f1819242007-05-03 18:14:10 +0000197 Index *pIdx;
dan1da40a32009-09-19 17:00:31 +0000198#ifndef SQLITE_OMIT_FOREIGN_KEY
199 if( db->flags&SQLITE_ForeignKeys ){
dan13167002009-10-02 06:35:06 +0000200 /* Check that the column is not part of an FK child key definition. It
201 ** is not necessary to check if it is part of a parent key, as parent
202 ** key columns must be indexed. The check below will pick up this
203 ** case. */
dan1da40a32009-09-19 17:00:31 +0000204 FKey *pFKey;
205 for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
206 int j;
207 for(j=0; j<pFKey->nCol; j++){
208 if( pFKey->aCol[j].iFrom==iCol ){
209 zFault = "foreign key";
210 }
211 }
212 }
213 }
214#endif
danielk1977f1819242007-05-03 18:14:10 +0000215 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
216 int j;
drhbbbdc832013-10-22 18:01:40 +0000217 for(j=0; j<pIdx->nKeyCol; j++){
drh1f9ca2c2015-08-25 16:57:52 +0000218 /* FIXME: Be smarter about indexes that use expressions */
drh4b92f982015-09-29 17:20:14 +0000219 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
dan1da40a32009-09-19 17:00:31 +0000220 zFault = "indexed";
danielk1977f1819242007-05-03 18:14:10 +0000221 }
222 }
223 }
dan1da40a32009-09-19 17:00:31 +0000224 if( zFault ){
225 sqlite3DbFree(db, zErr);
226 zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
227 rc = SQLITE_ERROR;
dan1da40a32009-09-19 17:00:31 +0000228 sqlite3BtreeLeaveAll(db);
229 goto blob_open_out;
230 }
danielk1977f1819242007-05-03 18:14:10 +0000231 }
232
drh9ac79622013-12-18 15:11:47 +0000233 pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
dan61c7f592010-10-26 18:42:52 +0000234 assert( pBlob->pStmt || db->mallocFailed );
235 if( pBlob->pStmt ){
drh2ce18652016-01-16 20:50:21 +0000236
237 /* This VDBE program seeks a btree cursor to the identified
238 ** db/table/row entry. The reason for using a vdbe program instead
239 ** of writing code to use the b-tree layer directly is that the
240 ** vdbe program will take advantage of the various transaction,
241 ** locking and error handling infrastructure built into the vdbe.
242 **
243 ** After seeking the cursor, the vdbe executes an OP_ResultRow.
244 ** Code external to the Vdbe then "borrows" the b-tree cursor and
245 ** uses it to implement the blob_read(), blob_write() and
246 ** blob_bytes() functions.
247 **
248 ** The sqlite3_blob_close() function finalizes the vdbe program,
249 ** which closes the b-tree cursor and (possibly) commits the
250 ** transaction.
251 */
drhe617bc82016-01-18 00:46:11 +0000252 static const int iLn = VDBE_OFFSET_LINENO(4);
drh2ce18652016-01-16 20:50:21 +0000253 static const VdbeOpList openBlob[] = {
drhe617bc82016-01-18 00:46:11 +0000254 /* addr/ofst */
255 /* {OP_Transaction, 0, 0, 0}, // 0/ inserted separately */
256 {OP_TableLock, 0, 0, 0}, /* 1/0: Acquire a read or write lock */
257 {OP_OpenRead, 0, 0, 0}, /* 2/1: Open a cursor */
258 {OP_Variable, 1, 1, 0}, /* 3/2: Move ?1 into reg[1] */
259 {OP_NotExists, 0, 8, 1}, /* 4/3: Seek the cursor */
260 {OP_Column, 0, 0, 1}, /* 5/4 */
261 {OP_ResultRow, 1, 0, 0}, /* 6/5 */
262 {OP_Goto, 0, 3, 0}, /* 7/6 */
263 {OP_Close, 0, 0, 0}, /* 8/7 */
264 {OP_Halt, 0, 0, 0}, /* 9/8 */
drh2ce18652016-01-16 20:50:21 +0000265 };
dan61c7f592010-10-26 18:42:52 +0000266 Vdbe *v = (Vdbe *)pBlob->pStmt;
danielk1977b4e9af92007-05-01 17:49:49 +0000267 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
drh2ce18652016-01-16 20:50:21 +0000268 VdbeOp *aOp;
drhb22f7c82014-02-06 23:56:27 +0000269
270 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags,
271 pTab->pSchema->schema_cookie,
272 pTab->pSchema->iGeneration);
273 sqlite3VdbeChangeP5(v, 1);
drh2ce18652016-01-16 20:50:21 +0000274 aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
danielk1977b4e9af92007-05-01 17:49:49 +0000275
drhff0587c2007-08-29 17:43:19 +0000276 /* Make sure a mutex is held on the table to be accessed */
drhfb982642007-08-30 01:19:59 +0000277 sqlite3VdbeUsesBtree(v, iDb);
drhff0587c2007-08-29 17:43:19 +0000278
drh2ce18652016-01-16 20:50:21 +0000279 if( db->mallocFailed==0 ){
280 assert( aOp!=0 );
281 /* Configure the OP_TableLock instruction */
danc548b782010-06-19 19:06:33 +0000282#ifdef SQLITE_OMIT_SHARED_CACHE
drh2ce18652016-01-16 20:50:21 +0000283 aOp[0].opcode = OP_Noop;
danc548b782010-06-19 19:06:33 +0000284#else
drh2ce18652016-01-16 20:50:21 +0000285 aOp[0].p1 = iDb;
286 aOp[0].p2 = pTab->tnum;
287 aOp[0].p3 = flags;
288 sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
289 }
290 if( db->mallocFailed==0 ){
danc548b782010-06-19 19:06:33 +0000291#endif
danielk197796d48e92009-06-29 06:00:37 +0000292
drh2ce18652016-01-16 20:50:21 +0000293 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
294 ** parameter of the other to pTab->tnum. */
drhe617bc82016-01-18 00:46:11 +0000295 if( flags ) aOp[1].opcode = OP_OpenWrite;
296 aOp[1].p2 = pTab->tnum;
297 aOp[1].p3 = iDb;
danielk1977b4e9af92007-05-01 17:49:49 +0000298
drh2ce18652016-01-16 20:50:21 +0000299 /* Configure the number of columns. Configure the cursor to
300 ** think that the table has one more column than it really
301 ** does. An OP_Column to retrieve this imaginary column will
302 ** always return an SQL NULL. This is useful because it means
303 ** we can invoke OP_Column to fill in the vdbe cursors type
304 ** and offset cache without causing any IO.
305 */
drhe617bc82016-01-18 00:46:11 +0000306 aOp[1].p4type = P4_INT32;
307 aOp[1].p4.i = pTab->nCol+1;
308 aOp[4].p2 = pTab->nCol;
drh2ce18652016-01-16 20:50:21 +0000309
drh124c0b42011-06-01 18:15:55 +0000310 pParse->nVar = 1;
311 pParse->nMem = 1;
312 pParse->nTab = 1;
313 sqlite3VdbeMakeReady(v, pParse);
danielk197792d4d7a2007-05-04 12:05:56 +0000314 }
danielk1977b4e9af92007-05-01 17:49:49 +0000315 }
drhff0587c2007-08-29 17:43:19 +0000316
danielk1977b4e9af92007-05-01 17:49:49 +0000317 pBlob->flags = flags;
dan4e76cc32010-10-20 18:56:04 +0000318 pBlob->iCol = iCol;
drh605264d2007-08-21 15:13:19 +0000319 pBlob->db = db;
dan4e76cc32010-10-20 18:56:04 +0000320 sqlite3BtreeLeaveAll(db);
dan4e76cc32010-10-20 18:56:04 +0000321 if( db->mallocFailed ){
322 goto blob_open_out;
323 }
dan4e76cc32010-10-20 18:56:04 +0000324 sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
325 rc = blobSeekToRow(pBlob, iRow, &zErr);
drh60625312013-04-06 18:06:51 +0000326 } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
danielk1977b4e9af92007-05-01 17:49:49 +0000327
328blob_open_out:
dan4e76cc32010-10-20 18:56:04 +0000329 if( rc==SQLITE_OK && db->mallocFailed==0 ){
330 *ppBlob = (sqlite3_blob *)pBlob;
331 }else{
dan4e76cc32010-10-20 18:56:04 +0000332 if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
333 sqlite3DbFree(db, pBlob);
danielk1977b4e9af92007-05-01 17:49:49 +0000334 }
drh13f40da2014-08-22 18:00:11 +0000335 sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
drh6ee700c2009-06-01 19:53:30 +0000336 sqlite3DbFree(db, zErr);
drhf30a9692013-11-15 01:10:18 +0000337 sqlite3ParserReset(pParse);
drh6ee700c2009-06-01 19:53:30 +0000338 sqlite3StackFree(db, pParse);
drh605264d2007-08-21 15:13:19 +0000339 rc = sqlite3ApiExit(db, rc);
340 sqlite3_mutex_leave(db->mutex);
341 return rc;
danielk1977b4e9af92007-05-01 17:49:49 +0000342}
343
344/*
drh16a9b832007-05-05 18:39:25 +0000345** Close a blob handle that was previously created using
346** sqlite3_blob_open().
danielk1977b4e9af92007-05-01 17:49:49 +0000347*/
348int sqlite3_blob_close(sqlite3_blob *pBlob){
349 Incrblob *p = (Incrblob *)pBlob;
drh605264d2007-08-21 15:13:19 +0000350 int rc;
drhd9da78a2009-03-24 15:08:09 +0000351 sqlite3 *db;
drh605264d2007-08-21 15:13:19 +0000352
drh28414ee2009-05-09 15:17:47 +0000353 if( p ){
354 db = p->db;
355 sqlite3_mutex_enter(db->mutex);
356 rc = sqlite3_finalize(p->pStmt);
357 sqlite3DbFree(db, p);
358 sqlite3_mutex_leave(db->mutex);
359 }else{
360 rc = SQLITE_OK;
361 }
drh605264d2007-08-21 15:13:19 +0000362 return rc;
danielk1977b4e9af92007-05-01 17:49:49 +0000363}
364
drh605264d2007-08-21 15:13:19 +0000365/*
366** Perform a read or write operation on a blob
367*/
drhee858132007-05-08 20:37:38 +0000368static int blobReadWrite(
danielk1977dcbb5d32007-05-04 18:36:44 +0000369 sqlite3_blob *pBlob,
370 void *z,
371 int n,
372 int iOffset,
373 int (*xCall)(BtCursor*, u32, u32, void*)
374){
375 int rc;
376 Incrblob *p = (Incrblob *)pBlob;
drh605264d2007-08-21 15:13:19 +0000377 Vdbe *v;
drh28414ee2009-05-09 15:17:47 +0000378 sqlite3 *db;
danielk1977dcbb5d32007-05-04 18:36:44 +0000379
drh413c3d32010-02-23 20:11:56 +0000380 if( p==0 ) return SQLITE_MISUSE_BKPT;
drh28414ee2009-05-09 15:17:47 +0000381 db = p->db;
drh605264d2007-08-21 15:13:19 +0000382 sqlite3_mutex_enter(db->mutex);
drh605264d2007-08-21 15:13:19 +0000383 v = (Vdbe*)p->pStmt;
danielk1977a8b30182008-10-02 14:49:01 +0000384
drhd10d18d2015-02-07 15:16:35 +0000385 if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){
danielk1977a8b30182008-10-02 14:49:01 +0000386 /* Request is out of range. Return a transient error. */
387 rc = SQLITE_ERROR;
dan4e76cc32010-10-20 18:56:04 +0000388 }else if( v==0 ){
danielk1977a8b30182008-10-02 14:49:01 +0000389 /* If there is no statement handle, then the blob-handle has
390 ** already been invalidated. Return SQLITE_ABORT in this case.
391 */
drh605264d2007-08-21 15:13:19 +0000392 rc = SQLITE_ABORT;
danielk1977dcbb5d32007-05-04 18:36:44 +0000393 }else{
drh605264d2007-08-21 15:13:19 +0000394 /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
395 ** returned, clean-up the statement handle.
396 */
397 assert( db == v->db );
drhff0587c2007-08-29 17:43:19 +0000398 sqlite3BtreeEnterCursor(p->pCsr);
drh605264d2007-08-21 15:13:19 +0000399 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
drhff0587c2007-08-29 17:43:19 +0000400 sqlite3BtreeLeaveCursor(p->pCsr);
drh605264d2007-08-21 15:13:19 +0000401 if( rc==SQLITE_ABORT ){
402 sqlite3VdbeFinalize(v);
403 p->pStmt = 0;
404 }else{
drh605264d2007-08-21 15:13:19 +0000405 v->rc = rc;
406 }
danielk1977dcbb5d32007-05-04 18:36:44 +0000407 }
dan923c4b32014-11-10 17:53:03 +0000408 sqlite3Error(db, rc);
drh605264d2007-08-21 15:13:19 +0000409 rc = sqlite3ApiExit(db, rc);
410 sqlite3_mutex_leave(db->mutex);
411 return rc;
danielk1977dcbb5d32007-05-04 18:36:44 +0000412}
413
danielk1977b4e9af92007-05-01 17:49:49 +0000414/*
415** Read data from a blob handle.
416*/
417int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
danielk1977dcbb5d32007-05-04 18:36:44 +0000418 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
danielk1977b4e9af92007-05-01 17:49:49 +0000419}
420
421/*
422** Write data to a blob handle.
423*/
424int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
danielk1977dcbb5d32007-05-04 18:36:44 +0000425 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
danielk1977b4e9af92007-05-01 17:49:49 +0000426}
427
428/*
429** Query a blob handle for the size of the data.
drh605264d2007-08-21 15:13:19 +0000430**
431** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
432** so no mutex is required for access.
danielk1977b4e9af92007-05-01 17:49:49 +0000433*/
434int sqlite3_blob_bytes(sqlite3_blob *pBlob){
435 Incrblob *p = (Incrblob *)pBlob;
daneefab752010-12-06 17:11:05 +0000436 return (p && p->pStmt) ? p->nByte : 0;
danielk1977b4e9af92007-05-01 17:49:49 +0000437}
438
dan4e76cc32010-10-20 18:56:04 +0000439/*
440** Move an existing blob handle to point to a different row of the same
441** database table.
442**
443** If an error occurs, or if the specified row does not exist or does not
444** contain a blob or text value, then an error code is returned and the
445** database handle error code and message set. If this happens, then all
446** subsequent calls to sqlite3_blob_xxx() functions (except blob_close())
447** immediately return SQLITE_ABORT.
448*/
449int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
450 int rc;
451 Incrblob *p = (Incrblob *)pBlob;
452 sqlite3 *db;
453
454 if( p==0 ) return SQLITE_MISUSE_BKPT;
455 db = p->db;
456 sqlite3_mutex_enter(db->mutex);
457
458 if( p->pStmt==0 ){
459 /* If there is no statement handle, then the blob-handle has
460 ** already been invalidated. Return SQLITE_ABORT in this case.
461 */
462 rc = SQLITE_ABORT;
463 }else{
464 char *zErr;
465 rc = blobSeekToRow(p, iRow, &zErr);
466 if( rc!=SQLITE_OK ){
drh13f40da2014-08-22 18:00:11 +0000467 sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
dan4e76cc32010-10-20 18:56:04 +0000468 sqlite3DbFree(db, zErr);
469 }
470 assert( rc!=SQLITE_SCHEMA );
471 }
472
473 rc = sqlite3ApiExit(db, rc);
daneefab752010-12-06 17:11:05 +0000474 assert( rc==SQLITE_OK || p->pStmt==0 );
dan4e76cc32010-10-20 18:56:04 +0000475 sqlite3_mutex_leave(db->mutex);
476 return rc;
477}
478
danielk1977b4e9af92007-05-01 17:49:49 +0000479#endif /* #ifndef SQLITE_OMIT_INCRBLOB */