Lines Matching refs:nCol
18806 i16 nCol; /* Number of columns in this table */ member
18959 int nCol; /* Number of columns in this key */ member
33248 int nCol, in sqlite3TreeViewColumnList() argument
33254 for(i=0; i<nCol; i++){ in sqlite3TreeViewColumnList()
33256 int colMoreToFollow = i<(nCol - 1); in sqlite3TreeViewColumnList()
33351 pItem->pSTab->zName, pItem->pSTab->nCol, pItem->pSTab, in sqlite3TreeViewSrcList()
33402 sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1); in sqlite3TreeViewSrcList()
85281 int nCol = pIdx->nColumn; /* Number of index columns including rowid */ local
85283 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
85288 assert( pRec->pKeyInfo->nAllField==nCol );
85291 for(i=0; i<nCol; i++){
85832 int nCol = pRec->pKeyInfo->nAllField; local
85835 for(i=0; i<nCol; i++){
91398 nRealCol = pTab->nCol;
91428 preupdate.pKeyinfo->nKeyField = pTab->nCol;
91451 for(i=0; i<pTab->nCol; i++){
93697 assert( sizeof(sqlite3_value*)*UMXV(p->pTab->nCol) < 0x7fffffff );
93698 nByte = sizeof(sqlite3_value*)*p->pTab->nCol;
97611 for(i=0; i<pTab->nCol; i++){
103801 for(j=0; j<pFKey->nCol; j++){
103897 aOp[1].p4.i = pTab->nCol+1;
103898 aOp[3].p2 = pTab->nCol;
108221 assert( n < pExTab->nCol );
108225 testcase( pExTab->nCol==BMS-1 );
108226 testcase( pExTab->nCol==BMS );
108227 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
108383 assert( pTab->nCol>0 || pParse->nErr );
108400 assert( pEList->nExpr==pTab->nCol );
108598 iCol = pTab->nCol;
108601 if( iCol<pTab->nCol ){
108626 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
108909 testcase( pTab->nCol==63 );
108910 testcase( pTab->nCol==64 );
108911 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
110370 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
113244 && ALWAYS(p->iColumn<p->y.pTab->nCol)
115179 assert( iCol<pTab->nCol );
115567 int nCol;
115574 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
115576 sqlite3SubselectError(pParse, nCol, 1);
115682 p1 = pExpr->iTable * (pTab->nCol+1) + 1
115686 assert( iCol>=-1 && iCol<pTab->nCol );
115688 assert( p1>=0 && p1<(pTab->nCol*2+2) );
118105 pCol = &pNew->aCol[pNew->nCol-1];
118298 pNew->nCol = pTab->nCol;
118299 assert( pNew->nCol>0 );
118300 nAlloc = (((pNew->nCol-1)/8)*8)+8;
118301 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
118308 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*(size_t)pNew->nCol);
118309 for(i=0; i<pNew->nCol; i++){
119308 if( pTab==0 || iCol>=pTab->nCol ){
119347 if( iCol<sParse.pNewTable->nCol ){
119363 for(i=0; i<sParse.pNewTable->nCol; i++){
119373 for(i=0; i<pFKey->nCol; i++){
119735 for(i=0; i<sParse.pNewTable->nCol; i++){
119901 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
119908 if( iCol<pTab->nCol-1 ){
119983 if( pTab->nCol<=1 ){
120027 pParse->nMem += pTab->nCol;
120037 for(i=0; i<pTab->nCol; i++){
120387 int nCol; /* Number of columns in index + pk/rowid */
120452 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
120453 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
120454 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
120471 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
120507 int nCol; /* Number of columns in index being sampled */
120519 nCol = sqlite3_value_int(argv[0]);
120520 assert( nCol>0 );
120521 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
120523 assert( nKeyCol<=nCol );
120533 + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */
120534 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
120547 p->nCol = nCol;
120562 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
120567 pSpace = (u8*)(&p->a[mxSample+nCol]);
120568 for(i=0; i<(mxSample+nCol); i++){
120575 for(i=0; i<nCol; i++){
120616 int nCol = pAccum->nCol;
120619 for(i=pNew->iCol+1; i<nCol; i++){
120718 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
120755 for(i=(p->nCol-2); i>=iChng; i--){
120767 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
120774 for(j=iChng; j<p->nCol; j++){
120815 assert( p->nCol>0 );
120816 assert( iChng<p->nCol );
120821 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
120836 for(i=iChng; i<p->nCol; i++){
120857 nLt = p->current.anLt[p->nCol-1];
120862 sampleInsert(p, &p->current, p->nCol-1);
120867 for(i=0; i<(p->nCol-1); i++){
121011 sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100);
121012 for(i=0; i<p->nCol; i++){
121142 pStat1->nCol = 3;
121160 int nCol; /* Number of columns in pIdx. "N" */
121169 nCol = pIdx->nKeyCol;
121171 nColTest = nCol - 1;
121173 nCol = pIdx->nColumn;
121175 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
121251 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
121391 int regSampleRowid = regCol + nCol;
121404 int mxCol = nCol;
121431 assert( sqlite3NoTempsInRange(pParse, regEq, regCol+nCol) );
121442 for(i=0; i<nCol; i++){
121445 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
121720 int nCol = pIndex->nKeyCol+1;
121726 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
121732 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
121788 int nCol = 1;
121794 nCol = pIdx->nSampleCol-1;
121795 pIdx->aAvgEq[nCol] = 1;
121797 for(iCol=0; iCol<nCol; iCol++){
121953 int nCol = 1; /* Number of columns in index */
121966 nCol = pIdx->nSampleCol;
121972 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
121973 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
121974 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
122913 assert( iCol<pTab->nCol );
122916 assert( pTab->iPKey<pTab->nCol );
123758 for(i=0; i<pTable->nCol; i++, pCol++){
123768 pTable->nCol = 0;
124150 assert( iCol<pTab->nCol );
124492 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
124539 if( p->nCol && sqlite3ColumnIndex(p, z)>=0 ){
124544 aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
124550 pCol = &p->aCol[p->nCol];
124577 if( p->nCol<=0xff ){
124579 p->aHx[h] = p->nCol;
124581 p->nCol++;
124597 if( p==0 || NEVER(p->nCol<1) ) return;
124598 pCol = &p->aCol[p->nCol-1];
124608 if( pIdx->aiColumn[0]==p->nCol-1 ){
124730 pCol = &(p->aCol[p->nCol-1]);
124837 iCol = pTab->nCol - 1;
124934 i = p->nCol-1;
124969 pCol = &(pTab->aCol[pTab->nCol-1]);
125108 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
125121 n += 35 + 6*p->nCol;
125132 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
125215 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
125231 assert( x<pIdx->pTable->nCol );
125241 static int hasColumn(const i16 *aiCol, int nCol, int x){
125242 while( nCol-- > 0 ){
125355 for(i=0; i<pTab->nCol; i++){
125477 for(i=0; i<pTab->nCol; i++){
125482 for(i=0, j=nPk; i<pTab->nCol; i++){
125676 for(ii=0; ii<p->nCol; ii++){
125743 for(ii=0; ii<p->nCol; ii++){
125851 p->nCol = p->nNVCol = pSelTab->nCol;
125853 pSelTab->nCol = 0;
126100 assert( pTable->nCol<=0 );
126117 if( pTable->nCol<0 ){
126121 assert( pTable->nCol>=0 );
126138 pTable->nCol = -1;
126151 pTable->nCol = 0;
126161 &pTable->nCol, &pTable->aCol);
126163 && pTable->nCol==pSel->pEList->nExpr
126173 pTable->nCol = pSelTab->nCol;
126176 pSelTab->nCol = 0;
126180 pTable->nNVCol = pTable->nCol;
126197 if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0;
126616 int nCol;
126622 int iCol = p->nCol-1;
126630 nCol = 1;
126637 nCol = pFromCol->nExpr;
126639 nByte = SZ_FKEY(nCol) + pTo->n + 1;
126652 z = (char*)&pFKey->aCol[nCol];
126661 pFKey->nCol = nCol;
126663 pFKey->aCol[0].iFrom = p->nCol-1;
126665 for(i=0; i<nCol; i++){
126667 for(j=0; j<p->nCol; j++){
126673 if( j>=p->nCol ){
126685 for(i=0; i<nCol; i++){
126865 int nCol, /* Total number of columns in the index */
126872 assert( nCol <= 2*db->aLimit[SQLITE_LIMIT_COLUMN] );
126874 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
126875 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
126876 sizeof(i16)*nCol + /* Index.aiColumn */
126877 sizeof(u8)*nCol); /* Index.aSortOrder */
126881 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
126882 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
126883 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
126885 assert( nCol>0 );
126886 p->nColumn = (u16)nCol;
126887 p->nKeyCol = (u16)(nCol - 1);
127121 Column *pCol = &pTab->aCol[pTab->nCol-1];
127290 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
127292 for(j=0; j<pTab->nCol; j++){
128643 int nCol = pIdx->nColumn;
128648 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
128650 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
128654 for(i=0; i<nCol; i++){
129581 assert( pPk->aiColumn[0]>=0 && pPk->aiColumn[0]<pTab->nCol );
129589 assert( pPk->aiColumn[i]>=0 && pPk->aiColumn[i]<pTab->nCol );
130139 pParse->nMem += (1 + pTab->nCol);
130144 for(iCol=0; iCol<pTab->nCol; iCol++){
130323 int nCol;
130338 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
130339 regBase = sqlite3GetTempRange(pParse, nCol);
130341 for(j=0; j<nCol; j++){
130361 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
130363 sqlite3ReleaseTempRange(pParse, regBase, nCol);
133519 int nCol = pFKey->nCol; /* Number of columns in parent key */
133535 if( nCol==1 ){
133550 assert( nCol>1 );
133551 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
133557 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
133569 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
133579 for(i=0; i<nCol; i++){
133594 for(j=0; j<nCol; j++){
133600 if( j==nCol ) break;
133602 if( i==nCol ) break; /* pIdx is usable */
133680 for(i=0; i<pFKey->nCol; i++){
133718 int nCol = pFKey->nCol;
133719 int regTemp = sqlite3GetTempRange(pParse, nCol);
133723 for(i=0; i<nCol; i++){
133740 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
133741 for(i=0; i<nCol; i++){
133759 sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0,
133760 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
133761 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);
133763 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
133893 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
133894 assert( pIdx!=0 || pFKey->nCol==1 );
133910 for(i=0; i<pFKey->nCol; i++){
134132 for(i=0; i<p->nCol; i++){
134159 for(i=0; i<p->nCol; i++){
134162 for(iKey=0; iKey<pTab->nCol; iKey++){
134278 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
134279 for(i=0; i<pFKey->nCol; i++){
134289 assert( pFKey->nCol==1 || (aiFree && pIdx) );
134297 for(i=0; i<pFKey->nCol; i++){
134366 assert( aiCol || pFKey->nCol==1 );
134429 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
134573 assert( aiCol || pFKey->nCol==1 );
134575 for(i=0; i<pFKey->nCol; i++){
134585 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
134938 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
134941 for(i=j=0; i<pTab->nCol; i++){
135082 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
135146 for(i=0; i<pTab->nCol; i++){
135168 for(i=0; i<pTab->nCol; i++){
135240 || pSeqTab->nCol!=2
135861 pParse->nMem += pTab->nCol + 1;
135889 aTabColMap = sqlite3DbMallocZero(db, pTab->nCol*sizeof(int));
135945 if( bIdListInOrder && nColumn==pTab->nCol ){
135957 dest.nSdst = pTab->nCol;
136056 for(i=0; i<pTab->nCol; i++){
136060 if( nColumn!=(pTab->nCol-nHidden) ){
136063 pTabList->a, pTab->nCol-nHidden, nColumn);
136154 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
136174 for(i=0; i<pTab->nCol; i++, iRegStore++){
136255 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
136307 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
136309 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
136372 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
136418 pTab, regData-2-pTab->nCol, onError, endOfLoop);
136727 int nCol; /* Number of columns */
136752 nCol = pTab->nCol;
136777 for(i=0; i<nCol; i++){
137550 for(i=pTab->nCol-1; i>0; i--){
137918 if( pDest->nCol!=pSrc->nCol ){
137927 for(i=0; i<pDest->nCol; i++){
138256 int nCol = 0;
138281 nCol = sqlite3_column_count(pStmt);
138282 azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
138286 for(i=0; i<nCol; i++){
138295 azVals = &azCols[nCol];
138296 for(i=0; i<nCol; i++){
138305 if( xCallback(pArg, nCol, azVals, azCols) ){
141874 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
141895 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
141949 if( pTab->nCol==0 ){
141985 pTab->nCol,
142171 for(j=0; j<pFK->nCol; j++){
142225 sqlite3TouchRegister(pParse, pTab->nCol+regRow);
142266 sqlite3TouchRegister(pParse, regRow + pFK->nCol);
142267 for(j=0; j<pFK->nCol; j++){
142276 sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0,
142277 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
142278 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol);
142284 assert( pFK->nCol==1 || db->mallocFailed );
142519 for(j=0; j<pTab->nCol; j++){
142564 for(j=0; j<pTab->nCol; j++){
142777 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
142814 if( pTab->nCol<=0 ){
145163 int nCol;
145167 nCol = pTab->nCol;
145171 assert( i<nCol );
145187 if( i>=nCol ) break;
145384 for(j=0; j<pRightTab->nCol; j++){
146862 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
146876 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
147031 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
147085 int nCol; /* Number of columns in the result set */
147093 nCol = pEList->nExpr;
147094 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
147096 if( NEVER(nCol>32767) ) nCol = 32767;
147098 nCol = 0;
147101 assert( nCol==(i16)nCol );
147102 *pnCol = nCol;
147105 for(i=0, pCol=aCol; i<nCol && !pParse->nErr; i++, pCol++){
147210 assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );
147217 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
147306 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
147511 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
147572 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
147579 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
148059 int nCol; /* Number of columns in result set */
148063 nCol = p->pEList->nExpr;
148064 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
148069 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
148085 sqlite3VdbeChangeP2(v, addr, nCol);
150228 int nCol;
150244 assert( pSub->pEList->nExpr==pTab->nCol );
150275 nCol = pTab->nCol;
150276 for(j=0; j<nCol; j++){
150762 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
150824 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
150972 i16 nCol;
150996 nCol = pTab->nCol;
150997 pTab->nCol = -1;
151003 pTab->nCol = nCol;
151105 assert( pNestedFrom->nExpr==pTab->nCol );
151138 nAdd = pTab->nCol;
151144 if( j==pTab->nCol ){
151230 pX->fg.eEName = (j==pTab->nCol ? ENAME_ROWID : ENAME_TAB);
151234 || (j<pTab->nCol && (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND))
152467 if( pTab->nCol!=pSub->pEList->nExpr ){
152469 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
153242 int nCol;
153255 nCol = nGroupBy;
153259 nCol++;
153263 regBase = sqlite3GetTempRange(pParse, nCol);
153277 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
153281 sqlite3ReleaseTempRange(pParse, regBase, nCol);
153287 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
153704 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
153714 need = nCol*2;
153716 need = nCol;
153730 p->nColumn = nCol;
153731 for(i=0; i<nCol; i++){
153736 }else if( (int)p->nColumn!=nCol ){
153748 for(i=0; i<nCol; i++){
154799 for(jj=0; jj<pTab->nCol; jj++){
154953 int nCol = pNew->nExpr;
154956 pParse->nMem += nCol+2;
154958 for(i=0; i<nCol; i++){
155499 assert( pTab->nCol>i );
155506 assert( i<pTab->nCol );
155679 for(i=0; i<pTab->nCol; i++){
155876 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
155878 aRegIdx = aXRef+pTab->nCol;
155882 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
155973 for(i=0; i<pTab->nCol; i++){
156047 pParse->nMem += pTab->nCol;
156053 pParse->nMem += pTab->nCol;
156117 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
156339 for(i=0; i<pTab->nCol; i++){
156376 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
156385 int nOff = (isView ? pTab->nCol : nPk);
156446 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
156647 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
156688 for(i=0; i<pTab->nCol; i++){
156714 for(i=0; i<pTab->nCol; i++){
157119 for(i=0; i<pTab->nCol; i++){
158206 for(iCol=0; iCol<pTab->nCol; iCol++){
158428 pTab->nNVCol = pTab->nCol = pNew->nCol;
158430 pNew->nCol = 0;
160894 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
160896 ai[0] = pTab->nCol;
160899 assert( pIdx->aiColumn[i]<pTab->nCol );
164438 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
164439 if( k>=pTab->nCol ){
165559 for(i=0; i<pTable->nCol; i++){
165569 mxBitCol = MIN(BMS-1,pTable->nCol);
165570 testcase( pTable->nCol==BMS-1 );
165571 testcase( pTable->nCol==BMS-2 );
165576 nKeyCol += pTable->nCol - BMS + 1;
165580 assert( nKeyCol <= pTable->nCol + MAX(0, pTable->nCol - BMS + 1) );
165632 for(i=BMS-1; i<pTable->nCol; i++){
165923 assert( pTerm->u.x.leftColumn<pTab->nCol );
165955 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
165968 assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol );
169891 LogEst rSortCost, nCol;
169895 nCol = sqlite3LogEst((pWInfo->pSelect->pEList->nExpr+59)/30);
169896 rSortCost = nRow + nCol;
171576 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
171577 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
171579 && pTab->nCol<BMS
171590 assert( n<=pTab->nCol );
171955 m = pSrc->pSTab->nCol;
174952 int nInput = p->pSrc->a[0].pSTab->nCol; /* Number of cols returned by sub */
190200 int nCol; /* Number of table columns */
190206 nCol = sqlite3_column_count(pStmt);
190207 for(i=0; i<nCol; i++){
190213 azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
190217 char *p = (char *)&azCol[nCol];
190218 for(i=0; i<nCol; i++){
190229 *pnCol = nCol;
190264 int nCol = 0; /* Number of columns in the FTS table */
190427 aCol[nCol++] = z;
190443 if( nCol==0 ){
190446 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
190452 for(j=0; j<nCol; j++){
190455 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
190456 nCol--;
190465 if( nCol==0 ){
190469 nCol = 1;
190487 nCol * sizeof(char *) + /* azColumn */
190489 nCol * sizeof(u8) + /* abNotindexed */
190500 p->nColumn = nCol;
190517 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
190526 zCsr = (char *)&p->abNotindexed[nCol];
190535 for(iCol=0; iCol<nCol; iCol++){
190550 for(iCol=0; iCol<nCol; iCol++){
194891 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
194914 }while( iCol<nCol );
194917 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
194918 fts3EvalUpdateCounts(pExpr->pRight, nCol);
195948 int nCol; /* Number of entries in azCol[] */
196399 for(ii=0; ii<pParse->nCol; ii++){
196840 int nCol, /* Number of entries in azCol[] */
196853 sParse.nCol = nCol;
196903 int nCol, /* Number of entries in azCol[] */
196910 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
197064 int nCol;
197093 nCol = argc-2;
197094 azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
197099 for(ii=0; ii<nCol; ii++){
197106 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
197112 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
205369 int nCol; /* Number of columns in table */
206158 iStart = pExpr->iPhrase * p->nCol;
206160 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
206176 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
206235 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
206251 int iStart = iPhrase * p->nCol * 3;
206254 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
206301 nVal = pInfo->nCol;
206305 nVal = (size_t)pInfo->nCol * pInfo->nPhrase;
206309 nVal = (size_t)pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
206314 nVal = (size_t)pInfo->nCol * pInfo->nPhrase * 3;
206444 for(iCol=0; iCol<pInfo->nCol; iCol++){
206531 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
206551 for(iCol=0; iCol<pInfo->nCol; iCol++){
206573 for(iCol=0; iCol<pInfo->nCol; iCol++){
206649 sInfo.nCol = pTab->nColumn;
221560 int nCol; /* Number of columns in current object */
222134 pIter->nCol = 0;
222384 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
222385 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
222391 pIter->azTblType = &azNew[nCol];
222392 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
222393 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
222394 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
222395 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
222625 int nCol = 0;
222653 nCol = sqlite3_column_count(pStmt);
222654 rbuAllocateIterArrays(p, pIter, nCol);
222656 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
222929 for(iCol=0; iCol<pIter->nCol; iCol++){
223659 pIter->nCol = nBind;
223744 pIter->nCol = pIter->nTblCol;
224600 int iCol = p->objiter.nCol; /* Index of rbu_control column */
224681 for(i=0; i<pIter->nCol; i++){
224714 assertColumnName(pIter->pSelect, pIter->nCol+1,
224717 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
224718 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
224771 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
224782 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
224783 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
224784 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
228242 int nCol; /* Number of columns in zTab */
228277 int nCol; /* Number of non-hidden columns */
228691 for(i=0; i<pTab->nCol; i++){
228776 for(i=0; i<pTab->nCol; i++){
228826 for(iCol=0; iCol<pTab->nCol; iCol++){
228860 int nCol,
228869 for(iCol=0; iCol<nCol; iCol++){
228961 for(i=0; i<pTab->nCol; i++){
228986 for(i=0; i<pTab->nCol; i++){
229031 for(iCol=0; iCol<pTab->nCol; iCol++){
229344 if( pTab->nCol==0 ){
229350 pTab->zName, &pTab->nCol, &pTab->nTotalCol, 0, &pTab->azCol,
229356 for(i=0; i<pTab->nCol; i++){
229368 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
229385 int nCol = 0;
229396 pTab->zName, &nCol, &nTotalCol, 0, &azCol, &azDflt, &aiIdx, &abPK,
229400 if( pTab->nCol>nCol || pTab->bRowid!=bRowid ){
229404 int nOldCol = pTab->nCol;
229405 for(ii=0; ii<nCol; ii++){
229406 if( ii<pTab->nCol ){
229418 pTab->nCol = nCol;
229426 pSession->nMaxChangesetSize += (nCol - nOldCol);
229427 pSession->nMaxChangesetSize += sessionVarintLen(nCol);
229446 int nCol, /* Number of columns now in table */
229451 while( pOld->nRecordField<nCol ){
229646 for(ii=0; ii<pTab->nCol; ii++){
229674 if( (*pp)->nRecordField!=pTab->nCol ){
229675 sessionUpdateOneChange(pSession, &rc, pp, pTab->nCol, pStmt);
229738 for(ii=0; ii<pTab->nCol; ii++){
229756 for(ii=pTab->bRowid; ii<pTab->nCol; ii++){
229920 for(i=pTab->bRowid; i<pTab->nCol; i++){
229963 for(i=pTab->bRowid; i<pTab->nCol; i++){
229978 pC->nRecordField = pTab->nCol;
230164 int nCol,
230173 for(i=0; i<nCol; i++){
230187 int nCol,
230197 for(i=0; i<nCol; i++){
230281 for(ii=0; ii<pTab->nCol; ii++){
230298 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
230319 pDiffCtx->nOldOff = pTab->nCol;
230369 int nCol = 0; /* Columns in zFrom.zTbl */
230384 nCol = -1;
230390 if( rc==SQLITE_OK && nCol==0 ){
230392 &nCol, 0, 0, &azCol, 0, 0, &abPK,
230397 if( pTo->nCol!=nCol ){
230398 if( nCol<=0 ){
230408 for(i=0; i<nCol; i++){
230429 zExpr = sessionExprComparePK(pTo->nCol,
230908 int nCol, /* Number of columns in table */
230921 for(i=0; i<nCol; i++){
230971 int nCol, /* Number of columns in table */
231002 for(i=0; i<nCol; i++){
231013 " AND (?%d OR ?%d IS %w.%w)", i+1+nCol, i+1, zTab, azCol[i]
231044 for(i=0; i<nCol; i++){
231079 int nCol, /* Number of columns in table */
231087 for(i=0; i<nCol && rc==SQLITE_OK; i++){
231156 sessionAppendVarint(pBuf, pTab->nCol, pRc);
231157 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
231209 int nOldCol = pTab->nCol;
231213 if( rc==SQLITE_OK && pTab->nCol!=nOldCol ){
231223 zName, pTab->bRowid, pTab->nCol, pTab->azCol, pTab->abPK, &pSel
231232 rc = sessionSelectBind(pSel, pTab->nCol, pTab->abPK, p);
231239 for(iCol=0; iCol<pTab->nCol; iCol++){
231247 rc = sessionAppendDelete(&buf, bPatchset, p, pTab->nCol,pTab->abPK);
231584 int nCol /* Number of values in record */
231588 for(i=0; i<nCol; i++){
231651 int nCol, /* Number of values in record */
231661 for(i=0; i<nCol && rc==SQLITE_OK; i++){
231731 int nCol = 0;
231736 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
231744 if( nCol<0 || nCol>65536 ){
231747 rc = sessionInputBuffer(pIn, nRead+nCol+100);
231748 nRead += nCol;
231774 int nCol, /* Number of columns in record */
231780 for(i=0; rc==SQLITE_OK && i<nCol; i++){
231825 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
231826 if( p->nCol>0 ){
231829 nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
231838 size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
231849 p->abPK = (u8*)&p->apValue[p->nCol*2];
231850 p->zTab = p->abPK ? (char*)&p->abPK[p->nCol] : 0;
231883 for(i=0; i<p->nCol*2; i++){
231886 memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
231931 nVal = p->nCol * 2;
231934 for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
231936 nVal = p->nCol;
231943 sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
231944 sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
231949 p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0);
231955 p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty);
231964 for(i=0; i<p->nCol; i++){
231968 p->apValue[i] = p->apValue[i+p->nCol];
231970 p->apValue[i+p->nCol] = 0;
231986 for(i=0; i<p->nCol; i++){
231987 if( p->abPK[i]==0 && p->apValue[i+p->nCol]==0 ){
232054 *pnCol = pIter->nCol;
232072 if( pnCol ) *pnCol = pIter->nCol;
232097 if( iVal<0 || iVal>=pIter->nCol ){
232125 if( iVal<0 || iVal>=pIter->nCol ){
232128 *ppValue = pIter->apValue[pIter->nCol+iVal];
232137 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
232159 if( iVal<0 || iVal>=pIter->nCol ){
232181 *pnOut = pIter->nCol;
232198 for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
232216 int nCol = 0; /* Number of cols in current table */
232253 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
232255 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
232274 rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
232287 apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
232292 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
232301 rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0);
232303 rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0);
232309 for(iCol=0; iCol<nCol; iCol++){
232310 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
232317 for(iCol=0; iCol<nCol; iCol++){
232322 for(iCol=0; iCol<nCol*2; iCol++){
232325 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
232418 int nCol; /* Size of azCol[] and abPK[] arrays */
232451 int nCol = pIter->nCol;
232452 int nU32 = (pIter->nCol+33)/32;
232465 for(ii=0; ii<pIter->nCol; ii++){
232474 if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32));
232521 for(ii=0; ii<pIter->nCol; ii++){
232534 for(ii=0; ii<pIter->nCol; ii++){
232627 for(i=0; i<p->nCol; i++){
232638 if( nPk<p->nCol ){
232640 sessionAppendInteger(&buf, p->nCol+1, &rc);
232644 for(i=0; i<p->nCol; i++){
232684 "main", zTab, p->bRowid, p->nCol, p->azCol, p->abPK, &p->pSelect
232709 for(i=0; i<p->nCol; i++){
232715 for(i=1; i<p->nCol; i++){
232796 int nCol, /* Number of columns */
232809 for(i=0; rc==SQLITE_OK && i<nCol; i++){
232848 int nCol; /* Number of columns in table */
232853 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
232856 nCol, p->abPK, pSelect
232861 for(ii=0; rc==SQLITE_OK && ii<nCol; ii++){
232865 sqlite3_bind_int(pSelect, ii+1+nCol, (pVal==0));
232902 sessionAppendVarint(&p->rebase, p->nCol, &rc);
232903 sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
232915 for(i=0; i<p->nCol; i++){
232973 int nCol;
232977 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
233077 int nCol;
233084 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
233100 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
233101 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
233102 rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
233126 for(i=0; rc==SQLITE_OK && i<nCol; i++){
233173 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
233235 sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
233236 sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
233276 size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
233280 pIter2->nCol = pApply->nCol;
233357 int nCol;
233361 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
233380 sApply.nCol = 0;
233407 &sApply.nCol, 0, &zTab, &sApply.azCol, 0, 0,
233411 for(i=0; i<sApply.nCol; i++){
233415 if( sApply.nCol==0 ){
233421 else if( sApply.nCol<nCol ){
233426 zTab, sApply.nCol, nCol
233429 else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
233436 sApply.nCol = nCol;
233481 sIter.nCol = nFk;
233687 for(i=0; i<pTab->nCol; i++){
233720 for(i=0; i<pTab->nCol; i++){
233786 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
233787 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
233805 sessionSkipRecord(&a1, pTab->nCol);
233806 sessionSkipRecord(&a2, pTab->nCol);
233820 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
233843 int nCol,
233846 if( pTab->azCol && nCol<pTab->nCol ){
233848 for(ii=0; ii<pTab->nCol; ii++){
233849 u8 bPK = (ii < nCol) ? abPK[ii] : 0;
233854 return (pTab->nCol==nCol && 0==memcmp(abPK, pTab->abPK, nCol));
233860 int nCol,
233870 assert( nCol<pTab->nCol );
233882 for(ii=nCol; rc==SQLITE_OK && ii<pTab->nCol; ii++){
233926 for(ii=0; ii<nCol; ii++){
233930 for(ii=0; ii<(pTab->nCol-nCol); ii++){
233936 for(ii=0; ii<(pTab->nCol-nCol); ii++){
233964 int nCol = 0;
233967 sqlite3changeset_pk(pIter, &abPK, &nCol);
233978 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nTab+1);
233983 pTab->nCol = nCol;
233985 memcpy(pTab->abPK, abPK, nCol);
233986 pTab->zName = (char*)&pTab->abPK[nCol];
233990 pTab->nCol = 0;
234008 if( !sessionChangesetCheckCompat(pTab, nCol, abPK) ){
234026 int nCol = 0;
234050 sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
234054 if( rc==SQLITE_OK && nCol<pTab->nCol ){
234056 rc = sessionChangesetExtendRecord(pGrp, pTab, nCol, op, aRec, nRec, pBuf);
234398 int nCol, /* Number of columns in each record */
234407 for(i=0; i<nCol; i++){
234462 for(i=0; i<pIter->nCol; i++){
234481 for(i=0; i<pIter->nCol; i++){
234546 sessionAppendVarint(&sOut, pIter->nCol, &rc);
234547 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
234581 sessionSkipRecord(&pCsr, pIter->nCol);
234584 sessionAppendRecordMerge(&sOut, pIter->nCol,
234602 sessionAppendRecordMerge(&sOut, pIter->nCol,
235705 int nCol;
235777 int nCol; /* Number of columns */
238462 int nCol;
238470 nCol = pApi->xColumnCount(pFts);
238490 for(i=0; i<nCol; i++){
239759 p->abUnindexed[p->nCol] = 1;
239767 p->azCol[p->nCol++] = zCol;
239785 for(i=0; i<p->nCol; i++){
239796 for(i=0; i<p->nCol; i++){
239993 for(i=0; i<pConfig->nCol; i++){
240018 for(i=0; zSql && i<pConfig->nCol; i++){
240690 if( sParse.rc==SQLITE_OK && iCol<pConfig->nCol ){
240694 pColset->nCol = 1;
240803 iCol = pConfig->nCol;
242310 nByte = SZ_FTS5COLSET(pColsetOrig->nCol);
242427 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
242431 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
242433 pNew = sqlite3_realloc64(p, SZ_FTS5COLSET(nCol+1));
242439 for(i=0; i<nCol; i++){
242443 for(j=nCol; j>i; j--){
242447 pNew->nCol = nCol+1;
242451 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
242465 int nCol = pParse->pConfig->nCol;
242468 SZ_FTS5COLSET(nCol+1)
242473 for(i=0; i<nCol; i++){
242474 if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
242475 pRet->aiCol[pRet->nCol++] = i;
242499 for(iCol=0; iCol<pConfig->nCol; iCol++){
242502 if( iCol==pConfig->nCol ){
242529 sqlite3_int64 nByte = SZ_FTS5COLSET(pOrig->nCol);
242548 while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
242560 pColset->nCol = iOut;
242584 if( pNear->pColset->nCol==0 ){
242973 int nCol = pNear->pColset->nCol;
242974 if( nCol==1 ){
242978 for(i=1; i<pNear->pColset->nCol; i++){
243054 if( pColset->nCol>1 ) zRet = fts5PrintfAppend(zRet, "{");
243055 for(ii=0; ii<pColset->nCol; ii++){
243057 pConfig->azCol[pColset->aiCol[ii]], ii==pColset->nCol-1 ? "" : " "
243061 zRet = fts5PrintfAppend(zRet, "%s : ", pColset->nCol>1 ? "}" : "");
243185 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
243397 for(i=0; i<pColset->nCol; i++){
247714 for(i=0; i<pColset->nCol; i++){
247903 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
247910 if( i==pColset->nCol ){
247924 if( pColset->nCol==1 ){
248025 int *aiColEnd = &aiCol[pIter->pColset->nCol];
248090 else if( pIter->pColset->nCol==0 ){
248100 if( pConfig->nCol<=100 ){
248102 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
251945 int nCol = p->pConfig->nCol;
251949 memset(anSize, 0, sizeof(i64) * nCol);
251955 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
254324 const int nCol = pConfig->nCol;
254361 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
254370 if( iCol==nCol+1 ){
254385 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
254429 if( iSort==(pConfig->nCol+1) && nSeenMatch>0 ){
254481 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
255584 for(ii=0; ii<pConfig->nCol; ii++){
255640 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
255657 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
255660 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
255673 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
255718 for(ii=0; ii<pConfig->nCol; ii++){
255854 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
255954 pLoc = (const char*)sqlite3_column_text(pStmt, iCol+1+pConfig->nCol);
255955 nLoc = sqlite3_column_bytes(pStmt, iCol+1+pConfig->nCol);
255973 if( iCol<0 || iCol>=pTab->pConfig->nCol ){
256023 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
256069 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
256126 if( aInst[1]>=nCol ){
256206 for(i=0; i<pConfig->nCol; i++){
256214 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
256234 for(i=0; i<pConfig->nCol; i++){
256237 }else if( iCol<pConfig->nCol ){
256319 int nCol = ((Fts5Table*)(((Fts5Cursor*)pCtx)->base.pVtab))->pConfig->nCol;
256321 *piCol = (iVal>=nCol ? nCol-1 : iVal);
256488 if( iCol<0 || iCol>=pConfig->nCol ){
256742 if( iCol==pConfig->nCol ){
256747 if( iCol==pConfig->nCol ){
256753 }else if( iCol==pConfig->nCol+1 ){
257740 for(i=0; rc==SQLITE_OK && i<(pC->nCol+1); i++){
257749 for(i=0; rc==SQLITE_OK && i<pC->nCol; i++){
257751 zBind = sqlite3Fts5Mprintf(&rc, "%z,?%d", zBind, pC->nCol+i+2);
257938 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
257951 int nDefn = 32 + pConfig->nCol*10;
257952 char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 20);
257960 for(i=0; i<pConfig->nCol; i++){
257969 for(i=0; i<pConfig->nCol; i++){
258122 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
258155 pLoc = (const char*)sqlite3_column_text(pSeek, iCol+pConfig->nCol);
258156 nLoc = sqlite3_column_bytes(pSeek, iCol + pConfig->nCol);
258301 int nCol = p->pConfig->nCol;
258308 for(i=0; i<nCol; i++){
258443 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
258460 int iCol = ctx.iCol + 1 + pConfig->nCol;
258571 for(i=2; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
258581 sqlite3_bind_value(pInsert, pConfig->nCol + i,
258582 sqlite3_column_value(p->pSavedRow, pConfig->nCol + i - 1)
258596 int iLoc = pConfig->nCol + i;
258637 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
258649 int iCol = ctx.iCol + 1 + pConfig->nCol;
258810 aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
258812 aColSize = (int*)&aTotalSize[pConfig->nCol];
258813 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
258834 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
258850 int iCol = i + 1 + pConfig->nCol;
258905 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
258981 int *aCol, int nCol, /* Array to populate */
258986 for(i=0; i<nCol; i++){
259002 int nCol = p->pConfig->nCol; /* Number of user columns in table */
259015 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
259036 for(i=0; i<p->pConfig->nCol; i++){
259039 }else if( iCol<p->pConfig->nCol ){
262113 i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
262121 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
262212 int nCol = pCsr->pFts5->pConfig->nCol;
262224 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
262229 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
262248 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
262249 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
262288 if( ii>=nCol ){
262299 assert_nc( iPos>=0 && iPos<nCol );
262300 if( iPos>=nCol ){
262336 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
262337 if( pCsr->iCol==nCol ){
262473 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){