SHARED --> RESERVED --> PENDING --> EXCLUSIVE

// /framework/base/core/java/android/database/sqlite/SQLiteConnection.java
// 平时Framework对数据库操作最终都是由这些JNI接口转寄到SQLite中
    private static native int nativeOpen(String path, int openFlags, String label,
            boolean enableTrace, boolean enableProfile);
    private static native void nativeClose(int connectionPtr);
    ...
    private static native long nativeExecuteForLastInsertedRowId(
            int connectionPtr, int statementPtr);
    ...
    private static native void nativeResetCancel(int connectionPtr, boolean cancelable);

static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags,
        jstring labelStr, jboolean enableTrace, jboolean enableProfile) {
    ... //sqliteFlags 检查和字符转换
    sqlite3* db;
    //通过 sqlite3_open_v2 方式打开数据库，还有sqlite3_open、sqlite3_open16等方式
    int err = sqlite3_open_v2(path.string(), &db, sqliteFlags, NULL);
    if (err != SQLITE_OK) {
        throw_sqlite3_exception_errcode(env, err, "Could not open database");
        return 0;
    }
    ...
    //1. 如果请求的拥有读写功能数据库连接，则需要检查数据库对象是否真的可以读写
    //2. 设置busy handler来处理SQLITE_BUSY
    //3. 注册android function

    //将数据库对象包装到数据库连接当中
    SQLiteConnection* connection = new SQLiteConnection(db, openFlags, path, label);
    ... //设置 tracing、profiling 等功能
    //返回
    return reinterpret_cast<jint>(connection);
}

static int openDatabase(
  const char *zFilename, /* Database filename UTF-8 encoded */
  sqlite3 **ppDb,        /* OUT: Returned database handle */
  unsigned int flags,    /* Operational flags */
  const char *zVfs       /* Name of the VFS to use */
){
  sqlite3 *db;                    /* Store allocated handle here */
  int rc;                         /* Return code */
  int isThreadsafe;               /* True for threadsafe connections */
  char *zOpen = 0;                /* Filename argument to pass to BtreeOpen() */
  char *zErrMsg = 0;              /* Error message from sqlite3ParseUri() */
  *ppDb = 0;

    ... //flag设置  
  // SQLite DB 分配内存
  db = sqlite3MallocZero( sizeof(sqlite3) );
  //分配失败则跳转到 opendb_out
  if( db==0 ) goto opendb_out;
  if( isThreadsafe ){   // 没有设置有关线程安全的标识符因此跟具体的SQLite配置有关
    db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
    if( db->mutex==0 ){
      sqlite3_free(db);
      db = 0;
      goto opendb_out;
    }
  }
  //锁上db.mutex，再进入后面的执行
  sqlite3_mutex_enter(db->mutex);
  //两个db的backend, 第一个是主要操作的main, 第二个是temp，后面会看到
  db->nDb = 2;
  db->aDb = db->aDbStatic;
    ... //设置db一些参数   
  // 创建排序函数
  createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
  createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
  createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
  createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
  if( db->mallocFailed ){   //分配内存失败，跳转到opendb_out
    goto opendb_out;
  }
  // 默认的排序函数为 BINARY
  db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
  assert( db->pDfltColl!=0 );
  // 创建UTF-8 大小写不敏感的排序函数
  createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
  // 将数据库文件名、指定的VFS、flag 等信息转换成对应的 Uri
  db->openFlags = flags;
  rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
  if( rc!=SQLITE_OK ){  //Uri parse 出错
    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
    sqlite3Error(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
    sqlite3_free(zErrMsg);
    goto opendb_out;
  }
  //打开数据库驱动并将其指向到 第一个database backend的pBt上
  //这里是真实打开数据库文件的地方，使用BTree的方式打开数据库文件
  //将创建的BTree 放到db->aDb[0].pBt当中。
  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, 0);
    goto opendb_out;
  }
  //获取database backend 对应的数据库模式
  db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
  db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
  db->aDb[0].zName = "main";
  db->aDb[0].safety_level = 3;
  db->aDb[1].zName = "temp";
  db->aDb[1].safety_level = 1;
    ...
  //注册内建函数到db中，这个时候还没有从db中读取内容，
  //第一次读取内容将是在db对象第一次被访问的时候
  sqlite3RegisterBuiltinFunctions(db);
    ...
// 如何退出
opendb_out:
  sqlite3_free(zOpen);
  if( db ){
    assert( db->mutex!=0 || isThreadsafe==0 || sqlite3GlobalConfig.bFullMutex==0 );
    // 有控制线程安全的锁则需要退出
    sqlite3_mutex_leave(db->mutex);
  }
  rc = sqlite3_errcode(db);
  assert( db!=0 || rc==SQLITE_NOMEM );
  if( rc==SQLITE_NOMEM ){
    // 没有空间创建数据库对象，执行数据库关闭，释放资源
    sqlite3_close(db);
    db = 0;
  }else if( rc!=SQLITE_OK ){
    db->magic = SQLITE_MAGIC_SICK;
  }
  //让ppDb指针指向db，供调用方使用。
  *ppDb = db;
  return sqlite3ApiExit(0, rc);
}

