Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / vdbeblob.c
blob71bd8816d5a22b0d623d55e01e70653390dd630e
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.
11 *************************************************************************
13 ** This file contains code used to implement incremental BLOB I/O.
16 #include "sqliteInt.h"
17 #include "vdbeInt.h"
19 #ifndef SQLITE_OMIT_INCRBLOB
22 ** Valid sqlite3_blob* handles point to Incrblob structures.
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 */
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.
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().
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.
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;
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.
62 assert( v->aVar[0].flags&MEM_Int );
63 v->aVar[0].u.i = iRow;
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"
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);
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));
97 assert( rc!=SQLITE_OK || zErr==0 );
98 assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
100 *pzErr = zErr;
101 return rc;
105 ** Open a blob handle.
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 */
116 int nAttempt = 0;
117 int iCol; /* Index of zColumn in row-record */
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.
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.
130 ** The sqlite3_blob_close() function finalizes the vdbe program,
131 ** which closes the b-tree cursor and (possibly) commits the
132 ** transaction.
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 */
150 int rc = SQLITE_OK;
151 char *zErr = 0;
152 Table *pTab;
153 Parse *pParse = 0;
154 Incrblob *pBlob = 0;
156 flags = !!flags; /* flags = (flags ? 1 : 0); */
157 *ppBlob = 0;
159 sqlite3_mutex_enter(db->mutex);
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;
166 do {
167 memset(pParse, 0, sizeof(Parse));
168 pParse->db = db;
169 sqlite3DbFree(db, zErr);
170 zErr = 0;
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);
178 if( pTab && !HasRowid(pTab) ){
179 pTab = 0;
180 sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
182 #ifndef SQLITE_OMIT_VIEW
183 if( pTab && pTab->pSelect ){
184 pTab = 0;
185 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
187 #endif
188 if( !pTab ){
189 if( pParse->zErrMsg ){
190 sqlite3DbFree(db, zErr);
191 zErr = pParse->zErrMsg;
192 pParse->zErrMsg = 0;
194 rc = SQLITE_ERROR;
195 sqlite3BtreeLeaveAll(db);
196 goto blob_open_out;
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;
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;
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";
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";
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;
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);
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);
267 /* Make sure a mutex is held on the table to be accessed */
268 sqlite3VdbeUsesBtree(v, iDb);
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
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);
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.
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);
303 pBlob->flags = flags;
304 pBlob->iCol = iCol;
305 pBlob->db = db;
306 sqlite3BtreeLeaveAll(db);
307 if( db->mallocFailed ){
308 goto blob_open_out;
310 sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
311 rc = blobSeekToRow(pBlob, iRow, &zErr);
312 } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
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);
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;
331 ** Close a blob handle that was previously created using
332 ** sqlite3_blob_open().
334 int sqlite3_blob_close(sqlite3_blob *pBlob){
335 Incrblob *p = (Incrblob *)pBlob;
336 int rc;
337 sqlite3 *db;
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;
348 return rc;
352 ** Perform a read or write operation on a blob
354 static int blobReadWrite(
355 sqlite3_blob *pBlob,
356 void *z,
357 int n,
358 int iOffset,
359 int (*xCall)(BtCursor*, u32, u32, void*)
361 int rc;
362 Incrblob *p = (Incrblob *)pBlob;
363 Vdbe *v;
364 sqlite3 *db;
366 if( p==0 ) return SQLITE_MISUSE_BKPT;
367 db = p->db;
368 sqlite3_mutex_enter(db->mutex);
369 v = (Vdbe*)p->pStmt;
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.
379 rc = SQLITE_ABORT;
380 }else{
381 /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
382 ** returned, clean-up the statement handle.
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;
396 rc = sqlite3ApiExit(db, rc);
397 sqlite3_mutex_leave(db->mutex);
398 return rc;
402 ** Read data from a blob handle.
404 int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
405 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
409 ** Write data to a blob handle.
411 int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
412 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
416 ** Query a blob handle for the size of the data.
418 ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
419 ** so no mutex is required for access.
421 int sqlite3_blob_bytes(sqlite3_blob *pBlob){
422 Incrblob *p = (Incrblob *)pBlob;
423 return (p && p->pStmt) ? p->nByte : 0;
427 ** Move an existing blob handle to point to a different row of the same
428 ** database table.
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.
436 int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
437 int rc;
438 Incrblob *p = (Incrblob *)pBlob;
439 sqlite3 *db;
441 if( p==0 ) return SQLITE_MISUSE_BKPT;
442 db = p->db;
443 sqlite3_mutex_enter(db->mutex);
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.
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);
457 assert( rc!=SQLITE_SCHEMA );
460 rc = sqlite3ApiExit(db, rc);
461 assert( rc==SQLITE_OK || p->pStmt==0 );
462 sqlite3_mutex_leave(db->mutex);
463 return rc;
466 #endif /* #ifndef SQLITE_OMIT_INCRBLOB */