After merge fix

mysql-test/r/join_outer.result:
  Auto merged
mysql-test/r/select.result:
  Auto merged
sql/item_cmpfunc.h:
  Auto merged
sql/sql_lex.cc:
  Auto merged
sql/sql_lex.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.h:
  Auto merged

mysql-test/r/join_outer.result

@@ -356,13 +356,7 @@ select t1.name, t2.name, t2.id, t2.owner, t3.id from t1 left join t2 on (t1.id =
 name	name	id	owner	id
 Antonio Paz	El Gato	1	1	1
 Antonio Paz	Perrito	2	1	1
-Lilliana Angelovska	NULL	NULL	NULL	1
-Thimble Smith	NULL	NULL	NULL	1
-Antonio Paz	NULL	NULL	NULL	2
-Lilliana Angelovska	NULL	NULL	NULL	2
-Thimble Smith	NULL	NULL	NULL	2
-Antonio Paz	NULL	NULL	NULL	3
-Lilliana Angelovska	NULL	NULL	NULL	3
+NULL	NULL	NULL	NULL	2
 Thimble Smith	Happy	3	3	3
 drop table t1,t2;
 create table t1 (id int not null, str char(10), index(str));

mysql-test/r/select.result

@@ -2157,13 +2157,10 @@ a	a	a
 3	3	3
 select * from t1 inner join (t1 as t2 left join t1 as t3 using (a)) on t1.a>1;
 a	a	a
-1	1	NULL
 2	1	1
 3	1	1
-1	2	NULL
 2	2	2
 3	2	2
-1	3	NULL
 2	3	3
 3	3	3
 select * from (t1 as t2 left join t1 as t3 using (a)) inner join t1 using ( a );
@@ -2174,13 +2171,7 @@ a	a	a
 select * from t1 inner join (t1 as t2 left join t1 as t3 using (a)) using ( a );
 a	a	a
 1	1	1
-2	1	NULL
-3	1	NULL
-1	2	NULL
 2	2	2
-3	2	NULL
-1	3	NULL
-2	3	NULL
 3	3	3
 select * from (t1 as t2 left join t1 as t3 using (a)) left outer join t1 on t1.a>1;
 a	a	a
@@ -2192,14 +2183,12 @@ a	a	a
 3	3	3
 select * from t1 left outer join (t1 as t2 left join t1 as t3 using (a)) on t1.a>1;
 a	a	a
-1	1	NULL
+1	NULL	NULL
 2	1	1
-3	1	1
-1	2	NULL
 2	2	2
-3	2	2
-1	3	NULL
 2	3	3
+3	1	1
+3	2	2
 3	3	3
 select * from (t1 as t2 left join t1 as t3 using (a)) left join t1 using ( a );
 a	a	a
@@ -2209,13 +2198,7 @@ a	a	a
 select * from t1 left join (t1 as t2 left join t1 as t3 using (a)) using ( a );
 a	a	a
 1	1	1
-2	1	NULL
-3	1	NULL
-1	2	NULL
 2	2	2
-3	2	NULL
-1	3	NULL
-2	3	NULL
 3	3	3
 select * from (t1 as t2 left join t1 as t3 using (a)) natural left join t1;
 a	a	a
@@ -2229,9 +2212,7 @@ a	a	a
 3	3	3
 select * from (t1 as t2 left join t1 as t3 using (a)) right join t1 on t1.a>1;
 a	a	a
-1	NULL	1
-2	NULL	1
-3	NULL	1
+NULL	NULL	1
 1	1	2
 2	2	2
 3	3	2
@@ -2249,13 +2230,7 @@ a	a	a
 select * from (t1 as t2 left join t1 as t3 using (a)) right outer join t1 using ( a );
 a	a	a
 1	1	1
-2	NULL	1
-3	NULL	1
-1	NULL	2
 2	2	2
-3	NULL	2
-1	NULL	3
-2	NULL	3
 3	3	3
 select * from t1 right outer join (t1 as t2 left join t1 as t3 using (a)) using ( a );
 a	a	a
@@ -2265,13 +2240,7 @@ a	a	a
 select * from (t1 as t2 left join t1 as t3 using (a)) natural right join t1;
 a	a	a
 1	1	1
-2	NULL	1
-3	NULL	1
-1	NULL	2
 2	2	2
-3	NULL	2
-1	NULL	3
-2	NULL	3
 3	3	3
 select * from t1 natural right join (t1 as t2 left join t1 as t3 using (a));
 a	a	a

sql/item_cmpfunc.h

@@ -233,6 +233,40 @@ class Item_func_not :public Item_bool_func
   Item *neg_transformer(THD *thd);
 };
 
