/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** This file contains C code routines that are called by the parser

** to handle SELECT statements in SQLite.

*/

#include "sqliteInt.h"

/*

** Trace output macros

*/

#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

#else

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

#endif

/*

** An instance of the following object is used to record information about

** how to process the DISTINCT keyword, to simplify passing that information

** into the selectInnerLoop() routine.

*/

typedef struct DistinctCtx DistinctCtx;

struct DistinctCtx {

u8 isTnct; /* True if the DISTINCT keyword is present */

u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */

int tabTnct; /* Ephemeral table used for DISTINCT processing */

int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */

};

/*

** An instance of the following object is used to record information about

** the ORDER BY (or GROUP BY) clause of query is being coded.

*/

typedef struct SortCtx SortCtx;

struct SortCtx {

ExprList *pOrderBy; /* The ORDER BY (or GROUP BY clause) */

int nOBSat; /* Number of ORDER BY terms satisfied by indices */

int iECursor; /* Cursor number for the sorter */

int regReturn; /* Register holding block-output return address */

int labelBkOut; /* Start label for the block-output subroutine */

int addrSortIndex; /* Address of the OP_SorterOpen or OP_OpenEphemeral */

int labelDone; /* Jump here when done, ex: LIMIT reached */

u8 sortFlags; /* Zero or more SORTFLAG_* bits */

};

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

/*

** Delete all the content of a Select structure. Deallocate the structure

** itself only if bFree is true.

*/

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);

sqlite3WithDelete(db, p->pWith);

if( bFree ) sqlite3DbFree(db, p);

p = pPrior;

bFree = 1;

}

}

/*

** Initialize a SelectDest structure.

*/

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

pDest->eDest = (u8)eDest;

pDest->iSDParm = iParm;

pDest->affSdst = 0;

pDest->iSdst = 0;

pDest->nSdst = 0;

}

/*

** Allocate a new Select structure and return a pointer to that

** structure.

*/

Select *sqlite3SelectNew(

Parse *pParse, /* Parsing context */

ExprList *pEList, /* which columns to include in the result */

SrcList *pSrc, /* the FROM clause -- which tables to scan */

Expr *pWhere, /* the WHERE clause */

ExprList *pGroupBy, /* the GROUP BY clause */

Expr *pHaving, /* the HAVING clause */

ExprList *pOrderBy, /* the ORDER BY clause */

u16 selFlags, /* Flag parameters, such as SF_Distinct */

Expr *pLimit, /* LIMIT value. NULL means not used */

Expr *pOffset /* OFFSET value. NULL means no offset */

){

Select *pNew;

Select standin;

sqlite3 *db = pParse->db;

pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );

if( pNew==0 ){

assert( db->mallocFailed );

pNew = &standin;

}

if( pEList==0 ){

pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(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;

#endif

pNew->addrOpenEphm[0] = -1;

pNew->addrOpenEphm[1] = -1;

pNew->nSelectRow = 0;

if( pSrc==0 ) pSrc = sqlite3DbMallocZero(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 || db->mallocFailed!=0 );

if( db->mallocFailed ) {

clearSelect(db, pNew, pNew!=&standin);

pNew = 0;

}else{

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

}

assert( pNew!=&standin );

return pNew;

}

#if SELECTTRACE_ENABLED

/*

** Set the name of a Select object

*/

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

if( p && zName ){

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

}

}

#endif

/*

** Delete the given Select structure and all of its substructures.

*/

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

clearSelect(db, p, 1);

}

/*

** Return a pointer to the right-most SELECT statement in a compound.

*/

static Select *findRightmost(Select *p){

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

return p;

}

/*

** Given 1 to 3 identifiers preceding the JOIN keyword, determine the

** type of join. Return an integer constant that expresses that type

** in terms of the following bit values:

**

** JT_INNER

** JT_CROSS

** JT_OUTER

** JT_NATURAL

** JT_LEFT

** JT_RIGHT

**

** A full outer join is the combination of JT_LEFT and JT_RIGHT.

**

** If an illegal or unsupported join type is seen, then still return

** a join type, but put an error in the pParse structure.

*/

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;

}

/*

** Return the index of a column in a table. Return -1 if the column

** is not contained in the table.

*/

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;

}

/*

** Search the first N tables in pSrc, from left to right, looking for a

** table that has a column named zCol.

**

** When found, set *piTab and *piCol to the table index and column index

** of the matching column and return TRUE.

**

** If not found, return FALSE.

*/

static int tableAndColumnIndex(

SrcList *pSrc, /* Array of tables to search */

int N, /* Number of tables in pSrc->a[] to search */

const char *zCol, /* Name of the column we are looking for */

int *piTab, /* Write index of pSrc->a[] here */

int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */

){

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;

}

