Sqlite Source Code

struct sqlite3 {
    sqlite3_vfs *pVfs;            /* OS Interface */
    struct Vdbe *pVdbe;           /* List of active virtual machines */
    CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */
    sqlite3_mutex *mutex;         /* Connection mutex */
    Db *aDb;                      /* All backends */
    int nDb;                      /* Number of backends currently in use */
    int flags;                    /* Miscellaneous flags. See below */
    i64 lastRowid;                /* ROWID of most recent insert (see above) */
    unsigned int openFlags;       /* Flags passed to sqlite3_vfs.xOpen() */
    int errCode;                  /* Most recent error code (SQLITE_*) */
    int errMask;                  /* & result codes with this before returning */
    u8 autoCommit;                /* The auto-commit flag. */
    u8 temp_store;                /* 1: file 2: memory 0: default */
    u8 mallocFailed;              /* True if we have seen a malloc failure */
    u8 dfltLockMode;              /* Default locking-mode for attached dbs */
    signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
    u8 suppressErr;               /* Do not issue error messages if true */
    u8 vtabOnConflict;            /* Value to return for s3_vtab_on_conflict() */
    u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */
    int nextPagesize;             /* Pagesize after VACUUM if >0 */
    u32 magic;                    /* Magic number for detect library misuse */
    int nChange;                  /* Value returned by sqlite3_changes() */
    int nTotalChange;             /* Value returned by sqlite3_total_changes() */
    int aLimit[SQLITE_N_LIMIT];   /* Limits */
    struct sqlite3InitInfo {      /* Information used during initialization */
        int newTnum;                /* Rootpage of table being initialized */
        u8 iDb;                     /* Which db file is being initialized */
        u8 busy;                    /* TRUE if currently initializing */
        u8 orphanTrigger;           /* Last statement is orphaned TEMP trigger */
    } init;
    int activeVdbeCnt;            /* Number of VDBEs currently executing */
    int writeVdbeCnt;             /* Number of active VDBEs that are writing */
    int vdbeExecCnt;              /* Number of nested calls to VdbeExec() */
    int nExtension;               /* Number of loaded extensions */
    void **aExtension;            /* Array of shared library handles */
    void (*xTrace)(void*,const char*);        /* Trace function */
    void *pTraceArg;                          /* Argument to the trace function */
    void (*xProfile)(void*,const char*,u64);  /* Profiling function */
    void *pProfileArg;                        /* Argument to profile function */
    void *pCommitArg;                 /* Argument to xCommitCallback() */   
    int (*xCommitCallback)(void*);    /* Invoked at every commit. */
    void *pRollbackArg;               /* Argument to xRollbackCallback() */   
    void (*xRollbackCallback)(void*); /* Invoked at every commit. */
    void *pUpdateArg;
    void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
#ifndef SQLITE_OMIT_WAL
    int (*xWalCallback)(void *, sqlite3 *, const char *, int);
    void *pWalArg;
#endif
    void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
    void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
    void *pCollNeededArg;
    sqlite3_value *pErr;          /* Most recent error message */
    char *zErrMsg;                /* Most recent error message (UTF-8 encoded) */
    char *zErrMsg16;              /* Most recent error message (UTF-16 encoded) */
    union {
        volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
        double notUsed1;            /* Spacer */
    } u1;
    Lookaside lookaside;          /* Lookaside malloc configuration */
#ifndef SQLITE_OMIT_AUTHORIZATION
    int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
    /* Access authorization function */
    void *pAuthArg;               /* 1st argument to the access auth function */
#endif
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
    int (*xProgress)(void *);     /* The progress callback */
    void *pProgressArg;           /* Argument to the progress callback */
    int nProgressOps;             /* Number of opcodes for progress callback */
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
    int nVTrans;                  /* Allocated size of aVTrans */
    Hash aModule;                 /* populated by sqlite3_create_module() */
    VtabCtx *pVtabCtx;            /* Context for active vtab connect/create */
    VTable **aVTrans;             /* Virtual tables with open transactions */
    VTable *pDisconnect;    /* Disconnect these in next sqlite3_prepare() */
#endif
    FuncDefHash aFunc;            /* Hash table of connection functions */
    Hash aCollSeq;                /* All collating sequences */
    BusyHandler busyHandler;      /* Busy callback */
    Db aDbStatic[2];              /* Static space for the 2 default backends */
    Savepoint *pSavepoint;        /* List of active savepoints */
    int busyTimeout;              /* Busy handler timeout, in msec */
    int nSavepoint;               /* Number of non-transaction savepoints */
    int nStatement;               /* Number of nested statement-transactions  */
    i64 nDeferredCons;            /* Net deferred constraints this transaction. */
    int *pnBytesFreed;            /* If not NULL, increment this in DbFree() */

#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
    /* The following variables are all protected by the STATIC_MASTER 
    ** mutex, not by sqlite3.mutex. They are used by code in notify.c. 
    **
    ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
    ** unlock so that it can proceed.
    **
    ** When X.pBlockingConnection==Y, that means that something that X tried
    ** tried to do recently failed with an SQLITE_LOCKED error due to locks
    ** held by Y.
    */
    sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
    sqlite3 *pUnlockConnection;           /* Connection to watch for unlock */
    void *pUnlockArg;                     /* Argument to xUnlockNotify */
    void (*xUnlockNotify)(void **, int);  /* Unlock notify callback */
    sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
#endif
}

