Merge gbichot3.local:/home/mysql_src/mysql-5.1-clean

into  gbichot3.local:/home/mysql_src/mysql-maria


BitKeeper/etc/ignore:
  auto-union
BUILD/SETUP.sh:
  Auto merged
Makefile.am:
  Auto merged
configure.in:
  Auto merged
BitKeeper/triggers/post-commit:
  merge
include/Makefile.am:
  merge
include/my_global.h:
  merge
include/my_sys.h:
  merge
libmysql/Makefile.shared:
  merge
libmysqld/Makefile.am:
  merge
mysql-test/mysql-test-run.pl:
  merge
mysys/Makefile.am:
  merge
mysys/mf_keycache.c:
  merge
mysys/mf_keycaches.c:
  merge
mysys/my_handler.c:
  merge
mysys/my_init.c:
  merge
mysys/my_open.c:
  merge
mysys/my_pread.c:
  merge
sql/Makefile.am:
  merge
sql/handler.h:
  merge
sql/item_func.cc:
  merge
sql/item_func.h:
  merge
sql/log.cc:
  merge
sql/mysql_priv.h:
  merge
sql/mysqld.cc:
  merge
sql/set_var.cc:
  merge
sql/sql_class.h:
  merge
sql/sql_parse.cc:
  merge
sql/sql_select.cc:
  merge
sql/sql_test.cc:
  merge
sql/unireg.cc:
  merge
storage/csv/ha_tina.cc:
  merge
storage/myisam/ft_boolean_search.c:
  merge
storage/myisam/ha_myisam.cc:
  merge
storage/myisam/ha_myisam.h:
  merge
storage/myisam/mi_create.c:
  merge
storage/myisam/mi_delete.c:
  merge
storage/myisam/mi_dynrec.c:
  merge
storage/myisam/mi_key.c:
  merge
storage/myisam/mi_open.c:
  merge
storage/myisam/mi_test2.c:
  merge
storage/myisam/mi_unique.c:
  merge
storage/myisam/mi_write.c:
  merge
storage/myisam/myisamchk.c:
  merge
storage/myisam/myisampack.c:
  merge
storage/myisam/sort.c:
  merge
unittest/mytap/tap.c:
  merge

14 files changed, 148 insertions, 45 deletions

diff --git a/sql/handler.h b/sql/handler.h
index f27912f4d1e..17e98803209 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -21,6 +21,7 @@
 #pragma interface			/* gcc class implementation */
 #endif
 
+#include <my_handler.h>
 #include <ft_global.h>
 #include <keycache.h>
 
@@ -260,6 +261,7 @@ enum legacy_db_type
   DB_TYPE_TABLE_FUNCTION,
   DB_TYPE_MEMCACHE,
   DB_TYPE_FALCON,
+  DB_TYPE_MARIA,
   DB_TYPE_FIRST_DYNAMIC=42,
   DB_TYPE_DEFAULT=127 // Must be last
 };
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 0f5faf93cc3..3141af3a8b3 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -27,6 +27,7 @@
 #include <hash.h>
 #include <time.h>
 #include <ft_global.h>
+#include <my_bit.h>
 
 #include "sp_head.h"
 #include "sp_rcontext.h"
diff --git a/sql/item_func.h b/sql/item_func.h
index 9130ef0a0c4..4b0da6d5a58 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -1324,7 +1324,6 @@ public:
 
 
 /* for fulltext search */
