Merge mskold@bk-internal.mysql.com:/home/bk/mysql-5.0

into  mysql.com:/windows/Linux_space/MySQL/mysql-5.0


sql/ha_ndbcluster.cc:
  Auto merged

mysql-test/r/ndb_condition_pushdown.result

@@ -1782,6 +1782,28 @@ select * from t5 where b like '%jo%' order by a;
 a	b
 1	jonas
 3	johan
+set engine_condition_pushdown = off;
+select auto from t1 where date_time like '1902-02-02 %' order by auto;
+auto
+2
+select auto from t1 where date_time not like '1902-02-02 %' order by auto;
+auto
+3
+4
+set engine_condition_pushdown = on;
+explain select auto from t1 where date_time like '1902-02-02 %';
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	3	Using where
+select auto from t1 where date_time like '1902-02-02 %' order by auto;
+auto
+2
+explain select auto from t1 where date_time not like '1902-02-02 %';
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	3	Using where
+select auto from t1 where date_time not like '1902-02-02 %' order by auto;
+auto
+3
+4
 drop table t1;
 create table t1 (a int, b varchar(3), primary key using hash(a))
 engine=ndb;

mysql-test/r/ndb_multi.result

@@ -69,3 +69,35 @@ t3
 t4
 drop table t1, t2, t3, t4;
 drop table t1, t3, t4;
+create table t1(c1 int key)ENGINE=MyISAM;
+insert into t1 values(1),(3),(5);
+select * from t1 order by c1;
+c1
+1
+3
+5
+create table t1(c1 int key)ENGINE=MyISAM;
+insert into t1 values(100),(344),(533);
+select * from t1 order by c1;
+c1
+100
+344
+533
+alter table t1 engine=ndb;
+show tables;
+Tables_in_test
+t1
+Warnings:
+Warning	1050	Local table test.t1 shadows ndb table
+select * from t1 order by c1;
+c1
+100
+344
+533
+drop table t1;
+select * from t1 order by c1;
+c1
+1
+3
+5
+drop table t1;

mysql-test/t/ndb_condition_pushdown.test

@@ -1649,6 +1649,16 @@ set engine_condition_pushdown = on;
 explain select * from t5 where b like '%jo%';
 select * from t5 where b like '%jo%' order by a;
 
+# bug#21056  	ndb pushdown equal/setValue error on datetime
+set engine_condition_pushdown = off;
+select auto from t1 where date_time like '1902-02-02 %' order by auto;
+select auto from t1 where date_time not like '1902-02-02 %' order by auto;
+set engine_condition_pushdown = on;
+explain select auto from t1 where date_time like '1902-02-02 %';
+select auto from t1 where date_time like '1902-02-02 %' order by auto;
+explain select auto from t1 where date_time not like '1902-02-02 %';
+select auto from t1 where date_time not like '1902-02-02 %' order by auto;
+
 # bug#17421 -1
 drop table t1;
 create table t1 (a int, b varchar(3), primary key using hash(a))

mysql-test/t/ndb_multi.test

@@ -69,4 +69,26 @@ drop table t1, t2, t3, t4;
 connection server2;
 drop table t1, t3, t4;
 
+# bug#21378
+connection server1;
+create table t1(c1 int key)ENGINE=MyISAM;
+insert into t1 values(1),(3),(5);
+select * from t1 order by c1;
+
+connection server2;
+create table t1(c1 int key)ENGINE=MyISAM;
+insert into t1 values(100),(344),(533);
+select * from t1 order by c1;
+
+connection server1;
+alter table t1 engine=ndb;
+
+connection server2;
+show tables;
+select * from t1 order by c1;
+drop table t1;
+
+connection server1;
+select * from t1 order by c1;
+drop table t1;
 # End of 4.1 tests

sql/ha_ndbcluster.cc

