Lines Matching refs:nCol
17472 i16 nCol; /* Number of columns in this table */ member
17593 int nCol; /* Number of columns in this key */ member
29541 pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
76959 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
76961 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
76966 assert( pRec->pKeyInfo->nAllField==nCol );
76969 for(i=0; i<nCol; i++){
77475 int nCol = pRec->pKeyInfo->nAllField;
77478 for(i=0; i<nCol; i++){
82744 assert( pCsr->nField==pTab->nCol
82745 || (pCsr->nField==pTab->nCol+1 && op==SQLITE_DELETE && iReg==-1)
82754 preupdate.keyinfo.nKeyField = pTab->nCol;
93335 for(iCol=0; iCol<pTab->nCol; iCol++) {
93340 if( iCol==pTab->nCol ){
93363 for(j=0; j<pFKey->nCol; j++){
93460 aOp[1].p4.i = pTab->nCol+1;
93461 aOp[3].p2 = pTab->nCol;
97722 testcase( pExTab->nCol==BMS-1 );
97723 testcase( pExTab->nCol==BMS );
97724 return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
97830 assert( pTab->nCol>0 );
97862 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
97927 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
97935 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
97939 if( iCol<pTab->nCol ){
98186 testcase( pTab->nCol==63 );
98187 testcase( pTab->nCol==64 );
98188 pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
99509 assert( iCol<pTab->nCol );
103361 assert( iCol<pTab->nCol );
103749 int nCol;
103752 if( op==TK_SELECT && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 ){
103753 sqlite3SubselectError(pParse, nCol, 1);
103837 int p1 = pExpr->iTable * (pTab->nCol+1) + 1
103841 assert( iCol>=-1 && iCol<pTab->nCol );
103843 assert( p1>=0 && p1<(pTab->nCol*2+2) );
105794 pCol = &pNew->aCol[pNew->nCol-1];
105963 pNew->nCol = pTab->nCol;
105964 assert( pNew->nCol>0 );
105965 nAlloc = (((pNew->nCol-1)/8)*8)+8;
105966 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
105973 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
105974 for(i=0; i<pNew->nCol; i++){
106067 for(iCol=0; iCol<pTab->nCol; iCol++){
106070 if( iCol==pTab->nCol ){
106826 if( pTab==0 || iCol>=pTab->nCol ){
106881 for(i=0; i<sParse.pNewTable->nCol; i++){
106887 for(i=0; i<pFKey->nCol; i++){
107516 int nCol; /* Number of columns in index + pk/rowid */
107581 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
107582 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
107583 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
107600 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
107636 int nCol; /* Number of columns in index being sampled */
107648 nCol = sqlite3_value_int(argv[0]);
107649 assert( nCol>0 );
107650 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
107652 assert( nKeyCol<=nCol );
107662 + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */
107663 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample);
107677 p->nCol = nCol;
107692 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
107697 pSpace = (u8*)(&p->a[mxSample+nCol]);
107698 for(i=0; i<(mxSample+nCol); i++){
107705 for(i=0; i<nCol; i++){
107746 int nCol = pAccum->nCol;
107749 for(i=pNew->iCol+1; i<nCol; i++){
107848 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
107885 for(i=(p->nCol-2); i>=iChng; i--){
107897 for(j=p->nMaxEqZero; j<p->nCol; j++) assert( p->a[i].anEq[j]>0 );
107904 for(j=iChng; j<p->nCol; j++){
107945 assert( p->nCol>0 );
107946 assert( iChng<p->nCol );
107950 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
107962 for(i=iChng; i<p->nCol; i++){
107983 nLt = p->current.anLt[p->nCol-1];
107988 sampleInsert(p, &p->current, p->nCol-1);
107993 for(i=0; i<(p->nCol-1); i++){
108138 char *zRet = sqlite3MallocZero(p->nCol * 25);
108144 for(i=0; i<p->nCol; i++){
108249 pStat1->nCol = 3;
108267 int nCol; /* Number of columns in pIdx. "N" */
108276 nCol = pIdx->nKeyCol;
108278 nColTest = nCol - 1;
108280 nCol = pIdx->nColumn;
108282 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
108340 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
108492 int regSampleRowid = regCol + nCol;
108497 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
108508 for(i=0; i<nCol; i++){
108511 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
108781 int nCol = pIndex->nKeyCol+1;
108787 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
108793 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
108847 int nCol = 1;
108853 nCol = pIdx->nSampleCol-1;
108854 pIdx->aAvgEq[nCol] = 1;
108856 for(iCol=0; iCol<nCol; iCol++){
109002 int nCol = 1; /* Number of columns in index */
109010 nCol = pIdx->nSampleCol;
109016 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
109017 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
109018 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
109950 assert( iCol<pTab->nCol );
109953 assert( pTab->iPKey<pTab->nCol );
110657 for(i=0; i<pTable->nCol; i++, pCol++){
111023 assert( iCol<pTab->nCol );
111278 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
111288 for(i=0; i<p->nCol; i++){
111295 if( (p->nCol & 0x7)==0 ){
111297 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
111304 pCol = &p->aCol[p->nCol];
111328 p->nCol++;
111343 if( p==0 || NEVER(p->nCol<1) ) return;
111344 pCol = &p->aCol[p->nCol-1];
111354 if( pIdx->aiColumn[0]==p->nCol-1 ){
111475 pCol = &(p->aCol[p->nCol-1]);
111582 iCol = pTab->nCol - 1;
111594 for(iCol=0; iCol<pTab->nCol; iCol++){
111670 i = p->nCol-1;
111707 pCol = &(pTab->aCol[pTab->nCol-1]);
111837 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
111850 n += 35 + 6*p->nCol;
111860 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
111927 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
111943 assert( x<pIdx->pTable->nCol );
111953 static int hasColumn(const i16 *aiCol, int nCol, int x){
111954 while( nCol-- > 0 ){
112067 for(i=0; i<pTab->nCol; i++){
112179 for(i=0; i<pTab->nCol; i++){
112184 for(i=0, j=nPk; i<pTab->nCol; i++){
112372 for(ii=0; ii<p->nCol; ii++){
112474 p->nCol = p->nNVCol = pSelTab->nCol;
112476 pSelTab->nCol = 0;
112691 if( pTable->nCol>0 ) return 0;
112708 if( pTable->nCol<0 ){
112712 assert( pTable->nCol>=0 );
112730 pTable->nCol = -1;
112742 pTable->nCol = 0;
112752 &pTable->nCol, &pTable->aCol);
112755 && pTable->nCol==pSel->pEList->nExpr
112765 pTable->nCol = pSelTab->nCol;
112767 pSelTab->nCol = 0;
112771 pTable->nNVCol = pTable->nCol;
112785 pTable->nCol = 0;
112805 pTab->nCol = 0;
113197 int nCol;
113203 int iCol = p->nCol-1;
113211 nCol = 1;
113218 nCol = pFromCol->nExpr;
113220 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
113232 z = (char*)&pFKey->aCol[nCol];
113241 pFKey->nCol = nCol;
113243 pFKey->aCol[0].iFrom = p->nCol-1;
113245 for(i=0; i<nCol; i++){
113247 for(j=0; j<p->nCol; j++){
113253 if( j>=p->nCol ){
113265 for(i=0; i<nCol; i++){
113442 i16 nCol, /* Total number of columns in the index */
113450 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
113451 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
113452 sizeof(i16)*nCol + /* Index.aiColumn */
113453 sizeof(u8)*nCol); /* Index.aSortOrder */
113457 p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
113458 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
113459 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
113461 p->nColumn = nCol;
113462 p->nKeyCol = nCol - 1;
113700 Column *pCol = &pTab->aCol[pTab->nCol-1];
113865 if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
113867 for(j=0; j<pTab->nCol; j++){
115031 int nCol = pIdx->nColumn;
115036 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
115038 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
115042 for(i=0; i<nCol; i++){
116407 pParse->nMem += (1 + pTab->nCol);
116412 for(iCol=0; iCol<pTab->nCol; iCol++){
116589 int nCol;
116604 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
116605 regBase = sqlite3GetTempRange(pParse, nCol);
116607 for(j=0; j<nCol; j++){
116625 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
116631 sqlite3ReleaseTempRange(pParse, regBase, nCol);
118890 int nCol = pFKey->nCol; /* Number of columns in parent key */
118906 if( nCol==1 ){
118919 assert( nCol>1 );
118920 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
118926 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
118938 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
118948 for(i=0; i<nCol; i++){
118963 for(j=0; j<nCol; j++){
118969 if( j==nCol ) break;
118971 if( i==nCol ) break; /* pIdx is usable */
119049 for(i=0; i<pFKey->nCol; i++){
119087 int nCol = pFKey->nCol;
119088 int regTemp = sqlite3GetTempRange(pParse, nCol);
119093 for(i=0; i<nCol; i++){
119110 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
119111 for(i=0; i<nCol; i++){
119129 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
119130 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
119134 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
119267 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
119268 assert( pIdx!=0 || pFKey->nCol==1 );
119284 for(i=0; i<pFKey->nCol; i++){
119487 for(i=0; i<p->nCol; i++){
119514 for(i=0; i<p->nCol; i++){
119517 for(iKey=0; iKey<pTab->nCol; iKey++){
119631 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
119632 for(i=0; i<pFKey->nCol; i++){
119642 assert( pFKey->nCol==1 || (aiFree && pIdx) );
119650 for(i=0; i<pFKey->nCol; i++){
119719 assert( aiCol || pFKey->nCol==1 );
119780 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
119916 assert( aiCol || pFKey->nCol==1 );
119918 for(i=0; i<pFKey->nCol; i++){
119928 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
120285 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
120291 for(i=j=0; i<pTab->nCol; i++){
120358 assert( pExpr->iColumn < pWalker->u.pTab->nCol );
120416 for(i=0; i<pTab->nCol; i++){
120438 for(i=0; i<pTab->nCol; i++){
120510 || pSeqTab->nCol!=2
120910 pParse->nMem += pTab->nCol + 1;
120942 for(j=0; j<pTab->nCol; j++){
120960 if( j>=pTab->nCol ){
120991 dest.nSdst = pTab->nCol;
121084 for(i=0; i<pTab->nCol; i++){
121087 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
121090 pTabList, 0, pTab->nCol-nHidden, nColumn);
121172 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
121192 for(i=0; i<pTab->nCol; i++, iRegStore++){
121261 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
121318 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
121320 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
121383 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
121420 pTab, regData-2-pTab->nCol, onError, endOfLoop);
121662 int nCol; /* Number of columns */
121686 nCol = pTab->nCol;
121711 for(i=0; i<nCol; i++){
122418 for(i=pTab->nCol-1; i>0; i--){
122776 if( pDest->nCol!=pSrc->nCol ){
122782 for(i=0; i<pDest->nCol; i++){
123076 int nCol = 0;
123101 nCol = sqlite3_column_count(pStmt);
123102 azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
123106 for(i=0; i<nCol; i++){
123115 azVals = &azCols[nCol];
123116 for(i=0; i<nCol; i++){
123125 if( xCallback(pArg, nCol, azVals, azCols) ){
126492 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
126512 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
126703 for(j=0; j<pFK->nCol; j++){
126759 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
126798 for(j=0; j<pFK->nCol; j++){
126807 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
126808 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
126815 assert( pFK->nCol==1 );
126983 for(j=0; j<pTab->nCol; j++){
127053 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
129132 for(i=0; i<pTab->nCol; i++){
129323 for(j=0; j<pRightTab->nCol; j++){
130570 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
130584 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
130743 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
130797 int nCol; /* Number of columns in the result set */
130804 nCol = pEList->nExpr;
130805 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
130807 if( nCol>32767 ) nCol = 32767;
130809 nCol = 0;
130812 assert( nCol==(i16)nCol );
130813 *pnCol = nCol;
130816 for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){
130908 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
130913 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
130961 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
131166 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
131226 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
131233 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
131689 int nCol; /* Number of columns in result set */
131692 nCol = p->pEList->nExpr;
131693 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
131698 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
131714 sqlite3VdbeChangeP2(v, addr, nCol);
133688 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
133749 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
133852 i16 nCol;
133871 nCol = pTab->nCol;
133872 pTab->nCol = -1;
133876 pTab->nCol = nCol;
133969 for(j=0; j<pTab->nCol; j++){
134688 if( pTab->nCol!=pSub->pEList->nExpr ){
134690 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
135320 int nCol;
135329 nCol = nGroupBy;
135333 nCol++;
135337 regBase = sqlite3GetTempRange(pParse, nCol);
135350 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
135353 sqlite3ReleaseTempRange(pParse, regBase, nCol);
135357 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
135684 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
135694 need = nCol*2;
135696 need = nCol;
135710 p->nColumn = nCol;
135711 for(i=0; i<nCol; i++){
135716 }else if( (int)p->nColumn!=nCol ){
135728 for(i=0; i<nCol; i++){
137112 assert( i<pTab->nCol );
137322 aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
137324 aRegIdx = aXRef+pTab->nCol;
137328 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
137352 for(j=0; j<pTab->nCol; j++){
137374 if( j>=pTab->nCol ){
137418 for(i=0; i<pTab->nCol; i++){
137490 pParse->nMem += pTab->nCol;
137496 pParse->nMem += pTab->nCol;
137713 for(i=0; i<pTab->nCol; i++){
137747 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
137810 for(i=0, k=regNew; i<pTab->nCol; i++, k++){
138012 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
138037 for(i=0; i<pTab->nCol; i++){
138367 for(i=0; i<pTab->nCol; i++){
139428 for(iCol=0; iCol<pTab->nCol; iCol++){
139620 pTab->nCol = pNew->nCol;
139622 pNew->nCol = 0;
141789 int *ai = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*(pTab->nCol+1));
141791 ai[0] = pTab->nCol;
141794 assert( pIdx->aiColumn[i]<pTab->nCol );
144801 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
144802 if( k>=pTab->nCol ){
145606 mxBitCol = MIN(BMS-1,pTable->nCol);
145607 testcase( pTable->nCol==BMS-1 );
145608 testcase( pTable->nCol==BMS-2 );
145613 nKeyCol += pTable->nCol - BMS + 1;
145653 for(i=BMS-1; i<pTable->nCol; i++){
149933 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
149934 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
149936 && pTab->nCol<BMS
149946 assert( n<=pTab->nCol );
153084 int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */
163855 for(iCol=0; iCol<pTab->nCol; iCol++){
163861 if( iCol==pTab->nCol ){
167158 int nCol; /* Number of table columns */
167164 nCol = sqlite3_column_count(pStmt);
167165 for(i=0; i<nCol; i++){
167171 azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
167175 char *p = (char *)&azCol[nCol];
167176 for(i=0; i<nCol; i++){
167187 *pnCol = nCol;
167222 int nCol = 0; /* Number of columns in the FTS table */
167385 aCol[nCol++] = z;
167401 if( nCol==0 ){
167404 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
167410 for(j=0; j<nCol; j++){
167413 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
167414 nCol--;
167423 if( nCol==0 ){
167427 nCol = 1;
167445 nCol * sizeof(char *) + /* azColumn */
167447 nCol * sizeof(u8) + /* abNotindexed */
167458 p->nColumn = nCol;
167475 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
167484 zCsr = (char *)&p->abNotindexed[nCol];
167493 for(iCol=0; iCol<nCol; iCol++){
167508 for(iCol=0; iCol<nCol; iCol++){
171745 static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
171768 }while( iCol<nCol );
171771 fts3EvalUpdateCounts(pExpr->pLeft, nCol);
171772 fts3EvalUpdateCounts(pExpr->pRight, nCol);
172775 int nCol; /* Number of entries in azCol[] */
173197 for(ii=0; ii<pParse->nCol; ii++){
173638 int nCol, /* Number of entries in azCol[] */
173651 sParse.nCol = nCol;
173701 int nCol, /* Number of entries in azCol[] */
173708 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
173862 int nCol;
173891 nCol = argc-2;
173892 azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
173897 for(ii=0; ii<nCol; ii++){
173904 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
173910 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
182112 int nCol; /* Number of columns in table */
182896 iStart = pExpr->iPhrase * p->nCol;
182898 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
182914 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
182973 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
182989 int iStart = iPhrase * p->nCol * 3;
182992 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
183039 nVal = pInfo->nCol;
183043 nVal = pInfo->nCol * pInfo->nPhrase;
183047 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
183052 nVal = pInfo->nCol * pInfo->nPhrase * 3;
183181 for(iCol=0; iCol<pInfo->nCol; iCol++){
183268 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
183288 for(iCol=0; iCol<pInfo->nCol; iCol++){
183310 for(iCol=0; iCol<pInfo->nCol; iCol++){
183386 sInfo.nCol = pTab->nColumn;
195239 int nCol; /* Number of columns in current object */
195789 pIter->nCol = 0;
196038 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
196039 sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
196045 pIter->azTblType = &azNew[nCol];
196046 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
196047 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
196048 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
196049 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
196277 int nCol = 0;
196305 nCol = sqlite3_column_count(pStmt);
196306 rbuAllocateIterArrays(p, pIter, nCol);
196308 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
196581 for(iCol=0; iCol<pIter->nCol; iCol++){
197309 pIter->nCol = nBind;
197394 pIter->nCol = pIter->nTblCol;
198221 int iCol = p->objiter.nCol; /* Index of rbu_control column */
198302 for(i=0; i<pIter->nCol; i++){
198335 assertColumnName(pIter->pSelect, pIter->nCol+1,
198338 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
198339 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
198392 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
198403 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
198404 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
198405 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
201638 int nCol; /* Number of columns in zTab */
201661 int nCol; /* Number of columns in table zName */
202043 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
202044 for(i=0; i<pTab->nCol; i++){
202125 for(i=0; i<pTab->nCol; i++){
202175 for(iCol=0; iCol<pTab->nCol; iCol++){
202209 int nCol,
202218 for(iCol=0; iCol<nCol; iCol++){
202310 for(i=0; i<pTab->nCol; i++){
202335 for(i=0; i<pTab->nCol; i++){
202374 for(iCol=0; iCol<pTab->nCol; iCol++){
202620 if( pTab->nCol==0 ){
202624 pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
202628 for(i=0; i<pTab->nCol; i++){
202708 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
202764 for(i=0; i<pTab->nCol; i++){
202795 for(i=0; i<pTab->nCol; i++){
202979 int nCol,
202988 for(i=0; i<nCol; i++){
203002 int nCol,
203012 for(i=0; i<nCol; i++){
203033 int nCol,
203057 char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
203087 char *zExpr2 = sessionExprCompareOther(pTab->nCol,
203106 pDiffCtx->nOldOff = pTab->nCol;
203151 int nCol; /* Columns in zFrom.zTbl */
203154 rc = sessionTableInfo(db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
203156 if( pTo->nCol!=nCol ){
203160 for(i=0; i<nCol; i++){
203181 zExpr = sessionExprComparePK(pTo->nCol,
203700 int nCol, /* Number of columns in table */
203713 for(i=0; i<nCol; i++){
203755 int nCol, /* Number of columns in table */
203780 for(i=0; i<nCol; i++){
203810 int nCol, /* Number of columns in table */
203818 for(i=0; i<nCol && rc==SQLITE_OK; i++){
203887 sessionAppendVarint(pBuf, pTab->nCol, pRc);
203888 sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
203934 int nCol; /* Number of columns in table */
203943 rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK);
203944 if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
203954 db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
203962 rc = sessionSelectBind(pSel, nCol, abPK, p);
203969 for(iCol=0; iCol<nCol; iCol++){
203976 rc = sessionAppendDelete(&buf, bPatchset, p, nCol, abPK);
204248 int nCol /* Number of values in record */
204252 for(i=0; i<nCol; i++){
204315 int nCol, /* Number of values in record */
204322 for(i=0; i<nCol && rc==SQLITE_OK; i++){
204387 int nCol = 0;
204392 nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
204400 if( nCol<0 || nCol>65536 ){
204403 rc = sessionInputBuffer(pIn, nRead+nCol+100);
204404 nRead += nCol;
204430 int nCol, /* Number of columns in record */
204436 for(i=0; rc==SQLITE_OK && i<nCol; i++){
204481 nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
204482 if( p->nCol>0 ){
204485 nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
204494 size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
204501 p->abPK = (u8*)&p->apValue[p->nCol*2];
204502 p->zTab = (char*)&p->abPK[p->nCol];
204538 for(i=0; i<p->nCol*2; i++){
204541 memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
204586 nVal = p->nCol * 2;
204589 for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
204591 nVal = p->nCol;
204598 sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
204599 sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
204604 p->rc = sessionReadRecord(&p->in, p->nCol, abPK, apOld);
204610 p->rc = sessionReadRecord(&p->in, p->nCol, 0, apNew);
204619 for(i=0; i<p->nCol; i++){
204623 p->apValue[i] = p->apValue[i+p->nCol];
204625 p->apValue[i+p->nCol] = 0;
204662 *pnCol = pIter->nCol;
204680 if( pnCol ) *pnCol = pIter->nCol;
204705 if( iVal<0 || iVal>=pIter->nCol ){
204733 if( iVal<0 || iVal>=pIter->nCol ){
204736 *ppValue = pIter->apValue[pIter->nCol+iVal];
204745 #define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
204767 if( iVal<0 || iVal>=pIter->nCol ){
204789 *pnOut = pIter->nCol;
204806 for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
204824 int nCol = 0; /* Number of cols in current table */
204861 nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
204863 sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
204882 rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
204895 apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
204900 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
204909 rc = sessionReadRecord(pInput, nCol, 0, &apVal[0]);
204911 rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol]);
204917 for(iCol=0; iCol<nCol; iCol++){
204918 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
204925 for(iCol=0; iCol<nCol; iCol++){
204930 for(iCol=0; iCol<nCol*2; iCol++){
204933 memset(apVal, 0, sizeof(apVal[0])*nCol*2);
205019 int nCol; /* Size of azCol[] and abPK[] arrays */
205062 for(i=0; i<p->nCol; i++){
205073 if( nPk<p->nCol ){
205075 sessionAppendInteger(&buf, p->nCol+1, &rc);
205079 for(i=0; i<p->nCol; i++){
205146 for(i=0; i<p->nCol; i++){
205161 for(i=0; i<p->nCol; i++){
205172 sessionAppendInteger(&buf, p->nCol*3+1, &rc);
205174 for(i=0; i<p->nCol; i++){
205215 db, "main", zTab, p->nCol, p->azCol, p->abPK, &p->pSelect);
205239 for(i=0; i<p->nCol; i++){
205245 for(i=1; i<p->nCol; i++){
205337 int nCol, /* Number of columns */
205350 for(i=0; rc==SQLITE_OK && i<nCol; i++){
205390 int nCol; /* Number of columns in table */
205394 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
205397 nCol, abPK, pSelect
205431 sessionAppendVarint(&p->rebase, p->nCol, &rc);
205432 sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
205444 for(i=0; i<p->nCol; i++){
205502 int nCol;
205506 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
205600 int nCol;
205607 sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
205623 rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
205624 if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
205625 rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
205645 for(i=0; rc==SQLITE_OK && i<nCol; i++){
205658 sqlite3_bind_int(p->pUpdate, nCol*3+1, pbRetry==0 || pIter->bPatchset);
205697 rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
205759 sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
205760 sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
205798 size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
205802 pIter2->nCol = pApply->nCol;
205871 int nCol;
205875 sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
205895 sApply.nCol = 0;
205921 db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK
205924 for(i=0; i<sApply.nCol; i++){
205928 if( sApply.nCol==0 ){
205934 else if( sApply.nCol<nCol ){
205939 zTab, sApply.nCol, nCol
205942 else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
205949 sApply.nCol = nCol;
205995 sIter.nCol = nFk;
206183 for(i=0; i<pTab->nCol; i++){
206216 for(i=0; i<pTab->nCol; i++){
206282 if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
206283 sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
206301 sessionSkipRecord(&a1, pTab->nCol);
206302 sessionSkipRecord(&a2, pTab->nCol);
206316 sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
206347 int nCol;
206362 sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
206375 pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
206381 pTab->nCol = nCol;
206383 memcpy(pTab->abPK, abPK, nCol);
206384 pTab->zName = (char*)&pTab->abPK[nCol];
206393 }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){
206663 int nCol, /* Number of columns in each record */
206672 for(i=0; i<nCol; i++){
206727 for(i=0; i<pIter->nCol; i++){
206746 for(i=0; i<pIter->nCol; i++){
206811 sessionAppendVarint(&sOut, pIter->nCol, &rc);
206812 sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
206846 sessionSkipRecord(&pCsr, pIter->nCol);
206849 sessionAppendRecordMerge(&sOut, pIter->nCol,
206867 sessionAppendRecordMerge(&sOut, pIter->nCol,
207723 int nCol;
207775 int nCol; /* Number of columns */
210311 int nCol;
210319 nCol = pApi->xColumnCount(pFts);
210338 for(i=0; i<nCol; i++){
211510 p->abUnindexed[p->nCol] = 1;
211517 p->azCol[p->nCol++] = zCol;
211531 for(i=0; i<p->nCol; i++){
211684 for(i=0; i<pConfig->nCol; i++){
211709 for(i=0; zSql && i<pConfig->nCol; i++){
212245 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
212249 pColset->nCol = 1;
213758 nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
213873 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
213877 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
213879 pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
213885 for(i=0; i<nCol; i++){
213889 for(j=nCol; j>i; j--){
213893 pNew->nCol = nCol+1;
213897 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
213911 int nCol = pParse->pConfig->nCol;
213914 sizeof(Fts5Colset) + sizeof(int)*nCol
213919 for(i=0; i<nCol; i++){
213920 if( iOld>=p->nCol || p->aiCol[iOld]!=i ){
213921 pRet->aiCol[pRet->nCol++] = i;
213945 for(iCol=0; iCol<pConfig->nCol; iCol++){
213948 if( iCol==pConfig->nCol ){
213975 sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
213994 while( iIn<pColset->nCol && iMerge<pMerge->nCol ){
214006 pColset->nCol = iOut;
214030 if( pNear->pColset->nCol==0 ){
214328 int nCol = pNear->pColset->nCol;
214329 if( nCol==1 ){
214333 for(i=1; i<pNear->pColset->nCol; i++){
214527 rc = sqlite3Fts5ExprNew(pConfig, pConfig->nCol, zExpr, &pExpr, &zErr);
214724 for(i=0; i<pColset->nCol; i++){
218430 for(i=0; i<pColset->nCol; i++){
218640 for(i=0; i<pColset->nCol; i++){
218728 int *aiColEnd = &aiCol[pIter->pColset->nCol];
218767 if( pColset->nCol==1 ){
218799 else if( pIter->pColset->nCol==0 ){
218809 if( pConfig->nCol<=100 ){
218811 sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
220999 int nCol = p->pConfig->nCol;
221003 memset(anSize, 0, sizeof(i64) * nCol);
221009 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
222611 const int nCol = pConfig->nCol;
222648 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
222659 if( iCol==nCol+1 ){
222666 if( iCol<nCol ){
222710 if( iSort==(pConfig->nCol+1) && bSeenMatch ){
222759 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
223325 iCol = pConfig->nCol;
223672 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
223684 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
223687 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
223693 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
223835 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
223917 for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
223956 int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
224010 if( aInst[1]<0 || aInst[1]>=nCol ){
224096 for(i=0; i<pConfig->nCol; i++){
224103 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
224122 for(i=0; i<pConfig->nCol; i++){
224125 }else if( iCol<pConfig->nCol ){
224520 if( iCol==pConfig->nCol ){
224525 if( iCol==pConfig->nCol ){
224531 }else if( iCol==pConfig->nCol+1 ){
225072 int nCol = pC->nCol + 1;
225076 zBind = sqlite3_malloc64(1 + nCol*2);
225078 for(i=0; i<nCol; i++){
225248 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
225259 int nDefn = 32 + pConfig->nCol*10;
225260 char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
225268 for(i=0; i<pConfig->nCol; i++){
225374 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
225455 int nCol = p->pConfig->nCol;
225462 for(i=0; i<nCol; i++){
225571 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
225664 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
225697 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
225845 aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
225847 aColSize = (int*)&aTotalSize[pConfig->nCol];
225848 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
225865 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
225904 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
225979 int *aCol, int nCol, /* Array to populate */
225984 for(i=0; i<nCol; i++){
226000 int nCol = p->pConfig->nCol; /* Number of user columns in table */
226012 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
226031 for(i=0; i<p->pConfig->nCol; i++){
226034 }else if( iCol<p->pConfig->nCol ){
228893 int nByte = pFts5->pConfig->nCol * sizeof(i64)*2 + sizeof(Fts5VocabCursor);
228901 pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
228991 int nCol = pCsr->pFts5->pConfig->nCol;
229000 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
229005 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
229024 memset(pCsr->aCnt, 0, nCol * sizeof(i64));
229025 memset(pCsr->aDoc, 0, nCol * sizeof(i64));
229054 if( ii>=nCol ){
229065 assert_nc( iPos>=0 && iPos<nCol );
229066 if( iPos>=nCol ){
229102 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
229103 if( pCsr->iCol==nCol ){
229235 if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){