Lines Matching defs:pData
10807 unsigned char *pData, /* The serialized database content */
10809 sqlite3_int64 szBuf, /* Total size of buffer pData[] */
11893 ** Add all changes within the changeset (or patchset) in buffer pData (size
11965 SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData);
12508 ** int (*xInput)(void *pIn, void *pData, int *pnData),
12514 ** argument, pData, points to a buffer (*pnData) bytes in size. Assuming no
12542 ** int (*xOutput)(void *pOut, const void *pData, int nData),
12548 ** pOut pointer supplied by the application. The second parameter, pData,
12562 int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
12577 int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
12593 int (*xInputA)(void *pIn, void *pData, int *pnData),
12595 int (*xInputB)(void *pIn, void *pData, int *pnData),
12597 int (*xOutput)(void *pOut, const void *pData, int nData),
12601 int (*xInput)(void *pIn, void *pData, int *pnData),
12603 int (*xOutput)(void *pOut, const void *pData, int nData),
12608 int (*xInput)(void *pIn, void *pData, int *pnData),
12613 int (*xInput)(void *pIn, void *pData, int *pnData),
12619 int (*xOutput)(void *pOut, const void *pData, int nData),
12624 int (*xOutput)(void *pOut, const void *pData, int nData),
12628 int (*xInput)(void *pIn, void *pData, int *pnData),
12632 int (*xOutput)(void *pOut, const void *pData, int nData),
12637 int (*xInput)(void *pIn, void *pData, int *pnData),
12639 int (*xOutput)(void *pOut, const void *pData, int nData),
13956 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData);
13968 ** SomeStructure *pData = sqliteHashData(p);
13969 ** // do something with pData
15698 ** key and the pData,nData,nZero fields are uninitialized. The aMem,nMem
15704 ** pData,nData hold the content of the new entry. nZero extra zero bytes
15714 ** pData data not used
15717 ** nData length of pData not used
15718 ** nZero extra zeros after pData not used
15729 const void *pData; /* Data for tables. */
15732 int nData; /* Size of pData. 0 if none. */
15733 int nZero; /* Extra zero data appended after pData,nData */
16506 void *pData; /* Page data */
20427 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
20429 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
52105 unsigned char *pData, /* The serialized database content */
52107 sqlite3_int64 szBuf, /* Total size of buffer pData[] */
52153 pStore->aData = pData;
52154 pData = 0;
52167 if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){
52168 sqlite3_free(pData);
53108 pPgHdr->pData = pPage->pBuf;
56750 static u32 pager_datahash(int nByte, unsigned char *pData){
56754 hash = (hash*1039) + pData[i];
56759 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
57979 void *pData;
57980 pData = pPg->pData;
57981 memcpy(pData, (u8*)aData, pPager->pageSize);
57992 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
57997 if( jrnlEnc ){ CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM_BKPT); }
58520 ** pPg->pData. A shared lock or greater must be held on the database
58544 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
58549 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
58571 u8 *dbFileVers = &((u8*)pPg->pData)[24];
58575 CODEC1(pPager, pPg->pData, pPg->pgno, 3, rc = SQLITE_NOMEM_BKPT);
58600 put32bits(((char*)pPg->pData)+24, change_counter);
58605 put32bits(((char*)pPg->pData)+92, change_counter);
58606 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
58734 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
59561 ** The new object will use the pointer pData, obtained from xFetch().
59572 void *pData, /* xFetch()'d data for this page */
59586 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
59602 p->pData = pData;
59620 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
59974 char *pData; /* Data to write */
59980 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM_BKPT, pData);
59983 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
59990 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
59998 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
60066 void *pData = pPg->pData;
60072 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
60075 pData2 = pData;
61133 memset(pPg->pData, 0, pPager->pageSize);
61202 void *pData = 0;
61204 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
61206 if( rc==SQLITE_OK && pData ){
61211 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
61213 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
61511 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
61876 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM_BKPT, zBuf);
62664 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
62845 return pPg->pData;
66905 void *pData; /* Data actually written */
66908 rc = checkHeaderValid(pPage->pPager, pPage->pData, "walWrite");
66912 if( (pData = sqlite3PagerCodec(pPage))==0 ) return SQLITE_NOMEM_BKPT;
66914 pData = pPage->pData;
66916 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
66920 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
67094 void *pData;
67099 if( (pData = sqlite3PagerCodec(p))==0 ) return SQLITE_NOMEM;
67101 pData = p->pData;
67103 rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
71016 static void pageReinit(DbPage *pData){
71018 pPage = (MemPage *)sqlite3PagerGetExtra(pData);
71019 assert( sqlite3PagerPageRefcount(pData)>0 );
71023 if( sqlite3PagerPageRefcount(pData)>1 ){
75467 pSrc = pX->pData;
75934 u8 *pData;
75946 pData = pEnd;
75960 pData -= sz;
75961 put2byte(pCellptr, (pData - aData));
75963 if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT;
75964 memmove(pData, pCell, sz);
75980 put2byte(&aData[hdr+5], pData - aData);
76020 u8 *pData = *ppData; /* Content area. A subset of aData[] */
76034 if( (pData - pBegin)<sz ) return 1;
76035 pData -= sz;
76036 pSlot = pData;
76061 *ppData = pData;
76144 u8 *pData;
76169 pData = &aData[get2byteNotZero(&aData[hdr+5])];
76170 if( pData<pBegin ) goto editpage_fail;
76171 if( pData>pPg->aDataEnd ) goto editpage_fail;
76181 pPg, pBegin, &pData, pCellptr,
76198 pPg, pBegin, &pData, pCellptr,
76208 pPg, pBegin, &pData, pCellptr,
76216 put2byte(&aData[hdr+5], pData - aData);
77532 if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
77539 memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt);
77550 int iOffset; /* Next byte of pX->pData to write */
77606 ** rowid or INTEGER PRIMARY KEY of the row. The pX.nData,pData,nZero fields
77611 ** pX.pData,nData,nZero fields must be zero.
77774 x2.pData = pX->pKey;
89956 Mem *pData = &p->v->aMem[p->iNewReg];
89957 rc = ExpandBlob(pData);
89959 pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
95898 Mem *pData; /* MEM cell holding data for the record to be inserted */
95906 pData = &aMem[pOp->p2];
95908 assert( memIsValid(pData) );
95916 REGISTER_TRACE(pOp->p2, pData);
95951 assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 );
95952 x.pData = pData->z;
95953 x.nData = pData->n;
95955 if( pData->flags & MEM_Zero ){
95956 x.nZero = pData->u.nZero;
101251 static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){
101259 memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
114924 static void sampleSetRowid(sqlite3 *db, StatSample *p, int n, const u8 *pData){
114930 memcpy(p->u.aRowid, pData, n);
116142 static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
116143 analysisInfo *pInfo = (analysisInfo*)pData;
137166 InitData *pData, /* Initialization context */
137170 sqlite3 *db = pData->db;
137172 pData->rc = SQLITE_NOMEM_BKPT;
137173 }else if( pData->pzErrMsg[0]!=0 ){
137175 }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){
137181 *pData->pzErrMsg = sqlite3MPrintf(db,
137183 azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1],
137186 pData->rc = SQLITE_ERROR;
137188 pData->rc = SQLITE_CORRUPT_BKPT;
137194 *pData->pzErrMsg = z;
137195 pData->rc = SQLITE_CORRUPT_BKPT;
137239 InitData *pData = (InitData*)pInit;
137240 sqlite3 *db = pData->db;
137241 int iDb = pData->iDb;
137248 pData->nInitRow++;
137250 corruptSchema(pData, argv, 0);
137256 corruptSchema(pData, argv, 0);
137278 || (db->init.newTnum>pData->mxPage && pData->mxPage>0)
137281 corruptSchema(pData, argv, "invalid rootpage");
137296 if( rc > pData->rc ) pData->rc = rc;
137300 corruptSchema(pData, argv, sqlite3_errmsg(db));
137307 corruptSchema(pData, argv, 0);
137318 corruptSchema(pData, argv, "orphan index");
137322 || pIndex->tnum>pData->mxPage
137326 corruptSchema(pData, argv, "invalid rootpage");
179281 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
179303 ** SomeStructure *pData = fts3HashData(p);
179304 ** // do something with pData
201899 u8 *pData;
201903 pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell);
201906 readCoord(pData, &pCoord[ii]);
201907 readCoord(pData+4, &pCoord[ii+1]);
201908 pData += 8;
215444 const void *pData = sqlite3_value_blob(argv[3]);
215445 assert( pData!=0 || pTab->db->mallocFailed );
215446 if( pData
215449 memcpy(sqlite3PagerGetData(pDbPage), pData, szPage);
218058 int (*xOutput)(void *pOut, const void *pData, int nData),
218204 int (*xOutput)(void *pOut, const void *pData, int nData),
218216 int (*xOutput)(void *pOut, const void *pData, int nData),
218329 int (*xInput)(void *pIn, void *pData, int *pnData),
218387 int (*xInput)(void *pIn, void *pData, int *pnData),
218394 int (*xInput)(void *pIn, void *pData, int *pnData),
219081 int (*xOutput)(void *pOut, const void *pData, int nData),
219258 int (*xInput)(void *pIn, void *pData, int *pnData),
219260 int (*xOutput)(void *pOut, const void *pData, int nData),
220421 int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
220448 int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
220787 int (*xOutput)(void *pOut, const void *pData, int nData),
220850 ** Add the changeset currently stored in buffer pData, size nData bytes,
220853 SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup *pGrp, int nData, void *pData){
220854 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
220857 rc = sqlite3changeset_start(&pIter, nData, pData);
220882 int (*xInput)(void *pIn, void *pData, int *pnData),
220885 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
220901 int (*xOutput)(void *pOut, const void *pData, int nData),
220950 int (*xInputA)(void *pIn, void *pData, int *pnData),
220952 int (*xInputB)(void *pIn, void *pData, int *pnData),
220954 int (*xOutput)(void *pOut, const void *pData, int nData),
221108 int (*xOutput)(void *pOut, const void *pData, int nData),
221258 sqlite3_changeset_iter *pIter = 0; /* Iterator opened on pData/nData */
221292 int (*xInput)(void *pIn, void *pData, int *pnData),
221294 int (*xOutput)(void *pOut, const void *pData, int nData),
222295 const u8 *pData;
224927 Fts5Bm25Data *pData; /* Values allocated/calculated once only */
224935 rc = fts5Bm25GetData(pApi, pFts, &pData);
224937 aFreq = pData->aFreq;
224938 memset(aFreq, 0, sizeof(double) * pData->nPhrase);
224960 for(i=0; i<pData->nPhrase; i++){
224961 score += pData->aIDF[i] * (
224963 ( aFreq[i] + k1 * (1 - b + b * D / pData->avgdl) )
225056 ** Append buffer nData/pData to buffer pBuf. If an OOM error occurs, set
225064 const u8 *pData
225068 memcpy(&pBuf->p[pBuf->n], pData, nData);
225149 ** Set the buffer to contain nData/pData. If an OOM error occurs, leave an
225157 const u8 *pData
225160 sqlite3Fts5BufferAppendBlob(pRc, pBuf, nData, pData);
226859 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
226950 a = (u8*)pTerm->pIter->pData;
227242 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
227554 pPhrase->poslist.p = (u8*)pIter->pData;
229434 *ppCollist = pPhrase->aTerm[0].pIter->pData;
230535 ** pData:
230542 ** Set to the current offset within record pData.
230545 Fts5Data *pData; /* Data for current page of this level */
230546 int iOff; /* Current offset into pData */
230713 static void fts5DataRelease(Fts5Data *pData){
230714 sqlite3_free(pData);
230751 static void fts5DataWrite(Fts5Index *p, i64 iRowid, const u8 *pData, int nData){
230764 sqlite3_bind_blob(p->pWriter, 2, pData, nData, SQLITE_STATIC);
230887 ** form within buffer pData/nData.
230898 const u8 *pData, /* Buffer containing serialized structure */
230899 int nData, /* Size of buffer pData in bytes */
230912 if( piCookie ) *piCookie = sqlite3Fts5Get32(pData);
230917 i += fts5GetVarint32(&pData[i], nLevel);
230918 i += fts5GetVarint32(&pData[i], nSegment);
230934 i += sqlite3Fts5GetVarint(&pData[i], &pRet->nWriteCounter);
230944 i += fts5GetVarint32(&pData[i], pLvl->nMerge);
230945 i += fts5GetVarint32(&pData[i], nTotal);
230961 i += fts5GetVarint32(&pData[i], pSeg->iSegid);
230962 i += fts5GetVarint32(&pData[i], pSeg->pgnoFirst);
230963 i += fts5GetVarint32(&pData[i], pSeg->pgnoLast);
231047 Fts5Data *pData;
231049 pData = fts5DataRead(p, FTS5_STRUCTURE_ROWID);
231052 memset(&pData->p[pData->nn], 0, FTS5_DATA_PADDING);
231053 p->rc = fts5StructureDecode(pData->p, pData->nn, &iCookie, &pRet);
231057 fts5DataRelease(pData);
231339 Fts5Data *pData = pLvl->pData;
231344 pLvl->iOff += fts5GetVarint32(&pData->p[1], pLvl->iLeafPgno);
231345 pLvl->iOff += fts5GetVarint(&pData->p[pLvl->iOff], (u64*)&pLvl->iRowid);
231349 for(iOff=pLvl->iOff; iOff<pData->nn; iOff++){
231350 if( pData->p[iOff] ) break;
231353 if( iOff<pData->nn ){
231356 iOff += fts5GetVarint(&pData->p[iOff], (u64*)&iVal);
231378 fts5DataRelease(pLvl->pData);
231380 pLvl->pData = fts5DataRead(p,
231383 if( pLvl->pData ) fts5DlidxLvlNext(pLvl);
231399 ** pData:
231429 fts5DataRelease(pChild->pData);
231431 pChild->pData = fts5DataRead(p,
231448 u8 *a = pLvl->pData->p;
231498 fts5DataRelease(pLvl->pData);
231500 pLvl->pData = fts5DataRead(p,
231503 if( pLvl->pData ){
231524 fts5DataRelease(pIter->aLvl[i].pData);
231552 pLvl->pData = fts5DataRead(p, iRowid);
231553 if( pLvl->pData && (pLvl->pData->p[0] & 0x0001)==0 ){
233131 Fts5Data *pData = 0;
233147 fts5DataRelease(pData);
233155 pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
233156 if( pData==0 ) break;
233157 pChunk = &pData->p[4];
233158 nChunk = MIN(nRem, pData->szLeaf - 4);
233161 pSeg->pNextLeaf = pData;
233162 pData = 0;
233210 ** and sets pIter->base.pData/nData to point to the new position list.
233213 ** pIter->base.pData/nData to point directly to it.
233240 pIter->base.pData = pIter->poslist.p;
233254 pIter->base.pData = aCopy;
233261 pIter->base.pData = pIter->poslist.p;
233299 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
233306 pIter->base.pData = pIter->poslist.p;
233328 pIter->base.pData = pIter->poslist.p;
233374 pIter->base.pData = pIter->poslist.p;
233402 pIter->base.pData = pIter->poslist.p;
233559 Fts5Data *pData, /* Doclist to iterate through */
233569 if( pData->szLeaf>0 ){
233570 pIter->pLeaf = pData;
233571 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
233572 pIter->iEndofDoclist = pData->nn;
233581 pData = 0;
233590 fts5DataRelease(pData);
234231 Fts5Data *pData;
234236 pData = fts5LeafRead(p, iLeafRowid);
234237 if( pData ){
234238 if( iOff>pData->szLeaf ){
234246 fts5BufferGrow(&p->rc, &buf, pData->nn);
234250 fts5BufferAppendBlob(&p->rc, &buf, pData->szLeaf-iOff,&pData->p[iOff]);
234259 && pSeg->iEndofDoclist<pData->szLeaf
234260 && pSeg->iPgidxOff<=pData->nn
234262 int nDiff = pData->szLeaf - pSeg->iEndofDoclist;
234265 pData->nn - pSeg->iPgidxOff, &pData->p[pSeg->iPgidxOff]
234273 fts5DataRelease(pData);
234881 fts5BufferSafeAppendBlob(pBuf, pMulti->base.pData, nData);
235241 Fts5Data *pData;
235323 pData = fts5IdxMalloc(p, sizeof(Fts5Data)+doclist.n+FTS5_DATA_ZERO_PADDING);
235324 if( pData ){
235325 pData->p = (u8*)&pData[1];
235326 pData->nn = pData->szLeaf = doclist.n;
235327 if( doclist.n ) memcpy(pData->p, doclist.p, doclist.n);
235328 fts5MultiIterNew2(p, pData, bDesc, ppIter);
235717 Fts5Data *pData;
235721 pData = fts5DataRead(p, FTS5_AVERAGES_ROWID);
235722 if( p->rc==SQLITE_OK && pData->nn ){
235725 i += fts5GetVarint(&pData->p[i], (u64*)pnRow);
235726 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
235727 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
235731 fts5DataRelease(pData);
235739 static int sqlite3Fts5IndexSetAverages(Fts5Index *p, const u8 *pData, int nData){
235741 fts5DataWrite(p, FTS5_AVERAGES_ROWID, pData, nData);
235879 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
236502 ** Buffer (pData/nData) contains a doclist in the format used by detail=none
236514 const u8 *pData, int nData /* Data to decode list-of-rowids from */
236522 i += sqlite3Fts5GetVarint(&pData[i], &iVal);
236525 if( i<nData && pData[i]==0x00 ){
236527 if( i<nData && pData[i]==0x00 ){
236584 lvl.pData = &dlidx;
237570 Fts5Auxdata *pData;
237589 for(pData=pCsr->pAuxdata; pData; pData=pNext){
237590 pNext = pData->pNext;
237591 if( pData->xDelete ) pData->xDelete(pData->pPtr);
237592 sqlite3_free(pData);
238932 Fts5Auxdata *pData;
238936 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
238937 if( pData->pAux==pCsr->pAux ) break;
238940 if( pData ){
238941 if( pData->xDelete ){
238942 pData->xDelete(pData->pPtr);
238946 pData = (Fts5Auxdata*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Auxdata));
238947 if( pData==0 ){
238951 pData->pAux = pCsr->pAux;
238952 pData->pNext = pCsr->pAuxdata;
238953 pCsr->pAuxdata = pData;
238956 pData->xDelete = xDelete;
238957 pData->pPtr = pPtr;
238963 Fts5Auxdata *pData;
238966 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
238967 if( pData->pAux==pCsr->pAux ) break;
238970 if( pData ){
238971 pRet = pData->pPtr;
238973 pData->pPtr = 0;
238974 pData->xDelete = 0;
243915 || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
243987 pPos = pCsr->pIter->pData;
245639 unsigned char *pData = (unsigned char *)data;
245644 return pData;
245658 return pData;
245661 rc = sqlite3CodecDecryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245665 (void)memcpy_s(pData, cipherPageSize, pCtx->buffer, cipherPageSize);
245666 return pData;
245673 return pData;
245676 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_WRITE, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245679 return pData;
245688 return pData;
245691 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245694 return pData;
245699 return pData;