Lines Matching refs:pCell
47629 u8 *pCell; /* Pointers to the body of the overflow cell */
47792 u8 *pCell; /* Pointer to the start of cell content */
49139 return pOvfl->pCell;
49158 u8 *pCell, /* Pointer to the cell text. */
49166 pInfo->pCell = pCell;
49172 n += getVarint32(&pCell[n], nPayload);
49176 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
49180 n += getVarint32(&pCell[n], nPayload);
49238 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
49239 u8 *pIter = &pCell[pPage->childPtrSize];
49248 btreeParseCellPtr(pPage, pCell, &debuginfo);
49280 nSize += (u32)(pIter - pCell);
49301 ** If the cell pCell, part of page pPage contains a pointer
49305 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
49308 assert( pCell!=0 );
49309 btreeParseCellPtr(pPage, pCell, &info);
49312 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
50952 u8 *pCell = findCell(pPage, i);
50954 ptrmapPutOvflPtr(pPage, pCell, &rc);
50957 Pgno childPgno = get4byte(pCell);
51004 u8 *pCell = findCell(pPage, i);
51007 btreeParseCellPtr(pPage, pCell, &info);
51009 && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
51010 && iFrom==get4byte(&pCell[info.iOverflow])
51012 put4byte(&pCell[info.iOverflow], iTo);
51016 if( get4byte(pCell)==iFrom ){
51017 put4byte(pCell, iTo);
52113 aPayload = pCur->info.pCell + pCur->info.nHeader;
52312 aPayload = pCur->info.pCell;
52744 u8 *pCell; /* Pointer to current cell in pPage */
52748 pCell = findCell(pPage, idx) + pPage->childPtrSize;
52753 pCell += getVarint32(pCell, dummy);
52755 getVarint(pCell, (u64*)&nCellKey);
52775 int nCell = pCell[0];
52780 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
52781 }else if( !(pCell[1] & 0x80)
52782 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
52786 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
52793 u8 * const pCellBody = pCell - pPage->childPtrSize;
53432 static int clearCell(MemPage *pPage, unsigned char *pCell){
53441 btreeParseCellPtr(pPage, pCell, &info);
53445 if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
53448 ovflPgno = get4byte(&pCell[info.iOverflow]);
53496 ** and write that byte sequence into pCell[]. Overflow pages are
53499 ** for pCell[].
53501 ** Note that pCell does not necessary need to point to the pPage->aData
53502 ** area. pCell might point to some temporary storage. The cell will
53508 unsigned char *pCell, /* Complete text of the cell */
53529 /* pPage is not necessarily writeable since pCell might be auxiliary
53531 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
53540 nHeader += putVarint(&pCell[nHeader], nData+nZero);
53544 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
53545 btreeParseCellPtr(pPage, pCell, &info);
53566 pPayload = &pCell[nHeader];
53567 pPrior = &pCell[info.iOverflow];
53705 ** Insert a new cell on pPage at cell index "i". pCell points to the
53712 ** in pTemp or the original pCell) and also record its index.
53718 ** nSkip is non-zero, then pCell may not point to an invalid memory location
53719 ** (but pCell+nSkip is always valid).
53724 u8 *pCell, /* Content of the new cell */
53725 int sz, /* Bytes of content in pCell */
53726 u8 *pTemp, /* Temp storage space for pCell, if needed */
53752 assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
53755 memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
53756 pCell = pTemp;
53759 put4byte(pCell, iChild);
53763 pPage->aOvfl[j].pCell = pCell;
53784 memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
53802 ptrmapPutOvflPtr(pPage, pCell, pRC);
53912 u8 *pCell = pPage->aOvfl[0].pCell;
53913 u16 szCell = cellSizePtr(pPage, pCell);
53919 assemblePage(pNew, 1, &pCell, &szCell);
53933 ptrmapPutOvflPtr(pNew, pCell, &rc);
53950 pCell = findCell(pPage, pPage->nCell-1);
53951 pStop = &pCell[9];
53952 while( (*(pCell++)&0x80) && pCell<pStop );
53953 pStop = &pCell[9];
53954 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
54207 apDiv[i] = pParent->aOvfl[0].pCell;
54524 u8 *pCell;
54529 pCell = apCell[j];
54533 memcpy(&pNew->aData[8], pCell, 4);
54543 pCell = pTemp;
54544 sz = 4 + putVarint(&pCell[4], info.nKey);
54547 pCell -= 4;
54548 /* Obscure case for non-leaf-data trees: If the cell at pCell was
54561 sz = cellSizePtr(pParent, pCell);
54567 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
55084 unsigned char *pCell; /* Pointer to cell to delete */
55086 int iCellDepth; /* Depth of node containing pCell */
55110 pCell = findCell(pPage, iCellIdx);
55134 rc = clearCell(pPage, pCell);
55135 dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
55149 pCell = findCell(pLeaf, pLeaf->nCell-1);
55150 nCell = cellSizePtr(pLeaf, pCell);
55157 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
55357 unsigned char *pCell;
55368 pCell = findCell(pPage, i);
55370 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
55373 rc = clearCell(pPage, pCell);
55923 u8 *pCell;
55931 pCell = findCell(pPage,i);
55932 btreeParseCellPtr(pPage, pCell, &info);
55947 && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
55950 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
55962 pgno = get4byte(pCell);
127579 ** Overwrite cell iCell of node pNode with the contents of pCell.
127584 RtreeCell *pCell,
127589 p += writeInt64(p, pCell->iRowid);
127591 p += writeCoord(p, &pCell->aCoord[ii]);
127609 ** Insert the contents of cell pCell into node pNode. If the insert
127618 RtreeCell *pCell
127628 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
127717 ** to by pCell with the results.
127723 RtreeCell *pCell
127726 pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
127728 nodeGetCoord(pRtree, pNode, iCell, ii, &pCell->aCoord[ii]);
127896 RtreeCell *pCell, /* Cell to test */
127907 aCoord[i] = DCOORD(pCell->aCoord[i]);
128509 ** Return the amount cell p would grow by if it were unioned with pCell.
128511 static float cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
128516 cellUnion(pRtree, &cell, pCell);
128586 RtreeCell *pCell, /* Cell to insert into rtree */
128587 int iHeight, /* Height of sub-tree rooted at pCell */
128625 /* Select the child node which will be enlarged the least if pCell
128635 growth = cellGrowth(pRtree, &cell, pCell);
128640 overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
128673 ** A cell with the same content as pCell has just been inserted into
128680 RtreeCell *pCell /* This cell was just inserted */
128693 if( !cellContains(pRtree, &cell, pCell) ){
128694 cellUnion(pRtree, &cell, pCell);
129106 RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
129107 nodeInsertCell(pRtree, pTarget, pCell);
129108 cellUnion(pRtree, pBbox, pCell);
129194 RtreeCell *pCell,
129211 /* Allocate an array and populate it with a copy of pCell and
129225 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
129291 if( iRowid==pCell->iRowid ){
129307 rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
129479 RtreeCell *pCell,
129514 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
129543 if( p->iRowid==pCell->iRowid ){
129576 ** Insert cell pCell into node pNode. Node pNode is the head of a
129582 RtreeCell *pCell,
129587 RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
129594 if( nodeInsertCell(pRtree, pNode, pCell) ){
129597 rc = SplitNode(pRtree, pNode, pCell, iHeight);
129600 rc = Reinsert(pRtree, pNode, pCell, iHeight);
129603 rc = SplitNode(pRtree, pNode, pCell, iHeight);
129606 rc = AdjustTree(pRtree, pNode, pCell);
129609 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
129611 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);