Lines Matching defs:nCell
50881 u16 nCell; /* Number of cells on this page, local and ovfl */
52654 int nCell; /* Number of cells on the page */
52670 nCell = pPage->nCell;
52671 assert( nCell==get2byte(&data[hdr+3]) );
52676 iCellFirst = cellOffset + 2*nCell;
52678 for(i=0; i<nCell; i++){
52756 gap = pPage->cellOffset + 2*pPage->nCell;
52996 pPage->nCell = get2byte(&data[hdr+3]);
52997 if( pPage->nCell>MX_CELL(pBt) ){
53001 testcase( pPage->nCell==MX_CELL(pBt) );
53010 iCellFirst = cellOffset + 2*pPage->nCell;
53018 for(i=0; i<pPage->nCell; i++){
53102 pPage->nCell = 0;
54366 int nCell; /* Number of cells in page pPage */
54377 nCell = pPage->nCell;
54379 for(i=0; i<nCell; i++){
54426 int nCell;
54429 nCell = pPage->nCell;
54431 for(i=0; i<nCell; i++){
54451 if( i==nCell ){
55514 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
55698 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
55725 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
55758 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
55818 if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
55833 assert( iIdx<=pParent->nCell );
55834 if( iIdx==pParent->nCell ){
55870 testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
55951 if( pRoot->nCell>0 ){
55980 assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
56006 pCur->aiIdx[pCur->iPage] = pPage->nCell;
56010 pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
56029 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
56032 assert( pCur->apPage[pCur->iPage]->nCell>0 );
56057 assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
56059 assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
56068 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
56160 assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
56163 assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
56173 /* pPage->nCell must be greater than zero. If this is the root-page
56179 assert( pPage->nCell>0 );
56182 upr = pPage->nCell-1;
56221 int nCell;
56232 nCell = pCell[0];
56233 if( nCell<=pPage->max1bytePayload ){
56237 testcase( pCell+nCell+1==pPage->aDataEnd );
56238 c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey, 0);
56240 && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
56244 testcase( pCell+nCell+2==pPage->aDataEnd );
56245 c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey, 0);
56254 nCell = (int)pCur->info.nKey;
56255 pCellKey = sqlite3Malloc( nCell );
56261 rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 2);
56266 c = xRecordCompare(nCell, pCellKey, pIdxKey, 0);
56290 assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
56297 if( lwr>=pPage->nCell ){
56384 testcase( idx>pPage->nCell );
56388 if( idx>=pPage->nCell ){
56407 }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
57221 assert( idx>=0 && idx<pPage->nCell );
57240 pPage->nCell--;
57241 memmove(ptr, ptr+2, 2*(pPage->nCell - idx));
57242 put2byte(&data[hdr+3], pPage->nCell);
57282 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
57284 assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );
57315 end = cellOffset + 2*pPage->nCell;
57323 pPage->nCell++;
57331 put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
57349 int nCell, /* The number of cells to add to this page */
57362 assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
57367 assert( pPage->nCell==0 );
57370 pCellptr = &pPage->aCellIdx[nCell*2];
57372 for(i=nCell-1; i>=0; i--){
57379 put2byte(&data[hdr+3], nCell);
57381 pPage->nFree -= (nCell*2 + nUsable - cellbody);
57382 pPage->nCell = (u16)nCell;
57436 if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT;
57485 pCell = findCell(pPage, pPage->nCell-1);
57492 insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
57521 for(j=0; j<pPage->nCell; j++){
57583 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
57657 int nCell = 0; /* Number of cells in apCell[] */
57715 i = pParent->nOverflow + pParent->nCell;
57731 if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
57743 nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
57837 limit = pOld->nCell+pOld->nOverflow;
57840 assert( nCell<nMaxCells );
57841 apCell[nCell] = findOverflowCell(pOld, j);
57842 szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
57843 nCell++;
57850 assert( nCell<nMaxCells );
57851 apCell[nCell] = findCellv2(aData, maskPage, cellOffset, j);
57852 szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
57853 nCell++;
57859 assert( nCell<nMaxCells );
57860 szCell[nCell] = sz;
57866 apCell[nCell] = pTemp+leafCorrection;
57868 szCell[nCell] = szCell[nCell] - leafCorrection;
57874 memcpy(apCell[nCell], &pOld->aData[8], 4);
57877 if( szCell[nCell]<4 ){
57879 szCell[nCell] = 4;
57882 nCell++;
57887 ** Figure out the number of pages needed to hold all nCell cells.
57891 ** cntNew[k] should equal nCell.
57903 for(subtotal=k=i=0; i<nCell; i++){
57916 cntNew[k] = nCell;
57961 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
58064 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
58072 assert( i<nNew-1 || j==nCell );
58073 if( j<nCell ){
58125 assert( j==nCell );
58133 if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
58150 (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
58189 int iNextOld = pOld->nCell + nOverflow;
58193 for(i=0; i<nCell; i++){
58202 iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;
58263 nOld, nNew, nCell));
58331 assert( pChild->nCell==pRoot->nCell );
58402 && pPage->aiOvfl[0]==pPage->nCell
58404 && pParent->nCell==iIdx
58581 assert( idx<pPage->nCell );
58594 }else if( loc<0 && pPage->nCell>0 ){
58601 assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
58661 if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
58712 int nCell;
58716 pCell = findCell(pLeaf, pLeaf->nCell-1);
58717 nCell = cellSizePtr(pLeaf, pCell);
58718 assert( MX_CELL_SIZE(pBt) >= nCell );
58724 insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
58725 dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
58943 for(i=0; i<pPage->nCell; i++){
58957 *pnChange += pPage->nCell;
59238 nEntry += pPage->nCell;
59259 }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
59266 ** points at. This is the right-child if (iIdx==pPage->nCell).
59269 if( iIdx==pPage->nCell ){
59492 int nCell;
59529 for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
59592 checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
59643 nCell = get2byte(&data[hdr+3]);
59645 for(i=0; i<nCell; i++){
145279 int nCell; /* Current number of cells in pNode */
145283 nCell = NCELL(pNode);
145285 assert( nCell<=nMaxCell );
145286 if( nCell<nMaxCell ){
145287 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
145288 writeInt16(&pNode->zData[2], nCell+1);
145292 return (nCell==nMaxCell);
145720 int nCell = NCELL(pNode);
145721 assert( nCell<200 );
145722 for(ii=0; ii<nCell; ii++){
145968 int nCell;
145978 nCell = NCELL(pNode);
145979 assert( nCell<200 );
145980 while( p->iCell<nCell ){
146007 if( p->iCell>=nCell ){
146020 if( p->iCell>=nCell ){
146462 int nCell
146466 for(ii=0; ii<nCell; ii++){
146508 int nCell = NCELL(pNode);
146518 for(iCell=0; iCell<nCell; iCell++){
146744 int nCell,
146758 int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
146765 aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell];
146769 aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell];
146770 for(jj=0; jj<nCell; jj++){
146773 SortByDimension(pRtree, aaSorted[ii], nCell, ii, aCell, aSpare);
146785 nLeft<=(nCell-RTREE_MINCELLS(pRtree));
146795 memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
146796 for(kk=1; kk<(nCell-1); kk++){
146826 for(ii=0; ii<nCell; ii++){
146868 int nCell = NCELL(pNode);
146881 aCell = sqlite3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
146886 aiUsed = (int *)&aCell[nCell+1];
146887 memset(aiUsed, 0, sizeof(int)*(nCell+1));
146888 for(i=0; i<nCell; i++){
146892 memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
146893 nCell++;
146915 rc = splitNodeStartree(pRtree, aCell, nCell, pLeft, pRight,
147091 int nCell = NCELL(pNode);
147094 for(ii=1; ii<nCell; ii++){
147154 int nCell;
147163 nCell = NCELL(pNode)+1;
147164 n = (nCell+1)&(~1);
147182 for(ii=0; ii<nCell; ii++){
147183 if( ii==(nCell-1) ){
147195 aCenterCoord[iDim] = (aCenterCoord[iDim]/(nCell*(RtreeDValue)2));
147198 for(ii=0; ii<nCell; ii++){
147207 SortByDistance(aOrder, nCell, aDistance, aSpare);
147210 for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
147224 for(; rc==SQLITE_OK && ii<nCell; ii++){
147287 int nCell = NCELL(pNode);
147289 for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
147919 int nCell = 0;
147924 sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
147925 nCell = (int)strlen(zCell);
147928 sqlite3_snprintf(512-nCell,&zCell[nCell], " %g",
147931 sqlite3_snprintf(512-nCell,&zCell[nCell], " %d",
147934 nCell = (int)strlen(zCell);