Merge alik.:/mnt/raid/alik/MySQL/devel/5.1-monty

into  alik.:/mnt/raid/alik/MySQL/devel/5.1-rt-merged


mysql-test/mysql-test-run.pl:
  Auto merged
sql/ha_ndbcluster.cc:
  Auto merged
sql/handler.cc:
  Auto merged
sql/log.cc:
  Auto merged
sql/mysqld.cc:
  Auto merged
sql/sp_head.cc:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_class.h:
  Auto merged
sql/sql_insert.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
sql/sql_view.cc:
  Auto merged
sql/table.cc:
  Auto merged
server-tools/instance-manager/guardian.cc:
  Manual merged.
server-tools/instance-manager/instance.cc:
  Manual merged.
server-tools/instance-manager/mysql_connection.cc:
  Manual merged.

33 files changed, 6205 insertions, 1758 deletions

diff --git a/sql/event_data_objects.cc b/sql/event_data_objects.cc
index 4b9aa43b14b..afd10350bb5 100644
--- a/sql/event_data_objects.cc
+++ b/sql/event_data_objects.cc
@@ -886,14 +886,29 @@ Event_queue_element::load_from_row(TABLE *table)
     goto error;
 
   /*
-    In DB the values start from 1 but enum interval_type starts
-    from 0
+    We load the interval type from disk as string and then map it to
+    an integer. This decouples the values of enum interval_type
+    and values actually stored on disk. Therefore the type can be
+    reordered without risking incompatibilities of data between versions.
   */
   if (!table->field[ET_FIELD_TRANSIENT_INTERVAL]->is_null())
-    interval= (interval_type) ((ulonglong)
-          table->field[ET_FIELD_TRANSIENT_INTERVAL]->val_int() - 1);
-  else
-    interval= (interval_type) 0;
+  {
+    int i;
+    char buff[MAX_FIELD_WIDTH];
+    String str(buff, sizeof(buff), &my_charset_bin);
+    LEX_STRING tmp;
+
+    table->field[ET_FIELD_TRANSIENT_INTERVAL]->val_str(&str);
+    if (!(tmp.length= str.length()))
+      goto error;
+
+    tmp.str= str.c_ptr_safe();
+
+    i= find_string_in_array(interval_type_to_name, &tmp, system_charset_info);
+    if (i < 0)
+      goto error;
+    interval= (interval_type) i;
+  }
 
   table->field[ET_FIELD_LAST_EXECUTED]->get_date(&last_executed,
                                                  TIME_NO_ZERO_DATE);
diff --git a/sql/event_db_repository.cc b/sql/event_db_repository.cc
index 464c26044c7..3d30aff669b 100644
--- a/sql/event_db_repository.cc
+++ b/sql/event_db_repository.cc
@@ -188,11 +188,11 @@ mysql_event_fill_row(THD *thd, TABLE *table, Event_parse_data *et,
     fields[ET_FIELD_INTERVAL_EXPR]->store((longlong)et->expression, TRUE);
 
     fields[ET_FIELD_TRANSIENT_INTERVAL]->set_notnull();
-    /*
-      In the enum (C) intervals start from 0 but in mysql enum valid values
-      start from 1. Thus +1 offset is needed!
-    */
-    fields[ET_FIELD_TRANSIENT_INTERVAL]->store((longlong)et->interval+1, TRUE);
+
+    fields[ET_FIELD_TRANSIENT_INTERVAL]->
+                            store(interval_type_to_name[et->interval].str,
+                                  interval_type_to_name[et->interval].length,
+                                  scs);
 
     fields[ET_FIELD_EXECUTE_AT]->set_null();
 
diff --git a/sql/handler.cc b/sql/handler.cc
index 288499a46ef..5dedc26969b 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -1483,8 +1483,9 @@ bool handler::check_if_log_table_locking_is_allowed(uint sql_command,
 {
   /*
     Deny locking of the log tables, which is incompatible with
-    concurrent insert. Unless called from a logger THD:
-    general_log_thd or slow_log_thd.
+    concurrent insert. The routine is not called if the table is
+    being locked from a logger THD (general_log_thd or slow_log_thd)
+    or from a privileged thread (see log.cc for details)
   */
   if (table->s->log_table &&
       sql_command != SQLCOM_TRUNCATE &&
diff --git a/sql/handler.h b/sql/handler.h
index 0cfd6da23d7..1756693ed3d 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -975,6 +975,10 @@ public:
         thd     Handler of the thread, trying to lock the table
         table   Table handler to check
         count   Number of locks already granted to the table
+        called_by_privileged_thread TRUE if called from a logger THD
+                                    (general_log_thd or slow_log_thd)
+                                    or by a privileged thread, which
+                                    has the right to lock log tables.
 
     DESCRIPTION
       Check whether a handler allows to lock the table. For instance,
@@ -990,7 +994,7 @@ public:
   virtual bool check_if_locking_is_allowed(uint sql_command,
                                            ulong type, TABLE *table,
                                            uint count,
-                                           bool called_by_logger_thread)
+                                           bool called_by_privileged_thread)
   {
     return TRUE;
   }
diff --git a/sql/item_create.cc b/sql/item_create.cc
index 3a93ec6e516..7722ce28d4a 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -14,728 +14,4926 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/* Functions to create an item. Used by lex.h */
+/* Functions to create an item. Used by sql_yacc.yy */
 
 #include "mysql_priv.h"
+#include "item_create.h"
+#include "sp_head.h"
+#include "sp.h"
+
+/*
+=============================================================================
+  LOCAL DECLARATIONS
+=============================================================================
+*/
+
+/**
+  Adapter for functions that takes exactly zero arguments.
+*/
+
+class Create_func_arg0 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with no arguments.
+    @param thd The current thread
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg0() {}
+  /** Destructor. */
+  virtual ~Create_func_arg0() {}
+};
+
+
+/**
+  Adapter for functions that takes exactly one argument.
+*/
+
+class Create_func_arg1 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with one argument.
+    @param thd The current thread
+    @param arg1 The first argument of the function
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd, Item *arg1) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg1() {}
+  /** Destructor. */
+  virtual ~Create_func_arg1() {}
+};
+
+
+/**
+  Adapter for functions that takes exactly two arguments.
+*/
+
+class Create_func_arg2 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with two arguments.
+    @param thd The current thread
+    @param arg1 The first argument of the function
+    @param arg2 The second argument of the function
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg2() {}
+  /** Destructor. */
+  virtual ~Create_func_arg2() {}
+};
+
+
+/**
+  Adapter for functions that takes exactly three arguments.
+*/
+
+class Create_func_arg3 : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    Builder method, with three arguments.
+    @param thd The current thread
+    @param arg1 The first argument of the function
+    @param arg2 The second argument of the function
+    @param arg3 The third argument of the function
+    @return An item representing the function call
+  */
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3) = 0;
+
+protected:
+  /** Constructor. */
+  Create_func_arg3() {}
+  /** Destructor. */
+  virtual ~Create_func_arg3() {}
+};
+
+
+/**
+  Function builder for Stored Functions.
+*/
+
+class Create_sp_func : public Create_qfunc
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name,
+                       List<Item> *item_list);
+
+  static Create_sp_func s_singleton;
+
+protected:
+  /** Constructor. */
+  Create_sp_func() {}
+  /** Destructor. */
+  virtual ~Create_sp_func() {}
+};
 
-Item *create_func_abs(Item* a)
+
+#ifndef HAVE_SPATIAL
+/**
+  Common (non) builder for geometry functions.
+  This builder is used in <code>--without-geometry</code> builds only,
+  to report an error.
+*/
+
+class Create_func_no_geom : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /** Singleton. */
+  static Create_func_no_geom s_singleton;
+
+protected:
+  /** Constructor. */
+  Create_func_no_geom() {}
+  /** Destructor. */
+  virtual ~Create_func_no_geom() {}
+};
+#endif
+
+
+/*
+  Concrete functions builders (native functions).
+  Please keep this list sorted in alphabetical order,
+  it helps to compare code between versions, and helps with merges conflicts.
+*/
+
+class Create_func_abs : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_abs s_singleton;
+
+protected:
+  Create_func_abs() {}
+  virtual ~Create_func_abs() {}
+};
+
+
+class Create_func_acos : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_acos s_singleton;
+
+protected:
+  Create_func_acos() {}
+  virtual ~Create_func_acos() {}
+};
+
+
+class Create_func_addtime : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_addtime s_singleton;
+
+protected:
+  Create_func_addtime() {}
+  virtual ~Create_func_addtime() {}
+};
+
+
+class Create_func_aes_encrypt : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_aes_encrypt s_singleton;
+
+protected:
+  Create_func_aes_encrypt() {}
+  virtual ~Create_func_aes_encrypt() {}
+};
+
+
+class Create_func_aes_decrypt : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_aes_decrypt s_singleton;
+
+protected:
+  Create_func_aes_decrypt() {}
+  virtual ~Create_func_aes_decrypt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_area : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_area s_singleton;
+
+protected:
+  Create_func_area() {}
+  virtual ~Create_func_area() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_as_wkb : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_as_wkb s_singleton;
+
+protected:
+  Create_func_as_wkb() {}
+  virtual ~Create_func_as_wkb() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_as_wkt : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_as_wkt s_singleton;
+
+protected:
+  Create_func_as_wkt() {}
+  virtual ~Create_func_as_wkt() {}
+};
+#endif
+
+
+class Create_func_asin : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_asin s_singleton;
+
+protected:
+  Create_func_asin() {}
+  virtual ~Create_func_asin() {}
+};
+
+
+class Create_func_atan : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_atan s_singleton;
+
+protected:
+  Create_func_atan() {}
+  virtual ~Create_func_atan() {}
+};
+
+
+class Create_func_benchmark : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_benchmark s_singleton;
+
+protected:
+  Create_func_benchmark() {}
+  virtual ~Create_func_benchmark() {}
+};
+
+
+class Create_func_bin : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_bin s_singleton;
+
+protected:
+  Create_func_bin() {}
+  virtual ~Create_func_bin() {}
+};
+
+
+class Create_func_bit_count : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_bit_count s_singleton;
+
+protected:
+  Create_func_bit_count() {}
+  virtual ~Create_func_bit_count() {}
+};
+
+
+class Create_func_bit_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_bit_length s_singleton;
+
+protected:
+  Create_func_bit_length() {}
+  virtual ~Create_func_bit_length() {}
+};
+
+
+class Create_func_ceiling : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg);
+
+  static Create_func_ceiling s_singleton;
+
+protected:
+  Create_func_ceiling() {}
+  virtual ~Create_func_ceiling() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_centroid : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_centroid s_singleton;
+
+protected:
+  Create_func_centroid() {}
+  virtual ~Create_func_centroid() {}
+};
+#endif
+
+
+class Create_func_char_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_char_length s_singleton;
+
+protected:
+  Create_func_char_length() {}
+  virtual ~Create_func_char_length() {}
+};
+
+
+class Create_func_coercibility : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_coercibility s_singleton;
+
+protected:
+  Create_func_coercibility() {}
+  virtual ~Create_func_coercibility() {}
+};
+
+
+class Create_func_compress : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_compress s_singleton;
+
+protected:
+  Create_func_compress() {}
+  virtual ~Create_func_compress() {}
+};
+
+
+class Create_func_concat : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_concat s_singleton;
+
+protected:
+  Create_func_concat() {}
+  virtual ~Create_func_concat() {}
+};
+
+
+class Create_func_concat_ws : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_concat_ws s_singleton;
+
+protected:
+  Create_func_concat_ws() {}
+  virtual ~Create_func_concat_ws() {}
+};
+
+
+class Create_func_connection_id : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_connection_id s_singleton;
+
+protected:
+  Create_func_connection_id() {}
+  virtual ~Create_func_connection_id() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_contains : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_contains s_singleton;
+
+protected:
+  Create_func_contains() {}
+  virtual ~Create_func_contains() {}
+};
+#endif
+
+
+class Create_func_conv : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_conv s_singleton;
+
+protected:
+  Create_func_conv() {}
+  virtual ~Create_func_conv() {}
+};
+
+
+class Create_func_convert_tz : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_convert_tz s_singleton;
+
+protected:
+  Create_func_convert_tz() {}
+  virtual ~Create_func_convert_tz() {}
+};
+
+
+class Create_func_cos : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_cos s_singleton;
+
+protected:
+  Create_func_cos() {}
+  virtual ~Create_func_cos() {}
+};
+
+
+class Create_func_cot : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_cot s_singleton;
+
+protected:
+  Create_func_cot() {}
+  virtual ~Create_func_cot() {}
+};
+
+
+class Create_func_crc32 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_crc32 s_singleton;
+
+protected:
+  Create_func_crc32() {}
+  virtual ~Create_func_crc32() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_crosses : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_crosses s_singleton;
+
+protected:
+  Create_func_crosses() {}
+  virtual ~Create_func_crosses() {}
+};
+#endif
+
+
+class Create_func_date_format : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_date_format s_singleton;
+
+protected:
+  Create_func_date_format() {}
+  virtual ~Create_func_date_format() {}
+};
+
+
+class Create_func_datediff : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_datediff s_singleton;
+
+protected:
+  Create_func_datediff() {}
+  virtual ~Create_func_datediff() {}
+};
+
+
+class Create_func_dayname : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayname s_singleton;
+
+protected:
+  Create_func_dayname() {}
+  virtual ~Create_func_dayname() {}
+};
+
+
+class Create_func_dayofmonth : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayofmonth s_singleton;
+
+protected:
+  Create_func_dayofmonth() {}
+  virtual ~Create_func_dayofmonth() {}
+};
+
+
+class Create_func_dayofweek : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayofweek s_singleton;
+
+protected:
+  Create_func_dayofweek() {}
+  virtual ~Create_func_dayofweek() {}
+};
+
+
+class Create_func_dayofyear : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dayofyear s_singleton;
+
+protected:
+  Create_func_dayofyear() {}
+  virtual ~Create_func_dayofyear() {}
+};
+
+
+class Create_func_decode : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_decode s_singleton;
+
+protected:
+  Create_func_decode() {}
+  virtual ~Create_func_decode() {}
+};
+
+
+class Create_func_degrees : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_degrees s_singleton;
+
+protected:
+  Create_func_degrees() {}
+  virtual ~Create_func_degrees() {}
+};
+
+
+class Create_func_des_decrypt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_des_decrypt s_singleton;
+
+protected:
+  Create_func_des_decrypt() {}
+  virtual ~Create_func_des_decrypt() {}
+};
+
+
+class Create_func_des_encrypt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_des_encrypt s_singleton;
+
+protected:
+  Create_func_des_encrypt() {}
+  virtual ~Create_func_des_encrypt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_dimension : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_dimension s_singleton;
+
+protected:
+  Create_func_dimension() {}
+  virtual ~Create_func_dimension() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_disjoint : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_disjoint s_singleton;
+
+protected:
+  Create_func_disjoint() {}
+  virtual ~Create_func_disjoint() {}
+};
+#endif
+
+
+class Create_func_elt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_elt s_singleton;
+
+protected:
+  Create_func_elt() {}
+  virtual ~Create_func_elt() {}
+};
+
+
+class Create_func_encode : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_encode s_singleton;
+
+protected:
+  Create_func_encode() {}
+  virtual ~Create_func_encode() {}
+};
+
+
+class Create_func_encrypt : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_encrypt s_singleton;
+
+protected:
+  Create_func_encrypt() {}
+  virtual ~Create_func_encrypt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_endpoint : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_endpoint s_singleton;
+
+protected:
+  Create_func_endpoint() {}
+  virtual ~Create_func_endpoint() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_envelope : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_envelope s_singleton;
+
+protected:
+  Create_func_envelope() {}
+  virtual ~Create_func_envelope() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_equals : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_equals s_singleton;
+
+protected:
+  Create_func_equals() {}
+  virtual ~Create_func_equals() {}
+};
+#endif
+
+
+class Create_func_exp : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_exp s_singleton;
+
+protected:
+  Create_func_exp() {}
+  virtual ~Create_func_exp() {}
+};
+
+
+class Create_func_export_set : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_export_set s_singleton;
+
+protected:
+  Create_func_export_set() {}
+  virtual ~Create_func_export_set() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_exteriorring : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_exteriorring s_singleton;
+
+protected:
+  Create_func_exteriorring() {}
+  virtual ~Create_func_exteriorring() {}
+};
+#endif
+
+
+class Create_func_field : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_field s_singleton;
+
+protected:
+  Create_func_field() {}
+  virtual ~Create_func_field() {}
+};
+
+
+class Create_func_find_in_set : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_find_in_set s_singleton;
+
+protected:
+  Create_func_find_in_set() {}
+  virtual ~Create_func_find_in_set() {}
+};
+
+
+class Create_func_floor : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_floor s_singleton;
+
+protected:
+  Create_func_floor() {}
+  virtual ~Create_func_floor() {}
+};
+
+
+class Create_func_format : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_format s_singleton;
+
+protected:
+  Create_func_format() {}
+  virtual ~Create_func_format() {}
+};
+
+
+class Create_func_found_rows : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_found_rows s_singleton;
+
+protected:
+  Create_func_found_rows() {}
+  virtual ~Create_func_found_rows() {}
+};
+
+
+class Create_func_from_days : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_from_days s_singleton;
+
+protected:
+  Create_func_from_days() {}
+  virtual ~Create_func_from_days() {}
+};
+
+
+class Create_func_from_unixtime : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_from_unixtime s_singleton;
+
+protected:
+  Create_func_from_unixtime() {}
+  virtual ~Create_func_from_unixtime() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometry_from_text : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_geometry_from_text s_singleton;
+
+protected:
+  Create_func_geometry_from_text() {}
+  virtual ~Create_func_geometry_from_text() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometry_from_wkb : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_geometry_from_wkb s_singleton;
+
+protected:
+  Create_func_geometry_from_wkb() {}
+  virtual ~Create_func_geometry_from_wkb() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometry_type : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_geometry_type s_singleton;
+
+protected:
+  Create_func_geometry_type() {}
+  virtual ~Create_func_geometry_type() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_geometryn : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_geometryn s_singleton;
+
+protected:
+  Create_func_geometryn() {}
+  virtual ~Create_func_geometryn() {}
+};
+#endif
+
+
+class Create_func_get_lock : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_get_lock s_singleton;
+
+protected:
+  Create_func_get_lock() {}
+  virtual ~Create_func_get_lock() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_glength : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_glength s_singleton;
+
+protected:
+  Create_func_glength() {}
+  virtual ~Create_func_glength() {}
+};
+#endif
+
+
+class Create_func_greatest : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_greatest s_singleton;
+
+protected:
+  Create_func_greatest() {}
+  virtual ~Create_func_greatest() {}
+};
+
+
+class Create_func_hex : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_hex s_singleton;
+
+protected:
+  Create_func_hex() {}
+  virtual ~Create_func_hex() {}
+};
+
+
+class Create_func_ifnull : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_ifnull s_singleton;
+
+protected:
+  Create_func_ifnull() {}
+  virtual ~Create_func_ifnull() {}
+};
+
+
+class Create_func_inet_ntoa : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_inet_ntoa s_singleton;
+
+protected:
+  Create_func_inet_ntoa() {}
+  virtual ~Create_func_inet_ntoa() {}
+};
+
+
+class Create_func_inet_aton : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_inet_aton s_singleton;
+
+protected:
+  Create_func_inet_aton() {}
+  virtual ~Create_func_inet_aton() {}
+};
+
+
+class Create_func_instr : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_instr s_singleton;
+
+protected:
+  Create_func_instr() {}
+  virtual ~Create_func_instr() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_interiorringn : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_interiorringn s_singleton;
+
+protected:
+  Create_func_interiorringn() {}
+  virtual ~Create_func_interiorringn() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_intersects : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_intersects s_singleton;
+
+protected:
+  Create_func_intersects() {}
+  virtual ~Create_func_intersects() {}
+};
+#endif
+
+
+class Create_func_is_free_lock : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_is_free_lock s_singleton;
+
+protected:
+  Create_func_is_free_lock() {}
+  virtual ~Create_func_is_free_lock() {}
+};
+
+
+class Create_func_is_used_lock : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_is_used_lock s_singleton;
+
+protected:
+  Create_func_is_used_lock() {}
+  virtual ~Create_func_is_used_lock() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_isclosed : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_isclosed s_singleton;
+
+protected:
+  Create_func_isclosed() {}
+  virtual ~Create_func_isclosed() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_isempty : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_isempty s_singleton;
+
+protected:
+  Create_func_isempty() {}
+  virtual ~Create_func_isempty() {}
+};
+#endif
+
+
+class Create_func_isnull : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_isnull s_singleton;
+
+protected:
+  Create_func_isnull() {}
+  virtual ~Create_func_isnull() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_issimple : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_issimple s_singleton;
+
+protected:
+  Create_func_issimple() {}
+  virtual ~Create_func_issimple() {}
+};
+#endif
+
+
+class Create_func_last_day : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_last_day s_singleton;
+
+protected:
+  Create_func_last_day() {}
+  virtual ~Create_func_last_day() {}
+};
+
+
+class Create_func_last_insert_id : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_last_insert_id s_singleton;
+
+protected:
+  Create_func_last_insert_id() {}
+  virtual ~Create_func_last_insert_id() {}
+};
+
+
+class Create_func_lcase : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_lcase s_singleton;
+
+protected:
+  Create_func_lcase() {}
+  virtual ~Create_func_lcase() {}
+};
+
+
+class Create_func_least : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_least s_singleton;
+
+protected:
+  Create_func_least() {}
+  virtual ~Create_func_least() {}
+};
+
+
+class Create_func_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_length s_singleton;
+
+protected:
+  Create_func_length() {}
+  virtual ~Create_func_length() {}
+};
+
+
+class Create_func_ln : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ln s_singleton;
+
+protected:
+  Create_func_ln() {}
+  virtual ~Create_func_ln() {}
+};
+
+
+class Create_func_load_file : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_load_file s_singleton;
+
+protected:
+  Create_func_load_file() {}
+  virtual ~Create_func_load_file() {}
+};
+
+
+class Create_func_locate : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_locate s_singleton;
+
+protected:
+  Create_func_locate() {}
+  virtual ~Create_func_locate() {}
+};
+
+
+class Create_func_log : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_log s_singleton;
+
+protected:
+  Create_func_log() {}
+  virtual ~Create_func_log() {}
+};
+
+
+class Create_func_log10 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_log10 s_singleton;
+
+protected:
+  Create_func_log10() {}
+  virtual ~Create_func_log10() {}
+};
+
+
+class Create_func_log2 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_log2 s_singleton;
+
+protected:
+  Create_func_log2() {}
+  virtual ~Create_func_log2() {}
+};
+
+
+class Create_func_lpad : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_lpad s_singleton;
+
+protected:
+  Create_func_lpad() {}
+  virtual ~Create_func_lpad() {}
+};
+
+
+class Create_func_ltrim : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ltrim s_singleton;
+
+protected:
+  Create_func_ltrim() {}
+  virtual ~Create_func_ltrim() {}
+};
+
+
+class Create_func_makedate : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_makedate s_singleton;
+
+protected:
+  Create_func_makedate() {}
+  virtual ~Create_func_makedate() {}
+};
+
+
+class Create_func_maketime : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_maketime s_singleton;
+
+protected:
+  Create_func_maketime() {}
+  virtual ~Create_func_maketime() {}
+};
+
+
+class Create_func_make_set : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_make_set s_singleton;
+
+protected:
+  Create_func_make_set() {}
+  virtual ~Create_func_make_set() {}
+};
+
+
+class Create_func_master_pos_wait : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_master_pos_wait s_singleton;
+
+protected:
+  Create_func_master_pos_wait() {}
+  virtual ~Create_func_master_pos_wait() {}
+};
+
+
+class Create_func_md5 : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_md5 s_singleton;
+
+protected:
+  Create_func_md5() {}
+  virtual ~Create_func_md5() {}
+};
+
+
+class Create_func_monthname : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_monthname s_singleton;
+
+protected:
+  Create_func_monthname() {}
+  virtual ~Create_func_monthname() {}
+};
+
+
+class Create_func_name_const : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_name_const s_singleton;
+
+protected:
+  Create_func_name_const() {}
+  virtual ~Create_func_name_const() {}
+};
+
+
+class Create_func_nullif : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_nullif s_singleton;
+
+protected:
+  Create_func_nullif() {}
+  virtual ~Create_func_nullif() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_numgeometries : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_numgeometries s_singleton;
+
+protected:
+  Create_func_numgeometries() {}
+  virtual ~Create_func_numgeometries() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_numinteriorring : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_numinteriorring s_singleton;
+
+protected:
+  Create_func_numinteriorring() {}
+  virtual ~Create_func_numinteriorring() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_numpoints : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_numpoints s_singleton;
+
+protected:
+  Create_func_numpoints() {}
+  virtual ~Create_func_numpoints() {}
+};
+#endif
+
+
+class Create_func_oct : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_oct s_singleton;
+
+protected:
+  Create_func_oct() {}
+  virtual ~Create_func_oct() {}
+};
+
+
+class Create_func_ord : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ord s_singleton;
+
+protected:
+  Create_func_ord() {}
+  virtual ~Create_func_ord() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_overlaps : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_overlaps s_singleton;
+
+protected:
+  Create_func_overlaps() {}
+  virtual ~Create_func_overlaps() {}
+};
+#endif
+
+
+class Create_func_period_add : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_period_add s_singleton;
+
+protected:
+  Create_func_period_add() {}
+  virtual ~Create_func_period_add() {}
+};
+
+
+class Create_func_period_diff : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_period_diff s_singleton;
+
+protected:
+  Create_func_period_diff() {}
+  virtual ~Create_func_period_diff() {}
+};
+
+
+class Create_func_pi : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_pi s_singleton;
+
+protected:
+  Create_func_pi() {}
+  virtual ~Create_func_pi() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_pointn : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_pointn s_singleton;
+
+protected:
+  Create_func_pointn() {}
+  virtual ~Create_func_pointn() {}
+};
+#endif
+
+
+class Create_func_pow : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_pow s_singleton;
+
+protected:
+  Create_func_pow() {}
+  virtual ~Create_func_pow() {}
+};
+
+
+class Create_func_quote : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_quote s_singleton;
+
+protected:
+  Create_func_quote() {}
+  virtual ~Create_func_quote() {}
+};
+
+
+class Create_func_radians : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_radians s_singleton;
+
+protected:
+  Create_func_radians() {}
+  virtual ~Create_func_radians() {}
+};
+
+
+class Create_func_rand : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_rand s_singleton;
+
+protected:
+  Create_func_rand() {}
+  virtual ~Create_func_rand() {}
+};
+
+
+class Create_func_release_lock : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_release_lock s_singleton;
+
+protected:
+  Create_func_release_lock() {}
+  virtual ~Create_func_release_lock() {}
+};
+
+
+class Create_func_reverse : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_reverse s_singleton;
+
+protected:
+  Create_func_reverse() {}
+  virtual ~Create_func_reverse() {}
+};
+
+
+class Create_func_round : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_round s_singleton;
+
+protected:
+  Create_func_round() {}
+  virtual ~Create_func_round() {}
+};
+
+
+class Create_func_row_count : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_row_count s_singleton;
+
+protected:
+  Create_func_row_count() {}
+  virtual ~Create_func_row_count() {}
+};
+
+
+class Create_func_rpad : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_rpad s_singleton;
+
+protected:
+  Create_func_rpad() {}
+  virtual ~Create_func_rpad() {}
+};
+
+
+class Create_func_rtrim : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_rtrim s_singleton;
+
+protected:
+  Create_func_rtrim() {}
+  virtual ~Create_func_rtrim() {}
+};
+
+
+class Create_func_sec_to_time : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sec_to_time s_singleton;
+
+protected:
+  Create_func_sec_to_time() {}
+  virtual ~Create_func_sec_to_time() {}
+};
+
+
+class Create_func_sha : public Create_func_arg1
 {
-  return new Item_func_abs(a);
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sha s_singleton;
+
+protected:
+  Create_func_sha() {}
+  virtual ~Create_func_sha() {}
+};
+
+
+class Create_func_sign : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sign s_singleton;
+
+protected:
+  Create_func_sign() {}
+  virtual ~Create_func_sign() {}
+};
+
+
+class Create_func_sin : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sin s_singleton;
+
+protected:
+  Create_func_sin() {}
+  virtual ~Create_func_sin() {}
+};
+
+
+class Create_func_sleep : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sleep s_singleton;
+
+protected:
+  Create_func_sleep() {}
+  virtual ~Create_func_sleep() {}
+};
+
+
+class Create_func_soundex : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_soundex s_singleton;
+
+protected:
+  Create_func_soundex() {}
+  virtual ~Create_func_soundex() {}
+};
+
+
+class Create_func_space : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_space s_singleton;
+
+protected:
+  Create_func_space() {}
+  virtual ~Create_func_space() {}
+};
+
+
+class Create_func_sqrt : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_sqrt s_singleton;
+
+protected:
+  Create_func_sqrt() {}
+  virtual ~Create_func_sqrt() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_srid : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_srid s_singleton;
+
+protected:
+  Create_func_srid() {}
+  virtual ~Create_func_srid() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_startpoint : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_startpoint s_singleton;
+
+protected:
+  Create_func_startpoint() {}
+  virtual ~Create_func_startpoint() {}
+};
+#endif
+
+
+class Create_func_str_to_date : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_str_to_date s_singleton;
+
+protected:
+  Create_func_str_to_date() {}
+  virtual ~Create_func_str_to_date() {}
+};
+
+
+class Create_func_strcmp : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_strcmp s_singleton;
+
+protected:
+  Create_func_strcmp() {}
+  virtual ~Create_func_strcmp() {}
+};
+
+
+class Create_func_substr_index : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_substr_index s_singleton;
+
+protected:
+  Create_func_substr_index() {}
+  virtual ~Create_func_substr_index() {}
+};
+
+
+class Create_func_subtime : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_subtime s_singleton;
+
+protected:
+  Create_func_subtime() {}
+  virtual ~Create_func_subtime() {}
+};
+
+
+class Create_func_tan : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_tan s_singleton;
+
+protected:
+  Create_func_tan() {}
+  virtual ~Create_func_tan() {}
+};
+
+
+class Create_func_time_format : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_time_format s_singleton;
+
+protected:
+  Create_func_time_format() {}
+  virtual ~Create_func_time_format() {}
+};
+
+
+class Create_func_time_to_sec : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_time_to_sec s_singleton;
+
+protected:
+  Create_func_time_to_sec() {}
+  virtual ~Create_func_time_to_sec() {}
+};
+
+
+class Create_func_timediff : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_timediff s_singleton;
+
+protected:
+  Create_func_timediff() {}
+  virtual ~Create_func_timediff() {}
+};
+
+
+class Create_func_to_days : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_to_days s_singleton;
+
+protected:
+  Create_func_to_days() {}
+  virtual ~Create_func_to_days() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_touches : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_touches s_singleton;
+
+protected:
+  Create_func_touches() {}
+  virtual ~Create_func_touches() {}
+};
+#endif
+
+
+class Create_func_ucase : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_ucase s_singleton;
+
+protected:
+  Create_func_ucase() {}
+  virtual ~Create_func_ucase() {}
+};
+
+
+class Create_func_uncompress : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_uncompress s_singleton;
+
+protected:
+  Create_func_uncompress() {}
+  virtual ~Create_func_uncompress() {}
+};
+
+
+class Create_func_uncompressed_length : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_uncompressed_length s_singleton;
+
+protected:
+  Create_func_uncompressed_length() {}
+  virtual ~Create_func_uncompressed_length() {}
+};
+
+
+class Create_func_unhex : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_unhex s_singleton;
+
+protected:
+  Create_func_unhex() {}
+  virtual ~Create_func_unhex() {}
+};
+
+
+class Create_func_unix_timestamp : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_unix_timestamp s_singleton;
+
+protected:
+  Create_func_unix_timestamp() {}
+  virtual ~Create_func_unix_timestamp() {}
+};
+
+
+class Create_func_uuid : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_uuid s_singleton;
+
+protected:
+  Create_func_uuid() {}
+  virtual ~Create_func_uuid() {}
+};
+
+
+class Create_func_version : public Create_func_arg0
+{
+public:
+  virtual Item* create(THD *thd);
+
+  static Create_func_version s_singleton;
+
+protected:
+  Create_func_version() {}
+  virtual ~Create_func_version() {}
+};
+
+
+class Create_func_weekday : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_weekday s_singleton;
+
+protected:
+  Create_func_weekday() {}
+  virtual ~Create_func_weekday() {}
+};
+
+
+class Create_func_weekofyear : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_weekofyear s_singleton;
+
+protected:
+  Create_func_weekofyear() {}
+  virtual ~Create_func_weekofyear() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_within : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_within s_singleton;
+
+protected:
+  Create_func_within() {}
+  virtual ~Create_func_within() {}
+};
+#endif
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_x : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_x s_singleton;
+
+protected:
+  Create_func_x() {}
+  virtual ~Create_func_x() {}
+};
+#endif
+
+
+class Create_func_xml_extractvalue : public Create_func_arg2
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_xml_extractvalue s_singleton;
+
+protected:
+  Create_func_xml_extractvalue() {}
+  virtual ~Create_func_xml_extractvalue() {}
+};
+
+
+class Create_func_xml_update : public Create_func_arg3
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1, Item *arg2, Item *arg3);
+
+  static Create_func_xml_update s_singleton;
+
+protected:
+  Create_func_xml_update() {}
+  virtual ~Create_func_xml_update() {}
+};
+
+
+#ifdef HAVE_SPATIAL
+class Create_func_y : public Create_func_arg1
+{
+public:
+  virtual Item* create(THD *thd, Item *arg1);
+
+  static Create_func_y s_singleton;
+
+protected:
+  Create_func_y() {}
+  virtual ~Create_func_y() {}
+};
+#endif
+
+
+class Create_func_year_week : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  static Create_func_year_week s_singleton;
+
+protected:
+  Create_func_year_week() {}
+  virtual ~Create_func_year_week() {}
+};
+
+
+/*
+=============================================================================
+  IMPLEMENTATION
+=============================================================================
+*/
+
+#ifndef HAVE_SPATIAL
+Create_func_no_geom Create_func_no_geom::s_singleton;
+
+Item*
+Create_func_no_geom::create(THD * /* unused */,
+                            LEX_STRING /* unused */,
+                            List<Item> * /* unused */)
+{
+  /* FIXME: error message can't be translated. */
+  my_error(ER_FEATURE_DISABLED, MYF(0),
+           sym_group_geom.name, sym_group_geom.needed_define);
+  return NULL;
 }
+#endif
 
-Item *create_func_acos(Item* a)
+
+Item*
+Create_qfunc::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_acos(a);
+  LEX_STRING db;
+  if (thd->copy_db_to(&db.str, &db.length))
+    return NULL;
+
+  return create(thd, db, name, item_list);
 }
 
-Item *create_func_aes_encrypt(Item* a, Item* b)
+
+#ifdef HAVE_DLOPEN
+Create_udf_func Create_udf_func::s_singleton;
+
+Item*
+Create_udf_func::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_aes_encrypt(a, b);
+  udf_func *udf= find_udf(name.str, name.length);
+  DBUG_ASSERT(udf);
+  return create(thd, udf, item_list);
 }
 