-#include <ft_global.h>
 
 class Item_func_match :public Item_real_func
 {
diff --git a/sql/log.cc b/sql/log.cc
index 5a6130057ff..3a2a344e514 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -2388,6 +2388,11 @@ bool MYSQL_BIN_LOG::open_index_file(const char *index_file_name_arg,
                      my_seek(index_file_nr,0L,MY_SEEK_END,MYF(0)),
 			0, MYF(MY_WME | MY_WAIT_IF_FULL)))
   {
+    /*
+      TODO: all operations creating/deleting the index file or a log, should
+      call my_sync_dir() or my_sync_dir_by_file() to be durable.
+      TODO: file creation should be done with my_create() not my_open().
+    */
     if (index_file_nr >= 0)
       my_close(index_file_nr,MYF(0));
     return TRUE;
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 812268fc92c..82e71f59b2c 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1555,7 +1555,7 @@ extern ulong max_connections,max_connect_errors, connect_timeout;
 extern ulong slave_net_timeout, slave_trans_retries;
 extern uint max_user_connections;
 extern ulong what_to_log,flush_time;
-extern ulong query_buff_size, thread_stack;
+extern ulong query_buff_size;
 extern ulong max_prepared_stmt_count, prepared_stmt_count;
 extern ulong binlog_cache_size, max_binlog_cache_size, open_files_limit;
 extern ulong max_binlog_size, max_relay_log_size;
@@ -1656,7 +1656,7 @@ extern SHOW_COMP_OPTION have_innodb;
 extern SHOW_COMP_OPTION have_csv_db;
 extern SHOW_COMP_OPTION have_ndbcluster;
 extern SHOW_COMP_OPTION have_partition_db;
-
+extern SHOW_COMP_OPTION have_maria_db;
 extern handlerton *partition_hton;
 extern handlerton *myisam_hton;
 extern handlerton *heap_hton;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 96dfb3d01ec..8b54efb1199 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -17,6 +17,7 @@
 #include "mysql_priv.h"
 #include <m_ctype.h>
 #include <my_dir.h>
+#include <my_bit.h>
 #include "slave.h"
 #include "sql_repl.h"
 #include "rpl_filter.h"
@@ -27,6 +28,9 @@
 #include "events.h"
 
 #include "../storage/myisam/ha_myisam.h"
+#ifdef WITH_MARIA_STORAGE_ENGINE
+#include "../storage/maria/ha_maria.h"
+#endif
 
 #ifdef HAVE_ROW_BASED_REPLICATION
 #include "rpl_injector.h"
@@ -465,7 +469,7 @@ uint volatile thread_count, thread_running;
 ulonglong thd_startup_options;
 ulong back_log, connect_timeout, concurrency, server_id;
 ulong table_cache_size, table_def_size;
-ulong thread_stack, what_to_log;
+ulong what_to_log;
 ulong query_buff_size, slow_launch_time, slave_open_temp_tables;
 ulong open_files_limit, max_binlog_size, max_relay_log_size;
 ulong slave_net_timeout, slave_trans_retries;
@@ -526,6 +530,7 @@ char *mysqld_unix_port, *opt_mysql_tmpdir;
 const char **errmesg;			/* Error messages */
 const char *myisam_recover_options_str="OFF";
 const char *myisam_stats_method_str="nulls_unequal";
+const char *maria_stats_method_str="nulls_unequal";
 /* name of reference on left espression in rewritten IN subquery */
 const char *in_left_expr_name= "<left expr>";
 /* name of additional condition */
@@ -2129,7 +2134,7 @@ the thread stack. Please read http://www.mysql.com/doc/en/Linux.html\n\n",
   {
     fprintf(stderr,"thd: 0x%lx\n",(long) thd);
     print_stacktrace(thd ? (gptr) thd->thread_stack : (gptr) 0,
-		     thread_stack);
+		     my_thread_stack_size);
   }
   if (thd)
   {
@@ -2272,9 +2277,9 @@ static void start_signal_handler(void)
     Peculiar things with ia64 platforms - it seems we only have half the
     stack size in reality, so we have to double it here
   */
-  pthread_attr_setstacksize(&thr_attr,thread_stack*2);
+  pthread_attr_setstacksize(&thr_attr,my_thread_stack_size*2);
 #else
-  pthread_attr_setstacksize(&thr_attr,thread_stack);
+  pthread_attr_setstacksize(&thr_attr,my_thread_stack_size);
 #endif
 #endif
 
@@ -3527,9 +3532,9 @@ int main(int argc, char **argv)
     Peculiar things with ia64 platforms - it seems we only have half the
     stack size in reality, so we have to double it here
   */
-  pthread_attr_setstacksize(&connection_attrib,thread_stack*2);
+  pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size*2);
 #else
