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
66081 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
66083 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
66088 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
66091 for(i=0; i<nCol; i++){
66622 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
66625 for(i=0; i<nCol; i++){
79809 for(iCol=0; iCol<pTab->nCol; iCol++) {
79814 if( iCol==pTab->nCol ){
79838 for(j=0; j<pFKey->nCol; j++){
79903 sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
79904 sqlite3VdbeChangeP2(v, 6, pTab->nCol);
83727 assert( pTab->nCol>0 );
83755 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
83806 for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
83814 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){
83819 if( iCol<pTab->nCol ){
85037 assert( pExpr->pTab && j<pExpr->pTab->nCol );
88044 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
88047 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
88049 assert( p1>=0 && p1<(pTab->nCol*2+2) );
89831 pCol = &pNew->aCol[pNew->nCol-1];
89984 pNew->nCol = pTab->nCol;
89985 assert( pNew->nCol>0 );
89986 nAlloc = (((pNew->nCol-1)/8)*8)+8;
89987 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
89994 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
89995 for(i=0; i<pNew->nCol; i++){
90305 int nCol; /* Number of columns in index + pk/rowid */
90310 Stat4Sample *aBest; /* Array of nCol best samples */
90366 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
90367 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
90368 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
90384 for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
90420 int nCol; /* Number of columns in index being sampled */
90422 int nColUp; /* nCol rounded up for alignment */
90431 nCol = sqlite3_value_int(argv[0]);
90432 assert( nCol>0 );
90433 nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol;
90435 assert( nKeyCol<=nCol );
90444 + sizeof(Stat4Sample)*(nCol+mxSample) /* Stat4Accum.aBest[], a[] */
90445 + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
90457 p->nCol = nCol;
90471 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
90476 pSpace = (u8*)(&p->a[mxSample+nCol]);
90477 for(i=0; i<(mxSample+nCol); i++){
90484 for(i=0; i<nCol; i++){
90526 int nCol = pAccum->nCol;
90529 for(i=pNew->iCol+1; i<nCol; i++){
90628 || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] );
90668 for(i=(p->nCol-2); i>=iChng; i--){
90679 for(j=iChng; j<p->nCol; j++){
90741 assert( p->nCol>0 );
90742 assert( iChng<p->nCol );
90746 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
90756 for(i=iChng; i<p->nCol; i++){
90777 tRowcnt nLt = p->current.anLt[p->nCol-1];
90783 sampleInsert(p, &p->current, p->nCol-1);
90788 for(i=0; i<(p->nCol-1); i++){
90923 char *zRet = sqlite3MallocZero(p->nCol * 25);
90929 for(i=0; i<p->nCol; i++){
91040 int nCol; /* Number of columns in pIdx. "N" */
91049 nCol = pIdx->nKeyCol;
91051 nColTest = nCol - 1;
91053 nCol = pIdx->nColumn;
91055 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
91119 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
91209 assert( k>=0 && k<pTab->nCol );
91239 int regSampleRowid = regCol + nCol;
91244 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
91261 for(i=0; i<nCol; i++){
91264 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
91542 int nCol = pIndex->nKeyCol+1;
91548 pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
91554 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
91603 int nCol = 1;
91609 nCol = pIdx->nSampleCol-1;
91610 pIdx->aAvgEq[nCol] = 1;
91612 for(iCol=0; iCol<nCol; iCol++){
91764 int nCol = 1; /* Number of columns in index */
91772 nCol = pIdx->nSampleCol;
91773 if( bStat3 && nCol>1 ) continue;
91779 decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0);
91780 decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0);
91781 decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0);
92679 assert( iCol<pTab->nCol );
92682 assert( pTab->iPKey<pTab->nCol );
93346 for(i=0; i<pTable->nCol; i++, pCol++){
93845 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
93852 for(i=0; i<p->nCol; i++){
93859 if( (p->nCol & 0x7)==0 ){
93861 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
93868 pCol = &p->aCol[p->nCol];
93878 p->nCol++;
93890 if( p==0 || NEVER(p->nCol<1) ) return;
93891 p->aCol[p->nCol-1].notNull = (u8)onError;
93995 if( p==0 || NEVER(p->nCol<1) ) return;
93996 pCol = &p->aCol[p->nCol-1];
94019 pCol = &(p->aCol[p->nCol-1]);
94099 iCol = pTab->nCol - 1;
94111 for(iCol=0; iCol<pTab->nCol; iCol++){
94185 i = p->nCol-1;
94334 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
94347 n += 35 + 6*p->nCol;
94357 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
94424 for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){
94440 assert( x<pIdx->pTable->nCol );
94446 /* Return true if value x is found any of the first nCol entries of aiCol[]
94448 static int hasColumn(const i16 *aiCol, int nCol, int x){
94449 while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
94580 if( nPk<pTab->nCol ){
94581 if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
94582 for(i=0, j=nPk; i<pTab->nCol; i++){
94591 assert( pTab->nCol==j );
94593 pPk->nColumn = pTab->nCol;
94752 p->nCol = pSelTab->nCol;
94754 pSelTab->nCol = 0;
94946 /* A positive nCol means the columns names for this view are
94949 if( pTable->nCol>0 ) return 0;
94951 /* A negative nCol is a special marker meaning that we are currently
94953 ** a negative nCol, it means two or more views form a loop, like this:
94966 if( pTable->nCol<0 ){
94970 assert( pTable->nCol>=0 );
94984 &pTable->nCol, &pTable->aCol);
94990 pTable->nCol = -1;
95003 pTable->nCol = pSelTab->nCol;
95005 pSelTab->nCol = 0;
95010 pTable->nCol = 0;
95038 pTab->nCol = 0;
95404 int nCol;
95410 int iCol = p->nCol-1;
95418 nCol = 1;
95425 nCol = pFromCol->nExpr;
95427 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
95439 z = (char*)&pFKey->aCol[nCol];
95445 pFKey->nCol = nCol;
95447 pFKey->aCol[0].iFrom = p->nCol-1;
95449 for(i=0; i<nCol; i++){
95451 for(j=0; j<p->nCol; j++){
95457 if( j>=p->nCol ){
95466 for(i=0; i<nCol; i++){
95613 ** Allocate heap space to hold an Index object with nCol columns.
95621 i16 nCol, /* Total number of columns in the index */
95629 ROUND8(sizeof(char*)*nCol) + /* Index.azColl */
95630 ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */
95631 sizeof(i16)*nCol + /* Index.aiColumn */
95632 sizeof(u8)*nCol); /* Index.aSortOrder */
95636 p->azColl = (char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
95637 p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
95638 p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol;
95640 p->nColumn = nCol;
95641 p->nKeyCol = nCol - 1;
95843 prevCol.z = pTab->aCol[pTab->nCol-1].zName;
97100 int nCol = pIdx->nColumn;
97105 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
97107 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
97111 for(i=0; i<nCol; i++){
98356 pParse->nMem += (1 + pTab->nCol);
98361 for(iCol=0; iCol<pTab->nCol; iCol++){
98519 int nCol;
98532 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
98533 regBase = sqlite3GetTempRange(pParse, nCol);
98535 for(j=0; j<nCol; j++){
98553 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
98555 sqlite3ReleaseTempRange(pParse, regBase, nCol);
100563 int nCol = pFKey->nCol; /* Number of columns in parent key */
100579 if( nCol==1 ){
100592 assert( nCol>1 );
100593 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
100599 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) ){
100611 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
100621 for(i=0; i<nCol; i++){
100638 for(j=0; j<nCol; j++){
100644 if( j==nCol ) break;
100646 if( i==nCol ) break; /* pIdx is usable */
100718 for(i=0; i<pFKey->nCol; i++){
100755 int nCol = pFKey->nCol;
100756 int regTemp = sqlite3GetTempRange(pParse, nCol);
100761 for(i=0; i<nCol; i++){
100776 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
100777 for(i=0; i<nCol; i++){
100792 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
100793 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
100797 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
100930 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
100931 assert( pIdx!=0 || pFKey->nCol==1 );
100947 for(i=0; i<pFKey->nCol; i++){
101144 for(i=0; i<p->nCol; i++){
101171 for(i=0; i<p->nCol; i++){
101174 for(iKey=0; iKey<pTab->nCol; iKey++){
101212 ** first register in an array of (pTab->nCol+1) registers containing the
101218 ** first register of an array of (pTab->nCol+1) registers containing the new
101288 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
101289 for(i=0; i<pFKey->nCol; i++){
101297 assert( pFKey->nCol==1 || (aiFree && pIdx) );
101305 for(i=0; i<pFKey->nCol; i++){
101374 assert( aiCol || pFKey->nCol==1 );
101435 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
101554 assert( aiCol || pFKey->nCol==1 );
101556 for(i=0; i<pFKey->nCol; i++){
101566 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
101824 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
101919 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
101925 for(i=0; i<pTab->nCol; i++){
102378 pParse->nMem += pTab->nCol + 1;
102402 for(j=0; j<pTab->nCol; j++){
102412 if( j>=pTab->nCol ){
102443 dest.nSdst = pTab->nCol;
102524 for(i=0; i<pTab->nCol; i++){
102528 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
102531 pTabList, 0, pTab->nCol-nHidden, nColumn);
102590 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
102622 for(i=0; i<pTab->nCol; i++){
102651 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
102653 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
102708 for(i=0; i<pTab->nCol; i++){
102752 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
102777 pTab, regData-2-pTab->nCol, onError, endOfLoop);
102848 ** pTab->nCol+1 registers in this range. The first register (the one
102944 int nCol; /* Number of columns */
102960 nCol = pTab->nCol;
102980 for(i=0; i<nCol; i++){
103390 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
103392 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
103687 if( pDest->nCol!=pSrc->nCol ){
103693 for(i=0; i<pDest->nCol; i++){
103929 int nCol;
103945 nCol = sqlite3_column_count(pStmt);
103956 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
103960 for(i=0; i<nCol; i++){
103969 azVals = &azCols[nCol];
103970 for(i=0; i<nCol; i++){
103978 if( xCallback(pArg, nCol, azVals, azCols) ){
106833 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
106843 for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){}
107002 for(j=0; j<pFK->nCol; j++){
107060 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
107096 assert( iKey>=0 && iKey<pTab->nCol );
107110 for(j=0; j<pFK->nCol; j++){
107116 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
107117 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
107291 for(j=0; j<pTab->nCol; j++){
107341 assert( iCol!=XN_ROWID && iCol<pTab->nCol );
108891 for(i=0; i<pTab->nCol; i++){
109057 for(j=0; j<pRightTab->nCol; j++){
110050 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
110190 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
110238 int nCol; /* Number of columns in the result set */
110244 nCol = pEList->nExpr;
110245 aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
110248 nCol = 0;
110251 *pnCol = nCol;
110254 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
110347 assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
110352 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
110395 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
110602 int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */
110655 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
110662 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
111123 int nCol; /* Number of columns in result set */
111126 nCol = p->pEList->nExpr;
111127 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
111132 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
111148 sqlite3VdbeChangeP2(v, addr, nCol);
112754 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
112869 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
112888 i16 nCol;
112897 nCol = pTab->nCol;
112898 pTab->nCol = -1;
112900 pTab->nCol = nCol;
112989 for(j=0; j<pTab->nCol; j++){
113491 if( pTab->nCol!=pSub->pEList->nExpr ){
113493 pTab->nCol, pTab->zName, pSub->pEList->nExpr);
113910 int nCol;
113919 nCol = nGroupBy;
113923 nCol++;
113927 regBase = sqlite3GetTempRange(pParse, nCol);
113946 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
113949 sqlite3ReleaseTempRange(pParse, regBase, nCol);
113953 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
114300 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
114310 need = nCol*2;
114312 need = nCol;
114326 p->nColumn = nCol;
114327 for(i=0; i<nCol; i++){
114332 }else if( (int)p->nColumn!=nCol ){
114344 for(i=0; i<nCol; i++){
115460 ** (a copy of pTab->nCol), then registers are populated as follows:
115649 assert( i<pTab->nCol );
115781 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
115783 aRegIdx = aXRef+pTab->nCol;
115787 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
115805 for(j=0; j<pTab->nCol; j++){
115817 if( j>=pTab->nCol ){
115890 pParse->nMem += pTab->nCol;
115896 pParse->nMem += pTab->nCol;
116059 for(i=0; i<pTab->nCol; i++){
116091 for(i=0; i<pTab->nCol; i++){
116140 for(i=0; i<pTab->nCol; i++){
116302 int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */
116333 for(i=0; i<pTab->nCol; i++){
117333 for(iCol=0; iCol<pTab->nCol; iCol++){
117531 pTab->nCol = pParse->pNewTable->nCol;
117532 pParse->pNewTable->nCol = 0;
121356 while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){ k++; }
121357 if( k>=pTab->nCol ){
122066 mxBitCol = MIN(BMS-1,pTable->nCol);
122067 testcase( pTable->nCol==BMS-1 );
122068 testcase( pTable->nCol==BMS-2 );
122073 nKeyCol += pTable->nCol - BMS + 1;
122112 for(i=BMS-1; i<pTable->nCol; i++){
125681 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 );
125682 testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS );
125683 if( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol<BMS && HasRowid(pTab) ){
125689 assert( n<=pTab->nCol );
134059 for(iCol=0; iCol<pTab->nCol; iCol++){
134065 if( iCol==pTab->nCol ){
135937 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
135938 ** where nCol is the number of columns in the queried FTS table. The array
136914 int nCol; /* Number of table columns */
136920 nCol = sqlite3_column_count(pStmt);
136921 for(i=0; i<nCol; i++){
136927 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
136931 char *p = (char *)&azCol[nCol];
136932 for(i=0; i<nCol; i++){
136943 *pnCol = nCol;
136978 int nCol = 0; /* Number of columns in the FTS table */
137140 aCol[nCol++] = z;
137156 if( nCol==0 ){
137159 rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr);
137165 for(j=0; j<nCol; j++){
137168 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
137169 nCol--;
137178 if( nCol==0 ){
137182 nCol = 1;
137200 nCol * sizeof(char *) + /* azColumn */
137202 nCol * sizeof(u8) + /* abNotindexed */
137213 p->nColumn = nCol;
137230 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
137239 zCsr = (char *)&p->abNotindexed[nCol];
137248 for(iCol=0; iCol<nCol; iCol++){
137261 for(iCol=0; iCol<nCol; iCol++){
140606 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
140607 ** varints, where nCol is the number of columns in the FTS3 table.
140609 ** the table. The following nCol varints contain the total amount of
142431 int nCol; /* Number of entries in azCol[] */
142857 for(ii=0; ii<pParse->nCol; ii++){
143298 int nCol, /* Number of entries in azCol[] */
143311 sParse.nCol = nCol;
143346 ** array, which is assumed to contain nCol entries, should contain the names
143361 int nCol, /* Number of entries in azCol[] */
143368 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
143550 int nCol;
143583 nCol = argc-2;
143584 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
143589 for(ii=0; ii<nCol; ii++){
143596 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
143602 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
149251 ** two. If nCol is the number of user defined columns, then values of the
149256 ** Varint 1..nCol: For each column, the total number of tokens stored in
149259 ** Varint 1+nCol: The total size, in bytes, of all text values in all
151592 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
151593 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
151594 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
151595 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
151596 #define FTS3_MATCHINFO_LHITS 'y' /* nCol*nPhrase values */
151597 #define FTS3_MATCHINFO_LHITS_BM 'b' /* nCol*nPhrase values */
151656 int nCol; /* Number of columns in table */
152433 iStart = pExpr->iPhrase * p->nCol;
152435 iStart = pExpr->iPhrase * ((p->nCol + 31) / 32);
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;
152506 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
152522 int iStart = iPhrase * p->nCol * 3;
152525 for(i=0; i<p->nCol && rc==SQLITE_OK; i++){
152572 nVal = pInfo->nCol;
152576 nVal = pInfo->nCol * pInfo->nPhrase;
152580 nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32);
152585 nVal = pInfo->nCol * pInfo->nPhrase * 3;
152674 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
152678 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
152701 for(iCol=0; iCol<pInfo->nCol; iCol++){
152758 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
152784 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
152803 for(iCol=0; iCol<pInfo->nCol; iCol++){
152820 for(iCol=0; iCol<pInfo->nCol; iCol++){
152892 sInfo.nCol = pTab->nColumn;
159037 int nCol; /* Number of columns in current object */
159515 pIter->nCol = 0;
159739 ** there is room for at least nCol elements. If an OOM occurs, store an
159742 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
159743 int nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
159749 pIter->azTblType = &azNew[nCol];
159750 pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
159751 pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
159752 pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
159753 pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
159966 int nCol = 0;
159994 nCol = sqlite3_column_count(pStmt);
159995 rbuAllocateIterArrays(p, pIter, nCol);
159997 for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
160290 ** stored in the (p->nCol+1)'th column. Set the error code and error message
160673 pIter->nCol = nBind;
160728 pIter->nCol = pIter->nTblCol;
161294 int iCol = p->objiter.nCol; /* Index of rbu_control column */
161387 for(i=0; i<pIter->nCol; i++){
161416 ** Hence column_value(pIter->nCol+1).
161418 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
161419 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
161420 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
161432 for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
161443 assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
161444 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
161445 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
166233 int nCol;
166285 int nCol; /* Number of columns */
169309 p->abUnindexed[p->nCol] = 1;
169316 p->azCol[p->nCol++] = zCol;
169330 for(i=0; i<p->nCol; i++){
169482 for(i=0; i<pConfig->nCol; i++){
169507 for(i=0; zSql && i<pConfig->nCol; i++){
171443 int nCol = p ? p->nCol : 0; /* Num. columns already in colset object */
171447 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
171449 pNew = sqlite3_realloc(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
171455 for(i=0; i<nCol; i++){
171459 for(j=nCol; j>i; j--){
171463 pNew->nCol = nCol+1;
171467 for(i=1; i<pNew->nCol; i++) assert( pNew->aiCol[i]>pNew->aiCol[i-1] );
171487 for(iCol=0; iCol<pConfig->nCol; iCol++){
171490 if( iCol==pConfig->nCol ){
171662 int nCol = pNear->pColset->nCol;
171663 if( nCol==1 ){
171667 for(i=1; i<pNear->pColset->nCol; i++){
176434 for(i=0; i<pColset->nCol; i++){
176595 && (pColset==0 || pColset->nCol==1)
177195 for(i=0; i<pColset->nCol; i++){
177229 }else if( pColset->nCol==1 ){
177275 ** Parameter anSize must point to an array of size nCol, where nCol is
177279 int nCol = p->pConfig->nCol;
177283 memset(anSize, 0, sizeof(i64) * nCol);
177289 for(iCol=0; i<pData->nn && iCol<nCol; iCol++){
178729 aColMap[1] = pConfig->nCol;
178730 aColMap[2] = pConfig->nCol+1;
178755 if( iSort==(pConfig->nCol+1) && BitFlagTest(idxFlags, FTS5_BI_MATCH) ){
178805 nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
179605 ** 3. Values for each of the nCol matchable columns.
179623 assert( nArg==1 || nArg==(2+pConfig->nCol+2) );
179636 && sqlite3_value_type(apVal[2+pConfig->nCol])!=SQLITE_NULL
179639 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
179645 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
179774 return ((Fts5Table*)(pCsr->base.pVtab))->pConfig->nCol;
179981 for(i=0; i<pConfig->nCol; i++){
179988 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
180007 for(i=0; i<pConfig->nCol; i++){
180010 }else if( iCol<pConfig->nCol ){
180242 *pnCol = pTab->pConfig->nCol;
180306 if( iCol==pConfig->nCol ){
180311 if( iCol==pConfig->nCol ){
180317 }else if( iCol==pConfig->nCol+1 ){
180822 int nCol = pC->nCol + 1;
180826 zBind = sqlite3_malloc(1 + nCol*2);
180828 for(i=0; i<nCol; i++){
180989 + pConfig->nCol * sizeof(i64); /* Fts5Storage.aTotalSize[] */
181000 int nDefn = 32 + pConfig->nCol*10;
181001 char *zDefn = sqlite3_malloc(32 + pConfig->nCol * 10);
181009 for(i=0; i<pConfig->nCol; i++){
181104 for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
181180 int nCol = p->pConfig->nCol;
181187 for(i=0; i<nCol; i++){
181261 for(iCol=0; rc==SQLITE_OK && iCol<pConfig->nCol; iCol++){
181351 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
181447 for(i=1; rc==SQLITE_OK && i<=pConfig->nCol+1; i++){
181480 for(ctx.iCol=0; rc==SQLITE_OK && ctx.iCol<pConfig->nCol; ctx.iCol++){
181577 int *aColSize; /* Array of size pConfig->nCol */
181578 i64 *aTotalSize; /* Array of size pConfig->nCol */
181584 aTotalSize = (i64*)sqlite3_malloc(pConfig->nCol * (sizeof(int)+sizeof(i64)));
181586 aColSize = (int*)&aTotalSize[pConfig->nCol];
181587 memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
181601 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
181627 for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
181702 int *aCol, int nCol, /* Array to populate */
181707 for(i=0; i<nCol; i++){
181723 int nCol = p->pConfig->nCol; /* Number of user columns in table */
181735 if( 0==fts5StorageDecodeSizeArray(aCol, nCol, aBlob, nBlob) ){
181754 for(i=0; i<p->pConfig->nCol; i++){
181757 }else if( iCol<p->pConfig->nCol ){
183816 int nCol;
184002 int nCol = 0;
184022 pIndex = sqlite3Fts5IndexFromCsrid(pTab->pGlobal, iId, &nCol);
184036 nByte = nCol * sizeof(i64) * 2 + sizeof(Fts5VocabCursor);
184041 pCsr->nCol = nCol;
184043 pCsr->aDoc = &pCsr->aCnt[nCol];
184083 for(pCsr->iCol++; pCsr->iCol<pCsr->nCol; pCsr->iCol++){
184088 if( pTab->eType==FTS5_VOCAB_ROW || pCsr->iCol>=pCsr->nCol ){
184098 memset(pCsr->aCnt, 0, pCsr->nCol * sizeof(i64));
184099 memset(pCsr->aDoc, 0, pCsr->nCol * sizeof(i64));