+
+/*
+  The class Item_func_trig_cond is used for guarded predicates 
+  which are employed only for internal purposes.
+  A guarded predicates is an object consisting of an a regular or
+  a guarded predicate P and a pointer to a boolean guard variable g. 
+  A guarded predicate P/g is evaluated to true if the value of the
+  guard g is false, otherwise it is evaluated to the same value that
+  the predicate P: val(P/g)= g ? val(P):true.
+  Guarded predicates allow us to include predicates into a conjunction
+  conditionally. Currently they are utilized for pushed down predicates
+  in queries with outer join operations.
+
+  In the future, probably, it makes sense to extend this class to
+  the objects consisting of three elements: a predicate P, a pointer
+  to a variable g and a firing value s with following evaluation
+  rule: val(P/g,s)= g==s? val(P) : true. It will allow us to build only
+  one item for the objects of the form P/g1/g2... 
+
+  Objects of this class are built only for query execution after
+  the execution plan has been already selected. That's why this
+  class needs only val_int out of generic methods. 
+*/
+
+class Item_func_trig_cond: public Item_bool_func
+{
+  bool *trig_var;
+public:
+  Item_func_trig_cond(Item *a, bool *f) : Item_bool_func(a) { trig_var= f; }
+  longlong val_int() { return *trig_var ? args[0]->val_int() : 1; }
+  enum Functype functype() const { return TRIG_COND_FUNC; };
+  const char *func_name() const { return "trigcond"; };
+};
+
 class Item_func_not_all :public Item_func_not
 {
   bool abort_on_null;
@@ -817,7 +851,7 @@ class Item_func_isnotnull :public Item_bool_func
   }
   const char *func_name() const { return "isnotnull"; }
   optimize_type select_optimize() const { return OPTIMIZE_NULL; }
-  table_map not_null_tables() const { return 0; }
+  table_map not_null_tables() const { return used_tables(); }
   Item *neg_transformer(THD *thd);
   void print(String *str);
   CHARSET_INFO *compare_collation() { return args[0]->collation.collation; }

sql/item_func.h

@@ -47,7 +47,8 @@ class Item_func :public Item_result_field
 		  SP_CONTAINS_FUNC,SP_OVERLAPS_FUNC,
 		  SP_STARTPOINT,SP_ENDPOINT,SP_EXTERIORRING,
 		  SP_POINTN,SP_GEOMETRYN,SP_INTERIORRINGN,
-		  NOT_FUNC, NOT_ALL_FUNC, NOW_FUNC,
+                  NOT_FUNC, NOT_ALL_FUNC,
+                  NOW_FUNC, TRIG_COND_FUNC,
                   GUSERVAR_FUNC};
   enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL };
   enum Type type() const { return FUNC_ITEM; }

sql/sql_lex.cc

@@ -1003,6 +1003,9 @@ void st_select_lex::init_query()
 {
   st_select_lex_node::init_query();
   table_list.empty();
+  top_join_list.empty();
+  join_list= &top_join_list;
+  embedding= 0;
   item_list.empty();
   join= 0;
   where= 0;

sql/sql_lex.h

@@ -416,6 +416,9 @@ class st_select_lex: public st_select_lex_node
   List<Item_func_match> *ftfunc_list;
   List<Item_func_match> ftfunc_list_alloc;
   JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
+  List<TABLE_LIST> top_join_list; /* join list of the top level          */
+  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */  
+  TABLE_LIST *embedding;          /* table embedding to the above list   */
   const char *type;               /* type of select for EXPLAIN          */
 
   SQL_LIST order_list;                /* ORDER clause */
@@ -513,6 +516,12 @@ class st_select_lex: public st_select_lex_node
 				List<String> *ignore_index= 0,
                                 LEX_STRING *option= 0);
   TABLE_LIST* get_table_list();
