Lines Matching full:ncol
8723 ** Table.nCol is the number of columns in this table. Table.aCol is a
8749 int nCol; /* Number of columns in this table */
8825 int nCol; /* Number of columns in this key */
8833 } aCol[1]; /* One entry for each of nCol column s */
8932 ** In the Table structure describing Ex1, nCol==3 because there are
58409 for(iCol=0; iCol < pTab->nCol; iCol++) {
58414 if( iCol==pTab->nCol ){
58438 for(j=0; j<pFKey->nCol; j++){
58499 sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
58500 sqlite3VdbeChangeP2(v, 7, pTab->nCol);
59468 assert( pTab->nCol>0 );
59489 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
59545 for(iCol=0; iCol<pTab->nCol; iCol++){
59554 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
59557 if( iCol<pTab->nCol ){
60554 assert( pExpr->pTab && j<pExpr->pTab->nCol );
63234 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
63237 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
63239 assert( p1>=0 && p1<(pTab->nCol*2+2) );
64855 pCol = &pNew->aCol[pNew->nCol-1];
65000 pNew->nCol = pTab->nCol;
65001 assert( pNew->nCol>0 );
65002 nAlloc = (((pNew->nCol-1)/8)*8)+8;
65003 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
65010 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
65011 for(i=0; i<pNew->nCol; i++){
65189 int nCol = pIdx->nColumn;
65192 if( iMem+1+(nCol*2)>pParse->nMem ){
65193 pParse->nMem = iMem+1+(nCol*2);
65239 ** iMem+1 .. iMem+nCol:
65241 ** left-most N columns only, where N is between 1 and nCol,
65244 ** iMem+nCol+1 .. Mem+2*nCol:
65247 ** Cells iMem through iMem+nCol are initialized to 0. The others are
65250 for(i=0; i<=nCol; i++){
65253 for(i=0; i<nCol; i++){
65254 sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
65264 for(i=0; i<nCol; i++){
65299 sqlite3VdbeAddOp3(v, OP_Ne, regCol, 0, iMem+nCol+i+1);
65311 for(i=0; i<nCol; i++){
65312 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-(nCol*2));
65314 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
65342 for(i=0; i<nCol; i++){
66392 assert( iCol<pTab->nCol );
66395 assert( pTab->iPKey<pTab->nCol );
66953 for(i=0; i<pTable->nCol; i++, pCol++){
66963 pTable->nCol = 0;
67411 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
67418 for(i=0; i<p->nCol; i++){
67425 if( (p->nCol & 0x7)==0 ){
67427 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
67434 pCol = &p->aCol[p->nCol];
67443 p->nCol++;
67455 if( p==0 || NEVER(p->nCol<1) ) return;
67456 p->aCol[p->nCol-1].notNull = (u8)onError;
67534 if( p==0 || NEVER(p->nCol<1) ) return;
67535 pCol = &p->aCol[p->nCol-1];
67557 pCol = &(p->aCol[p->nCol-1]);
67612 iCol = pTab->nCol - 1;
67616 for(iCol=0; iCol<pTab->nCol; iCol++){
67621 if( iCol<pTab->nCol ){
67627 if( iCol>=0 && iCol<pTab->nCol ){
67685 i = p->nCol-1;
67835 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
67848 n += 35 + 6*p->nCol;
67858 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
68026 p->nCol = pSelTab->nCol;
68028 pSelTab->nCol = 0;
68217 /* A positive nCol means the columns names for this view are
68220 if( pTable->nCol>0 ) return 0;
68222 /* A negative nCol is a special marker meaning that we are currently
68224 ** a negative nCol, it means two or more views form a loop, like this:
68237 if( pTable->nCol<0 ){
68241 assert( pTable->nCol>=0 );
68256 pTable->nCol = -1;
68270 pTable->nCol = pSelTab->nCol;
68272 pSelTab->nCol = 0;
68277 pTable->nCol = 0;
68629 int nCol;
68635 int iCol = p->nCol-1;
68643 nCol = 1;
68650 nCol = pFromCol->nExpr;
68652 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
68664 z = (char*)&pFKey->aCol[nCol];
68670 pFKey->nCol = nCol;
68672 pFKey->aCol[0].iFrom = p->nCol-1;
68674 for(i=0; i<nCol; i++){
68676 for(j=0; j<p->nCol; j++){
68682 if( j>=p->nCol ){
68691 for(i=0; i<nCol; i++){
68866 int nCol;
69006 nullId.z = pTab->aCol[pTab->nCol-1].zName;
69033 nCol = pList->nExpr;
69036 sizeof(int)*nCol + /* Index.aiColumn */
69037 sizeof(int)*(nCol+1) + /* Index.aiRowEst */
69038 sizeof(char *)*nCol + /* Index.azColl */
69039 sizeof(u8)*nCol + /* Index.aSortOrder */
69047 pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
69048 pIndex->aiRowEst = (unsigned *)(&pIndex->aiColumn[nCol]);
69049 pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]);
69050 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
69083 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
69086 if( j>=pTab->nCol ){
70152 int nCol = pIdx->nColumn;
70153 int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
70159 pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
70160 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
70161 for(i=0; i<nCol; i++){
70167 pKey->nField = (u16)nCol;
71133 pParse->nMem += (1 + pTab->nCol);
71138 for(iCol=0; iCol<pTab->nCol; iCol++){
71245 int nCol;
71247 nCol = pIdx->nColumn;
71248 regBase = sqlite3GetTempRange(pParse, nCol+1);
71249 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
71250 for(j=0; j<nCol; j++){
71253 sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
71260 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
71263 sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
72982 int nCol = pFKey->nCol; /* Number of columns in parent key */
72998 if( nCol==1 ){
73011 assert( nCol>1 );
73012 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
73018 if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){
73030 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
73040 for(i=0; i<nCol; i++){
73055 for(j=0; j<nCol; j++){
73061 if( j==nCol ) break;
73063 if( i==nCol ) break; /* pIdx is usable */
73132 for(i=0; i<pFKey->nCol; i++){
73167 int nCol = pFKey->nCol;
73168 int regTemp = sqlite3GetTempRange(pParse, nCol);
73174 for(i=0; i<nCol; i++){
73183 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
73184 for(i=0; i<nCol; i++){
73192 sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
73197 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
73281 for(i=0; i<pFKey->nCol; i++){
73460 ** first register in an array of (pTab->nCol+1) registers containing the
73466 ** first register of an array of (pTab->nCol+1) registers containing the new
73521 assert( pFKey->nCol==1 || (aiFree && pIdx) );
73529 for(i=0; i<pFKey->nCol; i++){
73584 assert( aiCol || pFKey->nCol==1 );
73631 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
73678 for(i=0; i<p->nCol; i++){
73687 for(i=0; i<p->nCol; i++){
73690 for(iKey=0; iKey<pTab->nCol; iKey++){
73761 assert( aiCol || pFKey->nCol==1 );
73763 for(i=0; i<pFKey->nCol; i++){
74018 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
74097 zColAff = (char *)sqlite3Malloc(pTab->nCol+1);
74103 for(i=0; i<pTab->nCol; i++){
74106 zColAff[pTab->nCol] = '\0';
74669 for(i=0; i<pTab->nCol; i++){
74673 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
74676 pTabList, 0, pTab->nCol-nHidden, nColumn);
74700 for(j=0; j<pTab->nCol; j++){
74709 if( j>=pTab->nCol ){
74784 pParse->nMem += pTab->nCol + 1;
74795 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
74826 for(i=0; i<pTab->nCol; i++){
74850 sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
74856 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
74858 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
74915 for(i=0; i<pTab->nCol; i++){
74956 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
74981 pTab, regData-2-pTab->nCol, onError, endOfLoop);
75136 int nCol; /* Number of columns */
75149 nCol = pTab->nCol;
75154 for(i=0; i<nCol; i++){
75424 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
75426 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
75674 if( pDest->nCol!=pSrc->nCol ){
75680 for(i=0; i<pDest->nCol; i++){
75851 int nCol;
75867 nCol = sqlite3_column_count(pStmt);
75878 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
75882 for(i=0; i<nCol; i++){
75891 azVals = &azCols[nCol];
75892 for(i=0; i<nCol; i++){
75900 if( xCallback(pArg, nCol, azVals, azCols) ){
77790 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
77828 assert( pTab->nCol>cnum );
77920 for(j=0; j<pFK->nCol; j++){
79415 for(i=0; i<pTab->nCol; i++){
79575 for(j=0; j<pRightTab->nCol; j++){
80205 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
80332 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
80395 int nCol; /* Number of columns in the result set */
80400 *pnCol = nCol = pEList->nExpr;
80401 aCol = *paCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
80403 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
80478 int nCol, /* Number of columns */
80492 assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
80497 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
80535 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
80536 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
80974 int nCol; /* Number of columns in result set */
80977 nCol = p->pEList->nExpr;
80979 sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
80986 pKeyInfo->nField = (u16)nCol;
80988 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
81004 sqlite3VdbeChangeP2(v, addr, nCol);
82331 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
82431 for(j=0; j<pTab->nCol; j++){
82570 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
83124 int nCol;
83129 nCol = nGroupBy + 1;
83133 nCol++;
83137 regBase = sqlite3GetTempRange(pParse, nCol);
83157 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
83160 sqlite3ReleaseTempRange(pParse, regBase, nCol);
83306 if( pBest && pBest->nColumn<pTab->nCol ){
83558 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
83568 need = nCol*2;
83570 need = nCol;
83584 p->nColumn = nCol;
83585 for(i=0; i<nCol; i++){
83590 }else if( p->nColumn!=nCol ){
83602 for(i=0; i<nCol; i++){
84685 ** (a copy of pTab->nCol), then registers are populated as follows:
84872 assert( i<pTab->nCol );
84974 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
84976 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
85004 for(j=0; j<pTab->nCol; j++){
85014 if( j>=pTab->nCol ){
85086 pParse->nMem += pTab->nCol;
85092 pParse->nMem += pTab->nCol;
85202 for(i=0; i<pTab->nCol; i++){
85231 for(i=0; i<pTab->nCol; i++){
85256 sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
85274 for(i=0; i<pTab->nCol; i++){
85430 for(i=0; i<pTab->nCol; i++){
85445 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
85454 pParse->nMem += pTab->nCol+1;
85458 for(i=0; i<pTab->nCol; i++){
85462 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
86294 for(iCol=0; iCol<pTab->nCol; iCol++){
86470 pTab->nCol = pParse->pNewTable->nCol;
86471 pParse->pNewTable->nCol = 0;
90636 if( !pWInfo->okOnePass && pTab->nCol<BMS ){
90642 assert( n<=pTab->nCol );
97476 for(iCol=0; iCol<pTab->nCol
97482 if( iCol==pTab->nCol ){
99274 int nCol = 0;
99294 nCol = argc - 3 - (zTokenizer!=0);
99303 if( nCol==0 ){
99304 nCol = 1;
99309 nCol * sizeof(char *) + /* azColumn */
99321 p->nColumn = nCol;
99327 zCsr = (char *)&p->azColumn[nCol];
99355 assert( nCol==1 );
101252 int nCol; /* Number of entries in azCol[] */
101607 for(ii=0; ii<pParse->nCol; ii++){
101849 ** array, which is assumed to contain nCol entries, should contain the names
101862 int nCol, /* Number of entries in azCol[] */
101872 sParse.nCol = nCol;
102011 int nCol;
102043 nCol = argc-2;
102044 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
102049 for(ii=0; ii<nCol; ii++){
102054 pTokenizer, azCol, nCol, nCol, zExpr, nExpr, &pExpr
107306 ** 2. The number of columns in the FTS3 table (nCol).
107308 ** 3. A matrix of (nPhrase*nCol) integers containing the sum of the
107327 int nCol; /* Number of columns in table */
107375 const int iStart = 2 + p->nCol*p->iPhrase;
107400 int iOffset = 2 + p->nCol*(p->aGlobal[0]+iPhrase);
107402 memset(&p->aGlobal[iOffset], 0, p->nCol*sizeof(u32));
107423 g.nCol = pTab->nColumn;
107430 nMatchinfo = 2 + 2*g.nCol*nPhrase;
107440 g.aGlobal[1] = g.nCol;
107448 g.nCol = pTab->nColumn;
