#include "sqliteInt.h"

#if SELECTTRACE_ENABLED

/***/ int sqlite3SelectTrace = 0;

# define SELECTTRACE(K,P,S,X) \

if(sqlite3SelectTrace&(K)) \

sqlite3DebugPrintf("%*s%s.%p: ",(P)->nSelectIndent*2-2,"",\

(S)->zSelName,(S)),\

sqlite3DebugPrintf X

# define SELECTTRACE(K,P,S,X)

typedef struct DistinctCtx DistinctCtx;

struct DistinctCtx {

};

typedef struct SortCtx SortCtx;

struct SortCtx {

};

#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */

static void clearSelect(sqlite3 *db, Select *p, int bFree){

while( p ){

Select *pPrior = p->pPrior;

sqlite3ExprListDelete(db, p->pEList);

sqlite3SrcListDelete(db, p->pSrc);

sqlite3ExprDelete(db, p->pWhere);

sqlite3ExprListDelete(db, p->pGroupBy);

sqlite3ExprDelete(db, p->pHaving);

sqlite3ExprListDelete(db, p->pOrderBy);

sqlite3ExprDelete(db, p->pLimit);

sqlite3ExprDelete(db, p->pOffset);

if( p->pWith ) sqlite3WithDelete(db, p->pWith);

if( bFree ) sqlite3DbFreeNN(db, p);

p = pPrior;

bFree = 1;

}

}

void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){

pDest->eDest = (u8)eDest;

pDest->iSDParm = iParm;

pDest->zAffSdst = 0;

pDest->iSdst = 0;

pDest->nSdst = 0;

}

Select *sqlite3SelectNew(

){

Select *pNew;

Select standin;

pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );

if( pNew==0 ){

assert( pParse->db->mallocFailed );

pNew = &standin;

}

if( pEList==0 ){

pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(pParse->db,TK_ASTERISK,0));

}

pNew->pEList = pEList;

pNew->op = TK_SELECT;

pNew->selFlags = selFlags;

pNew->iLimit = 0;

pNew->iOffset = 0;

#if SELECTTRACE_ENABLED

pNew->zSelName[0] = 0;

pNew->addrOpenEphm[0] = -1;

pNew->addrOpenEphm[1] = -1;

pNew->nSelectRow = 0;

if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));

pNew->pSrc = pSrc;

pNew->pWhere = pWhere;

pNew->pGroupBy = pGroupBy;

pNew->pHaving = pHaving;

pNew->pOrderBy = pOrderBy;

pNew->pPrior = 0;

pNew->pNext = 0;

pNew->pLimit = pLimit;

pNew->pOffset = pOffset;

pNew->pWith = 0;

assert( pOffset==0 || pLimit!=0 || pParse->nErr>0 || pParse->db->mallocFailed!=0 );

if( pParse->db->mallocFailed ) {

clearSelect(pParse->db, pNew, pNew!=&standin);

pNew = 0;

}else{

assert( pNew->pSrc!=0 || pParse->nErr>0 );

}

assert( pNew!=&standin );

return pNew;

}

#if SELECTTRACE_ENABLED

void sqlite3SelectSetName(Select *p, const char *zName){

if( p && zName ){

sqlite3_snprintf(sizeof(p->zSelName), p->zSelName, "%s", zName);

}

}

void sqlite3SelectDelete(sqlite3 *db, Select *p){

if( p ) clearSelect(db, p, 1);

}

static Select *findRightmost(Select *p){

while( p->pNext ) p = p->pNext;

return p;

}

int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){

int jointype = 0;

Token *apAll[3];

Token *p;

/* 0123456789 123456789 123456789 123 */

static const char zKeyText[] = "naturaleftouterightfullinnercross";

static const struct {

u8 i; /* Beginning of keyword text in zKeyText[] */

u8 nChar; /* Length of the keyword in characters */

u8 code; /* Join type mask */

} aKeyword[] = {

/* natural */ { 0, 7, JT_NATURAL },

/* left */ { 6, 4, JT_LEFT|JT_OUTER },

/* outer */ { 10, 5, JT_OUTER },

/* right */ { 14, 5, JT_RIGHT|JT_OUTER },

/* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },

/* inner */ { 23, 5, JT_INNER },

/* cross */ { 28, 5, JT_INNER|JT_CROSS },

};

int i, j;

apAll[0] = pA;

apAll[1] = pB;

apAll[2] = pC;

for(i=0; i<3 && apAll[i]; i++){

p = apAll[i];

for(j=0; j<ArraySize(aKeyword); j++){

if( p->n==aKeyword[j].nChar

&& sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){

jointype |= aKeyword[j].code;

break;

}

}

testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );

if( j>=ArraySize(aKeyword) ){

jointype |= JT_ERROR;

break;

}

}

