自学教程：C++ sqlite3BtreeEnter函数代码示例

/*** Usage:   btree_get_meta ID**** Return meta data*/static int btree_get_meta(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int rc;  int i;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  for(i=0; i<SQLITE_N_BTREE_META; i++){    char zBuf[30];    u32 v;    sqlite3BtreeEnter(pBt);    rc = sqlite3BtreeGetMeta(pBt, i, &v);    sqlite3BtreeLeave(pBt);    if( rc!=SQLITE_OK ){      Tcl_AppendResult(interp, errorName(rc), 0);      return TCL_ERROR;    }    sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",v);    Tcl_AppendElement(interp, zBuf);  }  return TCL_OK;}

/*** Usage:   btree_cursor ID TABLENUM WRITEABLE**** Create a new cursor.  Return the ID for the cursor.*/static int btree_cursor(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int iTable;  BtCursor *pCur;  int rc;  int wrFlag;  char zBuf[30];  if( argc!=4 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID TABLENUM WRITEABLE/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;  if( Tcl_GetBoolean(interp, argv[3], &wrFlag) ) return TCL_ERROR;  pCur = (BtCursor *)ckalloc(sqlite3BtreeCursorSize());  memset(pCur, 0, sqlite3BtreeCursorSize());  sqlite3BtreeEnter(pBt);  rc = sqlite3BtreeCursor(pBt, iTable, wrFlag, 0, pCur);  sqlite3BtreeLeave(pBt);  if( rc ){    ckfree((char *)pCur);    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pCur);  Tcl_AppendResult(interp, zBuf, 0);  return SQLITE_OK;}

/*** Usage:   btree_ismemdb ID**** Return true if the B-Tree is currently stored entirely in memory.*/static int btree_ismemdb(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int res;  sqlite3_file *pFile;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  sqlite3_mutex_enter(pBt->db->mutex);  sqlite3BtreeEnter(pBt);  pFile = sqlite3PagerFile(sqlite3BtreePager(pBt));  res = (pFile->pMethods==0);  sqlite3BtreeLeave(pBt);  sqlite3_mutex_leave(pBt->db->mutex);  Tcl_SetObjResult(interp, Tcl_NewBooleanObj(res));  return SQLITE_OK;}

/*** Usage:   btree_update_meta ID METADATA...**** Return meta data*/static int btree_update_meta(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int rc;  int i;  int aMeta[SQLITE_N_BTREE_META];  if( argc!=2+SQLITE_N_BTREE_META ){    char zBuf[30];    sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",SQLITE_N_BTREE_META);    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID METADATA.../" (METADATA is ", zBuf, " integers)", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  for(i=1; i<SQLITE_N_BTREE_META; i++){    if( Tcl_GetInt(interp, argv[i+2], &aMeta[i]) ) return TCL_ERROR;  }  for(i=1; i<SQLITE_N_BTREE_META; i++){    sqlite3BtreeEnter(pBt);    rc = sqlite3BtreeUpdateMeta(pBt, i, aMeta[i]);    sqlite3BtreeLeave(pBt);    if( rc!=SQLITE_OK ){      Tcl_AppendResult(interp, errorName(rc), 0);      return TCL_ERROR;    }  }  return TCL_OK;}

/*** Usage:   btree_close_cursor ID**** Close a cursor opened using btree_cursor.*/static int btree_close_cursor(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  BtCursor *pCur;  Btree *pBt;  int rc;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pCur = sqlite3TestTextToPtr(argv[1]);  pBt = pCur->pBtree;  sqlite3BtreeEnter(pBt);  rc = sqlite3BtreeCloseCursor(pCur);  sqlite3BtreeLeave(pBt);  ckfree((char *)pCur);  if( rc ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  return SQLITE_OK;}

/*** Usage:   btree_first ID**** Move the cursor to the first entry in the table.  Return 0 if the** cursor was left point to something and 1 if the table is empty.*/static int btree_first(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  BtCursor *pCur;  int rc;  int res = 0;  char zBuf[100];  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pCur = sqlite3TestTextToPtr(argv[1]);  sqlite3BtreeEnter(pCur->pBtree);  rc = sqlite3BtreeFirst(pCur, &res);  sqlite3BtreeLeave(pCur->pBtree);  if( rc ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);  Tcl_AppendResult(interp, zBuf, 0);  return SQLITE_OK;}

/*** Usage:   btree_payload_size ID**** Return the number of bytes of payload*/static int btree_payload_size(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  BtCursor *pCur;  int n2;  u64 n1;  char zBuf[50];  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pCur = sqlite3TestTextToPtr(argv[1]);  sqlite3BtreeEnter(pCur->pBtree);  /* The cursor may be in "require-seek" state. If this is the case, the  ** call to BtreeDataSize() will fix it. */  sqlite3BtreeDataSize(pCur, (u32*)&n2);  if( pCur->apPage[pCur->iPage]->intKey ){    n1 = 0;  }else{    sqlite3BtreeKeySize(pCur, (i64*)&n1);  }  sqlite3BtreeLeave(pCur->pBtree);  sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", (int)(n1+n2));  Tcl_AppendResult(interp, zBuf, 0);  return SQLITE_OK;}

/*** Invoke the xFileControl method on a particular database.*/EXPORT_C int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){  int rc = SQLITE_ERROR;  int iDb;  sqlite3_mutex_enter(db->mutex);  if( zDbName==0 ){    iDb = 0;  }else{    for(iDb=0; iDb<db->nDb; iDb++){      if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;    }  }  if( iDb<db->nDb ){    Btree *pBtree = db->aDb[iDb].pBt;    if( pBtree ){      Pager *pPager;      sqlite3BtreeEnter(pBtree);      pPager = sqlite3BtreePager(pBtree);      if( pPager ){        sqlite3_file *fd = sqlite3PagerFile(pPager);        if( fd ){          rc = sqlite3OsFileControl(fd, op, pArg);        }      }      sqlite3BtreeLeave(pBtree);    }  }  sqlite3_mutex_leave(db->mutex);  return rc;   }

/*** Usage:   btree_create_table ID FLAGS**** Create a new table in the database*/static int btree_create_table(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int rc, iTable, flags;  char zBuf[30];  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID FLAGS/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  if( Tcl_GetInt(interp, argv[2], &flags) ) return TCL_ERROR;  sqlite3BtreeEnter(pBt);  rc = sqlite3BtreeCreateTable(pBt, &iTable, flags);  sqlite3BtreeLeave(pBt);  if( rc!=SQLITE_OK ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", iTable);  Tcl_AppendResult(interp, zBuf, 0);  return TCL_OK;}

/*** Usage:   btree_clear_table ID TABLENUM**** Remove all entries from the given table but keep the table around.*/static int btree_clear_table(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int iTable;  int rc;  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID TABLENUM/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;  sqlite3BtreeEnter(pBt);  rc = sqlite3BtreeClearTable(pBt, iTable, 0);  sqlite3BtreeLeave(pBt);  if( rc!=SQLITE_OK ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  return TCL_OK;}

/*** Enter the mutex on every Btree associated with a database** connection.  This is needed (for example) prior to parsing** a statement since we will be comparing table and column names** against all schemas and we do not want those schemas being** reset out from under us.**** There is a corresponding leave-all procedures.**** Enter the mutexes in accending order by BtShared pointer address** to avoid the possibility of deadlock when two threads with** two or more btrees in common both try to lock all their btrees** at the same instant.*/void sqlite3BtreeEnterAll(sqlite3 *db){  int i;  Btree *p;  assert( sqlite3_mutex_held(db->mutex) );  for(i=0; i<db->nDb; i++){    p = db->aDb[i].pBt;    if( p ) sqlite3BtreeEnter(p);  }}

/*** Usage:   btree_pager_stats ID**** Returns pager statistics*/static int btree_pager_stats(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int i;  int *a;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);   /* Normally in this file, with a b-tree handle opened using the   ** [btree_open] command it is safe to call sqlite3BtreeEnter() directly.  ** But this function is sometimes called with a btree handle obtained  ** from an open SQLite connection (using [btree_from_db]). In this case  ** we need to obtain the mutex for the controlling SQLite handle before  ** it is safe to call sqlite3BtreeEnter().  */  sqlite3_mutex_enter(pBt->db->mutex);  sqlite3BtreeEnter(pBt);  a = sqlite3PagerStats(sqlite3BtreePager(pBt));  for(i=0; i<11; i++){    static char *zName[] = {      "ref", "page", "max", "size", "state", "err",      "hit", "miss", "ovfl", "read", "write"    };    char zBuf[100];    Tcl_AppendElement(interp, zName[i]);    sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",a[i]);    Tcl_AppendElement(interp, zBuf);  }  sqlite3BtreeLeave(pBt);  /* Release the mutex on the SQLite handle that controls this b-tree */  sqlite3_mutex_leave(pBt->db->mutex);  return TCL_OK;}

/*** This function is called after a transaction has been committed. It ** invokes callbacks registered with sqlite3_wal_hook() as required.*/static int doWalCallbacks(sqlite3 *db){  int rc = SQLITE_OK;#ifndef SQLITE_OMIT_WAL  int i;  for(i=0; i<db->nDb; i++){    Btree *pBt = db->aDb[i].pBt;    if( pBt ){      int nEntry;      sqlite3BtreeEnter(pBt);      nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));      sqlite3BtreeLeave(pBt);      if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){        rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);      }    }  }#endif  return rc;}

/*** Usage:   btree_cursor_list ID**** Print information about all cursors to standard output for debugging.*/static int btree_cursor_list(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  sqlite3BtreeEnter(pBt);  sqlite3BtreeCursorList(pBt);  sqlite3BtreeLeave(pBt);  return SQLITE_OK;}

/*** Usage:   btree_pager_ref_dump ID**** Print out all outstanding pages.*/static int btree_pager_ref_dump(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TextToPtr(argv[1]);#ifdef SQLITE_TEST  sqlite3BtreeEnter(pBt);  sqlite3PagerRefdump(sqlite3BtreePager(pBt));  sqlite3BtreeLeave(pBt);#endif  return TCL_OK;}

/*** usage:   btree_insert CSR ?KEY? VALUE**** Set the size of the cache used by btree $ID.*/static int btree_insert(  ClientData clientData,  Tcl_Interp *interp,  int objc,  Tcl_Obj *const objv[]){  BtCursor *pCur;  int rc;  BtreePayload x;  if( objc!=4 && objc!=3 ){    Tcl_WrongNumArgs(interp, 1, objv, "?-intkey? CSR KEY VALUE");    return TCL_ERROR;  }  memset(&x, 0, sizeof(x));  if( objc==4 ){    if( Tcl_GetIntFromObj(interp, objv[2], &rc) ) return TCL_ERROR;    x.nKey = rc;    x.pData = (void*)Tcl_GetByteArrayFromObj(objv[3], &x.nData);  }else{    x.pKey = (void*)Tcl_GetByteArrayFromObj(objv[2], &rc);    x.nKey = rc;  }  pCur = (BtCursor*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));  sqlite3_mutex_enter(pCur->pBtree->db->mutex);  sqlite3BtreeEnter(pCur->pBtree);  rc = sqlite3BtreeInsert(pCur, &x, 0, 0);  sqlite3BtreeLeave(pCur->pBtree);  sqlite3_mutex_leave(pCur->pBtree->db->mutex);  Tcl_ResetResult(interp);  if( rc ){    Tcl_AppendResult(interp, sqlite3ErrName(rc), 0);    return TCL_ERROR;  }  return TCL_OK;}

/*** Usage:   btree_move_to ID KEY**** Move the cursor to the entry with the given key.*/static int btree_move_to(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  BtCursor *pCur;  int rc;  int res;  char zBuf[20];  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID KEY/"", 0);    return TCL_ERROR;  }  pCur = sqlite3TestTextToPtr(argv[1]);  sqlite3BtreeEnter(pCur->pBtree);  if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){    int iKey;    if( Tcl_GetInt(interp, argv[2], &iKey) ){      sqlite3BtreeLeave(pCur->pBtree);      return TCL_ERROR;    }    rc = sqlite3BtreeMovetoUnpacked(pCur, 0, iKey, 0, &res);  }else{    rc = sqlite3BtreeMoveto(pCur, argv[2], strlen(argv[2]), 0, &res);    }  sqlite3BtreeLeave(pCur->pBtree);  if( rc ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  if( res<0 ) res = -1;  if( res>0 ) res = 1;  sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",res);  Tcl_AppendResult(interp, zBuf, 0);  return SQLITE_OK;}

/*** Usage:   btree_integrity_check ID ROOT ...**** Look through every page of the given BTree file to verify correct** formatting and linkage.  Return a line of text for each problem found.** Return an empty string if everything worked.*/static int btree_integrity_check(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int nRoot;  int *aRoot;  int i;  int nErr;  char *zResult;  if( argc<3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID ROOT .../"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  nRoot = argc-2;  aRoot = (int*)sqlite3_malloc( sizeof(int)*(argc-2) );  for(i=0; i<argc-2; i++){    if( Tcl_GetInt(interp, argv[i+2], &aRoot[i]) ) return TCL_ERROR;  }#ifndef SQLITE_OMIT_INTEGRITY_CHECK  sqlite3BtreeEnter(pBt);  zResult = sqlite3BtreeIntegrityCheck(pBt, aRoot, nRoot, 10000, &nErr);  sqlite3BtreeLeave(pBt);#else  zResult = 0;#endif  sqlite3_free((void*)aRoot);  if( zResult ){    Tcl_AppendResult(interp, zResult, 0);    sqlite3_free(zResult);   }  return TCL_OK;}

/*** Usage:   btree_begin_transaction ID**** Start a new transaction*/static int btree_begin_transaction(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int rc;  if( argc!=2 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " ID/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  sqlite3BtreeEnter(pBt);  rc = sqlite3BtreeBeginTrans(pBt, 1);  sqlite3BtreeLeave(pBt);  if( rc!=SQLITE_OK ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  return TCL_OK;}

/*** usage:   btree_set_cache_size ID NCACHE**** Set the size of the cache used by btree $ID.*/static int btree_set_cache_size(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  int nCache;  Btree *pBt;    if( argc!=3 ){    Tcl_AppendResult(        interp, "wrong # args: should be /"", argv[0], " BT NCACHE/"", 0);    return TCL_ERROR;  }  pBt = sqlite3TestTextToPtr(argv[1]);  if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;  sqlite3_mutex_enter(pBt->db->mutex);  sqlite3BtreeEnter(pBt);  sqlite3BtreeSetCacheSize(pBt, nCache);  sqlite3BtreeLeave(pBt);  sqlite3_mutex_leave(pBt->db->mutex);  return TCL_OK;}      

/*** Copy nPage pages from the source b-tree to the destination.*/int sqlite3_backup_step(sqlite3_backup *p, int nPage){  int rc;  int destMode;       /* Destination journal mode */  int pgszSrc = 0;    /* Source page size */  int pgszDest = 0;   /* Destination page size */#ifdef SQLITE_ENABLE_API_ARMOR  if( p==0 ) return SQLITE_MISUSE_BKPT;#endif  sqlite3_mutex_enter(p->pSrcDb->mutex);  sqlite3BtreeEnter(p->pSrc);  if( p->pDestDb ){    sqlite3_mutex_enter(p->pDestDb->mutex);  }  rc = p->rc;  if( !isFatalError(rc) ){    Pager * const pSrcPager = sqlite3BtreePager(p->pSrc);     /* Source pager */    Pager * const pDestPager = sqlite3BtreePager(p->pDest);   /* Dest pager */    int ii;                            /* Iterator variable */    int nSrcPage = -1;                 /* Size of source db in pages */    int bCloseTrans = 0;               /* True if src db requires unlocking */    /* If the source pager is currently in a write-transaction, return    ** SQLITE_BUSY immediately.    */    if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){      rc = SQLITE_BUSY;    }else{      rc = SQLITE_OK;    }    /* If there is no open read-transaction on the source database, open    ** one now. If a transaction is opened here, then it will be closed    ** before this function exits.    */    if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){      rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0);      bCloseTrans = 1;    }    /* If the destination database has not yet been locked (i.e. if this    ** is the first call to backup_step() for the current backup operation),    ** try to set its page size to the same as the source database. This    ** is especially important on ZipVFS systems, as in that case it is    ** not possible to create a database file that uses one page size by    ** writing to it with another.  */    if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){      rc = SQLITE_NOMEM;    }    /* Lock the destination database, if it is not locked already. */    if( SQLITE_OK==rc && p->bDestLocked==0     && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,                                                (int*)&p->iDestSchema))     ){      p->bDestLocked = 1;    }    /* Do not allow backup if the destination database is in WAL mode    ** and the page sizes are different between source and destination */    pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);    pgszDest = sqlite3BtreeGetPageSize(p->pDest);    destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));    if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){      rc = SQLITE_READONLY;    }      /* Now that there is a read-lock on the source database, query the    ** source pager for the number of pages in the database.    */    nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);    assert( nSrcPage>=0 );    for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){      const Pgno iSrcPg = p->iNext;                 /* Source page number */      if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){        DbPage *pSrcPg;                             /* Source page object */        rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg,PAGER_GET_READONLY);        if( rc==SQLITE_OK ){          rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0);          sqlite3PagerUnref(pSrcPg);        }      }      p->iNext++;    }    if( rc==SQLITE_OK ){      p->nPagecount = nSrcPage;      p->nRemaining = nSrcPage+1-p->iNext;      if( p->iNext>(Pgno)nSrcPage ){        rc = SQLITE_DONE;      }else if( !p->isAttached ){        attachBackupObject(p);      }    }      /* Update the schema version field in the destination database. This    ** is to make sure that the schema-version really does change in//.........这里部分代码省略.........

/*** Copy nPage pages from the source b-tree to the destination.*/int sqlite3_backup_step(sqlite3_backup *p, int nPage){  int rc;  int destMode;       /* Destination journal mode */  int pgszSrc = 0;    /* Source page size */  int pgszDest = 0;   /* Destination page size */  sqlite3_mutex_enter(p->pSrcDb->mutex);  sqlite3BtreeEnter(p->pSrc);  if( p->pDestDb ){    sqlite3_mutex_enter(p->pDestDb->mutex);  }  rc = p->rc;  if( !isFatalError(rc) ){    Pager * const pSrcPager = sqlite3BtreePager(p->pSrc);     /* Source pager */    Pager * const pDestPager = sqlite3BtreePager(p->pDest);   /* Dest pager */    int ii;                            /* Iterator variable */    int nSrcPage = -1;                 /* Size of source db in pages */    int bCloseTrans = 0;               /* True if src db requires unlocking */    /* If the source pager is currently in a write-transaction, return    ** SQLITE_BUSY immediately.    */    if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){      rc = SQLITE_BUSY;    }else{      rc = SQLITE_OK;    }    /* Lock the destination database, if it is not locked already. */    if( SQLITE_OK==rc && p->bDestLocked==0     && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))     ){      p->bDestLocked = 1;      sqlite3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema);    }    /* If there is no open read-transaction on the source database, open    ** one now. If a transaction is opened here, then it will be closed    ** before this function exits.    */    if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){      rc = sqlite3BtreeBeginTrans(p->pSrc, 0);      bCloseTrans = 1;    }    /* Do not allow backup if the destination database is in WAL mode    ** and the page sizes are different between source and destination */    pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);    pgszDest = sqlite3BtreeGetPageSize(p->pDest);    destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));    if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){      rc = SQLITE_READONLY;    }      /* Now that there is a read-lock on the source database, query the    ** source pager for the number of pages in the database.    */    nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);    assert( nSrcPage>=0 );    for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){      const Pgno iSrcPg = p->iNext;                 /* Source page number */      if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){        DbPage *pSrcPg;                             /* Source page object */        rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);        if( rc==SQLITE_OK ){          rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg));          sqlite3PagerUnref(pSrcPg);        }      }      p->iNext++;    }    if( rc==SQLITE_OK ){      p->nPagecount = nSrcPage;      p->nRemaining = nSrcPage+1-p->iNext;      if( p->iNext>(Pgno)nSrcPage ){        rc = SQLITE_DONE;      }else if( !p->isAttached ){        attachBackupObject(p);      }    }      /* Update the schema version field in the destination database. This    ** is to make sure that the schema-version really does change in    ** the case where the source and destination databases have the    ** same schema version.    */    if( rc==SQLITE_DONE      && (rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1))==SQLITE_OK    ){      int nDestTruncate;        if( p->pDestDb ){        sqlite3ResetInternalSchema(p->pDestDb, 0);      }      /* Set nDestTruncate to the final number of pages in the destination//.........这里部分代码省略.........

static int statDecodePage(Btree *pBt, StatPage *p){  int nUnused;  int iOff;  int nHdr;  int isLeaf;  int szPage;  u8 *aData = sqlite3PagerGetData(p->pPg);  u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];  p->flags = aHdr[0];  p->nCell = get2byte(&aHdr[3]);  p->nMxPayload = 0;  isLeaf = (p->flags==0x0A || p->flags==0x0D);  nHdr = 12 - isLeaf*4 + (p->iPgno==1)*100;  nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;  nUnused += (int)aHdr[7];  iOff = get2byte(&aHdr[1]);  while( iOff ){    nUnused += get2byte(&aData[iOff+2]);    iOff = get2byte(&aData[iOff]);  }  p->nUnused = nUnused;  p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);  szPage = sqlite3BtreeGetPageSize(pBt);  if( p->nCell ){    int i;                        /* Used to iterate through cells */    int nUsable;                  /* Usable bytes per page */    sqlite3BtreeEnter(pBt);    nUsable = szPage - sqlite3BtreeGetReserveNoMutex(pBt);    sqlite3BtreeLeave(pBt);    p->aCell = sqlite3_malloc64((p->nCell+1) * sizeof(StatCell));    if( p->aCell==0 ) return SQLITE_NOMEM_BKPT;    memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));    for(i=0; i<p->nCell; i++){      StatCell *pCell = &p->aCell[i];      iOff = get2byte(&aData[nHdr+i*2]);      if( !isLeaf ){        pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);        iOff += 4;      }      if( p->flags==0x05 ){        /* A table interior node. nPayload==0. */      }else{        u32 nPayload;             /* Bytes of payload total (local+overflow) */        int nLocal;               /* Bytes of payload stored locally */        iOff += getVarint32(&aData[iOff], nPayload);        if( p->flags==0x0D ){          u64 dummy;          iOff += sqlite3GetVarint(&aData[iOff], &dummy);        }        if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;        getLocalPayload(nUsable, p->flags, nPayload, &nLocal);        pCell->nLocal = nLocal;        assert( nLocal>=0 );        assert( nPayload>=(u32)nLocal );        assert( nLocal<=(nUsable-35) );        if( nPayload>(u32)nLocal ){          int j;          int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);          pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);          pCell->nOvfl = nOvfl;          pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);          if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;          pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);          for(j=1; j<nOvfl; j++){            int rc;            u32 iPrev = pCell->aOvfl[j-1];            DbPage *pPg = 0;            rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);            if( rc!=SQLITE_OK ){              assert( pPg==0 );              return rc;            }             pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));            sqlite3PagerUnref(pPg);          }        }      }    }  }  return SQLITE_OK;}

