Lines Matching refs:nCell
46486 u16 nCell; /* Number of cells on this page, local and ovfl */
48182 int nCell; /* Number of cells on the page */
48198 nCell = pPage->nCell;
48199 assert( nCell==get2byte(&data[hdr+3]) );
48204 iCellFirst = cellOffset + 2*nCell;
48206 for(i=0; i<nCell; i++){
48284 gap = pPage->cellOffset + 2*pPage->nCell;
48521 pPage->nCell = get2byte(&data[hdr+3]);
48522 if( pPage->nCell>MX_CELL(pBt) ){
48526 testcase( pPage->nCell==MX_CELL(pBt) );
48535 iCellFirst = cellOffset + 2*pPage->nCell;
48543 for(i=0; i<pPage->nCell; i++){
48626 pPage->nCell = 0;
49787 int nCell; /* Number of cells in page pPage */
49798 nCell = pPage->nCell;
49800 for(i=0; i<nCell; i++){
49847 int nCell;
49850 nCell = pPage->nCell;
49852 for(i=0; i<nCell; i++){
49871 if( i==nCell ){
50956 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
51088 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
51115 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
51154 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
51241 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
51256 assert( iIdx<=pParent->nCell );
51257 if( iIdx==pParent->nCell ){
51369 if( pRoot->nCell==0 && !pRoot->leaf ){
51376 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
51396 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
51422 pCur->aiIdx[pCur->iPage] = pPage->nCell;
51426 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
51445 assert( pCur->apPage[pCur->iPage]->nCell==0 );
51448 assert( pCur->apPage[pCur->iPage]->nCell>0 );
51473 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
51475 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
51484 assert( pCur->apPage[pCur->iPage]->nCell==0 );
51559 assert( pCur->apPage[pCur->iPage]->nCell>0 || pCur->eState==CURSOR_INVALID );
51562 assert( pCur->apPage[pCur->iPage]->nCell==0 );
51572 /* pPage->nCell must be greater than zero. If this is the root-page
51578 assert( pPage->nCell>0 );
51581 upr = pPage->nCell-1;
51619 int nCell = pCell[0];
51620 if( !(nCell & 0x80) && nCell<=pPage->maxLocal ){
51624 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
51626 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
51630 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
51639 nCell = (int)pCur->info.nKey;
51640 pCellKey = sqlite3Malloc( nCell );
51645 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
51650 c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
51679 }else if( lwr>=pPage->nCell ){
51685 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
51747 assert( idx<=pPage->nCell );
51751 if( idx>=pPage->nCell ){
51767 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
52515 assert( idx>=0 && idx<pPage->nCell );
52534 for(i=idx+1; i<pPage->nCell; i++, ptr+=2){
52538 pPage->nCell--;
52539 put2byte(&data[hdr+3], pPage->nCell);
52581 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
52582 assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
52612 end = cellOffset + 2*pPage->nCell;
52620 pPage->nCell++;
52631 put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
52649 int nCell, /* The number of cells to add to this page */
52662 assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
52667 assert( pPage->nCell==0 );
52670 pCellptr = &data[pPage->cellOffset + nCell*2];
52672 for(i=nCell-1; i>=0; i--){
52678 put2byte(&data[hdr+3], nCell);
52680 pPage->nFree -= (nCell*2 + nUsable - cellbody);
52681 pPage->nCell = (u16)nCell;
52735 if( pPage->nCell<=0 ) return SQLITE_CORRUPT_BKPT;
52784 pCell = findCell(pPage, pPage->nCell-1);
52791 insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
52820 for(j=0; j<pPage->nCell; j++){
52882 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
52952 int nCell = 0; /* Number of cells in apCell[] */
53010 i = pParent->nOverflow + pParent->nCell;
53025 if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
53037 nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
53129 limit = pOld->nCell+pOld->nOverflow;
53131 assert( nCell<nMaxCells );
53132 apCell[nCell] = findOverflowCell(pOld, j);
53133 szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
53134 nCell++;
53139 assert( nCell<nMaxCells );
53140 szCell[nCell] = sz;
53146 apCell[nCell] = pTemp+leafCorrection;
53148 szCell[nCell] = szCell[nCell] - leafCorrection;
53154 memcpy(apCell[nCell], &pOld->aData[8], 4);
53157 if( szCell[nCell]<4 ){
53159 szCell[nCell] = 4;
53162 nCell++;
53167 ** Figure out the number of pages needed to hold all nCell cells.
53171 ** cntNew[k] should equal nCell.
53183 for(subtotal=k=i=0; i<nCell; i++){
53196 cntNew[k] = nCell;
53234 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
53336 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
53344 assert( i<nNew-1 || j==nCell );
53345 if( j<nCell ){
53397 assert( j==nCell );
53405 if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
53422 (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
53461 int iNextOld = pOld->nCell + nOverflow;
53465 for(i=0; i<nCell; i++){
53472 iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;
53533 nOld, nNew, nCell));
53598 assert( pChild->nCell==pRoot->nCell );
53666 && pPage->aOvfl[0].idx==pPage->nCell
53668 && pParent->nCell==iIdx
53837 assert( idx<pPage->nCell );
53850 }else if( loc<0 && pPage->nCell>0 ){
53857 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
53917 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
53967 int nCell;
53971 pCell = findCell(pLeaf, pLeaf->nCell-1);
53972 nCell = cellSizePtr(pLeaf, pCell);
53973 assert( MX_CELL_SIZE(pBt) >= nCell );
53979 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
53980 dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
54189 for(i=0; i<pPage->nCell; i++){
54203 *pnChange += pPage->nCell;
54468 nEntry += pPage->nCell;
54489 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
54496 ** points at. This is the right-child if (iIdx==pPage->nCell).
54499 if( iIdx==pPage->nCell ){
54702 int nCell;
54739 for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
54802 checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
54853 nCell = get2byte(&data[hdr+3]);
54855 for(i=0; i<nCell; i++){
124848 int nCell; /* Current number of cells in pNode */
124852 nCell = NCELL(pNode);
124854 assert( nCell<=nMaxCell );
124855 if( nCell<nMaxCell ){
124856 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
124857 writeInt16(&pNode->zData[2], nCell+1);
124861 return (nCell==nMaxCell);
125315 int nCell = NCELL(pNode);
125316 for(ii=0; ii<nCell; ii++){
125361 int nCell = NCELL(pNode);
125362 for(pCsr->iCell++; pCsr->iCell<nCell; pCsr->iCell++){
125555 int nCell = NCELL(pRoot);
125557 for(pCsr->iCell=0; rc==SQLITE_OK && pCsr->iCell<nCell; pCsr->iCell++){
125753 int nCell,
125758 for(ii=0; ii<nCell; ii++){
125795 int nCell,
125800 before = cellOverlap(pRtree, p, aCell, nCell, iExclude);
125802 after = cellOverlap(pRtree, p, aCell, nCell, iExclude);
125831 int nCell = NCELL(pNode);
125840 aCell = sqlite3_malloc(sizeof(RtreeCell)*nCell);
125847 for(jj=0; jj<nCell; jj++){
125857 for(iCell=0; iCell<nCell; iCell++){
125868 overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
125961 int nCell,
125979 int nCell,
126003 for(jj=1; jj<nCell; jj++){
126041 int nCell,
126051 for(ii=0; ii<nCell; ii++){
126073 int nCell,
126084 for(ii=0; ii<nCell; ii++){
126085 for(jj=ii+1; jj<nCell; jj++){
126249 int nCell,
126263 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
126270 aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell];
126274 aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell];
126275 for(jj=0; jj<nCell; jj++){
126278 SortByDimension(pRtree, aaSorted[ii], nCell, ii, aCell, aSpare);
126290 nLeft<=(nCell-RTREE_MINCELLS(pRtree));
126300 memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
126301 for(kk=1; kk<(nCell-1); kk++){
126331 for(ii=0; ii<nCell; ii++){
126351 int nCell,
126362 aiUsed = sqlite3_malloc(sizeof(int)*nCell);
126366 memset(aiUsed, 0, sizeof(int)*nCell);
126368 PickSeeds(pRtree, aCell, nCell, &iLeftSeed, &iRightSeed);
126377 for(i=nCell-2; i>0; i--){
126379 pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
126429 int nCell = NCELL(pNode);
126442 aCell = sqlite3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
126447 aiUsed = (int *)&aCell[nCell+1];
126448 memset(aiUsed, 0, sizeof(int)*(nCell+1));
126449 for(i=0; i<nCell; i++){
126453 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
126454 nCell++;
126476 rc = AssignCells(pRtree, aCell, nCell, pLeft, pRight, &leftbbox, &rightbbox);
126651 int nCell = NCELL(pNode);
126654 for(ii=1; ii<nCell; ii++){
126714 int nCell;
126722 nCell = NCELL(pNode)+1;
126727 aCell = (RtreeCell *)sqlite3_malloc(nCell * (
126736 aOrder = (int *)&aCell[nCell];
126737 aSpare = (int *)&aOrder[nCell];
126738 aDistance = (float *)&aSpare[nCell];
126740 for(ii=0; ii<nCell; ii++){
126741 if( ii==(nCell-1) ){
126753 aCenterCoord[iDim] = aCenterCoord[iDim]/((float)nCell*2.0);
126756 for(ii=0; ii<nCell; ii++){
126765 SortByDistance(aOrder, nCell, aDistance, aSpare);
126768 for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
126782 for(; rc==SQLITE_OK && ii<nCell; ii++){
126849 int nCell = NCELL(pNode);
126851 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
127359 int nCell = 0;
127364 sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
127365 nCell = strlen(zCell);
127367 sqlite3_snprintf(512-nCell,&zCell[nCell]," %f",(double)cell.aCoord[jj].f);
127368 nCell = strlen(zCell);