struct sqlite3_vfs {
    // vfs 中 xOpen 的参数 sqlite3_file 的"子类"代表了不同平台上的
    // file, 例如 unixFile, winFile, ..., 每个"子类"的成员和大小都不同,
    // 例如 unixFile 会包含 unixInodeInfo, unixShm 这些和 unix 相关的
    // 成员, 当使用 xOpen 时, 调用者需要根据 szOsFile 初始化相应大小的
    // 内存以容纳 unixFile 或者 winFile
    int szOsFile;            /* Size of subclassed sqlite3_file */

    // sqlite3OsInit 时会通过 sqlite3_vfs_register 注册多个
    // sqlite3_vfs, 例如 "unix_nolock" -> unixVfs, 这里的 vfs 的区别并
    // 不是指不同的平台例如 unix, win (平台的不同会通过编译宏来区分),而
    // 不是指同一个平台上不同的实现.

    // 这些 vfs 通过 pNext 组织起来. vfs_register 只会在第一次调用
    // sqlite3OsInit 时被调用一次 sqlite3OsInit 后, 以后每次调用
    // sqlite3_open_v2 时, 会根据传入的 zVfs 参数通过 sqlite3_vfs_find
    // 找到对应的 sqlite3_vfs, 并赋给 sqlite3->pVfs
    sqlite3_vfs *pNext;      /* Next registered VFS */

    const char *zName;       /* Name of this virtual file system */
    void *pAppData;          /* Pointer to application-specific data
                              * */

    // xOpen 用来打开文件 (包括 db, journal, wal 文件), 无论打开文件是
    // 否成功, sqlite3_file 的 sqlite3_io_methods 都需要被赋值. 以
    // sqlite3PagerOpen 为例, sqlite3PagerOpen 会把 sqlite3_file 赋给
    // pPager->fd
    int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
                 int flags, int *pOutFlags);

    int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
    int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
    int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
    void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
    void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
    void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
    void (*xDlClose)(sqlite3_vfs*, void*);
    int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
    int (*xSleep)(sqlite3_vfs*, int microseconds);
    int (*xCurrentTime)(sqlite3_vfs*, double*);
    int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
    int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
    sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
    const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
}

struct sqlite3_mem_methods {
    void *(*xMalloc)(int);         /* Memory allocation function */
    void (*xFree)(void*);          /* Free a prior allocation */
    void *(*xRealloc)(void*,int);  /* Resize an allocation */
    int (*xSize)(void*);           /* Return the size of an allocation */
    int (*xRoundup)(int);          /* Round up request size to allocation size */
    int (*xInit)(void*);           /* Initialize the memory allocator */
    void (*xShutdown)(void*);      /* Deinitialize the memory allocator */
    void *pAppData;                /* Argument to xInit() and xShutdown() */
};

struct PgHdr {
    sqlite3_pcache_page *pPage;    /* Pcache object page handle */
    void *pData;                   /* Page data */
    void *pExtra;                  /* Extra content */
    PgHdr *pDirty;                 /* Transient list of dirty pages */
    Pager *pPager;                 /* The pager this page is part of */
    Pgno pgno;                     /* Page number for this page */
    u32 pageHash;                  /* Hash of page content */  
    /* flags 可能为 dirty, need_sync, need_read, dont_write 等 */
    u16 flags;                     /* PGHDR flags defined below */

