logging_ok:

  Logging to logging@openlogging.org accepted
sql_union.cc, sql_select.cc, opt_range.h, opt_range.cc, opt_ft.h:
  Post-merge fixes
Many files:
  new file


sql/opt_ft.h:
  Post-merge fixes
sql/opt_range.cc:
  Post-merge fixes
sql/opt_range.h:
  Post-merge fixes
sql/sql_select.cc:
  Post-merge fixes
sql/sql_union.cc:
  Post-merge fixes
BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted

BitKeeper/etc/logging_ok

@@ -119,6 +119,7 @@ serg@serg.mylan
 serg@serg.mysql.com
 serg@sergbook.mylan
 serg@sergbook.mysql.com
+sergefp@mysql.com
 sinisa@rhols221.adsl.netsonic.fi
 tfr@beta.frontier86.ee
 tfr@indrek.tfr.cafe.ee

mysql-test/r/index_merge_innodb.result

+drop table if exists t1;
+create table t1
+(
+key1 int not null, 
+key2 int not null, 
+INDEX i1(key1),
+INDEX i2(key2),
+) type=innodb;
+explain select * from t1 where key1 < 5 or key2 > 197;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	index_merge	i1,i2	i1,i2	4,4	NULL	8	Using where
+select * from t1 where key1 < 5 or key2 > 197;
+key1	key2
+0	200
+1	199
+2	198
+3	197
+4	196
+explain select * from t1 where key1 < 3 or key2 > 195;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	index_merge	i1,i2	i1,i2	4,4	NULL	8	Using where
+select * from t1 where key1 < 3 or key2 > 195;
+key1	key2
+0	200
+1	199
+2	198
+4	196
+3	197
+alter table t1 add str1 char (255) not null, 
+add zeroval int not null default 0,
+add str2 char (255) not null,
+add str3 char (255) not null;
+update t1 set str1='aaa', str2='bbb', str3=concat(key2, '-', key1 div 2, '_' ,if(key1 mod 2 = 0, 'a', 'A'));
+alter table t1 add primary key (str1, zeroval, str2, str3);
+explain select * from t1 where key1 < 5 or key2 > 197;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	index_merge	i1,i2	i1,i2	4,4	NULL	8	Using where
+select * from t1 where key1 < 5 or key2 > 197;
+key1	key2	str1	zeroval	str2	str3
+0	200	aaa	0	bbb	200-0_a
+1	199	aaa	0	bbb	199-0_A
+2	198	aaa	0	bbb	198-1_a
+3	197	aaa	0	bbb	197-1_A
+4	196	aaa	0	bbb	196-2_a
+explain select * from t1 where key1 < 3 or key2 > 195;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	index_merge	i1,i2	i1,i2	4,4	NULL	8	Using where
+select * from t1 where key1 < 3 or key2 > 195;
+key1	key2	str1	zeroval	str2	str3
+0	200	aaa	0	bbb	200-0_a
+1	199	aaa	0	bbb	199-0_A
+2	198	aaa	0	bbb	198-1_a
+4	196	aaa	0	bbb	196-2_a
+3	197	aaa	0	bbb	197-1_A
+drop table t1;

mysql-test/t/index_merge.test