/*

** This function is used to add terms implied by JOIN syntax to the

** WHERE clause expression of a SELECT statement. The new term, which

** is ANDed with the existing WHERE clause, is of the form:

**

** (tab1.col1 = tab2.col2)

**

** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the

** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is

** column iColRight of tab2.

*/

static void addWhereTerm(

Parse *pParse, /* Parsing context */

SrcList *pSrc, /* List of tables in FROM clause */

int iLeft, /* Index of first table to join in pSrc */

int iColLeft, /* Index of column in first table */

int iRight, /* Index of second table in pSrc */

int iColRight, /* Index of column in second table */

int isOuterJoin, /* True if this is an OUTER join */

Expr **ppWhere /* IN/OUT: The WHERE clause to add to */

){

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, 0);

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);

}

/*

** Set the EP_FromJoin property on all terms of the given expression.

** And set the Expr.iRightJoinTable to iTable for every term in the

** expression.

**

** The EP_FromJoin property is used on terms of an expression to tell

** the LEFT OUTER JOIN processing logic that this term is part of the

** join restriction specified in the ON or USING clause and not a part

** of the more general WHERE clause. These terms are moved over to the

** WHERE clause during join processing but we need to remember that they

** originated in the ON or USING clause.

**

** The Expr.iRightJoinTable tells the WHERE clause processing that the

** expression depends on table iRightJoinTable even if that table is not

** explicitly mentioned in the expression. That information is needed

** for cases like this:

**

** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5

**

** The where clause needs to defer the handling of the t1.x=5

** term until after the t2 loop of the join. In that way, a

** NULL t2 row will be inserted whenever t1.x!=5. If we do not

** defer the handling of t1.x=5, it will be processed immediately

** after the t1 loop and rows with t1.x!=5 will never appear in

** the output, which is incorrect.

*/

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;

}

}

/*

** This routine processes the join information for a SELECT statement.

** ON and USING clauses are converted into extra terms of the WHERE clause.

** NATURAL joins also create extra WHERE clause terms.

**

** The terms of a FROM clause are contained in the Select.pSrc structure.

** The left most table is the first entry in Select.pSrc. The right-most

** table is the last entry. The join operator is held in the entry to

** the left. Thus entry 0 contains the join operator for the join between

** entries 0 and 1. Any ON or USING clauses associated with the join are

** also attached to the left entry.

**

** This routine returns the number of errors encountered.

*/

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

** every column that the two tables have in common.

*/

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

** an AND operator.

*/

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

** in the USING clause. Example: If the two tables to be joined are

** A and B and the USING clause names X, Y, and Z, then add this

** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z

** Report an error if any column mentioned in the USING clause is

** not contained in both tables to be joined.

*/

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;

}

/* Forward reference */

static KeyInfo *keyInfoFromExprList(

Parse *pParse, /* Parsing context */

ExprList *pList, /* Form the KeyInfo object from this ExprList */

int iStart, /* Begin with this column of pList */

int nExtra /* Add this many extra columns to the end */

);

/*

** Generate code that will push the record in registers regData

** through regData+nData-1 onto the sorter.

*/

static void pushOntoSorter(

Parse *pParse, /* Parser context */

SortCtx *pSort, /* Information about the ORDER BY clause */

Select *pSelect, /* The whole SELECT statement */

int regData, /* First register holding data to be sorted */

int regOrigData, /* First register holding data before packing */

int nData, /* Number of elements in the data array */

int nPrefixReg /* No. of reg prior to regData available for use */

){

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 );

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|SQLITE_ECEL_REF);

if( bSeq ){

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

}

if( nPrefixReg==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;

}

sqlite3VdbeAddOp2(v, op, pSort->iECursor, regRecord);

if( iLimit ){

int addr;

addr = sqlite3VdbeAddOp3(v, OP_IfNotZero, iLimit, 0, 1); VdbeCoverage(v);

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

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

sqlite3VdbeJumpHere(v, addr);

}

}

/*

** Add code to implement the OFFSET

*/

static void codeOffset(

Vdbe *v, /* Generate code into this VM */

int iOffset, /* Register holding the offset counter */

int iContinue /* Jump here to skip the current record */

){

if( iOffset>0 ){

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

VdbeComment((v, "OFFSET"));

}

}

/*

** Add code that will check to make sure the N registers starting at iMem

** form a distinct entry. iTab is a sorting index that holds previously

** seen combinations of the N values. A new entry is made in iTab

** if the current N values are new.

**

** A jump to addrRepeat is made and the N+1 values are popped from the

** stack if the top N elements are not distinct.

*/

static void codeDistinct(

Parse *pParse, /* Parsing and code generating context */

int iTab, /* A sorting index used to test for distinctness */

int addrRepeat, /* Jump to here if not distinct */

int N, /* Number of elements */

int iMem /* First element */

){

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);

sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);

sqlite3ReleaseTempReg(pParse, r1);

}