    i16 nRef;                      /* Number of users of this page */
    PCache *pCache;                /* Cache that owns this page */
    PgHdr *pDirtyNext;             /* Next element in list of dirty pages */
    PgHdr *pDirtyPrev;             /* Previous element in list of dirty pages */
}

struct Schema {
    int schema_cookie;   /* Database schema version number for this file */
    int iGeneration;     /* Generation counter.  Incremented with each change */
    Hash tblHash;        /* All tables indexed by name */
    Hash idxHash;        /* All (named) indices indexed by name */
    Hash trigHash;       /* All triggers indexed by name */
    Hash fkeyHash;       /* All foreign keys by referenced table name */
    Table *pSeqTab;      /* The sqlite_sequence table used by AUTOINCREMENT */
    u8 file_format;      /* Schema format version for this file */
    u8 enc;              /* Text encoding used by this database */
    u16 flags;           /* Flags associated with this schema */
    int cache_size;      /* Number of pages to use in the cache */
};

struct Lookaside {
    u16 sz;                 /* Size of each buffer in bytes */
    u8 bEnabled;            /* False to disable new lookaside allocations */
    u8 bMalloced;           /* True if pStart obtained from sqlite3_malloc() */
    int nOut;               /* Number of buffers currently checked out */
    int mxOut;              /* Highwater mark for nOut */
    int anStat[3];          /* 0: hits.  1: size misses.  2: full misses */
    LookasideSlot *pFree;   /* List of available buffers */
    void *pStart;           /* First byte of available memory space */
    void *pEnd;             /* First byte past end of available space */
};

struct unixInodeInfo {
    struct unixFileId fileId;       /* The lookup key */
    int nShared;                    /* Number of SHARED locks held */
    unsigned char eFileLock;        /* One of SHARED_LOCK, RESERVED_LOCK etc. */
    unsigned char bProcessLock;     /* An exclusive process lock is held */
    int nRef;                       /* Number of pointers to this structure */
    unixShmNode *pShmNode;          /* Shared memory associated with this inode */
    int nLock;                      /* Number of outstanding file locks */
    UnixUnusedFd *pUnused;          /* Unused file descriptors to close */
    unixInodeInfo *pNext;           /* List of all unixInodeInfo objects */
    unixInodeInfo *pPrev;           /*    .... doubly linked */
}

int sqlite3PcacheFetch(
    PCache *pCache,       /* Obtain the page from this cache */
    Pgno pgno,            /* Page number to obtain */
    int createFlag,       /* If true, create page if it does not exist already */
    PgHdr **ppPage        /* Write the page here */
  ):
  // 通过 pcach1 获得一个 page
  pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
  // 若 pcach1 无法分配一个 page: 例如 pcache1 满了而 lru list 为空
  if( !pPage && eCreate==1 ):
    // 从 pcache 自己维护的 pDirty 中找到一个 dirty 的但 nRef 为 0 的 page
    // pDirty 中的 page 一定不存在于 pcach1 的 lru list 中.
    for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
    // 调用 pagerStress, 把 pPg 这个空闲的 dirty page 刷新到数据库中
    // 刷新后会调用 pPg
    rc = pCache->xStress(pCache->pStress, pPg);
      sqlite3PcacheMakeClean(pPg);
        pcacheRemoveFromDirtyList(p);
        // unpin 会导致这个 page 被放入 lru list
        pcacheUnpin(p);
    // 再次调用 pcache1Fetch
    pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
  // page 的 nRef + 1
  pPgHdr->nRef++;