+#
+# Index merge tests
+#
+
+--disable_warnings
+drop table if exists t0, t1, t2, t3;
+--enable_warnings
+
+# Create and fill a table with simple keys
+create table t0
+(
+  key1 int not null, 
+  INDEX i1(key1),
+);
+
+--disable_query_log
+insert into t0 values (1),(2),(3),(4),(5),(6),(7),(8);
+
+let $1=7;
+set @d=8;
+while ($1)
+{
+  eval insert into t0 select key1+@d from t0;
+  eval set @d=@d*2;
+  dec $1;
+}
+--enable_query_log
+
+alter table t0 add key2 int not null, add index i2(key2);
+alter table t0 add key3 int not null, add index i3(key3);
+alter table t0 add key4 int not null, add index i4(key4);
+alter table t0 add key5 int not null, add index i5(key5);
+alter table t0 add key6 int not null, add index i6(key6);
+alter table t0 add key7 int not null, add index i7(key7);
+alter table t0 add key8 int not null, add index i8(key8);
+
+update t0 set key2=key1,key3=key1,key4=key1,key5=key1,key6=key1,key7=key1,key8=1024-key1;
+analyze table t0;
+
+# 1. One index 
+explain select * from t0 where key1 < 3 or key1 > 1020;
+
+# 2. Simple cases
+explain 
+select * from t0 where key1 < 3 or key2 > 1020;
+select * from t0 where key1 < 3 or key2 > 1020;
+
+explain select * from t0 where key1 < 3 or key2 <4;
+
+explain
+select * from t0 where (key1 > 30 and key1<35) or (key2 >32 and key2 < 40);
+select * from t0 where (key1 > 30 and key1<35) or (key2 >32 and key2 < 40);
+
+# 3. Check that index_merge doesn't break "ignore/force/use index"
+explain select * from t0 ignore index (i2) where key1 < 3 or key2 <4;
+explain select * from t0 where (key1 < 3 or key2 <4) and key3 = 50;
+explain select * from t0 use index (i1,i2) where (key1 < 3 or key2 <4) and key3 = 50;
+
+explain select * from t0 where (key1 > 1 or key2  > 2);
+explain select * from t0 force index (i1,i2) where (key1 > 1 or key2  > 2);
+
+
+# 4. Check if conjuncts are grouped by keyuse
+explain 
+  select * from t0 where key1<3 or key2<3 or (key1>5 and key1<8) or 
+  (key1>10 and key1<12) or (key2>100 and key2<110);
+
+# 5. Check index_merge with conjuncts that are always true/false
+#    verify fallback to "range" if there is only one non-confluent condition
+explain select * from t0 where key2 = 45 or key1 <=> null;
+
+explain select * from t0 where key2 = 45 or key1 is not null;
+explain select * from t0 where key2 = 45 or key1 is null;
+
+#   the last conj. is always false and will be discarded
+explain select * from t0 where key2=10 or key3=3 or key4 <=> null;
+
+#   the last conj. is always true and will cause 'all' scan
+explain select * from t0 where key2=10 or key3=3 or key4 is null;
+
+#   some more complicated cases
+explain select key1 from t0 where (key1 <=> null) or (key2 < 5) or 
+                                   (key3=10) or (key4 <=> null);
+explain select key1 from t0 where (key1 <=> null) or (key1 < 5) or 
+                                   (key3=10) or (key4 <=> null);
+
+# 6.Several ways to do index_merge, (ignored) index_merge vs. range
+explain select * from t0 where 
+  (key1 < 3 or key2 < 3) and (key3 < 4 or key4 < 4) and (key5 < 5 or key6 < 5);
+
+explain
+select * from t0 where (key1 < 3 or key2 < 6) and (key1 < 7 or key3 < 4);
+
+select * from t0 where (key1 < 3 or key2 < 6) and (key1 < 7 or key3 < 4);
+
+
+explain select * from t0 where 
+  (key1 < 3 or key2 < 3) and (key3 < 4 or key4 < 4) and (key5 < 2 or key6 < 2);
+                                                                  
+#   now index_merge is not used at all when "range" is possible
+explain select * from t0 where 
+  (key1 < 3 or key2 < 3) and (key3 < 100);
+
+#   this even can cause "all" scan:
+explain select * from t0 where
+  (key1 < 3 or key2 < 3) and (key3 < 1000);
+  
+
+# 7. Complex cases
+#   tree_or(List<SEL_IMERGE>, range SEL_TREE).
+explain select * from t0 where 
+    ((key1 < 4 or key2 < 4) and (key2 <5 or key3 < 4)) 
+  or 
+    key2 > 5;
+
+explain select * from t0 where
+    ((key1 < 4 or key2 < 4) and (key2 <5 or key3 < 4))
+  or
+    key1 < 7;
+
+select * from t0 where
+    ((key1 < 4 or key2 < 4) and (key2 <5 or key3 < 4))
+  or
+    key1 < 7;
+        
+#   tree_or(List<SEL_IMERGE>, List<SEL_IMERGE>).   
+explain select * from t0 where 
+    ((key1 < 4 or key2 < 4) and (key3 <5 or key5 < 4)) 
+  or 
+    ((key5 < 5 or key6 < 6) and (key7 <7 or key8 < 4));
+
+explain select * from t0 where
+    ((key3 <5 or key5 < 4) and (key1 < 4 or key2 < 4))
+  or
+    ((key7 <7 or key8 < 4) and (key5 < 5 or key6 < 6));
+    
+explain select * from t0 where
+    ((key3 <5 or key5 < 4) and (key1 < 4 or key2 < 4))
+  or
+    ((key3 <7 or key5 < 2) and (key5 < 5 or key6 < 6));
+
+explain select * from t0 where
+    ((key3 <5 or key5 < 4) and (key1 < 4 or key2 < 4))
+  or
+    (((key3 <7 and key7 < 6) or key5 < 2) and (key5 < 5 or key6 < 6));
+
+explain select * from t0 where
+    ((key3 <5 or key5 < 4) and (key1 < 4 or key2 < 4))
+  or
+    ((key3 >=5 or key5 < 2) and (key5 < 5 or key6 < 6));
+
+explain select * from t0 force index(i1, i2, i3, i4, i5, i6 ) where
+    ((key3 <5 or key5 < 4) and (key1 < 4 or key2 < 4))
+  or
+    ((key3 >=5 or key5 < 2) and (key5 < 5 or key6 < 6));
+    
+# 8. Verify that "order by" after index merge uses filesort
+select * from t0 where key1 < 5 or key8 < 4 order by key1;
+
+explain
+select * from t0 where key1 < 5 or key8 < 4 order by key1;
+
+# 9. Check that index_merge cost is compared to 'index' where possible
+create table t2 like t0;
+insert into t2 select * from t0;
+
+alter table t2 add index i1_3(key1, key3);
+alter table t2 add index i2_3(key2, key3);
+alter table t2 drop index i1;
+alter table t2 drop index i2;
+alter table t2 add index i321(key3, key2, key1);
+
+#   index_merge vs 'index', index_merge is better.
+explain select key3 from t2 where key1 = 100 or key2 = 100;
+
+#   index_merge vs 'index', 'index' is better.
+explain select key3 from t2 where key1 <100 or key2 < 100;
+
+#   index_merge vs 'all', index_merge is better.
+explain select key7 from t2 where key1 <100 or key2 < 100;
+
+# 10. Multipart keys.
+create table t4 (
+  key1a int not null,
+  key1b int not null,
+  key2  int not null,
+  key2_1 int not null,
+  key2_2 int not null,
+  key3  int not null,
+  
+  index i1a (key1a, key1b),
+  index i1b (key1b, key1a),
+  
+  index i2_1(key2, key2_1),
+  index i2_2(key2, key2_1),  
+);
+
+insert into t4 select key1,key1,key1 div 10, key1 % 10, key1 % 10, key1 from t0;
+
+#   the following will be handled by index_merge:
+select * from t4 where key1a = 3 or key1b = 4; 
+explain select * from t4 where key1a = 3 or key1b = 4; 
+
+#   and the following will not
+explain select * from t4 where key2 = 1 and (key2_1 = 1 or key3 = 5);
+
+explain select * from t4 where key2 = 1 and (key2_1 = 1 or key2_2 = 5);
+
+explain select * from t4 where key2_1 = 1 or key2_2 = 5;
+
+
+# 11. Multitable selects
+create table t1 like t0;
+insert into t1 select * from t0;
+
+#  index_merge on first table in join
+explain select * from t0 left join t1 on (t0.key1=t1.key1) 
+  where t0.key1=3 or t0.key2=4; 
+
+select * from t0 left join t1 on (t0.key1=t1.key1)
+  where t0.key1=3 or t0.key2=4;
+
+explain 
+select * from t0,t1 where (t0.key1=t1.key1) and ( t0.key1=3 or t0.key2=4);
+
+#  index_merge vs. ref
+explain 
+select * from t0,t1 where (t0.key1=t1.key1) and 
+  (t0.key1=3 or t0.key2=4) and t1.key1<200;
+
+#  index_merge vs. ref
+explain 
+select * from t0,t1 where (t0.key1=t1.key1) and 
+  (t0.key1=3 or t0.key2<4) and t1.key1=2;
+
+#  index_merge on second table in join
+explain select * from t0,t1 where t0.key1 = 5 and 
+  (t1.key1 = t0.key1 or t1.key8 = t0.key1);
+
+#  index_merge inside union
+explain select * from t1 where key1=3 or key2=4 
+  union select * from t1 where key1<4 or key3=5;
+
+#  index merge in subselect
+explain select * from (select * from t1 where key1 = 3 or key2 =3) as Z where key8 >5;
+
+# 12. check for long index_merges.
+create table t3 like t0;
+insert into t3 select * from t0;
+alter table t3 add key9 int not null, add index i9(key9);
+alter table t3 add keyA int not null, add index iA(keyA);
+alter table t3 add keyB int not null, add index iB(keyB);
+alter table t3 add keyC int not null, add index iC(keyC);
+update t3 set key9=key1,keyA=key1,keyB=key1,keyC=key1;
+
+explain select * from t3 where 
+  key1=1 or key2=2 or key3=3 or key4=4 or
+  key5=5 or key6=6 or key7=7 or key8=8 or
+  key9=9 or keyA=10 or keyB=11 or keyC=12;
+ 
+select * from t3 where
+  key1=1 or key2=2 or key3=3 or key4=4 or
+  key5=5 or key6=6 or key7=7 or key8=8 or
+  key9=9 or keyA=10 or keyB=11 or keyC=12; 
+
+
+drop table t0, t1, t2, t3, t4; 