-Item *create_func_aes_decrypt(Item* a, Item* b)
+
+Item*
+Create_udf_func::create(THD *thd, udf_func *udf, List<Item> *item_list)
 {
-  return new Item_func_aes_decrypt(a, b);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+#ifdef HAVE_ROW_BASED_REPLICATION
+  thd->lex->binlog_row_based_if_mixed= TRUE;
+#endif
+
+  DBUG_ASSERT(   (udf->type == UDFTYPE_FUNCTION)
+              || (udf->type == UDFTYPE_AGGREGATE));
+
+  switch(udf->returns) {
+  case STRING_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_str(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_str(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_str(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_str(udf);
+    }
+    break;
+  }
+  case REAL_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_float(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_float(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_float(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_float(udf);
+    }
+    break;
+  }
+  case INT_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_int(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_int(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_int(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_int(udf);
+    }
+    break;
+  }
+  case DECIMAL_RESULT:
+  {
+    if (udf->type == UDFTYPE_FUNCTION)
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_func_udf_decimal(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_func_udf_decimal(udf);
+    }
+    else
+    {
+      if (arg_count)
+        func= new (thd->mem_root) Item_sum_udf_decimal(udf, *item_list);
+      else
+        func= new (thd->mem_root) Item_sum_udf_decimal(udf);
+    }
+    break;
+  }
+  default:
+  {
+    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "UDF return type");
+  }
+  }
+  return func;
 }
+#endif
+
+
+Create_sp_func Create_sp_func::s_singleton;
 
-Item *create_func_ascii(Item* a)
+Item*
+Create_sp_func::create(THD *thd, LEX_STRING db, LEX_STRING name,
+                       List<Item> *item_list)
 {
-  return new Item_func_ascii(a);
+  int arg_count= 0;
+  Item *func= NULL;
+  LEX *lex= thd->lex;
+  sp_name *qname= new (thd->mem_root) sp_name(db, name);
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  qname->init_qname(thd);
+  sp_add_used_routine(lex, thd, qname, TYPE_ENUM_FUNCTION);
+
+  if (arg_count > 0)
+    func= new (thd->mem_root) Item_func_sp(lex->current_context(), qname,
+                                           *item_list);
+  else
+    func= new (thd->mem_root) Item_func_sp(lex->current_context(), qname);
+
+  lex->safe_to_cache_query= 0;
+  return func;
 }
 
-Item *create_func_ord(Item* a)
+
+Item*
+Create_func_arg0::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_ord(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count != 0)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return create(thd);
 }
 
-Item *create_func_asin(Item* a)
+
+Item*
+Create_func_arg1::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_asin(a);
+  int arg_count= 0;
+
+  if (item_list)
+    arg_count= item_list->elements;
+
+  if (arg_count != 1)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  return create(thd, param_1);
 }
 
-Item *create_func_bin(Item* a)
+
+Item*
+Create_func_arg2::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_conv(a,new Item_int((int32) 10,2),
-			    new Item_int((int32) 2,1));
+  int arg_count= 0;
+
+  if (item_list)
+    arg_count= item_list->elements;
+
+  if (arg_count != 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  Item *param_2= item_list->pop();
+  return create(thd, param_1, param_2);
 }
 
-Item *create_func_bit_count(Item* a)
+
+Item*
+Create_func_arg3::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_bit_count(a);
+  int arg_count= 0;
+
+  if (item_list)
+    arg_count= item_list->elements;
+
+  if (arg_count != 3)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  Item *param_2= item_list->pop();
+  Item *param_3= item_list->pop();
+  return create(thd, param_1, param_2, param_3);
 }
 
-Item *create_func_ceiling(Item* a)
+
+Create_func_abs Create_func_abs::s_singleton;
+
+Item*
+Create_func_abs::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ceiling(a);
+  return new (thd->mem_root) Item_func_abs(arg1);
 }
 
-Item *create_func_connection_id(void)
+
+Create_func_acos Create_func_acos::s_singleton;
+
+Item*
+Create_func_acos::create(THD *thd, Item *arg1)
 {
-  current_thd->lex->safe_to_cache_query= 0;
-  return new Item_func_connection_id();
+  return new (thd->mem_root) Item_func_acos(arg1);
 }
 
-Item *create_func_conv(Item* a, Item *b, Item *c)
+
+Create_func_addtime Create_func_addtime::s_singleton;
+
+Item*
+Create_func_addtime::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_conv(a,b,c);
+  return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 0);
 }
 
-Item *create_func_cos(Item* a)
+
+Create_func_aes_encrypt Create_func_aes_encrypt::s_singleton;
+
+Item*
+Create_func_aes_encrypt::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_cos(a);
+  return new (thd->mem_root) Item_func_aes_encrypt(arg1, arg2);
 }
 
-Item *create_func_cot(Item* a)
+
+Create_func_aes_decrypt Create_func_aes_decrypt::s_singleton;
+
+Item*
+Create_func_aes_decrypt::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_div(new Item_int((char*) "1",1,1),
-			   new Item_func_tan(a));
+  return new (thd->mem_root) Item_func_aes_decrypt(arg1, arg2);
 }
 
-Item *create_func_date_format(Item* a,Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_area Create_func_area::s_singleton;
+
+Item*
+Create_func_area::create(THD *thd, Item *arg1)
 {
-  return new Item_func_date_format(a,b,0);
+  return new (thd->mem_root) Item_func_area(arg1);
 }
+#endif
 
-Item *create_func_dayofmonth(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_as_wkb Create_func_as_wkb::s_singleton;
+
+Item*
+Create_func_as_wkb::create(THD *thd, Item *arg1)
 {
-  return new Item_func_dayofmonth(a);
+  return new (thd->mem_root) Item_func_as_wkb(arg1);
 }
+#endif
+
 
-Item *create_func_dayofweek(Item* a)
+#ifdef HAVE_SPATIAL
+Create_func_as_wkt Create_func_as_wkt::s_singleton;
+
+Item*
+Create_func_as_wkt::create(THD *thd, Item *arg1)
 {
-  return new Item_func_weekday(a, 1);
+  return new (thd->mem_root) Item_func_as_wkt(arg1);
+}
+#endif
+
+
+Create_func_asin Create_func_asin::s_singleton;
+
+Item*
+Create_func_asin::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_asin(arg1);
+}
+
+
+Create_func_atan Create_func_atan::s_singleton;
+
+Item*
+Create_func_atan::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item* func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_atan(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_atan(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_dayofyear(Item* a)
+
+Create_func_benchmark Create_func_benchmark::s_singleton;
+
+Item*
+Create_func_benchmark::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_dayofyear(a);
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg1->type() != Item::INT_ITEM) || ! arg1->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "BENCHMARK");
+    return NULL;
+  }
+
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_benchmark(arg1->val_int(), arg2);
 }
 
-Item *create_func_dayname(Item* a)
+
+Create_func_bin Create_func_bin::s_singleton;
+
+Item*
+Create_func_bin::create(THD *thd, Item *arg1)
 {
-  return new Item_func_dayname(a);
+  Item *i10= new (thd->mem_root) Item_int((int32) 10,2);
+  Item *i2= new (thd->mem_root) Item_int((int32) 2,1);
+  return new (thd->mem_root) Item_func_conv(arg1, i10, i2);
 }
 
-Item *create_func_degrees(Item *a)
+
+Create_func_bit_count Create_func_bit_count::s_singleton;
+
+Item*
+Create_func_bit_count::create(THD *thd, Item *arg1)
 {
-  return new Item_func_units((char*) "degrees",a,180/M_PI,0.0);
+  return new (thd->mem_root) Item_func_bit_count(arg1);
 }
 
-Item *create_func_exp(Item* a)
+
+Create_func_bit_length Create_func_bit_length::s_singleton;
+
+Item*
+Create_func_bit_length::create(THD *thd, Item *arg1)
 {
-  return new Item_func_exp(a);
+  return new (thd->mem_root) Item_func_bit_length(arg1);
 }
 
-Item *create_func_find_in_set(Item* a, Item *b)
+
+Create_func_ceiling Create_func_ceiling::s_singleton;
+
+Item*
+Create_func_ceiling::create(THD *thd, Item *arg1)
 {
-  return new Item_func_find_in_set(a, b);
+  return new (thd->mem_root) Item_func_ceiling(arg1);
 }
 
-Item *create_func_floor(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_centroid Create_func_centroid::s_singleton;
+
+Item*
+Create_func_centroid::create(THD *thd, Item *arg1)
 {
-  return new Item_func_floor(a);
+  return new (thd->mem_root) Item_func_centroid(arg1);
 }
+#endif
 
-Item *create_func_found_rows(void)
+
+Create_func_char_length Create_func_char_length::s_singleton;
+
+Item*
+Create_func_char_length::create(THD *thd, Item *arg1)
 {
-  THD *thd=current_thd;
-  thd->lex->safe_to_cache_query= 0;
-  return new Item_func_found_rows();
+  return new (thd->mem_root) Item_func_char_length(arg1);
 }
 
-Item *create_func_from_days(Item* a)
+
+Create_func_coercibility Create_func_coercibility::s_singleton;
+
+Item*
+Create_func_coercibility::create(THD *thd, Item *arg1)
 {
-  return new Item_func_from_days(a);
+  return new (thd->mem_root) Item_func_coercibility(arg1);
 }
 
-Item *create_func_get_lock(Item* a, Item *b)
+
+Create_func_concat Create_func_concat::s_singleton;
+
+Item*
+Create_func_concat::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_get_lock(a, b);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 1)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_concat(*item_list);
 }
 
-Item *create_func_hex(Item *a)
+
+Create_func_concat_ws Create_func_concat_ws::s_singleton;
+
+Item*
+Create_func_concat_ws::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_hex(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  /* "WS" stands for "With Separator": this function takes 2+ arguments */
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_concat_ws(*item_list);
 }
 
-Item *create_func_inet_ntoa(Item* a)
+
+Create_func_compress Create_func_compress::s_singleton;
+
+Item*
+Create_func_compress::create(THD *thd, Item *arg1)
 {
-  return new Item_func_inet_ntoa(a);
+  return new (thd->mem_root) Item_func_compress(arg1);
 }
 
-Item *create_func_inet_aton(Item* a)
+
+Create_func_connection_id Create_func_connection_id::s_singleton;
+
+Item*
+Create_func_connection_id::create(THD *thd)
 {
-  return new Item_func_inet_aton(a);
+  thd->lex->safe_to_cache_query= 0;
+  return new (thd->mem_root) Item_func_connection_id();
 }
 
 
-Item *create_func_ifnull(Item* a, Item *b)
+#ifdef HAVE_SPATIAL
+Create_func_contains Create_func_contains::s_singleton;
+
+Item*
+Create_func_contains::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_ifnull(a,b);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_CONTAINS_FUNC);
 }
+#endif
+
 
-Item *create_func_nullif(Item* a, Item *b)
+Create_func_conv Create_func_conv::s_singleton;
+
+Item*
+Create_func_conv::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_nullif(a,b);
+  return new (thd->mem_root) Item_func_conv(arg1, arg2, arg3);
 }
 
-Item *create_func_locate(Item* a, Item *b)
+
+Create_func_convert_tz Create_func_convert_tz::s_singleton;
+
+Item*
+Create_func_convert_tz::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_locate(b,a);
+  if (thd->lex->add_time_zone_tables_to_query_tables(thd))
+    return NULL;
+
+  return new (thd->mem_root) Item_func_convert_tz(arg1, arg2, arg3);
 }
 
-Item *create_func_instr(Item* a, Item *b)
+
+Create_func_cos Create_func_cos::s_singleton;
+
+Item*
+Create_func_cos::create(THD *thd, Item *arg1)
 {
-  return new Item_func_locate(a,b);
+  return new (thd->mem_root) Item_func_cos(arg1);
 }
 
-Item *create_func_isnull(Item* a)
+
+Create_func_cot Create_func_cot::s_singleton;
+
+Item*
+Create_func_cot::create(THD *thd, Item *arg1)
 {
-  return new Item_func_isnull(a);
+  Item *i1= new (thd->mem_root) Item_int((char*) "1", 1, 1);
+  Item *i2= new (thd->mem_root) Item_func_tan(arg1);
+  return new (thd->mem_root) Item_func_div(i1, i2);
 }
 
-Item *create_func_lcase(Item* a)
+
+Create_func_crc32 Create_func_crc32::s_singleton;
+
+Item*
+Create_func_crc32::create(THD *thd, Item *arg1)
 {
-  return new Item_func_lcase(a);
+  return new (thd->mem_root) Item_func_crc32(arg1);
 }
 
-Item *create_func_length(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_crosses Create_func_crosses::s_singleton;
+
+Item*
+Create_func_crosses::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_length(a);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_CROSSES_FUNC);
 }
+#endif
 
-Item *create_func_bit_length(Item* a)
+
+Create_func_date_format Create_func_date_format::s_singleton;
+
+Item*
+Create_func_date_format::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_bit_length(a);
+  return new (thd->mem_root) Item_func_date_format(arg1, arg2, 0);
 }
 
-Item *create_func_coercibility(Item* a)
+
+Create_func_datediff Create_func_datediff::s_singleton;
+
+Item*
+Create_func_datediff::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_coercibility(a);
+  Item *i1= new (thd->mem_root) Item_func_to_days(arg1);
+  Item *i2= new (thd->mem_root) Item_func_to_days(arg2);
+
+  return new (thd->mem_root) Item_func_minus(i1, i2);
 }
 
-Item *create_func_char_length(Item* a)
+
+Create_func_dayname Create_func_dayname::s_singleton;
+
+Item*
+Create_func_dayname::create(THD *thd, Item *arg1)
 {
-  return new Item_func_char_length(a);
+  return new (thd->mem_root) Item_func_dayname(arg1);
 }
 
-Item *create_func_ln(Item* a)
+
+Create_func_dayofmonth Create_func_dayofmonth::s_singleton;
+
+Item*
+Create_func_dayofmonth::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ln(a);
+  return new (thd->mem_root) Item_func_dayofmonth(arg1);
 }
 
-Item *create_func_log2(Item* a)
+
+Create_func_dayofweek Create_func_dayofweek::s_singleton;
+
+Item*
+Create_func_dayofweek::create(THD *thd, Item *arg1)
 {
-  return new Item_func_log2(a);
+  return new (thd->mem_root) Item_func_weekday(arg1, 1);
 }
 
-Item *create_func_log10(Item* a)
+
+Create_func_dayofyear Create_func_dayofyear::s_singleton;
+
+Item*
+Create_func_dayofyear::create(THD *thd, Item *arg1)
 {
-  return new Item_func_log10(a);
+  return new (thd->mem_root) Item_func_dayofyear(arg1);
 }
 
-Item *create_func_lpad(Item* a, Item *b, Item *c)
+
+Create_func_decode Create_func_decode::s_singleton;
+
+Item*
+Create_func_decode::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_lpad(a,b,c);
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg2->type() != Item::STRING_ITEM) || ! arg2->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "DECODE");
+    return NULL;
+  }
+
+  String dummy;
+  String *val = arg2->val_str(& dummy);
+  DBUG_ASSERT(val);
+  return new (thd->mem_root) Item_func_decode(arg1, val->c_ptr());
 }
 
-Item *create_func_ltrim(Item* a)
+
+Create_func_degrees Create_func_degrees::s_singleton;
+
+Item*
+Create_func_degrees::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ltrim(a);
+  return new (thd->mem_root) Item_func_units((char*) "degrees", arg1,
+                                             180/M_PI, 0.0);
 }
 
-Item *create_func_md5(Item* a)
+
+Create_func_des_decrypt Create_func_des_decrypt::s_singleton;
+
+Item*
+Create_func_des_decrypt::create(THD *thd, LEX_STRING name,
+                                List<Item> *item_list)
 {
-  return new Item_func_md5(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_decrypt(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_decrypt(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_mod(Item* a, Item *b)
+
+Create_func_des_encrypt Create_func_des_encrypt::s_singleton;
+
+Item*
+Create_func_des_encrypt::create(THD *thd, LEX_STRING name,
+                                List<Item> *item_list)
 {
-  return new Item_func_mod(a,b);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_encrypt(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_des_encrypt(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_name_const(Item *a, Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_dimension Create_func_dimension::s_singleton;
+
+Item*
+Create_func_dimension::create(THD *thd, Item *arg1)
 {
-  return new Item_name_const(a,b);
+  return new (thd->mem_root) Item_func_dimension(arg1);
 }
+#endif
+
 
-Item *create_func_monthname(Item* a)
+#ifdef HAVE_SPATIAL
+Create_func_disjoint Create_func_disjoint::s_singleton;
+
+Item*
+Create_func_disjoint::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_monthname(a);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_DISJOINT_FUNC);
 }
+#endif
+
 
-Item *create_func_month(Item* a)
+Create_func_elt Create_func_elt::s_singleton;
+
+Item*
+Create_func_elt::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_month(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_elt(*item_list);
 }
 
-Item *create_func_oct(Item *a)
+
+Create_func_encode Create_func_encode::s_singleton;
+
+Item*
+Create_func_encode::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_conv(a,new Item_int((int32) 10,2),
-			    new Item_int((int32) 8,1));
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg2->type() != Item::STRING_ITEM) || ! arg2->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "ENCODE");
+    return NULL;
+  }
+
+  String dummy;
+  String *val = arg2->val_str(& dummy);
+  DBUG_ASSERT(val);
+  return new (thd->mem_root) Item_func_encode(arg1, val->c_ptr());
 }
 
-Item *create_func_period_add(Item* a, Item *b)
+
+Create_func_encrypt Create_func_encrypt::s_singleton;
+
+Item*
+Create_func_encrypt::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_period_add(a,b);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_encrypt(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_encrypt(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_period_diff(Item* a, Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_endpoint Create_func_endpoint::s_singleton;
+
+Item*
+Create_func_endpoint::create(THD *thd, Item *arg1)
 {
-  return new Item_func_period_diff(a,b);
+  return new (thd->mem_root) Item_func_spatial_decomp(arg1,
+                                                      Item_func::SP_ENDPOINT);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_envelope Create_func_envelope::s_singleton;
 
-Item *create_func_pi(void)
+Item*
+Create_func_envelope::create(THD *thd, Item *arg1)
 {
-  return new Item_static_float_func("pi()", M_PI, 6, 8);
+  return new (thd->mem_root) Item_func_envelope(arg1);
 }
+#endif
+
 
-Item *create_func_pow(Item* a, Item *b)
+#ifdef HAVE_SPATIAL
+Create_func_equals Create_func_equals::s_singleton;
+
+Item*
+Create_func_equals::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_pow(a,b);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_EQUALS_FUNC);
 }
+#endif
+
+
+Create_func_exp Create_func_exp::s_singleton;
 
-Item *create_func_radians(Item *a)
+Item*
+Create_func_exp::create(THD *thd, Item *arg1)
 {
-  return new Item_func_units((char*) "radians",a,M_PI/180,0.0);
+  return new (thd->mem_root) Item_func_exp(arg1);
 }
 
-Item *create_func_release_lock(Item* a)
+
+Create_func_export_set Create_func_export_set::s_singleton;
+
+Item*
+Create_func_export_set::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_release_lock(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 3:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    func= new (thd->mem_root) Item_func_export_set(param_1, param_2, param_3);
+    break;
+  }
+  case 4:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    Item *param_4= item_list->pop();
+    func= new (thd->mem_root) Item_func_export_set(param_1, param_2, param_3,
+                                                   param_4);
+    break;
+  }
+  case 5:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    Item *param_4= item_list->pop();
+    Item *param_5= item_list->pop();
+    func= new (thd->mem_root) Item_func_export_set(param_1, param_2, param_3,
+                                                   param_4, param_5);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_repeat(Item* a, Item *b)
+
+#ifdef HAVE_SPATIAL
+Create_func_exteriorring Create_func_exteriorring::s_singleton;
+
+Item*
+Create_func_exteriorring::create(THD *thd, Item *arg1)
 {
-  return new Item_func_repeat(a,b);
+  return new (thd->mem_root) Item_func_spatial_decomp(arg1,
+                                                      Item_func::SP_EXTERIORRING);
 }
+#endif
 
-Item *create_func_reverse(Item* a)
+
+Create_func_field Create_func_field::s_singleton;
+
+Item*
+Create_func_field::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_reverse(a);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_field(*item_list);
 }
 
-Item *create_func_rpad(Item* a, Item *b, Item *c)
+
+Create_func_find_in_set Create_func_find_in_set::s_singleton;
+
+Item*
+Create_func_find_in_set::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_rpad(a,b,c);
+  return new (thd->mem_root) Item_func_find_in_set(arg1, arg2);
 }
 
-Item *create_func_rtrim(Item* a)
+
+Create_func_floor Create_func_floor::s_singleton;
+
+Item*
+Create_func_floor::create(THD *thd, Item *arg1)
 {
-  return new Item_func_rtrim(a);
+  return new (thd->mem_root) Item_func_floor(arg1);
 }
 
-Item *create_func_sec_to_time(Item* a)
+
+Create_func_format Create_func_format::s_singleton;
+
+Item*
+Create_func_format::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_sec_to_time(a);
+  /* TODO: Known limitation, see Bug#22684 */
+  if ((arg2->type() != Item::INT_ITEM) || ! arg2->basic_const_item())
+  {
+    my_error(ER_WRONG_PARAMETERS_TO_NATIVE_FCT, MYF(0), "FORMAT");
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_format(arg1, arg2->val_int());
 }
 
-Item *create_func_sign(Item* a)
+
+Create_func_found_rows Create_func_found_rows::s_singleton;
+
+Item*
+Create_func_found_rows::create(THD *thd)
 {
-  return new Item_func_sign(a);
+  thd->lex->safe_to_cache_query= 0;
+  return new (thd->mem_root) Item_func_found_rows();
 }
 
-Item *create_func_sin(Item* a)
+
+Create_func_from_days Create_func_from_days::s_singleton;
+
+Item*
+Create_func_from_days::create(THD *thd, Item *arg1)
 {
-  return new Item_func_sin(a);
+  return new (thd->mem_root) Item_func_from_days(arg1);
 }
 
-Item *create_func_sha(Item* a)
+
+Create_func_from_unixtime Create_func_from_unixtime::s_singleton;
+
+Item*
+Create_func_from_unixtime::create(THD *thd, LEX_STRING name,
+                                  List<Item> *item_list)
 {
-  return new Item_func_sha(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_from_unixtime(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *ut= new (thd->mem_root) Item_func_from_unixtime(param_1);
+    func= new (thd->mem_root) Item_func_date_format(ut, param_2, 0);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_sleep(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_geometry_from_text Create_func_geometry_from_text::s_singleton;
+
+Item*
+Create_func_geometry_from_text::create(THD *thd, LEX_STRING name,
+                                       List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_sleep(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_text(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_text(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_geometry_from_wkb Create_func_geometry_from_wkb::s_singleton;
 
-Item *create_func_space(Item *a)
+Item*
+Create_func_geometry_from_wkb::create(THD *thd, LEX_STRING name,
+                                      List<Item> *item_list)
 {
-  CHARSET_INFO *cs= current_thd->variables.collation_connection;
-  Item *sp;
+  Item *func= NULL;
+  int arg_count= 0;
 
-  if (cs->mbminlen > 1)
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
   {
-    uint dummy_errors;
-    sp= new Item_string("",0,cs);
-    if (sp)
-      sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors);
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_wkb(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
   }
-  else
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_geometry_from_wkb(param_1, param_2);
+    break;
+  }
+  default:
   {
-    sp= new Item_string(" ",1,cs);
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
   }
-  return sp ? new Item_func_repeat(sp, a) : 0;
+
+  return func;
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_geometry_type Create_func_geometry_type::s_singleton;
 
-Item *create_func_soundex(Item* a)
+Item*
+Create_func_geometry_type::create(THD *thd, Item *arg1)
 {
-  return new Item_func_soundex(a);
+  return new (thd->mem_root) Item_func_geometry_type(arg1);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_geometryn Create_func_geometryn::s_singleton;
 
-Item *create_func_sqrt(Item* a)
+Item*
+Create_func_geometryn::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_sqrt(a);
+  return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2,
+                                                        Item_func::SP_GEOMETRYN);
 }
+#endif
+
+
+Create_func_get_lock Create_func_get_lock::s_singleton;
 
-Item *create_func_strcmp(Item* a, Item *b)
+Item*
+Create_func_get_lock::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_strcmp(a,b);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_get_lock(arg1, arg2);
 }
 
-Item *create_func_tan(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_glength Create_func_glength::s_singleton;
+
+Item*
+Create_func_glength::create(THD *thd, Item *arg1)
 {
-  return new Item_func_tan(a);
+  return new (thd->mem_root) Item_func_glength(arg1);
 }
+#endif
 
-Item *create_func_time_format(Item *a, Item *b)
+
+Create_func_greatest Create_func_greatest::s_singleton;
+
+Item*
+Create_func_greatest::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_date_format(a,b,1);
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_max(*item_list);
 }
 
-Item *create_func_time_to_sec(Item* a)
+
+Create_func_hex Create_func_hex::s_singleton;
+
+Item*
+Create_func_hex::create(THD *thd, Item *arg1)
 {
-  return new Item_func_time_to_sec(a);
+  return new (thd->mem_root) Item_func_hex(arg1);
 }
 
-Item *create_func_to_days(Item* a)
+
+Create_func_ifnull Create_func_ifnull::s_singleton;
+
+Item*
+Create_func_ifnull::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_to_days(a);
+  return new (thd->mem_root) Item_func_ifnull(arg1, arg2);
 }
 
-Item *create_func_ucase(Item* a)
+
+Create_func_inet_ntoa Create_func_inet_ntoa::s_singleton;
+
+Item*
+Create_func_inet_ntoa::create(THD *thd, Item *arg1)
 {
-  return new Item_func_ucase(a);
+  return new (thd->mem_root) Item_func_inet_ntoa(arg1);
 }
 
-Item *create_func_unhex(Item* a)
+
+Create_func_inet_aton Create_func_inet_aton::s_singleton;
+
+Item*
+Create_func_inet_aton::create(THD *thd, Item *arg1)
 {
-  return new Item_func_unhex(a);
+  return new (thd->mem_root) Item_func_inet_aton(arg1);
 }
 
-Item *create_func_uuid(void)
+
+Create_func_instr Create_func_instr::s_singleton;
+
+Item*
+Create_func_instr::create(THD *thd, Item *arg1, Item *arg2)
 {
-  THD *thd= current_thd;
-#ifdef HAVE_ROW_BASED_REPLICATION
-  thd->lex->binlog_row_based_if_mixed= TRUE;
+  return new (thd->mem_root) Item_func_locate(arg1, arg2);
+}
+
+
+#ifdef HAVE_SPATIAL
+Create_func_interiorringn Create_func_interiorringn::s_singleton;
+
+Item*
+Create_func_interiorringn::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2,
+                                                        Item_func::SP_INTERIORRINGN);
+}
 #endif
-  return new(thd->mem_root) Item_func_uuid();
+
+
+#ifdef HAVE_SPATIAL
+Create_func_intersects Create_func_intersects::s_singleton;
+
+Item*
+Create_func_intersects::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_INTERSECTS_FUNC);
 }
+#endif
+
+
+Create_func_is_free_lock Create_func_is_free_lock::s_singleton;
 
-Item *create_func_version(void)
+Item*
+Create_func_is_free_lock::create(THD *thd, Item *arg1)
 {
-  return new Item_static_string_func("version()", server_version,
-			 (uint) strlen(server_version),
-			 system_charset_info, DERIVATION_SYSCONST);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_is_free_lock(arg1);
 }
 
-Item *create_func_weekday(Item* a)
+
+Create_func_is_used_lock Create_func_is_used_lock::s_singleton;
+
+Item*
+Create_func_is_used_lock::create(THD *thd, Item *arg1)
 {
-  return new Item_func_weekday(a, 0);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_is_used_lock(arg1);
 }
 
-Item *create_func_year(Item* a)
+
+#ifdef HAVE_SPATIAL
+Create_func_isclosed Create_func_isclosed::s_singleton;
+
+Item*
+Create_func_isclosed::create(THD *thd, Item *arg1)
 {
-  return new Item_func_year(a);
+  return new (thd->mem_root) Item_func_isclosed(arg1);
 }
+#endif
+
 
-Item *create_load_file(Item* a)
+#ifdef HAVE_SPATIAL
+Create_func_isempty Create_func_isempty::s_singleton;
+
+Item*
+Create_func_isempty::create(THD *thd, Item *arg1)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_load_file(a);
+  return new (thd->mem_root) Item_func_isempty(arg1);
 }
+#endif
 
 
-Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec,
-		       CHARSET_INFO *cs)
+Create_func_isnull Create_func_isnull::s_singleton;
+
+Item*
+Create_func_isnull::create(THD *thd, Item *arg1)
 {
-  Item *res;
-  int tmp_len;
-  LINT_INIT(res);
+  return new (thd->mem_root) Item_func_isnull(arg1);
+}
 
-  switch (cast_type) {
-  case ITEM_CAST_BINARY: 	res= new Item_func_binary(a); break;
-  case ITEM_CAST_SIGNED_INT:	res= new Item_func_signed(a); break;
-  case ITEM_CAST_UNSIGNED_INT:  res= new Item_func_unsigned(a); break;
-  case ITEM_CAST_DATE:		res= new Item_date_typecast(a); break;
-  case ITEM_CAST_TIME:		res= new Item_time_typecast(a); break;
-  case ITEM_CAST_DATETIME:	res= new Item_datetime_typecast(a); break;
-  case ITEM_CAST_DECIMAL:
-    tmp_len= (len>0) ? len : 10;
-    if (tmp_len < dec)
-    {
-      my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
-      return 0;
-    }
-    res= new Item_decimal_typecast(a, tmp_len, dec);
+
+#ifdef HAVE_SPATIAL
+Create_func_issimple Create_func_issimple::s_singleton;
+
+Item*
+Create_func_issimple::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_issimple(arg1);
+}
+#endif
+
+
+Create_func_last_day Create_func_last_day::s_singleton;
+
+Item*
+Create_func_last_day::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_last_day(arg1);
+}
+
+
+Create_func_last_insert_id Create_func_last_insert_id::s_singleton;
+
+Item*
+Create_func_last_insert_id::create(THD *thd, LEX_STRING name,
+                                   List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 0:
+  {
+    func= new (thd->mem_root) Item_func_last_insert_id();
+    thd->lex->safe_to_cache_query= 0;
     break;
-  case ITEM_CAST_CHAR:
-    res= new Item_char_typecast(a, len, cs ? cs : 
-				current_thd->variables.collation_connection);
+  }
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_last_insert_id(param_1);
+    thd->lex->safe_to_cache_query= 0;
     break;
+  }
   default:
-    DBUG_ASSERT(0);
-    res= 0;
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
     break;
   }
-  return res;
+  }
+
+  return func;
+}
+
+
+Create_func_lcase Create_func_lcase::s_singleton;
+
+Item*
+Create_func_lcase::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_lcase(arg1);
+}
+
+
+Create_func_least Create_func_least::s_singleton;
+
+Item*
+Create_func_least::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  return new (thd->mem_root) Item_func_min(*item_list);
+}
+
+
+Create_func_length Create_func_length::s_singleton;
+
+Item*
+Create_func_length::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_length(arg1);
+}
+
+
+Create_func_ln Create_func_ln::s_singleton;
+
+Item*
+Create_func_ln::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_ln(arg1);
+}
+
+
+Create_func_load_file Create_func_load_file::s_singleton;
+
+Item*
+Create_func_load_file::create(THD *thd, Item *arg1)
+{
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_load_file(arg1);
+}
+
+
+Create_func_locate Create_func_locate::s_singleton;
+
+Item*
+Create_func_locate::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    /* Yes, parameters in that order : 2, 1 */
+    func= new (thd->mem_root) Item_func_locate(param_2, param_1);
+    break;
+  }
+  case 3:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    /* Yes, parameters in that order : 2, 1, 3 */
+    func= new (thd->mem_root) Item_func_locate(param_2, param_1, param_3);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+Create_func_log Create_func_log::s_singleton;
+
+Item*
+Create_func_log::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_log(param_1);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_log(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+Create_func_log10 Create_func_log10::s_singleton;
+
+Item*
+Create_func_log10::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_log10(arg1);
+}
+
+
+Create_func_log2 Create_func_log2::s_singleton;
+
+Item*
+Create_func_log2::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_log2(arg1);
+}
+
+
+Create_func_lpad Create_func_lpad::s_singleton;
+
+Item*
+Create_func_lpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
+{
+  return new (thd->mem_root) Item_func_lpad(arg1, arg2, arg3);
+}
+
+
+Create_func_ltrim Create_func_ltrim::s_singleton;
+
+Item*
+Create_func_ltrim::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_ltrim(arg1);
+}
+
+
+Create_func_makedate Create_func_makedate::s_singleton;
+
+Item*
+Create_func_makedate::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_makedate(arg1, arg2);
+}
+
+
+Create_func_maketime Create_func_maketime::s_singleton;
+
+Item*
+Create_func_maketime::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
+{
+  return new (thd->mem_root) Item_func_maketime(arg1, arg2, arg3);
+}
+
+
+Create_func_make_set Create_func_make_set::s_singleton;
+
+Item*
+Create_func_make_set::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  if (arg_count < 2)
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    return NULL;
+  }
+
+  Item *param_1= item_list->pop();
+  return new (thd->mem_root) Item_func_make_set(param_1, *item_list);
 }
 
-Item *create_func_is_free_lock(Item* a)
+
+Create_func_master_pos_wait Create_func_master_pos_wait::s_singleton;
+
+Item*
+Create_func_master_pos_wait::create(THD *thd, LEX_STRING name,
+                                    List<Item> *item_list)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_is_free_lock(a);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_master_pos_wait(param_1, param_2);
+    thd->lex->safe_to_cache_query= 0;
+    break;
+  }
+  case 3:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    Item *param_3= item_list->pop();
+    func= new (thd->mem_root) Item_master_pos_wait(param_1, param_2, param_3);
+    thd->lex->safe_to_cache_query= 0;
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_is_used_lock(Item* a)
+
+Create_func_md5 Create_func_md5::s_singleton;
+
+Item*
+Create_func_md5::create(THD *thd, Item *arg1)
 {
-  current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return new Item_func_is_used_lock(a);
+  return new (thd->mem_root) Item_func_md5(arg1);
 }
 
-Item *create_func_quote(Item* a)
+
+Create_func_monthname Create_func_monthname::s_singleton;
+
+Item*
+Create_func_monthname::create(THD *thd, Item *arg1)
 {
-  return new Item_func_quote(a);
+  return new (thd->mem_root) Item_func_monthname(arg1);
 }
 
-Item *create_func_xml_extractvalue(Item *a, Item *b)
+
+Create_func_name_const Create_func_name_const::s_singleton;
+
+Item*
+Create_func_name_const::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_xml_extractvalue(a, b);
+  return new (thd->mem_root) Item_name_const(arg1, arg2);
 }
 
-Item *create_func_xml_update(Item *a, Item *b, Item *c)
+
+Create_func_nullif Create_func_nullif::s_singleton;
+
+Item*
+Create_func_nullif::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_xml_update(a, b, c);
+  return new (thd->mem_root) Item_func_nullif(arg1, arg2);
 }
 
+
 #ifdef HAVE_SPATIAL
-Item *create_func_as_wkt(Item *a)
+Create_func_numgeometries Create_func_numgeometries::s_singleton;
+
+Item*
+Create_func_numgeometries::create(THD *thd, Item *arg1)
 {
-  return new Item_func_as_wkt(a);
+  return new (thd->mem_root) Item_func_numgeometries(arg1);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_numinteriorring Create_func_numinteriorring::s_singleton;
 
-Item *create_func_as_wkb(Item *a)
+Item*
+Create_func_numinteriorring::create(THD *thd, Item *arg1)
 {
-  return new Item_func_as_wkb(a);
+  return new (thd->mem_root) Item_func_numinteriorring(arg1);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_numpoints Create_func_numpoints::s_singleton;
 
-Item *create_func_srid(Item *a)
+Item*
+Create_func_numpoints::create(THD *thd, Item *arg1)
 {
-  return new Item_func_srid(a);
+  return new (thd->mem_root) Item_func_numpoints(arg1);
 }
+#endif
+
+
+Create_func_oct Create_func_oct::s_singleton;
 
-Item *create_func_startpoint(Item *a)
+Item*
+Create_func_oct::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_decomp(a, Item_func::SP_STARTPOINT);
+  Item *i10= new (thd->mem_root) Item_int((int32) 10,2);
+  Item *i8= new (thd->mem_root) Item_int((int32) 8,1);
+  return new (thd->mem_root) Item_func_conv(arg1, i10, i8);
 }
 
-Item *create_func_endpoint(Item *a)
+
+Create_func_ord Create_func_ord::s_singleton;
+
+Item*
+Create_func_ord::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_decomp(a, Item_func::SP_ENDPOINT);
+  return new (thd->mem_root) Item_func_ord(arg1);
 }
 
