Lines Matching refs:pCell
48895 u8 *pCell; /* Pointer to the start of cell content */
50259 u8 *pCell, /* Pointer to the cell text. */
50267 pInfo->pCell = pCell;
50273 n += getVarint32(&pCell[n], nPayload);
50277 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
50281 n += getVarint32(&pCell[n], nPayload);
50339 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
50340 u8 *pIter = &pCell[pPage->childPtrSize];
50349 btreeParseCellPtr(pPage, pCell, &debuginfo);
50381 nSize += (u32)(pIter - pCell);
50402 ** If the cell pCell, part of page pPage contains a pointer
50406 static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
50409 assert( pCell!=0 );
50410 btreeParseCellPtr(pPage, pCell, &info);
50413 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
52069 u8 *pCell = findCell(pPage, i);
52071 ptrmapPutOvflPtr(pPage, pCell, &rc);
52074 Pgno childPgno = get4byte(pCell);
52121 u8 *pCell = findCell(pPage, i);
52124 btreeParseCellPtr(pPage, pCell, &info);
52126 && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
52127 && iFrom==get4byte(&pCell[info.iOverflow])
52129 put4byte(&pCell[info.iOverflow], iTo);
52133 if( get4byte(pCell)==iFrom ){
52134 put4byte(pCell, iTo);
53228 aPayload = pCur->info.pCell + pCur->info.nHeader;
53461 aPayload = pCur->info.pCell;
53903 u8 *pCell; /* Pointer to current cell in pPage */
53907 pCell = findCell(pPage, idx) + pPage->childPtrSize;
53912 pCell += getVarint32(pCell, dummy);
53914 getVarint(pCell, (u64*)&nCellKey);
53934 int nCell = pCell[0];
53936 /* && (pCell+nCell)<pPage->aDataEnd */
53941 testcase( pCell+nCell+1==pPage->aDataEnd );
53942 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
53943 }else if( !(pCell[1] & 0x80)
53944 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
53945 /* && (pCell+nCell+2)<=pPage->aDataEnd */
53949 testcase( pCell+nCell+2==pPage->aDataEnd );
53950 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
53957 u8 * const pCellBody = pCell - pPage->childPtrSize;
54603 static int clearCell(MemPage *pPage, unsigned char *pCell){
54612 btreeParseCellPtr(pPage, pCell, &info);
54616 if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
54619 ovflPgno = get4byte(&pCell[info.iOverflow]);
54667 ** and write that byte sequence into pCell[]. Overflow pages are
54670 ** for pCell[].
54672 ** Note that pCell does not necessary need to point to the pPage->aData
54673 ** area. pCell might point to some temporary storage. The cell will
54679 unsigned char *pCell, /* Complete text of the cell */
54700 /* pPage is not necessarily writeable since pCell might be auxiliary
54702 assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
54711 nHeader += putVarint(&pCell[nHeader], nData+nZero);
54715 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
54716 btreeParseCellPtr(pPage, pCell, &info);
54737 pPayload = &pCell[nHeader];
54738 pPrior = &pCell[info.iOverflow];
54876 ** Insert a new cell on pPage at cell index "i". pCell points to the
54883 ** in pTemp or the original pCell) and also record its index.
54889 ** nSkip is non-zero, then pCell may not point to an invalid memory location
54890 ** (but pCell+nSkip is always valid).
54895 u8 *pCell, /* Content of the new cell */
54896 int sz, /* Bytes of content in pCell */
54897 u8 *pTemp, /* Temp storage space for pCell, if needed */
54924 assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
54927 memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
54928 pCell = pTemp;
54931 put4byte(pCell, iChild);
54935 pPage->apOvfl[j] = pCell;
54956 memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
54974 ptrmapPutOvflPtr(pPage, pCell, pRC);
55084 u8 *pCell = pPage->apOvfl[0];
55085 u16 szCell = cellSizePtr(pPage, pCell);
55091 assemblePage(pNew, 1, &pCell, &szCell);
55105 ptrmapPutOvflPtr(pNew, pCell, &rc);
55122 pCell = findCell(pPage, pPage->nCell-1);
55123 pStop = &pCell[9];
55124 while( (*(pCell++)&0x80) && pCell<pStop );
55125 pStop = &pCell[9];
55126 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
55704 u8 *pCell;
55709 pCell = apCell[j];
55713 memcpy(&pNew->aData[8], pCell, 4);
55723 pCell = pTemp;
55724 sz = 4 + putVarint(&pCell[4], info.nKey);
55727 pCell -= 4;
55728 /* Obscure case for non-leaf-data trees: If the cell at pCell was
55741 sz = cellSizePtr(pParent, pCell);
55747 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
56269 unsigned char *pCell; /* Pointer to cell to delete */
56271 int iCellDepth; /* Depth of node containing pCell */
56295 pCell = findCell(pPage, iCellIdx);
56319 rc = clearCell(pPage, pCell);
56320 dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
56334 pCell = findCell(pLeaf, pLeaf->nCell-1);
56335 nCell = cellSizePtr(pLeaf, pCell);
56342 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
56542 unsigned char *pCell;
56553 pCell = findCell(pPage, i);
56555 rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
56558 rc = clearCell(pPage, pCell);
57110 u8 *pCell;
57118 pCell = findCell(pPage,i);
57119 btreeParseCellPtr(pPage, pCell, &info);
57134 && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
57137 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
57149 pgno = get4byte(pCell);
130663 ** Overwrite cell iCell of node pNode with the contents of pCell.
130668 RtreeCell *pCell,
130673 p += writeInt64(p, pCell->iRowid);
130675 p += writeCoord(p, &pCell->aCoord[ii]);
130693 ** Insert the contents of cell pCell into node pNode. If the insert
130702 RtreeCell *pCell
130712 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
130801 ** to by pCell with the results.
130807 RtreeCell *pCell
130810 pCell
130812 nodeGetCoord(pRtree, pNode, iCell, ii, &pCell->aCoord[ii]);
130980 RtreeCell *pCell, /* Cell to test */
130991 aCoord[i] = DCOORD(pCell->aCoord[i]);
131594 ** Return the amount cell p would grow by if it were unioned with pCell.
131596 static float cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
131601 cellUnion(pRtree, &cell, pCell);
131671 RtreeCell *pCell, /* Cell to insert into rtree */
131672 int iHeight, /* Height of sub-tree rooted at pCell */
131713 /* Select the child node which will be enlarged the least if pCell
131722 growth = cellGrowth(pRtree, &cell, pCell);
131727 overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
131762 ** A cell with the same content as pCell has just been inserted into
131769 RtreeCell *pCell /* This cell was just inserted */
131782 if( !cellContains(pRtree, &cell, pCell) ){
131783 cellUnion(pRtree, &cell, pCell);
132195 RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
132196 nodeInsertCell(pRtree, pTarget, pCell);
132197 cellUnion(pRtree, pBbox, pCell);
132283 RtreeCell *pCell,
132300 /* Allocate an array and populate it with a copy of pCell and
132314 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
132380 if( iRowid==pCell->iRowid ){
132396 rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
132568 RtreeCell *pCell,
132603 memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
132632 if( p->iRowid==pCell->iRowid ){
132665 ** Insert cell pCell into node pNode. Node pNode is the head of a
132671 RtreeCell *pCell,
132676 RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
132683 if( nodeInsertCell(pRtree, pNode, pCell) ){
132686 rc = SplitNode(pRtree, pNode, pCell, iHeight);
132689 rc = Reinsert(pRtree, pNode, pCell, iHeight);
132692 rc = SplitNode(pRtree, pNode, pCell, iHeight);
132695 rc = AdjustTree(pRtree, pNode, pCell);
132698 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
132700 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
