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
61754 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
61756 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
61761 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
61764 for(i=0; i<nCol; i++){
62165 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
62168 for(i=0; i<nCol; i++){
74732 for(iCol=0; iCol<pTab->nCol; iCol++) {
74737 if( iCol==pTab->nCol ){
74761 for(j=0; j<pFKey->nCol; j++){
74825 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
74826 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
77041 assert( pTab->nCol>0 );
77069 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
77115 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
77123 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && HasRowid(pTab) ){
77128 if( iCol<pTab->nCol ){
78281 assert( pExpr->pTab && j<pExpr->pTab->nCol );
81192 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
81195 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
81197 assert( p1>=0 && p1<(pTab->nCol*2+2) );
83225 pCol = &pNew->aCol[pNew->nCol-1];
83375 pNew->nCol = pTab->nCol;
83376 assert( pNew->nCol>0 );
83377 nAlloc = (((pNew->nCol-1)/8)*8)+8;
83378 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
83385 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
83386 for(i=0; i<pNew->nCol; i++){
83695 int nCol; /* Number of columns in index + pk/rowid */
83700 Stat4Sample *aBest; /* Array of nCol best samples */
83756 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
83757 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
83758 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
83774 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
83809 int nCol; /* Number of columns in index being sampled */
83811 int nColUp; /* nCol rounded up for alignment */
83820 nCol = sqlite3_value_int(argv[0]);
83821 assert( nCol>0 );
83822 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
83824 assert( nKeyCol<=nCol );
83833 + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */
83834 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
83846 p->nCol = nCol;
83860 p->iPrn = nCol*0x689e962d ^ sqlite3_value_int(argv[2])*0xd0944565;
83865 pSpace = (u8*)(&p->a[mxSample+nCol]);
83866 for(i=0; i<(mxSample+nCol); i++){
83873 for(i=0; i<nCol; i++){
83912 int nCol = pAccum->nCol;
83915 for(i=pNew->iCol+1; i<nCol; i++){
84014 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
84054 for(i=(p->nCol-2); i>=iChng; i--){
84065 for(j=iChng; j<p->nCol; j++){
84127 assert( p->nCol>0 );
84128 assert( iChng<p->nCol );
84132 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
84142 for(i=iChng; i<p->nCol; i++){
84163 tRowcnt nLt = p->current.anLt[p->nCol-1];
84169 sampleInsert(p, &p->current, p->nCol-1);
84174 for(i=0; i<(p->nCol-1); i++){
84309 char *zRet = sqlite3MallocZero(p->nCol * 25);
84315 for(i=0; i<p->nCol; i++){
84426 int nCol; /* Number of columns in pIdx. "N" */
84435 nCol = pIdx->nKeyCol;
84437 nColTest = nCol - 1;
84439 nCol = pIdx->nColumn;
84441 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
84505 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
84623 int regSampleRowid = regCol + nCol;
84628 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
84646 for(i=0; i<nCol; i++){
84650 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
84973 int nCol = 1;
84979 nCol = pIdx->nSampleCol-1;
84980 pIdx->aAvgEq[nCol] = 1;
84982 for(iCol=0; iCol<nCol; iCol++){
85120 int nCol = 1; /* Number of columns in index */
85128 nCol = pIdx->nSampleCol;
85129 if( bStat3 && nCol>1 ) continue;
85135 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
85136 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
85137 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
86011 assert( iCol<pTab->nCol );
86014 assert( pTab->iPKey<pTab->nCol );
86626 for(i=0; i<pTable->nCol; i++, pCol++){
87128 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
87135 for(i=0; i<p->nCol; i++){
87142 if( (p->nCol & 0x7)==0 ){
87144 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
87151 pCol = &p->aCol[p->nCol];
87161 p->nCol++;
87173 if( p==0 || NEVER(p->nCol<1) ) return;
87174 p->aCol[p->nCol-1].notNull = (u8)onError;
87278 if( p==0 || NEVER(p->nCol<1) ) return;
87279 pCol = &p->aCol[p->nCol-1];
87301 pCol = &(p->aCol[p->nCol-1]);
87357 iCol = pTab->nCol - 1;
87364 for(iCol=0; iCol<pTab->nCol; iCol++){
87440 i = p->nCol-1;
87589 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
87602 n += 35 + 6*p->nCol;
87612 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
87679 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
87695 assert( x<pIdx->pTable->nCol );
87701 /* Return true if value x is found any of the first nCol entries of aiCol[]
87703 static int hasColumn(const i16 *aiCol, int nCol, int x){
87704 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
87815 if( nPk<pTab->nCol ){
87816 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
87817 for(i=0, j=nPk; i<pTab->nCol; i++){
87826 assert( pTab->nCol==j );
87828 pPk->nColumn = pTab->nCol;
87974 p->nCol = pSelTab->nCol;
87976 pSelTab->nCol = 0;
88165 /* A positive nCol means the columns names for this view are
88168 if( pTable->nCol>0 ) return 0;
88170 /* A negative nCol is a special marker meaning that we are currently
88172 ** a negative nCol, it means two or more views form a loop, like this:
88185 if( pTable->nCol<0 ){
88189 assert( pTable->nCol>=0 );
88204 pTable->nCol = -1;
88218 pTable->nCol = pSelTab->nCol;
88220 pSelTab->nCol = 0;
88226 pTable->nCol = 0;
88251 pTab->nCol = 0;
88616 int nCol;
88622 nCol-1;
88630 nCol = 1;
88637 nCol = pFromCol->nExpr;
88639 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
88651 z = (char*)&pFKey->aCol[nCol];
88657 pFKey->nCol = nCol;
88659 pFKey->aCol[0].iFrom = p->nCol-1;
88661 for(i=0; i<nCol; i++){
88663 for(j=0; j<p->nCol; j++){
88669 if( j>=p->nCol ){
88678 for(i=0; i<nCol; i++){
88824 ** Allocate heap space to hold an Index object with nCol columns.
88832 i16 nCol, /* Total number of columns in the index */
88840 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
88841 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
88842 sizeof(i16)*nCol + /* Index.aiColumn */
88843 sizeof(u8)*nCol); /* Index.aSortOrder */
88847 p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
88848 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
88849 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
88851 p->nColumn = nCol;
88852 p->nKeyCol = nCol - 1;
89054 pTab->aCol[pTab->nCol-1].zName);
89120 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
89123 if( j>=pTab->nCol ){
89129 assert( pTab->nCol<=0x7fff && j<=0x7fff );
90256 int nCol = pIdx->nColumn;
90260 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
90262 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
90266 for(i=0; i<nCol; i++){
91466 pParse->nMem += (1 + pTab->nCol);
91471 for(iCol=0; iCol<pTab->nCol; iCol++){
91624 int nCol;
91637 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
91638 regBase = sqlite3GetTempRange(pParse, nCol);
91640 for(j=0; j<nCol; j++){
91653 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
91655 sqlite3ReleaseTempRange(pParse, regBase, nCol);
93612 int nCol = pFKey->nCol; /* Number of columns in parent key */
93628 if( nCol==1 ){
93641 assert( nCol>1 );
93642 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
93648 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){
93660 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
93670 for(i=0; i<nCol; i++){
93685 for(j=0; j<nCol; j++){
93691 if( j==nCol ) break;
93693 if( i==nCol ) break; /* pIdx is usable */
93765 for(i=0; i<pFKey->nCol; i++){
93802 int nCol = pFKey->nCol;
93803 int regTemp = sqlite3GetTempRange(pParse, nCol);
93808 for(i=0; i<nCol; i++){
93823 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
93824 for(i=0; i<nCol; i++){
93838 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
93839 sqlite3IndexAffinityStr(v,pIdx), nCol);
93843 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
93972 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
93973 assert( pIdx!=0 || pFKey->nCol==1 );
93989 for(i=0; i<pFKey->nCol; i++){
94190 for(i=0; i<p->nCol; i++){
94217 for(i=0; i<p->nCol; i++){
94220 for(iKey=0; iKey<pTab->nCol; iKey++){
94240 ** first register in an array of (pTab->nCol+1) registers containing the
94246 ** first register of an array of (pTab->nCol+1) registers containing the new
94316 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
94317 for(i=0; i<pFKey->nCol; i++){
94325 assert( pFKey->nCol==1 || (aiFree && pIdx) );
94333 for(i=0; i<pFKey->nCol; i++){
94395 assert( aiCol || pFKey->nCol==1 );
94441 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
94557 assert( aiCol || pFKey->nCol==1 );
94559 for(i=0; i<pFKey->nCol; i++){
94825 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
94910 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
94916 for(i=0; i<pTab->nCol; i++){
95366 pParse->nMem += pTab->nCol + 1;
95389 for(j=0; j<pTab->nCol; j++){
95399 if( j>=pTab->nCol ){
95429 dest.nSdst = pTab->nCol;
95509 for(i=0; i<pTab->nCol; i++){
95513 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
95516 pTabList, 0, pTab->nCol-nHidden, nColumn);
95575 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
95607 for(i=0; i<pTab->nCol; i++){
95636 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
95638 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
95693 for(i=0; i<pTab->nCol; i++){
95737 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
95762 pTab, regData-2-pTab->nCol, onError, endOfLoop);
95833 ** pTab->nCol+1 registers in this range. The first register (the one
95929 int nCol; /* Number of columns */
95945 nCol = pTab->nCol;
95965 for(i=0; i<nCol; i++){
96361 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
96363 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
96647 if( pDest->nCol!=pSrc->nCol ){
96653 for(i=0; i<pDest->nCol; i++){
96854 int nCol;
96870 nCol = sqlite3_column_count(pStmt);
96881 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
96885 for(i=0; i<nCol; i++){
96894 azVals = &azCols[nCol];
96895 for(i=0; i<nCol; i++){
96903 if( xCallback(pArg, nCol, azVals, azCols) ){
99646 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
99666 for(k=1; ALWAYS(k<=pTab->nCol) && pPk->aiColumn[k-1]!=i; k++){}
99724 assert( pTab->nCol>cnum );
99814 for(j=0; j<pFK->nCol; j++){
99878 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
99915 assert( iKey>=0 && iKey<pTab->nCol );
99929 for(j=0; j<pFK->nCol; j++){
99935 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
99936 sqlite3IndexAffinityStr(v,pIdx), pFK->nCol);
100112 for(j=0; j<pTab->nCol; j++){
100164 assert( iCol>=0 && iCol<pTab->nCol );
101676 for(i=0; i<pTab->nCol; i++){
101836 for(j=0; j<pRightTab->nCol; j++){
102795 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
102935 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
102983 int nCol; /* Number of columns in the result set */
102989 nCol = pEList->nExpr;
102990 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
102993 nCol = 0;
102996 *pnCol = nCol;
102999 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
103092 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
103097 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
103137 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
103345 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
103398 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
103405 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
103817 int nCol; /* Number of columns in result set */
103820 nCol = p->pEList->nExpr;
103821 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
103826 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
103842 sqlite3VdbeChangeP2(v, addr, nCol);
105328 selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
105449 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
105568 for(j=0; j<pTab->nCol; j++){
106423 int nCol;
106432 nCol = nGroupBy + 1;
106436 nCol++;
106440 regBase = sqlite3GetTempRange(pParse, nCol);
106460 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
106463 sqlite3ReleaseTempRange(pParse, regBase, nCol);
106467 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
106903 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
106913 need = nCol*2;
106915 need = nCol;
106929 p->nColumn = nCol;
106930 for(i=0; i<nCol; i++){
106935 }else if( p->nColumn!=nCol ){
106947 for(i=0; i<nCol; i++){
108064 ** (a copy of pTab->nCol), then registers are populated as follows:
108252 assert( i<pTab->nCol );
108384 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
108386 aRegIdx = aXRef+pTab->nCol;
108390 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
108408 for(j=0; j<pTab->nCol; j++){
108420 if( j>=pTab->nCol ){
108500 pParse->nMem += pTab->nCol;
108506 pParse->nMem += pTab->nCol;
108658 for(i=0; i<pTab->nCol; i++){
108690 /*sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);*/
108691 for(i=0; i<pTab->nCol; i++){
108740 for(i=0; i<pTab->nCol; i++){
108915 for(i=0; i<pTab->nCol; i++){
108930 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
108940 pParse->nMem += pTab->nCol+1;
108944 for(i=0; i<pTab->nCol; i++){
108948 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
109870 for(iCol=0; iCol<pTab->nCol; iCol++){
110055 pTab->nCol = pParse->pNewTable->nCol;
110056 pParse->pNewTable->nCol = 0;
112540 mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol;
112541 testcase( pTable->nCol==BMS-1 );
112542 testcase( pTable->nCol==BMS-2 );
112547 nKeyCol += pTable->nCol - BMS + 1;
112587 for(i=BMS-1; i<pTable->nCol; i++){
117176 testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
117177 testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
117178 if( !pWInfo->okOnePass && pTab->nCol<BMS && HasRowid(pTab) ){
117184 assert( n<=pTab->nCol );
125107 for(iCol=0; iCol<pTab->nCol; iCol++){
125113 if( iCol==pTab->nCol ){
126924 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
126925 ** where nCol is the number of columns in the queried FTS table. The array
127861 int nCol; /* Number of table columns */
127867 nCol = sqlite3_column_count(pStmt);
127868 for(i=0; i<nCol; i++){
127874 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
127878 char *p = (char *)&azCol[nCol];
127879 for(i=0; i<nCol; i++){
127890 *pnCol = nCol;
127925 int nCol = 0; /* Number of columns in the FTS table */
128087 aCol[nCol++] = z;
128103 if( nCol==0 ){
128106 rc = fts3ContentColumns(db, argv[1], zContent, &aCol, &nCol, &nString);
128112 for(j=0; j<nCol; j++){
128115 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
128116 nCol--;
128125 if( nCol==0 ){
128129 nCol = 1;
128147 nCol * sizeof(char *) + /* azColumn */
128149 nCol * sizeof(u8) + /* abNotindexed */
128160 p->nColumn = nCol;
128177 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
128186 zCsr = (char *)&p->abNotindexed[nCol];
128195 for(iCol=0; iCol<nCol; iCol++){
128208 for(iCol=0; iCol<nCol; iCol++){
131472 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
131473 ** varints, where nCol is the number of columns in the FTS3 table.
131475 ** the table. The following nCol varints contain the total amount of
133284 int nCol; /* Number of entries in azCol[] */
133710 for(ii=0; ii<pParse->nCol; ii++){
134125 int nCol, /* Number of entries in azCol[] */
134138 sParse.nCol = nCol;
134173 ** array, which is assumed to contain nCol entries, should contain the names
134188 int nCol, /* Number of entries in azCol[] */
134195 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
134377 int nCol;
134410 nCol = argc-2;
134411 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
134416 for(ii=0; ii<nCol; ii++){
134423 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
134429 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
140048 ** two. If nCol is the number of user defined columns, then values of the
140053 ** Varint 1..nCol: For each column, the total number of tokens stored in
140056 ** Varint 1+nCol: The total size, in bytes, of all text values in all
142387 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
142388 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
142389 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
142390 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
142449 int nCol; /* Number of columns in table */
143113 ** for(iCol=0; iCol<nCol; iCol++){
143114 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
143115 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
143135 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
143151 int iStart = iPhrase * p->nCol * 3;
143154 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
143199 nVal = pInfo->nCol;
143204 nVal = pInfo->nCol * pInfo->nPhrase * 3;
143293 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
143297 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
143320 for(iCol=0; iCol<pInfo->nCol; iCol++){
143377 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
143403 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
143422 for(iCol=0; iCol<pInfo->nCol; iCol++){
143439 for(iCol=0; iCol<pInfo->nCol; iCol++){
143498 sInfo.nCol = pTab->nColumn;
