Merge

include/my_global.h

@@ -950,8 +950,7 @@ typedef long long	my_ptrdiff_t;
 #define MY_ALIGN(A,L)	(((A) + (L) - 1) & ~((L) - 1))
 #define ALIGN_SIZE(A)	MY_ALIGN((A),sizeof(double))
 /* Size to make adressable obj. */
-#define ALIGN_PTR(A, t) ((t*) MY_ALIGN((A),sizeof(t)))
-			 /* Offset of field f in structure t */
+#define ALIGN_PTR(A, t) ((t*) MY_ALIGN((A), sizeof(double)))
 #define OFFSET(t, f)	((size_t)(char *)&((t *)0)->f)
 #define ADD_TO_PTR(ptr,size,type) (type) ((uchar*) (ptr)+size)
 #define PTR_BYTE_DIFF(A,B) (my_ptrdiff_t) ((uchar*) (A) - (uchar*) (B))

sql-bench/test-table-elimination.sh

@@ -290,10 +290,6 @@ print "time for select_one_attribute ($count:$rows): " .
     timestr(timediff($end_time, $loop_time),"all") . "\n";
 
 
-###
-### TODO...
-###
-
 ;
 
 ####

sql/item.cc

@@ -1916,10 +1916,10 @@ void Item_field::reset_field(Field *f)
 }
 
 
-bool Item_field::check_column_usage_processor(uchar *arg)
+bool Item_field::enumerate_field_refs_processor(uchar *arg)
 {
   Field_enumerator *fe= (Field_enumerator*)arg;
-  fe->see_field(field);
+  fe->visit_field(field);
   return FALSE;
 }
 

sql/item.h

@@ -734,7 +734,7 @@ public:
   /* 
     Bitmap of tables used by item
     (note: if you need to check dependencies on individual columns, check out
-     check_column_usage_processor)
+     class Field_enumerator)
   */
   virtual table_map used_tables() const { return (table_map) 0L; }
   /*
@@ -892,7 +892,7 @@ public:
   virtual bool reset_query_id_processor(uchar *query_id_arg) { return 0; }
   virtual bool is_expensive_processor(uchar *arg) { return 0; }
   virtual bool register_field_in_read_map(uchar *arg) { return 0; }
-  virtual bool check_column_usage_processor(uchar *arg) { return 0; }
+  virtual bool enumerate_field_refs_processor(uchar *arg) { return 0; }
   virtual bool mark_as_eliminated_processor(uchar *arg) { return 0; }
   /*
     Check if a partition function is allowed
@@ -1018,14 +1018,29 @@ public:
 };
 
 
-/* Data for Item::check_column_usage_processor */
+/*
+  Class to be used to enumerate all field references in an item tree.
+  Suggested usage:
+
+    class My_enumerator : public Field_enumerator 
+    {
+      virtual void visit_field() { ... your actions ...} 
+    }
+
+    My_enumerator enumerator;
+    item->walk(Item::enumerate_field_refs_processor, ...,(uchar*)&enumerator);
+
+  This is similar to Visitor pattern.
+*/
+
 class Field_enumerator
 {
 public:
-  virtual void see_field(Field *field)= 0;
-  virtual ~Field_enumerator() {}; /* Shut up compiler warning */
+  virtual void visit_field(Field *field)= 0;
+  virtual ~Field_enumerator() {}; /* purecov: inspected */
 };
 
+
 class sp_head;
 
 
@@ -1491,7 +1506,7 @@ public:
   bool find_item_in_field_list_processor(uchar *arg);
   bool register_field_in_read_map(uchar *arg);
   bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
-  bool check_column_usage_processor(uchar *arg);
+  bool enumerate_field_refs_processor(uchar *arg);
   void cleanup();
   bool result_as_longlong()
   {

sql/item_cmpfunc.cc

@@ -5168,33 +5168,7 @@ void Item_equal::merge(Item_equal *item)
 
 void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
 {
-  bool swap;
-  List_iterator<Item_field> it(fields);
-  do
-  {
-    Item_field *item1= it++;
-    Item_field **ref1= it.ref();
-    Item_field *item2;
-
-    swap= FALSE;
-    while ((item2= it++))
-    {
-      Item_field **ref2= it.ref();
-      if (cmp(item1, item2, arg) < 0)
-      {
-        Item_field *item= *ref1;
-        *ref1= *ref2;
-        *ref2= item;
-        swap= TRUE;
-      }
-      else
-      {
-        item1= item2;
-        ref1= ref2;
-      }
-    }
-    it.rewind();
-  } while (swap);
+  exchange_sort<Item_field>(&fields, cmp, arg);
 }
 
 

sql/item_subselect.cc

@@ -215,13 +215,13 @@ err:
 }
 
 
