/*
** Return a pointer corresponding to database zDb (i.e. "main", "temp")
** in connection handle pDb. If such a database cannot be found, return
** a NULL pointer and write an error message to pErrorDb.
**
** If the "temp" database is requested, it may need to be opened by this
** function. If an error occurs while doing so, return 0 and write an
** error message to pErrorDb.
*/
static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
int i = sqlite3FindDbName(pDb, zDb);
if( i==1 ){
Parse sParse;
int rc = 0;
memset(&sParse, 0, sizeof(sParse));
sParse.db = pDb;
if( sqlite3OpenTempDatabase(&sParse) ){
sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s", sParse.zErrMsg);
rc = SQLITE_ERROR;
}
sqlite3DbFree(pErrorDb, sParse.zErrMsg);
sqlite3ParserReset(&sParse);
if( rc ){
return 0;
}
}
if( i<0 ){
sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
return 0;
}
return pDb->aDb[i].pBt;
}
/*
** Return a pointer corresponding to database zDb (i.e. "main", "temp")
** in connection handle pDb. If such a database cannot be found, return
** a NULL pointer and write an error message to pErrorDb.
**
** If the "temp" database is requested, it may need to be opened by this
** function. If an error occurs while doing so, return 0 and write an
** error message to pErrorDb.
*/
static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb) {
int i = sqlite3FindDbName(pDb, zDb);
if( i==1 ) {
Parse *pParse;
int rc = 0;
pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
if( pParse==0 ) {
sqlite3Error(pErrorDb, SQLITE_NOMEM, "out of memory");
rc = SQLITE_NOMEM;
} else {
pParse->db = pDb;
if( sqlite3OpenTempDatabase(pParse) ) {
sqlite3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
rc = SQLITE_ERROR;
}
sqlite3DbFree(pErrorDb, pParse->zErrMsg);
sqlite3StackFree(pErrorDb, pParse);
}
if( rc ) {
return 0;
}
}
if( i<0 ) {
sqlite3Error(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
return 0;
}
return pDb->aDb[i].pBt;
}
/* Convert zSchema to a MemDB and initialize its content.
*/
int sqlite3_deserialize(
sqlite3 *db, /* The database connection */
const char *zSchema, /* Which DB to reopen with the deserialization */
unsigned char *pData, /* The serialized database content */
sqlite3_int64 szDb, /* Number bytes in the deserialization */
sqlite3_int64 szBuf, /* Total size of buffer pData[] */
unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */
){
MemFile *p;
char *zSql;
sqlite3_stmt *pStmt = 0;
int rc;
int iDb;
#ifdef SQLITE_ENABLE_API_ARMOR
if( !sqlite3SafetyCheckOk(db) ){
return SQLITE_MISUSE_BKPT;
}
if( szDb<0 ) return SQLITE_MISUSE_BKPT;
if( szBuf<0 ) return SQLITE_MISUSE_BKPT;
#endif
sqlite3_mutex_enter(db->mutex);
if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
iDb = sqlite3FindDbName(db, zSchema);
if( iDb<0 ){
rc = SQLITE_ERROR;
goto end_deserialize;
}
zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema);
rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
sqlite3_free(zSql);
if( rc ) goto end_deserialize;
db->init.iDb = (u8)iDb;
db->init.reopenMemdb = 1;
rc = sqlite3_step(pStmt);
db->init.reopenMemdb = 0;
if( rc!=SQLITE_DONE ){
rc = SQLITE_ERROR;
goto end_deserialize;
}
p = memdbFromDbSchema(db, zSchema);
if( p==0 ){
rc = SQLITE_ERROR;
}else{
p->aData = pData;
p->sz = szDb;
p->szMax = szBuf;
p->mFlags = mFlags;
rc = SQLITE_OK;
}
end_deserialize:
sqlite3_finalize(pStmt);
sqlite3_mutex_leave(db->mutex);
return rc;
}
static int statFilter(
sqlite3_vtab_cursor *pCursor,
int idxNum, const char *idxStr,
int argc, sqlite3_value **argv
){
StatCursor *pCsr = (StatCursor *)pCursor;
StatTable *pTab = (StatTable*)(pCursor->pVtab);
char *zSql;
int rc = SQLITE_OK;
char *zMaster;
if( idxNum==1 ){
const char *zDbase = (const char*)sqlite3_value_text(argv[0]);
pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
if( pCsr->iDb<0 ){
sqlite3_free(pCursor->pVtab->zErrMsg);
pCursor->pVtab->zErrMsg = sqlite3_mprintf("no such schema: %s", zDbase);
return pCursor->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM_BKPT;
}
}else{
pCsr->iDb = pTab->iDb;
}
statResetCsr(pCsr);
sqlite3_finalize(pCsr->pStmt);
pCsr->pStmt = 0;
zMaster = pCsr->iDb==1 ? "sqlite_temp_master" : "sqlite_master";
zSql = sqlite3_mprintf(
"SELECT 'sqlite_master' AS name, 1 AS rootpage, 'table' AS type"
" UNION ALL "
"SELECT name, rootpage, type"
" FROM \"%w\".%s WHERE rootpage!=0"
" ORDER BY name", pTab->db->aDb[pCsr->iDb].zName, zMaster);
if( zSql==0 ){
return SQLITE_NOMEM_BKPT;
}else{
rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
sqlite3_free(zSql);
}
if( rc==SQLITE_OK ){
rc = statNext(pCursor);
}
return rc;
}
/*
** idxNum:
**
** 0 schema=main, full table scan
** 1 schema=main, pgno=?1
** 2 schema=?1, full table scan
** 3 schema=?1, pgno=?2
**
** idxStr is not used
*/
static int dbpageFilter(
sqlite3_vtab_cursor *pCursor,
int idxNum, const char *idxStr,
int argc, sqlite3_value **argv
){
DbpageCursor *pCsr = (DbpageCursor *)pCursor;
DbpageTable *pTab = (DbpageTable *)pCursor->pVtab;
int rc;
sqlite3 *db = pTab->db;
Btree *pBt;
/* Default setting is no rows of result */
pCsr->pgno = 1;
pCsr->mxPgno = 0;
if( idxNum & 2 ){
const char *zSchema;
assert( argc>=1 );
zSchema = (const char*)sqlite3_value_text(argv[0]);
pCsr->iDb = sqlite3FindDbName(db, zSchema);
if( pCsr->iDb<0 ) return SQLITE_OK;
}else{
pCsr->iDb = 0;
}
pBt = db->aDb[pCsr->iDb].pBt;
if( pBt==0 ) return SQLITE_OK;
pCsr->pPager = sqlite3BtreePager(pBt);
pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
pCsr->mxPgno = sqlite3BtreeLastPage(pBt);
if( idxNum & 1 ){
assert( argc>(idxNum>>1) );
pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
pCsr->pgno = 1;
pCsr->mxPgno = 0;
}else{
pCsr->mxPgno = pCsr->pgno;
}
}else{
/*
** Copy nPage pages from the source b-tree to the destination.
*/
int sqlite3_backup_step(sqlite3_backup *p, int nPage) {
int returnCode, pages;
Parse parse;
DB_ENV *dbenv;
BtShared *pBtDest, *pBtSrc;
pBtDest = pBtSrc = NULL;
if (p->rc != SQLITE_OK || nPage == 0)
return p->rc;
sqlite3_mutex_enter(p->pSrcDb->mutex);
sqlite3_mutex_enter(p->pDestDb->mutex);
/*
* Make sure the schema has been read in, so the keyInfo
* can be retrieved for the indexes. No-op if already read.
* If the schema has not been read then an update must have
* changed it, so backup will restart.
*/
memset(&parse, 0, sizeof(parse));
parse.db = p->pSrcDb;
p->rc = sqlite3ReadSchema(&parse);
if (p->rc != SQLITE_OK)
goto err;
/*
* This process updated the source database, so
* the backup process has to restart.
*/
if (p->pSrc->updateDuringBackup > p->lastUpdate) {
p->rc = SQLITE_LOCKED;
if ((p->rc = backupCleanup(p)) != SQLITE_OK)
goto err;
else
backupReset(p);
}
pages = nPage;
if (!p->cleaned) {
const char *home;
const char inmem[9] = ":memory:";
int storage;
pBtDest = p->pDest->pBt;
storage = p->pDest->pBt->dbStorage;
if (storage == DB_STORE_NAMED)
p->openDest = 1;
p->rc = btreeDeleteEnvironment(p->pDest, p->fullName, 1);
if (storage == DB_STORE_INMEM && strcmp(p->destName, "temp")
!= 0)
home = inmem;
else
home = p->fullName;
p->pDest = p->pDestDb->aDb[p->iDb].pBt;
if (p->rc != SQLITE_OK)
goto err;
/*
* Call sqlite3OpenTempDatabase instead of
* sqlite3BtreeOpen, because sqlite3OpenTempDatabase
* automatically chooses the right flags before calling
* sqlite3BtreeOpen.
*/
if (strcmp(p->destName, "temp") == 0) {
memset(&parse, 0, sizeof(parse));
parse.db = p->pDestDb;
p->rc = sqlite3OpenTempDatabase(&parse);
p->pDest = p->pDestDb->aDb[p->iDb].pBt;
} else {
p->rc = sqlite3BtreeOpen(home, p->pDestDb,
&p->pDest, SQLITE_DEFAULT_CACHE_SIZE |
SQLITE_OPEN_MAIN_DB, p->pDestDb->openFlags);
p->pDestDb->aDb[p->iDb].pBt = p->pDest;
if (p->rc == SQLITE_OK) {
p->pDestDb->aDb[p->iDb].pSchema =
sqlite3SchemaGet(p->pDestDb, p->pDest);
if (!p->pDestDb->aDb[p->iDb].pSchema)
p->rc = SQLITE_NOMEM;
} else
p->pDestDb->aDb[p->iDb].pSchema = NULL;
}
if (p->pDest)
p->pDest->nBackup++;
#ifdef SQLITE_HAS_CODEC
/*
* In the case of a temporary source database, use the
* encryption of the main database.
*/
if (strcmp(p->srcName, "temp") == 0) {
int iDb = sqlite3FindDbName(p->pSrcDb, "main");
pBtSrc = p->pSrcDb->aDb[iDb].pBt->pBt;
} else
pBtSrc = p->pSrc->pBt;
if (p->rc == SQLITE_OK) {
if (p->iDb == 0)
p->rc = sqlite3_key(p->pDestDb,
pBtSrc->encrypt_pwd,
pBtSrc->encrypt_pwd_len);
else
p->rc = sqlite3CodecAttach(p->pDestDb, p->iDb,
pBtSrc->encrypt_pwd,
pBtSrc->encrypt_pwd_len);
}
#endif
if (p->rc != SQLITE_OK)
goto err;
p->cleaned = 1;
}
/*
* Begin a transaction, unfortuantely the lock on
* the schema has to be released to allow the sqlite_master
* table to be cleared, which could allow another thread to
* alter it, however accessing the backup database during
* backup is already an illegal condition with undefined
* results.
*/
if (!sqlite3BtreeIsInTrans(p->pDest)) {
if (!p->pDest->connected) {
p->rc = btreeOpenEnvironment(p->pDest, 1);
if (p->rc != SQLITE_OK)
goto err;
}
if ((p->rc = sqlite3BtreeBeginTrans(p->pDest, 2))
!= SQLITE_OK)
goto err;
}
/* Only this process should be accessing the backup environment. */
if (p->pDest->pBt->nRef > 1) {
p->rc = SQLITE_BUSY;
goto err;
}
/*
* Begin a transaction, a lock error or update could have caused
* it to be released in a previous call to step.
*/
if (!p->srcTxn) {
dbenv = p->pSrc->pBt->dbenv;
if ((p->rc = dberr2sqlite(dbenv->txn_begin(dbenv,
p->pSrc->family_txn, &p->srcTxn, 0))) != SQLITE_OK)
goto err;
}
/*
* An update could have dropped or created a table, so recalculate
* the list of tables.
*/
if (!p->tables) {
if ((p->rc = btreeGetPageCount(p->pSrc,
&p->tables, &p->nPagecount, p->srcTxn)) != SQLITE_OK) {
sqlite3Error(p->pSrcDb, p->rc, 0);
goto err;
}
p->nRemaining = p->nPagecount;
}
/* Copy the pages. */
p->rc = btreeCopyPages(p, &pages);
if (p->rc == SQLITE_DONE) {
p->nRemaining = 0;
sqlite3ResetInternalSchema(p->pDestDb, p->iDb);
memset(&parse, 0, sizeof(parse));
parse.db = p->pDestDb;
p->rc = sqlite3ReadSchema(&parse);
if (p->rc == SQLITE_OK)
p->rc = SQLITE_DONE;
} else if (p->rc != SQLITE_OK)
goto err;
/*
* The number of pages left to copy is an estimate, so
* do not let the number go to zero unless we are really
* done.
*/
if (p->rc != SQLITE_DONE) {
if ((u32)pages >= p->nRemaining)
p->nRemaining = 1;
else
p->nRemaining -= pages;
}
err: /*
* This process updated the source database, so
* the backup process has to restart.
*/
if (p->pSrc->updateDuringBackup > p->lastUpdate &&
(p->rc == SQLITE_OK || p->rc == SQLITE_DONE)) {
int cleanCode;
returnCode = p->rc;
p->rc = SQLITE_LOCKED;
if ((cleanCode = backupCleanup(p)) != SQLITE_OK)
returnCode = p->rc = cleanCode;
else
backupReset(p);
} else {
returnCode = backupCleanup(p);
if (returnCode == SQLITE_OK ||
(p->rc != SQLITE_OK && p->rc != SQLITE_DONE))
returnCode = p->rc;
else
p->rc = returnCode;
}
/*
* On a locked or busy error the backup process is rolled back,
* but can be restarted by the user.
*/
if ( returnCode == SQLITE_LOCKED || returnCode == SQLITE_BUSY )
backupReset(p);
else if ( returnCode != SQLITE_OK && returnCode != SQLITE_DONE ) {
sqlite3Error(p->pDestDb, p->rc, 0);
}
sqlite3_mutex_leave(p->pDestDb->mutex);
sqlite3_mutex_leave(p->pSrcDb->mutex);
return (returnCode);
}
/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
** pDestDb Database to write to
** zDestDb Name of database within pDestDb
** pSrcDb Database connection to read from
** zSrcDb Name of database within pSrcDb
*/
sqlite3_backup *sqlite3_backup_init(sqlite3* pDestDb, const char *zDestDb,
sqlite3* pSrcDb, const char *zSrcDb)
{
sqlite3_backup *p; /* Value to return */
Parse parse;
DB_ENV *dbenv;
int ret;
p = NULL;
ret = 0;
if (!pDestDb || !pSrcDb)
return 0;
sqlite3_mutex_enter(pSrcDb->mutex);
sqlite3_mutex_enter(pDestDb->mutex);
if (pSrcDb == pDestDb) {
sqlite3Error(pDestDb, SQLITE_ERROR,
"source and destination must be distinct");
goto err;
}
/* Allocate space for a new sqlite3_backup object */
p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup));
if (!p) {
sqlite3Error(pDestDb, SQLITE_NOMEM, 0);
goto err;
}
memset(p, 0, sizeof(sqlite3_backup));
p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
p->pDestDb = pDestDb;
p->pSrcDb = pSrcDb;
if (0 == p->pSrc) {
p->rc = p->pSrcDb->errCode;
goto err;
}
if (0 == p->pDest) {
p->rc = p->pDestDb->errCode;
goto err;
}
p->iDb = sqlite3FindDbName(pDestDb, zDestDb);
p->srcName = sqlite3_malloc((int)strlen(zSrcDb) + 1);
p->destName = sqlite3_malloc((int)strlen(zDestDb) + 1);
if (0 == p->srcName || 0 == p->destName) {
p->rc = SQLITE_NOMEM;
goto err;
}
strncpy(p->srcName, zSrcDb, strlen(zSrcDb) + 1);
strncpy(p->destName, zDestDb, strlen(zDestDb) + 1);
if (p->pDest->pBt->full_name) {
const char *fullName = p->pDest->pBt->full_name;
p->fullName = sqlite3_malloc((int)strlen(fullName) + 1);
if (!p->fullName) {
p->rc = SQLITE_NOMEM;
goto err;
}
strncpy(p->fullName, fullName, strlen(fullName) + 1);
}
/*
* Make sure the schema has been read in, so the keyInfo
* can be retrieved for the indexes. No-op if already read.
*/
memset(&parse, 0, sizeof(parse));
parse.db = p->pSrcDb;
p->rc = sqlite3ReadSchema(&parse);
if (p->rc != SQLITE_OK) {
if (parse.zErrMsg != NULL)
sqlite3DbFree(p->pSrcDb, parse.zErrMsg);
goto err;
}
/* Begin a transaction on the source. */
if (!p->pSrc->connected) {
if ((p->rc = btreeOpenEnvironment(p->pSrc, 1)) != SQLITE_OK)
goto err;
}
dbenv = p->pSrc->pBt->dbenv;
p->rc = dberr2sqlite(dbenv->txn_begin(dbenv, p->pSrc->family_txn,
&p->srcTxn, 0));
if (p->rc != SQLITE_OK) {
sqlite3Error(pSrcDb, p->rc, 0);
goto err;
}
/*
* Get the page count and list of tables to copy. This will
* result in a read lock on the schema table, held in the
* read transaction.
*/
if ((p->rc = btreeGetPageCount(p->pSrc,
&p->tables, &p->nPagecount, p->srcTxn)) != SQLITE_OK) {
sqlite3Error(pSrcDb, p->rc, 0);
goto err;
}
p->nRemaining = p->nPagecount;
p->pSrc->nBackup++;
p->pDest->nBackup++;
p->lastUpdate = p->pSrc->updateDuringBackup;
goto done;
err: if (p != 0) {
if (pDestDb->errCode == SQLITE_OK)
sqlite3Error(pDestDb, p->rc, 0);
if (p->srcTxn)
p->srcTxn->abort(p->srcTxn);
if (p->srcName != 0)
sqlite3_free(p->srcName);
if (p->destName != 0)
sqlite3_free(p->destName);
if (p->fullName != 0)
sqlite3_free(p->fullName);
if (p->tables != 0)
sqlite3_free(p->tables);
sqlite3_free(p);
p = NULL;
}
done: sqlite3_mutex_leave(pDestDb->mutex);
sqlite3_mutex_leave(pSrcDb->mutex);
return p;
}
/*
** Return the serialization of a database
*/
unsigned char *sqlite3_serialize(
sqlite3 *db, /* The database connection */
const char *zSchema, /* Which database within the connection */
sqlite3_int64 *piSize, /* Write size here, if not NULL */
unsigned int mFlags /* Maybe SQLITE_SERIALIZE_NOCOPY */
){
MemFile *p;
int iDb;
Btree *pBt;
sqlite3_int64 sz;
int szPage = 0;
sqlite3_stmt *pStmt = 0;
unsigned char *pOut;
char *zSql;
int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
if( !sqlite3SafetyCheckOk(db) ){
(void)SQLITE_MISUSE_BKPT;
return 0;
}
#endif
if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
p = memdbFromDbSchema(db, zSchema);
iDb = sqlite3FindDbName(db, zSchema);
if( piSize ) *piSize = -1;
if( iDb<0 ) return 0;
if( p ){
if( piSize ) *piSize = p->sz;
if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
pOut = p->aData;
}else{
pOut = sqlite3_malloc64( p->sz );
if( pOut ) memcpy(pOut, p->aData, p->sz);
}
return pOut;
}
pBt = db->aDb[iDb].pBt;
if( pBt==0 ) return 0;
szPage = sqlite3BtreeGetPageSize(pBt);
zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema);
rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
sqlite3_free(zSql);
if( rc ) return 0;
rc = sqlite3_step(pStmt);
if( rc!=SQLITE_ROW ){
pOut = 0;
}else{
sz = sqlite3_column_int64(pStmt, 0)*szPage;
if( piSize ) *piSize = sz;
if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
pOut = 0;
}else{
pOut = sqlite3_malloc64( sz );
if( pOut ){
int nPage = sqlite3_column_int(pStmt, 0);
Pager *pPager = sqlite3BtreePager(pBt);
int pgno;
for(pgno=1; pgno<=nPage; pgno++){
DbPage *pPage = 0;
unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
if( rc==SQLITE_OK ){
memcpy(pTo, sqlite3PagerGetData(pPage), szPage);
}else{
memset(pTo, 0, szPage);
}
sqlite3PagerUnref(pPage);
}
}
}
}
sqlite3_finalize(pStmt);
return pOut;
}
