Lines Matching defs:iCol
4236 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
4237 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
4238 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
4239 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
4240 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
4241 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
4242 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
4243 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
4244 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
4245 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
63433 ** Check to see if column iCol of the given statement is valid. If
63435 ** If iCol is not valid, return a pointer to a Mem which has a value
71202 int iCol; /* Table column this handle is open on */
71240 u32 type = v->apCsr[0]->aType[p->iCol];
71249 p->iOffset = v->apCsr[0]->aOffset[p->iCol];
71291 int iCol; /* Index of zColumn in row-record */
71372 for(iCol=0; iCol<pTab->nCol; iCol++) {
71373 if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
71377 if( iCol==pTab->nCol ){
71402 if( pFKey->aCol[j].iFrom==iCol ){
71412 if( pIdx->aiColumn[j]==iCol ){
71481 pBlob->iCol = iCol;
73188 ** Turn the pExpr expression into an alias for the iCol-th column of the
73217 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
73221 Expr *pOrig; /* The iCol-th column of the result set */
73225 assert( iCol>=0 && iCol<pEList->nExpr );
73226 pOrig = pEList->a[iCol].pExpr;
73234 if( pEList->a[iCol].iAlias==0 ){
73235 pEList->a[iCol].iAlias = (u16)(++pParse->nAlias);
73237 pDup->iTable = pEList->a[iCol].iAlias;
73414 int iCol;
73417 for(iCol=0; iCol<pTab->nCol; iCol++){
73418 Column *pCol = &pTab->aCol[iCol];
73420 if( iCol==pTab->iPKey ){
73421 iCol = -1;
73426 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
73427 iCol = -1; /* IMP: R-44911-55124 */
73429 if( iCol<pTab->nCol ){
73431 if( iCol<0 ){
73434 testcase( iCol==31 );
73435 testcase( iCol==32 );
73436 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73438 testcase( iCol==31 );
73439 testcase( iCol==32 );
73440 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73442 pExpr->iColumn = (i16)iCol;
73577 ** Allocate and return a pointer to an expression to load the column iCol
73580 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
73586 if( p->pTab->iPKey==iCol ){
73589 p->iColumn = (ynVar)iCol;
73590 testcase( iCol==BMS );
73591 testcase( iCol==BMS-1 );
73592 pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
73939 int iCol = -1;
73943 if( sqlite3ExprIsInteger(pE, &iCol) ){
73944 if( iCol<=0 || iCol>pEList->nExpr ){
73949 iCol = resolveAsName(pParse, pEList, pE);
73950 if( iCol==0 ){
73954 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
73959 if( iCol>0 ){
73967 pE->u.iValue = iCol;
73968 pItem->iOrderByCol = (u16)iCol;
73989 ** result set expression (as determined by the ExprList.a.iCol field)
74053 int iCol; /* Column number */
74063 iCol = resolveAsName(pParse, pSelect->pEList, pE);
74064 if( iCol>0 ){
74066 ** a copy of the iCol-th result-set column. The subsequent call to
74068 ** copy of the iCol-th result-set expression. */
74069 pItem->iOrderByCol = (u16)iCol;
74072 if( sqlite3ExprIsInteger(pE, &iCol) ){
74076 if( iCol<1 ){
74080 pItem->iOrderByCol = (u16)iCol;
75853 int iCol; /* Index of column <column> */
75862 iCol = pExpr->iColumn;
75874 if( iCol<0 ){
75896 int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
75899 if( (pIdx->aiColumn[0]==iCol)
75915 if( prNotFound && !pTab->aCol[iCol].notNull ){
76404 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
76411 assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
76427 if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
76435 assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
76444 p->iColumn = iCol;
76465 p->iColumn = iCol;
76535 ** Generate code to extract the value of the iCol-th column of a table.
76541 int iCol, /* Index of the column to extract */
76544 if( iCol<0 || iCol==pTab->iPKey ){
76548 sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
76550 if( iCol>=0 ){
76551 sqlite3ColumnDefault(v, pTab, iCol, regOut);
81090 int iCol; /* Index of column in table */
81112 iCol = pExpr->iColumn;
81115 if( iCol>=0 ){
81116 assert( iCol<pTab->nCol );
81117 zCol = pTab->aCol[iCol].zName;
82340 int iCol = -1, i;
82349 iCol = pTab->nCol - 1;
82350 pTab->aCol[iCol].isPrimKey = 1;
82353 for(iCol=0; iCol<pTab->nCol; iCol++){
82354 if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
82358 if( iCol<pTab->nCol ){
82359 pTab->aCol[iCol].isPrimKey = 1;
82362 if( pList->nExpr>1 ) iCol = -1;
82364 if( iCol>=0 && iCol<pTab->nCol ){
82365 zType = pTab->aCol[iCol].zType;
82369 pTab->iPKey = iCol;
83411 int iCol = p->nCol-1;
83412 if( NEVER(iCol<0) ) goto fk_end;
83416 p->aCol[iCol].zName, pTo);
85977 int iCol; /* Iterator used while populating OLD.* */
85991 for(iCol=0; iCol<pTab->nCol; iCol++){
85992 if( mask==0xffffffff || mask&(1<<iCol) ){
85993 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);
87990 int iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
87997 zDfltColl = pParent->aCol[iCol].zColl;
88003 zIdxCol = pParent->aCol[iCol].zName;
88246 int iCol; /* Index of column in child table */
88255 iCol = pIdx->aiColumn[i];
88256 pCol = &pTab->aCol[iCol];
88257 if( pTab->iPKey==iCol ) iCol = -1;
88258 pLeft->iTable = regData+iCol+1;
88266 iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
88267 assert( iCol>=0 );
88268 zCol = pFKey->pFrom->aCol[iCol].zName;
88464 int iCol;
88503 iCol = pFKey->aCol[0].iFrom;
88504 aiCol = &iCol;
91029 const void * (*column_blob)(sqlite3_stmt*,int iCol);
91030 int (*column_bytes)(sqlite3_stmt*,int iCol);
91031 int (*column_bytes16)(sqlite3_stmt*,int iCol);
91037 double (*column_double)(sqlite3_stmt*,int iCol);
91038 int (*column_int)(sqlite3_stmt*,int iCol);
91039 sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
91046 const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
91047 const void * (*column_text16)(sqlite3_stmt*,int iCol);
91048 int (*column_type)(sqlite3_stmt*,int iCol);
91049 sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
94715 int iCol; /* Index of column matching zCol */
94719 iCol = columnIndex(pSrc->a[i].pTab, zCol);
94720 if( iCol>=0 ){
94723 *piCol = iCol;
95526 int iCol = pExpr->iColumn; /* Index of column in pTab */
95567 if( iCol>=0 && ALWAYS(iCol<pS->pEList->nExpr) ){
95568 /* If iCol is less than zero, then the expression requests the
95573 Expr *p = pS->pEList->a[iCol].pExpr;
95582 if( iCol<0 ) iCol = pTab->iPKey;
95583 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95584 if( iCol<0 ){
95588 zType = pTab->aCol[iCol].zType;
95589 zOriginCol = pTab->aCol[iCol].zName;
95703 int iCol = p->iColumn;
95709 if( iCol<0 ) iCol = pTab->iPKey;
95710 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95711 if( iCol<0 ){
95714 zCol = pTab->aCol[iCol].zName;
95783 int iCol = pColExpr->iColumn;
95785 if( iCol<0 ) iCol = pTab->iPKey;
95787 iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
95999 ** Return the appropriate collating sequence for the iCol-th column of
96006 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
96009 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
96013 assert( iCol>=0 );
96014 if( pRet==0 && iCol<p->pEList->nExpr ){
96015 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
101962 int iCol;
101971 for(iCol=0; iCol<pTab->nCol; iCol++){
101972 char *zType = pTab->aCol[iCol].zType;
101997 pTab->aCol[iCol].isHidden = 1;
103235 int iCol = pRight->iColumn;
103236 pVal = sqlite3VdbeGetValue(pReprepare, iCol, SQLITE_AFF_NONE);
103240 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
103960 ** uses the same collation sequence as the iCol'th column of index pIdx.
103972 int iCol /* Column of index to match */
103975 const char *zColl = pIdx->azColl[iCol];
103980 && p->iColumn==pIdx->aiColumn[iCol]
104098 int iCol = pIdx->aiColumn[i];
104099 if( 0==findTerm(pWC, iBase, iCol, ~(Bitmask)0, WO_EQ, pIdx)
104566 int iCol = pTerm->u.leftColumn;
104567 Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol;
104568 testcase( iCol==BMS );
104569 testcase( iCol==BMS-1 );
104617 int iCol = pTerm->u.leftColumn;
104618 Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol;
115019 int iCol;
115044 iCol = pTab->iPKey;
115045 if( iCol>=0 ){
115046 pCol = &pTab->aCol[iCol];
115049 for(iCol=0; iCol<pTab->nCol; iCol++){
115050 pCol = &pTab->aCol[iCol];
115055 if( iCol==pTab->nCol ){
115076 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
116311 int fts3_global_term_cnt(int iTerm, int iCol);
116312 int fts3_term_cnt(int iTerm, int iCol);
116755 ** aMI[iCol*3 + 0] = Undefined
116756 ** aMI[iCol*3 + 1] = Number of occurrences
116757 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
116843 int iCol;
116918 SQLITE_PRIVATE char *sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol);
117688 int iCol; /* Column index */
117938 for(iCol=0; iCol<nCol; iCol++){
117941 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
117945 p->azColumn[iCol] = zCsr;
118516 ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
118517 ** the value of iCol encoded as a varint to *pp. This will start a new
118521 ** returning (do not modify it if iCol==0). Return the total number of bytes
118522 ** written (0 if iCol==0).
118524 static int fts3PutColNumber(char **pp, int iCol){
118526 if( iCol ){
118528 n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
119065 sqlite3_int64 iCol;
119067 p += sqlite3Fts3GetVarint(p, &iCol);
119074 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
119454 filter.iCol = iColumn;
119586 int iCol = idxNum-FTS3_FULLTEXT_SEARCH;
119597 p->azColumn, p->bHasStat, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr
119671 ** (iCol < p->nColumn) -> The value of the iCol'th user column.
119672 ** (iCol == p->nColumn) -> Magic column with the same name as the table.
119673 ** (iCol == p->nColumn+1) -> Docid column
119674 ** (iCol == p->nColumn+2) -> Langid column
119679 int iCol /* Index of column to read value from */
119686 assert( iCol>=0 && iCol<=p->nColumn+2 );
119688 if( iCol==p->nColumn+1 ){
119693 }else if( iCol==p->nColumn ){
119697 }else if( iCol==p->nColumn+2 && pCsr->pExpr ){
119705 if( iCol==p->nColumn+2 ){
119711 }else if( sqlite3_data_count(pCsr->pStmt)>(iCol+1) ){
119712 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
119849 int iCol = -1;
119866 case 5: iCol = sqlite3_value_int(apVal[4]);
119874 sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
120496 int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
120498 pTab, pFirst->pSegcsr, iCol, pFirst->z, pFirst->n);
120705 int iCol; /* The column the token must match */
120733 pTC->iCol = pPhrase->iColumn;
120913 rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
120929 rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
121530 int iCol = 0;
121542 /* aMI[iCol*3 + 1] = Number of occurrences
121543 ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
121545 pExpr->aMI[iCol*3 + 1] += iCnt;
121546 pExpr->aMI[iCol*3 + 2] += (iCnt>0);
121549 p += sqlite3Fts3GetVarint32(p, &iCol);
121664 ** aiOut[iCol*3 + 1] = Number of occurrences
121665 ** aiOut[iCol*3 + 2] = Number of rows containing at least one instance
121688 int iCol;
121692 for(iCol=0; iCol<pTab->nColumn; iCol++){
121693 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
121694 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
121700 for(iCol=0; iCol<pTab->nColumn; iCol++){
121701 aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
121702 aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
121715 ** a position-list indicating the occurrences of the phrase in column iCol
121732 int iCol /* Column to return position list for */
121739 assert( iCol>=0 && iCol<pTab->nColumn );
121743 || (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol)
121755 while( iThis<iCol ){
121762 return ((iCol==iThis)?pIter:0);
121847 int iCol; /* Current value of 'col' column */
122056 for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
122057 if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
122065 int iCol;
122080 iCol = 0;
122091 iCol = 0;
122103 assert( iCol==0 );
122116 pCsr->aStat[iCol+1].nOcc++;
122123 iCol = (int)v;
122124 if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
122125 pCsr->aStat[iCol+1].nDoc++;
122131 pCsr->iCol = 0;
122214 int iCol /* Index of column to read value from */
122219 if( iCol==0 ){ /* Column "term" */
122221 }else if( iCol==1 ){ /* Column "col" */
122222 if( p->iCol ){
122223 sqlite3_result_int(pContext, p->iCol-1);
122227 }else if( iCol==2 ){ /* Column "documents" */
122228 sqlite3_result_int64(pContext, p->aStat[p->iCol].nDoc);
122230 sqlite3_result_int64(pContext, p->aStat[p->iCol].nOcc);
122459 int iCol, /* Value for Fts3Phrase.iColumn */
122487 pRet->pPhrase->iColumn = iCol;
122690 int iCol;
122807 iCol = pParse->iDefaultCol;
122815 iCol = ii;
122820 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
125146 int iCol; /* Column token must occur in */
125644 sqlite3_int64 iCol, /* Column for entry to add */
125667 if( iCol>0 && p->iLastCol!=iCol ){
125669 || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
125673 p->iLastCol = iCol;
125676 if( iCol>=0 ){
125705 int iCol,
125718 if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
125737 ** p->iPrevDocid, and the column is specified by argument iCol.
125745 int iCol, /* Column into which text is being inserted */
125795 p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
125804 p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
127419 ** identify the subset of the position list that corresponds to column iCol.
127421 ** If there are no entries in the input position list for column iCol, then
127425 int iCol, /* Column to filter on */
127435 assert( iCol>=0 );
127440 if( iCol==iCurrent ){
127594 int iCol, /* Column to match on. */
127628 assert( iCol<0 || iCol<p->nColumn );
127629 pCsr->iColFilter = iCol;
127782 fts3ColumnFilter(pFilter->iCol, &pList, &nList);
128192 int iCol;
128196 for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
128197 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
128198 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
128199 aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
128209 for(iCol=0; iCol<=p->nColumn; iCol++){
128210 aSzIns[iCol] += aSz[iCol];
128327 if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
128383 int iCol /* Column that token must appear in (or -1) */
128393 pDeferred->iCol = iCol;
128668 int iCol; /* Extract snippet from this column */
128685 int iCol; /* Column snippet is extracted from */
128976 pCsr = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
128995 ** from column iCol that represent the "best" snippet. The best snippet
129011 int iCol, /* Index of column to create snippet from */
129048 sIter.iCol = iCol;
129064 pFragment->iCol = iCol;
129227 int iCol = pFragment->iCol+1; /* Query column to extract text from */
129233 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
129235 if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
129240 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
129347 ** for(iCol=0; iCol<nCol; iCol++){
129348 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
129349 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
129352 ** where X is the number of matches for phrase iPhrase is column iCol of all
129353 ** rows of the table. Y is the number of rows for which column iCol contains
129485 ** If LcsIterator.iCol is set to the following value, the iterator has
129536 int iCol;
129553 for(iCol=0; iCol<pInfo->nCol; iCol++){
129559 pIt->pRead = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol);
129591 pInfo->aMatchinfo[iCol] = nLcs;
129652 int iCol;
129653 for(iCol=0; iCol<pInfo->nCol; iCol++){
129658 pInfo->aMatchinfo[iCol] = iVal;
129668 int iCol;
129670 for(iCol=0; iCol<pInfo->nCol; iCol++){
129673 pInfo->aMatchinfo[iCol] = (u32)nToken;
129792 int iCol, /* Extract snippet from this column */
129837 ** If the iCol argument to this function was negative, this means all
129838 ** columns of the FTS3 table. Otherwise, only column iCol is considered.
129843 if( iCol>=0 && iRead!=iCol ) continue;
129896 int iCol; /* Column of table to populate aTerm for */
129913 pList = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
129943 int iCol; /* Column currently being processed */
129971 for(iCol=0; iCol<pTab->nColumn; iCol++){
129979 /* Initialize the contents of sCtx.aTerm[] for column iCol. There is
129983 sCtx.iCol = iCol;
129987 /* Retreive the text stored in column iCol. If an SQL NULL is stored
129988 ** in column iCol, jump immediately to the next iteration of the loop.
129993 zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
129994 nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
129996 if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
130003 /* Initialize a tokenizer iterator to iterate through column iCol. */
130039 "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