-bool Item_subselect::check_column_usage_processor(uchar *arg)
+bool Item_subselect::enumerate_field_refs_processor(uchar *arg)
 {
   List_iterator<Item> it(refers_to);
   Item *item;
   while ((item= it++))
   {
-    if (item->walk(&Item::check_column_usage_processor,FALSE, arg))
+    if (item->walk(&Item::enumerate_field_refs_processor, FALSE, arg))
       return TRUE;
   }
   return FALSE;

sql/item_subselect.h

@@ -135,7 +135,7 @@ public:
   enum_parsing_place place() { return parsing_place; }
   bool walk(Item_processor processor, bool walk_subquery, uchar *arg);
   bool mark_as_eliminated_processor(uchar *arg);
-  bool check_column_usage_processor(uchar *arg);
+  bool enumerate_field_refs_processor(uchar *arg);
 
   /**
     Get the SELECT_LEX structure associated with this Item.

sql/sql_list.h

@@ -442,6 +442,43 @@ public:
 };
 
 
+/*
+  Exchange sort algorithm for List<T>.
+*/
+template <class T> 
+inline void exchange_sort(List<T> *list_to_sort,
+                          int (*sort_func)(T *a, T *b, void *arg), void *arg)
+{
+  bool swap;
+  List_iterator<T> it(*list_to_sort);
+  do
+  {
+    T *item1= it++;
+    T **ref1= it.ref();
+    T *item2;
+
+    swap= FALSE;
+    while ((item2= it++))
+    {
+      T **ref2= it.ref();
+      if (sort_func(item1, item2, arg) < 0)
+      {
+        T *item= *ref1;
+        *ref1= *ref2;
+        *ref2= item;
+        swap= TRUE;
+      }
+      else
+      {
+        item1= item2;
+        ref1= ref2;
+      }
+    }
+    it.rewind();
+  } while (swap);
+}
+
+
 /*
   A simple intrusive list which automaticly removes element from list
   on delete (for THD element)

sql/sql_select.cc

@@ -2991,22 +2991,33 @@ typedef struct key_field_t {
   elements that would correspond to "$LEFT_PART OR $RIGHT_PART". 
   
   The rules for combining elements are as follows:
+
     (keyfieldA1 AND keyfieldA2 AND ...) OR (keyfieldB1 AND keyfieldB2 AND ...)=
-    AND_ij (keyfieldA_i OR keyfieldB_j)
+     
+     = AND_ij (keyfieldA_i OR keyfieldB_j)
   
   We discard all (keyfieldA_i OR keyfieldB_j) that refer to different
   fields. For those referring to the same field, the logic is as follows:
     
-  t.keycol=
+    t.keycol=expr1 OR t.keycol=expr2 -> (since expr1 and expr2 are different 
+                                         we can't produce a single equality,
+                                         so produce nothing)
+
+    t.keycol=expr1 OR t.keycol=expr1 -> t.keycol=expr1
+
+    t.keycol=expr1 OR t.keycol IS NULL -> t.keycol=expr1, and also set
+                                          KEY_OPTIMIZE_REF_OR_NULL flag
 
-  To be able to do 'ref_or_null' we merge a comparison of a column
-  and 'column IS NULL' to one test.  This is useful for sub select queries
-  that are internally transformed to something like:.
+  The last one is for ref_or_null access. We have handling for this special
+  because it's needed for evaluating IN subqueries that are internally
+  transformed into 
 
   @code
-  SELECT * FROM t1 WHERE t1.key=outer_ref_field or t1.key IS NULL 
+    EXISTS(SELECT * FROM t1 WHERE t1.key=outer_ref_field or t1.key IS NULL)
   @endcode
 
+  See add_key_fields() for discussion of what is and_level.
+
   KEY_FIELD::null_rejecting is processed as follows: @n
   result has null_rejecting=true if it is set for both ORed references.
   for example:
@@ -3346,6 +3357,26 @@ add_key_equal_fields(KEY_FIELD **key_fields, uint and_level,
   }
 }
 
+
+/*
+  In this and other functions, and_level is a number that is ever-growing
+  and is different for the contents of every AND or OR clause. For example,
+  when processing clause
+
+     (a AND b AND c) OR (x AND y)
+  
+  we'll have
+   * KEY_FIELD elements for (a AND b AND c) are assigned and_level=1
+   * KEY_FIELD elements for (x AND y) are assigned and_level=2
+   * OR operation is performed, and whatever elements are left after it are
+     assigned and_level=3.
+
+  The primary reason for having and_level attribute is the OR operation which 
+  uses and_level to mark KEY_FIELDs that should get into the result of the OR
+  operation
+
+*/
+
 static void
 add_key_fields(JOIN *join, KEY_FIELD **key_fields, uint *and_level,
                COND *cond, table_map usable_tables,