Lines Matching defs:nCol
10152 ** Table.nCol is the number of columns in this table. Table.aCol is a
10177 int nCol; /* Number of columns in this table */
10252 int nCol; /* Number of columns in this key */
10260 } aCol[1]; /* One entry for each of nCol column s */
10356 ** In the Table structure describing Ex1, nCol==3 because there are
71372 for(iCol=0; iCol<pTab->nCol; iCol++) {
71377 if( iCol==pTab->nCol ){
71401 for(j=0; j<pFKey->nCol; j++){
71470 sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
71471 sqlite3VdbeChangeP2(v, 7, pTab->nCol);
73353 assert( pTab->nCol>0 );
73374 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
73417 for(iCol=0; iCol<pTab->nCol; iCol++){
73426 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
73429 if( iCol<pTab->nCol ){
74443 assert( pExpr->pTab && j<pExpr->pTab->nCol );
77123 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
77126 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
77128 assert( p1>=0 && p1<(pTab->nCol*2+2) );
79074 pCol = &pNew->aCol[pNew->nCol-1];
79224 pNew->nCol = pTab->nCol;
79225 assert( pNew->nCol>0 );
79226 nAlloc = (((pNew->nCol-1)/8)*8)+8;
79227 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
79234 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
79235 for(i=0; i<pNew->nCol; i++){
79757 int nCol;
79764 nCol = pIdx->nColumn;
79765 aChngAddr = sqlite3DbMallocRaw(db, sizeof(int)*nCol);
79768 if( iMem+1+(nCol*2)>pParse->nMem ){
79769 pParse->nMem = iMem+1+(nCol*2);
79802 ** iMem+1 .. iMem+nCol:
79804 ** left-most N columns only, where N is between 1 and nCol,
79807 ** iMem+nCol+1 .. Mem+2*nCol:
79810 ** Cells iMem through iMem+nCol are initialized to 0. The others are
79813 for(i=0; i<=nCol; i++){
79816 for(i=0; i<nCol; i++){
79817 sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
79827 for(i=0; i<nCol; i++){
79837 aChngAddr[i] = sqlite3VdbeAddOp4(v, OP_Ne, regCol, 0, iMem+nCol+i+1,
79849 for(i=0; i<nCol; i++){
79864 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
79868 /* Always jump here after updating the iMem+1...iMem+1+nCol counters */
79925 for(i=0; i<nCol; i++){
81116 assert( iCol<pTab->nCol );
81119 assert( pTab->iPKey<pTab->nCol );
81682 for(i=0; i<pTable->nCol; i++, pCol++){
82148 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
82155 for(i=0; i<p->nCol; i++){
82162 if( (p->nCol & 0x7)==0 ){
82164 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
82171 pCol = &p->aCol[p->nCol];
82180 p->nCol++;
82192 if( p==0 || NEVER(p->nCol<1) ) return;
82193 p->aCol[p->nCol-1].notNull = (u8)onError;
82271 if( p==0 || NEVER(p->nCol<1) ) return;
82272 pCol = &p->aCol[p->nCol-1];
82294 pCol = &(p->aCol[p->nCol-1]);
82349 iCol = pTab->nCol - 1;
82353 for(iCol=0; iCol<pTab->nCol; iCol++){
82358 if( iCol<pTab->nCol ){
82364 if( iCol>=0 && iCol<pTab->nCol ){
82422 i = p->nCol-1;
82573 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
82586 n += 35 + 6*p->nCol;
82596 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
82764 p->nCol = pSelTab->nCol;
82766 pSelTab->nCol = 0;
82954 /* A positive nCol means the columns names for this view are
82957 if( pTable->nCol>0 ) return 0;
82959 /* A negative nCol is a special marker meaning that we are currently
82961 ** a negative nCol, it means two or more views form a loop, like this:
82974 if( pTable->nCol<0 ){
82978 assert( pTable->nCol>=0 );
82993 pTable->nCol = -1;
83007 pTable->nCol = pSelTab->nCol;
83009 pSelTab->nCol = 0;
83015 pTable->nCol = 0;
83040 pTab->nCol = 0;
83405 int nCol;
83411 int iCol = p->nCol-1;
83419 nCol = 1;
83426 nCol = pFromCol->nExpr;
83428 nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
83440 z = (char*)&pFKey->aCol[nCol];
83446 pFKey->nCol = nCol;
83448 pFKey->aCol[0].iFrom = p->nCol-1;
83450 for(i=0; i<nCol; i++){
83452 for(j=0; j<p->nCol; j++){
83458 if( j>=p->nCol ){
83467 for(i=0; i<nCol; i++){
83684 int nCol;
83830 nullId.z = pTab->aCol[pTab->nCol-1].zName;
83857 nCol = pList->nExpr;
83860 ROUND8(sizeof(tRowcnt)*(nCol+1)) + /* Index.aiRowEst */
83861 sizeof(char *)*nCol + /* Index.azColl */
83862 sizeof(int)*nCol + /* Index.aiColumn */
83863 sizeof(u8)*nCol + /* Index.aSortOrder */
83873 ((char*)pIndex->aiRowEst + ROUND8(sizeof(tRowcnt)*nCol+1));
83876 pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
83877 pIndex->aSortOrder = (u8 *)(&pIndex->aiColumn[nCol]);
83878 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
83912 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
83915 if( j>=pTab->nCol ){
84987 int nCol = pIdx->nColumn;
84988 int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
84994 pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
84995 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
84996 for(i=0; i<nCol; i++){
85002 pKey->nField = (u16)nCol;
85986 pParse->nMem += (1 + pTab->nCol);
85991 for(iCol=0; iCol<pTab->nCol; iCol++){
86096 int nCol;
86098 nCol = pIdx->nColumn;
86099 regBase = sqlite3GetTempRange(pParse, nCol+1);
86100 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
86101 for(j=0; j<nCol; j++){
86104 sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
86117 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
86120 sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
87931 int nCol = pFKey->nCol; /* Number of columns in parent key */
87947 if( nCol==1 ){
87960 assert( nCol>1 );
87961 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
87967 if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){
87979 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
87989 for(i=0; i<nCol; i++){
88004 for(j=0; j<nCol; j++){
88010 if( j==nCol ) break;
88012 if( i==nCol ) break; /* pIdx is usable */
88081 for(i=0; i<pFKey->nCol; i++){
88116 int nCol = pFKey->nCol;
88117 int regTemp = sqlite3GetTempRange(pParse, nCol);
88123 for(i=0; i<nCol; i++){
88138 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
88139 for(i=0; i<nCol; i++){
88153 sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
88158 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
88242 for(i=0; i<pFKey->nCol; i++){
88422 ** first register in an array of (pTab->nCol+1) registers containing the
88428 ** first register of an array of (pTab->nCol+1) registers containing the new
88489 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
88490 for(i=0; i<pFKey->nCol; i++){
88498 assert( pFKey->nCol==1 || (aiFree && pIdx) );
88506 for(i=0; i<pFKey->nCol; i++){
88561 assert( aiCol || pFKey->nCol==1 );
88608 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
88655 for(i=0; i<p->nCol; i++){
88664 for(i=0; i<p->nCol; i++){
88667 for(iKey=0; iKey<pTab->nCol; iKey++){
88738 assert( aiCol || pFKey->nCol==1 );
88740 for(i=0; i<pFKey->nCol; i++){
88995 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
89074 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
89080 for(i=0; i<pTab->nCol; i++){
89083 zColAff[pTab->nCol] = '\0';
89648 for(i=0; i<pTab->nCol; i++){
89652 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
89655 pTabList, 0, pTab->nCol-nHidden, nColumn);
89679 for(j=0; j<pTab->nCol; j++){
89688 if( j>=pTab->nCol ){
89762 pParse->nMem += pTab->nCol + 1;
89773 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
89804 for(i=0; i<pTab->nCol; i++){
89828 sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
89834 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
89836 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
89893 for(i=0; i<pTab->nCol; i++){
89934 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
89960 pTab, regData-2-pTab->nCol, onError, endOfLoop);
90115 int nCol; /* Number of columns */
90128 nCol = pTab->nCol;
90133 for(i=0; i<nCol; i++){
90418 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
90420 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
90660 if( pDest->nCol!=pSrc->nCol ){
90666 for(i=0; i<pDest->nCol; i++){
90856 int nCol;
90872 nCol = sqlite3_column_count(pStmt);
90883 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
90887 for(i=0; i<nCol; i++){
90896 azVals = &azCols[nCol];
90897 for(i=0; i<nCol; i++){
90905 if( xCallback(pArg, nCol, azVals, azCols) ){
92981 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
93019 assert( pTab->nCol>cnum );
93111 for(j=0; j<pFK->nCol; j++){
94692 for(i=0; i<pTab->nCol; i++){
94852 for(j=0; j<pRightTab->nCol; j++){
95583 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95710 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95757 int nCol; /* Number of columns in the result set */
95762 *pnCol = nCol = pEList ? pEList->nExpr : 0;
95763 aCol = *paCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
95765 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95843 int nCol, /* Number of columns */
95857 assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
95862 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95900 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
95901 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
96368 int nCol; /* Number of columns in result set */
96371 nCol = p->pEList->nExpr;
96373 sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
96380 pKeyInfo->nField = (u16)nCol;
96382 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
96398 sqlite3VdbeChangeP2(v, addr, nCol);
97747 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
97848 for(j=0; j<pTab->nCol; j++){
97987 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
98704 int nCol;
98712 nCol = nGroupBy + 1;
98716 nCol++;
98720 regBase = sqlite3GetTempRange(pParse, nCol);
98740 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
98743 sqlite3ReleaseTempRange(pParse, regBase, nCol);
98747 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
98898 if( pBest && pBest->nColumn<pTab->nCol ){
99159 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
99169 need = nCol*2;
99171 need = nCol;
99185 p->nColumn = nCol;
99186 for(i=0; i<nCol; i++){
99191 }else if( p->nColumn!=nCol ){
99203 for(i=0; i<nCol; i++){
100320 ** (a copy of pTab->nCol), then registers are populated as follows:
100508 assert( i<pTab->nCol );
100609 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
100611 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
100639 for(j=0; j<pTab->nCol; j++){
100649 if( j>=pTab->nCol ){
100723 pParse->nMem += pTab->nCol;
100729 pParse->nMem += pTab->nCol;
100840 for(i=0; i<pTab->nCol; i++){
100868 sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);
100869 for(i=0; i<pTab->nCol; i++){
100894 sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
100912 for(i=0; i<pTab->nCol; i++){
101070 for(i=0; i<pTab->nCol; i++){
101085 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
101095 pParse->nMem += pTab->nCol+1;
101099 for(i=0; i<pTab->nCol; i++){
101103 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
101971 for(iCol=0; iCol<pTab->nCol; iCol++){
102156 pTab->nCol = pParse->pNewTable->nCol;
102157 pParse->pNewTable->nCol = 0;
104588 mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol;
104589 testcase( pTable->nCol==BMS-1 );
104590 testcase( pTable->nCol==BMS-2 );
104595 nColumn += pTable->nCol - BMS + 1;
104641 for(i=BMS-1; i<pTable->nCol; i++){
107553 testcase( pTab->nCol==BMS-1 );
107554 testcase( pTab->nCol==BMS );
107555 if( !pWInfo->okOnePass && pTab->nCol<BMS ){
107561 assert( n<=pTab->nCol );
115049 for(iCol=0; iCol<pTab->nCol; iCol++){
115055 if( iCol==pTab->nCol ){
116751 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
116752 ** where nCol is the number of columns in the queried FTS table. The array
117626 int nCol; /* Number of table columns */
117632 nCol = sqlite3_column_count(pStmt);
117633 for(i=0; i<nCol; i++){
117639 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
117643 char *p = (char *)&azCol[nCol];
117644 for(i=0; i<nCol; i++){
117655 *pnCol = nCol;
117690 int nCol = 0; /* Number of columns in the FTS table */
117834 aCol[nCol++] = z;
117850 if( nCol==0 ){
117853 rc = fts3ContentColumns(db, argv[1], zContent, &aCol, &nCol, &nString);
117859 for(j=0; j<nCol; j++){
117862 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
117863 nCol--;
117872 if( nCol==0 ){
117876 nCol = 1;
117894 nCol * sizeof(char *) + /* azColumn */
117906 p->nColumn = nCol;
117921 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
117938 for(iCol=0; iCol<nCol; iCol++){
120775 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
120776 ** varints, where nCol is the number of columns in the FTS3 table.
120778 ** the table. The following nCol varints contain the total amount of
122384 int nCol; /* Number of entries in azCol[] */
122809 for(ii=0; ii<pParse->nCol; ii++){
123048 ** array, which is assumed to contain nCol entries, should contain the names
123063 int nCol, /* Number of entries in azCol[] */
123076 sParse.nCol = nCol;
123224 int nCol;
123257 nCol = argc-2;
123258 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
123263 for(ii=0; ii<nCol; ii++){
123268 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
128039 ** two. If nCol is the number of user defined columns, then values of the
128044 ** Varint 1..nCol: For each column, the total number of tokens stored in
128047 ** Varint 1+nCol: The total size, in bytes, of all text values in all
128636 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
128637 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
128638 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
128639 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
128698 int nCol; /* Number of columns in table */
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;
129369 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
129384 int iStart = iPhrase * p->nCol * 3;
129387 for(i=0; i<p->nCol; i++){
129432 nVal = pInfo->nCol;
129437 nVal = pInfo->nCol * pInfo->nPhrase * 3;
129526 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
129530 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
129553 for(iCol=0; iCol<pInfo->nCol; iCol++){
129608 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
129634 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
129653 for(iCol=0; iCol<pInfo->nCol; iCol++){
129670 for(iCol=0; iCol<pInfo->nCol; iCol++){
129729 sInfo.nCol