+  bool init_nested_join(THD *thd);
+  TABLE_LIST *end_nested_join(THD *thd);
+  TABLE_LIST *nest_last_join(THD *thd);
+  void save_names_for_using_list(TABLE_LIST *tab1, TABLE_LIST *tab2);
+  void add_joined_table(TABLE_LIST *table);
+  TABLE_LIST *convert_right_join();
   List<Item>* get_item_list();
   List<String>* get_use_index();
   List<String>* get_ignore_index();

sql/sql_parse.cc

@@ -4796,6 +4796,237 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
 }
 
 
+/*
+  Initialize a new table list for a nested join
+
+  SYNOPSIS
+    init_table_list() 
+    thd         current thread
+  
+  DESCRIPTION
+    The function initializes a structure of the TABLE_LIST type
+    for a nested join. It sets up its nested join list as empty.
+    The created structure is added to the front of the current
+    join list in the st_select_lex object. Then the function
+    changes the current nest level for joins to refer to the newly
+    created empty list after having saved the info on the old level
+    in the initialized structure.
+
+  RETURN VALUE
+    0,  if success
+    1,  otherwise
+*/
+
+bool st_select_lex::init_nested_join(THD *thd)
+{
+  TABLE_LIST *ptr;
+  NESTED_JOIN *nested_join;
+  DBUG_ENTER("init_nested_join");
+  
+  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))) ||
+      !(nested_join= ptr->nested_join=
+                    (NESTED_JOIN *) thd->calloc(sizeof(NESTED_JOIN))))
+    DBUG_RETURN(1);
+  join_list->push_front(ptr);
+  ptr->embedding= embedding;
+  ptr->join_list= join_list;
+  embedding= ptr;
+  join_list= &nested_join->join_list;
+  join_list->empty();
+  DBUG_RETURN(0);
+}
+
+
+/*
+  End a nested join table list
+
+  SYNOPSIS
+    end_nested_join()
+    thd         current thread
+
+  DESCRIPTION
+    The function returns to the previous join nest level.
+    If the current level contains only one member, the function
+    moves it one level up, eliminating the nest. 
+
+  RETURN VALUE
+    Pointer to TABLE_LIST element added to the total table list, if success
+    0, otherwise
+*/
+
+TABLE_LIST *st_select_lex::end_nested_join(THD *thd)
+{
+  TABLE_LIST *ptr;
+  DBUG_ENTER("end_nested_join");
+  ptr= embedding;
+  join_list= ptr->join_list;
+  embedding= ptr->embedding;
+  NESTED_JOIN *nested_join= ptr->nested_join;
+  if (nested_join->join_list.elements == 1)
+  {
+    TABLE_LIST *embedded= nested_join->join_list.head();
+    join_list->pop();
+    embedded->join_list= join_list;
+    embedded->embedding= embedding;
+    join_list->push_front(embedded);
+    ptr= embedded;
+  }
+  DBUG_RETURN(ptr);
+}
+
+
+/*
+  Nest last join operation
+
+  SYNOPSIS
+    nest_last_join() 
+    thd         current thread
+
+  DESCRIPTION
+    The function nest last join operation as if it was enclosed in braces.
+
+  RETURN VALUE
+    Pointer to TABLE_LIST element created for the new nested join, if success
+    0, otherwise
+*/
+
+TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
+{
+  TABLE_LIST *ptr;
+  NESTED_JOIN *nested_join;
+  DBUG_ENTER("nest_last_join");
+  
+  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))) ||
+      !(nested_join= ptr->nested_join=
+                    (NESTED_JOIN *) thd->calloc(sizeof(NESTED_JOIN))))
+    DBUG_RETURN(0);
+  ptr->embedding= embedding;
+  ptr->join_list= join_list;
+  List<TABLE_LIST> *embedded_list= &nested_join->join_list;
+  embedded_list->empty();
+  for (int i=0; i < 2; i++)
+  {
+    TABLE_LIST *table= join_list->pop();
+    table->join_list= embedded_list;
+    table->embedding= ptr;
+    embedded_list->push_back(table);
+  }
+  join_list->push_front(ptr);
+  nested_join->used_tables= nested_join->not_null_tables= (table_map) 0;
+  DBUG_RETURN(ptr);
+}
+
+
+/*
+  Save names for a join with using clase
+   
+  SYNOPSIS
+    save_names_for_using_list
+    tab1      left table in join
+    tab2      right table in join
+
+  DESCRIPTION
+    The function saves the full names of the tables in st_select_lex
+    to be able to build later an on expression to replace the using clause.   
+  
+  RETURN VALUE
+    None  
+*/    
+
+void st_select_lex::save_names_for_using_list(TABLE_LIST *tab1,
+                                              TABLE_LIST *tab2)
+{
+  while (tab1->nested_join)
+  {
+    tab1= tab1->nested_join->join_list.head();
+  }
+  db1= tab1->db;
+  table1= tab1->alias;
+  while (tab2->nested_join)
+  {
+    TABLE_LIST *next;
+    List_iterator_fast<TABLE_LIST> it(tab2->nested_join->join_list);
+    tab2= it++;
+    while ((next= it++))
+      tab2= next;
+  }
+  db2= tab2->db;
+  table2= tab2->alias;
+}
+  
+
+/*
+  Add a table to the current join list
+
+  SYNOPSIS
+    add_joined_table()
+    table       the table to add
+
+  DESCRIPTION
+    The function puts a table in front of the current join list
+    of st_select_lex object.
+    Thus, joined tables are put into this list in the reverse order
+    (the most outer join operation follows first).
+
+  RETURN VALUE
+    None
+*/
+
+void st_select_lex::add_joined_table(TABLE_LIST *table)
+{
+  DBUG_ENTER("add_joined_table");
+  join_list->push_front(table);
+  table->join_list= join_list;
+  table->embedding= embedding;
+  DBUG_VOID_RETURN;
+}
+
+
+/*
+  Convert a right join into equivalent left join
+
+  SYNOPSIS
+    convert_right_join()
+    thd         current thread
+  
+  DESCRIPTION 
+    The function takes the current join list t[0],t[1] ... and 
+    effectively converts it into the list t[1],t[0] ...
+    Although the outer_join flag for the new nested table contains
+    JOIN_TYPE_RIGHT, it will be handled as the inner table of a left join
+    operation.
+
+  EXAMPLES
+    SELECT * FROM t1 RIGHT JOIN t2 ON on_expr =>
+      SELECT * FROM t2 LEFT JOIN t1 ON on_expr
+
+    SELECT * FROM t1,t2 RIGHT JOIN t3 ON on_expr =>
+      SELECT * FROM t1,t3 LEFT JOIN t2 ON on_expr
+
+    SELECT * FROM t1,t2 RIGHT JOIN (t3,t4) ON on_expr =>
+      SELECT * FROM t1,(t3,t4) LEFT JOIN t2 ON on_expr
+
+    SELECT * FROM t1 LEFT JOIN t2 ON on_expr1 RIGHT JOIN t3  ON on_expr2 =>
+      SELECT * FROM t3 LEFT JOIN (t1 LEFT JOIN t2 ON on_expr2) ON on_expr1
+
+  RETURN
+    Pointer to the table representing the inner table, if success
+    0, otherwise
+*/
+
+TABLE_LIST *st_select_lex::convert_right_join() 
+{
+  TABLE_LIST *tab2= join_list->pop();
+  TABLE_LIST *tab1= join_list->pop(); 
+  DBUG_ENTER("convert_right_join");
+
+  join_list->push_front(tab2);
+  join_list->push_front(tab1);
+  tab1->outer_join|= JOIN_TYPE_RIGHT;
+
+  DBUG_RETURN(tab1);
+}
+
 /*
   Set lock for all tables in current select level
 

sql/sql_select.h

@@ -75,7 +75,6 @@ typedef struct st_join_cache {
 /*
 ** The structs which holds the join connections and join states
 */
