Merge

sql/field.cc:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_class.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_lex.h:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/handler.cc:
  SCCS merged

16 files changed, 191 insertions, 196 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 4ef80a99695..cfda1ab29fc 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -3230,13 +3230,13 @@ int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
   long store_tmp;
   int error;
   char *end;
-  
+
   tmp_scan= cs->cset->scan(cs, from, from+len, MY_SEQ_SPACES);
   len-= tmp_scan;
   from+= tmp_scan;
 
   end= (char*) from+len;
-  tmp= cs->cset->my_strtoll10(cs, from, &end, &error);
+  tmp= cs->cset->strtoll10(cs, from, &end, &error);
 
   if (error != MY_ERRNO_EDOM)
   {
diff --git a/sql/handler.cc b/sql/handler.cc
index 330ea83566c..3eead37482b 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -25,10 +25,6 @@
 #include "ha_heap.h"
 #include "ha_myisam.h"
 #include "ha_myisammrg.h"
-#ifdef HAVE_ISAM
-#include "ha_isam.h"
-#include "ha_isammrg.h"
-#endif
 #ifdef HAVE_BERKELEY_DB
 #include "ha_berkeley.h"
 #endif
@@ -750,17 +746,15 @@ int ha_autocommit_or_rollback(THD *thd, int error)
   DBUG_RETURN(error);
 }
 
-int ha_commit_or_rollback_by_xid(LEX_STRING *ident, bool commit)
+int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
 {
-  XID xid;
   handlerton **ht= handlertons, **end_ht=ht+total_ha;
   int res= 1;
 
-  xid.set(ident);
   for ( ; ht < end_ht ; ht++)
     if ((*ht)->recover)
       res= res &&
-        (*(commit ? (*ht)->commit_by_xid : (*ht)->rollback_by_xid))(&xid);
+        (*(commit ? (*ht)->commit_by_xid : (*ht)->rollback_by_xid))(xid);
   return res;
 }
 
@@ -2366,10 +2360,9 @@ TYPELIB *ha_known_exts(void)
     const char **ext, *old_ext;
 
     known_extensions_id= mysys_usage_id;
-    found_exts.push_back((char*) ".db");
     found_exts.push_back((char*) triggers_file_ext);
     for (types= sys_table_types; types->type; types++)
-    {      
+    {
       if (*types->value == SHOW_OPTION_YES)
       {
 	handler *file= get_new_handler(0,(enum db_type) types->db_type);
diff --git a/sql/handler.h b/sql/handler.h
index e5b63c7f25c..3751af29194 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -213,13 +213,22 @@ struct xid_t {
   long bqual_length;
   char data[XIDDATASIZE];  // not \0-terminated !
 
-  bool eq(LEX_STRING *l) { return eq(l->length, 0, l->str); }
+  bool eq(struct xid_t *xid)
+  { return !memcmp(this, xid, sizeof(long)*3+gtrid_length+bqual_length); }
   bool eq(long g, long b, const char *d)
   { return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); }
-  void set(LEX_STRING *l) { set(l->length, 0, l->str); }
+  void set(struct xid_t *xid)
+  { memcpy(this, xid, sizeof(long)*3+xid->gtrid_length+xid->bqual_length); }
+  void set(long f, const char *g, long gl, const char *b, long bl)
+  {
+    formatID= f;
+    memcpy(data, g, gtrid_length= gl);
+    memcpy(data+gl, b, bqual_length= bl);
+  }
   void set(ulonglong xid)
   {
     my_xid tmp;
+    formatID= 1;
     set(MYSQL_XID_PREFIX_LEN, 0, MYSQL_XID_PREFIX);
     memcpy(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id));
     tmp= xid;
@@ -228,7 +237,7 @@ struct xid_t {
   }
   void set(long g, long b, const char *d)
   {
-    formatID=1;
+    formatID= 1;
     gtrid_length= g;
     bqual_length= b;
     memcpy(data, d, g+b);
@@ -244,7 +253,7 @@ struct xid_t {
   my_xid get_my_xid()
   {
     return gtrid_length == MYSQL_XID_GTRID_LEN && bqual_length == 0 &&
-           *(ulong*)(data+MYSQL_XID_PREFIX_LEN) == server_id &&
+           !memcmp(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id)) &&
            !memcmp(data, MYSQL_XID_PREFIX, MYSQL_XID_PREFIX_LEN) ?
            quick_get_my_xid() : 0;
   }
@@ -261,8 +270,8 @@ typedef struct xid_t XID;
 
 /*
   handlerton is a singleton structure - one instance per storage engine -
-  to provide access to storage engine functionality that works on
-  "global" level (unlike handler class that works on per-table basis)
+  to provide access to storage engine functionality that works on the
+  "global" level (unlike handler class that works on a per-table basis)
 
   usually handlerton instance is defined statically in ha_xxx.cc as
 
@@ -826,7 +835,7 @@ int ha_release_temporary_latches(THD *thd);
 
 /* transactions: interface to handlerton functions */
 int ha_start_consistent_snapshot(THD *thd);
-int ha_commit_or_rollback_by_xid(LEX_STRING *ident, bool commit);
+int ha_commit_or_rollback_by_xid(XID *xid, bool commit);
 int ha_commit_one_phase(THD *thd, bool all);
 int ha_rollback_trans(THD *thd, bool all);
 int ha_prepare(THD *thd);
diff --git a/sql/item_sum.h b/sql/item_sum.h
index d03ef94b9cd..8c8360b0726 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -734,7 +734,7 @@ public:
       return 0;                                 /* Null value */
     cs= res->charset();
     end= (char*) res->ptr()+res->length();
-    return cs->cset->my_strtoll10(cs, res->ptr(), &end, &err_not_used);
+    return cs->cset->strtoll10(cs, res->ptr(), &end, &err_not_used);
   }
   my_decimal *val_decimal(my_decimal *dec);
   enum Item_result result_type () const { return STRING_RESULT; }
diff --git a/sql/lock.cc b/sql/lock.cc
index 266e8dc4d4d..a8ccba32d4f 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -736,6 +736,13 @@ static void print_lock_error(int error, const char *table)
   protect_against_global_read_lock
     count of threads which have set protection against global read lock.
 
+  access to them is protected with a mutex LOCK_global_read_lock
+
+  (XXX: one should never take LOCK_open if LOCK_global_read_lock is taken,
+  otherwise a deadlock may occur - see mysql_rm_table. Other mutexes could
+  be a problem too - grep the code for global_read_lock if you want to use
+  any other mutex here)
+
   How blocking of threads by global read lock is achieved: that's
   advisory. Any piece of code which should be blocked by global read lock must
   be designed like this:
@@ -773,7 +780,7 @@ static void print_lock_error(int error, const char *table)
   table instance of thd2
   thd1: COMMIT; # blocked by thd3.
   thd1 blocks thd2 which blocks thd3 which blocks thd1: deadlock.
-  
+
   Note that we need to support that one thread does
   FLUSH TABLES WITH READ LOCK; and then COMMIT;
   (that's what innobackup does, for some good reason).
@@ -818,7 +825,7 @@ bool lock_global_read_lock(THD *thd)
     }
     thd->global_read_lock= GOT_GLOBAL_READ_LOCK;
     global_read_lock++;
-    thd->exit_cond(old_message);
+    thd->exit_cond(old_message); // this unlocks LOCK_global_read_lock
   }
   /*
     We DON'T set global_read_lock_blocks_commit now, it will be set after
@@ -887,8 +894,8 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,
     The following is only true in case of a global read locks (which is rare)
     and if old_message is set
   */
-  if (unlikely(need_exit_cond)) 
-    thd->exit_cond(old_message);
+  if (unlikely(need_exit_cond))
+    thd->exit_cond(old_message); // this unlocks LOCK_global_read_lock
   else
     pthread_mutex_unlock(&LOCK_global_read_lock);
   DBUG_RETURN(result);
@@ -938,7 +945,7 @@ bool make_global_read_lock_block_commit(THD *thd)
     global_read_lock_blocks_commit--; // undo what we did
   else
     thd->global_read_lock= MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT;
-  thd->exit_cond(old_message);
+  thd->exit_cond(old_message); // this unlocks LOCK_global_read_lock
   DBUG_RETURN(error);
 }
 
diff --git a/sql/log.cc b/sql/log.cc
index 9af70a4d527..1d6bb4cdf41 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -1531,18 +1531,20 @@ bool MYSQL_LOG::write(THD *thd,enum enum_server_command command,
   return 0;
 }
 
-
-inline bool sync_binlog(IO_CACHE *cache)
+bool MYSQL_LOG::flush_and_sync()
 {
-  if (sync_binlog_period == ++sync_binlog_counter && sync_binlog_period)
+  int err=0, fd=log_file.file;
+  safe_mutex_assert_owner(&LOCK_log);
+  if (flush_io_cache(&log_file))
+    return 1;
+  if (++sync_binlog_counter >= sync_binlog_period && sync_binlog_period)
   {
     sync_binlog_counter= 0;
-    return my_sync(cache->file, MYF(MY_WME));
+    err=my_sync(fd, MYF(MY_WME));
   }
-  return 0;
+  return err;
 }
 
-
 /*
   Write an event to the binary log
 */
@@ -1675,8 +1677,8 @@ bool MYSQL_LOG::write(Log_event *event_info)
       }
     }
 
