SQLite handle-Basic SQLite tutorial (3)

Statement You are welcome to repost this article, but please respect the author's Labor achievements. repost this article and keep the statement in this box. Thank you. Article Source: http://blog.csdn.net/iukey

If you want to manipulate a database, you have to have a handle to the database (you have come across this incomprehensible word, but there is really no better word to replace it ). In fact, you don't need to care about what the term is. You just need to figure out what it is. It's just like why a shoe is called a shoes. It's hard to understand it if you think about it carefully, but it's okay to know his function, isn't it?

We have seen handles in many places. The most common thing is the file handle. to manipulate a file, we need to obtain a file handle. What is a handle? In fact, it is very simple. The handle is a description of something. It is defined as a struct, which may contain the specific information of the stuff to be described, such as the location, size, type, and so on. With this description, we can find this stuff and manipulate it.

In a word, a handle is the description structure of an object.

Let's take a look at how the SQLite handle is defined (don't be scared, just skip the code ):

struct sqlite3 {  sqlite3_vfs *pVfs;            /* OS Interface */  int nDb;                      /* Number of backends currently in use */  Db *aDb;                      /* All backends */  int flags;                    /* Miscellaneous flags. See below */  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() */  int nextPagesize;             /* Pagesize after VACUUM if >0 */  int nTable;                   /* Number of tables in the database */  CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */  i64 lastRowid;                /* ROWID of most recent insert (see above) */  u32 magic;                    /* Magic number for detect library misuse */  int nChange;                  /* Value returned by sqlite3_changes() */  int nTotalChange;             /* Value returned by sqlite3_total_changes() */  sqlite3_mutex *mutex;         /* Connection mutex */  int aLimit[SQLITE_N_LIMIT];   /* Limits */  struct sqlite3InitInfo {      /* Information used during initialization */    int iDb;                    /* When back is being initialized */    int newTnum;                /* Rootpage of table being initialized */    u8 busy;                    /* TRUE if currently initializing */    u8 orphanTrigger;           /* Last statement is orphaned TEMP trigger */  } init;  int nExtension;               /* Number of loaded extensions */  void **aExtension;            /* Array of shared library handles */  struct Vdbe *pVdbe;           /* List of active virtual machines */  int activeVdbeCnt;            /* Number of VDBEs currently executing */  int writeVdbeCnt;             /* Number of active VDBEs that are writing */  int vdbeExecCnt;              /* Number of nested calls to VdbeExec() */  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  Hash aModule;                 /* populated by sqlite3_create_module() */  VtabCtx *pVtabCtx;            /* Context for active vtab connect/create */  VTable **aVTrans;             /* Virtual tables with open transactions */  int nVTrans;                  /* Allocated size of aVTrans */  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 */  int busyTimeout;              /* Busy handler timeout, in msec */  Db aDbStatic[2];              /* Static space for the 2 default backends */  Savepoint *pSavepoint;        /* List of active savepoints */  int nSavepoint;               /* Number of non-transaction savepoints */  int nStatement;               /* Number of nested statement-transactions  */  u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */  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};

typedef struct sqlite3 sqlite3;//

It doesn't matter if it's scared. I posted this code to scare you. I didn't study this code seriously or want to study it, unless someone asks me to study at a high price one day, I only know how to use it.

This sqlite3 struct is used to describe the database files on our disk. With this descriptor, we can perform various operations on this database. We do not need to know the specific operation details, we only need to know how to call the API. Of course, sometimes we need to know a little bit about it. I will discuss it later.

I add a large piece of scary code with such a long length for only one purpose: Do not fear the handle.

Now, let's get started. In SQLite, you must first create a handle to manipulate the database, and then use this handle for all subsequent operations on the database.

sqlite3* pdb;

This is simple, so we have created a ssqlite handle, and we will not be able to do anything about the database in the future. You may still have questions. I also know what your questions are. Please refer to the next decomposition.