-  pthread_attr_setstacksize(&connection_attrib,thread_stack);
+  pthread_attr_setstacksize(&connection_attrib,my_thread_stack_size);
 #endif
 #ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
   {
@@ -3540,15 +3545,15 @@ int main(int argc, char **argv)
     stack_size/= 2;
 #endif
     /* We must check if stack_size = 0 as Solaris 2.9 can return 0 here */
-    if (stack_size && stack_size < thread_stack)
+    if (stack_size && stack_size < my_thread_stack_size)
     {
       if (global_system_variables.log_warnings)
 	sql_print_warning("Asked for %lu thread stack, but got %ld",
-			  thread_stack, (long) stack_size);
+			  my_thread_stack_size, (long) stack_size);
 #if defined(__ia64__) || defined(__ia64)
-      thread_stack= stack_size*2;
+      my_thread_stack_size= stack_size*2;
 #else
-      thread_stack= stack_size;
+      my_thread_stack_size= stack_size;
 #endif
     }
   }
@@ -4780,10 +4785,17 @@ enum options_mysqld
   OPT_MAX_LENGTH_FOR_SORT_DATA,
   OPT_MAX_WRITE_LOCK_COUNT, OPT_BULK_INSERT_BUFFER_SIZE,
   OPT_MAX_ERROR_COUNT, OPT_MULTI_RANGE_COUNT, OPT_MYISAM_DATA_POINTER_SIZE,
+
   OPT_MYISAM_BLOCK_SIZE, OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
   OPT_MYISAM_MAX_SORT_FILE_SIZE, OPT_MYISAM_SORT_BUFFER_SIZE,
-  OPT_MYISAM_USE_MMAP,
+  OPT_MYISAM_USE_MMAP, OPT_MYISAM_REPAIR_THREADS,
   OPT_MYISAM_STATS_METHOD,
+
+  OPT_MARIA_BLOCK_SIZE,
+  OPT_MARIA_MAX_SORT_FILE_SIZE, OPT_MARIA_SORT_BUFFER_SIZE,
+  OPT_MARIA_USE_MMAP, OPT_MARIA_REPAIR_THREADS,
+  OPT_MARIA_STATS_METHOD,
+
   OPT_NET_BUFFER_LENGTH, OPT_NET_RETRY_COUNT,
   OPT_NET_READ_TIMEOUT, OPT_NET_WRITE_TIMEOUT,
   OPT_OPEN_FILES_LIMIT,
@@ -4797,7 +4809,7 @@ enum options_mysqld
   OPT_SORT_BUFFER, OPT_TABLE_OPEN_CACHE, OPT_TABLE_DEF_CACHE,
   OPT_THREAD_CONCURRENCY, OPT_THREAD_CACHE_SIZE,
   OPT_TMP_TABLE_SIZE, OPT_THREAD_STACK,
-  OPT_WAIT_TIMEOUT, OPT_MYISAM_REPAIR_THREADS,
+  OPT_WAIT_TIMEOUT, 
   OPT_INNODB_MIRRORED_LOG_GROUPS,
   OPT_INNODB_LOG_FILES_IN_GROUP,
   OPT_INNODB_LOG_FILE_SIZE,
@@ -5924,6 +5936,49 @@ log and this option does nothing anymore.",
     0
 #endif
    , 0, 2, 0, 1, 0},