-    /* 
-       Write the SQL command 
+    /*
+       Write the SQL command
      */
 
     if (event_info->write(file))
@@ -1684,8 +1686,10 @@ bool MYSQL_LOG::write(Log_event *event_info)
 
     if (file == &log_file) // we are writing to the real log (disk)
     {
-      if (flush_io_cache(file) || sync_binlog(file))
+      if (flush_and_sync())
 	goto err;
+      signal_update();
+      rotate_and_purge(RP_LOCK_LOG_IS_ALREADY_LOCKED);
     }
     error=0;
 
@@ -1698,15 +1702,9 @@ err:
 	my_error(ER_ERROR_ON_WRITE, MYF(0), name, errno);
       write_error=1;
     }
-    if (file == &log_file)
-    {
-      signal_update();
-      rotate_and_purge(RP_LOCK_LOG_IS_ALREADY_LOCKED);
-    }
   }
 
   pthread_mutex_unlock(&LOCK_log);
-
   DBUG_RETURN(error);
 }
 
@@ -1813,7 +1811,7 @@ bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event)
     if (commit_event->write(&log_file))
       goto err;
 DBUG_skip_commit:
-    if (flush_io_cache(&log_file) || sync_binlog(&log_file))
+    if (flush_and_sync())
       goto err;
     DBUG_EXECUTE_IF("half_binlogged_transaction", abort(););
     if (cache->error)				// Error on read
@@ -1983,26 +1981,26 @@ bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
   SYNOPSIS
     wait_for_update()
     thd			Thread variable
-    master_or_slave     If 0, the caller is the Binlog_dump thread from master;
+    is_slave            If 0, the caller is the Binlog_dump thread from master;
                         if 1, the caller is the SQL thread from the slave. This
                         influences only thd->proc_info.
 
   NOTES
     One must have a lock on LOCK_log before calling this function.
-    This lock will be freed before return! That's required by
+    This lock will be released before return! That's required by
     THD::enter_cond() (see NOTES in sql_class.h).
 */
 
-void MYSQL_LOG::wait_for_update(THD* thd, bool master_or_slave)
+void MYSQL_LOG::wait_for_update(THD* thd, bool is_slave)
 {
   const char *old_msg;
   DBUG_ENTER("wait_for_update");
   old_msg= thd->enter_cond(&update_cond, &LOCK_log,
-                           master_or_slave ?
+                           is_slave ?
                            "Has read all relay log; waiting for the slave I/O "
-                           "thread to update it" : 
+                           "thread to update it" :
                            "Has sent all binlog to slave; waiting for binlog "
-                           "to be updated"); 
+                           "to be updated");
   pthread_cond_wait(&update_cond, &LOCK_log);
   thd->exit_cond(old_msg);
   DBUG_VOID_RETURN;
@@ -2051,7 +2049,12 @@ void MYSQL_LOG::close(uint exiting)
       my_pwrite(log_file.file, &flags, 1, offset, MYF(0));
     }
 
