Lines Matching defs:iCol
4278 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt*, int iCol);
4279 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt*, int iCol);
4280 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
4281 SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt*, int iCol);
4282 SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt*, int iCol);
4283 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt*, int iCol);
4284 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt*, int iCol);
4285 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt*, int iCol);
4286 SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt*, int iCol);
4287 SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt*, int iCol);
8197 ** xColumnTotalSize(pFts, iCol, pnToken):
8198 ** If parameter iCol is less than zero, set output variable *pnToken
8199 ** to the total number of tokens in the FTS5 table. Or, if iCol is
8201 ** the total number of tokens in column iCol, considering all rows in
8204 ** If parameter iCol is greater than or equal to the number of columns
8212 ** xColumnSize(pFts, iCol, pnToken):
8213 ** If parameter iCol is less than zero, set output variable *pnToken
8214 ** to the total number of tokens in the current row. Or, if iCol is
8216 ** *pnToken to the number of tokens in column iCol of the current row.
8218 ** If parameter iCol is greater than or equal to the number of columns
8224 ** This function attempts to retrieve the text of column iCol of the
8333 ** int iCol, iOff;
8334 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
8336 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
8338 ** // An instance of phrase iPhrase at offset iOff of column iCol
8355 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
8370 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
8371 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
66567 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
66578 int iCol, /* Column to extract */
66590 assert( iCol>0 );
66594 for(i=0; i<=iCol; i++){
71882 ** Check to see if column iCol of the given statement is valid. If
71884 ** If iCol is not valid, return a pointer to a Mem which has a value
79628 int iCol; /* Table column this handle is open on */
79667 u32 type = pC->aType[p->iCol];
79676 p->iOffset = pC->aType[p->iCol + pC->nField];
79716 int iCol; /* Index of zColumn in row-record */
79809 for(iCol=0; iCol<pTab->nCol; iCol++) {
79810 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
79814 if( iCol==pTab->nCol ){
79839 if( pFKey->aCol[j].iFrom==iCol ){
79850 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
79914 pBlob->iCol = iCol;
83530 ** Turn the pExpr expression into an alias for the iCol-th column of the
83551 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
83556 Expr *pOrig; /* The iCol-th column of the result set */
83560 assert( iCol>=0 && iCol<pEList->nExpr );
83561 pOrig = pEList->a[iCol].pExpr;
83803 int iCol;
83806 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
83808 if( iCol==pTab->iPKey ){
83809 iCol = -1;
83814 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
83817 iCol = -1;
83819 if( iCol<pTab->nCol ){
83821 if( iCol<0 ){
83824 testcase( iCol==31 );
83825 testcase( iCol==32 );
83826 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
83828 testcase( iCol==31 );
83829 testcase( iCol==32 );
83830 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
83832 pExpr->iColumn = (i16)iCol;
83985 ** Allocate and return a pointer to an expression to load the column iCol
83988 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
83994 if( p->pTab->iPKey==iCol ){
83997 p->iColumn = (ynVar)iCol;
83998 testcase( iCol==BMS );
83999 testcase( iCol==BMS-1 );
84000 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
84421 int iCol = -1;
84425 if( sqlite3ExprIsInteger(pE, &iCol) ){
84426 if( iCol<=0 || iCol>pEList->nExpr ){
84431 iCol = resolveAsName(pParse, pEList, pE);
84432 if( iCol==0 ){
84436 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
84441 if( iCol>0 ){
84442 /* Convert the ORDER BY term into an integer column number iCol,
84447 pNew->u.iValue = iCol;
84458 pItem->u.x.iOrderByCol = (u16)iCol;
84544 int iCol; /* Column number */
84556 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
84557 if( iCol>0 ){
84559 ** a copy of the iCol-th result-set column. The subsequent call to
84561 ** copy of the iCol-th result-set expression. */
84562 pItem->u.x.iOrderByCol = (u16)iCol;
84566 if( sqlite3ExprIsInteger(pE2, &iCol) ){
84570 if( iCol<1 || iCol>0xffff ){
84574 pItem->u.x.iOrderByCol = (u16)iCol;
86697 i16 iCol; /* Index of column <column> */
86706 iCol = (i16)pExpr->iColumn;
86718 if( iCol<0 ){
86738 int affinity_ok = sqlite3IndexAffinityOk(pX, pTab->aCol[iCol].affinity);
86741 if( (pIdx->aiColumn[0]==iCol)
86752 if( prRhsHasNull && !pTab->aCol[iCol].notNull ){
87286 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
87294 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
87309 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
87318 p->iColumn = iCol;
87339 p->iColumn = iCol;
87440 ** Generate code to extract the value of the iCol-th column of a table.
87446 int iCol, /* Index of the column to extract */
87449 if( iCol<0 || iCol==pTab->iPKey ){
87453 int x = iCol;
87455 x = sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
87459 if( iCol>=0 ){
87460 sqlite3ColumnDefault(v, pTab, iCol, regOut);
90298 int iCol; /* If !isPSample, the reason for inclusion */
90364 pTo->iCol = pFrom->iCol;
90485 p->aBest[i].iCol = i;
90512 ** the same column (pNew->iCol==pOld->iCol). Ignoring this column and
90519 ** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid.
90528 assert( pNew->iCol==pOld->iCol );
90529 for(i=pNew->iCol+1; i<nCol; i++){
90543 ** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid.
90550 tRowcnt nEqNew = pNew->anEq[pNew->iCol];
90551 tRowcnt nEqOld = pOld->anEq[pOld->iCol];
90554 assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) );
90559 if( pNew->iCol<pOld->iCol ) return 1;
90560 return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld));
90581 assert( pNew->anEq[pNew->iCol]>0 );
90584 ** iCol occurs many times in the table. However, if we have already
90590 if( pOld->anEq[pNew->iCol]==0 ){
90592 assert( pOld->iCol>pNew->iCol );
90600 pUpgrade->iCol = pNew->iCol;
90601 pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol];
90782 p->current.iCol = 0;
90789 p->current.iCol = i;
91602 int iCol;
91612 for(iCol=0; iCol<nCol; iCol++){
91621 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
91622 nRow = pFinal->anLt[iCol];
91623 nDist100 = (i64)100 * pFinal->anDLt[iCol];
91627 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
91631 /* Set nSum to the number of distinct (iCol+1) field prefixes that
91633 ** the nEq values for column iCol for the same set (adding the value
91637 || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol]
91639 sumEq += aSample[i].anEq[iCol];
91648 pIdx->aAvgEq[iCol] = avgEq;
92653 int iCol; /* Index of column in table */
92675 iCol = pExpr->iColumn;
92678 if( iCol>=0 ){
92679 assert( iCol<pTab->nCol );
92680 zCol = pTab->aCol[iCol].zName;
93586 ** column iCol. Return -1 if not found.
93588 SQLITE_PRIVATE i16 sqlite3ColumnOfIndex(Index *pIdx, i16 iCol){
93591 if( iCol==pIdx->aiColumn[i] ) return i;
94089 int iCol = -1, i;
94099 iCol = pTab->nCol - 1;
94100 pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
94101 zType = pTab->aCol[iCol].zType;
94111 for(iCol=0; iCol<pTab->nCol; iCol++){
94112 if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zName)==0 ){
94113 pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
94114 zType = pTab->aCol[iCol].zType;
94125 pTab->iPKey = iCol;
95410 int iCol = p->nCol-1;
95411 if( NEVER(iCol<0) ) goto fk_end;
95415 p->aCol[iCol].zName, pTo);
98346 int iCol; /* Iterator used while populating OLD.* */
98361 for(iCol=0; iCol<pTab->nCol; iCol++){
98362 testcase( mask!=0xffffffff && iCol==31 );
98363 testcase( mask!=0xffffffff && iCol==32 );
98364 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
98365 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1);
100622 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
100626 if( iCol<0 ) break; /* No foreign keys against expression indexes */
100631 zDfltColl = pParent->aCol[iCol].zColl;
100637 zIdxCol = pParent->aCol[iCol].zName;
100826 ** to column iCol of table pTab.
100836 i16 iCol /* Which column of pTab is desired */
100845 if( iCol>=0 && iCol!=pTab->iPKey ){
100846 pCol = &pTab->aCol[iCol];
100847 pExpr->iTable = regBase + iCol + 1;
100861 ** Return an Expr object that refers to column iCol of table pTab which
100868 i16 iCol /* The column that is wanted */
100874 pExpr->iColumn = iCol;
100951 i16 iCol; /* Index of column in child table */
100954 iCol = pIdx ? pIdx->aiColumn[i] : -1;
100955 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
100956 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
100957 assert( iCol>=0 );
100958 zCol = pFKey->pFrom->aCol[iCol].zName;
100988 i16 iCol = pIdx->aiColumn[i];
100989 assert( iCol>=0 );
100990 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
100991 pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, iCol);
101256 int iCol;
101302 iCol = pFKey->aCol[0].iFrom;
101303 aiCol = &iCol;
104103 const void * (*column_blob)(sqlite3_stmt*,int iCol);
104104 int (*column_bytes)(sqlite3_stmt*,int iCol);
104105 int (*column_bytes16)(sqlite3_stmt*,int iCol);
104111 double (*column_double)(sqlite3_stmt*,int iCol);
104112 int (*column_int)(sqlite3_stmt*,int iCol);
104113 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
104120 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
104121 const void * (*column_text16)(sqlite3_stmt*,int iCol);
104122 int (*column_type)(sqlite3_stmt*,int iCol);
104123 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
107340 int iCol = pIdx->aiColumn[kk];
107341 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
107342 if( iCol>=0 && pTab->aCol[iCol].notNull ) continue;
108914 int iCol; /* Index of column matching zCol */
108918 iCol = columnIndex(pSrc->a[i].pTab, zCol);
108919 if( iCol>=0 ){
108922 *piCol = iCol;
109990 int iCol = pExpr->iColumn; /* Index of column in pTab */
110031 if( iCol>=0 && ALWAYS(iCol<pS->pEList->nExpr) ){
110032 /* If iCol is less than zero, then the expression requests the
110036 ** The ALWAYS() is because iCol>=pS->pEList->nExpr will have been
110040 Expr *p = pS->pEList->a[iCol].pExpr;
110049 if( iCol<0 ) iCol = pTab->iPKey;
110050 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
110052 if( iCol<0 ){
110056 zType = pTab->aCol[iCol].zType;
110057 zOrigCol = pTab->aCol[iCol].zName;
110058 estWidth = pTab->aCol[iCol].szEst;
110066 if( iCol<0 ){
110069 zType = pTab->aCol[iCol].zType;
110070 estWidth = pTab->aCol[iCol].szEst;
110183 int iCol = p->iColumn;
110189 if( iCol<0 ) iCol = pTab->iPKey;
110190 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
110191 if( iCol<0 ){
110194 zCol = pTab->aCol[iCol].zName;
110270 int iCol = pColExpr->iColumn;
110272 if( iCol<0 ) iCol = pTab->iPKey;
110274 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
110497 ** Return the appropriate collating sequence for the iCol-th column of
110504 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
110507 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
110511 assert( iCol>=0 );
110512 /* iCol must be less than p->pEList->nExpr. Otherwise an error would
110515 if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
110516 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
117323 int iCol;
117333 for(iCol=0; iCol<pTab->nCol; iCol++){
117334 char *zType = pTab->aCol[iCol].zType;
117362 pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN;
119825 int iCol = pPk->aiColumn[iPk];
119827 rx = sqlite3ExprCodeGetColumn(pParse, pTab, iCol, iCur,r+iPk,0);
120263 int iCol = pRight->iColumn;
120264 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
120268 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
121735 ** This function searches pList for an entry that matches the iCol-th column
121746 int iCol /* Column of index to match */
121749 const char *zColl = pIdx->azColl[iCol];
121754 && p->iColumn==pIdx->aiColumn[iCol]
121768 ** Return TRUE if the iCol-th column of index pIdx is NOT NULL
121770 static int indexColumnNotNull(Index *pIdx, int iCol){
121773 assert( iCol>=0 && iCol<pIdx->nColumn );
121774 j = pIdx->aiColumn[iCol];
122033 int iCol = pTerm->u.leftColumn;
122034 Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
122035 testcase( iCol==BMS );
122036 testcase( iCol==BMS-1 );
122040 pTable->aCol[iCol].zName);
122086 int iCol = pTerm->u.leftColumn;
122087 Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol);
122088 testcase( iCol==BMS-1 );
122089 testcase( iCol==BMS );
122360 int iCol; /* Index of required stats in anEq[] etc. */
122421 iCol = 0;
122451 iCol = n-1;
122464 assert( iCol==nField-1 );
122472 ** (iCol+1) field prefix of sample i. */
122474 pRec->nField = iCol+1;
122479 /* if i==0 and iCol==0, then record pRec is smaller than all samples
122480 ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
122481 ** be greater than or equal to the (iCol) field prefix of sample i.
122483 if( iCol>0 ){
122484 pRec->nField = iCol;
122499 assert( iCol==nField-1 );
122500 aStat[0] = aSample[i].anLt[iCol];
122501 aStat[1] = aSample[i].anEq[iCol];
122503 /* At this point, the (iCol+1) field prefix of aSample[i] is the first
122510 iUpper = aSample[i].anLt[iCol];
122524 aStat[1] = pIdx->aAvgEq[iCol];
122561 static char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
122562 assert( iCol>=0 && iCol<pIdx->nColumn );
122566 return pIdx->zColAff[iCol];
123635 int iCol = pProbe->aiColumn[saved_nEq];
123638 if( iCol==XN_ROWID
123639 || (iCol>0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1)
123641 if( iCol>=0 && pProbe->uniqNotNull==0 ){
134026 int iCol = 0;
134059 for(iCol=0; iCol<pTab->nCol; iCol++){
134060 pCol = &pTab->aCol[iCol];
134065 if( iCol==pTab->nCol ){
134067 iCol = pTab->iPKey;
134068 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
134091 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
135446 int fts3_global_term_cnt(int iTerm, int iCol);
135447 int fts3_term_cnt(int iTerm, int iCol);
135941 ** aMI[iCol*3 + 0] = Undefined
135942 ** aMI[iCol*3 + 1] = Number of occurrences
135943 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
136041 int iCol;
136126 SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **);
136976 int iCol; /* Column index */
137248 for(iCol=0; iCol<nCol; iCol++){
137251 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
137255 p->azColumn[iCol] = zCsr;
137261 for(iCol=0; iCol<nCol; iCol++){
137262 int n = (int)strlen(p->azColumn[iCol]);
137266 && 0==sqlite3_strnicmp(p->azColumn[iCol], zNot, n)
137268 p->abNotindexed[iCol] = 1;
137926 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
137927 ** the value of iCol encoded as a varint to *pp. This will start a new
137931 ** returning (do not modify it if iCol==0). Return the total number of bytes
137932 ** written (0 if iCol==0).
137934 static int fts3PutColNumber(char **pp, int iCol){
137936 if( iCol ){
137938 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
138488 sqlite3_int64 iCol;
138490 p += sqlite3Fts3GetVarint(p, &iCol);
138497 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
138886 filter.iCol = iColumn;
139064 int iCol = eSearch-FTS3_FULLTEXT_SEARCH;
139076 p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr,
139150 ** (iCol < p->nColumn) -> The value of the iCol'th user column.
139151 ** (iCol == p->nColumn) -> Magic column with the same name as the table.
139152 ** (iCol == p->nColumn+1) -> Docid column
139153 ** (iCol == p->nColumn+2) -> Langid column
139158 int iCol /* Index of column to read value from */
139165 assert( iCol>=0 && iCol<=p->nColumn+2 );
139167 if( iCol==p->nColumn+1 ){
139172 }else if( iCol==p->nColumn ){
139176 }else if( iCol==p->nColumn+2 && pCsr->pExpr ){
139184 if( iCol==p->nColumn+2 ){
139190 }else if( sqlite3_data_count(pCsr->pStmt)>(iCol+1) ){
139191 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
139413 int iCol = -1;
139430 case 5: iCol = sqlite3_value_int(apVal[4]);
139440 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
140117 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
140122 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
140536 int iCol; /* The column the token must match */
140564 pTC->iCol = pPhrase->iColumn;
140744 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
140760 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
141405 int iCol = 0;
141417 /* aMI[iCol*3 + 1] = Number of occurrences
141418 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
141420 pExpr->aMI[iCol*3 + 1] += iCnt;
141421 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
141424 p += fts3GetVarint32(p, &iCol);
141538 ** aiOut[iCol*3 + 1] = Number of occurrences
141539 ** aiOut[iCol*3 + 2] = Number of rows containing at least one instance
141562 int iCol;
141566 for(iCol=0; iCol<pTab->nColumn; iCol++){
141567 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
141568 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
141574 for(iCol=0; iCol<pTab->nColumn; iCol++){
141575 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
141576 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
141589 ** a position-list indicating the occurrences of the phrase in column iCol
141606 int iCol, /* Column to return position list for */
141616 ** column iCol, return a NULL pointer. */
141618 assert( iCol>=0 && iCol<pTab->nColumn );
141619 if( (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol) ){
141716 while( iThis<iCol ){
141726 *ppOut = ((iCol==iThis)?pIter:0);
141818 int iCol; /* Current value of 'col' column */
141955 int iCol = pInfo->aConstraint[i].iColumn;
141957 if( iCol==0 ){
141964 if( iCol==4 ){
142055 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
142056 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
142064 int iCol;
142079 iCol = 0;
142090 iCol = 0;
142102 assert( iCol==0 );
142115 pCsr->aStat[iCol+1].nOcc++;
142122 iCol = (int)v;
142123 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
142124 pCsr->aStat[iCol+1].nDoc++;
142130 pCsr->iCol = 0;
142247 int iCol /* Index of column to read value from */
142252 switch( iCol ){
142258 if( p->iCol ){
142259 sqlite3_result_int(pCtx, p->iCol-1);
142266 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
142270 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
142274 assert( iCol==4 );
142511 int iCol, /* Value for Fts3Phrase.iColumn */
142546 pRet->pPhrase->iColumn = iCol;
142744 int iCol;
142855 iCol = pParse->iDefaultCol;
142863 iCol = ii;
142868 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
145810 int iCol /* Index of column to read value from */
145815 switch( iCol ){
145829 assert( iCol==4 );
146002 int iCol; /* Column token must occur in */
146573 sqlite3_int64 iCol, /* Column for entry to add */
146596 if( iCol>0 && p->iLastCol!=iCol ){
146598 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
146602 p->iLastCol = iCol;
146605 if( iCol>=0 ){
146634 int iCol,
146647 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
146666 ** p->iPrevDocid, and the column is specified by argument iCol.
146674 int iCol, /* Column into which text is being inserted */
146724 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
146733 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
146810 int iCol = i-2;
146811 if( p->abNotindexed[iCol]==0 ){
146813 int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]);
146966 int iCol = i-1;
146967 if( p->abNotindexed[iCol]==0 ){
146969 rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]);
148455 ** identify the subset of the position list that corresponds to column iCol.
148457 ** If there are no entries in the input position list for column iCol, then
148464 int iCol, /* Column to filter on */
148475 assert( iCol>=0 );
148480 if( iCol==iCurrent ){
148637 int iCol, /* Column to match on. */
148671 assert( iCol<0 || iCol<p->nColumn );
148672 pCsr->iColFilter = iCol;
148825 fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList);
148905 ** Decode the "end_block" field, selected by column iCol of the SELECT
148916 int iCol,
148920 const unsigned char *zText = sqlite3_column_text(pStmt, iCol);
149412 int iCol;
149416 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
149417 if( p->abNotindexed[iCol]==0 ){
149418 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
149419 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
149420 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
149431 for(iCol=0; iCol<=p->nColumn; iCol++){
149432 aSzIns[iCol] += aSz[iCol];
150939 int iCol, /* Column number */
150947 ret += (ret<<3) + iCol;
150994 i64 iCol = 0;
151003 iCol = 0;
151006 pCsr += sqlite3Fts3GetVarint(pCsr, &iCol);
151015 (int)iCol, (int)iPos
151077 int iCol;
151079 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
151080 if( p->abNotindexed[iCol]==0 ){
151081 const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1);
151082 int nText = sqlite3_column_bytes(pStmt, iCol+1);
151096 zToken, nToken, iLang, 0, iDocid, iCol, iPos
151101 zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos
151269 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
151326 int iCol /* Column that token must appear in (or -1) */
151336 pDeferred->iCol = iCol;
151626 int iCol; /* Extract snippet from this column */
151643 int iCol; /* Column snippet is extracted from */
152038 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr);
152060 ** from column iCol that represent the "best" snippet. The best snippet
152076 int iCol, /* Index of column to create snippet from */
152113 sIter.iCol = iCol;
152130 pFragment->iCol = iCol;
152295 int iCol = pFragment->iCol+1; /* Query column to extract text from */
152299 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
152301 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
152306 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
152429 int iCol = 0;
152440 if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){
152442 p->aMatchinfo[iStart + iCol] = (u32)nHit;
152444 p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F));
152450 pIter += fts3GetVarint32(pIter, &iCol);
152484 ** for(iCol=0; iCol<nCol; iCol++){
152485 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
152486 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
152489 ** where X is the number of matches for phrase iPhrase is column iCol of all
152490 ** rows of the table. Y is the number of rows for which column iCol contains
152633 ** If LcsIterator.iCol is set to the following value, the iterator has
152684 int iCol;
152701 for(iCol=0; iCol<pInfo->nCol; iCol++){
152708 rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
152741 pInfo->aMatchinfo[iCol] = nLcs;
152802 int iCol;
152803 for(iCol=0; iCol<pInfo->nCol; iCol++){
152808 pInfo->aMatchinfo[iCol] = iVal;
152818 int iCol;
152820 for(iCol=0; iCol<pInfo->nCol; iCol++){
152823 pInfo->aMatchinfo[iCol] = (u32)nToken;
152968 int iCol, /* Extract snippet from this column */
153013 ** If the iCol argument to this function was negative, this means all
153014 ** columns of the FTS3 table. Otherwise, only column iCol is considered.
153019 if( iCol>=0 && iRead!=iCol ) continue;
153072 int iCol; /* Column of table to populate aTerm for */
153090 rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pList);
153118 int iCol; /* Column currently being processed */
153146 for(iCol=0; iCol<pTab->nColumn; iCol++){
153156 /* Initialize the contents of sCtx.aTerm[] for column iCol. There is
153160 sCtx.iCol = iCol;
153164 /* Retreive the text stored in column iCol. If an SQL NULL is stored
153165 ** in column iCol, jump immediately to the next iteration of the loop.
153170 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
153171 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
153173 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
153180 /* Initialize a tokenizer iterator to iterate through column iCol. */
153216 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
160535 int iCol;
160538 for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
160540 const char *zCol = pIter->azTblCol[iCol];
160547 if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
160553 zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
160554 (pIter->abNotNull[iCol] ? " NOT NULL" : "")
161294 int iCol = p->objiter.nCol; /* Index of rbu_control column */
161297 switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
161299 int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
161313 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
161336 ** Assert that column iCol of statement pStmt is named zName.
161338 static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
161339 const char *zCol = sqlite3_column_name(pStmt, iCol);
165681 ** xColumnTotalSize(pFts, iCol, pnToken):
165682 ** If parameter iCol is less than zero, set output variable *pnToken
165683 ** to the total number of tokens in the FTS5 table. Or, if iCol is
165685 ** the total number of tokens in column iCol, considering all rows in
165688 ** If parameter iCol is greater than or equal to the number of columns
165696 ** xColumnSize(pFts, iCol, pnToken):
165697 ** If parameter iCol is less than zero, set output variable *pnToken
165698 ** to the total number of tokens in the current row. Or, if iCol is
165700 ** *pnToken to the number of tokens in column iCol of the current row.
165702 ** If parameter iCol is greater than or equal to the number of columns
165708 ** This function attempts to retrieve the text of column iCol of the
165817 ** int iCol, iOff;
165818 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
165820 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
165822 ** // An instance of phrase iPhrase at offset iOff of column iCol
165839 int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken);
165854 int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn);
165855 int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken);
166405 i64 iPos; /* (iCol<<32) + iPos */
166510 ** unique token in the document with an iCol value less than zero. The iPos
166515 int iCol, /* Column token appears in (-ve -> delete) */
166638 int iCol, /* Column token appears in (-ve -> delete) */
166701 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnAvg);
168062 ** for(rc = fts5CInstIterNext(pApi, pFts, iCol, &iter);
168074 int iCol; /* Column to search */
168096 if( ic==pIter->iCol ){
168116 ** iterate through coalesced phrase instances in column iCol.
168121 int iCol,
168129 pIter->iCol = iCol;
168243 int iCol;
168251 iCol = sqlite3_value_int(apVal[0]);
168255 rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
168259 rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
168292 iCol; /* 1st argument to snippet() */
168312 iCol = sqlite3_value_int(apVal[0]);
168319 iBestCol = (iCol>=0 ? iCol : 0);
168333 if( rc==SQLITE_OK && (iCol<0 || iSnippetCol==iCol) ){
171433 ** number iCol appended.
171441 int iCol /* New column to add to colset object */
171447 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
171456 if( aiCol[i]==iCol ) return pNew;
171457 if( aiCol[i]>iCol ) break;
171462 aiCol[i] = iCol;
171480 int iCol;
171487 for(iCol=0; iCol<pConfig->nCol; iCol++){
171488 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
171490 if( iCol==pConfig->nCol ){
171493 pRet = fts5ParseColset(pParse, pColset, iCol);
171731 int iCol = pNear->pColset->aiCol[0];
171732 zRet = fts5PrintfAppend(zRet, "%s : ", pConfig->azCol[iCol]);
172067 int iCol; /* Column of last value written */
172209 int iCol, /* Column token appears in (-ve -> delete) */
172290 p->iCol = 0;
172295 if( iCol>=0 ){
172297 assert( iCol>=p->iCol );
172298 if( iCol!=p->iCol ){
172300 p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
172301 p->iCol = iCol;
176432 static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
176435 if( pColset->aiCol[i]==iCol ) return 1;
176454 int iCol;
176455 fts5FastGetVarint32(pChunk, i, iCol);
176456 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
176473 int iCol;
176479 fts5FastGetVarint32(pChunk, i, iCol);
176480 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
176519 ** the position list contains entries for column iCol, then (*pa) is set
176522 ** contain any entries for column iCol, return 0.
176527 int iCol /* Column to extract from poslist */
176534 while( iCol!=iCurrent ){
177021 ** unique token in the document with an iCol value less than zero. The iPos
177026 int iCol, /* Column token appears in (-ve -> delete) */
177035 assert( (iCol<0)==p->bDelete );
177039 p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
177046 p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX+i+1, pToken, nByte
177287 int iCol;
177289 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
177290 i += fts5GetVarint(&pData->p[i], (u64*)&anSize[iCol]);
177362 int iCol,
177370 ret += (ret<<3) + iCol;
177446 int iCol = FTS5_POS2COLUMN(sReader.iPos);
177448 cksum ^= fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
177808 int iCol = FTS5_POS2COLUMN(iPos);
177810 cksum2 ^= fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
177833 int iCol, /* Column term appears in */
177840 ret = fts5IndexEntryCksum(iRowid, iCol, iPos, 0, pTerm, nTerm);
177845 ret ^= fts5IndexEntryCksum(iRowid, iCol, iPos, iIdx+1, pTerm, nByte);
178712 int iCol; /* 0==rowid, 1==tbl, 2==rank */
178738 if( p->iColumn==aColMap[pC->iCol] && p->op & pC->op ){
179779 int iCol,
179784 return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
179935 int iCol,
179947 *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
179948 *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
179969 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
180004 if( iCol<0 ){
180010 }else if( iCol<pConfig->nCol ){
180011 *pnToken = pCsr->aColumnSize[iCol];
180296 int iCol /* Index of column to read value from */
180306 if( iCol==pConfig->nCol ){
180311 if( iCol==pConfig->nCol ){
180317 }else if( iCol==pConfig->nCol+1 ){
180333 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
181061 int iCol;
181081 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
181099 int iCol;
181102 ctx.iCol = -1;
181104 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
181105 if( pConfig->abUnindexed[iCol-1] ) continue;
181109 (const char*)sqlite3_column_text(pSeek, iCol),
181110 sqlite3_column_bytes(pSeek, iCol),
181114 p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
181255 int iCol;
181258 ctx.iCol = -1;
181261 for(iCol=0; rc==SQLITE_OK && iCol<pConfig->nCol; iCol++){
181262 if( pConfig->abUnindexed[iCol] ) continue;
181266 (const char*)sqlite3_value_text(apVal[iCol]),
181267 sqlite3_value_bytes(apVal[iCol]),
181271 p->aTotalSize[iCol] -= (i64)ctx.szCol;
181351 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
181353 if( pConfig->abUnindexed[ctx.iCol]==0 ){
181356 (const char*)sqlite3_column_text(pScan, ctx.iCol+1),
181357 sqlite3_column_bytes(pScan, ctx.iCol+1),
181363 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
181480 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
181482 if( pConfig->abUnindexed[ctx.iCol]==0 ){
181485 (const char*)sqlite3_value_text(apVal[ctx.iCol+2]),
181486 sqlite3_value_bytes(apVal[ctx.iCol+2]),
181492 p->aTotalSize[ctx.iCol] += (i64)ctx.szCol;
181541 int iCol;
181563 pCtx->pConfig, pCtx->iRowid, pCtx->iCol, pCtx->szCol-1, pToken, nToken
181603 ctx.iCol = i;
181748 static int sqlite3Fts5StorageSize(Fts5Storage *p, int iCol, i64 *pnToken){
181752 if( iCol<0 ){
181757 }else if( iCol<p->pConfig->nCol ){
181758 *pnToken = p->aTotalSize[iCol];
183817 int iCol;
184083 for(pCsr->iCol++; pCsr->iCol<pCsr->nCol; pCsr->iCol++){
184084 if( pCsr->aCnt[pCsr->iCol] ) break;
184088 if( pTab->eType==FTS5_VOCAB_ROW || pCsr->iCol>=pCsr->nCol ){
184100 pCsr->iCol = 0;
184117 int iCol = -1;
184121 if( iCol!=ii ){
184123 iCol = ii;
184139 while( pCsr->aCnt[pCsr->iCol]==0 ) pCsr->iCol++;
184140 pCsr->aVal[0] = pCsr->iCol;
184141 pCsr->aVal[1] = pCsr->aDoc[pCsr->iCol];
184142 pCsr->aVal[2] = pCsr->aCnt[pCsr->iCol];
184182 int iCol /* Index of column to read value from */
184185 switch( iCol ){
184193 assert( iCol<4 && iCol>0 );
184194 sqlite3_result_int64(pCtx, pCsr->aVal[iCol-1]);
