Lines Matching refs:nCol
11589 i16 nCol; /* Number of columns in this table */ member
11681 int nCol; /* Number of columns in this key */ member
65295 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
65297 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
65302 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
65305 for(i=0; i<nCol; i++){
65836 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
65839 for(i=0; i<nCol; i++){
78974 for(iCol=0; iCol<pTab->nCol; iCol++) {
78979 if( iCol==pTab->nCol ){
79003 for(j=0; j<pFKey->nCol; j++){
79067 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
79068 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
82918 assert( pTab->nCol>0 );
82946 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
82997 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
83005 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
83010 if( iCol<pTab->nCol ){
84214 assert( pExpr->pTab && j<pExpr->pTab->nCol );
87186 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
87189 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
87191 assert( p1>=0 && p1<(pTab->nCol*2+2) );
88968 pCol = &pNew->aCol[pNew->nCol-1];
89121 pNew->nCol = pTab->nCol;
89122 assert( pNew->nCol>0 );
89123 nAlloc = (((pNew->nCol-1)/8)*8)+8;
89124 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
89131 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
89132 for(i=0; i<pNew->nCol; i++){
89442 int nCol; /* Number of columns in index + pk/rowid */
89503 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
89504 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
89505 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
89521 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
89557 int nCol; /* Number of columns in index being sampled */
89568 nCol = sqlite3_value_int(argv[0]);
89569 assert( nCol>0 );
89570 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
89572 assert( nKeyCol<=nCol );
89581 + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */
89582 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
89594 p->nCol = nCol;
89608 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
89613 pSpace = (u8*)(&p->a[mxSample+nCol]);
89614 for(i=0; i<(mxSample+nCol); i++){
89621 for(i=0; i<nCol; i++){
89663 int nCol = pAccum->nCol;
89666 for(i=pNew->iCol+1; i<nCol; i++){
89765 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
89805 for(i=(p->nCol-2); i>=iChng; i--){
89816 for(j=iChng; j<p->nCol; j++){
89878 assert( p->nCol>0 );
89879 assert( iChng<p->nCol );
89883 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
89893 for(i=iChng; i<p->nCol; i++){
89914 tRowcnt nLt = p->current.anLt[p->nCol-1];
89920 sampleInsert(p, &p->current, p->nCol-1);
89925 for(i=0; i<(p->nCol-1); i++){
90060 char *zRet = sqlite3MallocZero(p->nCol * 25);
90066 for(i=0; i<p->nCol; i++){
90177 int nCol; /* Number of columns in pIdx. "N" */
90186 nCol = pIdx->nKeyCol;
90188 nColTest = nCol - 1;
90190 nCol = pIdx->nColumn;
90192 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
90256 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
90375 int regSampleRowid = regCol + nCol;
90380 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
90398 for(i=0; i<nCol; i++){
90402 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
90680 int nCol = pIndex->nKeyCol+1;
90686 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
90692 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
90741 int nCol = 1;
90747 nCol = pIdx->nSampleCol-1;
90748 pIdx->aAvgEq[nCol] = 1;
90750 for(iCol=0; iCol<nCol; iCol++){
90902 int nCol = 1; /* Number of columns in index */
90910 nCol = pIdx->nSampleCol;
90911 if( bStat3 && nCol>1 ) continue;
90917 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
90918 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
90919 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
91817 assert( iCol<pTab->nCol );
91820 assert( pTab->iPKey<pTab->nCol );
92470 for(i=0; i<pTable->nCol; i++, pCol++){
92969 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
92976 for(i=0; i<p->nCol; i++){
92983 if( (p->nCol & 0x7)==0 ){
92985 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
92992 pCol = &p->aCol[p->nCol];
93002 p->nCol++;
93014 if( p==0 || NEVER(p->nCol<1) ) return;
93015 p->aCol[p->nCol-1].notNull = (u8)onError;
93119 if( p==0 || NEVER(p->nCol<1) ) return;
93120 pCol = &p->aCol[p->nCol-1];
93143 pCol = &(p->aCol[p->nCol-1]);
93199 iCol = pTab->nCol - 1;
93206 for(iCol=0; iCol<pTab->nCol; iCol++){
93279 i = p->nCol-1;
93428 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
93441 n += 35 + 6*p->nCol;
93451 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
93518 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
93534 assert( x<pIdx->pTable->nCol );
93542 static int hasColumn(const i16 *aiCol, int nCol, int x){
93543 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
93672 if( nPk<pTab->nCol ){
93673 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
93674 for(i=0, j=nPk; i<pTab->nCol; i++){
93683 assert( pTab->nCol==j );
93685 pPk->nColumn = pTab->nCol;
93843 p->nCol = pSelTab->nCol;
93845 pSelTab->nCol = 0;
94044 if( pTable->nCol>0 ) return 0;
94061 if( pTable->nCol<0 ){
94065 assert( pTable->nCol>=0 );
94080 pTable->nCol = -1;
94094 pTable->nCol = pSelTab->nCol;
94096 pSelTab->nCol = 0;
94102 pTable->nCol = 0;
94127 pTab->nCol = 0;
94493 int nCol;
94499 int iCol = p->nCol-1;
94507 nCol = 1;
94514 nCol = pFromCol->nExpr;
94516 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
94528 z = (char*)&pFKey->aCol[nCol];
94534 pFKey->nCol = nCol;
94536 pFKey->aCol[0].iFrom = p->nCol-1;
94538 for(i=0; i<nCol; i++){
94540 for(j=0; j<p->nCol; j++){
94546 if( j>=p->nCol ){
94555 for(i=0; i<nCol; i++){
94710 i16 nCol, /* Total number of columns in the index */
94718 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
94719 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
94720 sizeof(i16)*nCol + /* Index.aiColumn */
94721 sizeof(u8)*nCol); /* Index.aSortOrder */
94725 p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
94726 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
94727 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
94729 p->nColumn = nCol;
94730 p->nKeyCol = nCol - 1;
94935 pTab->aCol[pTab->nCol-1].zName);
95001 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
95004 if( j>=pTab->nCol ){
96134 int nCol = pIdx->nColumn;
96139 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
96141 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
96145 for(i=0; i<nCol; i++){
97347 pParse->nMem += (1 + pTab->nCol);
97352 for(iCol=0; iCol<pTab->nCol; iCol++){
97505 int nCol;
97518 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
97519 regBase = sqlite3GetTempRange(pParse, nCol);
97521 for(j=0; j<nCol; j++){
97534 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
97536 sqlite3ReleaseTempRange(pParse, regBase, nCol);
99544 int nCol = pFKey->nCol; /* Number of columns in parent key */
99560 if( nCol==1 ){
99573 assert( nCol>1 );
99574 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
99580 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){
99592 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
99602 for(i=0; i<nCol; i++){
99617 for(j=0; j<nCol; j++){
99623 if( j==nCol ) break;
99625 if( i==nCol ) break; /* pIdx is usable */
99697 for(i=0; i<pFKey->nCol; i++){
99734 int nCol = pFKey->nCol;
99735 int regTemp = sqlite3GetTempRange(pParse, nCol);
99740 for(i=0; i<nCol; i++){
99755 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
99756 for(i=0; i<nCol; i++){
99770 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
99771 sqlite3IndexAffinityStr(v,pIdx), nCol);
99775 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
99908 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
99909 assert( pIdx!=0 || pFKey->nCol==1 );
99925 for(i=0; i<pFKey->nCol; i++){
100121 for(i=0; i<p->nCol; i++){
100148 for(i=0; i<p->nCol; i++){
100151 for(iKey=0; iKey<pTab->nCol; iKey++){
100265 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
100266 for(i=0; i<pFKey->nCol; i++){
100274 assert( pFKey->nCol==1 || (aiFree && pIdx) );
100282 for(i=0; i<pFKey->nCol; i++){
100350 assert( aiCol || pFKey->nCol==1 );
100411 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
100527 assert( aiCol || pFKey->nCol==1 );
100529 for(i=0; i<pFKey->nCol; i++){
100539 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
100796 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
100881 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
100887 for(i=0; i<pTab->nCol; i++){
101340 pParse->nMem += pTab->nCol + 1;
101364 for(j=0; j<pTab->nCol; j++){
101374 if( j>=pTab->nCol ){
101405 dest.nSdst = pTab->nCol;
101484 for(i=0; i<pTab->nCol; i++){
101488 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
101491 pTabList, 0, pTab->nCol-nHidden, nColumn);
101550 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
101582 for(i=0; i<pTab->nCol; i++){
101611 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
101613 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
101668 for(i=0; i<pTab->nCol; i++){
101712 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
101737 pTab, regData-2-pTab->nCol, onError, endOfLoop);
101904 int nCol; /* Number of columns */
101920 nCol = pTab->nCol;
101940 for(i=0; i<nCol; i++){
102336 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
102338 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
102626 if( pDest->nCol!=pSrc->nCol ){
102632 for(i=0; i<pDest->nCol; i++){
102868 int nCol;
102884 nCol = sqlite3_column_count(pStmt);
102895 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
102899 for(i=0; i<nCol; i++){
102908 azVals = &azCols[nCol];
102909 for(i=0; i<nCol; i++){
102917 if( xCallback(pArg, nCol, azVals, azCols) ){
105770 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
105790 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
105965 for(j=0; j<pFK->nCol; j++){
106029 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
106066 assert( iKey>=0 && iKey<pTab->nCol );
106080 for(j=0; j<pFK->nCol; j++){
106086 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
106087 sqlite3IndexAffinityStr(v,pIdx), pFK->nCol);
106263 for(j=0; j<pTab->nCol; j++){
106315 assert( iCol>=0 && iCol<pTab->nCol );
107877 for(i=0; i<pTab->nCol; i++){
108043 for(j=0; j<pRightTab->nCol; j++){
109035 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
109175 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
109223 int nCol; /* Number of columns in the result set */
109229 nCol = pEList->nExpr;
109230 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
109233 nCol = 0;
109236 *pnCol = nCol;
109239 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
109332 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
109337 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
109380 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
109591 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
109644 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
109651 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
110107 int nCol; /* Number of columns in result set */
110110 nCol = p->pEList->nExpr;
110111 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
110116 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
110132 sqlite3VdbeChangeP2(v, addr, nCol);
111743 selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
111866 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
111979 for(j=0; j<pTab->nCol; j++){
112890 int nCol;
112899 nCol = nGroupBy;
112903 nCol++;
112907 regBase = sqlite3GetTempRange(pParse, nCol);
112926 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
112929 sqlite3ReleaseTempRange(pParse, regBase, nCol);
112933 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
113280 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
113290 need = nCol*2;
113292 need = nCol;
113306 p->nColumn = nCol;
113307 for(i=0; i<nCol; i++){
113312 }else if( (int)p->nColumn!=nCol ){
113324 for(i=0; i<nCol; i++){
114629 assert( i<pTab->nCol );
114761 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
114763 aRegIdx = aXRef+pTab->nCol;
114767 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
114785 for(j=0; j<pTab->nCol; j++){
114797 if( j>=pTab->nCol ){
114877 pParse->nMem += pTab->nCol;
114883 pParse->nMem += pTab->nCol;
115035 for(i=0; i<pTab->nCol; i++){
115068 for(i=0; i<pTab->nCol; i++){
115117 for(i=0; i<pTab->nCol; i++){
115292 for(i=0; i<pTab->nCol; i++){
115315 pParse->nMem += pTab->nCol+1;
115319 for(i=0; i<pTab->nCol; i++){
115323 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
116283 for(iCol=0; iCol<pTab->nCol; iCol++){
116481 pTab->nCol = pParse->pNewTable->nCol;
116482 pParse->pNewTable->nCol = 0;
120805 mxBitCol = MIN(BMS-1,pTable->nCol);
120806 testcase( pTable->nCol==BMS-1 );
120807 testcase( pTable->nCol==BMS-2 );
120812 nKeyCol += pTable->nCol - BMS + 1;
120851 for(i=BMS-1; i<pTable->nCol; i++){
124365 testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
124366 testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
124367 if( !pWInfo->okOnePass && pTab->nCol<BMS && HasRowid(pTab) ){
124373 assert( n<=pTab->nCol );
132668 for(iCol=0; iCol<pTab->nCol; iCol++){
132674 if( iCol==pTab->nCol ){
135522 int nCol; /* Number of table columns */
135528 nCol = sqlite3_column_count(pStmt);
135529 for(i=0; i<nCol; i++){
135535 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
135539 char *p = (char *)&azCol[nCol];
135540 for(i=0; i<nCol; i++){
135551 *pnCol = nCol;
135586 int nCol = 0; /* Number of columns in the FTS table */
135748 aCol[nCol++] = z;
135764 if( nCol==0 ){
135767 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
135773 for(j=0; j<nCol; j++){
135776 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
135777 nCol--;
135786 if( nCol==0 ){
135790 nCol = 1;
135808 nCol * sizeof(char *) + /* azColumn */
135810 nCol * sizeof(u8) + /* abNotindexed */
135821 p->nColumn = nCol;
135838 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
135847 zCsr = (char *)&p->abNotindexed[nCol];
135856 for(iCol=0; iCol<nCol; iCol++){
135869 for(iCol=0; iCol<nCol; iCol++){
141023 int nCol; /* Number of entries in azCol[] */
141449 for(ii=0; ii<pParse->nCol; ii++){
141864 int nCol, /* Number of entries in azCol[] */
141877 sParse.nCol = nCol;
141927 int nCol, /* Number of entries in azCol[] */
141934 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
142116 int nCol;
142149 nCol = argc-2;
142150 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
142155 for(ii=0; ii<nCol; ii++){
142162 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
142168 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
150210 int nCol; /* Number of columns in table */
150987 iStart = pExpr->iPhrase * p->nCol;
150989 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
151060 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
151076 int iStart = iPhrase * p->nCol * 3;
151079 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
151126 nVal = pInfo->nCol;
151130 nVal = pInfo->nCol * pInfo->nPhrase;
151134 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
151139 nVal = pInfo->nCol * pInfo->nPhrase * 3;
151255 for(iCol=0; iCol<pInfo->nCol; iCol++){
151338 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
151357 for(iCol=0; iCol<pInfo->nCol; iCol++){
151374 for(iCol=0; iCol<pInfo->nCol; iCol++){
151446 sInfo.nCol = pTab->nColumn;
157550 int nCol; /* Number of columns in current object */
157782 pIter->nCol = 0;
157973 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
157974 int nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
157980 pIter->azTblType = &azNew[nCol];
157981 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
157982 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
157983 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
157984 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
158197 int nCol = 0;
158225 nCol = sqlite3_column_count(pStmt);
158226 rbuAllocateIterArrays(p, pIter, nCol);
158228 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
158898 pIter->nCol = nBind;
158953 pIter->nCol = pIter->nTblCol;
159455 int iCol = p->objiter.nCol; /* Index of rbu_control column */
159548 for(i=0; i<pIter->nCol; i++){
159579 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
159580 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
159581 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
159593 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
159604 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
159605 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
159606 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);