-Item *create_func_exteriorring(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_overlaps Create_func_overlaps::s_singleton;
+
+Item*
+Create_func_overlaps::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_spatial_decomp(a, Item_func::SP_EXTERIORRING);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_OVERLAPS_FUNC);
 }
+#endif
+
 
-Item *create_func_pointn(Item *a, Item *b)
+Create_func_period_add Create_func_period_add::s_singleton;
+
+Item*
+Create_func_period_add::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_spatial_decomp_n(a, b, Item_func::SP_POINTN);
+  return new (thd->mem_root) Item_func_period_add(arg1, arg2);
 }
 
-Item *create_func_interiorringn(Item *a, Item *b)
+
+Create_func_period_diff Create_func_period_diff::s_singleton;
+
+Item*
+Create_func_period_diff::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_spatial_decomp_n(a, b, Item_func::SP_INTERIORRINGN);
+  return new (thd->mem_root) Item_func_period_diff(arg1, arg2);
 }
 
-Item *create_func_geometryn(Item *a, Item *b)
+
+Create_func_pi Create_func_pi::s_singleton;
+
+Item*
+Create_func_pi::create(THD *thd)
 {
-  return new Item_func_spatial_decomp_n(a, b, Item_func::SP_GEOMETRYN);
+  return new (thd->mem_root) Item_static_float_func("pi()", M_PI, 6, 8);
 }
 
-Item *create_func_centroid(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_pointn Create_func_pointn::s_singleton;
+
+Item*
+Create_func_pointn::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_centroid(a);
+  return new (thd->mem_root) Item_func_spatial_decomp_n(arg1, arg2,
+                                                        Item_func::SP_POINTN);
 }
+#endif
+
 
-Item *create_func_envelope(Item *a)
+Create_func_pow Create_func_pow::s_singleton;
+
+Item*
+Create_func_pow::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_envelope(a);
+  return new (thd->mem_root) Item_func_pow(arg1, arg2);
 }
 
-Item *create_func_equals(Item *a, Item *b)
+
+Create_func_quote Create_func_quote::s_singleton;
+
+Item*
+Create_func_quote::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_EQUALS_FUNC);
+  return new (thd->mem_root) Item_func_quote(arg1);
 }
 
-Item *create_func_disjoint(Item *a, Item *b)
+
+Create_func_radians Create_func_radians::s_singleton;
+
+Item*
+Create_func_radians::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_DISJOINT_FUNC);
+  return new (thd->mem_root) Item_func_units((char*) "radians", arg1,
+                                             M_PI/180, 0.0);
 }
 
-Item *create_func_intersects(Item *a, Item *b)
+
+Create_func_rand Create_func_rand::s_singleton;
+
+Item*
+Create_func_rand::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_INTERSECTS_FUNC);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 0:
+  {
+    func= new (thd->mem_root) Item_func_rand();
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_rand(param_1);
+    thd->lex->uncacheable(UNCACHEABLE_RAND);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_touches(Item *a, Item *b)
+
+Create_func_release_lock Create_func_release_lock::s_singleton;
+
+Item*
+Create_func_release_lock::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_TOUCHES_FUNC);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_release_lock(arg1);
 }
 
-Item *create_func_crosses(Item *a, Item *b)
+
+Create_func_reverse Create_func_reverse::s_singleton;
+
+Item*
+Create_func_reverse::create(THD *thd, Item *arg1)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_CROSSES_FUNC);
+  return new (thd->mem_root) Item_func_reverse(arg1);
 }
 
-Item *create_func_within(Item *a, Item *b)
+
+Create_func_round Create_func_round::s_singleton;
+
+Item*
+Create_func_round::create(THD *thd, LEX_STRING name, List<Item> *item_list)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_WITHIN_FUNC);
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    Item *i0 = new (thd->mem_root) Item_int((char*)"0", 0, 1);
+    func= new (thd->mem_root) Item_func_round(param_1, i0, 0);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_round(param_1, param_2, 0);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
 }
 
-Item *create_func_contains(Item *a, Item *b)
+
+Create_func_row_count Create_func_row_count::s_singleton;
+
+Item*
+Create_func_row_count::create(THD *thd)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_CONTAINS_FUNC);
+  thd->lex->safe_to_cache_query= 0;
+  return new (thd->mem_root) Item_func_row_count();
 }
 
-Item *create_func_overlaps(Item *a, Item *b)
+
+Create_func_rpad Create_func_rpad::s_singleton;
+
+Item*
+Create_func_rpad::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_spatial_rel(a, b, Item_func::SP_OVERLAPS_FUNC);
+  return new (thd->mem_root) Item_func_rpad(arg1, arg2, arg3);
 }
 
-Item *create_func_isempty(Item *a)
+
+Create_func_rtrim Create_func_rtrim::s_singleton;
+
+Item*
+Create_func_rtrim::create(THD *thd, Item *arg1)
 {
-  return new Item_func_isempty(a);
+  return new (thd->mem_root) Item_func_rtrim(arg1);
 }
 
-Item *create_func_issimple(Item *a)
+
+Create_func_sec_to_time Create_func_sec_to_time::s_singleton;
+
+Item*
+Create_func_sec_to_time::create(THD *thd, Item *arg1)
 {
-  return new Item_func_issimple(a);
+  return new (thd->mem_root) Item_func_sec_to_time(arg1);
 }
 
-Item *create_func_isclosed(Item *a)
+
+Create_func_sha Create_func_sha::s_singleton;
+
+Item*
+Create_func_sha::create(THD *thd, Item *arg1)
 {
-  return new Item_func_isclosed(a);
+  return new (thd->mem_root) Item_func_sha(arg1);
 }
 
-Item *create_func_geometry_type(Item *a)
+
+Create_func_sign Create_func_sign::s_singleton;
+
+Item*
+Create_func_sign::create(THD *thd, Item *arg1)
 {
-  return new Item_func_geometry_type(a);
+  return new (thd->mem_root) Item_func_sign(arg1);
 }
 
-Item *create_func_dimension(Item *a)
+
+Create_func_sin Create_func_sin::s_singleton;
+
+Item*
+Create_func_sin::create(THD *thd, Item *arg1)
 {
-  return new Item_func_dimension(a);
+  return new (thd->mem_root) Item_func_sin(arg1);
 }
 
-Item *create_func_x(Item *a)
+
+Create_func_sleep Create_func_sleep::s_singleton;
+
+Item*
+Create_func_sleep::create(THD *thd, Item *arg1)
 {
-  return new Item_func_x(a);
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return new (thd->mem_root) Item_func_sleep(arg1);
 }
 
-Item *create_func_y(Item *a)
+
+Create_func_soundex Create_func_soundex::s_singleton;
+
+Item*
+Create_func_soundex::create(THD *thd, Item *arg1)
 {
-  return new Item_func_y(a);
+  return new (thd->mem_root) Item_func_soundex(arg1);
 }
 
-Item *create_func_numpoints(Item *a)
+
+Create_func_space Create_func_space::s_singleton;
+
+Item*
+Create_func_space::create(THD *thd, Item *arg1)
 {
-  return new Item_func_numpoints(a);
+  /**
+    TODO: Fix Bug#23637
+    The parsed item tree should not depend on
+    <code>thd->variables.collation_connection</code>.
+  */
+  CHARSET_INFO *cs= thd->variables.collation_connection;
+  Item *sp;
+
+  if (cs->mbminlen > 1)
+  {
+    uint dummy_errors;
+    sp= new (thd->mem_root) Item_string("", 0, cs);
+    sp->str_value.copy(" ", 1, &my_charset_latin1, cs, &dummy_errors);
+  }
+  else
+  {
+    sp= new (thd->mem_root) Item_string(" ", 1, cs);
+  }
+
+  return new (thd->mem_root) Item_func_repeat(sp, arg1);
 }
 
-Item *create_func_numinteriorring(Item *a)
+
+Create_func_sqrt Create_func_sqrt::s_singleton;
+
+Item*
+Create_func_sqrt::create(THD *thd, Item *arg1)
 {
-  return new Item_func_numinteriorring(a);
+  return new (thd->mem_root) Item_func_sqrt(arg1);
 }
 
-Item *create_func_numgeometries(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_srid Create_func_srid::s_singleton;
+
+Item*
+Create_func_srid::create(THD *thd, Item *arg1)
 {
-  return new Item_func_numgeometries(a);
+  return new (thd->mem_root) Item_func_srid(arg1);
 }
+#endif
 
-Item *create_func_area(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_startpoint Create_func_startpoint::s_singleton;
+
+Item*
+Create_func_startpoint::create(THD *thd, Item *arg1)
 {
-  return new Item_func_area(a);
+  return new (thd->mem_root) Item_func_spatial_decomp(arg1,
+                                                      Item_func::SP_STARTPOINT);
 }
+#endif
 
-Item *create_func_glength(Item *a)
+
+Create_func_str_to_date Create_func_str_to_date::s_singleton;
+
+Item*
+Create_func_str_to_date::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_glength(a);
+  return new (thd->mem_root) Item_func_str_to_date(arg1, arg2);
 }
 
-Item *create_func_point(Item *a, Item *b)
+
+Create_func_strcmp Create_func_strcmp::s_singleton;
+
+Item*
+Create_func_strcmp::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_point(a, b);
+  return new (thd->mem_root) Item_func_strcmp(arg1, arg2);
 }
-#endif /*HAVE_SPATIAL*/
 
-Item *create_func_crc32(Item* a)
+
+Create_func_substr_index Create_func_substr_index::s_singleton;
+
+Item*
+Create_func_substr_index::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
 {
-  return new Item_func_crc32(a);
+  return new (thd->mem_root) Item_func_substr_index(arg1, arg2, arg3);
 }
 
-Item *create_func_compress(Item* a)
+
+Create_func_subtime Create_func_subtime::s_singleton;
+
+Item*
+Create_func_subtime::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_compress(a);
+  return new (thd->mem_root) Item_func_add_time(arg1, arg2, 0, 1);
 }
 
-Item *create_func_uncompress(Item* a)
+
+Create_func_tan Create_func_tan::s_singleton;
+
+Item*
+Create_func_tan::create(THD *thd, Item *arg1)
 {
-  return new Item_func_uncompress(a);
+  return new (thd->mem_root) Item_func_tan(arg1);
 }
 
-Item *create_func_uncompressed_length(Item* a)
+
+Create_func_time_format Create_func_time_format::s_singleton;
+
+Item*
+Create_func_time_format::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_uncompressed_length(a);
+  return new (thd->mem_root) Item_func_date_format(arg1, arg2, 1);
 }
 
-Item *create_func_datediff(Item *a, Item *b)
+
+Create_func_time_to_sec Create_func_time_to_sec::s_singleton;
+
+Item*
+Create_func_time_to_sec::create(THD *thd, Item *arg1)
 {
-  return new Item_func_minus(new Item_func_to_days(a),
-			     new Item_func_to_days(b));
+  return new (thd->mem_root) Item_func_time_to_sec(arg1);
 }
 
-Item *create_func_weekofyear(Item *a)
+
+Create_func_timediff Create_func_timediff::s_singleton;
+
+Item*
+Create_func_timediff::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_week(a, new Item_int((char*) "0", 3, 1));
+  return new (thd->mem_root) Item_func_timediff(arg1, arg2);
 }
 
-Item *create_func_makedate(Item* a,Item* b)
+
+Create_func_to_days Create_func_to_days::s_singleton;
+
+Item*
+Create_func_to_days::create(THD *thd, Item *arg1)
 {
-  return new Item_func_makedate(a, b);
+  return new (thd->mem_root) Item_func_to_days(arg1);
 }
 
-Item *create_func_addtime(Item* a,Item* b)
+
+#ifdef HAVE_SPATIAL
+Create_func_touches Create_func_touches::s_singleton;
+
+Item*
+Create_func_touches::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_add_time(a, b, 0, 0);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_TOUCHES_FUNC);
 }
+#endif
+
 