SQLITE_PRIVATE int sqlite3BtreeOpen(
  sqlite3_vfs *pVfs,      /* VFS to use for this b-tree */
  const char *zFilename,  /* Name of the file containing the BTree database */
  sqlite3 *db,            /* Associated database handle */
  Btree **ppBtree,        /* Pointer to new Btree object written here */
  int flags,              /* Options */
  int vfsFlags            /* Flags passed through to sqlite3_vfs.xOpen() */
){
  BtShared *pBt = 0;             /* Shared part of btree structure */
  Btree *p;                      /* Handle to return */
  sqlite3_mutex *mutexOpen = 0;  /* Prevents a race condition. Ticket #3537 */
  int rc = SQLITE_OK;            /* Result code from this function */
  u8 nReserve;                   /* Byte of unused space on each page */
  unsigned char zDbHeader[100];  /* Database header content */

    ...
  if( isMemdb ){
  //是否是 in-memory 的DB
    flags |= BTREE_MEMORY;
  }
  if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){
    vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
  }
  //分配内存
  p = sqlite3MallocZero(sizeof(Btree));
  if( !p ){
    return SQLITE_NOMEM;
  }
  p->inTrans = TRANS_NONE;
  p->db = db;
  // 如果设置使用缓存则尝试寻找并使用缓存的BTree 共享内存，找到则可以直接返回，不再执行后续执行。
    ...

  // pBt = 0,  共享的BTree存储对象为空
  ...
pBt = sqlite3MallocZero( sizeof(*pBt) );
if( pBt==0 ){
  rc = SQLITE_NOMEM;
  goto btree_open_out;
}
// 打开sqlite3 数据库文件
rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
                      EXTRA_SIZE, flags, vfsFlags, pageReinit);
if( rc==SQLITE_OK ){    //打开成功，则继续读取该文件的头
  rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
}
if( rc!=SQLITE_OK ){
  goto btree_open_out;
}
pBt->openFlags = (u8)flags;
pBt->db = db;
// 注册数据库文件的 BusyHandler
sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
p->pBt = pBt;

pBt->pCursor = 0;
pBt->pPage1 = 0;
// 判断sqlite3 是否以只读方法打开
if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
...
// 设置Pager Object的size
rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
// 将共享的BTree 对象添加进全局的 linkedlist
// 将新的BTree 添加进同一个连接的共享Btree 对象链表中
// 如何退出
...
}

static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz,
        jint connectionPtr, jint statementPtr) {
    // 将上层保存的int指针转换成SQLiteConnection指针
    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
    // 转换Statement指针
    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
    int err = executeNonQuery(env, connection, statement);
    return err == SQLITE_DONE && sqlite3_changes(connection->db) > 0
            ? sqlite3_last_insert_rowid(connection->db) : -1;
}

// 通过 sqlite3_step 到SQLite中执行
int err = sqlite3_step(statement);
if (err == SQLITE_ROW) {
    throw_sqlite3_exception(env,
            "Queries can be performed using SQLiteDatabase query or rawQuery methods only.");
} else if (err != SQLITE_DONE) {
    throw_sqlite3_exception(env, connection->db);
}

SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){
  int rc = SQLITE_OK;      /* Result from sqlite3Step() */
  int rc2 = SQLITE_OK;     /* Result from sqlite3Reprepare() */
  Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
  int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
  sqlite3 *db;             /* The database connection */

  if( vdbeSafetyNotNull(v) ){
    return SQLITE_MISUSE_BKPT;
  }
  db = v->db;
  // 加锁
  sqlite3_mutex_enter(db->mutex);
  // 循环执行 sqlite3Step, 并最终转发到sqlite3VdbeExec() 中执行
  while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
         && cnt++ < SQLITE_MAX_SCHEMA_RETRY
         && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
    // reset SQLiteStatement
    sqlite3_reset(pStmt);
    assert( v->expired==0 );
  }
  // 如果执行出错则进行清理阶段
  if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
    const char *zErr = (const char *)sqlite3_value_text(db->pErr);
    sqlite3DbFree(db, v->zErrMsg);
    if( !db->mallocFailed ){
      v->zErrMsg = sqlite3DbStrDup(db, zErr);
      v->rc = rc2;
    } else {
      v->zErrMsg = 0;
      v->rc = rc = SQLITE_NOMEM;
    }
  }
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}