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
71400 for(iCol=0; iCol<pTab->nCol; iCol++) {
71405 if( iCol==pTab->nCol ){
71429 for(j=0; j<pFKey->nCol; j++){
71498 sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
71499 sqlite3VdbeChangeP2(v, 7, pTab->nCol);
73389 assert( pTab->nCol>0 );
73410 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
73453 for(iCol=0; iCol<pTab->nCol; iCol++){
73462 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
73465 if( iCol<pTab->nCol ){
74479 assert( pExpr->pTab && j<pExpr->pTab->nCol );
77159 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
77162 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
77164 assert( p1>=0 && p1<(pTab->nCol*2+2) );
79110 pCol = &pNew->aCol[pNew->nCol-1];
79260 pNew->nCol = pTab->nCol;
79261 assert( pNew->nCol>0 );
79262 nAlloc = (((pNew->nCol-1)/8)*8)+8;
79263 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
79270 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
79271 for(i=0; i<pNew->nCol; i++){
79793 int nCol;
79800 nCol = pIdx->nColumn;
79801 aChngAddr = sqlite3DbMallocRaw(db, sizeof(int)*nCol);
79804 if( iMem+1+(nCol*2)>pParse->nMem ){
79805 pParse->nMem = iMem+1+(nCol*2);
79838 ** iMem+1 .. iMem+nCol:
79840 ** left-most N columns only, where N is between 1 and nCol,
79843 ** iMem+nCol+1 .. Mem+2*nCol:
79846 ** Cells iMem through iMem+nCol are initialized to 0. The others are
79849 for(i=0; i<=nCol; i++){
79852 for(i=0; i<nCol; i++){
79853 sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
79863 for(i=0; i<nCol; i++){
79873 aChngAddr[i] = sqlite3VdbeAddOp4(v, OP_Ne, regCol, 0, iMem+nCol+i+1,
79885 for(i=0; i<nCol; i++){
79900 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
79904 /* Always jump here after updating the iMem+1...iMem+1+nCol counters */
79961 for(i=0; i<nCol; i++){
81152 assert( iCol<pTab->nCol );
81155 assert( pTab->iPKey<pTab->nCol );
81718 for(i=0; i<pTable->nCol; i++, pCol++){
82184 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
82191 for(i=0; i<p->nCol; i++){
82198 if( (p->nCol & 0x7)==0 ){
82200 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
82207 pCol = &p->aCol[p->nCol];
82216 p->nCol++;
82228 if( p==0 || NEVER(p->nCol<1) ) return;
82229 p->aCol[p->nCol-1].notNull = (u8)onError;
82307 if( p==0 || NEVER(p->nCol<1) ) return;
82308 pCol = &p->aCol[p->nCol-1];
82330 pCol = &(p->aCol[p->nCol-1]);
82385 iCol = pTab->nCol - 1;
82389 for(iCol=0; iCol<pTab->nCol; iCol++){
82394 if( iCol<pTab->nCol ){
82400 if( iCol>=0 && iCol<pTab->nCol ){
82458 i = p->nCol-1;
82609 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
82622 n += 35 + 6*p->nCol;
82632 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
82800 p->nCol = pSelTab->nCol;
82802 pSelTab->nCol = 0;
82990 /* A positive nCol means the columns names for this view are
82993 if( pTable->nCol>0 ) return 0;
82995 /* A negative nCol is a special marker meaning that we are currently
82997 ** a negative nCol, it means two or more views form a loop, like this:
83010 if( pTable->nCol<0 ){
83014 assert( pTable->nCol>=0 );
83029 pTable->nCol = -1;
83043 pTable->nCol = pSelTab->nCol;
83045 pSelTab->nCol = 0;
83051 pTable->nCol = 0;
83076 pTab->nCol = 0;
83441 int nCol;
83447 int iCol = p->nCol-1;
83455 nCol = 1;
83462 nCol = pFromCol->nExpr;
83464 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
83476 z = (char*)&pFKey->aCol[nCol];
83482 pFKey->nCol = nCol;
83484 pFKey->aCol[0].iFrom = p->nCol-1;
83486 for(i=0; i<nCol; i++){
83488 for(j=0; j<p->nCol; j++){
83494 if( j>=p->nCol ){
83503 for(i=0; i<nCol; i++){
83720 int nCol;
83866 nullId.z = pTab->aCol[pTab->nCol-1].zName;
83893 nCol = pList->nExpr;
83896 ROUND8(sizeof(tRowcnt)*(nCol+1)) + /* Index.aiRowEst */
83897 sizeof(char *)*nCol + /* Index.azColl */
83898 sizeof(int)*nCol + /* Index.aiColumn */
83899 sizeof(u8)*nCol + /* Index.aSortOrder */
83909 ((char*)pIndex->aiRowEst + ROUND8(sizeof(tRowcnt)*nCol+1));
83912 pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
83913 pIndex->aSortOrder = (u8 *)(&pIndex->aiColumn[nCol]);
83914 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
83948 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
83951 if( j>=pTab->nCol ){
85023 int nCol = pIdx->nColumn;
85024 int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
85030 pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
85031 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
85032 for(i=0; i<nCol; i++){
85038 pKey->nField = (u16)nCol;
86022 pParse->nMem += (1 + pTab->nCol);
86027 for(iCol=0; iCol<pTab->nCol; iCol++){
86132 int nCol;
86134 nCol = pIdx->nColumn;
86135 regBase = sqlite3GetTempRange(pParse, nCol+1);
86136 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
86137 for(j=0; j<nCol; j++){
86140 sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
86153 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
86156 sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
87967 int nCol = pFKey->nCol; /* Number of columns in parent key */
87983 if( nCol==1 ){
87996 assert( nCol>1 );
87997 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
88003 if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){
88015 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
88025 for(i=0; i<nCol; i++){
88040 for(j=0; j<nCol; j++){
88046 if( j==nCol ) break;
88048 if( i==nCol ) break; /* pIdx is usable */
88117 for(i=0; i<pFKey->nCol; i++){
88152 int nCol = pFKey->nCol;
88153 int regTemp = sqlite3GetTempRange(pParse, nCol);
88159 for(i=0; i<nCol; i++){
88174 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
88175 for(i=0; i<nCol; i++){
88189 sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
88194 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
88278 for(i=0; i<pFKey->nCol; i++){
88458 ** first register in an array of (pTab->nCol+1) registers containing the
88464 ** first register of an array of (pTab->nCol+1) registers containing the new
88525 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
88526 for(i=0; i<pFKey->nCol; i++){
88534 assert( pFKey->nCol==1 || (aiFree && pIdx) );
88542 for(i=0; i<pFKey->nCol; i++){
88597 assert( aiCol || pFKey->nCol==1 );
88644 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
88691 for(i=0; i<p->nCol; i++){
88700 for(i=0; i<p->nCol; i++){
88703 for(iKey=0; iKey<pTab->nCol; iKey++){
88774 assert( aiCol || pFKey->nCol==1 );
88776 for(i=0; i<pFKey->nCol; i++){
89031 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
89110 zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
89116 for(i=0; i<pTab->nCol; i++){
89119 zColAff[pTab->nCol] = '\0';
89684 for(i=0; i<pTab->nCol; i++){
89688 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
89691 pTabList, 0, pTab->nCol-nHidden, nColumn);
89715 for(j=0; j<pTab->nCol; j++){
89724 if( j>=pTab->nCol ){
89798 pParse->nMem += pTab->nCol + 1;
89809 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
89840 for(i=0; i<pTab->nCol; i++){
89864 sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
89870 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
89872 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
89929 for(i=0; i<pTab->nCol; i++){
89970 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
89996 pTab, regData-2-pTab->nCol, onError, endOfLoop);
90151 int nCol; /* Number of columns */
90164 nCol = pTab->nCol;
90169 for(i=0; i<nCol; i++){
90454 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
90456 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
90696 if( pDest->nCol!=pSrc->nCol ){
90702 for(i=0; i<pDest->nCol; i++){
90892 int nCol;
90908 nCol = sqlite3_column_count(pStmt);
90919 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
90923 for(i=0; i<nCol; i++){
90932 azVals = &azCols[nCol];
90933 for(i=0; i<nCol; i++){
90941 if( xCallback(pArg, nCol, azVals, azCols) ){
93017 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
93055 assert( pTab->nCol>cnum );
93147 for(j=0; j<pFK->nCol; j++){
94728 for(i=0; i<pTab->nCol; i++){
94888 for(j=0; j<pRightTab->nCol; j++){
95619 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95746 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95793 int nCol; /* Number of columns in the result set */
95798 *pnCol = nCol = pEList ? pEList->nExpr : 0;
95799 aCol = *paCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
95801 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95879 int nCol, /* Number of columns */
95893 assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
95898 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95936 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
95937 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
96404 int nCol; /* Number of columns in result set */
96407 nCol = p->pEList->nExpr;
96409 sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
96416 pKeyInfo->nField = (u16)nCol;
96418 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
96434 sqlite3VdbeChangeP2(v, addr, nCol);
97783 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
97884 for(j=0; j<pTab->nCol; j++){
98023 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
98740 int nCol;
98748 nCol = nGroupBy + 1;
98752 nCol++;
98756 regBase = sqlite3GetTempRange(pParse, nCol);
98776 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
98779 sqlite3ReleaseTempRange(pParse, regBase, nCol);
98783 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
98934 if( pBest && pBest->nColumn<pTab->nCol ){
99195 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
99205 need = nCol*2;
99207 need = nCol;
99221 p->nColumn = nCol;
99222 for(i=0; i<nCol; i++){
99227 }else if( p->nColumn!=nCol ){
99239 for(i=0; i<nCol; i++){
100356 ** (a copy of pTab->nCol), then registers are populated as follows:
100544 assert( i<pTab->nCol );
100645 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
100647 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
100675 for(j=0; j<pTab->nCol; j++){
100685 if( j>=pTab->nCol ){
100759 pParse->nMem += pTab->nCol;
100765 pParse->nMem += pTab->nCol;
100876 for(i=0; i<pTab->nCol; i++){
100904 sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);
100905 for(i=0; i<pTab->nCol; i++){
100930 sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
100948 for(i=0; i<pTab->nCol; i++){
101106 for(i=0; i<pTab->nCol; i++){
101121 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
101131 pParse->nMem += pTab->nCol+1;
101135 for(i=0; i<pTab->nCol; i++){
101139 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
102007 for(iCol=0; iCol<pTab->nCol; iCol++){
102192 pTab->nCol = pParse->pNewTable->nCol;
102193 pParse->pNewTable->nCol = 0;
104624 mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol;
104625 testcase( pTable->nCol==BMS-1 );
104626 testcase( pTable->nCol==BMS-2 );
104631 nColumn += pTable->nCol - BMS + 1;
104677 for(i=BMS-1; i<pTable->nCol; i++){
107589 testcase( pTab->nCol==BMS-1 );
107590 testcase( pTab->nCol==BMS );
107591 if( !pWInfo->okOnePass && pTab->nCol<BMS ){
107597 assert( n<=pTab->nCol );
115085 for(iCol=0; iCol<pTab->nCol; iCol++){
115091 if( iCol==pTab->nCol ){
116787 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
116788 ** where nCol is the number of columns in the queried FTS table. The array
117662 int nCol; /* Number of table columns */
117668 nCol = sqlite3_column_count(pStmt);
117669 for(i=0; i<nCol; i++){
117675 azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
117679 char *p = (char *)&azCol[nCol];
117680 for(i=0; i<nCol; i++){
117691 *pnCol = nCol;
117726 int nCol = 0; /* Number of columns in the FTS table */
117870 aCol[nCol++] = z;
117886 if( nCol==0 ){
117889 rc = fts3ContentColumns(db, argv[1], zContent, &aCol, &nCol, &nString);
117895 for(j=0; j<nCol; j++){
117898 for(k=j; k<nCol; k++) aCol[k] = aCol[k+1];
117899 nCol--;
117908 if( nCol==0 ){
117912 nCol = 1;
117930 nCol * sizeof(char *) + /* azColumn */
117942 p->nColumn = nCol;
117957 p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
117974 for(iCol=0; iCol<nCol; iCol++){
120823 ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
120824 ** varints, where nCol is the number of columns in the FTS3 table.
120826 ** the table. The following nCol varints contain the total amount of
122432 int nCol; /* Number of entries in azCol[] */
122857 for(ii=0; ii<pParse->nCol; ii++){
123096 ** array, which is assumed to contain nCol entries, should contain the names
123111 int nCol, /* Number of entries in azCol[] */
123124 sParse.nCol = nCol;
123272 int nCol;
123305 nCol = argc-2;
123306 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
123311 for(ii=0; ii<nCol; ii++){
123316 pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
128087 ** two. If nCol is the number of user defined columns, then values of the
128092 ** Varint 1..nCol: For each column, the total number of tokens stored in
128095 ** Varint 1+nCol: The total size, in bytes, of all text values in all
128684 #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
128685 #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
128686 #define FTS3_MATCHINFO_LCS 's' /* nCol values */
128687 #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
128746 int nCol; /* Number of columns in table */
129395 ** for(iCol=0; iCol<nCol; iCol++){
129396 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
129397 ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
129417 p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
129432 int iStart = iPhrase * p->nCol * 3;
129435 for(i=0; i<p->nCol; i++){
129480 nVal = pInfo->nCol;
129485 nVal = pInfo->nCol * pInfo->nPhrase * 3;
129574 ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
129578 ** data written to the first nCol elements of pInfo->aMatchinfo[] is
129601 for(iCol=0; iCol<pInfo->nCol; iCol++){
129656 ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
129682 if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
129701 for(iCol=0; iCol<pInfo->nCol; iCol++){
129718 for(iCol=0; iCol<pInfo->nCol; iCol++){
129777 sInfo.nCol = pTab->nColumn;