if(

(jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||

(jointype & JT_ERROR)!=0

){

const char *zSp = " ";

assert( pB!=0 );

if( pC==0 ){ zSp++; }

sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "

"%T %T%s%T", pA, pB, zSp, pC);

jointype = JT_INNER;

}else if( (jointype & JT_OUTER)!=0

&& (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){

sqlite3ErrorMsg(pParse,

"RIGHT and FULL OUTER JOINs are not currently supported");

jointype = JT_INNER;

}

return jointype;

}

static int columnIndex(Table *pTab, const char *zCol){

int i;

for(i=0; i<pTab->nCol; i++){

if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;

}

return -1;

}

static int tableAndColumnIndex(

){

int i; /* For looping over tables in pSrc */

int iCol; /* Index of column matching zCol */

assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */

for(i=0; i<N; i++){

iCol = columnIndex(pSrc->a[i].pTab, zCol);

if( iCol>=0 ){

if( piTab ){

*piTab = i;

*piCol = iCol;

}

return 1;

}

}

return 0;

}

static void addWhereTerm(

){

sqlite3 *db = pParse->db;

Expr *pE1;

Expr *pE2;

Expr *pEq;

assert( iLeft<iRight );

assert( pSrc->nSrc>iRight );

assert( pSrc->a[iLeft].pTab );

assert( pSrc->a[iRight].pTab );

pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);

pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);

pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);

if( pEq && isOuterJoin ){

ExprSetProperty(pEq, EP_FromJoin);

assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );

ExprSetVVAProperty(pEq, EP_NoReduce);

pEq->iRightJoinTable = (i16)pE2->iTable;

}

*ppWhere = sqlite3ExprAnd(db, *ppWhere, pEq);

}

static void setJoinExpr(Expr *p, int iTable){

while( p ){

ExprSetProperty(p, EP_FromJoin);

assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );

ExprSetVVAProperty(p, EP_NoReduce);

p->iRightJoinTable = (i16)iTable;

if( p->op==TK_FUNCTION && p->x.pList ){

int i;

for(i=0; i<p->x.pList->nExpr; i++){

setJoinExpr(p->x.pList->a[i].pExpr, iTable);

}

}

setJoinExpr(p->pLeft, iTable);

p = p->pRight;

}

}

static int sqliteProcessJoin(Parse *pParse, Select *p){

SrcList *pSrc; /* All tables in the FROM clause */

int i, j; /* Loop counters */

struct SrcList_item *pLeft; /* Left table being joined */

struct SrcList_item *pRight; /* Right table being joined */

pSrc = p->pSrc;

pLeft = &pSrc->a[0];

pRight = &pLeft[1];

for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){

Table *pLeftTab = pLeft->pTab;

Table *pRightTab = pRight->pTab;

int isOuter;

if( NEVER(pLeftTab==0 || pRightTab==0) ) continue;

isOuter = (pRight->fg.jointype & JT_OUTER)!=0;

/* When the NATURAL keyword is present, add WHERE clause terms for

if( pRight->fg.jointype & JT_NATURAL ){

if( pRight->pOn || pRight->pUsing ){

sqlite3ErrorMsg(pParse, "a NATURAL join may not have "

"an ON or USING clause", 0);

return 1;

}

for(j=0; j<pRightTab->nCol; j++){

char *zName; /* Name of column in the right table */

int iLeft; /* Matching left table */

int iLeftCol; /* Matching column in the left table */

zName = pRightTab->aCol[j].zName;

if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){

addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,

isOuter, &p->pWhere);

}

}

}