mysql-test/t/index_merge_innodb.test

+#
+# Index merge tests
+#
+-- source include/have_innodb.inc
+
+--disable_warnings
+drop table if exists t1;
+--enable_warnings
+
+create table t1
+(
+  key1 int not null, 
+  key2 int not null, 
+  
+  INDEX i1(key1),
+  INDEX i2(key2),
+) type=innodb;
+
+--disable_query_log
+let $1=200;
+while ($1)
+{
+  eval insert into t1 values (200-$1, $1);
+  dec $1;
+}
+--enable_query_log
+
+# No primary key
+explain select * from t1 where key1 < 5 or key2 > 197;
+
+select * from t1 where key1 < 5 or key2 > 197;
+
+explain select * from t1 where key1 < 3 or key2 > 195;
+select * from t1 where key1 < 3 or key2 > 195;
+
+# Primary key as case-sensitive string with \0s.
+# also make primary key be longer then max. index length of MyISAM.
+alter table t1 add str1 char (255) not null, 
+                add zeroval int not null default 0,
+                add str2 char (255) not null,
+                add str3 char (255) not null;
+
+update t1 set str1='aaa', str2='bbb', str3=concat(key2, '-', key1 div 2, '_' ,if(key1 mod 2 = 0, 'a', 'A'));
+
+alter table t1 add primary key (str1, zeroval, str2, str3);
+                
+explain select * from t1 where key1 < 5 or key2 > 197;
+
+select * from t1 where key1 < 5 or key2 > 197;
+
+explain select * from t1 where key1 < 3 or key2 > 195;
+select * from t1 where key1 < 3 or key2 > 195;
+
+drop table t1;

