Lines Matching refs:nCol
17196 i16 nCol; /* Number of columns in this table */ member
17340 int nCol; /* Number of columns in this key */ member
30390 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
78594 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
78596 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
78601 assert( pRec->pKeyInfo->nAllField==nCol );
78604 for(i=0; i<nCol; i++){
79116 int nCol = pRec->pKeyInfo->nAllField;
79119 for(i=0; i<nCol; i++){
84404 assert( pCsr->nField==pTab->nCol
84405 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
84414 preupdate.keyinfo.nKeyField = pTab->nCol;
89646 for(i=0; i<pTab->nCol; i++){
95367 for(iCol=0; iCol<pTab->nCol; iCol++) {
95372 if( iCol==pTab->nCol ){
95396 for(j=0; j<pFKey->nCol; j++){
95493 aOp[1].p4.i = pTab->nCol+1;
95494 aOp[3].p2 = pTab->nCol;
99787 testcase( pExTab->nCol==BMS-1 );
99788 testcase( pExTab->nCol==BMS );
99789 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
99895 assert( pTab->nCol>0 || pParse->nErr );
99925 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
100005 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
100015 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
100019 if( iCol<pTab->nCol ){
100042 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
100283 testcase( pTab->nCol==63 );
100284 testcase( pTab->nCol==64 );
100285 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
101663 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
105709 assert( iCol<pTab->nCol );
106105 int nCol;
106112 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
106114 sqlite3SubselectError(pParse, nCol, 1);
106202 p1 = pExpr->iTable * (pTab->nCol+1) + 1
106206 assert( iCol>=-1 && iCol<pTab->nCol );
106208 assert( p1>=0 && p1<(pTab->nCol*2+2) );
108327 pCol = &pNew->aCol[pNew->nCol-1];
108515 pNew->nCol = pTab->nCol;
108516 assert( pNew->nCol>0 );
108517 nAlloc = (((pNew->nCol-1)/8)*8)+8;
108518 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
108525 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
108526 for(i=0; i<pNew->nCol; i++){
108620 for(iCol=0; iCol<pTab->nCol; iCol++){
108623 if( iCol==pTab->nCol ){
109474 if( pTab==0 || iCol>=pTab->nCol ){
109513 if( iCol<sParse.pNewTable->nCol ){
109529 for(i=0; i<sParse.pNewTable->nCol; i++){
109539 for(i=0; i<pFKey->nCol; i++){
109884 for(i=0; i<sParse.pNewTable->nCol; i++){
110039 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
110046 if( iCol<pTab->nCol-1 ){
110121 if( pTab->nCol<=1 ){
110159 pParse->nMem += pTab->nCol;
110169 for(i=0; i<pTab->nCol; i++){
110513 int nCol; /* Number of columns in index + pk/rowid */
110578 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
110579 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
110580 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
110597 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
110633 int nCol; /* Number of columns in index being sampled */
110645 nCol = sqlite3_value_int(argv[0]);
110646 assert( nCol>0 );
110647 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
110649 assert( nKeyCol<=nCol );
110659 + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */
110660 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
110673 p->nCol = nCol;
110688 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
110693 pSpace = (u8*)(&p->a[mxSample+nCol]);
110694 for(i=0; i<(mxSample+nCol); i++){
110701 for(i=0; i<nCol; i++){
110742 int nCol = pAccum->nCol;
110745 for(i=pNew->iCol+1; i<nCol; i++){
110844 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
110881 for(i=(p->nCol-2); i>=iChng; i--){
110893 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
110900 for(j=iChng; j<p->nCol; j++){
110941 assert( p->nCol>0 );
110942 assert( iChng<p->nCol );
110946 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
110958 for(i=iChng; i<p->nCol; i++){
110979 nLt = p->current.anLt[p->nCol-1];
110984 sampleInsert(p, &p->current, p->nCol-1);
110989 for(i=0; i<(p->nCol-1); i++){
111125 sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100);
111126 for(i=0; i<p->nCol; i++){
111251 pStat1->nCol = 3;
111269 int nCol; /* Number of columns in pIdx. "N" */
111278 nCol = pIdx->nKeyCol;
111280 nColTest = nCol - 1;
111282 nCol = pIdx->nColumn;
111284 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
111342 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
111494 int regSampleRowid = regCol + nCol;
111499 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
111510 for(i=0; i<nCol; i++){
111513 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
111783 int nCol = pIndex->nKeyCol+1;
111789 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
111795 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
111849 int nCol = 1;
111855 nCol = pIdx->nSampleCol-1;
111856 pIdx->aAvgEq[nCol] = 1;
111858 for(iCol=0; iCol<nCol; iCol++){
112005 int nCol = 1; /* Number of columns in index */
112013 nCol = pIdx->nSampleCol;
112019 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
112020 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
112021 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
112938 assert( iCol<pTab->nCol );
112941 assert( pTab->iPKey<pTab->nCol );
113817 for(i=0; i<pTable->nCol; i++, pCol++){
113827 pTable->nCol = 0;
114198 assert( iCol<pTab->nCol );
114542 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
114590 for(i=0; i<p->nCol; i++){
114597 aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
114603 pCol = &p->aCol[p->nCol];
114630 p->nCol++;
114645 if( p==0 || NEVER(p->nCol<1) ) return;
114646 pCol = &p->aCol[p->nCol-1];
114656 if( pIdx->aiColumn[0]==p->nCol-1 ){
114777 pCol = &(p->aCol[p->nCol-1]);
114884 iCol = pTab->nCol - 1;
114898 for(iCol=0; iCol<pTab->nCol; iCol++){
114983 i = p->nCol-1;
115018 pCol = &(pTab->aCol[pTab->nCol-1]);
115148 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
115161 n += 35 + 6*p->nCol;
115171 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
115241 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
115257 assert( x<pIdx->pTable->nCol );
115267 static int hasColumn(const i16 *aiCol, int nCol, int x){
115268 while( nCol-- > 0 ){
115380 for(i=0; i<pTab->nCol; i++){
115501 for(i=0; i<pTab->nCol; i++){
115506 for(i=0, j=nPk; i<pTab->nCol; i++){
115699 for(ii=0; ii<p->nCol; ii++){
115766 for(ii=0; ii<p->nCol; ii++){
115868 p->nCol = p->nNVCol = pSelTab->nCol;
115870 pSelTab->nCol = 0;
116104 if( pTable->nCol>0 ) return 0;
116121 if( pTable->nCol<0 ){
116125 assert( pTable->nCol>=0 );
116141 pTable->nCol = -1;
116153 pTable->nCol = 0;
116163 &pTable->nCol, &pTable->aCol);
116166 && pTable->nCol==pSel->pEList->nExpr
116176 pTable->nCol = pSelTab->nCol;
116179 pSelTab->nCol = 0;
116183 pTable->nNVCol = pTable->nCol;
116612 int nCol;
116618 int iCol = p->nCol-1;
116626 nCol = 1;
116633 nCol = pFromCol->nExpr;
116635 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
116648 z = (char*)&pFKey->aCol[nCol];
116657 pFKey->nCol = nCol;
116659 pFKey->aCol[0].iFrom = p->nCol-1;
116661 for(i=0; i<nCol; i++){
116663 for(j=0; j<p->nCol; j++){
116669 if( j>=p->nCol ){
116681 for(i=0; i<nCol; i++){
116861 i16 nCol, /* Total number of columns in the index */
116869 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
116870 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
116871 sizeof(i16)*nCol + /* Index.aiColumn */
116872 sizeof(u8)*nCol); /* Index.aSortOrder */
116876 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
116877 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
116878 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
116880 p->nColumn = nCol;
116881 p->nKeyCol = nCol - 1;
117117 Column *pCol = &pTab->aCol[pTab->nCol-1];
117284 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
117286 for(j=0; j<pTab->nCol; j++){
118511 int nCol = pIdx->nColumn;
118516 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
118518 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
118522 for(i=0; i<nCol; i++){
119941 pParse->nMem += (1 + pTab->nCol);
119946 for(iCol=0; iCol<pTab->nCol; iCol++){
120123 int nCol;
120138 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
120139 regBase = sqlite3GetTempRange(pParse, nCol);
120141 for(j=0; j<nCol; j++){
120161 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
120163 sqlite3ReleaseTempRange(pParse, regBase, nCol);
122734 int nCol = pFKey->nCol; /* Number of columns in parent key */
122750 if( nCol==1 ){
122765 assert( nCol>1 );
122766 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
122772 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
122784 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
122794 for(i=0; i<nCol; i++){
122809 for(j=0; j<nCol; j++){
122815 if( j==nCol ) break;
122817 if( i==nCol ) break; /* pIdx is usable */
122895 for(i=0; i<pFKey->nCol; i++){
122933 int nCol = pFKey->nCol;
122934 int regTemp = sqlite3GetTempRange(pParse, nCol);
122939 for(i=0; i<nCol; i++){
122956 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
122957 for(i=0; i<nCol; i++){
122975 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
122976 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
122980 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
123114 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
123115 assert( pIdx!=0 || pFKey->nCol==1 );
123131 for(i=0; i<pFKey->nCol; i++){
123353 for(i=0; i<p->nCol; i++){
123380 for(i=0; i<p->nCol; i++){
123383 for(iKey=0; iKey<pTab->nCol; iKey++){
123498 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
123499 for(i=0; i<pFKey->nCol; i++){
123509 assert( pFKey->nCol==1 || (aiFree && pIdx) );
123517 for(i=0; i<pFKey->nCol; i++){
123586 assert( aiCol || pFKey->nCol==1 );
123647 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
123786 assert( aiCol || pFKey->nCol==1 );
123788 for(i=0; i<pFKey->nCol; i++){
123798 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
124197 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
124203 for(i=j=0; i<pTab->nCol; i++){
124272 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
124336 for(i=0; i<pTab->nCol; i++){
124358 for(i=0; i<pTab->nCol; i++){
124430 || pSeqTab->nCol!=2
124832 pParse->nMem += pTab->nCol + 1;
124864 for(j=0; j<pTab->nCol; j++){
124882 if( j>=pTab->nCol ){
124913 dest.nSdst = pTab->nCol;
125009 for(i=0; i<pTab->nCol; i++){
125013 if( nColumn!=(pTab->nCol-nHidden) ){
125016 pTabList->a, pTab->nCol-nHidden, nColumn);
125107 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
125127 for(i=0; i<pTab->nCol; i++, iRegStore++){
125202 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
125254 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
125256 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
125319 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
125363 pTab, regData-2-pTab->nCol, onError, endOfLoop);
125671 int nCol; /* Number of columns */
125696 nCol = pTab->nCol;
125721 for(i=0; i<nCol; i++){
126493 for(i=pTab->nCol-1; i>0; i--){
126864 if( pDest->nCol!=pSrc->nCol ){
126873 for(i=0; i<pDest->nCol; i++){
127199 int nCol = 0;
127224 nCol = sqlite3_column_count(pStmt);
127225 azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
127229 for(i=0; i<nCol; i++){
127238 azVals = &azCols[nCol];
127239 for(i=0; i<nCol; i++){
127248 if( xCallback(pArg, nCol, azVals, azCols) ){
130679 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
130700 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
130754 if( pTab->nCol==0 ){
130785 pTab->nCol,
130971 for(j=0; j<pFK->nCol; j++){
131027 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
131068 if( regRow+pFK->nCol>pParse->nMem ) pParse->nMem = regRow+pFK->nCol;
131069 for(j=0; j<pFK->nCol; j++){
131078 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
131079 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
131086 assert( pFK->nCol==1 || db->mallocFailed );
131282 for(j=0; j<pTab->nCol; j++){
131374 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
133529 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
133732 for(j=0; j<pRightTab->nCol; j++){
135105 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
135119 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
135281 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
135335 int nCol; /* Number of columns in the result set */
135343 nCol = pEList->nExpr;
135344 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
135346 if( NEVER(nCol>32767) ) nCol = 32767;
135348 nCol = 0;
135351 assert( nCol==(i16)nCol );
135352 *pnCol = nCol;
135355 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
135448 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
135453 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
135506 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
135711 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
135772 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
135779 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
136259 int nCol; /* Number of columns in result set */
136263 nCol = p->pEList->nExpr;
136264 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
136269 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
136285 sqlite3VdbeChangeP2(v, addr, nCol);
138610 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
138669 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
138789 i16 nCol;
138813 nCol = pTab->nCol;
138814 pTab->nCol = -1;
138818 pTab->nCol = nCol;
138911 for(j=0; j<pTab->nCol; j++){
139705 if( pTab->nCol!=pSub->pEList->nExpr ){
139707 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
140420 int nCol;
140429 nCol = nGroupBy;
140433 nCol++;
140437 regBase = sqlite3GetTempRange(pParse, nCol);
140450 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
140453 sqlite3ReleaseTempRange(pParse, regBase, nCol);
140458 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
140825 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
140835 need = nCol*2;
140837 need = nCol;
140851 p->nColumn = nCol;
140852 for(i=0; i<nCol; i++){
140857 }else if( (int)p->nColumn!=nCol ){
140869 for(i=0; i<nCol; i++){
141861 for(jj=0; jj<pTab->nCol; jj++){
141936 int nCol = pNew->nExpr;
141938 pParse->nMem += nCol+2;
141940 for(i=0; i<nCol; i++){
142477 assert( i<pTab->nCol );
142650 for(i=0; i<pTab->nCol; i++){
142836 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
142838 aRegIdx = aXRef+pTab->nCol;
142842 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
142869 for(j=0; j<pTab->nCol; j++){
142894 if( j>=pTab->nCol ){
142939 for(i=0; i<pTab->nCol; i++){
143013 pParse->nMem += pTab->nCol;
143019 pParse->nMem += pTab->nCol;
143083 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
143293 for(i=0; i<pTab->nCol; i++){
143327 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
143336 int nOff = (isView ? pTab->nCol : nPk);
143397 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
143598 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
143639 for(i=0; i<pTab->nCol; i++){
143661 for(i=0; i<pTab->nCol; i++){
144052 for(i=0; i<pTab->nCol; i++){
145122 for(iCol=0; iCol<pTab->nCol; iCol++){
145323 pTab->nNVCol = pTab->nCol = pNew->nCol;
145325 pNew->nCol = 0;
147518 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
147520 ai[0] = pTab->nCol;
147523 assert( pIdx->aiColumn[i]<pTab->nCol );
150614 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
150615 if( k>=pTab->nCol ){
151478 mxBitCol = MIN(BMS-1,pTable->nCol);
151479 testcase( pTable->nCol==BMS-1 );
151480 testcase( pTable->nCol==BMS-2 );
151485 nKeyCol += pTable->nCol - BMS + 1;
151528 for(i=BMS-1; i<pTable->nCol; i++){
155901 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
155902 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
155904 && pTab->nCol<BMS
155914 assert( n<=pTab->nCol );
159148 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
170374 for(iCol=0; iCol<pTab->nCol; iCol++){
170380 if( iCol==pTab->nCol ){
173758 int nCol; /* Number of table columns */
173764 nCol = sqlite3_column_count(pStmt);
173765 for(i=0; i<nCol; i++){
173771 azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
173775 char *p = (char *)&azCol[nCol];
173776 for(i=0; i<nCol; i++){
173787 *pnCol = nCol;
173822 int nCol = 0; /* Number of columns in the FTS table */
173985 aCol[nCol++] = z;
174001 if( nCol==0 ){
174004 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
174010 for(j=0; j<nCol; j++){
174013 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
174014 nCol--;
174023 if( nCol==0 ){
174027 nCol = 1;
174045 nCol * sizeof(char *) + /* azColumn */
174047 nCol * sizeof(u8) + /* abNotindexed */
174058 p->nColumn = nCol;
174075 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
174084 zCsr = (char *)&p->abNotindexed[nCol];
174093 for(iCol=0; iCol<nCol; iCol++){
174108 for(iCol=0; iCol<nCol; iCol++){
178362 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
178385 }while( iCol<nCol );
178388 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
178389 fts3EvalUpdateCounts(pExpr->pRight, nCol);
179401 int nCol; /* Number of entries in azCol[] */
179828 for(ii=0; ii<pParse->nCol; ii++){
180269 int nCol, /* Number of entries in azCol[] */
180282 sParse.nCol = nCol;
180332 int nCol, /* Number of entries in azCol[] */
180339 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
180493 int nCol;
180522 nCol = argc-2;
180523 azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
180528 for(ii=0; ii<nCol; ii++){
180535 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
180541 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
188775 int nCol; /* Number of columns in table */
189557 iStart = pExpr->iPhrase * p->nCol;
189559 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
189575 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
189634 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
189650 int iStart = iPhrase * p->nCol * 3;
189653 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
189700 nVal = pInfo->nCol;
189704 nVal = pInfo->nCol * pInfo->nPhrase;
189708 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
189713 nVal = pInfo->nCol * pInfo->nPhrase * 3;
189843 for(iCol=0; iCol<pInfo->nCol; iCol++){
189930 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
189950 for(iCol=0; iCol<pInfo->nCol; iCol++){
189972 for(iCol=0; iCol<pInfo->nCol; iCol++){
190048 sInfo.nCol = pTab->nColumn;
202068 int nCol; /* Number of columns in current object */
202618 pIter->nCol = 0;
202867 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
202868 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
202874 pIter->azTblType = &azNew[nCol];
202875 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
202876 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
202877 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
202878 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
203108 int nCol = 0;
203136 nCol = sqlite3_column_count(pStmt);
203137 rbuAllocateIterArrays(p, pIter, nCol);
203139 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
203412 for(iCol=0; iCol<pIter->nCol; iCol++){
204142 pIter->nCol = nBind;
204227 pIter->nCol = pIter->nTblCol;
205090 int iCol = p->objiter.nCol; /* Index of rbu_control column */
205171 for(i=0; i<pIter->nCol; i++){
205204 assertColumnName(pIter->pSelect, pIter->nCol+1,
205207 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
205208 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
205261 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
205272 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
205273 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
205274 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
208553 int nCol; /* Number of columns in zTab */
208576 int nCol; /* Number of columns in table zName */
208979 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
208980 for(i=0; i<pTab->nCol; i++){
209061 for(i=0; i<pTab->nCol; i++){
209111 for(iCol=0; iCol<pTab->nCol; iCol++){
209145 int nCol,
209154 for(iCol=0; iCol<nCol; iCol++){
209246 for(i=0; i<pTab->nCol; i++){
209271 for(i=0; i<pTab->nCol; i++){
209310 for(iCol=0; iCol<pTab->nCol; iCol++){
209579 if( pTab->nCol==0 ){
209583 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
209587 for(i=0; i<pTab->nCol; i++){
209599 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
209657 for(ii=0; ii<pTab->nCol; ii++){
209671 for(ii=0; ii<pTab->nCol; ii++){
209770 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
209825 for(i=0; i<pTab->nCol; i++){
209856 for(i=0; i<pTab->nCol; i++){
210050 int nCol,
210059 for(i=0; i<nCol; i++){
210073 int nCol,
210083 for(i=0; i<nCol; i++){
210104 int nCol,
210128 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
210158 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
210177 pDiffCtx->nOldOff = pTab->nCol;
210222 int nCol; /* Columns in zFrom.zTbl */
210225 rc = sessionTableInfo(0, db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
210227 if( pTo->nCol!=nCol ){
210231 for(i=0; i<nCol; i++){
210252 zExpr = sessionExprComparePK(pTo->nCol,
210791 int nCol, /* Number of columns in table */
210804 for(i=0; i<nCol; i++){
210846 int nCol, /* Number of columns in table */
210871 for(i=0; i<nCol; i++){
210901 int nCol, /* Number of columns in table */
210909 for(i=0; i<nCol && rc==SQLITE_OK; i++){
210978 sessionAppendVarint(pBuf, pTab->nCol, pRc);
210979 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
211027 int nCol = 0; /* Number of columns in table */
211036 rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK);
211037 if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
211047 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
211055 rc = sessionSelectBind(pSel, nCol, abPK, p);
211062 for(iCol=0; iCol<nCol; iCol++){
211070 rc = sessionAppendDelete(&buf, bPatchset, p, nCol, abPK);
211394 int nCol /* Number of values in record */
211398 for(i=0; i<nCol; i++){
211461 int nCol, /* Number of values in record */
211471 for(i=0; i<nCol && rc==SQLITE_OK; i++){
211537 int nCol = 0;
211542 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
211550 if( nCol<0 || nCol>65536 ){
211553 rc = sessionInputBuffer(pIn, nRead+nCol+100);
211554 nRead += nCol;
211580 int nCol, /* Number of columns in record */
211586 for(i=0; rc==SQLITE_OK && i<nCol; i++){
211631 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
211632 if( p->nCol>0 ){
211635 nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
211644 size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
211655 p->abPK = (u8*)&p->apValue[p->nCol*2];
211656 p->zTab = p->abPK ? (char*)&p->abPK[p->nCol] : 0;
211689 for(i=0; i<p->nCol*2; i++){
211692 memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
211737 nVal = p->nCol * 2;
211740 for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
211742 nVal = p->nCol;
211749 sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
211750 sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
211755 p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0);
211761 p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty);
211770 for(i=0; i<p->nCol; i++){
211774 p->apValue[i] = p->apValue[i+p->nCol];
211776 p->apValue[i+p->nCol] = 0;
211844 *pnCol = pIter->nCol;
211862 if( pnCol ) *pnCol = pIter->nCol;
211887 if( iVal<0 || iVal>=pIter->nCol ){
211915 if( iVal<0 || iVal>=pIter->nCol ){
211918 *ppValue = pIter->apValue[pIter->nCol+iVal];
211927 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
211949 if( iVal<0 || iVal>=pIter->nCol ){
211971 *pnOut = pIter->nCol;
211988 for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
212006 int nCol = 0; /* Number of cols in current table */
212043 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
212045 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
212064 rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
212077 apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
212082 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
212091 rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0);
212093 rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0);
212099 for(iCol=0; iCol<nCol; iCol++){
212100 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
212107 for(iCol=0; iCol<nCol; iCol++){
212112 for(iCol=0; iCol<nCol*2; iCol++){
212115 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
212208 int nCol; /* Size of azCol[] and abPK[] arrays */
212239 int nCol = pIter->nCol;
212240 int nU32 = (pIter->nCol+33)/32;
212253 for(ii=0; ii<pIter->nCol; ii++){
212262 if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32));
212309 for(ii=0; ii<pIter->nCol; ii++){
212322 for(ii=0; ii<pIter->nCol; ii++){
212415 for(i=0; i<p->nCol; i++){
212426 if( nPk<p->nCol ){
212428 sessionAppendInteger(&buf, p->nCol+1, &rc);
212432 for(i=0; i<p->nCol; i++){
212471 db, "main", zTab, p->nCol, p->azCol, p->abPK, &p->pSelect);
212495 for(i=0; i<p->nCol; i++){
212501 for(i=1; i<p->nCol; i++){
212582 int nCol, /* Number of columns */
212595 for(i=0; rc==SQLITE_OK && i<nCol; i++){
212635 int nCol; /* Number of columns in table */
212639 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
212642 nCol, abPK, pSelect
212676 sessionAppendVarint(&p->rebase, p->nCol, &rc);
212677 sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
212689 for(i=0; i<p->nCol; i++){
212747 int nCol;
212751 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
212845 int nCol;
212852 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
212868 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
212869 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
212870 rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
212894 for(i=0; rc==SQLITE_OK && i<nCol; i++){
212941 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
213003 sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
213004 sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
213044 size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
213048 pIter2->nCol = pApply->nCol;
213118 int nCol;
213122 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
213141 sApply.nCol = 0;
213167 db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK
213170 for(i=0; i<sApply.nCol; i++){
213174 if( sApply.nCol==0 ){
213180 else if( sApply.nCol<nCol ){
213185 zTab, sApply.nCol, nCol
213188 else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
213195 sApply.nCol = nCol;
213240 sIter.nCol = nFk;
213428 for(i=0; i<pTab->nCol; i++){
213461 for(i=0; i<pTab->nCol; i++){
213527 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
213528 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
213546 sessionSkipRecord(&a1, pTab->nCol);
213547 sessionSkipRecord(&a2, pTab->nCol);
213561 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
213592 int nCol;
213607 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
213620 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
213626 pTab->nCol = nCol;
213628 memcpy(pTab->abPK, abPK, nCol);
213629 pTab->zName = (char*)&pTab->abPK[nCol];
213638 }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){
213908 int nCol, /* Number of columns in each record */
213917 for(i=0; i<nCol; i++){
213972 for(i=0; i<pIter->nCol; i++){
213991 for(i=0; i<pIter->nCol; i++){
214056 sessionAppendVarint(&sOut, pIter->nCol, &rc);
214057 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
214091 sessionSkipRecord(&pCsr, pIter->nCol);
214094 sessionAppendRecordMerge(&sOut, pIter->nCol,
214112 sessionAppendRecordMerge(&sOut, pIter->nCol,
214980 int nCol;
215032 int nCol; /* Number of columns */
217596 int nCol;
217604 nCol = pApi->xColumnCount(pFts);
217623 for(i=0; i<nCol; i++){
218796 p->abUnindexed[p->nCol] = 1;
218803 p->azCol[p->nCol++] = zCol;
218817 for(i=0; i<p->nCol; i++){
218975 for(i=0; i<pConfig->nCol; i++){
219000 for(i=0; zSql && i<pConfig->nCol; i++){
219540 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
219544 pColset->nCol = 1;
219643 iCol = pConfig->nCol;
221137 nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
221252 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
221256 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
221258 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
221264 for(i=0; i<nCol; i++){
221268 for(j=nCol; j>i; j--){
221272 pNew->nCol = nCol+1;
221276 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
221290 int nCol = pParse->pConfig->nCol;
221293 sizeof(Fts5Colset) + sizeof(int)*nCol
221298 for(i=0; i<nCol; i++){
221299 if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
221300 pRet->aiCol[pRet->nCol++] = i;
221324 for(iCol=0; iCol<pConfig->nCol; iCol++){
221327 if( iCol==pConfig->nCol ){
221354 sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
221373 while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
221385 pColset->nCol = iOut;
221409 if( pNear->pColset->nCol==0 ){
221772 int nCol = pNear->pColset->nCol;
221773 if( nCol==1 ){
221777 for(i=1; i<pNear->pColset->nCol; i++){
221849 if( pColset->nCol>1 ) zRet = fts5PrintfAppend(zRet, "{");
221850 for(ii=0; ii<pColset->nCol; ii++){
221852 pConfig->azCol[pColset->aiCol[ii]], ii==pColset->nCol-1 ? "" : " "
221856 zRet = fts5PrintfAppend(zRet, "%s : ", pColset->nCol>1 ? "}" : "");
221980 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
222192 for(i=0; i<pColset->nCol; i++){
225958 for(i=0; i<pColset->nCol; i++){
226147 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
226154 if( i==pColset->nCol ){
226168 if( pColset->nCol==1 ){
226269 int *aiColEnd = &aiCol[pIter->pColset->nCol];
226334 else if( pIter->pColset->nCol==0 ){
226344 if( pConfig->nCol<=100 ){
226346 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
228629 int nCol = p->pConfig->nCol;
228633 memset(anSize, 0, sizeof(i64) * nCol);
228639 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
230290 const int nCol = pConfig->nCol;
230327 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
230338 if( iCol==nCol+1 ){
230353 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
230393 if( iSort==(pConfig->nCol+1) && bSeenMatch ){
230442 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
231371 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
231383 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
231386 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
231392 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
231534 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
231616 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
231655 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
231711 if( aInst[1]<0 || aInst[1]>=nCol ){
231797 for(i=0; i<pConfig->nCol; i++){
231804 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
231823 for(i=0; i<pConfig->nCol; i++){
231826 }else if( iCol<pConfig->nCol ){
232224 if( iCol==pConfig->nCol ){
232229 if( iCol==pConfig->nCol ){
232235 }else if( iCol==pConfig->nCol+1 ){
232781 int nCol = pC->nCol + 1;
232785 zBind = sqlite3_malloc64(1 + nCol*2);
232787 for(i=0; i<nCol; i++){
232957 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
232968 int nDefn = 32 + pConfig->nCol*10;
232969 char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
232977 for(i=0; i<pConfig->nCol; i++){
233083 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
233175 int nCol = p->pConfig->nCol;
233182 for(i=0; i<nCol; i++){
233291 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
233384 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
233417 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
233566 aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
233568 aColSize = (int*)&aTotalSize[pConfig->nCol];
233569 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
233590 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
233629 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
233705 int *aCol, int nCol, /* Array to populate */
233710 for(i=0; i<nCol; i++){
233726 int nCol = p->pConfig->nCol; /* Number of user columns in table */
233739 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
233760 for(i=0; i<p->pConfig->nCol; i++){
233763 }else if( iCol<p->pConfig->nCol ){
236753 i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
236761 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
236852 int nCol = pCsr->pFts5->pConfig->nCol;
236864 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
236869 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
236888 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
236889 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
236918 if( ii>=nCol ){
236929 assert_nc( iPos>=0 && iPos<nCol );
236930 if( iPos>=nCol ){
236966 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
236967 if( pCsr->iCol==nCol ){
237102 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){