Lines Matching refs:iCol
5566 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
5567 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
5568 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
5569 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
5570 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
5571 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
5572 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
5573 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
5574 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
5575 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
13356 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
13371 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
13372 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
23174 int iCol; /* Column for which the cache is valid */ member
84263 int iCol, /* Column to extract */
84275 assert( iCol>0 );
84279 for(i=0; i<=iCol; i++){
93317 int iCol, /* The column to read */
93350 || pCache->iCol!=iCol
93363 pCache->iCol = iCol;
101771 u16 iCol; /* Table column this handle is open on */
101823 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
101824 testcase( pC->nHdrParsed==p->iCol );
101825 testcase( pC->nHdrParsed==p->iCol+1 );
101834 p->iOffset = pC->aType[p->iCol + pC->nField];
101874 int iCol; /* Index of zColumn in row-record */
101933 for(iCol=0; iCol<pTab->nCol; iCol++) {
101934 if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
101938 if( iCol==pTab->nCol ){
101963 if( pFKey->aCol[j].iFrom==iCol ){
101974 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
102069 pBlob->iCol = iCol;
102172 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
106255 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
106263 assert( iCol>=0 && iCol<pEList->nExpr );
106264 pOrig = pEList->a[iCol].pExpr;
106708 int iCol;
106712 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
106716 if( iCol==pTab->iPKey ){
106717 iCol = -1;
106722 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
106724 iCol = -1;
106726 if( iCol<pTab->nCol ){
106731 testcase( iCol==(-1) );
106734 pExpr->iColumn = iCol;
106739 sqlite3TableColumnToStorage(pTab, iCol);
106750 pExpr->iColumn = iCol;
106752 sqlite3TableColumnToStorage(pTab, iCol) + 1;
106754 pExpr->iColumn = (i16)iCol;
106757 if( iCol<0 ){
106760 testcase( iCol==31 );
106761 testcase( iCol==32 );
106762 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
106764 testcase( iCol==31 );
106765 testcase( iCol==32 );
106766 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107006 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
107014 if( p->y.pTab->iPKey==iCol ){
107017 p->iColumn = (ynVar)iCol;
107019 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
107025 testcase( iCol==BMS );
107026 testcase( iCol==BMS-1 );
107027 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
107712 int iCol = -1;
107717 if( sqlite3ExprIsInteger(pE, &iCol) ){
107718 if( iCol<=0 || iCol>pEList->nExpr ){
107723 iCol = resolveAsName(pParse, pEList, pE);
107724 if( iCol==0 ){
107739 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
107740 if( IN_RENAME_OBJECT && iCol>0 ){
107747 if( iCol>0 ){
107754 pNew->u.iValue = iCol;
107765 pItem->u.x.iOrderByCol = (u16)iCol;
107879 int iCol; /* Column number */
107892 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
107893 if( iCol>0 ){
107898 pItem->u.x.iOrderByCol = (u16)iCol;
107902 if( sqlite3ExprIsInteger(pE2, &iCol) ){
107906 if( iCol<1 || iCol>0xffff ){
107910 pItem->u.x.iOrderByCol = (u16)iCol;
108415 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
108416 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
108417 return pTab->aCol[iCol].affinity;
111207 int iCol;
111208 for(iCol=0; iCol<pTab->nCol; iCol++){
111209 if( sqlite3_stricmp(azOpt[ii], pTab->aCol[iCol].zCnName)==0 ) break;
111211 if( iCol==pTab->nCol ){
111461 int iCol = pEList->a[i].pExpr->iColumn;
111462 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
112434 int iCol, /* Index of the column to extract */
112440 assert( iCol!=XN_EXPR );
112441 if( iCol<0 || iCol==pTab->iPKey ){
112449 x = iCol;
112451 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
112467 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
112468 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
112471 x = sqlite3TableColumnToStorage(pTab,iCol);
112472 testcase( x!=iCol );
112476 sqlite3ColumnDefault(v, pTab, iCol, regOut);
112908 int iCol = pExpr->iColumn;
112912 assert( iCol>=XN_ROWID );
112913 assert( iCol<pTab->nCol );
112914 if( iCol<0 ){
112917 pCol = pTab->aCol + iCol;
112918 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
112919 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
113407 int iCol;
113412 iCol = pExpr->iColumn;
113414 + sqlite3TableColumnToStorage(pTab, iCol);
113417 assert( iCol>=-1 && iCol<pTab->nCol );
113418 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
113424 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
113433 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
116014 int iCol; /* Index of column being renamed */
116045 for(iCol=0; iCol<pTab->nCol; iCol++){
116046 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
116048 if( iCol==pTab->nCol ){
116072 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
116080 zDb, pTab->zName, iCol, zNew, bQuote
116125 int iCol; /* Index of column being renamed */
116427 && pExpr->iColumn==p->iCol
116432 && pExpr->iColumn==p->iCol
116910 int iCol = sqlite3_value_int(argv[5]);
116929 if( iCol<0 ) return;
116932 if( pTab==0 || iCol>=pTab->nCol ){
116936 zOld = pTab->aCol[iCol].zCnName;
116938 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
116971 if( iCol<sParse.pNewTable->nCol ){
116973 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
116976 if( sCtx.iCol<0 ){
116998 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
117507 int iCol = sqlite3_value_int(argv[2]);
117525 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
117531 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
117532 if( iCol<pTab->nCol-1 ){
117534 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
117570 int iCol; /* Index of column zCol in pTab->aCol[] */
117590 iCol = sqlite3ColumnIndex(pTab, zCol);
117591 if( iCol<0 ){
117598 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
117600 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
117628 , zDb, iDb, iCol, pTab->zName
117636 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
117662 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
117666 int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
117996 int iCol; /* If !isPSample, the reason for inclusion */
118068 pTo->iCol = pFrom->iCol;
118194 p->aBest[i].iCol = i;
118236 assert( pNew->iCol==pOld->iCol );
118237 for(i=pNew->iCol+1; i<nCol; i++){
118258 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
118259 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
118262 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
118266 if( pNew->iCol<pOld->iCol ) return 1;
118267 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
118291 assert( pNew->anEq[pNew->iCol]>0 );
118300 if( pOld->anEq[pNew->iCol]==0 ){
118302 assert( pOld->iCol>pNew->iCol );
118310 pUpgrade->iCol = pNew->iCol;
118311 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
118479 p->current.iCol = 0;
118486 p->current.iCol = i;
119402 int iCol;
119412 for(iCol=0; iCol<nCol; iCol++){
119421 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
119422 nRow = pFinal->anLt[iCol];
119423 nDist100 = (i64)100 * pFinal->anDLt[iCol];
119427 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
119437 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
119439 sumEq += aSample[i].anEq[iCol];
119448 pIdx->aAvgEq[iCol] = avgEq;
120496 int iCol; /* Index of column in table */
120519 iCol = pExpr->iColumn;
120522 if( iCol>=0 ){
120523 assert( iCol<pTab->nCol );
120524 zCol = pTab->aCol[iCol].zCnName;
121710 SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
121713 if( iCol==pIdx->aiColumn[i] ) return i;
121730 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
121733 for(i=0; i<=iCol; i++){
121734 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
121737 return iCol;
121778 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
121781 assert( iCol<pTab->nCol );
121782 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
121783 for(i=0, n=0; i<iCol; i++){
122455 int iCol = -1, i;
122465 iCol = pTab->nCol - 1;
122466 pCol = &pTab->aCol[iCol];
122479 for(iCol=0; iCol<pTab->nCol; iCol++){
122480 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
122481 pCol = &pTab->aCol[iCol];
122498 pTab->iPKey = iCol;
122881 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
122884 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
122889 j = pPk->aiColumn[iCol];
122894 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
124235 int iCol = p->nCol-1;
124236 if( NEVER(iCol<0) ) goto fk_end;
124240 p->aCol[iCol].zCnName, pTo);
127647 int iCol; /* Iterator used while populating OLD.* */
127662 for(iCol=0; iCol<pTab->nCol; iCol++){
127663 testcase( mask!=0xffffffff && iCol==31 );
127664 testcase( mask!=0xffffffff && iCol==32 );
127665 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
127666 int kk = sqlite3TableColumnToStorage(pTab, iCol);
127667 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
130908 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
130912 if( iCol<0 ) break; /* No foreign keys against expression indexes */
130917 zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);
130921 zIdxCol = pParent->aCol[iCol].zCnName;
131130 i16 iCol /* Which column of pTab is desired */
131139 if( iCol>=0 && iCol!=pTab->iPKey ){
131140 pCol = &pTab->aCol[iCol];
131141 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
131162 i16 iCol /* The column that is wanted */
131169 pExpr->iColumn = iCol;
131242 i16 iCol; /* Index of column in child table */
131245 iCol = pIdx ? pIdx->aiColumn[i] : -1;
131246 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
131247 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
131248 assert( iCol>=0 );
131249 zCol = pFKey->pFrom->aCol[iCol].zCnName;
131281 i16 iCol = pIdx->aiColumn[i];
131282 assert( iCol>=0 );
131283 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
131284 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
131574 int iCol;
131622 iCol = pFKey->aCol[0].iFrom;
131623 aiCol = &iCol;
135526 const void * (*column_blob)(sqlite3_stmt*,int iCol);
135527 int (*column_bytes)(sqlite3_stmt*,int iCol);
135528 int (*column_bytes16)(sqlite3_stmt*,int iCol);
135534 double (*column_double)(sqlite3_stmt*,int iCol);
135535 int (*column_int)(sqlite3_stmt*,int iCol);
135536 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
135543 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
135544 const void * (*column_text16)(sqlite3_stmt*,int iCol);
135545 int (*column_type)(sqlite3_stmt*,int iCol);
135546 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
139337 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
139338 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
139839 int iCol = pIdx->aiColumn[kk];
139840 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
139841 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
142117 SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol){
142125 assert( iCol>=0 && iCol<pResults->nExpr );
142126 pResults->a[iCol].fg.bUsed = 1;
142150 int iCol; /* Index of column matching zCol */
142157 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
142158 if( iCol>=0
142159 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
142162 sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol);
142164 *piCol = iCol;
143449 int iCol;
143524 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
143528 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
143532 int iKey = iCol+1;
143572 iRead = iCol--;
143700 int iCol = pExpr->iColumn; /* Index of column in pTab */
143739 if( iCol<pS->pEList->nExpr
143741 && iCol>=0
143743 && ALWAYS(iCol>=0)
143751 Expr *p = pS->pEList->a[iCol].pExpr;
143761 if( iCol<0 ) iCol = pTab->iPKey;
143762 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
143763 if( iCol<0 ){
143767 zOrigCol = pTab->aCol[iCol].zCnName;
143768 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
143776 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
143777 if( iCol<0 ){
143780 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
143927 int iCol = p->iColumn;
143930 if( iCol<0 ) iCol = pTab->iPKey;
143931 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
143932 if( iCol<0 ){
143935 zCol = pTab->aCol[iCol].zCnName;
144023 int iCol = pColExpr->iColumn;
144025 if( iCol<0 ) iCol = pTab->iPKey;
144026 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
144309 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
144312 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
144316 assert( iCol>=0 );
144320 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
144321 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
147111 u16 iCol = pList->a[j].u.x.iOrderByCol;
147112 if( iCol>0 ){
147113 iCol--;
147114 colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
152152 int iCol, /* Which column of the index to check */
152156 i16 iIdxCol = pIdx->aiColumn[iCol];
152163 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
152164 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
152196 static Expr *exprRowColumn(Parse *pParse, int iCol){
152198 if( pRet ) pRet->iColumn = iCol+1;
154796 int iCol;
154806 for(iCol=0; iCol<pTab->nCol; iCol++){
154807 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
154829 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
156850 int iCol = aiMap ? aiMap[iMap++] : 0;
156851 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
158487 int iCol = pPk->aiColumn[iPk];
158488 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
158781 int iCol = pPk->aiColumn[iPk];
158782 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
158928 int iCol = pPk->aiColumn[iPk];
158929 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
159151 int iCol = pRight->iColumn;
159152 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
159156 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
161359 int iCol /* Column of index to match */
161362 const char *zColl = pIdx->azColl[iCol];
161368 && p->iColumn==pIdx->aiColumn[iCol]
161384 static int indexColumnNotNull(Index *pIdx, int iCol){
161387 assert( iCol>=0 && iCol<pIdx->nColumn );
161388 j = pIdx->aiColumn[iCol];
161675 int iCol = pIdx->aiColumn[ii];
161677 zName = pTab->aCol[iCol].zCnName;
161763 int iCol;
161766 iCol = pTerm->u.x.leftColumn;
161767 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
161768 testcase( iCol==BMS );
161769 testcase( iCol==BMS-1 );
161773 pTable->aCol[iCol].zCnName);
161823 int iCol;
161826 iCol = pTerm->u.x.leftColumn;
161827 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
161828 testcase( iCol==BMS-1 );
161829 testcase( iCol==BMS );
162362 int iCol; /* Index of required stats in anEq[] etc. */
162429 iCol = 0;
162459 iCol = n-1;
162472 assert( iCol==nField-1 );
162482 pRec->nField = iCol+1;
162491 if( iCol>0 ){
162492 pRec->nField = iCol;
162507 assert( iCol==nField-1 );
162508 aStat[0] = aSample[i].anLt[iCol];
162509 aStat[1] = aSample[i].anEq[iCol];
162518 iUpper = aSample[i].anLt[iCol];
162569 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
162570 assert( iCol>=0 && iCol<pIdx->nColumn );
162574 assert( pIdx->zColAff[iCol]!=0 );
162575 return pIdx->zColAff[iCol];
163932 int iCol = pProbe->aiColumn[saved_nEq];
163935 if( iCol==XN_ROWID
163936 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
163938 if( iCol==XN_ROWID || pProbe->uniqNotNull
168644 int iCol = -1;
168650 iCol = i;
168655 if( iCol<0 ){
168669 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
182081 int iCol = 0;
182114 for(iCol=0; iCol<pTab->nCol; iCol++){
182115 pCol = &pTab->aCol[iCol];
182120 if( iCol==pTab->nCol ){
182122 iCol = pTab->iPKey;
182123 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
182146 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
184085 int fts3_global_term_cnt(int iTerm, int iCol);
184086 int fts3_term_cnt(int iTerm, int iCol);
184714 int iCol;
184803 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
185721 int iCol; /* Column index */
185994 for(iCol=0; iCol<nCol; iCol++){
185997 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
186003 p->azColumn[iCol] = zCsr;
186009 for(iCol=0; iCol<nCol; iCol++){
186010 int n = (int)strlen(p->azColumn[iCol]);
186014 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
186016 p->abNotindexed[iCol] = 1;
186742 static int fts3PutColNumber(char **pp, int iCol){
186744 if( iCol ){
186746 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
187318 sqlite3_int64 iCol;
187320 p += sqlite3Fts3GetVarint(p, &iCol);
187327 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
187717 filter.iCol = iColumn;
187886 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
187898 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
187989 int iCol /* Index of column to read value from */
187996 assert( iCol>=0 && iCol<=p->nColumn+2 );
187998 switch( iCol-p->nColumn ){
188017 iCol = p->nColumn;
188025 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
188026 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
188250 int iCol = -1;
188268 case 5: iCol = sqlite3_value_int(apVal[4]);
188281 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
189039 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
189044 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
189460 int iCol; /* The column the token must match */
189488 pTC->iCol = pPhrase->iColumn;
189668 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
189684 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
190329 int iCol = 0;
190343 pExpr->aMI[iCol*3 + 1] += iCnt;
190344 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
190347 p += fts3GetVarint32(p, &iCol);
190348 }while( iCol<nCol );
190497 int iCol;
190501 for(iCol=0; iCol<pTab->nColumn; iCol++){
190502 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
190503 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
190509 for(iCol=0; iCol<pTab->nColumn; iCol++){
190510 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
190511 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
190541 int iCol, /* Column to return position list for */
190553 assert( iCol>=0 && iCol<pTab->nColumn );
190554 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
190660 while( iThis<iCol ){
190670 *ppOut = ((iCol==iThis)?pIter:0);
190762 int iCol; /* Current value of 'col' column */
190899 int iCol = pInfo->aConstraint[i].iColumn;
190901 if( iCol==0 ){
190908 if( iCol==4 ){
190999 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
191000 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
191008 int iCol;
191023 iCol = 0;
191035 iCol = 0;
191047 assert( iCol==0 );
191060 pCsr->aStat[iCol+1].nOcc++;
191067 iCol = (int)v;
191068 if( iCol<1 ){
191072 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
191073 pCsr->aStat[iCol+1].nDoc++;
191079 pCsr->iCol = 0;
191196 int iCol /* Index of column to read value from */
191201 switch( iCol ){
191207 if( p->iCol ){
191208 sqlite3_result_int(pCtx, p->iCol-1);
191215 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
191219 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
191223 assert( iCol==4 );
191462 int iCol, /* Value for Fts3Phrase.iColumn */
191497 pRet->pPhrase->iColumn = iCol;
191695 int iCol;
191807 iCol = pParse->iDefaultCol;
191815 iCol = ii;
191820 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
194772 int iCol /* Index of column to read value from */
194777 switch( iCol ){
194791 assert( iCol==4 );
194968 int iCol; /* Column token must occur in */
195544 sqlite3_int64 iCol, /* Column for entry to add */
195567 if( iCol>0 && p->iLastCol!=iCol ){
195569 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
195573 p->iLastCol = iCol;
195576 if( iCol>=0 ){
195605 int iCol,
195618 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
195645 int iCol, /* Column into which text is being inserted */
195695 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
195704 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
195781 int iCol = i-2;
195782 if( p->abNotindexed[iCol]==0 ){
195784 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
195937 int iCol = i-1;
195938 if( p->abNotindexed[iCol]==0 ){
195940 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
197474 int iCol, /* Column to filter on */
197485 assert( iCol>=0 );
197490 if( iCol==iCurrent ){
197650 int iCol, /* Column to match on. */
197684 assert( iCol<0 || iCol<p->nColumn );
197685 pCsr->iColFilter = iCol;
197852 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
197941 int iCol,
197945 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
198447 int iCol;
198451 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
198452 if( p->abNotindexed[iCol]==0 ){
198453 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
198454 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
198455 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
198466 for(iCol=0; iCol<=p->nColumn; iCol++){
198467 aSzIns[iCol] += aSz[iCol];
200048 int iCol, /* Column number */
200056 ret += (ret<<3) + iCol;
200103 i64 iCol = 0;
200112 iCol = 0;
200115 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
200128 (int)iCol, (int)iPos
200190 int iCol;
200192 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
200193 if( p->abNotindexed[iCol]==0 ){
200194 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
200208 zToken, nToken, iLang, 0, iDocid, iCol, iPos
200213 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
200390 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
200447 int iCol /* Column that token must appear in (or -1) */
200457 pDeferred->iCol = iCol;
200749 int iCol; /* Extract snippet from this column */
200766 int iCol; /* Column snippet is extracted from */
201163 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
201204 int iCol, /* Index of column to create snippet from */
201240 sIter.iCol = iCol;
201259 pFragment->iCol = iCol;
201425 int iCol = pFragment->iCol+1; /* Query column to extract text from */
201429 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
201431 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
201436 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
201559 int iCol = 0;
201570 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
201572 p->aMatchinfo[iStart + iCol] = (u32)nHit;
201574 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
201580 pIter += fts3GetVarint32(pIter, &iCol);
201581 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
201832 int iCol;
201849 for(iCol=0; iCol<pInfo->nCol; iCol++){
201855 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
201892 pInfo->aMatchinfo[iCol] = nLcs;
201955 int iCol;
201956 for(iCol=0; iCol<pInfo->nCol; iCol++){
201965 pInfo->aMatchinfo[iCol] = iVal;
201975 int iCol;
201978 for(iCol=0; iCol<pInfo->nCol; iCol++){
201985 pInfo->aMatchinfo[iCol] = (u32)nToken;
202130 int iCol, /* Extract snippet from this column */
202185 if( iCol>=0 && iRead!=iCol ) continue;
202238 int iCol; /* Column of table to populate aTerm for */
202256 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
202284 int iCol; /* Column currently being processed */
202312 for(iCol=0; iCol<pTab->nColumn; iCol++){
202325 sCtx.iCol = iCol;
202338 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
202339 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
202341 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
202384 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
208225 int iCol;
208228 iCol = pConstraint->iColumn - JEACH_JSON;
208229 assert( iCol==0 || iCol==1 );
208230 testcase( iCol==0 );
208231 iMask = 1 << iCol;
208235 aIdx[iCol] = i;
211552 static int rtreeConstraintError(Rtree *pRtree, int iCol){
211557 assert( iCol==0 || iCol%2 );
211567 if( iCol==0 ){
211573 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
211574 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
217856 int iCol = 0;
217888 zOrder, zSep, iCol, zCol, zCollate
217891 zSelect, zSep, iCol, zCol
217894 iCol++;
217909 for(iCol=0; iCol<pIter->nCol; iCol++){
217910 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
218396 int iCol;
218399 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
218401 const char *zCol = pIter->azTblCol[iCol];
218408 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
218414 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
218415 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
219578 int iCol = p->objiter.nCol; /* Index of rbu_control column */
219581 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
219583 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
219595 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
219620 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
219621 const char *zCol = sqlite3_column_name(pStmt, iCol);
223725 int iCol; /* Used to iterate through table columns */
223727 for(iCol=0; iCol<pTab->nCol; iCol++){
223728 if( pTab->abPK[iCol] ){
223768 int iCol; /* Used to iterate from 0 to nCol */
223770 for(iCol=0; iCol<nCol; iCol++){
223923 int iCol; /* Used to iterate through columns */
223932 for(iCol=0; iCol<pTab->nCol; iCol++){
223933 if( !pTab->abPK[iCol] ){
223947 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
223950 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
224578 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
224581 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
224582 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
224588 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
224591 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
224592 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
225588 int iCol, /* Column to read value from */
225592 int eType = sqlite3_column_type(pStmt, iCol);
225598 i = sqlite3_column_int64(pStmt, iCol);
225600 double r = sqlite3_column_double(pStmt, iCol);
225610 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
225612 z = (u8 *)sqlite3_column_text(pStmt, iCol);
225614 nByte = sqlite3_column_bytes(pStmt, iCol);
226071 int iCol;
226074 for(iCol=0; iCol<pTab->nCol; iCol++){
226075 sessionAppendCol(&buf, pSel, iCol, &rc);
227118 int iCol;
227143 for(iCol=0; iCol<nCol; iCol++){
227144 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
227151 for(iCol=0; iCol<nCol; iCol++){
227152 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
227156 for(iCol=0; iCol<nCol*2; iCol++){
227157 sqlite3ValueFree(apVal[iCol]);
229830 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
229845 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
229846 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
230554 int iCol,
230627 int iCol, /* Column token appears in (-ve -> delete) */
230695 Fts5IndexIter*, const char*, int, i64 iRowid, int iCol, int iOff
230771 int iCol, /* Column token appears in (-ve -> delete) */
230842 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
230882 int iCol, /* Column on LHS of MATCH operator */
230890 int iCol,
232576 int iCol; /* Column to search */
232598 if( ic==pIter->iCol ){
232623 int iCol,
232631 pIter->iCol = iCol;
232776 int iCol;
232784 iCol = sqlite3_value_int(apVal[0]);
232789 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
232795 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
232893 int iCol, /* Column to score */
232913 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
232954 int iCol; /* 1st argument to snippet() */
232976 iCol = sqlite3_value_int(apVal[0]);
232983 iBestCol = (iCol>=0 ? iCol : 0);
232995 if( iCol<0 || iCol==i ){
235001 int iCol,
235031 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
235036 pColset->aiCol[0] = iCol;
235095 Fts5Config *pConfig, int bGlob, int iCol, const char *zText, Fts5Expr **pp
235148 iCol = pConfig->nCol;
235152 rc = sqlite3Fts5ExprNew(pConfig, bAnd, iCol, zExpr, pp,pConfig->pzErrmsg);
236772 int iCol /* New column to add to colset object */
236778 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
236787 if( aiCol[i]==iCol ) return pNew;
236788 if( aiCol[i]>iCol ) break;
236793 aiCol[i] = iCol;
236839 int iCol;
236846 for(iCol=0; iCol<pConfig->nCol; iCol++){
236847 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
236849 if( iCol==pConfig->nCol ){
236852 pRet = fts5ParseColset(pParse, pColset, iCol);
237732 static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
237735 if( pColset->aiCol[i]==iCol ) return 1;
237783 int iCol = p->iOff>>32;
237786 pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
237801 int iCol,
237808 sCtx.iOff = (((i64)iCol) << 32) - 1;
237813 if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
237956 int iCol,
237977 pTerm->pIter, iRowid, iCol, iOff+iToken, ppOut, pnOut
238074 i16 iCol; /* Column of last value written */
238248 int iCol, /* Column token appears in (-ve -> delete) */
238310 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
238353 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
238358 if( iCol>=0 ){
238363 assert_nc( iCol>=p->iCol );
238364 if( iCol!=p->iCol ){
238367 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
238368 p->iCol = (i16)iCol;
238372 p->iCol = (i16)(iPos = iCol);
242033 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
242036 if( pColset->aiCol[i]==iCol ) return 1;
242079 int iCol;
242080 fts5FastGetVarint32(pChunk, i, iCol);
242081 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
242098 int iCol;
242104 fts5FastGetVarint32(pChunk, i, iCol);
242105 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
245124 int iCol, /* Column token appears in (-ve -> delete) */
245133 assert( (iCol<0)==p->bDelete );
245137 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
245145 p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
245770 int iCol,
245777 i64 iPos = (((i64)iCol)<<32) + iOff;
245834 i64 iRowid, int iCol, int iOff
245849 fts5TokendataIterAppendMap(p, pT, ii, iRowid, (((i64)iCol)<<32) + iOff);
245882 int iCol;
245884 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
245885 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
246298 int iCol,
246306 ret += (ret<<3) + iCol;
246384 int iCol = FTS5_POS2COLUMN(sReader.iPos);
246386 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
246814 int iCol = FTS5_POS2COLUMN(iPos);
246816 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
248252 int iCol = p->iColumn;
248254 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
248257 if( p->usable==0 || iCol<0 ){
248265 if( iCol==nCol+1 ){
248269 }else if( iCol>=0 ){
248272 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
248280 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
248283 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
248287 }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
248902 int iCol; /* Column on LHS of MATCH operator */
248940 iCol = 0;
248942 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
248954 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
248968 iCol = 0;
248970 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
248974 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
249530 int iCol,
249535 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
249569 int iCol,
249576 if( iCol<0 || iCol>=pTab->pConfig->nCol ){
249586 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
249587 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
249780 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
249815 if( iCol<0 ){
249821 }else if( iCol<pConfig->nCol ){
249822 *pnToken = pCsr->aColumnSize[iCol];
250036 int iCol = pCsr->aInst[iIdx*3 + 1];
250040 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
250254 int iCol /* Index of column to read value from */
250264 if( iCol==pConfig->nCol ){
250269 if( iCol==pConfig->nCol ){
250275 }else if( iCol==pConfig->nCol+1 ){
250292 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
251143 int iCol;
251165 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
251182 int iCol;
251195 ctx.iCol = -1;
251196 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
251197 if( pConfig->abUnindexed[iCol-1]==0 ){
251203 zText = (const char*)sqlite3_column_text(pSeek, iCol);
251204 nText = sqlite3_column_bytes(pSeek, iCol);
251206 zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
251207 nText = sqlite3_value_bytes(apVal[iCol-1]);
251215 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
251216 if( p->aTotalSize[iCol-1]<0 ){
251450 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
251452 if( pConfig->abUnindexed[ctx.iCol]==0 ){
251453 const char *zText = (const char*)sqlite3_column_text(pScan, ctx.iCol+1);
251454 int nText = sqlite3_column_bytes(pScan, ctx.iCol+1);
251463 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
251576 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
251578 if( pConfig->abUnindexed[ctx.iCol]==0 ){
251579 const char *zText = (const char*)sqlite3_value_text(apVal[ctx.iCol+2]);
251580 int nText = sqlite3_value_bytes(apVal[ctx.iCol+2]);
251589 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
251633 int iCol;
251658 int iCol;
251670 iCol = pCtx->iCol;
251674 iPos = pCtx->iCol;
251675 iCol = 0;
251681 iCol = 0;
251688 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
251699 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
251751 ctx.iCol = i;
251913 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
251917 if( iCol<0 ){
251922 }else if( iCol<p->pConfig->nCol ){
251923 *pnToken = p->aTotalSize[iCol];
254649 int iCol;
255068 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
255069 if( pCsr->aDoc[pCsr->iCol] ) break;
255073 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
255094 pCsr->iCol = 0;
255118 int iCol = -1;
255121 if( iCol!=ii ){
255127 iCol = ii;
255170 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
255171 if( pCsr->iCol==nCol ){
255263 int iCol /* Index of column to read value from */
255270 if( iCol==0 ){
255275 assert( iCol==1 || iCol==2 || iCol==3 );
255276 if( iCol==1 ){
255278 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
255281 }else if( iCol==2 ){
255282 iVal = pCsr->aDoc[pCsr->iCol];
255284 iVal = pCsr->aCnt[pCsr->iCol];
255287 assert( iCol==1 || iCol==2 );
255288 if( iCol==1 ){
255295 switch( iCol ){
255313 assert( iCol==3 );