Lines Matching refs:iCol
5453 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
5454 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
5455 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
5456 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
5457 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
5458 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
5459 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
5460 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
5461 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
5462 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
7470 ** set. In other words, column iCol may be required if the expression
7471 ** (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to
12753 ** xColumnTotalSize(pFts, iCol, pnToken):
12754 ** If parameter iCol is less than zero, set output variable *pnToken
12755 ** to the total number of tokens in the FTS5 table. Or, if iCol is
12757 ** the total number of tokens in column iCol, considering all rows in
12760 ** If parameter iCol is greater than or equal to the number of columns
12768 ** xColumnSize(pFts, iCol, pnToken):
12769 ** If parameter iCol is less than zero, set output variable *pnToken
12770 ** to the total number of tokens in the current row. Or, if iCol is
12772 ** *pnToken to the number of tokens in column iCol of the current row.
12774 ** If parameter iCol is greater than or equal to the number of columns
12783 ** This function attempts to retrieve the text of column iCol of the
12904 ** int iCol, iOff;
12905 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
12906 ** iCol>=0;
12907 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
12909 ** // An instance of phrase iPhrase at offset iOff of column iCol
12921 ** through an empty set (all calls to xPhraseFirst() set iCol to -1).
12934 ** int iCol;
12935 ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
12936 ** iCol>=0;
12937 ** pApi->xPhraseNextColumn(pFts, &iter, &iCol)
12939 ** // Column iCol contains at least one instance of phrase iPhrase
12946 ** xPhraseFirstColumn() set iCol to -1).
12964 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
12979 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
12980 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
82416 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
82427 int iCol, /* Column to extract */
82439 assert( iCol>0 );
82443 for(i=0; i<=iCol; i++){
89059 ** Check to see if column iCol of the given statement is valid. If
89061 ** If iCol is not valid, return a pointer to a Mem which has a value
99285 u16 iCol; /* Table column this handle is open on */
99338 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
99339 testcase( pC->nHdrParsed==p->iCol );
99340 testcase( pC->nHdrParsed==p->iCol+1 );
99349 p->iOffset = pC->aType[p->iCol + pC->nField];
99389 int iCol; /* Index of zColumn in row-record */
99448 for(iCol=0; iCol<pTab->nCol; iCol++) {
99449 if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){
99453 if( iCol==pTab->nCol ){
99478 if( pFKey->aCol[j].iFrom==iCol ){
99489 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
99584 pBlob->iCol = iCol;
99687 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
103725 ** Turn the pExpr expression into an alias for the iCol-th column of the
103746 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
103750 Expr *pOrig; /* The iCol-th column of the result set */
103754 assert( iCol>=0 && iCol<pEList->nExpr );
103755 pOrig = pEList->a[iCol].pExpr;
104142 int iCol;
104146 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
104150 if( iCol==pTab->iPKey ){
104151 iCol = -1;
104156 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
104158 iCol = -1;
104160 if( iCol<pTab->nCol ){
104165 testcase( iCol==(-1) );
104168 pExpr->iColumn = iCol;
104173 sqlite3TableColumnToStorage(pTab, iCol);
104185 sqlite3TableColumnToStorage(pTab, iCol) + 1;
104187 pExpr->iColumn = (i16)iCol;
104190 if( iCol<0 ){
104193 testcase( iCol==31 );
104194 testcase( iCol==32 );
104195 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
104197 testcase( iCol==31 );
104198 testcase( iCol==32 );
104199 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
104435 ** Allocate and return a pointer to an expression to load the column iCol
104438 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
104446 if( p->y.pTab->iPKey==iCol ){
104449 p->iColumn = (ynVar)iCol;
104451 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
104457 testcase( iCol==BMS );
104458 testcase( iCol==BMS-1 );
104459 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
105137 int iCol = -1;
105142 if( sqlite3ExprIsInteger(pE, &iCol) ){
105143 if( iCol<=0 || iCol>pEList->nExpr ){
105148 iCol = resolveAsName(pParse, pEList, pE);
105149 if( iCol==0 ){
105164 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
105165 if( IN_RENAME_OBJECT && iCol>0 ){
105172 if( iCol>0 ){
105173 /* Convert the ORDER BY term into an integer column number iCol,
105179 pNew->u.iValue = iCol;
105190 pItem->u.x.iOrderByCol = (u16)iCol;
105304 int iCol; /* Column number */
105317 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
105318 if( iCol>0 ){
105320 ** a copy of the iCol-th result-set column. The subsequent call to
105322 ** copy of the iCol-th result-set expression. */
105323 pItem->u.x.iOrderByCol = (u16)iCol;
105327 if( sqlite3ExprIsInteger(pE2, &iCol) ){
105331 if( iCol<1 || iCol>0xffff ){
105335 pItem->u.x.iOrderByCol = (u16)iCol;
105837 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
105838 if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER;
105839 return pTab->aCol[iCol].affinity;
108630 int iCol = pEList->a[i].pExpr->iColumn;
108631 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
109591 ** Generate code to extract the value of the iCol-th column of a table.
109597 int iCol, /* Index of the column to extract */
109603 if( iCol<0 || iCol==pTab->iPKey ){
109611 x = iCol;
109613 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
109629 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
109630 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
109633 x = sqlite3TableColumnToStorage(pTab,iCol);
109634 testcase( x!=iCol );
109638 sqlite3ColumnDefault(v, pTab, iCol, regOut);
109999 int iCol = pExpr->iColumn;
110003 assert( iCol>=XN_ROWID );
110004 assert( iCol<pTab->nCol );
110005 if( iCol<0 ){
110008 pCol = pTab->aCol + iCol;
110009 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
110010 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
110495 int iCol;
110500 iCol = pExpr->iColumn;
110502 + sqlite3TableColumnToStorage(pTab, iCol);
110505 assert( iCol>=-1 && iCol<pTab->nCol );
110506 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
110512 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
110521 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
112925 int iCol; /* Index of column being renamed */
112953 ** altered. Set iCol to be the index of the column being renamed */
112956 for(iCol=0; iCol<pTab->nCol; iCol++){
112957 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
112959 if( iCol==pTab->nCol ){
112983 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
112991 zDb, pTab->zName, iCol, zNew, bQuote
113036 int iCol; /* Index of column being renamed */
113337 && pExpr->iColumn==p->iCol
113342 && pExpr->iColumn==p->iCol
113773 ** 5. iCol: Index of column to rename
113779 ** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
113797 int iCol = sqlite3_value_int(argv[5]);
113816 if( iCol<0 ) return;
113819 if( pTab==0 || iCol>=pTab->nCol ){
113823 zOld = pTab->aCol[iCol].zCnName;
113825 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
113858 if( iCol<sParse.pNewTable->nCol ){
113860 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
113863 if( sCtx.iCol<0 ){
113885 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
114394 int iCol = sqlite3_value_int(argv[2]);
114412 if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){
114418 pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName);
114419 if( iCol<pTab->nCol-1 ){
114421 pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName);
114457 int iCol; /* Index of column zCol in pTab->aCol[] */
114477 iCol = sqlite3ColumnIndex(pTab, zCol);
114478 if( iCol<0 ){
114485 if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){
114487 (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE",
114515 , zDb, iDb, iCol, pTab->zName
114523 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
114549 if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
114553 int iColPos = sqlite3TableColumnToIndex(pPk, iCol);
114883 int iCol; /* If !isPSample, the reason for inclusion */
114955 pTo->iCol = pFrom->iCol;
115081 p->aBest[i].iCol = i;
115107 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
115114 ** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid.
115123 assert( pNew->iCol==pOld->iCol );
115124 for(i=pNew->iCol+1; i<nCol; i++){
115138 ** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid.
115145 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
115146 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
115149 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
115153 if( pNew->iCol<pOld->iCol ) return 1;
115154 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
115178 assert( pNew->anEq[pNew->iCol]>0 );
115181 ** iCol occurs many times in the table. However, if we have already
115187 if( pOld->anEq[pNew->iCol]==0 ){
115189 assert( pOld->iCol>pNew->iCol );
115197 pUpgrade->iCol = pNew->iCol;
115198 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
115362 p->current.iCol = 0;
115369 p->current.iCol = i;
116234 int iCol;
116244 for(iCol=0; iCol<nCol; iCol++){
116253 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
116254 nRow = pFinal->anLt[iCol];
116255 nDist100 = (i64)100 * pFinal->anDLt[iCol];
116259 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
116263 /* Set nSum to the number of distinct (iCol+1) field prefixes that
116265 ** the nEq values for column iCol for the same set (adding the value
116269 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
116271 sumEq += aSample[i].anEq[iCol];
116280 pIdx->aAvgEq[iCol] = avgEq;
117336 int iCol; /* Index of column in table */
117359 iCol = pExpr->iColumn;
117362 if( iCol>=0 ){
117363 assert( iCol<pTab->nCol );
117364 zCol = pTab->aCol[iCol].zCnName;
118561 ** for the column iCol in the table (as defined by the CREATE TABLE statement)
118563 ** if column iCol is not used in index pIdx.
118565 SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
118568 if( iCol==pIdx->aiColumn[i] ) return i;
118585 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
118588 for(i=0; i<=iCol; i++){
118589 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
118592 return iCol;
118630 ** columns, then this routine is no-op that always return iCol. If iCol
118631 ** is negative (indicating the ROWID column) then this routine return iCol.
118633 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
118636 assert( iCol<pTab->nCol );
118637 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
118638 for(i=0, n=0; i<iCol; i++){
118642 /* iCol is a virtual column itself */
118645 /* iCol is a normal or stored column */
119313 int iCol = -1, i;
119323 iCol = pTab->nCol - 1;
119324 pCol = &pTab->aCol[iCol];
119337 for(iCol=0; iCol<pTab->nCol; iCol++){
119338 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){
119339 pCol = &pTab->aCol[iCol];
119356 pTab->iPKey = iCol;
119717 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
119728 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
119731 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
119736 j = pPk->aiColumn[iCol];
119741 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
121071 int iCol = p->nCol-1;
121072 if( NEVER(iCol<0) ) goto fk_end;
121076 p->aCol[iCol].zCnName, pTo);
124468 int iCol; /* Iterator used while populating OLD.* */
124483 for(iCol=0; iCol<pTab->nCol; iCol++){
124484 testcase( mask!=0xffffffff && iCol==31 );
124485 testcase( mask!=0xffffffff && iCol==32 );
124486 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
124487 int kk = sqlite3TableColumnToStorage(pTab, iCol);
124488 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
127377 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
127381 if( iCol<0 ) break; /* No foreign keys against expression indexes */
127386 zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]);
127390 zIdxCol = pParent->aCol[iCol].zCnName;
127589 ** to column iCol of table pTab.
127599 i16 iCol /* Which column of pTab is desired */
127608 if( iCol>=0 && iCol!=pTab->iPKey ){
127609 pCol = &pTab->aCol[iCol];
127610 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
127624 ** Return an Expr object that refers to column iCol of table pTab which
127631 i16 iCol /* The column that is wanted */
127638 pExpr->iColumn = iCol;
127711 i16 iCol; /* Index of column in child table */
127714 iCol = pIdx ? pIdx->aiColumn[i] : -1;
127715 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
127716 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
127717 assert( iCol>=0 );
127718 zCol = pFKey->pFrom->aCol[iCol].zCnName;
127750 i16 iCol = pIdx->aiColumn[i];
127751 assert( iCol>=0 );
127752 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
127753 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
128042 int iCol;
128090 iCol = pFKey->aCol[0].iFrom;
128091 aiCol = &iCol;
131981 const void * (*column_blob)(sqlite3_stmt*,int iCol);
131982 int (*column_bytes)(sqlite3_stmt*,int iCol);
131983 int (*column_bytes16)(sqlite3_stmt*,int iCol);
131989 double (*column_double)(sqlite3_stmt*,int iCol);
131990 int (*column_int)(sqlite3_stmt*,int iCol);
131991 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
131998 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
131999 const void * (*column_text16)(sqlite3_stmt*,int iCol);
132000 int (*column_type)(sqlite3_stmt*,int iCol);
132001 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
135823 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
135824 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
136240 int iCol = pIdx->aiColumn[kk];
136241 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
136242 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
138536 SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol){
138544 assert( iCol>=0 && iCol<pResults->nExpr );
138545 pResults->a[iCol].fg.bUsed = 1;
138569 int iCol; /* Index of column matching zCol */
138576 iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol);
138577 if( iCol>=0
138578 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
138581 sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol);
138583 *piCol = iCol;
139881 int iCol;
139958 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
139962 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
139966 int iKey = iCol+1;
140006 iRead = iCol--;
140132 int iCol = pExpr->iColumn; /* Index of column in pTab */
140171 if( iCol<pS->pEList->nExpr
140173 && iCol>=0
140175 && ALWAYS(iCol>=0)
140178 /* If iCol is less than zero, then the expression requests the
140183 Expr *p = pS->pEList->a[iCol].pExpr;
140193 if( iCol<0 ) iCol = pTab->iPKey;
140194 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
140195 if( iCol<0 ){
140199 zOrigCol = pTab->aCol[iCol].zCnName;
140200 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
140208 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
140209 if( iCol<0 ){
140212 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
140366 int iCol = p->iColumn;
140369 if( iCol<0 ) iCol = pTab->iPKey;
140370 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
140371 if( iCol<0 ){
140374 zCol = pTab->aCol[iCol].zCnName;
140462 int iCol = pColExpr->iColumn;
140464 if( iCol<0 ) iCol = pTab->iPKey;
140465 zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid";
140704 ** Return the appropriate collating sequence for the iCol-th column of
140711 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
140714 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
140718 assert( iCol>=0 );
140719 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
140722 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
140723 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
147927 ** Check to see if column iCol of index pIdx references any of the
147939 int iCol, /* Which column of the index to check */
147943 i16 iIdxCol = pIdx->aiColumn[iCol];
147950 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
147951 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
147979 ** Expr.iColumn set to value (iCol+1). The resolver will modify the
147980 ** expression to be a TK_COLUMN reading column iCol of the first
147983 static Expr *exprRowColumn(Parse *pParse, int iCol){
147985 if( pRet ) pRet->iColumn = iCol+1;
148900 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
150575 int iCol;
150585 for(iCol=0; iCol<pTab->nCol; iCol++){
150586 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
150608 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
152591 int iCol = aiMap ? aiMap[iMap++] : 0;
152592 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
154237 int iCol = pPk->aiColumn[iPk];
154238 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
154531 int iCol = pPk->aiColumn[iPk];
154532 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
154678 int iCol = pPk->aiColumn[iPk];
154679 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
154901 int iCol = pRight->iColumn;
154902 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
154906 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
157078 ** This function searches pList for an entry that matches the iCol-th column
157089 int iCol /* Column of index to match */
157092 const char *zColl = pIdx->azColl[iCol];
157098 && p->iColumn==pIdx->aiColumn[iCol]
157112 ** Return TRUE if the iCol-th column of index pIdx is NOT NULL
157114 static int indexColumnNotNull(Index *pIdx, int iCol){
157117 assert( iCol>=0 && iCol<pIdx->nColumn );
157118 j = pIdx->aiColumn[iCol];
157426 int iCol;
157429 iCol = pTerm->u.x.leftColumn;
157430 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
157431 testcase( iCol==BMS );
157432 testcase( iCol==BMS-1 );
157436 pTable->aCol[iCol].zCnName);
157482 int iCol;
157485 iCol = pTerm->u.x.leftColumn;
157486 cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
157487 testcase( iCol==BMS-1 );
157488 testcase( iCol==BMS );
157675 int iCol = pIdx->aiColumn[jj];
157677 sqlite3ExprCodeGetColumnOfTable(v, pIdx->pTable, iCur, iCol,r1+jj);
157991 int iCol; /* Index of required stats in anEq[] etc. */
158052 iCol = 0;
158082 iCol = n-1;
158095 assert( iCol==nField-1 );
158103 ** (iCol+1) field prefix of sample i. */
158105 pRec->nField = iCol+1;
158110 /* if i==0 and iCol==0, then record pRec is smaller than all samples
158111 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
158112 ** be greater than or equal to the (iCol) field prefix of sample i.
158114 if( iCol>0 ){
158115 pRec->nField = iCol;
158130 assert( iCol==nField-1 );
158131 aStat[0] = aSample[i].anLt[iCol];
158132 aStat[1] = aSample[i].anEq[iCol];
158134 /* At this point, the (iCol+1) field prefix of aSample[i] is the first
158141 iUpper = aSample[i].anLt[iCol];
158192 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
158193 assert( iCol>=0 && iCol<pIdx->nColumn );
158197 assert( pIdx->zColAff[iCol]!=0 );
158198 return pIdx->zColAff[iCol];
159507 int iCol = pProbe->aiColumn[saved_nEq];
159510 if( iCol==XN_ROWID
159511 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
159513 if( iCol==XN_ROWID || pProbe->uniqNotNull
163916 int iCol = -1;
163922 iCol = i;
163927 if( iCol<0 ){
163941 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
177259 int iCol = 0;
177292 for(iCol=0; iCol<pTab->nCol; iCol++){
177293 pCol = &pTab->aCol[iCol];
177298 if( iCol==pTab->nCol ){
177300 iCol = pTab->iPKey;
177301 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
177324 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
179197 int fts3_global_term_cnt(int iTerm, int iCol);
179198 int fts3_term_cnt(int iTerm, int iCol);
179725 ** aMI[iCol*3 + 0] = Undefined
179726 ** aMI[iCol*3 + 1] = Number of occurrences
179727 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
179825 int iCol;
179914 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
180827 int iCol; /* Column index */
181100 for(iCol=0; iCol<nCol; iCol++){
181103 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
181109 p->azColumn[iCol] = zCsr;
181115 for(iCol=0; iCol<nCol; iCol++){
181116 int n = (int)strlen(p->azColumn[iCol]);
181120 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
181122 p->abNotindexed[iCol] = 1;
181840 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
181841 ** the value of iCol encoded as a varint to *pp. This will start a new
181845 ** returning (do not modify it if iCol==0). Return the total number of bytes
181846 ** written (0 if iCol==0).
181848 static int fts3PutColNumber(char **pp, int iCol){
181850 if( iCol ){
181852 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
182424 sqlite3_int64 iCol;
182426 p += sqlite3Fts3GetVarint(p, &iCol);
182433 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
182823 filter.iCol = iColumn;
182992 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
183004 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
183087 ** (iCol < p->nColumn) -> The value of the iCol'th user column.
183088 ** (iCol == p->nColumn) -> Magic column with the same name as the table.
183089 ** (iCol == p->nColumn+1) -> Docid column
183090 ** (iCol == p->nColumn+2) -> Langid column
183095 int iCol /* Index of column to read value from */
183102 assert( iCol>=0 && iCol<=p->nColumn+2 );
183104 switch( iCol-p->nColumn ){
183123 iCol = p->nColumn;
183131 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
183132 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
183356 int iCol = -1;
183374 case 5: iCol = sqlite3_value_int(apVal[4]);
183387 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
184091 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
184096 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
184512 int iCol; /* The column the token must match */
184540 pTC->iCol = pPhrase->iColumn;
184720 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
184736 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
185382 int iCol = 0;
185393 /* aMI[iCol*3 + 1] = Number of occurrences
185394 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
185396 pExpr->aMI[iCol*3 + 1] += iCnt;
185397 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
185400 p += fts3GetVarint32(p, &iCol);
185401 }while( iCol<nCol );
185515 ** aiOut[iCol*3 + 1] = Number of occurrences
185516 ** aiOut[iCol*3 + 2] = Number of rows containing at least one instance
185539 int iCol;
185543 for(iCol=0; iCol<pTab->nColumn; iCol++){
185544 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
185545 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
185551 for(iCol=0; iCol<pTab->nColumn; iCol++){
185552 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
185553 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
185566 ** a position-list indicating the occurrences of the phrase in column iCol
185583 int iCol, /* Column to return position list for */
185593 ** column iCol, return a NULL pointer. */
185595 assert( iCol>=0 && iCol<pTab->nColumn );
185596 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
185696 while( iThis<iCol ){
185706 *ppOut = ((iCol==iThis)?pIter:0);
185798 int iCol; /* Current value of 'col' column */
185935 int iCol = pInfo->aConstraint[i].iColumn;
185937 if( iCol==0 ){
185944 if( iCol==4 ){
186035 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
186036 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
186044 int iCol;
186059 iCol = 0;
186071 iCol = 0;
186083 assert( iCol==0 );
186096 pCsr->aStat[iCol+1].nOcc++;
186103 iCol = (int)v;
186104 if( iCol<1 ){
186108 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
186109 pCsr->aStat[iCol+1].nDoc++;
186115 pCsr->iCol = 0;
186232 int iCol /* Index of column to read value from */
186237 switch( iCol ){
186243 if( p->iCol ){
186244 sqlite3_result_int(pCtx, p->iCol-1);
186251 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
186255 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
186259 assert( iCol==4 );
186497 int iCol, /* Value for Fts3Phrase.iColumn */
186532 pRet->pPhrase->iColumn = iCol;
186730 int iCol;
186842 iCol = pParse->iDefaultCol;
186850 iCol = ii;
186855 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
189807 int iCol /* Index of column to read value from */
189812 switch( iCol ){
189826 assert( iCol==4 );
190002 int iCol; /* Column token must occur in */
190578 sqlite3_int64 iCol, /* Column for entry to add */
190601 if( iCol>0 && p->iLastCol!=iCol ){
190603 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
190607 p->iLastCol = iCol;
190610 if( iCol>=0 ){
190639 int iCol,
190652 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
190671 ** p->iPrevDocid, and the column is specified by argument iCol.
190679 int iCol, /* Column into which text is being inserted */
190729 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
190738 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
190815 int iCol = i-2;
190816 if( p->abNotindexed[iCol]==0 ){
190818 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
190971 int iCol = i-1;
190972 if( p->abNotindexed[iCol]==0 ){
190974 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
192499 ** identify the subset of the position list that corresponds to column iCol.
192501 ** If there are no entries in the input position list for column iCol, then
192508 int iCol, /* Column to filter on */
192519 assert( iCol>=0 );
192524 if( iCol==iCurrent ){
192682 int iCol, /* Column to match on. */
192716 assert( iCol<0 || iCol<p->nColumn );
192717 pCsr->iColFilter = iCol;
192884 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
192962 ** Decode the "end_block" field, selected by column iCol of the SELECT
192973 int iCol,
192977 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
193476 int iCol;
193480 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
193481 if( p->abNotindexed[iCol]==0 ){
193482 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
193483 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
193484 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
193495 for(iCol=0; iCol<=p->nColumn; iCol++){
193496 aSzIns[iCol] += aSz[iCol];
195070 int iCol, /* Column number */
195078 ret += (ret<<3) + iCol;
195125 i64 iCol = 0;
195134 iCol = 0;
195137 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
195150 (int)iCol, (int)iPos
195212 int iCol;
195214 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
195215 if( p->abNotindexed[iCol]==0 ){
195216 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
195230 zToken, nToken, iLang, 0, iDocid, iCol, iPos
195235 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
195409 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
195466 int iCol /* Column that token must appear in (or -1) */
195476 pDeferred->iCol = iCol;
195768 int iCol; /* Extract snippet from this column */
195785 int iCol; /* Column snippet is extracted from */
196182 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
196207 ** from column iCol that represent the "best" snippet. The best snippet
196223 int iCol, /* Index of column to create snippet from */
196259 sIter.iCol = iCol;
196276 pFragment->iCol = iCol;
196442 int iCol = pFragment->iCol+1; /* Query column to extract text from */
196446 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
196448 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
196453 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
196576 int iCol = 0;
196587 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
196589 p->aMatchinfo[iStart + iCol] = (u32)nHit;
196591 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
196597 pIter += fts3GetVarint32(pIter, &iCol);
196598 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
196635 ** for(iCol=0; iCol<nCol; iCol++){
196636 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
196637 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
196640 ** where X is the number of matches for phrase iPhrase is column iCol of all
196641 ** rows of the table. Y is the number of rows for which column iCol contains
196796 ** If LcsIterator.iCol is set to the following value, the iterator has
196849 int iCol;
196866 for(iCol=0; iCol<pInfo->nCol; iCol++){
196872 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
196909 pInfo->aMatchinfo[iCol] = nLcs;
196972 int iCol;
196973 for(iCol=0; iCol<pInfo->nCol; iCol++){
196982 pInfo->aMatchinfo[iCol] = iVal;
196992 int iCol;
196995 for(iCol=0; iCol<pInfo->nCol; iCol++){
197002 pInfo->aMatchinfo[iCol] = (u32)nToken;
197147 int iCol, /* Extract snippet from this column */
197196 ** If the iCol argument to this function was negative, this means all
197197 ** columns of the FTS3 table. Otherwise, only column iCol is considered.
197202 if( iCol>=0 && iRead!=iCol ) continue;
197255 int iCol; /* Column of table to populate aTerm for */
197273 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
197301 int iCol; /* Column currently being processed */
197329 for(iCol=0; iCol<pTab->nColumn; iCol++){
197339 /* Initialize the contents of sCtx.aTerm[] for column iCol. This
197342 sCtx.iCol = iCol;
197347 /* Retreive the text stored in column iCol. If an SQL NULL is stored
197348 ** in column iCol, jump immediately to the next iteration of the loop.
197353 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
197354 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
197356 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
197363 /* Initialize a tokenizer iterator to iterate through column iCol. */
197399 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
200706 int iCol;
200709 iCol = pConstraint->iColumn - JEACH_JSON;
200710 assert( iCol==0 || iCol==1 );
200711 testcase( iCol==0 );
200712 iMask = 1 << iCol;
200716 aIdx[iCol] = i;
204119 ** Parameter iCol is the index of the leftmost column involved in the
204122 ** (c1<=c2) constraint on columns iCol and iCol+1 that has failed.
204126 static int rtreeConstraintError(Rtree *pRtree, int iCol){
204131 assert( iCol==0 || iCol%2 );
204141 if( iCol==0 ){
204147 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
204148 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
210388 int iCol = 0;
210420 zOrder, zSep, iCol, zCol, zCollate
210423 zSelect, zSep, iCol, zCol
210426 iCol++;
210441 for(iCol=0; iCol<pIter->nCol; iCol++){
210442 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
210928 int iCol;
210931 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
210933 const char *zCol = pIter->azTblCol[iCol];
210940 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
210946 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
210947 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
212094 int iCol = p->objiter.nCol; /* Index of rbu_control column */
212097 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
212099 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
212111 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
212134 ** Assert that column iCol of statement pStmt is named zName.
212136 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
212137 const char *zCol = sqlite3_column_name(pStmt, iCol);
216171 int iCol; /* Used to iterate through table columns */
216173 for(iCol=0; iCol<pTab->nCol; iCol++){
216174 if( pTab->abPK[iCol] ){
216214 int iCol; /* Used to iterate from 0 to nCol */
216216 for(iCol=0; iCol<nCol; iCol++){
216368 int iCol; /* Used to iterate through columns */
216372 for(iCol=0; iCol<pTab->nCol; iCol++){
216373 if( !pTab->abPK[iCol] ){
216387 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
216390 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
216680 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
216683 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
216684 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
216690 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
216693 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
216694 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
217684 ** in column iCol of the row that SQL statement pStmt currently points
217690 int iCol, /* Column to read value from */
217694 int eType = sqlite3_column_type(pStmt, iCol);
217700 i = sqlite3_column_int64(pStmt, iCol);
217702 double r = sqlite3_column_double(pStmt, iCol);
217712 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
217714 z = (u8 *)sqlite3_column_text(pStmt, iCol);
217716 nByte = sqlite3_column_bytes(pStmt, iCol);
218121 int iCol;
218124 for(iCol=0; iCol<nCol; iCol++){
218125 sessionAppendCol(&buf, pSel, iCol, &rc);
219156 int iCol;
219181 for(iCol=0; iCol<nCol; iCol++){
219182 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
219189 for(iCol=0; iCol<nCol; iCol++){
219190 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
219194 for(iCol=0; iCol<nCol*2; iCol++){
219195 sqlite3ValueFree(apVal[iCol]);
221414 ** xColumnTotalSize(pFts, iCol, pnToken):
221415 ** If parameter iCol is less than zero, set output variable *pnToken
221416 ** to the total number of tokens in the FTS5 table. Or, if iCol is
221418 ** the total number of tokens in column iCol, considering all rows in
221421 ** If parameter iCol is greater than or equal to the number of columns
221429 ** xColumnSize(pFts, iCol, pnToken):
221430 ** If parameter iCol is less than zero, set output variable *pnToken
221431 ** to the total number of tokens in the current row. Or, if iCol is
221433 ** *pnToken to the number of tokens in column iCol of the current row.
221435 ** If parameter iCol is greater than or equal to the number of columns
221444 ** This function attempts to retrieve the text of column iCol of the
221565 ** int iCol, iOff;
221566 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
221567 ** iCol>=0;
221568 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
221570 ** // An instance of phrase iPhrase at offset iOff of column iCol
221582 ** through an empty set (all calls to xPhraseFirst() set iCol to -1).
221595 ** int iCol;
221596 ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
221597 ** iCol>=0;
221598 ** pApi->xPhraseNextColumn(pFts, &iter, &iCol)
221600 ** // Column iCol contains at least one instance of phrase iPhrase
221607 ** xPhraseFirstColumn() set iCol to -1).
221625 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
221640 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
221641 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
222246 i64 iPos; /* (iCol<<32) + iPos */
222327 int iCol,
222391 ** unique token in the document with an iCol value less than zero. The iPos
222396 int iCol, /* Column token appears in (-ve -> delete) */
222530 int iCol, /* Column token appears in (-ve -> delete) */
222594 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
222634 int iCol, /* Column on LHS of MATCH operator */
222642 int iCol,
224311 ** for(rc = fts5CInstIterNext(pApi, pFts, iCol, &iter);
224323 int iCol; /* Column to search */
224345 if( ic==pIter->iCol ){
224365 ** iterate through coalesced phrase instances in column iCol.
224370 int iCol,
224378 pIter->iCol = iCol;
224494 int iCol;
224502 iCol = sqlite3_value_int(apVal[0]);
224506 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
224510 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
224605 int iCol, /* Column to score */
224625 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
224666 int iCol; /* 1st argument to snippet() */
224688 iCol = sqlite3_value_int(apVal[0]);
224694 iBestCol = (iCol>=0 ? iCol : 0);
224706 if( iCol<0 || iCol==i ){
226594 int iCol,
226622 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
226627 pColset->aiCol[0] = iCol;
226667 ** against column iCol. This function creates and compiles an FTS5 MATCH
226673 Fts5Config *pConfig, int bGlob, int iCol, const char *zText, Fts5Expr **pp
226725 iCol = pConfig->nCol;
226729 rc = sqlite3Fts5ExprNew(pConfig, bAnd, iCol, zExpr, pp,pConfig->pzErrmsg);
228327 ** number iCol appended.
228335 int iCol /* New column to add to colset object */
228341 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
228350 if( aiCol[i]==iCol ) return pNew;
228351 if( aiCol[i]>iCol ) break;
228356 aiCol[i] = iCol;
228402 int iCol;
228409 for(iCol=0; iCol<pConfig->nCol; iCol++){
228410 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
228412 if( iCol==pConfig->nCol ){
228415 pRet = fts5ParseColset(pParse, pColset, iCol);
229275 static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
229278 if( pColset->aiCol[i]==iCol ) return 1;
229322 int iCol,
229329 sCtx.iOff = (((i64)iCol) << 32) - 1;
229334 if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
229513 i16 iCol; /* Column of last value written */
229679 ** of bByte and (pToken/nToken). The value is (iRowid/iCol/iPos).
229681 ** (bByte || pToken) -> (iRowid,iCol,iPos)
229683 ** Or, if iCol is negative, then the value is a delete marker.
229688 int iCol, /* Column token appears in (-ve -> delete) */
229750 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
229793 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
229798 if( iCol>=0 ){
229803 assert_nc( iCol>=p->iCol );
229804 if( iCol!=p->iCol ){
229807 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
229808 p->iCol = (i16)iCol;
229812 p->iCol = (i16)(iPos = iCol);
233041 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
233044 if( pColset->aiCol[i]==iCol ) return 1;
233087 int iCol;
233088 fts5FastGetVarint32(pChunk, i, iCol);
233089 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
233106 int iCol;
233112 fts5FastGetVarint32(pChunk, i, iCol);
233113 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
235519 ** unique token in the document with an iCol value less than zero. The iPos
235524 int iCol, /* Column token appears in (-ve -> delete) */
235533 assert( (iCol<0)==p->bDelete );
235537 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
235545 p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
235724 int iCol;
235726 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
235727 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
235799 int iCol,
235807 ret += (ret<<3) + iCol;
235883 int iCol = FTS5_POS2COLUMN(sReader.iPos);
235885 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
236297 int iCol = FTS5_POS2COLUMN(iPos);
236299 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
237413 int iCol = p->iColumn;
237415 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
237418 if( p->usable==0 || iCol<0 ){
237426 if( iCol==nCol+1 ){
237430 }else if( iCol>=0 ){
237433 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
237441 if( iCol>=0 && iCol<nCol && fts5UsePatternMatch(pConfig, p) ){
237444 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
237448 }else if( bSeenEq==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0 ){
238050 int iCol; /* Column on LHS of MATCH operator */
238088 iCol = 0;
238090 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
238102 rc = sqlite3Fts5ExprNew(pConfig, 0, iCol, zText, &pExpr, pzErr);
238116 iCol = 0;
238118 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
238122 rc = sqlite3Fts5ExprPattern(pConfig, bGlob, iCol, zText, &pExpr);
238627 int iCol,
238632 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
238666 int iCol,
238680 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
238681 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
238873 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
238908 if( iCol<0 ){
238914 }else if( iCol<pConfig->nCol ){
238915 *pnToken = pCsr->aColumnSize[iCol];
239302 int iCol /* Index of column to read value from */
239312 if( iCol==pConfig->nCol ){
239317 if( iCol==pConfig->nCol ){
239323 }else if( iCol==pConfig->nCol+1 ){
239340 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
240117 int iCol;
240139 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
240156 int iCol;
240169 ctx.iCol = -1;
240171 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
240172 if( pConfig->abUnindexed[iCol-1]==0 ){
240178 zText = (const char*)sqlite3_column_text(pSeek, iCol);
240179 nText = sqlite3_column_bytes(pSeek, iCol);
240181 zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
240182 nText = sqlite3_value_bytes(apVal[iCol-1]);
240190 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
240191 if( p->aTotalSize[iCol-1]<0 ){
240379 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
240381 if( pConfig->abUnindexed[ctx.iCol]==0 ){
240382 const char *zText = (const char*)sqlite3_column_text(pScan, ctx.iCol+1);
240383 int nText = sqlite3_column_bytes(pScan, ctx.iCol+1);
240392 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
240505 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
240507 if( pConfig->abUnindexed[ctx.iCol]==0 ){
240508 const char *zText = (const char*)sqlite3_value_text(apVal[ctx.iCol+2]);
240509 int nText = sqlite3_value_bytes(apVal[ctx.iCol+2]);
240518 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
240562 int iCol;
240587 int iCol;
240599 iCol = pCtx->iCol;
240603 iPos = pCtx->iCol;
240604 iCol = 0;
240610 iCol = 0;
240617 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
240628 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
240680 ctx.iCol = i;
240842 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
240846 if( iCol<0 ){
240851 }else if( iCol<p->pConfig->nCol ){
240852 *pnToken = p->aTotalSize[iCol];
243533 int iCol;
243952 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
243953 if( pCsr->aDoc[pCsr->iCol] ) break;
243957 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
243978 pCsr->iCol = 0;
244002 int iCol = -1;
244005 if( iCol!=ii ){
244011 iCol = ii;
244054 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
244055 if( pCsr->iCol==nCol ){
244147 int iCol /* Index of column to read value from */
244154 if( iCol==0 ){
244159 assert( iCol==1 || iCol==2 || iCol==3 );
244160 if( iCol==1 ){
244162 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
244165 }else if( iCol==2 ){
244166 iVal = pCsr->aDoc[pCsr->iCol];
244168 iVal = pCsr->aCnt[pCsr->iCol];
244171 assert( iCol==1 || iCol==2 );
244172 if( iCol==1 ){
244179 switch( iCol ){
244197 assert( iCol==3 );