Lines Matching refs:nCol
11613 ** If successful, *pabPK is set to point to an array of nCol entries, where
11614 ** nCol is the number of columns in the table. Elements of *pabPK are set to
17762 i16 nCol; /* Number of columns in this table */
17906 int nCol; /* Number of columns in this key */
17914 } aCol[1]; /* One entry for each of nCol columns */
18050 ** In the Table structure describing Ex1, nCol==3 because there are
31426 int nCol,
31432 for(i=0; i<nCol; i++){
31434 int colMoreToFollow = i<(nCol - 1);
31528 sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
31529 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
31564 sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1);
81951 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
81953 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
81958 assert( pRec->pKeyInfo->nAllField==nCol );
81961 for(i=0; i<nCol; i++){
82471 int nCol = pRec->pKeyInfo->nAllField;
82474 for(i=0; i<nCol; i++){
87828 assert( pCsr->nField==pTab->nCol
87829 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
87838 preupdate.keyinfo.nKeyField = pTab->nCol;
93495 for(i=0; i<pTab->nCol; i++){
99448 for(iCol=0; iCol<pTab->nCol; iCol++) {
99453 if( iCol==pTab->nCol ){
99477 for(j=0; j<pFKey->nCol; j++){
99574 aOp[1].p4.i = pTab->nCol+1;
99575 aOp[3].p2 = pTab->nCol;
103846 testcase( pExTab->nCol==BMS-1 );
103847 testcase( pExTab->nCol==BMS );
103848 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
103979 assert( pTab->nCol>0 || pParse->nErr );
103992 assert( pEList->nExpr==pTab->nCol );
104049 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
104146 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
104156 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
104160 if( iCol<pTab->nCol ){
104184 pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +
104453 testcase( pTab->nCol==63 );
104454 testcase( pTab->nCol==64 );
104455 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
105838 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
110004 assert( iCol<pTab->nCol );
110386 int nCol;
110393 && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1
110395 sqlite3SubselectError(pParse, nCol, 1);
110501 p1 = pExpr->iTable * (pTab->nCol+1) + 1
110505 assert( iCol>=-1 && iCol<pTab->nCol );
110507 assert( p1>=0 && p1<(pTab->nCol*2+2) );
112663 pCol = &pNew->aCol[pNew->nCol-1];
112851 pNew->nCol = pTab->nCol;
112852 assert( pNew->nCol>0 );
112853 nAlloc = (((pNew->nCol-1)/8)*8)+8;
112854 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
112861 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
112862 for(i=0; i<pNew->nCol; i++){
112956 for(iCol=0; iCol<pTab->nCol; iCol++){
112959 if( iCol==pTab->nCol ){
113819 if( pTab==0 || iCol>=pTab->nCol ){
113858 if( iCol<sParse.pNewTable->nCol ){
113874 for(i=0; i<sParse.pNewTable->nCol; i++){
113884 for(i=0; i<pFKey->nCol; i++){
114246 for(i=0; i<sParse.pNewTable->nCol; i++){
114412 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
114419 if( iCol<pTab->nCol-1 ){
114494 if( pTab->nCol<=1 ){
114538 pParse->nMem += pTab->nCol;
114548 for(i=0; i<pTab->nCol; i++){
114892 int nCol; /* Number of columns in index + pk/rowid */
114900 StatSample *aBest; /* Array of nCol best samples */
114957 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
114958 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
114959 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
114976 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
115012 int nCol; /* Number of columns in index being sampled */
115014 int nColUp; /* nCol rounded up for alignment */
115024 nCol = sqlite3_value_int(argv[0]);
115025 assert( nCol>0 );
115026 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
115028 assert( nKeyCol<=nCol );
115038 + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */
115039 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
115052 p->nCol = nCol;
115067 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
115072 pSpace = (u8*)(&p->a[mxSample+nCol]);
115073 for(i=0; i<(mxSample+nCol); i++){
115080 for(i=0; i<nCol; i++){
115121 int nCol = pAccum->nCol;
115124 for(i=pNew->iCol+1; i<nCol; i++){
115223 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
115260 for(i=(p->nCol-2); i>=iChng; i--){
115272 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
115279 for(j=iChng; j<p->nCol; j++){
115320 assert( p->nCol>0 );
115321 assert( iChng<p->nCol );
115325 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
115337 for(i=iChng; i<p->nCol; i++){
115358 nLt = p->current.anLt[p->nCol-1];
115363 sampleInsert(p, &p->current, p->nCol-1);
115368 for(i=0; i<(p->nCol-1); i++){
115510 sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100);
115511 for(i=0; i<p->nCol; i++){
115637 pStat1->nCol = 3;
115655 int nCol; /* Number of columns in pIdx. "N" */
115664 nCol = pIdx->nKeyCol;
115666 nColTest = nCol - 1;
115668 nCol = pIdx->nColumn;
115670 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
115728 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
115880 int regSampleRowid = regCol + nCol;
115885 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
115896 for(i=0; i<nCol; i++){
115899 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
116169 int nCol = pIndex->nKeyCol+1;
116175 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
116181 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
116235 int nCol = 1;
116241 nCol = pIdx->nSampleCol-1;
116242 pIdx->aAvgEq[nCol] = 1;
116244 for(iCol=0; iCol<nCol; iCol++){
116391 int nCol = 1; /* Number of columns in index */
116399 nCol = pIdx->nSampleCol;
116405 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
116406 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
116407 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
117363 assert( iCol<pTab->nCol );
117366 assert( pTab->iPKey<pTab->nCol );
118237 for(i=0; i<pTable->nCol; i++, pCol++){
118247 pTable->nCol = 0;
118636 assert( iCol<pTab->nCol );
118981 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
119029 for(i=0; i<p->nCol; i++){
119036 aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0]));
119042 pCol = &p->aCol[p->nCol];
119069 p->nCol++;
119084 if( p==0 || NEVER(p->nCol<1) ) return;
119085 pCol = &p->aCol[p->nCol-1];
119095 if( pIdx->aiColumn[0]==p->nCol-1 ){
119216 pCol = &(p->aCol[p->nCol-1]);
119323 iCol = pTab->nCol - 1;
119337 for(iCol=0; iCol<pTab->nCol; iCol++){
119422 i = p->nCol-1;
119457 pCol = &(pTab->aCol[pTab->nCol-1]);
119587 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
119600 n += 35 + 6*p->nCol;
119610 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
119680 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
119696 assert( x<pIdx->pTable->nCol );
119702 /* Return true if column number x is any of the first nCol entries of aiCol[].
119704 ** first nCol entries of an index.
119706 static int hasColumn(const i16 *aiCol, int nCol, int x){
119707 while( nCol-- > 0 ){
119820 for(i=0; i<pTab->nCol; i++){
119942 for(i=0; i<pTab->nCol; i++){
119947 for(i=0, j=nPk; i<pTab->nCol; i++){
120140 for(ii=0; ii<p->nCol; ii++){
120207 for(ii=0; ii<p->nCol; ii++){
120314 p->nCol = p->nNVCol = pSelTab->nCol;
120316 pSelTab->nCol = 0;
120546 /* A positive nCol means the columns names for this view are
120548 ** table is virtual or nCol is zero.
120550 assert( pTable->nCol<=0 );
120552 /* A negative nCol is a special marker meaning that we are currently
120554 ** a negative nCol, it means two or more views form a loop, like this:
120567 if( pTable->nCol<0 ){
120571 assert( pTable->nCol>=0 );
120588 pTable->nCol = -1;
120601 pTable->nCol = 0;
120611 &pTable->nCol, &pTable->aCol);
120613 && pTable->nCol==pSel->pEList->nExpr
120624 pTable->nCol = pSelTab->nCol;
120627 pSelTab->nCol = 0;
120631 pTable->nNVCol = pTable->nCol;
120648 if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0;
121065 int nCol;
121071 int iCol = p->nCol-1;
121079 nCol = 1;
121086 nCol = pFromCol->nExpr;
121088 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
121101 z = (char*)&pFKey->aCol[nCol];
121110 pFKey->nCol = nCol;
121112 pFKey->aCol[0].iFrom = p->nCol-1;
121114 for(i=0; i<nCol; i++){
121116 for(j=0; j<p->nCol; j++){
121122 if( j>=p->nCol ){
121134 for(i=0; i<nCol; i++){
121306 ** Allocate heap space to hold an Index object with nCol columns.
121314 i16 nCol, /* Total number of columns in the index */
121322 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
121323 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
121324 sizeof(i16)*nCol + /* Index.aiColumn */
121325 sizeof(u8)*nCol); /* Index.aSortOrder */
121329 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
121330 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
121331 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
121333 p->nColumn = nCol;
121334 p->nKeyCol = nCol - 1;
121571 Column *pCol = &pTab->aCol[pTab->nCol-1];
121740 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
121742 for(j=0; j<pTab->nCol; j++){
123003 int nCol = pIdx->nColumn;
123008 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
123010 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
123014 for(i=0; i<nCol; i++){
124478 pParse->nMem += (1 + pTab->nCol);
124483 for(iCol=0; iCol<pTab->nCol; iCol++){
124660 int nCol;
124675 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
124676 regBase = sqlite3GetTempRange(pParse, nCol);
124678 for(j=0; j<nCol; j++){
124698 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
124700 sqlite3ReleaseTempRange(pParse, regBase, nCol);
127316 int nCol = pFKey->nCol; /* Number of columns in parent key */
127332 if( nCol==1 ){
127347 assert( nCol>1 );
127348 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
127354 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
127366 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
127376 for(i=0; i<nCol; i++){
127391 for(j=0; j<nCol; j++){
127397 if( j==nCol ) break;
127399 if( i==nCol ) break; /* pIdx is usable */
127477 for(i=0; i<pFKey->nCol; i++){
127515 int nCol = pFKey->nCol;
127516 int regTemp = sqlite3GetTempRange(pParse, nCol);
127520 for(i=0; i<nCol; i++){
127537 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
127538 for(i=0; i<nCol; i++){
127556 sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0,
127557 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
127558 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);
127560 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
127690 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
127691 assert( pIdx!=0 || pFKey->nCol==1 );
127707 for(i=0; i<pFKey->nCol; i++){
127929 for(i=0; i<p->nCol; i++){
127956 for(i=0; i<p->nCol; i++){
127959 for(iKey=0; iKey<pTab->nCol; iKey++){
127997 ** first register in an array of (pTab->nCol+1) registers containing the
128003 ** first register of an array of (pTab->nCol+1) registers containing the new
128074 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
128075 for(i=0; i<pFKey->nCol; i++){
128085 assert( pFKey->nCol==1 || (aiFree && pIdx) );
128093 for(i=0; i<pFKey->nCol; i++){
128162 assert( aiCol || pFKey->nCol==1 );
128223 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
128362 assert( aiCol || pFKey->nCol==1 );
128364 for(i=0; i<pFKey->nCol; i++){
128374 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
128722 zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1);
128725 for(i=j=0; i<pTab->nCol; i++){
128866 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
128930 for(i=0; i<pTab->nCol; i++){
128952 for(i=0; i<pTab->nCol; i++){
129024 || pSeqTab->nCol!=2
129440 pParse->nMem += pTab->nCol + 1;
129474 for(j=0; j<pTab->nCol; j++){
129492 if( j>=pTab->nCol ){
129523 dest.nSdst = pTab->nCol;
129621 for(i=0; i<pTab->nCol; i++){
129625 if( nColumn!=(pTab->nCol-nHidden) ){
129628 pTabList->a, pTab->nCol-nHidden, nColumn);
129719 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
129739 for(i=0; i<pTab->nCol; i++, iRegStore++){
129820 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
129872 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
129874 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
129937 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
129983 pTab, regData-2-pTab->nCol, onError, endOfLoop);
130183 ** pTab->nCol+1 registers in this range. The first register (the one
130289 int nCol; /* Number of columns */
130314 nCol = pTab->nCol;
130339 for(i=0; i<nCol; i++){
131111 for(i=pTab->nCol-1; i>0; i--){
131477 if( pDest->nCol!=pSrc->nCol ){
131486 for(i=0; i<pDest->nCol; i++){
131812 int nCol = 0;
131837 nCol = sqlite3_column_count(pStmt);
131838 azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
131842 for(i=0; i<nCol; i++){
131851 azVals = &azCols[nCol];
131852 for(i=0; i<nCol; i++){
131861 if( xCallback(pArg, nCol, azVals, azCols) ){
135430 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
135451 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
135493 /* Ensure that the Table.nCol field is initialized for all views
135494 ** and virtual tables. Each time we initialize a Table.nCol value
135505 if( pTab->nCol==0 ){
135540 pTab->nCol,
135726 for(j=0; j<pFK->nCol; j++){
135780 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
135821 if( regRow+pFK->nCol>pParse->nMem ) pParse->nMem = regRow+pFK->nCol;
135822 for(j=0; j<pFK->nCol; j++){
135831 sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0,
135832 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
135833 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol);
135839 assert( pFK->nCol==1 || db->mallocFailed );
136041 mxCol = pTab->nCol-1;
136080 for(j=0; j<pTab->nCol; j++){
136241 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
138527 for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
138722 for(j=0; j<pRightTab->nCol; j++){
140194 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
140208 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
140370 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
140424 int nCol; /* Number of columns in the result set */
140432 nCol = pEList->nExpr;
140433 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
140435 if( NEVER(nCol>32767) ) nCol = 32767;
140437 nCol = 0;
140440 assert( nCol==(i16)nCol );
140441 *pnCol = nCol;
140444 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
140546 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
140551 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
140604 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
140809 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
140870 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
140877 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
141357 int nCol; /* Number of columns in result set */
141361 nCol = p->pEList->nExpr;
141362 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
141367 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
141383 sqlite3VdbeChangeP2(v, addr, nCol);
143852 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
143911 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
144055 i16 nCol;
144079 nCol = pTab->nCol;
144080 pTab->nCol = -1;
144084 pTab->nCol = nCol;
144177 assert( pNestedFrom->nExpr==pTab->nCol );
144207 for(j=0; j<pTab->nCol; j++){
145056 if( pTab->nCol!=pSub->pEList->nExpr ){
145058 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
145796 int nCol;
145805 nCol = nGroupBy;
145809 nCol++;
145813 regBase = sqlite3GetTempRange(pParse, nCol);
145826 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
145829 sqlite3ReleaseTempRange(pParse, regBase, nCol);
145834 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
146203 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
146213 need = nCol*2;
146215 need = nCol;
146229 p->nColumn = nCol;
146230 for(i=0; i<nCol; i++){
146235 }else if( (int)p->nColumn!=nCol ){
146247 for(i=0; i<nCol; i++){
147287 for(jj=0; jj<pTab->nCol; jj++){
147364 int nCol = pNew->nExpr;
147366 pParse->nMem += nCol+2;
147368 for(i=0; i<nCol; i++){
147706 ** (a copy of pTab->nCol), then registers are populated as follows:
147904 assert( pTab->nCol>i );
147911 assert( i<pTab->nCol );
148084 for(i=0; i<pTab->nCol; i++){
148280 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
148282 aRegIdx = aXRef+pTab->nCol;
148286 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
148313 for(j=0; j<pTab->nCol; j++){
148338 if( j>=pTab->nCol ){
148383 for(i=0; i<pTab->nCol; i++){
148457 pParse->nMem += pTab->nCol;
148463 pParse->nMem += pTab->nCol;
148527 int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
148737 for(i=0; i<pTab->nCol; i++){
148771 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
148780 int nOff = (isView ? pTab->nCol : nPk);
148841 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
149040 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
149081 for(i=0; i<pTab->nCol; i++){
149105 for(i=0; i<pTab->nCol; i++){
149497 for(i=0; i<pTab->nCol; i++){
150585 for(iCol=0; iCol<pTab->nCol; iCol++){
150786 pTab->nNVCol = pTab->nCol = pNew->nCol;
150788 pNew->nCol = 0;
153093 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
153095 ai[0] = pTab->nCol;
153098 assert( pIdx->aiColumn[i]<pTab->nCol );
156523 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
156524 if( k>=pTab->nCol ){
157462 mxBitCol = MIN(BMS-1,pTable->nCol);
157463 testcase( pTable->nCol==BMS-1 );
157464 testcase( pTable->nCol==BMS-2 );
157469 nKeyCol += pTable->nCol - BMS + 1;
157512 for(i=BMS-1; i<pTable->nCol; i++){
157762 assert( pTerm->u.x.leftColumn<pTab->nCol );
157793 assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumn<pTab->nCol );
157806 assert( pE2->iColumn>=XN_ROWID && pE2->iColumn<pTab->nCol );
162571 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
162572 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
162574 && pTab->nCol<BMS
162585 assert( n<=pTab->nCol );
165915 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
177292 for(iCol=0; iCol<pTab->nCol; iCol++){
177298 if( iCol==pTab->nCol ){
179721 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
179722 ** where nCol is the number of columns in the queried FTS table. The array
180765 int nCol; /* Number of table columns */
180771 nCol = sqlite3_column_count(pStmt);
180772 for(i=0; i<nCol; i++){
180778 azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
180782 char *p = (char *)&azCol[nCol];
180783 for(i=0; i<nCol; i++){
180794 *pnCol = nCol;
180829 int nCol = 0; /* Number of columns in the FTS table */
180992 aCol[nCol++] = z;
181008 if( nCol==0 ){
181011 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
181017 for(j=0; j<nCol; j++){
181020 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
181021 nCol--;
181030 if( nCol==0 ){
181034 nCol = 1;
181052 nCol * sizeof(char *) + /* azColumn */
181054 nCol * sizeof(u8) + /* abNotindexed */
181065 p->nColumn = nCol;
181082 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
181091 zCsr = (char *)&p->abNotindexed[nCol];
181100 for(iCol=0; iCol<nCol; iCol++){
181115 for(iCol=0; iCol<nCol; iCol++){
184583 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
184584 ** varints, where nCol is the number of columns in the FTS3 table.
184586 ** the table. The following nCol varints contain the total amount of
185378 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
185401 }while( iCol<nCol );
185404 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
185405 fts3EvalUpdateCounts(pExpr->pRight, nCol);
186417 int nCol; /* Number of entries in azCol[] */
186844 for(ii=0; ii<pParse->nCol; ii++){
187285 int nCol, /* Number of entries in azCol[] */
187298 sParse.nCol = nCol;
187333 ** array, which is assumed to contain nCol entries, should contain the names
187348 int nCol, /* Number of entries in azCol[] */
187355 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
187509 int nCol;
187538 nCol = argc-2;
187539 azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
187544 for(ii=0; ii<nCol; ii++){
187551 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
187557 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
193312 ** two. If nCol is the number of user defined columns, then values of the
193317 ** Varint 1..nCol: For each column, the total number of tokens stored in
193320 ** Varint 1+nCol: The total size, in bytes, of all text values in all
195734 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
195735 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
195736 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
195737 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
195738 #define FTS3_MATCHINFO_LHITS 'y' /* nCol*nPhrase values */
195739 #define FTS3_MATCHINFO_LHITS_BM 'b' /* nCol*nPhrase values */
195798 int nCol; /* Number of columns in table */
196580 iStart = pExpr->iPhrase * p->nCol;
196582 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
196598 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
196635 ** for(iCol=0; iCol<nCol; iCol++){
196636 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
196637 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
196657 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
196673 int iStart = iPhrase * p->nCol * 3;
196676 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
196723 nVal = pInfo->nCol;
196727 nVal = pInfo->nCol * pInfo->nPhrase;
196731 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
196736 nVal = pInfo->nCol * pInfo->nPhrase * 3;
196839 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
196843 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
196866 for(iCol=0; iCol<pInfo->nCol; iCol++){
196953 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
196973 for(iCol=0; iCol<pInfo->nCol; iCol++){
196995 for(iCol=0; iCol<pInfo->nCol; iCol++){
197071 sInfo.nCol = pTab->nColumn;
209095 int nCol; /* Number of columns in current object */
209647 pIter->nCol = 0;
209893 ** there is room for at least nCol elements. If an OOM occurs, store an
209896 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
209897 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
209903 pIter->azTblType = &azNew[nCol];
209904 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
209905 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
209906 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
209907 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
210137 int nCol = 0;
210165 nCol = sqlite3_column_count(pStmt);
210166 rbuAllocateIterArrays(p, pIter, nCol);
210168 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
210441 for(iCol=0; iCol<pIter->nCol; iCol++){
210683 ** stored in the (p->nCol+1)'th column. Set the error code and error message
211171 pIter->nCol = nBind;
211256 pIter->nCol = pIter->nTblCol;
212094 int iCol = p->objiter.nCol; /* Index of rbu_control column */
212175 for(i=0; i<pIter->nCol; i++){
212206 ** Hence column_value(pIter->nCol+1).
212208 assertColumnName(pIter->pSelect, pIter->nCol+1,
212211 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
212212 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
212265 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
212276 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
212277 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
212278 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
215615 int nCol; /* Number of columns in zTab */
215638 int nCol; /* Number of columns in table zName */
215699 ** nCol bytes: 0x01 for PK columns, 0x00 otherwise.
215741 ** nCol bytes: 0x01 for PK columns, 0x00 otherwise.
215784 ** nCol bytes: 0x01 for PK columns, 0x00 otherwise.
216041 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
216042 for(i=0; i<pTab->nCol; i++){
216123 for(i=0; i<pTab->nCol; i++){
216173 for(iCol=0; iCol<pTab->nCol; iCol++){
216194 ** records with nCol columns. This function "merges" the two records into
216207 int nCol,
216214 int iCol; /* Used to iterate from 0 to nCol */
216216 for(iCol=0; iCol<nCol; iCol++){
216308 for(i=0; i<pTab->nCol; i++){
216333 for(i=0; i<pTab->nCol; i++){
216372 for(iCol=0; iCol<pTab->nCol; iCol++){
216631 ** write to this table, initalize the SessionTable.nCol, azCol[] and
216641 if( pTab->nCol==0 ){
216645 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
216649 for(i=0; i<pTab->nCol; i++){
216661 1 + sessionVarintLen(pTab->nCol) + pTab->nCol + strlen(pTab->zName)+1
216719 for(ii=0; ii<pTab->nCol; ii++){
216733 for(ii=0; ii<pTab->nCol; ii++){
216832 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
216887 for(i=0; i<pTab->nCol; i++){
216918 for(i=0; i<pTab->nCol; i++){
217112 int nCol,
217121 for(i=0; i<nCol; i++){
217135 int nCol,
217145 for(i=0; i<nCol; i++){
217166 int nCol,
217190 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
217220 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
217239 pDiffCtx->nOldOff = pTab->nCol;
217284 int nCol; /* Columns in zFrom.zTbl */
217287 rc = sessionTableInfo(0, db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
217289 if( pTo->nCol!=nCol ){
217293 for(i=0; i<nCol; i++){
217314 zExpr = sessionExprComparePK(pTo->nCol,
217853 int nCol, /* Number of columns in table */
217866 for(i=0; i<nCol; i++){
217908 int nCol, /* Number of columns in table */
217933 for(i=0; i<nCol; i++){
217963 int nCol, /* Number of columns in table */
217971 for(i=0; i<nCol && rc==SQLITE_OK; i++){
218040 sessionAppendVarint(pBuf, pTab->nCol, pRc);
218041 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
218089 int nCol = 0; /* Number of columns in table */
218098 rc = sessionTableInfo(0, db, pSession->zDb, zName, &nCol, 0,&azCol,&abPK);
218099 if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
218109 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
218117 rc = sessionSelectBind(pSel, nCol, abPK, p);
218124 for(iCol=0; iCol<nCol; iCol++){
218132 rc = sessionAppendDelete(&buf, bPatchset, p, nCol, abPK);
218451 ** that contains nCol values. This function advances the pointer *ppRec
218456 int nCol /* Number of values in record */
218460 for(i=0; i<nCol; i++){
218504 ** If the argument abPK is NULL, then the record contains nCol values. Or,
218523 int nCol, /* Number of values in record */
218533 for(i=0; i<nCol && rc==SQLITE_OK; i++){
218603 int nCol = 0;
218608 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
218613 ** if the (nCol>65536) condition below were omitted, a sufficiently
218614 ** large value for nCol may cause nRead to wrap around and become
218616 if( nCol<0 || nCol>65536 ){
218619 rc = sessionInputBuffer(pIn, nRead+nCol+100);
218620 nRead += nCol;
218637 ** of a record consisting of nCol columns. This function ensures the entire
218646 int nCol, /* Number of columns in record */
218652 for(i=0; rc==SQLITE_OK && i<nCol; i++){
218679 ** This function decodes the table-header and populates the p->nCol,
218681 ** also allocated or resized according to the new value of p->nCol. The
218697 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
218698 if( p->nCol>0 ){
218701 nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
218710 size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
218721 p->abPK = (u8*)&p->apValue[p->nCol*2];
218722 p->zTab = p->abPK ? (char*)&p->abPK[p->nCol] : 0;
218755 for(i=0; i<p->nCol*2; i++){
218758 memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
218803 nVal = p->nCol * 2;
218806 for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
218808 nVal = p->nCol;
218815 sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
218816 sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
218821 p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld, 0);
218827 p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew, pbEmpty);
218836 for(i=0; i<p->nCol; i++){
218840 p->apValue[i] = p->apValue[i+p->nCol];
218842 p->apValue[i+p->nCol] = 0;
218858 for(i=0; i<p->nCol; i++){
218859 if( p->abPK[i]==0 && p->apValue[i+p->nCol]==0 ){
218926 *pnCol = pIter->nCol;
218944 if( pnCol ) *pnCol = pIter->nCol;
218969 if( iVal<0 || iVal>=pIter->nCol ){
218997 if( iVal<0 || iVal>=pIter->nCol ){
219000 *ppValue = pIter->apValue[pIter->nCol+iVal];
219009 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
219031 if( iVal<0 || iVal>=pIter->nCol ){
219053 *pnOut = pIter->nCol;
219070 for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
219088 int nCol = 0; /* Number of cols in current table */
219116 ** * An array of nCol bytes (sPK),
219125 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
219127 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
219146 rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
219159 apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
219164 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
219173 rc = sessionReadRecord(pInput, nCol, 0, &apVal[0], 0);
219175 rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol], 0);
219181 for(iCol=0; iCol<nCol; iCol++){
219182 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
219189 for(iCol=0; iCol<nCol; iCol++){
219194 for(iCol=0; iCol<nCol*2; iCol++){
219197 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
219290 int nCol; /* Size of azCol[] and abPK[] arrays */
219321 int nCol = pIter->nCol;
219322 int nU32 = (pIter->nCol+33)/32;
219335 for(ii=0; ii<pIter->nCol; ii++){
219344 if( bPatchset ) p->aUpdateMask[nCol/32] |= (1<<(nCol%32));
219391 for(ii=0; ii<pIter->nCol; ii++){
219404 for(ii=0; ii<pIter->nCol; ii++){
219475 ** Variable :5 (nCol+1) is a boolean. It should be set to 0 if we require
219497 for(i=0; i<p->nCol; i++){
219508 if( nPk<p->nCol ){
219510 sessionAppendInteger(&buf, p->nCol+1, &rc);
219514 for(i=0; i<p->nCol; i++){
219553 db, "main", zTab, p->nCol, p->azCol, p->abPK, &p->pSelect);
219577 for(i=0; i<p->nCol; i++){
219583 for(i=1; i<p->nCol; i++){
219650 ** pStmt. The table being inserted into has nCol columns.
219653 ** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
219655 ** to an array nCol elements in size. In this case only those values for
219664 int nCol, /* Number of columns */
219677 for(i=0; rc==SQLITE_OK && i<nCol; i++){
219717 int nCol; /* Number of columns in table */
219721 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
219724 nCol, abPK, pSelect
219758 sessionAppendVarint(&p->rebase, p->nCol, &rc);
219759 sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
219771 for(i=0; i<p->nCol; i++){
219829 int nCol;
219833 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
219927 int nCol;
219934 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
219939 ** bind values for all columns and set bound variable (nCol+1) to true.
219941 ** values and, if it exists, set (nCol+1) to false. Conflict handling
219947 ** no (nCol+1) variable to bind to).
219950 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
219951 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
219952 rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
219976 for(i=0; rc==SQLITE_OK && i<nCol; i++){
220023 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
220085 sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
220086 sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
220126 size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
220130 pIter2->nCol = pApply->nCol;
220200 int nCol;
220204 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
220223 sApply.nCol = 0;
220249 db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK
220252 for(i=0; i<sApply.nCol; i++){
220256 if( sApply.nCol==0 ){
220262 else if( sApply.nCol<nCol ){
220267 zTab, sApply.nCol, nCol
220270 else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
220277 sApply.nCol = nCol;
220322 sIter.nCol = nFk;
220510 for(i=0; i<pTab->nCol; i++){
220543 for(i=0; i<pTab->nCol; i++){
220609 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
220610 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
220628 sessionSkipRecord(&a1, pTab->nCol);
220629 sessionSkipRecord(&a2, pTab->nCol);
220643 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
220674 int nCol;
220689 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
220702 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
220708 pTab->nCol = nCol;
220710 memcpy(pTab->abPK, abPK, nCol);
220711 pTab->zName = (char*)&pTab->abPK[nCol];
220720 }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){
220983 ** Buffers a1 and a2 must both contain a sessions module record nCol
220984 ** fields in size. This function appends an nCol sessions module
220990 int nCol, /* Number of columns in each record */
220999 for(i=0; i<nCol; i++){
221054 for(i=0; i<pIter->nCol; i++){
221073 for(i=0; i<pIter->nCol; i++){
221138 sessionAppendVarint(&sOut, pIter->nCol, &rc);
221139 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
221173 sessionSkipRecord(&pCsr, pIter->nCol);
221176 sessionAppendRecordMerge(&sOut, pIter->nCol,
221194 sessionAppendRecordMerge(&sOut, pIter->nCol,
222062 int nCol;
222114 int nCol; /* Number of columns */
224678 int nCol;
224686 nCol = pApi->xColumnCount(pFts);
224705 for(i=0; i<nCol; i++){
225878 p->abUnindexed[p->nCol] = 1;
225885 p->azCol[p->nCol++] = zCol;
225899 for(i=0; i<p->nCol; i++){
226057 for(i=0; i<pConfig->nCol; i++){
226082 for(i=0; zSql && i<pConfig->nCol; i++){
226622 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
226626 pColset->nCol = 1;
226725 iCol = pConfig->nCol;
228222 nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
228337 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
228341 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
228343 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
228349 for(i=0; i<nCol; i++){
228353 for(j=nCol; j>i; j--){
228357 pNew->nCol = nCol+1;
228361 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
228375 int nCol = pParse->pConfig->nCol;
228378 sizeof(Fts5Colset) + sizeof(int)*nCol
228383 for(i=0; i<nCol; i++){
228384 if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
228385 pRet->aiCol[pRet->nCol++] = i;
228409 for(iCol=0; iCol<pConfig->nCol; iCol++){
228412 if( iCol==pConfig->nCol ){
228439 sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
228458 while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
228470 pColset->nCol = iOut;
228494 if( pNear->pColset->nCol==0 ){
228857 int nCol = pNear->pColset->nCol;
228858 if( nCol==1 ){
228862 for(i=1; i<pNear->pColset->nCol; i++){
228934 if( pColset->nCol>1 ) zRet = fts5PrintfAppend(zRet, "{");
228935 for(ii=0; ii<pColset->nCol; ii++){
228937 pConfig->azCol[pColset->aiCol[ii]], ii==pColset->nCol-1 ? "" : " "
228941 zRet = fts5PrintfAppend(zRet, "%s : ", pColset->nCol>1 ? "}" : "");
229065 rc = sqlite3Fts5ExprNew(pConfig, 0, pConfig->nCol, zExpr, &pExpr, &zErr);
229277 for(i=0; i<pColset->nCol; i++){
233043 for(i=0; i<pColset->nCol; i++){
233232 if( pColset->nCol>1 && sqlite3Fts5BufferSize(pRc, &pIter->poslist, nPos) ){
233239 if( i==pColset->nCol ){
233253 if( pColset->nCol==1 ){
233311 ** xSetOutputs callback used when the Fts5Colset object has nCol==0 (match
233354 int *aiColEnd = &aiCol[pIter->pColset->nCol];
233419 else if( pIter->pColset->nCol==0 ){
233429 if( pConfig->nCol<=100 ){
233431 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
235712 ** Parameter anSize must point to an array of size nCol, where nCol is
235716 int nCol = p->pConfig->nCol;
235720 memset(anSize, 0, sizeof(i64) * nCol);
235726 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
237378 const int nCol = pConfig->nCol;
237415 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
237426 if( iCol==nCol+1 ){
237441 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
237481 if( iSort==(pConfig->nCol+1) && bSeenMatch ){
237530 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
238441 ** 3. Values for each of the nCol matchable columns.
238459 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
238471 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
238474 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
238480 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
238622 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
238704 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
238743 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
238799 if( aInst[1]<0 || aInst[1]>=nCol ){
238885 for(i=0; i<pConfig->nCol; i++){
238892 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
238911 for(i=0; i<pConfig->nCol; i++){
238914 }else if( iCol<pConfig->nCol ){
239312 if( iCol==pConfig->nCol ){
239317 if( iCol==pConfig->nCol ){
239323 }else if( iCol==pConfig->nCol+1 ){
239869 int nCol = pC->nCol + 1;
239873 zBind = sqlite3_malloc64(1 + nCol*2);
239875 for(i=0; i<nCol; i++){
240045 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
240056 int nDefn = 32 + pConfig->nCol*10;
240057 char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
240065 for(i=0; i<pConfig->nCol; i++){
240171 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
240263 int nCol = p->pConfig->nCol;
240270 for(i=0; i<nCol; i++){
240379 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
240472 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
240505 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
240646 int *aColSize; /* Array of size pConfig->nCol */
240647 i64 *aTotalSize; /* Array of size pConfig->nCol */
240654 aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
240656 aColSize = (int*)&aTotalSize[pConfig->nCol];
240657 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
240678 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
240717 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
240793 int *aCol, int nCol, /* Array to populate */
240798 for(i=0; i<nCol; i++){
240814 int nCol = p->pConfig->nCol; /* Number of user columns in table */
240827 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
240848 for(i=0; i<p->pConfig->nCol; i++){
240851 }else if( iCol<p->pConfig->nCol ){
243841 i64 nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
243849 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
243940 int nCol = pCsr->pFts5->pConfig->nCol;
243952 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
243957 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
243976 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
243977 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
244006 if( ii>=nCol ){
244017 assert_nc( iPos>=0 && iPos<nCol );
244018 if( iPos>=nCol ){
244054 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
244055 if( pCsr->iCol==nCol ){
244190 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){