-Item *create_func_subtime(Item* a,Item* b)
+Create_func_ucase Create_func_ucase::s_singleton;
+
+Item*
+Create_func_ucase::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_ucase(arg1);
+}
+
+
+Create_func_uncompress Create_func_uncompress::s_singleton;
+
+Item*
+Create_func_uncompress::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_uncompress(arg1);
+}
+
+
+Create_func_uncompressed_length Create_func_uncompressed_length::s_singleton;
+
+Item*
+Create_func_uncompressed_length::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_uncompressed_length(arg1);
+}
+
+
+Create_func_unhex Create_func_unhex::s_singleton;
+
+Item*
+Create_func_unhex::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_unhex(arg1);
+}
+
+
+Create_func_unix_timestamp Create_func_unix_timestamp::s_singleton;
+
+Item*
+Create_func_unix_timestamp::create(THD *thd, LEX_STRING name,
+                                   List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 0:
+  {
+    func= new (thd->mem_root) Item_func_unix_timestamp();
+    thd->lex->safe_to_cache_query= 0;
+    break;
+  }
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    func= new (thd->mem_root) Item_func_unix_timestamp(param_1);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+Create_func_uuid Create_func_uuid::s_singleton;
+
+Item*
+Create_func_uuid::create(THD *thd)
 {
-  return new Item_func_add_time(a, b, 0, 1);
+#ifdef HAVE_ROW_BASED_REPLICATION
+  thd->lex->binlog_row_based_if_mixed= TRUE;
+#endif
+  return new (thd->mem_root) Item_func_uuid();
 }
 
-Item *create_func_timediff(Item* a,Item* b)
+
+Create_func_version Create_func_version::s_singleton;
+
+Item*
+Create_func_version::create(THD *thd)
 {
-  return new Item_func_timediff(a, b);
+  return new (thd->mem_root) Item_static_string_func("version()",
+                                                     server_version,
+                                                     (uint) strlen(server_version),
+                                                     system_charset_info,
+                                                     DERIVATION_SYSCONST);
 }
 
-Item *create_func_maketime(Item* a,Item* b,Item* c)
+
+Create_func_weekday Create_func_weekday::s_singleton;
+
+Item*
+Create_func_weekday::create(THD *thd, Item *arg1)
 {
-  return new Item_func_maketime(a, b, c);
+  return new (thd->mem_root) Item_func_weekday(arg1, 0);
 }
 
-Item *create_func_str_to_date(Item* a,Item* b)
+
+Create_func_weekofyear Create_func_weekofyear::s_singleton;
+
+Item*
+Create_func_weekofyear::create(THD *thd, Item *arg1)
 {
-  return new Item_func_str_to_date(a, b);
+  Item *i1= new (thd->mem_root) Item_int((char*) "0", 3, 1);
+  return new (thd->mem_root) Item_func_week(arg1, i1);
 }
 
-Item *create_func_last_day(Item *a)
+
+#ifdef HAVE_SPATIAL
+Create_func_within Create_func_within::s_singleton;
+
+Item*
+Create_func_within::create(THD *thd, Item *arg1, Item *arg2)
 {
-  return new Item_func_last_day(a);
+  return new (thd->mem_root) Item_func_spatial_rel(arg1, arg2,
+                                                   Item_func::SP_WITHIN_FUNC);
 }
+#endif
+
+
+#ifdef HAVE_SPATIAL
+Create_func_x Create_func_x::s_singleton;
+
+Item*
+Create_func_x::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_x(arg1);
+}
+#endif
+
+
+Create_func_xml_extractvalue Create_func_xml_extractvalue::s_singleton;
+
+Item*
+Create_func_xml_extractvalue::create(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_xml_extractvalue(arg1, arg2);
+}
+
+
+Create_func_xml_update Create_func_xml_update::s_singleton;
+
+Item*
+Create_func_xml_update::create(THD *thd, Item *arg1, Item *arg2, Item *arg3)
+{
+  return new (thd->mem_root) Item_func_xml_update(arg1, arg2, arg3);
+}
+
+
+#ifdef HAVE_SPATIAL
+Create_func_y Create_func_y::s_singleton;
+
+Item*
+Create_func_y::create(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_y(arg1);
+}
+#endif
+
+
+Create_func_year_week Create_func_year_week::s_singleton;
+
+Item*
+Create_func_year_week::create(THD *thd, LEX_STRING name, List<Item> *item_list)
+{
+  Item *func= NULL;
+  int arg_count= 0;
+
+  if (item_list != NULL)
+    arg_count= item_list->elements;
+
+  switch (arg_count) {
+  case 1:
+  {
+    Item *param_1= item_list->pop();
+    Item *i0= new (thd->mem_root) Item_int((char*) "0", 0, 1);
+    func= new (thd->mem_root) Item_func_yearweek(param_1, i0);
+    break;
+  }
+  case 2:
+  {
+    Item *param_1= item_list->pop();
+    Item *param_2= item_list->pop();
+    func= new (thd->mem_root) Item_func_yearweek(param_1, param_2);
+    break;
+  }
+  default:
+  {
+    my_error(ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, MYF(0), name.str);
+    break;
+  }
+  }
+
+  return func;
+}
+
+
+struct Native_func_registry
+{
+  LEX_STRING name;
+  Create_func *builder;
+};
+
+#define BUILDER(F) & F::s_singleton
+
+#ifdef HAVE_SPATIAL
+  #define GEOM_BUILDER(F) & F::s_singleton
+#else
+  #define GEOM_BUILDER(F) & Create_func_no_geom::s_singleton
+#endif
+
+/*
+  MySQL native functions.
+  MAINTAINER:
+  - Keep sorted for human lookup. At runtime, a hash table is used.
+  - do **NOT** conditionally (#ifdef, #ifndef) define a function *NAME*:
+    doing so will cause user code that works against a --without-XYZ binary
+    to fail with name collisions against a --with-XYZ binary.
+    Use something similar to GEOM_BUILDER instead.
+  - keep 1 line per entry, it makes grep | sort easier
+*/
+
+static Native_func_registry func_array[] =
+{
+  { C_STRING_WITH_LEN("ABS"), BUILDER(Create_func_abs)},
+  { C_STRING_WITH_LEN("ACOS"), BUILDER(Create_func_acos)},
+  { C_STRING_WITH_LEN("ADDTIME"), BUILDER(Create_func_addtime)},
+  { C_STRING_WITH_LEN("AES_DECRYPT"), BUILDER(Create_func_aes_decrypt)},
+  { C_STRING_WITH_LEN("AES_ENCRYPT"), BUILDER(Create_func_aes_encrypt)},
+  { C_STRING_WITH_LEN("AREA"), GEOM_BUILDER(Create_func_area)},
+  { C_STRING_WITH_LEN("ASBINARY"), GEOM_BUILDER(Create_func_as_wkb)},
+  { C_STRING_WITH_LEN("ASIN"), BUILDER(Create_func_asin)},
+  { C_STRING_WITH_LEN("ASTEXT"), GEOM_BUILDER(Create_func_as_wkt)},
+  { C_STRING_WITH_LEN("ASWKB"), GEOM_BUILDER(Create_func_as_wkb)},
+  { C_STRING_WITH_LEN("ASWKT"), GEOM_BUILDER(Create_func_as_wkt)},
+  { C_STRING_WITH_LEN("ATAN"), BUILDER(Create_func_atan)},
+  { C_STRING_WITH_LEN("ATAN2"), BUILDER(Create_func_atan)},
+  { C_STRING_WITH_LEN("BENCHMARK"), BUILDER(Create_func_benchmark)},
+  { C_STRING_WITH_LEN("BIN"), BUILDER(Create_func_bin)},
+  { C_STRING_WITH_LEN("BIT_COUNT"), BUILDER(Create_func_bit_count)},
+  { C_STRING_WITH_LEN("BIT_LENGTH"), BUILDER(Create_func_bit_length)},
+  { C_STRING_WITH_LEN("CEIL"), BUILDER(Create_func_ceiling)},
+  { C_STRING_WITH_LEN("CEILING"), BUILDER(Create_func_ceiling)},
+  { C_STRING_WITH_LEN("CENTROID"), GEOM_BUILDER(Create_func_centroid)},
+  { C_STRING_WITH_LEN("CHARACTER_LENGTH"), BUILDER(Create_func_char_length)},
+  { C_STRING_WITH_LEN("CHAR_LENGTH"), BUILDER(Create_func_char_length)},
+  { C_STRING_WITH_LEN("COERCIBILITY"), BUILDER(Create_func_coercibility)},
+  { C_STRING_WITH_LEN("COMPRESS"), BUILDER(Create_func_compress)},
+  { C_STRING_WITH_LEN("CONCAT"), BUILDER(Create_func_concat)},
+  { C_STRING_WITH_LEN("CONCAT_WS"), BUILDER(Create_func_concat_ws)},
+  { C_STRING_WITH_LEN("CONNECTION_ID"), BUILDER(Create_func_connection_id)},
+  { C_STRING_WITH_LEN("CONV"), BUILDER(Create_func_conv)},
+  { C_STRING_WITH_LEN("CONVERT_TZ"), BUILDER(Create_func_convert_tz)},
+  { C_STRING_WITH_LEN("COS"), BUILDER(Create_func_cos)},
+  { C_STRING_WITH_LEN("COT"), BUILDER(Create_func_cot)},
+  { C_STRING_WITH_LEN("CRC32"), BUILDER(Create_func_crc32)},
+  { C_STRING_WITH_LEN("CROSSES"), GEOM_BUILDER(Create_func_crosses)},
+  { C_STRING_WITH_LEN("DATEDIFF"), BUILDER(Create_func_datediff)},
+  { C_STRING_WITH_LEN("DATE_FORMAT"), BUILDER(Create_func_date_format)},
+  { C_STRING_WITH_LEN("DAYNAME"), BUILDER(Create_func_dayname)},
+  { C_STRING_WITH_LEN("DAYOFMONTH"), BUILDER(Create_func_dayofmonth)},
+  { C_STRING_WITH_LEN("DAYOFWEEK"), BUILDER(Create_func_dayofweek)},
+  { C_STRING_WITH_LEN("DAYOFYEAR"), BUILDER(Create_func_dayofyear)},
+  { C_STRING_WITH_LEN("DECODE"), BUILDER(Create_func_decode)},
+  { C_STRING_WITH_LEN("DEGREES"), BUILDER(Create_func_degrees)},
+  { C_STRING_WITH_LEN("DES_DECRYPT"), BUILDER(Create_func_des_decrypt)},
+  { C_STRING_WITH_LEN("DES_ENCRYPT"), BUILDER(Create_func_des_encrypt)},
+  { C_STRING_WITH_LEN("DIMENSION"), GEOM_BUILDER(Create_func_dimension)},
+  { C_STRING_WITH_LEN("DISJOINT"), GEOM_BUILDER(Create_func_disjoint)},
+  { C_STRING_WITH_LEN("ELT"), BUILDER(Create_func_elt)},
+  { C_STRING_WITH_LEN("ENCODE"), BUILDER(Create_func_encode)},
+  { C_STRING_WITH_LEN("ENCRYPT"), BUILDER(Create_func_encrypt)},
+  { C_STRING_WITH_LEN("ENDPOINT"), GEOM_BUILDER(Create_func_endpoint)},
+  { C_STRING_WITH_LEN("ENVELOPE"), GEOM_BUILDER(Create_func_envelope)},
+  { C_STRING_WITH_LEN("EQUALS"), GEOM_BUILDER(Create_func_equals)},
+  { C_STRING_WITH_LEN("EXP"), BUILDER(Create_func_exp)},
+  { C_STRING_WITH_LEN("EXPORT_SET"), BUILDER(Create_func_export_set)},
+  { C_STRING_WITH_LEN("EXTERIORRING"), GEOM_BUILDER(Create_func_exteriorring)},
+  { C_STRING_WITH_LEN("EXTRACTVALUE"), BUILDER(Create_func_xml_extractvalue)},
+  { C_STRING_WITH_LEN("FIELD"), BUILDER(Create_func_field)},
+  { C_STRING_WITH_LEN("FIND_IN_SET"), BUILDER(Create_func_find_in_set)},
+  { C_STRING_WITH_LEN("FLOOR"), BUILDER(Create_func_floor)},
+  { C_STRING_WITH_LEN("FORMAT"), BUILDER(Create_func_format)},
+  { C_STRING_WITH_LEN("FOUND_ROWS"), BUILDER(Create_func_found_rows)},
+  { C_STRING_WITH_LEN("FROM_DAYS"), BUILDER(Create_func_from_days)},
+  { C_STRING_WITH_LEN("FROM_UNIXTIME"), BUILDER(Create_func_from_unixtime)},
+  { C_STRING_WITH_LEN("GEOMCOLLFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMCOLLFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMETRYCOLLECTIONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GEOMETRYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMETRYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GEOMETRYN"), GEOM_BUILDER(Create_func_geometryn)},
+  { C_STRING_WITH_LEN("GEOMETRYTYPE"), GEOM_BUILDER(Create_func_geometry_type)},
+  { C_STRING_WITH_LEN("GEOMFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("GEOMFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("GET_LOCK"), BUILDER(Create_func_get_lock)},
+  { C_STRING_WITH_LEN("GLENGTH"), GEOM_BUILDER(Create_func_glength)},
+  { C_STRING_WITH_LEN("GREATEST"), BUILDER(Create_func_greatest)},
+  { C_STRING_WITH_LEN("HEX"), BUILDER(Create_func_hex)},
+  { C_STRING_WITH_LEN("IFNULL"), BUILDER(Create_func_ifnull)},
+  { C_STRING_WITH_LEN("INET_ATON"), BUILDER(Create_func_inet_aton)},
+  { C_STRING_WITH_LEN("INET_NTOA"), BUILDER(Create_func_inet_ntoa)},
+  { C_STRING_WITH_LEN("INSTR"), BUILDER(Create_func_instr)},
+  { C_STRING_WITH_LEN("INTERIORRINGN"), GEOM_BUILDER(Create_func_interiorringn)},
+  { C_STRING_WITH_LEN("INTERSECTS"), GEOM_BUILDER(Create_func_intersects)},
+  { C_STRING_WITH_LEN("ISCLOSED"), GEOM_BUILDER(Create_func_isclosed)},
+  { C_STRING_WITH_LEN("ISEMPTY"), GEOM_BUILDER(Create_func_isempty)},
+  { C_STRING_WITH_LEN("ISNULL"), BUILDER(Create_func_isnull)},
+  { C_STRING_WITH_LEN("ISSIMPLE"), GEOM_BUILDER(Create_func_issimple)},
+  { C_STRING_WITH_LEN("IS_FREE_LOCK"), BUILDER(Create_func_is_free_lock)},
+  { C_STRING_WITH_LEN("IS_USED_LOCK"), BUILDER(Create_func_is_used_lock)},
+  { C_STRING_WITH_LEN("LAST_DAY"), BUILDER(Create_func_last_day)},
+  { C_STRING_WITH_LEN("LAST_INSERT_ID"), BUILDER(Create_func_last_insert_id)},
+  { C_STRING_WITH_LEN("LCASE"), BUILDER(Create_func_lcase)},
+  { C_STRING_WITH_LEN("LEAST"), BUILDER(Create_func_least)},
+  { C_STRING_WITH_LEN("LENGTH"), BUILDER(Create_func_length)},
+  { C_STRING_WITH_LEN("LINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("LINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("LINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("LINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("LN"), BUILDER(Create_func_ln)},
+  { C_STRING_WITH_LEN("LOAD_FILE"), BUILDER(Create_func_load_file)},
+  { C_STRING_WITH_LEN("LOCATE"), BUILDER(Create_func_locate)},
+  { C_STRING_WITH_LEN("LOG"), BUILDER(Create_func_log)},
+  { C_STRING_WITH_LEN("LOG10"), BUILDER(Create_func_log10)},
+  { C_STRING_WITH_LEN("LOG2"), BUILDER(Create_func_log2)},
+  { C_STRING_WITH_LEN("LOWER"), BUILDER(Create_func_lcase)},
+  { C_STRING_WITH_LEN("LPAD"), BUILDER(Create_func_lpad)},
+  { C_STRING_WITH_LEN("LTRIM"), BUILDER(Create_func_ltrim)},
+  { C_STRING_WITH_LEN("MAKEDATE"), BUILDER(Create_func_makedate)},
+  { C_STRING_WITH_LEN("MAKETIME"), BUILDER(Create_func_maketime)},
+  { C_STRING_WITH_LEN("MAKE_SET"), BUILDER(Create_func_make_set)},
+  { C_STRING_WITH_LEN("MASTER_POS_WAIT"), BUILDER(Create_func_master_pos_wait)},
+  { C_STRING_WITH_LEN("MBRCONTAINS"), GEOM_BUILDER(Create_func_contains)},
+  { C_STRING_WITH_LEN("MD5"), BUILDER(Create_func_md5)},
+  { C_STRING_WITH_LEN("MLINEFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MLINEFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MONTHNAME"), BUILDER(Create_func_monthname)},
+  { C_STRING_WITH_LEN("MPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MPOLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MPOLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MULTILINESTRINGFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MULTILINESTRINGFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MULTIPOINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MULTIPOINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("MULTIPOLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("MULTIPOLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("NAME_CONST"), BUILDER(Create_func_name_const)},
+  { C_STRING_WITH_LEN("NULLIF"), BUILDER(Create_func_nullif)},
+  { C_STRING_WITH_LEN("NUMGEOMETRIES"), GEOM_BUILDER(Create_func_numgeometries)},
+  { C_STRING_WITH_LEN("NUMINTERIORRINGS"), GEOM_BUILDER(Create_func_numinteriorring)},
+  { C_STRING_WITH_LEN("NUMPOINTS"), GEOM_BUILDER(Create_func_numpoints)},
+  { C_STRING_WITH_LEN("OCT"), BUILDER(Create_func_oct)},
+  { C_STRING_WITH_LEN("OCTET_LENGTH"), BUILDER(Create_func_length)},
+  { C_STRING_WITH_LEN("ORD"), BUILDER(Create_func_ord)},
+  { C_STRING_WITH_LEN("OVERLAPS"), GEOM_BUILDER(Create_func_overlaps)},
+  { C_STRING_WITH_LEN("PERIOD_ADD"), BUILDER(Create_func_period_add)},
+  { C_STRING_WITH_LEN("PERIOD_DIFF"), BUILDER(Create_func_period_diff)},
+  { C_STRING_WITH_LEN("PI"), BUILDER(Create_func_pi)},
+  { C_STRING_WITH_LEN("POINTFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("POINTFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("POINTN"), GEOM_BUILDER(Create_func_pointn)},
+  { C_STRING_WITH_LEN("POLYFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("POLYFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("POLYGONFROMTEXT"), GEOM_BUILDER(Create_func_geometry_from_text)},
+  { C_STRING_WITH_LEN("POLYGONFROMWKB"), GEOM_BUILDER(Create_func_geometry_from_wkb)},
+  { C_STRING_WITH_LEN("POW"), BUILDER(Create_func_pow)},
+  { C_STRING_WITH_LEN("POWER"), BUILDER(Create_func_pow)},
+  { C_STRING_WITH_LEN("QUOTE"), BUILDER(Create_func_quote)},
+  { C_STRING_WITH_LEN("RADIANS"), BUILDER(Create_func_radians)},
+  { C_STRING_WITH_LEN("RAND"), BUILDER(Create_func_rand)},
+  { C_STRING_WITH_LEN("RELEASE_LOCK"), BUILDER(Create_func_release_lock)},
+  { C_STRING_WITH_LEN("REVERSE"), BUILDER(Create_func_reverse)},
+  { C_STRING_WITH_LEN("ROUND"), BUILDER(Create_func_round)},
+  { C_STRING_WITH_LEN("ROW_COUNT"), BUILDER(Create_func_row_count)},
+  { C_STRING_WITH_LEN("RPAD"), BUILDER(Create_func_rpad)},
+  { C_STRING_WITH_LEN("RTRIM"), BUILDER(Create_func_rtrim)},
+  { C_STRING_WITH_LEN("SEC_TO_TIME"), BUILDER(Create_func_sec_to_time)},
+  { C_STRING_WITH_LEN("SHA"), BUILDER(Create_func_sha)},
+  { C_STRING_WITH_LEN("SHA1"), BUILDER(Create_func_sha)},
+  { C_STRING_WITH_LEN("SIGN"), BUILDER(Create_func_sign)},
+  { C_STRING_WITH_LEN("SIN"), BUILDER(Create_func_sin)},
+  { C_STRING_WITH_LEN("SLEEP"), BUILDER(Create_func_sleep)},
+  { C_STRING_WITH_LEN("SOUNDEX"), BUILDER(Create_func_soundex)},
+  { C_STRING_WITH_LEN("SPACE"), BUILDER(Create_func_space)},
+  { C_STRING_WITH_LEN("SQRT"), BUILDER(Create_func_sqrt)},
+  { C_STRING_WITH_LEN("SRID"), GEOM_BUILDER(Create_func_srid)},
+  { C_STRING_WITH_LEN("STARTPOINT"), GEOM_BUILDER(Create_func_startpoint)},
+  { C_STRING_WITH_LEN("STRCMP"), BUILDER(Create_func_strcmp)},
+  { C_STRING_WITH_LEN("STR_TO_DATE"), BUILDER(Create_func_str_to_date)},
+  { C_STRING_WITH_LEN("SUBSTRING_INDEX"), BUILDER(Create_func_substr_index)},
+  { C_STRING_WITH_LEN("SUBTIME"), BUILDER(Create_func_subtime)},
+  { C_STRING_WITH_LEN("TAN"), BUILDER(Create_func_tan)},
+  { C_STRING_WITH_LEN("TIMEDIFF"), BUILDER(Create_func_timediff)},
+  { C_STRING_WITH_LEN("TIME_FORMAT"), BUILDER(Create_func_time_format)},
+  { C_STRING_WITH_LEN("TIME_TO_SEC"), BUILDER(Create_func_time_to_sec)},
+  { C_STRING_WITH_LEN("TOUCHES"), GEOM_BUILDER(Create_func_touches)},
+  { C_STRING_WITH_LEN("TO_DAYS"), BUILDER(Create_func_to_days)},
+  { C_STRING_WITH_LEN("UCASE"), BUILDER(Create_func_ucase)},
+  { C_STRING_WITH_LEN("UNCOMPRESS"), BUILDER(Create_func_uncompress)},
+  { C_STRING_WITH_LEN("UNCOMPRESSED_LENGTH"), BUILDER(Create_func_uncompressed_length)},
+  { C_STRING_WITH_LEN("UNHEX"), BUILDER(Create_func_unhex)},
+  { C_STRING_WITH_LEN("UNIX_TIMESTAMP"), BUILDER(Create_func_unix_timestamp)},
+  { C_STRING_WITH_LEN("UPDATEXML"), BUILDER(Create_func_xml_update)},
+  { C_STRING_WITH_LEN("UPPER"), BUILDER(Create_func_ucase)},
+  { C_STRING_WITH_LEN("UUID"), BUILDER(Create_func_uuid)},
+  { C_STRING_WITH_LEN("VERSION"), BUILDER(Create_func_version)},
+  { C_STRING_WITH_LEN("WEEKDAY"), BUILDER(Create_func_weekday)},
+  { C_STRING_WITH_LEN("WEEKOFYEAR"), BUILDER(Create_func_weekofyear)},
+  { C_STRING_WITH_LEN("WITHIN"), GEOM_BUILDER(Create_func_within)},
+  { C_STRING_WITH_LEN("X"), GEOM_BUILDER(Create_func_x)},
+  { C_STRING_WITH_LEN("Y"), GEOM_BUILDER(Create_func_y)},
+  { C_STRING_WITH_LEN("YEARWEEK"), BUILDER(Create_func_year_week)},
+
+  { {0, 0}, NULL}
+};
+
+static HASH native_functions_hash;
+
+extern "C" byte*
+get_native_fct_hash_key(const byte *buff, uint *length, my_bool /* unused */)
+{
+  Native_func_registry *func= (Native_func_registry*) buff;
+  *length= func->name.length;
+  return (byte*) func->name.str;
+}
+
+/*
+  Load the hash table for native functions.
+  Note: this code is not thread safe, and is intended to be used at server
+  startup only (before going multi-threaded)
+*/
+
+int item_create_init()
+{
+  Native_func_registry *func;
+
+  DBUG_ENTER("item_create_init");
+
+  if (hash_init(& native_functions_hash,
+                system_charset_info,
+                array_elements(func_array),
+                0,
+                0,
+                (hash_get_key) get_native_fct_hash_key,
+                NULL,                          /* Nothing to free */
+                MYF(0)))
+    DBUG_RETURN(1);
+
+  for (func= func_array; func->builder != NULL; func++)
+  {
+    if (my_hash_insert(& native_functions_hash, (byte*) func))
+      DBUG_RETURN(1);
+  }
+
+#ifndef DBUG_OFF
+  for (uint i=0 ; i < native_functions_hash.records ; i++)
+  {
+    func= (Native_func_registry*) hash_element(& native_functions_hash, i);
+    DBUG_PRINT("info", ("native function %s, length %d",
+                        func->name.str, func->name.length));
+  }
+#endif
+
+  DBUG_RETURN(0);
+}
+
+/*
+  Empty the hash table for native functions.
+  Note: this code is not thread safe, and is intended to be used at server
+  shutdown only (after thread requests have been executed).
+*/
+
+void item_create_cleanup()
+{
+  DBUG_ENTER("item_create_cleanup");
+  hash_free(& native_functions_hash);
+  DBUG_VOID_RETURN;
+}
+
+Create_func *
+find_native_function_builder(THD *thd, LEX_STRING name)
+{
+  Native_func_registry *func;
+  Create_func *builder= NULL;
+
+  /* Thread safe */
+  func= (Native_func_registry*) hash_search(& native_functions_hash,
+                                            (byte*) name.str,
+                                             name.length);
+
+  if (func)
+  {
+    builder= func->builder;
+  }
+
+  return builder;
+}
+
+Create_qfunc *
+find_qualified_function_builder(THD *thd)
+{
+  return & Create_sp_func::s_singleton;
+}
+
+Item*
+create_func_cast(THD *thd, Item *a, Cast_target cast_type, int len, int dec,
+                 CHARSET_INFO *cs)
+{
+  Item *res;
+  LINT_INIT(res);
+
+  switch (cast_type) {
+  case ITEM_CAST_BINARY:
+    res= new (thd->mem_root) Item_func_binary(a);
+    break;
+  case ITEM_CAST_SIGNED_INT:
+    res= new (thd->mem_root) Item_func_signed(a);
+    break;
+  case ITEM_CAST_UNSIGNED_INT:
+    res= new (thd->mem_root) Item_func_unsigned(a);
+    break;
+  case ITEM_CAST_DATE:
+    res= new (thd->mem_root) Item_date_typecast(a);
+    break;
+  case ITEM_CAST_TIME:
+    res= new (thd->mem_root) Item_time_typecast(a);
+    break;
+  case ITEM_CAST_DATETIME:
+    res= new (thd->mem_root) Item_datetime_typecast(a);
+    break;
+  case ITEM_CAST_DECIMAL:
+  {
+    int tmp_len= (len>0) ? len : 10;
+    if (tmp_len < dec)
+    {
+      my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
+      return 0;
+    }
+    res= new (thd->mem_root) Item_decimal_typecast(a, tmp_len, dec);
+    break;
+  }
+  case ITEM_CAST_CHAR:
+  {
+    CHARSET_INFO *real_cs= (cs ? cs : thd->variables.collation_connection);
+    res= new (thd->mem_root) Item_char_typecast(a, len, real_cs);
+    break;
+  }
+  default:
+  {
+    DBUG_ASSERT(0);
+    res= 0;
+    break;
+  }
+  }
+  return res;
+}
+
diff --git a/sql/item_create.h b/sql/item_create.h
index 9b6a74b5bdd..c20e36af04f 100644
--- a/sql/item_create.h
+++ b/sql/item_create.h
@@ -14,148 +14,154 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/* Functions to create an item. Used by lex.h */
-
-Item *create_func_abs(Item* a);
-Item *create_func_acos(Item* a);
-Item *create_func_aes_encrypt(Item* a, Item* b);
-Item *create_func_aes_decrypt(Item* a, Item* b);
-Item *create_func_ascii(Item* a);
-Item *create_func_asin(Item* a);
-Item *create_func_bin(Item* a);
-Item *create_func_bit_count(Item* a);
-Item *create_func_bit_length(Item* a);
-Item *create_func_coercibility(Item* a);
-Item *create_func_ceiling(Item* a);
-Item *create_func_char_length(Item* a);
-Item *create_func_cast(Item *a, Cast_target cast_type, int len, int dec,
-                       CHARSET_INFO *cs);
-Item *create_func_connection_id(void);
-Item *create_func_conv(Item* a, Item *b, Item *c);
-Item *create_func_cos(Item* a);
-Item *create_func_cot(Item* a);
-Item *create_func_crc32(Item* a);
-Item *create_func_date_format(Item* a,Item *b);
-Item *create_func_dayname(Item* a);
-Item *create_func_dayofmonth(Item* a);
-Item *create_func_dayofweek(Item* a);
-Item *create_func_dayofyear(Item* a);
-Item *create_func_degrees(Item *);
-Item *create_func_exp(Item* a);
-Item *create_func_find_in_set(Item* a, Item *b);
-Item *create_func_floor(Item* a);
-Item *create_func_found_rows(void);
-Item *create_func_from_days(Item* a);
-Item *create_func_get_lock(Item* a, Item *b);
-Item *create_func_hex(Item *a);
-Item *create_func_inet_aton(Item* a);
-Item *create_func_inet_ntoa(Item* a);
-
-Item *create_func_ifnull(Item* a, Item *b);
-Item *create_func_instr(Item* a, Item *b);
-Item *create_func_isnull(Item* a);
-Item *create_func_lcase(Item* a);
-Item *create_func_length(Item* a);
-Item *create_func_ln(Item* a);
-Item *create_func_locate(Item* a, Item *b);
-Item *create_func_log2(Item* a);
-Item *create_func_log10(Item* a);
-Item *create_func_lpad(Item* a, Item *b, Item *c);
-Item *create_func_ltrim(Item* a);
-Item *create_func_md5(Item* a);
-Item *create_func_mod(Item* a, Item *b);
-Item *create_func_monthname(Item* a);
-Item *create_func_name_const(Item *a, Item *b);
-Item *create_func_nullif(Item* a, Item *b);
-Item *create_func_oct(Item *);
-Item *create_func_ord(Item* a);
-Item *create_func_period_add(Item* a, Item *b);
-Item *create_func_period_diff(Item* a, Item *b);
-Item *create_func_pi(void);
-Item *create_func_pow(Item* a, Item *b);
-Item *create_func_radians(Item *a);
-Item *create_func_release_lock(Item* a);
-Item *create_func_repeat(Item* a, Item *b);
-Item *create_func_reverse(Item* a);
-Item *create_func_rpad(Item* a, Item *b, Item *c);
-Item *create_func_rtrim(Item* a);
-Item *create_func_sec_to_time(Item* a);
-Item *create_func_sign(Item* a);
-Item *create_func_sin(Item* a);
-Item *create_func_sha(Item* a);
-Item *create_func_sleep(Item* a);
-Item *create_func_soundex(Item* a);
-Item *create_func_space(Item *);
-Item *create_func_sqrt(Item* a);
-Item *create_func_strcmp(Item* a, Item *b);
-Item *create_func_tan(Item* a);
-Item *create_func_time_format(Item *a, Item *b);
-Item *create_func_time_to_sec(Item* a);
-Item *create_func_to_days(Item* a);
-Item *create_func_ucase(Item* a);
-Item *create_func_unhex(Item* a);
-Item *create_func_uuid(void);
-Item *create_func_version(void);
-Item *create_func_weekday(Item* a);
-Item *create_load_file(Item* a);
-Item *create_func_is_free_lock(Item* a);
-Item *create_func_is_used_lock(Item* a);
-Item *create_func_quote(Item* a);
-Item *create_func_xml_extractvalue(Item *a, Item *b);
-Item *create_func_xml_update(Item *a, Item *b, Item *c);
-#ifdef HAVE_SPATIAL
-
-Item *create_func_geometry_from_text(Item *a);
-Item *create_func_as_wkt(Item *a);
-Item *create_func_as_wkb(Item *a);
-Item *create_func_srid(Item *a);
-Item *create_func_startpoint(Item *a);
-Item *create_func_endpoint(Item *a);
-Item *create_func_exteriorring(Item *a);
-Item *create_func_centroid(Item *a);
-Item *create_func_envelope(Item *a);
-Item *create_func_pointn(Item *a, Item *b);
-Item *create_func_interiorringn(Item *a, Item *b);
-Item *create_func_geometryn(Item *a, Item *b);
-
-Item *create_func_equals(Item *a, Item *b);
-Item *create_func_disjoint(Item *a, Item *b);
-Item *create_func_intersects(Item *a, Item *b);
-Item *create_func_touches(Item *a, Item *b);
-Item *create_func_crosses(Item *a, Item *b);
-Item *create_func_within(Item *a, Item *b);
-Item *create_func_contains(Item *a, Item *b);
-Item *create_func_overlaps(Item *a, Item *b);
-
-Item *create_func_isempty(Item *a);
-Item *create_func_issimple(Item *a);
-Item *create_func_isclosed(Item *a);
-
-Item *create_func_geometry_type(Item *a);
-Item *create_func_dimension(Item *a);
-Item *create_func_x(Item *a);
-Item *create_func_y(Item *a);
-Item *create_func_area(Item *a);
-Item *create_func_glength(Item *a);
-
-Item *create_func_numpoints(Item *a);
-Item *create_func_numinteriorring(Item *a);
-Item *create_func_numgeometries(Item *a);
-
-Item *create_func_point(Item *a, Item *b);
-
-#endif /*HAVE_SPATIAL*/
-
-Item *create_func_compress(Item *a);
-Item *create_func_uncompress(Item *a);
-Item *create_func_uncompressed_length(Item *a);
-
-Item *create_func_datediff(Item *a, Item *b);
-Item *create_func_weekofyear(Item *a);
-Item *create_func_makedate(Item* a,Item* b);
-Item *create_func_addtime(Item* a,Item* b);
-Item *create_func_subtime(Item* a,Item* b);
-Item *create_func_timediff(Item* a,Item* b);
-Item *create_func_maketime(Item* a,Item* b,Item* c);
-Item *create_func_str_to_date(Item* a,Item* b);
-Item *create_func_last_day(Item *a);
+/* Functions to create an item. Used by sql/sql_yacc.yy */
+
+#ifndef ITEM_CREATE_H
+#define ITEM_CREATE_H
+
+/**
+  Public function builder interface.
+  The parser (sql/sql_yacc.yy) uses a factory / builder pattern to
+  construct an <code>Item</code> object for each function call.
+  All the concrete function builders implements this interface,
+  either directly or indirectly with some adapter helpers.
+  Keeping the function creation separated from the bison grammar allows
+  to simplify the parser, and avoid the need to introduce a new token
+  for each function, which has undesirable side effects in the grammar.
+*/
+
+class Create_func
+{
+public:
+  /**
+    The builder create method.
+    Given the function name and list or arguments, this method creates
+    an <code>Item</code> that represents the function call.
+    In case or errors, a NULL item is returned, and an error is reported.
+    Note that the <code>thd</code> object may be modified by the builder.
+    In particular, the following members/methods can be set/called,
+    depending on the function called and the function possible side effects.
+    <ul>
+      <li><code>thd->lex->binlog_row_based_if_mixed</code></li>
+      <li><code>thd->lex->current_context()</code></li>
+      <li><code>thd->lex->safe_to_cache_query</code></li>
+      <li><code>thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT)</code></li>
+      <li><code>thd->lex->uncacheable(UNCACHEABLE_RAND)</code></li>
+      <li><code>thd->lex->add_time_zone_tables_to_query_tables(thd)</code></li>
+    </ul>
+    @param thd The current thread
+    @param name The function name
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call, or NULL
+  */
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list) = 0;
+
+protected:
+  /** Constructor */
+  Create_func() {}
+  /** Destructor */
+  virtual ~Create_func() {}
+};
+
+
+/**
+  Function builder for qualified functions.
+  This builder is used with functions call using a qualified function name
+  syntax, as in <code>db.func(expr, expr, ...)</code>.
+*/
+
+class Create_qfunc : public Create_func
+{
+public:
+  /**
+    The builder create method, for unqualified functions.
+    This builder will use the current database for the database name.
+    @param thd The current thread
+    @param name The function name
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call
+  */
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    The builder create method, for qualified functions.
+    @param thd The current thread
+    @param db The database name
+    @param name The function name
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call
+  */
+  virtual Item* create(THD *thd, LEX_STRING db, LEX_STRING name,
+                       List<Item> *item_list) = 0;
+
+protected:
+  /** Constructor. */
+  Create_qfunc() {}
+  /** Destructor. */
+  virtual ~Create_qfunc() {}
+};
+
+
+/**
+  Find the native function builder associated with a given function name.
+  @param thd The current thread
+  @param name The native function name
+  @return The native function builder associated with the name, or NULL
+*/
+extern Create_func * find_native_function_builder(THD *thd, LEX_STRING name);
+
+
+/**
+  Find the function builder for qualified functions.
+  @param thd The current thread
+  @return A function builder for qualified functions
+*/
+extern Create_qfunc * find_qualified_function_builder(THD *thd);
+
+
+#ifdef HAVE_DLOPEN
+/**
+  Function builder for User Defined Functions.
+*/
+
+class Create_udf_func : public Create_func
+{
+public:
+  virtual Item* create(THD *thd, LEX_STRING name, List<Item> *item_list);
+
+  /**
+    The builder create method, for User Defined Functions.
+    @param thd The current thread
+    @param fct The User Defined Function metadata
+    @param item_list The list of arguments to the function, can be NULL
+    @return An item representing the parsed function call
+  */
+  Item* create(THD *thd, udf_func *fct, List<Item> *item_list);
+
+  /** Singleton. */
+  static Create_udf_func s_singleton;
+
+protected:
+  /** Constructor. */
+  Create_udf_func() {}
+  /** Destructor. */
+  virtual ~Create_udf_func() {}
+};
+#endif
+
+
+/**
+  Builder for cast expressions.
+  @param thd The current thread
+  @param a The item to cast
+  @param cast_type the type casted into
+  @param len TODO
+  @param dec TODO
+  @param cs The character set
+*/
+Item*
+create_func_cast(THD *thd, Item *a, Cast_target cast_type, int len, int dec,
+                 CHARSET_INFO *cs);
+
+#endif
+
diff --git a/sql/item_geofunc.h b/sql/item_geofunc.h
index 4848f59301d..42f11820869 100644
--- a/sql/item_geofunc.h
+++ b/sql/item_geofunc.h
@@ -348,11 +348,11 @@ public:
   void fix_length_and_dec() { max_length= 10; }
 };
 
-#define GEOM_NEW(obj_constructor) new obj_constructor
+#define GEOM_NEW(thd, obj_constructor) new (thd->mem_root) obj_constructor
 
 #else /*HAVE_SPATIAL*/
 
-#define GEOM_NEW(obj_constructor) NULL
+#define GEOM_NEW(thd, obj_constructor) NULL
 
 #endif
 
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index c656faa7c49..b2ff62028c1 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -1065,6 +1065,7 @@ longlong Item_sum_count::val_int()
 void Item_sum_count::cleanup()
 {
   DBUG_ENTER("Item_sum_count::cleanup");
+  count= 0;
   Item_sum_int::cleanup();
   used_table_cache= ~(table_map) 0;
   DBUG_VOID_RETURN;
diff --git a/sql/item_sum.h b/sql/item_sum.h
index 3679780db60..eb4c21bbe06 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -260,9 +260,30 @@ public:
   Item_sum(THD *thd, Item_sum *item);
   enum Type type() const { return SUM_FUNC_ITEM; }
   virtual enum Sumfunctype sum_func () const=0;
+
+  /*
+    This method is similar to add(), but it is called when the current
+    aggregation group changes. Thus it performs a combination of
+    clear() and add().
+  */
   inline bool reset() { clear(); return add(); };
+
+  /*
+    Prepare this item for evaluation of an aggregate value. This is
+    called by reset() when a group changes, or, for correlated
+    subqueries, between subquery executions.  E.g. for COUNT(), this
+    method should set count= 0;
+  */
   virtual void clear()= 0;
+
+  /*
+    This method is called for the next row in the same group. Its
+    purpose is to aggregate the new value to the previous values in
+    the group (i.e. since clear() was called last time). For example,
+    for COUNT(), do count++.
+  */
   virtual bool add()=0;
+
   /*
     Called when new group is started and results are being saved in
     a temporary table. Similar to reset(), but must also store value in
@@ -306,7 +327,17 @@ public:
   void make_field(Send_field *field);
   void print(String *str);
   void fix_num_length_and_dec();
-  void no_rows_in_result() { reset(); }
+
+  /*
+    This function is called by the execution engine to assign 'NO ROWS
+    FOUND' value to an aggregate item, when the underlying result set
+    has no rows. Such value, in a general case, may be different from
+    the default value of the item after 'clear()': e.g. a numeric item
+    may be initialized to 0 by clear() and to NULL by
+    no_rows_in_result().
+  */
+  void no_rows_in_result() { clear(); }
+
   virtual bool setup(THD *thd) {return 0;}
   virtual void make_unique() {}
   Item *get_tmp_table_item(THD *thd);
@@ -610,6 +641,11 @@ public:
   const char *func_name() const { return "avg("; }
   Item *copy_or_same(THD* thd);
   Field *create_tmp_field(bool group, TABLE *table, uint convert_blob_length);
+  void cleanup()
+  {
+    count= 0;
+    Item_sum_sum::cleanup();
+  }
 };
 
 class Item_sum_variance;
@@ -689,6 +725,12 @@ public:
   Item *copy_or_same(THD* thd);
   Field *create_tmp_field(bool group, TABLE *table, uint convert_blob_length);
   enum Item_result result_type () const { return REAL_RESULT; }
+  void cleanup()
+  {
+    cur_dec= 0;
+    count= 0;
+    Item_sum_num::cleanup();
+  }
 };
 
 class Item_sum_std;
@@ -819,6 +861,11 @@ public:
   void update_field();
   void fix_length_and_dec()
   { decimals= 0; max_length=21; unsigned_flag= 1; maybe_null= null_value= 0; }
+  void cleanup()
+  {
+    bits= reset_bits;
+    Item_sum_int::cleanup();
+  }
 };
 
 
diff --git a/sql/lex.h b/sql/lex.h
index f19c9413e0e..97b097148aa 100644
--- a/sql/lex.h
+++ b/sql/lex.h
@@ -30,16 +30,7 @@ SYM_GROUP sym_group_rtree= {"RTree keys", "HAVE_RTREE_KEYS"};
 #define SYM_OR_NULL(A) A
 #endif
 
-#define SYM(A) SYM_OR_NULL(A),0,0,&sym_group_common
-#define F_SYM(A) SYM_OR_NULL(A)
-
-#define CREATE_FUNC(A) (void *)(SYM_OR_NULL(A)), &sym_group_common
-
-#ifdef HAVE_SPATIAL
-#define CREATE_FUNC_GEOM(A) (void *)(SYM_OR_NULL(A)), &sym_group_geom
-#else
-#define CREATE_FUNC_GEOM(A) 0, &sym_group_geom
-#endif
+#define SYM(A) SYM_OR_NULL(A),0,&sym_group_common
 
 /*
   Symbols are broken into separated arrays to allow field names with
@@ -588,235 +579,38 @@ static SYMBOL symbols[] = {
 
 
 static SYMBOL sql_functions[] = {
-  { "ABS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_abs)},
-  { "ACOS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_acos)},
   { "ADDDATE",		SYM(ADDDATE_SYM)},
-  { "ADDTIME",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_addtime)},
-  { "AES_ENCRYPT",      F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_encrypt)},
-  { "AES_DECRYPT",      F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_decrypt)},
-  { "AREA",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_area)},
-  { "ASIN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_asin)},
-  { "ASBINARY",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkb)},
-  { "ASTEXT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkt)},
-  { "ASWKB",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkb)},
-  { "ASWKT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_as_wkt)},
-  { "ATAN",		SYM(ATAN)},
-  { "ATAN2",		SYM(ATAN)},
-  { "BENCHMARK",	SYM(BENCHMARK_SYM)},
-  { "BIN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bin)},
-  { "BIT_COUNT",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_count)},
-  { "BIT_OR",		SYM(BIT_OR)},
   { "BIT_AND",		SYM(BIT_AND)},
+  { "BIT_OR",		SYM(BIT_OR)},
   { "BIT_XOR",		SYM(BIT_XOR)},
   { "CAST",		SYM(CAST_SYM)},
-  { "CEIL",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
-  { "CEILING",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
-  { "BIT_LENGTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_length)},
-  { "CENTROID",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_centroid)},
-  { "CHAR_LENGTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
-  { "CHARACTER_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
-  { "COERCIBILITY",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_coercibility)},
-  { "COMPRESS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_compress)},
-  { "CONCAT",		SYM(CONCAT)},
-  { "CONCAT_WS",	SYM(CONCAT_WS)},
-  { "CONNECTION_ID",	F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_connection_id)},
-  { "CONV",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_conv)},
-  { "CONVERT_TZ",	SYM(CONVERT_TZ_SYM)},
   { "COUNT",		SYM(COUNT_SYM)},
-  { "COS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cos)},
-  { "COT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cot)},
-  { "CRC32",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_crc32)},
-  { "CROSSES",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_crosses)},
   { "CURDATE",		SYM(CURDATE)},
   { "CURTIME",		SYM(CURTIME)},
   { "DATE_ADD",		SYM(DATE_ADD_INTERVAL)},
-  { "DATEDIFF",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_datediff)},
-  { "DATE_FORMAT",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_date_format)},
   { "DATE_SUB",		SYM(DATE_SUB_INTERVAL)},
-  { "DAYNAME",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayname)},
-  { "DAYOFMONTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofmonth)},
-  { "DAYOFWEEK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofweek)},
-  { "DAYOFYEAR",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofyear)},
-  { "DECODE",		SYM(DECODE_SYM)},
-  { "DEGREES",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_degrees)},
-  { "DES_ENCRYPT",	SYM(DES_ENCRYPT_SYM)},
-  { "DES_DECRYPT",	SYM(DES_DECRYPT_SYM)},
-  { "DIMENSION",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_dimension)},
-  { "DISJOINT",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_disjoint)},
-  { "ELT",		SYM(ELT_FUNC)},
-  { "ENCODE",		SYM(ENCODE_SYM)},
-  { "ENCRYPT",		SYM(ENCRYPT)},
-  { "ENDPOINT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_endpoint)},
-  { "ENVELOPE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_envelope)},
-  { "EQUALS",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_equals)},
-  { "EXTERIORRING",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_exteriorring)},
   { "EXTRACT",		SYM(EXTRACT_SYM)},
-  { "EXTRACTVALUE",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_xml_extractvalue)},
-  { "EXP",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_exp)},
-  { "EXPORT_SET",	SYM(EXPORT_SET)},
-  { "FIELD",		SYM(FIELD_FUNC)},	/* For compability */
-  { "FIND_IN_SET",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_find_in_set)},
-  { "FLOOR",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_floor)},
-  { "FORMAT",		SYM(FORMAT_SYM)},
-  { "FOUND_ROWS",	F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_found_rows)},
-  { "FROM_DAYS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_from_days)},
-  { "FROM_UNIXTIME",	SYM(FROM_UNIXTIME)},
-  { "GET_LOCK",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_get_lock)},
-  { "GEOMETRYN",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_geometryn)},
-  { "GEOMETRYTYPE",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_geometry_type)},
-  { "GEOMCOLLFROMTEXT",	SYM(GEOMCOLLFROMTEXT)},
-  { "GEOMCOLLFROMWKB",	SYM(GEOMFROMWKB)},
-  { "GEOMETRYCOLLECTIONFROMTEXT",SYM(GEOMCOLLFROMTEXT)},
-  { "GEOMETRYCOLLECTIONFROMWKB",SYM(GEOMFROMWKB)},
-  { "GEOMETRYFROMTEXT", SYM(GEOMFROMTEXT)},
-  { "GEOMETRYFROMWKB",	SYM(GEOMFROMWKB)},
-  { "GEOMFROMTEXT",	SYM(GEOMFROMTEXT)},
-  { "GEOMFROMWKB",	SYM(GEOMFROMWKB)},
-  { "GLENGTH",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_glength)},
-  { "GREATEST",		SYM(GREATEST_SYM)},
   { "GROUP_CONCAT",	SYM(GROUP_CONCAT_SYM)},
   { "GROUP_UNIQUE_USERS",	SYM(GROUP_UNIQUE_USERS)},
-  { "HEX",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_hex)},
-  { "IFNULL",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_ifnull)},
-  { "INET_ATON",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_aton)},
-  { "INET_NTOA",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_ntoa)},
-  { "INSTR",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_instr)},
-  { "INTERIORRINGN",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_interiorringn)},
-  { "INTERSECTS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_intersects)},
-  { "ISCLOSED",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_isclosed)},
-  { "ISEMPTY",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_isempty)},
-  { "ISNULL",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_isnull)},
-  { "IS_FREE_LOCK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_free_lock)},
-  { "IS_USED_LOCK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_used_lock)},
-  { "LAST_INSERT_ID",	SYM(LAST_INSERT_ID)},
-  { "ISSIMPLE",         F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_issimple)},
-  { "LAST_DAY",         F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_last_day)},
-  { "LCASE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
-  { "LEAST",		SYM(LEAST_SYM)},
-  { "LENGTH",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
-  { "LN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ln)},
-  { "LINEFROMTEXT",	SYM(LINEFROMTEXT)},
-  { "LINEFROMWKB",	SYM(GEOMFROMWKB)},
-  { "LINESTRINGFROMTEXT",SYM(LINEFROMTEXT)},
-  { "LINESTRINGFROMWKB",SYM(GEOMFROMWKB)},
-  { "LOAD_FILE",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_load_file)},
-  { "LOCATE",		SYM(LOCATE)},
-  { "LOG",		SYM(LOG_SYM)},
-  { "LOG2",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log2)},
-  { "LOG10",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log10)},
-  { "LOWER",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
-  { "LPAD",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_lpad)},
-  { "LTRIM",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ltrim)},
-  { "MAKE_SET",		SYM(MAKE_SET_SYM)},
-  { "MAKEDATE",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_makedate)},
-  { "MAKETIME",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_maketime)},
-  { "MASTER_POS_WAIT",	SYM(MASTER_POS_WAIT)},
   { "MAX",		SYM(MAX_SYM)},
-  { "MBRCONTAINS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_contains)},
-  { "MBRDISJOINT",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_disjoint)},
-  { "MBREQUAL",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_equals)},
-  { "MBRINTERSECTS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_intersects)},
-  { "MBROVERLAPS",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_overlaps)},
-  { "MBRTOUCHES",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)},
-  { "MBRWITHIN",	F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)},
-  { "MD5",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_md5)},
   { "MID",		SYM(SUBSTRING)},	/* unireg function */
   { "MIN",		SYM(MIN_SYM)},
-  { "MLINEFROMTEXT",	SYM(MLINEFROMTEXT)},
-  { "MLINEFROMWKB",	SYM(GEOMFROMWKB)},
-  { "MPOINTFROMTEXT",	SYM(MPOINTFROMTEXT)},
-  { "MPOINTFROMWKB",	SYM(GEOMFROMWKB)},
-  { "MPOLYFROMTEXT",	SYM(MPOLYFROMTEXT)},
-  { "MPOLYFROMWKB",	SYM(GEOMFROMWKB)},
-  { "MONTHNAME",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_monthname)},
-  { "MULTILINESTRINGFROMTEXT",SYM(MLINEFROMTEXT)},
-  { "MULTILINESTRINGFROMWKB",SYM(GEOMFROMWKB)},
-  { "MULTIPOINTFROMTEXT",SYM(MPOINTFROMTEXT)},
-  { "MULTIPOINTFROMWKB",SYM(GEOMFROMWKB)},
-  { "MULTIPOLYGONFROMTEXT",SYM(MPOLYFROMTEXT)},
-  { "MULTIPOLYGONFROMWKB",SYM(GEOMFROMWKB)},
-  { "NAME_CONST",       F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_name_const)},
   { "NOW",		SYM(NOW_SYM)},
-  { "NULLIF",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_nullif)},
-  { "NUMGEOMETRIES",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numgeometries)},
-  { "NUMINTERIORRINGS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numinteriorring)},
-  { "NUMPOINTS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_numpoints)},
-  { "OCTET_LENGTH",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
-  { "OCT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_oct)},
-  { "ORD",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ord)},
-  { "OVERLAPS",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_overlaps)},
-  { "PERIOD_ADD",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_add)},
-  { "PERIOD_DIFF",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_diff)},
-  { "PI",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_pi)},
-  { "POINTFROMTEXT",	SYM(POINTFROMTEXT)},
-  { "POINTFROMWKB",	SYM(GEOMFROMWKB)},
-  { "POINTN",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_pointn)},
-  { "POLYFROMTEXT",	SYM(POLYFROMTEXT)},
-  { "POLYFROMWKB",	SYM(GEOMFROMWKB)},
-  { "POLYGONFROMTEXT",	SYM(POLYFROMTEXT)},
-  { "POLYGONFROMWKB",	SYM(GEOMFROMWKB)},
   { "POSITION",		SYM(POSITION_SYM)},
-  { "POW",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
-  { "POWER",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
-  { "QUOTE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quote)},
-  { "RADIANS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_radians)},
-  { "RAND",		SYM(RAND)},
-  { "RELEASE_LOCK",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_release_lock)},
-  { "REVERSE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_reverse)},
-  { "ROUND",		SYM(ROUND)},
-  { "ROW_COUNT",	SYM(ROW_COUNT_SYM)},
-  { "RPAD",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_rpad)},
-  { "RTRIM",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_rtrim)},
-  { "SEC_TO_TIME",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sec_to_time)},
-  { "SESSION_USER",	SYM(USER)},
-  { "SUBDATE",		SYM(SUBDATE_SYM)},
-  { "SIGN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sign)},
-  { "SIN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sin)},
-  { "SHA",              F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
-  { "SHA1",             F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
-  { "SLEEP",            F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sleep)},
-  { "SOUNDEX",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_soundex)},
-  { "SPACE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_space)},
-  { "SQRT",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sqrt)},
-  { "SRID",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_srid)},
-  { "STARTPOINT",	F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_startpoint)},
+  { "SESSION_USER",     SYM(USER)},
   { "STD",		SYM(STD_SYM)},
   { "STDDEV",		SYM(STD_SYM)},
   { "STDDEV_POP",	SYM(STD_SYM)},
   { "STDDEV_SAMP",	SYM(STDDEV_SAMP_SYM)},
-  { "STR_TO_DATE",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_str_to_date)},
-  { "STRCMP",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_strcmp)},
+  { "SUBDATE",		SYM(SUBDATE_SYM)},
   { "SUBSTR",		SYM(SUBSTRING)},
   { "SUBSTRING",	SYM(SUBSTRING)},
-  { "SUBSTRING_INDEX",	SYM(SUBSTRING_INDEX)},
-  { "SUBTIME",          F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_subtime)},
   { "SUM",		SYM(SUM_SYM)},
   { "SYSDATE",		SYM(SYSDATE)},
-  { "SYSTEM_USER",	SYM(USER)},
-  { "TAN",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_tan)},
-  { "TIME_FORMAT",	F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_time_format)},
-  { "TIME_TO_SEC",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_time_to_sec)},
-  { "TIMEDIFF",         F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_timediff)},
-  { "TO_DAYS",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_to_days)},
-  { "TOUCHES",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_touches)},
+  { "SYSTEM_USER",      SYM(USER)},
   { "TRIM",		SYM(TRIM)},
-  { "UCASE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
-  { "UNCOMPRESS",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompress)},
-  { "UNCOMPRESSED_LENGTH", F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompressed_length)},
-  { "UNHEX",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_unhex)},
   { "UNIQUE_USERS",	SYM(UNIQUE_USERS)},
-  { "UNIX_TIMESTAMP",	SYM(UNIX_TIMESTAMP)},
-  { "UPDATEXML",	F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_xml_update)},
-  { "UPPER",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
-  { "UUID",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_uuid)},
   { "VARIANCE",		SYM(VARIANCE_SYM)},
   { "VAR_POP",		SYM(VARIANCE_SYM)},
   { "VAR_SAMP",		SYM(VAR_SAMP_SYM)},
-  { "VERSION",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_version)},
-  { "WEEKDAY",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekday)},
-  { "WEEKOFYEAR",	F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekofyear)},
-  { "WITHIN",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_within)},
-  { "X",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_x)},
-  { "Y",		F_SYM(FUNC_ARG1),0,CREATE_FUNC_GEOM(create_func_y)},
-  { "YEARWEEK",		SYM(YEARWEEK)}
 };
diff --git a/sql/lex_symbol.h b/sql/lex_symbol.h
index 3074a489b6a..5ba785d16f3 100644
--- a/sql/lex_symbol.h
+++ b/sql/lex_symbol.h
@@ -26,7 +26,6 @@ typedef struct st_symbol {
   const char *name;
   uint	tok;
   uint length;
-  void *create_func;
   struct st_sym_group *group;
 } SYMBOL;
 
diff --git a/sql/lock.cc b/sql/lock.cc
index 06f538a2a03..f36ecf58620 100644
--- a/sql/lock.cc
+++ b/sql/lock.cc
@@ -691,7 +691,8 @@ static MYSQL_LOCK *get_lock_data(THD *thd, TABLE **table_ptr, uint count,
           check_if_locking_is_allowed(thd->lex->sql_command, thd->lex->type,
                                       table_ptr[i], count,
                                       (thd == logger.get_general_log_thd()) ||
-                                           (thd == logger.get_slow_log_thd())))
+                                      (thd == logger.get_slow_log_thd()) ||
+                                      (thd == logger.get_privileged_thread())))
       DBUG_RETURN(0);
   }
 
diff --git a/sql/log.cc b/sql/log.cc
index fb14aa62dd8..83e190a5c01 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -173,6 +173,33 @@ public:
 
 handlerton *binlog_hton;
 
