Lines Matching defs:nField
14854 ** Note that aSortOrder[] and aColl[] have nField+1 slots. There
14855 ** are nField slots for the columns of an index then one extra slot
14861 u16 nField; /* Number of key columns in the index */
14882 ** pKeyInfo->nField.
14906 u16 nField; /* Number of entries in apMem[] */
18109 i16 nField; /* Number of fields in the header */
18112 u32 *aOffset; /* Pointer to aType[nField] */
18120 /* 2*nField extra array elements allocated for aType[], beyond the one
18121 ** static element declared in the structure. nField total array slots for
18122 ** aType[] and nField+1 array slots for aOffset[] */
59977 if( pIdxKey->nField==0 ){
67340 r.nField = pX->nMem;
70991 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
71007 pRec->nField = p->iVal+1;
71530 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
72888 sqlite3XPrintf(&x, "k(%d", pKeyInfo->nField);
72889 for(j=0; j<pKeyInfo->nField; j++){
75114 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
75120 p->nField = pKeyInfo->nField + 1;
75158 if( (++u)>=p->nField ) break;
75160 assert( u<=pKeyInfo->nField + 1 );
75161 p->nField = u;
75209 assert( pKeyInfo->nField+pKeyInfo->nXField>=pPKey2->nField || CORRUPT_DB );
75211 assert( pKeyInfo->nField>0 );
75246 }while( idx1<szHdr1 && i<pPKey2->nField );
75273 ** limit given by pKeyInfo->nField + pKeyInfo->nXField.
75278 ** that the KeyInfo.nField or KeyInfo.nXField values were computed
75285 int nField = 0;
75297 nField++;
75299 assert( nField <= pKeyInfo->nField+pKeyInfo->nXField );
75603 assert( pPKey2->pKeyInfo->nField+pPKey2->pKeyInfo->nXField>=pPKey2->nField
75606 assert( pPKey2->pKeyInfo->nField>0 );
75736 }while( idx1<(unsigned)szHdr1 && i<pPKey2->nField && d1<=(unsigned)nKey1 );
75843 }else if( pPKey2->nField>1 ){
75895 if( pPKey2->nField>1 ){
75939 if( (p->pKeyInfo->nField + p->pKeyInfo->nXField)<=13 ){
76186 static void vdbeFreeUnpacked(sqlite3 *db, int nField, UnpackedRecord *p){
76189 for(i=0; i<nField; i++){
76233 assert( pCsr->nField==pTab->nCol
76234 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
76243 preupdate.keyinfo.nField = pTab->nCol;
76253 vdbeFreeUnpacked(db, preupdate.keyinfo.nField+1, preupdate.pUnpacked);
76254 vdbeFreeUnpacked(db, preupdate.keyinfo.nField+1, preupdate.pNewUnpacked);
76257 for(i=0; i<pCsr->nField; i++){
77933 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nField+1));
77957 if( iIdx>=p->pCsr->nField || iIdx<0 ){
77985 }else if( iIdx>=p->pUnpacked->nField ){
78006 return (p ? p->keyinfo.nField : 0);
78045 if( iIdx>=p->pCsr->nField || iIdx<0 ){
78068 }else if( iIdx>=pUnpack->nField ){
78079 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
78085 assert( iIdx>=0 && iIdx<p->pCsr->nField );
78558 int nField, /* Number of fields in the table or index */
78585 ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
78598 pCx->nField = nField;
78599 pCx->aOffset = &pCx->aType[nField];
78602 &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
80676 assert( i<pKeyInfo->nField );
80967 assert( p2<pC->nField );
81235 int nField; /* Number of fields in the record */
81260 nField = pOp->p1;
81262 assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
81263 pData0 = &aMem[nField];
81264 nField = pOp->p2;
81265 pLast = &pData0[nField-1];
81291 while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
81293 nField--;
81900 int nField;
81931 nField = 0;
81968 nField = pKeyInfo->nField+pKeyInfo->nXField;
81970 nField = pOp->p4.i;
81973 assert( nField>=0 );
81974 testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */
81975 pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
82019 pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE);
82311 int nField; /* Number of columns or fields in the key */
82399 nField = pOp->p4.i;
82401 assert( nField>0 );
82403 r.nField = (u16)nField;
82420 { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
82558 r.nField = (u16)pOp->p4.i;
82561 for(ii=0; ii<r.nField; ii++){
82584 for(ii=0; ii<pIdxKey->nField; ii++){
83702 r.nField = (u16)pOp->p3;
83861 r.nField = (u16)pOp->p4.i;
83871 { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
85760 p->iOffset = pC->aType[p->iCol + pC->nField];
87010 if( pTask->pSorter->pKeyInfo->nField>1 ){
87079 if( pTask->pSorter->pKeyInfo->nField>1 ){
87094 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nField)
87096 ** records being sorted. However, if the value passed as argument nField
87097 ** is non-zero and the sorter is able to guarantee a stable sort, nField
87112 int nField, /* Number of key fields in each record */
87147 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nField-1)*sizeof(CollSeq*);
87158 if( nField && nWorker==0 ){
87159 pKeyInfo->nXField += (pKeyInfo->nField - nField);
87160 pKeyInfo->nField = nField;
87200 if( (pKeyInfo->nField+pKeyInfo->nXField)<13
87515 pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nField;
88917 r2->nField = nKeyCol;
88919 assert( r2->nField==nKeyCol );
117272 memset(pKI->aSortOrder, 0, pKI->nField); /* Makes OP_Jump below testable */
117745 p->nField = (u16)N;
131571 int nField; /* Number of fields in pRec */
131579 assert( pRec->nField>0 && pRec->nField<=pIdx->nSampleCol );
131625 nField = pRec->nField;
131627 iSample = pIdx->nSample * nField;
131633 iSamp = iTest / nField;
131636 ** Specifically, the shortest prefix of at least (1 + iTest%nField)
131638 for(n=(iTest % nField) + 1; n<nField; n++){
131645 pRec->nField = n;
131650 }else if( res==0 && n<nField ){
131659 i = iSample / nField;
131669 assert( iCol==nField-1 );
131670 pRec->nField = nField;
131679 pRec->nField = iCol+1;
131689 pRec->nField = iCol;
131694 pRec->nField = nField;
131704 assert( iCol==nField-1 );
131732 /* Restore the pRec->nField value before returning. */
131733 pRec->nField = nField;
131971 testcase( pRec->nField!=pBuilder->nRecValid );
131972 pRec->nField = pBuilder->nRecValid;