-    if (my_close(log_file.file,MYF(0)) < 0 && ! write_error)
+    if (my_sync(log_file.file,MYF(MY_WME)) && ! write_error)
+    {
+      write_error=1;
+      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
+    }
+    if (my_close(log_file.file,MYF(MY_WME)) && ! write_error)
     {
       write_error=1;
       sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
@@ -2945,8 +2948,10 @@ int TC_LOG_BINLOG::log(THD *thd, my_xid xid)
 
 void TC_LOG_BINLOG::unlog(ulong cookie, my_xid xid)
 {
-  if (thread_safe_dec_and_test(prepared_xids, &LOCK_prep_xids))
+  pthread_mutex_lock(&LOCK_prep_xids);
+  if (--prepared_xids == 0)
     pthread_cond_signal(&COND_prep_xids);
+  pthread_mutex_unlock(&LOCK_prep_xids);
   rotate_and_purge(0);     // as ::write() did not rotate
 }
 
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 7290cfd8e0d..1b1da6772af 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1114,10 +1114,6 @@ extern MY_BITMAP temp_pool;
 extern String my_empty_string;
 extern const String my_null_string;
 extern SHOW_VAR init_vars[],status_vars[], internal_vars[];
-extern SHOW_COMP_OPTION have_isam;
-extern SHOW_COMP_OPTION have_innodb;
-extern SHOW_COMP_OPTION have_berkeley_db;
-extern SHOW_COMP_OPTION have_ndbcluster;
 extern struct system_variables global_system_variables;
 extern struct system_variables max_system_variables;
 extern struct system_status_var global_status_var;
@@ -1138,12 +1134,13 @@ extern struct my_option my_long_options[];
 extern SHOW_COMP_OPTION have_isam, have_innodb, have_berkeley_db;
 extern SHOW_COMP_OPTION have_example_db, have_archive_db, have_csv_db;
 extern SHOW_COMP_OPTION have_federated_db;
+extern SHOW_COMP_OPTION have_blackhole_db;
+extern SHOW_COMP_OPTION have_ndbcluster;
 extern SHOW_COMP_OPTION have_raid, have_openssl, have_symlink;
-extern SHOW_COMP_OPTION have_query_cache, have_berkeley_db, have_innodb;
+extern SHOW_COMP_OPTION have_query_cache;
 extern SHOW_COMP_OPTION have_geometry, have_rtree_keys;
 extern SHOW_COMP_OPTION have_crypt;
 extern SHOW_COMP_OPTION have_compress;
-extern SHOW_COMP_OPTION have_blackhole_db;
 
 #ifndef __WIN__
 extern pthread_t signal_thread;
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index e1303585114..ba149e5cee6 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -30,9 +30,6 @@
 #include "ha_innodb.h"
 #endif
 #include "ha_myisam.h"
-#ifdef HAVE_ISAM
-#include "ha_isam.h"
-#endif
 #ifdef HAVE_NDBCLUSTER_DB
 #include "ha_ndbcluster.h"
 #endif
@@ -47,11 +44,6 @@
 #else
 #define OPT_BDB_DEFAULT 0
 #endif
-#ifdef HAVE_ISAM_DB
-#define OPT_ISAM_DEFAULT 1
-#else
-#define OPT_ISAM_DEFAULT 0
-#endif
 #ifdef HAVE_NDBCLUSTER_DB
 #define OPT_NDBCLUSTER_DEFAULT 0
 #if defined(NOT_ENOUGH_TESTED) \
@@ -64,7 +56,6 @@
 #define OPT_NDBCLUSTER_DEFAULT 0
 #endif
 
-#include <nisam.h>
 #include <thr_alarm.h>
 #include <ft_global.h>
 #include <errmsg.h>
@@ -4342,7 +4333,7 @@ Disable with --skip-bdb (will save memory).",
    "Don't try to recover Berkeley DB tables on start.", 0, 0, 0, GET_NO_ARG,
    NO_ARG, 0, 0, 0, 0, 0, 0},
   {"bdb-no-sync", OPT_BDB_NOSYNC,
-   "Disable synchronously flushing logs. This option is deprecated, use --skip-sync-bdb-logs or sync-bdb-logs=0 instead",
+   "This option is deprecated, use --skip-sync-bdb-logs instead",
    //   (gptr*) &opt_sync_bdb_logs, (gptr*) &opt_sync_bdb_logs, 0, GET_BOOL,
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"bdb-shared-data", OPT_BDB_SHARED,
@@ -4551,9 +4542,8 @@ Disable with --skip-innodb-doublewrite.", (gptr*) &innobase_use_doublewrite,
    (gptr*) &global_system_variables.innodb_support_xa,
    0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
 #endif /* End HAVE_INNOBASE_DB */
-  {"isam", OPT_ISAM, "Enable ISAM (if this version of MySQL supports it). \
-Disable with --skip-isam.",
-   (gptr*) &opt_isam, (gptr*) &opt_isam, 0, GET_BOOL, NO_ARG, OPT_ISAM_DEFAULT, 0, 0,
+  {"isam", OPT_ISAM, "Obsolete. ISAM storage engine is no longer supported.",
+   (gptr*) &opt_isam, (gptr*) &opt_isam, 0, GET_BOOL, NO_ARG, 0, 0, 0,
    0, 0, 0},
   {"language", 'L',
    "Client error messages in given language. May be given as a full path.",
@@ -5469,36 +5459,35 @@ The minimum value for this variable is 4096.",
    1, 0},
 #ifdef HAVE_BERKELEY_DB
   {"sync-bdb-logs", OPT_BDB_SYNC,
-   "Synchronously flush logs. Enabled by default",
+   "Synchronously flush Berkeley DB logs. Enabled by default",
    (gptr*) &opt_sync_bdb_logs, (gptr*) &opt_sync_bdb_logs, 0, GET_BOOL,
    NO_ARG, 1, 0, 0, 0, 0, 0},
 #endif /* HAVE_BERKELEY_DB */
   {"sync-binlog", OPT_SYNC_BINLOG,
-   "Sync the binlog to disk after every #th event. \
-#=0 (the default) does no sync. Syncing slows MySQL down",
-   (gptr*) &sync_binlog_period,
-   (gptr*) &sync_binlog_period, 0, GET_ULONG, REQUIRED_ARG, 0, 0, ~0L, 0, 1,
-   0},
+   "Synchronously flush binary log to disk after every #th event. "
+   "Use 0 (default) to disable synchronous flushing.",
+   (gptr*) &sync_binlog_period, (gptr*) &sync_binlog_period, 0, GET_ULONG,
+   REQUIRED_ARG, 1, 0, ~0L, 0, 1, 0},
+  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
+   (gptr*) &opt_sync_frm, (gptr*) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
+   0, 0, 0, 0},
 #ifdef DOES_NOTHING_YET
   {"sync-replication", OPT_SYNC_REPLICATION,
-   "Enable synchronous replication",
+   "Enable synchronous replication.",
    (gptr*) &global_system_variables.sync_replication,
    (gptr*) &global_system_variables.sync_replication,
    0, GET_ULONG, REQUIRED_ARG, 0, 0, 1, 0, 1, 0},
   {"sync-replication-slave-id", OPT_SYNC_REPLICATION_SLAVE_ID,
-   "Synchronous replication is wished for this slave",
+   "Synchronous replication is wished for this slave.",
    (gptr*) &global_system_variables.sync_replication_slave_id,
    (gptr*) &global_system_variables.sync_replication_slave_id,
    0, GET_ULONG, REQUIRED_ARG, 0, 0, ~0L, 0, 1, 0},
   {"sync-replication-timeout", OPT_SYNC_REPLICATION_TIMEOUT,
-   "Synchronous replication timeout",
+   "Synchronous replication timeout.",
    (gptr*) &global_system_variables.sync_replication_timeout,
    (gptr*) &global_system_variables.sync_replication_timeout,
    0, GET_ULONG, REQUIRED_ARG, 10, 0, ~0L, 0, 1, 0},
 #endif
