Lines Matching defs:nCol
12195 i16 nCol; /* Number of columns in this table */
12287 int nCol; /* Number of columns in this key */
12295 } aCol[1]; /* One entry for each of nCol columns */
12396 ** In the Table structure describing Ex1, nCol==3 because there are
66099 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
66101 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
66106 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
66109 for(i=0; i<nCol; i++){
66640 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
66643 for(i=0; i<nCol; i++){
79827 for(iCol=0; iCol<pTab->nCol; iCol++) {
79832 if( iCol==pTab->nCol ){
79856 for(j=0; j<pFKey->nCol; j++){
79921 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
79922 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
83745 assert( pTab->nCol>0 );
83773 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
83824 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
83832 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
83837 if( iCol<pTab->nCol ){
85055 assert( pExpr->pTab && j<pExpr->pTab->nCol );
88062 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
88065 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
88067 assert( p1>=0 && p1<(pTab->nCol*2+2) );
89849 pCol = &pNew->aCol[pNew->nCol-1];
90002 pNew->nCol = pTab->nCol;
90003 assert( pNew->nCol>0 );
90004 nAlloc = (((pNew->nCol-1)/8)*8)+8;
90005 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
90012 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
90013 for(i=0; i<pNew->nCol; i++){
90323 int nCol; /* Number of columns in index + pk/rowid */
90328 Stat4Sample *aBest; /* Array of nCol best samples */
90384 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
90385 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
90386 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
90402 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
90438 int nCol; /* Number of columns in index being sampled */
90440 int nColUp; /* nCol rounded up for alignment */
90449 nCol = sqlite3_value_int(argv[0]);
90450 assert( nCol>0 );
90451 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
90453 assert( nKeyCol<=nCol );
90462 + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */
90463 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
90475 p->nCol = nCol;
90489 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
90494 pSpace = (u8*)(&p->a[mxSample+nCol]);
90495 for(i=0; i<(mxSample+nCol); i++){
90502 for(i=0; i<nCol; i++){
90544 int nCol = pAccum->nCol;
90547 for(i=pNew->iCol+1; i<nCol; i++){
90646 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
90686 for(i=(p->nCol-2); i>=iChng; i--){
90697 for(j=iChng; j<p->nCol; j++){
90759 assert( p->nCol>0 );
90760 assert( iChng<p->nCol );
90764 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
90774 for(i=iChng; i<p->nCol; i++){
90795 tRowcnt nLt = p->current.anLt[p->nCol-1];
90801 sampleInsert(p, &p->current, p->nCol-1);
90806 for(i=0; i<(p->nCol-1); i++){
90941 char *zRet = sqlite3MallocZero(p->nCol * 25);
90947 for(i=0; i<p->nCol; i++){
91058 int nCol; /* Number of columns in pIdx. "N" */
91067 nCol = pIdx->nKeyCol;
91069 nColTest = nCol - 1;
91071 nCol = pIdx->nColumn;
91073 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
91137 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
91227 assert( k>=0 && k<pTab->nCol );
91257 int regSampleRowid = regCol + nCol;
91262 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
91279 for(i=0; i<nCol; i++){
91282 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
91560 int nCol = pIndex->nKeyCol+1;
91566 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
91572 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
91621 int nCol = 1;
91627 nCol = pIdx->nSampleCol-1;
91628 pIdx->aAvgEq[nCol] = 1;
91630 for(iCol=0; iCol<nCol; iCol++){
91782 int nCol = 1; /* Number of columns in index */
91790 nCol = pIdx->nSampleCol;
91791 if( bStat3 && nCol>1 ) continue;
91797 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
91798 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
91799 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
92697 assert( iCol<pTab->nCol );
92700 assert( pTab->iPKey<pTab->nCol );
93364 for(i=0; i<pTable->nCol; i++, pCol++){
93863 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
93870 for(i=0; i<p->nCol; i++){
93877 if( (p->nCol & 0x7)==0 ){
93879 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
93886 pCol = &p->aCol[p->nCol];
93896 p->nCol++;
93908 if( p==0 || NEVER(p->nCol<1) ) return;
93909 p->aCol[p->nCol-1].notNull = (u8)onError;
94013 if( p==0 || NEVER(p->nCol<1) ) return;
94014 pCol = &p->aCol[p->nCol-1];
94037 pCol = &(p->aCol[p->nCol-1]);
94117 iCol = pTab->nCol - 1;
94129 for(iCol=0; iCol<pTab->nCol; iCol++){
94203 i = p->nCol-1;
94352 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
94365 n += 35 + 6*p->nCol;
94375 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
94442 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
94458 assert( x<pIdx->pTable->nCol );
94464 /* Return true if value x is found any of the first nCol entries of aiCol[]
94466 static int hasColumn(const i16 *aiCol, int nCol, int x){
94467 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
94598 if( nPk<pTab->nCol ){
94599 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
94600 for(i=0, j=nPk; i<pTab->nCol; i++){
94609 assert( pTab->nCol==j );
94611 pPk->nColumn = pTab->nCol;
94770 p->nCol = pSelTab->nCol;
94772 pSelTab->nCol = 0;
94964 /* A positive nCol means the columns names for this view are
94967 if( pTable->nCol>0 ) return 0;
94969 /* A negative nCol is a special marker meaning that we are currently
94971 ** a negative nCol, it means two or more views form a loop, like this:
94984 if( pTable->nCol<0 ){
94988 assert( pTable->nCol>=0 );
95002 &pTable->nCol, &pTable->aCol);
95008 pTable->nCol = -1;
95021 pTable->nCol = pSelTab->nCol;
95023 pSelTab->nCol = 0;
95028 pTable->nCol = 0;
95056 pTab->nCol = 0;
95422 int nCol;
95428 int iCol = p->nCol-1;
95436 nCol = 1;
95443 nCol = pFromCol->nExpr;
95445 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
95457 z = (char*)&pFKey->aCol[nCol];
95463 pFKey->nCol = nCol;
95465 pFKey->aCol[0].iFrom = p->nCol-1;
95467 for(i=0; i<nCol; i++){
95469 for(j=0; j<p->nCol; j++){
95475 if( j>=p->nCol ){
95484 for(i=0; i<nCol; i++){
95631 ** Allocate heap space to hold an Index object with nCol columns.
95639 i16 nCol, /* Total number of columns in the index */
95647 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
95648 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
95649 sizeof(i16)*nCol + /* Index.aiColumn */
95650 sizeof(u8)*nCol); /* Index.aSortOrder */
95654 p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
95655 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
95656 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
95658 p->nColumn = nCol;
95659 p->nKeyCol = nCol - 1;
95861 prevCol.z = pTab->aCol[pTab->nCol-1].zName;
97118 int nCol = pIdx->nColumn;
97123 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
97125 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
97129 for(i=0; i<nCol; i++){
98374 pParse->nMem += (1 + pTab->nCol);
98379 for(iCol=0; iCol<pTab->nCol; iCol++){
98537 int nCol;
98550 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
98551 regBase = sqlite3GetTempRange(pParse, nCol);
98553 for(j=0; j<nCol; j++){
98571 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
98573 sqlite3ReleaseTempRange(pParse, regBase, nCol);
100581 int nCol = pFKey->nCol; /* Number of columns in parent key */
100597 if( nCol==1 ){
100610 assert( nCol>1 );
100611 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
100617 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){
100629 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
100639 for(i=0; i<nCol; i++){
100656 for(j=0; j<nCol; j++){
100662 if( j==nCol ) break;
100664 if( i==nCol ) break; /* pIdx is usable */
100736 for(i=0; i<pFKey->nCol; i++){
100773 int nCol = pFKey->nCol;
100774 int regTemp = sqlite3GetTempRange(pParse, nCol);
100779 for(i=0; i<nCol; i++){
100794 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
100795 for(i=0; i<nCol; i++){
100810 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
100811 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
100815 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
100948 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
100949 assert( pIdx!=0 || pFKey->nCol==1 );
100965 for(i=0; i<pFKey->nCol; i++){
101162 for(i=0; i<p->nCol; i++){
101189 for(i=0; i<p->nCol; i++){
101192 for(iKey=0; iKey<pTab->nCol; iKey++){
101230 ** first register in an array of (pTab->nCol+1) registers containing the
101236 ** first register of an array of (pTab->nCol+1) registers containing the new
101306 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
101307 for(i=0; i<pFKey->nCol; i++){
101315 assert( pFKey->nCol==1 || (aiFree && pIdx) );
101323 for(i=0; i<pFKey->nCol; i++){
101392 assert( aiCol || pFKey->nCol==1 );
101453 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
101572 assert( aiCol || pFKey->nCol==1 );
101574 for(i=0; i<pFKey->nCol; i++){
101584 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
101842 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
101937 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
101943 for(i=0; i<pTab->nCol; i++){
102396 pParse->nMem += pTab->nCol + 1;
102420 for(j=0; j<pTab->nCol; j++){
102430 if( j>=pTab->nCol ){
102461 dest.nSdst = pTab->nCol;
102542 for(i=0; i<pTab->nCol; i++){
102546 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
102549 pTabList, 0, pTab->nCol-nHidden, nColumn);
102608 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
102640 for(i=0; i<pTab->nCol; i++){
102669 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
102671 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
102726 for(i=0; i<pTab->nCol; i++){
102770 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
102795 pTab, regData-2-pTab->nCol, onError, endOfLoop);
102866 ** pTab->nCol+1 registers in this range. The first register (the one
102962 int nCol; /* Number of columns */
102978 nCol = pTab->nCol;
102998 for(i=0; i<nCol; i++){
103408 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
103410 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
103705 if( pDest->nCol!=pSrc->nCol ){
103711 for(i=0; i<pDest->nCol; i++){
103947 int nCol;
103963 nCol = sqlite3_column_count(pStmt);
103974 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
103978 for(i=0; i<nCol; i++){
103987 azVals = &azCols[nCol];
103988 for(i=0; i<nCol; i++){
103996 if( xCallback(pArg, nCol, azVals, azCols) ){
106851 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
106861 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
107020 for(j=0; j<pFK->nCol; j++){
107078 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
107114 assert( iKey>=0 && iKey<pTab->nCol );
107128 for(j=0; j<pFK->nCol; j++){
107134 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
107135 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
107309 for(j=0; j<pTab->nCol; j++){
107359 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
108909 for(i=0; i<pTab->nCol; i++){
109075 for(j=0; j<pRightTab->nCol; j++){
110068 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
110208 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
110256 int nCol; /* Number of columns in the result set */
110262 nCol = pEList->nExpr;
110263 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
110266 nCol = 0;
110269 *pnCol = nCol;
110272 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
110365 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
110370 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
110413 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
110620 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
110673 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
110680 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
111141 int nCol; /* Number of columns in result set */
111144 nCol = p->pEList->nExpr;
111145 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
111150 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
111166 sqlite3VdbeChangeP2(v, addr, nCol);
112772 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
112887 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
112906 i16 nCol;
112915 nCol = pTab->nCol;
112916 pTab->nCol = -1;
112918 pTab->nCol = nCol;
113007 for(j=0; j<pTab->nCol; j++){
113509 if( pTab->nCol!=pSub->pEList->nExpr ){
113511 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
113928 int nCol;
113937 nCol = nGroupBy;
113941 nCol++;
113945 regBase = sqlite3GetTempRange(pParse, nCol);
113964 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
113967 sqlite3ReleaseTempRange(pParse, regBase, nCol);
113971 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
114318 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
114328 need = nCol*2;
114330 need = nCol;
114344 p->nColumn = nCol;
114345 for(i=0; i<nCol; i++){
114350 }else if( (int)p->nColumn!=nCol ){
114362 for(i=0; i<nCol; i++){
115478 ** (a copy of pTab->nCol), then registers are populated as follows:
115667 assert( i<pTab->nCol );
115799 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
115801 aRegIdx = aXRef+pTab->nCol;
115805 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
115823 for(j=0; j<pTab->nCol; j++){
115835 if( j>=pTab->nCol ){
115908 pParse->nMem += pTab->nCol;
115914 pParse->nMem += pTab->nCol;
116077 for(i=0; i<pTab->nCol; i++){
116109 for(i=0; i<pTab->nCol; i++){
116158 for(i=0; i<pTab->nCol; i++){
116320 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
116351 for(i=0; i<pTab->nCol; i++){
117351 for(iCol=0; iCol<pTab->nCol; iCol++){
117549 pTab->nCol = pParse->pNewTable->nCol;
117550 pParse->pNewTable->nCol = 0;
121374 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){ k++; }
121375 if( k>=pTab->nCol ){
122084 mxBitCol = MIN(BMS-1,pTable->nCol);
122085 testcase( pTable->nCol==BMS-1 );
122086 testcase( pTable->nCol==BMS-2 );
122091 nKeyCol += pTable->nCol - BMS + 1;
122130 for(i=BMS-1; i<pTable->nCol; i++){
125699 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
125700 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
125701 if( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol<BMS && HasRowid(pTab) ){
125707 assert( n<=pTab->nCol );
134077 for(iCol=0; iCol<pTab->nCol; iCol++){
134083 if( iCol==pTab->nCol ){
135955 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
135956 ** where nCol is the number of columns in the queried FTS table. The array
136932 int nCol; /* Number of table columns */
136938 nCol = sqlite3_column_count(pStmt);
136939 for(i=0; i<nCol; i++){
136945 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
136949 char *p = (char *)&azCol[nCol];
136950 for(i=0; i<nCol; i++){
136961 *pnCol = nCol;
136996 int nCol = 0; /* Number of columns in the FTS table */
137158 aCol[nCol++] = z;
137174 if( nCol==0 ){
137177 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
137183 for(j=0; j<nCol; j++){
137186 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
137187 nCol--;
137196 if( nCol==0 ){
137200 nCol = 1;
137218 nCol * sizeof(char *) + /* azColumn */
137220 nCol * sizeof(u8) + /* abNotindexed */
137231 p->nColumn = nCol;
137248 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
137257 zCsr = (char *)&p->abNotindexed[nCol];
137266 for(iCol=0; iCol<nCol; iCol++){
137279 for(iCol=0; iCol<nCol; iCol++){
140636 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
140637 ** varints, where nCol is the number of columns in the FTS3 table.
140639 ** the table. The following nCol varints contain the total amount of
142461 int nCol; /* Number of entries in azCol[] */
142887 for(ii=0; ii<pParse->nCol; ii++){
143328 int nCol, /* Number of entries in azCol[] */
143341 sParse.nCol = nCol;
143376 ** array, which is assumed to contain nCol entries, should contain the names
143391 int nCol, /* Number of entries in azCol[] */
143398 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
143580 int nCol;
143613 nCol = argc-2;
143614 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
143619 for(ii=0; ii<nCol; ii++){
143626 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
143632 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
149281 ** two. If nCol is the number of user defined columns, then values of the
149286 ** Varint 1..nCol: For each column, the total number of tokens stored in
149289 ** Varint 1+nCol: The total size, in bytes, of all text values in all
151622 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
151623 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
151624 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
151625 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
151626 #define FTS3_MATCHINFO_LHITS 'y' /* nCol*nPhrase values */
151627 #define FTS3_MATCHINFO_LHITS_BM 'b' /* nCol*nPhrase values */
151686 int nCol; /* Number of columns in table */
152463 iStart = pExpr->iPhrase * p->nCol;
152465 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
152514 ** for(iCol=0; iCol<nCol; iCol++){
152515 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
152516 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
152536 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
152552 int iStart = iPhrase * p->nCol * 3;
152555 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
152602 nVal = pInfo->nCol;
152606 nVal = pInfo->nCol * pInfo->nPhrase;
152610 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
152615 nVal = pInfo->nCol * pInfo->nPhrase * 3;
152704 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
152708 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
152731 for(iCol=0; iCol<pInfo->nCol; iCol++){
152788 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
152814 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
152833 for(iCol=0; iCol<pInfo->nCol; iCol++){
152850 for(iCol=0; iCol<pInfo->nCol; iCol++){
152922 sInfo.nCol = pTab->nColumn;
159067 int nCol; /* Number of columns in current object */
159545 pIter->nCol = 0;
159769 ** there is room for at least nCol elements. If an OOM occurs, store an
159772 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
159773 int nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
159779 pIter->azTblType = &azNew[nCol];
159780 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
159781 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
159782 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
159783 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
159996 int nCol = 0;
160024 nCol = sqlite3_column_count(pStmt);
160025 rbuAllocateIterArrays(p, pIter, nCol);
160027 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
160320 ** stored in the (p->nCol+1)'th column. Set the error code and error message
160703 pIter->nCol = nBind;
160758 pIter->nCol = pIter->nTblCol;
161324 int iCol = p->objiter.nCol; /* Index of rbu_control column */
161417 for(i=0; i<pIter->nCol; i++){
161446 ** Hence column_value(pIter->nCol+1).
161448 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
161449 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
161450 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
161462 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
161473 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
161474 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
161475 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
166263 int nCol;
166315 int nCol; /* Number of columns */
169339 p->abUnindexed[p->nCol] = 1;
169346 p->azCol[p->nCol++] = zCol;
169360 for(i=0; i<p->nCol; i++){
169512 for(i=0; i<pConfig->nCol; i++){
169537 for(i=0; zSql && i<pConfig->nCol; i++){
171473 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
171477 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
171479 pNew = sqlite3_realloc(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
171485 for(i=0; i<nCol; i++){
171489 for(j=nCol; j>i; j--){
171493 pNew->nCol = nCol+1;
171497 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
171517 for(iCol=0; iCol<pConfig->nCol; iCol++){
171520 if( iCol==pConfig->nCol ){
171692 int nCol = pNear->pColset->nCol;
171693 if( nCol==1 ){
171697 for(i=1; i<pNear->pColset->nCol; i++){
176464 for(i=0; i<pColset->nCol; i++){
176625 && (pColset==0 || pColset->nCol==1)
177225 for(i=0; i<pColset->nCol; i++){
177259 }else if( pColset->nCol==1 ){
177305 ** Parameter anSize must point to an array of size nCol, where nCol is
177309 int nCol = p->pConfig->nCol;
177313 memset(anSize, 0, sizeof(i64) * nCol);
177319 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
178759 aColMap[1] = pConfig->nCol;
178760 aColMap[2] = pConfig->nCol+1;
178785 if( iSort==(pConfig->nCol+1) && BitFlagTest(idxFlags, FTS5_BI_MATCH) ){
178835 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
179635 ** 3. Values for each of the nCol matchable columns.
179653 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
179666 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
179669 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
179675 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
179804 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
180011 for(i=0; i<pConfig->nCol; i++){
180018 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
180037 for(i=0; i<pConfig->nCol; i++){
180040 }else if( iCol<pConfig->nCol ){
180272 *pnCol = pTab->pConfig->nCol;
180336 if( iCol==pConfig->nCol ){
180341 if( iCol==pConfig->nCol ){
180347 }else if( iCol==pConfig->nCol+1 ){
180852 int nCol = pC->nCol + 1;
180856 zBind = sqlite3_malloc(1 + nCol*2);
180858 for(i=0; i<nCol; i++){
181019 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
181030 int nDefn = 32 + pConfig->nCol*10;
181031 char *zDefn = sqlite3_malloc(32 + pConfig->nCol * 10);
181039 for(i=0; i<pConfig->nCol; i++){
181134 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
181210 int nCol = p->pConfig->nCol;
181217 for(i=0; i<nCol; i++){
181291 for(iCol=0; rc==SQLITE_OK && iCol<pConfig->nCol; iCol++){
181381 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
181477 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
181510 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
181607 int *aColSize; /* Array of size pConfig->nCol */
181608 i64 *aTotalSize; /* Array of size pConfig->nCol */
181614 aTotalSize = (i64*)sqlite3_malloc(pConfig->nCol * (sizeof(int)+sizeof(i64)));
181616 aColSize = (int*)&aTotalSize[pConfig->nCol];
181617 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
181631 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
181657 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
181732 int *aCol, int nCol, /* Array to populate */
181737 for(i=0; i<nCol; i++){
181753 int nCol = p->pConfig->nCol; /* Number of user columns in table */
181765 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
181784 for(i=0; i<p->pConfig->nCol; i++){
181787 }else if( iCol<p->pConfig->nCol ){
183846 int nCol;
184032 int nCol = 0;
184052 pIndex = sqlite3Fts5IndexFromCsrid(pTab->pGlobal, iId, &nCol);
184066 nByte = nCol * sizeof(i64) * 2 + sizeof(Fts5VocabCursor);
184071 pCsr->nCol = nCol;
184073 pCsr->aDoc = &pCsr->aCnt[nCol];
184113 for(pCsr->iCol++; pCsr->iCol<pCsr->nCol; pCsr->iCol++){
184118 if( pTab->eType==FTS5_VOCAB_ROW || pCsr->iCol>=pCsr->nCol ){
184128 memset(pCsr->aCnt, 0, pCsr->nCol * sizeof(i64));
184129 memset(pCsr->aDoc, 0, pCsr->nCol * sizeof(i64));