// p 是 pcache 实例
// iKey 实际上是 pgno
// pcache 模块本身涉及到 dirty, 
static sqlite3_pcache_page *pcache1Fetch(       
       sqlite3_pcache *p, 
       unsigned int iKey, 
       int createFlag):
  // 通过 pcache1 的 apHash 查找, apHash 中可能包含了所有的 cached
  // page, 包含 pinned (不存在于 lru list), unpinned (存在于 lru list)
  // 以及 dirty 的等
  /* Step 1: Search the hash table for an existing entry. */
  if( pCache->nHash>0 ):
    unsigned int h = iKey % pCache->nHash;
    for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
  // 若 pPage 找到, 则返回这个 pPage, 但返回之前先通过 pcache1PinPage
  // 确保这个 page 不存在于 lru list 中, 因为这个 lru list 的意义是一
  // 个对象缓存, 存放着那些已经没有意义的对象
  if( pPage || createFlag==0 ):
    pcache1PinPage(pPage);
    goto fetch_out;

  /* Step 3: Abort if createFlag is 1 but the cache is nearly full */
  // 若 createFlag==1, 但 pcache1 已经快满了, 则返回空
  if( createFlag==1 && (
    nPinned>=pGroup->mxPinned
    || nPinned>=pCache->n90pct
    || pcache1UnderMemoryPressure(pCache)
    ):
    goto fetch_out;

  /* Step 4. Try to recycle a page. */
  if( pCache->bPurgeable && pGroup->pLruTail && (
    (pCache->nPage+1>=pCache->nMax)
    || pGroup->nCurrentPage>=pGroup->nMaxPage
    || pcache1UnderMemoryPressure(pCache)
    )):
    // 尝试从 lru list 中获得一个无用的 page
    // 从 lru list 的队尾获取一个 page
    pPage = pGroup->pLruTail;
    // 从 apHash 中去掉这个 page, 因为过一会儿这个 page 的内容都重写后
    // 其 key 与 value 不再对应. 
    pcache1RemoveFromHash(pPage);
    // 把 page 从 lru list 中移除
    pcache1PinPage(pPage);

  /* Step 5. If a usable page buffer has still not been found, 
  ** attempt to allocate a new one. 
  */
  if( !pPage ):
    // 分配一个新的 page, 并加入于 apHash 中
    pPage = pcache1AllocPage(pCache);
    pCache->apHash[h] = pPage;

sqlite3PagerSharedLock -> pagerBeginReadTransaction -> sqlite3WalBeginReadTransaction

sqlite3PagerCommitPhaseOne
  pagerWalFrames(pPager, pList, pPager->dbSize, 1);
    sqlite3WalFrames(  Wal *pWal,                      /* Wal handle to write to */
      int szPage,                     /* Database page-size in bytes */
      PgHdr *pList,                   /* List of dirty pages to write */
      Pgno nTruncate,                 /* Database size after this commit */
      int isCommit,                   /* True if this is a commit */
      int sync_flags                  /* Flags to pass to OsSync() (or 0) */pPager)
      // pList 是所有 dirty 的 pcache 页
      iFrame = pWal->hdr.mxFrame;
      // mxFrame 是 wal 中当前最大的 frame 号, 若 mxFrame 为 0, 说明 wal 日志为空
      if( iFrame==0 ):
        // 写 wal 头到日志
        sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
      /* Write all frames into the log file exactly once */
      for(p=pList; p; p=p->pDirty){
        walWriteOneFrame(&w, p, nDbSize, iOffset);

      // 对每一个新写入的 frame, 更新 wal index
      for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
        walIndexAppend(pWal, iFrame, p->pgno);

sqlite3PagerClose
  sqlite3WalClose
    // 需要先获得对 db 文件的 exclusive lock
    // 而在 wal 模式下, shared lock 在 commit 时并不会释放, 所以
    // 这里实际上会导致最后一个连接关闭时才删除 wal 文件
    sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE);
    sqlite3WalCheckpoint
    walIndexClose(pWal, isDelete);
    sqlite3OsClose(pWal->pWalFd);
    sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);

syncJournal
  // 构造 zHeader, 包含 magic 和 nRec
  u8 zHeader[sizeof(aJournalMagic)+4];
  memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
  put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
  if( pPager->fullSync):
    // 若为 fullSync 模式, 将在写 header 到 journal 之前, 先将 journal
    // sync
    sqlite3OsSync(pPager->jfd, pPager->syncFlags);
  // 将 header 写到日志
  sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr);
  // 再 sync 一次, 此后日志变为 hot journal
  sqlite3OsSync(pPager->jfd, ...)
  pPager->eState = PAGER_WRITER_DBMOD;

