Lines Matching defs:nCol
10916 ** Table.nCol is the number of columns in this table. Table.aCol is a
10951 i16 nCol; /* Number of columns in this table */
11033 int nCol; /* Number of columns in this key */
11041 } aCol[1]; /* One entry for each of nCol columns */
11142 ** In the Table structure describing Ex1, nCol==3 because there are
61774 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
61776 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
61781 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
61784 for(i=0; i<nCol; i++){
62185 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
62188 for(i=0; i<nCol; i++){
74752 for(iCol=0; iCol<pTab->nCol; iCol++) {
74757 if( iCol==pTab->nCol ){
74781 for(j=0; j<pFKey->nCol; j++){
74845 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
74846 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
77061 assert( pTab->nCol>0 );
77089 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
77135 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
77143 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && HasRowid(pTab) ){
77148 if( iCol<pTab->nCol ){
78301 assert( pExpr->pTab && j<pExpr->pTab->nCol );
81212 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
81215 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
81217 assert( p1>=0 && p1<(pTab->nCol*2+2) );
83245 pCol = &pNew->aCol[pNew->nCol-1];
83395 pNew->nCol = pTab->nCol;
83396 assert( pNew->nCol>0 );
83397 nAlloc = (((pNew->nCol-1)/8)*8)+8;
83398 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
83405 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
83406 for(i=0; i<pNew->nCol; i++){
83715 int nCol; /* Number of columns in index + pk/rowid */
83720 Stat4Sample *aBest; /* Array of nCol best samples */
83776 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
83777 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
83778 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
83794 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
83829 int nCol; /* Number of columns in index being sampled */
83831 int nColUp; /* nCol rounded up for alignment */
83840 nCol = sqlite3_value_int(argv[0]);
83841 assert( nCol>0 );
83842 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
83844 assert( nKeyCol<=nCol );
83853 + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */
83854 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
83866 p->nCol = nCol;
83880 p->iPrn = nCol*0x689e962d ^ sqlite3_value_int(argv[2])*0xd0944565;
83885 pSpace = (u8*)(&p->a[mxSample+nCol]);
83886 for(i=0; i<(mxSample+nCol); i++){
83893 for(i=0; i<nCol; i++){
83932 int nCol = pAccum->nCol;
83935 for(i=pNew->iCol+1; i<nCol; i++){
84034 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
84074 for(i=(p->nCol-2); i>=iChng; i--){
84085 for(j=iChng; j<p->nCol; j++){
84147 assert( p->nCol>0 );
84148 assert( iChng<p->nCol );
84152 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
84162 for(i=iChng; i<p->nCol; i++){
84183 tRowcnt nLt = p->current.anLt[p->nCol-1];
84189 sampleInsert(p, &p->current, p->nCol-1);
84194 for(i=0; i<(p->nCol-1); i++){
84329 char *zRet = sqlite3MallocZero(p->nCol * 25);
84335 for(i=0; i<p->nCol; i++){
84446 int nCol; /* Number of columns in pIdx. "N" */
84455 nCol = pIdx->nKeyCol;
84457 nColTest = nCol - 1;
84459 nCol = pIdx->nColumn;
84461 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
84525 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
84643 int regSampleRowid = regCol + nCol;
84648 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
84666 for(i=0; i<nCol; i++){
84670 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
84993 int nCol = 1;
84999 nCol = pIdx->nSampleCol-1;
85000 pIdx->aAvgEq[nCol] = 1;
85002 for(iCol=0; iCol<nCol; iCol++){
85140 int nCol = 1; /* Number of columns in index */
85148 nCol = pIdx->nSampleCol;
85149 if( bStat3 && nCol>1 ) continue;
85155 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
85156 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
85157 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
86031 assert( iCol<pTab->nCol );
86034 assert( pTab->iPKey<pTab->nCol );
86646 for(i=0; i<pTable->nCol; i++, pCol++){
87148 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
87155 for(i=0; i<p->nCol; i++){
87162 if( (p->nCol & 0x7)==0 ){
87164 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
87171 pCol = &p->aCol[p->nCol];
87181 p->nCol++;
87193 if( p==0 || NEVER(p->nCol<1) ) return;
87194 p->aCol[p->nCol-1].notNull = (u8)onError;
87298 if( p==0 || NEVER(p->nCol<1) ) return;
87299 pCol = &p->aCol[p->nCol-1];
87321 pCol = &(p->aCol[p->nCol-1]);
87377 iCol = pTab->nCol - 1;
87384 for(iCol=0; iCol<pTab->nCol; iCol++){
87460 i = p->nCol-1;
87609 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
87622 n += 35 + 6*p->nCol;
87632 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
87699 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
87715 assert( x<pIdx->pTable->nCol );
87721 /* Return true if value x is found any of the first nCol entries of aiCol[]
87723 static int hasColumn(const i16 *aiCol, int nCol, int x){
87724 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
87835 if( nPk<pTab->nCol ){
87836 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
87837 for(i=0, j=nPk; i<pTab->nCol; i++){
87846 assert( pTab->nCol==j );
87848 pPk->nColumn = pTab->nCol;
87994 p->nCol = pSelTab->nCol;
87996 pSelTab->nCol = 0;
88185 /* A positive nCol means the columns names for this view are
88188 if( pTable->nCol>0 ) return 0;
88190 /* A negative nCol is a special marker meaning that we are currently
88192 ** a negative nCol, it means two or more views form a loop, like this:
88205 if( pTable->nCol<0 ){
88209 assert( pTable->nCol>=0 );
88224 pTable->nCol = -1;
88238 pTable->nCol = pSelTab->nCol;
88240 pSelTab->nCol = 0;
88246 pTable->nCol = 0;
88271 pTab->nCol = 0;
88636 int nCol;
88642 int iCol = p->nCol-1;
88650 nCol = 1;
88657 nCol = pFromCol->nExpr;
88659 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
88671 z = (char*)&pFKey->aCol[nCol];
88677 pFKey->nCol = nCol;
88679 pFKey->aCol[0].iFrom = p->nCol-1;
88681 for(i=0; i<nCol; i++){
88683 for(j=0; j<p->nCol; j++){
88689 if( j>=p->nCol ){
88698 for(i=0; i<nCol; i++){
88844 ** Allocate heap space to hold an Index object with nCol columns.
88852 i16 nCol, /* Total number of columns in the index */
88860 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
88861 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
88862 sizeof(i16)*nCol + /* Index.aiColumn */
88863 sizeof(u8)*nCol); /* Index.aSortOrder */
88867 p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
88868 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
88869 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
88871 p->nColumn = nCol;
88872 p->nKeyCol = nCol - 1;
89074 pTab->aCol[pTab->nCol-1].zName);
89140 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
89143 if( j>=pTab->nCol ){
89149 assert( pTab->nCol<=0x7fff && j<=0x7fff );
90276 int nCol = pIdx->nColumn;
90280 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
90282 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
90286 for(i=0; i<nCol; i++){
91486 pParse->nMem += (1 + pTab->nCol);
91491 for(iCol=0; iCol<pTab->nCol; iCol++){
91644 int nCol;
91657 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
91658 regBase = sqlite3GetTempRange(pParse, nCol);
91660 for(j=0; j<nCol; j++){
91673 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
91675 sqlite3ReleaseTempRange(pParse, regBase, nCol);
93632 int nCol = pFKey->nCol; /* Number of columns in parent key */
93648 if( nCol==1 ){
93661 assert( nCol>1 );
93662 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
93668 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){
93680 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
93690 for(i=0; i<nCol; i++){
93705 for(j=0; j<nCol; j++){
93711 if( j==nCol ) break;
93713 if( i==nCol ) break; /* pIdx is usable */
93785 for(i=0; i<pFKey->nCol; i++){
93822 int nCol = pFKey->nCol;
93823 int regTemp = sqlite3GetTempRange(pParse, nCol);
93828 for(i=0; i<nCol; i++){
93843 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
93844 for(i=0; i<nCol; i++){
93858 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
93859 sqlite3IndexAffinityStr(v,pIdx), nCol);
93863 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
93992 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
93993 assert( pIdx!=0 || pFKey->nCol==1 );
94009 for(i=0; i<pFKey->nCol; i++){
94210 for(i=0; i<p->nCol; i++){
94237 for(i=0; i<p->nCol; i++){
94240 for(iKey=0; iKey<pTab->nCol; iKey++){
94260 ** first register in an array of (pTab->nCol+1) registers containing the
94266 ** first register of an array of (pTab->nCol+1) registers containing the new
94336 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
94337 for(i=0; i<pFKey->nCol; i++){
94345 assert( pFKey->nCol==1 || (aiFree && pIdx) );
94353 for(i=0; i<pFKey->nCol; i++){
94415 assert( aiCol || pFKey->nCol==1 );
94461 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
94577 assert( aiCol || pFKey->nCol==1 );
94579 for(i=0; i<pFKey->nCol; i++){
94845 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
94930 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
94936 for(i=0; i<pTab->nCol; i++){
95386 pParse->nMem += pTab->nCol + 1;
95409 for(j=0; j<pTab->nCol; j++){
95419 if( j>=pTab->nCol ){
95449 dest.nSdst = pTab->nCol;
95529 for(i=0; i<pTab->nCol; i++){
95533 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
95536 pTabList, 0, pTab->nCol-nHidden, nColumn);
95595 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
95627 for(i=0; i<pTab->nCol; i++){
95656 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
95658 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
95713 for(i=0; i<pTab->nCol; i++){
95757 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
95782 pTab, regData-2-pTab->nCol, onError, endOfLoop);
95853 ** pTab->nCol+1 registers in this range. The first register (the one
95949 int nCol; /* Number of columns */
95965 nCol = pTab->nCol;
95985 for(i=0; i<nCol; i++){
96381 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
96383 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
96667 if( pDest->nCol!=pSrc->nCol ){
96673 for(i=0; i<pDest->nCol; i++){
96874 int nCol;
96890 nCol = sqlite3_column_count(pStmt);
96901 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
96905 for(i=0; i<nCol; i++){
96914 azVals = &azCols[nCol];
96915 for(i=0; i<nCol; i++){
96923 if( xCallback(pArg, nCol, azVals, azCols) ){
99666 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
99686 for(k=1; ALWAYS(k<=pTab->nCol) && pPk->aiColumn[k-1]!=i; k++){}
99744 assert( pTab->nCol>cnum );
99834 for(j=0; j<pFK->nCol; j++){
99898 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
99935 assert( iKey>=0 && iKey<pTab->nCol );
99949 for(j=0; j<pFK->nCol; j++){
99955 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
99956 sqlite3IndexAffinityStr(v,pIdx), pFK->nCol);
100132 for(j=0; j<pTab->nCol; j++){
100184 assert( iCol>=0 && iCol<pTab->nCol );
101696 for(i=0; i<pTab->nCol; i++){
101856 for(j=0; j<pRightTab->nCol; j++){
102815 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
102955 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
103003 int nCol; /* Number of columns in the result set */
103009 nCol = pEList->nExpr;
103010 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
103013 nCol = 0;
103016 *pnCol = nCol;
103019 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
103112 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
103117 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
103157 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
103365 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
103418 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
103425 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
103837 int nCol; /* Number of columns in result set */
103840 nCol = p->pEList->nExpr;
103841 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
103846 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
103862 sqlite3VdbeChangeP2(v, addr, nCol);
105348 selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
105469 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
105588 for(j=0; j<pTab->nCol; j++){
106443 int nCol;
106452 nCol = nGroupBy + 1;
106456 nCol++;
106460 regBase = sqlite3GetTempRange(pParse, nCol);
106480 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
106483 sqlite3ReleaseTempRange(pParse, regBase, nCol);
106487 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
106923 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
106933 need = nCol*2;
106935 need = nCol;
106949 p->nColumn = nCol;
106950 for(i=0; i<nCol; i++){
106955 }else if( p->nColumn!=nCol ){
106967 for(i=0; i<nCol; i++){
108084 ** (a copy of pTab->nCol), then registers are populated as follows:
108272 assert( i<pTab->nCol );
108404 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
108406 aRegIdx = aXRef+pTab->nCol;
108410 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
108428 for(j=0; j<pTab->nCol; j++){
108440 if( j>=pTab->nCol ){
108520 pParse->nMem += pTab->nCol;
108526 pParse->nMem += pTab->nCol;
108678 for(i=0; i<pTab->nCol; i++){
108710 /*sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);*/
108711 for(i=0; i<pTab->nCol; i++){
108760 for(i=0; i<pTab->nCol; i++){
108935 for(i=0; i<pTab->nCol; i++){
108950 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
108960 pParse->nMem += pTab->nCol+1;
108964 for(i=0; i<pTab->nCol; i++){
108968 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
109890 for(iCol=0; iCol<pTab->nCol; iCol++){
110075 pTab->nCol = pParse->pNewTable->nCol;
110076 pParse->pNewTable->nCol = 0;
112560 mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol;
112561 testcase( pTable->nCol==BMS-1 );
112562 testcase( pTable->nCol==BMS-2 );
112567 nKeyCol += pTable->nCol - BMS + 1;
112607 for(i=BMS-1; i<pTable->nCol; i++){
117196 testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
117197 testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
117198 if( !pWInfo->okOnePass && pTab->nCol<BMS && HasRowid(pTab) ){
117204 assert( n<=pTab->nCol );
125127 for(iCol=0; iCol<pTab->nCol; iCol++){
125133 if( iCol==pTab->nCol ){
126944 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
126945 ** where nCol is the number of columns in the queried FTS table. The array
127881 int nCol; /* Number of table columns */
127887 nCol = sqlite3_column_count(pStmt);
127888 for(i=0; i<nCol; i++){
127894 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
127898 char *p = (char *)&azCol[nCol];
127899 for(i=0; i<nCol; i++){
127910 *pnCol = nCol;
127945 int nCol = 0; /* Number of columns in the FTS table */
128107 aCol[nCol++] = z;
128123 if( nCol==0 ){
128126 rc = fts3ContentColumns(db, argv[1], zContent, &aCol, &nCol, &nString);
128132 for(j=0; j<nCol; j++){
128135 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
128136 nCol--;
128145 if( nCol==0 ){
128149 nCol = 1;
128167 nCol * sizeof(char *) + /* azColumn */
128169 nCol * sizeof(u8) + /* abNotindexed */
128180 p->nColumn = nCol;
128197 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
128206 zCsr = (char *)&p->abNotindexed[nCol];
128215 for(iCol=0; iCol<nCol; iCol++){
128228 for(iCol=0; iCol<nCol; iCol++){
131504 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
131505 ** varints, where nCol is the number of columns in the FTS3 table.
131507 ** the table. The following nCol varints contain the total amount of
133316 int nCol; /* Number of entries in azCol[] */
133742 for(ii=0; ii<pParse->nCol; ii++){
134157 int nCol, /* Number of entries in azCol[] */
134170 sParse.nCol = nCol;
134205 ** array, which is assumed to contain nCol entries, should contain the names
134220 int nCol, /* Number of entries in azCol[] */
134227 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
134409 int nCol;
134442 nCol = argc-2;
134443 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
134448 for(ii=0; ii<nCol; ii++){
134455 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
134461 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
140080 ** two. If nCol is the number of user defined columns, then values of the
140085 ** Varint 1..nCol: For each column, the total number of tokens stored in
140088 ** Varint 1+nCol: The total size, in bytes, of all text values in all
142419 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
142420 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
142421 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
142422 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
142481 int nCol; /* Number of columns in table */
143145 ** for(iCol=0; iCol<nCol; iCol++){
143146 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
143147 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
143167 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
143183 int iStart = iPhrase * p->nCol * 3;
143186 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
143231 nVal = pInfo->nCol;
143236 nVal = pInfo->nCol * pInfo->nPhrase * 3;
143325 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
143329 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
143352 for(iCol=0; iCol<pInfo->nCol; iCol++){
143409 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
143435 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
143454 for(iCol=0; iCol<pInfo->nCol; iCol++){
143471 for(iCol=0; iCol<pInfo->nCol; iCol++){
143530 sInfo.nCol = pTab->nColumn;