-
 enum join_type { JT_UNKNOWN,JT_SYSTEM,JT_CONST,JT_EQ_REF,JT_REF,JT_MAYBE_REF,
 		 JT_ALL, JT_RANGE, JT_NEXT, JT_FT, JT_REF_OR_NULL,
 		 JT_UNIQUE_SUBQUERY, JT_INDEX_SUBQUERY, JT_INDEX_MERGE};
@@ -88,7 +87,13 @@ typedef struct st_join_table {
   SQL_SELECT	*select;
   COND		*select_cond;
   QUICK_SELECT_I *quick;
-  Item		*on_expr;
+  Item		*on_expr;       /* associated on expression                  */
+  st_join_table *first_inner;   /* first inner table for including outerjoin */
+  bool           found;         /* true after all matches or null complement */
+  bool           not_null_compl;/* true before null complement is added      */
+  st_join_table *last_inner;    /* last table table for embedding outer join */
+  st_join_table *first_upper;  /* first inner table for embedding outer join */
+  st_join_table *first_unmatched; /* used for optimization purposes only     */
   const char	*info;
   int		(*read_first_record)(struct st_join_table *tab);
   int		(*next_select)(JOIN *,struct st_join_table *,bool);
@@ -201,8 +206,10 @@ class JOIN :public Sql_alloc
   ORDER *order, *group_list, *proc_param; //hold parameters of mysql_select
   COND *conds;                            // ---"---
   Item *conds_history;                    // store WHERE for explain
-  TABLE_LIST *tables_list;           //hold 'tables' parameter of mysql_selec
+  TABLE_LIST *tables_list;           //hold 'tables' parameter of mysql_select
+  List<TABLE_LIST> *join_list;       // list of joined tables in reverse order
   SQL_SELECT *select;                //created in optimisation phase
+  JOIN_TAB *return_tab;              //used only for outer joins
   Item **ref_pointer_array; //used pointer reference for this select
   // Copy of above to be used with different lists
   Item **items0, **items1, **items2, **items3, **current_ref_pointer_array;
@@ -226,6 +233,7 @@ class JOIN :public Sql_alloc
     table= 0;
     tables= 0;
     const_tables= 0;
+    join_list= 0;
     sort_and_group= 0;
     first_record= 0;
     do_send_rows= 1;
@@ -256,6 +264,7 @@ class JOIN :public Sql_alloc
     fields_list= fields_arg;
     error= 0;
     select= 0;
+    return_tab= 0;
     ref_pointer_array= items0= items1= items2= items3= 0;
     ref_pointer_array_size= 0;
     zero_result_cause= 0;

sql/table.h

@@ -26,7 +26,6 @@ class st_select_lex_unit;
 typedef struct st_order {
   struct st_order *next;
   Item	 **item;			/* Point at item in select fields */
-  Item	 *item_ptr;			/* Storage for initial item */
   Item   **item_copy;			/* For SPs; the original item ptr */
   bool	 asc;				/* true if ascending */
   bool	 free_me;			/* true if item isn't shared  */
@@ -67,8 +66,7 @@ struct st_table {
   handler *file;
   Field **field;			/* Pointer to fields */
   Field_blob **blob_field;		/* Pointer to blob fields */
-  /* hash of field names (contains pointers to elements of field array) */
-  HASH	name_hash;
+  HASH	name_hash;			/* hash of field names */
   byte *record[2];			/* Pointer to records */
   byte *default_values;          	/* Default values for INSERT */
   byte *insert_values;                  /* used by INSERT ... UPDATE */
@@ -99,20 +97,8 @@ struct st_table {
   uint raid_type,raid_chunks;
   uint status;				/* Used by postfix.. */
   uint system;				/* Set if system record */
-
-  /* 
-    These two members hold offset in record + 1 for TIMESTAMP field
-    with NOW() as default value or/and with ON UPDATE NOW() option. 
-    If 0 then such field is absent in this table or auto-set for default
-    or/and on update should be temporaly disabled for some reason.
-    These values is setup to offset value for each statement in open_table()
-    and turned off in statement processing code (see mysql_update as example).
-  */
-  ulong timestamp_default_now;
-  ulong timestamp_on_update_now;
-  /* Index of auto-updated TIMESTAMP field in field array */
+  ulong time_stamp;			/* Set to offset+1 of record */
   uint timestamp_field_offset;
-  
   uint next_number_index;
   uint blob_ptr_size;			/* 4 or 8 */
   uint next_number_key_offset;
@@ -123,7 +109,7 @@ struct st_table {
   my_bool maybe_null,outer_join;	/* Used with OUTER JOIN */
   my_bool force_index;
   my_bool distinct,const_table,no_rows;
-  my_bool key_read;
+  my_bool key_read, bulk_insert;
   my_bool crypted;
   my_bool db_low_byte_first;		/* Portable row format */
   my_bool locked_by_flush;
@@ -157,12 +143,8 @@ struct st_table {
   uint		quick_key_parts[MAX_KEY];
   key_part_map  const_key_parts[MAX_KEY];
   ulong		query_id;
-
-  union					/* Temporary variables */
-  {
   uint        temp_pool_slot;		/* Used by intern temp tables */
-    struct st_table_list *pos_in_table_list;
-  };
+  struct st_table_list *pos_in_table_list;/* Element referring to this table */
   /* number of select if it is derived table */
   uint          derived_select_number;
   THD		*in_use;		/* Which thread uses this */
@@ -188,17 +170,28 @@ typedef struct st_table_list
  GRANT_INFO	grant;
   thr_lock_type lock_type;
   uint		outer_join;		/* Which join type */
-  uint		shared;			/* Used in multi-upd */
+  uint		shared;			/* Used in union or in multi-upd */
   uint32        db_length, real_name_length;
   bool		straight;		/* optimize with prev table */
   bool          updating;               /* for replicate-do/ignore table */
-  bool		force_index;		/* Prefer index over table scan */
-  bool          ignore_leaves;          /* Preload only non-leaf nodes */
-  bool		cacheable_table;	/* stop PS caching */
-  /* used in multi-upd privelege check */
-  bool		table_in_update_from_clause;
+  bool		force_index;		/* prefer index over table scan */
+  bool          ignore_leaves;          /* preload only non-leaf nodes */
+  table_map     dep_tables;             /* tables the table depends on      */
+  table_map     on_expr_dep_tables;     /* tables on expression depends on  */ 
+  struct st_nested_join *nested_join;   /* if the element is a nested join  */
+  st_table_list *embedding;             /* nested join containing the table */
+  List<struct st_table_list> *join_list;/* join list the table belongs to   */ 
 } TABLE_LIST;
 
+typedef struct st_nested_join
+{
+  List<TABLE_LIST>  join_list;       /* list of elements in the nested join */
+  table_map         used_tables;     /* bitmap of tables in the nested join */
+  table_map         not_null_tables; /* tables that rejects nulls           */ 
+  struct st_join_table *first_nested;/* the first nested table in the plan  */
+  uint              counter;         /* to count tables in the nested join  */
+} NESTED_JOIN;
+  
 typedef struct st_changed_table_list
 {
   struct	st_changed_table_list *next;
@@ -206,8 +199,7 @@ typedef struct st_changed_table_list
   uint32        key_length;
 } CHANGED_TABLE_LIST;
 
-typedef struct st_open_table_list
-{
+typedef struct st_open_table_list{
   struct st_open_table_list *next;
   char	*db,*table;
   uint32 in_use,locked;