Lines Matching refs:iCol
6040 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
6041 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
6042 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
6043 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
6044 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
6045 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
6046 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
6047 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
6048 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
6049 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
7915 ** set. In other words, column iCol may be required if the expression
7916 ** (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to
12811 ** xColumnTotalSize(pFts, iCol, pnToken):
12812 ** If parameter iCol is less than zero, set output variable *pnToken
12813 ** to the total number of tokens in the FTS5 table. Or, if iCol is
12815 ** the total number of tokens in column iCol, considering all rows in
12818 ** If parameter iCol is greater than or equal to the number of columns
12826 ** xColumnSize(pFts, iCol, pnToken):
12827 ** If parameter iCol is less than zero, set output variable *pnToken
12828 ** to the total number of tokens in the current row. Or, if iCol is
12830 ** *pnToken to the number of tokens in column iCol of the current row.
12832 ** If parameter iCol is greater than or equal to the number of columns
12841 ** This function attempts to retrieve the text of column iCol of the
12962 ** int iCol, iOff;
12963 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
12964 ** iCol>=0;
12965 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
12967 ** // An instance of phrase iPhrase at offset iOff of column iCol
12979 ** through an empty set (all calls to xPhraseFirst() set iCol to -1).
12992 ** int iCol;
12993 ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
12994 ** iCol>=0;
12995 ** pApi->xPhraseNextColumn(pFts, &iter, &iCol)
12997 ** // Column iCol contains at least one instance of phrase iPhrase
13004 ** xPhraseFirstColumn() set iCol to -1).
13022 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
13037 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
13038 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
78262 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
78273 int iCol, /* Column to extract */
78285 assert( iCol>0 );
78289 for(i=0; i<=iCol; i++){
84677 ** Check to see if column iCol of the given statement is valid. If
84679 ** If iCol is not valid, return a pointer to a Mem which has a value
94264 u16 iCol; /* Table column this handle is open on */
94314 u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
94315 testcase( pC->nHdrParsed==p->iCol );
94316 testcase( pC->nHdrParsed==p->iCol+1 );
94325 p->iOffset = pC->aType[p->iCol + pC->nField];
94365 int iCol; /* Index of zColumn in row-record */
94425 for(iCol=0; iCol<pTab->nCol; iCol++) {
94426 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
94430 if( iCol==pTab->nCol ){
94454 if( pFKey->aCol[j].iFrom==iCol ){
94465 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
94560 pBlob->iCol = iCol;
98677 ** Turn the pExpr expression into an alias for the iCol-th column of the
98698 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
98702 Expr *pOrig; /* The iCol-th column of the result set */
98706 assert( iCol>=0 && iCol<pEList->nExpr );
98707 pOrig = pEList->a[iCol].pExpr;
99033 int iCol;
99037 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
99039 if( iCol==pTab->iPKey ){
99040 iCol = -1;
99045 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
99047 iCol = -1;
99049 if( iCol<pTab->nCol ){
99054 testcase( iCol==(-1) );
99056 pExpr->iColumn = iCol;
99061 sqlite3TableColumnToStorage(pTab, iCol);
99071 sqlite3TableColumnToStorage(pTab, iCol) + 1;
99073 pExpr->iColumn = (i16)iCol;
99076 if( iCol<0 ){
99079 testcase( iCol==31 );
99080 testcase( iCol==32 );
99081 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
99083 testcase( iCol==31 );
99084 testcase( iCol==32 );
99085 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
99299 ** Allocate and return a pointer to an expression to load the column iCol
99302 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
99308 if( p->y.pTab->iPKey==iCol ){
99311 p->iColumn = (ynVar)iCol;
99313 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
99319 testcase( iCol==BMS );
99320 testcase( iCol==BMS-1 );
99321 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
99976 int iCol = -1;
99981 if( sqlite3ExprIsInteger(pE, &iCol) ){
99982 if( iCol<=0 || iCol>pEList->nExpr ){
99987 iCol = resolveAsName(pParse, pEList, pE);
99988 if( iCol==0 ){
100009 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
100016 if( iCol>0 ){
100017 /* Convert the ORDER BY term into an integer column number iCol,
100023 pNew->u.iValue = iCol;
100034 pItem->u.x.iOrderByCol = (u16)iCol;
100148 int iCol; /* Column number */
100161 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
100162 if( iCol>0 ){
100164 ** a copy of the iCol-th result-set column. The subsequent call to
100166 ** copy of the iCol-th result-set expression. */
100167 pItem->u.x.iOrderByCol = (u16)iCol;
100171 if( sqlite3ExprIsInteger(pE2, &iCol) ){
100175 if( iCol<1 || iCol>0xffff ){
100179 pItem->u.x.iOrderByCol = (u16)iCol;
100676 SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table *pTab, int iCol){
100677 assert( iCol<pTab->nCol );
100678 return iCol>=0 ? pTab->aCol[iCol].affinity : SQLITE_AFF_INTEGER;
103282 int iCol = pEList->a[i].pExpr->iColumn;
103283 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
104217 ** Generate code to extract the value of the iCol-th column of a table.
104223 int iCol, /* Index of the column to extract */
104229 sqlite3VdbeAddOp3(v, OP_Column, iTabCur, iCol, regOut);
104232 if( iCol<0 || iCol==pTab->iPKey ){
104239 x = iCol;
104241 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
104256 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
104257 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
104260 x = sqlite3TableColumnToStorage(pTab,iCol);
104261 testcase( x!=iCol );
104265 sqlite3ColumnDefault(v, pTab, iCol, regOut);
104564 int iCol = pExpr->iColumn;
104566 assert( iCol>=XN_ROWID );
104567 assert( iCol<pTab->nCol );
104568 if( iCol<0 ){
104571 pCol = pTab->aCol + iCol;
104572 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
104573 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
105044 int iCol = pExpr->iColumn;
105046 + sqlite3TableColumnToStorage(pTab, iCol);
105049 assert( iCol>=-1 && iCol<pTab->nCol );
105050 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
105056 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName)
105065 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
107330 int iCol; /* Index of column being renamed */
107358 ** altered. Set iCol to be the index of the column being renamed */
107361 for(iCol=0; iCol<pTab->nCol; iCol++){
107362 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break;
107364 if( iCol==pTab->nCol ){
107385 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
107393 zDb, pTab->zName, iCol, zNew, bQuote
107438 int iCol; /* Index of column being renamed */
107702 && pExpr->iColumn==p->iCol
107707 && pExpr->iColumn==p->iCol
108104 ** sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld)
108111 ** 5. iCol: Index of column to rename
108117 ** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
108134 int iCol = sqlite3_value_int(argv[5]);
108153 if( iCol<0 ) return;
108156 if( pTab==0 || iCol>=pTab->nCol ){
108160 zOld = pTab->aCol[iCol].zName;
108162 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
108197 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName
108199 if( sCtx.iCol<0 ){
108218 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
108570 int iCol = sqlite3_value_int(argv[2]);
108588 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
108594 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zName);
108595 if( iCol<pTab->nCol-1 ){
108597 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zName);
108632 int iCol; /* Index of column zCol in pTab->aCol[] */
108652 iCol = sqlite3ColumnIndex(pTab, zCol);
108653 if( iCol<0 ){
108660 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
108662 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
108683 , zDb, iDb, iCol, pTab->zName
108691 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
108717 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
108721 int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
109044 int iCol; /* If !isPSample, the reason for inclusion */
109116 pTo->iCol = pFrom->iCol;
109243 p->aBest[i].iCol = i;
109269 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
109276 ** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid.
109285 assert( pNew->iCol==pOld->iCol );
109286 for(i=pNew->iCol+1; i<nCol; i++){
109300 ** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid.
109307 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
109308 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
109311 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
109315 if( pNew->iCol<pOld->iCol ) return 1;
109316 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
109340 assert( pNew->anEq[pNew->iCol]>0 );
109343 ** iCol occurs many times in the table. However, if we have already
109349 if( pOld->anEq[pNew->iCol]==0 ){
109351 assert( pOld->iCol>pNew->iCol );
109359 pUpgrade->iCol = pNew->iCol;
109360 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
109524 p->current.iCol = 0;
109531 p->current.iCol = i;
110407 int iCol;
110417 for(iCol=0; iCol<nCol; iCol++){
110426 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
110427 nRow = pFinal->anLt[iCol];
110428 nDist100 = (i64)100 * pFinal->anDLt[iCol];
110432 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
110436 /* Set nSum to the number of distinct (iCol+1) field prefixes that
110438 ** the nEq values for column iCol for the same set (adding the value
110442 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
110444 sumEq += aSample[i].anEq[iCol];
110453 pIdx->aAvgEq[iCol] = avgEq;
111458 int iCol; /* Index of column in table */
111481 iCol = pExpr->iColumn;
111484 if( iCol>=0 ){
111485 assert( iCol<pTab->nCol );
111486 zCol = pTab->aCol[iCol].zName;
112538 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
112540 ** if column iCol is not used in index pIdx.
112542 SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
112545 if( iCol==pIdx->aiColumn[i] ) return i;
112562 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
112565 for(i=0; i<=iCol; i++){
112566 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
112569 return iCol;
112607 ** columns, then this routine is no-op that always return iCol. If iCol
112608 ** is negative (indicating the ROWID column) then this routine return iCol.
112610 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
112613 assert( iCol<pTab->nCol );
112614 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
112615 for(i=0, n=0; i<iCol; i++){
112619 /* iCol is a virtual column itself */
112622 /* iCol is a normal or stored column */
113239 int iCol = -1, i;
113249 iCol = pTab->nCol - 1;
113250 pCol = &pTab->aCol[iCol];
113261 for(iCol=0; iCol<pTab->nCol; iCol++){
113262 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
113263 pCol = &pTab->aCol[iCol];
113280 pTab->iPKey = iCol;
113644 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
113655 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
113658 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
113663 j = pPk->aiColumn[iCol];
113668 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
114879 int iCol = p->nCol-1;
114880 if( NEVER(iCol<0) ) goto fk_end;
114884 p->aCol[iCol].zName, pTo);
118177 int iCol; /* Iterator used while populating OLD.* */
118192 for(iCol=0; iCol<pTab->nCol; iCol++){
118193 testcase( mask!=0xffffffff && iCol==31 );
118194 testcase( mask!=0xffffffff && iCol==32 );
118195 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
118196 int kk = sqlite3TableColumnToStorage(pTab, iCol);
118197 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
120964 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
120968 if( iCol<0 ) break; /* No foreign keys against expression indexes */
120973 zDfltColl = pParent->aCol[iCol].zColl;
120977 zIdxCol = pParent->aCol[iCol].zName;
121178 ** to column iCol of table pTab.
121188 i16 iCol /* Which column of pTab is desired */
121197 if( iCol>=0 && iCol!=pTab->iPKey ){
121198 pCol = &pTab->aCol[iCol];
121199 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
121213 ** Return an Expr object that refers to column iCol of table pTab which
121220 i16 iCol /* The column that is wanted */
121226 pExpr->iColumn = iCol;
121303 i16 iCol; /* Index of column in child table */
121306 iCol = pIdx ? pIdx->aiColumn[i] : -1;
121307 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
121308 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
121309 assert( iCol>=0 );
121310 zCol = pFKey->pFrom->aCol[iCol].zName;
121342 i16 iCol = pIdx->aiColumn[i];
121343 assert( iCol>=0 );
121344 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
121345 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName);
121614 int iCol;
121662 iCol = pFKey->aCol[0].iFrom;
121663 aiCol = &iCol;
125444 const void * (*column_blob)(sqlite3_stmt*,int iCol);
125445 int (*column_bytes)(sqlite3_stmt*,int iCol);
125446 int (*column_bytes16)(sqlite3_stmt*,int iCol);
125452 double (*column_double)(sqlite3_stmt*,int iCol);
125453 int (*column_int)(sqlite3_stmt*,int iCol);
125454 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
125461 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
125462 const void * (*column_text16)(sqlite3_stmt*,int iCol);
125463 int (*column_type)(sqlite3_stmt*,int iCol);
125464 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
129011 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
129012 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
129288 int iCol = pIdx->aiColumn[kk];
129289 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
129290 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
131455 int iCol; /* Index of column matching zCol */
131459 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
131460 if( iCol>=0
131461 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
131465 *piCol = iCol;
132617 int iCol;
132676 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
132680 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
132684 int iKey = iCol+1;
132724 iRead = iCol--;
132853 int iCol = pExpr->iColumn; /* Index of column in pTab */
132892 if( iCol>=0 && iCol<pS->pEList->nExpr ){
132893 /* If iCol is less than zero, then the expression requests the
132898 Expr *p = pS->pEList->a[iCol].pExpr;
132908 if( iCol<0 ) iCol = pTab->iPKey;
132909 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
132910 if( iCol<0 ){
132914 zOrigCol = pTab->aCol[iCol].zName;
132915 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
132923 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
132924 if( iCol<0 ){
132927 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
133078 int iCol = p->iColumn;
133081 if( iCol<0 ) iCol = pTab->iPKey;
133082 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
133083 if( iCol<0 ){
133086 zCol = pTab->aCol[iCol].zName;
133169 int iCol = pColExpr->iColumn;
133170 if( iCol<0 ) iCol = pTab->iPKey;
133171 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
133400 ** Return the appropriate collating sequence for the iCol-th column of
133407 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
133410 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
133414 assert( iCol>=0 );
133415 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
133418 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
133419 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
140008 ** Check to see if column iCol of index pIdx references any of the
140020 int iCol, /* Which column of the index to check */
140024 i16 iIdxCol = pIdx->aiColumn[iCol];
140031 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
140032 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
140060 ** Expr.iColumn set to value (iCol+1). The resolver will modify the
140061 ** expression to be a TK_COLUMN reading column iCol of the first
140064 static Expr *exprRowColumn(Parse *pParse, int iCol){
140066 if( pRet ) pRet->iColumn = iCol+1;
140958 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
142603 int iCol;
142613 for(iCol=0; iCol<pTab->nCol; iCol++){
142614 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
142636 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
144499 int iCol = aiMap ? aiMap[iMap++] : 0;
144500 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
146126 int iCol = pPk->aiColumn[iPk];
146127 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
146609 int iCol = pRight->iColumn;
146610 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
146614 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
148784 ** This function searches pList for an entry that matches the iCol-th column
148795 int iCol /* Column of index to match */
148798 const char *zColl = pIdx->azColl[iCol];
148804 && p->iColumn==pIdx->aiColumn[iCol]
148818 ** Return TRUE if the iCol-th column of index pIdx is NOT NULL
148820 static int indexColumnNotNull(Index *pIdx, int iCol){
148823 assert( iCol>=0 && iCol<pIdx->nColumn );
148824 j = pIdx->aiColumn[iCol];
149093 int iCol = pTerm->u.x.leftColumn;
149094 Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
149095 testcase( iCol==BMS );
149096 testcase( iCol==BMS-1 );
149100 pTable->aCol[iCol].zName);
149146 int iCol = pTerm->u.x.leftColumn;
149147 Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
149148 testcase( iCol==BMS-1 );
149149 testcase( iCol==BMS );
149443 int iCol; /* Index of required stats in anEq[] etc. */
149504 iCol = 0;
149534 iCol = n-1;
149547 assert( iCol==nField-1 );
149555 ** (iCol+1) field prefix of sample i. */
149557 pRec->nField = iCol+1;
149562 /* if i==0 and iCol==0, then record pRec is smaller than all samples
149563 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
149564 ** be greater than or equal to the (iCol) field prefix of sample i.
149566 if( iCol>0 ){
149567 pRec->nField = iCol;
149582 assert( iCol==nField-1 );
149583 aStat[0] = aSample[i].anLt[iCol];
149584 aStat[1] = aSample[i].anEq[iCol];
149586 /* At this point, the (iCol+1) field prefix of aSample[i] is the first
149593 iUpper = aSample[i].anLt[iCol];
149644 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
149645 assert( iCol>=0 && iCol<pIdx->nColumn );
149649 assert( pIdx->zColAff[iCol]!=0 );
149650 return pIdx->zColAff[iCol];
150916 int iCol = pProbe->aiColumn[saved_nEq];
150919 if( iCol==XN_ROWID
150920 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
150922 if( iCol==XN_ROWID || pProbe->uniqNotNull
154727 int iCol = -1;
154732 iCol = i;
154737 if( iCol<0 ){
154751 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
167743 int iCol = 0;
167776 for(iCol=0; iCol<pTab->nCol; iCol++){
167777 pCol = &pTab->aCol[iCol];
167782 if( iCol==pTab->nCol ){
167784 iCol = pTab->iPKey;
167785 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
167808 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
169562 int fts3_global_term_cnt(int iTerm, int iCol);
169563 int fts3_term_cnt(int iTerm, int iCol);
170089 ** aMI[iCol*3 + 0] = Undefined
170090 ** aMI[iCol*3 + 1] = Number of occurrences
170091 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
170189 int iCol;
170277 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
171189 int iCol; /* Column index */
171462 for(iCol=0; iCol<nCol; iCol++){
171465 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
171471 p->azColumn[iCol] = zCsr;
171477 for(iCol=0; iCol<nCol; iCol++){
171478 int n = (int)strlen(p->azColumn[iCol]);
171482 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
171484 p->abNotindexed[iCol] = 1;
172202 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
172203 ** the value of iCol encoded as a varint to *pp. This will start a new
172207 ** returning (do not modify it if iCol==0). Return the total number of bytes
172208 ** written (0 if iCol==0).
172210 static int fts3PutColNumber(char **pp, int iCol){
172212 if( iCol ){
172214 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
172786 sqlite3_int64 iCol;
172788 p += sqlite3Fts3GetVarint(p, &iCol);
172795 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
173185 filter.iCol = iColumn;
173354 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
173366 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
173449 ** (iCol < p->nColumn) -> The value of the iCol'th user column.
173450 ** (iCol == p->nColumn) -> Magic column with the same name as the table.
173451 ** (iCol == p->nColumn+1) -> Docid column
173452 ** (iCol == p->nColumn+2) -> Langid column
173457 int iCol /* Index of column to read value from */
173464 assert( iCol>=0 && iCol<=p->nColumn+2 );
173466 switch( iCol-p->nColumn ){
173485 iCol = p->nColumn;
173493 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
173494 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
173712 int iCol = -1;
173730 case 5: iCol = sqlite3_value_int(apVal[4]);
173743 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
174437 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
174442 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
174858 int iCol; /* The column the token must match */
174886 pTC->iCol = pPhrase->iColumn;
175066 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
175082 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
175730 int iCol = 0;
175741 /* aMI[iCol*3 + 1] = Number of occurrences
175742 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
175744 pExpr->aMI[iCol*3 + 1] += iCnt;
175745 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
175748 p += fts3GetVarint32(p, &iCol);
175749 }while( iCol<nCol );
175863 ** aiOut[iCol*3 + 1] = Number of occurrences
175864 ** aiOut[iCol*3 + 2] = Number of rows containing at least one instance
175887 int iCol;
175891 for(iCol=0; iCol<pTab->nColumn; iCol++){
175892 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
175893 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
175899 for(iCol=0; iCol<pTab->nColumn; iCol++){
175900 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
175901 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
175914 ** a position-list indicating the occurrences of the phrase in column iCol
175931 int iCol, /* Column to return position list for */
175941 ** column iCol, return a NULL pointer. */
175943 assert( iCol>=0 && iCol<pTab->nColumn );
175944 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
176041 while( iThis<iCol ){
176051 *ppOut = ((iCol==iThis)?pIter:0);
176143 int iCol; /* Current value of 'col' column */
176280 int iCol = pInfo->aConstraint[i].iColumn;
176282 if( iCol==0 ){
176289 if( iCol==4 ){
176380 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
176381 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
176389 int iCol;
176404 iCol = 0;
176415 iCol = 0;
176427 assert( iCol==0 );
176440 pCsr->aStat[iCol+1].nOcc++;
176447 iCol = (int)v;
176448 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
176449 pCsr->aStat[iCol+1].nDoc++;
176455 pCsr->iCol = 0;
176572 int iCol /* Index of column to read value from */
176577 switch( iCol ){
176583 if( p->iCol ){
176584 sqlite3_result_int(pCtx, p->iCol-1);
176591 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
176595 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
176599 assert( iCol==4 );
176837 int iCol, /* Value for Fts3Phrase.iColumn */
176872 pRet->pPhrase->iColumn = iCol;
177070 int iCol;
177182 iCol = pParse->iDefaultCol;
177190 iCol = ii;
177195 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
180147 int iCol /* Index of column to read value from */
180152 switch( iCol ){
180166 assert( iCol==4 );
180340 int iCol; /* Column token must occur in */
180916 sqlite3_int64 iCol, /* Column for entry to add */
180939 if( iCol>0 && p->iLastCol!=iCol ){
180941 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
180945 p->iLastCol = iCol;
180948 if( iCol>=0 ){
180977 int iCol,
180990 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
181009 ** p->iPrevDocid, and the column is specified by argument iCol.
181017 int iCol, /* Column into which text is being inserted */
181067 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
181076 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
181153 int iCol = i-2;
181154 if( p->abNotindexed[iCol]==0 ){
181156 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
181309 int iCol = i-1;
181310 if( p->abNotindexed[iCol]==0 ){
181312 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
182829 ** identify the subset of the position list that corresponds to column iCol.
182831 ** If there are no entries in the input position list for column iCol, then
182838 int iCol, /* Column to filter on */
182849 assert( iCol>=0 );
182854 if( iCol==iCurrent ){
183012 int iCol, /* Column to match on. */
183046 assert( iCol<0 || iCol<p->nColumn );
183047 pCsr->iColFilter = iCol;
183213 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
183290 ** Decode the "end_block" field, selected by column iCol of the SELECT
183301 int iCol,
183305 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
183804 int iCol;
183808 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
183809 if( p->abNotindexed[iCol]==0 ){
183810 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
183811 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
183812 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
183823 for(iCol=0; iCol<=p->nColumn; iCol++){
183824 aSzIns[iCol] += aSz[iCol];
185391 int iCol, /* Column number */
185399 ret += (ret<<3) + iCol;
185446 i64 iCol = 0;
185455 iCol = 0;
185458 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
185471 (int)iCol, (int)iPos
185533 int iCol;
185535 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
185536 if( p->abNotindexed[iCol]==0 ){
185537 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
185551 zToken, nToken, iLang, 0, iDocid, iCol, iPos
185556 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
185730 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
185787 int iCol /* Column that token must appear in (or -1) */
185797 pDeferred->iCol = iCol;
186085 int iCol; /* Extract snippet from this column */
186102 int iCol; /* Column snippet is extracted from */
186500 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
186525 ** from column iCol that represent the "best" snippet. The best snippet
186541 int iCol, /* Index of column to create snippet from */
186578 sIter.iCol = iCol;
186595 pFragment->iCol = iCol;
186761 int iCol = pFragment->iCol+1; /* Query column to extract text from */
186765 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
186767 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
186772 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
186895 int iCol = 0;
186906 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
186908 p->aMatchinfo[iStart + iCol] = (u32)nHit;
186910 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
186916 pIter += fts3GetVarint32(pIter, &iCol);
186917 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
186954 ** for(iCol=0; iCol<nCol; iCol++){
186955 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
186956 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
186959 ** where X is the number of matches for phrase iPhrase is column iCol of all
186960 ** rows of the table. Y is the number of rows for which column iCol contains
187115 ** If LcsIterator.iCol is set to the following value, the iterator has
187166 int iCol;
187184 for(iCol=0; iCol<pInfo->nCol; iCol++){
187190 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
187227 pInfo->aMatchinfo[iCol] = nLcs;
187290 int iCol;
187291 for(iCol=0; iCol<pInfo->nCol; iCol++){
187300 pInfo->aMatchinfo[iCol] = iVal;
187310 int iCol;
187313 for(iCol=0; iCol<pInfo->nCol; iCol++){
187320 pInfo->aMatchinfo[iCol] = (u32)nToken;
187465 int iCol, /* Extract snippet from this column */
187514 ** If the iCol argument to this function was negative, this means all
187515 ** columns of the FTS3 table. Otherwise, only column iCol is considered.
187520 if( iCol>=0 && iRead!=iCol ) continue;
187573 int iCol; /* Column of table to populate aTerm for */
187591 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
187619 int iCol; /* Column currently being processed */
187647 for(iCol=0; iCol<pTab->nColumn; iCol++){
187657 /* Initialize the contents of sCtx.aTerm[] for column iCol. There is
187661 sCtx.iCol = iCol;
187665 /* Retreive the text stored in column iCol. If an SQL NULL is stored
187666 ** in column iCol, jump immediately to the next iteration of the loop.
187671 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
187672 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
187674 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
187681 /* Initialize a tokenizer iterator to iterate through column iCol. */
187717 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
190919 int iCol;
190922 iCol = pConstraint->iColumn - JEACH_JSON;
190923 assert( iCol==0 || iCol==1 );
190924 iMask = 1 << iCol;
190928 aIdx[iCol] = i;
194336 ** Parameter iCol is the index of the leftmost column involved in the
194339 ** (c1<=c2) constraint on columns iCol and iCol+1 that has failed.
194343 static int rtreeConstraintError(Rtree *pRtree, int iCol){
194348 assert( iCol==0 || iCol%2 );
194358 if( iCol==0 ){
194364 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
194365 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
200557 int iCol = 0;
200589 zOrder, zSep, iCol, zCol, zCollate
200592 zSelect, zSep, iCol, zCol
200595 iCol++;
200610 for(iCol=0; iCol<pIter->nCol; iCol++){
200611 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
201095 int iCol;
201098 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
201100 const char *zCol = pIter->azTblCol[iCol];
201107 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
201113 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
201114 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
202250 int iCol = p->objiter.nCol; /* Index of rbu_control column */
202253 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
202255 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
202267 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
202290 ** Assert that column iCol of statement pStmt is named zName.
202292 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
202293 const char *zCol = sqlite3_column_name(pStmt, iCol);
206226 int iCol; /* Used to iterate through table columns */
206228 for(iCol=0; iCol<pTab->nCol; iCol++){
206229 if( pTab->abPK[iCol] ){
206269 int iCol; /* Used to iterate from 0 to nCol */
206271 for(iCol=0; iCol<nCol; iCol++){
206423 int iCol; /* Used to iterate through columns */
206427 for(iCol=0; iCol<pTab->nCol; iCol++){
206428 if( !pTab->abPK[iCol] ){
206442 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
206445 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
206713 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
206716 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
206717 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
206723 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
206726 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
206727 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
207595 ** in column iCol of the row that SQL statement pStmt currently points
207601 int iCol, /* Column to read value from */
207605 int eType = sqlite3_column_type(pStmt, iCol);
207611 i = sqlite3_column_int64(pStmt, iCol);
207613 double r = sqlite3_column_double(pStmt, iCol);
207623 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
207625 z = (u8 *)sqlite3_column_text(pStmt, iCol);
207627 nByte = sqlite3_column_bytes(pStmt, iCol);
208029 int iCol;
208032 for(iCol=0; iCol<nCol; iCol++){
208033 sessionAppendCol(&buf, pSel, iCol, &rc);
209000 int iCol;
209025 for(iCol=0; iCol<nCol; iCol++){
209026 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
209033 for(iCol=0; iCol<nCol; iCol++){
209034 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
209038 for(iCol=0; iCol<nCol*2; iCol++){
209039 sqlite3ValueFree(apVal[iCol]);
211258 ** xColumnTotalSize(pFts, iCol, pnToken):
211259 ** If parameter iCol is less than zero, set output variable *pnToken
211260 ** to the total number of tokens in the FTS5 table. Or, if iCol is
211262 ** the total number of tokens in column iCol, considering all rows in
211265 ** If parameter iCol is greater than or equal to the number of columns
211273 ** xColumnSize(pFts, iCol, pnToken):
211274 ** If parameter iCol is less than zero, set output variable *pnToken
211275 ** to the total number of tokens in the current row. Or, if iCol is
211277 ** *pnToken to the number of tokens in column iCol of the current row.
211279 ** If parameter iCol is greater than or equal to the number of columns
211288 ** This function attempts to retrieve the text of column iCol of the
211409 ** int iCol, iOff;
211410 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
211411 ** iCol>=0;
211412 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
211414 ** // An instance of phrase iPhrase at offset iOff of column iCol
211426 ** through an empty set (all calls to xPhraseFirst() set iCol to -1).
211439 ** int iCol;
211440 ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
211441 ** iCol>=0;
211442 ** pApi->xPhraseNextColumn(pFts, &iter, &iCol)
211444 ** // Column iCol contains at least one instance of phrase iPhrase
211451 ** xPhraseFirstColumn() set iCol to -1).
211469 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
211484 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
211485 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
212078 i64 iPos; /* (iCol<<32) + iPos */
212159 int iCol,
212220 ** unique token in the document with an iCol value less than zero. The iPos
212225 int iCol, /* Column token appears in (-ve -> delete) */
212359 int iCol, /* Column token appears in (-ve -> delete) */
212423 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
212463 int iCol, /* Column on LHS of MATCH operator */
212471 int iCol,
214141 ** for(rc = fts5CInstIterNext(pApi, pFts, iCol, &iter);
214153 int iCol; /* Column to search */
214175 if( ic==pIter->iCol ){
214195 ** iterate through coalesced phrase instances in column iCol.
214200 int iCol,
214208 pIter->iCol = iCol;
214324 int iCol;
214332 iCol = sqlite3_value_int(apVal[0]);
214336 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
214340 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
214435 int iCol, /* Column to score */
214455 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
214496 int iCol; /* 1st argument to snippet() */
214518 iCol = sqlite3_value_int(apVal[0]);
214524 iBestCol = (iCol>=0 ? iCol : 0);
214536 if( iCol<0 || iCol==i ){
216413 int iCol,
216441 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
216446 pColset->aiCol[0] = iCol;
216486 ** against column iCol. This function creates and compiles an FTS5 MATCH
216492 Fts5Config *pConfig, int bGlob, int iCol, const char *zText, Fts5Expr **pp
216544 iCol = pConfig->nCol;
216548 rc = sqlite3Fts5ExprNew(pConfig, bAnd, iCol, zExpr, pp,pConfig->pzErrmsg);
218142 ** number iCol appended.
218150 int iCol /* New column to add to colset object */
218156 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
218165 if( aiCol[i]==iCol ) return pNew;
218166 if( aiCol[i]>iCol ) break;
218171 aiCol[i] = iCol;
218217 int iCol;
218224 for(iCol=0; iCol<pConfig->nCol; iCol++){
218225 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
218227 if( iCol==pConfig->nCol ){
218230 pRet = fts5ParseColset(pParse, pColset, iCol);
219078 static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
219081 if( pColset->aiCol[i]==iCol ) return 1;
219125 int iCol,
219132 sCtx.iOff = (((i64)iCol) << 32) - 1;
219137 if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
219316 i16 iCol; /* Column of last value written */
219482 ** of bByte and (pToken/nToken). The value is (iRowid/iCol/iPos).
219484 ** (bByte || pToken) -> (iRowid,iCol,iPos)
219486 ** Or, if iCol is negative, then the value is a delete marker.
219491 int iCol, /* Column token appears in (-ve -> delete) */
219553 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
219596 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
219601 if( iCol>=0 ){
219606 assert( iCol>=p->iCol );
219607 if( iCol!=p->iCol ){
219610 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
219611 p->iCol = (i16)iCol;
219615 p->iCol = (i16)(iPos = iCol);
222780 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
222783 if( pColset->aiCol[i]==iCol ) return 1;
222826 int iCol;
222827 fts5FastGetVarint32(pChunk, i, iCol);
222828 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
222845 int iCol;
222851 fts5FastGetVarint32(pChunk, i, iCol);
222852 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
225241 ** unique token in the document with an iCol value less than zero. The iPos
225246 int iCol, /* Column token appears in (-ve -> delete) */
225255 assert( (iCol<0)==p->bDelete );
225259 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
225267 p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
225442 int iCol;
225444 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
225445 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
225517 int iCol,
225525 ret += (ret<<3) + iCol;
225601 int iCol = FTS5_POS2COLUMN(sReader.iPos);
225603 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
226012 int iCol = FTS5_POS2COLUMN(iPos);
226014 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
227101 int iCol = p->iColumn;
227103 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
227106 if( p->usable==0 || iCol<0 ){
227114 if( iCol==nCol+1 ){
227118 }else if( iCol>=0 ){
227121 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
227129 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
227132 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
227136 }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
227738 int iCol; /* Column on LHS of MATCH operator */
227776 iCol = 0;
227778 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
227790 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
227804 iCol = 0;
227806 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
227810 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
228314 int iCol,
228319 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
228353 int iCol,
228367 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
228368 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
228558 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
228593 if( iCol<0 ){
228599 }else if( iCol<pConfig->nCol ){
228600 *pnToken = pCsr->aColumnSize[iCol];
228987 int iCol /* Index of column to read value from */
228997 if( iCol==pConfig->nCol ){
229002 if( iCol==pConfig->nCol ){
229008 }else if( iCol==pConfig->nCol+1 ){
229025 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
229802 int iCol;
229824 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
229841 int iCol;
229854 ctx.iCol = -1;
229856 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
229857 if( pConfig->abUnindexed[iCol-1]==0 ){
229861 zText = (const char*)sqlite3_column_text(pSeek, iCol);
229862 nText = sqlite3_column_bytes(pSeek, iCol);
229864 zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
229865 nText = sqlite3_value_bytes(apVal[iCol-1]);
229871 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
229872 if( p->aTotalSize[iCol-1]<0 ){
230060 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
230062 if( pConfig->abUnindexed[ctx.iCol]==0 ){
230063 const char *zText = (const char*)sqlite3_column_text(pScan, ctx.iCol+1);
230064 int nText = sqlite3_column_bytes(pScan, ctx.iCol+1);
230073 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
230186 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
230188 if( pConfig->abUnindexed[ctx.iCol]==0 ){
230189 const char *zText = (const char*)sqlite3_value_text(apVal[ctx.iCol+2]);
230190 int nText = sqlite3_value_bytes(apVal[ctx.iCol+2]);
230199 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
230243 int iCol;
230268 int iCol;
230280 iCol = pCtx->iCol;
230284 iPos = pCtx->iCol;
230285 iCol = 0;
230291 iCol = 0;
230298 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
230309 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
230361 ctx.iCol = i;
230520 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
230524 if( iCol<0 ){
230529 }else if( iCol<p->pConfig->nCol ){
230530 *pnToken = p->aTotalSize[iCol];
233210 int iCol;
233625 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
233626 if( pCsr->aDoc[pCsr->iCol] ) break;
233630 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
233651 pCsr->iCol = 0;
233675 int iCol = -1;
233678 if( iCol!=ii ){
233684 iCol = ii;
233727 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
233728 if( pCsr->iCol==nCol ){
233817 int iCol /* Index of column to read value from */
233824 if( iCol==0 ){
233829 assert( iCol==1 || iCol==2 || iCol==3 );
233830 if( iCol==1 ){
233832 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
233835 }else if( iCol==2 ){
233836 iVal = pCsr->aDoc[pCsr->iCol];
233838 iVal = pCsr->aCnt[pCsr->iCol];
233841 assert( iCol==1 || iCol==2 );
233842 if( iCol==1 ){
233849 switch( iCol ){
233867 assert( iCol==3 );