/* Disallow both ON and USING clauses in the same join

if( pRight->pOn && pRight->pUsing ){

sqlite3ErrorMsg(pParse, "cannot have both ON and USING "

"clauses in the same join");

return 1;

}

/* Add the ON clause to the end of the WHERE clause, connected by

if( pRight->pOn ){

if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);

p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);

pRight->pOn = 0;

}

/* Create extra terms on the WHERE clause for each column named

if( pRight->pUsing ){

IdList *pList = pRight->pUsing;

for(j=0; j<pList->nId; j++){

char *zName; /* Name of the term in the USING clause */

int iLeft; /* Table on the left with matching column name */

int iLeftCol; /* Column number of matching column on the left */

int iRightCol; /* Column number of matching column on the right */

zName = pList->a[j].zName;

iRightCol = columnIndex(pRightTab, zName);

if( iRightCol<0

|| !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)

){

sqlite3ErrorMsg(pParse, "cannot join using column %s - column "

"not present in both tables", zName);

return 1;

}

addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,

isOuter, &p->pWhere);

}

}

}

return 0;

}

static KeyInfo *keyInfoFromExprList(

);

static void pushOntoSorter(

){

Vdbe *v = pParse->pVdbe; /* Stmt under construction */

int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0);

int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */

int nBase = nExpr + bSeq + nData; /* Fields in sorter record */

int regBase; /* Regs for sorter record */

int regRecord = ++pParse->nMem; /* Assembled sorter record */

int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */

int op; /* Opcode to add sorter record to sorter */

int iLimit; /* LIMIT counter */

assert( bSeq==0 || bSeq==1 );

assert( nData==1 || regData==regOrigData || regOrigData==0 );

if( nPrefixReg ){

assert( nPrefixReg==nExpr+bSeq );

regBase = regData - nExpr - bSeq;

}else{

regBase = pParse->nMem + 1;

pParse->nMem += nBase;

}

assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );

iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;

pSort->labelDone = sqlite3VdbeMakeLabel(v);

sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,

SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0));

if( bSeq ){

sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);

}

if( nPrefixReg==0 && nData>0 ){

sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData);

}

sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regRecord);

if( nOBSat>0 ){

int regPrevKey; /* The first nOBSat columns of the previous row */

int addrFirst; /* Address of the OP_IfNot opcode */

int addrJmp; /* Address of the OP_Jump opcode */

VdbeOp *pOp; /* Opcode that opens the sorter */

int nKey; /* Number of sorting key columns, including OP_Sequence */

KeyInfo *pKI; /* Original KeyInfo on the sorter table */

regPrevKey = pParse->nMem+1;

pParse->nMem += pSort->nOBSat;

nKey = nExpr - pSort->nOBSat + bSeq;

if( bSeq ){

addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);

}else{

addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);

}

VdbeCoverage(v);

sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);

pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);

if( pParse->db->mallocFailed ) return;

pOp->p2 = nKey + nData;

pKI = pOp->p4.pKeyInfo;

memset(pKI->aSortOrder, 0, pKI->nField); /* Makes OP_Jump below testable */

sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);

testcase( pKI->nXField>2 );

pOp->p4.pKeyInfo = keyInfoFromExprList(pParse, pSort->pOrderBy, nOBSat,

pKI->nXField-1);

addrJmp = sqlite3VdbeCurrentAddr(v);

sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);

pSort->labelBkOut = sqlite3VdbeMakeLabel(v);

pSort->regReturn = ++pParse->nMem;

sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);

sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);

if( iLimit ){

sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);

VdbeCoverage(v);

}

sqlite3VdbeJumpHere(v, addrFirst);

sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);

sqlite3VdbeJumpHere(v, addrJmp);

}

if( pSort->sortFlags & SORTFLAG_UseSorter ){

op = OP_SorterInsert;

}else{

op = OP_IdxInsert;

}

sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,

regBase+nOBSat, nBase-nOBSat);