#ifndef SQLITE_OMIT_SUBQUERY

/*

** Generate an error message when a SELECT is used within a subexpression

** (example: "a IN (SELECT * FROM table)") but it has more than 1 result

** column. We do this in a subroutine because the error used to occur

** in multiple places. (The error only occurs in one place now, but we

** retain the subroutine to minimize code disruption.)

*/

static int checkForMultiColumnSelectError(

Parse *pParse, /* Parse context. */

SelectDest *pDest, /* Destination of SELECT results */

int nExpr /* Number of result columns returned by SELECT */

){

int eDest = pDest->eDest;

if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){

sqlite3ErrorMsg(pParse, "only a single result allowed for "

"a SELECT that is part of an expression");

return 1;

}else{

return 0;

}

}

#endif

/*

** This routine generates the code for the inside of the inner loop

** of a SELECT.

**

** If srcTab is negative, then the pEList expressions

** are evaluated in order to get the data for this row. If srcTab is

** zero or more, then data is pulled from srcTab and pEList is used only

** to get number columns and the datatype for each column.

*/

static void selectInnerLoop(

Parse *pParse, /* The parser context */

Select *p, /* The complete select statement being coded */

ExprList *pEList, /* List of values being extracted */

int srcTab, /* Pull data from this table */

SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */

DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */

SelectDest *pDest, /* How to dispose of the results */

int iContinue, /* Jump here to continue with next row */

int iBreak /* Jump here to break out of the inner loop */

){

Vdbe *v = pParse->pVdbe;

int i;

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

int regResult; /* Start of memory holding result set */

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 */

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

** on the right-hand side of an INSERT contains more result columns than

** there are columns in the table on the left. The error will be caught

** and reported later. But we need to make sure enough memory is allocated

** to avoid other spurious errors in the meantime. */

pParse->nMem += nResultCol;

}

pDest->nSdst = nResultCol;

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

** values returned by the SELECT are not required.

*/

u8 ecelFlags;

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

ecelFlags = SQLITE_ECEL_DUP;

}else{

ecelFlags = 0;

}

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

}

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

** and this row has been seen before, then do not make this row

** part of the result.

*/

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

** sets the MEM_Cleared bit on the first register of the

** previous value. This will cause the OP_Ne below to always

** fail on the first iteration of the loop even if the first

** row is all NULLs.

*/

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

** table iParm.

*/

#ifndef SQLITE_OMIT_COMPOUND_SELECT

case SRT_Union: {

int r1;

r1 = sqlite3GetTempReg(pParse);

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

sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);

sqlite3ReleaseTempReg(pParse, r1);

break;

}

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

** saving that record, use it as a key to delete elements from

** the temporary table iParm.

*/

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

** on an ephemeral index. If the current row is already present

** in the index, do not write it to the output. If not, add the

** current row to the index and proceed with writing it to the

** output table as well. */

int addr = sqlite3VdbeCurrentAddr(v) + 4;

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

VdbeCoverage(v);

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

assert( pSort==0 );

}

#endif

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,

** then there should be a single item on the stack. Write this

** item into the set table with bogus data.

*/

case SRT_Set: {

assert( nResultCol==1 );

pDest->affSdst =

sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affSdst);

if( pSort ){

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

** ORDER BY in this case since the order of entries in the set

** does not matter. But there might be a LIMIT clause, in which

** case the order does matter */

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

}else{

int r1 = sqlite3GetTempReg(pParse);

sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult,1,r1, &pDest->affSdst, 1);

sqlite3ExprCacheAffinityChange(pParse, regResult, 1);

sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);

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

** store the results in the appropriate memory cell and break out

** of the scan loop.

*/

case SRT_Mem: {

assert( nResultCol==1 );

if( pSort ){

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

}else{

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, regResult, 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

** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an

** index with pSO->nExpr+2 columns. Build a key using pSO for the first

** pSO->nExpr columns, then make sure all keys are unique by adding a

** final OP_Sequence column. The last column is the record as a blob.

*/

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

** on a second ephemeral index that holds all values every previously

** added to the queue. */

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);

sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);

if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);

sqlite3ReleaseTempReg(pParse, r1);

sqlite3ReleaseTempRange(pParse, r2, nKey+2);

break;

}

#endif /* SQLITE_OMIT_CTE */

#if !defined(SQLITE_OMIT_TRIGGER)

/* Discard the results. This is used for SELECT statements inside

** the body of a TRIGGER. The purpose of such selects is to call

** user-defined functions that have side effects. We do not care

** about the actual results of the select.

*/

default: {

assert( eDest==SRT_Discard );

break;

}

#endif

}

/* Jump to the end of the loop if the LIMIT is reached. Except, if

** there is a sorter, in which case the sorter has already limited

** the output for us.

*/

if( pSort==0 && p->iLimit ){

sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);

}