Merge mysqldev@production.mysql.com:/data0/mysqldev/my/build-200702202011-5.1.16-beta/mysql-5.1-release

into  poseidon.mysql.com:/home/tomas/mysql-5.1-new-ndb

8 files changed, 86 insertions, 4 deletions

diff --git a/include/my_base.h b/include/my_base.h
index 14e4e3afb44..26d513ba2a7 100644
--- a/include/my_base.h
+++ b/include/my_base.h
@@ -47,6 +47,7 @@
 #define HA_OPEN_ABORT_IF_CRASHED	16
 #define HA_OPEN_FOR_REPAIR		32	/* open even if crashed */
 #define HA_OPEN_FROM_SQL_LAYER          64
+#define HA_OPEN_MMAP                    128     /* open memory mapped */
 
 	/* The following is parameter to ha_rkey() how to use key */
 
diff --git a/mysql-test/r/keywords.result b/mysql-test/r/keywords.result
index 597983dab7e..e4c83b21138 100644
--- a/mysql-test/r/keywords.result
+++ b/mysql-test/r/keywords.result
@@ -16,6 +16,19 @@ select events.binlog from events;
 binlog
 1
 drop table events;
+create table t1 (connection int, b int);
+create procedure p1()
+begin
+declare connection int;
+select max(t1.connection) into connection from t1;
+select concat("max=",connection) 'p1';
+end|
+insert into t1 (connection) values (1);
+call p1();
+p1
+max=1
+drop procedure p1;
+drop table t1;
 create procedure p1()
 begin
 declare n int default 2;
diff --git a/mysql-test/t/keywords.test b/mysql-test/t/keywords.test
index 1af4a1354be..afc7fb55d51 100644
--- a/mysql-test/t/keywords.test
+++ b/mysql-test/t/keywords.test
@@ -20,6 +20,28 @@ drop table events;
 
 # End of 4.1 tests
 
+
+#
+# Bug#12204 - CONNECTION should not be a reserved word
+#
+
+create table t1 (connection int, b int);
+delimiter |;
+create procedure p1()
+begin
+  declare connection int;
+  select max(t1.connection) into connection from t1;
+  select concat("max=",connection) 'p1';
+end|
+delimiter ;|
+insert into t1 (connection) values (1);
+call p1();
+drop procedure p1;
+drop table t1;
+
+
+# End of 5.0 tests
+
 #
 # Bug#19939 "AUTHORS is not a keyword"
 #
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 424fd98c4fc..aa386dcf09c 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -9667,6 +9667,7 @@ keyword_sp:
 	| COMPLETION_SYM	{}
 	| COMPRESSED_SYM	{}
 	| CONCURRENT		{}
+	| CONNECTION_SYM	{}
 	| CONSISTENT_SYM	{}
 	| CONTRIBUTORS_SYM	{}
 	| CUBE_SYM		{}
diff --git a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc
index 764c53d2f75..06ec5c4b44e 100644
--- a/storage/myisam/ha_myisam.cc
+++ b/storage/myisam/ha_myisam.cc
@@ -598,15 +598,31 @@ bool ha_myisam::check_if_locking_is_allowed(uint sql_command,
 int ha_myisam::open(const char *name, int mode, uint test_if_locked)
 {
   uint i;
+
+  /*
+    If the user wants to have memory mapped data files, add an
+    open_flag. Do not memory map temporary tables because they are
+    expected to be inserted and thus extended a lot. Memory mapping is
+    efficient for files that keep their size, but very inefficient for
+    growing files. Using an open_flag instead of calling mi_extra(...
+    HA_EXTRA_MMAP ...) after mi_open() has the advantage that the
+    mapping is not repeated for every open, but just done on the initial
+    open, when the MyISAM share is created. Everytime the server
+    requires to open a new instance of a table it calls this method. We
+    will always supply HA_OPEN_MMAP for a permanent table. However, the
+    MyISAM storage engine will ignore this flag if this is a secondary
+    open of a table that is in use by other threads already (if the
+    MyISAM share exists already).
+  */
+  if (!(test_if_locked & HA_OPEN_TMP_TABLE) && opt_myisam_use_mmap)
+    test_if_locked|= HA_OPEN_MMAP;
+
   if (!(file=mi_open(name, mode, test_if_locked | HA_OPEN_FROM_SQL_LAYER)))
     return (my_errno ? my_errno : -1);
   
   if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))
     VOID(mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0));
 
-  if (!(test_if_locked & HA_OPEN_TMP_TABLE) && opt_myisam_use_mmap)
-    VOID(mi_extra(file, HA_EXTRA_MMAP, 0));
-
   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
   if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
     VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0));
diff --git a/storage/myisam/mi_dynrec.c b/storage/myisam/mi_dynrec.c
index 642efbd4389..5342619c79b 100644
--- a/storage/myisam/mi_dynrec.c
+++ b/storage/myisam/mi_dynrec.c
@@ -71,6 +71,14 @@ my_bool mi_dynmap_file(MI_INFO *info, my_off_t size)
     DBUG_PRINT("warning", ("File is too large for mmap"));
     DBUG_RETURN(1);
   }
+  /*
+    I wonder if it is good to use MAP_NORESERVE. From the Linux man page:
+    MAP_NORESERVE
+      Do not reserve swap space for this mapping. When swap space is
+      reserved, one has the guarantee that it is possible to modify the
+      mapping. When swap space is not reserved one might get SIGSEGV
+      upon a write if no physical memory is available.
+  */
   info->s->file_map= (byte*)
                   my_mmap(0, (size_t)(size + MEMMAP_EXTRA_MARGIN),
                           info->s->mode==O_RDONLY ? PROT_READ :
diff --git a/storage/myisam/mi_extra.c b/storage/myisam/mi_extra.c
index e1288fa6624..ae584b06173 100644
--- a/storage/myisam/mi_extra.c
+++ b/storage/myisam/mi_extra.c
@@ -349,7 +349,12 @@ int mi_extra(MI_INFO *info, enum ha_extra_function function, void *extra_arg)
   case HA_EXTRA_MMAP:
 #ifdef HAVE_MMAP
     pthread_mutex_lock(&share->intern_lock);
-    if (!share->file_map)
+    /*
+      Memory map the data file if it is not already mapped and if there
+      are no other threads using this table. intern_lock prevents other
+      threads from starting to use the table while we are mapping it.
+    */
+    if (!share->file_map && (share->tot_locks == 1))
     {
       if (mi_dynmap_file(info, share->state.state.data_file_length))
       {
diff --git a/storage/myisam/mi_open.c b/storage/myisam/mi_open.c
index 5e783bf7890..830332fe0c1 100644
--- a/storage/myisam/mi_open.c
+++ b/storage/myisam/mi_open.c
@@ -506,6 +506,22 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags)
       share->data_file_type = DYNAMIC_RECORD;
     my_afree((gptr) disk_cache);
     mi_setup_functions(share);
+    if (open_flags & HA_OPEN_MMAP)
+    {
+      info.s= share;
+      if (mi_dynmap_file(&info, share->state.state.data_file_length))
+      {
+        /* purecov: begin inspected */
+        /* Ignore if mmap fails. Use file I/O instead. */
+        DBUG_PRINT("warning", ("mmap failed: errno: %d", errno));
+        /* purecov: end */
+      }
+      else
+      {
+        share->file_read= mi_mmap_pread;
+        share->file_write= mi_mmap_pwrite;
+      }
+    }
     share->is_log_table= FALSE;
 #ifdef THREAD
     thr_lock_init(&share->lock);