if( iLimit ){

int addr;

int r1 = 0;

/* Fill the sorter until it contains LIMIT+OFFSET entries. (The iLimit

addr = sqlite3VdbeAddOp1(v, OP_IfNotZero, iLimit); VdbeCoverage(v);

sqlite3VdbeAddOp1(v, OP_Last, pSort->iECursor);

if( pSort->bOrderedInnerLoop ){

r1 = ++pParse->nMem;

sqlite3VdbeAddOp3(v, OP_Column, pSort->iECursor, nExpr, r1);

VdbeComment((v, "seq"));

}

sqlite3VdbeAddOp1(v, OP_Delete, pSort->iECursor);

if( pSort->bOrderedInnerLoop ){

/* If the inner loop is driven by an index such that values from

int iBrk = sqlite3VdbeCurrentAddr(v) + 2;

sqlite3VdbeAddOp3(v, OP_Eq, regBase+nExpr, iBrk, r1);

sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);

VdbeCoverage(v);

}

sqlite3VdbeJumpHere(v, addr);

}

}

static void codeOffset(

){

if( iOffset>0 ){

sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v);

VdbeComment((v, "OFFSET"));

}

}

static void codeDistinct(

){

Vdbe *v;

int r1;

v = pParse->pVdbe;

r1 = sqlite3GetTempReg(pParse);

sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);

sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);

sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);

sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);

sqlite3ReleaseTempReg(pParse, r1);

}

static void selectInnerLoop(

){

Vdbe *v = pParse->pVdbe;

int i;

int hasDistinct; /* True if the DISTINCT keyword is present */

int eDest = pDest->eDest; /* How to dispose of results */

int iParm = pDest->iSDParm; /* First argument to disposal method */

int nResultCol; /* Number of result columns */

int nPrefixReg = 0; /* Number of extra registers before regResult */

/* Usually, regResult is the first cell in an array of memory cells

int regResult; /* Start of memory holding current results */

int regOrig; /* Start of memory holding full result (or 0) */

assert( v );

assert( pEList!=0 );

hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;

if( pSort && pSort->pOrderBy==0 ) pSort = 0;

if( pSort==0 && !hasDistinct ){

assert( iContinue!=0 );

codeOffset(v, p->iOffset, iContinue);

}

/* Pull the requested columns.

nResultCol = pEList->nExpr;

if( pDest->iSdst==0 ){

if( pSort ){

nPrefixReg = pSort->pOrderBy->nExpr;

if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++;

pParse->nMem += nPrefixReg;

}

pDest->iSdst = pParse->nMem+1;

pParse->nMem += nResultCol;

}else if( pDest->iSdst+nResultCol > pParse->nMem ){

/* This is an error condition that can result, for example, when a SELECT

pParse->nMem += nResultCol;

}

pDest->nSdst = nResultCol;

regOrig = regResult = pDest->iSdst;

if( srcTab>=0 ){

for(i=0; i<nResultCol; i++){

sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);

VdbeComment((v, "%s", pEList->a[i].zName));

}

}else if( eDest!=SRT_Exists ){

/* If the destination is an EXISTS(...) expression, the actual

u8 ecelFlags;

if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){

ecelFlags = SQLITE_ECEL_DUP;

}else{

ecelFlags = 0;

}

if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){

/* For each expression in pEList that is a copy of an expression in

ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF);

for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){

int j;

if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){

pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;

}

}

regOrig = 0;

assert( eDest==SRT_Set || eDest==SRT_Mem

|| eDest==SRT_Coroutine || eDest==SRT_Output );

}

nResultCol = sqlite3ExprCodeExprList(pParse,pEList,regResult,0,ecelFlags);

}

/* If the DISTINCT keyword was present on the SELECT statement

if( hasDistinct ){

switch( pDistinct->eTnctType ){

case WHERE_DISTINCT_ORDERED: {

VdbeOp *pOp; /* No longer required OpenEphemeral instr. */

int iJump; /* Jump destination */

int regPrev; /* Previous row content */

/* Allocate space for the previous row */

regPrev = pParse->nMem+1;

pParse->nMem += nResultCol;

/* Change the OP_OpenEphemeral coded earlier to an OP_Null

sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);

pOp = sqlite3VdbeGetOp(v, pDistinct->addrTnct);

pOp->opcode = OP_Null;

pOp->p1 = 1;

pOp->p2 = regPrev;

iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;

for(i=0; i<nResultCol; i++){

CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);

if( i<nResultCol-1 ){

sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);

VdbeCoverage(v);

}else{

sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);

VdbeCoverage(v);

}

sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);

sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);

}

assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );

sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);

break;

}

case WHERE_DISTINCT_UNIQUE: {

sqlite3VdbeChangeToNoop(v, pDistinct->addrTnct);

break;

}

default: {

assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );

codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol,

regResult);

break;

}

}

if( pSort==0 ){

codeOffset(v, p->iOffset, iContinue);

}

}

switch( eDest ){

/* In this mode, write each query result to the key of the temporary

#ifndef SQLITE_OMIT_COMPOUND_SELECT

case SRT_Union: {

int r1;

r1 = sqlite3GetTempReg(pParse);

sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);

sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);

sqlite3ReleaseTempReg(pParse, r1);

break;

}

/* Construct a record from the query result, but instead of

case SRT_Except: {

sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);

break;

}

#endif /* SQLITE_OMIT_COMPOUND_SELECT */

/* Store the result as data using a unique key.

case SRT_Fifo:

case SRT_DistFifo:

case SRT_Table:

case SRT_EphemTab: {

int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1);

testcase( eDest==SRT_Table );

testcase( eDest==SRT_EphemTab );

testcase( eDest==SRT_Fifo );

testcase( eDest==SRT_DistFifo );

sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);

#ifndef SQLITE_OMIT_CTE

if( eDest==SRT_DistFifo ){

/* If the destination is DistFifo, then cursor (iParm+1) is open

int addr = sqlite3VdbeCurrentAddr(v) + 4;

sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);

VdbeCoverage(v);

sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);

assert( pSort==0 );

}

if( pSort ){

pushOntoSorter(pParse, pSort, p, r1+nPrefixReg,regResult,1,nPrefixReg);

}else{

int r2 = sqlite3GetTempReg(pParse);

sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);

sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);

sqlite3VdbeChangeP5(v, OPFLAG_APPEND);

sqlite3ReleaseTempReg(pParse, r2);

}

sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1);

break;

}

#ifndef SQLITE_OMIT_SUBQUERY

/* If we are creating a set for an "expr IN (SELECT ...)" construct,

case SRT_Set: {

if( pSort ){

/* At first glance you would think we could optimize out the

pushOntoSorter(

pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);

}else{

int r1 = sqlite3GetTempReg(pParse);

assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol );

sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,

r1, pDest->zAffSdst, nResultCol);

sqlite3ExprCacheAffinityChange(pParse, regResult, nResultCol);

sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);

sqlite3ReleaseTempReg(pParse, r1);

}

break;

}

/* If any row exist in the result set, record that fact and abort.

case SRT_Exists: {

sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);

/* The LIMIT clause will terminate the loop for us */

break;

}