/*** Enter and leave a mutex on a Btree given a cursor owned by that** Btree.  These entry points are used by incremental I/O and can be** omitted if that module is not used.*/SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){  sqlite3BtreeEnter(pCur->pBtree);}

/*** Move a statvfs cursor to the next entry in the file.*/static int statNext(sqlite3_vtab_cursor *pCursor){  int rc;  int nPayload;  char *z;  StatCursor *pCsr = (StatCursor *)pCursor;  StatTable *pTab = (StatTable *)pCursor->pVtab;  Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;  Pager *pPager = sqlite3BtreePager(pBt);  sqlite3_free(pCsr->zPath);  pCsr->zPath = 0;statNextRestart:  if( pCsr->aPage[0].pPg==0 ){    rc = sqlite3_step(pCsr->pStmt);    if( rc==SQLITE_ROW ){      int nPage;      u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);      sqlite3PagerPagecount(pPager, &nPage);      if( nPage==0 ){        pCsr->isEof = 1;        return sqlite3_reset(pCsr->pStmt);      }      rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0);      pCsr->aPage[0].iPgno = iRoot;      pCsr->aPage[0].iCell = 0;      pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");      pCsr->iPage = 0;      if( z==0 ) rc = SQLITE_NOMEM_BKPT;    }else{      pCsr->isEof = 1;      return sqlite3_reset(pCsr->pStmt);    }  }else{    /* Page p itself has already been visited. */    StatPage *p = &pCsr->aPage[pCsr->iPage];    while( p->iCell<p->nCell ){      StatCell *pCell = &p->aCell[p->iCell];      if( pCell->iOvfl<pCell->nOvfl ){        int nUsable;        sqlite3BtreeEnter(pBt);        nUsable = sqlite3BtreeGetPageSize(pBt) -                         sqlite3BtreeGetReserveNoMutex(pBt);        sqlite3BtreeLeave(pBt);        pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);        pCsr->iPageno = pCell->aOvfl[pCell->iOvfl];        pCsr->zPagetype = "overflow";        pCsr->nCell = 0;        pCsr->nMxPayload = 0;        pCsr->zPath = z = sqlite3_mprintf(            "%s%.3x+%.6x", p->zPath, p->iCell, pCell->iOvfl        );        if( pCell->iOvfl<pCell->nOvfl-1 ){          pCsr->nUnused = 0;          pCsr->nPayload = nUsable - 4;        }else{          pCsr->nPayload = pCell->nLastOvfl;          pCsr->nUnused = nUsable - 4 - pCsr->nPayload;        }        pCell->iOvfl++;        statSizeAndOffset(pCsr);        return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;      }      if( p->iRightChildPg ) break;      p->iCell++;    }    if( !p->iRightChildPg || p->iCell>p->nCell ){      statClearPage(p);      if( pCsr->iPage==0 ) return statNext(pCursor);      pCsr->iPage--;      goto statNextRestart; /* Tail recursion */    }    pCsr->iPage++;    assert( p==&pCsr->aPage[pCsr->iPage-1] );    if( p->iCell==p->nCell ){      p[1].iPgno = p->iRightChildPg;    }else{      p[1].iPgno = p->aCell[p->iCell].iChildPg;    }    rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg, 0);    p[1].iCell = 0;    p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);    p->iCell++;    if( z==0 ) rc = SQLITE_NOMEM_BKPT;  }  /* Populate the StatCursor fields with the values to be returned  ** by the xColumn() and xRowid() methods.  */  if( rc==SQLITE_OK ){    int i;    StatPage *p = &pCsr->aPage[pCsr->iPage];//.........这里部分代码省略.........

//.........这里部分代码省略.........  aNew = &db->aDb[db->nDb];  memset(aNew, 0, sizeof(*aNew));  /* Open the database file. If the btree is successfully opened, use  ** it to obtain the database schema. At this point the schema may  ** or may not be initialized.  */  flags = db->openFlags;  rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);  if( rc!=SQLITE_OK ){    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;    sqlite3_result_error(context, zErr, -1);    sqlite3_free(zErr);    return;  }  assert( pVfs );  flags |= SQLITE_OPEN_MAIN_DB;  rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);  sqlite3_free( zPath );  db->nDb++;  if( rc==SQLITE_CONSTRAINT ){    rc = SQLITE_ERROR;    zErrDyn = sqlite3MPrintf(db, "database is already attached");  }else if( rc==SQLITE_OK ){    Pager *pPager;    aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);    if( !aNew->pSchema ){      rc = SQLITE_NOMEM;    }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){      zErrDyn = sqlite3MPrintf(db,         "attached databases must use the same text encoding as main database");      rc = SQLITE_ERROR;    }    sqlite3BtreeEnter(aNew->pBt);    pPager = sqlite3BtreePager(aNew->pBt);    sqlite3PagerLockingMode(pPager, db->dfltLockMode);    sqlite3BtreeSecureDelete(aNew->pBt,                             sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );#ifndef SQLITE_OMIT_PAGER_PRAGMAS    sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK));#endif    sqlite3BtreeLeave(aNew->pBt);  }  aNew->safety_level = 3;  aNew->zName = sqlite3DbStrDup(db, zName);  if( rc==SQLITE_OK && aNew->zName==0 ){    rc = SQLITE_NOMEM;  }#ifdef SQLITE_HAS_CODEC  if( rc==SQLITE_OK ){    extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);    extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);    int nKey;    char *zKey;    int t = sqlite3_value_type(argv[2]);    switch( t ){      case SQLITE_INTEGER:      case SQLITE_FLOAT:        zErrDyn = sqlite3DbStrDup(db, "Invalid key value");        rc = SQLITE_ERROR;        break;              case SQLITE_TEXT:      case SQLITE_BLOB:

//.........这里部分代码省略.........  createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);  createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);  createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);  createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);  if( db->mallocFailed ){    goto opendb_out;  }  /* EVIDENCE-OF: R-08308-17224 The default collating function for all  ** strings is BINARY.   */  db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);  assert( db->pDfltColl!=0 );  /* Parse the filename/URI argument. */  db->openFlags = flags;  rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);  if( rc!=SQLITE_OK ){    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;    sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);    sqlite3_free(zErrMsg);    goto opendb_out;  }  /* Open the backend database driver */  rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,                        flags | SQLITE_OPEN_MAIN_DB);  if( rc!=SQLITE_OK ){    if( rc==SQLITE_IOERR_NOMEM ){      rc = SQLITE_NOMEM;    }    sqlite3Error(db, rc);    goto opendb_out;  }  sqlite3BtreeEnter(db->aDb[0].pBt);  db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);  if( !db->mallocFailed ) ENC(db) = SCHEMA_ENC(db);  sqlite3BtreeLeave(db->aDb[0].pBt);  db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);  /* The default safety_level for the main database is 'full'; for the temp  ** database it is 'NONE'. This matches the pager layer defaults.    */  db->aDb[0].zName = "main";  db->aDb[0].safety_level = 3;  db->aDb[1].zName = "temp";  db->aDb[1].safety_level = 1;  db->magic = SQLITE_MAGIC_OPEN;  if( db->mallocFailed ){    goto opendb_out;  }  /* Register all built-in functions, but do not attempt to read the  ** database schema yet. This is delayed until the first time the database  ** is accessed.  */  sqlite3Error(db, SQLITE_OK);  sqlite3RegisterBuiltinFunctions(db);  /* Load automatic extensions - extensions that have been registered  ** using the sqlite3_automatic_extension() API.  */  rc = sqlite3_errcode(db);  if( rc==SQLITE_OK ){    sqlite3AutoLoadExtensions(db);    rc = sqlite3_errcode(db);