Lines Matching full:ncol
8728 ** Table.nCol is the number of columns in this table. Table.aCol is a
8754 int nCol; /* Number of columns in this table */
8830 int nCol; /* Number of columns in this key */
8838 } aCol[1]; /* One entry for each of nCol column s */
8937 ** In the Table structure describing Ex1, nCol==3 because there are
58420 for(iCol=0; iCol < pTab->nCol; iCol++) {
58425 if( iCol==pTab->nCol ){
58449 for(j=0; j<pFKey->nCol; j++){
58510 sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
58511 sqlite3VdbeChangeP2(v, 7, pTab->nCol);
59479 assert( pTab->nCol>0 );
59500 for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
59556 for(iCol=0; iCol<pTab->nCol; iCol++){
59565 if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
59568 if( iCol<pTab->nCol ){
60565 assert( pExpr->pTab && j<pExpr->pTab->nCol );
63245 int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
63248 assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
63250 assert( p1>=0 && p1<(pTab->nCol*2+2) );
64866 pCol = &pNew->aCol[pNew->nCol-1];
65011 pNew->nCol = pTab->nCol;
65012 assert( pNew->nCol>0 );
65013 nAlloc = (((pNew->nCol-1)/8)*8)+8;
65014 assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
65021 memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
65022 for(i=0; i<pNew->nCol; i++){
65200 int nCol = pIdx->nColumn;
65203 if( iMem+1+(nCol*2)>pParse->nMem ){
65204 pParse->nMem = iMem+1+(nCol*2);
65250 ** iMem+1 .. iMem+nCol:
65252 ** left-most N columns only, where N is between 1 and nCol,
65255 ** iMem+nCol+1 .. Mem+2*nCol:
65258 ** Cells iMem through iMem+nCol are initialized to 0. The others are
65261 for(i=0; i<=nCol; i++){
65264 for(i=0; i<nCol; i++){
65265 sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
65275 for(i=0; i<nCol; i++){
65310 sqlite3VdbeAddOp3(v, OP_Ne, regCol, 0, iMem+nCol+i+1);
65322 for(i=0; i<nCol; i++){
65323 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-(nCol*2));
65325 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
65353 for(i=0; i<nCol; i++){
66403 assert( iCol<pTab->nCol );
66406 assert( pTab->iPKey<pTab->nCol );
66964 for(i=0; i<pTable->nCol; i++, pCol++){
66974 pTable->nCol = 0;
67422 if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
67429 for(i=0; i<p->nCol; i++){
67436 if( (p->nCol & 0x7)==0 ){
67438 aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
67445 pCol = &p->aCol[p->nCol];
67454 p->nCol++;
67466 if( p==0 || NEVER(p->nCol<1) ) return;
67467 p->aCol[p->nCol-1].notNull = (u8)onError;
67545 if( p==0 || NEVER(p->nCol<1) ) return;
67546 pCol = &p->aCol[p->nCol-1];
67568 pCol = &(p->aCol[p->nCol-1]);
67623 iCol = pTab->nCol - 1;
67627 for(iCol=0; iCol<pTab->nCol; iCol++){
67632 if( iCol<pTab->nCol ){
67638 if( iCol>=0 && iCol<pTab->nCol ){
67696 i = p->nCol-1;
67846 for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
67859 n += 35 + 6*p->nCol;
67869 for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
68037 p->nCol = pSelTab->nCol;
68039 pSelTab->nCol = 0;
68228 /* A positive nCol means the columns names for this view are
68231 if( pTable->nCol>0 ) return 0;
68233 /* A negative nCol is a special marker meaning that we are currently
68235 ** a negative nCol, it means two or more views form a loop, like this:
68248 if( pTable->nCol<0 ){
68252 assert( pTable->nCol>=0 );
68267 pTable->nCol = -1;
68281 pTable->nCol = pSelTab->nCol;
68283 pSelTab->nCol = 0;
68288 pTable->nCol = 0;
68640 int nCol;
68646 int iCol = p->nCol-1;
68654 nCol = 1;
68661 nCol = pFromCol->nExpr;
68663 nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
68675 z = (char*)&pFKey->aCol[nCol];
68681 pFKey->nCol = nCol;
68683 pFKey->aCol[0].iFrom = p->nCol-1;
68685 for(i=0; i<nCol; i++){
68687 for(j=0; j<p->nCol; j++){
68693 if( j>=p->nCol ){
68702 for(i=0; i<nCol; i++){
68877 int nCol;
69017 nullId.z = pTab->aCol[pTab->nCol-1].zName;
69044 nCol = pList->nExpr;
69047 sizeof(int)*nCol + /* Index.aiColumn */
69048 sizeof(int)*(nCol+1) + /* Index.aiRowEst */
69049 sizeof(char *)*nCol + /* Index.azColl */
69050 sizeof(u8)*nCol + /* Index.aSortOrder */
69058 pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
69059 pIndex->aiRowEst = (unsigned *)(&pIndex->aiColumn[nCol]);
69060 pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]);
69061 pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
69094 for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
69097 if( j>=pTab->nCol ){
70163 int nCol = pIdx->nColumn;
70164 int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
70170 pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
70171 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
70172 for(i=0; i<nCol; i++){
70178 pKey->nField = (u16)nCol;
71144 pParse->nMem += (1 + pTab->nCol);
71149 for(iCol=0; iCol<pTab->nCol; iCol++){
71256 int nCol;
71258 nCol = pIdx->nColumn;
71259 regBase = sqlite3GetTempRange(pParse, nCol+1);
71260 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
71261 for(j=0; j<nCol; j++){
71264 sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
71271 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
71274 sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
72993 int nCol = pFKey->nCol; /* Number of columns in parent key */
73009 if( nCol==1 ){
73022 assert( nCol>1 );
73023 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
73029 if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){
73041 for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
73051 for(i=0; i<nCol; i++){
73066 for(j=0; j<nCol; j++){
73072 if( j==nCol ) break;
73074 if( i==nCol ) break; /* pIdx is usable */
73143 for(i=0; i<pFKey->nCol; i++){
73178 int nCol = pFKey->nCol;
73179 int regTemp = sqlite3GetTempRange(pParse, nCol);
73185 for(i=0; i<nCol; i++){
73194 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
73195 for(i=0; i<nCol; i++){
73203 sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
73208 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
73292 for(i=0; i<pFKey->nCol; i++){
73471 ** first register in an array of (pTab->nCol+1) registers containing the
73477 ** first register of an array of (pTab->nCol+1) registers containing the new
73532 assert( pFKey->nCol==1 || (aiFree && pIdx) );
73540 for(i=0; i<pFKey->nCol; i++){
73595 assert( aiCol || pFKey->nCol==1 );
73642 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
73689 for(i=0; i<p->nCol; i++){
73698 for(i=0; i<p->nCol; i++){
73701 for(iKey=0; iKey<pTab->nCol; iKey++){
73772 assert( aiCol || pFKey->nCol==1 );
73774 for(i=0; i<pFKey->nCol; i++){
74029 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
74108 zColAff = (char *)sqlite3Malloc(pTab->nCol+1);
74114 for(i=0; i<pTab->nCol; i++){
74117 zColAff[pTab->nCol] = '\0';
74680 for(i=0; i<pTab->nCol; i++){
74684 if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
74687 pTabList, 0, pTab->nCol-nHidden, nColumn);
74711 for(j=0; j<pTab->nCol; j++){
74720 if( j>=pTab->nCol ){
74795 pParse->nMem += pTab->nCol + 1;
74806 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
74837 for(i=0; i<pTab->nCol; i++){
74861 sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
74867 pTab, regCols-pTab->nCol-1, onError, endOfLoop);
74869 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
74926 for(i=0; i<pTab->nCol; i++){
74967 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
74992 pTab, regData-2-pTab->nCol, onError, endOfLoop);
75147 int nCol; /* Number of columns */
75160 nCol = pTab->nCol;
75165 for(i=0; i<nCol; i++){
75435 sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
75437 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
75685 if( pDest->nCol!=pSrc->nCol ){
75691 for(i=0; i<pDest->nCol; i++){
75862 int nCol;
75878 nCol = sqlite3_column_count(pStmt);
75889 azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
75893 for(i=0; i<nCol; i++){
75902 azVals = &azCols[nCol];
75903 for(i=0; i<nCol; i++){
75911 if( xCallback(pArg, nCol, azVals, azCols) ){
77801 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
77839 assert( pTab->nCol>cnum );
77931 for(j=0; j<pFK->nCol; j++){
79426 for(i=0; i<pTab->nCol; i++){
79586 for(j=0; j<pRightTab->nCol; j++){
80216 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
80343 assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
80406 int nCol; /* Number of columns in the result set */
80411 *pnCol = nCol = pEList->nExpr;
80412 aCol = *paCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
80414 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
80489 int nCol, /* Number of columns */
80503 assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
80508 for(i=0, pCol=aCol; i<nCol; i++, pCol++){
80546 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
80547 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
80985 int nCol; /* Number of columns in result set */
80988 nCol = p->pEList->nExpr;
80990 sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
80997 pKeyInfo->nField = (u16)nCol;
80999 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
81015 sqlite3VdbeChangeP2(v, addr, nCol);
82342 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
82442 for(j=0; j<pTab->nCol; j++){
82581 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
83135 int nCol;
83140 nCol = nGroupBy + 1;
83144 nCol++;
83148 regBase = sqlite3GetTempRange(pParse, nCol);
83168 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
83171 sqlite3ReleaseTempRange(pParse, regBase, nCol);
83317 if( pBest && pBest->nColumn<pTab->nCol ){
83569 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
83579 need = nCol*2;
83581 need = nCol;
83595 p->nColumn = nCol;
83596 for(i=0; i<nCol; i++){
83601 }else if( p->nColumn!=nCol ){
83613 for(i=0; i<nCol; i++){
84696 ** (a copy of pTab->nCol), then registers are populated as follows:
84883 assert( i<pTab->nCol );
84985 aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
84987 for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
85015 for(j=0; j<pTab->nCol; j++){
85025 if( j>=pTab->nCol ){
85097 pParse->nMem += pTab->nCol;
85103 pParse->nMem += pTab->nCol;
85213 for(i=0; i<pTab->nCol; i++){
85242 for(i=0; i<pTab->nCol; i++){
85267 sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
85285 for(i=0; i<pTab->nCol; i++){
85441 for(i=0; i<pTab->nCol; i++){
85456 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
85465 pParse->nMem += pTab->nCol+1;
85469 for(i=0; i<pTab->nCol; i++){
85473 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
86305 for(iCol=0; iCol<pTab->nCol; iCol++){
86481 pTab->nCol = pParse->pNewTable->nCol;
86482 pParse->pNewTable->nCol = 0;
90647 if( !pWInfo->okOnePass && pTab->nCol<BMS ){
90653 assert( n<=pTab->nCol );
97510 for(iCol=0; iCol<pTab->nCol; iCol++){
97516 if( iCol==pTab->nCol ){
99308 int nCol = 0;
99328 nCol = argc - 3 - (zTokenizer!=0);
99337 if( nCol==0 ){
99338 nCol = 1;
99343 nCol * sizeof(char *) + /* azColumn */
99355 p->nColumn = nCol;
99361 zCsr = (char *)&p->azColumn[nCol];
99389 assert( nCol==1 );
101292 int nCol; /* Number of entries in azCol[] */
101647 for(ii=0; ii<pParse->nCol; ii++){
101889 ** array, which is assumed to contain nCol entries, should contain the names
101902 int nCol, /* Number of entries in azCol[] */
101912 sParse.nCol = nCol;
102051 int nCol;
102083 nCol = argc-2;
102084 azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
102089 for(ii=0; ii<nCol; ii++){
102094 pTokenizer, azCol, nCol, nCol, zExpr, nExpr, &pExpr
107346 ** 2. The number of columns in the FTS3 table (nCol).
107348 ** 3. A matrix of (nPhrase*nCol) integers containing the sum of the
107367 int nCol; /* Number of columns in table */
107415 const int iStart = 2 + p->nCol*p->iPhrase;
107440 int iOffset = 2 + p->nCol*(p->aGlobal[0]+iPhrase);
107442 memset(&p->aGlobal[iOffset], 0, p->nCol*sizeof(u32));
107463 g.nCol = pTab->nColumn;
107470 nMatchinfo = 2 + 2*g.nCol*nPhrase;
107480 g.aGlobal[1] = g.nCol;
107488 g.nCol = pTab->nColumn;
