251cced1f8
Various minor things done to project files Updated sample extension project file and updated makefile to the new unified version (more changes likely on the way) Updated regex project file and makefile --HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401971
341 lines
10 KiB
C
341 lines
10 KiB
C
/*
|
|
** 2007 May 1
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
**
|
|
** This file contains code used to implement incremental BLOB I/O.
|
|
**
|
|
** $Id$
|
|
*/
|
|
|
|
#include "sqliteInt.h"
|
|
#include "vdbeInt.h"
|
|
|
|
#ifndef SQLITE_OMIT_INCRBLOB
|
|
|
|
/*
|
|
** Valid sqlite3_blob* handles point to Incrblob structures.
|
|
*/
|
|
typedef struct Incrblob Incrblob;
|
|
struct Incrblob {
|
|
int flags; /* Copy of "flags" passed to sqlite3_blob_open() */
|
|
int nByte; /* Size of open blob, in bytes */
|
|
int iOffset; /* Byte offset of blob in cursor data */
|
|
BtCursor *pCsr; /* Cursor pointing at blob row */
|
|
sqlite3_stmt *pStmt; /* Statement holding cursor open */
|
|
sqlite3 *db; /* The associated database */
|
|
};
|
|
|
|
/*
|
|
** Open a blob handle.
|
|
*/
|
|
int sqlite3_blob_open(
|
|
sqlite3* db, /* The database connection */
|
|
const char *zDb, /* The attached database containing the blob */
|
|
const char *zTable, /* The table containing the blob */
|
|
const char *zColumn, /* The column containing the blob */
|
|
sqlite_int64 iRow, /* The row containing the glob */
|
|
int flags, /* True -> read/write access, false -> read-only */
|
|
sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
|
|
){
|
|
int nAttempt = 0;
|
|
int iCol; /* Index of zColumn in row-record */
|
|
|
|
/* This VDBE program seeks a btree cursor to the identified
|
|
** db/table/row entry. The reason for using a vdbe program instead
|
|
** of writing code to use the b-tree layer directly is that the
|
|
** vdbe program will take advantage of the various transaction,
|
|
** locking and error handling infrastructure built into the vdbe.
|
|
**
|
|
** After seeking the cursor, the vdbe executes an OP_Callback.
|
|
** Code external to the Vdbe then "borrows" the b-tree cursor and
|
|
** uses it to implement the blob_read(), blob_write() and
|
|
** blob_bytes() functions.
|
|
**
|
|
** The sqlite3_blob_close() function finalizes the vdbe program,
|
|
** which closes the b-tree cursor and (possibly) commits the
|
|
** transaction.
|
|
*/
|
|
static const VdbeOpList openBlob[] = {
|
|
{OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */
|
|
{OP_VerifyCookie, 0, 0, 0}, /* 1: Check the schema cookie */
|
|
{OP_Integer, 0, 0, 0}, /* 2: Database number */
|
|
|
|
/* One of the following two instructions is replaced by an
|
|
** OP_Noop before exection.
|
|
*/
|
|
{OP_OpenRead, 0, 0, 0}, /* 3: Open cursor 0 for reading */
|
|
{OP_OpenWrite, 0, 0, 0}, /* 4: Open cursor 0 for read/write */
|
|
{OP_SetNumColumns, 0, 0, 0}, /* 5: Num cols for cursor */
|
|
|
|
{OP_Variable, 1, 0, 0}, /* 6: Push the rowid to the stack */
|
|
{OP_NotExists, 0, 10, 0}, /* 7: Seek the cursor */
|
|
{OP_Column, 0, 0, 0}, /* 8 */
|
|
{OP_Callback, 0, 0, 0}, /* 9 */
|
|
{OP_Close, 0, 0, 0}, /* 10 */
|
|
{OP_Halt, 0, 0, 0}, /* 11 */
|
|
};
|
|
|
|
Vdbe *v = 0;
|
|
int rc = SQLITE_OK;
|
|
char zErr[128];
|
|
|
|
zErr[0] = 0;
|
|
sqlite3_mutex_enter(db->mutex);
|
|
do {
|
|
Parse sParse;
|
|
Table *pTab;
|
|
|
|
memset(&sParse, 0, sizeof(Parse));
|
|
sParse.db = db;
|
|
|
|
rc = sqlite3SafetyOn(db);
|
|
if( rc!=SQLITE_OK ){
|
|
sqlite3_mutex_leave(db->mutex);
|
|
return rc;
|
|
}
|
|
|
|
sqlite3BtreeEnterAll(db);
|
|
pTab = sqlite3LocateTable(&sParse, zTable, zDb);
|
|
if( !pTab ){
|
|
if( sParse.zErrMsg ){
|
|
sqlite3_snprintf(sizeof(zErr), zErr, "%s", sParse.zErrMsg);
|
|
}
|
|
sqlite3_free(sParse.zErrMsg);
|
|
rc = SQLITE_ERROR;
|
|
sqlite3SafetyOff(db);
|
|
sqlite3BtreeLeaveAll(db);
|
|
goto blob_open_out;
|
|
}
|
|
|
|
/* Now search pTab for the exact column. */
|
|
for(iCol=0; iCol < pTab->nCol; iCol++) {
|
|
if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
|
|
break;
|
|
}
|
|
}
|
|
if( iCol==pTab->nCol ){
|
|
sqlite3_snprintf(sizeof(zErr), zErr, "no such column: \"%s\"", zColumn);
|
|
rc = SQLITE_ERROR;
|
|
sqlite3SafetyOff(db);
|
|
sqlite3BtreeLeaveAll(db);
|
|
goto blob_open_out;
|
|
}
|
|
|
|
/* If the value is being opened for writing, check that the
|
|
** column is not indexed. It is against the rules to open an
|
|
** indexed column for writing.
|
|
*/
|
|
if( flags ){
|
|
Index *pIdx;
|
|
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
|
|
int j;
|
|
for(j=0; j<pIdx->nColumn; j++){
|
|
if( pIdx->aiColumn[j]==iCol ){
|
|
sqlite3_snprintf(sizeof(zErr), zErr,
|
|
"cannot open indexed column for writing");
|
|
rc = SQLITE_ERROR;
|
|
sqlite3SafetyOff(db);
|
|
sqlite3BtreeLeaveAll(db);
|
|
goto blob_open_out;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
v = sqlite3VdbeCreate(db);
|
|
if( v ){
|
|
int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
|
|
sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
|
|
|
|
/* Configure the OP_Transaction */
|
|
sqlite3VdbeChangeP1(v, 0, iDb);
|
|
sqlite3VdbeChangeP2(v, 0, (flags ? 1 : 0));
|
|
|
|
/* Configure the OP_VerifyCookie */
|
|
sqlite3VdbeChangeP1(v, 1, iDb);
|
|
sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
|
|
|
|
/* Make sure a mutex is held on the table to be accessed */
|
|
sqlite3VdbeUsesBtree(v, iDb);
|
|
|
|
/* Configure the db number pushed onto the stack */
|
|
sqlite3VdbeChangeP1(v, 2, iDb);
|
|
|
|
/* Remove either the OP_OpenWrite or OpenRead. Set the P2
|
|
** parameter of the other to pTab->tnum.
|
|
*/
|
|
sqlite3VdbeChangeToNoop(v, (flags ? 3 : 4), 1);
|
|
sqlite3VdbeChangeP2(v, (flags ? 4 : 3), pTab->tnum);
|
|
|
|
/* Configure the OP_SetNumColumns. Configure the cursor to
|
|
** think that the table has one more column than it really
|
|
** does. An OP_Column to retrieve this imaginary column will
|
|
** always return an SQL NULL. This is useful because it means
|
|
** we can invoke OP_Column to fill in the vdbe cursors type
|
|
** and offset cache without causing any IO.
|
|
*/
|
|
sqlite3VdbeChangeP2(v, 5, pTab->nCol+1);
|
|
if( !db->mallocFailed ){
|
|
sqlite3VdbeMakeReady(v, 1, 0, 1, 0);
|
|
}
|
|
}
|
|
|
|
sqlite3BtreeLeaveAll(db);
|
|
rc = sqlite3SafetyOff(db);
|
|
if( rc!=SQLITE_OK || db->mallocFailed ){
|
|
goto blob_open_out;
|
|
}
|
|
|
|
sqlite3_bind_int64((sqlite3_stmt *)v, 1, iRow);
|
|
rc = sqlite3_step((sqlite3_stmt *)v);
|
|
if( rc!=SQLITE_ROW ){
|
|
nAttempt++;
|
|
rc = sqlite3_finalize((sqlite3_stmt *)v);
|
|
sqlite3_snprintf(sizeof(zErr), zErr, sqlite3_errmsg(db));
|
|
v = 0;
|
|
}
|
|
} while( nAttempt<5 && rc==SQLITE_SCHEMA );
|
|
|
|
if( rc==SQLITE_ROW ){
|
|
/* The row-record has been opened successfully. Check that the
|
|
** column in question contains text or a blob. If it contains
|
|
** text, it is up to the caller to get the encoding right.
|
|
*/
|
|
Incrblob *pBlob;
|
|
u32 type = v->apCsr[0]->aType[iCol];
|
|
|
|
if( type<12 ){
|
|
sqlite3_snprintf(sizeof(zErr), zErr, "cannot open value of type %s",
|
|
type==0?"null": type==7?"real": "integer"
|
|
);
|
|
rc = SQLITE_ERROR;
|
|
goto blob_open_out;
|
|
}
|
|
pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
|
|
if( db->mallocFailed ){
|
|
sqlite3_free(pBlob);
|
|
goto blob_open_out;
|
|
}
|
|
pBlob->flags = flags;
|
|
pBlob->pCsr = v->apCsr[0]->pCursor;
|
|
sqlite3BtreeEnterCursor(pBlob->pCsr);
|
|
sqlite3BtreeCacheOverflow(pBlob->pCsr);
|
|
sqlite3BtreeLeaveCursor(pBlob->pCsr);
|
|
pBlob->pStmt = (sqlite3_stmt *)v;
|
|
pBlob->iOffset = v->apCsr[0]->aOffset[iCol];
|
|
pBlob->nByte = sqlite3VdbeSerialTypeLen(type);
|
|
pBlob->db = db;
|
|
*ppBlob = (sqlite3_blob *)pBlob;
|
|
rc = SQLITE_OK;
|
|
}else if( rc==SQLITE_OK ){
|
|
sqlite3_snprintf(sizeof(zErr), zErr, "no such rowid: %lld", iRow);
|
|
rc = SQLITE_ERROR;
|
|
}
|
|
|
|
blob_open_out:
|
|
zErr[sizeof(zErr)-1] = '\0';
|
|
if( rc!=SQLITE_OK || db->mallocFailed ){
|
|
sqlite3_finalize((sqlite3_stmt *)v);
|
|
}
|
|
sqlite3Error(db, rc, (rc==SQLITE_OK?0:zErr));
|
|
rc = sqlite3ApiExit(db, rc);
|
|
sqlite3_mutex_leave(db->mutex);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Close a blob handle that was previously created using
|
|
** sqlite3_blob_open().
|
|
*/
|
|
int sqlite3_blob_close(sqlite3_blob *pBlob){
|
|
Incrblob *p = (Incrblob *)pBlob;
|
|
int rc;
|
|
|
|
rc = sqlite3_finalize(p->pStmt);
|
|
sqlite3_free(p);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Perform a read or write operation on a blob
|
|
*/
|
|
static int blobReadWrite(
|
|
sqlite3_blob *pBlob,
|
|
void *z,
|
|
int n,
|
|
int iOffset,
|
|
int (*xCall)(BtCursor*, u32, u32, void*)
|
|
){
|
|
int rc;
|
|
Incrblob *p = (Incrblob *)pBlob;
|
|
Vdbe *v;
|
|
sqlite3 *db = p->db;
|
|
|
|
/* Request is out of range. Return a transient error. */
|
|
if( (iOffset+n)>p->nByte ){
|
|
return SQLITE_ERROR;
|
|
}
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
/* If there is no statement handle, then the blob-handle has
|
|
** already been invalidated. Return SQLITE_ABORT in this case.
|
|
*/
|
|
v = (Vdbe*)p->pStmt;
|
|
if( v==0 ){
|
|
rc = SQLITE_ABORT;
|
|
}else{
|
|
/* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
|
|
** returned, clean-up the statement handle.
|
|
*/
|
|
assert( db == v->db );
|
|
sqlite3BtreeEnterCursor(p->pCsr);
|
|
rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
|
|
sqlite3BtreeLeaveCursor(p->pCsr);
|
|
if( rc==SQLITE_ABORT ){
|
|
sqlite3VdbeFinalize(v);
|
|
p->pStmt = 0;
|
|
}else{
|
|
db->errCode = rc;
|
|
v->rc = rc;
|
|
}
|
|
}
|
|
rc = sqlite3ApiExit(db, rc);
|
|
sqlite3_mutex_leave(db->mutex);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
** Read data from a blob handle.
|
|
*/
|
|
int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
|
|
return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
|
|
}
|
|
|
|
/*
|
|
** Write data to a blob handle.
|
|
*/
|
|
int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
|
|
return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
|
|
}
|
|
|
|
/*
|
|
** Query a blob handle for the size of the data.
|
|
**
|
|
** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
|
|
** so no mutex is required for access.
|
|
*/
|
|
int sqlite3_blob_bytes(sqlite3_blob *pBlob){
|
|
Incrblob *p = (Incrblob *)pBlob;
|
|
return p->nByte;
|
|
}
|
|
|
|
#endif /* #ifndef SQLITE_OMIT_INCRBLOB */
|