+
+/* Check if a given table is opened log table */
+int check_if_log_table(uint db_len, const char *db, uint table_name_len,
+                       const char *table_name, uint check_if_opened)
+{
+  if (db_len == 5 &&
+      !(lower_case_table_names ?
+        my_strcasecmp(system_charset_info, db, "mysql") :
+        strcmp(db, "mysql")))
+  {
+    if (table_name_len == 11 && !(lower_case_table_names ?
+                                  my_strcasecmp(system_charset_info,
+                                                table_name, "general_log") :
+                                  strcmp(table_name, "general_log")) &&
+        (!check_if_opened || logger.is_log_table_enabled(QUERY_LOG_GENERAL)))
+      return QUERY_LOG_GENERAL;
+    else
+      if (table_name_len == 8 && !(lower_case_table_names ?
+        my_strcasecmp(system_charset_info, table_name, "slow_log") :
+        strcmp(table_name, "slow_log")) &&
+          (!check_if_opened ||logger.is_log_table_enabled(QUERY_LOG_SLOW)))
+        return QUERY_LOG_SLOW;
+  }
+  return 0;
+}
+
+
 /*
   Open log table of a given type (general or slow log)
 
@@ -273,6 +300,12 @@ bool Log_to_csv_event_handler::open_log_table(uint log_table_type)
     my_pthread_setspecific_ptr(THR_MALLOC, 0);
   }
 
+  /*
+    After a log table was opened, we should clear privileged thread
+    flag (which allows locking of a log table by a special thread, usually
+    the one who closed log tables temporarily).
+  */
+  privileged_thread= 0;
   DBUG_RETURN(error);
 }
 
@@ -284,11 +317,15 @@ Log_to_csv_event_handler::Log_to_csv_event_handler()
   /* logger thread always works with mysql database */
   general_log_thd->db= my_strdup("mysql", MYF(0));
   general_log_thd->db_length= 5;
+  general_log.table= 0;
 
   slow_log_thd= new THD;
   /* logger thread always works with mysql database */
   slow_log_thd->db= my_strdup("mysql", MYF(0));;
   slow_log_thd->db_length= 5;
+  slow_log.table= 0;
+  /* no privileged thread exists at the moment */
+  privileged_thread= 0;
 }
 
 
@@ -341,6 +378,7 @@ bool Log_to_csv_event_handler::reopen_log_table(uint log_table_type)
   return open_log_table(log_table_type);
 }
 
+
 void Log_to_csv_event_handler::cleanup()
 {
   if (opt_log)
@@ -395,9 +433,6 @@ bool Log_to_csv_event_handler::
     filled by the Logger (=> no need to load default ones).
   */
 
-  /* log table entries are not replicated at the moment */
-  tmp_disable_binlog(current_thd);
-
   /* Set current time. Required for CURRENT_TIMESTAMP to work */
   general_log_thd->start_time= event_time;
 
@@ -406,21 +441,36 @@ bool Log_to_csv_event_handler::
     default value (which is CURRENT_TIMESTAMP).
   */
 
-  table->field[1]->store(user_host, user_host_len, client_cs);
+  /* check that all columns exist */
+  if (!table->field[1] || !table->field[2] || !table->field[3] ||
+      !table->field[4] || !table->field[5])
+    goto err;
+
+  /* do a write */
+  if (table->field[1]->store(user_host, user_host_len, client_cs) ||
+      table->field[2]->store((longlong) thread_id, TRUE) ||
+      table->field[3]->store((longlong) server_id, TRUE) ||
+      table->field[4]->store(command_type, command_type_len, client_cs) ||
+      table->field[5]->store(sql_text, sql_text_len, client_cs))
+    goto err;
+
+  /* mark tables as not null */
   table->field[1]->set_notnull();
-  table->field[2]->store((longlong) thread_id, TRUE);
   table->field[2]->set_notnull();
-  table->field[3]->store((longlong) server_id, TRUE);
   table->field[3]->set_notnull();
-  table->field[4]->store(command_type, command_type_len, client_cs);
   table->field[4]->set_notnull();
-  table->field[5]->store(sql_text, sql_text_len, client_cs);
   table->field[5]->set_notnull();
+
+  /* log table entries are not replicated at the moment */
+  tmp_disable_binlog(current_thd);
+
   table->file->ha_write_row(table->record[0]);
 
   reenable_binlog(current_thd);
 
   return FALSE;
+err:
+  return TRUE;
 }
 
 
@@ -469,9 +519,6 @@ bool Log_to_csv_event_handler::
   if (unlikely(!logger.is_log_tables_initialized))
     return FALSE;
 
-  /* log table entries are not replicated at the moment */
-  tmp_disable_binlog(current_thd);
-
   /*
      Set start time for CURRENT_TIMESTAMP to the start of the query.
      This will be default value for the field[0]
@@ -484,19 +531,30 @@ bool Log_to_csv_event_handler::
     default value.
   */
 
+  if (!table->field[1] || !table->field[2] || !table->field[3] ||
+      !table->field[4] || !table->field[5] || !table->field[6] ||
+      !table->field[7] || !table->field[8] || !table->field[9] ||
+      !table->field[10])
+    goto err;
+
   /* store the value */
-  table->field[1]->store(user_host, user_host_len, client_cs);
+  if (table->field[1]->store(user_host, user_host_len, client_cs))
+    goto err;
 
   if (query_start_arg)
   {
     /* fill in query_time field */
-    table->field[2]->store(query_time, TRUE);
+    if (table->field[2]->store(query_time, TRUE))
+      goto err;
     /* lock_time */
-    table->field[3]->store(lock_time, TRUE);
+    if (table->field[3]->store(lock_time, TRUE))
+      goto err;
     /* rows_sent */
-    table->field[4]->store((longlong) thd->sent_row_count, TRUE);
+    if (table->field[4]->store((longlong) thd->sent_row_count, TRUE))
+      goto err;
     /* rows_examined */
-    table->field[5]->store((longlong) thd->examined_row_count, TRUE);
+    if (table->field[5]->store((longlong) thd->examined_row_count, TRUE))
+      goto err;
   }
   else
   {
@@ -509,14 +567,18 @@ bool Log_to_csv_event_handler::
   /* fill database field */
   if (thd->db)
   {
-    table->field[6]->store(thd->db, thd->db_length, client_cs);
+    if (table->field[6]->store(thd->db, thd->db_length, client_cs))
+      goto err;
     table->field[6]->set_notnull();
   }
 
   if (thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt)
   {
-    table->field[7]->store((longlong)
-                           thd->first_successful_insert_id_in_prev_stmt_for_binlog, TRUE);
+    if (table->
+        field[7]->store((longlong)
+                        thd->first_successful_insert_id_in_prev_stmt_for_binlog,
+                        TRUE))
+      goto err;
     table->field[7]->set_notnull();
   }
 
@@ -528,16 +590,23 @@ bool Log_to_csv_event_handler::
   */
   if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0)
   {
-    table->field[8]->store((longlong)
-                           thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(), TRUE);
+    if (table->
+        field[8]->store((longlong)
+          thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(), TRUE))
+      goto err;
     table->field[8]->set_notnull();
   }
 
-  table->field[9]->store((longlong) server_id, TRUE);
+  if (table->field[9]->store((longlong) server_id, TRUE))
+    goto err;
   table->field[9]->set_notnull();
 
   /* sql_text */
-  table->field[10]->store(sql_text,sql_text_len, client_cs);
+  if (table->field[10]->store(sql_text,sql_text_len, client_cs))
+    goto err;
+
+  /* log table entries are not replicated at the moment */
+  tmp_disable_binlog(current_thd);
 
   /* write the row */
   table->file->ha_write_row(table->record[0]);
@@ -545,6 +614,8 @@ bool Log_to_csv_event_handler::
   reenable_binlog(current_thd);
 
   DBUG_RETURN(0);
+err:
+  DBUG_RETURN(1);
 }
 
 bool Log_to_csv_event_handler::
@@ -733,61 +804,48 @@ bool LOGGER::reopen_log_table(uint log_table_type)
   return table_log_handler->reopen_log_table(log_table_type);
 }
 
-
-bool LOGGER::flush_logs(THD *thd)
+bool LOGGER::reopen_log_tables()
 {
-  TABLE_LIST close_slow_log, close_general_log;
+    /*
+      we use | and not || here, to ensure that both reopen_log_table
+      are called, even if the first one fails
+    */
+    if ((opt_slow_log && logger.reopen_log_table(QUERY_LOG_SLOW)) |
+        (opt_log && logger.reopen_log_table(QUERY_LOG_GENERAL)))
+      return TRUE;
+    return FALSE;
+}
 
-  /* reopen log tables */
-  bzero((char*) &close_slow_log, sizeof(TABLE_LIST));
-  close_slow_log.alias= close_slow_log.table_name=(char*) "slow_log";
-  close_slow_log.table_name_length= 8;
-  close_slow_log.db= (char*) "mysql";
-  close_slow_log.db_length= 5;
 
-  bzero((char*) &close_general_log, sizeof(TABLE_LIST));
-  close_general_log.alias= close_general_log.table_name=(char*) "general_log";
-  close_general_log.table_name_length= 11;
-  close_general_log.db= (char*) "mysql";
-  close_general_log.db_length= 5;
+void LOGGER::tmp_close_log_tables(THD *thd)
+{
+  table_log_handler->tmp_close_log_tables(thd);
+}
 
-  /* lock tables, in the case they are enabled */
-  if (logger.is_log_tables_initialized)
-  {
-    /*
-      This will lock and wait for all but the logger thread to release the
-      tables. Then we could reopen log tables. Then release the name locks.
-
-      NOTE: in fact, the first parameter used in lock_and_wait_for_table_name()
-      and table_log_handler->flush() could be any non-NULL THD, as the
-      underlying code makes certain assumptions about this.
-      Here we use one of the logger handler THD's. Simply because it
-      seems appropriate.
-    */
-    if (opt_slow_log)
-      lock_and_wait_for_table_name(table_log_handler->general_log_thd,
-				   &close_slow_log);
-    if (opt_log)
-      lock_and_wait_for_table_name(table_log_handler->general_log_thd,
-				   &close_general_log);
-  }
+bool LOGGER::flush_logs(THD *thd)
+{
+  int rc= 0;
 
   /*
-    Deny others from logging to general and slow log,
-    while reopening tables.
+    Now we lock logger, as nobody should be able to use logging routines while
+    log tables are closed
   */
   logger.lock();
+  if (logger.is_log_tables_initialized)
+    table_log_handler->tmp_close_log_tables(thd); // the locking happens here
 
   /* reopen log files */
   file_log_handler->flush();
 
-  /* flush tables, in the case they are enabled */
+  /* reopen tables in the case they were enabled */
   if (logger.is_log_tables_initialized)
-    table_log_handler->flush(table_log_handler->general_log_thd,
-                             &close_slow_log, &close_general_log);
+  {
+    if (reopen_log_tables())
+      rc= TRUE;
+  }
   /* end of log flush */
   logger.unlock();
-  return FALSE;
+  return rc;
 }
 
 
@@ -1095,31 +1153,50 @@ void LOGGER::deactivate_log_handler(THD *thd, uint log_type)
 }
 
 
-bool Log_to_csv_event_handler::flush(THD *thd, TABLE_LIST *close_slow_log,
-                                     TABLE_LIST *close_general_log)
+/*
+  Close log tables temporarily. The thread which closed
+  them this way can lock them in any mode it needs.
+  NOTE: one should call logger.lock() before entering this
+  function.
+*/
+void Log_to_csv_event_handler::tmp_close_log_tables(THD *thd)
 {
+  TABLE_LIST close_slow_log, close_general_log;
+
+  /* fill lists, we will need to perform operations on tables */
+  bzero((char*) &close_slow_log, sizeof(TABLE_LIST));
+  close_slow_log.alias= close_slow_log.table_name=(char*) "slow_log";
+  close_slow_log.table_name_length= 8;
+  close_slow_log.db= (char*) "mysql";
+  close_slow_log.db_length= 5;
+
+  bzero((char*) &close_general_log, sizeof(TABLE_LIST));
+  close_general_log.alias= close_general_log.table_name=(char*) "general_log";
+  close_general_log.table_name_length= 11;
+  close_general_log.db= (char*) "mysql";
+  close_general_log.db_length= 5;
+
+  privileged_thread= thd;
+
   VOID(pthread_mutex_lock(&LOCK_open));
+  /*
+    NOTE: in fact, the first parameter used in query_cache_invalidate3()
+    could be any non-NULL THD, as the underlying code makes certain
+    assumptions about this.
+    Here we use one of the logger handler THD's. Simply because it
+    seems appropriate.
+  */
   if (opt_log)
   {
     close_log_table(QUERY_LOG_GENERAL, TRUE);
-    query_cache_invalidate3(thd, close_general_log, 0);
-    unlock_table_name(thd, close_general_log);
+    query_cache_invalidate3(general_log_thd, &close_general_log, 0);
   }
   if (opt_slow_log)
   {
     close_log_table(QUERY_LOG_SLOW, TRUE);
-    query_cache_invalidate3(thd, close_slow_log, 0);
-    unlock_table_name(thd, close_slow_log);
+    query_cache_invalidate3(general_log_thd, &close_slow_log, 0);
   }
   VOID(pthread_mutex_unlock(&LOCK_open));
-  /*
-    we use | and not || here, to ensure that both reopen_log_table
-    are called, even if the first one fails
-  */
-  if ((opt_slow_log && reopen_log_table(QUERY_LOG_SLOW)) |
-      (opt_log && reopen_log_table(QUERY_LOG_GENERAL)))
-    return 1;
-  return 0;
 }
 
 /* the parameters are unused for the log tables */
@@ -1187,16 +1264,15 @@ void Log_to_csv_event_handler::
   THD *log_thd, *curr= current_thd;
   TABLE_LIST *table;
 
+  if (!logger.is_log_table_enabled(log_table_type))
+    return;                                     /* do nothing */
+
   switch (log_table_type) {
   case QUERY_LOG_GENERAL:
-    if (!logger.is_general_log_table_enabled())
-      return;                                     /* do nothing */
     log_thd= general_log_thd;
     table= &general_log;
     break;
   case QUERY_LOG_SLOW:
-    if (!logger.is_slow_log_table_enabled())
-      return;                                     /* do nothing */
     log_thd= slow_log_thd;
     table= &slow_log;
     break;
diff --git a/sql/log.h b/sql/log.h
index 8f75601f02b..f39b52f5db2 100644
--- a/sql/log.h
+++ b/sql/log.h
@@ -404,6 +404,9 @@ public:
 };
 
 
+int check_if_log_table(uint db_len, const char *db, uint table_name_len,
+                       const char *table_name, uint check_if_opened);
+
 class Log_to_csv_event_handler: public Log_event_handler
 {
   /*
@@ -412,6 +415,16 @@ class Log_to_csv_event_handler: public Log_event_handler
     THD's of the query. The reason is the locking order and duration.
   */
   THD *general_log_thd, *slow_log_thd;
+  /*
+    This is for the thread, which called tmp_close_log_tables. The thread
+    will be allowed to write-lock the log tables (as it explicitly disabled
+    logging). This is used for such operations as REPAIR, which require
+    exclusive lock on the log tables.
+    NOTE: there can be only one priviliged thread, as one should
+    lock logger with logger.lock() before calling tmp_close_log_tables().
+    So no other thread could get privileged status at the same time.
+  */
+  THD *privileged_thread;
   friend class LOGGER;
   TABLE_LIST general_log, slow_log;
 
@@ -436,13 +449,20 @@ public:
                            const char *command_type, uint command_type_len,
                            const char *sql_text, uint sql_text_len,
                             CHARSET_INFO *client_cs);
-  bool flush(THD *thd, TABLE_LIST *close_slow_Log,
-             TABLE_LIST* close_general_log);
+  void tmp_close_log_tables(THD *thd);
   void close_log_table(uint log_type, bool lock_in_use);
   bool reopen_log_table(uint log_type);
+  THD* get_privileged_thread()
+  {
+    return privileged_thread;
+  }
 };
 
 
+/* type of the log table */
+#define QUERY_LOG_SLOW 1
+#define QUERY_LOG_GENERAL 2
+
 class Log_to_file_event_handler: public Log_event_handler
 {
   MYSQL_QUERY_LOG mysql_log;
@@ -498,13 +518,18 @@ public:
   {}
   void lock() { (void) pthread_mutex_lock(&LOCK_logger); }
   void unlock() { (void) pthread_mutex_unlock(&LOCK_logger); }
-  bool is_general_log_table_enabled()
+  void tmp_close_log_tables(THD *thd);
+  bool is_log_table_enabled(uint log_table_type)
   {
-    return table_log_handler && table_log_handler->general_log.table != 0;
-  }
-  bool is_slow_log_table_enabled()
-  {
-    return table_log_handler && table_log_handler->slow_log.table != 0;
+    switch (log_table_type) {
+    case QUERY_LOG_SLOW:
+      return table_log_handler && table_log_handler->slow_log.table != 0;
+    case QUERY_LOG_GENERAL:
+      return table_log_handler && table_log_handler->general_log.table != 0;
+    default:
+      DBUG_ASSERT(0);
+      return FALSE;                             /* make compiler happy */
+    }
   }
   /*
     We want to initialize all log mutexes as soon as possible,
@@ -542,6 +567,7 @@ public:
 
   void close_log_table(uint log_type, bool lock_in_use);
   bool reopen_log_table(uint log_type);
+  bool reopen_log_tables();
 
   /* we use this function to setup all enabled log event handlers */
   int set_handlers(uint error_log_printer,
@@ -564,6 +590,13 @@ public:
       return file_log_handler->get_mysql_log();
     return NULL;
   }
+  THD* get_privileged_thread()
+  {
+    if (table_log_handler)
+      return table_log_handler->get_privileged_thread();
+    else
+      return NULL;
+  }
 };
 
 enum enum_binlog_format {
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 0bf75982626..7d9c5793c8d 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -140,6 +140,8 @@ MY_LOCALE *my_locale_by_name(const char *name);
 #define MAX_ACCEPT_RETRY	10	// Test accept this many times
 #define MAX_FIELDS_BEFORE_HASH	32
 #define USER_VARS_HASH_SIZE     16
+#define TABLE_OPEN_CACHE_MIN    64
+#define TABLE_OPEN_CACHE_DEFAULT 64
 
 /* 
  Value of 9236 discovered through binary search 2006-09-26 on Ubuntu Dapper
@@ -1451,10 +1453,6 @@ typedef void (*sql_print_message_func)(const char *format, ...)
   ATTRIBUTE_FORMAT(printf, 1, 2);
 extern sql_print_message_func sql_print_message_handlers[];
 
-/* type of the log table */
-#define QUERY_LOG_SLOW 1
-#define QUERY_LOG_GENERAL 2
-
 int error_log_print(enum loglevel level, const char *format,
                     va_list args);
 
@@ -1485,6 +1483,8 @@ uint find_type2(TYPELIB *lib, const char *find, uint length, CHARSET_INFO *cs);
 void unhex_type2(TYPELIB *lib);
 uint check_word(TYPELIB *lib, const char *val, const char *end,
 		const char **end_of_word);
+int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
+                         CHARSET_INFO * const cs);
 
 
 bool is_keyword(const char *name, uint len);
@@ -2052,6 +2052,10 @@ inline void kill_delayed_threads(void) {}
 void init_fill_schema_files_row(TABLE* table);
 bool schema_table_store_record(THD *thd, TABLE *table);
 
+/* sql/item_create.cc */
+int item_create_init();
+void item_create_cleanup();
+
 #endif /* MYSQL_SERVER */
 #endif /* MYSQL_CLIENT */
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 05cc75f1c05..740084f85bc 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -1184,6 +1184,7 @@ void clean_up(bool print_message)
   hostname_cache_free();
   item_user_lock_free();
   lex_free();				/* Free some memory */
+  item_create_cleanup();
   set_var_free();
   free_charsets();
   (void) ha_panic(HA_PANIC_CLOSE);	/* close all tables and logs */
@@ -2663,19 +2664,43 @@ static int init_common_variables(const char *conf_file_name, int argc,
 
   /* connections and databases needs lots of files */
   {
-    uint files, wanted_files;
+    uint files, wanted_files, max_open_files;
 
-    wanted_files= 10+(uint) max(max_connections*5,
-				 max_connections+table_cache_size*2);
-    set_if_bigger(wanted_files, open_files_limit);
-    files= my_set_max_open_files(wanted_files);
+    /* MyISAM requires two file handles per table. */
+    wanted_files= 10+max_connections+table_cache_size*2;
+    /*
+      We are trying to allocate no less than max_connections*5 file
+      handles (i.e. we are trying to set the limit so that they will
+      be available).  In addition, we allocate no less than how much
+      was already allocated.  However below we report a warning and
+      recompute values only if we got less file handles than were
+      explicitly requested.  No warning and re-computation occur if we
+      can't get max_connections*5 but still got no less than was
+      requested (value of wanted_files).
+    */
+    max_open_files= max(max(wanted_files, max_connections*5),
+                        open_files_limit);
+    files= my_set_max_open_files(max_open_files);
 
     if (files < wanted_files)
     {
       if (!open_files_limit)
       {
-	max_connections=	(ulong) min((files-10),max_connections);
-	table_cache_size= (ulong) max((files-10-max_connections)/2,64);
+        /*
+          If we have requested too much file handles than we bring
+          max_connections in supported bounds.
+        */
+        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
+                                     max_connections);
+        /*
+          Decrease table_cache_size according to max_connections, but
+          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
+          never increase table_cache_size automatically (that could
+          happen if max_connections is decreased above).
+        */
+        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
+                                          TABLE_OPEN_CACHE_MIN),
+                                      table_cache_size);    
 	DBUG_PRINT("warning",
 		   ("Changed limits: max_open_files: %u  max_connections: %ld  table_cache: %ld",
 		    files, max_connections, table_cache_size));
@@ -2693,6 +2718,8 @@ static int init_common_variables(const char *conf_file_name, int argc,
     return 1;
   init_client_errs();
   lex_init();
+  if (item_create_init())
+    return 1;
   item_init();
   set_var_init();
   mysys_uses_curses=0;
@@ -6185,15 +6212,15 @@ The minimum value for this variable is 4096.",
   {"table_cache", OPT_TABLE_OPEN_CACHE,
    "Deprecated; use --table_open_cache instead.",
    (gptr*) &table_cache_size, (gptr*) &table_cache_size, 0, GET_ULONG,
-   REQUIRED_ARG, 64, 1, 512*1024L, 0, 1, 0},
+   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
   {"table_definition_cache", OPT_TABLE_DEF_CACHE,
    "The number of cached table definitions.",
    (gptr*) &table_def_size, (gptr*) &table_def_size,
    0, GET_ULONG, REQUIRED_ARG, 128, 1, 512*1024L, 0, 1, 0},
   {"table_open_cache", OPT_TABLE_OPEN_CACHE,
    "The number of cached open tables.",
-   (gptr*) &table_cache_size, (gptr*) &table_cache_size,
-   0, GET_ULONG, REQUIRED_ARG, 64, 1, 512*1024L, 0, 1, 0},
+   (gptr*) &table_cache_size, (gptr*) &table_cache_size, 0, GET_ULONG,
+   REQUIRED_ARG, TABLE_OPEN_CACHE_DEFAULT, 1, 512*1024L, 0, 1, 0},
   {"table_lock_wait_timeout", OPT_TABLE_LOCK_WAIT_TIMEOUT,
    "Timeout in seconds to wait for a table level lock before returning an "
    "error. Used only if the connection has active cursors.",
diff --git a/sql/parse_file.h b/sql/parse_file.h
index 33871588e11..5fb65b4c7ec 100644
--- a/sql/parse_file.h
+++ b/sql/parse_file.h
@@ -107,4 +107,20 @@ public:
 					bool bad_format_errors);
 };
 
+
+/*
+  Custom version of standard offsetof() macro which can be used to get
+  offsets of members in class for non-POD types (according to the current
+  version of C++ standard offsetof() macro can't be used in such cases and
+  attempt to do so causes warnings to be emitted, OTOH in many cases it is
+  still OK to assume that all instances of the class has the same offsets
+  for the same members).
+
+  This is temporary solution which should be removed once File_parser class
+  and related routines are refactored.
+*/
+
+#define my_offsetof(TYPE, MEMBER) \
+        ((size_t)((char *)&(((TYPE *)0x10)->MEMBER) - (char*)0x10))
+
 #endif /* _PARSE_FILE_H_ */
diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt
index 0bcd15c2b82..3022967eeeb 100644
--- a/sql/share/errmsg.txt
+++ b/sql/share/errmsg.txt
@@ -6004,4 +6004,10 @@ ER_BAD_LOG_STATEMENT
         ger "Sie können eine Logtabelle nicht '%s', wenn Loggen angeschaltet ist"
 ER_NON_INSERTABLE_TABLE  
         eng "The target table %-.100s of the %s is not insertable-into"
+ER_CANT_RENAME_LOG_TABLE
+        eng "Cannot rename '%s'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to '%s'"
+ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT 42000
+        eng "Incorrect parameter count in the call to native function '%-.64s'"
+ER_WRONG_PARAMETERS_TO_NATIVE_FCT 42000
+        eng "Incorrect parameters in the call to native function '%-.64s'"
 
diff --git a/sql/sp.cc b/sql/sp.cc
index 3411a18c17a..20e07afa92a 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -1371,6 +1371,10 @@ static bool add_used_routine(LEX *lex, Query_arena *arena,
                              const LEX_STRING *key,
                              TABLE_LIST *belong_to_view)
 {
+  hash_init_opt(&lex->sroutines, system_charset_info,
+                Query_tables_list::START_SROUTINES_HASH_SIZE,
+                0, 0, sp_sroutine_key, 0, 0);
+
   if (!hash_search(&lex->sroutines, (byte *)key->str, key->length))
   {
     Sroutine_hash_entry *rn=
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index c6fb2a4064e..47a623ec749 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -1029,8 +1029,7 @@ sp_head::execute(THD *thd)
   save_sql_mode= thd->variables.sql_mode;
   thd->variables.sql_mode= m_sql_mode;
   save_abort_on_warning= thd->abort_on_warning;
-  thd->abort_on_warning=
-    (m_sql_mode & (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES));
+  thd->abort_on_warning= 0;
 
   /*
     It is also more efficient to save/restore current thd->lex once when
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 5a1586c21fd..28bc1e9dcbf 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -1365,6 +1365,10 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table,
     Also SELECT::exclude_from_table_unique_test used to exclude from check
     tables of main SELECT of multi-delete and multi-update
 
+    We also skip tables with TABLE_LIST::prelocking_placeholder set,
+    because we want to allow SELECTs from them, and their modification
+    will rise the error anyway.
+
     TODO: when we will have table/view change detection we can do this check
           only once for PS/SP
 
@@ -1411,12 +1415,13 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list)
     if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
          (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
         ((!res->table || res->table != table->table) &&
-         res->select_lex && !res->select_lex->exclude_from_table_unique_test))
+         res->select_lex && !res->select_lex->exclude_from_table_unique_test &&
+         !res->prelocking_placeholder))
       break;
     /*
-      If we found entry of this table or or table of SELECT which already
+      If we found entry of this table or table of SELECT which already
       processed in derived table or top select of multi-update/multi-delete
-      (exclude_from_table_unique_test).
+      (exclude_from_table_unique_test) or prelocking placeholder.
     */
     table_list= res->next_global;
     DBUG_PRINT("info",
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index f128b5e8706..a0cd419e6c6 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -350,7 +350,7 @@ cleanup:
     mysql_unlock_tables(thd, thd->lock);
     thd->lock=0;
   }
-  if (error < 0)
+  if (error < 0 || (thd->lex->ignore && !thd->is_fatal_error))
   {
     thd->row_count_func= deleted;
     send_ok(thd,deleted);
@@ -862,6 +862,7 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
   bool error;
   uint closed_log_tables= 0, lock_logger= 0;
   uint path_length;
+  uint log_type;
   DBUG_ENTER("mysql_truncate");
 
   bzero((char*) &create_info,sizeof(create_info));
@@ -913,28 +914,16 @@ bool mysql_truncate(THD *thd, TABLE_LIST *table_list, bool dont_send_ok)
       DBUG_RETURN(TRUE);
   }
 
+  log_type= check_if_log_table(table_list->db_length, table_list->db,
+                               table_list->table_name_length,
+                               table_list->table_name, 1);
   /* close log tables in use */
-  if (!my_strcasecmp(system_charset_info, table_list->db, "mysql"))
+  if (log_type)
   {
-    if (opt_log &&
-        !my_strcasecmp(system_charset_info, table_list->table_name,
-                       "general_log"))
-    {
-      lock_logger= 1;
-      logger.lock();
-      logger.close_log_table(QUERY_LOG_GENERAL, FALSE);
-      closed_log_tables= closed_log_tables | QUERY_LOG_GENERAL;
-    }
-    else
-      if (opt_slow_log &&
-          !my_strcasecmp(system_charset_info, table_list->table_name,
-                         "slow_log"))
-      {
-        lock_logger= 1;
-        logger.lock();
-        logger.close_log_table(QUERY_LOG_SLOW, FALSE);
-        closed_log_tables= closed_log_tables | QUERY_LOG_SLOW;
-      }
+    lock_logger= 1;
+    logger.lock();
+    logger.close_log_table(log_type, FALSE);
+    closed_log_tables= closed_log_tables | log_type;
   }
 
   // Remove the .frm extension AIX 5.2 64-bit compiler bug (BUG#16155): this
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index dd358492d0d..c35ef4079d3 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -151,7 +151,6 @@ void lex_start(THD *thd, const uchar *buf, uint length)
   lex->safe_to_cache_query= 1;
   lex->time_zone_tables_used= 0;
   lex->leaf_tables_insert= 0;
-  lex->variables_used= 0;
   lex->empty_field_list_on_rset= 0;
   lex->select_lex.select_number= 1;
   lex->next_state=MY_LEX_START;
@@ -1644,9 +1643,18 @@ void Query_tables_list::reset_query_tables_list(bool init)
   query_tables_last= &query_tables;
   query_tables_own_last= 0;
   if (init)
-    hash_init(&sroutines, system_charset_info, 0, 0, 0, sp_sroutine_key, 0, 0);
+  {
+    /*
+      We delay real initialization of hash (and therefore related
+      memory allocation) until first insertion into this hash.
+    */
+    hash_clear(&sroutines);
+  }
   else if (sroutines.records)
+  {
+    /* Non-zero sroutines.records means that hash was initialized. */
     my_hash_reset(&sroutines);
+  }
   sroutines_list.empty();
   sroutines_list_own_last= sroutines_list.next;
   sroutines_list_own_elements= 0;
@@ -2142,6 +2150,28 @@ void st_lex::restore_backup_query_tables_list(Query_tables_list *backup)
 
 
 /*
+  Checks for usage of routines and/or tables in a parsed statement
+
+  SYNOPSIS
+    st_lex:table_or_sp_used()
+
+  RETURN
+    FALSE  No routines and tables used
+    TRUE   Either or both routines and tables are used.
+*/
+
+bool st_lex::table_or_sp_used()
+{
+  DBUG_ENTER("table_or_sp_used");
+
+  if (sroutines.records || query_tables)
+    DBUG_RETURN(TRUE);
+
+  DBUG_RETURN(FALSE);
+}
+
+
+/*
   Do end-of-prepare fixup for list of tables and their merge-VIEWed tables
 
   SYNOPSIS
@@ -2208,6 +2238,7 @@ void st_select_lex::fix_prepare_information(THD *thd, Item **conds,
   }
 }
 
+
 /*
   There are st_select_lex::add_table_to_list &
   st_select_lex::set_lock_for_tables are in sql_parse.cc
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 1815774526f..7e09675cb0a 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -792,7 +792,11 @@ public:
     0 - indicates that this query does not need prelocking.
   */
   TABLE_LIST **query_tables_own_last;
-  /* Set of stored routines called by statement. */
+  /*
+    Set of stored routines called by statement.
+    (Note that we use lazy-initialization for this hash).
+  */
+  enum { START_SROUTINES_HASH_SIZE= 16 };
   HASH sroutines;
   /*
     List linking elements of 'sroutines' set. Allows you to add new elements
@@ -867,6 +871,25 @@ public:
 };
 
 
+/*
+  st_parsing_options contains the flags for constructions that are
+  allowed in the current statement.
+*/
+
+struct st_parsing_options
+{
+  bool allows_variable;
+  bool allows_select_into;
+  bool allows_select_procedure;
+  bool allows_derived;
+
+  st_parsing_options()
+    : allows_variable(TRUE), allows_select_into(TRUE),
+      allows_select_procedure(TRUE), allows_derived(TRUE)
+  {}
+};
+
+
 /* The state of the lex parsing. This is saved in the THD struct */
 
 typedef struct st_lex : public Query_tables_list
@@ -1023,7 +1046,7 @@ typedef struct st_lex : public Query_tables_list
   bool stmt_prepare_mode;
   bool safe_to_cache_query;
   bool subqueries, ignore;
-  bool variables_used;
+  st_parsing_options parsing_options;
   ALTER_INFO alter_info;
   /* Prepared statements SQL syntax:*/
   LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
@@ -1180,6 +1203,8 @@ typedef struct st_lex : public Query_tables_list
 
   void reset_n_backup_query_tables_list(Query_tables_list *backup);
   void restore_backup_query_tables_list(Query_tables_list *backup);
+
+  bool table_or_sp_used();
 } LEX;
 
 struct st_lex_local: public st_lex
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index edf43fd4fb5..055790988ea 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -3075,11 +3075,6 @@ end_with_restore_list:
 
   case SQLCOM_ALTER_TABLE:
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
-#if defined(DONT_ALLOW_SHOW_COMMANDS)
-    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
-               MYF(0)); /* purecov: inspected */
-    goto error;
-#else
     {
       ulong priv=0;
       ulong priv_needed= ALTER_ACL;
@@ -3148,7 +3143,6 @@ end_with_restore_list:
                              lex->ignore, &lex->alter_info, 1);
       break;
     }
-#endif /*DONT_ALLOW_SHOW_COMMANDS*/
   case SQLCOM_RENAME_TABLE:
   {
     DBUG_ASSERT(first_table == all_tables && first_table != 0);
@@ -3394,9 +3388,17 @@ end_with_restore_list:
     res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
 		      lex->update_list, lex->value_list,
                       lex->duplicates, lex->ignore);
-    /* do not show last insert ID if VIEW does not have auto_inc */
+
+    /*
+      If we have inserted into a VIEW, and the base table has
+      AUTO_INCREMENT column, but this column is not accessible through
+      a view, then we should restore LAST_INSERT_ID to the value it
+      had before the statement.
+    */
     if (first_table->view && !first_table->contain_auto_increment)
-      thd->first_successful_insert_id_in_cur_stmt= 0;
+      thd->first_successful_insert_id_in_cur_stmt=
+        thd->first_successful_insert_id_in_prev_stmt;
+
     break;
   }
   case SQLCOM_REPLACE_SELECT:
@@ -3456,9 +3458,17 @@ end_with_restore_list:
       /* revert changes for SP */
       select_lex->table_list.first= (byte*) first_table;
     }
-    /* do not show last insert ID if VIEW does not have auto_inc */
+
+    /*
+      If we have inserted into a VIEW, and the base table has
+      AUTO_INCREMENT column, but this column is not accessible through
+      a view, then we should restore LAST_INSERT_ID to the value it
+      had before the statement.
+    */
     if (first_table->view && !first_table->contain_auto_increment)
-      thd->first_successful_insert_id_in_cur_stmt= 0;
+      thd->first_successful_insert_id_in_cur_stmt=
+        thd->first_successful_insert_id_in_prev_stmt;
+
     break;
   }
   case SQLCOM_TRUNCATE:
@@ -3890,6 +3900,12 @@ end_with_restore_list:
   case SQLCOM_ALTER_EVENT:
   {
     DBUG_ASSERT(lex->event_parse_data);
+    if (lex->table_or_sp_used())
+    {
+      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "Usage of subqueries or stored "
+               "function calls as part of this statement");
+      break;
+    }
     switch (lex->sql_command) {
     case SQLCOM_CREATE_EVENT:
       res= Events::get_instance()->
@@ -4191,6 +4207,13 @@ end_with_restore_list:
   {
     Item *it= (Item *)lex->value_list.head();
 
+    if (lex->table_or_sp_used())
+    {
+      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "Usage of subqueries or stored "
+               "function calls as part of this statement");
+      break;
+    }
+
     if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
     {
       my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY),
@@ -6091,14 +6114,19 @@ void mysql_parse(THD *thd, char *inBuf, uint length)
       DBUG_ASSERT(thd->net.report_error);
       DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
 			 thd->is_fatal_error));
