lib/sqlite/sqlite3.c

7384 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7396 **     SomeStructure *pData = sqliteHashData(p);
7397 **     // do something with pData
8079                                   const void *pData, int nData,
8805   void *pData;                   /* Content of this page */
11537 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
11538 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
35448     if( !pPage->pData ){
35450       pPage->pData = (void *)&pPage[1];
35451       pPage->pExtra = (void*)&((char *)pPage->pData)[pCache->szPage];
35458     assert( pPage->pData==(void *)&pPage[1] );
35609       memset(pCache->pPage1->pData, 0, pCache->szPage);
38680 static u32 pager_datahash(int nByte, unsigned char *pData){
38684     hash = (hash*1039) + pData[i];
38689   return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
39812     void *pData;
39813     pData = pPg->pData;
39814     memcpy(pData, (u8*)aData, pPager->pageSize);
39844       memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
39848     CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
40322 ** pPg->pData. A shared lock or greater must be held on the database
40343     memset(pPg->pData, 0, pPager->pageSize);
40349     rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
40353     rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
40375       u8 *dbFileVers = &((u8*)pPg->pData)[24];
40379   CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
40403   put32bits(((char*)pPg->pData)+24, change_counter);
40408   put32bits(((char*)pPg->pData)+92, change_counter);
40409   put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
40531       sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
41561       char *pData;                                   /* Data to write */
41567       CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
41570       rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
41577         memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
41584       sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
41652       void *pData = pPg->pData;
41656       CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
42583       memset(pPg->pData, 0, pPager->pageSize);
42824   void *pData = pPg->pData;
42889         CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
43168         CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
43984   return pPg->pData;
44360   CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
47044     void *pData;
47052     if( (pData = sqlite3PagerCodec(p))==0 ) return SQLITE_NOMEM;
47054     pData = p->pData;
47056     walEncodeFrame(pWal, p->pgno, nDbsize, pData, aFrame);
47063     rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOffset+sizeof(aFrame));
47080       void *pData;
47082       if( (pData = sqlite3PagerCodec(pLast))==0 ) return SQLITE_NOMEM;
47084       pData = pLast->pData;
47086       walEncodeFrame(pWal, pLast->pgno, nTruncate, pData, aFrame);
47093       rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOffset);
49907 static void pageReinit(DbPage *pData){
49909   pPage = (MemPage *)sqlite3PagerGetExtra(pData);
49910   assert( sqlite3PagerPageRefcount(pData)>0 );
49914     if( sqlite3PagerPageRefcount(pData)>1 ){
53510   const void *pData,int nData,   /* The data */
53511   int nZero,                     /* Extra zero bytes to append to pData */
53553     pSrc = pData;
53649       pSrc = pData;
54917 ** and the data is given by (pData,nData).  The cursor is used only to
54922 ** ignored.  For a ZERODATA table, the pData and nData are both ignored.
54940   const void *pData, int nData,  /* The data of the new record */
55008   rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
63889       Mem *pData;       /* MEM cell holding data for the record to be inserted */
67536   Mem *pData;       /* MEM cell holding data for the record to be inserted */
67547   u.bg.pData = &aMem[pOp->p2];
67549   assert( memIsValid(u.bg.pData) );
67555   REGISTER_TRACE(pOp->p2, u.bg.pData);
67570   if( u.bg.pData->flags & MEM_Null ){
67571     u.bg.pData->z = 0;
67572     u.bg.pData->n = 0;
67574     assert( u.bg.pData->flags & (MEM_Blob|MEM_Str) );
67577   if( u.bg.pData->flags & MEM_Zero ){
67578     u.bg.nZero = u.bg.pData->u.nZero;
67584                           u.bg.pData->z, u.bg.pData->n, u.bg.nZero,
78121 static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
78122   analysisInfo *pInfo = (analysisInfo*)pData;
91510   InitData *pData,     /* Initialization context */
91514   sqlite3 *db = pData->db;
91517     sqlite3SetString(pData->pzErrMsg, db,
91520       *pData->pzErrMsg = sqlite3MAppendf(db, *pData->pzErrMsg,
91521                                  "%s - %s", *pData->pzErrMsg, zExtra);
91524   pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
91540   InitData *pData = (InitData*)pInit;
91541   sqlite3 *db = pData->db;
91542   int iDb = pData->iDb;
91549     corruptSchema(pData, argv[0], 0);
91556     corruptSchema(pData, argv[0], 0);
91579         pData->rc = rc;
91583           corruptSchema(pData, argv[0], sqlite3_errmsg(db));
91589     corruptSchema(pData, 0, 0);
91607       corruptSchema(pData, argv[0], "invalid rootpage");
113998 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
114020 **     SomeStructure *pData = fts3HashData(p);
114021 **     // do something with pData