Lines Matching refs:iCol
6000 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
6001 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
6002 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
6003 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
6004 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
6005 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
6006 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
6007 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
6008 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
6009 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
12902 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
12917 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
12918 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
77431 int iCol, /* Column to extract */
77443 assert( iCol>0 );
77447 for(i=0; i<=iCol; i++){
93174 u16 iCol; /* Table column this handle is open on */
93224 u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
93225 testcase( pC->nHdrParsed==p->iCol );
93226 testcase( pC->nHdrParsed==p->iCol+1 );
93235 p->iOffset = pC->aType[p->iCol + pC->nField];
93275 int iCol; /* Index of zColumn in row-record */
93335 for(iCol=0; iCol<pTab->nCol; iCol++) {
93336 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
93340 if( iCol==pTab->nCol ){
93364 if( pFKey->aCol[j].iFrom==iCol ){
93375 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
93470 pBlob->iCol = iCol;
97594 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
97603 assert( iCol>=0 && iCol<pEList->nExpr );
97604 pOrig = pEList->a[iCol].pExpr;
97923 int iCol;
97927 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
97929 if( iCol==pTab->iPKey ){
97930 iCol = -1;
97935 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
97937 iCol = -1;
97939 if( iCol<pTab->nCol ){
97943 testcase( iCol==(-1) );
97945 pExpr->iColumn = iCol;
97949 pExpr->iTable = pNC->uNC.pUpsert->regData + iCol;
97957 if( iCol<0 ){
97960 testcase( iCol==31 );
97961 testcase( iCol==32 );
97962 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
97964 testcase( iCol==31 );
97965 testcase( iCol==32 );
97966 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
97969 pExpr->iColumn = (i16)iCol;
98173 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
98179 if( p->y.pTab->iPKey==iCol ){
98182 p->iColumn = (ynVar)iCol;
98184 && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
98190 testcase( iCol==BMS );
98191 testcase( iCol==BMS-1 );
98192 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
98808 int iCol = -1;
98812 if( sqlite3ExprIsInteger(pE, &iCol) ){
98813 if( iCol<=0 || iCol>pEList->nExpr ){
98818 iCol = resolveAsName(pParse, pEList, pE);
98819 if( iCol==0 ){
98840 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
98847 if( iCol>0 ){
98854 pNew->u.iValue = iCol;
98865 pItem->u.x.iOrderByCol = (u16)iCol;
98980 int iCol; /* Column number */
98992 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
98993 if( iCol>0 ){
98998 pItem->u.x.iOrderByCol = (u16)iCol;
99002 if( sqlite3ExprIsInteger(pE2, &iCol) ){
99006 if( iCol<1 || iCol>0xffff ){
99010 pItem->u.x.iOrderByCol = (u16)iCol;
99508 SQLITE_PRIVATE char sqlite3TableColumnAffinity(Table *pTab, int iCol){
99509 assert( iCol<pTab->nCol );
99510 return iCol>=0 ? pTab->aCol[iCol].affinity : SQLITE_AFF_INTEGER;
102075 int iCol = pEList->a[i].pExpr->iColumn;
102076 char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
103016 int iCol, /* Index of the column to extract */
103022 sqlite3VdbeAddOp3(v, OP_Column, iTabCur, iCol, regOut);
103025 if( iCol<0 || iCol==pTab->iPKey ){
103032 x = iCol;
103034 }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){
103049 testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) );
103050 x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
103053 x = sqlite3TableColumnToStorage(pTab,iCol);
103054 testcase( x!=iCol );
103058 sqlite3ColumnDefault(v, pTab, iCol, regOut);
103358 int iCol = pExpr->iColumn;
103360 assert( iCol>=XN_ROWID );
103361 assert( iCol<pTab->nCol );
103362 if( iCol<0 ){
103365 pCol = pTab->aCol + iCol;
103366 testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) );
103367 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
103836 int iCol = pExpr->iColumn;
103838 + sqlite3TableColumnToStorage(pTab, iCol);
103841 assert( iCol>=-1 && iCol<pTab->nCol );
103842 assert( pTab->iPKey<0 || iCol!=pTab->iPKey );
103848 (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zName)
103857 if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){
106036 int iCol; /* Index of column being renamed */
106067 for(iCol=0; iCol<pTab->nCol; iCol++){
106068 if( 0==sqlite3StrICmp(pTab->aCol[iCol].zName, zOld) ) break;
106070 if( iCol==pTab->nCol ){
106091 zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
106100 zDb, pTab->zName, iCol, zNew, bQuote
106145 int iCol; /* Index of column being renamed */
106399 && pExpr->iColumn==p->iCol
106404 && pExpr->iColumn==p->iCol
106804 int iCol = sqlite3_value_int(argv[5]);
106823 if( iCol<0 ) return;
106826 if( pTab==0 || iCol>=pTab->nCol ){
106830 zOld = pTab->aCol[iCol].zName;
106832 sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
106867 &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zName
106869 if( sCtx.iCol<0 ){
106888 if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
107507 int iCol; /* If !isPSample, the reason for inclusion */
107579 pTo->iCol = pFrom->iCol;
107706 p->aBest[i].iCol = i;
107748 assert( pNew->iCol==pOld->iCol );
107749 for(i=pNew->iCol+1; i<nCol; i++){
107770 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
107771 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
107774 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
107778 if( pNew->iCol<pOld->iCol ) return 1;
107779 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
107803 assert( pNew->anEq[pNew->iCol]>0 );
107812 if( pOld->anEq[pNew->iCol]==0 ){
107814 assert( pOld->iCol>pNew->iCol );
107822 pUpgrade->iCol = pNew->iCol;
107823 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
107987 p->current.iCol = 0;
107994 p->current.iCol = i;
108846 int iCol;
108856 for(iCol=0; iCol<nCol; iCol++){
108865 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
108866 nRow = pFinal->anLt[iCol];
108867 nDist100 = (i64)100 * pFinal->anDLt[iCol];
108871 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
108881 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
108883 sumEq += aSample[i].anEq[iCol];
108892 pIdx->aAvgEq[iCol] = avgEq;
109923 int iCol; /* Index of column in table */
109946 iCol = pExpr->iColumn;
109949 if( iCol>=0 ){
109950 assert( iCol<pTab->nCol );
109951 zCol = pTab->aCol[iCol].zName;
110952 SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){
110955 if( iCol==pIdx->aiColumn[i] ) return i;
110972 SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){
110975 for(i=0; i<=iCol; i++){
110976 if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++;
110979 return iCol;
111020 SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
111023 assert( iCol<pTab->nCol );
111024 if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
111025 for(i=0, n=0; i<iCol; i++){
111572 int iCol = -1, i;
111582 iCol = pTab->nCol - 1;
111583 pCol = &pTab->aCol[iCol];
111594 for(iCol=0; iCol<pTab->nCol; iCol++){
111595 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
111596 pCol = &pTab->aCol[iCol];
111613 pTab->iPKey = iCol;
111976 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
111979 assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
111984 j = pPk->aiColumn[iCol];
111989 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
113203 int iCol = p->nCol-1;
113204 if( NEVER(iCol<0) ) goto fk_end;
113208 p->aCol[iCol].zName, pTo);
116397 int iCol; /* Iterator used while populating OLD.* */
116412 for(iCol=0; iCol<pTab->nCol; iCol++){
116413 testcase( mask!=0xffffffff && iCol==31 );
116414 testcase( mask!=0xffffffff && iCol==32 );
116415 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
116416 int kk = sqlite3TableColumnToStorage(pTab, iCol);
116417 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
118949 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
118953 if( iCol<0 ) break; /* No foreign keys against expression indexes */
118958 zDfltColl = pParent->aCol[iCol].zColl;
118962 zIdxCol = pParent->aCol[iCol].zName;
119173 i16 iCol /* Which column of pTab is desired */
119182 if( iCol>=0 && iCol!=pTab->iPKey ){
119183 pCol = &pTab->aCol[iCol];
119184 pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1;
119205 i16 iCol /* The column that is wanted */
119211 pExpr->iColumn = iCol;
119288 i16 iCol; /* Index of column in child table */
119291 iCol = pIdx ? pIdx->aiColumn[i] : -1;
119292 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
119293 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
119294 assert( iCol>=0 );
119295 zCol = pFKey->pFrom->aCol[iCol].zName;
119327 i16 iCol = pIdx->aiColumn[i];
119328 assert( iCol>=0 );
119329 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
119330 pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zName);
119599 int iCol;
119647 iCol = pFKey->aCol[0].iFrom;
119648 aiCol = &iCol;
123245 const void * (*column_blob)(sqlite3_stmt*,int iCol);
123246 int (*column_bytes)(sqlite3_stmt*,int iCol);
123247 int (*column_bytes16)(sqlite3_stmt*,int iCol);
123253 double (*column_double)(sqlite3_stmt*,int iCol);
123254 int (*column_int)(sqlite3_stmt*,int iCol);
123255 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
123262 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
123263 const void * (*column_text16)(sqlite3_stmt*,int iCol);
123264 int (*column_type)(sqlite3_stmt*,int iCol);
123265 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
126799 int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom;
126800 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
127052 int iCol = pIdx->aiColumn[kk];
127053 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
127054 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
129156 int iCol; /* Index of column matching zCol */
129160 iCol = columnIndex(pSrc->a[i].pTab, zCol);
129161 if( iCol>=0
129162 && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
129166 *piCol = iCol;
130289 int iCol;
130348 for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
130352 if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
130356 int iKey = iCol+1;
130396 iRead = iCol--;
130514 int iCol = pExpr->iColumn; /* Index of column in pTab */
130553 if( iCol>=0 && iCol<pS->pEList->nExpr ){
130559 Expr *p = pS->pEList->a[iCol].pExpr;
130569 if( iCol<0 ) iCol = pTab->iPKey;
130570 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
130571 if( iCol<0 ){
130575 zOrigCol = pTab->aCol[iCol].zName;
130576 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
130584 assert( iCol==XN_ROWID || (iCol>=0 && iCol<pTab->nCol) );
130585 if( iCol<0 ){
130588 zType = sqlite3ColumnType(&pTab->aCol[iCol],0);
130739 int iCol = p->iColumn;
130742 if( iCol<0 ) iCol = pTab->iPKey;
130743 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
130744 if( iCol<0 ){
130747 zCol = pTab->aCol[iCol].zName;
130829 int iCol = pColExpr->iColumn;
130832 if( iCol<0 ) iCol = pTab->iPKey;
130833 zName = iCol>=0 ? pTab->aCol[iCol].zName : "rowid";
131068 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
131071 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
131075 assert( iCol>=0 );
131079 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
131080 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
137139 int iCol, /* Which column of the index to check */
137143 i16 iIdxCol = pIdx->aiColumn[iCol];
137150 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
137151 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
139418 int iCol;
139428 for(iCol=0; iCol<pTab->nCol; iCol++){
139429 char *zType = sqlite3ColumnType(&pTab->aCol[iCol], "");
139451 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
141323 int iCol = aiMap ? aiMap[iMap++] : 0;
141324 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
142933 int iCol = pPk->aiColumn[iPk];
142934 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
143413 int iCol = pRight->iColumn;
143414 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
143418 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
145277 int iCol /* Column of index to match */
145280 const char *zColl = pIdx->azColl[iCol];
145285 && p->iColumn==pIdx->aiColumn[iCol]
145301 static int indexColumnNotNull(Index *pIdx, int iCol){
145304 assert( iCol>=0 && iCol<pIdx->nColumn );
145305 j = pIdx->aiColumn[iCol];
145573 int iCol = pTerm->u.leftColumn;
145574 Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
145575 testcase( iCol==BMS );
145576 testcase( iCol==BMS-1 );
145580 pTable->aCol[iCol].zName);
145626 int iCol = pTerm->u.leftColumn;
145627 Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
145628 testcase( iCol==BMS-1 );
145629 testcase( iCol==BMS );
145923 int iCol; /* Index of required stats in anEq[] etc. */
145984 iCol = 0;
146014 iCol = n-1;
146027 assert( iCol==nField-1 );
146037 pRec->nField = iCol+1;
146046 if( iCol>0 ){
146047 pRec->nField = iCol;
146062 assert( iCol==nField-1 );
146063 aStat[0] = aSample[i].anLt[iCol];
146064 aStat[1] = aSample[i].anEq[iCol];
146073 iUpper = aSample[i].anLt[iCol];
146124 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
146125 assert( iCol>=0 && iCol<pIdx->nColumn );
146129 assert( pIdx->zColAff[iCol]!=0 );
146130 return pIdx->zColAff[iCol];
147395 int iCol = pProbe->aiColumn[saved_nEq];
147398 if( iCol==XN_ROWID
147399 || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
147401 if( iCol==XN_ROWID || pProbe->uniqNotNull
151153 int iCol = -1;
151158 iCol = i;
151163 if( iCol<0 ){
151176 pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
163822 int iCol = 0;
163855 for(iCol=0; iCol<pTab->nCol; iCol++){
163856 pCol = &pTab->aCol[iCol];
163861 if( iCol==pTab->nCol ){
163863 iCol = pTab->iPKey;
163864 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
163887 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
165595 int fts3_global_term_cnt(int iTerm, int iCol);
165596 int fts3_term_cnt(int iTerm, int iCol);
166220 int iCol;
166308 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
167220 int iCol; /* Column index */
167493 for(iCol=0; iCol<nCol; iCol++){
167496 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
167502 p->azColumn[iCol] = zCsr;
167508 for(iCol=0; iCol<nCol; iCol++){
167509 int n = (int)strlen(p->azColumn[iCol]);
167513 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
167515 p->abNotindexed[iCol] = 1;
168241 static int fts3PutColNumber(char **pp, int iCol){
168243 if( iCol ){
168245 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
168814 sqlite3_int64 iCol;
168816 p += sqlite3Fts3GetVarint(p, &iCol);
168823 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
169213 filter.iCol = iColumn;
169382 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
169394 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
169485 int iCol /* Index of column to read value from */
169492 assert( iCol>=0 && iCol<=p->nColumn+2 );
169494 switch( iCol-p->nColumn ){
169513 iCol = p->nColumn;
169521 if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){
169522 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
169740 int iCol = -1;
169757 case 5: iCol = sqlite3_value_int(apVal[4]);
169767 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
170461 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
170466 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
170882 int iCol; /* The column the token must match */
170910 pTC->iCol = pPhrase->iColumn;
171090 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
171106 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
171749 int iCol = 0;
171763 pExpr->aMI[iCol*3 + 1] += iCnt;
171764 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
171767 p += fts3GetVarint32(p, &iCol);
171768 }while( iCol<nCol );
171905 int iCol;
171909 for(iCol=0; iCol<pTab->nColumn; iCol++){
171910 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
171911 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
171917 for(iCol=0; iCol<pTab->nColumn; iCol++){
171918 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
171919 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
171949 int iCol, /* Column to return position list for */
171961 assert( iCol>=0 && iCol<pTab->nColumn );
171962 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
172059 while( iThis<iCol ){
172069 *ppOut = ((iCol==iThis)?pIter:0);
172161 int iCol; /* Current value of 'col' column */
172298 int iCol = pInfo->aConstraint[i].iColumn;
172300 if( iCol==0 ){
172307 if( iCol==4 ){
172398 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
172399 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
172407 int iCol;
172422 iCol = 0;
172433 iCol = 0;
172445 assert( iCol==0 );
172458 pCsr->aStat[iCol+1].nOcc++;
172465 iCol = (int)v;
172466 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
172467 pCsr->aStat[iCol+1].nDoc++;
172473 pCsr->iCol = 0;
172590 int iCol /* Index of column to read value from */
172595 switch( iCol ){
172601 if( p->iCol ){
172602 sqlite3_result_int(pCtx, p->iCol-1);
172609 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
172613 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
172617 assert( iCol==4 );
172855 int iCol, /* Value for Fts3Phrase.iColumn */
172890 pRet->pPhrase->iColumn = iCol;
173088 int iCol;
173195 iCol = pParse->iDefaultCol;
173203 iCol = ii;
173208 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
176159 int iCol /* Index of column to read value from */
176164 switch( iCol ){
176178 assert( iCol==4 );
176352 int iCol; /* Column token must occur in */
176926 sqlite3_int64 iCol, /* Column for entry to add */
176949 if( iCol>0 && p->iLastCol!=iCol ){
176951 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
176955 p->iLastCol = iCol;
176958 if( iCol>=0 ){
176987 int iCol,
177000 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
177027 int iCol, /* Column into which text is being inserted */
177077 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
177086 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
177163 int iCol = i-2;
177164 if( p->abNotindexed[iCol]==0 ){
177166 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
177319 int iCol = i-1;
177320 if( p->abNotindexed[iCol]==0 ){
177322 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
178848 int iCol, /* Column to filter on */
178859 assert( iCol>=0 );
178864 if( iCol==iCurrent ){
179022 int iCol, /* Column to match on. */
179056 assert( iCol<0 || iCol<p->nColumn );
179057 pCsr->iColFilter = iCol;
179210 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
179301 int iCol,
179305 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
179804 int iCol;
179808 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
179809 if( p->abNotindexed[iCol]==0 ){
179810 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
179811 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
179812 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
179823 for(iCol=0; iCol<=p->nColumn; iCol++){
179824 aSzIns[iCol] += aSz[iCol];
181388 int iCol, /* Column number */
181396 ret += (ret<<3) + iCol;
181443 i64 iCol = 0;
181452 iCol = 0;
181455 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
181468 (int)iCol, (int)iPos
181530 int iCol;
181532 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
181533 if( p->abNotindexed[iCol]==0 ){
181534 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
181548 zToken, nToken, iLang, 0, iDocid, iCol, iPos
181553 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
181727 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
181784 int iCol /* Column that token must appear in (or -1) */
181794 pDeferred->iCol = iCol;
182082 int iCol; /* Extract snippet from this column */
182099 int iCol; /* Column snippet is extracted from */
182497 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
182538 int iCol, /* Index of column to create snippet from */
182575 sIter.iCol = iCol;
182592 pFragment->iCol = iCol;
182758 int iCol = pFragment->iCol+1; /* Query column to extract text from */
182762 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
182764 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
182769 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
182892 int iCol = 0;
182903 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
182905 p->aMatchinfo[iStart + iCol] = (u32)nHit;
182907 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
182913 pIter += fts3GetVarint32(pIter, &iCol);
182914 if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
183163 int iCol;
183181 for(iCol=0; iCol<pInfo->nCol; iCol++){
183187 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
183224 pInfo->aMatchinfo[iCol] = nLcs;
183287 int iCol;
183288 for(iCol=0; iCol<pInfo->nCol; iCol++){
183297 pInfo->aMatchinfo[iCol] = iVal;
183307 int iCol;
183310 for(iCol=0; iCol<pInfo->nCol; iCol++){
183317 pInfo->aMatchinfo[iCol] = (u32)nToken;
183462 int iCol, /* Extract snippet from this column */
183517 if( iCol>=0 && iRead!=iCol ) continue;
183570 int iCol; /* Column of table to populate aTerm for */
183588 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
183616 int iCol; /* Column currently being processed */
183644 for(iCol=0; iCol<pTab->nColumn; iCol++){
183658 sCtx.iCol = iCol;
183668 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
183669 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
183671 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
183714 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
186910 int iCol;
186913 iCol = pConstraint->iColumn - JEACH_JSON;
186914 assert( iCol==0 || iCol==1 );
186915 iMask = 1 << iCol;
186919 aIdx[iCol] = i;
190316 static int rtreeConstraintError(Rtree *pRtree, int iCol){
190321 assert( iCol==0 || iCol%2 );
190331 if( iCol==0 ){
190337 const char *zCol1 = sqlite3_column_name(pStmt, iCol);
190338 const char *zCol2 = sqlite3_column_name(pStmt, iCol+1);
196528 int iCol = 0;
196560 zOrder, zSep, iCol, zCol, zCollate
196563 zSelect, zSep, iCol, zCol
196566 iCol++;
196581 for(iCol=0; iCol<pIter->nCol; iCol++){
196582 const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
197066 int iCol;
197069 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
197071 const char *zCol = pIter->azTblCol[iCol];
197078 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
197084 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
197085 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
198221 int iCol = p->objiter.nCol; /* Index of rbu_control column */
198224 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
198226 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
198238 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
198263 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
198264 const char *zCol = sqlite3_column_name(pStmt, iCol);
202173 int iCol; /* Used to iterate through table columns */
202175 for(iCol=0; iCol<pTab->nCol; iCol++){
202176 if( pTab->abPK[iCol] ){
202216 int iCol; /* Used to iterate from 0 to nCol */
202218 for(iCol=0; iCol<nCol; iCol++){
202370 int iCol; /* Used to iterate through columns */
202374 for(iCol=0; iCol<pTab->nCol; iCol++){
202375 if( !pTab->abPK[iCol] ){
202389 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
202392 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
202653 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
202656 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
202657 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
202663 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
202666 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
202667 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
203538 int iCol, /* Column to read value from */
203542 int eType = sqlite3_column_type(pStmt, iCol);
203548 i = sqlite3_column_int64(pStmt, iCol);
203550 double r = sqlite3_column_double(pStmt, iCol);
203560 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
203562 z = (u8 *)sqlite3_column_text(pStmt, iCol);
203564 nByte = sqlite3_column_bytes(pStmt, iCol);
203966 int iCol;
203969 for(iCol=0; iCol<nCol; iCol++){
203970 sessionAppendCol(&buf, pSel, iCol, &rc);
204892 int iCol;
204917 for(iCol=0; iCol<nCol; iCol++){
204918 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
204925 for(iCol=0; iCol<nCol; iCol++){
204926 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
204930 for(iCol=0; iCol<nCol*2; iCol++){
204931 sqlite3ValueFree(apVal[iCol]);
207298 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
207313 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
207314 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
207985 int iCol,
208051 int iCol, /* Column token appears in (-ve -> delete) */
208186 int iCol, /* Column token appears in (-ve -> delete) */
208250 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
208289 int iCol, /* Column on LHS of MATCH operator */
209956 int iCol; /* Column to search */
209978 if( ic==pIter->iCol ){
210003 int iCol,
210011 pIter->iCol = iCol;
210127 int iCol;
210135 iCol = sqlite3_value_int(apVal[0]);
210139 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
210143 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
210238 int iCol, /* Column to score */
210258 if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
210299 int iCol; /* 1st argument to snippet() */
210321 iCol = sqlite3_value_int(apVal[0]);
210327 iBestCol = (iCol>=0 ? iCol : 0);
210339 if( iCol<0 || iCol==i ){
212218 int iCol,
212245 if( iCol<pConfig->nCol && sParse.pExpr && sParse.rc==SQLITE_OK ){
212250 pColset->aiCol[0] = iCol;
213871 int iCol /* New column to add to colset object */
213877 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
213886 if( aiCol[i]==iCol ) return pNew;
213887 if( aiCol[i]>iCol ) break;
213892 aiCol[i] = iCol;
213938 int iCol;
213945 for(iCol=0; iCol<pConfig->nCol; iCol++){
213946 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
213948 if( iCol==pConfig->nCol ){
213951 pRet = fts5ParseColset(pParse, pColset, iCol);
214403 int iCol = pNear->pColset->aiCol[0];
214404 zRet = fts5PrintfAppend(zRet, "%s : ", pConfig->azCol[iCol]);
214722 static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
214725 if( pColset->aiCol[i]==iCol ) return 1;
214769 int iCol,
214776 sCtx.iOff = (((i64)iCol) << 32) - 1;
214781 if( (pColset && 0==fts5ExprColsetTest(pColset, iCol))
214960 i16 iCol; /* Column of last value written */
215135 int iCol, /* Column token appears in (-ve -> delete) */
215197 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
215240 p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
215245 if( iCol>=0 ){
215250 assert( iCol>=p->iCol );
215251 if( iCol!=p->iCol ){
215254 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
215255 p->iCol = (i16)iCol;
215259 p->iCol = (i16)(iPos = iCol);
218428 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
218431 if( pColset->aiCol[i]==iCol ) return 1;
218474 int iCol;
218475 fts5FastGetVarint32(pChunk, i, iCol);
218476 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
218493 int iCol;
218499 fts5FastGetVarint32(pChunk, i, iCol);
218500 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
218597 int iCol /* Column to extract from poslist */
218603 while( iCol>iCurrent ){
218620 if( iCol!=iCurrent ) return 0;
220814 int iCol, /* Column token appears in (-ve -> delete) */
220823 assert( (iCol<0)==p->bDelete );
220827 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
220835 p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
221007 int iCol;
221009 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
221010 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
221082 int iCol,
221090 ret += (ret<<3) + iCol;
221166 int iCol = FTS5_POS2COLUMN(sReader.iPos);
221168 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
221576 int iCol = FTS5_POS2COLUMN(iPos);
221578 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
222646 int iCol = p->iColumn;
222648 || (p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol>=nCol)
222651 if( p->usable==0 || iCol<0 ){
222659 if( iCol==nCol+1 ){
222666 if( iCol<nCol ){
222667 sqlite3_snprintf(6, &idxStr[iIdxStr], "%d", iCol);
222677 && p->op==SQLITE_INDEX_CONSTRAINT_EQ && iCol<0
223279 int iCol; /* Column on LHS of MATCH operator */
223319 iCol = 0;
223321 iCol = iCol*10 + (idxStr[iIdxStr]-'0');
223325 iCol = pConfig->nCol;
223336 rc = sqlite3Fts5ExprNew(pConfig, iCol, zText, &pExpr, pzErr);
223840 int iCol,
223845 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
223879 int iCol,
223893 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
223894 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
224084 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
224119 if( iCol<0 ){
224125 }else if( iCol<pConfig->nCol ){
224126 *pnToken = pCsr->aColumnSize[iCol];
224510 int iCol /* Index of column to read value from */
224520 if( iCol==pConfig->nCol ){
224525 if( iCol==pConfig->nCol ){
224531 }else if( iCol==pConfig->nCol+1 ){
224548 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
225320 int iCol;
225342 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
225359 int iCol;
225372 ctx.iCol = -1;
225374 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
225375 if( pConfig->abUnindexed[iCol-1]==0 ){
225379 zText = (const char*)sqlite3_column_text(pSeek, iCol);
225380 nText = sqlite3_column_bytes(pSeek, iCol);
225382 zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
225383 nText = sqlite3_value_bytes(apVal[iCol-1]);
225389 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
225571 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
225573 if( pConfig->abUnindexed[ctx.iCol]==0 ){
225574 const char *zText = (const char*)sqlite3_column_text(pScan, ctx.iCol+1);
225575 int nText = sqlite3_column_bytes(pScan, ctx.iCol+1);
225584 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
225697 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
225699 if( pConfig->abUnindexed[ctx.iCol]==0 ){
225700 const char *zText = (const char*)sqlite3_value_text(apVal[ctx.iCol+2]);
225701 int nText = sqlite3_value_bytes(apVal[ctx.iCol+2]);
225710 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
225754 int iCol;
225779 int iCol;
225791 iCol = pCtx->iCol;
225795 iPos = pCtx->iCol;
225796 iCol = 0;
225802 iCol = 0;
225809 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
225820 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
225867 ctx.iCol = i;
226025 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
226029 if( iCol<0 ){
226034 }else if( iCol<p->pConfig->nCol ){
226035 *pnToken = p->aTotalSize[iCol];
228585 int iCol;
229000 for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
229001 if( pCsr->aDoc[pCsr->iCol] ) break;
229005 if( pTab->eType!=FTS5_VOCAB_COL || pCsr->iCol>=nCol ){
229026 pCsr->iCol = 0;
229050 int iCol = -1;
229053 if( iCol!=ii ){
229059 iCol = ii;
229102 for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
229103 if( pCsr->iCol==nCol ){
229192 int iCol /* Index of column to read value from */
229199 if( iCol==0 ){
229204 assert( iCol==1 || iCol==2 || iCol==3 );
229205 if( iCol==1 ){
229207 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
229210 }else if( iCol==2 ){
229211 iVal = pCsr->aDoc[pCsr->iCol];
229213 iVal = pCsr->aCnt[pCsr->iCol];
229216 assert( iCol==1 || iCol==2 );
229217 if( iCol==1 ){
229224 switch( iCol ){
229242 assert( iCol==3 );