Lines Matching refs:nCol
18402 i16 nCol; /* Number of columns in this table */ member
18554 int nCol; /* Number of columns in this key */ member
32679 int nCol, in sqlite3TreeViewColumnList() argument
32685 for(i=0; i<nCol; i++){ in sqlite3TreeViewColumnList()
32687 int colMoreToFollow = i<(nCol - 1); in sqlite3TreeViewColumnList()
32782 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, in sqlite3TreeViewSrcList()
32827 sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1); in sqlite3TreeViewSrcList()
84224 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
84226 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
84231 assert( pRec->pKeyInfo->nAllField==nCol );
84234 for(i=0; i<nCol; i++){
84774 int nCol = pRec->pKeyInfo->nAllField;
84777 for(i=0; i<nCol; i++){
90323 nRealCol = pTab->nCol;
90352 preupdate.keyinfo.nKeyField = pTab->nCol;
96354 for(i=0; i<pTab->nCol; i++){
102473 for(iCol=0; iCol<pTab->nCol; iCol++) {
102478 if( iCol==pTab->nCol ){
102502 for(j=0; j<pFKey->nCol; j++){
102599 aOp[1].p4.i = pTab->nCol+1;
102600 aOp[3].p2 = pTab->nCol;
106911 assert( n < pExTab->nCol );
106915 testcase( pExTab->nCol==BMS-1 );
106916 testcase( pExTab->nCol==BMS );
106917 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
107075 assert( pTab->nCol>0 || pParse->nErr );
107088 assert( pEList->nExpr==pTab->nCol );
107157 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
107285 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
107295 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
107299 if( iCol<pTab->nCol ){
107324 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
107607 testcase( pTab->nCol==63 );
107608 testcase( pTab->nCol==64 );
107609 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
109036 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
111874 && ALWAYS(p->iColumn<p->y.pTab->nCol)
111945 for(iCol=0; iCol<pTab->nCol; iCol++){
111948 if( iCol==pTab->nCol ){
113650 assert( iCol<pTab->nCol );
114032 int nCol;
114039 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
114041 sqlite3SubselectError(pParse, nCol, 1);
114147 p1 = pExpr->iTable * (pTab->nCol+1) + 1
114151 assert( iCol>=-1 && iCol<pTab->nCol );
114153 assert( p1>=0 && p1<(pTab->nCol*2+2) );
116479 pCol = &pNew->aCol[pNew->nCol-1];
116672 pNew->nCol = pTab->nCol;
116673 assert( pNew->nCol>0 );
116674 nAlloc = (((pNew->nCol-1)/8)*8)+8;
116675 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
116682 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
116683 for(i=0; i<pNew->nCol; i++){
116777 for(iCol=0; iCol<pTab->nCol; iCol++){
116780 if( iCol==pTab->nCol ){
117664 if( pTab==0 || iCol>=pTab->nCol ){
117703 if( iCol<sParse.pNewTable->nCol ){
117719 for(i=0; i<sParse.pNewTable->nCol; i++){
117729 for(i=0; i<pFKey->nCol; i++){
118091 for(i=0; i<sParse.pNewTable->nCol; i++){
118257 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
118264 if( iCol<pTab->nCol-1 ){
118339 if( pTab->nCol<=1 ){
118383 pParse->nMem += pTab->nCol;
118393 for(i=0; i<pTab->nCol; i++){
118742 int nCol; /* Number of columns in index + pk/rowid */
118807 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
118808 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
118809 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
118826 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
118862 int nCol; /* Number of columns in index being sampled */
118874 nCol = sqlite3_value_int(argv[0]);
118875 assert( nCol>0 );
118876 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
118878 assert( nKeyCol<=nCol );
118888 + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */
118889 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
118902 p->nCol = nCol;
118917 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
118922 pSpace = (u8*)(&p->a[mxSample+nCol]);
118923 for(i=0; i<(mxSample+nCol); i++){
118930 for(i=0; i<nCol; i++){
118971 int nCol = pAccum->nCol;
118974 for(i=pNew->iCol+1; i<nCol; i++){
119073 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
119110 for(i=(p->nCol-2); i>=iChng; i--){
119122 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
119129 for(j=iChng; j<p->nCol; j++){
119170 assert( p->nCol>0 );
119171 assert( iChng<p->nCol );
119176 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
119191 for(i=iChng; i<p->nCol; i++){
119212 nLt = p->current.anLt[p->nCol-1];
119217 sampleInsert(p, &p->current, p->nCol-1);
119222 for(i=0; i<(p->nCol-1); i++){
119366 sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100);
119367 for(i=0; i<p->nCol; i++){
119497 pStat1->nCol = 3;
119515 int nCol; /* Number of columns in pIdx. "N" */
119524 nCol = pIdx->nKeyCol;
119526 nColTest = nCol - 1;
119528 nCol = pIdx->nColumn;
119530 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
119606 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
119746 int regSampleRowid = regCol + nCol;
119759 int mxCol = nCol;
119786 assert( sqlite3NoTempsInRange(pParse, regEq, regCol+nCol) );
119797 for(i=0; i<nCol; i++){
119800 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
120085 int nCol = pIndex->nKeyCol+1;
120091 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
120097 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
120153 int nCol = 1;
120159 nCol = pIdx->nSampleCol-1;
120160 pIdx->aAvgEq[nCol] = 1;
120162 for(iCol=0; iCol<nCol; iCol++){
120314 int nCol = 1; /* Number of columns in index */
120327 nCol = pIdx->nSampleCol;
120333 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
120334 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
120335 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
121273 assert( iCol<pTab->nCol );
121276 assert( pTab->iPKey<pTab->nCol );
122145 for(i=0; i<pTable->nCol; i++, pCol++){
122155 pTable->nCol = 0;
122531 assert( iCol<pTab->nCol );
122872 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
122920 for(i=0; i<p->nCol; i++){
122927 aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
122933 pCol = &p->aCol[p->nCol];
122960 p->nCol++;
122975 if( p==0 || NEVER(p->nCol<1) ) return;
122976 pCol = &p->aCol[p->nCol-1];
122986 if( pIdx->aiColumn[0]==p->nCol-1 ){
123108 pCol = &(p->aCol[p->nCol-1]);
123215 iCol = pTab->nCol - 1;
123229 for(iCol=0; iCol<pTab->nCol; iCol++){
123314 i = p->nCol-1;
123349 pCol = &(pTab->aCol[pTab->nCol-1]);
123487 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
123500 n += 35 + 6*p->nCol;
123510 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
123583 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
123599 assert( x<pIdx->pTable->nCol );
123609 static int hasColumn(const i16 *aiCol, int nCol, int x){
123610 while( nCol-- > 0 ){
123723 for(i=0; i<pTab->nCol; i++){
123845 for(i=0; i<pTab->nCol; i++){
123850 for(i=0, j=nPk; i<pTab->nCol; i++){
124044 for(ii=0; ii<p->nCol; ii++){
124111 for(ii=0; ii<p->nCol; ii++){
124218 p->nCol = p->nNVCol = pSelTab->nCol;
124220 pSelTab->nCol = 0;
124466 assert( pTable->nCol<=0 );
124483 if( pTable->nCol<0 ){
124487 assert( pTable->nCol>=0 );
124504 pTable->nCol = -1;
124517 pTable->nCol = 0;
124527 &pTable->nCol, &pTable->aCol);
124529 && pTable->nCol==pSel->pEList->nExpr
124539 pTable->nCol = pSelTab->nCol;
124542 pSelTab->nCol = 0;
124546 pTable->nNVCol = pTable->nCol;
124563 if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0;
124980 int nCol;
124986 int iCol = p->nCol-1;
124994 nCol = 1;
125001 nCol = pFromCol->nExpr;
125003 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
125016 z = (char*)&pFKey->aCol[nCol];
125025 pFKey->nCol = nCol;
125027 pFKey->aCol[0].iFrom = p->nCol-1;
125029 for(i=0; i<nCol; i++){
125031 for(j=0; j<p->nCol; j++){
125037 if( j>=p->nCol ){
125049 for(i=0; i<nCol; i++){
125229 i16 nCol, /* Total number of columns in the index */
125237 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
125238 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
125239 sizeof(i16)*nCol + /* Index.aiColumn */
125240 sizeof(u8)*nCol); /* Index.aSortOrder */
125244 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
125245 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
125246 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
125248 p->nColumn = nCol;
125249 p->nKeyCol = nCol - 1;
125486 Column *pCol = &pTab->aCol[pTab->nCol-1];
125655 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
125657 for(j=0; j<pTab->nCol; j++){
126919 int nCol = pIdx->nColumn;
126924 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
126926 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
126930 for(i=0; i<nCol; i++){
127850 assert( pPk->aiColumn[0]>=0 && pPk->aiColumn[0]<pTab->nCol );
127858 assert( pPk->aiColumn[i]>=0 && pPk->aiColumn[i]<pTab->nCol );
128408 pParse->nMem += (1 + pTab->nCol);
128413 for(iCol=0; iCol<pTab->nCol; iCol++){
128592 int nCol;
128607 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
128608 regBase = sqlite3GetTempRange(pParse, nCol);
128610 for(j=0; j<nCol; j++){
128630 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
128632 sqlite3ReleaseTempRange(pParse, regBase, nCol);
131600 int nCol = pFKey->nCol; /* Number of columns in parent key */
131616 if( nCol==1 ){
131631 assert( nCol>1 );
131632 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
131638 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
131650 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
131660 for(i=0; i<nCol; i++){
131675 for(j=0; j<nCol; j++){
131681 if( j==nCol ) break;
131683 if( i==nCol ) break; /* pIdx is usable */
131761 for(i=0; i<pFKey->nCol; i++){
131799 int nCol = pFKey->nCol;
131800 int regTemp = sqlite3GetTempRange(pParse, nCol);
131804 for(i=0; i<nCol; i++){
131821 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
131822 for(i=0; i<nCol; i++){
131840 sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0,
131841 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
131842 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);
131844 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
131974 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
131975 assert( pIdx!=0 || pFKey->nCol==1 );
131991 for(i=0; i<pFKey->nCol; i++){
132213 for(i=0; i<p->nCol; i++){
132240 for(i=0; i<p->nCol; i++){
132243 for(iKey=0; iKey<pTab->nCol; iKey++){
132359 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
132360 for(i=0; i<pFKey->nCol; i++){
132370 assert( pFKey->nCol==1 || (aiFree && pIdx) );
132378 for(i=0; i<pFKey->nCol; i++){
132447 assert( aiCol || pFKey->nCol==1 );
132510 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
132654 assert( aiCol || pFKey->nCol==1 );
132656 for(i=0; i<pFKey->nCol; i++){
132666 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
133017 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
133020 for(i=j=0; i<pTab->nCol; i++){
133161 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
133225 for(i=0; i<pTab->nCol; i++){
133247 for(i=0; i<pTab->nCol; i++){
133319 || pSeqTab->nCol!=2
133925 pParse->nMem += pTab->nCol + 1;
133959 for(j=0; j<pTab->nCol; j++){
133977 if( j>=pTab->nCol ){
134010 if( bIdListInOrder && nColumn==pTab->nCol ){
134022 dest.nSdst = pTab->nCol;
134121 for(i=0; i<pTab->nCol; i++){
134125 if( nColumn!=(pTab->nCol-nHidden) ){
134128 pTabList->a, pTab->nCol-nHidden, nColumn);
134219 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
134239 for(i=0; i<pTab->nCol; i++, iRegStore++){
134320 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
134372 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
134374 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
134437 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
134483 pTab, regData-2-pTab->nCol, onError, endOfLoop);
134789 int nCol; /* Number of columns */
134814 nCol = pTab->nCol;
134839 for(i=0; i<nCol; i++){
135612 for(i=pTab->nCol-1; i>0; i--){
135980 if( pDest->nCol!=pSrc->nCol ){
135989 for(i=0; i<pDest->nCol; i++){
136318 int nCol = 0;
136343 nCol = sqlite3_column_count(pStmt);
136344 azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
136348 for(i=0; i<nCol; i++){
136357 azVals = &azCols[nCol];
136358 for(i=0; i<nCol; i++){
136367 if( xCallback(pArg, nCol, azVals, azCols) ){
139933 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
139954 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
140008 if( pTab->nCol==0 ){
140043 pTab->nCol,
140229 for(j=0; j<pFK->nCol; j++){
140283 sqlite3TouchRegister(pParse, pTab->nCol+regRow);
140324 sqlite3TouchRegister(pParse, regRow + pFK->nCol);
140325 for(j=0; j<pFK->nCol; j++){
140334 sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0,
140335 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
140336 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol);
140342 assert( pFK->nCol==1 || db->mallocFailed );
140576 for(j=0; j<pTab->nCol; j++){
140621 for(j=0; j<pTab->nCol; j++){
140834 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
140871 if( pTab->nCol<=0 ){
143215 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
143411 for(j=0; j<pRightTab->nCol; j++){
144871 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144885 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
145040 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
145094 int nCol; /* Number of columns in the result set */
145102 nCol = pEList->nExpr;
145103 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
145105 if( NEVER(nCol>32767) ) nCol = 32767;
145107 nCol = 0;
145110 assert( nCol==(i16)nCol );
145111 *pnCol = nCol;
145114 for(i=0, pCol=aCol; i<nCol && !pParse->nErr; i++, pCol++){
145219 assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );
145226 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
145315 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
145520 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
145581 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
145588 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
146068 int nCol; /* Number of columns in result set */
146072 nCol = p->pEList->nExpr;
146073 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
146078 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
146094 sqlite3VdbeChangeP2(v, addr, nCol);
148212 int nCol;
148228 assert( pSub->pEList->nExpr==pTab->nCol );
148259 nCol = pTab->nCol;
148260 for(j=0; j<nCol; j++){
148736 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
148795 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
148941 i16 nCol;
148965 nCol = pTab->nCol;
148966 pTab->nCol = -1;
148970 pTab->nCol = nCol;
149071 assert( pNestedFrom->nExpr==pTab->nCol );
149104 nAdd = pTab->nCol;
149110 if( j==pTab->nCol ){
149196 pX->fg.eEName = (j==pTab->nCol ? ENAME_ROWID : ENAME_TAB);
149200 || (j<pTab->nCol && (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND))
150386 if( pTab->nCol!=pSub->pEList->nExpr ){
150388 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
151114 int nCol;
151127 nCol = nGroupBy;
151131 nCol++;
151135 regBase = sqlite3GetTempRange(pParse, nCol);
151149 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
151153 sqlite3ReleaseTempRange(pParse, regBase, nCol);
151159 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
151553 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
151563 need = nCol*2;
151565 need = nCol;
151579 p->nColumn = nCol;
151580 for(i=0; i<nCol; i++){
151585 }else if( (int)p->nColumn!=nCol ){
151597 for(i=0; i<nCol; i++){
152642 for(jj=0; jj<pTab->nCol; jj++){
152793 int nCol = pNew->nExpr;
152796 pParse->nMem += nCol+2;
152798 for(i=0; i<nCol; i++){
153337 assert( pTab->nCol>i );
153344 assert( i<pTab->nCol );
153517 for(i=0; i<pTab->nCol; i++){
153714 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
153716 aRegIdx = aXRef+pTab->nCol;
153720 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
153747 for(j=0; j<pTab->nCol; j++){
153772 if( j>=pTab->nCol ){
153817 for(i=0; i<pTab->nCol; i++){
153891 pParse->nMem += pTab->nCol;
153897 pParse->nMem += pTab->nCol;
153961 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
154183 for(i=0; i<pTab->nCol; i++){
154220 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
154229 int nOff = (isView ? pTab->nCol : nPk);
154290 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
154491 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
154532 for(i=0; i<pTab->nCol; i++){
154558 for(i=0; i<pTab->nCol; i++){
154963 for(i=0; i<pTab->nCol; i++){
156044 for(iCol=0; iCol<pTab->nCol; iCol++){
156263 pTab->nNVCol = pTab->nCol = pNew->nCol;
156265 pNew->nCol = 0;
158606 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
158608 ai[0] = pTab->nCol;
158611 assert( pIdx->aiColumn[i]<pTab->nCol );
162087 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
162088 if( k>=pTab->nCol ){
163152 mxBitCol = MIN(BMS-1,pTable->nCol);
163153 testcase( pTable->nCol==BMS-1 );
163154 testcase( pTable->nCol==BMS-2 );
163159 nKeyCol += pTable->nCol - BMS + 1;
163212 for(i=BMS-1; i<pTable->nCol; i++){
163479 assert( pTerm->u.x.leftColumn<pTab->nCol );
163510 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
163523 assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol );
167296 LogEst rSortCost, nCol;
167300 nCol = sqlite3LogEst((pWInfo->pSelect->pEList->nExpr+59)/30);
167301 rSortCost = nRow + nCol;
168791 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
168792 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
168794 && pTab->nCol<BMS
168805 assert( n<=pTab->nCol );
169163 m = pSrc->pTab->nCol;
172139 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
183730 for(iCol=0; iCol<pTab->nCol; iCol++){
183736 if( iCol==pTab->nCol ){
187275 int nCol; /* Number of table columns */
187281 nCol = sqlite3_column_count(pStmt);
187282 for(i=0; i<nCol; i++){
187288 azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
187292 char *p = (char *)&azCol[nCol];
187293 for(i=0; i<nCol; i++){
187304 *pnCol = nCol;
187339 int nCol = 0; /* Number of columns in the FTS table */
187502 aCol[nCol++] = z;
187518 if( nCol==0 ){
187521 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
187527 for(j=0; j<nCol; j++){
187530 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
187531 nCol--;
187540 if( nCol==0 ){
187544 nCol = 1;
187562 nCol * sizeof(char *) + /* azColumn */
187564 nCol * sizeof(u8) + /* abNotindexed */
187575 p->nColumn = nCol;
187592 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
187601 zCsr = (char *)&p->abNotindexed[nCol];
187610 for(iCol=0; iCol<nCol; iCol++){
187625 for(iCol=0; iCol<nCol; iCol++){
191943 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
191966 }while( iCol<nCol );
191969 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
191970 fts3EvalUpdateCounts(pExpr->pRight, nCol);
193000 int nCol; /* Number of entries in azCol[] */
193427 for(ii=0; ii<pParse->nCol; ii++){
193868 int nCol, /* Number of entries in azCol[] */
193881 sParse.nCol = nCol;
193931 int nCol, /* Number of entries in azCol[] */
193938 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
194092 int nCol;
194121 nCol = argc-2;
194122 azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
194127 for(ii=0; ii<nCol; ii++){
194134 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
194140 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
202402 int nCol; /* Number of columns in table */
203186 iStart = pExpr->iPhrase * p->nCol;
203188 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
203204 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
203263 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
203279 int iStart = iPhrase * p->nCol * 3;
203282 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
203329 nVal = pInfo->nCol;
203333 nVal = pInfo->nCol * pInfo->nPhrase;
203337 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
203342 nVal = pInfo->nCol * pInfo->nPhrase * 3;
203472 for(iCol=0; iCol<pInfo->nCol; iCol++){
203559 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
203579 for(iCol=0; iCol<pInfo->nCol; iCol++){
203601 for(iCol=0; iCol<pInfo->nCol; iCol++){
203677 sInfo.nCol = pTab->nColumn;
218405 int nCol; /* Number of columns in current object */
218957 pIter->nCol = 0;
219207 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
219208 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
219214 pIter->azTblType = &azNew[nCol];
219215 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
219216 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
219217 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
219218 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
219448 int nCol = 0;
219476 nCol = sqlite3_column_count(pStmt);
219477 rbuAllocateIterArrays(p, pIter, nCol);
219479 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
219752 for(iCol=0; iCol<pIter->nCol; iCol++){
220482 pIter->nCol = nBind;
220567 pIter->nCol = pIter->nTblCol;
221421 int iCol = p->objiter.nCol; /* Index of rbu_control column */
221502 for(i=0; i<pIter->nCol; i++){
221535 assertColumnName(pIter->pSelect, pIter->nCol+1,
221538 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
221539 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
221592 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
221603 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
221604 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
221605 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
224988 int nCol; /* Number of columns in zTab */
225023 int nCol; /* Number of columns in table zName */
225431 assert( pTab->nCol-1==pSession->hook.xCount(pSession->hook.pCtx) );
225435 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
225436 for(i=0; i<pTab->nCol; i++){
225520 for(i=0; i<pTab->nCol; i++){
225570 for(iCol=0; iCol<pTab->nCol; iCol++){
225604 int nCol,
225613 for(iCol=0; iCol<nCol; iCol++){
225705 for(i=0; i<pTab->nCol; i++){
225730 for(i=0; i<pTab->nCol; i++){
225775 for(iCol=0; iCol<pTab->nCol; iCol++){
226074 if( pTab->nCol==0 ){
226078 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &pTab->azDflt, &abPK,
226083 for(i=0; i<pTab->nCol; i++){
226095 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
226112 int nCol = 0;
226121 pTab->zName, &nCol, 0, &azCol, &azDflt, &abPK,
226125 if( pTab->nCol>nCol || pTab->bRowid!=bRowid ){
226129 int nOldCol = pTab->nCol;
226130 for(ii=0; ii<nCol; ii++){
226131 if( ii<pTab->nCol ){
226143 pTab->nCol = nCol;
226149 pSession->nMaxChangesetSize += (nCol - nOldCol);
226150 pSession->nMaxChangesetSize += sessionVarintLen(nCol);
226169 int nCol, /* Number of columns now in table */
226174 while( pOld->nRecordField<nCol ){
226369 for(ii=0; ii<pTab->nCol; ii++){
226397 if( (*pp)->nRecordField!=pTab->nCol ){
226398 sessionUpdateOneChange(pSession, &rc, pp, pTab->nCol, pStmt);
226461 for(ii=0; ii<pTab->nCol; ii++){
226479 for(ii=pTab->bRowid; ii<pTab->nCol; ii++){
226581 if( (pTab->nCol-pTab->bRowid)<nExpect ){
226585 if( (pTab->nCol-pTab->bRowid)!=nExpect ){
226642 for(i=0; i<(pTab->nCol-pTab->bRowid); i++){
226681 for(i=0; i<(pTab->nCol-pTab->bRowid); i++){
226695 pC->nRecordField = pTab->nCol;
226881 int nCol,
226890 for(i=0; i<nCol; i++){
226904 int nCol,
226914 for(i=0; i<nCol; i++){
226998 for(ii=0; ii<pTab->nCol; ii++){
227015 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
227036 pDiffCtx->nOldOff = pTab->nCol;
227084 int nCol; /* Columns in zFrom.zTbl */
227088 rc = sessionTableInfo(0, db, zFrom, zTbl, &nCol, 0, &azCol, 0, &abPK,
227092 if( pTo->nCol!=nCol ){
227096 for(i=0; i<nCol; i++){
227117 zExpr = sessionExprComparePK(pTo->nCol,
227594 int nCol, /* Number of columns in table */
227607 for(i=0; i<nCol; i++){
227657 int nCol, /* Number of columns in table */
227683 for(i=0; i<nCol; i++){
227692 " AND (?%d OR ?%d IS %w.%w)", i+1+nCol, i+1, zTab, azCol[i]
227723 for(i=0; i<nCol; i++){
227757 int nCol, /* Number of columns in table */
227765 for(i=0; i<nCol && rc==SQLITE_OK; i++){
227834 sessionAppendVarint(pBuf, pTab->nCol, pRc);
227835 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
227887 int nOldCol = pTab->nCol;
227891 if( rc==SQLITE_OK && pTab->nCol!=nOldCol ){
227901 zName, pTab->bRowid, pTab->nCol, pTab->azCol, pTab->abPK, &pSel
227910 rc = sessionSelectBind(pSel, pTab->nCol, pTab->abPK, p);
227917 for(iCol=0; iCol<pTab->nCol; iCol++){
227925 rc = sessionAppendDelete(&buf, bPatchset, p, pTab->nCol,pTab->abPK);
228261 int nCol /* Number of values in record */
228265 for(i=0; i<nCol; i++){
228328 int nCol, /* Number of values in record */
228338 for(i=0; i<nCol && rc==SQLITE_OK; i++){
228408 int nCol = 0;
228413 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
228421 if( nCol<0 || nCol>65536 ){
228424 rc = sessionInputBuffer(pIn, nRead+nCol+100);
228425 nRead += nCol;
228451 int nCol, /* Number of columns in record */
228457 for(i=0; rc==SQLITE_OK && i<nCol; i++){
228502 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
228503 if( p->nCol>0 ){
228506 nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
228515 size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
228526 p->abPK = (u8*)&p->apValue[p->nCol*2];
228527 p->zTab = p->abPK ? (char*)&p->abPK[p->nCol] : 0;
228560 for(i=0; i<p->nCol*2; i++){
228563 memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
228608 nVal = p->nCol * 2;
228611 for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
228613 nVal = p->nCol;
228620 sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
228621 sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
228626 p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0);
228632 p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty);
228641 for(i=0; i<p->nCol; i++){
228645 p->apValue[i] = p->apValue[i+p->nCol];
228647 p->apValue[i+p->nCol] = 0;
228663 for(i=0; i<p->nCol; i++){
228664 if( p->abPK[i]==0 && p->apValue[i+p->nCol]==0 ){
228731 *pnCol = pIter->nCol;
228749 if( pnCol ) *pnCol = pIter->nCol;
228774 if( iVal<0 || iVal>=pIter->nCol ){
228802 if( iVal<0 || iVal>=pIter->nCol ){
228805 *ppValue = pIter->apValue[pIter->nCol+iVal];
228814 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
228836 if( iVal<0 || iVal>=pIter->nCol ){
228858 *pnOut = pIter->nCol;
228875 for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
228893 int nCol = 0; /* Number of cols in current table */
228930 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
228932 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
228951 rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
228964 apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
228969 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
228978 rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0);
228980 rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0);
228986 for(iCol=0; iCol<nCol; iCol++){
228987 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
228994 for(iCol=0; iCol<nCol; iCol++){
228999 for(iCol=0; iCol<nCol*2; iCol++){
229002 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
229095 int nCol; /* Size of azCol[] and abPK[] arrays */
229128 int nCol = pIter->nCol;
229129 int nU32 = (pIter->nCol+33)/32;
229142 for(ii=0; ii<pIter->nCol; ii++){
229151 if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32));
229198 for(ii=0; ii<pIter->nCol; ii++){
229211 for(ii=0; ii<pIter->nCol; ii++){
229304 for(i=0; i<p->nCol; i++){
229315 if( nPk<p->nCol ){
229317 sessionAppendInteger(&buf, p->nCol+1, &rc);
229321 for(i=0; i<p->nCol; i++){
229361 "main", zTab, p->bRowid, p->nCol, p->azCol, p->abPK, &p->pSelect
229386 for(i=0; i<p->nCol; i++){
229392 for(i=1; i<p->nCol; i++){
229473 int nCol, /* Number of columns */
229486 for(i=0; rc==SQLITE_OK && i<nCol; i++){
229525 int nCol; /* Number of columns in table */
229530 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
229533 nCol, p->abPK, pSelect
229538 for(ii=0; rc==SQLITE_OK && ii<nCol; ii++){
229542 sqlite3_bind_int(pSelect, ii+1+nCol, (pVal==0));
229579 sessionAppendVarint(&p->rebase, p->nCol, &rc);
229580 sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
229592 for(i=0; i<p->nCol; i++){
229650 int nCol;
229654 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
229754 int nCol;
229761 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
229777 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
229778 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
229779 rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
229803 for(i=0; rc==SQLITE_OK && i<nCol; i++){
229850 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
229912 sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
229913 sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
229953 size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
229957 pIter2->nCol = pApply->nCol;
230028 int nCol;
230032 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
230051 sApply.nCol = 0;
230078 &sApply.nCol, &zTab, &sApply.azCol, 0, &sApply.abPK, &sApply.bRowid
230081 for(i=0; i<sApply.nCol; i++){
230085 if( sApply.nCol==0 ){
230091 else if( sApply.nCol<nCol ){
230096 zTab, sApply.nCol, nCol
230099 else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
230106 sApply.nCol = nCol;
230151 sIter.nCol = nFk;
230357 for(i=0; i<pTab->nCol; i++){
230390 for(i=0; i<pTab->nCol; i++){
230456 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
230457 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
230475 sessionSkipRecord(&a1, pTab->nCol);
230476 sessionSkipRecord(&a2, pTab->nCol);
230490 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
230513 int nCol,
230516 if( pTab->azCol && nCol<pTab->nCol ){
230518 for(ii=0; ii<pTab->nCol; ii++){
230519 u8 bPK = (ii < nCol) ? abPK[ii] : 0;
230524 return (pTab->nCol==nCol && 0==memcmp(abPK, pTab->abPK, nCol));
230530 int nCol,
230540 assert( nCol<pTab->nCol );
230549 for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
230592 for(ii=0; ii<nCol; ii++){
230596 for(ii=0; ii<(pTab->nCol-nCol); ii++){
230602 for(ii=0; ii<(pTab->nCol-nCol); ii++){
230630 int nCol = 0;
230633 sqlite3changeset_pk(pIter, &abPK, &nCol);
230644 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nTab+1);
230649 pTab->nCol = nCol;
230651 memcpy(pTab->abPK, abPK, nCol);
230652 pTab->zName = (char*)&pTab->abPK[nCol];
230656 pTab->nCol = 0;
230674 if( !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
230692 int nCol = 0;
230714 sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
230718 if( rc==SQLITE_OK && nCol<pTab->nCol ){
230720 rc = sessionChangesetExtendRecord(pGrp, pTab, nCol, op, aRec, nRec, pBuf);
231056 int nCol, /* Number of columns in each record */
231065 for(i=0; i<nCol; i++){
231120 for(i=0; i<pIter->nCol; i++){
231139 for(i=0; i<pIter->nCol; i++){
231204 sessionAppendVarint(&sOut, pIter->nCol, &rc);
231205 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
231239 sessionSkipRecord(&pCsr, pIter->nCol);
231242 sessionAppendRecordMerge(&sOut, pIter->nCol,
231260 sessionAppendRecordMerge(&sOut, pIter->nCol,
232179 int nCol;
232235 int nCol; /* Number of columns */
234894 int nCol;
234902 nCol = pApi->xColumnCount(pFts);
234922 for(i=0; i<nCol; i++){
236123 p->abUnindexed[p->nCol] = 1;
236130 p->azCol[p->nCol++] = zCol;
236144 for(i=0; i<p->nCol; i++){
236325 for(i=0; i<pConfig->nCol; i++){
236350 for(i=0; zSql && i<pConfig->nCol; i++){
236959 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
236963 pColset->nCol = 1;
237080 iCol = pConfig->nCol;
238590 nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
238706 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
238710 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
238712 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
238718 for(i=0; i<nCol; i++){
238722 for(j=nCol; j>i; j--){
238726 pNew->nCol = nCol+1;
238730 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
238744 int nCol = pParse->pConfig->nCol;
238747 sizeof(Fts5Colset) + sizeof(int)*nCol
238752 for(i=0; i<nCol; i++){
238753 if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
238754 pRet->aiCol[pRet->nCol++] = i;
238778 for(iCol=0; iCol<pConfig->nCol; iCol++){
238781 if( iCol==pConfig->nCol ){
238808 sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
238827 while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
238839 pColset->nCol = iOut;
238863 if( pNear->pColset->nCol==0 ){
239243 int nCol = pNear->pColset->nCol;
239244 if( nCol==1 ){
239248 for(i=1; i<pNear->pColset->nCol; i++){
239324 if( pColset->nCol>1 ) zRet = fts5PrintfAppend(zRet, "{");
239325 for(ii=0; ii<pColset->nCol; ii++){
239327 pConfig->azCol[pColset->aiCol[ii]], ii==pColset->nCol-1 ? "" : " "
239331 zRet = fts5PrintfAppend(zRet, "%s : ", pColset->nCol>1 ? "}" : "");
239455 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
239667 for(i=0; i<pColset->nCol; i++){
243968 for(i=0; i<pColset->nCol; i++){
244157 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
244164 if( i==pColset->nCol ){
244178 if( pColset->nCol==1 ){
244279 int *aiColEnd = &aiCol[pIter->pColset->nCol];
244344 else if( pIter->pColset->nCol==0 ){
244354 if( pConfig->nCol<=100 ){
244356 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
247810 int nCol = p->pConfig->nCol;
247814 memset(anSize, 0, sizeof(i64) * nCol);
247820 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
250153 const int nCol = pConfig->nCol;
250190 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
250201 if( iCol==nCol+1 ){
250216 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
250259 if( iSort==(pConfig->nCol+1) && bSeenMatch ){
250308 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
251266 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
251283 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
251286 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
251300 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
251462 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
251513 if( iCol<0 || iCol>=pTab->pConfig->nCol ){
251548 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
251593 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
251649 if( aInst[1]<0 || aInst[1]>=nCol ){
251729 for(i=0; i<pConfig->nCol; i++){
251736 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
251755 for(i=0; i<pConfig->nCol; i++){
251758 }else if( iCol<pConfig->nCol ){
252201 if( iCol==pConfig->nCol ){
252206 if( iCol==pConfig->nCol ){
252212 }else if( iCol==pConfig->nCol+1 ){
252826 int nCol = pC->nCol + 1;
252830 zBind = sqlite3_malloc64(1 + nCol*2);
252832 for(i=0; i<nCol; i++){
253015 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
253026 int nDefn = 32 + pConfig->nCol*10;
253027 char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
253035 for(i=0; i<pConfig->nCol; i++){
253142 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
253272 int nCol = p->pConfig->nCol;
253279 for(i=0; i<nCol; i++){
253396 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
253489 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
253522 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
253671 aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
253673 aColSize = (int*)&aTotalSize[pConfig->nCol];
253674 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
253695 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
253734 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
253810 int *aCol, int nCol, /* Array to populate */
253815 for(i=0; i<nCol; i++){
253831 int nCol = p->pConfig->nCol; /* Number of user columns in table */
253844 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
253865 for(i=0; i<p->pConfig->nCol; i++){
253868 }else if( iCol<p->pConfig->nCol ){
256905 i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
256913 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
257004 int nCol = pCsr->pFts5->pConfig->nCol;
257016 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
257021 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
257040 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
257041 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
257070 if( ii>=nCol ){
257081 assert_nc( iPos>=0 && iPos<nCol );
257082 if( iPos>=nCol ){
257118 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
257119 if( pCsr->iCol==nCol ){
257254 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){