+#ifdef WITH_MARIA_STORAGE_ENGINE
+  {"maria_block_size", OPT_MARIA_BLOCK_SIZE,
+   "Block size to be used for MARIA index pages.",
+   (gptr*) &maria_block_size,
+   (gptr*) &maria_block_size, 0, GET_ULONG, REQUIRED_ARG,
+   MARIA_KEY_BLOCK_LENGTH, MARIA_MIN_KEY_BLOCK_LENGTH,
+   MARIA_MAX_KEY_BLOCK_LENGTH,
+   0, MARIA_MIN_KEY_BLOCK_LENGTH, 0},
+  {"maria_key_buffer_size", OPT_KEY_BUFFER_SIZE,
+   "The size of the buffer used for index blocks for Maria tables. Increase "
+   "this to get better index handling (for all reads and multiple writes) to "
+   "as much as you can afford; 64M on a 256M machine that mainly runs MySQL "
+   "is quite common.",
+   (gptr*) &maria_key_cache_var.param_buff_size, (gptr*) 0,
+   0, (GET_ULL | GET_ASK_ADDR),
+   REQUIRED_ARG, KEY_CACHE_SIZE, MALLOC_OVERHEAD, ~(ulong) 0, MALLOC_OVERHEAD,
+   IO_SIZE, 0},
+  {"maria_max_sort_file_size", OPT_MARIA_MAX_SORT_FILE_SIZE,
+   "Don't use the fast sort index method to created index if the temporary "
+   "file would get bigger than this.",
+   (gptr*) &global_system_variables.maria_max_sort_file_size,
+   (gptr*) &max_system_variables.maria_max_sort_file_size, 0,
+   GET_ULL, REQUIRED_ARG, (longlong) LONG_MAX, 0, (ulonglong) MAX_FILE_SIZE,
+   0, 1024*1024, 0},
+  {"maria_repair_threads", OPT_MARIA_REPAIR_THREADS,
+   "Number of threads to use when repairing maria tables. The value of 1 "
+   "disables parallel repair.",
+   (gptr*) &global_system_variables.maria_repair_threads,
+   (gptr*) &max_system_variables.maria_repair_threads, 0,
+   GET_ULONG, REQUIRED_ARG, 1, 1, ~0L, 0, 1, 0},
+  {"maria_sort_buffer_size", OPT_MARIA_SORT_BUFFER_SIZE,
+   "The buffer that is allocated when sorting the index when doing a REPAIR "
+   "or when creating indexes with CREATE INDEX or ALTER TABLE.",
+   (gptr*) &global_system_variables.maria_sort_buff_size,
+   (gptr*) &max_system_variables.maria_sort_buff_size, 0,
+   GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
+  {"maria_stats_method", OPT_MARIA_STATS_METHOD,
+   "Specifies how maria index statistics collection code should threat NULLs. "
+   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
+   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",
+   (gptr*) &maria_stats_method_str, (gptr*) &maria_stats_method_str, 0,
+    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+#endif
   {"max_allowed_packet", OPT_MAX_ALLOWED_PACKET,
    "Max packetlength to send/receive from to server.",
    (gptr*) &global_system_variables.max_allowed_packet,
@@ -6027,12 +6082,6 @@ The minimum value for this variable is 4096.",
    (gptr*) &myisam_data_pointer_size,
    (gptr*) &myisam_data_pointer_size, 0, GET_ULONG, REQUIRED_ARG,
    6, 2, 7, 0, 1, 0},
-  {"myisam_max_extra_sort_file_size", OPT_MYISAM_MAX_EXTRA_SORT_FILE_SIZE,
-   "Deprecated option",
-   (gptr*) &global_system_variables.myisam_max_extra_sort_file_size,
-   (gptr*) &max_system_variables.myisam_max_extra_sort_file_size,
-   0, GET_ULL, REQUIRED_ARG, (ulonglong) MI_MAX_TEMP_LENGTH,
-   0, (ulonglong) MAX_FILE_SIZE, 0, 1, 0},
   {"myisam_max_sort_file_size", OPT_MYISAM_MAX_SORT_FILE_SIZE,
    "Don't use the fast sort index method to created index if the temporary file would get bigger than this.",
    (gptr*) &global_system_variables.myisam_max_sort_file_size,
@@ -6239,8 +6288,8 @@ The minimum value for this variable is 4096.",
    (gptr*) &concurrency, (gptr*) &concurrency, 0, GET_ULONG, REQUIRED_ARG,
    DEFAULT_CONCURRENCY, 1, 512, 0, 1, 0},
   {"thread_stack", OPT_THREAD_STACK,
-   "The stack size for each thread.", (gptr*) &thread_stack,
-   (gptr*) &thread_stack, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
+   "The stack size for each thread.", (gptr*) &my_thread_stack_size,
+   (gptr*) &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
    1024L*128L, ~0L, 0, 1024, 0},
   { "time_format", OPT_TIME_FORMAT,
     "The TIME format (for future).",
@@ -6981,15 +7030,24 @@ static void mysql_init_variables(void)
   query_id= thread_id= 1L;
   strmov(server_version, MYSQL_SERVER_VERSION);
   myisam_recover_options_str= sql_mode_str= "OFF";
-  myisam_stats_method_str= "nulls_unequal";
+  myisam_stats_method_str= maria_stats_method_str= "nulls_unequal";
   my_bind_addr = htonl(INADDR_ANY);
   threads.empty();
   thread_cache.empty();
   key_caches.empty();
   if (!(dflt_key_cache= get_or_create_key_cache(default_key_cache_base.str,
-					       default_key_cache_base.length)))
+                                                default_key_cache_base.length)))
     exit(1);
