/*
** A list of expressions.  Each expression may optionally have a
** name.  An expr/name combination can be used in several ways, such
** as the list of "expr AS ID" fields following a "SELECT" or in the
** list of "ID = expr" items in an UPDATE.  A list of expressions can
** also be used as the argument to a function, in which case the a.zName
** field is not used.







*/
struct ExprList {
  int nExpr;             /* Number of expressions on the list */
  int iECursor;          /* VDBE Cursor associated with this ExprList */
  struct ExprList_item { /* For each expression in the list */
    Expr *pExpr;           /* The list of expressions */
    char *zName;           /* Token associated with this expression */
    char *zSpan;           /* Original text of the expression */
    u8 sortOrder;          /* 1 for DESC or 0 for ASC */
    u8 done;               /* A flag to indicate when processing is finished */

    u16 iOrderByCol;       /* For ORDER BY, column number in result set */
    u16 iAlias;            /* Index into Parse.aAlias[] for zName */
  } *a;                  /* Alloc a power of two greater or equal to nExpr */
};

/*
** An instance of this structure is used by the parser to record both
** the parse tree for an expression and the span of input text for an
** expression.

/*
** A list of expressions.  Each expression may optionally have a
** name.  An expr/name combination can be used in several ways, such
** as the list of "expr AS ID" fields following a "SELECT" or in the
** list of "ID = expr" items in an UPDATE.  A list of expressions can
** also be used as the argument to a function, in which case the a.zName
** field is not used.
**
** By default the Expr.zSpan field holds a human-readable description of
** the expression that is used in the generation of error messages and
** column labels.  In this case, Expr.zSpan is typically the text of a
** column expression as it exists in a SELECT statement.  However, if
** the bSpanIsTab flag is set, then zSpan is overloaded to mean the name
** of the table to which the column of a FROM-clause subquery refers.
*/
struct ExprList {
  int nExpr;             /* Number of expressions on the list */
  int iECursor;          /* VDBE Cursor associated with this ExprList */
  struct ExprList_item { /* For each expression in the list */
    Expr *pExpr;            /* The list of expressions */
    char *zName;            /* Token associated with this expression */
    char *zSpan;            /* Original text of the expression */
    u8 sortOrder;           /* 1 for DESC or 0 for ASC */
    unsigned done :1;       /* A flag to indicate when processing is finished */
    unsigned bSpanIsTab :1; /* zSpan holds table name, not the span */
    u16 iOrderByCol;        /* For ORDER BY, column number in result set */
    u16 iAlias;             /* Index into Parse.aAlias[] for zName */
  } *a;                  /* Alloc a power of two greater or equal to nExpr */
};

/*
** An instance of this structure is used by the parser to record both
** the parse tree for an expression and the span of input text for an
** expression.

# 2012 December 19
#
# 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 implements regression tests for name resolution in SELECT
# statements that have parenthesized FROM clauses.
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl

do_test selectD-1.1 {
  db eval {
    CREATE TABLE t1(a,b); INSERT INTO t1 VALUES(111,'x1');
    CREATE TABLE t2(a,b); INSERT INTO t2 VALUES(222,'x2');
    CREATE TABLE t3(a,b); INSERT INTO t3 VALUES(333,'x3');
    CREATE TABLE t4(a,b); INSERT INTO t4 VALUES(444,'x4');

    SELECT *
      FROM (t1), (t2), (t3), (t4)
     WHERE t4.a=t3.a+111 
       AND t3.a=t2.a+111
       AND t2.a=t1.a+111;
  }
} {111 x1 222 x2 333 x3 444 x4}
do_test selectD-1.2 {
  db eval {
    SELECT *
      FROM t1 JOIN (t2 JOIN (t3 JOIN t4 ON t4.a=t3.a+111)
                            ON t3.a=t2.a+111)
                   ON t2.a=t1.a+111;
  }
} {111 x1 222 x2 333 x3 444 x4}
do_test selectD-1.3 {
  db eval {
    UPDATE t2 SET a=111;
    UPDATE t3 SET a=111;
    UPDATE t4 SET a=111;
    SELECT *
      FROM t1 JOIN (t2 JOIN (t3 JOIN t4 USING(a)) USING (a)) USING (a);
  }
} {111 x1 x2 x3 x4}
do_test selectD-1.4 {
  db eval {
    UPDATE t2 SET a=111;
    UPDATE t3 SET a=111;
    UPDATE t4 SET a=111;
    SELECT *
      FROM t1 LEFT JOIN (t2 LEFT JOIN (t3 LEFT JOIN t4 USING(a))
                                      USING (a))
                         USING (a);
  }
} {111 x1 x2 x3 x4}
do_test selectD-1.5 {
  db eval {
    UPDATE t3 SET a=222;
    UPDATE t4 SET a=222;
    SELECT *
      FROM (t1 LEFT JOIN t2 USING(a)) JOIN (t3 LEFT JOIN t4 USING(a))
           ON t1.a=t3.a-111;
  }
} {111 x1 x2 222 x3 x4}
do_test selectD-1.6 {
  db eval {
    UPDATE t4 SET a=333;
    SELECT *
      FROM (t1 LEFT JOIN t2 USING(a)) JOIN (t3 LEFT JOIN t4 USING(a))
           ON t1.a=t3.a-111;
  }
} {111 x1 x2 222 x3 {}}

finish_test