-      query_cache_abort(&thd->net);
-      lex->unit.cleanup();
+
+      /*
+        The first thing we do after parse error is freeing sp_head to
+        ensure that we have restored original memroot.
+      */
       if (lex->sphead)
       {
 	/* Clean up after failed stored procedure/function */
 	delete lex->sphead;
 	lex->sphead= NULL;
       }
+      query_cache_abort(&thd->net);
+      lex->unit.cleanup();
     }
     thd->proc_info="freeing items";
     thd->end_statement();
diff --git a/sql/sql_prepare.cc b/sql/sql_prepare.cc
index 63a129918d0..314d4ed5631 100644
--- a/sql/sql_prepare.cc
+++ b/sql/sql_prepare.cc
@@ -2811,7 +2811,19 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
 
   error= MYSQLparse((void *)thd) || thd->is_fatal_error ||
       thd->net.report_error || init_param_array(this);
+
+  /*
+    The first thing we do after parse error is freeing sp_head to
+    ensure that we have restored original memroot.
+  */
+  if (error && lex->sphead)
+  {
+    delete lex->sphead;
+    lex->sphead= NULL;
+  }
+
   lex->safe_to_cache_query= FALSE;
+
   /*
     While doing context analysis of the query (in check_prepared_statement)
     we allocate a lot of additional memory: for open tables, JOINs, derived
@@ -2837,6 +2849,7 @@ bool Prepared_statement::prepare(const char *packet, uint packet_len)
   if (error == 0)
     error= check_prepared_statement(this, name.str != 0);
 
+  /* Free sp_head if check_prepared_statement() failed. */
   if (error && lex->sphead)
   {
     delete lex->sphead;
diff --git a/sql/sql_rename.cc b/sql/sql_rename.cc
index bf2e2d506cd..cd2c3c348d4 100644
--- a/sql/sql_rename.cc
+++ b/sql/sql_rename.cc
@@ -35,7 +35,10 @@ static TABLE_LIST *reverse_table_list(TABLE_LIST *table_list);
 bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
 {
   bool error= 1;
-  TABLE_LIST *ren_table= 0;
+  TABLE_LIST *ren_table= 0, *new_table;
+  int to_table;
+  char *rename_log_table[2]= {NULL, NULL};
+  int disable_logs= 0;
   DBUG_ENTER("mysql_rename_tables");
 
   /*
@@ -52,6 +55,96 @@ bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
 
   if (wait_if_global_read_lock(thd,0,1))
     DBUG_RETURN(1);
+
+  if (logger.is_log_table_enabled(QUERY_LOG_GENERAL) ||
+      logger.is_log_table_enabled(QUERY_LOG_SLOW))
+  {
+
+    /*
+      Rules for rename of a log table:
+
+      IF   1. Log tables are enabled
+      AND  2. Rename operates on the log table and nothing is being
+              renamed to the log table.
+      DO   3. Throw an error message.
+      ELSE 4. Perform rename.
+    */
+
+    for (to_table= 0, ren_table= table_list; ren_table;
+         to_table= 1 - to_table, ren_table= ren_table->next_local)
+    {
+      int log_table_rename= 0;
+
+      if ((log_table_rename=
+           check_if_log_table(ren_table->db_length, ren_table->db,
+                              ren_table->table_name_length,
+                              ren_table->table_name, 1)))
+      {
+        /*
+          Log table encoutered we will need to disable and lock logs
+          for duration of rename.
+        */
+        disable_logs= TRUE;
+
+        /*
+          as we use log_table_rename as an array index, we need it to start
+          with 0, while QUERY_LOG_SLOW == 1 and QUERY_LOG_GENERAL == 2.
+          So, we shift the value to start with 0;
+        */
+        log_table_rename--;
+        if (rename_log_table[log_table_rename])
+        {
+          if (to_table)
+            rename_log_table[log_table_rename]= NULL;
+          else
+          {
+            /*
+              Two renames of "log_table TO" w/o rename "TO log_table" in
+              between.
+            */
+            my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), ren_table->table_name,
+                     ren_table->table_name);
+            DBUG_RETURN(1);
+          }
+        }
+        else
+        {
+          if (to_table)
+          {
+            /*
+              Attempt to rename a table TO log_table w/o renaming
+              log_table TO some table.
+            */
+            my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), ren_table->table_name,
+                     ren_table->table_name);
+            DBUG_RETURN(1);
+          }
+          else
+          {
+            /* save the name of the log table to report an error */
+            rename_log_table[log_table_rename]= ren_table->table_name;
+          }
+        }
+      }
+    }
+    if (rename_log_table[0] || rename_log_table[1])
+    {
+      if (rename_log_table[0])
+        my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), rename_log_table[0],
+                 rename_log_table[0]);
+      else
+        my_error(ER_CANT_RENAME_LOG_TABLE, MYF(0), rename_log_table[1],
+                 rename_log_table[1]);
+      DBUG_RETURN(1);
+    }
+
+    if (disable_logs)
+    {
+      logger.lock();
+      logger.tmp_close_log_tables(thd);
+    }
+  }
+
   VOID(pthread_mutex_lock(&LOCK_open));
   if (lock_table_names(thd, table_list))
     goto err;
@@ -95,6 +188,13 @@ bool mysql_rename_tables(THD *thd, TABLE_LIST *table_list, bool silent)
 
 err:
   pthread_mutex_unlock(&LOCK_open);
+  /* enable logging back if needed */
+  if (disable_logs)
+  {
+    if (logger.reopen_log_tables())
+      error= TRUE;
+    logger.unlock();
+  }
   start_waiting_global_read_lock(thd);
   DBUG_RETURN(error);
 }
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index c024ee8ddbe..6a868f07ce9 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -1639,11 +1639,8 @@ int mysql_rm_table_part2(THD *thd, TABLE_LIST *tables, bool if_exists,
 
     /* Disable drop of enabled log tables */
     if (share && share->log_table &&
-        ((!my_strcasecmp(system_charset_info, table->table_name,
-                         "general_log") && opt_log &&
-          logger.is_general_log_table_enabled()) ||
-         (!my_strcasecmp(system_charset_info, table->table_name, "slow_log")
-          && opt_slow_log && logger.is_slow_log_table_enabled())))
+        check_if_log_table(table->db_length, table->db,
+                           table->table_name_length, table->table_name, 1))
     {
       my_error(ER_BAD_LOG_STATEMENT, MYF(0), "DROP");
       DBUG_RETURN(1);
@@ -4043,7 +4040,7 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
   Item *item;
   Protocol *protocol= thd->protocol;
   LEX *lex= thd->lex;
-  int result_code;
+  int result_code, disable_logs= 0;
   DBUG_ENTER("mysql_admin_table");
 
   if (end_active_trans(thd))
@@ -4088,6 +4085,23 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
     thd->no_warnings_for_error= no_warnings_for_error;
     if (view_operator_func == NULL)
       table->required_type=FRMTYPE_TABLE;
+
+    /*
+      If we want to perform an admin operation on the log table
+      (E.g. rename) and lock_type >= TL_READ_NO_INSERT disable
+      log tables
+    */
+
+    if (check_if_log_table(table->db_length, table->db,
+                                  table->table_name_length,
+                                  table->table_name, 1) &&
+        lock_type >= TL_READ_NO_INSERT)
+    {
+      disable_logs= 1;
+      logger.lock();
+      logger.tmp_close_log_tables(thd);
+    }
+
     open_and_lock_tables(thd, table);
     thd->no_warnings_for_error= 0;
     table->next_global= save_next_global;
@@ -4404,11 +4418,24 @@ send_result_message:
   }
 
   send_eof(thd);
+  if (disable_logs)
+  {
+    if (logger.reopen_log_tables())
+      my_error(ER_CANT_ACTIVATE_LOG, MYF(0));
+    logger.unlock();
+  }
   DBUG_RETURN(FALSE);
 
  err:
   ha_autocommit_or_rollback(thd, 1);
   close_thread_tables(thd);			// Shouldn't be needed
+  /* enable logging back if needed */
+  if (disable_logs)
+  {
+    if (logger.reopen_log_tables())
+      my_error(ER_CANT_ACTIVATE_LOG, MYF(0));
+    logger.unlock();
+  }
   if (table)
     table->table=0;
   DBUG_RETURN(TRUE);
@@ -4573,17 +4600,18 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
 {
   TABLE *tmp_table;
   char src_path[FN_REFLEN], dst_path[FN_REFLEN], tmp_path[FN_REFLEN];
+  char src_table_name_buff[FN_REFLEN], src_db_name_buff[FN_REFLEN];
   uint dst_path_length;
   char *db= table->db;
   char *table_name= table->table_name;
   char *src_db;
   char *src_table= table_ident->table.str;
   int  err;
-  bool res= TRUE;
+  bool res= TRUE, unlock_dst_table= FALSE;
   enum legacy_db_type not_used;
   HA_CREATE_INFO *create_info;
 
-  TABLE_LIST src_tables_list;
+  TABLE_LIST src_tables_list, dst_tables_list;
   DBUG_ENTER("mysql_create_like_table");
 
   if (!(create_info= copy_create_info(lex_create_info)))
@@ -4609,13 +4637,6 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
     DBUG_RETURN(-1);
   }
 
-  bzero((gptr)&src_tables_list, sizeof(src_tables_list));
-  src_tables_list.db= src_db;
-  src_tables_list.table_name= src_table;
-
-  if (lock_and_wait_for_table_name(thd, &src_tables_list))
-    goto err;
-
   if ((tmp_table= find_temporary_table(thd, src_db, src_table)))
     strxmov(src_path, tmp_table->s->path.str, reg_ext, NullS);
   else
@@ -4642,6 +4663,34 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
     goto err;
   }
 
+  if (lower_case_table_names)
+  {
+    if (src_db)
+    {
+      strmake(src_db_name_buff, src_db,
+              min(sizeof(src_db_name_buff) - 1, table_ident->db.length));
+      my_casedn_str(files_charset_info, src_db_name_buff);
+      src_db= src_db_name_buff;
+    }
+    if (src_table)
+    {
+      strmake(src_table_name_buff, src_table,
+              min(sizeof(src_table_name_buff) - 1, table_ident->table.length));
+      my_casedn_str(files_charset_info, src_table_name_buff);
+      src_table= src_table_name_buff;
+    }
+  }
+
+  bzero((gptr)&src_tables_list, sizeof(src_tables_list));
+  src_tables_list.db= src_db;
+  src_tables_list.db_length= table_ident->db.length;
+  src_tables_list.lock_type= TL_READ;
+  src_tables_list.table_name= src_table;
+  src_tables_list.alias= src_table;
+
+  if (simple_open_n_lock_tables(thd, &src_tables_list))
+    DBUG_RETURN(TRUE);
+
   /*
     Validate the destination table
 
@@ -4745,17 +4794,29 @@ bool mysql_create_like_table(THD* thd, TABLE_LIST* table,
         char buf[2048];
         String query(buf, sizeof(buf), system_charset_info);
         query.length(0);  // Have to zero it since constructor doesn't
-        TABLE *table_ptr;
-        int error;
+        uint counter;
 
         /*
-          Let's open and lock the table: it will be closed (and
-          unlocked) by close_thread_tables() at the end of the
-          statement anyway.
-         */
-        if (!(table_ptr= open_ltable(thd, table, TL_READ_NO_INSERT)))
+          Here we open the destination table. This is needed for
+          store_create_info() to work. The table will be closed
+          by close_thread_tables() at the end of the statement.
+        */
+        if (open_tables(thd, &table, &counter, 0))
           goto err;
 
+        bzero((gptr)&dst_tables_list, sizeof(dst_tables_list));
+        dst_tables_list.db= table->db;
+        dst_tables_list.table_name= table->table_name;
+
+        /*
+          lock destination table name, to make sure that nobody
+          can drop/alter the table while we execute store_create_info()
+        */
+        if (lock_and_wait_for_table_name(thd, &dst_tables_list))
+          goto err;
+        else
+          unlock_dst_table= TRUE;
+
         int result= store_create_info(thd, table, &query, create_info);
 
         DBUG_ASSERT(result == 0); // store_create_info() always return 0
@@ -4788,9 +4849,12 @@ table_exists:
     my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
 
 err:
-  pthread_mutex_lock(&LOCK_open);
-  unlock_table_name(thd, &src_tables_list);
-  pthread_mutex_unlock(&LOCK_open);
+  if (unlock_dst_table)
+  {
+    pthread_mutex_lock(&LOCK_open);
+    unlock_table_name(thd, &dst_tables_list);
+    pthread_mutex_unlock(&LOCK_open);
+  }
   DBUG_RETURN(res);
 }
 
@@ -5179,33 +5243,23 @@ bool mysql_alter_table(THD *thd,char *new_db, char *new_name,
   LINT_INIT(index_add_buffer);
   LINT_INIT(index_drop_buffer);
 
-  if (table_list && table_list->db &&
-      !my_strcasecmp(system_charset_info, table_list->db, "mysql") &&
-      table_list->table_name)
+  if (table_list && table_list->db && table_list->table_name)
   {
-    enum enum_table_kind { NOT_LOG_TABLE= 1, GENERAL_LOG, SLOW_LOG }
-         table_kind= NOT_LOG_TABLE;
+    int table_kind= 0;
 
-    if (!my_strcasecmp(system_charset_info, table_list->table_name,
-                       "general_log"))
-      table_kind= GENERAL_LOG;
-    else
-      if (!my_strcasecmp(system_charset_info, table_list->table_name,
-                         "slow_log"))
-        table_kind= SLOW_LOG;
+    table_kind= check_if_log_table(table_list->db_length, table_list->db,
+                                   table_list->table_name_length,
+                                   table_list->table_name, 0);
 
     /* Disable alter of enabled log tables */
-    if ((table_kind == GENERAL_LOG && opt_log &&
-        logger.is_general_log_table_enabled()) ||
-       (table_kind == SLOW_LOG && opt_slow_log &&
-         logger.is_slow_log_table_enabled()))
+    if (table_kind && logger.is_log_table_enabled(table_kind))
     {
       my_error(ER_BAD_LOG_STATEMENT, MYF(0), "ALTER");
       DBUG_RETURN(TRUE);
     }
 
     /* Disable alter of log tables to unsupported engine */
-    if ((table_kind == GENERAL_LOG || table_kind == SLOW_LOG) &&
+    if (table_kind &&
         (lex_create_info->used_fields & HA_CREATE_USED_ENGINE) &&
         (!lex_create_info->db_type || /* unknown engine */
         !(lex_create_info->db_type->flags & HTON_SUPPORT_LOG_TABLES)))
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index acb7d5b61df..ca95b39f215 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -36,17 +36,17 @@ static File_option triggers_file_parameters[]=
 {
   {
     { C_STRING_WITH_LEN("triggers") },
-    offsetof(class Table_triggers_list, definitions_list),
+    my_offsetof(class Table_triggers_list, definitions_list),
     FILE_OPTIONS_STRLIST
   },
   {
     { C_STRING_WITH_LEN("sql_modes") },
-    offsetof(class Table_triggers_list, definition_modes_list),
+    my_offsetof(class Table_triggers_list, definition_modes_list),
     FILE_OPTIONS_ULLLIST
   },
   {
     { C_STRING_WITH_LEN("definers") },
-    offsetof(class Table_triggers_list, definers_list),
+    my_offsetof(class Table_triggers_list, definers_list),
     FILE_OPTIONS_STRLIST
   },
   { { 0, 0 }, 0, FILE_OPTIONS_STRING }
@@ -55,7 +55,7 @@ static File_option triggers_file_parameters[]=
 File_option sql_modes_parameters=
 {
   { C_STRING_WITH_LEN("sql_modes") },
-  offsetof(class Table_triggers_list, definition_modes_list),
+  my_offsetof(class Table_triggers_list, definition_modes_list),
   FILE_OPTIONS_ULLLIST
 };
 
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index 744fbf1c9f1..22d9024982f 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -236,25 +236,9 @@ bool mysql_create_view(THD *thd,
   bool res= FALSE;
   DBUG_ENTER("mysql_create_view");
 
-  if (lex->proc_list.first ||
-      lex->result)
-  {
-    my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), (lex->result ?
-                                             "INTO" :
-                                             "PROCEDURE"));
-    res= TRUE;
-    goto err;
-  }
-  if (lex->derived_tables ||
-      lex->variables_used || lex->param_list.elements)
-  {
-    int err= (lex->derived_tables ?
-              ER_VIEW_SELECT_DERIVED :
-              ER_VIEW_SELECT_VARIABLE);
-    my_message(err, ER(err), MYF(0));
-    res= TRUE;
-    goto err;
-  }
+  /* This is ensured in the parser. */
+  DBUG_ASSERT(!lex->proc_list.first && !lex->result &&
+              !lex->param_list.elements && !lex->derived_tables);
 
   if (mode != VIEW_CREATE_NEW)
   {
@@ -582,40 +566,40 @@ static const int num_view_backups= 3;
 */
 static File_option view_parameters[]=
 {{{ C_STRING_WITH_LEN("query")},
-  offsetof(TABLE_LIST, query),
+  my_offsetof(TABLE_LIST, query),
   FILE_OPTIONS_ESTRING},
  {{ C_STRING_WITH_LEN("md5")},
-  offsetof(TABLE_LIST, md5),
+  my_offsetof(TABLE_LIST, md5),
   FILE_OPTIONS_STRING},
  {{ C_STRING_WITH_LEN("updatable")},
-  offsetof(TABLE_LIST, updatable_view),
+  my_offsetof(TABLE_LIST, updatable_view),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("algorithm")},
-  offsetof(TABLE_LIST, algorithm),
+  my_offsetof(TABLE_LIST, algorithm),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("definer_user")},
-  offsetof(TABLE_LIST, definer.user),
+  my_offsetof(TABLE_LIST, definer.user),
   FILE_OPTIONS_STRING},
  {{ C_STRING_WITH_LEN("definer_host")},
-  offsetof(TABLE_LIST, definer.host),
+  my_offsetof(TABLE_LIST, definer.host),
   FILE_OPTIONS_STRING},
  {{ C_STRING_WITH_LEN("suid")},
-  offsetof(TABLE_LIST, view_suid),
+  my_offsetof(TABLE_LIST, view_suid),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("with_check_option")},
-  offsetof(TABLE_LIST, with_check),
+  my_offsetof(TABLE_LIST, with_check),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("revision")},
-  offsetof(TABLE_LIST, revision),
+  my_offsetof(TABLE_LIST, revision),
   FILE_OPTIONS_REV},
  {{ C_STRING_WITH_LEN("timestamp")},
-  offsetof(TABLE_LIST, timestamp),
+  my_offsetof(TABLE_LIST, timestamp),
   FILE_OPTIONS_TIMESTAMP},
  {{ C_STRING_WITH_LEN("create-version")},
-  offsetof(TABLE_LIST, file_version),
+  my_offsetof(TABLE_LIST, file_version),
   FILE_OPTIONS_ULONGLONG},
  {{ C_STRING_WITH_LEN("source")},
-  offsetof(TABLE_LIST, source),
+  my_offsetof(TABLE_LIST, source),
   FILE_OPTIONS_ESTRING},
  {{NullS, 0},			0,
   FILE_OPTIONS_STRING}
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index a5a9430504e..f2c72654473 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -56,12 +56,17 @@ const LEX_STRING null_lex_str={0,0};
   }
 
 /* Helper for parsing "IS [NOT] truth_value" */
-inline Item *is_truth_value(Item *A, bool v1, bool v2)
+inline Item *is_truth_value(THD *thd, Item *A, bool v1, bool v2)
 {
-  return new Item_func_if(create_func_ifnull(A,
-	new Item_int((char *) (v2 ? "TRUE" : "FALSE"), v2, 1)),
-	new Item_int((char *) (v1 ? "TRUE" : "FALSE"), v1, 1),
-	new Item_int((char *) (v1 ? "FALSE" : "TRUE"),!v1, 1));
+  Item *v1_t= new (thd->mem_root) Item_int((char *) (v1 ? "TRUE" : "FALSE"),
+                                           v1, 1);
+  Item *v1_f= new (thd->mem_root) Item_int((char *) (v1 ? "FALSE" : "TRUE"),
+                                           !v1, 1);
+  Item *v2_t= new (thd->mem_root) Item_int((char *) (v2 ? "TRUE" : "FALSE"),
+                                           v2, 1);
+  Item *ifnull= new (thd->mem_root) Item_func_ifnull(A, v2_t);
+
+  return new (thd->mem_root) Item_func_if(ifnull, v1_t, v1_f);
 }
 
 #ifndef DBUG_OFF
@@ -142,213 +147,209 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %pure_parser					/* We have threads */
 
-%token  END_OF_INPUT
+/*
+   Comments for TOKENS.
+   For each token, please include in the same line a comment that contains
+   the following tags:
+   SQL-2003-R : Reserved keyword as per SQL-2003
+   SQL-2003-N : Non Reserved keyword as per SQL-2003
+   SQL-1999-R : Reserved keyword as per SQL-1999
+   SQL-1999-N : Non Reserved keyword as per SQL-1999
+   MYSQL      : MySQL extention (unspecified)
+   MYSQL-FUNC : MySQL extention, function
+   INTERNAL   : Not a real token, lex optimization
+   OPERATOR   : SQL operator
+   FUTURE-USE : Reserved for futur use
+
+   This makes the code grep-able, and helps maintenance.
+*/
 
-%token  ABORT_SYM
+%token  ABORT_SYM                     /* INTERNAL (used in lex) */
 %token  ACCESSIBLE_SYM
-%token  ACTION
-%token  ADD
-%token  ADDDATE_SYM
-%token  AFTER_SYM
+%token  ACTION                        /* SQL-2003-N */
+%token  ADD                           /* SQL-2003-R */
+%token  ADDDATE_SYM                   /* MYSQL-FUNC */
+%token  AFTER_SYM                     /* SQL-2003-N */
 %token  AGAINST
 %token  AGGREGATE_SYM
 %token  ALGORITHM_SYM
-%token  ALL
-%token  ALTER
+%token  ALL                           /* SQL-2003-R */
+%token  ALTER                         /* SQL-2003-R */
 %token  ANALYZE_SYM
-%token  AND_AND_SYM
-%token  AND_SYM
-%token  ANY_SYM
-%token  AS
-%token  ASC
-%token  ASCII_SYM
-%token  ASENSITIVE_SYM
-%token  AT_SYM
-%token  ATAN
+%token  AND_AND_SYM                   /* OPERATOR */
+%token  AND_SYM                       /* SQL-2003-R */
+%token  ANY_SYM                       /* SQL-2003-R */
+%token  AS                            /* SQL-2003-R */
+%token  ASC                           /* SQL-2003-N */
+%token  ASCII_SYM                     /* MYSQL-FUNC */
+%token  ASENSITIVE_SYM                /* FUTURE-USE */
+%token  AT_SYM                        /* SQL-2003-R */
 %token  AUTHORS_SYM
-%token  AUTO_INC
 %token  AUTOEXTEND_SIZE_SYM
+%token  AUTO_INC
 %token  AVG_ROW_LENGTH
-%token  AVG_SYM
+%token  AVG_SYM                       /* SQL-2003-N */
 %token  BACKUP_SYM
-%token  BEFORE_SYM
-%token  BEGIN_SYM
-%token  BENCHMARK_SYM
-%token  BIGINT
-%token  BINARY
+%token  BEFORE_SYM                    /* SQL-2003-N */
+%token  BEGIN_SYM                     /* SQL-2003-R */
+%token  BETWEEN_SYM                   /* SQL-2003-R */
+%token  BIGINT                        /* SQL-2003-R */
+%token  BINARY                        /* SQL-2003-R */
 %token  BINLOG_SYM
 %token  BIN_NUM
-%token  BIT_AND
-%token  BIT_OR
-%token  BIT_SYM
-%token  BIT_XOR
-%token  BLOB_SYM
-%token  BOOLEAN_SYM
+%token  BIT_AND                       /* MYSQL-FUNC */
+%token  BIT_OR                        /* MYSQL-FUNC */
+%token  BIT_SYM                       /* MYSQL-FUNC */
+%token  BIT_XOR                       /* MYSQL-FUNC */
+%token  BLOB_SYM                      /* SQL-2003-R */
+%token  BOOLEAN_SYM                   /* SQL-2003-R */
 %token  BOOL_SYM
-%token  BOTH
+%token  BOTH                          /* SQL-2003-R */
 %token  BTREE_SYM
-%token  BY
+%token  BY                            /* SQL-2003-R */
 %token  BYTE_SYM
 %token  CACHE_SYM
-%token  CALL_SYM
-%token  CASCADE
-%token  CASCADED
-%token  CAST_SYM
-%token  CHAIN_SYM
+%token  CALL_SYM                      /* SQL-2003-R */
+%token  CASCADE                       /* SQL-2003-N */
+%token  CASCADED                      /* SQL-2003-R */
+%token  CASE_SYM                      /* SQL-2003-R */
+%token  CAST_SYM                      /* SQL-2003-R */
+%token  CHAIN_SYM                     /* SQL-2003-N */
 %token  CHANGE
 %token  CHANGED
 %token  CHARSET
-%token  CHAR_SYM
+%token  CHAR_SYM                      /* SQL-2003-R */
 %token  CHECKSUM_SYM
-%token  CHECK_SYM
+%token  CHECK_SYM                     /* SQL-2003-R */
 %token  CIPHER_SYM
 %token  CLIENT_SYM
-%token  CLOSE_SYM
-%token  COALESCE
+%token  CLOSE_SYM                     /* SQL-2003-R */
+%token  COALESCE                      /* SQL-2003-N */
 %token  CODE_SYM
-%token  COLLATE_SYM
-%token  COLLATION_SYM
+%token  COLLATE_SYM                   /* SQL-2003-R */
+%token  COLLATION_SYM                 /* SQL-2003-N */
 %token  COLUMNS
-%token  COLUMN_SYM
+%token  COLUMN_SYM                    /* SQL-2003-R */
 %token  COMMENT_SYM
-%token  COMMITTED_SYM
-%token  COMMIT_SYM
+%token  COMMITTED_SYM                 /* SQL-2003-N */
+%token  COMMIT_SYM                    /* SQL-2003-R */
 %token  COMPACT_SYM
 %token  COMPLETION_SYM
 %token  COMPRESSED_SYM
-%token  CONCAT
-%token  CONCAT_WS
 %token  CONCURRENT
-%token  CONDITION_SYM
+%token  CONDITION_SYM                 /* SQL-2003-N */
 %token  CONNECTION_SYM
 %token  CONSISTENT_SYM
-%token  CONSTRAINT
-%token  CONTAINS_SYM
-%token  CONTINUE_SYM
+%token  CONSTRAINT                    /* SQL-2003-R */
+%token  CONTAINS_SYM                  /* SQL-2003-N */
+%token  CONTINUE_SYM                  /* SQL-2003-R */
 %token  CONTRIBUTORS_SYM
-%token  CONVERT_SYM
-%token  CONVERT_TZ_SYM
-%token  COUNT_SYM
-%token  CREATE
-%token  CROSS
-%token  CUBE_SYM
-%token  CURDATE
-%token  CURRENT_USER
-%token  CURSOR_SYM
-%token  CURTIME
+%token  CONVERT_SYM                   /* SQL-2003-N */
+%token  COUNT_SYM                     /* SQL-2003-N */
+%token  CREATE                        /* SQL-2003-R */
+%token  CROSS                         /* SQL-2003-R */
+%token  CUBE_SYM                      /* SQL-2003-R */
+%token  CURDATE                       /* MYSQL-FUNC */
+%token  CURRENT_USER                  /* SQL-2003-R */
+%token  CURSOR_SYM                    /* SQL-2003-R */
+%token  CURTIME                       /* MYSQL-FUNC */
 %token  DATABASE
 %token  DATABASES
 %token  DATAFILE_SYM
-%token  DATA_SYM
+%token  DATA_SYM                      /* SQL-2003-N */
 %token  DATETIME
-%token  DATE_ADD_INTERVAL
-%token  DATE_SUB_INTERVAL
-%token  DATE_SYM
+%token  DATE_ADD_INTERVAL             /* MYSQL-FUNC */
+%token  DATE_SUB_INTERVAL             /* MYSQL-FUNC */
+%token  DATE_SYM                      /* SQL-2003-R */
 %token  DAY_HOUR_SYM
 %token  DAY_MICROSECOND_SYM
 %token  DAY_MINUTE_SYM
 %token  DAY_SECOND_SYM
-%token  DAY_SYM
-%token  DEALLOCATE_SYM
+%token  DAY_SYM                       /* SQL-2003-R */
+%token  DEALLOCATE_SYM                /* SQL-2003-R */
 %token  DECIMAL_NUM
-%token  DECIMAL_SYM
-%token  DECLARE_SYM
-%token  DECODE_SYM
-%token  DEFAULT
+%token  DECIMAL_SYM                   /* SQL-2003-R */
+%token  DECLARE_SYM                   /* SQL-2003-R */
+%token  DEFAULT                       /* SQL-2003-R */
 %token  DEFINER_SYM
 %token  DELAYED_SYM
 %token  DELAY_KEY_WRITE_SYM
-%token  DELETE_SYM
-%token  DESC
-%token  DESCRIBE
-%token  DES_DECRYPT_SYM
-%token  DES_ENCRYPT_SYM
+%token  DELETE_SYM                    /* SQL-2003-R */
+%token  DESC                          /* SQL-2003-N */
+%token  DESCRIBE                      /* SQL-2003-R */
 %token  DES_KEY_FILE
-%token  DETERMINISTIC_SYM
+%token  DETERMINISTIC_SYM             /* SQL-2003-R */
 %token  DIRECTORY_SYM
 %token  DISABLE_SYM
 %token  DISCARD
 %token  DISK_SYM
-%token  DISTINCT
+%token  DISTINCT                      /* SQL-2003-R */
 %token  DIV_SYM
-%token  DOUBLE_SYM
+%token  DOUBLE_SYM                    /* SQL-2003-R */
 %token  DO_SYM
-%token  DROP
+%token  DROP                          /* SQL-2003-R */
 %token  DUAL_SYM
 %token  DUMPFILE
 %token  DUPLICATE_SYM
-%token  DYNAMIC_SYM
-%token  EACH_SYM
+%token  DYNAMIC_SYM                   /* SQL-2003-R */
+%token  EACH_SYM                      /* SQL-2003-R */
+%token  ELSE                          /* SQL-2003-R */
 %token  ELSEIF_SYM
-%token  ELT_FUNC
 %token  ENABLE_SYM
 %token  ENCLOSED
-%token  ENCODE_SYM
-%token  ENCRYPT
-%token  END
+%token  END                           /* SQL-2003-R */
 %token  ENDS_SYM
+%token  END_OF_INPUT                  /* INTERNAL */
 %token  ENGINES_SYM
 %token  ENGINE_SYM
 %token  ENUM
-%token  EQ
-%token  EQUAL_SYM
+%token  EQ                            /* OPERATOR */
+%token  EQUAL_SYM                     /* OPERATOR */
 %token  ERRORS
 %token  ESCAPED
-%token  ESCAPE_SYM
-%token  EVENT_SYM
+%token  ESCAPE_SYM                    /* SQL-2003-R */
 %token  EVENTS_SYM
-%token  EVERY_SYM
-%token  EXECUTE_SYM
-%token  EXISTS
+%token  EVENT_SYM
+%token  EVERY_SYM                     /* SQL-2003-N */
+%token  EXECUTE_SYM                   /* SQL-2003-R */
+%token  EXISTS                        /* SQL-2003-R */
 %token  EXIT_SYM
 %token  EXPANSION_SYM
-%token  EXPORT_SET
 %token  EXTENDED_SYM
 %token  EXTENT_SIZE_SYM
-%token  EXTRACT_SYM
-%token  FALSE_SYM
+%token  EXTRACT_SYM                   /* SQL-2003-N */
+%token  FALSE_SYM                     /* SQL-2003-R */
 %token  FAST_SYM
-%token  FETCH_SYM
-%token  FIELD_FUNC
+%token  FETCH_SYM                     /* SQL-2003-R */
 %token  FILE_SYM
-%token  FIRST_SYM
+%token  FIRST_SYM                     /* SQL-2003-N */
 %token  FIXED_SYM
 %token  FLOAT_NUM
-%token  FLOAT_SYM
+%token  FLOAT_SYM                     /* SQL-2003-R */
 %token  FLUSH_SYM
 %token  FORCE_SYM
-%token  FOREIGN
-%token  FORMAT_SYM
-%token  FOR_SYM
-%token  FOUND_SYM
+%token  FOREIGN                       /* SQL-2003-R */
+%token  FOR_SYM                       /* SQL-2003-R */
+%token  FOUND_SYM                     /* SQL-2003-R */
 %token  FRAC_SECOND_SYM
 %token  FROM
-%token  FROM_UNIXTIME
-%token  FULL
+%token  FULL                          /* SQL-2003-R */
 %token  FULLTEXT_SYM
-%token  FUNCTION_SYM
-%token  FUNC_ARG0
-%token  FUNC_ARG1
-%token  FUNC_ARG2
-%token  FUNC_ARG3
+%token  FUNCTION_SYM                  /* SQL-2003-R */
 %token  GE
-%token  GEOMCOLLFROMTEXT
 %token  GEOMETRYCOLLECTION
 %token  GEOMETRY_SYM
-%token  GEOMFROMTEXT
-%token  GEOMFROMWKB
-%token  GET_FORMAT
-%token  GLOBAL_SYM
-%token  GRANT
+%token  GET_FORMAT                    /* MYSQL-FUNC */
+%token  GLOBAL_SYM                    /* SQL-2003-R */
+%token  GRANT                         /* SQL-2003-R */
 %token  GRANTS
-%token  GREATEST_SYM
-%token  GROUP
+%token  GROUP                         /* SQL-2003-R */
 %token  GROUP_CONCAT_SYM
 %token  GROUP_UNIQUE_USERS
-%token  GT_SYM
+%token  GT_SYM                        /* OPERATOR */
 %token  HANDLER_SYM
 %token  HASH_SYM
-%token  HAVING
+%token  HAVING                        /* SQL-2003-R */
 %token  HELP_SYM
 %token  HEX_NUM
 %token  HIGH_PRIORITY
@@ -356,7 +357,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  HOUR_MICROSECOND_SYM
 %token  HOUR_MINUTE_SYM
 %token  HOUR_SECOND_SYM
-%token  HOUR_SYM
+%token  HOUR_SYM                      /* SQL-2003-R */
 %token  IDENT
 %token  IDENTIFIED_SYM
 %token  IDENT_QUOTED
@@ -367,70 +368,63 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  INDEX_SYM
 %token  INFILE
 %token  INITIAL_SIZE_SYM
-%token  INNER_SYM
+%token  INNER_SYM                     /* SQL-2003-R */
 %token  INNOBASE_SYM
-%token  INOUT_SYM
-%token  INSENSITIVE_SYM
-%token  INSERT
+%token  INOUT_SYM                     /* SQL-2003-R */
+%token  INSENSITIVE_SYM               /* SQL-2003-R */
+%token  INSERT                        /* SQL-2003-R */
 %token  INSERT_METHOD
 %token  INSTALL_SYM
-%token  INTERVAL_SYM
-%token  INTO
-%token  INT_SYM
+%token  INTERVAL_SYM                  /* SQL-2003-R */
+%token  INTO                          /* SQL-2003-R */
+%token  INT_SYM                       /* SQL-2003-R */
 %token  INVOKER_SYM
-%token  IN_SYM
-%token  IS
-%token  ISOLATION
+%token  IN_SYM                        /* SQL-2003-R */
+%token  IS                            /* SQL-2003-R */
+%token  ISOLATION                     /* SQL-2003-R */
 %token  ISSUER_SYM
 %token  ITERATE_SYM