int pager_playback(Pager *pPager, int isHot):
  // 获得 journal 文件大小, 后面可能会使用这个值来确定 journal 中有几
  // 个 page
  sqlite3OsFileSize(pPager->jfd, &szJ);
  // 从 journal header 中读到 nRec, mxPg.
  // 对于 hot journal, nRec 在 journal header 是有记录的, 但对于
  // 通过 rollback 发起的 playback, 此时 journal 并没有 sync 到磁盘,
  // 其 nRec 也是没有值的 (0)
  readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);

  // 若 nRec 没有值, 说明不是 hot journal, 通过 szJ 计算 nRec
  /* If nRec is 0 and this rollback is of a transaction created by this
  ** process and if this is the final header in the journal, then it means
  ** that this part of the journal was being filled but has not yet been
  ** synced to disk.  Compute the number of pages based on the remaining
  ** size of the file.

  if( nRec==0 && !isHot &&
    pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ):
    nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));

  for(u=0; u<nRec; u++):
    // 对 journal 中每一个 page 进行 playback.
    // 但实际上, 并不是每个 page 都会被 playback,
    // 例如, persist 模式的 journal 中实际会包含一些旧的, 并非
    // 本次 transaction 修改过的 page, 这些是不能被 playback 的
    // pager_playback_one_page 会通过 journal header 的 checksum 与
    // journal 中各个 page 的 checksum 来决定这个 page 是否需要 playback
    // 每次通过 pager_write -> pager_open_journal 时, journal header
    // 的 checksum 会被初始化一个随机数, 确定每次 transaction 时这个值
    // 都是不同的
    pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
      read32bits(jfd, (*pOffset)-4, &cksum);
      if pager_cksum(pPager, (u8*)aData)!=cksum:
        // 这个 SQLITE_DONE 导致上层函数退出循环, playback 结束
        return SQLITE_DONE;
      // 找到 对应的 pcache, 若不存在, 说明该 pgno 在 pcache 中没有对
      // 应. 
      pPg = pager_lookup(pPager, pgno);
      // 若 eState 显示该 pager 已经 sync 过, 则需要写数据库文件
      if (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN):
        sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
      if( pPg ):
        // pcache 中存在这个 page, 则修改 pcache 的值
        pData = pPg->pData;
        memcpy(pData, (u8*)aData, pPager->pageSize);
        sqlite3PcacheMakeClean(pPg);

int readDbPage(PgHdr *pPg):
  if pagerUseWal(pPager):
    /* Try to pull the page from the write-ahead log. */
    sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
  else:
    sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);

if( NOT <in-memory journal> ){
  // 若 synchronous == FULL, 则在 update journal header 之前 (主要是
  // nRec 和 magic number), 先执行一次 sync 将 journal 内容先写进磁盘
  // 因为这时 magic 部分为空, 所以这时的 journal 还不是 hot journal
  if( <full-sync mode> ) xSync(<journal file>);
  // 根据 pager->nRec 更新 journal 的 nRec, 并添加 magic
  <update nRec field>
  // 再 sync 一次 journal 文件, 这时包括文件头
  // 可见, synchronous == FULL 时会比 synchronous == NORMAL 时多一次
  // sync 操作
  xSync(<journal file>);
}

if !pagerUseWal(pPager):
  pager_wait_on_lock(pPager, SHARED_LOCK);
  hasHotJournal(pPager, &bHotJournal);
  if bHotJournal:
    pagerLockDb(pPager, EXCLUSIVE_LOCK);
    pagerSyncHotJournal(pPager);
    pager_playback(pPager, 1);
if pagerUseWal(pPager):
  pagerBeginReadTransaction(pPager);
    sqlite3WalBeginReadTransaction
      walTryBeginRead
        walIndexReadHdr
          walIndexRecover
        walLockShared

sqlite3PagerCommitPhaseOne
  /* If no database changes have been made, return early. */
  if (pPager->eState<PAGER_WRITER_CACHEMOD) return SQLITE_OK;
  if( MEMDB ) return SQLITE_OK;
  if( pagerUseWal(pPager) ):
    // 若是 wal, 则只通过 pagerWalFrames 修改 wal 日志
    pagerWalFrames(pPager, pList, pPager->dbSize, 1);
  else:
    pager_incr_changecounter(pPager, 1);
    syncJournal(pPager, 0);
    pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
    // 此时所有 pcache 中的 page 与 db 都是一致的了, 把 dirty list 置
    // 空, 并且 nRef 为 0 的 page 进入 lru list
    sqlite3PcacheCleanAll(pPager->pPCache);
    sqlite3PagerSync(pPager);