sql/opt_ft.h

@@ -30,6 +30,8 @@ class FT_SELECT: public QUICK_RANGE_SELECT {
 
   FT_SELECT(THD *thd, TABLE *table, TABLE_REF *tref) :
       QUICK_RANGE_SELECT (thd, table, tref->key, 1), ref(tref) { init(); }
+
+  int init() { return error=file->ft_init(); }
   int get_next() { return error=file->ft_read(record); }
   int get_type() { return QS_TYPE_FULLTEXT; }
 };

sql/opt_range.cc

@@ -609,12 +609,19 @@ SQL_SELECT::~SQL_SELECT()
 
 #undef index					// Fix for Unixware 7
 
-QUICK_SELECT::QUICK_SELECT(THD *thd, TABLE *table, uint key_nr, bool no_alloc)
-  :dont_free(0),error(0),index(key_nr),max_used_key_length(0),
-   used_key_parts(0), head(table), it(ranges),range(0)
+QUICK_SELECT_I::QUICK_SELECT_I()
+  :max_used_key_length(0),
+   used_key_parts(0)
+{}
+
+QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr, 
+                                       bool no_alloc, MEM_ROOT *parent_alloc)
+  :dont_free(0),error(0),it(ranges),range(0)
 {
-  //!!psergey: split this again to QUICK_SELECT_I
-  if (!no_alloc)
+  index= key_nr;
+  head=  table;
+
+  if (!no_alloc && !parent_alloc)
   {
     // Allocates everything through the internal memroot
     init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0);
@@ -860,7 +867,6 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
   uint idx;
   double scan_time;
   QUICK_INDEX_MERGE_SELECT *quick_imerge;
-  THD *thd= current_thd;
   DBUG_ENTER("test_quick_select");
   DBUG_PRINT("enter",("keys_to_use: %lu  prev_tables: %lu  const_tables: %lu",
 		      (ulong) keys_to_use, (ulong) prev_tables,
@@ -909,7 +915,6 @@ int SQL_SELECT::test_quick_select(THD *thd, key_map keys_to_use,
 
     thd->no_errors=1;				// Don't warn about NULL
     init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0);
-    //!!todo:remerge this.
     if (!(param.key_parts = (KEY_PART*) alloc_root(&alloc,
 						   sizeof(KEY_PART)*
 						   head->key_parts)))
@@ -1106,7 +1111,6 @@ imerge_fail:;
                 QUICK_RANGE_SELECT::QUICK_RANGE_SELECT leaves THR_MALLOC
                 pointing to its allocator, restore it back
               */
-              //my_pthread_setspecific_ptr(THR_MALLOC,old_root);
               quick_imerge->last_quick_select= new_quick;
 
               if (quick_imerge->push_quick_back(new_quick))
@@ -1141,12 +1145,14 @@ imerge_fail:;
             quick->reset();
           }
 
-	        needed_reg|= (key_map) 1 << keynr; /!!todo entire function is not merged properly
+          goto end;
+        }
       }
     }
 end_free:
     free_root(&alloc,MYF(0));			// Return memory & allocator
     my_pthread_setspecific_ptr(THR_MALLOC,old_root);