-%token  JOIN_SYM
+%token  JOIN_SYM                      /* SQL-2003-R */
 %token  KEYS
-%token  KEY_SYM
 %token  KEY_BLOCK_SIZE
+%token  KEY_SYM                       /* SQL-2003-N */
 %token  KILL_SYM
-%token  LANGUAGE_SYM
-%token  LAST_INSERT_ID
-%token  LAST_SYM
-%token  LE
-%token  LEADING
-%token  LEAST_SYM
+%token  LANGUAGE_SYM                  /* SQL-2003-R */
+%token  LAST_SYM                      /* SQL-2003-N */
+%token  LE                            /* OPERATOR */
+%token  LEADING                       /* SQL-2003-R */
 %token  LEAVES
 %token  LEAVE_SYM
-%token  LEFT
+%token  LEFT                          /* SQL-2003-R */
 %token  LESS_SYM
 %token  LEVEL_SYM
 %token  LEX_HOSTNAME
-%token  LIKE
+%token  LIKE                          /* SQL-2003-R */
 %token  LIMIT
 %token  LINEAR_SYM
-%token  LINEFROMTEXT
 %token  LINES
 %token  LINESTRING
 %token  LIST_SYM
 %token  LOAD
-%token  LOCAL_SYM
-%token  LOCATE
-%token  LOCATOR_SYM
+%token  LOCAL_SYM                     /* SQL-2003-R */
+%token  LOCATOR_SYM                   /* SQL-2003-N */
 %token  LOCKS_SYM
 %token  LOCK_SYM
 %token  LOGFILE_SYM
 %token  LOGS_SYM
-%token  LOG_SYM
 %token  LONGBLOB
 %token  LONGTEXT
 %token  LONG_NUM
 %token  LONG_SYM
 %token  LOOP_SYM
 %token  LOW_PRIORITY
-%token  LT
-%token  MAKE_SET_SYM
+%token  LT                            /* OPERATOR */
 %token  MASTER_CONNECT_RETRY_SYM
 %token  MASTER_HOST_SYM
 %token  MASTER_LOG_FILE_SYM
 %token  MASTER_LOG_POS_SYM
 %token  MASTER_PASSWORD_SYM
 %token  MASTER_PORT_SYM
-%token  MASTER_POS_WAIT
 %token  MASTER_SERVER_ID_SYM
 %token  MASTER_SSL_CAPATH_SYM
 %token  MASTER_SSL_CA_SYM
@@ -440,134 +434,128 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  MASTER_SSL_SYM
 %token  MASTER_SYM
 %token  MASTER_USER_SYM
-%token  MATCH
+%token  MATCH                         /* SQL-2003-R */
 %token  MAX_CONNECTIONS_PER_HOUR
 %token  MAX_QUERIES_PER_HOUR
 %token  MAX_ROWS
 %token  MAX_SIZE_SYM
-%token  MAX_SYM
+%token  MAX_SYM                       /* SQL-2003-N */
 %token  MAX_UPDATES_PER_HOUR
 %token  MAX_USER_CONNECTIONS_SYM
-%token  MAX_VALUE_SYM
+%token  MAX_VALUE_SYM                 /* SQL-2003-N */
 %token  MEDIUMBLOB
 %token  MEDIUMINT
 %token  MEDIUMTEXT
 %token  MEDIUM_SYM
 %token  MEMORY_SYM
-%token  MERGE_SYM
-%token  MICROSECOND_SYM
+%token  MERGE_SYM                     /* SQL-2003-R */
+%token  MICROSECOND_SYM               /* MYSQL-FUNC */
 %token  MIGRATE_SYM
 %token  MINUTE_MICROSECOND_SYM
 %token  MINUTE_SECOND_SYM
-%token  MINUTE_SYM
+%token  MINUTE_SYM                    /* SQL-2003-R */
 %token  MIN_ROWS
-%token  MIN_SYM
-%token  MLINEFROMTEXT
+%token  MIN_SYM                       /* SQL-2003-N */
 %token  MODE_SYM
-%token  MODIFIES_SYM
+%token  MODIFIES_SYM                  /* SQL-2003-R */
 %token  MODIFY_SYM
-%token  MOD_SYM
-%token  MONTH_SYM
-%token  MPOINTFROMTEXT
-%token  MPOLYFROMTEXT
+%token  MOD_SYM                       /* SQL-2003-N */
+%token  MONTH_SYM                     /* SQL-2003-R */
 %token  MULTILINESTRING
 %token  MULTIPOINT
 %token  MULTIPOLYGON
 %token  MUTEX_SYM
-%token  NAMES_SYM
-%token  NAME_SYM
-%token  NATIONAL_SYM
-%token  NATURAL
+%token  NAMES_SYM                     /* SQL-2003-N */
+%token  NAME_SYM                      /* SQL-2003-N */
+%token  NATIONAL_SYM                  /* SQL-2003-R */
+%token  NATURAL                       /* SQL-2003-R */
 %token  NCHAR_STRING
-%token  NCHAR_SYM
+%token  NCHAR_SYM                     /* SQL-2003-R */
 %token  NDBCLUSTER_SYM
-%token  NE
-%token  NEW_SYM
-%token  NEXT_SYM
+%token  NE                            /* OPERATOR */
+%token  NEG
+%token  NEW_SYM                       /* SQL-2003-R */
+%token  NEXT_SYM                      /* SQL-2003-N */
 %token  NODEGROUP_SYM
-%token  NONE_SYM
+%token  NONE_SYM                      /* SQL-2003-R */
 %token  NOT2_SYM
-%token  NOT_SYM
+%token  NOT_SYM                       /* SQL-2003-R */
 %token  NOW_SYM
-%token  NO_SYM
+%token  NO_SYM                        /* SQL-2003-R */
 %token  NO_WAIT_SYM
 %token  NO_WRITE_TO_BINLOG
-%token  NULL_SYM
+%token  NULL_SYM                      /* SQL-2003-R */
 %token  NUM
-%token  NUMERIC_SYM
+%token  NUMERIC_SYM                   /* SQL-2003-R */
 %token  NVARCHAR_SYM
 %token  OFFSET_SYM
-%token  OJ_SYM
 %token  OLD_PASSWORD
-%token  ON
+%token  ON                            /* SQL-2003-R */
 %token  ONE_SHOT_SYM
 %token  ONE_SYM
-%token  OPEN_SYM
+%token  OPEN_SYM                      /* SQL-2003-R */
 %token  OPTIMIZE
-%token  OPTION
+%token  OPTION                        /* SQL-2003-N */
 %token  OPTIONALLY
 %token  OR2_SYM
-%token  ORDER_SYM
-%token  OR_OR_SYM
-%token  OR_SYM
+%token  ORDER_SYM                     /* SQL-2003-R */
+%token  OR_OR_SYM                     /* OPERATOR */
+%token  OR_SYM                        /* SQL-2003-R */
 %token  OUTER
 %token  OUTFILE
-%token  OUT_SYM
+%token  OUT_SYM                       /* SQL-2003-R */
 %token  PACK_KEYS_SYM
+%token  PARAM_MARKER
 %token  PARSER_SYM
-%token  PARTIAL
-%token  PARTITION_SYM
+%token  PARTIAL                       /* SQL-2003-N */
 %token  PARTITIONING_SYM
 %token  PARTITIONS_SYM
+%token  PARTITION_SYM                 /* SQL-2003-R */
 %token  PASSWORD
-%token  PARAM_MARKER
 %token  PHASE_SYM
-%token  PLUGIN_SYM
 %token  PLUGINS_SYM
-%token  POINTFROMTEXT
+%token  PLUGIN_SYM
 %token  POINT_SYM
-%token  POLYFROMTEXT
 %token  POLYGON
-%token  POSITION_SYM
-%token  PRECISION
-%token  PREPARE_SYM
+%token  POSITION_SYM                  /* SQL-2003-N */
+%token  PRECISION                     /* SQL-2003-R */
+%token  PREPARE_SYM                   /* SQL-2003-R */
 %token  PRESERVE_SYM
 %token  PREV_SYM
-%token  PRIMARY_SYM
-%token  PRIVILEGES
-%token  PROCEDURE
+%token  PRIMARY_SYM                   /* SQL-2003-R */
+%token  PRIVILEGES                    /* SQL-2003-N */
+%token  PROCEDURE                     /* SQL-2003-R */
 %token  PROCESS
 %token  PROCESSLIST_SYM
 %token  PURGE
 %token  QUARTER_SYM
 %token  QUERY_SYM
 %token  QUICK
-%token  RAND
-%token  RANGE_SYM
-%token  READS_SYM
+%token  RANGE_SYM                     /* SQL-2003-R */
+%token  READS_SYM                     /* SQL-2003-R */
 %token  READ_ONLY_SYM
-%token  READ_SYM
+%token  READ_SYM                      /* SQL-2003-N */
 %token  READ_WRITE_SYM
-%token  REAL
+%token  REAL                          /* SQL-2003-R */
 %token  REBUILD_SYM
 %token  RECOVER_SYM
-%token  REDO_BUFFER_SIZE_SYM
 %token  REDOFILE_SYM
+%token  REDO_BUFFER_SIZE_SYM
 %token  REDUNDANT_SYM
-%token  REFERENCES
+%token  REFERENCES                    /* SQL-2003-R */
 %token  REGEXP
 %token  RELAY_LOG_FILE_SYM
 %token  RELAY_LOG_POS_SYM
 %token  RELAY_THREAD
-%token  RELEASE_SYM
+%token  RELEASE_SYM                   /* SQL-2003-R */
 %token  RELOAD
 %token  REMOVE_SYM
 %token  RENAME
 %token  REORGANIZE_SYM
 %token  REPAIR
-%token  REPEATABLE_SYM
-%token  REPEAT_SYM
-%token  REPLACE
+%token  REPEATABLE_SYM                /* SQL-2003-N */
+%token  REPEAT_SYM                    /* MYSQL-FUNC */
+%token  REPLACE                       /* MYSQL-FUNC */
 %token  REPLICATION
 %token  REQUIRE_SYM
 %token  RESET_SYM
@@ -575,159 +563,155 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  RESTORE_SYM
 %token  RESTRICT
 %token  RESUME_SYM
-%token  RETURNS_SYM
-%token  RETURN_SYM
-%token  REVOKE
-%token  RIGHT
-%token  ROLLBACK_SYM
-%token  ROLLUP_SYM
-%token  ROUND
-%token  ROUTINE_SYM
-%token  ROWS_SYM
-%token  ROW_COUNT_SYM
+%token  RETURNS_SYM                   /* SQL-2003-R */
+%token  RETURN_SYM                    /* SQL-2003-R */
+%token  REVOKE                        /* SQL-2003-R */
+%token  RIGHT                         /* SQL-2003-R */
+%token  ROLLBACK_SYM                  /* SQL-2003-R */
+%token  ROLLUP_SYM                    /* SQL-2003-R */
+%token  ROUTINE_SYM                   /* SQL-2003-N */
+%token  ROWS_SYM                      /* SQL-2003-R */
 %token  ROW_FORMAT_SYM
-%token  ROW_SYM
+%token  ROW_SYM                       /* SQL-2003-R */
 %token  RTREE_SYM
-%token  SAVEPOINT_SYM
+%token  SAVEPOINT_SYM                 /* SQL-2003-R */
 %token  SCHEDULE_SYM
 %token  SECOND_MICROSECOND_SYM
-%token  SECOND_SYM
-%token  SECURITY_SYM
-%token  SELECT_SYM
-%token  SENSITIVE_SYM
+%token  SECOND_SYM                    /* SQL-2003-R */
+%token  SECURITY_SYM                  /* SQL-2003-N */
+%token  SELECT_SYM                    /* SQL-2003-R */
+%token  SENSITIVE_SYM                 /* FUTURE-USE */
 %token  SEPARATOR_SYM
-%token  SERIALIZABLE_SYM
+%token  SERIALIZABLE_SYM              /* SQL-2003-N */
 %token  SERIAL_SYM
-%token  SESSION_SYM
-%token  SET
+%token  SESSION_SYM                   /* SQL-2003-N */
+%token  SET                           /* SQL-2003-R */
 %token  SET_VAR
 %token  SHARE_SYM
-%token  SHIFT_LEFT
-%token  SHIFT_RIGHT
+%token  SHIFT_LEFT                    /* OPERATOR */
+%token  SHIFT_RIGHT                   /* OPERATOR */
 %token  SHOW
 %token  SHUTDOWN
 %token  SIGNED_SYM
-%token  SIMPLE_SYM
+%token  SIMPLE_SYM                    /* SQL-2003-N */
 %token  SLAVE
-%token  SMALLINT
+%token  SMALLINT                      /* SQL-2003-R */
 %token  SNAPSHOT_SYM
 %token  SONAME_SYM
 %token  SOUNDS_SYM
 %token  SPATIAL_SYM
-%token  SPECIFIC_SYM
-%token  SQLEXCEPTION_SYM
-%token  SQLSTATE_SYM
-%token  SQLWARNING_SYM
+%token  SPECIFIC_SYM                  /* SQL-2003-R */
+%token  SQLEXCEPTION_SYM              /* SQL-2003-R */
+%token  SQLSTATE_SYM                  /* SQL-2003-R */
+%token  SQLWARNING_SYM                /* SQL-2003-R */
 %token  SQL_BIG_RESULT
 %token  SQL_BUFFER_RESULT
 %token  SQL_CACHE_SYM
 %token  SQL_CALC_FOUND_ROWS
 %token  SQL_NO_CACHE_SYM
 %token  SQL_SMALL_RESULT
-%token  SQL_SYM
+%token  SQL_SYM                       /* SQL-2003-R */
 %token  SQL_THREAD
 %token  SSL_SYM
 %token  STARTING
-%token  START_SYM
 %token  STARTS_SYM
+%token  START_SYM                     /* SQL-2003-R */
 %token  STATUS_SYM
+%token  STDDEV_SAMP_SYM               /* SQL-2003-N */
 %token  STD_SYM
-%token  STDDEV_SAMP_SYM
 %token  STOP_SYM
 %token  STORAGE_SYM
 %token  STRAIGHT_JOIN
 %token  STRING_SYM
 %token  SUBDATE_SYM
 %token  SUBJECT_SYM
-%token  SUBPARTITION_SYM
 %token  SUBPARTITIONS_SYM
-%token  SUBSTRING
-%token  SUBSTRING_INDEX
-%token  SUM_SYM
+%token  SUBPARTITION_SYM
+%token  SUBSTRING                     /* SQL-2003-N */
+%token  SUM_SYM                       /* SQL-2003-N */
 %token  SUPER_SYM
 %token  SUSPEND_SYM
 %token  SYSDATE
 %token  TABLES
 %token  TABLESPACE
-%token  TABLE_SYM
-%token  TEMPORARY
+%token  TABLE_REF_PRIORITY
+%token  TABLE_SYM                     /* SQL-2003-R */
+%token  TEMPORARY                     /* SQL-2003-N */
 %token  TEMPTABLE_SYM
 %token  TERMINATED
 %token  TEXT_STRING
 %token  TEXT_SYM
-%token  TIMESTAMP
+%token  THAN_SYM
+%token  THEN_SYM                      /* SQL-2003-R */
+%token  TIMESTAMP                     /* SQL-2003-R */
 %token  TIMESTAMP_ADD
 %token  TIMESTAMP_DIFF
-%token  TIME_SYM
+%token  TIME_SYM                      /* SQL-2003-R */
 %token  TINYBLOB
 %token  TINYINT
 %token  TINYTEXT
-%token  THAN_SYM
-%token  TO_SYM
-%token  TRAILING
+%token  TO_SYM                        /* SQL-2003-R */
+%token  TRAILING                      /* SQL-2003-R */
 %token  TRANSACTION_SYM
-%token  TRIGGER_SYM
 %token  TRIGGERS_SYM
-%token  TRIM
-%token  TRUE_SYM
+%token  TRIGGER_SYM                   /* SQL-2003-R */
+%token  TRIM                          /* SQL-2003-N */
+%token  TRUE_SYM                      /* SQL-2003-R */
 %token  TRUNCATE_SYM
 %token  TYPES_SYM
-%token  TYPE_SYM
+%token  TYPE_SYM                      /* SQL-2003-N */
 %token  UDF_RETURNS_SYM
 %token  ULONGLONG_NUM
-%token  UNCOMMITTED_SYM
+%token  UNCOMMITTED_SYM               /* SQL-2003-N */
 %token  UNDEFINED_SYM
-%token  UNDO_BUFFER_SIZE_SYM
-%token  UNDOFILE_SYM
 %token  UNDERSCORE_CHARSET
-%token  UNDO_SYM
+%token  UNDOFILE_SYM
+%token  UNDO_BUFFER_SIZE_SYM
+%token  UNDO_SYM                      /* FUTURE-USE */
 %token  UNICODE_SYM
 %token  UNINSTALL_SYM
-%token  UNION_SYM
+%token  UNION_SYM                     /* SQL-2003-R */
 %token  UNIQUE_SYM
 %token  UNIQUE_USERS
-%token  UNIX_TIMESTAMP
-%token  UNKNOWN_SYM
+%token  UNKNOWN_SYM                   /* SQL-2003-R */
 %token  UNLOCK_SYM
 %token  UNSIGNED
 %token  UNTIL_SYM
-%token  UPDATE_SYM
+%token  UPDATE_SYM                    /* SQL-2003-R */
 %token  UPGRADE_SYM
-%token  USAGE
-%token  USER
+%token  USAGE                         /* SQL-2003-N */
+%token  USER                          /* SQL-2003-R */
 %token  USE_FRM
 %token  USE_SYM
-%token  USING
+%token  USING                         /* SQL-2003-R */
 %token  UTC_DATE_SYM
 %token  UTC_TIMESTAMP_SYM
 %token  UTC_TIME_SYM
-%token  VAR_SAMP_SYM
-%token  VALUES
-%token  VALUE_SYM
+%token  VALUES                        /* SQL-2003-R */
+%token  VALUE_SYM                     /* SQL-2003-R */
 %token  VARBINARY
-%token  VARCHAR
+%token  VARCHAR                       /* SQL-2003-R */
 %token  VARIABLES
 %token  VARIANCE_SYM
-%token  VARYING
-%token  VIEW_SYM
+%token  VARYING                       /* SQL-2003-R */
+%token  VAR_SAMP_SYM
+%token  VIEW_SYM                      /* SQL-2003-N */
 %token  WAIT_SYM
 %token  WARNINGS
 %token  WEEK_SYM
-%token  WHEN_SYM
-%token  WHERE
+%token  WHEN_SYM                      /* SQL-2003-R */
+%token  WHERE                         /* SQL-2003-R */
 %token  WHILE_SYM
-%token  WITH
-%token  WORK_SYM
-%token  WRITE_SYM
+%token  WITH                          /* SQL-2003-R */
+%token  WORK_SYM                      /* SQL-2003-N */
+%token  WRITE_SYM                     /* SQL-2003-N */
 %token  X509_SYM
 %token  XA_SYM
 %token  XOR
-%token  YEARWEEK
 %token  YEAR_MONTH_SYM
-%token  YEAR_SYM
+%token  YEAR_SYM                      /* SQL-2003-R */
 %token  ZEROFILL
 
-
 %left   JOIN_SYM INNER_SYM STRAIGHT_JOIN CROSS LEFT RIGHT
 /* A dummy token to force the priority of table_ref production in a join. */
 %left   TABLE_REF_PRIORITY
@@ -793,7 +777,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <item>
 	literal text_literal insert_ident order_ident
 	simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr
-	bool_term bool_factor bool_test bool_pri 
+	variable variable_aux bool_term bool_factor bool_test bool_pri 
 	predicate bit_expr bit_term bit_factor value_expr term factor
 	table_wild simple_expr udf_expr
 	expr_or_default set_expr_or_default interval_expr
@@ -803,6 +787,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 	simple_ident_nospvar simple_ident_q
         field_or_var limit_option
         part_func_expr
+        function_call_keyword
+        function_call_nonkeyword
+        function_call_generic
+        function_call_conflict
 
 %type <item_num>
 	NUM_literal
@@ -810,6 +798,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %type <item_list>
 	expr_list udf_expr_list udf_expr_list2 when_list
 	ident_list ident_list_arg
+        expr_list_opt
 
 %type <var_type>
         option_type opt_var_type opt_var_ident_type
@@ -848,7 +837,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
 %type <udf_type> udf_func_type
 
-%type <symbol> FUNC_ARG0 FUNC_ARG1 FUNC_ARG2 FUNC_ARG3 keyword keyword_sp
+%type <symbol> keyword keyword_sp
 
 %type <lex_user> user grant_user
 
@@ -1329,7 +1318,6 @@ event_tail:
 
             Lex->sql_command= SQLCOM_CREATE_EVENT;
             /* We need that for disallowing subqueries */
-            Lex->expr_allows_subselect= FALSE;
           }
           ON SCHEDULE_SYM ev_schedule_time
           opt_ev_on_completion
@@ -1351,7 +1339,6 @@ event_tail:
               can overwrite it
             */
             Lex->sql_command= SQLCOM_CREATE_EVENT;
-            Lex->expr_allows_subselect= TRUE;
           }
       ;
 
@@ -1725,15 +1712,20 @@ call:
 	    lex->value_list.empty();
 	    sp_add_used_routine(lex, YYTHD, $2, TYPE_ENUM_PROCEDURE);
 	  }
-          '(' sp_cparam_list ')' {}
+          opt_sp_cparam_list {}
 	;
 
 /* CALL parameters */
-sp_cparam_list:
+opt_sp_cparam_list:
 	  /* Empty */
-	| sp_cparams
+	| '(' opt_sp_cparams ')'
 	;
 
+opt_sp_cparams:
+          /* Empty */
+        | sp_cparams
+        ;
+
 sp_cparams:
 	  sp_cparams ',' expr
 	  {
@@ -4732,8 +4724,6 @@ alter:
             YYTHD->client_capabilities &= ~CLIENT_MULTI_QUERIES;
 
             Lex->sql_command= SQLCOM_ALTER_EVENT;
-            /* we need that for disallowing subqueries */
-            Lex->expr_allows_subselect= FALSE;
           }
           ev_alter_on_schedule_completion
           opt_ev_rename_to
@@ -4759,7 +4749,6 @@ alter:
               can overwrite it
             */
             Lex->sql_command= SQLCOM_ALTER_EVENT;
-            Lex->expr_allows_subselect= TRUE;
           }
         | ALTER TABLESPACE alter_tablespace_info
           {
@@ -5821,10 +5810,10 @@ bool_factor:
 	| bool_test ;
 
 bool_test:
-	bool_pri IS TRUE_SYM	{ $$= is_truth_value($1,1,0); }
-	| bool_pri IS not TRUE_SYM { $$= is_truth_value($1,0,0); }
-	| bool_pri IS FALSE_SYM	{ $$= is_truth_value($1,0,1); }
-	| bool_pri IS not FALSE_SYM { $$= is_truth_value($1,1,1); }
+	bool_pri IS TRUE_SYM	{ $$= is_truth_value(YYTHD, $1,1,0); }
+	| bool_pri IS not TRUE_SYM { $$= is_truth_value(YYTHD, $1,0,0); }
+	| bool_pri IS FALSE_SYM	{ $$= is_truth_value(YYTHD, $1,0,1); }
+	| bool_pri IS not FALSE_SYM { $$= is_truth_value(YYTHD, $1,1,1); }
 	| bool_pri IS UNKNOWN_SYM { $$= new Item_func_isnull($1); }
 	| bool_pri IS not UNKNOWN_SYM { $$= new Item_func_isnotnull($1); }
 	| bool_pri ;
@@ -5945,81 +5934,67 @@ interval_expr:
 
 simple_expr:
 	simple_ident
+        | function_call_keyword
+        | function_call_nonkeyword
+        | function_call_generic
+        | function_call_conflict
  	| simple_expr COLLATE_SYM ident_or_text %prec NEG
 	  {
-	    $$= new Item_func_set_collation($1,
-					    new Item_string($3.str,
-							    $3.length,
-                                                            YYTHD->charset()));
+            THD *thd= YYTHD;
+            Item *i1= new (thd->mem_root) Item_string($3.str,
+                                                      $3.length,
+                                                      thd->charset());
+	    $$= new (thd->mem_root) Item_func_set_collation($1, i1);
 	  }
 	| literal
 	| param_marker
-	| '@' ident_or_text SET_VAR expr
-	  {
-	    $$= new Item_func_set_user_var($2,$4);
-	    LEX *lex= Lex;
-	    lex->uncacheable(UNCACHEABLE_RAND);
-	    lex->variables_used= 1;
-	  }
-	| '@' ident_or_text
-	  {
-	    $$= new Item_func_get_user_var($2);
-	    LEX *lex= Lex;
-	    lex->uncacheable(UNCACHEABLE_RAND);
-	    lex->variables_used= 1;
-	  }
-	| '@' '@' opt_var_ident_type ident_or_text opt_component
-	  {
-
-            if ($4.str && $5.str && check_reserved_words(&$4))
-            {
-              yyerror(ER(ER_SYNTAX_ERROR));
-              YYABORT;
-            }
-	    if (!($$= get_system_var(YYTHD, $3, $4, $5)))
-	      YYABORT;
-	    Lex->variables_used= 1;
-	  }
+	| variable
 	| sum_expr
 	| simple_expr OR_OR_SYM simple_expr
-	  { $$= new Item_func_concat($1, $3); }
+	  { $$= new (YYTHD->mem_root) Item_func_concat($1, $3); }
 	| '+' simple_expr %prec NEG	{ $$= $2; }
-	| '-' simple_expr %prec NEG	{ $$= new Item_func_neg($2); }
-	| '~' simple_expr %prec NEG	{ $$= new Item_func_bit_neg($2); }
-	| not2 simple_expr %prec NEG	{ $$= negate_expression(YYTHD, $2); }
+	| '-' simple_expr %prec NEG
+          { $$= new (YYTHD->mem_root) Item_func_neg($2); }
+	| '~' simple_expr %prec NEG
+          { $$= new (YYTHD->mem_root) Item_func_bit_neg($2); }
+	| not2 simple_expr %prec NEG
+          { $$= negate_expression(YYTHD, $2); }
 	| '(' subselect ')'   
           { 
-            $$= new Item_singlerow_subselect($2); 
+            $$= new (YYTHD->mem_root) Item_singlerow_subselect($2); 
           }
 	| '(' expr ')'		{ $$= $2; }
 	| '(' expr ',' expr_list ')'
 	  {
 	    $4->push_front($2);
-	    $$= new Item_row(*$4);
+	    $$= new (YYTHD->mem_root) Item_row(*$4);
 	  }
 	| ROW_SYM '(' expr ',' expr_list ')'
 	  {
 	    $5->push_front($3);
-	    $$= new Item_row(*$5);
+	    $$= new (YYTHD->mem_root) Item_row(*$5);
 	  }
 	| EXISTS '(' subselect ')' 
           {
-            $$= new Item_exists_subselect($3); 
+            $$= new (YYTHD->mem_root) Item_exists_subselect($3); 
           }
 	| '{' ident expr '}'	{ $$= $3; }
         | MATCH ident_list_arg AGAINST '(' bit_expr fulltext_options ')'
-          { $2->push_front($5);
-            Select->add_ftfunc_to_list((Item_func_match*)
-                                        ($$=new Item_func_match(*$2,$6))); }
-	| ASCII_SYM '(' expr ')' { $$= new Item_func_ascii($3); }
+          {
+            $2->push_front($5);
+            Item_func_match *i1= new (YYTHD->mem_root) Item_func_match(*$2, $6);
+            Select->add_ftfunc_to_list(i1);
+            $$= i1;
+          }
 	| BINARY simple_expr %prec NEG
 	  {
-            $$= create_func_cast($2, ITEM_CAST_CHAR, -1, 0, &my_charset_bin);
+            $$= create_func_cast(YYTHD, $2, ITEM_CAST_CHAR, -1, 0,
+                                 &my_charset_bin);
 	  }
 	| CAST_SYM '(' expr AS cast_type ')'
 	  {
             LEX *lex= Lex;
-	    $$= create_func_cast($3, $5,
+	    $$= create_func_cast(YYTHD, $3, $5,
                                  lex->length ? atoi(lex->length) : -1,
                                  lex->dec ? atoi(lex->dec) : 0,
                                  lex->charset);
@@ -6027,10 +6002,10 @@ simple_expr:
               YYABORT;
 	  }
 	| CASE_SYM opt_expr WHEN_SYM when_list opt_else END
-	  { $$= new Item_func_case(* $4, $2, $5 ); }
+	  { $$= new (YYTHD->mem_root) Item_func_case(* $4, $2, $5 ); }
 	| CONVERT_SYM '(' expr ',' cast_type ')'
 	  {
-	    $$= create_func_cast($3, $5,
+	    $$= create_func_cast(YYTHD, $3, $5,
 				 Lex->length ? atoi(Lex->length) : -1,
                                  Lex->dec ? atoi(Lex->dec) : 0,
 				 Lex->charset);
@@ -6038,7 +6013,7 @@ simple_expr:
               YYABORT;
 	  }
 	| CONVERT_SYM '(' expr USING charset_name ')'
-	  { $$= new Item_func_conv_charset($3,$5); }
+	  { $$= new (YYTHD->mem_root) Item_func_conv_charset($3,$5); }
 	| DEFAULT '(' simple_ident ')'
 	  {
 	    if ($3->is_splocal())
@@ -6048,545 +6023,432 @@ simple_expr:
 	      my_error(ER_WRONG_COLUMN_NAME, MYF(0), il->my_name()->str);
 	      YYABORT;
 	    }
-	    $$= new Item_default_value(Lex->current_context(), $3);
+	    $$= new (YYTHD->mem_root) Item_default_value(Lex->current_context(),
+                                                         $3);
 	  }
 	| VALUES '(' simple_ident_nospvar ')'
-	  { $$= new Item_insert_value(Lex->current_context(), $3); }
-	| FUNC_ARG0 '(' ')'
-	  {
-	    if (!$1.symbol->create_func)
-	    {
-              my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(void))($1.symbol->create_func))();
-	  }
-	| FUNC_ARG1 '(' expr ')'
-	  {
-	    if (!$1.symbol->create_func)
-	    {
-              my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(Item*))($1.symbol->create_func))($3);
-	  }
-	| FUNC_ARG2 '(' expr ',' expr ')'
-	  {
-	    if (!$1.symbol->create_func)
-	    {
-	      my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5);
-	  }
-	| FUNC_ARG3 '(' expr ',' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_insert_value(Lex->current_context(),
+                                                        $3); }
+	| interval_expr interval '+' expr
+	  /* we cannot put interval before - */
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($4,$1,$2,0); }
+	| interval_expr
 	  {
-	    if (!$1.symbol->create_func)
-	    {
-              my_error(ER_FEATURE_DISABLED, MYF(0),
-                       $1.symbol->group->name,
-                       $1.symbol->group->needed_define);
-	      YYABORT;
-	    }
-	    $$= ((Item*(*)(Item*,Item*,Item*))($1.symbol->create_func))($3,$5,$7);
-	  }
-	| ADDDATE_SYM '(' expr ',' expr ')'
-	  { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 0);}
-	| ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
-	  { $$= new Item_date_add_interval($3, $6, $7, 0); }
-	| REPEAT_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_repeat($3,$5); }
-	| ATAN	'(' expr ')'
-	  { $$= new Item_func_atan($3); }
-	| ATAN	'(' expr ',' expr ')'
-	  { $$= new Item_func_atan($3,$5); }
-	| CHAR_SYM '(' expr_list ')'
-	  { $$= new Item_func_char(*$3); }
-	| CHAR_SYM '(' expr_list USING charset_name ')'
-	  { $$= new Item_func_char(*$3, $5); }
-	| CHARSET '(' expr ')'
-	  { $$= new Item_func_charset($3); }
-	| COALESCE '(' expr_list ')'
-	  { $$= new Item_func_coalesce(* $3); }
-	| COLLATION_SYM '(' expr ')'
-	  { $$= new Item_func_collation($3); }
-	| CONCAT '(' expr_list ')'
-	  { $$= new Item_func_concat(* $3); }
-	| CONCAT_WS '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_concat_ws(*$5); }
-	| CONVERT_TZ_SYM '(' expr ',' expr ',' expr ')'
-	  {
-            if (Lex->add_time_zone_tables_to_query_tables(YYTHD))
+            if ($1->type() != Item::ROW_ITEM)
+            {
+              yyerror(ER(ER_SYNTAX_ERROR));
               YYABORT;
-	    $$= new Item_func_convert_tz($3, $5, $7);
-	  }
-	| CURDATE optional_braces
-	  { $$= new Item_func_curdate_local(); Lex->safe_to_cache_query=0; }
-	| CURTIME optional_braces
-	  { $$= new Item_func_curtime_local(); Lex->safe_to_cache_query=0; }
-	| CURTIME '(' expr ')'
+            }
+            $$= new (YYTHD->mem_root) Item_func_interval((Item_row *)$1);
+          }
+	| UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')'
 	  {
-	    $$= new Item_func_curtime_local($3);
-	    Lex->safe_to_cache_query=0;
+            $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9);
 	  }
+        ;
+
+/*
+  Function call syntax using official SQL 2003 keywords.
+  Because the function name is an official token,
+  a dedicated grammar rule is needed in the parser.
+  There is no potential for conflicts
+*/
+function_call_keyword:
+	  CHAR_SYM '(' expr_list ')'
+	  { $$= new (YYTHD->mem_root) Item_func_char(*$3); }
+	| CHAR_SYM '(' expr_list USING charset_name ')'
+	  { $$= new (YYTHD->mem_root) Item_func_char(*$3, $5); }
 	| CURRENT_USER optional_braces
           {
-            $$= new Item_func_current_user(Lex->current_context());
+            $$= new (YYTHD->mem_root) Item_func_current_user(Lex->current_context());
             Lex->safe_to_cache_query= 0;
           }
-	| DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')'
-	  { $$= new Item_date_add_interval($3,$5,$6,0); }
-	| DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')'
-	  { $$= new Item_date_add_interval($3,$5,$6,1); }
-	| DATABASE '(' ')'
-	  {
-	    $$= new Item_func_database();
-            Lex->safe_to_cache_query=0;
-	  }
 	| DATE_SYM '(' expr ')'
-	  { $$= new Item_date_typecast($3); }
+	  { $$= new (YYTHD->mem_root) Item_date_typecast($3); }
 	| DAY_SYM '(' expr ')'