-  multi_keycache_init(); /* set key_cache_hash.default_value = dflt_key_cache */
+#ifdef WITH_MARIA_STORAGE_ENGINE
+  if (!(maria_key_cache= get_or_create_key_cache(maria_key_cache_base.str,
+                                                 maria_key_cache_base.length)))
+    exit(1);
+  maria_key_cache->param_buff_size=      maria_key_cache_var.param_buff_size;
+  maria_key_cache->param_block_size=     maria_block_size;
+#endif
+
+ /* set key_cache_hash.default_value = dflt_key_cache */
+  multi_keycache_init();
 
   /* Set directory paths */
   strmake(language, LANGUAGE, sizeof(language)-1);
@@ -7048,6 +7106,11 @@ static void mysql_init_variables(void)
 #else
   have_csv_db= SHOW_OPTION_NO;
 #endif
+#ifdef WITH_MARIA_STORAGE_ENGINE
+  have_maria_db= SHOW_OPTION_YES;
+#else
+  have_maria_db= SHOW_OPTION_NO;
+#endif
 #ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
     have_ndbcluster= SHOW_OPTION_DISABLED;
 #else
@@ -7662,7 +7725,6 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
     int method;
     LINT_INIT(method_conv);
 
-    myisam_stats_method_str= argument;
     if ((method=find_type(argument, &myisam_stats_method_typelib, 2)) <= 0)
     {
       fprintf(stderr, "Invalid value of myisam_stats_method: %s.\n", argument);
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 2fe839189a0..c72fe6fd6fe 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -56,6 +56,9 @@
 #include <thr_alarm.h>
 #include <myisam.h>
 #include <my_dir.h>
+#ifdef WITH_MARIA_STORAGE_ENGINE
+#include <maria.h>
+#endif
 
 #include "events.h"
 
@@ -144,6 +147,7 @@ static void fix_max_join_size(THD *thd, enum_var_type type);
 static void fix_query_cache_size(THD *thd, enum_var_type type);
 static void fix_query_cache_min_res_unit(THD *thd, enum_var_type type);
 static void fix_myisam_max_sort_file_size(THD *thd, enum_var_type type);
+static void fix_maria_max_sort_file_size(THD *thd, enum_var_type type);
 static void fix_max_binlog_size(THD *thd, enum_var_type type);
 static void fix_max_relay_log_size(THD *thd, enum_var_type type);
 static void fix_max_connections(THD *thd, enum_var_type type);
@@ -346,6 +350,14 @@ sys_var_thd_enum        sys_myisam_stats_method("myisam_stats_method",
                                                 &myisam_stats_method_typelib,
                                                 NULL);
 
+sys_var_thd_ulonglong	sys_maria_max_sort_file_size("maria_max_sort_file_size", &SV::maria_max_sort_file_size, fix_maria_max_sort_file_size, 1);
+sys_var_thd_ulong       sys_maria_repair_threads("maria_repair_threads", &SV::maria_repair_threads);
+sys_var_thd_ulong	sys_maria_sort_buffer_size("maria_sort_buffer_size", &SV::maria_sort_buff_size);
+sys_var_thd_enum        sys_maria_stats_method("maria_stats_method",
+                                                &SV::maria_stats_method,
+                                                &myisam_stats_method_typelib,
+                                                NULL);
+
 sys_var_thd_ulong	sys_net_buffer_length("net_buffer_length",
 					      &SV::net_buffer_length);
 sys_var_thd_ulong	sys_net_read_timeout("net_read_timeout",
@@ -867,6 +879,15 @@ SHOW_VAR init_vars[]= {
   {sys_low_priority_updates.name, (char*) &sys_low_priority_updates, SHOW_SYS},
   {"lower_case_file_system",  (char*) &lower_case_file_system,      SHOW_MY_BOOL},
   {"lower_case_table_names",  (char*) &lower_case_table_names,      SHOW_INT},
+
+  {sys_maria_max_sort_file_size.name, (char*) &sys_maria_max_sort_file_size,
+   SHOW_SYS},
+  {sys_maria_repair_threads.name, (char*) &sys_maria_repair_threads,
+   SHOW_SYS},
+  {sys_maria_sort_buffer_size.name, (char*) &sys_maria_sort_buffer_size,
+   SHOW_SYS},
+  {sys_maria_stats_method.name, (char*) &sys_maria_stats_method, SHOW_SYS},
+
   {sys_max_allowed_packet.name,(char*) &sys_max_allowed_packet,	    SHOW_SYS},
   {sys_max_binlog_cache_size.name,(char*) &sys_max_binlog_cache_size, SHOW_SYS},
   {sys_max_binlog_size.name,    (char*) &sys_max_binlog_size,	    SHOW_SYS},
@@ -1011,10 +1032,10 @@ SHOW_VAR init_vars[]= {
 #ifdef HAVE_THR_SETCONCURRENCY
   {"thread_concurrency",      (char*) &concurrency,                 SHOW_LONG},
 #endif
-  {"thread_stack",            (char*) &thread_stack,                SHOW_LONG},
+  {"thread_stack",            (char*) &my_thread_stack_size,        SHOW_LONG},
   {sys_time_format.name,      (char*) &sys_time_format,		    SHOW_SYS},
   {"time_zone",               (char*) &sys_time_zone,               SHOW_SYS},
-  {sys_timed_mutexes.name,    (char*) &sys_timed_mutexes,       SHOW_SYS},
+  {sys_timed_mutexes.name,    (char*) &sys_timed_mutexes,           SHOW_SYS},
   {sys_tmp_table_size.name,   (char*) &sys_tmp_table_size,	    SHOW_SYS},
   {sys_tmpdir.name,           (char*) &sys_tmpdir,	            SHOW_SYS},
   {sys_trans_alloc_block_size.name, (char*) &sys_trans_alloc_block_size,
@@ -1157,6 +1178,16 @@ fix_myisam_max_sort_file_size(THD *thd, enum_var_type type)
     (my_off_t) global_system_variables.myisam_max_sort_file_size;
 }
 
+static void
+fix_maria_max_sort_file_size(THD *thd, enum_var_type type)
+{
+#ifdef WITH_MARIA_STORAGE_ENGINE
+  maria_max_temp_length=
+    (my_off_t) global_system_variables.myisam_max_sort_file_size;
+#endif
+}
+
+
 /*
   Set the OPTION_BIG_SELECTS flag if max_join_size == HA_POS_ERROR
 */
@@ -2363,6 +2394,7 @@ void sys_var_collation_server::set_default(THD *thd, enum_var_type type)
 
 
 LEX_STRING default_key_cache_base= {(char *) "default", 7 };
+LEX_STRING maria_key_cache_base= {(char *) "maria", 5 };
 
 static KEY_CACHE zero_key_cache;
 
@@ -2372,7 +2404,7 @@ KEY_CACHE *get_key_cache(LEX_STRING *cache_name)
   if (!cache_name || ! cache_name->length)
     cache_name= &default_key_cache_base;
   return ((KEY_CACHE*) find_named(&key_caches,
-                                      cache_name->str, cache_name->length, 0));
+                                  cache_name->str, cache_name->length, 0));
 }
 
 
diff --git a/sql/set_var.h b/sql/set_var.h
index 01669b378e1..17f9b248c07 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -1105,6 +1105,7 @@ public:
 extern sys_var_thd_bool sys_old_alter_table;
 extern sys_var_thd_bool sys_old_passwords;
 extern LEX_STRING default_key_cache_base;
+extern LEX_STRING maria_key_cache_base;
 
 /* For sql_yacc */
 struct sys_var_with_base
diff --git a/sql/sql_class.h b/sql/sql_class.h
index de4a394d53c..4087281f1e9 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -181,7 +181,7 @@ class Time_zone;
 
 struct system_variables
 {
-  ulonglong myisam_max_extra_sort_file_size;
+  ulonglong maria_max_sort_file_size;
   ulonglong myisam_max_sort_file_size;
   ulonglong max_heap_table_size;
   ulonglong tmp_table_size;
@@ -197,6 +197,9 @@ struct system_variables
   ulong max_sort_length;
   ulong max_tmp_tables;
   ulong max_insert_delayed_threads;
+  ulong maria_repair_threads;
+  ulong maria_sort_buff_size;
+  ulong maria_stats_method;
   ulong multi_range_count;
   ulong myisam_repair_threads;
   ulong myisam_sort_buff_size;
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 1c46c3189d9..9a93a9cf2e7 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -5786,10 +5786,10 @@ bool check_stack_overrun(THD *thd, long margin,
   long stack_used;
   DBUG_ASSERT(thd == current_thd);
   if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
-      (long) (thread_stack - margin))
+      (long) (my_thread_stack_size - margin))
   {
     sprintf(errbuff[0],ER(ER_STACK_OVERRUN_NEED_MORE),
-            stack_used,thread_stack,margin);
+            stack_used,my_thread_stack_size,margin);
     my_message(ER_STACK_OVERRUN_NEED_MORE,errbuff[0],MYF(0));
     thd->fatal_error();
     return 1;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 9a64055f2e3..c83872293df 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -26,6 +26,7 @@
 #include "sql_cursor.h"
 
 #include <m_ctype.h>
+#include <my_bit.h>
 #include <hash.h>
 #include <ft_global.h>
 
diff --git a/sql/sql_sort.h b/sql/sql_sort.h
index 1831c4a2f3d..e39ea1aaf38 100644
--- a/sql/sql_sort.h
+++ b/sql/sql_sort.h
@@ -35,7 +35,9 @@
    the callback function 'unpack_addon_fields'.
 */
 
-typedef struct st_sort_addon_field {  /* Sort addon packed field */
+typedef struct st_sort_addon_field
+{
+  /* Sort addon packed field */
   Field *field;          /* Original field */
   uint   offset;         /* Offset from the last sorted field */
   uint   null_offset;    /* Offset to to null bit from the last sorted field */
@@ -43,13 +45,6 @@ typedef struct st_sort_addon_field {  /* Sort addon packed field */
   uint8  null_bit;       /* Null bit mask for the field */
 } SORT_ADDON_FIELD;
 
-typedef struct st_buffpek {		/* Struktur om sorteringsbuffrarna */
-  my_off_t file_pos;			/* Where we are in the sort file */
-  uchar *base,*key;			/* key pointers */
-  ha_rows count;			/* Number of rows in table */
-  ulong mem_count;			/* numbers of keys in memory */
-  ulong max_keys;			/* Max keys in buffert */
-} BUFFPEK;
 
 typedef struct st_sort_param {
   uint rec_length;          /* Length of sorted records */
diff --git a/sql/sql_test.cc b/sql/sql_test.cc
index 219ca8260ed..d2d65d662ea 100644
--- a/sql/sql_test.cc
+++ b/sql/sql_test.cc
@@ -458,7 +458,7 @@ void mysql_print_status()
   VOID(my_getwd(current_dir, sizeof(current_dir),MYF(0)));
   printf("Current dir: %s\n", current_dir);
   printf("Running threads: %d  Stack size: %ld\n", thread_count,
-	 (long) thread_stack);
+	 (long) my_thread_stack_size);
   thr_print_locks();				// Write some debug info
 #ifndef DBUG_OFF
   print_cached_tables();
@@ -533,7 +533,7 @@ Estimated memory (with thread stack):    %ld\n",
 	 (int) info.uordblks,
 	 (int) info.fordblks,
 	 (int) info.keepcost,
-	 (long) (thread_count * thread_stack + info.hblkhd + info.arena));
+	 (long) (thread_count * my_thread_stack_size + info.hblkhd + info.arena));
 #endif
 
   Events::get_instance()->dump_internal_status();
diff --git a/sql/unireg.cc b/sql/unireg.cc
index 4514f969913..a080de489e9 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -286,8 +286,10 @@ bool mysql_create_frm(THD *thd, const char *file_name,
   my_free((gptr) keybuff, MYF(0));
 
   if (opt_sync_frm && !(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
-      my_sync(file, MYF(MY_WME)))
-    goto err2;
+      (my_sync(file, MYF(MY_WME)) ||
+       my_sync_dir_by_file(file_name, MYF(MY_WME))))
+      goto err2;
+
   if (my_close(file,MYF(MY_WME)))
     goto err3;