Lines Matching refs:nCol
16895 i16 nCol; /* Number of columns in this table */ member
17004 int nCol; /* Number of columns in this key */ member
28658 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab);
75699 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
75701 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
75706 assert( pRec->pKeyInfo->nAllField==nCol );
75709 for(i=0; i<nCol; i++){
76255 int nCol = pRec->pKeyInfo->nAllField;
76258 for(i=0; i<nCol; i++){
81262 assert( pCsr->nField==pTab->nCol
81263 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
81272 preupdate.keyinfo.nKeyField = pTab->nCol;
91400 for(iCol=0; iCol<pTab->nCol; iCol++) {
91405 if( iCol==pTab->nCol ){
91428 for(j=0; j<pFKey->nCol; j++){
91525 aOp[1].p4.i = pTab->nCol+1;
91526 aOp[3].p2 = pTab->nCol;
95354 assert( pTab->nCol>0 );
95385 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
95449 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
95457 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
95461 if( iCol<pTab->nCol ){
96914 assert( iCol<pTab->nCol );
100764 int nCol;
100767 if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){
100768 sqlite3SubselectError(pParse, nCol, 1);
100851 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
100854 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
100856 assert( p1>=0 && p1<(pTab->nCol*2+2) );
102635 pCol = &pNew->aCol[pNew->nCol-1];
102798 pNew->nCol = pTab->nCol;
102799 assert( pNew->nCol>0 );
102800 nAlloc = (((pNew->nCol-1)/8)*8)+8;
102801 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
102808 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
102809 for(i=0; i<pNew->nCol; i++){
102901 for(iCol=0; iCol<pTab->nCol; iCol++){
102904 if( iCol==pTab->nCol ){
103601 if( pTab==0 || iCol>=pTab->nCol ){
103656 for(i=0; i<pFKey->nCol; i++){
104281 int nCol; /* Number of columns in index + pk/rowid */
104343 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
104344 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
104345 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
104361 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
104397 int nCol; /* Number of columns in index being sampled */
104408 nCol = sqlite3_value_int(argv[0]);
104409 assert( nCol>0 );
104410 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
104412 assert( nKeyCol<=nCol );
104421 + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */
104422 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
104434 p->nCol = nCol;
104448 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
104453 pSpace = (u8*)(&p->a[mxSample+nCol]);
104454 for(i=0; i<(mxSample+nCol); i++){
104461 for(i=0; i<nCol; i++){
104502 int nCol = pAccum->nCol;
104505 for(i=pNew->iCol+1; i<nCol; i++){
104611 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
104651 for(i=(p->nCol-2); i>=iChng; i--){
104663 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
104670 for(j=iChng; j<p->nCol; j++){
104734 assert( p->nCol>0 );
104735 assert( iChng<p->nCol );
104739 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
104749 for(i=iChng; i<p->nCol; i++){
104770 tRowcnt nLt = p->current.anLt[p->nCol-1];
104776 sampleInsert(p, &p->current, p->nCol-1);
104781 for(i=0; i<(p->nCol-1); i++){
104921 char *zRet = sqlite3MallocZero(p->nCol * 25);
104927 for(i=0; i<p->nCol; i++){
105034 pStat1->nCol = 3;
105052 int nCol; /* Number of columns in pIdx. "N" */
105061 nCol = pIdx->nKeyCol;
105063 nColTest = nCol - 1;
105065 nCol = pIdx->nColumn;
105067 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
105131 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
105254 int regSampleRowid = regCol + nCol;
105259 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
105273 for(i=0; i<nCol; i++){
105276 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
105545 int nCol = pIndex->nKeyCol+1;
105551 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
105557 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
105611 int nCol = 1;
105617 nCol = pIdx->nSampleCol-1;
105618 pIdx->aAvgEq[nCol] = 1;
105620 for(iCol=0; iCol<nCol; iCol++){
105772 int nCol = 1; /* Number of columns in index */
105780 nCol = pIdx->nSampleCol;
105781 if( bStat3 && nCol>1 ) continue;
105787 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
105788 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
105789 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
106743 assert( iCol<pTab->nCol );
106746 assert( pTab->iPKey<pTab->nCol );
107433 for(i=0; i<pTable->nCol; i++, pCol++){
107941 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
107951 for(i=0; i<p->nCol; i++){
107958 if( (p->nCol & 0x7)==0 ){
107960 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
107967 pCol = &p->aCol[p->nCol];
107990 p->nCol++;
108004 if( p==0 || NEVER(p->nCol<1) ) return;
108005 pCol = &p->aCol[p->nCol-1];
108015 if( pIdx->aiColumn[0]==p->nCol-1 ){
108135 pCol = &(p->aCol[p->nCol-1]);
108221 iCol = pTab->nCol - 1;
108233 for(iCol=0; iCol<pTab->nCol; iCol++){
108308 i = p->nCol-1;
108458 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
108471 n += 35 + 6*p->nCol;
108481 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
108548 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
108564 assert( x<pIdx->pTable->nCol );
108572 static int hasColumn(const i16 *aiCol, int nCol, int x){
108573 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
108637 for(i=0; i<pTab->nCol; i++){
108732 if( nPk<pTab->nCol ){
108733 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
108734 for(i=0, j=nPk; i<pTab->nCol; i++){
108743 assert( pTab->nCol==j );
108745 pPk->nColumn = pTab->nCol;
108946 p->nCol = pSelTab->nCol;
108948 pSelTab->nCol = 0;
109163 if( pTable->nCol>0 ) return 0;
109180 if( pTable->nCol<0 ){
109184 assert( pTable->nCol>=0 );
109202 pTable->nCol = -1;
109221 &pTable->nCol, &pTable->aCol);
109224 && pTable->nCol==pSel->pEList->nExpr
109233 pTable->nCol = pSelTab->nCol;
109235 pSelTab->nCol = 0;
109239 pTable->nCol = 0;
109255 pTable->nCol = 0;
109275 pTab->nCol = 0;
109637 int nCol;
109643 int iCol = p->nCol-1;
109651 nCol = 1;
109658 nCol = pFromCol->nExpr;
109660 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
109672 z = (char*)&pFKey->aCol[nCol];
109681 pFKey->nCol = nCol;
109683 pFKey->aCol[0].iFrom = p->nCol-1;
109685 for(i=0; i<nCol; i++){
109687 for(j=0; j<p->nCol; j++){
109693 if( j>=p->nCol ){
109705 for(i=0; i<nCol; i++){
109865 i16 nCol, /* Total number of columns in the index */
109873 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
109874 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
109875 sizeof(i16)*nCol + /* Index.aiColumn */
109876 sizeof(u8)*nCol); /* Index.aSortOrder */
109880 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
109881 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
109882 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
109884 p->nColumn = nCol;
109885 p->nKeyCol = nCol - 1;
110099 Column *pCol = &pTab->aCol[pTab->nCol-1];
110258 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
110260 for(j=0; j<pTab->nCol; j++){
111425 int nCol = pIdx->nColumn;
111430 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
111432 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
111436 for(i=0; i<nCol; i++){
112754 pParse->nMem += (1 + pTab->nCol);
112759 for(iCol=0; iCol<pTab->nCol; iCol++){
112934 int nCol;
112947 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
112948 regBase = sqlite3GetTempRange(pParse, nCol);
112950 for(j=0; j<nCol; j++){
112968 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
112974 sqlite3ReleaseTempRange(pParse, regBase, nCol);
115211 int nCol = pFKey->nCol; /* Number of columns in parent key */
115227 if( nCol==1 ){
115240 assert( nCol>1 );
115241 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
115247 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
115259 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
115269 for(i=0; i<nCol; i++){
115284 for(j=0; j<nCol; j++){
115290 if( j==nCol ) break;
115292 if( i==nCol ) break; /* pIdx is usable */
115370 for(i=0; i<pFKey->nCol; i++){
115407 int nCol = pFKey->nCol;
115408 int regTemp = sqlite3GetTempRange(pParse, nCol);
115413 for(i=0; i<nCol; i++){
115428 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
115429 for(i=0; i<nCol; i++){
115444 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
115445 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
115449 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
115582 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
115583 assert( pIdx!=0 || pFKey->nCol==1 );
115599 for(i=0; i<pFKey->nCol; i++){
115802 for(i=0; i<p->nCol; i++){
115829 for(i=0; i<p->nCol; i++){
115832 for(iKey=0; iKey<pTab->nCol; iKey++){
115946 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
115947 for(i=0; i<pFKey->nCol; i++){
115955 assert( pFKey->nCol==1 || (aiFree && pIdx) );
115963 for(i=0; i<pFKey->nCol; i++){
116032 assert( aiCol || pFKey->nCol==1 );
116093 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
116229 assert( aiCol || pFKey->nCol==1 );
116231 for(i=0; i<pFKey->nCol; i++){
116241 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
116493 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
116588 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
116594 for(i=0; i<pTab->nCol; i++){
116697 || pSeqTab->nCol!=2
117096 pParse->nMem += pTab->nCol + 1;
117120 for(j=0; j<pTab->nCol; j++){
117130 if( j>=pTab->nCol ){
117161 dest.nSdst = pTab->nCol;
117241 for(i=0; i<pTab->nCol; i++){
117244 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
117247 pTabList, 0, pTab->nCol-nHidden, nColumn);
117329 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
117361 for(i=j=0; i<pTab->nCol; i++){
117390 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
117392 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
117444 for(i=0; i<pTab->nCol; i++){
117487 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
117526 pTab, regData-2-pTab->nCol, onError, endOfLoop);
117751 int nCol; /* Number of columns */
117769 nCol = pTab->nCol;
117789 for(i=0; i<nCol; i++){
118319 for(i=pTab->nCol-1; i>0; i--){
118395 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
118684 if( pDest->nCol!=pSrc->nCol ){
118690 for(i=0; i<pDest->nCol; i++){
118953 int nCol = 0;
118978 nCol = sqlite3_column_count(pStmt);
118979 azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
118983 for(i=0; i<nCol; i++){
118992 azVals = &azCols[nCol];
118993 for(i=0; i<nCol; i++){
119002 if( xCallback(pArg, nCol, azVals, azCols) ){
122288 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
122299 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
122481 for(j=0; j<pFK->nCol; j++){
122537 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
122576 for(j=0; j<pFK->nCol; j++){
122585 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
122586 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
122593 assert( pFK->nCol==1 );
122755 sqlite3VdbeAddOp3(v, OP_Column, iDataCur, pTab->nCol-1, 3);
122759 for(j=0; j<pTab->nCol; j++){
122827 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
124899 for(i=0; i<pTab->nCol; i++){
125087 for(j=0; j<pRightTab->nCol; j++){
126333 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
126347 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
126506 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
126560 int nCol; /* Number of columns in the result set */
126567 nCol = pEList->nExpr;
126568 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
126570 if( nCol>32767 ) nCol = 32767;
126572 nCol = 0;
126575 assert( nCol==(i16)nCol );
126576 *pnCol = nCol;
126579 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
126670 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
126675 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
126726 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
126931 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
126991 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
126998 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
127447 int nCol; /* Number of columns in result set */
127450 nCol = p->pEList->nExpr;
127451 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
127456 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
127472 sqlite3VdbeChangeP2(v, addr, nCol);
129355 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
129416 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
129515 i16 nCol;
129519 nCol = pTab->nCol;
129520 pTab->nCol = -1;
129522 pTab->nCol = nCol;
129616 for(j=0; j<pTab->nCol; j++){
130323 if( pTab->nCol!=pSub->pEList->nExpr ){
130325 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
130925 int nCol;
130934 nCol = nGroupBy;
130938 nCol++;
130942 regBase = sqlite3GetTempRange(pParse, nCol);
130955 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
130958 sqlite3ReleaseTempRange(pParse, regBase, nCol);
130962 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
131285 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
131295 need = nCol*2;
131297 need = nCol;
131311 p->nColumn = nCol;
131312 for(i=0; i<nCol; i++){
131317 }else if( (int)p->nColumn!=nCol ){
131329 for(i=0; i<nCol; i++){
132701 assert( i<pTab->nCol );
132909 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
132911 aRegIdx = aXRef+pTab->nCol;
132915 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
132935 for(j=0; j<pTab->nCol; j++){
132947 if( j>=pTab->nCol ){
133032 pParse->nMem += pTab->nCol;
133038 pParse->nMem += pTab->nCol;
133248 for(i=0; i<pTab->nCol; i++){
133280 for(i=0; i<pTab->nCol; i++){
133333 for(i=0; i<pTab->nCol; i++){
133518 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
133543 for(i=0; i<pTab->nCol; i++){
134883 for(iCol=0; iCol<pTab->nCol; iCol++){
135075 pTab->nCol = pNew->nCol;
135077 pNew->nCol = 0;
137194 int *ai = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*(pTab->nCol+1));
137196 ai[0] = pTab->nCol;
137198 assert( pIdx->aiColumn[i]<pTab->nCol );
140016 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
140017 if( k>=pTab->nCol ){
140812 mxBitCol = MIN(BMS-1,pTable->nCol);
140813 testcase( pTable->nCol==BMS-1 );
140814 testcase( pTable->nCol==BMS-2 );
140819 nKeyCol += pTable->nCol - BMS + 1;
140858 for(i=BMS-1; i<pTable->nCol; i++){
145019 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
145020 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
145021 if( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol<BMS && HasRowid(pTab) ){
145026 assert( n<=pTab->nCol );
147802 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
158251 for(iCol=0; iCol<pTab->nCol; iCol++){
158257 if( iCol==pTab->nCol ){
161334 int nCol; /* Number of table columns */
161340 nCol = sqlite3_column_count(pStmt);
161341 for(i=0; i<nCol; i++){
161347 azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
161351 char *p = (char *)&azCol[nCol];
161352 for(i=0; i<nCol; i++){
161363 *pnCol = nCol;
161398 int nCol = 0; /* Number of columns in the FTS table */
161561 aCol[nCol++] = z;
161577 if( nCol==0 ){
161580 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
161586 for(j=0; j<nCol; j++){
161589 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
161590 nCol--;
161599 if( nCol==0 ){
161603 nCol = 1;
161621 nCol * sizeof(char *) + /* azColumn */
161623 nCol * sizeof(u8) + /* abNotindexed */
161634 p->nColumn = nCol;
161651 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
161660 zCsr = (char *)&p->abNotindexed[nCol];
161669 for(iCol=0; iCol<nCol; iCol++){
161684 for(iCol=0; iCol<nCol; iCol++){
165885 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
165908 }while( iCol<nCol );
165911 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
165912 fts3EvalUpdateCounts(pExpr->pRight, nCol);
166915 int nCol; /* Number of entries in azCol[] */
167340 for(ii=0; ii<pParse->nCol; ii++){
167781 int nCol, /* Number of entries in azCol[] */
167794 sParse.nCol = nCol;
167844 int nCol, /* Number of entries in azCol[] */
167851 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
168005 int nCol;
168034 nCol = argc-2;
168035 azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
168040 for(ii=0; ii<nCol; ii++){
168047 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
168053 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
176185 int nCol; /* Number of columns in table */
176969 iStart = pExpr->iPhrase * p->nCol;
176971 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
176987 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
177046 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
177062 int iStart = iPhrase * p->nCol * 3;
177065 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
177112 nVal = pInfo->nCol;
177116 nVal = pInfo->nCol * pInfo->nPhrase;
177120 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
177125 nVal = pInfo->nCol * pInfo->nPhrase * 3;
177242 for(iCol=0; iCol<pInfo->nCol; iCol++){
177329 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
177348 for(iCol=0; iCol<pInfo->nCol; iCol++){
177365 for(iCol=0; iCol<pInfo->nCol; iCol++){
177437 sInfo.nCol = pTab->nColumn;
189135 int nCol; /* Number of columns in current object */
189680 pIter->nCol = 0;
189925 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
189926 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
189932 pIter->azTblType = &azNew[nCol];
189933 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
189934 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
189935 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
189936 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
190160 int nCol = 0;
190188 nCol = sqlite3_column_count(pStmt);
190189 rbuAllocateIterArrays(p, pIter, nCol);
190191 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
190937 pIter->nCol = nBind;
191006 pIter->nCol = pIter->nTblCol;
191809 int iCol = p->objiter.nCol; /* Index of rbu_control column */
191890 for(i=0; i<pIter->nCol; i++){
191923 assertColumnName(pIter->pSelect, pIter->nCol+1,
191926 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
191927 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
191980 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
191991 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
191992 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
191993 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
195128 int nCol; /* Number of columns in zTab */
195151 int nCol; /* Number of columns in table zName */
195533 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
195534 for(i=0; i<pTab->nCol; i++){
195615 for(i=0; i<pTab->nCol; i++){
195665 for(iCol=0; iCol<pTab->nCol; iCol++){
195699 int nCol,
195708 for(iCol=0; iCol<nCol; iCol++){
195800 for(i=0; i<pTab->nCol; i++){
195825 for(i=0; i<pTab->nCol; i++){
195864 for(iCol=0; iCol<pTab->nCol; iCol++){
196110 if( pTab->nCol==0 ){
196114 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
196118 for(i=0; i<pTab->nCol; i++){
196198 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
196254 for(i=0; i<pTab->nCol; i++){
196285 for(i=0; i<pTab->nCol; i++){
196469 int nCol,
196478 for(i=0; i<nCol; i++){
196492 int nCol,
196502 for(i=0; i<nCol; i++){
196523 int nCol,
196547 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
196577 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
196596 pDiffCtx->nOldOff = pTab->nCol;
196641 int nCol; /* Columns in zFrom.zTbl */
196644 rc = sessionTableInfo(db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
196646 if( pTo->nCol!=nCol ){
196650 for(i=0; i<nCol; i++){
196669 zExpr = sessionExprComparePK(pTo->nCol,
197188 int nCol, /* Number of columns in table */
197201 for(i=0; i<nCol; i++){
197243 int nCol, /* Number of columns in table */
197268 for(i=0; i<nCol; i++){
197298 int nCol, /* Number of columns in table */
197306 for(i=0; i<nCol && rc==SQLITE_OK; i++){
197375 sessionAppendVarint(pBuf, pTab->nCol, pRc);
197376 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
197422 int nCol; /* Number of columns in table */
197431 rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK);
197432 if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
197442 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
197450 rc = sessionSelectBind(pSel, nCol, abPK, p);
197457 for(iCol=0; iCol<nCol; iCol++){
197464 rc = sessionAppendDelete(&buf, bPatchset, p, nCol, abPK);
197736 int nCol /* Number of values in record */
197740 for(i=0; i<nCol; i++){
197803 int nCol, /* Number of values in record */
197810 for(i=0; i<nCol && rc==SQLITE_OK; i++){
197875 int nCol = 0;
197880 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
197888 if( nCol<0 || nCol>65536 ){
197891 rc = sessionInputBuffer(pIn, nRead+nCol+100);
197892 nRead += nCol;
197918 int nCol, /* Number of columns in record */
197924 for(i=0; rc==SQLITE_OK && i<nCol; i++){
197969 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
197970 if( p->nCol>0 ){
197973 nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
197982 size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
197989 p->abPK = (u8*)&p->apValue[p->nCol*2];
197990 p->zTab = (char*)&p->abPK[p->nCol];
198026 for(i=0; i<p->nCol*2; i++){
198029 memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
198074 nVal = p->nCol * 2;
198077 for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
198079 nVal = p->nCol;
198086 sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
198087 sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
198092 p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld);
198098 p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew);
198107 for(i=0; i<p->nCol; i++){
198111 p->apValue[i] = p->apValue[i+p->nCol];
198113 p->apValue[i+p->nCol] = 0;
198150 *pnCol = pIter->nCol;
198168 if( pnCol ) *pnCol = pIter->nCol;
198193 if( iVal<0 || iVal>=pIter->nCol ){
198221 if( iVal<0 || iVal>=pIter->nCol ){
198224 *ppValue = pIter->apValue[pIter->nCol+iVal];
198233 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
198255 if( iVal<0 || iVal>=pIter->nCol ){
198277 *pnOut = pIter->nCol;
198294 for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
198312 int nCol = 0; /* Number of cols in current table */
198349 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
198351 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
198370 rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
198383 apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
198388 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
198397 rc = sessionReadRecord(pInput, nCol, 0, &apVal[0]);
198399 rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol]);
198405 for(iCol=0; iCol<nCol; iCol++){
198406 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
198413 for(iCol=0; iCol<nCol; iCol++){
198418 for(iCol=0; iCol<nCol*2; iCol++){
198421 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
198507 int nCol; /* Size of azCol[] and abPK[] arrays */
198550 for(i=0; i<p->nCol; i++){
198561 if( nPk<p->nCol ){
198563 sessionAppendInteger(&buf, p->nCol+1, &rc);
198567 for(i=0; i<p->nCol; i++){
198634 for(i=0; i<p->nCol; i++){
198649 for(i=0; i<p->nCol; i++){
198660 sessionAppendInteger(&buf, p->nCol*3+1, &rc);
198662 for(i=0; i<p->nCol; i++){
198703 db, "main", zTab, p->nCol, p->azCol, p->abPK, &p->pSelect);
198727 for(i=0; i<p->nCol; i++){
198733 for(i=1; i<p->nCol; i++){
198825 int nCol, /* Number of columns */
198838 for(i=0; rc==SQLITE_OK && i<nCol; i++){
198878 int nCol; /* Number of columns in table */
198882 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
198885 nCol, abPK, pSelect
198919 sessionAppendVarint(&p->rebase, p->nCol, &rc);
198920 sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
198932 for(i=0; i<p->nCol; i++){
198990 int nCol;
198994 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
199088 int nCol;
199095 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
199111 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
199112 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
199113 rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
199133 for(i=0; rc==SQLITE_OK && i<nCol; i++){
199146 sqlite3_bind_int(p->pUpdate, nCol*3+1, pbRetry==0 || pIter->bPatchset);
199185 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
199247 sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
199248 sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
199286 size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
199290 pIter2->nCol = pApply->nCol;
199359 int nCol;
199363 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
199383 sApply.nCol = 0;
199409 db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK
199412 for(i=0; i<sApply.nCol; i++){
199416 if( sApply.nCol==0 ){
199422 else if( sApply.nCol<nCol ){
199427 zTab, sApply.nCol, nCol
199430 else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
199437 sApply.nCol = nCol;
199483 sIter.nCol = nFk;
199671 for(i=0; i<pTab->nCol; i++){
199704 for(i=0; i<pTab->nCol; i++){
199770 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
199771 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
199789 sessionSkipRecord(&a1, pTab->nCol);
199790 sessionSkipRecord(&a2, pTab->nCol);
199804 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
199835 int nCol;
199850 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
199863 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
199869 pTab->nCol = nCol;
199871 memcpy(pTab->abPK, abPK, nCol);
199872 pTab->zName = (char*)&pTab->abPK[nCol];
199881 }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){
200151 int nCol, /* Number of columns in each record */
200160 for(i=0; i<nCol; i++){
200215 for(i=0; i<pIter->nCol; i++){
200234 for(i=0; i<pIter->nCol; i++){
200299 sessionAppendVarint(&sOut, pIter->nCol, &rc);
200300 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
200334 sessionSkipRecord(&pCsr, pIter->nCol);
200337 sessionAppendRecordMerge(&sOut, pIter->nCol,
200355 sessionAppendRecordMerge(&sOut, pIter->nCol,
201206 int nCol;
201258 int nCol; /* Number of columns */
203788 int nCol;
203796 nCol = pApi->xColumnCount(pFts);
203815 for(i=0; i<nCol; i++){
204978 p->abUnindexed[p->nCol] = 1;
204985 p->azCol[p->nCol++] = zCol;
204999 for(i=0; i<p->nCol; i++){
205152 for(i=0; i<pConfig->nCol; i++){
205177 for(i=0; zSql && i<pConfig->nCol; i++){
205712 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
205716 pColset->nCol = 1;
207189 nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
207304 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
207308 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
207310 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
207316 for(i=0; i<nCol; i++){
207320 for(j=nCol; j>i; j--){
207324 pNew->nCol = nCol+1;
207328 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
207342 int nCol = pParse->pConfig->nCol;
207345 sizeof(Fts5Colset) + sizeof(int)*nCol
207350 for(i=0; i<nCol; i++){
207351 if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
207352 pRet->aiCol[pRet->nCol++] = i;
207376 for(iCol=0; iCol<pConfig->nCol; iCol++){
207379 if( iCol==pConfig->nCol ){
207406 sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
207425 while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
207437 pColset->nCol = iOut;
207461 if( pNear->pColset->nCol==0 ){
207759 int nCol = pNear->pColset->nCol;
207760 if( nCol==1 ){
207764 for(i=1; i<pNear->pColset->nCol; i++){
207956 rc = sqlite3Fts5ExprNew(pConfig, pConfig->nCol, zExpr, &pExpr, &zErr);
208153 for(i=0; i<pColset->nCol; i++){
211863 for(i=0; i<pColset->nCol; i++){
212073 for(i=0; i<pColset->nCol; i++){
212161 int *aiColEnd = &aiCol[pIter->pColset->nCol];
212200 if( pColset->nCol==1 ){
212232 else if( pIter->pColset->nCol==0 ){
212242 if( pConfig->nCol<=100 ){
212244 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
214410 int nCol = p->pConfig->nCol;
214414 memset(anSize, 0, sizeof(i64) * nCol);
214420 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
215959 const int nCol = pConfig->nCol;
215985 aColMap[1] = nCol;
215986 aColMap[2] = nCol+1;
215999 if( (p->op==SQLITE_INDEX_CONSTRAINT_MATCH && iCol>=0 && iCol<=nCol)
216000 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol==nCol)
216027 if( iSort==(pConfig->nCol+1) && BitFlagTest(idxFlags, FTS5_BI_MATCH) ){
216087 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
216631 assert( iCol>=0 && iCol<=pConfig->nCol );
216953 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
216965 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
216968 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
216974 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
217116 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
217198 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
217237 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
217291 if( aInst[1]<0 || aInst[1]>=nCol ){
217377 for(i=0; i<pConfig->nCol; i++){
217384 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
217403 for(i=0; i<pConfig->nCol; i++){
217406 }else if( iCol<pConfig->nCol ){
217801 if( iCol==pConfig->nCol ){
217806 if( iCol==pConfig->nCol ){
217812 }else if( iCol==pConfig->nCol+1 ){
218351 int nCol = pC->nCol + 1;
218355 zBind = sqlite3_malloc64(1 + nCol*2);
218357 for(i=0; i<nCol; i++){
218525 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
218536 int nDefn = 32 + pConfig->nCol*10;
218537 char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
218545 for(i=0; i<pConfig->nCol; i++){
218651 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
218732 int nCol = p->pConfig->nCol;
218739 for(i=0; i<nCol; i++){
218846 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
218938 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
218971 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
219118 aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
219120 aColSize = (int*)&aTotalSize[pConfig->nCol];
219121 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
219138 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
219176 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
219251 int *aCol, int nCol, /* Array to populate */
219256 for(i=0; i<nCol; i++){
219272 int nCol = p->pConfig->nCol; /* Number of user columns in table */
219284 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
219303 for(i=0; i<p->pConfig->nCol; i++){
219306 }else if( iCol<p->pConfig->nCol ){
222156 int nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
222164 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
222254 int nCol = pCsr->pFts5->pConfig->nCol;
222263 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
222268 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
222287 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
222288 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
222317 if( ii>=nCol ){
222328 assert_nc( iPos>=0 && iPos<nCol );
222329 if( iPos>=nCol ){
222366 assert( pCsr->iCol<pCsr->pFts5->pConfig->nCol );
222496 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){
