Lines Matching refs:pCell
65430 u8 *pCell, /* Pointer to the cell text. */
65456 pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4;
65475 u8 *pCell, /* Pointer to the cell text. */
65484 pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey);
65492 u8 *pCell, /* Pointer to the cell text. */
65503 pIter = pCell;
65551 pInfo->nSize = nPayload + (u16)(pIter - pCell);
65555 btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo);
65560 u8 *pCell, /* Pointer to the cell text. */
65569 pIter = pCell + pPage->childPtrSize;
65588 pInfo->nSize = nPayload + (u16)(pIter - pCell);
65592 btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo);
65615 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
65616 u8 *pIter = pCell + pPage->childPtrSize; /* For looping over bytes of pCell */
65626 pPage->xParseCell(pPage, pCell, &debuginfo);
65648 nSize += (u32)(pIter - pCell);
65658 nSize += 4 + (u16)(pIter - pCell);
65663 static u16 cellSizePtrNoPayload(MemPage *pPage, u8 *pCell){
65664 u8 *pIter = pCell + 4; /* For looping over bytes of pCell */
65673 pPage->xParseCell(pPage, pCell, &debuginfo);
65681 assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
65682 return (u16)(pIter - pCell);
65701 static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){
65704 assert( pCell!=0 );
65705 pPage->xParseCell(pPage, pCell, &info);
65708 if( SQLITE_WITHIN(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){
65713 ovfl = get4byte(&pCell[info.nSize-4]);
67891 u8 *pCell = findCell(pPage, i);
67893 ptrmapPutOvflPtr(pPage, pPage, pCell, &rc);
67896 Pgno childPgno = get4byte(pCell);
67942 u8 *pCell = findCell(pPage, i);
67945 pPage->xParseCell(pPage, pCell, &info);
67947 if( pCell+info.nSize > pPage->aData+pPage->pBt->usableSize ){
67950 if( iFrom==get4byte(pCell+info.nSize-4) ){
67951 put4byte(pCell+info.nSize-4, iTo);
67956 if( get4byte(pCell)==iFrom ){
67957 put4byte(pCell, iTo);
69816 u8 *pCell; /* Pointer to current cell in pPage */
69834 pCell = findCellPastPtr(pPage, idx);
69836 while( 0x80 <= *(pCell++) ){
69837 if( pCell>=pPage->aDataEnd ){
69842 getVarint(pCell, (u64*)&nCellKey);
69869 pCell = findCellPastPtr(pPage, idx);
69879 nCell = pCell[0];
69884 testcase( pCell+nCell+1==pPage->aDataEnd );
69885 c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
69886 }else if( !(pCell[1] & 0x80)
69887 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
69891 testcase( pCell+nCell+2==pPage->aDataEnd );
69892 c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
69904 u8 * const pCellBody = pCell - pPage->childPtrSize;
70700 unsigned char *pCell, /* First byte of the Cell */
70710 pPage->xParseCell(pPage, pCell, pInfo);
70714 testcase( pCell + pInfo->nSize == pPage->aDataEnd );
70715 testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd );
70716 if( pCell + pInfo->nSize > pPage->aDataEnd ){
70720 ovflPgno = get4byte(pCell + pInfo->nSize - 4);
70783 unsigned char *pCell, /* Complete text of the cell */
70802 assert( pCell<pPage->aData || pCell>=&pPage->aData[pPage->pBt->pageSize]
70812 nHeader += putVarint32(&pCell[nHeader], nPayload);
70813 nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey);
70818 nHeader += putVarint32(&pCell[nHeader], nPayload);
70822 pPayload = &pCell[nHeader];
70848 pPrior = &pCell[nHeader+n];
70868 pPage->xParseCell(pPage, pCell, &info);
70869 assert( nHeader==(int)(info.pPayload - pCell) );
71030 u8 *pCell, /* Content of the new cell */
71048 assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB );
71052 memcpy(pTemp, pCell, sz);
71053 pCell = pTemp;
71056 put4byte(pCell, iChild);
71063 pPage->apOvfl[j] = pCell;
71096 memcpy(&data[idx+4], pCell+4, sz-4);
71099 memcpy(&data[idx], pCell, sz);
71113 ptrmapPutOvflPtr(pPage, pPage, pCell, pRC);
71288 u8 *pCell = pCArray->apCell[i];
71291 if( SQLITE_WITHIN(pCell,aData,pEnd) ){
71292 if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT;
71293 pCell = &pTmp[pCell - aData];
71294 }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd
71295 && (uptr)(pCell)<(uptr)pSrcEnd
71304 memcpy(pData, pCell, sz);
71305 assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
71306 testcase( sz!=pPg->xCellSize(pPg,pCell) )
71431 u8 *pCell = pCArray->apCell[i];
71432 if( SQLITE_WITHIN(pCell, pStart, pEnd) ){
71438 if( pFree!=(pCell + sz) ){
71443 pFree = pCell;
71447 pFree = pCell;
71558 u8 *pCell = pCArray->apCell[i+iNew];
71560 if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
71561 pCell = &pTmp[pCell - aData];
71563 assert( 0==memcmp(pCell, &aData[iOff],
71623 u8 *pCell = pPage->apOvfl[0];
71624 u16 szCell = pPage->xCellSize(pPage, pCell);
71633 b.apCell = &pCell;
71656 ptrmapPutOvflPtr(pNew, pNew, pCell, &rc);
71673 pCell = findCell(pPage, pPage->nCell-1);
71674 pStop = &pCell[9];
71675 while( (*(pCell++)&0x80) && pCell<pStop );
71676 pStop = &pCell[9];
71677 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
72379 u8 *pCell = b.apCell[i];
72400 || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd)
72403 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
72406 ptrmapPutOvflPtr(pNew, pOld, pCell, &rc);
72415 u8 *pCell;
72423 pCell = b.apCell[j];
72427 memcpy(&pNew->aData[8], pCell, 4);
72437 pCell = pTemp;
72438 sz = 4 + putVarint(&pCell[4], info.nKey);
72441 pCell -= 4;
72455 sz = pParent->xCellSize(pParent, pCell);
72461 insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc);
73238 unsigned char *pCell; /* Pointer to cell to delete */
73261 pCell = findCell(pPage, iCellIdx);
73275 || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3)
73318 rc = clearCell(pPage, pCell, &info);
73342 pCell = findCell(pLeaf, pLeaf->nCell-1);
73343 if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT;
73344 nCell = pLeaf->xCellSize(pLeaf, pCell);
73350 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
73580 unsigned char *pCell;
73598 pCell = findCell(pPage, i);
73600 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
73603 rc = clearCell(pPage, pCell, &info);
74193 u8 *pCell; /* Cell content */
74288 pCell = &data[pc];
74289 pPage->xParseCell(pPage, pCell, &info);
74311 pgnoOvfl = get4byte(&pCell[info.nSize - 4]);
74322 pgno = get4byte(pCell);
187976 RtreeCell *pCell, /* The cell to write */
187981 p += writeInt64(p, pCell->iRowid);
187983 p += writeCoord(p, &pCell->aCoord[ii]);
188009 RtreeCell *pCell /* The cell to be inserted */
188019 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
188115 RtreeCell *pCell /* OUT: Write the cell contents here */
188120 pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
188122 pCoord = pCell->aCoord;
189306 static RtreeDValue cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
189311 cellUnion(pRtree, &cell, pCell);
189349 RtreeCell *pCell, /* Cell to insert into rtree */
189380 growth = cellGrowth(pRtree, &cell, pCell);
189410 RtreeCell *pCell /* This cell was just inserted */
189425 if( !cellContains(pRtree, &cell, pCell) ){
189426 cellUnion(pRtree, &cell, pCell);
189688 RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
189689 nodeInsertCell(pRtree, pTarget, pCell);
189690 cellUnion(pRtree, pBbox, pCell);
189720 RtreeCell *pCell,
189751 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
189818 if( iRowid==pCell->iRowid ){
189834 rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
190009 RtreeCell *pCell,
190046 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
190075 if( p->iRowid==pCell->iRowid ){
190114 RtreeCell *pCell,
190119 RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
190126 if( nodeInsertCell(pRtree, pNode, pCell) ){
190128 rc = SplitNode(pRtree, pNode, pCell, iHeight);
190131 rc = Reinsert(pRtree, pNode, pCell, iHeight);
190134 rc = AdjustTree(pRtree, pNode, pCell);
190137 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
190139 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
191272 u8 *pCell, /* Pointer to cell coordinates */
191280 readCoord(&pCell[4*2*i], &c1);
191281 readCoord(&pCell[4*(2*i + 1)], &c2);
191351 u8 *pCell = &aNode[4 + i*(8 + pCheck->nDim*2*4)];
191352 i64 iVal = readInt64(pCell);
191353 rtreeCheckCellCoord(pCheck, iNode, i, &pCell[8], aParent);
191357 rtreeCheckNode(pCheck, iDepth-1, &pCell[8], iVal);
200696 StatCell *pCell = &p->aCell[i];
200701 pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
200717 pCell->nLocal = nLocal;
200726 pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
200727 pCell->nOvfl = nOvfl;
200728 pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
200729 if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;
200730 pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
200733 u32 iPrev = pCell->aOvfl[j-1];
200740 pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
200830 StatCell *pCell = &p->aCell[p->iCell];
200831 while( pCell->iOvfl<pCell->nOvfl ){
200839 if( pCell->iOvfl<pCell->nOvfl-1 ){
200842 pCsr->nPayload += pCell->nLastOvfl;
200843 pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl;
200845 iOvfl = pCell->iOvfl;
200846 pCell->iOvfl++;
200849 pCsr->iPageno = pCell->aOvfl[iOvfl];