Lines Matching defs:pCell
46489 u8 *pCell; /* Pointers to the body of the overflow cell */
46652 u8 *pCell; /* Pointer to the start of cell content */
47988 return pOvfl->pCell;
48007 u8 *pCell, /* Pointer to the cell text. */
48015 pInfo->pCell = pCell;
48021 n += getVarint32(&pCell[n], nPayload);
48025 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
48029 n += getVarint32(&pCell[n], nPayload);
48087 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
48088 u8 *pIter = &pCell[pPage->childPtrSize];
48097 btreeParseCellPtr(pPage, pCell, &debuginfo);
48129 nSize += (u32)(pIter - pCell);
48150 ** If the cell pCell, part of page pPage contains a pointer
48154 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
48157 assert( pCell!=0 );
48158 btreeParseCellPtr(pPage, pCell, &info);
48161 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
49801 u8 *pCell = findCell(pPage, i);
49803 ptrmapPutOvflPtr(pPage, pCell, &rc);
49806 Pgno childPgno = get4byte(pCell);
49853 u8 *pCell = findCell(pPage, i);
49856 btreeParseCellPtr(pPage, pCell, &info);
49858 if( iFrom==get4byte(&pCell[info.iOverflow]) ){
49859 put4byte(&pCell[info.iOverflow], iTo);
49864 if( get4byte(pCell)==iFrom ){
49865 put4byte(pCell, iTo);
50960 aPayload = pCur->info.pCell + pCur->info.nHeader;
51159 aPayload = pCur->info.pCell;
51589 u8 *pCell; /* Pointer to current cell in pPage */
51592 pCell = findCell(pPage, idx) + pPage->childPtrSize;
51597 pCell += getVarint32(pCell, dummy);
51599 getVarint(pCell, (u64*)&nCellKey);
51619 int nCell = pCell[0];
51624 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
51625 }else if( !(pCell[1] & 0x80)
51626 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
51630 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
51637 u8 * const pCellBody = pCell - pPage->childPtrSize;
52276 static int clearCell(MemPage *pPage, unsigned char *pCell){
52285 btreeParseCellPtr(pPage, pCell, &info);
52289 ovflPgno = get4byte(&pCell[info.iOverflow]);
52337 ** and write that byte sequence into pCell[]. Overflow pages are
52340 ** for pCell[].
52342 ** Note that pCell does not necessary need to point to the pPage->aData
52343 ** area. pCell might point to some temporary storage. The cell will
52349 unsigned char *pCell, /* Complete text of the cell */
52370 /* pPage is not necessarily writeable since pCell might be auxiliary
52372 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
52381 nHeader += putVarint(&pCell[nHeader], nData+nZero);
52385 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
52386 btreeParseCellPtr(pPage, pCell, &info);
52407 pPayload = &pCell[nHeader];
52408 pPrior = &pCell[info.iOverflow];
52544 ** Insert a new cell on pPage at cell index "i". pCell points to the
52551 ** in pTemp or the original pCell) and also record its index.
52557 ** nSkip is non-zero, then pCell may not point to an invalid memory location
52558 ** (but pCell+nSkip is always valid).
52563 u8 *pCell, /* Content of the new cell */
52564 int sz, /* Bytes of content in pCell */
52565 u8 *pTemp, /* Temp storage space for pCell, if needed */
52590 assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
52593 memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
52594 pCell = pTemp;
52597 put4byte(pCell, iChild);
52601 pPage->aOvfl[j].pCell = pCell;
52622 memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
52637 ptrmapPutOvflPtr(pPage, pCell, pRC);
52746 u8 *pCell = pPage->aOvfl[0].pCell;
52747 u16 szCell = cellSizePtr(pPage, pCell);
52753 assemblePage(pNew, 1, &pCell, &szCell);
52767 ptrmapPutOvflPtr(pNew, pCell, &rc);
52784 pCell = findCell(pPage, pPage->nCell-1);
52785 pStop = &pCell[9];
52786 while( (*(pCell++)&0x80) && pCell<pStop );
52787 pStop = &pCell[9];
52788 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
53041 apDiv[i] = pParent->aOvfl[0].pCell;
53346 u8 *pCell;
53351 pCell = apCell[j];
53355 memcpy(&pNew->aData[8], pCell, 4);
53365 pCell = pTemp;
53366 sz = 4 + putVarint(&pCell[4], info.nKey);
53369 pCell -= 4;
53370 /* Obscure case for non-leaf-data trees: If the cell at pCell was
53383 sz = cellSizePtr(pParent, pCell);
53389 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
53906 unsigned char *pCell; /* Pointer to cell to delete */
53908 int iCellDepth; /* Depth of node containing pCell */
53932 pCell = findCell(pPage, iCellIdx);
53956 rc = clearCell(pPage, pCell);
53957 dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
53971 pCell = findCell(pLeaf, pLeaf->nCell-1);
53972 nCell = cellSizePtr(pLeaf, pCell);
53979 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
54179 unsigned char *pCell;
54190 pCell = findCell(pPage, i);
54192 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
54195 rc = clearCell(pPage, pCell);
54740 u8 *pCell;
54748 pCell = findCell(pPage,i);
54749 btreeParseCellPtr(pPage, pCell, &info);
54764 && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
54767 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
54779 pgno = get4byte(pCell);
111527 const unsigned char *pCell; /* Pointer to data at iCellOffset. */
111556 pCell = PageData(pCursor->pPage, iCellOffset);
111565 if( !checkVarints(pCell, nCellMaxBytes, 3) ){
111569 nRead = getVarint(pCell, &nRecordBytes);
111573 nRead += getVarint(pCell + nRead, &iRowid);
111599 nRecordHeaderRead = getVarint(pCell + nRead, &nRecordHeaderBytes);
124807 ** Overwrite cell iCell of node pNode with the contents of pCell.
124812 RtreeCell *pCell,
124817 p += writeInt64(p, pCell->iRowid);
124819 p += writeCoord(p, &pCell->aCoord[ii]);
124837 ** Insert the contents of cell pCell into node pNode. If the insert
124846 RtreeCell *pCell
124856 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
124945 ** to by pCell with the results.
124951 RtreeCell *pCell
124954 pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
124956 nodeGetCoord(pRtree, pNode, iCell, ii, &pCell->aCoord[ii]);
125124 RtreeCell *pCell, /* Cell to test */
125135 aCoord[i] = DCOORD(pCell->aCoord[i]);
125737 ** Return the amount cell p would grow by if it were unioned with pCell.
125739 static float cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
125744 cellUnion(pRtree, &cell, pCell);
125814 RtreeCell *pCell, /* Cell to insert into rtree */
125815 int iHeight, /* Height of sub-tree rooted at pCell */
125853 /* Select the child node which will be enlarged the least if pCell
125863 growth = cellGrowth(pRtree, &cell, pCell);
125868 overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
125901 ** A cell with the same content as pCell has just been inserted into
125908 RtreeCell *pCell /* This cell was just inserted */
125921 if( !cellContains(pRtree, &cell, pCell) ){
125922 cellUnion(pRtree, &cell, pCell);
126334 RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
126335 nodeInsertCell(pRtree, pTarget, pCell);
126336 cellUnion(pRtree, pBbox, pCell);
126422 RtreeCell *pCell,
126439 /* Allocate an array and populate it with a copy of pCell and
126453 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
126519 if( iRowid==pCell->iRowid ){
126535 rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
126707 RtreeCell *pCell,
126742 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
126771 if( p->iRowid==pCell->iRowid ){
126804 ** Insert cell pCell into node pNode. Node pNode is the head of a
126810 RtreeCell *pCell,
126815 RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
126822 if( nodeInsertCell(pRtree, pNode, pCell) ){
126825 rc = SplitNode(pRtree, pNode, pCell, iHeight);
126828 rc = Reinsert(pRtree, pNode, pCell, iHeight);
126831 rc = SplitNode(pRtree, pNode, pCell, iHeight);
126834 rc = AdjustTree(pRtree, pNode, pCell);
126837 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
126839 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);