Lines Matching refs:pData
9514 ** Add all changes within the changeset (or patchset) in buffer pData (size
9586 int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData);
9906 ** int (*xInput)(void *pIn, void *pData, int *pnData),
9912 ** argument, pData, points to a buffer (*pnData) bytes in size. Assuming no
9940 ** int (*xOutput)(void *pOut, const void *pData, int nData),
9946 ** pOut pointer supplied by the application. The second parameter, pData,
9960 int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
9974 int (*xInputA)(void *pIn, void *pData, int *pnData),
9976 int (*xInputB)(void *pIn, void *pData, int *pnData),
9978 int (*xOutput)(void *pOut, const void *pData, int nData),
9982 int (*xInput)(void *pIn, void *pData, int *pnData),
9984 int (*xOutput)(void *pOut, const void *pData, int nData),
9989 int (*xInput)(void *pIn, void *pData, int *pnData),
9994 int (*xOutput)(void *pOut, const void *pData, int nData),
9999 int (*xOutput)(void *pOut, const void *pData, int nData),
10003 int (*xInput)(void *pIn, void *pData, int *pnData),
10007 int (*xOutput)(void *pOut, const void *pData, int nData),
11230 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData);
11242 ** SomeStructure *pData = sqliteHashData(p);
11243 ** // do something with pData
12248 ** key and pData,nData,nZero set to zero.
12252 ** pData,nData hold the content of the new entry. nZero extra zero bytes
12264 const void *pData; /* Data for tables. NULL for indexes */
12265 int nData; /* Size of pData. 0 if none. */
12266 int nZero; /* Extra zero data appended after pData,nData */
13147 void *pData; /* Page data */
16438 SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
16439 SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
43956 pPgHdr->pData = pPage->pBuf;
47464 static u32 pager_datahash(int nByte, unsigned char *pData){
47468 hash = (hash*1039) + pData[i];
47473 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
48666 void *pData;
48667 pData = pPg->pData;
48668 memcpy(pData, (u8*)aData, pPager->pageSize);
48679 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
48683 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM_BKPT);
49184 ** pPg->pData. A shared lock or greater must be held on the database
49205 rc = sqlite3WalReadFrame(pPager->pWal, iFrame, pgsz, pPg->pData);
49210 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
49232 u8 *dbFileVers = &((u8*)pPg->pData)[24];
49236 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM_BKPT);
49260 put32bits(((char*)pPg->pData)+24, change_counter);
49265 put32bits(((char*)pPg->pData)+92, change_counter);
49266 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
49398 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
50214 ** The new object will use the pointer pData, obtained from xFetch().
50225 void *pData, /* xFetch()'d data for this page */
50238 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
50254 p->pData = pData;
50271 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
50592 char *pData; /* Data to write */
50598 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM_BKPT, pData);
50601 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
50608 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
50616 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
50684 void *pData = pPg->pData;
50688 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
51634 void *pData = 0;
51637 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
51640 if( rc==SQLITE_OK && pData ){
51645 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
51647 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
51730 memset(pPg->pData, 0, pPager->pageSize);
51998 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
52363 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM_BKPT, zBuf);
53062 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
53245 return pPg->pData;
56556 void *pData; /* Data actually written */
56559 if( (pData = sqlite3PagerCodec(pPage))==0 ) return SQLITE_NOMEM_BKPT;
56561 pData = pPage->pData;
56563 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
56567 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
56741 void *pData;
56746 if( (pData = sqlite3PagerCodec(p))==0 ) return SQLITE_NOMEM;
56748 pData = p->pData;
56750 rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
60224 static void pageReinit(DbPage *pData){
60226 pPage = (MemPage *)sqlite3PagerGetExtra(pData);
60227 assert( sqlite3PagerPageRefcount(pData)>0 );
60231 if( sqlite3PagerPageRefcount(pData)>1 ){
64230 pSrc = pX->pData;
64594 u8 *pData;
64599 pData = pEnd;
64605 pData -= szCell[i];
64606 put2byte(pCellptr, (pData - aData));
64608 if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT;
64609 memcpy(pData, pCell, szCell[i]);
64620 put2byte(&aData[hdr+5], pData - aData);
64661 u8 *pData = *ppData;
64669 if( (pData - pBegin)<sz ) return 1;
64670 pData -= sz;
64671 pSlot = pData;
64683 *ppData = pData;
64764 u8 *pData;
64785 pData = &aData[get2byteNotZero(&aData[hdr+5])];
64786 if( pData<pBegin ) goto editpage_fail;
64795 pPg, pBegin, &pData, pCellptr,
64809 pPg, pBegin, &pData, pCellptr,
64818 pPg, pBegin, &pData, pCellptr,
64826 put2byte(&aData[hdr+5], pData - aData);
66058 ** rowid or INTEGER PRIMARY KEY of the row. The pX.nData,pData,nZero fields
66063 ** pX.pData,nData,nZero fields must be zero.
76721 Mem *pData = &p->v->aMem[p->iNewReg];
76722 rc = sqlite3VdbeMemExpandBlob(pData);
76724 pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
81442 Mem *pData; /* MEM cell holding data for the record to be inserted */
81452 pData = &aMem[pOp->p2];
81454 assert( memIsValid(pData) );
81461 REGISTER_TRACE(pOp->p2, pData);
81498 if( pData->flags & MEM_Null ){
81499 x.pData = 0;
81502 assert( pData->flags & (MEM_Blob|MEM_Str) );
81503 x.pData = pData->z;
81504 x.nData = pData->n;
81507 if( pData->flags & MEM_Zero ){
81508 x.nZero = pData->u.nZero;
82144 x.pData = 0;
86093 static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){
86101 memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
94962 static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){
94968 memcpy(p->u.aRowid, pData, n);
96138 static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
96139 analysisInfo *pInfo = (analysisInfo*)pData;
112652 InitData *pData, /* Initialization context */
112656 sqlite3 *db = pData->db;
112662 sqlite3DbFree(db, *pData->pzErrMsg);
112663 *pData->pzErrMsg = z;
112665 pData->rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_CORRUPT_BKPT;
112681 InitData *pData = (InitData*)pInit;
112682 sqlite3 *db = pData->db;
112683 int iDb = pData->iDb;
112690 corruptSchema(pData, argv[0], 0);
112697 corruptSchema(pData, argv[0], 0);
112720 pData->rc = rc;
112724 corruptSchema(pData, argv[0], sqlite3_errmsg(db));
112730 corruptSchema(pData, argv[0], 0);
112748 corruptSchema(pData, argv[0], "invalid rootpage");
141430 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
141452 ** SomeStructure *pData = fts3HashData(p);
141453 ** // do something with pData
160700 u8 *pData;
160704 pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell);
160707 readCoord(&pData[ii*4], &pCoord[ii]);
172573 int (*xOutput)(void *pOut, const void *pData, int nData),
172709 int (*xOutput)(void *pOut, const void *pData, int nData),
172720 int (*xOutput)(void *pOut, const void *pData, int nData),
172791 int (*xInput)(void *pIn, void *pData, int *pnData),
172836 int (*xInput)(void *pIn, void *pData, int *pnData),
173427 int (*xOutput)(void *pOut, const void *pData, int nData),
173604 int (*xInput)(void *pIn, void *pData, int *pnData),
173606 int (*xOutput)(void *pOut, const void *pData, int nData),
174513 int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
174796 int (*xOutput)(void *pOut, const void *pData, int nData),
174860 ** Add the changeset currently stored in buffer pData, size nData bytes,
174863 SQLITE_API int SQLITE_STDCALL sqlite3changegroup_add(sqlite3_changegroup *pGrp, int nData, void *pData){
174864 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
174867 rc = sqlite3changeset_start(&pIter, nData, pData);
174892 int (*xInput)(void *pIn, void *pData, int *pnData),
174895 sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
174911 int (*xOutput)(void *pOut, const void *pData, int nData),
174960 int (*xInputA)(void *pIn, void *pData, int *pnData),
174962 int (*xInputB)(void *pIn, void *pData, int *pnData),
174964 int (*xOutput)(void *pOut, const void *pData, int nData),
178132 const u8 *pData;
180329 Fts5Bm25Data *pData; /* Values allocated/calculated once only */
180337 rc = fts5Bm25GetData(pApi, pFts, &pData);
180339 aFreq = pData->aFreq;
180340 memset(aFreq, 0, sizeof(double) * pData->nPhrase);
180360 for(i=0; rc==SQLITE_OK && i<pData->nPhrase; i++){
180361 score += pData->aIDF[i] * (
180363 ( aFreq[i] + k1 * (1 - b + b * D / pData->avgdl) )
180462 ** Append buffer nData/pData to buffer pBuf. If an OOM error occurs, set
180470 const u8 *pData
180474 memcpy(&pBuf->p[pBuf->n], pData, nData);
180554 ** Set the buffer to contain nData/pData. If an OOM error occurs, leave an
180562 const u8 *pData
180565 sqlite3Fts5BufferAppendBlob(pRc, pBuf, nData, pData);
182111 sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
182201 a = (u8*)pTerm->pIter->pData;
182489 fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
182788 pPhrase->poslist.p = (u8*)pIter->pData;
184405 *ppCollist = pPhrase->aTerm[0].pIter->pData;
185480 ** pData:
185487 ** Set to the current offset within record pData.
185490 Fts5Data *pData; /* Data for current page of this level */
185491 int iOff; /* Current offset into pData */
185654 static void fts5DataRelease(Fts5Data *pData){
185655 sqlite3_free(pData);
185678 static void fts5DataWrite(Fts5Index *p, i64 iRowid, const u8 *pData, int nData){
185691 sqlite3_bind_blob(p->pWriter, 2, pData, nData, SQLITE_STATIC);
185771 ** form within buffer pData/nData.
185782 const u8 *pData, /* Buffer containing serialized structure */
185783 int nData, /* Size of buffer pData in bytes */
185796 if( piCookie ) *piCookie = sqlite3Fts5Get32(pData);
185801 i += fts5GetVarint32(&pData[i], nLevel);
185802 i += fts5GetVarint32(&pData[i], nSegment);
185813 i += sqlite3Fts5GetVarint(&pData[i], &pRet->nWriteCounter);
185823 i += fts5GetVarint32(&pData[i], pLvl->nMerge);
185824 i += fts5GetVarint32(&pData[i], nTotal);
185838 i += fts5GetVarint32(&pData[i], pLvl->aSeg[iSeg].iSegid);
185839 i += fts5GetVarint32(&pData[i], pLvl->aSeg[iSeg].pgnoFirst);
185840 i += fts5GetVarint32(&pData[i], pLvl->aSeg[iSeg].pgnoLast);
185914 Fts5Data *pData;
185916 pData = fts5DataRead(p, FTS5_STRUCTURE_ROWID);
185919 memset(&pData->p[pData->nn], 0, FTS5_DATA_PADDING);
185920 p->rc = fts5StructureDecode(pData->p, pData->nn, &iCookie, &pRet);
185924 fts5DataRelease(pData);
186206 Fts5Data *pData = pLvl->pData;
186211 pLvl->iOff += fts5GetVarint32(&pData->p[1], pLvl->iLeafPgno);
186212 pLvl->iOff += fts5GetVarint(&pData->p[pLvl->iOff], (u64*)&pLvl->iRowid);
186216 for(iOff=pLvl->iOff; iOff<pData->nn; iOff++){
186217 if( pData->p[iOff] ) break;
186220 if( iOff<pData->nn ){
186223 iOff += fts5GetVarint(&pData->p[iOff], (u64*)&iVal);
186245 fts5DataRelease(pLvl->pData);
186247 pLvl->pData = fts5DataRead(p,
186250 if( pLvl->pData ) fts5DlidxLvlNext(pLvl);
186266 ** pData:
186296 fts5DataRelease(pChild->pData);
186298 pChild->pData = fts5DataRead(p,
186315 u8 *a = pLvl->pData->p;
186365 fts5DataRelease(pLvl->pData);
186367 pLvl->pData = fts5DataRead(p,
186370 if( pLvl->pData ){
186391 fts5DataRelease(pIter->aLvl[i].pData);
186419 pLvl->pData = fts5DataRead(p, iRowid);
186420 if( pLvl->pData && (pLvl->pData->p[0] & 0x0001)==0 ){
187977 Fts5Data *pData = 0;
187993 fts5DataRelease(pData);
187998 pData = fts5DataRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
187999 if( pData==0 ) break;
188000 pChunk = &pData->p[4];
188001 nChunk = MIN(nRem, pData->szLeaf - 4);
188004 pSeg->pNextLeaf = pData;
188005 pData = 0;
188131 pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
188138 pIter->base.pData = pIter->poslist.p;
188151 pIter->base.pData = pIter->poslist.p;
188197 pIter->base.pData = pIter->poslist.p;
188218 pIter->base.pData = a;
188222 pIter->base.pData = pIter->poslist.p;
188231 pIter->base.pData = pIter->poslist.p;
188378 Fts5Data *pData, /* Doclist to iterate through */
188388 if( pData->szLeaf>0 ){
188389 pIter->pLeaf = pData;
188390 pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
188391 pIter->iEndofDoclist = pData->nn;
188400 pData = 0;
188409 fts5DataRelease(pData);
189043 Fts5Data *pData;
189048 pData = fts5DataRead(p, iLeafRowid);
189049 if( pData ){
189051 fts5BufferGrow(&p->rc, &buf, pData->nn);
189055 fts5BufferAppendBlob(&p->rc, &buf, pData->szLeaf-iOff, &pData->p[iOff]);
189064 && pSeg->iEndofDoclist<pData->szLeaf
189066 int nDiff = pData->szLeaf - pSeg->iEndofDoclist;
189069 pData->nn - pSeg->iPgidxOff, &pData->p[pSeg->iPgidxOff]
189073 fts5DataRelease(pData);
189675 fts5BufferSafeAppendBlob(pBuf, pMulti->base.pData, nData);
189956 Fts5Data *pData;
190005 pData = fts5IdxMalloc(p, sizeof(Fts5Data) + doclist.n);
190006 if( pData ){
190007 pData->p = (u8*)&pData[1];
190008 pData->nn = pData->szLeaf = doclist.n;
190009 memcpy(pData->p, doclist.p, doclist.n);
190010 fts5MultiIterNew2(p, pData, bDesc, ppIter);
190384 Fts5Data *pData;
190388 pData = fts5DataRead(p, FTS5_AVERAGES_ROWID);
190389 if( p->rc==SQLITE_OK && pData->nn ){
190392 i += fts5GetVarint(&pData->p[i], (u64*)pnRow);
190393 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
190394 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
190398 fts5DataRelease(pData);
190406 static int sqlite3Fts5IndexSetAverages(Fts5Index *p, const u8 *pData, int nData){
190408 fts5DataWrite(p, FTS5_AVERAGES_ROWID, pData, nData);
190546 for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
191112 ** Buffer (pData/nData) contains a doclist in the format used by detail=none
191124 const u8 *pData, int nData /* Data to decode list-of-rowids from */
191132 i += sqlite3Fts5GetVarint(&pData[i], &iVal);
191135 if( i<nData && pData[i]==0x00 ){
191137 if( i<nData && pData[i]==0x00 ){
191193 lvl.pData = &dlidx;
192066 Fts5Auxdata *pData;
192085 for(pData=pCsr->pAuxdata; pData; pData=pNext){
192086 pNext = pData->pNext;
192087 if( pData->xDelete ) pData->xDelete(pData->pPtr);
192088 sqlite3_free(pData);
193335 Fts5Auxdata *pData;
193339 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
193340 if( pData->pAux==pCsr->pAux ) break;
193343 if( pData ){
193344 if( pData->xDelete ){
193345 pData->xDelete(pData->pPtr);
193349 pData = (Fts5Auxdata*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Auxdata));
193350 if( pData==0 ){
193354 pData->pAux = pCsr->pAux;
193355 pData->pNext = pCsr->pAuxdata;
193356 pCsr->pAuxdata = pData;
193359 pData->xDelete = xDelete;
193360 pData->pPtr = pPtr;
193366 Fts5Auxdata *pData;
193369 for(pData=pCsr->pAuxdata; pData; pData=pData->pNext){
193370 if( pData->pAux==pCsr->pAux ) break;
193373 if( pData ){
193374 pRet = pData->pPtr;
193376 pData->pPtr = 0;
193377 pData->xDelete = 0;
197639 pPos = pCsr->pIter->pData;
197643 pPos = pCsr->pIter->pData;