Lines Matching refs:iCol
5786 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
5787 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
5788 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
5789 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
5790 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
5791 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
5792 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
5793 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
5794 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
5795 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
13694 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
13709 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
13710 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
13732 int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
23749 int iCol; /* Column for which the cache is valid */ member
85788 int iCol, /* Column to extract */
85800 assert( iCol>0 );
85804 for(i=0; i<=iCol; i++){
95059 int iCol, /* The column to read */
95092 || pCache->iCol!=iCol
95105 pCache->iCol = iCol;
103605 u16 iCol; /* Table column this handle is open on */
103657 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
103658 testcase( pC->nHdrParsed==p->iCol );
103659 testcase( pC->nHdrParsed==p->iCol+1 );
103668 p->iOffset = pC->aType[p->iCol + pC->nField];
103708 int iCol; /* Index of zColumn in row-record */
103776 iCol = sqlite3ColumnIndex(pTab, zColumn);
103777 if( iCol<0 ){
103802 if( pFKey->aCol[j].iFrom==iCol ){
103813 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
103907 pBlob->iCol = iCol;
104010 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
108105 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
108113 assert( iCol>=0 && iCol<pEList->nExpr );
108114 pOrig = pEList->a[iCol].pExpr;
108588 int iCol;
108591 iCol = sqlite3ColumnIndex(pTab, zCol);
108592 if( iCol>=0 ){
108593 if( pTab->iPKey==iCol ) iCol = -1;
108596 iCol = -1;
108598 iCol = pTab->nCol;
108601 if( iCol<pTab->nCol ){
108606 testcase( iCol==(-1) );
108609 pExpr->iColumn = iCol;
108614 sqlite3TableColumnToStorage(pTab, iCol);
108625 pExpr->iColumn = iCol;
108627 sqlite3TableColumnToStorage(pTab, iCol) + 1;
108629 pExpr->iColumn = (i16)iCol;
108632 if( iCol<0 ){
108635 testcase( iCol==31 );
108636 testcase( iCol==32 );
108637 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
108639 testcase( iCol==31 );
108640 testcase( iCol==32 );
108641 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
108894 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
108902 if( p->y.pTab->iPKey==iCol ){
108905 p->iColumn = (ynVar)iCol;
108907 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
108913 testcase( iCol==BMS );
108914 testcase( iCol==BMS-1 );
108915 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
109648 int iCol = -1;
109653 if( sqlite3ExprIsInteger(pE, &iCol, 0) ){
109654 if( iCol<=0 || iCol>pEList->nExpr ){
109659 iCol = resolveAsName(pParse, pEList, pE);
109660 if( iCol==0 ){
109675 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
109676 if( IN_RENAME_OBJECT && iCol>0 ){
109683 if( iCol>0 ){
109690 pNew->u.iValue = iCol;
109701 pItem->u.x.iOrderByCol = (u16)iCol;
109815 int iCol; /* Column number */
109828 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
109829 if( iCol>0 ){
109834 pItem->u.x.iOrderByCol = (u16)iCol;
109838 if( sqlite3ExprIsInteger(pE2, &iCol, 0) ){
109842 if( iCol<1 || iCol>0xffff ){
109846 pItem->u.x.iOrderByCol = (u16)iCol;
110369 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
110370 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
110371 return pTab->aCol[iCol].affinity;
113562 int iCol = pEList->a[i].pExpr->iColumn;
113563 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
114632 int iCol, /* Index of the column to extract */
114638 assert( iCol!=XN_EXPR );
114639 if( iCol<0 || iCol==pTab->iPKey ){
114647 x = iCol;
114649 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
114665 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
114666 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
114669 x = sqlite3TableColumnToStorage(pTab,iCol);
114670 testcase( x!=iCol );
114674 sqlite3ColumnDefault(v, pTab, iCol, regOut);
115174 int iCol = pExpr->iColumn;
115178 assert( iCol>=XN_ROWID );
115179 assert( iCol<pTab->nCol );
115180 if( iCol<0 ){
115183 pCol = pTab->aCol + iCol;
115184 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
115185 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
115676 int iCol;
115681 iCol = pExpr->iColumn;
115683 + sqlite3TableColumnToStorage(pTab, iCol);
115686 assert( iCol>=-1 && iCol<pTab->nCol );
115687 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
115693 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
115702 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
118372 int iCol; /* Index of column being renamed */
118403 iCol = sqlite3ColumnIndex(pTab, zOld);
118404 if( iCol<0 ){
118428 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
118436 zDb, pTab->zName, iCol, zNew, bQuote
118481 int iCol; /* Index of column being renamed */
118783 && pExpr->iColumn==p->iCol
118788 && pExpr->iColumn==p->iCol
119286 int iCol = sqlite3_value_int(argv[5]);
119305 if( iCol<0 ) return;
119308 if( pTab==0 || iCol>=pTab->nCol ){
119312 zOld = pTab->aCol[iCol].zCnName;
119314 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
119347 if( iCol<sParse.pNewTable->nCol ){
119349 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
119352 if( sCtx.iCol<0 ){
119374 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
119883 int iCol = sqlite3_value_int(argv[2]);
119901 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
119907 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
119908 if( iCol<pTab->nCol-1 ){
119910 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
119946 int iCol; /* Index of column zCol in pTab->aCol[] */
119966 iCol = sqlite3ColumnIndex(pTab, zCol);
119967 if( iCol<0 ){
119974 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
119976 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
120004 , zDb, iDb, iCol, pTab->zName
120012 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
120038 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
120042 int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
120378 int iCol; /* If !isPSample, the reason for inclusion */
120450 pTo->iCol = pFrom->iCol;
120576 p->aBest[i].iCol = i;
120618 assert( pNew->iCol==pOld->iCol );
120619 for(i=pNew->iCol+1; i<nCol; i++){
120640 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
120641 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
120644 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
120648 if( pNew->iCol<pOld->iCol ) return 1;
120649 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
120673 assert( pNew->anEq[pNew->iCol]>0 );
120682 if( pOld->anEq[pNew->iCol]==0 ){
120684 assert( pOld->iCol>pNew->iCol );
120692 pUpgrade->iCol = pNew->iCol;
120693 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
120861 p->current.iCol = 0;
120868 p->current.iCol = i;
121787 int iCol;
121797 for(iCol=0; iCol<nCol; iCol++){
121806 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
121807 nRow = pFinal->anLt[iCol];
121808 nDist100 = (i64)100 * pFinal->anDLt[iCol];
121812 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
121822 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
121824 sumEq += aSample[i].anEq[iCol];
121833 pIdx->aAvgEq[iCol] = avgEq;
122886 int iCol; /* Index of column in table */
122909 iCol = pExpr->iColumn;
122912 if( iCol>=0 ){
122913 assert( iCol<pTab->nCol );
122914 zCol = pTab->aCol[iCol].zCnName;
124073 SQLITE_PRIVATE int sqlite3TableColumnToIndex(Index *pIdx, int iCol){
124076 assert( iCol>=(-1) && iCol<=SQLITE_MAX_COLUMN );
124078 iCol16 = iCol;
124099 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
124102 for(i=0; i<=iCol; i++){
124103 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
124106 return iCol;
124147 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
124150 assert( iCol<pTab->nCol );
124151 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
124152 for(i=0, n=0; i<iCol; i++){
124827 int iCol = -1, i;
124837 iCol = pTab->nCol - 1;
124838 pCol = &pTab->aCol[iCol];
124849 iCol = sqlite3ColumnIndex(pTab, pCExpr->u.zToken);
124850 if( iCol>=0 ){
124851 pCol = &pTab->aCol[iCol];
124866 pTab->iPKey = iCol;
125263 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
125266 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
125271 j = pPk->aiColumn[iCol];
125276 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
126622 int iCol = p->nCol-1;
126623 if( NEVER(iCol<0) ) goto fk_end;
126627 p->aCol[iCol].zCnName, pTo);
130129 int iCol; /* Iterator used while populating OLD.* */
130144 for(iCol=0; iCol<pTab->nCol; iCol++){
130145 testcase( mask!=0xffffffff && iCol==31 );
130146 testcase( mask!=0xffffffff && iCol==32 );
130147 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
130148 int kk = sqlite3TableColumnToStorage(pTab, iCol);
130149 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
133580 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
133584 if( iCol<0 ) break; /* No foreign keys against expression indexes */
133589 zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);
133593 zIdxCol = pParent->aCol[iCol].zCnName;
133802 i16 iCol /* Which column of pTab is desired */
133811 if( iCol>=0 && iCol!=pTab->iPKey ){
133812 pCol = &pTab->aCol[iCol];
133813 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
133834 i16 iCol /* The column that is wanted */
133841 pExpr->iColumn = iCol;
133914 i16 iCol; /* Index of column in child table */
133917 iCol = pIdx ? pIdx->aiColumn[i] : -1;
133918 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
133919 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
133920 assert( iCol>=0 );
133921 zCol = pFKey->pFrom->aCol[iCol].zCnName;
133953 i16 iCol = pIdx->aiColumn[i];
133954 assert( iCol>=0 );
133955 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
133956 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
134246 int iCol;
134294 iCol = pFKey->aCol[0].iFrom;
134295 aiCol = &iCol;
138425 const void * (*column_blob)(sqlite3_stmt*,int iCol);
138426 int (*column_bytes)(sqlite3_stmt*,int iCol);
138427 int (*column_bytes16)(sqlite3_stmt*,int iCol);
138433 double (*column_double)(sqlite3_stmt*,int iCol);
138434 int (*column_int)(sqlite3_stmt*,int iCol);
138435 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
138442 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
138443 const void * (*column_text16)(sqlite3_stmt*,int iCol);
138444 int (*column_type)(sqlite3_stmt*,int iCol);
138445 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
142268 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
142269 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
142776 int iCol = pIdx->aiColumn[kk];
142777 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
142778 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
145195 SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol){
145205 assert( iCol>=0 && iCol<pResults->nExpr );
145206 pResults->a[iCol].fg.bUsed = 1;
145230 int iCol; /* Index of column matching zCol */
145237 iCol = sqlite3ColumnIndex(pSrc->a[i].pSTab, zCol);
145238 if( iCol>=0
145239 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pSTab->aCol[iCol])==0)
145242 sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol);
145244 *piCol = iCol;
146543 int iCol;
146624 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
146628 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
146632 int iKey = iCol+1;
146672 iRead = iCol--;
146800 int iCol = pExpr->iColumn; /* Index of column in pTab */
146843 if( iCol<pS->pEList->nExpr
146844 && (!ViewCanHaveRowid || iCol>=0)
146851 Expr *p = pS->pEList->a[iCol].pExpr;
146861 if( iCol<0 ) iCol = pTab->iPKey;
146862 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
146863 if( iCol<0 ){
146867 zOrigCol = pTab->aCol[iCol].zCnName;
146868 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
146876 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
146877 if( iCol<0 ){
146880 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
147027 int iCol = p->iColumn;
147030 if( iCol<0 ) iCol = pTab->iPKey;
147031 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
147032 if( iCol<0 ){
147035 zCol = pTab->aCol[iCol].zCnName;
147123 int iCol = pColExpr->iColumn;
147125 if( iCol<0 ) iCol = pTab->iPKey;
147126 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
147413 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
147416 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
147420 assert( iCol>=0 );
147424 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
147425 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
150268 u16 iCol = pList->a[j].u.x.iOrderByCol;
150269 if( iCol>0 ){
150270 iCol--;
150271 colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
155534 int iCol, /* Which column of the index to check */
155538 i16 iIdxCol = pIdx->aiColumn[iCol];
155545 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
155546 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
155578 static Expr *exprRowColumn(Parse *pParse, int iCol){
155580 if( pRet ) pRet->iColumn = iCol+1;
158196 int iCol;
158206 for(iCol=0; iCol<pTab->nCol; iCol++){
158207 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
158229 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
160352 int iCol = aiMap ? aiMap[iMap++] : 0;
160353 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
162062 int iCol = pPk->aiColumn[iPk];
162063 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
162362 int iCol = pPk->aiColumn[iPk];
162363 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
162524 int iCol = pPk->aiColumn[iPk];
162525 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
162753 int iCol = pRight->iColumn;
162754 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
162758 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
165056 int iCol /* Column of index to match */
165059 const char *zColl = pIdx->azColl[iCol];
165065 && p->iColumn==pIdx->aiColumn[iCol]
165081 static int indexColumnNotNull(Index *pIdx, int iCol){
165084 assert( iCol>=0 && iCol<pIdx->nColumn );
165085 j = pIdx->aiColumn[iCol];
165344 int iCol
165350 if( pIdx->aiColumn[j]==iCol ){
165428 int iCol = pIdx->aiColumn[ii];
165430 zName = pTab->aCol[iCol].zCnName;
165516 int iCol;
165519 iCol = pTerm->u.x.leftColumn;
165520 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
165521 testcase( iCol==BMS );
165522 testcase( iCol==BMS-1 );
165526 pTable->aCol[iCol].zCnName);
165592 int iCol;
165595 iCol = pTerm->u.x.leftColumn;
165596 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
165597 testcase( iCol==BMS-1 );
165598 testcase( iCol==BMS );
166013 int iCol = pPk->aiColumn[i];
166014 assert( iCol>=0 );
166015 if( iCol>=BMS-1 ) iCol = BMS-1;
166016 pIdxInfo->colUsed |= MASKBIT(iCol);
166186 int iCol; /* Index of required stats in anEq[] etc. */
166253 iCol = 0;
166283 iCol = n-1;
166296 assert( iCol==nField-1 );
166306 pRec->nField = iCol+1;
166315 if( iCol>0 ){
166316 pRec->nField = iCol;
166331 assert( iCol==nField-1 );
166332 aStat[0] = aSample[i].anLt[iCol];
166333 aStat[1] = aSample[i].anEq[iCol];
166342 iUpper = aSample[i].anLt[iCol];
166393 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
166394 assert( iCol>=0 && iCol<pIdx->nColumn );
166398 assert( pIdx->zColAff[iCol]!=0 );
166399 return pIdx->zColAff[iCol];
167779 int iCol = pProbe->aiColumn[saved_nEq];
167782 if( iCol==XN_ROWID
167783 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
167785 if( iCol==XN_ROWID || pProbe->uniqNotNull
172945 int iCol = -1;
172951 iCol = i;
172956 if( iCol<0 ){
172970 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
186609 int iCol = 0;
186642 iCol = sqlite3ColumnIndex(pTab, zColumnName);
186643 if( iCol>=0 ){
186644 pCol = &pTab->aCol[iCol];
186647 iCol = pTab->iPKey;
186648 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
186671 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
188614 int fts3_global_term_cnt(int iTerm, int iCol);
188615 int fts3_term_cnt(int iTerm, int iCol);
189260 int iCol;
189349 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
190262 int iCol; /* Column index */
190535 for(iCol=0; iCol<nCol; iCol++){
190538 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
190544 p->azColumn[iCol] = zCsr;
190550 for(iCol=0; iCol<nCol; iCol++){
190551 int n = (int)strlen(p->azColumn[iCol]);
190555 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
190557 p->abNotindexed[iCol] = 1;
191283 static int fts3PutColNumber(char **pp, int iCol){
191285 if( iCol ){
191287 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
191864 sqlite3_int64 iCol;
191866 p += sqlite3Fts3GetVarint(p, &iCol);
191873 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
192263 filter.iCol = iColumn;
192432 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
192444 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
192535 int iCol /* Index of column to read value from */
192542 assert( iCol>=0 && iCol<=p->nColumn+2 );
192544 switch( iCol-p->nColumn ){
192563 iCol = p->nColumn;
192571 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
192572 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
192796 int iCol = -1;
192814 case 5: iCol = sqlite3_value_int(apVal[4]);
192827 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
193587 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
193592 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
194008 int iCol; /* The column the token must match */
194036 pTC->iCol = pPhrase->iColumn;
194216 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
194232 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
194895 int iCol = 0;
194909 pExpr->aMI[iCol*3 + 1] += iCnt;
194910 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
194913 p += fts3GetVarint32(p, &iCol);
194914 }while( iCol<nCol );
195063 int iCol;
195067 for(iCol=0; iCol<pTab->nColumn; iCol++){
195068 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
195069 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
195075 for(iCol=0; iCol<pTab->nColumn; iCol++){
195076 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
195077 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
195107 int iCol, /* Column to return position list for */
195119 assert( iCol>=0 && iCol<pTab->nColumn );
195120 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
195226 while( iThis<iCol ){
195236 *ppOut = ((iCol==iThis)?pIter:0);
195328 int iCol; /* Current value of 'col' column */
195465 int iCol = pInfo->aConstraint[i].iColumn;
195467 if( iCol==0 ){
195474 if( iCol==4 ){
195565 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
195566 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
195574 int iCol;
195589 iCol = 0;
195601 iCol = 0;
195613 assert( iCol==0 );
195626 pCsr->aStat[iCol+1].nOcc++;
195633 iCol = (int)v;
195634 if( iCol<1 ){
195638 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
195639 pCsr->aStat[iCol+1].nDoc++;
195645 pCsr->iCol = 0;
195762 int iCol /* Index of column to read value from */
195767 switch( iCol ){
195773 if( p->iCol ){
195774 sqlite3_result_int(pCtx, p->iCol-1);
195781 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
195785 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
195789 assert( iCol==4 );
196045 int iCol, /* Value for Fts3Phrase.iColumn */
196073 return getNextToken(pParse, iCol, z, iBarred, ppExpr, pnConsumed);
196084 pRet->pPhrase->iColumn = iCol;
196285 int iCol;
196397 iCol = pParse->iDefaultCol;
196405 iCol = ii;
196410 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
199357 int iCol /* Index of column to read value from */
199362 switch( iCol ){
199376 assert( iCol==4 );
199553 int iCol; /* Column token must occur in */
200129 sqlite3_int64 iCol, /* Column for entry to add */
200152 if( iCol>0 && p->iLastCol!=iCol ){
200154 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
200158 p->iLastCol = iCol;
200161 if( iCol>=0 ){
200190 int iCol,
200203 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
200230 int iCol, /* Column into which text is being inserted */
200280 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
200289 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
200366 int iCol = i-2;
200367 if( p->abNotindexed[iCol]==0 ){
200369 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
200522 int iCol = i-1;
200523 if( p->abNotindexed[iCol]==0 ){
200525 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
202059 int iCol, /* Column to filter on */
202070 assert( iCol>=0 );
202075 if( iCol==iCurrent ){
202235 int iCol, /* Column to match on. */
202269 assert( iCol<0 || iCol<p->nColumn );
202270 pCsr->iColFilter = iCol;
202437 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
202526 int iCol,
202530 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
203032 int iCol;
203036 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
203037 if( p->abNotindexed[iCol]==0 ){
203038 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
203039 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
203040 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
203051 for(iCol=0; iCol<=p->nColumn; iCol++){
203052 aSzIns[iCol] += aSz[iCol];
204633 int iCol, /* Column number */
204641 ret += (ret<<3) + iCol;
204688 i64 iCol = 0;
204697 iCol = 0;
204700 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
204713 (int)iCol, (int)iPos
204775 int iCol;
204777 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
204778 if( p->abNotindexed[iCol]==0 ){
204779 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
204793 zToken, nToken, iLang, 0, iDocid, iCol, iPos
204798 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
204980 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
205037 int iCol /* Column that token must appear in (or -1) */
205047 pDeferred->iCol = iCol;
205339 int iCol; /* Extract snippet from this column */
205356 int iCol; /* Column snippet is extracted from */
205758 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
205799 int iCol, /* Index of column to create snippet from */
205835 sIter.iCol = iCol;
205854 pFragment->iCol = iCol;
206020 int iCol = pFragment->iCol+1; /* Query column to extract text from */
206024 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
206026 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
206031 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
206154 int iCol = 0;
206165 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
206167 p->aMatchinfo[iStart + iCol] = (u32)nHit;
206169 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
206175 pIter += fts3GetVarint32(pIter, &iCol);
206176 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
206427 int iCol;
206444 for(iCol=0; iCol<pInfo->nCol; iCol++){
206450 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
206487 pInfo->aMatchinfo[iCol] = nLcs;
206550 int iCol;
206551 for(iCol=0; iCol<pInfo->nCol; iCol++){
206560 pInfo->aMatchinfo[iCol] = iVal;
206570 int iCol;
206573 for(iCol=0; iCol<pInfo->nCol; iCol++){
206580 pInfo->aMatchinfo[iCol] = (u32)nToken;
206725 int iCol, /* Extract snippet from this column */
206780 if( iCol>=0 && iRead!=iCol ) continue;
206833 int iCol; /* Column of table to populate aTerm for */
206851 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
206895 int iCol; /* Column currently being processed */
206929 for(iCol=0; iCol<pTab->nColumn; iCol++){
206942 sCtx.iCol = iCol;
206955 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
206956 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
206958 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
207001 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
213162 int iCol;
213165 iCol = pConstraint->iColumn - JEACH_JSON;
213166 assert( iCol==0 || iCol==1 );
213167 testcase( iCol==0 );
213168 iMask = 1 << iCol;
213172 aIdx[iCol] = i;
216513 static int rtreeConstraintError(Rtree *pRtree, int iCol){
216518 assert( iCol==0 || iCol%2 );
216528 if( iCol==0 ){
216534 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
216535 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
222876 int iCol = 0;
222908 zOrder, zSep, iCol, zCol, zCollate
222911 zSelect, zSep, iCol, zCol
222914 iCol++;
222929 for(iCol=0; iCol<pIter->nCol; iCol++){
222930 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
223416 int iCol;
223419 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
223421 const char *zCol = pIter->azTblCol[iCol];
223428 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
223434 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
223435 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
224600 int iCol = p->objiter.nCol; /* Index of rbu_control column */
224603 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
224605 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
224617 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
224642 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
224643 const char *zCol = sqlite3_column_name(pStmt, iCol);
228824 int iCol; /* Used to iterate through table columns */
228826 for(iCol=0; iCol<pTab->nCol; iCol++){
228827 if( pTab->abPK[iCol] ){
228867 int iCol; /* Used to iterate from 0 to nCol */
228869 for(iCol=0; iCol<nCol; iCol++){
229022 int iCol; /* Used to iterate through columns */
229031 for(iCol=0; iCol<pTab->nCol; iCol++){
229032 if( !pTab->abPK[iCol] ){
229038 int iIdx = pTab->aiIdx[iCol];
229698 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
229701 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
229702 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
229708 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
229711 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
229712 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
230745 int iCol, /* Column to read value from */
230749 int eType = sqlite3_column_type(pStmt, iCol);
230755 i = sqlite3_column_int64(pStmt, iCol);
230757 double r = sqlite3_column_double(pStmt, iCol);
230767 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
230769 z = (u8 *)sqlite3_column_text(pStmt, iCol);
230771 nByte = sqlite3_column_bytes(pStmt, iCol);
231236 int iCol;
231239 for(iCol=0; iCol<pTab->nCol; iCol++){
231240 sessionAppendCol(&buf, pSel, iCol, &rc);
232284 int iCol;
232309 for(iCol=0; iCol<nCol; iCol++){
232310 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
232317 for(iCol=0; iCol<nCol; iCol++){
232318 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
232322 for(iCol=0; iCol<nCol*2; iCol++){
232323 sqlite3ValueFree(apVal[iCol]);
235145 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
235160 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
235161 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
235183 int (*xColumnLocale)(Fts5Context*, int iCol, const char **pz, int *pn);
236006 int iCol,
236069 int iCol,
236086 int iCol, /* Column token appears in (-ve -> delete) */
236154 Fts5IndexIter*, const char*, int, i64 iRowid, int iCol, int iOff
236232 int iCol, /* Column token appears in (-ve -> delete) */
236303 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
236346 int iCol, /* Column on LHS of MATCH operator */
236354 int iCol,
238064 int iCol; /* Column to search */
238086 if( ic==pIter->iCol ){
238111 int iCol,
238119 pIter->iCol = iCol;
238265 int iCol;
238273 iCol = sqlite3_value_int(apVal[0]);
238278 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
238286 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
238290 rc = pApi->xColumnLocale(pFts, iCol, &pLoc, &nLoc);
238389 int iCol, /* Column to score */
238409 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
238450 int iCol; /* 1st argument to snippet() */
238472 iCol = sqlite3_value_int(apVal[0]);
238479 iBestCol = (iCol>=0 ? iCol : 0);
238491 if( iCol<0 || iCol==i ){
238782 int iCol = 0;
238804 iCol = sqlite3_value_int(apVal[0]);
238805 if( iCol<0 || iCol>=pApi->xColumnCount(pFts) ){
238810 rc = pApi->xColumnLocale(pFts, iCol, &zLocale, &nLocale);
240659 int iCol,
240690 if( sParse.rc==SQLITE_OK && iCol<pConfig->nCol ){
240695 pColset->aiCol[0] = iCol;
240750 Fts5Config *pConfig, int bGlob, int iCol, const char *zText, Fts5Expr **pp
240803 iCol = pConfig->nCol;
240807 rc = sqlite3Fts5ExprNew(pConfig, bAnd, iCol, zExpr, pp,pConfig->pzErrmsg);
242425 int iCol /* New column to add to colset object */
242431 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
242440 if( aiCol[i]==iCol ) return pNew;
242441 if( aiCol[i]>iCol ) break;
242446 aiCol[i] = iCol;
242492 int iCol;
242499 for(iCol=0; iCol<pConfig->nCol; iCol++){
242500 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
242502 if( iCol==pConfig->nCol ){
242505 pRet = fts5ParseColset(pParse, pColset, iCol);
243395 static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
243398 if( pColset->aiCol[i]==iCol ) return 1;
243446 int iCol = p->iOff>>32;
243449 pT->pIter, pToken, nToken, iRowid, iCol, iTokOff
243464 int iCol,
243471 sCtx.iOff = (((i64)iCol) << 32) - 1;
243476 if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
243620 int iCol,
243641 iRowid, iCol, iOff+iToken, ppOut, pnOut
243737 i16 iCol; /* Column of last value written */
243911 int iCol, /* Column token appears in (-ve -> delete) */
243973 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
244016 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
244021 if( iCol>=0 ){
244026 assert_nc( iCol>=p->iCol );
244027 if( iCol!=p->iCol ){
244030 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
244031 p->iCol = (i16)iCol;
244035 p->iCol = (i16)(iPos = iCol);
247712 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
247715 if( pColset->aiCol[i]==iCol ) return 1;
247758 int iCol;
247759 fts5FastGetVarint32(pChunk, i, iCol);
247760 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
247777 int iCol;
247783 fts5FastGetVarint32(pChunk, i, iCol);
247784 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
251178 int iCol, /* Column token appears in (-ve -> delete) */
251187 assert( (iCol<0)==p->bDelete );
251191 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
251199 p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
251813 int iCol,
251819 i64 iPos = (((i64)iCol)<<32) + iOff;
251894 i64 iRowid, int iCol, int iOff
251899 i64 iPos = (((i64)iCol)<<32) + iOff;
251953 int iCol;
251955 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
251956 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
252369 int iCol,
252377 ret += (ret<<3) + iCol;
252455 int iCol = FTS5_POS2COLUMN(sReader.iPos);
252457 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
252885 int iCol = FTS5_POS2COLUMN(iPos);
252887 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
254359 int iCol = p->iColumn;
254361 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
254364 if( p->usable==0 || iCol<0 ){
254370 if( iCol==nCol+1 ){
254377 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
254385 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
254388 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
254393 }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
255151 int iCol; /* Column on LHS of MATCH operator */
255193 iCol = 0;
255195 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
255207 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
255227 iCol = 0;
255229 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
255233 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
255859 int iCol,
255864 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
255936 int iCol,
255940 sqlite3_value *pVal = sqlite3_column_value(pStmt, iCol+1);
255954 pLoc = (const char*)sqlite3_column_text(pStmt, iCol+1+pConfig->nCol);
255955 nLoc = sqlite3_column_bytes(pStmt, iCol+1+pConfig->nCol);
255964 int iCol,
255973 if( iCol<0 || iCol>=pTab->pConfig->nCol ){
255981 rc = fts5TextFromStmt(pTab->pConfig, pCsr->pStmt, iCol, pz, pn);
256194 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
256231 if( iCol<0 ){
256237 }else if( iCol<pConfig->nCol ){
256238 *pnToken = pCsr->aColumnSize[iCol];
256455 int iCol = pCsr->aInst[iIdx*3 + 1];
256459 pCsr->pExpr, iRowid, iPhrase, iCol, iOff, iToken, ppOut, pnOut
256476 int iCol,
256488 if( iCol<0 || iCol>=pConfig->nCol ){
256491 pConfig->abUnindexed[iCol]==0
256499 rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &zDummy, &nDummy);
256732 int iCol /* Index of column to read value from */
256742 if( iCol==pConfig->nCol ){
256747 if( iCol==pConfig->nCol ){
256753 }else if( iCol==pConfig->nCol+1 ){
256771 sqlite3_value *pVal = sqlite3_column_value(pCsr->pStmt, iCol+1);
256778 rc = fts5TextFromStmt(pConfig, pCsr->pStmt, iCol, &z, &n);
258026 int iCol;
258048 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
258099 int iCol;
258121 ctx.iCol = -1;
258122 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
258123 if( pConfig->abUnindexed[iCol-1]==0 ){
258134 pVal = sqlite3_column_value(pSeek, iCol);
258136 pVal = apVal[iCol-1];
258155 pLoc = (const char*)sqlite3_column_text(pSeek, iCol+pConfig->nCol);
258156 nLoc = sqlite3_column_bytes(pSeek, iCol + pConfig->nCol);
258167 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
258168 if( rc==SQLITE_OK && p->aTotalSize[iCol-1]<0 ){
258443 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
258445 if( pConfig->abUnindexed[ctx.iCol]==0 ){
258451 sqlite3_value *pVal = sqlite3_column_value(pScan, ctx.iCol+1);
258460 int iCol = ctx.iCol + 1 + pConfig->nCol;
258461 pLoc = (const char*)sqlite3_column_text(pScan, iCol);
258462 nLoc = sqlite3_column_bytes(pScan, iCol);
258478 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
258637 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
258639 if( pConfig->abUnindexed[ctx.iCol]==0 ){
258645 sqlite3_value *pVal = apVal[ctx.iCol+2];
258647 pVal = sqlite3_column_value(p->pSavedRow, ctx.iCol+1);
258649 int iCol = ctx.iCol + 1 + pConfig->nCol;
258650 pLoc = (const char*)sqlite3_column_text(p->pSavedRow, iCol);
258651 nLoc = sqlite3_column_bytes(p->pSavedRow, iCol);
258654 pVal = apVal[ctx.iCol+2];
258674 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
258718 int iCol;
258743 int iCol;
258755 iCol = pCtx->iCol;
258759 iPos = pCtx->iCol;
258760 iCol = 0;
258766 iCol = 0;
258773 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
258784 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
258850 int iCol = i + 1 + pConfig->nCol;
258851 pLoc = (const char*)sqlite3_column_text(pScan, iCol);
258852 nLoc = sqlite3_column_bytes(pScan, iCol);
258858 ctx.iCol = i;
259030 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
259034 if( iCol<0 ){
259039 }else if( iCol<p->pConfig->nCol ){
259040 *pnToken = p->aTotalSize[iCol];
261801 int iCol;
262224 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
262225 if( pCsr->aDoc[pCsr->iCol] ) break;
262229 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
262250 pCsr->iCol = 0;
262284 int iCol = -1;
262287 if( iCol!=ii ){
262293 iCol = ii;
262336 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
262337 if( pCsr->iCol==nCol ){
262430 int iCol /* Index of column to read value from */
262437 if( iCol==0 ){
262442 assert( iCol==1 || iCol==2 || iCol==3 );
262443 if( iCol==1 ){
262445 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
262448 }else if( iCol==2 ){
262449 iVal = pCsr->aDoc[pCsr->iCol];
262451 iVal = pCsr->aCnt[pCsr->iCol];
262454 assert( iCol==1 || iCol==2 );
262455 if( iCol==1 ){
262462 switch( iCol ){
262480 assert( iCol==3 );