+end:
     thd->no_errors=0;
   }
 
@@ -1225,7 +1231,7 @@ static int get_quick_select_params(SEL_TREE *tree, PARAM& param,
 						param.range_count,
 						found_records)+
 			  (double) found_records / TIME_FOR_COMPARE);
-      if (*read_time > found_read_time)
+      if (*read_time > found_read_time && found_records != HA_POS_ERROR)
       {
         *read_time=   found_read_time;
         *records=     found_records;
@@ -2822,9 +2828,9 @@ get_quick_select(PARAM *param,uint idx,SEL_ARG *key_tree,
 {
   QUICK_RANGE_SELECT *quick;
   DBUG_ENTER("get_quick_select");
-  if ((quick=new QUICK_RANGE_SELECT(param->table,param->real_keynr[idx],
-                                    test(parent_alloc),
-                                    parent_alloc))) //!!todo: add thd to param
+  if ((quick=new QUICK_RANGE_SELECT(param->thd, param->table,
+                                    param->real_keynr[idx],test(parent_alloc),
+                                    parent_alloc)))
   {
     if (quick->error ||
 	get_quick_keys(param,quick,param->key[idx],key_tree,param->min_key,0,
@@ -2996,7 +3002,8 @@ static bool null_part_in_key(KEY_PART *key_part, const char *key, uint length)
 ** Create a QUICK RANGE based on a key
 ****************************************************************************/
 
-QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, TABLE_REF *ref) //!!todo: make use of thd
+QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, 
+                                             TABLE_REF *ref)
 {
   table->file->index_end();			// Remove old cursor
   QUICK_RANGE_SELECT *quick=new QUICK_RANGE_SELECT(thd, table, ref->key, 1);  
@@ -3006,7 +3013,7 @@ QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, TABLE_REF *
 
   if (!quick)
     return 0;			/* no ranges found */
-  if (quick->init())            /* !!todo: psergey: check if init is called exactly one time.*/
+  if (quick->init())
   {
     delete quick;
     return 0;

sql/opt_range.h

@@ -119,7 +119,7 @@ class QUICK_RANGE_SELECT : public QUICK_SELECT_I
 protected:
   friend void print_quick_sel_range(QUICK_RANGE_SELECT *quick,
                                     key_map needed_reg);
-  friend QUICK_RANGE_SELECT *get_quick_select_for_ref(TABLE *table, 
+  friend QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table, 
                                                       struct st_table_ref *ref);
   friend bool get_quick_keys(struct st_qsel_param *param,
                              QUICK_RANGE_SELECT *quick,KEY_PART *key,
@@ -134,11 +134,10 @@ class QUICK_RANGE_SELECT : public QUICK_SELECT_I
   List_iterator<QUICK_RANGE> it;
   QUICK_RANGE *range;
   MEM_ROOT alloc;
-  KEY_PART *key_parts;
-  QUICK_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc=0); //!!todo: add thd to my ctor below
+  KEY_PART *key_parts;  
   int cmp_next(QUICK_RANGE *range);
 public:
-  QUICK_RANGE_SELECT(TABLE *table,uint index_arg,bool no_alloc=0, 
+  QUICK_RANGE_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc=0,
                      MEM_ROOT *parent_alloc=NULL);
   ~QUICK_RANGE_SELECT();
   

sql/sql_select.cc

@@ -33,7 +33,7 @@
 const char *join_type_str[]={ "UNKNOWN","system","const","eq_ref","ref",
 			      "MAYBE_REF","ALL","range","index","fulltext",
 			      "ref_or_null","unique_subquery","index_subquery",
-                              "index_merge" //!!todo: psergey: check if constant values are same
+                              "index_merge"
 };
 
 static void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array);

sql/sql_union.cc

@@ -117,7 +117,6 @@ int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
 {
   SELECT_LEX *lex_select_save= thd->lex->current_select;
   SELECT_LEX *select_cursor,*sl;
-  SELECT_LEX *sl;
   DBUG_ENTER("st_select_lex_unit::prepare");  
 
   if (prepared)
@@ -188,7 +187,7 @@ int st_select_lex_unit::prepare(THD *thd, select_result *sel_result,
   union_result->not_describe=1;
   union_result->tmp_table_param=tmp_table_param;
 
-  for (;sl; sl= sl->next_select()) //!!todo: psergey: all my changes around this were to shut up the compiler. check they didn't make it here
+  for (;sl; sl= sl->next_select())
   {
     JOIN *join= new JOIN(thd, sl->item_list, 
 			 sl->options | thd->options | SELECT_NO_UNLOCK,