-  {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default",
-   (gptr*) &opt_sync_frm, (gptr*) &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
-   0, 0, 0, 0},
   {"table_cache", OPT_TABLE_CACHE,
    "The number of open tables for all threads.", (gptr*) &table_cache_size,
    (gptr*) &table_cache_size, 0, GET_ULONG, REQUIRED_ARG, 64, 1, 512*1024L,
@@ -5962,11 +5951,7 @@ static void mysql_init_variables(void)
 #else
   have_innodb=SHOW_OPTION_NO;
 #endif
-#ifdef HAVE_ISAM
-  have_isam=SHOW_OPTION_YES;
-#else
   have_isam=SHOW_OPTION_NO;
-#endif
 #ifdef HAVE_EXAMPLE_DB
   have_example_db= SHOW_OPTION_YES;
 #else
@@ -6375,9 +6360,6 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
       opt_error_log= 0;			// Force logs to stdout
     break;
   case (int) OPT_FLUSH:
-#ifdef HAVE_ISAM
-    nisam_flush=1;
-#endif
     myisam_flush=1;
     flush_time=0;			// No auto flush
     break;
@@ -6484,14 +6466,6 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
       have_berkeley_db= SHOW_OPTION_DISABLED;
 #endif
     break;
-  case OPT_ISAM:
-#ifdef HAVE_ISAM
-    if (opt_isam)
-      have_isam= SHOW_OPTION_YES;
-    else
-      have_isam= SHOW_OPTION_DISABLED;
-#endif
-    break;
   case OPT_NDBCLUSTER:
 #ifdef HAVE_NDBCLUSTER_DB
     if (opt_ndbcluster)
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 44e2f5ee9f2..9920d89519e 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -42,7 +42,6 @@
 
 #include "mysql_priv.h"
 #include <m_ctype.h>
-#include <nisam.h>
 #include "sql_select.h"
 
 #ifndef EXTRA_DEBUG
@@ -51,7 +50,7 @@
 #endif
 
 /*
-  Convert double value to #rows. Currently this does floor(), and we 
+  Convert double value to #rows. Currently this does floor(), and we
   might consider using round() instead.
 */
 #define double2rows(x) ((ha_rows)(x))
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 457df3f2947..3523e444216 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -954,10 +954,12 @@ struct show_var_st init_vars[]= {
   {"sql_warnings",            (char*) &sys_sql_warnings,            SHOW_BOOL},
 #ifdef HAVE_REPLICATION
   {sys_sync_binlog_period.name,(char*) &sys_sync_binlog_period,     SHOW_SYS},
+#ifdef DOES_NOTHING_YET
   {sys_sync_replication.name, (char*) &sys_sync_replication,        SHOW_SYS},
   {sys_sync_replication_slave_id.name, (char*) &sys_sync_replication_slave_id,SHOW_SYS},
   {sys_sync_replication_timeout.name, (char*) &sys_sync_replication_timeout,SHOW_SYS},
 #endif
+#endif
   {sys_sync_frm.name,         (char*) &sys_sync_frm,               SHOW_SYS},
 #ifdef HAVE_TZNAME
   {"system_time_zone",        system_time_zone,                     SHOW_CHAR},
@@ -2495,14 +2497,6 @@ bool sys_var_sync_binlog_period::update(THD *thd, set_var *var)
 {
   pthread_mutex_t *lock_log= mysql_bin_log.get_log_lock();
   sync_binlog_period= (ulong) var->save_result.ulonglong_value;
-  /*
-    Must reset the counter otherwise it may already be beyond the new period
-    and so the new period will not be taken into account. Need mutex otherwise
-    might be cancelled by a simultanate ++ in MYSQL_LOG::write().
-  */
-  pthread_mutex_lock(lock_log);
-  sync_binlog_counter= 0;
-  pthread_mutex_unlock(lock_log);
   return 0;
 }
 #endif /* HAVE_REPLICATION */
@@ -2522,7 +2516,7 @@ bool sys_var_rand_seed2::update(THD *thd, set_var *var)
 
 bool sys_var_thd_time_zone::check(THD *thd, set_var *var)
 {
-  char buff[MAX_TIME_ZONE_NAME_LENGTH]; 
+  char buff[MAX_TIME_ZONE_NAME_LENGTH];
   String str(buff, sizeof(buff), &my_charset_latin1);
   String *res= var->value->val_str(&str);
 
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 736b372cc8f..145244f1c02 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -25,7 +25,6 @@
 #include <m_ctype.h>
 #include <my_dir.h>
 #include <hash.h>
-#include <nisam.h>
 #ifdef	__WIN__
 #include <io.h>
 #endif
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 95d436069e2..cdda013d23a 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -343,7 +343,9 @@ void THD::change_user(void)
 void THD::cleanup(void)
 {
   DBUG_ENTER("THD::cleanup");
-  ha_rollback(this);
+  /* TODO uncomment the line below when binlog will be able to prepare */
+  // if (transaction.xa_state != XA_PREPARED)
+    ha_rollback(this);
   if (locked_tables)
   {
     lock=locked_tables; locked_tables=0;
@@ -385,17 +387,17 @@ THD::~THD()
   add_to_status(&global_status_var, &status_var);
 
   /* Close connection */
-#ifndef EMBEDDED_LIBRARY  
+#ifndef EMBEDDED_LIBRARY
   if (net.vio)
   {
     vio_delete(net.vio);
-    net_end(&net); 
+    net_end(&net);
   }
 #endif
   if (!cleanup_done)
     cleanup();
 
-    ha_close_connection(this);
+  ha_close_connection(this);
 
   sp_cache_clear(&sp_proc_cache);
   sp_cache_clear(&sp_func_cache);
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 517bf92abff..62cee00043b 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -327,6 +327,7 @@ public:
   bool is_active(const char* log_file_name);
   int update_log_index(LOG_INFO* linfo, bool need_update_threads);
   void rotate_and_purge(uint flags);
+  bool flush_and_sync();
   int purge_logs(const char *to_log, bool included,
                  bool need_mutex, bool need_update_threads,
                  ulonglong *decrease_log_space);
@@ -1264,18 +1265,18 @@ public:
     pthread_mutex_unlock(&LOCK_delete);
   }
   void close_active_vio();
-#endif  
+#endif
   void awake(THD::killed_state state_to_set);
   /*
     For enter_cond() / exit_cond() to work the mutex must be got before
-    enter_cond() (in 4.1 an assertion will soon ensure this); this mutex is
-    then released by exit_cond(). Use must be:
-    lock mutex; enter_cond(); your code; exit_cond().
+    enter_cond(); this mutex is then released by exit_cond().
+    Usage must be: lock mutex; enter_cond(); your code; exit_cond().
   */
   inline const char* enter_cond(pthread_cond_t *cond, pthread_mutex_t* mutex,
 			  const char* msg)
   {
     const char* old_msg = proc_info;
+    safe_mutex_assert_owner(mutex);
     mysys_var->current_mutex = mutex;
     mysys_var->current_cond = cond;
     proc_info = msg;
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 32a62173059..d8c83434423 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -695,6 +695,7 @@ typedef struct st_lex
   Item *default_value, *on_update_value;
   LEX_STRING comment, ident;
   LEX_USER *grant_user;
+  XID *xid;
   gptr yacc_yyss,yacc_yyvs;
   THD *thd;
   CHARSET_INFO *charset;
@@ -738,7 +739,7 @@ typedef struct st_lex
   enum enum_tx_isolation tx_isolation;
   enum enum_ha_read_modes ha_read_mode;
   union {
-  enum ha_rkey_function ha_rkey_mode;
+    enum ha_rkey_function ha_rkey_mode;
     enum xa_option_words xa_opt;
   };
   enum enum_var_type option_type;
@@ -764,15 +765,15 @@ typedef struct st_lex
   ALTER_INFO alter_info;
   /* Prepared statements SQL syntax:*/
   LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
-  /* 
+  /*
     Prepared statement query text or name of variable that holds the
     prepared statement (in PREPARE ... queries)
   */
-  LEX_STRING prepared_stmt_code; 
+  LEX_STRING prepared_stmt_code;
   /* If true, prepared_stmt_code is a name of variable that holds the query */
   bool prepared_stmt_code_is_varref;
   /* Names of user variables holding parameters (in EXECUTE) */
-  List<LEX_STRING> prepared_stmt_params; 
+  List<LEX_STRING> prepared_stmt_params;
   /*
     Points to part of global table list which contains time zone tables
     implicitly used by the statement.
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 029563bb53d..69126e35554 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -4317,7 +4317,7 @@ unsent_create_error:
   case SQLCOM_XA_START:
     if (thd->transaction.xa_state == XA_IDLE && thd->lex->xa_opt == XA_RESUME)
     {
-      if (! thd->transaction.xid.eq(&thd->lex->ident))
+      if (! thd->transaction.xid.eq(thd->lex->xid))
       {
         my_error(ER_XAER_NOTA, MYF(0));
         break;
@@ -4326,7 +4326,7 @@ unsent_create_error:
       send_ok(thd);
       break;
     }
-    if (thd->lex->ident.length > MAXGTRIDSIZE || thd->lex->xa_opt != XA_NONE)
+    if (thd->lex->xa_opt != XA_NONE)
     { // JOIN is not supported yet. TODO
       my_error(ER_XAER_INVAL, MYF(0));
       break;
@@ -4344,7 +4344,7 @@ unsent_create_error:
     }
     DBUG_ASSERT(thd->transaction.xid.is_null());
     thd->transaction.xa_state=XA_ACTIVE;
-    thd->transaction.xid.set(&thd->lex->ident);
+    thd->transaction.xid.set(thd->lex->xid);
     thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
                    OPTION_BEGIN);
     thd->server_status|= SERVER_STATUS_IN_TRANS;
@@ -4363,7 +4363,7 @@ unsent_create_error:
                xa_state_names[thd->transaction.xa_state]);
       break;
     }
-    if (!thd->transaction.xid.eq(&thd->lex->ident))
+    if (!thd->transaction.xid.eq(thd->lex->xid))
     {
       my_error(ER_XAER_NOTA, MYF(0));
       break;
@@ -4378,7 +4378,7 @@ unsent_create_error:
                xa_state_names[thd->transaction.xa_state]);
       break;
     }
-    if (!thd->transaction.xid.eq(&thd->lex->ident))
+    if (!thd->transaction.xid.eq(thd->lex->xid))
     {
       my_error(ER_XAER_NOTA, MYF(0));
       break;
@@ -4393,9 +4393,9 @@ unsent_create_error:
     send_ok(thd);
     break;
   case SQLCOM_XA_COMMIT:
-    if (!thd->transaction.xid.eq(&thd->lex->ident))
+    if (!thd->transaction.xid.eq(thd->lex->xid))
     {
-      if (!(res= !ha_commit_or_rollback_by_xid(&thd->lex->ident, 1)))
+      if (!(res= !ha_commit_or_rollback_by_xid(thd->lex->xid, 1)))
         my_error(ER_XAER_NOTA, MYF(0));
       else
         send_ok(thd);
@@ -4428,9 +4428,9 @@ unsent_create_error:
     thd->transaction.xa_state=XA_NOTR;
     break;
   case SQLCOM_XA_ROLLBACK:
-    if (!thd->transaction.xid.eq(&thd->lex->ident))
+    if (!thd->transaction.xid.eq(thd->lex->xid))
     {
-      if (!(res= !ha_commit_or_rollback_by_xid(&thd->lex->ident, 0)))
+      if (!(res= !ha_commit_or_rollback_by_xid(thd->lex->xid, 0)))
         my_error(ER_XAER_NOTA, MYF(0));
       else
         send_ok(thd);
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 4924f78dc0a..3c2577acf96 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -47,13 +47,13 @@ const LEX_STRING null_lex_str={0,0};
 
 #define yyoverflow(A,B,C,D,E,F) {ulong val= *(F); if(my_yyoverflow((B), (D), &val)) { yyerror((char*) (A)); return 2; } else { *(F)= (YYSIZE_T)val; }}
 
-#define WARN_DEPRECATED(A,B) \
+#define WARN_DEPRECATED(A,B)                                        \
   push_warning_printf(((THD *)yythd), MYSQL_ERROR::WARN_LEVEL_WARN, \
-		      ER_WARN_DEPRECATED_SYNTAX, \
+		      ER_WARN_DEPRECATED_SYNTAX,                    \
 		      ER(ER_WARN_DEPRECATED_SYNTAX), (A), (B));
 
-#define TEST_ASSERT(A) \
-  if (!(A)) \
+#define TEST_ASSERT(A)                  \
+  if (!(A))                             \
   {					\
     yyerror(ER(ER_SYNTAX_ERROR));	\
     YYABORT;				\
@@ -243,7 +243,6 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  DUPLICATE_SYM
 %token  DYNAMIC_SYM
 %token  EACH_SYM
-%token  EALLOCATE_SYM
 %token  ELSEIF_SYM
 %token  ELT_FUNC
 %token  ENABLE_SYM
@@ -702,7 +701,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
         union_opt select_derived_init
 
 %type <ulong_num>
-	ULONG_NUM raid_types merge_insert_types
+	ulong_num raid_types merge_insert_types
 
 %type <ulonglong_number>
 	ulonglong_num
@@ -1039,16 +1038,16 @@ master_def:
 	 Lex->mi.password = $3.str;
        }
        |
-       MASTER_PORT_SYM EQ ULONG_NUM
+       MASTER_PORT_SYM EQ ulong_num
        {
 	 Lex->mi.port = $3;
        }
        |
-       MASTER_CONNECT_RETRY_SYM EQ ULONG_NUM
+       MASTER_CONNECT_RETRY_SYM EQ ulong_num
        {
 	 Lex->mi.connect_retry = $3;
        }
-       | MASTER_SSL_SYM EQ ULONG_NUM
+       | MASTER_SSL_SYM EQ ulong_num
          {
            Lex->mi.ssl= $3 ? 
                LEX_MASTER_INFO::SSL_ENABLE : LEX_MASTER_INFO::SSL_DISABLE;
@@ -1102,7 +1101,7 @@ master_file_def:
          {
            Lex->mi.relay_log_name = $3.str;
          }
-       | RELAY_LOG_POS_SYM EQ ULONG_NUM
+       | RELAY_LOG_POS_SYM EQ ulong_num
          {
            Lex->mi.relay_log_pos = $3;
            /* Adjust if < BIN_LOG_HEADER_SIZE (same comment as Lex->mi.pos) */
@@ -1792,7 +1791,7 @@ sp_hcond_list:
 	;
 
 sp_cond:
-	  ULONG_NUM
+	  ulong_num
 	  {			/* mysql errno */
 	    $$= (sp_cond_type_t *)YYTHD->alloc(sizeof(sp_cond_type_t));
 	    $$->type= sp_cond_type_t::number;
@@ -2578,18 +2577,18 @@ create_table_option:
 	| TYPE_SYM opt_equal storage_engines    { Lex->create_info.db_type= $3; WARN_DEPRECATED("TYPE=storage_engine","ENGINE=storage_engine");   Lex->create_info.used_fields|= HA_CREATE_USED_ENGINE; }
 	| MAX_ROWS opt_equal ulonglong_num	{ Lex->create_info.max_rows= $3; Lex->create_info.used_fields|= HA_CREATE_USED_MAX_ROWS;}
 	| MIN_ROWS opt_equal ulonglong_num	{ Lex->create_info.min_rows= $3; Lex->create_info.used_fields|= HA_CREATE_USED_MIN_ROWS;}
-	| AVG_ROW_LENGTH opt_equal ULONG_NUM	{ Lex->create_info.avg_row_length=$3; Lex->create_info.used_fields|= HA_CREATE_USED_AVG_ROW_LENGTH;}
+	| AVG_ROW_LENGTH opt_equal ulong_num	{ Lex->create_info.avg_row_length=$3; Lex->create_info.used_fields|= HA_CREATE_USED_AVG_ROW_LENGTH;}
 	| PASSWORD opt_equal TEXT_STRING_sys	{ Lex->create_info.password=$3.str; Lex->create_info.used_fields|= HA_CREATE_USED_PASSWORD; }
 	| COMMENT_SYM opt_equal TEXT_STRING_sys	{ Lex->create_info.comment=$3.str; Lex->create_info.used_fields|= HA_CREATE_USED_COMMENT; }
 	| AUTO_INC opt_equal ulonglong_num	{ Lex->create_info.auto_increment_value=$3; Lex->create_info.used_fields|= HA_CREATE_USED_AUTO;}
-	| PACK_KEYS_SYM opt_equal ULONG_NUM	{ Lex->create_info.table_options|= $3 ? HA_OPTION_PACK_KEYS : HA_OPTION_NO_PACK_KEYS; Lex->create_info.used_fields|= HA_CREATE_USED_PACK_KEYS;}
+	| PACK_KEYS_SYM opt_equal ulong_num	{ Lex->create_info.table_options|= $3 ? HA_OPTION_PACK_KEYS : HA_OPTION_NO_PACK_KEYS; Lex->create_info.used_fields|= HA_CREATE_USED_PACK_KEYS;}
 	| PACK_KEYS_SYM opt_equal DEFAULT	{ Lex->create_info.table_options&= ~(HA_OPTION_PACK_KEYS | HA_OPTION_NO_PACK_KEYS); Lex->create_info.used_fields|= HA_CREATE_USED_PACK_KEYS;}
-	| CHECKSUM_SYM opt_equal ULONG_NUM	{ Lex->create_info.table_options|= $3 ? HA_OPTION_CHECKSUM : HA_OPTION_NO_CHECKSUM; Lex->create_info.used_fields|= HA_CREATE_USED_CHECKSUM; }
-	| DELAY_KEY_WRITE_SYM opt_equal ULONG_NUM { Lex->create_info.table_options|= $3 ? HA_OPTION_DELAY_KEY_WRITE : HA_OPTION_NO_DELAY_KEY_WRITE;  Lex->create_info.used_fields|= HA_CREATE_USED_DELAY_KEY_WRITE; }
+	| CHECKSUM_SYM opt_equal ulong_num	{ Lex->create_info.table_options|= $3 ? HA_OPTION_CHECKSUM : HA_OPTION_NO_CHECKSUM; Lex->create_info.used_fields|= HA_CREATE_USED_CHECKSUM; }
+	| DELAY_KEY_WRITE_SYM opt_equal ulong_num { Lex->create_info.table_options|= $3 ? HA_OPTION_DELAY_KEY_WRITE : HA_OPTION_NO_DELAY_KEY_WRITE;  Lex->create_info.used_fields|= HA_CREATE_USED_DELAY_KEY_WRITE; }
 	| ROW_FORMAT_SYM opt_equal row_types	{ Lex->create_info.row_type= $3;  Lex->create_info.used_fields|= HA_CREATE_USED_ROW_FORMAT; }
 	| RAID_TYPE opt_equal raid_types	{ Lex->create_info.raid_type= $3; Lex->create_info.used_fields|= HA_CREATE_USED_RAID;}
-	| RAID_CHUNKS opt_equal ULONG_NUM	{ Lex->create_info.raid_chunks= $3; Lex->create_info.used_fields|= HA_CREATE_USED_RAID;}
-	| RAID_CHUNKSIZE opt_equal ULONG_NUM	{ Lex->create_info.raid_chunksize= $3*RAID_BLOCK_SIZE; Lex->create_info.used_fields|= HA_CREATE_USED_RAID;}
+	| RAID_CHUNKS opt_equal ulong_num	{ Lex->create_info.raid_chunks= $3; Lex->create_info.used_fields|= HA_CREATE_USED_RAID;}
+	| RAID_CHUNKSIZE opt_equal ulong_num	{ Lex->create_info.raid_chunksize= $3*RAID_BLOCK_SIZE; Lex->create_info.used_fields|= HA_CREATE_USED_RAID;}
 	| UNION_SYM opt_equal '(' table_list ')'
 	  {
 	    /* Move the union list to the merge_list */
@@ -2666,7 +2665,7 @@ row_types:
 raid_types:
 	RAID_STRIPED_SYM { $$= RAID_TYPE_0; }
 	| RAID_0_SYM	 { $$= RAID_TYPE_0; }
-	| ULONG_NUM	 { $$=$1;};
+	| ulong_num	 { $$=$1;};
 
 merge_insert_types:
        NO_SYM            { $$= MERGE_INSERT_DISABLED; }
@@ -4704,7 +4703,7 @@ simple_expr:
 	  { $$= new Item_func_yearweek($3,new Item_int((char*) "0",0,1)); }
 	| YEARWEEK '(' expr ',' expr ')'
 	  { $$= new Item_func_yearweek($3, $5); }
-	| BENCHMARK_SYM '(' ULONG_NUM ',' expr ')'
+	| BENCHMARK_SYM '(' ulong_num ',' expr ')'
 	  {
 	    $$=new Item_func_benchmark($3,$5);
 	    Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
@@ -4989,7 +4988,7 @@ table_ref:
 join_table_list:
 	derived_table_list		{ TEST_ASSERT($$=$1); }
 	;
-        
+
 /* Warning - may return NULL in case of incomplete SELECT */
 derived_table_list:
         table_ref { $$=$1; }
@@ -5033,7 +5032,7 @@ join_table:
 	    $$=$6;
 	  }
 	| table_ref RIGHT opt_outer JOIN_SYM table_ref ON expr
-          { 
+          {
 	    LEX *lex= Lex;
             TEST_ASSERT($1 && $5);
             if (!($$= lex->current_select->convert_right_join()))
@@ -5047,7 +5046,7 @@ join_table:
             sel->save_names_for_using_list($1, $5);
 	  }
 	  USING '(' using_list ')'
-          { 
+          {
 	    LEX *lex= Lex;
             if (!($$= lex->current_select->convert_right_join()))
               YYABORT;
@@ -5063,7 +5062,7 @@ join_table:
 	  }
 	| table_ref NATURAL JOIN_SYM table_factor
 	  { TEST_ASSERT($1 && ($$=$4)); add_join_natural($1,$4); };
-        
+
 
 normal_join:
 	JOIN_SYM		{}
@@ -5109,9 +5108,9 @@ table_factor:
                    sel->master_unit()->fake_select_lex;
             }
             if ($2->init_nested_join(lex->thd))
-              YYABORT;            
+              YYABORT;
             $$= 0;
-            /* incomplete derived tables return NULL, we must be 
+            /* incomplete derived tables return NULL, we must be
                nested in select_derived rule to be here. */
           }
 	| '(' get_select_lex select_derived union_opt ')' opt_table_alias
@@ -5119,7 +5118,7 @@ table_factor:
           /* Use $2 instead of Lex->current_select as derived table will
              alter value of Lex->current_select. */
 
-          if (!($3 || $6) && $2->embedding && 
+          if (!($3 || $6) && $2->embedding &&
               !$2->embedding->nested_join->join_list.elements)
           {
             /* we have a derived table ($3 == NULL) but no alias,
@@ -5144,7 +5143,7 @@ table_factor:
 	                            (List<String> *)0)))
 
 	      YYABORT;
-            sel->add_joined_table($$);           
+            sel->add_joined_table($$);
           }
 	  else
           if ($4 || $6)
@@ -5171,7 +5170,7 @@ select_derived:
             LEX *lex= Lex;
             /* for normal joins, $3 != NULL and end_nested_join() != NULL,
                for derived tables, both must equal NULL */
-            
+
             if (!($$= $1->end_nested_join(lex->thd)) && $3)
               YYABORT;
             if (!$3 && $$)
@@ -5215,7 +5214,7 @@ select_derived_init:
           SELECT_SYM
           {
             LEX *lex= Lex;
-            SELECT_LEX *sel= lex->current_select;        
+            SELECT_LEX *sel= lex->current_select;
             TABLE_LIST *embedding;
             if (!sel->embedding || sel->end_nested_join(lex->thd))
 	    {
@@ -5488,21 +5487,21 @@ limit_clause:
 	;
 
 limit_options:
-	ULONG_NUM
+	ulong_num
 	  {
             SELECT_LEX *sel= Select;
             sel->select_limit= $1;
             sel->offset_limit= 0L;
 	    sel->explicit_limit= 1;
 	  }
-	| ULONG_NUM ',' ULONG_NUM
+	| ulong_num ',' ulong_num
 	  {
 	    SELECT_LEX *sel= Select;
 	    sel->select_limit= $3;
 	    sel->offset_limit= $1;
 	    sel->explicit_limit= 1;
 	  }
-	| ULONG_NUM OFFSET_SYM ULONG_NUM
+	| ulong_num OFFSET_SYM ulong_num
 	  {
 	    SELECT_LEX *sel= Select;
 	    sel->select_limit= $1;
@@ -5525,11 +5524,12 @@ delete_limit_clause:
 	  sel->explicit_limit= 1;
 	};
 
-ULONG_NUM:
-	NUM	        { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
+ulong_num:
+          NUM           { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
+	| HEX_NUM       { int error; $$= (ulong) strtol($1.str, (char**) 0, 16); }
 	| LONG_NUM      { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
 	| ULONGLONG_NUM { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
-        | DECIMAL_NUM 	{ int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
+        | DECIMAL_NUM   { int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
 	| FLOAT_NUM	{ int error; $$= (ulong) my_strtoll10($1.str, (char**) 0, &error); }
 	;
 
@@ -6139,7 +6139,7 @@ show_param:
         | NEW_SYM MASTER_SYM FOR_SYM SLAVE WITH MASTER_LOG_FILE_SYM EQ
 	  TEXT_STRING_sys AND_SYM MASTER_LOG_POS_SYM EQ ulonglong_num
 	  AND_SYM MASTER_SERVER_ID_SYM EQ
-	ULONG_NUM
+	ulong_num
           {
 	    Lex->sql_command = SQLCOM_SHOW_NEW_MASTER;
 	    Lex->mi.log_file_name = $8.str;
@@ -6688,7 +6688,7 @@ fields_or_vars:
         | field_or_var
           { Lex->field_list.push_back($1); }
         ;
-        
+
 field_or_var:
         simple_ident_nospvar {$$= $1;}
         | '@' ident_or_text
@@ -6836,9 +6836,9 @@ NUM_literal:
 	   }
 	}
 	;
-	
+
 /**********************************************************************
-** Createing different items.
+** Creating different items.
 **********************************************************************/
 
 insert_ident:
@@ -6854,8 +6854,8 @@ table_wild:
 	| ident '.' ident '.' '*'
 	{
 	  $$ = new Item_field((YYTHD->client_capabilities &
-   			     CLIENT_NO_SCHEMA ? NullS : $1.str),
-			     $3.str,"*");
+                             CLIENT_NO_SCHEMA ? NullS : $1.str),
+                             $3.str,"*");
 	  Lex->current_select->with_wild++;
 	}
 	;
@@ -6898,53 +6898,53 @@ simple_ident_nospvar:
 	      (Item*) new Item_ref(NullS,NullS,$1.str);
 	}
 	| simple_ident_q { $$= $1; }
-	;	
+	;
 
 simple_ident_q:
 	ident '.' ident
 	{
 	  THD *thd= YYTHD;
 	  LEX *lex= thd->lex;
-         
+
           /*
             FIXME This will work ok in simple_ident_nospvar case because
             we can't meet simple_ident_nospvar in trigger now. But it
             should be changed in future.
           */
           if (lex->sphead && lex->sphead->m_type == TYPE_ENUM_TRIGGER &&
-              (!my_strcasecmp(system_charset_info, $1.str, "NEW") || 
+              (!my_strcasecmp(system_charset_info, $1.str, "NEW") ||
                !my_strcasecmp(system_charset_info, $1.str, "OLD")))
           {
             Item_trigger_field *trg_fld;
             bool new_row= ($1.str[0]=='N' || $1.str[0]=='n');
-            
+
             if (lex->trg_chistics.event == TRG_EVENT_INSERT &&
                 !new_row)
             {
               my_error(ER_TRG_NO_SUCH_ROW_IN_TRG, MYF(0), "OLD", "on INSERT");
               YYABORT;
             }
-            
+
             if (lex->trg_chistics.event == TRG_EVENT_DELETE &&
                 new_row)
             {
               my_error(ER_TRG_NO_SUCH_ROW_IN_TRG, MYF(0), "NEW", "on DELETE");
               YYABORT;
             }
-            
+
             if (!(trg_fld= new Item_trigger_field(new_row ?
                                                   Item_trigger_field::NEW_ROW:
                                                   Item_trigger_field::OLD_ROW,
                                                   $3.str)))
               YYABORT;
-          
+
             /*
               Let us add this item to list of all Item_trigger_field objects
               in trigger.
             */
             lex->trg_table_fields.link_in_list((byte *)trg_fld,
               (byte**)&trg_fld->next_trg_field);
-            
+
             $$= (Item *)trg_fld;
           }
           else
@@ -7073,7 +7073,7 @@ ident:
 	;
 
 ident_or_text:
-	ident 			{ $$=$1;}
+        ident                   { $$=$1;}
 	| TEXT_STRING_sys	{ $$=$1;}
 	| LEX_HOSTNAME		{ $$=$1;};
 
@@ -8124,25 +8124,25 @@ grant_option_list:
 
 grant_option:
 	GRANT OPTION { Lex->grant |= GRANT_ACL;}
-        | MAX_QUERIES_PER_HOUR ULONG_NUM
+        | MAX_QUERIES_PER_HOUR ulong_num
         {
 	  LEX *lex=Lex;
 	  lex->mqh.questions=$2;
 	  lex->mqh.specified_limits|= USER_RESOURCES::QUERIES_PER_HOUR;
 	}
-        | MAX_UPDATES_PER_HOUR ULONG_NUM
+        | MAX_UPDATES_PER_HOUR ulong_num
         {
 	  LEX *lex=Lex;
 	  lex->mqh.updates=$2;
 	  lex->mqh.specified_limits|= USER_RESOURCES::UPDATES_PER_HOUR;
 	}
-        | MAX_CONNECTIONS_PER_HOUR ULONG_NUM
+        | MAX_CONNECTIONS_PER_HOUR ulong_num
         {
 	  LEX *lex=Lex;
 	  lex->mqh.conn_per_hour= $2;
 	  lex->mqh.specified_limits|= USER_RESOURCES::CONNECTIONS_PER_HOUR;
 	}
-        | MAX_USER_CONNECTIONS_SYM ULONG_NUM
+        | MAX_USER_CONNECTIONS_SYM ulong_num
         {
 	  LEX *lex=Lex;
           lex->mqh.user_conn= $2;
@@ -8413,38 +8413,52 @@ check_option:
 
 xa: XA_SYM begin_or_start xid opt_join_or_resume
       {
-        LEX *lex= Lex;
-        lex->sql_command = SQLCOM_XA_START;
+        Lex->sql_command = SQLCOM_XA_START;
       }
     | XA_SYM END xid opt_suspend_or_migrate
       {
-        LEX *lex= Lex;
-        lex->sql_command = SQLCOM_XA_END;
+        Lex->sql_command = SQLCOM_XA_END;
       }
     | XA_SYM PREPARE_SYM xid
       {
-        LEX *lex= Lex;
-        lex->sql_command = SQLCOM_XA_PREPARE;
+        Lex->sql_command = SQLCOM_XA_PREPARE;
       }
     | XA_SYM COMMIT_SYM xid opt_one_phase
       {
-        LEX *lex= Lex;
-        lex->sql_command = SQLCOM_XA_COMMIT;
+        Lex->sql_command = SQLCOM_XA_COMMIT;
       }
     | XA_SYM ROLLBACK_SYM xid
       {
-        LEX *lex= Lex;
-        lex->sql_command = SQLCOM_XA_ROLLBACK;
+        Lex->sql_command = SQLCOM_XA_ROLLBACK;
       }
     | XA_SYM RECOVER_SYM
       {
-        LEX *lex= Lex;
-        lex->sql_command = SQLCOM_XA_RECOVER;
+        Lex->sql_command = SQLCOM_XA_RECOVER;
       }
     ;
 
-xid: ident_or_text              { Lex->ident=$1; }
-    ;
+xid: text_string
+     {
+       TEST_ASSERT($1->length() <= MAXGTRIDSIZE);
+       if (!(Lex->xid=(XID *)YYTHD->alloc(sizeof(XID))))
+         YYABORT;
+       Lex->xid->set(1L, $1->ptr(), $1->length(), 0, 0);
+     }
+     | text_string ',' text_string
+     {
+       TEST_ASSERT($1->length() <= MAXGTRIDSIZE && $3->length() <= MAXBQUALSIZE);
+       if (!(Lex->xid=(XID *)YYTHD->alloc(sizeof(XID))))
+         YYABORT;
+       Lex->xid->set(1L, $1->ptr(), $1->length(), $3->ptr(), $3->length());
+     }
+     | text_string ',' text_string ',' ulong_num
+     {
+       TEST_ASSERT($1->length() <= MAXGTRIDSIZE && $3->length() <= MAXBQUALSIZE);
+       if (!(Lex->xid=(XID *)YYTHD->alloc(sizeof(XID))))
+         YYABORT;
+       Lex->xid->set($5, $1->ptr(), $1->length(), $3->ptr(), $3->length());
+     }
+     ;
 
 begin_or_start:   BEGIN_SYM {}
     |             START_SYM {}