Lines Matching defs:aData
36139 static int kvvfsEncode(const char *aData, int nData, char *aOut){
36141 const unsigned char *a = (const unsigned char*)aData;
36339 char aData[133073];
36356 got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey, aData, sizeof(aData)-1);
36360 aData[got] = 0;
36363 aData[k*2] = 0;
36364 n = kvvfsDecode(aData, &aData[2000], sizeof(aData)-2000);
36366 memcpy(zBuf, &aData[2000+iOfst], iAmt);
36372 n = kvvfsDecode(aData, zBuf, iAmt);
36423 char aData[131073];
36431 kvvfsEncode(zBuf, iAmt, aData);
36432 if( sqlite3KvvfsMethods.xWrite(pFile->zClass, zKey, aData) ){
51337 ** * The .aData pointer has the added requirement that it can can only
51343 sqlite3_int64 szAlloc; /* Space allocated to aData */
51345 unsigned char *aData; /* content of the file */
51509 sqlite3_free(p->aData);
51533 if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
51537 memcpy(zBuf, p->aData+iOfst, iAmt);
51555 pNew = sqlite3Realloc(p->aData, newSz);
51557 p->aData = pNew;
51587 if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz);
51590 memcpy(p->aData+iOfst, z, iAmt);
51740 *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz);
51793 *pp = (void*)(p->aData + iOfst);
52054 pOut = pStore->aData;
52057 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
52153 pStore->aData = pData;
57682 ** Parameter aData must point to a buffer of pPager->pageSize bytes
57700 static u32 pager_cksum(Pager *pPager, const u8 *aData){
57704 cksum += aData[i];
57787 char *aData; /* Temporary storage for the page */
57801 aData = pPager->pTmpSpace;
57802 assert( aData ); /* Temp storage must have already been allocated */
57822 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
57841 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
57855 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
57856 pPager->nReserve = ((u8*)aData)[20];
57902 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
57926 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT, aData);
57927 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
57928 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT);
57931 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
57939 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT);
57940 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
57941 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT,aData);
57944 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
57981 memcpy(pData, (u8*)aData, pPager->pageSize);
62663 void *aData = 0;
62664 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
62665 return aData;
64097 u32 *aData = (u32 *)a;
64113 s1 += *aData++ + s2;
64114 s2 += *aData++ + s1;
64115 }while( aData<aEnd );
64118 s1 += BYTESWAP32(aData[0]) + s2;
64119 s2 += BYTESWAP32(aData[1]) + s1;
64120 aData += 2;
64121 }while( aData<aEnd );
64187 u8 *aData, /* Pointer to page data */
64200 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
64211 ** in aData[] is valid. If it is a valid frame, fill *piPage and
64218 u8 *aData, /* Pointer to page data (for checksum) */
64247 walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
64619 u8 *aData; /* Pointer to data part of aFrame buffer */
64677 aData = &aFrame[WAL_FRAME_HDRSIZE];
64678 aPrivate = (u32*)&aData[szPage];
64701 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
65884 u8 *aData; /* Pointer to data part of aFrame buffer */
65979 aData = &aFrame[WAL_FRAME_HDRSIZE];
65997 if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break;
67853 u16 cellOffset; /* Index in aData of first cell pointer */
67861 u8 *aData; /* Pointer to disk image of the page data */
67866 u8 *aDataOfst; /* Same as aData for leaves. aData+4 for interior */
69720 ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)])))
70134 data = pPage->aData;
70249 u8 * const aData = pPg->aData; /* Page data */
70251 u8 *pTmp = &aData[iAddr]; /* Temporary ptr into aData[] */
70262 pTmp = &aData[pc+2];
70270 if( aData[hdr+7]>57 ) return 0;
70274 memcpy(&aData[iAddr], &aData[pc], 2);
70275 aData[hdr+7] += (u8)x;
70276 return &aData[pc];
70284 put2byte(&aData[pc+2], x);
70286 return &aData[pc + x];
70289 pTmp = &aData[pc];
70308 ** as the first argument. Write into *pIdx the index into pPage->aData[]
70321 u8 * const data = pPage->aData; /* Local cache of pPage->aData */
70405 ** Return a section of the pPage->aData to the freelist.
70406 ** The first byte of the new free block is pPage->aData[iStart]
70425 unsigned char *data = pPage->aData; /* Page content */
70603 int pc; /* Address of a freeblock within pPage->aData[] */
70605 u8 *data; /* Equal to pPage->aData */
70617 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
70623 data = pPage->aData;
70689 int pc; /* Address of a freeblock within pPage->aData[] */
70690 u8 *data; /* Equal to pPage->aData */
70697 data = pPage->aData;
70726 u8 *data; /* Equal to pPage->aData */
70734 assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
70738 data = pPage->aData + pPage->hdrOffset;
70749 pPage->aDataEnd = pPage->aData + pBt->pageSize;
70750 pPage->aDataOfst = pPage->aData + pPage->childPtrSize;
70779 unsigned char *data = pPage->aData;
70818 pPage->aData = sqlite3PagerGetData(pDbPage);
70824 assert( pPage->aData==sqlite3PagerGetData(pDbPage) );
70830 ** MemPage.aData elements if needed. See also: btreeGetUnusedPage().
70859 ** MemPage.aData elements if needed.
70927 assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) );
70956 assert( pPage->aData );
70960 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
70969 assert( pPage->aData );
70973 assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
71828 nPage = get4byte(28+(u8*)pPage1->aData);
71830 if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
71839 u8 *page1 = pPage1->aData;
72027 assert( pPage1->aData );
72050 data = pP1->aData;
72272 if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
72275 put4byte(&pPage1->aData[28], pBt->nPage);
72284 *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]);
72331 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
72357 if( get4byte(pPage->aData)!=iFrom ){
72360 put4byte(pPage->aData, iTo);
72376 if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){
72385 if( pCell+4 > pPage->aData+pPage->pBt->usableSize ){
72397 get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
72400 put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
72458 Pgno nextOvfl = get4byte(pDbPage->aData);
72521 nFreeList = get4byte(&pBt->pPage1->aData[36]);
72647 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
72660 put4byte(&pBt->pPage1->aData[28], pBt->nPage);
72705 nFree = get4byte(&pBt->pPage1->aData[36]);
72739 put4byte(&pBt->pPage1->aData[32], 0);
72740 put4byte(&pBt->pPage1->aData[36], 0);
72742 put4byte(&pBt->pPage1->aData[28], nFin);
72976 int nPage = get4byte(&pPage1->aData[28]);
73024 /* The rollback may have destroyed the pPage1->aData value. So
73026 ** sure pPage1->aData is set correctly. */
73188 assert( pBt->pPage1 && pBt->pPage1->aData );
73404 (i64)(pCur->info.pPayload - pCur->pPage->aData);
73506 next = get4byte(pPage->aData);
73608 assert( aPayload > pPage->aData );
73609 if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){
73612 ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
73851 assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
73924 assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
74051 subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
74101 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74331 chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74624 chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74728 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
74900 n = get4byte(&pPage1->aData[36]);
74937 put4byte(&pPage1->aData[36], n-1);
74950 iTrunk = get4byte(&pPrevTrunk->aData[0]);
74955 iTrunk = get4byte(&pPage1->aData[32]);
74968 assert( pTrunk->aData!=0 );
74971 k = get4byte(&pTrunk->aData[4]);
74982 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
75006 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
75012 memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
75020 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
75035 memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
75036 put4byte(&pNewTrunk->aData[4], k-1);
75037 memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
75041 put4byte(&pPage1->aData[32], iNewTrunk);
75047 put4byte(&pPrevTrunk->aData[0], iNewTrunk);
75057 unsigned char *aData = pTrunk->aData;
75063 iPage = get4byte(&aData[8+i*4]);
75071 dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
75073 int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
75084 iPage = get4byte(&aData[8+closest*4]);
75102 memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
75104 put4byte(&aData[4], k-1);
75165 put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
75226 nFree = get4byte(&pPage1->aData[36]);
75227 put4byte(&pPage1->aData[36], nFree+1);
75238 memset(pPage->aData, 0, pPage->pBt->pageSize);
75259 iTrunk = get4byte(&pPage1->aData[32]);
75269 nLeaf = get4byte(&pTrunk->aData[4]);
75297 put4byte(&pTrunk->aData[4], nLeaf+1);
75298 put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
75322 put4byte(pPage->aData, iTrunk);
75323 put4byte(&pPage->aData[4], 0);
75324 put4byte(&pPage1->aData[32], iPage);
75434 ** Note that pCell does not necessary need to point to the pPage->aData
75436 ** be constructed in this temporary area then copied into pPage->aData
75460 assert( pCell<pPage->aData || pCell>=&pPage->aData[pPage->pBt->pageSize]
75545 assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
75605 assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
75611 pPrior = pOvfl->aData;
75613 pPayload = &pOvfl->aData[4];
75631 u8 *data; /* pPage->aData */
75643 data = pPage->aData;
75740 data = pPage->aData;
75753 ** as many as 4 bytes in front of the start of the aData buffer for
75926 u8 * const aData = pPg->aData; /* Pointer to data for pPg */
75928 u8 * const pEnd = &aData[usableSize];
75939 j = get2byte(&aData[hdr+5]);
75941 memcpy(&pTmp[j], &aData[j], usableSize - j);
75951 if( SQLITE_WITHIN(pCell,aData+j,pEnd) ){
75953 pCell = &pTmp[pCell - aData];
75961 put2byte(pCellptr, (pData - aData));
75978 put2byte(&aData[hdr+1], 0);
75979 put2byte(&aData[hdr+3], pPg->nCell);
75980 put2byte(&aData[hdr+5], pData - aData);
75981 aData[hdr+7] = 0x00;
76019 u8 *aData = pPg->aData; /* Complete page */
76020 u8 *pData = *ppData; /* Content area. A subset of aData[] */
76033 if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){
76052 put2byte(pCellptr, (pSlot - aData));
76080 u8 * const aData = pPg->aData;
76081 u8 * const pEnd = &aData[pPg->pBt->usableSize];
76082 u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
76099 assert( pFree>aData && (pFree - aData)<65536 );
76100 freeSpace(pPg, (u16)(pFree - aData), szFree);
76115 assert( pFree>aData && (pFree - aData)<65536 );
76116 freeSpace(pPg, (u16)(pFree - aData), szFree);
76140 u8 * const aData = pPg->aData;
76152 memcpy(pTmp, aData, pPg->pBt->usableSize);
76169 pData = &aData[get2byteNotZero(&aData[hdr+5])];
76215 put2byte(&aData[hdr+3], pPg->nCell);
76216 put2byte(&aData[hdr+5], pData - aData);
76222 if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
76223 pCell = &pTmp[pCell - aData];
76225 assert( 0==memcmp(pCell, &aData[iOff],
76291 assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
76348 put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
76391 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
76420 u8 * const aFrom = pFrom->aData;
76421 u8 * const aTo = pTo->aData;
76473 ** might not actually be stored in MemPage.aData[]. This can happen
76475 ** to the page and its siblings fit into MemPage.aData[] before returning.
76516 int pageFlags; /* Value of pPage->aData[0] */
76579 pRight = &pParent->aData[pParent->hdrOffset+8];
76629 iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
76632 apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
76683 u8 *aData = pOld->aData;
76685 u8 *piCell = aData + pOld->cellOffset;
76692 if( pOld->aData[0]!=apOld[0]->aData[0] ){
76722 b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
76732 piEnd = aData + pOld->cellOffset + 2*pOld->nCell;
76735 b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
76760 memcpy(b.apCell[b.nCell], &pOld->aData[8], 4);
76915 pageFlags = apOld[0]->aData[0];
77013 memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4);
77061 || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd)
77089 memcpy(&pNew->aData[8], pCell, 4);
77219 (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset
77230 u32 key = get4byte(&apNew[i]->aData[8]);
77331 zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF);
77332 put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild);
77559 || pCur->info.pPayload < pPage->aData + pPage->cellOffset
77583 ovflPgno = get4byte(pPage->aData);
77587 rc = btreeOverwriteContent(pPage, pPage->aData+4, pX,
77852 if( oldCell < pPage->aData+pPage->hdrOffset+10 ){
78024 pPgnoOut = pPageOut->aData;
78184 if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT;
78459 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
78470 zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF);
78666 *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
78692 pP1 = pBt->pPage1->aData;
78771 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
79088 data = pPage->aData;
79371 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
79372 get4byte(&pBt->pPage1->aData[36]));
79384 mxInHdr = get4byte(&pBt->pPage1->aData[52]);
79391 }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){
79678 u8 *aData = pBt->pPage1->aData;
79679 if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
79684 aData[18] = (u8)iVersion;
79685 aData[19] = (u8)iVersion;
80438 const u8 *aData
80451 rc = backupOnePage(p, iPage, aData, 1);
80460 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
80461 if( pBackup ) backupUpdate(pBackup, iPage, aData);
189989 char *aData;
190080 int nSize; /* Size of allocation at aData */
190081 int nData; /* Bytes of data in aData */
190082 char *aData; /* Pointer to block from malloc() */
190114 char *aData; /* Node data */
190544 p->aData = (char *)&p[1];
190556 p->aData = (char *)&p[1];
190560 p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i);
190561 p->aData[p->nData] = '\0';
190591 assert( p->aData[p->nData]==0 );
191239 memcpy(aCopy, pList->aData, nCopy);
191949 assert( pTree->aData==(char *)&pTree[1] );
191950 pTree->aData = (char *)sqlite3_malloc64(nReq);
191951 if( !pTree->aData ){
191958 nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nPrefix);
191961 nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nSuffix);
191962 memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix);
192000 pNew->aData = (char *)&pNew[1];
192034 pTree->aData[nStart] = (char)iHeight;
192035 sqlite3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild);
192069 *paRoot = &pTree->aData[nStart];
192078 rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
192102 if( p->aData!=(char *)&p[1] ){
192103 sqlite3_free(p->aData);
192147 pWriter->aData = (char *)sqlite3_malloc64(p->nNodeSize);
192148 if( !pWriter->aData ) return SQLITE_NOMEM;
192183 rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData);
192222 char *aNew = sqlite3_realloc64(pWriter->aData, nReq);
192224 pWriter->aData = aNew;
192230 nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nPrefix);
192231 nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nSuffix);
192233 memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix);
192235 nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nDoclist);
192237 memcpy(&pWriter->aData[nData], aDoclist, nDoclist);
192286 rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData);
192298 0, 0, 0, pWriter->nLeafData, pWriter->aData, pWriter->nData);
192310 sqlite3_free(pWriter->aData);
195452 nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy);
195456 memcpy(pRet, &p->pList->aData[nSkip], *pnData);
204167 sqlite3_value **aData,
204202 /* Populate the cell.aCoord[] array. The first coordinate is aData[3].
204214 cell.aCoord[ii].f = rtreeValueDown(aData[ii+3]);
204215 cell.aCoord[ii+1].f = rtreeValueUp(aData[ii+4]);
204225 cell.aCoord[ii].i = sqlite3_value_int(aData[ii+3]);
204226 cell.aCoord[ii+1].i = sqlite3_value_int(aData[ii+4]);
204236 if( sqlite3_value_type(aData[2])!=SQLITE_NULL ){
204237 cell.iRowid = sqlite3_value_int64(aData[2]);
204238 if( sqlite3_value_type(aData[0])==SQLITE_NULL
204239 || sqlite3_value_int64(aData[0])!=cell.iRowid
204258 /* If aData[0] is not an SQL NULL value, it is the rowid of a
204262 if( sqlite3_value_type(aData[0])!=SQLITE_NULL ){
204263 rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(aData[0]));
204266 /* If the aData[] array contains more than one element, elements
204267 ** (aData[2]..aData[argc-1]) contain a new record to insert into
204297 sqlite3_bind_value(pUp, jj+2, aData[pRtree->nDim2+3+jj]);
206933 sqlite3_value **aData,
206954 oldRowidValid = sqlite3_value_type(aData[0])!=SQLITE_NULL;;
206955 oldRowid = oldRowidValid ? sqlite3_value_int64(aData[0]) : 0;
206956 newRowidValid = nData>1 && sqlite3_value_type(aData[1])!=SQLITE_NULL;
206957 newRowid = newRowidValid ? sqlite3_value_int64(aData[1]) : 0;
206962 || !sqlite3_value_nochange(aData[2]) /* UPDATE _shape */
206965 assert( aData[2]!=0 );
206966 geopolyBBox(0, aData[2], cell.aCoord, &rc);
206993 /* If aData[0] is not an SQL NULL value, it is the rowid of a
207001 /* If the aData[] array contains more than one element, elements
207002 ** (aData[2]..aData[argc-1]) contain a new record to insert into
207033 if( sqlite3_value_nochange(aData[2]) ){
207037 if( sqlite3_value_type(aData[2])==SQLITE_TEXT
207038 && (p = geopolyFuncParam(0, aData[2], &rc))!=0
207043 sqlite3_bind_value(pUp, 2, aData[2]);
207050 sqlite3_bind_value(pUp, jj+2, aData[jj+2]);
214584 u8 *aData = p->aPg;
214585 u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
214608 nUnused += get2byte(&aData[iOff+2]);
214609 iNext = get2byte(&aData[iOff]);
214630 iOff = get2byte(&aData[nHdr+i*2]);
214633 pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
214641 iOff += getVarint32(&aData[iOff], nPayload);
214644 iOff += sqlite3GetVarint(&aData[iOff], &dummy);
214662 pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
215592 int iCurrent; /* Offset in aData[] of current change */
215593 int iNext; /* Offset in aData[] of next change */
215594 u8 *aData; /* Pointer to buffer containing changeset */
215595 int nData; /* Number of bytes in aData */
218349 pRet->in.aData = (u8 *)pChangeset;
218442 pIn->aData = pIn->buf.aBuf;
218476 ** first argument to a copy of the string or blob held in the aData[]
218482 u8 *aData, /* Buffer containing string or blob data */
218483 int nData, /* Size of buffer aData[] in bytes */
218492 memcpy(aCopy, aData, nData);
218541 eType = pIn->aData[pIn->iNext++];
218552 u8 *aVal = &pIn->aData[pIn->iNext];
218562 rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc);
218608 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
218625 while( (pIn->iNext + nRead)<pIn->nData && pIn->aData[pIn->iNext + nRead] ){
218656 eType = pIn->aData[pIn->iNext + nByte++];
218659 nByte += sessionVarintGet(&pIn->aData[pIn->iNext+nByte], &n);
218697 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
218712 memcpy(&p->tblhdr.aBuf[iPK], &p->in.aData[p->in.iNext], nCopy);
218776 op = p->in.aData[p->in.iNext++];
218784 op = p->in.aData[p->in.iNext++];
218795 p->bIndirect = p->in.aData[p->in.iNext++];
218812 *paRec = &p->in.aData[p->in.iNext];
219108 eType = pInput->aData[pInput->iNext];
219125 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
219127 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
219129 sessionAppendBlob(&sOut, &pInput->aData[pInput->iNext], nByte, &rc);
219142 int bIndirect = pInput->aData[pInput->iNext+1];
219149 sessionAppendBlob(&sOut, &pInput->aData[pInput->iNext], nByte, &rc);
219169 sessionAppendByte(&sOut, pInput->aData[pInput->iNext+1], &rc);
219249 sInput.aData = (u8*)pChangeset;
219856 u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
234108 const u8 *aData,
234112 const u8 *a = aData;