Lines Matching refs:pCell
48923 u8 *pCell; /* Pointer to the start of cell content */
50287 u8 *pCell, /* Pointer to the cell text. */
50295 pInfo->pCell = pCell;
50301 n += getVarint32(&pCell[n], nPayload);
50305 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
50309 n += getVarint32(&pCell[n], nPayload);
50367 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
50368 u8 *pIter = &pCell[pPage->childPtrSize];
50377 btreeParseCellPtr(pPage, pCell, &debuginfo);
50409 nSize += (u32)(pIter - pCell);
50430 ** If the cell pCell, part of page pPage contains a pointer
50434 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
50437 assert( pCell!=0 );
50438 btreeParseCellPtr(pPage, pCell, &info);
50441 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
52097 u8 *pCell = findCell(pPage, i);
52099 ptrmapPutOvflPtr(pPage, pCell, &rc);
52102 Pgno childPgno = get4byte(pCell);
52149 u8 *pCell = findCell(pPage, i);
52152 btreeParseCellPtr(pPage, pCell, &info);
52154 && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
52155 && iFrom==get4byte(&pCell[info.iOverflow])
52157 put4byte(&pCell[info.iOverflow], iTo);
52161 if( get4byte(pCell)==iFrom ){
52162 put4byte(pCell, iTo);
53256 aPayload = pCur->info.pCell + pCur->info.nHeader;
53489 aPayload = pCur->info.pCell;
53931 u8 *pCell; /* Pointer to current cell in pPage */
53935 pCell = findCell(pPage, idx) + pPage->childPtrSize;
53940 pCell += getVarint32(pCell, dummy);
53942 getVarint(pCell, (u64*)&nCellKey);
53962 int nCell = pCell[0];
53964 /* && (pCell+nCell)<pPage->aDataEnd */
53969 testcase( pCell+nCell+1==pPage->aDataEnd );
53970 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
53971 }else if( !(pCell[1] & 0x80)
53972 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
53973 /* && (pCell+nCell+2)<=pPage->aDataEnd */
53977 testcase( pCell+nCell+2==pPage->aDataEnd );
53978 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
53985 u8 * const pCellBody = pCell - pPage->childPtrSize;
54631 static int clearCell(MemPage *pPage, unsigned char *pCell){
54640 btreeParseCellPtr(pPage, pCell, &info);
54644 if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
54647 ovflPgno = get4byte(&pCell[info.iOverflow]);
54695 ** and write that byte sequence into pCell[]. Overflow pages are
54698 ** for pCell[].
54700 ** Note that pCell does not necessary need to point to the pPage->aData
54701 ** area. pCell might point to some temporary storage. The cell will
54707 unsigned char *pCell, /* Complete text of the cell */
54728 /* pPage is not necessarily writeable since pCell might be auxiliary
54730 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
54739 nHeader += putVarint(&pCell[nHeader], nData+nZero);
54743 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
54744 btreeParseCellPtr(pPage, pCell, &info);
54765 pPayload = &pCell[nHeader];
54766 pPrior = &pCell[info.iOverflow];
54904 ** Insert a new cell on pPage at cell index "i". pCell points to the
54911 ** in pTemp or the original pCell) and also record its index.
54917 ** nSkip is non-zero, then pCell may not point to an invalid memory location
54918 ** (but pCell+nSkip is always valid).
54923 u8 *pCell, /* Content of the new cell */
54924 int sz, /* Bytes of content in pCell */
54925 u8 *pTemp, /* Temp storage space for pCell, if needed */
54952 assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
54955 memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
54956 pCell = pTemp;
54959 put4byte(pCell, iChild);
54963 pPage->apOvfl[j] = pCell;
54984 memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
55002 ptrmapPutOvflPtr(pPage, pCell, pRC);
55112 u8 *pCell = pPage->apOvfl[0];
55113 u16 szCell = cellSizePtr(pPage, pCell);
55119 assemblePage(pNew, 1, &pCell, &szCell);
55133 ptrmapPutOvflPtr(pNew, pCell, &rc);
55150 pCell = findCell(pPage, pPage->nCell-1);
55151 pStop = &pCell[9];
55152 while( (*(pCell++)&0x80) && pCell<pStop );
55153 pStop = &pCell[9];
55154 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
55732 u8 *pCell;
55737 pCell = apCell[j];
55741 memcpy(&pNew->aData[8], pCell, 4);
55751 pCell = pTemp;
55752 sz = 4 + putVarint(&pCell[4], info.nKey);
55755 pCell -= 4;
55756 /* Obscure case for non-leaf-data trees: If the cell at pCell was
55769 sz = cellSizePtr(pParent, pCell);
55775 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
56297 unsigned char *pCell; /* Pointer to cell to delete */
56299 int iCellDepth; /* Depth of node containing pCell */
56323 pCell = findCell(pPage, iCellIdx);
56347 rc = clearCell(pPage, pCell);
56348 dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
56362 pCell = findCell(pLeaf, pLeaf->nCell-1);
56363 nCell = cellSizePtr(pLeaf, pCell);
56370 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
56570 unsigned char *pCell;
56581 pCell = findCell(pPage, i);
56583 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
56586 rc = clearCell(pPage, pCell);
57138 u8 *pCell;
57146 pCell = findCell(pPage,i);
57147 btreeParseCellPtr(pPage, pCell, &info);
57162 && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
57165 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
57177 pgno = get4byte(pCell);
130711 ** Overwrite cell iCell of node pNode with the contents of pCell.
130716 RtreeCell *pCell,
130721 p += writeInt64(p, pCell->iRowid);
130723 p += writeCoord(p, &pCell->aCoord[ii]);
130741 ** Insert the contents of cell pCell into node pNode. If the insert
130750 RtreeCell *pCell
130760 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
130849 ** to by pCell with the results.
130855 RtreeCell *pCell
130858 pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
130860 nodeGetCoord(pRtree, pNode, iCell, ii, &pCell->aCoord[ii]);
131028 RtreeCell *pCell, /* Cell to test */
131039 aCoord[i] = DCOORD(pCell->aCoord[i]);
131642 ** Return the amount cell p would grow by if it were unioned with pCell.
131644 static float cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
131649 cellUnion(pRtree, &cell, pCell);
131719 RtreeCell *pCell, /* Cell to insert into rtree */
131720 int iHeight, /* Height of sub-tree rooted at pCell */
131761 /* Select the child node which will be enlarged the least if pCell
131770 growth = cellGrowth(pRtree, &cell, pCell);
131775 overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
131810 ** A cell with the same content as pCell has just been inserted into
131817 RtreeCell *pCell /* This cell was just inserted */
131830 if( !cellContains(pRtree, &cell, pCell) ){
131831 cellUnion(pRtree, &cell, pCell);
132243 RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
132244 nodeInsertCell(pRtree, pTarget, pCell);
132245 cellUnion(pRtree, pBbox, pCell);
132331 RtreeCell *pCell,
132348 /* Allocate an array and populate it with a copy of pCell and
132362 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
132428 if( iRowid==pCell->iRowid ){
132444 rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
132616 RtreeCell *pCell,
132651 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
132680 if( p->iRowid==pCell->iRowid ){
132713 ** Insert cell pCell into node pNode. Node pNode is the head of a
132719 RtreeCell *pCell,
132724 RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
132731 if( nodeInsertCell(pRtree, pNode, pCell) ){
132734 rc = SplitNode(pRtree, pNode, pCell, iHeight);
132737 rc = Reinsert(pRtree, pNode, pCell, iHeight);
132740 rc = SplitNode(pRtree, pNode, pCell, iHeight);
132743 rc = AdjustTree(pRtree, pNode, pCell);
132746 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
132748 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
