Lines Matching refs:pBuf
9010 void *pBuf; /* The content of the page */
9103 ** The pBuf element of the returned sqlite3_pcache_page object will be a
24951 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
24953 return id->pMethods->xRead(id, pBuf, amt, offset);
24955 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
24957 return id->pMethods->xWrite(id, pBuf, amt, offset);
25978 static void randomFill(char *pBuf, int nByte){
25980 x = SQLITE_PTR_TO_INT(pBuf);
25986 *(int*)pBuf = r;
25987 pBuf += 4;
25994 *(pBuf++) = r & 0xff;
29469 LookasideSlot *pBuf = (LookasideSlot*)p;
29474 pBuf->pNext = db->lookaside.pSmallFree;
29475 db->lookaside.pSmallFree = pBuf;
29480 LookasideSlot *pBuf = (LookasideSlot*)p;
29485 pBuf->pNext = db->lookaside.pFree;
29486 db->lookaside.pFree = pBuf;
29508 LookasideSlot *pBuf = (LookasideSlot*)p;
29513 pBuf->pNext = db->lookaside.pSmallFree;
29514 db->lookaside.pSmallFree = pBuf;
29519 LookasideSlot *pBuf = (LookasideSlot*)p;
29524 pBuf->pNext = db->lookaside.pFree;
29525 db->lookaside.pFree = pBuf;
29688 LookasideSlot *pBuf;
29702 if( (pBuf = db->lookaside.pSmallFree)!=0 ){
29703 db->lookaside.pSmallFree = pBuf->pNext;
29705 return (void*)pBuf;
29706 }else if( (pBuf = db->lookaside.pSmallInit)!=0 ){
29707 db->lookaside.pSmallInit = pBuf->pNext;
29709 return (void*)pBuf;
29713 if( (pBuf = db->lookaside.pFree)!=0 ){
29714 db->lookaside.pFree = pBuf->pNext;
29716 return (void*)pBuf;
29717 }else if( (pBuf = db->lookaside.pInit)!=0 ){
29718 db->lookaside.pInit = pBuf->pNext;
29720 return (void*)pBuf;
32683 SQLITE_API void sqlite3_randomness(int N, void *pBuf){
32684 unsigned char *zBuf = pBuf;
32712 if( N<=0 || pBuf==0 ){
40106 ** bytes into pBuf. Return the number of bytes actually read.
40117 static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
40128 got = osPread(id->h, pBuf, cnt, offset);
40131 got = osPread64(id->h, pBuf, cnt, offset);
40140 got = osRead(id->h, pBuf, cnt);
40152 pBuf = (void*)(got + (char*)pBuf);
40168 void *pBuf,
40192 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
40196 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
40197 pBuf = &((u8 *)pBuf)[nCopy];
40204 got = seekAndRead(pFile, offset, pBuf, amt);
40236 memset(&((char*)pBuf)[got], 0, amt-got);
40244 ** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise,
40251 const void *pBuf, /* Copy data from this buffer to the file */
40252 int nBuf, /* Size of buffer pBuf in bytes */
40264 do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR );
40266 do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR);
40275 rc = osWrite(fd, pBuf, nBuf);
40288 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
40294 static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
40295 return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);
40305 const void *pBuf,
40338 if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
40350 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
40354 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
40355 pBuf = &((u8 *)pBuf)[nCopy];
40362 while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
40365 pBuf = &((char*)pBuf)[wrote];
47795 void *pBuf, /* Write content into this buffer */
47812 pFile->h, pBuf, amt, offset, pFile->locktype));
47819 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
47825 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
47826 pBuf = &((u8 *)pBuf)[nCopy];
47839 while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
47844 while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) &&
47858 memset(&((char*)pBuf)[nRead], 0, amt-nRead);
47875 const void *pBuf, /* The bytes to be written */
47890 pFile->h, pBuf, amt, offset, pFile->locktype));
47897 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
47903 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
47904 pBuf = &((u8 *)pBuf)[nCopy];
47920 u8 *aRem = (u8 *)pBuf; /* Data yet to be written */
52432 ** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage
52435 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
52451 u32 *aiValues = pBuf;
52684 a = (unsigned char *)pLower->pBuf;
53108 pPgHdr->pData = pPage->pBuf;
53313 memset(pPage1->pBuf, 0, pCache->szPage);
53567 ** The superclass sqlite3_pcache_page.pBuf points to the start of the
53652 sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */
53803 ** verb to sqlite3_config(). Parameter pBuf points to an allocation large
53809 SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
53812 if( pBuf==0 ) sz = n = 0;
53818 pcache1.pStart = pBuf;
53822 p = (PgFreeslot*)pBuf;
53825 pBuf = (void*)&((char*)pBuf)[sz];
53827 pcache1.pEnd = pBuf;
53856 pX->page.pBuf = zBulk;
53993 p->page.pBuf = pPg;
54015 pcache1Free(p->page.pBuf);
54246 ** sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL
54247 ** pBuf argument.
54781 nFree += pcache1MemSize(p->page.pBuf);
73524 ** from pPayload to the buffer pointed at by pBuf. If eOp is true,
73526 ** of data are copied from the buffer pBuf to pPayload.
73532 void *pBuf, /* Pointer to buffer */
73543 memcpy(pPayload, pBuf, nByte);
73546 memcpy(pBuf, pPayload, nByte);
73560 ** Data is read to or from the buffer pBuf.
73584 unsigned char *pBuf, /* Write the bytes into this buffer */
73593 unsigned char * const pBufStart = pBuf; /* Start of original out buffer */
73624 rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
73626 pBuf += a;
73724 && &pBuf[-4]>=pBufStart /* (6) */
73728 u8 *aWrite = &pBuf[-4];
73746 rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
73753 pBuf += a;
73769 ** pointing. "amt" bytes will be transferred into pBuf[]. The transfer
73784 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
73788 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
73801 void *pBuf
73809 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
73811 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
73814 return accessPayload(pCur, offset, amt, pBuf, 0);
73816 return accessPayloadChecked(pCur, offset, amt, pBuf);
84923 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
84929 ** If pBuf is not initially NULL, that means that the memory has already
84931 ** of pBuf and leave ReusableSpace unchanged.
84939 void *pBuf, /* Pointer to a prior allocation */
84943 if( pBuf==0 ){
84947 pBuf = &p->pSpace[p->nFree];
84952 assert( EIGHT_BYTE_ALIGNMENT(pBuf) );
84953 return pBuf;
174154 static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
174180 }else if( pBuf==0 ){
174186 pStart = pBuf;
174231 db->lookaside.bMalloced = pBuf==0 ?1:0;
174336 void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
174339 rc = setupLookaside(db, pBuf, sz, cnt);
179997 SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *pBuf, sqlite_uint64 *v){
179998 const unsigned char *p = (const unsigned char*)pBuf;
180024 SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *pBuf, sqlite_int64 *v){
180025 return sqlite3Fts3GetVarintU(pBuf, (sqlite3_uint64*)v);
180035 const char *pBuf,
180039 const unsigned char *p = (const unsigned char*)pBuf;
195860 MatchinfoBuffer *pBuf = (MatchinfoBuffer*)((u8*)p - ((u32*)p)[-1]);
195862 assert( (u32*)p==&pBuf->aMatchinfo[1]
195863 || (u32*)p==&pBuf->aMatchinfo[pBuf->nElem+2]
195865 if( (u32*)p==&pBuf->aMatchinfo[1] ){
195866 pBuf->aRef[1] = 0;
195868 pBuf->aRef[2] = 0;
195871 if( pBuf->aRef[0]==0 && pBuf->aRef[1]==0 && pBuf->aRef[2]==0 ){
195872 sqlite3_free(pBuf);
213499 u8 *pBuf = (u8*)zBuf;
213500 p->iCookie = rbuGetU32(&pBuf[24]);
213501 p->iWriteVer = pBuf[19];
213542 u8 *pBuf = (u8*)zBuf;
213543 p->iCookie = rbuGetU32(&pBuf[24]);
213544 p->iWriteVer = pBuf[19];
217750 SessionBuffer *pBuf, /* Buffer to append to */
217759 int nRewind = pBuf->nBuf; /* Set to zero if any values are modified */
217764 sessionAppendByte(pBuf, SQLITE_UPDATE, &rc);
217765 sessionAppendByte(pBuf, p->bIndirect, &rc);
217817 sessionAppendBlob(pBuf, pCsr, nAdvance, &rc);
217819 sessionAppendByte(pBuf, 0, &rc);
217835 pBuf->nBuf = nRewind;
217837 sessionAppendBlob(pBuf, buf2.aBuf, buf2.nBuf, &rc);
217850 SessionBuffer *pBuf, /* Buffer to append to */
217858 sessionAppendByte(pBuf, SQLITE_DELETE, &rc);
217859 sessionAppendByte(pBuf, p->bIndirect, &rc);
217862 sessionAppendBlob(pBuf, p->aRecord, p->nRecord, &rc);
217889 sessionAppendBlob(pBuf, pStart, (int)(a-pStart), &rc);
218029 ** changeset format) to buffer *pBuf. If an error occurs, set *pRc to an
218033 SessionBuffer *pBuf, /* Append header to this buffer */
218039 sessionAppendByte(pBuf, (bPatchset ? 'P' : 'T'), pRc);
218040 sessionAppendVarint(pBuf, pTab->nCol, pRc);
218041 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
218042 sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
220985 ** record to buffer pBuf that is a copy of a1, except that for
220989 SessionBuffer *pBuf, /* Buffer to append to */
220995 sessionBufferGrow(pBuf, n1+n2, pRc);
220998 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
221013 pBuf->nBuf = pOut-pBuf->aBuf;
221014 assert( pBuf->nBuf<=pBuf->nAlloc );
221023 ** pBuf.
221038 SessionBuffer *pBuf, /* Append record here */
221044 sessionBufferGrow(pBuf, 2+nRec+nChange, pRc);
221047 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
221085 pBuf->nBuf = (pOut - pBuf->aBuf);
222223 #define fts5BufferGrow(pRc,pBuf,nn) ( \
222224 (u32)((pBuf)->n) + (u32)(nn) <= (u32)((pBuf)->nSpace) ? 0 : \
222225 sqlite3Fts5BufferSize((pRc),(pBuf),(nn)+(pBuf)->n) \
225015 static int sqlite3Fts5BufferSize(int *pRc, Fts5Buffer *pBuf, u32 nByte){
225016 if( (u32)pBuf->nSpace<nByte ){
225017 u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
225022 pNew = sqlite3_realloc64(pBuf->p, nNew);
225027 pBuf->nSpace = (int)nNew;
225028 pBuf->p = pNew;
225037 ** pBuf. If an OOM error occurs, set the error code in p.
225039 static void sqlite3Fts5BufferAppendVarint(int *pRc, Fts5Buffer *pBuf, i64 iVal){
225040 if( fts5BufferGrow(pRc, pBuf, 9) ) return;
225041 pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iVal);
225056 ** Append buffer nData/pData to buffer pBuf. If an OOM error occurs, set
225062 Fts5Buffer *pBuf,
225067 if( fts5BufferGrow(pRc, pBuf, nData) ) return;
225068 memcpy(&pBuf->p[pBuf->n], pData, nData);
225069 pBuf->n += nData;
225074 ** Append the nul-terminated string zStr to the buffer pBuf. This function
225076 ** though this byte is not included in the pBuf->n count.
225080 Fts5Buffer *pBuf,
225084 sqlite3Fts5BufferAppendBlob(pRc, pBuf, nStr+1, (const u8*)zStr);
225085 pBuf->n--;
225090 ** the printf() style processing, then appends the results to buffer pBuf.
225094 ** included in the pBuf->n count.
225098 Fts5Buffer *pBuf,
225111 sqlite3Fts5BufferAppendString(pRc, pBuf, zTmp);
225133 ** Free any buffer allocated by pBuf. Zero the structure before returning.
225135 static void sqlite3Fts5BufferFree(Fts5Buffer *pBuf){
225136 sqlite3_free(pBuf->p);
225137 memset(pBuf, 0, sizeof(Fts5Buffer));
225144 static void sqlite3Fts5BufferZero(Fts5Buffer *pBuf){
225145 pBuf->n = 0;
225155 Fts5Buffer *pBuf,
225159 pBuf->n = 0;
225160 sqlite3Fts5BufferAppendBlob(pRc, pBuf, nData, pData);
225226 ** pBuf, which must be already be large enough to hold the new data.
225231 Fts5Buffer *pBuf,
225238 pBuf->p[pBuf->n++] = 1;
225239 pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
225242 pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2);
225248 Fts5Buffer *pBuf,
225253 if( fts5BufferGrow(&rc, pBuf, 5+5+5) ) return rc;
225254 sqlite3Fts5PoslistSafeAppend(pBuf, &pWriter->iPrev, iPos);
226832 Fts5Buffer *pBuf, /* Use this buffer for space if required */
226871 fts5BufferZero(pBuf);
226886 rc = sqlite3Fts5PoslistWriterAppend(pBuf, &writer, iMin);
226890 *pa = pBuf->p;
226891 *pn = pBuf->n;
229250 Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
229254 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
229258 pBuf->n = 0;
229429 Fts5Buffer *pBuf = (Fts5Buffer*)&pTerm->pSynonym[1];
229431 pTerm, pNode->iRowid, pBuf, (u8**)ppCollist, pnCollist
231162 #define fts5BufferSafeAppendBlob(pBuf, pBlob, nBlob) { \
231163 assert( (pBuf)->nSpace>=((pBuf)->n+nBlob) ); \
231164 memcpy(&(pBuf)->p[(pBuf)->n], pBlob, nBlob); \
231165 (pBuf)->n += nBlob; \
231168 #define fts5BufferSafeAppendVarint(pBuf, iVal) { \
231169 (pBuf)->n += sqlite3Fts5PutVarint(&(pBuf)->p[(pBuf)->n], (iVal)); \
231170 assert( (pBuf)->nSpace>=(pBuf)->n ); \
233025 Fts5Buffer *pBuf; /* Append to this buffer */
233032 Fts5Buffer *pBuf; /* Append to this buffer */
233065 fts5BufferSafeAppendVarint(pCtx->pBuf, iVal + 2 - pCtx->iWrite);
233091 fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
233103 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
233115 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
233171 ** buffer pBuf. It does not make a copy of the position-list size
233178 Fts5Buffer *pBuf
233180 assert( pBuf!=0 );
233182 if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+FTS5_DATA_ZERO_PADDING) ){
233183 assert( pBuf->p!=0 );
233184 assert( pBuf->nSpace >= pBuf->n+pSeg->nPos+FTS5_DATA_ZERO_PADDING );
233185 memset(&pBuf->p[pBuf->n+pSeg->nPos], 0, FTS5_DATA_ZERO_PADDING);
233187 fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback);
233191 sCtx.pBuf = pBuf;
233199 sCtx.pBuf = pBuf;
233869 static i64 fts5DlidxExtractFirstRowid(Fts5Buffer *pBuf){
233873 iOff = 1 + fts5GetVarint(&pBuf->p[1], (u64*)&iRowid);
233874 fts5GetVarint(&pBuf->p[iOff], (u64*)&iRowid);
234594 Fts5Buffer *pBuf; /* Buffer in which to assemble leaf page */
234600 pBuf = &writer.writer.buf;
234605 assert( p->rc || pBuf->nSpace>=(pgsz + FTS5_DATA_PADDING) );
234624 if( pgsz>=(pBuf->n + pPgidx->n + nDoclist + 1) ){
234626 fts5BufferSafeAppendBlob(pBuf, pDoclist, nDoclist);
234640 fts5PutU16(&pBuf->p[0], (u16)pBuf->n); /* first rowid on page */
234641 pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iRowid);
234646 pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iDelta);
234648 assert( pBuf->n<=pBuf->nSpace );
234652 pBuf->p[pBuf->n++] = 0;
234655 pBuf->p[pBuf->n++] = 0;
234659 if( (pBuf->n + pPgidx->n)>=pgsz ){
234667 if( (pBuf->n + pPgidx->n + nCopy) <= pgsz ){
234670 fts5BufferSafeAppendBlob(pBuf, &pDoclist[iOff], nCopy);
234678 int nSpace = pgsz - pBuf->n - pPgidx->n;
234686 fts5BufferSafeAppendBlob(pBuf, &pPoslist[iPos], n);
234688 if( (pBuf->n + pPgidx->n)>=pgsz ){
234700 /* pBuf->p[pBuf->n++] = '\0'; */
234701 assert( pBuf->n<=pBuf->nSpace );
234863 Fts5Buffer *pBuf
234866 fts5BufferAppendVarint(&p->rc, pBuf, iDelta);
234873 Fts5Buffer *pBuf
234878 if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nByte) ){
234879 fts5BufferSafeAppendVarint(pBuf, iDelta);
234880 fts5BufferSafeAppendVarint(pBuf, nData*2);
234881 fts5BufferSafeAppendBlob(pBuf, pMulti->base.pData, nData);
234882 memset(&pBuf->p[pBuf->n], 0, FTS5_DATA_ZERO_PADDING);
234917 Fts5Buffer *pBuf,
234921 if( pBuf->n>0 ){
234922 pIter->aPoslist = pBuf->p;
234923 pIter->aEof = &pBuf->p[pBuf->n];
234930 ** Append a doclist to buffer pBuf.
234936 Fts5Buffer *pBuf, /* Buffer to write to */
234940 assert( pBuf->n!=0 || (*piLastRowid)==0 );
234941 fts5BufferSafeAppendVarint(pBuf, iRowid - *piLastRowid);
234946 #define fts5MergeAppendDocid(pBuf, iLastRowid, iRowid) { \
234947 assert( (pBuf)->n!=0 || (iLastRowid)==0 ); \
234948 fts5BufferSafeAppendVarint((pBuf), (u64)(iRowid) - (u64)(iLastRowid)); \
234961 static void fts5NextRowid(Fts5Buffer *pBuf, int *piOff, i64 *piRowid){
234963 if( i>=pBuf->n ){
234967 *piOff = i + sqlite3Fts5GetVarint(&pBuf->p[i], &iVal);
236348 static void fts5DebugRowid(int *pRc, Fts5Buffer *pBuf, i64 iKey){
236354 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{averages} ");
236356 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{structure}");
236360 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{%ssegid=%d h=%d pgno=%d}",
236370 Fts5Buffer *pBuf,
236377 sqlite3Fts5BufferAppendPrintf(pRc, pBuf,
236382 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " {id=%d leaves=%d..%d}",
236386 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "}");
236401 Fts5Buffer *pBuf,
236413 fts5DebugStructure(pRc, pBuf, p);
236428 Fts5Buffer *pBuf,
236437 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "%s%d", zSpace, (int)iVal);
236446 ** each varint and append its string representation to buffer pBuf. Return
236451 static int fts5DecodePoslist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
236456 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %d", iVal);
236467 ** pBuf.
236471 static int fts5DecodeDoclist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
236477 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " id=%lld", iDocid);
236483 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " nPos=%d%s", nPos, bDel?"*":"");
236484 iOff += fts5DecodePoslist(pRc, pBuf, &a[iOff], MIN(n-iOff, nPos));
236489 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " id=%lld", iDocid);
236504 ** buffer pBuf.
236509 ** pBuf is undefined in this case.
236513 Fts5Buffer *pBuf, /* Buffer to append text to */
236535 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %lld%s", iRowid, zApp);
240211 ** INSERT OR REPLACE INTO %_docsize(id, sz) VALUES(iRowid, pBuf);
240219 Fts5Buffer *pBuf /* sz value */
240227 sqlite3_bind_blob(pReplace, 2, pBuf->p, pBuf->n, SQLITE_STATIC);