sqlite3LockAndPrepare
  // prepare 时需要 lock 住 db->mutex, 即 bFullMutex 模式
  // 因为只有 SERIALIZED 模式下 db->mutex 才起作用, 
  // 所以非 SERIALIZED 模式下不能在不同线程同时调用 sqlite3_prepare,
  // 否则会出错
  sqlite3_mutex_enter(db->mutex);
  sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
    sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
      // the main parser program
      sqlite3Parser();
        do{
          yy_reduce(yypParser,yyact-YYNSTATE);
            switch( yyruleno ):
              case 112: /* cmd ::= select */
                sqlite3Select(pParse, yymsp[0].minor.yy159, &dest);
                  sqlite3SelectPrep(pParse, p, 0);
                    sqlite3SelectExpand(pParse, p);
                      sqlite3WalkSelect(&w, pSelect);
                        sqlite3LocateTable()
                          // 在 parse 阶段需要 read schema
                          sqlite3ReadSchema();
              case xxx:
                // xxx

    *ppStmt = (sqlite3_stmt*)pParse->pVdbe;    

sqlite3_step(stmt)
  sqlite3_mutex_enter(db->mutex);
  sqlite3Step(stmt)
    sqlite3VdbeExec(vdbe);
    // sqlite3VdbeExec 相当于一个解释器, 内部实现就是一个 while (true)
    // {swich} 循环
      for(pc=p->pc; rc==SQLITE_OK; pc++){
        OP_GOTO:

        OP_Transaction:
          sqlite3BtreeBeginTrans(u.at.pBt, pOp->p2);
            lockBtree
              sqlite3PagerSharedLock
                pager_wait_on_lock(pPager, SHARED_LOCK);
                // 检测是否有 hot journal
                if hasHotJournal():
                  pagerLockDb(pPager, EXCLUSIVE_LOCK);
                  pagerSyncHotJournal(pPager);
              // if write mode
              sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
                // 获得 reserved_lock
                pagerLockDb(pPager, RESERVED_LOCK);

        OP_OpenRead:
          allocateCursor(p, pOp->p1, u.aw.nField, u.aw.iDb, 1);
          sqlite3BtreeCursor(u.aw.pX, ...);
        OP_Rewind:
          sqlite3BtreeFirst(u.bl.pCrsr, &u.bl.res);
          moveToRoot(pCur);
            getAndInitPage;
              btreeGetPage;
                sqlite3PagerAcquire;
                  sqlite3PcacheFetch
                  readDbPage;
                    sqlite3OsRead
        OP_Column:
          // 从 cursor 中取出数据放在 vdbe->aMem 中
        OP_ResultRow:
           // 这一句 byte code 正常会返回 SQLITE_ROW, 而不是 SQLITE_OK,
           // 导致最外层 for 返回, 整个 sqlite3_step 结束
           // 下次 step 将以 p->pc 为起点, 即 OP_Next
           p->pc = pc + 1;
           rc = SQLITE_ROW;
           goto vdbe_return;
        OP_Next:
          sqlite3BtreeNext(u.bm.pCrsr, &u.bm.res);
            moveToChild;
              getAndInitPage;
        OP_Halt:
          sqlite3VdbeHalt(p);
          if autoCommit == 1:
            vdbeCommit(db, p);
              // 获得 exclusive lock
              sqlite3PagerExclusiveLock(sqlite3BtreePager(pBt));
              sqlite3BtreeCommitPhaseOne
              sqlite3BtreeCommitPhaseTwo
                btreeEndTransaction
                  releasePage
                    // 释放锁
                    pagerUnlockAndRollback;

OP_NewRowid:
  // NewRowid 需要为该新记录生成一个唯一的 rowid,
  // 根据 schema 的不同分为两种情况:
  // 1. 假设记录中使用了 integer primary key autoincrement 类型的字段 _id, 这
  // 时 rowid 内部实现上直接使用这个 _id 字段, _id 不仅需要唯一: 还需
  // 要自增. sqlite 通过 sqlite_sequence 这张表来控制这种情况下 _id 的生成
  // 2. schema 中并没指定 autoincrement 这种类型的字段. 这时 NewRowid
  // 需要生成一个唯一的 rowid, sqlite 定义了两种算法:
  // 1) 扫描全表, 找到已经使用的最大 rowid +1, 得到新的 rowid
  // 2) 随机生成一个 rowid, 通过查表确定是否冲突, 若冲突再重新生成一个
  // 不论哪种算法, 扫描全表都是必须的. 

OP_Insert:
  sqlite3BtreeInsert(u.bh.pC->pCursor, 0, u.bh.iKey,...)
    // 找到对应的 page
    btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
    // 写到 cell 中
    fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero,&szNew);
    // sqlite3PagerWrite 会导致 journal 被写入
    sqlite3PagerWrite(pPage->pDbPage);