blob: 161242db5b5b966759ab41cd527bf4ddf9543d68 [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.
14**
drhff0587c2007-08-29 17:43:19 +000015** $Id: vdbeblob.c,v 1.15 2007/08/29 17:43:20 drh Exp $
danielk1977b4e9af92007-05-01 17:49:49 +000016*/
17
18#include "sqliteInt.h"
19#include "vdbeInt.h"
20
21#ifndef SQLITE_OMIT_INCRBLOB
22
23/*
24** Valid sqlite3_blob* handles point to Incrblob structures.
25*/
26typedef struct Incrblob Incrblob;
danielk1977b4e9af92007-05-01 17:49:49 +000027struct Incrblob {
28 int flags; /* Copy of "flags" passed to sqlite3_blob_open() */
29 int nByte; /* Size of open blob, in bytes */
30 int iOffset; /* Byte offset of blob in cursor data */
31 BtCursor *pCsr; /* Cursor pointing at blob row */
32 sqlite3_stmt *pStmt; /* Statement holding cursor open */
drh605264d2007-08-21 15:13:19 +000033 sqlite3 *db; /* The associated database */
danielk1977b4e9af92007-05-01 17:49:49 +000034};
35
36/*
37** Open a blob handle.
38*/
39int sqlite3_blob_open(
drh16a9b832007-05-05 18:39:25 +000040 sqlite3* db, /* The database connection */
41 const char *zDb, /* The attached database containing the blob */
42 const char *zTable, /* The table containing the blob */
43 const char *zColumn, /* The column containing the blob */
44 sqlite_int64 iRow, /* The row containing the glob */
danielk1977b4e9af92007-05-01 17:49:49 +000045 int flags, /* True -> read/write access, false -> read-only */
drh16a9b832007-05-05 18:39:25 +000046 sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
danielk1977b4e9af92007-05-01 17:49:49 +000047){
danielk1977b4e9af92007-05-01 17:49:49 +000048 int nAttempt = 0;
49 int iCol; /* Index of zColumn in row-record */
50
51 /* This VDBE program seeks a btree cursor to the identified
52 ** db/table/row entry. The reason for using a vdbe program instead
53 ** of writing code to use the b-tree layer directly is that the
54 ** vdbe program will take advantage of the various transaction,
55 ** locking and error handling infrastructure built into the vdbe.
56 **
57 ** After seeking the cursor, the vdbe executes an OP_Callback.
58 ** Code external to the Vdbe then "borrows" the b-tree cursor and
59 ** uses it to implement the blob_read(), blob_write() and
60 ** blob_bytes() functions.
61 **
62 ** The sqlite3_blob_close() function finalizes the vdbe program,
63 ** which closes the b-tree cursor and (possibly) commits the
64 ** transaction.
65 */
66 static const VdbeOpList openBlob[] = {
67 {OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */
68 {OP_VerifyCookie, 0, 0, 0}, /* 1: Check the schema cookie */
69 {OP_Integer, 0, 0, 0}, /* 2: Database number */
70
71 /* One of the following two instructions is replaced by an
72 ** OP_Noop before exection.
73 */
74 {OP_OpenRead, 0, 0, 0}, /* 3: Open cursor 0 for reading */
75 {OP_OpenWrite, 0, 0, 0}, /* 4: Open cursor 0 for read/write */
76 {OP_SetNumColumns, 0, 0, 0}, /* 5: Num cols for cursor */
77
78 {OP_Variable, 1, 0, 0}, /* 6: Push the rowid to the stack */
79 {OP_NotExists, 0, 10, 0}, /* 7: Seek the cursor */
80 {OP_Column, 0, 0, 0}, /* 8 */
81 {OP_Callback, 0, 0, 0}, /* 9 */
82 {OP_Close, 0, 0, 0}, /* 10 */
83 {OP_Halt, 0, 0, 0}, /* 11 */
84 };
85
86 Vdbe *v = 0;
danielk19778cbadb02007-05-03 16:31:26 +000087 int rc = SQLITE_OK;
drh5bb3eb92007-05-04 13:15:55 +000088 char zErr[128];
danielk1977b4e9af92007-05-01 17:49:49 +000089
drh5bb3eb92007-05-04 13:15:55 +000090 zErr[0] = 0;
drh605264d2007-08-21 15:13:19 +000091 sqlite3_mutex_enter(db->mutex);
danielk1977b4e9af92007-05-01 17:49:49 +000092 do {
93 Parse sParse;
94 Table *pTab;
95
96 memset(&sParse, 0, sizeof(Parse));
97 sParse.db = db;
98
danielk197720713f32007-05-03 11:43:33 +000099 rc = sqlite3SafetyOn(db);
100 if( rc!=SQLITE_OK ){
drh605264d2007-08-21 15:13:19 +0000101 sqlite3_mutex_leave(db->mutex);
danielk197720713f32007-05-03 11:43:33 +0000102 return rc;
103 }
104
drhff0587c2007-08-29 17:43:19 +0000105 sqlite3BtreeEnterAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000106 pTab = sqlite3LocateTable(&sParse, zTable, zDb);
107 if( !pTab ){
danielk19778cbadb02007-05-03 16:31:26 +0000108 if( sParse.zErrMsg ){
109 sqlite3_snprintf(sizeof(zErr), zErr, "%s", sParse.zErrMsg);
danielk19778cbadb02007-05-03 16:31:26 +0000110 }
drh17435752007-08-16 04:30:38 +0000111 sqlite3_free(sParse.zErrMsg);
danielk19778cbadb02007-05-03 16:31:26 +0000112 rc = SQLITE_ERROR;
danielk197720713f32007-05-03 11:43:33 +0000113 sqlite3SafetyOff(db);
drhff0587c2007-08-29 17:43:19 +0000114 sqlite3BtreeLeaveAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000115 goto blob_open_out;
116 }
117
118 /* Now search pTab for the exact column. */
119 for(iCol=0; iCol < pTab->nCol; iCol++) {
120 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
121 break;
122 }
123 }
124 if( iCol==pTab->nCol ){
danielk1977f1819242007-05-03 18:14:10 +0000125 sqlite3_snprintf(sizeof(zErr), zErr, "no such column: \"%s\"", zColumn);
danielk1977b4e9af92007-05-01 17:49:49 +0000126 rc = SQLITE_ERROR;
danielk197720713f32007-05-03 11:43:33 +0000127 sqlite3SafetyOff(db);
drhff0587c2007-08-29 17:43:19 +0000128 sqlite3BtreeLeaveAll(db);
danielk1977b4e9af92007-05-01 17:49:49 +0000129 goto blob_open_out;
130 }
131
danielk1977f1819242007-05-03 18:14:10 +0000132 /* If the value is being opened for writing, check that the
133 ** column is not indexed. It is against the rules to open an
134 ** indexed column for writing.
135 */
136 if( flags ){
137 Index *pIdx;
138 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
139 int j;
140 for(j=0; j<pIdx->nColumn; j++){
141 if( pIdx->aiColumn[j]==iCol ){
drh5bb3eb92007-05-04 13:15:55 +0000142 sqlite3_snprintf(sizeof(zErr), zErr,
143 "cannot open indexed column for writing");
danielk1977f1819242007-05-03 18:14:10 +0000144 rc = SQLITE_ERROR;
145 sqlite3SafetyOff(db);
drhff0587c2007-08-29 17:43:19 +0000146 sqlite3BtreeLeaveAll(db);
danielk1977f1819242007-05-03 18:14:10 +0000147 goto blob_open_out;
148 }
149 }
150 }
151 }
152
danielk1977b4e9af92007-05-01 17:49:49 +0000153 v = sqlite3VdbeCreate(db);
154 if( v ){
155 int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
156 sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
157
158 /* Configure the OP_Transaction */
159 sqlite3VdbeChangeP1(v, 0, iDb);
160 sqlite3VdbeChangeP2(v, 0, (flags ? 1 : 0));
161
162 /* Configure the OP_VerifyCookie */
163 sqlite3VdbeChangeP1(v, 1, iDb);
164 sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
165
drhff0587c2007-08-29 17:43:19 +0000166 /* Make sure a mutex is held on the table to be accessed */
167 sqlite3VdbeUsesBtree(v, iDb, db->aDb[iDb].pBt);
168
danielk1977b4e9af92007-05-01 17:49:49 +0000169 /* Configure the db number pushed onto the stack */
170 sqlite3VdbeChangeP1(v, 2, iDb);
171
danielk1977f1819242007-05-03 18:14:10 +0000172 /* Remove either the OP_OpenWrite or OpenRead. Set the P2
173 ** parameter of the other to pTab->tnum.
danielk1977b4e9af92007-05-01 17:49:49 +0000174 */
175 sqlite3VdbeChangeToNoop(v, (flags ? 3 : 4), 1);
176 sqlite3VdbeChangeP2(v, (flags ? 4 : 3), pTab->tnum);
177
178 /* Configure the OP_SetNumColumns. Configure the cursor to
179 ** think that the table has one more column than it really
180 ** does. An OP_Column to retrieve this imaginary column will
181 ** always return an SQL NULL. This is useful because it means
182 ** we can invoke OP_Column to fill in the vdbe cursors type
183 ** and offset cache without causing any IO.
184 */
185 sqlite3VdbeChangeP2(v, 5, pTab->nCol+1);
drh17435752007-08-16 04:30:38 +0000186 if( !db->mallocFailed ){
danielk197792d4d7a2007-05-04 12:05:56 +0000187 sqlite3VdbeMakeReady(v, 1, 0, 1, 0);
188 }
danielk1977b4e9af92007-05-01 17:49:49 +0000189 }
drhff0587c2007-08-29 17:43:19 +0000190
191 sqlite3BtreeLeaveAll(db);
danielk197720713f32007-05-03 11:43:33 +0000192 rc = sqlite3SafetyOff(db);
drh17435752007-08-16 04:30:38 +0000193 if( rc!=SQLITE_OK || db->mallocFailed ){
danielk197792d4d7a2007-05-04 12:05:56 +0000194 goto blob_open_out;
danielk197720713f32007-05-03 11:43:33 +0000195 }
196
danielk1977b4e9af92007-05-01 17:49:49 +0000197 sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);
198 rc = sqlite3_step((sqlite3_stmt *)v);
199 if( rc!=SQLITE_ROW ){
200 nAttempt++;
201 rc = sqlite3_finalize((sqlite3_stmt *)v);
danielk1977f1819242007-05-03 18:14:10 +0000202 sqlite3_snprintf(sizeof(zErr), zErr, sqlite3_errmsg(db));
danielk1977b4e9af92007-05-01 17:49:49 +0000203 v = 0;
204 }
205 } while( nAttempt<5 && rc==SQLITE_SCHEMA );
206
207 if( rc==SQLITE_ROW ){
208 /* The row-record has been opened successfully. Check that the
209 ** column in question contains text or a blob. If it contains
210 ** text, it is up to the caller to get the encoding right.
211 */
212 Incrblob *pBlob;
213 u32 type = v->apCsr[0]->aType[iCol];
214
215 if( type<12 ){
danielk1977f1819242007-05-03 18:14:10 +0000216 sqlite3_snprintf(sizeof(zErr), zErr, "cannot open value of type %s",
217 type==0?"null": type==7?"real": "integer"
218 );
danielk1977b4e9af92007-05-01 17:49:49 +0000219 rc = SQLITE_ERROR;
220 goto blob_open_out;
221 }
drh17435752007-08-16 04:30:38 +0000222 pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
223 if( db->mallocFailed ){
224 sqlite3_free(pBlob);
danielk1977b4e9af92007-05-01 17:49:49 +0000225 goto blob_open_out;
226 }
227 pBlob->flags = flags;
228 pBlob->pCsr = v->apCsr[0]->pCursor;
drhff0587c2007-08-29 17:43:19 +0000229 sqlite3BtreeEnterCursor(pBlob->pCsr);
danielk19772dec9702007-05-02 16:48:37 +0000230 sqlite3BtreeCacheOverflow(pBlob->pCsr);
drhff0587c2007-08-29 17:43:19 +0000231 sqlite3BtreeLeaveCursor(pBlob->pCsr);
danielk1977b4e9af92007-05-01 17:49:49 +0000232 pBlob->pStmt = (sqlite3_stmt *)v;
233 pBlob->iOffset = v->apCsr[0]->aOffset[iCol];
234 pBlob->nByte = sqlite3VdbeSerialTypeLen(type);
drh605264d2007-08-21 15:13:19 +0000235 pBlob->db = db;
danielk1977b4e9af92007-05-01 17:49:49 +0000236 *ppBlob = (sqlite3_blob *)pBlob;
237 rc = SQLITE_OK;
danielk19778cbadb02007-05-03 16:31:26 +0000238 }else if( rc==SQLITE_OK ){
danielk1977f1819242007-05-03 18:14:10 +0000239 sqlite3_snprintf(sizeof(zErr), zErr, "no such rowid: %lld", iRow);
danielk19778cbadb02007-05-03 16:31:26 +0000240 rc = SQLITE_ERROR;
danielk1977b4e9af92007-05-01 17:49:49 +0000241 }
242
243blob_open_out:
danielk197792d4d7a2007-05-04 12:05:56 +0000244 zErr[sizeof(zErr)-1] = '\0';
drh17435752007-08-16 04:30:38 +0000245 if( rc!=SQLITE_OK || db->mallocFailed ){
danielk1977b4e9af92007-05-01 17:49:49 +0000246 sqlite3_finalize((sqlite3_stmt *)v);
247 }
danielk197792d4d7a2007-05-04 12:05:56 +0000248 sqlite3Error(db, rc, (rc==SQLITE_OK?0:zErr));
drh605264d2007-08-21 15:13:19 +0000249 rc = sqlite3ApiExit(db, rc);
250 sqlite3_mutex_leave(db->mutex);
251 return rc;
danielk1977b4e9af92007-05-01 17:49:49 +0000252}
253
254/*
drh16a9b832007-05-05 18:39:25 +0000255** Close a blob handle that was previously created using
256** sqlite3_blob_open().
danielk1977b4e9af92007-05-01 17:49:49 +0000257*/
258int sqlite3_blob_close(sqlite3_blob *pBlob){
259 Incrblob *p = (Incrblob *)pBlob;
drh605264d2007-08-21 15:13:19 +0000260 int rc;
261
drh605264d2007-08-21 15:13:19 +0000262 rc = sqlite3_finalize(p->pStmt);
drh17435752007-08-16 04:30:38 +0000263 sqlite3_free(p);
drh605264d2007-08-21 15:13:19 +0000264 return rc;
danielk1977b4e9af92007-05-01 17:49:49 +0000265}
266
drh605264d2007-08-21 15:13:19 +0000267/*
268** Perform a read or write operation on a blob
269*/
drhee858132007-05-08 20:37:38 +0000270static int blobReadWrite(
danielk1977dcbb5d32007-05-04 18:36:44 +0000271 sqlite3_blob *pBlob,
272 void *z,
273 int n,
274 int iOffset,
275 int (*xCall)(BtCursor*, u32, u32, void*)
276){
277 int rc;
278 Incrblob *p = (Incrblob *)pBlob;
drh605264d2007-08-21 15:13:19 +0000279 Vdbe *v;
280 sqlite3 *db = p->db;
danielk1977dcbb5d32007-05-04 18:36:44 +0000281
282 /* Request is out of range. Return a transient error. */
283 if( (iOffset+n)>p->nByte ){
284 return SQLITE_ERROR;
285 }
drh605264d2007-08-21 15:13:19 +0000286 sqlite3_mutex_enter(db->mutex);
danielk1977dcbb5d32007-05-04 18:36:44 +0000287
drh605264d2007-08-21 15:13:19 +0000288 /* If there is no statement handle, then the blob-handle has
289 ** already been invalidated. Return SQLITE_ABORT in this case.
danielk1977dcbb5d32007-05-04 18:36:44 +0000290 */
drh605264d2007-08-21 15:13:19 +0000291 v = (Vdbe*)p->pStmt;
292 if( v==0 ){
293 rc = SQLITE_ABORT;
danielk1977dcbb5d32007-05-04 18:36:44 +0000294 }else{
drh605264d2007-08-21 15:13:19 +0000295 /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
296 ** returned, clean-up the statement handle.
297 */
298 assert( db == v->db );
drhff0587c2007-08-29 17:43:19 +0000299 sqlite3BtreeEnterCursor(p->pCsr);
drh605264d2007-08-21 15:13:19 +0000300 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
drhff0587c2007-08-29 17:43:19 +0000301 sqlite3BtreeLeaveCursor(p->pCsr);
drh605264d2007-08-21 15:13:19 +0000302 if( rc==SQLITE_ABORT ){
303 sqlite3VdbeFinalize(v);
304 p->pStmt = 0;
305 }else{
306 db->errCode = rc;
307 v->rc = rc;
308 }
danielk1977dcbb5d32007-05-04 18:36:44 +0000309 }
drh605264d2007-08-21 15:13:19 +0000310 rc = sqlite3ApiExit(db, rc);
311 sqlite3_mutex_leave(db->mutex);
312 return rc;
danielk1977dcbb5d32007-05-04 18:36:44 +0000313}
314
danielk1977b4e9af92007-05-01 17:49:49 +0000315/*
316** Read data from a blob handle.
317*/
318int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
danielk1977dcbb5d32007-05-04 18:36:44 +0000319 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
danielk1977b4e9af92007-05-01 17:49:49 +0000320}
321
322/*
323** Write data to a blob handle.
324*/
325int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
danielk1977dcbb5d32007-05-04 18:36:44 +0000326 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
danielk1977b4e9af92007-05-01 17:49:49 +0000327}
328
329/*
330** Query a blob handle for the size of the data.
drh605264d2007-08-21 15:13:19 +0000331**
332** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
333** so no mutex is required for access.
danielk1977b4e9af92007-05-01 17:49:49 +0000334*/
335int sqlite3_blob_bytes(sqlite3_blob *pBlob){
336 Incrblob *p = (Incrblob *)pBlob;
337 return p->nByte;
338}
339
340#endif /* #ifndef SQLITE_OMIT_INCRBLOB */