/* If this is a scalar select that is part of an expression, then

case SRT_Mem: {

if( pSort ){

assert( nResultCol<=pDest->nSdst );

pushOntoSorter(

pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);

}else{

assert( nResultCol==pDest->nSdst );

assert( regResult==iParm );

/* The LIMIT clause will jump out of the loop for us */

}

break;

}

#endif /* #ifndef SQLITE_OMIT_SUBQUERY */

case SRT_Coroutine: /* Send data to a co-routine */

case SRT_Output: { /* Return the results */

testcase( eDest==SRT_Coroutine );

testcase( eDest==SRT_Output );

if( pSort ){

pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol,

nPrefixReg);

}else if( eDest==SRT_Coroutine ){

sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);

}else{

sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);

sqlite3ExprCacheAffinityChange(pParse, regResult, nResultCol);

}

break;

}

#ifndef SQLITE_OMIT_CTE

/* Write the results into a priority queue that is order according to

case SRT_DistQueue:

case SRT_Queue: {

int nKey;

int r1, r2, r3;

int addrTest = 0;

ExprList *pSO;

pSO = pDest->pOrderBy;

assert( pSO );

nKey = pSO->nExpr;

r1 = sqlite3GetTempReg(pParse);

r2 = sqlite3GetTempRange(pParse, nKey+2);

r3 = r2+nKey+1;

if( eDest==SRT_DistQueue ){

/* If the destination is DistQueue, then cursor (iParm+1) is open

addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,

regResult, nResultCol);

VdbeCoverage(v);

}

sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);

if( eDest==SRT_DistQueue ){

sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);

sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);

}

for(i=0; i<nKey; i++){

sqlite3VdbeAddOp2(v, OP_SCopy,

regResult + pSO->a[i].u.x.iOrderByCol - 1,

r2+i);

}

sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);

sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);

sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);

if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);

sqlite3ReleaseTempReg(pParse, r1);

sqlite3ReleaseTempRange(pParse, r2, nKey+2);