Lines Matching defs:nCell
47626 u16 nCell; /* Number of cells on this page, local and ovfl */
49333 int nCell; /* Number of cells on the page */
49349 nCell = pPage->nCell;
49350 assert( nCell==get2byte(&data[hdr+3]) );
49355 iCellFirst = cellOffset + 2*nCell;
49357 for(i=0; i<nCell; i++){
49435 gap = pPage->cellOffset + 2*pPage->nCell;
49672 pPage->nCell = get2byte(&data[hdr+3]);
49673 if( pPage->nCell>MX_CELL(pBt) ){
49677 testcase( pPage->nCell==MX_CELL(pBt) );
49686 iCellFirst = cellOffset + 2*pPage->nCell;
49694 for(i=0; i<pPage->nCell; i++){
49777 pPage->nCell = 0;
50938 int nCell; /* Number of cells in page pPage */
50949 nCell = pPage->nCell;
50951 for(i=0; i<nCell; i++){
50998 int nCell;
51001 nCell = pPage->nCell;
51003 for(i=0; i<nCell; i++){
51023 if( i==nCell ){
52109 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52241 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52268 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52307 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52394 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
52409 assert( iIdx<=pParent->nCell );
52410 if( iIdx==pParent->nCell ){
52525 if( pRoot->nCell==0 && !pRoot->leaf ){
52532 pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
52552 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
52578 pCur->aiIdx[pCur->iPage] = pPage->nCell;
52582 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
52601 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52604 assert( pCur->apPage[pCur->iPage]->nCell>0 );
52629 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
52631 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
52640 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52715 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
52718 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
52728 /* pPage->nCell must be greater than zero. If this is the root-page
52734 assert( pPage->nCell>0 );
52737 upr = pPage->nCell-1;
52775 int nCell = pCell[0];
52776 if( !(nCell & 0x80) && nCell<=pPage->maxLocal ){
52780 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
52782 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
52786 c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
52795 nCell = (int)pCur->info.nKey;
52796 pCellKey = sqlite3Malloc( nCell );
52801 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
52806 c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
52835 }else if( lwr>=pPage->nCell ){
52841 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
52903 assert( idx<=pPage->nCell );
52907 if( idx>=pPage->nCell ){
52923 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
53674 assert( idx>=0 && idx<pPage->nCell );
53693 endPtr = &data[pPage->cellOffset + 2*pPage->nCell - 2];
53699 pPage->nCell--;
53700 put2byte(&data[hdr+3], pPage->nCell);
53743 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
53744 assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
53774 end = cellOffset + 2*pPage->nCell;
53782 pPage->nCell++;
53796 put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
53814 int nCell, /* The number of cells to add to this page */
53827 assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
53832 assert( pPage->nCell==0 );
53835 pCellptr = &data[pPage->cellOffset + nCell*2];
53837 for(i=nCell-1; i>=0; i--){
53844 put2byte(&data[hdr+3], nCell);
53846 pPage->nFree -= (nCell*2 + nUsable - cellbody);
53847 pPage->nCell = (u16)nCell;
53901 if( pPage->nCell<=0 ) return SQLITE_CORRUPT_BKPT;
53950 pCell = findCell(pPage, pPage->nCell-1);
53957 insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
53986 for(j=0; j<pPage->nCell; j++){
54048 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
54118 int nCell = 0; /* Number of cells in apCell[] */
54176 i = pParent->nOverflow + pParent->nCell;
54191 if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
54203 nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
54295 limit = pOld->nCell+pOld->nOverflow;
54298 assert( nCell<nMaxCells );
54299 apCell[nCell] = findOverflowCell(pOld, j);
54300 szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
54301 nCell++;
54308 assert( nCell<nMaxCells );
54309 apCell[nCell] = findCellv2(aData, maskPage, cellOffset, j);
54310 szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
54311 nCell++;
54317 assert( nCell<nMaxCells );
54318 szCell[nCell] = sz;
54324 apCell[nCell] = pTemp+leafCorrection;
54326 szCell[nCell] = szCell[nCell] - leafCorrection;
54332 memcpy(apCell[nCell], &pOld->aData[8], 4);
54335 if( szCell[nCell]<4 ){
54337 szCell[nCell] = 4;
54340 nCell++;
54345 ** Figure out the number of pages needed to hold all nCell cells.
54349 ** cntNew[k] should equal nCell.
54361 for(subtotal=k=i=0; i<nCell; i++){
54374 cntNew[k] = nCell;
54412 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
54514 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
54522 assert( i<nNew-1 || j==nCell );
54523 if( j<nCell ){
54575 assert( j==nCell );
54583 if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
54600 (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
54639 int iNextOld = pOld->nCell + nOverflow;
54643 for(i=0; i<nCell; i++){
54650 iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;
54711 nOld, nNew, nCell));
54776 assert( pChild->nCell==pRoot->nCell );
54844 && pPage->aOvfl[0].idx==pPage->nCell
54846 && pParent->nCell==iIdx
55015 assert( idx<pPage->nCell );
55028 }else if( loc<0 && pPage->nCell>0 ){
55035 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
55095 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
55145 int nCell;
55149 pCell = findCell(pLeaf, pLeaf->nCell-1);
55150 nCell = cellSizePtr(pLeaf, pCell);
55151 assert( MX_CELL_SIZE(pBt) >= nCell );
55157 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
55158 dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
55367 for(i=0; i<pPage->nCell; i++){
55381 *pnChange += pPage->nCell;
55651 nEntry += pPage->nCell;
55672 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
55679 ** points at. This is the right-child if (iIdx==pPage->nCell).
55682 if( iIdx==pPage->nCell ){
55885 int nCell;
55922 for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
55985 checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
56036 nCell = get2byte(&data[hdr+3]);
56038 for(i=0; i<nCell; i++){
127620 int nCell; /* Current number of cells in pNode */
127624 nCell = NCELL(pNode);
127626 assert( nCell<=nMaxCell );
127627 if( nCell<nMaxCell ){
127628 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
127629 writeInt16(&pNode->zData[2], nCell+1);
127633 return (nCell==nMaxCell);
128087 int nCell = NCELL(pNode);
128088 for(ii=0; ii<nCell; ii++){
128133 int nCell = NCELL(pNode);
128134 for(pCsr->iCell++; pCsr->iCell<nCell; pCsr->iCell++){
128327 int nCell = NCELL(pRoot);
128329 for(pCsr->iCell=0; rc==SQLITE_OK && pCsr->iCell<nCell; pCsr->iCell++){
128525 int nCell,
128530 for(ii=0; ii<nCell; ii++){
128567 int nCell,
128572 before = cellOverlap(pRtree, p, aCell, nCell, iExclude);
128574 after = cellOverlap(pRtree, p, aCell, nCell, iExclude);
128603 int nCell = NCELL(pNode);
128612 aCell = sqlite3_malloc(sizeof(RtreeCell)*nCell);
128619 for(jj=0; jj<nCell; jj++){
128629 for(iCell=0; iCell<nCell; iCell++){
128640 overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
128733 int nCell,
128751 int nCell,
128775 for(jj=1; jj<nCell; jj++){
128813 int nCell,
128823 for(ii=0; ii<nCell; ii++){
128845 int nCell,
128856 for(ii=0; ii<nCell; ii++){
128857 for(jj=ii+1; jj<nCell; jj++){
129021 int nCell,
129035 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
129042 aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell];
129046 aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell];
129047 for(jj=0; jj<nCell; jj++){
129050 SortByDimension(pRtree, aaSorted[ii], nCell, ii, aCell, aSpare);
129062 nLeft<=(nCell-RTREE_MINCELLS(pRtree));
129072 memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
129073 for(kk=1; kk<(nCell-1); kk++){
129103 for(ii=0; ii<nCell; ii++){
129123 int nCell,
129134 aiUsed = sqlite3_malloc(sizeof(int)*nCell);
129138 memset(aiUsed, 0, sizeof(int)*nCell);
129140 PickSeeds(pRtree, aCell, nCell, &iLeftSeed, &iRightSeed);
129149 for(i=nCell-2; i>0; i--){
129151 pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
129201 int nCell = NCELL(pNode);
129214 aCell = sqlite3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
129219 aiUsed = (int *)&aCell[nCell+1];
129220 memset(aiUsed, 0, sizeof(int)*(nCell+1));
129221 for(i=0; i<nCell; i++){
129225 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
129226 nCell++;
129248 rc = AssignCells(pRtree, aCell, nCell, pLeft, pRight, &leftbbox, &rightbbox);
129423 int nCell = NCELL(pNode);
129426 for(ii=1; ii<nCell; ii++){
129486 int nCell;
129494 nCell = NCELL(pNode)+1;
129499 aCell = (RtreeCell *)sqlite3_malloc(nCell * (
129508 aOrder = (int *)&aCell[nCell];
129509 aSpare = (int *)&aOrder[nCell];
129510 aDistance = (float *)&aSpare[nCell];
129512 for(ii=0; ii<nCell; ii++){
129513 if( ii==(nCell-1) ){
129525 aCenterCoord[iDim] = (float)(aCenterCoord[iDim]/((float)nCell*2.0));
129528 for(ii=0; ii<nCell; ii++){
129537 SortByDistance(aOrder, nCell, aDistance, aSpare);
129540 for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
129554 for(; rc==SQLITE_OK && ii<nCell; ii++){
129621 int nCell = NCELL(pNode);
129623 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
130173 int nCell = 0;
130178 sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
130179 nCell = strlen(zCell);
130181 sqlite3_snprintf(512-nCell,&zCell[nCell]," %f",(double)cell.aCoord[jj].f);
130182 nCell = strlen(zCell);