Lines Matching refs:iCol
5585 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
5586 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
5587 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
5588 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
5589 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
5590 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
5591 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
5592 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
5593 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
5594 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
13426 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
13441 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
13442 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
23262 int iCol; /* Column for which the cache is valid */ member
84730 int iCol, /* Column to extract */
84742 assert( iCol>0 );
84746 for(i=0; i<=iCol; i++){
93822 int iCol, /* The column to read */
93855 || pCache->iCol!=iCol
93868 pCache->iCol = iCol;
102311 u16 iCol; /* Table column this handle is open on */
102363 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
102364 testcase( pC->nHdrParsed==p->iCol );
102365 testcase( pC->nHdrParsed==p->iCol+1 );
102374 p->iOffset = pC->aType[p->iCol + pC->nField];
102414 int iCol; /* Index of zColumn in row-record */
102473 for(iCol=0; iCol<pTab->nCol; iCol++) {
102474 if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
102478 if( iCol==pTab->nCol ){
102503 if( pFKey->aCol[j].iFrom==iCol ){
102514 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
102609 pBlob->iCol = iCol;
102712 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
106795 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
106803 assert( iCol>=0 && iCol<pEList->nExpr );
106804 pOrig = pEList->a[iCol].pExpr;
107281 int iCol;
107285 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
107289 if( iCol==pTab->iPKey ){
107290 iCol = -1;
107295 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
107297 iCol = -1;
107299 if( iCol<pTab->nCol ){
107304 testcase( iCol==(-1) );
107307 pExpr->iColumn = iCol;
107312 sqlite3TableColumnToStorage(pTab, iCol);
107323 pExpr->iColumn = iCol;
107325 sqlite3TableColumnToStorage(pTab, iCol) + 1;
107327 pExpr->iColumn = (i16)iCol;
107330 if( iCol<0 ){
107333 testcase( iCol==31 );
107334 testcase( iCol==32 );
107335 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107337 testcase( iCol==31 );
107338 testcase( iCol==32 );
107339 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107592 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
107600 if( p->y.pTab->iPKey==iCol ){
107603 p->iColumn = (ynVar)iCol;
107605 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
107611 testcase( iCol==BMS );
107612 testcase( iCol==BMS-1 );
107613 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
108326 int iCol = -1;
108331 if( sqlite3ExprIsInteger(pE, &iCol) ){
108332 if( iCol<=0 || iCol>pEList->nExpr ){
108337 iCol = resolveAsName(pParse, pEList, pE);
108338 if( iCol==0 ){
108353 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
108354 if( IN_RENAME_OBJECT && iCol>0 ){
108361 if( iCol>0 ){
108368 pNew->u.iValue = iCol;
108379 pItem->u.x.iOrderByCol = (u16)iCol;
108493 int iCol; /* Column number */
108506 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
108507 if( iCol>0 ){
108512 pItem->u.x.iOrderByCol = (u16)iCol;
108516 if( sqlite3ExprIsInteger(pE2, &iCol) ){
108520 if( iCol<1 || iCol>0xffff ){
108524 pItem->u.x.iOrderByCol = (u16)iCol;
109035 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
109036 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
109037 return pTab->aCol[iCol].affinity;
111944 int iCol;
111945 for(iCol=0; iCol<pTab->nCol; iCol++){
111946 if( sqlite3_stricmp(azOpt[ii], pTab->aCol[iCol].zCnName)==0 ) break;
111948 if( iCol==pTab->nCol ){
112198 int iCol = pEList->a[i].pExpr->iColumn;
112199 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
113171 int iCol, /* Index of the column to extract */
113177 assert( iCol!=XN_EXPR );
113178 if( iCol<0 || iCol==pTab->iPKey ){
113186 x = iCol;
113188 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
113204 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
113205 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
113208 x = sqlite3TableColumnToStorage(pTab,iCol);
113209 testcase( x!=iCol );
113213 sqlite3ColumnDefault(v, pTab, iCol, regOut);
113645 int iCol = pExpr->iColumn;
113649 assert( iCol>=XN_ROWID );
113650 assert( iCol<pTab->nCol );
113651 if( iCol<0 ){
113654 pCol = pTab->aCol + iCol;
113655 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
113656 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
114141 int iCol;
114146 iCol = pExpr->iColumn;
114148 + sqlite3TableColumnToStorage(pTab, iCol);
114151 assert( iCol>=-1 && iCol<pTab->nCol );
114152 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
114158 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
114167 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
116746 int iCol; /* Index of column being renamed */
116777 for(iCol=0; iCol<pTab->nCol; iCol++){
116778 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
116780 if( iCol==pTab->nCol ){
116804 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
116812 zDb, pTab->zName, iCol, zNew, bQuote
116857 int iCol; /* Index of column being renamed */
117159 && pExpr->iColumn==p->iCol
117164 && pExpr->iColumn==p->iCol
117642 int iCol = sqlite3_value_int(argv[5]);
117661 if( iCol<0 ) return;
117664 if( pTab==0 || iCol>=pTab->nCol ){
117668 zOld = pTab->aCol[iCol].zCnName;
117670 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
117703 if( iCol<sParse.pNewTable->nCol ){
117705 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
117708 if( sCtx.iCol<0 ){
117730 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
118239 int iCol = sqlite3_value_int(argv[2]);
118257 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
118263 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
118264 if( iCol<pTab->nCol-1 ){
118266 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
118302 int iCol; /* Index of column zCol in pTab->aCol[] */
118322 iCol = sqlite3ColumnIndex(pTab, zCol);
118323 if( iCol<0 ){
118330 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
118332 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
118360 , zDb, iDb, iCol, pTab->zName
118368 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
118394 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
118398 int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
118733 int iCol; /* If !isPSample, the reason for inclusion */
118805 pTo->iCol = pFrom->iCol;
118931 p->aBest[i].iCol = i;
118973 assert( pNew->iCol==pOld->iCol );
118974 for(i=pNew->iCol+1; i<nCol; i++){
118995 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
118996 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
118999 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
119003 if( pNew->iCol<pOld->iCol ) return 1;
119004 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
119028 assert( pNew->anEq[pNew->iCol]>0 );
119037 if( pOld->anEq[pNew->iCol]==0 ){
119039 assert( pOld->iCol>pNew->iCol );
119047 pUpgrade->iCol = pNew->iCol;
119048 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
119216 p->current.iCol = 0;
119223 p->current.iCol = i;
120152 int iCol;
120162 for(iCol=0; iCol<nCol; iCol++){
120171 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
120172 nRow = pFinal->anLt[iCol];
120173 nDist100 = (i64)100 * pFinal->anDLt[iCol];
120177 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
120187 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
120189 sumEq += aSample[i].anEq[iCol];
120198 pIdx->aAvgEq[iCol] = avgEq;
121246 int iCol; /* Index of column in table */
121269 iCol = pExpr->iColumn;
121272 if( iCol>=0 ){
121273 assert( iCol<pTab->nCol );
121274 zCol = pTab->aCol[iCol].zCnName;
122460 SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
122463 if( iCol==pIdx->aiColumn[i] ) return i;
122480 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
122483 for(i=0; i<=iCol; i++){
122484 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
122487 return iCol;
122528 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
122531 assert( iCol<pTab->nCol );
122532 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
122533 for(i=0, n=0; i<iCol; i++){
123205 int iCol = -1, i;
123215 iCol = pTab->nCol - 1;
123216 pCol = &pTab->aCol[iCol];
123229 for(iCol=0; iCol<pTab->nCol; iCol++){
123230 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
123231 pCol = &pTab->aCol[iCol];
123248 pTab->iPKey = iCol;
123631 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
123634 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
123639 j = pPk->aiColumn[iCol];
123644 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
124986 int iCol = p->nCol-1;
124987 if( NEVER(iCol<0) ) goto fk_end;
124991 p->aCol[iCol].zCnName, pTo);
128398 int iCol; /* Iterator used while populating OLD.* */
128413 for(iCol=0; iCol<pTab->nCol; iCol++){
128414 testcase( mask!=0xffffffff && iCol==31 );
128415 testcase( mask!=0xffffffff && iCol==32 );
128416 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
128417 int kk = sqlite3TableColumnToStorage(pTab, iCol);
128418 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
131661 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
131665 if( iCol<0 ) break; /* No foreign keys against expression indexes */
131670 zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);
131674 zIdxCol = pParent->aCol[iCol].zCnName;
131883 i16 iCol /* Which column of pTab is desired */
131892 if( iCol>=0 && iCol!=pTab->iPKey ){
131893 pCol = &pTab->aCol[iCol];
131894 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
131915 i16 iCol /* The column that is wanted */
131922 pExpr->iColumn = iCol;
131995 i16 iCol; /* Index of column in child table */
131998 iCol = pIdx ? pIdx->aiColumn[i] : -1;
131999 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
132000 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
132001 assert( iCol>=0 );
132002 zCol = pFKey->pFrom->aCol[iCol].zCnName;
132034 i16 iCol = pIdx->aiColumn[i];
132035 assert( iCol>=0 );
132036 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
132037 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
132327 int iCol;
132375 iCol = pFKey->aCol[0].iFrom;
132376 aiCol = &iCol;
136487 const void * (*column_blob)(sqlite3_stmt*,int iCol);
136488 int (*column_bytes)(sqlite3_stmt*,int iCol);
136489 int (*column_bytes16)(sqlite3_stmt*,int iCol);
136495 double (*column_double)(sqlite3_stmt*,int iCol);
136496 int (*column_int)(sqlite3_stmt*,int iCol);
136497 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
136504 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
136505 const void * (*column_text16)(sqlite3_stmt*,int iCol);
136506 int (*column_type)(sqlite3_stmt*,int iCol);
136507 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
140326 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
140327 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
140833 int iCol = pIdx->aiColumn[kk];
140834 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
140835 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
143224 SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol){
143232 assert( iCol>=0 && iCol<pResults->nExpr );
143233 pResults->a[iCol].fg.bUsed = 1;
143257 int iCol; /* Index of column matching zCol */
143264 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
143265 if( iCol>=0
143266 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
143269 sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol);
143271 *piCol = iCol;
144556 int iCol;
144637 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
144641 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
144645 int iKey = iCol+1;
144685 iRead = iCol--;
144813 int iCol = pExpr->iColumn; /* Index of column in pTab */
144852 if( iCol<pS->pEList->nExpr
144853 && (!ViewCanHaveRowid || iCol>=0)
144860 Expr *p = pS->pEList->a[iCol].pExpr;
144870 if( iCol<0 ) iCol = pTab->iPKey;
144871 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144872 if( iCol<0 ){
144876 zOrigCol = pTab->aCol[iCol].zCnName;
144877 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
144885 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
144886 if( iCol<0 ){
144889 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
145036 int iCol = p->iColumn;
145039 if( iCol<0 ) iCol = pTab->iPKey;
145040 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
145041 if( iCol<0 ){
145044 zCol = pTab->aCol[iCol].zCnName;
145132 int iCol = pColExpr->iColumn;
145134 if( iCol<0 ) iCol = pTab->iPKey;
145135 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
145422 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
145425 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
145429 assert( iCol>=0 );
145433 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
145434 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
148252 u16 iCol = pList->a[j].u.x.iOrderByCol;
148253 if( iCol>0 ){
148254 iCol--;
148255 colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
153372 int iCol, /* Which column of the index to check */
153376 i16 iIdxCol = pIdx->aiColumn[iCol];
153383 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
153384 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
153416 static Expr *exprRowColumn(Parse *pParse, int iCol){
153418 if( pRet ) pRet->iColumn = iCol+1;
156034 int iCol;
156044 for(iCol=0; iCol<pTab->nCol; iCol++){
156045 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
156067 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
158106 int iCol = aiMap ? aiMap[iMap++] : 0;
158107 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
159766 int iCol = pPk->aiColumn[iPk];
159767 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
160066 int iCol = pPk->aiColumn[iPk];
160067 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
160222 int iCol = pPk->aiColumn[iPk];
160223 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
160445 int iCol = pRight->iColumn;
160446 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
160450 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
162700 int iCol /* Column of index to match */
162703 const char *zColl = pIdx->azColl[iCol];
162709 && p->iColumn==pIdx->aiColumn[iCol]
162725 static int indexColumnNotNull(Index *pIdx, int iCol){
162728 assert( iCol>=0 && iCol<pIdx->nColumn );
162729 j = pIdx->aiColumn[iCol];
163024 int iCol = pIdx->aiColumn[ii];
163026 zName = pTab->aCol[iCol].zCnName;
163112 int iCol;
163115 iCol = pTerm->u.x.leftColumn;
163116 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
163117 testcase( iCol==BMS );
163118 testcase( iCol==BMS-1 );
163122 pTable->aCol[iCol].zCnName);
163172 int iCol;
163175 iCol = pTerm->u.x.leftColumn;
163176 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
163177 testcase( iCol==BMS-1 );
163178 testcase( iCol==BMS );
163711 int iCol; /* Index of required stats in anEq[] etc. */
163778 iCol = 0;
163808 iCol = n-1;
163821 assert( iCol==nField-1 );
163831 pRec->nField = iCol+1;
163840 if( iCol>0 ){
163841 pRec->nField = iCol;
163856 assert( iCol==nField-1 );
163857 aStat[0] = aSample[i].anLt[iCol];
163858 aStat[1] = aSample[i].anEq[iCol];
163867 iUpper = aSample[i].anLt[iCol];
163918 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
163919 assert( iCol>=0 && iCol<pIdx->nColumn );
163923 assert( pIdx->zColAff[iCol]!=0 );
163924 return pIdx->zColAff[iCol];
165283 int iCol = pProbe->aiColumn[saved_nEq];
165286 if( iCol==XN_ROWID
165287 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
165289 if( iCol==XN_ROWID || pProbe->uniqNotNull
170138 int iCol = -1;
170144 iCol = i;
170149 if( iCol<0 ){
170163 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
183697 int iCol = 0;
183730 for(iCol=0; iCol<pTab->nCol; iCol++){
183731 pCol = &pTab->aCol[iCol];
183736 if( iCol==pTab->nCol ){
183738 iCol = pTab->iPKey;
183739 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
183762 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
185701 int fts3_global_term_cnt(int iTerm, int iCol);
185702 int fts3_term_cnt(int iTerm, int iCol);
186330 int iCol;
186419 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
187337 int iCol; /* Column index */
187610 for(iCol=0; iCol<nCol; iCol++){
187613 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
187619 p->azColumn[iCol] = zCsr;
187625 for(iCol=0; iCol<nCol; iCol++){
187626 int n = (int)strlen(p->azColumn[iCol]);
187630 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
187632 p->abNotindexed[iCol] = 1;
188358 static int fts3PutColNumber(char **pp, int iCol){
188360 if( iCol ){
188362 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
188934 sqlite3_int64 iCol;
188936 p += sqlite3Fts3GetVarint(p, &iCol);
188943 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
189333 filter.iCol = iColumn;
189502 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
189514 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
189605 int iCol /* Index of column to read value from */
189612 assert( iCol>=0 && iCol<=p->nColumn+2 );
189614 switch( iCol-p->nColumn ){
189633 iCol = p->nColumn;
189641 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
189642 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
189866 int iCol = -1;
189884 case 5: iCol = sqlite3_value_int(apVal[4]);
189897 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
190657 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
190662 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
191078 int iCol; /* The column the token must match */
191106 pTC->iCol = pPhrase->iColumn;
191286 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
191302 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
191947 int iCol = 0;
191961 pExpr->aMI[iCol*3 + 1] += iCnt;
191962 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
191965 p += fts3GetVarint32(p, &iCol);
191966 }while( iCol<nCol );
192115 int iCol;
192119 for(iCol=0; iCol<pTab->nColumn; iCol++){
192120 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
192121 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
192127 for(iCol=0; iCol<pTab->nColumn; iCol++){
192128 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
192129 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
192159 int iCol, /* Column to return position list for */
192171 assert( iCol>=0 && iCol<pTab->nColumn );
192172 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
192278 while( iThis<iCol ){
192288 *ppOut = ((iCol==iThis)?pIter:0);
192380 int iCol; /* Current value of 'col' column */
192517 int iCol = pInfo->aConstraint[i].iColumn;
192519 if( iCol==0 ){
192526 if( iCol==4 ){
192617 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
192618 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
192626 int iCol;
192641 iCol = 0;
192653 iCol = 0;
192665 assert( iCol==0 );
192678 pCsr->aStat[iCol+1].nOcc++;
192685 iCol = (int)v;
192686 if( iCol<1 ){
192690 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
192691 pCsr->aStat[iCol+1].nDoc++;
192697 pCsr->iCol = 0;
192814 int iCol /* Index of column to read value from */
192819 switch( iCol ){
192825 if( p->iCol ){
192826 sqlite3_result_int(pCtx, p->iCol-1);
192833 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
192837 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
192841 assert( iCol==4 );
193080 int iCol, /* Value for Fts3Phrase.iColumn */
193115 pRet->pPhrase->iColumn = iCol;
193313 int iCol;
193425 iCol = pParse->iDefaultCol;
193433 iCol = ii;
193438 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
196390 int iCol /* Index of column to read value from */
196395 switch( iCol ){
196409 assert( iCol==4 );
196586 int iCol; /* Column token must occur in */
197162 sqlite3_int64 iCol, /* Column for entry to add */
197185 if( iCol>0 && p->iLastCol!=iCol ){
197187 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
197191 p->iLastCol = iCol;
197194 if( iCol>=0 ){
197223 int iCol,
197236 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
197263 int iCol, /* Column into which text is being inserted */
197313 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
197322 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
197399 int iCol = i-2;
197400 if( p->abNotindexed[iCol]==0 ){
197402 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
197555 int iCol = i-1;
197556 if( p->abNotindexed[iCol]==0 ){
197558 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
199092 int iCol, /* Column to filter on */
199103 assert( iCol>=0 );
199108 if( iCol==iCurrent ){
199268 int iCol, /* Column to match on. */
199302 assert( iCol<0 || iCol<p->nColumn );
199303 pCsr->iColFilter = iCol;
199470 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
199559 int iCol,
199563 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
200065 int iCol;
200069 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
200070 if( p->abNotindexed[iCol]==0 ){
200071 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
200072 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
200073 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
200084 for(iCol=0; iCol<=p->nColumn; iCol++){
200085 aSzIns[iCol] += aSz[iCol];
201666 int iCol, /* Column number */
201674 ret += (ret<<3) + iCol;
201721 i64 iCol = 0;
201730 iCol = 0;
201733 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
201746 (int)iCol, (int)iPos
201808 int iCol;
201810 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
201811 if( p->abNotindexed[iCol]==0 ){
201812 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
201826 zToken, nToken, iLang, 0, iDocid, iCol, iPos
201831 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
202013 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
202070 int iCol /* Column that token must appear in (or -1) */
202080 pDeferred->iCol = iCol;
202372 int iCol; /* Extract snippet from this column */
202389 int iCol; /* Column snippet is extracted from */
202786 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
202827 int iCol, /* Index of column to create snippet from */
202863 sIter.iCol = iCol;
202882 pFragment->iCol = iCol;
203048 int iCol = pFragment->iCol+1; /* Query column to extract text from */
203052 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
203054 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
203059 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
203182 int iCol = 0;
203193 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
203195 p->aMatchinfo[iStart + iCol] = (u32)nHit;
203197 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
203203 pIter += fts3GetVarint32(pIter, &iCol);
203204 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
203455 int iCol;
203472 for(iCol=0; iCol<pInfo->nCol; iCol++){
203478 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
203515 pInfo->aMatchinfo[iCol] = nLcs;
203578 int iCol;
203579 for(iCol=0; iCol<pInfo->nCol; iCol++){
203588 pInfo->aMatchinfo[iCol] = iVal;
203598 int iCol;
203601 for(iCol=0; iCol<pInfo->nCol; iCol++){
203608 pInfo->aMatchinfo[iCol] = (u32)nToken;
203753 int iCol, /* Extract snippet from this column */
203808 if( iCol>=0 && iRead!=iCol ) continue;
203861 int iCol; /* Column of table to populate aTerm for */
203879 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
203907 int iCol; /* Column currently being processed */
203935 for(iCol=0; iCol<pTab->nColumn; iCol++){
203948 sCtx.iCol = iCol;
203961 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
203962 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
203964 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
204007 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
210019 int iCol;
210022 iCol = pConstraint->iColumn - JEACH_JSON;
210023 assert( iCol==0 || iCol==1 );
210024 testcase( iCol==0 );
210025 iMask = 1 << iCol;
210029 aIdx[iCol] = i;
213357 static int rtreeConstraintError(Rtree *pRtree, int iCol){
213362 assert( iCol==0 || iCol%2 );
213372 if( iCol==0 ){
213378 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
213379 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
219699 int iCol = 0;
219731 zOrder, zSep, iCol, zCol, zCollate
219734 zSelect, zSep, iCol, zCol
219737 iCol++;
219752 for(iCol=0; iCol<pIter->nCol; iCol++){
219753 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
220239 int iCol;
220242 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
220244 const char *zCol = pIter->azTblCol[iCol];
220251 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
220257 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
220258 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
221421 int iCol = p->objiter.nCol; /* Index of rbu_control column */
221424 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
221426 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
221438 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
221463 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
221464 const char *zCol = sqlite3_column_name(pStmt, iCol);
225568 int iCol; /* Used to iterate through table columns */
225570 for(iCol=0; iCol<pTab->nCol; iCol++){
225571 if( pTab->abPK[iCol] ){
225611 int iCol; /* Used to iterate from 0 to nCol */
225613 for(iCol=0; iCol<nCol; iCol++){
225766 int iCol; /* Used to iterate through columns */
225775 for(iCol=0; iCol<pTab->nCol; iCol++){
225776 if( !pTab->abPK[iCol] ){
225790 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
225793 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
226421 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
226424 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
226425 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
226431 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
226434 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
226435 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
227431 int iCol, /* Column to read value from */
227435 int eType = sqlite3_column_type(pStmt, iCol);
227441 i = sqlite3_column_int64(pStmt, iCol);
227443 double r = sqlite3_column_double(pStmt, iCol);
227453 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
227455 z = (u8 *)sqlite3_column_text(pStmt, iCol);
227457 nByte = sqlite3_column_bytes(pStmt, iCol);
227914 int iCol;
227917 for(iCol=0; iCol<pTab->nCol; iCol++){
227918 sessionAppendCol(&buf, pSel, iCol, &rc);
228961 int iCol;
228986 for(iCol=0; iCol<nCol; iCol++){
228987 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
228994 for(iCol=0; iCol<nCol; iCol++){
228995 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
228999 for(iCol=0; iCol<nCol*2; iCol++){
229000 sqlite3ValueFree(apVal[iCol]);
231735 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
231750 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
231751 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
232459 int iCol,
232532 int iCol, /* Column token appears in (-ve -> delete) */
232600 Fts5IndexIter*, const char*, int, i64 iRowid, int iCol, int iOff
232676 int iCol, /* Column token appears in (-ve -> delete) */
232747 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
232787 int iCol, /* Column on LHS of MATCH operator */
232795 int iCol,
234504 int iCol; /* Column to search */
234526 if( ic==pIter->iCol ){
234551 int iCol,
234559 pIter->iCol = iCol;
234704 int iCol;
234712 iCol = sqlite3_value_int(apVal[0]);
234717 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
234723 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
234821 int iCol, /* Column to score */
234841 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
234882 int iCol; /* 1st argument to snippet() */
234904 iCol = sqlite3_value_int(apVal[0]);
234911 iBestCol = (iCol>=0 ? iCol : 0);
234923 if( iCol<0 || iCol==i ){
236929 int iCol,
236959 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
236964 pColset->aiCol[0] = iCol;
237027 Fts5Config *pConfig, int bGlob, int iCol, const char *zText, Fts5Expr **pp
237080 iCol = pConfig->nCol;
237084 rc = sqlite3Fts5ExprNew(pConfig, bAnd, iCol, zExpr, pp,pConfig->pzErrmsg);
238704 int iCol /* New column to add to colset object */
238710 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
238719 if( aiCol[i]==iCol ) return pNew;
238720 if( aiCol[i]>iCol ) break;
238725 aiCol[i] = iCol;
238771 int iCol;
238778 for(iCol=0; iCol<pConfig->nCol; iCol++){
238779 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
238781 if( iCol==pConfig->nCol ){
238784 pRet = fts5ParseColset(pParse, pColset, iCol);
239665 static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
239668 if( pColset->aiCol[i]==iCol ) return 1;
239716 int iCol = p->iOff>>32;
239719 pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
239734 int iCol,
239741 sCtx.iOff = (((i64)iCol) << 32) - 1;
239746 if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
239889 int iCol,
239910 pTerm->pIter, iRowid, iCol, iOff+iToken, ppOut, pnOut
240007 i16 iCol; /* Column of last value written */
240181 int iCol, /* Column token appears in (-ve -> delete) */
240243 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
240286 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
240291 if( iCol>=0 ){
240296 assert_nc( iCol>=p->iCol );
240297 if( iCol!=p->iCol ){
240300 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
240301 p->iCol = (i16)iCol;
240305 p->iCol = (i16)(iPos = iCol);
243966 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
243969 if( pColset->aiCol[i]==iCol ) return 1;
244012 int iCol;
244013 fts5FastGetVarint32(pChunk, i, iCol);
244014 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
244031 int iCol;
244037 fts5FastGetVarint32(pChunk, i, iCol);
244038 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
247057 int iCol, /* Column token appears in (-ve -> delete) */
247066 assert( (iCol<0)==p->bDelete );
247070 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
247078 p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
247706 int iCol,
247713 i64 iPos = (((i64)iCol)<<32) + iOff;
247770 i64 iRowid, int iCol, int iOff
247785 fts5TokendataIterAppendMap(p, pT, ii, iRowid, (((i64)iCol)<<32) + iOff);
247818 int iCol;
247820 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
247821 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
248234 int iCol,
248242 ret += (ret<<3) + iCol;
248320 int iCol = FTS5_POS2COLUMN(sReader.iPos);
248322 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
248750 int iCol = FTS5_POS2COLUMN(iPos);
248752 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
250188 int iCol = p->iColumn;
250190 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
250193 if( p->usable==0 || iCol<0 ){
250201 if( iCol==nCol+1 ){
250205 }else if( iCol>=0 ){
250208 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
250216 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
250219 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
250223 }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
250838 int iCol; /* Column on LHS of MATCH operator */
250876 iCol = 0;
250878 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
250890 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
250904 iCol = 0;
250906 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
250910 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
251467 int iCol,
251472 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
251506 int iCol,
251513 if( iCol<0 || iCol>=pTab->pConfig->nCol ){
251523 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
251524 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
251717 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
251752 if( iCol<0 ){
251758 }else if( iCol<pConfig->nCol ){
251759 *pnToken = pCsr->aColumnSize[iCol];
251973 int iCol = pCsr->aInst[iIdx*3 + 1];
251977 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
252191 int iCol /* Index of column to read value from */
252201 if( iCol==pConfig->nCol ){
252206 if( iCol==pConfig->nCol ){
252212 }else if( iCol==pConfig->nCol+1 ){
252229 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
253089 int iCol;
253111 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
253128 int iCol;
253141 ctx.iCol = -1;
253142 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
253143 if( pConfig->abUnindexed[iCol-1]==0 ){
253149 zText = (const char*)sqlite3_column_text(pSeek, iCol);
253150 nText = sqlite3_column_bytes(pSeek, iCol);
253152 zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
253153 nText = sqlite3_value_bytes(apVal[iCol-1]);
253161 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
253162 if( p->aTotalSize[iCol-1]<0 ){
253396 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
253398 if( pConfig->abUnindexed[ctx.iCol]==0 ){
253399 const char *zText = (const char*)sqlite3_column_text(pScan, ctx.iCol+1);
253400 int nText = sqlite3_column_bytes(pScan, ctx.iCol+1);
253409 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
253522 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
253524 if( pConfig->abUnindexed[ctx.iCol]==0 ){
253525 const char *zText = (const char*)sqlite3_value_text(apVal[ctx.iCol+2]);
253526 int nText = sqlite3_value_bytes(apVal[ctx.iCol+2]);
253535 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
253579 int iCol;
253604 int iCol;
253616 iCol = pCtx->iCol;
253620 iPos = pCtx->iCol;
253621 iCol = 0;
253627 iCol = 0;
253634 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
253645 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
253697 ctx.iCol = i;
253859 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
253863 if( iCol<0 ){
253868 }else if( iCol<p->pConfig->nCol ){
253869 *pnToken = p->aTotalSize[iCol];
256597 int iCol;
257016 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
257017 if( pCsr->aDoc[pCsr->iCol] ) break;
257021 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
257042 pCsr->iCol = 0;
257066 int iCol = -1;
257069 if( iCol!=ii ){
257075 iCol = ii;
257118 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
257119 if( pCsr->iCol==nCol ){
257211 int iCol /* Index of column to read value from */
257218 if( iCol==0 ){
257223 assert( iCol==1 || iCol==2 || iCol==3 );
257224 if( iCol==1 ){
257226 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
257229 }else if( iCol==2 ){
257230 iVal = pCsr->aDoc[pCsr->iCol];
257232 iVal = pCsr->aCnt[pCsr->iCol];
257235 assert( iCol==1 || iCol==2 );
257236 if( iCol==1 ){
257243 switch( iCol ){
257261 assert( iCol==3 );