-	  { $$= new Item_func_dayofmonth($3); }
-	| ELT_FUNC '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_elt(*$5); }
-	| MAKE_SET_SYM '(' expr ',' expr_list ')'
-	  { $$= new Item_func_make_set($3, *$5); }
-	| ENCRYPT '(' expr ')'
-	  {
-	    $$= new Item_func_encrypt($3);
-	    Lex->uncacheable(UNCACHEABLE_RAND);
-	  }
-	| ENCRYPT '(' expr ',' expr ')'   { $$= new Item_func_encrypt($3,$5); }
-	| DECODE_SYM '(' expr ',' TEXT_STRING_literal ')'
-	  { $$= new Item_func_decode($3,$5.str); }
-	| ENCODE_SYM '(' expr ',' TEXT_STRING_literal ')'
-	 { $$= new Item_func_encode($3,$5.str); }
-	| DES_DECRYPT_SYM '(' expr ')'
-        { $$= new Item_func_des_decrypt($3); }
-	| DES_DECRYPT_SYM '(' expr ',' expr ')'
-        { $$= new Item_func_des_decrypt($3,$5); }
-	| DES_ENCRYPT_SYM '(' expr ')'
-        { $$= new Item_func_des_encrypt($3); }
-	| DES_ENCRYPT_SYM '(' expr ',' expr ')'
-        { $$= new Item_func_des_encrypt($3,$5); }
-	| EXPORT_SET '(' expr ',' expr ',' expr ')'
-		{ $$= new Item_func_export_set($3, $5, $7); }
-	| EXPORT_SET '(' expr ',' expr ',' expr ',' expr ')'
-		{ $$= new Item_func_export_set($3, $5, $7, $9); }
-	| EXPORT_SET '(' expr ',' expr ',' expr ',' expr ',' expr ')'
-		{ $$= new Item_func_export_set($3, $5, $7, $9, $11); }
-	| FORMAT_SYM '(' expr ',' NUM ')'
-	  { $$= new Item_func_format($3,atoi($5.str)); }
-	| FROM_UNIXTIME '(' expr ')'
-	  { $$= new Item_func_from_unixtime($3); }
-	| FROM_UNIXTIME '(' expr ',' expr ')'
-	  {
-	    $$= new Item_func_date_format (new Item_func_from_unixtime($3),$5,0);
-	  }
-	| FIELD_FUNC '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_field(*$5); }
-	| geometry_function
-	  {
-#ifdef HAVE_SPATIAL
-	    $$= $1;
-#else
-	    my_error(ER_FEATURE_DISABLED, MYF(0),
-                     sym_group_geom.name, sym_group_geom.needed_define);
-	    YYABORT;
-#endif
-	  }
-	| GET_FORMAT '(' date_time_type  ',' expr ')'
-	  { $$= new Item_func_get_format($3, $5); }
+	  { $$= new (YYTHD->mem_root) Item_func_dayofmonth($3); }
 	| HOUR_SYM '(' expr ')'
-	  { $$= new Item_func_hour($3); }
-	| IF '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_if($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_hour($3); }
 	| INSERT '(' expr ',' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_insert($3,$5,$7,$9); }
-	| interval_expr interval '+' expr
-	  /* we cannot put interval before - */
-	  { $$= new Item_date_add_interval($4,$1,$2,0); }
-	| interval_expr
+	  { $$= new (YYTHD->mem_root) Item_func_insert($3,$5,$7,$9); }
+	| LEFT '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_left($3,$5); }
+	| MINUTE_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_minute($3); }
+	| MONTH_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_month($3); }
+	| RIGHT '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_right($3,$5); }
+	| SECOND_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_second($3); }
+	| TIME_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_time_typecast($3); }
+	| TIMESTAMP '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_datetime_typecast($3); }
+	| TIMESTAMP '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_add_time($3, $5, 1, 0); }
+	| TRIM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($3); }
+	| TRIM '(' LEADING expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_ltrim($6,$4); }
+	| TRIM '(' TRAILING expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_rtrim($6,$4); }
+	| TRIM '(' BOTH expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($6,$4); }
+	| TRIM '(' LEADING FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_ltrim($5); }
+	| TRIM '(' TRAILING FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_rtrim($5); }
+	| TRIM '(' BOTH FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($5); }
+	| TRIM '(' expr FROM expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_trim($5,$3); }
+	| USER '(' ')'
 	  {
-            if ($1->type() != Item::ROW_ITEM)
-            {
-              yyerror(ER(ER_SYNTAX_ERROR));
-              YYABORT;
-            }
-            $$= new Item_func_interval((Item_row *)$1);
+            $$= new (YYTHD->mem_root) Item_func_user();
+            Lex->safe_to_cache_query=0;
+          }
+	| YEAR_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_year($3); }
+        ;
+
+/*
+  Function calls using non reserved keywords, with special syntaxic forms.
+  Dedicated grammar rules are needed because of the syntax,
+  but also have the potential to cause incompatibilities with other
+  parts of the language.
+  MAINTAINER:
+  The only reasons a function should be added here are:
+  - for compatibility reasons with another SQL syntax (CURDATE),
+  - for typing reasons (GET_FORMAT)
+  Any other 'Syntaxic sugar' enhancements should be *STRONGLY*
+  discouraged.
+*/
+function_call_nonkeyword:
+	  ADDDATE_SYM '(' expr ',' expr ')'
+	  {
+            $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5,
+                                                             INTERVAL_DAY, 0);
           }
-	| LAST_INSERT_ID '(' ')'
+	| ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 0); }
+	| CURDATE optional_braces
 	  {
-	    $$= new Item_func_last_insert_id();
-	    Lex->safe_to_cache_query= 0;
-	  }
-	| LAST_INSERT_ID '(' expr ')'
+            $$= new (YYTHD->mem_root) Item_func_curdate_local();
+            Lex->safe_to_cache_query=0;
+          }
+	| CURTIME optional_braces
 	  {
-	    $$= new Item_func_last_insert_id($3);
-	    Lex->safe_to_cache_query= 0;
-	  }
-	| LEFT '(' expr ',' expr ')'
-	  { $$= new Item_func_left($3,$5); }
-	| LOCATE '(' expr ',' expr ')'
-	  { $$= new Item_func_locate($5,$3); }
-	| LOCATE '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_locate($5,$3,$7); }
-	| GREATEST_SYM '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_max(*$5); }
-	| LEAST_SYM '(' expr ',' expr_list ')'
-	  { $5->push_front($3); $$= new Item_func_min(*$5); }
-	| LOG_SYM '(' expr ')'
-	  { $$= new Item_func_log($3); }
-	| LOG_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_log($3, $5); }
-	| MASTER_POS_WAIT '(' expr ',' expr ')'
-	  {
-	    $$= new Item_master_pos_wait($3, $5);
-	    Lex->safe_to_cache_query=0;
-		  }
-	| MASTER_POS_WAIT '(' expr ',' expr ',' expr ')'
+            $$= new (YYTHD->mem_root) Item_func_curtime_local();
+            Lex->safe_to_cache_query=0;
+          }
+	| CURTIME '(' expr ')'
 	  {
-	    $$= new Item_master_pos_wait($3, $5, $7);
+	    $$= new (YYTHD->mem_root) Item_func_curtime_local($3);
 	    Lex->safe_to_cache_query=0;
 	  }
-	| MICROSECOND_SYM '(' expr ')'
-	  { $$= new Item_func_microsecond($3); }
-	| MINUTE_SYM '(' expr ')'
-	  { $$= new Item_func_minute($3); }
-	| MOD_SYM '(' expr ',' expr ')'
-	  { $$ = new Item_func_mod( $3, $5); }
-	| MONTH_SYM '(' expr ')'
-	  { $$= new Item_func_month($3); }
+	| DATE_ADD_INTERVAL '(' expr ',' interval_expr interval ')'
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3,$5,$6,0); }
+	| DATE_SUB_INTERVAL '(' expr ',' interval_expr interval ')'
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3,$5,$6,1); }
+	| EXTRACT_SYM '(' interval FROM expr ')'
+	  { $$=new (YYTHD->mem_root) Item_extract( $3, $5); }
+	| GET_FORMAT '(' date_time_type  ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_get_format($3, $5); }
 	| NOW_SYM optional_braces
-	  { $$= new Item_func_now_local(); Lex->safe_to_cache_query=0;}
+	  {
+            $$= new (YYTHD->mem_root) Item_func_now_local();
+            Lex->safe_to_cache_query=0;
+          }
 	| NOW_SYM '(' expr ')'
-	  { $$= new Item_func_now_local($3); Lex->safe_to_cache_query=0;}
-	| PASSWORD '(' expr ')'
 	  {
-	    $$= YYTHD->variables.old_passwords ?
-              (Item *) new Item_func_old_password($3) :
-	      (Item *) new Item_func_password($3);
-	  }
-	| OLD_PASSWORD '(' expr ')'
-	  { $$=  new Item_func_old_password($3); }
+            $$= new (YYTHD->mem_root) Item_func_now_local($3);
+            Lex->safe_to_cache_query=0;
+          }
 	| POSITION_SYM '(' bit_expr IN_SYM expr ')'
-	  { $$ = new Item_func_locate($5,$3); }
-	| QUARTER_SYM '(' expr ')'
-	  { $$ = new Item_func_quarter($3); }
-	| RAND '(' expr ')'
-	  { $$= new Item_func_rand($3); Lex->uncacheable(UNCACHEABLE_RAND);}
-	| RAND '(' ')'
-	  { $$= new Item_func_rand(); Lex->uncacheable(UNCACHEABLE_RAND);}
-	| REPLACE '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_replace($3,$5,$7); }
-	| RIGHT '(' expr ',' expr ')'
-	  { $$= new Item_func_right($3,$5); }
-	| ROUND '(' expr ')'
-	  { $$= new Item_func_round($3, new Item_int((char*)"0",0,1),0); }
-	| ROUND '(' expr ',' expr ')' { $$= new Item_func_round($3,$5,0); }
-	| ROW_COUNT_SYM '(' ')'
-	  {
-	    $$= new Item_func_row_count();
-	    Lex->safe_to_cache_query= 0;
-	  }
+	  { $$ = new (YYTHD->mem_root) Item_func_locate($5,$3); }
 	| SUBDATE_SYM '(' expr ',' expr ')'
-	  { $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 1);}
+	  {
+            $$= new (YYTHD->mem_root) Item_date_add_interval($3, $5,
+                                                             INTERVAL_DAY, 1);
+          }
 	| SUBDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
-	  { $$= new Item_date_add_interval($3, $6, $7, 1); }
-	| SECOND_SYM '(' expr ')'
-	  { $$= new Item_func_second($3); }
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($3, $6, $7, 1); }
 	| SUBSTRING '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_substr($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); }
 	| SUBSTRING '(' expr ',' expr ')'
-	  { $$= new Item_func_substr($3,$5); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); }
 	| SUBSTRING '(' expr FROM expr FOR_SYM expr ')'
-	  { $$= new Item_func_substr($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5,$7); }
 	| SUBSTRING '(' expr FROM expr ')'
-	  { $$= new Item_func_substr($3,$5); }
-	| SUBSTRING_INDEX '(' expr ',' expr ',' expr ')'
-	  { $$= new Item_func_substr_index($3,$5,$7); }
+	  { $$= new (YYTHD->mem_root) Item_func_substr($3,$5); }
 	| SYSDATE optional_braces
           {
             if (global_system_variables.sysdate_is_now == 0)
-              $$= new Item_func_sysdate_local();
-            else $$= new Item_func_now_local();
+              $$= new (YYTHD->mem_root) Item_func_sysdate_local();
+            else
+              $$= new (YYTHD->mem_root) Item_func_now_local();
             Lex->safe_to_cache_query=0;
           }
 	| SYSDATE '(' expr ')'
           {
             if (global_system_variables.sysdate_is_now == 0)
-              $$= new Item_func_sysdate_local($3);
-            else $$= new Item_func_now_local($3);
+              $$= new (YYTHD->mem_root) Item_func_sysdate_local($3);
+            else
+              $$= new (YYTHD->mem_root) Item_func_now_local($3);
             Lex->safe_to_cache_query=0;
           }
-	| TIME_SYM '(' expr ')'
-	  { $$= new Item_time_typecast($3); }
-	| TIMESTAMP '(' expr ')'
-	  { $$= new Item_datetime_typecast($3); }
-	| TIMESTAMP '(' expr ',' expr ')'
-	  { $$= new Item_func_add_time($3, $5, 1, 0); }
 	| TIMESTAMP_ADD '(' interval_time_st ',' expr ',' expr ')'
-	  { $$= new Item_date_add_interval($7,$5,$3,0); }
+	  { $$= new (YYTHD->mem_root) Item_date_add_interval($7,$5,$3,0); }
 	| TIMESTAMP_DIFF '(' interval_time_st ',' expr ',' expr ')'
-	  { $$= new Item_func_timestamp_diff($5,$7,$3); }
-	| TRIM '(' expr ')'
-	  { $$= new Item_func_trim($3); }
-	| TRIM '(' LEADING expr FROM expr ')'
-	  { $$= new Item_func_ltrim($6,$4); }
-	| TRIM '(' TRAILING expr FROM expr ')'
-	  { $$= new Item_func_rtrim($6,$4); }
-	| TRIM '(' BOTH expr FROM expr ')'
-	  { $$= new Item_func_trim($6,$4); }
-	| TRIM '(' LEADING FROM expr ')'
-	 { $$= new Item_func_ltrim($5); }
-	| TRIM '(' TRAILING FROM expr ')'
-	  { $$= new Item_func_rtrim($5); }
-	| TRIM '(' BOTH FROM expr ')'
-	  { $$= new Item_func_trim($5); }
-	| TRIM '(' expr FROM expr ')'
-	  { $$= new Item_func_trim($5,$3); }
-	| TRUNCATE_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_round($3,$5,1); }
-	| ident '.' ident '(' udf_expr_list ')'
+	  { $$= new (YYTHD->mem_root) Item_func_timestamp_diff($5,$7,$3); }
+	| UTC_DATE_SYM optional_braces
 	  {
-	    LEX *lex= Lex;
-	    sp_name *name= new sp_name($1, $3);
+            $$= new (YYTHD->mem_root) Item_func_curdate_utc();
+            Lex->safe_to_cache_query=0;
+          }
+	| UTC_TIME_SYM optional_braces
+	  {
+            $$= new (YYTHD->mem_root) Item_func_curtime_utc();
+            Lex->safe_to_cache_query=0;
+          }
+	| UTC_TIMESTAMP_SYM optional_braces
+	  {
+            $$= new (YYTHD->mem_root) Item_func_now_utc();
+            Lex->safe_to_cache_query=0;
+          }
+        ;
 
-	    name->init_qname(YYTHD);
-	    sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION);
-	    if ($5)
-	      $$= new Item_func_sp(Lex->current_context(), name, *$5);
-	    else
-	      $$= new Item_func_sp(Lex->current_context(), name);
-	    lex->safe_to_cache_query=0;
+/*
+  Functions calls using a non reserved keywork, and using a regular syntax.
+  Because the non reserved keyword is used in another part of the grammar,
+  a dedicated rule is needed here.
+*/
+function_call_conflict:
+	  ASCII_SYM '(' expr ')'
+          { $$= new (YYTHD->mem_root) Item_func_ascii($3); }
+	| CHARSET '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_charset($3); }
+	| COALESCE '(' expr_list ')'
+	  { $$= new (YYTHD->mem_root) Item_func_coalesce(* $3); }
+	| COLLATION_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_collation($3); }
+	| DATABASE '(' ')'
+	  {
+	    $$= new (YYTHD->mem_root) Item_func_database();
+            Lex->safe_to_cache_query=0;
+	  }
+	| IF '(' expr ',' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_if($3,$5,$7); }
+	| MICROSECOND_SYM '(' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_microsecond($3); }
+	| MOD_SYM '(' expr ',' expr ')'
+	  { $$ = new (YYTHD->mem_root) Item_func_mod( $3, $5); }
+	| OLD_PASSWORD '(' expr ')'
+	  { $$=  new (YYTHD->mem_root) Item_func_old_password($3); }
+	| PASSWORD '(' expr ')'
+	  {
+            THD *thd= YYTHD;
+            Item* i1;
+            if (thd->variables.old_passwords)
+              i1= new (thd->mem_root) Item_func_old_password($3);
+            else
+              i1= new (thd->mem_root) Item_func_password($3);
+            $$= i1;
 	  }
-	| IDENT_sys '(' 
+	| QUARTER_SYM '(' expr ')'
+	  { $$ = new (YYTHD->mem_root) Item_func_quarter($3); }
+	| REPEAT_SYM '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_repeat($3,$5); }
+	| REPLACE '(' expr ',' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_replace($3,$5,$7); }
+	| TRUNCATE_SYM '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_round($3,$5,1); }
+	| WEEK_SYM '(' expr ')'
+	  {
+            THD *thd= YYTHD;
+            Item *i1= new (thd->mem_root) Item_int((char*) "0",
+                                           thd->variables.default_week_format,
+                                                   1);
+
+            $$= new (thd->mem_root) Item_func_week($3, i1);
+          }
+	| WEEK_SYM '(' expr ',' expr ')'
+	  { $$= new (YYTHD->mem_root) Item_func_week($3,$5); }
+        | geometry_function
           {
+#ifdef HAVE_SPATIAL
+            $$= $1;
+#else
+            my_error(ER_FEATURE_DISABLED, MYF(0),
+                     sym_group_geom.name, sym_group_geom.needed_define);
+            YYABORT;
+#endif
+          }
+        ;
+
+geometry_function:
+	  CONTAINS_SYM '(' expr ',' expr ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_rel($3, $5,
+                                               Item_func::SP_CONTAINS_FUNC));
+          }
+	| GEOMETRYCOLLECTION '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_geometrycollection,
+                           Geometry::wkb_point));
+          }
+	| LINESTRING '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_linestring,
+                           Geometry::wkb_point));
+          }
+ 	| MULTILINESTRING '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_multilinestring,
+                           Geometry::wkb_linestring));
+          }
+	| MULTIPOINT '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_multipoint,
+                           Geometry::wkb_point));
+          }
+ 	| MULTIPOLYGON '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+                           Geometry::wkb_multipolygon,
+                           Geometry::wkb_polygon));
+          }
+	| POINT_SYM '(' expr ',' expr ')'
+	  { $$= GEOM_NEW(YYTHD, Item_func_point($3,$5)); }
+	| POLYGON '(' expr_list ')'
+	  {
+            $$= GEOM_NEW(YYTHD,
+                         Item_func_spatial_collection(* $3,
+	                   Geometry::wkb_polygon,
+                           Geometry::wkb_linestring));
+          }
+        ;
+
+/*
+  Regular function calls.
+  The function name is *not* a token, and therefore is guaranteed to not
+  introduce side effects to the language in general.
+  MAINTAINER:
+  All the new functions implemented for new features should fit into
+  this category. The place to implement the function itself is
+  in sql/item_create.cc
+*/
+function_call_generic:
+        IDENT_sys '('
+        {
 #ifdef HAVE_DLOPEN
-            udf_func *udf= 0;
-            if (using_udf_functions &&
-                (udf= find_udf($1.str, $1.length)) &&
-                udf->type == UDFTYPE_AGGREGATE)
+          udf_func *udf= 0;
+          if (using_udf_functions &&
+              (udf= find_udf($1.str, $1.length)) &&
+              udf->type == UDFTYPE_AGGREGATE)
+          {
+            LEX *lex= Lex;
+            if (lex->current_select->inc_in_sum_expr())
             {
-              LEX *lex= Lex;
-              if (lex->current_select->inc_in_sum_expr())
-              {
-                yyerror(ER(ER_SYNTAX_ERROR));
-                YYABORT;
-              }
+              yyerror(ER(ER_SYNTAX_ERROR));
+              YYABORT;
             }
-            $<udf>$= udf;
+          }
+          /* Temporary placing the result of find_udf in $3 */
+          $<udf>$= udf;
 #endif
+        }
+        expr_list_opt ')'
+        {
+          THD *thd= YYTHD;
+          LEX *lex= Lex;
+          Create_func *builder;
+          Item *item= NULL;
+
+          /*
+            Implementation note:
+            names are resolved with the following order:
+            - MySQL native functions,
+            - User Defined Functions,
+            - Stored Functions (assuming the current <use> database)
+
+            This will be revised with WL#2128 (SQL PATH)
+          */
+          builder= find_native_function_builder(thd, $1);
+          if (builder)
+          {
+            item= builder->create(thd, $1, $4);
           }
-          udf_expr_list ')'
+          else
           {
 #ifdef HAVE_DLOPEN
+            /* Retrieving the result of find_udf */
             udf_func *udf= $<udf>3;
-            SELECT_LEX *sel= Select;
 
             if (udf)
             {
               if (udf->type == UDFTYPE_AGGREGATE)
+              {
                 Select->in_sum_expr--;
-
-              Lex->binlog_row_based_if_mixed= TRUE;
-
-              switch (udf->returns) {
-              case STRING_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_str(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_str(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_str(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_str(udf);
-                }
-                break;
-              case REAL_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_float(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_float(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_float(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_float(udf);
-                }
-                break;
-              case INT_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_int(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_int(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_int(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_int(udf);
-                }
-                break;
-              case DECIMAL_RESULT:
-                if (udf->type == UDFTYPE_FUNCTION)
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_func_udf_decimal(udf, *$4);
-                  else
-                    $$ = new Item_func_udf_decimal(udf);
-                }
-                else
-                {
-                  if ($4 != NULL)
-                    $$ = new Item_sum_udf_decimal(udf, *$4);
-                  else
-                    $$ = new Item_sum_udf_decimal(udf);
-                }
-                break;
-              default:
-                YYABORT;
               }
+
+              item= Create_udf_func::s_singleton.create(thd, udf, $4);
             }
             else
-#endif /* HAVE_DLOPEN */
+#endif
             {
-	      LEX *lex= Lex;
-              THD *thd= lex->thd;
-              LEX_STRING db;
-              if (thd->copy_db_to(&db.str, &db.length))
-                YYABORT;
-              sp_name *name= new sp_name(db, $1);
-              if (name)
-                name->init_qname(thd);
-
-              sp_add_used_routine(lex, YYTHD, name, TYPE_ENUM_FUNCTION);
-              if ($4)
-                $$= new Item_func_sp(Lex->current_context(), name, *$4);
-              else
-                $$= new Item_func_sp(Lex->current_context(), name);
-	      lex->safe_to_cache_query=0;
-	    }
+              builder= find_qualified_function_builder(thd);
+              DBUG_ASSERT(builder);
+              item= builder->create(thd, $1, $4);
+            }
           }
-	| UNIQUE_USERS '(' text_literal ',' NUM ',' NUM ',' expr_list ')'
-	  {
-            $$= new Item_func_unique_users($3,atoi($5.str),atoi($7.str), * $9);
-	  }
-	| UNIX_TIMESTAMP '(' ')'
-	  {
-	    $$= new Item_func_unix_timestamp();
-	    Lex->safe_to_cache_query=0;
-	  }
-	| UNIX_TIMESTAMP '(' expr ')'
-	  { $$= new Item_func_unix_timestamp($3); }
-	| USER '(' ')'
-	  { $$= new Item_func_user(); Lex->safe_to_cache_query=0; }
-	| UTC_DATE_SYM optional_braces
-	  { $$= new Item_func_curdate_utc(); Lex->safe_to_cache_query=0;}
-	| UTC_TIME_SYM optional_braces
-	  { $$= new Item_func_curtime_utc(); Lex->safe_to_cache_query=0;}
-	| UTC_TIMESTAMP_SYM optional_braces
-	  { $$= new Item_func_now_utc(); Lex->safe_to_cache_query=0;}
-	| WEEK_SYM '(' expr ')'
-	  {
-            $$= new Item_func_week($3,new Item_int((char*) "0",
-				   YYTHD->variables.default_week_format,1));
+
+          if (! ($$= item))
+          {
+            YYABORT;
           }
-	| WEEK_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_week($3,$5); }
-	| YEAR_SYM '(' expr ')'
-	  { $$= new Item_func_year($3); }
-	| YEARWEEK '(' 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 ')'
-	  {
-	    $$=new Item_func_benchmark($3,$5);
-	    Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-	  }
-	| EXTRACT_SYM '(' interval FROM expr ')'
-	{ $$=new Item_extract( $3, $5); };
+        }
+	| ident '.' ident '(' udf_expr_list ')'
+	{
+          THD *thd= YYTHD;
+          Create_qfunc *builder;
+          Item *item= NULL;
 
-geometry_function:
-	  CONTAINS_SYM '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_spatial_rel($3, $5, Item_func::SP_CONTAINS_FUNC)); }
-	| GEOMFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| GEOMFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| GEOMFROMWKB '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_wkb($3)); }
-	| GEOMFROMWKB '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_wkb($3, $5)); }
-	| GEOMETRYCOLLECTION '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                           Geometry::wkb_geometrycollection,
-                           Geometry::wkb_point)); }
-	| LINESTRING '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                  Geometry::wkb_linestring, Geometry::wkb_point)); }
- 	| MULTILINESTRING '(' expr_list ')'
-	  { $$= GEOM_NEW( Item_func_spatial_collection(* $3,
-                   Geometry::wkb_multilinestring, Geometry::wkb_linestring)); }
- 	| MLINEFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| MLINEFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| MPOINTFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| MPOINTFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| MPOLYFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| MPOLYFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| MULTIPOINT '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                  Geometry::wkb_multipoint, Geometry::wkb_point)); }
- 	| MULTIPOLYGON '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-                  Geometry::wkb_multipolygon, Geometry::wkb_polygon)); }
-	| POINT_SYM '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_point($3,$5)); }
- 	| POINTFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| POINTFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| POLYFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| POLYFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	| POLYGON '(' expr_list ')'
-	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
-	          Geometry::wkb_polygon, Geometry::wkb_linestring)); }
- 	| GEOMCOLLFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| GEOMCOLLFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
- 	| LINEFROMTEXT '(' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3)); }
-	| LINEFROMTEXT '(' expr ',' expr ')'
-	  { $$= GEOM_NEW(Item_func_geometry_from_text($3, $5)); }
-	;
+          /*
+            The following in practice calls:
+            <code>Create_sp_func::create()</code>
+            and builds a stored function.
+
+            However, it's important to maintain the interface between the
+            parser and the implementation in item_create.cc clean,
+            since this will change with WL#2128 (SQL PATH):
+            - INFORMATION_SCHEMA.version() is the SQL 99 syntax for the native
+            funtion version(),
+            - MySQL.version() is the SQL 2003 syntax for the native function
+            version() (a vendor can specify any schema).
+          */
+
+          builder= find_qualified_function_builder(thd);
+          DBUG_ASSERT(builder);
+          item= builder->create(thd, $1, $3, $5);
+
+          if (! ($$= item))
+          {
+            YYABORT;
+          }
+	}
+        ;
 
 fulltext_options:
           opt_natural_language_mode opt_query_expansion
@@ -6702,6 +6564,46 @@ sum_expr:
 	    $5->empty();
 	  };
 
+variable:
+          '@'
+          {
+            if (! Lex->parsing_options.allows_variable)
+            {
+              my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+              YYABORT;
+            }
+          }
+          variable_aux
+          {
+            $$= $3;
+          }
+          ;
+
+variable_aux:
+          ident_or_text SET_VAR expr
+          {
+            $$= new Item_func_set_user_var($1, $3);
+            LEX *lex= Lex;
+            lex->uncacheable(UNCACHEABLE_RAND);
+          }
+        | ident_or_text
+          {
+            $$= new Item_func_get_user_var($1);
+            LEX *lex= Lex;
+            lex->uncacheable(UNCACHEABLE_RAND);
+          }
+        | '@' opt_var_ident_type ident_or_text opt_component
+          {
+            if ($3.str && $4.str && check_reserved_words(&$3))
+            {
+              yyerror(ER(ER_SYNTAX_ERROR));
+              YYABORT;
+            }
+            if (!($$= get_system_var(YYTHD, $2, $3, $4)))
+              YYABORT;
+          }
+        ;
+
 opt_distinct:
     /* empty */ { $$ = 0; }
     |DISTINCT   { $$ = 1; };
@@ -6756,6 +6658,13 @@ cast_type:
         | DECIMAL_SYM float_options { $$=ITEM_CAST_DECIMAL; Lex->charset= NULL; }
 	;
 
+expr_list_opt:
+        /* empty */
+          { $$ = NULL; }
+        | expr_list
+          { $$ = $1;}
+        ;
+
 expr_list:
 	{ Select->expr_list.push_front(new List<Item>); }
 	expr_list2
@@ -6808,7 +6717,7 @@ when_list2:
 /* Warning - may return NULL in case of incomplete SELECT */
 table_ref:
         table_factor            { $$=$1; }
-        | join_table            { $$=$1; }
+        | join_table
           {
 	    LEX *lex= Lex;
             if (!($$= lex->current_select->nest_last_join(lex->thd)))
@@ -6850,7 +6759,7 @@ join_table:
 	| table_ref normal_join table_ref
           ON
           {
-            YYERROR_UNLESS($1 && ($$=$3));
+            YYERROR_UNLESS($1 && $3);
             /* Change the current name resolution context to a local context. */
             if (push_new_name_resolution_context(YYTHD, $1, $3))
               YYABORT;
@@ -6865,7 +6774,7 @@ join_table:
         | table_ref STRAIGHT_JOIN table_factor
           ON
           {
-            YYERROR_UNLESS($1 && ($$=$3));
+            YYERROR_UNLESS($1 && $3);
             /* Change the current name resolution context to a local context. */
             if (push_new_name_resolution_context(YYTHD, $1, $3))
               YYABORT;
@@ -7131,6 +7040,13 @@ select_derived_init:
           SELECT_SYM
           {
             LEX *lex= Lex;
+
+            if (! lex->parsing_options.allows_derived)
+            {
+              my_error(ER_VIEW_SELECT_DERIVED, MYF(0));
+              YYABORT;
+            }
+
             SELECT_LEX *sel= lex->current_select;
             TABLE_LIST *embedding;
             if (!sel->embedding || sel->end_nested_join(lex->thd))
@@ -7515,6 +7431,13 @@ procedure_clause:
 	| PROCEDURE ident			/* Procedure name */
 	  {
 	    LEX *lex=Lex;
+
+            if (! lex->parsing_options.allows_select_procedure)
+            {
+              my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "PROCEDURE");
+              YYABORT;
+            }
+
 	    if (&lex->select_lex != lex->current_select)
 	    {
 	      my_error(ER_WRONG_USAGE, MYF(0), "PROCEDURE", "subquery");
@@ -7614,28 +7537,40 @@ select_var_ident:
            ;
 
 into:
-        INTO OUTFILE TEXT_STRING_filesystem
+        INTO
+	{
+          if (! Lex->parsing_options.allows_select_into)
+          {
+            my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "INTO");
+            YYABORT;
+          }
+	}
+        into_destination
+        ;
+
+into_destination:
+        OUTFILE TEXT_STRING_filesystem
 	{
           LEX *lex= Lex;
           lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-          if (!(lex->exchange= new sql_exchange($3.str, 0)) ||
+          if (!(lex->exchange= new sql_exchange($2.str, 0)) ||
               !(lex->result= new select_export(lex->exchange)))
             YYABORT;
 	}
 	opt_field_term opt_line_term
-	| INTO DUMPFILE TEXT_STRING_filesystem
+	| DUMPFILE TEXT_STRING_filesystem
 	{
 	  LEX *lex=Lex;
 	  if (!lex->describe)
 	  {
 	    lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-	    if (!(lex->exchange= new sql_exchange($3.str,1)))
+	    if (!(lex->exchange= new sql_exchange($2.str,1)))
 	      YYABORT;
 	    if (!(lex->result= new select_dump(lex->exchange)))
 	      YYABORT;
 	  }
 	}
-        | INTO select_var_list_init
+        | select_var_list_init
 	{
 	  Lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
 	}
@@ -8593,17 +8528,12 @@ purge_option:
 /* kill threads */
 
 kill:
-	KILL_SYM
-        {
-          Lex->sql_command= SQLCOM_KILL;
-          Lex->expr_allows_subselect= FALSE;
-        }
-        kill_option expr
+	KILL_SYM kill_option expr
 	{
 	  LEX *lex=Lex;
 	  lex->value_list.empty();
-	  lex->value_list.push_front($4);
-          Lex->expr_allows_subselect= TRUE;
+	  lex->value_list.push_front($3);
+          lex->sql_command= SQLCOM_KILL;
 	};
 
 kill_option:
@@ -8844,8 +8774,13 @@ param_marker:
         {
           THD *thd=YYTHD;
 	  LEX *lex= thd->lex;
-          Item_param *item= new Item_param((uint) (lex->tok_start -
-                                                   (uchar *) thd->query));
+          Item_param *item;
+          if (! lex->parsing_options.allows_variable)
+          {
+            my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+            YYABORT;
+          }
+          item= new Item_param((uint) (lex->tok_start - (uchar *) thd->query));
           if (!($$= item) || lex->param_list.push_back(item))
           {
             my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
@@ -8965,6 +8900,12 @@ simple_ident:
 	  if (spc && (spv = spc->find_variable(&$1)))
 	  {
             /* We're compiling a stored procedure and found a variable */
+            if (! lex->parsing_options.allows_variable)
+            {
+              my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
+              YYABORT;
+            }
+
             Item_splocal *splocal;
             splocal= new Item_splocal($1, spv->offset, spv->type,
                                       lex->tok_start_prev - 
@@ -8974,7 +8915,6 @@ simple_ident:
               splocal->m_sp= lex->sphead;
 #endif
 	    $$ = (Item*) splocal;
-            lex->variables_used= 1;
 	    lex->safe_to_cache_query=0;
 	  }
 	  else
@@ -10873,6 +10813,24 @@ view_list:
 	;
 
 view_select:
+        {
+          LEX *lex= Lex;
+          lex->parsing_options.allows_variable= FALSE;
+          lex->parsing_options.allows_select_into= FALSE;
+          lex->parsing_options.allows_select_procedure= FALSE;
+          lex->parsing_options.allows_derived= FALSE;
+        }        
+        view_select_aux
+        {
+          LEX *lex= Lex;
+          lex->parsing_options.allows_variable= TRUE;
+          lex->parsing_options.allows_select_into= TRUE;
+          lex->parsing_options.allows_select_procedure= TRUE;
+          lex->parsing_options.allows_derived= TRUE;
+        }
+        ;
+
+view_select_aux:
 	SELECT_SYM remember_name select_init2
 	{
           THD *thd=YYTHD;
diff --git a/sql/strfunc.cc b/sql/strfunc.cc
index 2525703172f..ef769a5b16e 100644
--- a/sql/strfunc.cc
+++ b/sql/strfunc.cc
@@ -312,3 +312,33 @@ outp:
   return (uint32) (to - to_start);
 
 }
+
+
+/*
+  Searches for a LEX_STRING in an LEX_STRING array.
+
+  SYNOPSIS
+    find_string_in_array()
+      heap    The array
+      needle  The string to search for
+
+  NOTE
+    The last LEX_STRING in the array should have str member set to NULL
+
+  RETURN VALUES
+    -1   Not found
+    >=0  Ordinal position
+*/
+
+int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
+                         CHARSET_INFO * const cs)
+{
+  const LEX_STRING *pos;
+  for (pos= haystack; pos->str; pos++)
+    if (!cs->coll->strnncollsp(cs, (uchar *) pos->str, pos->length,
+                               (uchar *) needle->str, needle->length, 0))
+    {
+      return (pos - haystack);
+    }
+  return -1;
+}
diff --git a/sql/table.cc b/sql/table.cc
index f15555138f8..6db617ab579 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -363,25 +363,24 @@ int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
     error= open_binary_frm(thd, share, head, file);
     *root_ptr= old_root;
 
-    if (share->db.length == 5 &&
-        !my_strcasecmp(system_charset_info, share->db.str, "mysql"))
+    if (share->db.length == 5 && !(lower_case_table_names ?
+        my_strcasecmp(system_charset_info, share->db.str, "mysql") :
+        strcmp(share->db.str, "mysql")))
     {
       /*
         We can't mark all tables in 'mysql' database as system since we don't
         allow to lock such tables for writing with any other tables (even with
         other system tables) and some privilege tables need this.
       */
-      if (!my_strcasecmp(system_charset_info, share->table_name.str, "proc"))
+      if (!(lower_case_table_names ?
+            my_strcasecmp(system_charset_info, share->table_name.str, "proc") :
+            strcmp(share->table_name.str, "proc")))
         share->system_table= 1;
       else
       {
-        if (!my_strcasecmp(system_charset_info, share->table_name.str,
-                           "general_log"))
-          share->log_table= QUERY_LOG_GENERAL;
-        else
-          if (!my_strcasecmp(system_charset_info, share->table_name.str,
-                             "slow_log"))
-            share->log_table= QUERY_LOG_SLOW;
+        share->log_table= check_if_log_table(share->db.length, share->db.str,
+                                             share->table_name.length,
+                                             share->table_name.str, 0);
       }
     }
     error_given= 1;