@@ -5072,16 +5072,15 @@ int ndbcluster_find_files(THD *thd,const char *db,const char *path,
   List<char> delete_list;
   while ((file_name=it++))
   {
+    bool file_on_disk= false;
     DBUG_PRINT("info", ("%s", file_name));     
     if (hash_search(&ndb_tables, file_name, strlen(file_name)))
     {
       DBUG_PRINT("info", ("%s existed in NDB _and_ on disk ", file_name));
-      // File existed in NDB and as frm file, put in ok_tables list
+      file_on_disk= true;
-      my_hash_insert(&ok_tables, (byte*)file_name);
-      continue;
     }
     
-    // File is not in NDB, check for .ndb file with this name
+    // Check for .ndb file with this name
     (void)strxnmov(name, FN_REFLEN, 
                    mysql_data_home,"/",db,"/",file_name,ha_ndb_ext,NullS);
     DBUG_PRINT("info", ("Check access for %s", name));
@@ -5089,9 +5088,25 @@ int ndbcluster_find_files(THD *thd,const char *db,const char *path,
     {
       DBUG_PRINT("info", ("%s did not exist on disk", name));     
       // .ndb file did not exist on disk, another table type
+      if (file_on_disk)
+      {
+	// Ignore this ndb table
+	gptr record=  hash_search(&ndb_tables, file_name, strlen(file_name));
+	DBUG_ASSERT(record);
+	hash_delete(&ndb_tables, record);
+	push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+			    ER_TABLE_EXISTS_ERROR,
+			    "Local table %s.%s shadows ndb table",
+			    db, file_name);
+      }
+      continue;
+    }
+    if (file_on_disk) 
+    {
+      // File existed in NDB and as frm file, put in ok_tables list
+      my_hash_insert(&ok_tables, (byte*)file_name);
       continue;
     }
-
     DBUG_PRINT("info", ("%s existed on disk", name));     
     // The .ndb file exists on disk, but it's not in list of tables in ndb
     // Verify that handler agrees table is gone.
@@ -6896,11 +6911,13 @@ void ndb_serialize_cond(const Item *item, void *arg)
             DBUG_PRINT("info", ("FIELD_ITEM"));
             DBUG_PRINT("info", ("table %s", tab->getName()));
             DBUG_PRINT("info", ("column %s", field->field_name));
+            DBUG_PRINT("info", ("type %d", field->type()));
             DBUG_PRINT("info", ("result type %d", field->result_type()));
             
             // Check that we are expecting a field and with the correct
             // result type
             if (context->expecting(Item::FIELD_ITEM) &&
+                context->expecting_field_type(field->type()) &&
                 (context->expecting_field_result(field->result_type()) ||
                  // Date and year can be written as string or int
                  ((type == MYSQL_TYPE_TIME ||
@@ -6923,7 +6940,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
               curr_cond->ndb_item= new Ndb_item(field, col->getColumnNo());
               context->dont_expect(Item::FIELD_ITEM);
               context->expect_no_field_result();
-              if (context->expect_mask)
+              if (! context->expecting_nothing())
               {
                 // We have not seen second argument yet
                 if (type == MYSQL_TYPE_TIME ||
@@ -7120,6 +7137,9 @@ void ndb_serialize_cond(const Item *item, void *arg)
                                               func_item);      
             context->expect(Item::STRING_ITEM);
             context->expect(Item::FIELD_ITEM);
+            context->expect_only_field_type(MYSQL_TYPE_STRING);
+            context->expect_field_type(MYSQL_TYPE_VAR_STRING);
+            context->expect_field_type(MYSQL_TYPE_VARCHAR);
             context->expect_field_result(STRING_RESULT);
             context->expect(Item::FUNC_ITEM);
             break;
@@ -7225,7 +7245,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
                 NDB_ITEM_QUALIFICATION q;
                 q.value_type= Item::STRING_ITEM;
                 curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item); 
-                if (context->expect_field_result_mask)
+                if (! context->expecting_no_field_result())
                 {
                   // We have not seen the field argument yet
                   context->expect_only(Item::FIELD_ITEM);
@@ -7255,7 +7275,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
                 NDB_ITEM_QUALIFICATION q;
                 q.value_type= Item::REAL_ITEM;
                 curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
-                if (context->expect_field_result_mask) 
+                if (! context->expecting_no_field_result()) 
                 {
                   // We have not seen the field argument yet
                   context->expect_only(Item::FIELD_ITEM);
@@ -7278,7 +7298,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
                 NDB_ITEM_QUALIFICATION q;
                 q.value_type= Item::INT_ITEM;
                 curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
-                if (context->expect_field_result_mask) 
+                if (! context->expecting_no_field_result()) 
                 {
                   // We have not seen the field argument yet
                   context->expect_only(Item::FIELD_ITEM);
@@ -7301,7 +7321,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
                 NDB_ITEM_QUALIFICATION q;
                 q.value_type= Item::DECIMAL_ITEM;
                 curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
-                if (context->expect_field_result_mask) 
+                if (! context->expecting_no_field_result()) 
                 {
                   // We have not seen the field argument yet
                   context->expect_only(Item::FIELD_ITEM);
@@ -7351,7 +7371,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::STRING_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);      
-            if (context->expect_field_result_mask)
+            if (! context->expecting_no_field_result())
             {
               // We have not seen the field argument yet
               context->expect_only(Item::FIELD_ITEM);
@@ -7384,7 +7404,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::INT_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
-            if (context->expect_field_result_mask) 
+            if (! context->expecting_no_field_result()) 
             {
               // We have not seen the field argument yet
               context->expect_only(Item::FIELD_ITEM);
@@ -7411,7 +7431,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::REAL_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
-            if (context->expect_field_result_mask) 
+            if (! context->expecting_no_field_result()) 
             {
               // We have not seen the field argument yet
               context->expect_only(Item::FIELD_ITEM);
@@ -7434,7 +7454,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::VARBIN_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);      
-            if (context->expect_field_result_mask)
+            if (! context->expecting_no_field_result())
             {
               // We have not seen the field argument yet
               context->expect_only(Item::FIELD_ITEM);
@@ -7459,7 +7479,7 @@ void ndb_serialize_cond(const Item *item, void *arg)
             NDB_ITEM_QUALIFICATION q;
             q.value_type= Item::DECIMAL_ITEM;
             curr_cond->ndb_item= new Ndb_item(NDB_VALUE, q, item);
-            if (context->expect_field_result_mask) 
+            if (! context->expecting_no_field_result()) 
             {
               // We have not seen the field argument yet
               context->expect_only(Item::FIELD_ITEM);

sql/ha_ndbcluster.h

@@ -362,53 +362,95 @@ class Ndb_cond_traverse_context
   Ndb_cond_traverse_context(TABLE *tab, void* ndb_tab, Ndb_cond_stack* stack)
     : table(tab), ndb_table(ndb_tab), 
     supported(TRUE), stack_ptr(stack), cond_ptr(NULL),
-    expect_mask(0), expect_field_result_mask(0), skip(0), collation(NULL),
+    skip(0), collation(NULL), rewrite_stack(NULL)
-    rewrite_stack(NULL)
   {
+    // Allocate type checking bitmaps   
+    bitmap_init(&expect_mask, 0, 512, FALSE);
+    bitmap_init(&expect_field_type_mask, 0, 512, FALSE);
+    bitmap_init(&expect_field_result_mask, 0, 512, FALSE);
+
     if (stack)
       cond_ptr= stack->ndb_cond;
   };
   ~Ndb_cond_traverse_context()
   {
+    bitmap_free(&expect_mask);
+    bitmap_free(&expect_field_type_mask);
+    bitmap_free(&expect_field_result_mask);
     if (rewrite_stack) delete rewrite_stack;
   }
   void expect(Item::Type type)
   {
-    expect_mask|= (1 << type);
+    bitmap_set_bit(&expect_mask, (uint) type);
+    if (type == Item::FIELD_ITEM) expect_all_field_types();
   };
   void dont_expect(Item::Type type)
   {
-    expect_mask&= ~(1 << type);
+    bitmap_clear_bit(&expect_mask, (uint) type);
   };
   bool expecting(Item::Type type)
   {
-    return (expect_mask & (1 << type));
+    return bitmap_is_set(&expect_mask, (uint) type);
   };
   void expect_nothing()
   {
-    expect_mask= 0;
+    bitmap_clear_all(&expect_mask);
   };
+  bool expecting_nothing()
+  {
+    return bitmap_is_clear_all(&expect_mask);
+  }
   void expect_only(Item::Type type)
   {
-    expect_mask= 0;
+    expect_nothing();
     expect(type);
   };
 
+  void expect_field_type(enum_field_types type)
+  {
+    bitmap_set_bit(&expect_field_type_mask, (uint) type);
+  };
+  void expect_all_field_types()
+  {
+    bitmap_set_all(&expect_field_type_mask);
+  };
+  bool expecting_field_type(enum_field_types type)
+  {
+    return bitmap_is_set(&expect_field_type_mask, (uint) type);
+  };
+  void expect_no_field_type()
+  {
+    bitmap_clear_all(&expect_field_type_mask);
+  };
+  bool expecting_no_field_type()
+  {
+    return bitmap_is_clear_all(&expect_field_type_mask);
+  }
+  void expect_only_field_type(enum_field_types result)
+  {
+    expect_no_field_type();
+    expect_field_type(result);
+  };
+
   void expect_field_result(Item_result result)
   {
-    expect_field_result_mask|= (1 << result);
+    bitmap_set_bit(&expect_field_result_mask, (uint) result);
   };
   bool expecting_field_result(Item_result result)
   {
-    return (expect_field_result_mask & (1 << result));
+    return bitmap_is_set(&expect_field_result_mask, (uint) result);
   };
   void expect_no_field_result()
   {
-    expect_field_result_mask= 0;
+    bitmap_clear_all(&expect_field_result_mask);
   };
+  bool expecting_no_field_result()
+  {
+    return bitmap_is_clear_all(&expect_field_result_mask);
+  }
   void expect_only_field_result(Item_result result)
   {
-    expect_field_result_mask= 0;
+    expect_no_field_result();
     expect_field_result(result);
   };
   void expect_collation(CHARSET_INFO* col)
@@ -428,8 +470,9 @@ class Ndb_cond_traverse_context
   bool supported;
   Ndb_cond_stack* stack_ptr;
   Ndb_cond* cond_ptr;
-  uint expect_mask;
+  MY_BITMAP expect_mask;
-  uint expect_field_result_mask;
+  MY_BITMAP expect_field_type_mask;
+  MY_BITMAP expect_field_result_mask;
   uint skip;
   CHARSET_INFO* collation;
   Ndb_rewrite_context *rewrite_stack;