diff --git a/include/my_global.h b/include/my_global.h
index 32516cd5810..c9660d4d649 100644
--- a/include/my_global.h
+++ b/include/my_global.h
@@ -1168,4 +1168,6 @@ typedef union {
 #define MYSQL_UNIVERSAL_CLIENT_CHARSET MYSQL_DEFAULT_CHARSET_NAME
 #endif
 
+#define HAVE_SPATIAL
+#define HAVE_RTREE_KEYS
 #endif /* my_global_h */
diff --git a/include/mysqld_error.h b/include/mysqld_error.h
index 179a2f823d7..80cfed9e338 100644
--- a/include/mysqld_error.h
+++ b/include/mysqld_error.h
@@ -304,4 +304,5 @@
 #define ER_UNKNOWN_STORAGE_ENGINE 1285
 #define ER_WARN_DEPRECATED_SYNTAX 1286
 #define ER_NON_UPDATABLE_TABLE 1287
-#define ER_ERROR_MESSAGES 288
+#define ER_FEATURE_DISABLED 1288
+#define ER_ERROR_MESSAGES 289
diff --git a/mysql-test/r/derived.result b/mysql-test/r/derived.result
index d38601c331f..170c393524b 100644
--- a/mysql-test/r/derived.result
+++ b/mysql-test/r/derived.result
@@ -254,7 +254,7 @@ CREATE TABLE `t1` (
 `M` tinyint(1) default '0',
 ) TYPE=MyISAM DEFAULT CHARSET=latin1;
 Warnings:
-Warning	1286	'TYPE=database_engine' is deprecated. Use 'ENGINE=database_engine' instead.
+Warning	1286	'TYPE=storage_engine' is deprecated. Use 'ENGINE=storage_engine' instead.
 INSERT INTO `t1` (N, M) VALUES (1, 0),(1, 0),(1, 0),(2, 0),(2, 0),(3, 0);
 UPDATE `t1` AS P1 INNER JOIN (SELECT N FROM `t1` GROUP BY N HAVING Count(M) > 1) AS P2 ON P1.N = P2.N SET P1.M = 2;
 select * from t1;
diff --git a/mysys/default.c b/mysys/default.c
index 81e1fd06374..d27efce27ed 100644
--- a/mysys/default.c
+++ b/mysys/default.c
@@ -462,7 +462,7 @@ static char *remove_end_comment(char *ptr)
 	quote= 0;
     }
     /* We are not inside a comment */
-    if (!quote && (*ptr == '#' || *ptr == ';'))
+    if (!quote && *ptr == '#')
     {
       *ptr= 0;
       return ptr;
diff --git a/mysys/my_new.cc b/mysys/my_new.cc
index 5f2da90bbd1..ec27502d8aa 100644
--- a/mysys/my_new.cc
+++ b/mysys/my_new.cc
@@ -19,9 +19,9 @@
   with gcc 3.0.x to avoid including libstdc++
 */
 
-#include "mysys_priv.h"
+#ifdef USE_MYSYS_NEW
 
-#ifdef USE_MYSYS_NEW  
+#include "mysys_priv.h"
 
 void *operator new (size_t sz)
 {
diff --git a/sql/field.cc b/sql/field.cc
index 8dc133adae8..9f25b770ab0 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -4465,7 +4465,7 @@ Field_blob::Field_blob(char *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
   :Field_str(ptr_arg, (1L << min(blob_pack_length,3)*8)-1L,
 	     null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
 	     table_arg, cs),
-   geom_flag(true), packlength(blob_pack_length)
+   packlength(blob_pack_length)
 {
   flags|= BLOB_FLAG;
   if (table)
@@ -4703,6 +4703,7 @@ void Field_blob::get_key_image(char *buff,uint length,
   uint32 blob_length= get_length(ptr);
   char *blob;
 
+#ifdef HAVE_SPATIAL
   if (type == itMBR)
   {
     if (!blob_length)
@@ -4719,6 +4720,7 @@ void Field_blob::get_key_image(char *buff,uint length,
     float8store(buff+24, mbr.ymax);
     return;
   }
+#endif /*HAVE_SPATIAL*/
 
   if ((uint32) length > blob_length)
   {
@@ -4928,6 +4930,7 @@ uint Field_blob::max_packed_col_length(uint max_length)
   return (max_length > 255 ? 2 : 1)+max_length;
 }
 
+#ifdef HAVE_SPATIAL
 
 void Field_geom::get_key_image(char *buff, uint length, CHARSET_INFO *cs,
 			       imagetype type)
@@ -5011,6 +5014,7 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
   return 0;
 }
 
+#endif /*HAVE_SPATIAL*/
 
 /****************************************************************************
 ** enum type.
@@ -5486,10 +5490,12 @@ Field *make_field(char *ptr, uint32 field_length,
 				      f_packtype(pack_flag),
 				      field_length);
 
+#ifdef HAVE_SPATIAL
     if (f_is_geom(pack_flag))
       return new Field_geom(ptr,null_pos,null_bit,
 			    unireg_check, field_name, table,
 			    pack_length, geom_type);
+#endif
     if (f_is_blob(pack_flag))
       return new Field_blob(ptr,null_pos,null_bit,
 			    unireg_check, field_name, table,
@@ -5649,10 +5655,12 @@ create_field::create_field(Field *old_field,Field *orig_field)
       def=new Item_string(pos,tmp.length(), charset);
     }
   }
+#ifdef HAVE_SPATIAL
   if (sql_type == FIELD_TYPE_GEOMETRY)
   {
     geom_type= ((Field_geom*)old_field)->geom_type;
   }
+#endif
 }
 
 
diff --git a/sql/field.h b/sql/field.h
index e3b4bf29fb8..9a12fd48e54 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -913,7 +913,6 @@ public:
 
 
 class Field_blob :public Field_str {
-  bool geom_flag;
 protected:
   uint packlength;
   String value;				// For temporaries
@@ -926,7 +925,7 @@ public:
 	     struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
 	       NONE, field_name_arg, table_arg, cs),
-    geom_flag(true), packlength(4)
+    packlength(4)
   {
     flags|= BLOB_FLAG;
   }
@@ -1001,7 +1000,7 @@ public:
   field_cast_enum field_cast_type() { return FIELD_CAST_BLOB; }
 };
 
-
+#ifdef HAVE_SPATIAL
 class Field_geom :public Field_blob {
 public:
   enum geometry_type geom_type;
@@ -1029,7 +1028,7 @@ public:
   void set_key_image(char *buff,uint length, CHARSET_INFO *cs);
   field_cast_enum field_cast_type() { return FIELD_CAST_GEOM; }
 };
-
+#endif /*HAVE_SPATIAL*/
 
 class Field_enum :public Field_str {
 protected:
diff --git a/sql/gen_lex_hash.cc b/sql/gen_lex_hash.cc
index 7126b7ee577..6df7d867a4d 100644
--- a/sql/gen_lex_hash.cc
+++ b/sql/gen_lex_hash.cc
@@ -81,9 +81,10 @@ TODO:
 #endif
 #include <my_getopt.h>
 #include "mysql_version.h"
+#include "mysql_priv.h"
 #include "lex.h"
 
-static struct my_option my_long_options[] =
+struct my_option my_long_options[] =
 {
   {"help", '?', "Display help and exit",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
diff --git a/sql/item_create.cc b/sql/item_create.cc
index f61b87ebe88..4ed8182305d 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -487,6 +487,7 @@ Item *create_func_quote(Item* a)
   return new Item_func_quote(a);
 }
 
+#ifdef HAVE_SPATIAL
 Item *create_func_as_wkt(Item *a)
 {
   return new Item_func_as_wkt(a);
@@ -646,6 +647,7 @@ Item *create_func_point(Item *a, Item *b)
 {
   return new Item_func_point(a, b);
 }
+#endif /*HAVE_SPATIAL*/
 
 Item *create_func_crc32(Item* a)
 {
diff --git a/sql/item_create.h b/sql/item_create.h
index 083868d87a6..773fdffbaf2 100644
--- a/sql/item_create.h
+++ b/sql/item_create.h
@@ -99,6 +99,8 @@ Item *create_func_is_free_lock(Item* a);
 Item *create_func_is_used_lock(Item* a);
 Item *create_func_quote(Item* a);
 
+#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);
@@ -138,6 +140,8 @@ 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);
diff --git a/sql/item_geofunc.cc b/sql/item_geofunc.cc
index 5ac87a25e67..6934ad9d3b0 100644
--- a/sql/item_geofunc.cc
+++ b/sql/item_geofunc.cc
@@ -22,6 +22,8 @@
 #endif
 
 #include "mysql_priv.h"
+
+#ifdef HAVE_SPATIAL
 #include "sql_acl.h"
 #include <m_ctype.h>
 
@@ -651,3 +653,5 @@ longlong Item_func_srid::val_int()
   uint32 res= uint4korr(swkb->ptr());
   return (longlong) res;
 }
+
+#endif /*HAVE_SPATIAL*/
diff --git a/sql/item_geofunc.h b/sql/item_geofunc.h
index f6f00ed2bab..545052807ec 100644
--- a/sql/item_geofunc.h
+++ b/sql/item_geofunc.h
@@ -17,6 +17,8 @@
 
 /* This file defines all spatial functions */
 
+#ifdef HAVE_SPATIAL
+
 #ifdef __GNUC__
 #pragma interface			/* gcc class implementation */
 #endif
@@ -338,3 +340,12 @@ public:
   const char *func_name() const { return "srid"; }
   void fix_length_and_dec() { max_length= 10; }
 };
+
+#define GEOM_NEW(obj_constructor) new obj_constructor
+
+#else /*HAVE_SPATIAL*/
+
+#define GEOM_NEW(obj_constructor) NULL
+
+#endif
+
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index badc134ae1d..5420a8f69e4 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -1648,11 +1648,11 @@ void Item_func_elt::fix_length_and_dec()
 {
   max_length=0;
   decimals=0;
-  
+
   if (agg_arg_collations(collation, args+1, arg_count-1))
     return;
 
-  for (uint i=1 ; i < arg_count ; i++)
+  for (uint i= 1 ; i < arg_count ; i++)
   {
     set_if_bigger(max_length,args[i]->max_length);
     set_if_bigger(decimals,args[i]->decimals);
diff --git a/sql/lex.h b/sql/lex.h
index 6e69df6f96c..029a8ac4218 100644
--- a/sql/lex.h
+++ b/sql/lex.h
@@ -20,13 +20,25 @@
 #include "lex_symbol.h"
 
 /* We don't want to include sql_yacc.h into gen_lex_hash */
+SYM_GROUP sym_group_common= {"", ""};
+SYM_GROUP sym_group_geom= {"Spatial extentions", "HAVE_SPATIAL"};
+SYM_GROUP sym_group_rtree= {"RTree keys", "HAVE_RTREE_KEYS"};
 
 #ifdef NO_YACC_SYMBOLS
-#define SYM(A) 0
-#define CREATE_FUNC(A) 0
+#define SYM_OR_NULL(A) 0
 #else
-#define SYM(A) A
-#define CREATE_FUNC(A) (void*) (A)
+#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
 
 /*
@@ -36,639 +48,639 @@
 */
 
 static SYMBOL symbols[] = {
-  { "&&",		SYM(AND),0,0},
-  { "<",		SYM(LT),0,0},
-  { "<=",		SYM(LE),0,0},
-  { "<>",		SYM(NE),0,0},
-  { "!=",		SYM(NE),0,0},
-  { "=",		SYM(EQ),0,0},
-  { ">",		SYM(GT_SYM),0,0},
-  { ">=",		SYM(GE),0,0},
-  { "<<",		SYM(SHIFT_LEFT),0,0},
-  { ">>",		SYM(SHIFT_RIGHT),0,0},
-  { "<=>",		SYM(EQUAL_SYM),0,0},
-  { "ACTION",		SYM(ACTION),0,0},
-  { "ADD",		SYM(ADD),0,0},
-  { "AFTER",		SYM(AFTER_SYM),0,0},
-  { "AGAINST",          SYM(AGAINST),0,0},
-  { "AGGREGATE",	SYM(AGGREGATE_SYM),0,0},
-  { "ALL",		SYM(ALL),0,0},
-  { "ALTER",		SYM(ALTER),0,0},
-  { "ANALYZE",		SYM(ANALYZE_SYM),0,0},
-  { "AND",		SYM(AND),0,0},
-  { "ANY",              SYM(ANY_SYM),0,0},
-  { "AS",		SYM(AS),0,0},
-  { "ASC",		SYM(ASC),0,0},
-  { "ASCII",		SYM(ASCII_SYM),0,0},
-  { "AUTO_INCREMENT",	SYM(AUTO_INC),0,0},
-  { "AVG",		SYM(AVG_SYM),0,0},
-  { "AVG_ROW_LENGTH",	SYM(AVG_ROW_LENGTH),0,0},
-  { "BACKUP",	        SYM(BACKUP_SYM),0,0},
-  { "BDB",              SYM(BERKELEY_DB_SYM),0,0},
-  { "BEFORE",	        SYM(BEFORE_SYM),0,0},
-  { "BEGIN",	        SYM(BEGIN_SYM),0,0},
-  { "BERKELEYDB",       SYM(BERKELEY_DB_SYM),0,0},
-  { "BETWEEN",		SYM(BETWEEN_SYM),0,0},
-  { "BIGINT",		SYM(BIGINT),0,0},
-  { "BINARY",		SYM(BINARY),0,0},
-  { "BINLOG",		SYM(BINLOG_SYM),0,0},
-  { "BIT",		SYM(BIT_SYM),0,0},
-  { "BLOB",		SYM(BLOB_SYM),0,0},
-  { "BOOL",		SYM(BOOL_SYM),0,0},
-  { "BOOLEAN",		SYM(BOOLEAN_SYM),0,0},
-  { "BOTH",		SYM(BOTH),0,0},
-  { "BTREE",		SYM(BTREE_SYM),0,0},
-  { "BY",		SYM(BY),0,0},
-  { "BYTE",		SYM(BYTE_SYM), 0, 0},
-  { "CACHE",		SYM(CACHE_SYM),0,0},
-  { "CASCADE",		SYM(CASCADE),0,0},
-  { "CASE",		SYM(CASE_SYM),0,0},
-  { "CHANGE",		SYM(CHANGE),0,0},
-  { "CHANGED",		SYM(CHANGED),0,0},
-  { "CHAR",		SYM(CHAR_SYM),0,0},
-  { "CHARACTER",	SYM(CHAR_SYM),0,0},
-  { "CHARSET",		SYM(CHARSET),0,0},
-  { "CHECK",		SYM(CHECK_SYM),0,0},
-  { "CHECKSUM",		SYM(CHECKSUM_SYM),0,0},
-  { "CIPHER",		SYM(CIPHER_SYM),0,0},
-  { "CLIENT",		SYM(CLIENT_SYM),0,0},
-  { "CLOSE",		SYM(CLOSE_SYM),0,0},
-  { "COLLATE",		SYM(COLLATE_SYM),0,0},
-  { "COLLATION",	SYM(COLLATION_SYM),0,0},
-  { "COLUMN",		SYM(COLUMN_SYM),0,0},
-  { "COLUMNS",		SYM(COLUMNS),0,0},
-  { "COMMENT",		SYM(COMMENT_SYM),0,0},
-  { "COMMIT",		SYM(COMMIT_SYM),0,0},
-  { "COMMITTED",	SYM(COMMITTED_SYM),0,0},
-  { "COMPRESSED",	SYM(COMPRESSED_SYM),0,0},
-  { "CONCURRENT",	SYM(CONCURRENT),0,0},
-  { "CONSTRAINT",	SYM(CONSTRAINT),0,0},
-  { "CREATE",		SYM(CREATE),0,0},
-  { "CROSS",		SYM(CROSS),0,0},
-  { "CUBE",		SYM(CUBE_SYM),0,0},
-  { "CURRENT_DATE",	SYM(CURDATE),0,0},
-  { "CURRENT_TIME",	SYM(CURTIME),0,0},
-  { "CURRENT_TIMESTAMP", SYM(NOW_SYM),0,0},
-  { "DATA",		SYM(DATA_SYM),0,0},
-  { "DATABASE",		SYM(DATABASE),0,0},
-  { "DATABASES",	SYM(DATABASES),0,0},
-  { "DATE",		SYM(DATE_SYM),0,0},
-  { "DATETIME",		SYM(DATETIME),0,0},
-  { "DAY",		SYM(DAY_SYM),0,0},
-  { "DAY_HOUR",		SYM(DAY_HOUR_SYM),0,0},
-  { "DAY_MICROSECOND",	SYM(DAY_MICROSECOND_SYM),0,0},
-  { "DAY_MINUTE",	SYM(DAY_MINUTE_SYM),0,0},
-  { "DAY_SECOND",	SYM(DAY_SECOND_SYM),0,0},
-  { "DEC",		SYM(DECIMAL_SYM),0,0},
-  { "DECIMAL",		SYM(DECIMAL_SYM),0,0},
-  { "DEFAULT",		SYM(DEFAULT),0,0},
-  { "DELAYED",		SYM(DELAYED_SYM),0,0},
-  { "DELAY_KEY_WRITE",	SYM(DELAY_KEY_WRITE_SYM),0,0},
-  { "DELETE",		SYM(DELETE_SYM),0,0},
-  { "DESC",		SYM(DESC),0,0},
-  { "DESCRIBE",		SYM(DESCRIBE),0,0},
-  { "DES_KEY_FILE",	SYM(DES_KEY_FILE),0,0},
-  { "DIRECTORY",	SYM(DIRECTORY_SYM),0,0},
-  { "DISABLE",		SYM(DISABLE_SYM),0,0},
-  { "DISCARD",		SYM(DISCARD),0,0},
-  { "DISTINCT",		SYM(DISTINCT),0,0},
-  { "DISTINCTROW",	SYM(DISTINCT),0,0},	/* Access likes this */
-  { "DIV",		SYM(DIV_SYM),0,0},
-  { "DO",		SYM(DO_SYM),0,0},
-  { "DOUBLE",		SYM(DOUBLE_SYM),0,0},
-  { "DROP",		SYM(DROP),0,0},
-  { "DUAL",		SYM(DUAL_SYM),0,0},
-  { "DUMPFILE",		SYM(DUMPFILE),0,0},
-  { "DUPLICATE",	SYM(DUPLICATE_SYM),0,0},
-  { "DYNAMIC",		SYM(DYNAMIC_SYM),0,0},
-  { "ELSE",             SYM(ELSE),0,0},
-  { "ENABLE",		SYM(ENABLE_SYM),0,0},
-  { "ENCLOSED",		SYM(ENCLOSED),0,0},
-  { "END",		SYM(END),0,0},
-  { "ENGINE",		SYM(ENGINE_SYM),0,0},
-  { "ENGINES",		SYM(ENGINES_SYM),0,0},
-  { "ENUM",		SYM(ENUM),0,0},
-  { "ERRORS",		SYM(ERRORS),0,0},
-  { "ESCAPE",		SYM(ESCAPE_SYM),0,0},
-  { "ESCAPED",		SYM(ESCAPED),0,0},
-  { "EVENTS",		SYM(EVENTS_SYM),0,0},
-  { "EXECUTE",		SYM(EXECUTE_SYM),0,0},
-  { "EXISTS",		SYM(EXISTS),0,0},
-  { "EXPANSION",	SYM(EXPANSION_SYM),0,0},
-  { "EXPLAIN",		SYM(DESCRIBE),0,0},
-  { "EXTENDED",		SYM(EXTENDED_SYM),0,0},
-  { "FALSE",		SYM(FALSE_SYM),0,0},
-  { "FAST",		SYM(FAST_SYM),0,0},
-  { "FIELDS",		SYM(COLUMNS),0,0},
-  { "FILE",		SYM(FILE_SYM),0,0},
-  { "FIRST",		SYM(FIRST_SYM),0,0},
-  { "FIXED",		SYM(FIXED_SYM),0,0},
-  { "FLOAT",		SYM(FLOAT_SYM),0,0},
-  { "FLOAT4",		SYM(FLOAT_SYM),0,0},
-  { "FLOAT8",		SYM(DOUBLE_SYM),0,0},
-  { "FLUSH",		SYM(FLUSH_SYM),0,0},
-  { "FOR",		SYM(FOR_SYM),0,0},
-  { "FORCE",		SYM(FORCE_SYM),0,0},
-  { "FOREIGN",		SYM(FOREIGN),0,0},
-  { "FROM",		SYM(FROM),0,0},
-  { "FULL",		SYM(FULL),0,0},
-  { "FULLTEXT",		SYM(FULLTEXT_SYM),0,0},
-  { "FUNCTION",		SYM(UDF_SYM),0,0},
-  { "GEOMETRY",		SYM(GEOMETRY_SYM),0,0},
-  { "GEOMETRYCOLLECTION",SYM(GEOMETRYCOLLECTION),0,0},
-  { "GET_FORMAT",       SYM(GET_FORMAT),0,0},
-  { "GLOBAL",		SYM(GLOBAL_SYM),0,0},
-  { "GRANT",		SYM(GRANT),0,0},
-  { "GRANTS",	        SYM(GRANTS),0,0},
-  { "GROUP",		SYM(GROUP),0,0},
-  { "HANDLER",		SYM(HANDLER_SYM),0,0},
-  { "HASH",		SYM(HASH_SYM),0,0},
-  { "HAVING",		SYM(HAVING),0,0},
-  { "HELP",		SYM(HELP_SYM),0,0},
-  { "HIGH_PRIORITY",	SYM(HIGH_PRIORITY),0,0},
-  { "HOSTS",		SYM(HOSTS_SYM),0,0},
-  { "HOUR",		SYM(HOUR_SYM),0,0},
-  { "HOUR_MICROSECOND",	SYM(HOUR_MICROSECOND_SYM),0,0},
-  { "HOUR_MINUTE",	SYM(HOUR_MINUTE_SYM),0,0},
-  { "HOUR_SECOND",	SYM(HOUR_SECOND_SYM),0,0},
-  { "IDENTIFIED",	SYM(IDENTIFIED_SYM),0,0},
-  { "IF",		SYM(IF),0,0},
-  { "IGNORE",		SYM(IGNORE_SYM),0,0},
-  { "IMPORT",		SYM(IMPORT),0,0},
-  { "IN",		SYM(IN_SYM),0,0},
-  { "INDEX",		SYM(INDEX),0,0},
-  { "INDEXES",		SYM(INDEXES),0,0},
-  { "INFILE",		SYM(INFILE),0,0},
-  { "INNER",		SYM(INNER_SYM),0,0},
-  { "INNOBASE",		SYM(INNOBASE_SYM),0,0},
-  { "INNODB",		SYM(INNOBASE_SYM),0,0},
-  { "INSERT",		SYM(INSERT),0,0},
-  { "INSERT_METHOD",    SYM(INSERT_METHOD),0,0},
-  { "INT",		SYM(INT_SYM),0,0},
-  { "INT1",		SYM(TINYINT),0,0},
-  { "INT2",		SYM(SMALLINT),0,0},
-  { "INT3",		SYM(MEDIUMINT),0,0},
-  { "INT4",		SYM(INT_SYM),0,0},
-  { "INT8",		SYM(BIGINT),0,0},
-  { "INTEGER",		SYM(INT_SYM),0,0},
-  { "INTERVAL",		SYM(INTERVAL_SYM),0,0},
-  { "INTO",		SYM(INTO),0,0},
-  { "IO_THREAD",        SYM(RELAY_THREAD),0,0},
-  { "IS",		SYM(IS),0,0},
-  { "ISOLATION",	SYM(ISOLATION),0,0},
-  { "ISSUER",		SYM(ISSUER_SYM),0,0},
-  { "JOIN",		SYM(JOIN_SYM),0,0},
-  { "KEY",		SYM(KEY_SYM),0,0},
-  { "KEYS",		SYM(KEYS),0,0},
-  { "KILL",		SYM(KILL_SYM),0,0},
-  { "LAST",		SYM(LAST_SYM),0,0},
-  { "LEADING",		SYM(LEADING),0,0},
-  { "LEAVES",		SYM(LEAVES),0,0},
-  { "LEFT",		SYM(LEFT),0,0},
-  { "LEVEL",		SYM(LEVEL_SYM),0,0},
-  { "LIKE",		SYM(LIKE),0,0},
-  { "LIMIT",		SYM(LIMIT),0,0},
-  { "LINES",		SYM(LINES),0,0},
-  { "LINESTRING",	SYM(LINESTRING),0,0},
-  { "LOAD",		SYM(LOAD),0,0},
-  { "LOCAL",		SYM(LOCAL_SYM),0,0},
-  { "LOCALTIME",	SYM(NOW_SYM),0,0},
-  { "LOCALTIMESTAMP",	SYM(NOW_SYM),0,0},
-  { "LOCK",		SYM(LOCK_SYM),0,0},
-  { "LOCKS",		SYM(LOCKS_SYM),0,0},
-  { "LOGS",		SYM(LOGS_SYM),0,0},
-  { "LONG",		SYM(LONG_SYM),0,0},
-  { "LONGBLOB",		SYM(LONGBLOB),0,0},
-  { "LONGTEXT",		SYM(LONGTEXT),0,0},
-  { "LOW_PRIORITY",	SYM(LOW_PRIORITY),0,0},
-  { "MASTER",           SYM(MASTER_SYM),0,0},
-  { "MASTER_CONNECT_RETRY",           SYM(MASTER_CONNECT_RETRY_SYM),0,0},
-  { "MASTER_HOST",           SYM(MASTER_HOST_SYM),0,0},
-  { "MASTER_LOG_FILE",           SYM(MASTER_LOG_FILE_SYM),0,0},
-  { "MASTER_LOG_POS",           SYM(MASTER_LOG_POS_SYM),0,0},
-  { "MASTER_PASSWORD",           SYM(MASTER_PASSWORD_SYM),0,0},
-  { "MASTER_PORT",           SYM(MASTER_PORT_SYM),0,0},
-  { "MASTER_SERVER_ID",           SYM(MASTER_SERVER_ID_SYM),0,0},
-  { "MASTER_SSL",       SYM(MASTER_SSL_SYM),0,0},
-  { "MASTER_SSL_CA",    SYM(MASTER_SSL_CA_SYM),0,0},
-  { "MASTER_SSL_CAPATH",SYM(MASTER_SSL_CAPATH_SYM),0,0},
-  { "MASTER_SSL_CERT",  SYM(MASTER_SSL_CERT_SYM),0,0},
-  { "MASTER_SSL_CIPHER",SYM(MASTER_SSL_CIPHER_SYM),0,0},
-  { "MASTER_SSL_KEY",   SYM(MASTER_SSL_KEY_SYM),0,0},
-  { "MASTER_USER",           SYM(MASTER_USER_SYM),0,0},
-  { "MATCH",		SYM(MATCH),0,0},
-  { "MAX_CONNECTIONS_PER_HOUR", SYM(MAX_CONNECTIONS_PER_HOUR), 0,0},
-  { "MAX_QUERIES_PER_HOUR", SYM(MAX_QUERIES_PER_HOUR), 0,0},
-  { "MAX_ROWS",		SYM(MAX_ROWS),0,0},
-  { "MAX_UPDATES_PER_HOUR", SYM(MAX_UPDATES_PER_HOUR), 0,0},
-  { "MEDIUM",		SYM(MEDIUM_SYM),0,0},
-  { "MEDIUMBLOB",	SYM(MEDIUMBLOB),0,0},
-  { "MEDIUMINT",	SYM(MEDIUMINT),0,0},
-  { "MEDIUMTEXT",	SYM(MEDIUMTEXT),0,0},
-  { "MICROSECOND",	SYM(MICROSECOND_SYM),0,0},
-  { "MIDDLEINT",	SYM(MEDIUMINT),0,0},	/* For powerbuilder */
-  { "MINUTE",		SYM(MINUTE_SYM),0,0},
-  { "MINUTE_MICROSECOND", SYM(MINUTE_MICROSECOND_SYM),0,0},
-  { "MINUTE_SECOND",	SYM(MINUTE_SECOND_SYM),0,0},
-  { "MIN_ROWS",		SYM(MIN_ROWS),0,0},
-  { "MOD",		SYM(MOD_SYM),0,0},
-  { "MODE",		SYM(MODE_SYM),0,0},
-  { "MODIFY",		SYM(MODIFY_SYM),0,0},
-  { "MONTH",		SYM(MONTH_SYM),0,0},
-  { "MULTILINESTRING",	SYM(MULTILINESTRING),0,0},
-  { "MULTIPOINT",	SYM(MULTIPOINT),0,0},
-  { "MULTIPOLYGON",	SYM(MULTIPOLYGON),0,0},
-  { "NAMES",		SYM(NAMES_SYM),0,0},
-  { "NATIONAL",		SYM(NATIONAL_SYM),0,0},
-  { "NATURAL",		SYM(NATURAL),0,0},
-  { "NCHAR",		SYM(NCHAR_SYM),0,0},
-  { "NEW",              SYM(NEW_SYM),0,0},
-  { "NEXT",		SYM(NEXT_SYM),0,0},
-  { "NO",		SYM(NO_SYM),0,0},
-  { "NONE",		SYM(NONE_SYM),0,0},
-  { "NOT",		SYM(NOT),0,0},
-  { "NO_WRITE_TO_BINLOG",  SYM(NO_WRITE_TO_BINLOG),0,0},
-  { "NULL",		SYM(NULL_SYM),0,0},
-  { "NUMERIC",		SYM(NUMERIC_SYM),0,0},
-  { "NVARCHAR",		SYM(NVARCHAR_SYM),0,0},
-  { "OFFSET",		SYM(OFFSET_SYM),0,0},
-  { "OLD_PASSWORD",	SYM(OLD_PASSWORD),0,0},
-  { "ON",		SYM(ON),0,0},
-  { "OPEN",		SYM(OPEN_SYM),0,0},
-  { "OPTIMIZE",		SYM(OPTIMIZE),0,0},
-  { "OPTION",		SYM(OPTION),0,0},
-  { "OPTIONALLY",	SYM(OPTIONALLY),0,0},
-  { "OR",		SYM(OR),0,0},
-  { "ORDER",		SYM(ORDER_SYM),0,0},
-  { "OUTER",		SYM(OUTER),0,0},
-  { "OUTFILE",		SYM(OUTFILE),0,0},
-  { "PACK_KEYS",	SYM(PACK_KEYS_SYM),0,0},
-  { "PARTIAL",		SYM(PARTIAL),0,0},
-  { "PASSWORD",		SYM(PASSWORD),0,0},
-  { "POINT",		SYM(POINT_SYM),0,0},
-  { "POLYGON",		SYM(POLYGON),0,0},
-  { "PRECISION",	SYM(PRECISION),0,0},
-  { "PREV",		SYM(PREV_SYM),0,0},
-  { "PRIMARY",		SYM(PRIMARY_SYM),0,0},
-  { "PRIVILEGES",	SYM(PRIVILEGES),0,0},
-  { "PROCEDURE",	SYM(PROCEDURE),0,0},
-  { "PROCESS"	,	SYM(PROCESS),0,0},
-  { "PROCESSLIST",	SYM(PROCESSLIST_SYM),0,0},
-  { "PURGE",		SYM(PURGE),0,0},
-  { "QUERY",		SYM(QUERY_SYM),0,0},
-  { "QUICK",	        SYM(QUICK),0,0},
-  { "RAID0",		SYM(RAID_0_SYM),0,0},
-  { "RAID_CHUNKS",	SYM(RAID_CHUNKS),0,0},
-  { "RAID_CHUNKSIZE",	SYM(RAID_CHUNKSIZE),0,0},
-  { "RAID_TYPE",	SYM(RAID_TYPE),0,0},
-  { "READ",		SYM(READ_SYM),0,0},
-  { "REAL",		SYM(REAL),0,0},
-  { "REFERENCES",	SYM(REFERENCES),0,0},
-  { "REGEXP",		SYM(REGEXP),0,0},
-  { "RELAY_LOG_FILE",   SYM(RELAY_LOG_FILE_SYM),0,0},
-  { "RELAY_LOG_POS",    SYM(RELAY_LOG_POS_SYM),0,0},
-  { "RELAY_THREAD",     SYM(RELAY_THREAD),0,0},
-  { "RELOAD",		SYM(RELOAD),0,0},
-  { "RENAME",		SYM(RENAME),0,0},
-  { "REPAIR",		SYM(REPAIR),0,0},
-  { "REPEATABLE",	SYM(REPEATABLE_SYM),0,0},
-  { "REPLACE",		SYM(REPLACE),0,0},
-  { "REPLICATION",	SYM(REPLICATION),0,0},
-  { "REQUIRE",	        SYM(REQUIRE_SYM),0,0},
-  { "RESET",		SYM(RESET_SYM),0,0},
-  { "RESTORE",		SYM(RESTORE_SYM),0,0},
-  { "RESTRICT",		SYM(RESTRICT),0,0},
-  { "RETURNS",		SYM(UDF_RETURNS_SYM),0,0},
-  { "REVOKE",		SYM(REVOKE),0,0},
-  { "RIGHT",		SYM(RIGHT),0,0},
-  { "RLIKE",		SYM(REGEXP),0,0},	/* Like in mSQL2 */
-  { "ROLLBACK",		SYM(ROLLBACK_SYM),0,0},
-  { "ROLLUP",		SYM(ROLLUP_SYM),0,0},
-  { "ROW",		SYM(ROW_SYM),0,0},
-  { "ROWS",		SYM(ROWS_SYM),0,0},
-  { "ROW_FORMAT",	SYM(ROW_FORMAT_SYM),0,0},
-  { "RTREE",		SYM(RTREE_SYM),0,0},
-  { "SAVEPOINT",	SYM(SAVEPOINT_SYM),0,0},
-  { "SECOND",		SYM(SECOND_SYM),0,0},
-  { "SECOND_MICROSECOND", SYM(SECOND_MICROSECOND_SYM),0,0},
-  { "SELECT",		SYM(SELECT_SYM),0,0},
-  { "SEPARATOR",	SYM(SEPARATOR_SYM),0,0},
-  { "SERIAL",		SYM(SERIAL_SYM),0,0},
-  { "SERIALIZABLE",	SYM(SERIALIZABLE_SYM),0,0},
-  { "SESSION",		SYM(SESSION_SYM),0,0},
-  { "SET",		SYM(SET),0,0},
-  { "SHARE",		SYM(SHARE_SYM),0,0},
-  { "SHOW",		SYM(SHOW),0,0},
-  { "SHUTDOWN",		SYM(SHUTDOWN),0,0},
-  { "SIGNED",		SYM(SIGNED_SYM),0,0},
-  { "SIMPLE",		SYM(SIMPLE_SYM),0,0},
-  { "SLAVE",            SYM(SLAVE),0,0},
-  { "SMALLINT",		SYM(SMALLINT),0,0},
-  { "SOME",             SYM(ANY_SYM),0,0},
-  { "SONAME",		SYM(UDF_SONAME_SYM),0,0},
-  { "SOUNDS",		SYM(SOUNDS_SYM),0,0},
-  { "SPATIAL",		SYM(SPATIAL_SYM),0,0},
-  { "SQL_BIG_RESULT",	SYM(SQL_BIG_RESULT),0,0},
-  { "SQL_BUFFER_RESULT", SYM(SQL_BUFFER_RESULT),0,0},
-  { "SQL_CACHE",        SYM(SQL_CACHE_SYM), 0, 0},
-  { "SQL_CALC_FOUND_ROWS", SYM(SQL_CALC_FOUND_ROWS),0,0},
-  { "SQL_NO_CACHE",	SYM(SQL_NO_CACHE_SYM), 0, 0},
-  { "SQL_SMALL_RESULT", SYM(SQL_SMALL_RESULT),0,0},
-  { "SQL_THREAD",	SYM(SQL_THREAD),0,0},
-  { "SSL",		SYM(SSL_SYM),0,0},
-  { "START",		SYM(START_SYM),0,0},
-  { "STARTING",		SYM(STARTING),0,0},
-  { "STATUS",		SYM(STATUS_SYM),0,0},
-  { "STOP",		SYM(STOP_SYM),0,0},
-  { "STORAGE",		SYM(STORAGE_SYM),0,0},
-  { "STRAIGHT_JOIN",	SYM(STRAIGHT_JOIN),0,0},
-  { "STRING",		SYM(STRING_SYM),0,0},
-  { "STRIPED",		SYM(RAID_STRIPED_SYM),0,0},
-  { "SUBJECT",		SYM(SUBJECT_SYM),0,0},
-  { "SUPER",		SYM(SUPER_SYM),0,0},
-  { "TABLE",		SYM(TABLE_SYM),0,0},
-  { "TABLES",		SYM(TABLES),0,0},
-  { "TABLESPACE",	SYM(TABLESPACE),0,0},
-  { "TEMPORARY",	SYM(TEMPORARY),0,0},
-  { "TERMINATED",	SYM(TERMINATED),0,0},
-  { "TEXT",		SYM(TEXT_SYM),0,0},
-  { "THEN",		SYM(THEN_SYM),0,0},
-  { "TIME",		SYM(TIME_SYM),0,0},
-  { "TIMESTAMP",	SYM(TIMESTAMP),0,0},
-  { "TINYBLOB",		SYM(TINYBLOB),0,0},
-  { "TINYINT",		SYM(TINYINT),0,0},
-  { "TINYTEXT",		SYM(TINYTEXT),0,0},
-  { "TO",		SYM(TO_SYM),0,0},
-  { "TRAILING",		SYM(TRAILING),0,0},
-  { "TRANSACTION",	SYM(TRANSACTION_SYM),0,0},
-  { "TRUE",		SYM(TRUE_SYM),0,0},
-  { "TRUNCATE",		SYM(TRUNCATE_SYM),0,0},
-  { "TYPE",		SYM(TYPE_SYM),0,0},
-  { "TYPES",		SYM(TYPES_SYM),0,0},
-  { "UNCOMMITTED",	SYM(UNCOMMITTED_SYM),0,0},
-  { "UNICODE",	        SYM(UNICODE_SYM),0,0},
-  { "UNION",	        SYM(UNION_SYM),0,0},
-  { "UNIQUE",		SYM(UNIQUE_SYM),0,0},
-  { "UNLOCK",		SYM(UNLOCK_SYM),0,0},
-  { "UNSIGNED",		SYM(UNSIGNED),0,0},
-  { "UNTIL",		SYM(UNTIL_SYM),0,0},
-  { "UPDATE",		SYM(UPDATE_SYM),0,0},
-  { "USAGE",		SYM(USAGE),0,0},
-  { "USE",		SYM(USE_SYM),0,0},
-  { "USER",		SYM(USER),0,0},
-  { "USER_RESOURCES",	SYM(RESOURCES),0,0},
-  { "USE_FRM",		SYM(USE_FRM),0,0},
-  { "USING",		SYM(USING),0,0},
-  { "UTC_DATE",         SYM(UTC_DATE_SYM),0,0},
-  { "UTC_TIME",         SYM(UTC_TIME_SYM),0,0},
-  { "UTC_TIMESTAMP",    SYM(UTC_TIMESTAMP_SYM),0,0},
-  { "VALUE",		SYM(VALUE_SYM),0,0},
-  { "VALUES",		SYM(VALUES),0,0},
-  { "VARBINARY",	SYM(VARBINARY),0,0},
-  { "VARCHAR",		SYM(VARCHAR),0,0},
-  { "VARCHARACTER",	SYM(VARCHAR),0,0},
-  { "VARIABLES",	SYM(VARIABLES),0,0},
-  { "VARYING",		SYM(VARYING),0,0},
-  { "WARNINGS",		SYM(WARNINGS),0,0},
-  { "WHEN",		SYM(WHEN_SYM),0,0},
-  { "WHERE",		SYM(WHERE),0,0},
-  { "WITH",		SYM(WITH),0,0},
-  { "WORK",		SYM(WORK_SYM),0,0},
-  { "WRITE",		SYM(WRITE_SYM),0,0},
-  { "X509",		SYM(X509_SYM),0,0},
-  { "XOR",		SYM(XOR),0,0},
-  { "YEAR",		SYM(YEAR_SYM),0,0},
-  { "YEAR_MONTH",	SYM(YEAR_MONTH_SYM),0,0},
-  { "ZEROFILL",		SYM(ZEROFILL),0,0},
-  { "||",		SYM(OR_OR_CONCAT),0,0}
+  { "&&",		SYM(AND)},
+  { "<",		SYM(LT)},
+  { "<=",		SYM(LE)},
+  { "<>",		SYM(NE)},
+  { "!=",		SYM(NE)},
+  { "=",		SYM(EQ)},
+  { ">",		SYM(GT_SYM)},
+  { ">=",		SYM(GE)},
+  { "<<",		SYM(SHIFT_LEFT)},
+  { ">>",		SYM(SHIFT_RIGHT)},
+  { "<=>",		SYM(EQUAL_SYM)},
+  { "ACTION",		SYM(ACTION)},
+  { "ADD",		SYM(ADD)},
+  { "AFTER",		SYM(AFTER_SYM)},
+  { "AGAINST",          SYM(AGAINST)},
+  { "AGGREGATE",	SYM(AGGREGATE_SYM)},
+  { "ALL",		SYM(ALL)},
+  { "ALTER",		SYM(ALTER)},
+  { "ANALYZE",		SYM(ANALYZE_SYM)},
+  { "AND",		SYM(AND)},
+  { "ANY",              SYM(ANY_SYM)},
+  { "AS",		SYM(AS)},
+  { "ASC",		SYM(ASC)},
+  { "ASCII",		SYM(ASCII_SYM)},
+  { "AUTO_INCREMENT",	SYM(AUTO_INC)},
+  { "AVG",		SYM(AVG_SYM)},
+  { "AVG_ROW_LENGTH",	SYM(AVG_ROW_LENGTH)},
+  { "BACKUP",	        SYM(BACKUP_SYM)},
+  { "BDB",              SYM(BERKELEY_DB_SYM)},
+  { "BEFORE",	        SYM(BEFORE_SYM)},
+  { "BEGIN",	        SYM(BEGIN_SYM)},
+  { "BERKELEYDB",       SYM(BERKELEY_DB_SYM)},
+  { "BETWEEN",		SYM(BETWEEN_SYM)},
+  { "BIGINT",		SYM(BIGINT)},
+  { "BINARY",		SYM(BINARY)},
+  { "BINLOG",		SYM(BINLOG_SYM)},
+  { "BIT",		SYM(BIT_SYM)},
+  { "BLOB",		SYM(BLOB_SYM)},
+  { "BOOL",		SYM(BOOL_SYM)},
+  { "BOOLEAN",		SYM(BOOLEAN_SYM)},
+  { "BOTH",		SYM(BOTH)},
+  { "BTREE",		SYM(BTREE_SYM)},
+  { "BY",		SYM(BY)},
+  { "BYTE",		SYM(BYTE_SYM)},
+  { "CACHE",		SYM(CACHE_SYM)},
+  { "CASCADE",		SYM(CASCADE)},
+  { "CASE",		SYM(CASE_SYM)},
+  { "CHANGE",		SYM(CHANGE)},
+  { "CHANGED",		SYM(CHANGED)},
+  { "CHAR",		SYM(CHAR_SYM)},
+  { "CHARACTER",	SYM(CHAR_SYM)},
+  { "CHARSET",		SYM(CHARSET)},
+  { "CHECK",		SYM(CHECK_SYM)},
+  { "CHECKSUM",		SYM(CHECKSUM_SYM)},
+  { "CIPHER",		SYM(CIPHER_SYM)},
+  { "CLIENT",		SYM(CLIENT_SYM)},
+  { "CLOSE",		SYM(CLOSE_SYM)},
+  { "COLLATE",		SYM(COLLATE_SYM)},
+  { "COLLATION",	SYM(COLLATION_SYM)},
+  { "COLUMN",		SYM(COLUMN_SYM)},
+  { "COLUMNS",		SYM(COLUMNS)},
+  { "COMMENT",		SYM(COMMENT_SYM)},
+  { "COMMIT",		SYM(COMMIT_SYM)},
+  { "COMMITTED",	SYM(COMMITTED_SYM)},
+  { "COMPRESSED",	SYM(COMPRESSED_SYM)},
+  { "CONCURRENT",	SYM(CONCURRENT)},
+  { "CONSTRAINT",	SYM(CONSTRAINT)},
+  { "CREATE",		SYM(CREATE)},
+  { "CROSS",		SYM(CROSS)},
+  { "CUBE",		SYM(CUBE_SYM)},
+  { "CURRENT_DATE",	SYM(CURDATE)},
+  { "CURRENT_TIME",	SYM(CURTIME)},
+  { "CURRENT_TIMESTAMP", SYM(NOW_SYM)},
+  { "DATA",		SYM(DATA_SYM)},
+  { "DATABASE",		SYM(DATABASE)},
+  { "DATABASES",	SYM(DATABASES)},
+  { "DATE",		SYM(DATE_SYM)},
+  { "DATETIME",		SYM(DATETIME)},
+  { "DAY",		SYM(DAY_SYM)},
+  { "DAY_HOUR",		SYM(DAY_HOUR_SYM)},
+  { "DAY_MICROSECOND",	SYM(DAY_MICROSECOND_SYM)},
+  { "DAY_MINUTE",	SYM(DAY_MINUTE_SYM)},
+  { "DAY_SECOND",	SYM(DAY_SECOND_SYM)},
+  { "DEC",		SYM(DECIMAL_SYM)},
+  { "DECIMAL",		SYM(DECIMAL_SYM)},
+  { "DEFAULT",		SYM(DEFAULT)},
+  { "DELAYED",		SYM(DELAYED_SYM)},
+  { "DELAY_KEY_WRITE",	SYM(DELAY_KEY_WRITE_SYM)},
+  { "DELETE",		SYM(DELETE_SYM)},
+  { "DESC",		SYM(DESC)},
+  { "DESCRIBE",		SYM(DESCRIBE)},
+  { "DES_KEY_FILE",	SYM(DES_KEY_FILE)},
+  { "DIRECTORY",	SYM(DIRECTORY_SYM)},
+  { "DISABLE",		SYM(DISABLE_SYM)},
+  { "DISCARD",		SYM(DISCARD)},
+  { "DISTINCT",		SYM(DISTINCT)},
+  { "DISTINCTROW",	SYM(DISTINCT)},	/* Access likes this */
+  { "DIV",		SYM(DIV_SYM)},
+  { "DO",		SYM(DO_SYM)},
+  { "DOUBLE",		SYM(DOUBLE_SYM)},
+  { "DROP",		SYM(DROP)},
+  { "DUAL",		SYM(DUAL_SYM)},
+  { "DUMPFILE",		SYM(DUMPFILE)},
+  { "DUPLICATE",	SYM(DUPLICATE_SYM)},
+  { "DYNAMIC",		SYM(DYNAMIC_SYM)},
+  { "ELSE",             SYM(ELSE)},
+  { "ENABLE",		SYM(ENABLE_SYM)},
+  { "ENCLOSED",		SYM(ENCLOSED)},
+  { "END",		SYM(END)},
+  { "ENGINE",		SYM(ENGINE_SYM)},
+  { "ENGINES",		SYM(ENGINES_SYM)},
+  { "ENUM",		SYM(ENUM)},
+  { "ERRORS",		SYM(ERRORS)},
+  { "ESCAPE",		SYM(ESCAPE_SYM)},
+  { "ESCAPED",		SYM(ESCAPED)},
+  { "EVENTS",		SYM(EVENTS_SYM)},
+  { "EXECUTE",		SYM(EXECUTE_SYM)},
+  { "EXISTS",		SYM(EXISTS)},
+  { "EXPANSION",	SYM(EXPANSION_SYM)},
+  { "EXPLAIN",		SYM(DESCRIBE)},
+  { "EXTENDED",		SYM(EXTENDED_SYM)},
+  { "FALSE",		SYM(FALSE_SYM)},
+  { "FAST",		SYM(FAST_SYM)},
+  { "FIELDS",		SYM(COLUMNS)},
+  { "FILE",		SYM(FILE_SYM)},
+  { "FIRST",		SYM(FIRST_SYM)},
+  { "FIXED",		SYM(FIXED_SYM)},
+  { "FLOAT",		SYM(FLOAT_SYM)},
+  { "FLOAT4",		SYM(FLOAT_SYM)},
+  { "FLOAT8",		SYM(DOUBLE_SYM)},
+  { "FLUSH",		SYM(FLUSH_SYM)},
+  { "FOR",		SYM(FOR_SYM)},
+  { "FORCE",		SYM(FORCE_SYM)},
+  { "FOREIGN",		SYM(FOREIGN)},
+  { "FROM",		SYM(FROM)},
+  { "FULL",		SYM(FULL)},
+  { "FULLTEXT",		SYM(FULLTEXT_SYM)},
+  { "FUNCTION",		SYM(UDF_SYM)},
+  { "GEOMETRY",		SYM(GEOMETRY_SYM)},
+  { "GEOMETRYCOLLECTION",SYM(GEOMETRYCOLLECTION)},
+  { "GET_FORMAT",       SYM(GET_FORMAT)},
+  { "GLOBAL",		SYM(GLOBAL_SYM)},
+  { "GRANT",		SYM(GRANT)},
+  { "GRANTS",	        SYM(GRANTS)},
+  { "GROUP",		SYM(GROUP)},
+  { "HANDLER",		SYM(HANDLER_SYM)},
+  { "HASH",		SYM(HASH_SYM)},
+  { "HAVING",		SYM(HAVING)},
+  { "HELP",		SYM(HELP_SYM)},
+  { "HIGH_PRIORITY",	SYM(HIGH_PRIORITY)},
+  { "HOSTS",		SYM(HOSTS_SYM)},
+  { "HOUR",		SYM(HOUR_SYM)},
+  { "HOUR_MICROSECOND",	SYM(HOUR_MICROSECOND_SYM)},
+  { "HOUR_MINUTE",	SYM(HOUR_MINUTE_SYM)},
+  { "HOUR_SECOND",	SYM(HOUR_SECOND_SYM)},
+  { "IDENTIFIED",	SYM(IDENTIFIED_SYM)},
+  { "IF",		SYM(IF)},
+  { "IGNORE",		SYM(IGNORE_SYM)},
+  { "IMPORT",		SYM(IMPORT)},
+  { "IN",		SYM(IN_SYM)},
+  { "INDEX",		SYM(INDEX)},
+  { "INDEXES",		SYM(INDEXES)},
+  { "INFILE",		SYM(INFILE)},
+  { "INNER",		SYM(INNER_SYM)},
+  { "INNOBASE",		SYM(INNOBASE_SYM)},
+  { "INNODB",		SYM(INNOBASE_SYM)},
+  { "INSERT",		SYM(INSERT)},
+  { "INSERT_METHOD",    SYM(INSERT_METHOD)},
+  { "INT",		SYM(INT_SYM)},
+  { "INT1",		SYM(TINYINT)},
+  { "INT2",		SYM(SMALLINT)},
+  { "INT3",		SYM(MEDIUMINT)},
+  { "INT4",		SYM(INT_SYM)},
+  { "INT8",		SYM(BIGINT)},
+  { "INTEGER",		SYM(INT_SYM)},
+  { "INTERVAL",		SYM(INTERVAL_SYM)},
+  { "INTO",		SYM(INTO)},
+  { "IO_THREAD",        SYM(RELAY_THREAD)},
+  { "IS",		SYM(IS)},
+  { "ISOLATION",	SYM(ISOLATION)},
+  { "ISSUER",		SYM(ISSUER_SYM)},
+  { "JOIN",		SYM(JOIN_SYM)},
+  { "KEY",		SYM(KEY_SYM)},
+  { "KEYS",		SYM(KEYS)},
+  { "KILL",		SYM(KILL_SYM)},
+  { "LAST",		SYM(LAST_SYM)},
+  { "LEADING",		SYM(LEADING)},
+  { "LEAVES",		SYM(LEAVES)},
+  { "LEFT",		SYM(LEFT)},
+  { "LEVEL",		SYM(LEVEL_SYM)},
+  { "LIKE",		SYM(LIKE)},
+  { "LIMIT",		SYM(LIMIT)},
+  { "LINES",		SYM(LINES)},
+  { "LINESTRING",	SYM(LINESTRING)},
+  { "LOAD",		SYM(LOAD)},
+  { "LOCAL",		SYM(LOCAL_SYM)},
+  { "LOCALTIME",	SYM(NOW_SYM)},
+  { "LOCALTIMESTAMP",	SYM(NOW_SYM)},
+  { "LOCK",		SYM(LOCK_SYM)},
+  { "LOCKS",		SYM(LOCKS_SYM)},
+  { "LOGS",		SYM(LOGS_SYM)},
+  { "LONG",		SYM(LONG_SYM)},
+  { "LONGBLOB",		SYM(LONGBLOB)},
+  { "LONGTEXT",		SYM(LONGTEXT)},
+  { "LOW_PRIORITY",	SYM(LOW_PRIORITY)},
+  { "MASTER",           SYM(MASTER_SYM)},
+  { "MASTER_CONNECT_RETRY",           SYM(MASTER_CONNECT_RETRY_SYM)},
+  { "MASTER_HOST",           SYM(MASTER_HOST_SYM)},
+  { "MASTER_LOG_FILE",           SYM(MASTER_LOG_FILE_SYM)},
+  { "MASTER_LOG_POS",           SYM(MASTER_LOG_POS_SYM)},
+  { "MASTER_PASSWORD",           SYM(MASTER_PASSWORD_SYM)},
+  { "MASTER_PORT",           SYM(MASTER_PORT_SYM)},
+  { "MASTER_SERVER_ID",           SYM(MASTER_SERVER_ID_SYM)},
+  { "MASTER_SSL",       SYM(MASTER_SSL_SYM)},
+  { "MASTER_SSL_CA",    SYM(MASTER_SSL_CA_SYM)},
+  { "MASTER_SSL_CAPATH",SYM(MASTER_SSL_CAPATH_SYM)},
+  { "MASTER_SSL_CERT",  SYM(MASTER_SSL_CERT_SYM)},
+  { "MASTER_SSL_CIPHER",SYM(MASTER_SSL_CIPHER_SYM)},
+  { "MASTER_SSL_KEY",   SYM(MASTER_SSL_KEY_SYM)},
+  { "MASTER_USER",           SYM(MASTER_USER_SYM)},
+  { "MATCH",		SYM(MATCH)},
+  { "MAX_CONNECTIONS_PER_HOUR", SYM(MAX_CONNECTIONS_PER_HOUR)},
+  { "MAX_QUERIES_PER_HOUR", SYM(MAX_QUERIES_PER_HOUR)},
+  { "MAX_ROWS",		SYM(MAX_ROWS)},
+  { "MAX_UPDATES_PER_HOUR", SYM(MAX_UPDATES_PER_HOUR)},
+  { "MEDIUM",		SYM(MEDIUM_SYM)},
+  { "MEDIUMBLOB",	SYM(MEDIUMBLOB)},
+  { "MEDIUMINT",	SYM(MEDIUMINT)},
+  { "MEDIUMTEXT",	SYM(MEDIUMTEXT)},
+  { "MICROSECOND",	SYM(MICROSECOND_SYM)},
+  { "MIDDLEINT",	SYM(MEDIUMINT)},	/* For powerbuilder */
+  { "MINUTE",		SYM(MINUTE_SYM)},
+  { "MINUTE_MICROSECOND", SYM(MINUTE_MICROSECOND_SYM)},
+  { "MINUTE_SECOND",	SYM(MINUTE_SECOND_SYM)},
+  { "MIN_ROWS",		SYM(MIN_ROWS)},
+  { "MOD",		SYM(MOD_SYM)},
+  { "MODE",		SYM(MODE_SYM)},
+  { "MODIFY",		SYM(MODIFY_SYM)},
+  { "MONTH",		SYM(MONTH_SYM)},
+  { "MULTILINESTRING",	SYM(MULTILINESTRING)},
+  { "MULTIPOINT",	SYM(MULTIPOINT)},
+  { "MULTIPOLYGON",	SYM(MULTIPOLYGON)},
+  { "NAMES",		SYM(NAMES_SYM)},
+  { "NATIONAL",		SYM(NATIONAL_SYM)},
+  { "NATURAL",		SYM(NATURAL)},
+  { "NCHAR",		SYM(NCHAR_SYM)},
+  { "NEW",              SYM(NEW_SYM)},
+  { "NEXT",		SYM(NEXT_SYM)},
+  { "NO",		SYM(NO_SYM)},
+  { "NONE",		SYM(NONE_SYM)},
+  { "NOT",		SYM(NOT)},
+  { "NO_WRITE_TO_BINLOG",  SYM(NO_WRITE_TO_BINLOG)},
+  { "NULL",		SYM(NULL_SYM)},
+  { "NUMERIC",		SYM(NUMERIC_SYM)},
+  { "NVARCHAR",		SYM(NVARCHAR_SYM)},
+  { "OFFSET",		SYM(OFFSET_SYM)},
+  { "OLD_PASSWORD",	SYM(OLD_PASSWORD)},
+  { "ON",		SYM(ON)},
+  { "OPEN",		SYM(OPEN_SYM)},
+  { "OPTIMIZE",		SYM(OPTIMIZE)},
+  { "OPTION",		SYM(OPTION)},
+  { "OPTIONALLY",	SYM(OPTIONALLY)},
+  { "OR",		SYM(OR)},
+  { "ORDER",		SYM(ORDER_SYM)},
+  { "OUTER",		SYM(OUTER)},
+  { "OUTFILE",		SYM(OUTFILE)},
+  { "PACK_KEYS",	SYM(PACK_KEYS_SYM)},
+  { "PARTIAL",		SYM(PARTIAL)},
+  { "PASSWORD",		SYM(PASSWORD)},
+  { "POINT",		SYM(POINT_SYM)},
+  { "POLYGON",		SYM(POLYGON)},
+  { "PRECISION",	SYM(PRECISION)},
+  { "PREV",		SYM(PREV_SYM)},
+  { "PRIMARY",		SYM(PRIMARY_SYM)},
+  { "PRIVILEGES",	SYM(PRIVILEGES)},
+  { "PROCEDURE",	SYM(PROCEDURE)},
+  { "PROCESS"	,	SYM(PROCESS)},
+  { "PROCESSLIST",	SYM(PROCESSLIST_SYM)},
+  { "PURGE",		SYM(PURGE)},
+  { "QUERY",		SYM(QUERY_SYM)},
+  { "QUICK",	        SYM(QUICK)},
+  { "RAID0",		SYM(RAID_0_SYM)},
+  { "RAID_CHUNKS",	SYM(RAID_CHUNKS)},
+  { "RAID_CHUNKSIZE",	SYM(RAID_CHUNKSIZE)},
+  { "RAID_TYPE",	SYM(RAID_TYPE)},
+  { "READ",		SYM(READ_SYM)},
+  { "REAL",		SYM(REAL)},
+  { "REFERENCES",	SYM(REFERENCES)},
+  { "REGEXP",		SYM(REGEXP)},
+  { "RELAY_LOG_FILE",   SYM(RELAY_LOG_FILE_SYM)},
+  { "RELAY_LOG_POS",    SYM(RELAY_LOG_POS_SYM)},
+  { "RELAY_THREAD",     SYM(RELAY_THREAD)},
+  { "RELOAD",		SYM(RELOAD)},
+  { "RENAME",		SYM(RENAME)},
+  { "REPAIR",		SYM(REPAIR)},
+  { "REPEATABLE",	SYM(REPEATABLE_SYM)},
+  { "REPLACE",		SYM(REPLACE)},
+  { "REPLICATION",	SYM(REPLICATION)},
+  { "REQUIRE",	        SYM(REQUIRE_SYM)},
+  { "RESET",		SYM(RESET_SYM)},
+  { "RESTORE",		SYM(RESTORE_SYM)},
+  { "RESTRICT",		SYM(RESTRICT)},
+  { "RETURNS",		SYM(UDF_RETURNS_SYM)},
+  { "REVOKE",		SYM(REVOKE)},
+  { "RIGHT",		SYM(RIGHT)},
+  { "RLIKE",		SYM(REGEXP)},	/* Like in mSQL2 */
+  { "ROLLBACK",		SYM(ROLLBACK_SYM)},
+  { "ROLLUP",		SYM(ROLLUP_SYM)},
+  { "ROW",		SYM(ROW_SYM)},
+  { "ROWS",		SYM(ROWS_SYM)},
+  { "ROW_FORMAT",	SYM(ROW_FORMAT_SYM)},
+  { "RTREE",		SYM(RTREE_SYM)},
+  { "SAVEPOINT",	SYM(SAVEPOINT_SYM)},
+  { "SECOND",		SYM(SECOND_SYM)},
+  { "SECOND_MICROSECOND", SYM(SECOND_MICROSECOND_SYM)},
+  { "SELECT",		SYM(SELECT_SYM)},
+  { "SEPARATOR",	SYM(SEPARATOR_SYM)},
+  { "SERIAL",		SYM(SERIAL_SYM)},
+  { "SERIALIZABLE",	SYM(SERIALIZABLE_SYM)},
+  { "SESSION",		SYM(SESSION_SYM)},
+  { "SET",		SYM(SET)},
+  { "SHARE",		SYM(SHARE_SYM)},
+  { "SHOW",		SYM(SHOW)},
+  { "SHUTDOWN",		SYM(SHUTDOWN)},
+  { "SIGNED",		SYM(SIGNED_SYM)},
+  { "SIMPLE",		SYM(SIMPLE_SYM)},
+  { "SLAVE",            SYM(SLAVE)},
+  { "SMALLINT",		SYM(SMALLINT)},
+  { "SOME",             SYM(ANY_SYM)},
+  { "SONAME",		SYM(UDF_SONAME_SYM)},
+  { "SOUNDS",		SYM(SOUNDS_SYM)},
+  { "SPATIAL",		SYM(SPATIAL_SYM)},
+  { "SQL_BIG_RESULT",	SYM(SQL_BIG_RESULT)},
+  { "SQL_BUFFER_RESULT", SYM(SQL_BUFFER_RESULT)},
+  { "SQL_CACHE",        SYM(SQL_CACHE_SYM)},
+  { "SQL_CALC_FOUND_ROWS", SYM(SQL_CALC_FOUND_ROWS)},
+  { "SQL_NO_CACHE",	SYM(SQL_NO_CACHE_SYM)},
+  { "SQL_SMALL_RESULT", SYM(SQL_SMALL_RESULT)},
+  { "SQL_THREAD",	SYM(SQL_THREAD)},
+  { "SSL",		SYM(SSL_SYM)},
+  { "START",		SYM(START_SYM)},
+  { "STARTING",		SYM(STARTING)},
+  { "STATUS",		SYM(STATUS_SYM)},
+  { "STOP",		SYM(STOP_SYM)},
+  { "STORAGE",		SYM(STORAGE_SYM)},
+  { "STRAIGHT_JOIN",	SYM(STRAIGHT_JOIN)},
+  { "STRING",		SYM(STRING_SYM)},
+  { "STRIPED",		SYM(RAID_STRIPED_SYM)},
+  { "SUBJECT",		SYM(SUBJECT_SYM)},
+  { "SUPER",		SYM(SUPER_SYM)},
+  { "TABLE",		SYM(TABLE_SYM)},
+  { "TABLES",		SYM(TABLES)},
+  { "TABLESPACE",	SYM(TABLESPACE)},
+  { "TEMPORARY",	SYM(TEMPORARY)},
+  { "TERMINATED",	SYM(TERMINATED)},
+  { "TEXT",		SYM(TEXT_SYM)},
+  { "THEN",		SYM(THEN_SYM)},
+  { "TIME",		SYM(TIME_SYM)},
+  { "TIMESTAMP",	SYM(TIMESTAMP)},
+  { "TINYBLOB",		SYM(TINYBLOB)},
+  { "TINYINT",		SYM(TINYINT)},
+  { "TINYTEXT",		SYM(TINYTEXT)},
+  { "TO",		SYM(TO_SYM)},
+  { "TRAILING",		SYM(TRAILING)},
+  { "TRANSACTION",	SYM(TRANSACTION_SYM)},
+  { "TRUE",		SYM(TRUE_SYM)},
+  { "TRUNCATE",		SYM(TRUNCATE_SYM)},
+  { "TYPE",		SYM(TYPE_SYM)},
+  { "TYPES",		SYM(TYPES_SYM)},
+  { "UNCOMMITTED",	SYM(UNCOMMITTED_SYM)},
+  { "UNICODE",	        SYM(UNICODE_SYM)},
+  { "UNION",	        SYM(UNION_SYM)},
+  { "UNIQUE",		SYM(UNIQUE_SYM)},
+  { "UNLOCK",		SYM(UNLOCK_SYM)},
+  { "UNSIGNED",		SYM(UNSIGNED)},
+  { "UNTIL",		SYM(UNTIL_SYM)},
+  { "UPDATE",		SYM(UPDATE_SYM)},
+  { "USAGE",		SYM(USAGE)},
+  { "USE",		SYM(USE_SYM)},
+  { "USER",		SYM(USER)},
+  { "USER_RESOURCES",	SYM(RESOURCES)},
+  { "USE_FRM",		SYM(USE_FRM)},
+  { "USING",		SYM(USING)},
+  { "UTC_DATE",         SYM(UTC_DATE_SYM)},
+  { "UTC_TIME",         SYM(UTC_TIME_SYM)},
+  { "UTC_TIMESTAMP",    SYM(UTC_TIMESTAMP_SYM)},
+  { "VALUE",		SYM(VALUE_SYM)},
+  { "VALUES",		SYM(VALUES)},
+  { "VARBINARY",	SYM(VARBINARY)},
+  { "VARCHAR",		SYM(VARCHAR)},
+  { "VARCHARACTER",	SYM(VARCHAR)},
+  { "VARIABLES",	SYM(VARIABLES)},
+  { "VARYING",		SYM(VARYING)},
+  { "WARNINGS",		SYM(WARNINGS)},
+  { "WHEN",		SYM(WHEN_SYM)},
+  { "WHERE",		SYM(WHERE)},
+  { "WITH",		SYM(WITH)},
+  { "WORK",		SYM(WORK_SYM)},
+  { "WRITE",		SYM(WRITE_SYM)},
+  { "X509",		SYM(X509_SYM)},
+  { "XOR",		SYM(XOR)},
+  { "YEAR",		SYM(YEAR_SYM)},
+  { "YEAR_MONTH",	SYM(YEAR_MONTH_SYM)},
+  { "ZEROFILL",		SYM(ZEROFILL)},
+  { "||",		SYM(OR_OR_CONCAT)}
 };
 
 
 static SYMBOL sql_functions[] = {
-  { "ABS",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_abs)},
-  { "ACOS",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_acos)},
-  { "ADDDATE",		SYM(ADDDATE_SYM),0,0},
-  { "ADDTIME",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_addtime)},
-  { "AES_ENCRYPT",      SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_encrypt)},
-  { "AES_DECRYPT",      SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_aes_decrypt)},
-  { "AREA",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_area)},
-  { "ASIN",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_asin)},
-  { "ASBINARY",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_as_wkb)},
-  { "ASTEXT",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_as_wkt)},
-  { "ASWKB",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_as_wkb)},
-  { "ASWKT",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_as_wkt)},
-  { "ATAN",		SYM(ATAN),0,0},
-  { "ATAN2",		SYM(ATAN),0,0},
-  { "BENCHMARK",	SYM(BENCHMARK_SYM),0,0},
-  { "BIN",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bin)},
-  { "BIT_COUNT",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_count)},
-  { "BIT_OR",		SYM(BIT_OR),0,0},
-  { "BIT_AND",		SYM(BIT_AND),0,0},
-  { "BIT_XOR",		SYM(BIT_XOR),0,0},
-  { "CAST",		SYM(CAST_SYM),0,0},
-  { "CEIL",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
-  { "CEILING",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ceiling)},
-  { "CURRENT_USER",	SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_current_user)},
-  { "BIT_LENGTH",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_bit_length)},
-  { "CENTROID",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_centroid)},
-  { "CHAR_LENGTH",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
-  { "CHARACTER_LENGTH", SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_char_length)},
-  { "COALESCE",		SYM(COALESCE),0,0},
-  { "COERCIBILITY",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_coercibility)},
-  { "COMPRESS",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_compress)},
-  { "CONCAT",		SYM(CONCAT),0,0},
-  { "CONCAT_WS",	SYM(CONCAT_WS),0,0},
-  { "CONNECTION_ID",	SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_connection_id)},
-  { "CONTAINS",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_contains)},
-  { "CONV",		SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_conv)},
-  { "CONVERT",		SYM(CONVERT_SYM),0,0},
-  { "COUNT",		SYM(COUNT_SYM),0,0},
-  { "COS",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cos)},
-  { "COT",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_cot)},
-  { "CRC32",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_crc32)},
-  { "CROSSES",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_crosses)},
-  { "CURDATE",		SYM(CURDATE),0,0},
-  { "CURTIME",		SYM(CURTIME),0,0},
-  { "DATE_ADD",		SYM(DATE_ADD_INTERVAL),0,0},
-  { "DATEDIFF",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_datediff)},
-  { "DATE_FORMAT",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_date_format)},
-  { "DATE_SUB",		SYM(DATE_SUB_INTERVAL),0,0},
-  { "DAYNAME",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayname)},
-  { "DAYOFMONTH",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofmonth)},
-  { "DAYOFWEEK",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofweek)},
-  { "DAYOFYEAR",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dayofyear)},
-  { "DECODE",		SYM(DECODE_SYM),0,0},
-  { "DEGREES",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_degrees)},
-  { "DES_ENCRYPT",	SYM(DES_ENCRYPT_SYM),0,0},
-  { "DES_DECRYPT",	SYM(DES_DECRYPT_SYM),0,0},
-  { "DIMENSION",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_dimension)},
-  { "DISJOINT",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_disjoint)},
-  { "ELT",		SYM(ELT_FUNC),0,0},
-  { "ENCODE",		SYM(ENCODE_SYM),0,0},
-  { "ENCRYPT",		SYM(ENCRYPT),0,0},
-  { "ENDPOINT",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_endpoint)},
-  { "ENVELOPE",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_envelope)},
-  { "EQUALS",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_equals)},
-  { "EXTERIORRING",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_exteriorring)},
-  { "EXTRACT",		SYM(EXTRACT_SYM),0,0},
-  { "EXP",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_exp)},
-  { "EXPORT_SET",	SYM(EXPORT_SET),0,0},
-  { "FIELD",		SYM(FIELD_FUNC),0,0},	/* For compability */
-  { "FIND_IN_SET",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_find_in_set)},
-  { "FLOOR",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_floor)},
-  { "FORMAT",		SYM(FORMAT_SYM),0,0},
-  { "FOUND_ROWS",	SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_found_rows)},
-  { "FROM_DAYS",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_from_days)},
-  { "FROM_UNIXTIME",	SYM(FROM_UNIXTIME),0,0},
-  { "GET_LOCK",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_get_lock)},
-  { "GEOMETRYN",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_geometryn)},
-  { "GEOMETRYTYPE",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_geometry_type)},
-  { "GEOMCOLLFROMTEXT",	SYM(GEOMCOLLFROMTEXT),0,0},
-  { "GEOMCOLLFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "GEOMETRYCOLLECTIONFROMTEXT",SYM(GEOMCOLLFROMTEXT),0,0},
-  { "GEOMETRYCOLLECTIONFROMWKB",SYM(GEOMFROMWKB),0,0},
-  { "GEOMETRYFROMTEXT", SYM(GEOMFROMTEXT),0,0},
-  { "GEOMETRYFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "GEOMFROMTEXT",	SYM(GEOMFROMTEXT),0,0},
-  { "GEOMFROMWKB",	SYM(GEOMFROMWKB),0,0},
-    { "GLENGTH",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_glength)},
-  { "GREATEST",		SYM(GREATEST_SYM),0,0},
-  { "GROUP_CONCAT",	SYM(GROUP_CONCAT_SYM),0,0},
-  { "GROUP_UNIQUE_USERS",	SYM(GROUP_UNIQUE_USERS),0,0},
-  { "HEX",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_hex)},
-  { "IFNULL",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_ifnull)},
-  { "INET_ATON",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_aton)},
-  { "INET_NTOA",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_inet_ntoa)},
-  { "INSTR",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_instr)},
-  { "INTERIORRINGN",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_interiorringn)},
-  { "INTERSECTS",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_intersects)},
-  { "ISCLOSED",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_isclosed)},
-  { "ISEMPTY",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_isempty)},
-  { "ISNULL",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_isnull)},
-  { "IS_FREE_LOCK",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_free_lock)},
-  { "IS_USED_LOCK",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_is_used_lock)},
-  { "LAST_INSERT_ID",	SYM(LAST_INSERT_ID),0,0},
-  { "ISSIMPLE",         SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_issimple)},
-  { "LAST_DAY",         SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_last_day)},
-  { "LCASE",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
-  { "LEAST",		SYM(LEAST_SYM),0,0},
-  { "LENGTH",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
-  { "LN",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ln)},
-  { "LINEFROMTEXT",	SYM(LINEFROMTEXT),0,0},
-  { "LINEFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "LINESTRINGFROMTEXT",SYM(LINEFROMTEXT),0,0},
-  { "LINESTRINGFROMWKB",SYM(GEOMFROMWKB),0,0},
-  { "LOAD_FILE",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_load_file)},
-  { "LOCATE",		SYM(LOCATE),0,0},
-  { "LOG",		SYM(LOG_SYM),0,0},
-  { "LOG2",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log2)},
-  { "LOG10",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_log10)},
-  { "LOWER",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_lcase)},
-  { "LPAD",		SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_lpad)},
-  { "LTRIM",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ltrim)},
-  { "MAKE_SET",		SYM(MAKE_SET_SYM),0,0},
-  { "MAKEDATE",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_makedate)},
-  { "MAKETIME",		SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_maketime)},
-  { "MASTER_POS_WAIT",	SYM(MASTER_POS_WAIT),0,0},
-  { "MAX",		SYM(MAX_SYM),0,0},
-  { "MBRCONTAINS",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_contains)},
-  { "MBRDISJOINT",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_disjoint)},
-  { "MBREQUAL",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_equals)},
-  { "MBRINTERSECTS",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_intersects)},
-  { "MBROVERLAPS",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_overlaps)},
-  { "MBRTOUCHES",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_touches)},
-  { "MBRWITHIN",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_within)},
-  { "MD5",              SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_md5)},
-  { "MID",		SYM(SUBSTRING),0,0},	/* unireg function */
-  { "MIN",		SYM(MIN_SYM),0,0},
-  { "MLINEFROMTEXT",	SYM(MLINEFROMTEXT),0,0},
-  { "MLINEFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "MPOINTFROMTEXT",	SYM(MPOINTFROMTEXT),0,0},
-  { "MPOINTFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "MPOLYFROMTEXT",	SYM(MPOLYFROMTEXT),0,0},
-  { "MPOLYFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "MONTHNAME",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_monthname)},
-  { "MULTILINESTRINGFROMTEXT",SYM(MLINEFROMTEXT),0,0},
-  { "MULTILINESTRINGFROMWKB",SYM(GEOMFROMWKB),0,0},
-  { "MULTIPOINTFROMTEXT",SYM(MPOINTFROMTEXT),0,0},
-  { "MULTIPOINTFROMWKB",SYM(GEOMFROMWKB),0,0},
-  { "MULTIPOLYGONFROMTEXT",SYM(MPOLYFROMTEXT),0,0},
-  { "MULTIPOLYGONFROMWKB",SYM(GEOMFROMWKB),0,0},
-  { "NOW",		SYM(NOW_SYM),0,0},
-  { "NULLIF",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_nullif)},
-  { "NUMGEOMETRIES",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_numgeometries)},
-  { "NUMINTERIORRINGS",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_numinteriorring)},
-  { "NUMPOINTS",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_numpoints)},
-  { "OCTET_LENGTH",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_length)},
-  { "OCT",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_oct)},
-  { "ORD",              SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ord)},
-  { "OVERLAPS",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_overlaps)},
-  { "PERIOD_ADD",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_add)},
-  { "PERIOD_DIFF",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_period_diff)},
-  { "PI",		SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_pi)},
-  { "POINTFROMTEXT",	SYM(POINTFROMTEXT),0,0},
-  { "POINTFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "POINTN",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pointn)},
-  { "POLYFROMTEXT",	SYM(POLYFROMTEXT),0,0},
-  { "POLYFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "POLYGONFROMTEXT",	SYM(POLYFROMTEXT),0,0},
-  { "POLYGONFROMWKB",	SYM(GEOMFROMWKB),0,0},
-  { "POSITION",		SYM(POSITION_SYM),0,0},
-  { "POW",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
-  { "POWER",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_pow)},
-  { "QUARTER",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quarter)},
-  { "QUOTE",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quote)},
-  { "RADIANS",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_radians)},
-  { "RAND",		SYM(RAND),0,0},
-  { "RELEASE_LOCK",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_release_lock)},
-  { "REPEAT",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_repeat)},
-  { "REVERSE",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_reverse)},
-  { "ROUND",		SYM(ROUND),0,0},
-  { "RPAD",		SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_rpad)},
-  { "RTRIM",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_rtrim)},
-  { "SEC_TO_TIME",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sec_to_time)},
-  { "SESSION_USER",	SYM(USER),0,0},
-  { "SUBDATE",		SYM(SUBDATE_SYM),0,0},
-  { "SIGN",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sign)},
-  { "SIN",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sin)},
-  { "SHA",              SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
-  { "SHA1",             SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sha)},
-  { "SOUNDEX",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_soundex)},
-  { "SPACE",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_space)},
-  { "SQRT",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_sqrt)},
-  { "SRID",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_srid)},
-  { "STARTPOINT",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_startpoint)},
-  { "STD",		SYM(STD_SYM),0,0},
-  { "STDDEV",		SYM(STD_SYM),0,0},
-  { "STR_TO_DATE",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_str_to_date)},
-  { "STRCMP",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_strcmp)},
-  { "SUBSTR",	  	SYM(SUBSTRING),0,0},
-  { "SUBSTRING",	SYM(SUBSTRING),0,0},
-  { "SUBSTRING_INDEX",	SYM(SUBSTRING_INDEX),0,0},
-  { "SUBTIME",          SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_subtime)},
-  { "SUM",		SYM(SUM_SYM),0,0},
-  { "SYSDATE",		SYM(NOW_SYM),0,0},
-  { "SYSTEM_USER",	SYM(USER),0,0},
-  { "TAN",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_tan)},
-  { "TIME_FORMAT",	SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_time_format)},
-  { "TIME_TO_SEC",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_time_to_sec)},
-  { "TIMEDIFF",         SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_timediff)},
-  { "TO_DAYS",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_to_days)},
-  { "TOUCHES",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_touches)},
-  { "TRIM",		SYM(TRIM),0,0},
-  { "UCASE",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
-  { "UNCOMPRESS",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompress)},
-  { "UNCOMPRESSED_LENGTH", SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_uncompressed_length)},
-  { "UNIQUE_USERS",	SYM(UNIQUE_USERS),0,0},
-  { "UNIX_TIMESTAMP",	SYM(UNIX_TIMESTAMP),0,0},
-  { "UPPER",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
-  { "VARIANCE",		SYM(VARIANCE_SYM),0,0},
-  { "VERSION",		SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_version)},
-  { "WEEK",		SYM(WEEK_SYM),0,0},
-  { "WEEKDAY",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekday)},
-  { "WEEKOFYEAR",	SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_weekofyear)},
-  { "WITHIN",		SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_within)},
-  { "X",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_x)},
-  { "Y",		SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_y)},
-  { "YEARWEEK",		SYM(YEARWEEK),0,0}
+  { "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_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)},
+  { "CURRENT_USER",	F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_current_user)},
+  { "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)},
+  { "COALESCE",		SYM(COALESCE)},
+  { "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)},
+  { "CONTAINS",		F_SYM(FUNC_ARG2),0,CREATE_FUNC_GEOM(create_func_contains)},
+  { "CONV",		F_SYM(FUNC_ARG3),0,CREATE_FUNC(create_func_conv)},
+  { "CONVERT",		SYM(CONVERT_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)},
+  { "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)},
+  { "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)},
+  { "QUARTER",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_quarter)},
+  { "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)},
+  { "REPEAT",		F_SYM(FUNC_ARG2),0,CREATE_FUNC(create_func_repeat)},
+  { "REVERSE",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_reverse)},
+  { "ROUND",		SYM(ROUND)},
+  { "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)},
+  { "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)},
+  { "STD",		SYM(STD_SYM)},
+  { "STDDEV",		SYM(STD_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)},
+  { "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(NOW_SYM)},
+  { "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)},
+  { "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)},
+  { "UNIQUE_USERS",	SYM(UNIQUE_USERS)},
+  { "UNIX_TIMESTAMP",	SYM(UNIX_TIMESTAMP)},
+  { "UPPER",		F_SYM(FUNC_ARG1),0,CREATE_FUNC(create_func_ucase)},
+  { "VARIANCE",		SYM(VARIANCE_SYM)},
+  { "VERSION",		F_SYM(FUNC_ARG0),0,CREATE_FUNC(create_func_version)},
+  { "WEEK",		SYM(WEEK_SYM)},
+  { "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 9fff1751b1b..d1d30a73669 100644
--- a/sql/lex_symbol.h
+++ b/sql/lex_symbol.h
@@ -20,11 +20,14 @@
 #ifndef _lex_symbol_h
 #define _lex_symbol_h
 
+struct st_sym_group;
+
 typedef struct st_symbol {
   const char *name;
   uint	tok;
   uint length;
   void *create_func;
+  struct st_sym_group *group;
 } SYMBOL;
 
 typedef struct st_lex_symbol
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index d8b65ec81b9..e7faaf1767d 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1105,3 +1105,12 @@ inline void setup_table_map(TABLE *table, TABLE_LIST *table_list, uint tablenr)
   table->map= (table_map) 1 << tablenr;
   table->force_index= table_list->force_index;
 }
+
+typedef struct st_sym_group {
+  const char *name;
+  const char *needed_define;
+} SYM_GROUP;
+
+extern SYM_GROUP sym_group_common;
+extern SYM_GROUP sym_group_geom;
+extern SYM_GROUP sym_group_rtree;
diff --git a/sql/share/czech/errmsg.txt b/sql/share/czech/errmsg.txt
index cf5f573774b..16c04fc7656 100644
--- a/sql/share/czech/errmsg.txt
+++ b/sql/share/czech/errmsg.txt
@@ -300,3 +300,4 @@ character-set=latin2
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/danish/errmsg.txt b/sql/share/danish/errmsg.txt
index 2a42570ded3..99470e1a32c 100644
--- a/sql/share/danish/errmsg.txt
+++ b/sql/share/danish/errmsg.txt
@@ -294,3 +294,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/dutch/errmsg.txt b/sql/share/dutch/errmsg.txt
index 53463c31d02..0b4a8139e57 100644
--- a/sql/share/dutch/errmsg.txt
+++ b/sql/share/dutch/errmsg.txt
@@ -302,3 +302,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/english/errmsg.txt b/sql/share/english/errmsg.txt
index 71c8c8f1559..0f9d9fc1144 100644
--- a/sql/share/english/errmsg.txt
+++ b/sql/share/english/errmsg.txt
@@ -291,3 +291,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/estonian/errmsg.txt b/sql/share/estonian/errmsg.txt
index fecf0cde7be..a54bc435fc1 100644
--- a/sql/share/estonian/errmsg.txt
+++ b/sql/share/estonian/errmsg.txt
@@ -296,3 +296,4 @@ character-set=latin7
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/french/errmsg.txt b/sql/share/french/errmsg.txt
index afc1879a526..accf5913ce2 100644
--- a/sql/share/french/errmsg.txt
+++ b/sql/share/french/errmsg.txt
@@ -291,3 +291,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/german/errmsg.txt b/sql/share/german/errmsg.txt
index 56e263bc64e..79b8ad5fe64 100644
--- a/sql/share/german/errmsg.txt
+++ b/sql/share/german/errmsg.txt
@@ -303,3 +303,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/greek/errmsg.txt b/sql/share/greek/errmsg.txt
index 1596b1adbab..09928aed242 100644
--- a/sql/share/greek/errmsg.txt
+++ b/sql/share/greek/errmsg.txt
@@ -291,3 +291,4 @@ character-set=greek
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/hungarian/errmsg.txt b/sql/share/hungarian/errmsg.txt
index bcd17fca7cc..b7491154815 100644
--- a/sql/share/hungarian/errmsg.txt
+++ b/sql/share/hungarian/errmsg.txt
@@ -293,3 +293,4 @@ character-set=latin2
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/italian/errmsg.txt b/sql/share/italian/errmsg.txt
index 22a09ac1a1b..829428f2fd4 100644
--- a/sql/share/italian/errmsg.txt
+++ b/sql/share/italian/errmsg.txt
@@ -291,3 +291,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/japanese/errmsg.txt b/sql/share/japanese/errmsg.txt
index b76fa5d8f6d..2acd11a399e 100644
--- a/sql/share/japanese/errmsg.txt
+++ b/sql/share/japanese/errmsg.txt
@@ -293,3 +293,4 @@ character-set=ujis
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/korean/errmsg.txt b/sql/share/korean/errmsg.txt
index 482bc91852c..0533f52fc12 100644
--- a/sql/share/korean/errmsg.txt
+++ b/sql/share/korean/errmsg.txt
@@ -291,3 +291,4 @@ character-set=euckr
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/norwegian-ny/errmsg.txt b/sql/share/norwegian-ny/errmsg.txt
index a442a5879b8..bb6b5b8cb11 100644
--- a/sql/share/norwegian-ny/errmsg.txt
+++ b/sql/share/norwegian-ny/errmsg.txt
@@ -293,3 +293,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/norwegian/errmsg.txt b/sql/share/norwegian/errmsg.txt
index 47660e29676..b8a678d9b64 100644
--- a/sql/share/norwegian/errmsg.txt
+++ b/sql/share/norwegian/errmsg.txt
@@ -293,3 +293,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/polish/errmsg.txt b/sql/share/polish/errmsg.txt
index 7f81facf6f5..04cf28915b5 100644
--- a/sql/share/polish/errmsg.txt
+++ b/sql/share/polish/errmsg.txt
@@ -295,3 +295,4 @@ character-set=latin2
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/portuguese/errmsg.txt b/sql/share/portuguese/errmsg.txt
index 8ddd281b346..16620380603 100644
--- a/sql/share/portuguese/errmsg.txt
+++ b/sql/share/portuguese/errmsg.txt
@@ -292,3 +292,4 @@ character-set=latin1
 "Motor de tabela desconhecido '%s'",
 "'%s' � desatualizado. Use '%s' em seu lugar.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/romanian/errmsg.txt b/sql/share/romanian/errmsg.txt
index 2235871738c..6ccccd95417 100644
--- a/sql/share/romanian/errmsg.txt
+++ b/sql/share/romanian/errmsg.txt
@@ -295,3 +295,4 @@ character-set=latin2
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/russian/errmsg.txt b/sql/share/russian/errmsg.txt
index 76fc04f42e4..c5d06722cd8 100644
--- a/sql/share/russian/errmsg.txt
+++ b/sql/share/russian/errmsg.txt
@@ -293,3 +293,4 @@ character-set=koi8r
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "������� %-.100s � %s �� ����� ���������.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/serbian/errmsg.txt b/sql/share/serbian/errmsg.txt
index a61c6a25ccc..c47c7b66e5a 100644
--- a/sql/share/serbian/errmsg.txt
+++ b/sql/share/serbian/errmsg.txt
@@ -286,3 +286,4 @@ character-set=cp1250
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/slovak/errmsg.txt b/sql/share/slovak/errmsg.txt
index 36437930095..8820b36b746 100644
--- a/sql/share/slovak/errmsg.txt
+++ b/sql/share/slovak/errmsg.txt
@@ -299,3 +299,4 @@ character-set=latin2
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/spanish/errmsg.txt b/sql/share/spanish/errmsg.txt
index 8e61ce6a62f..a17d58c2d35 100644
--- a/sql/share/spanish/errmsg.txt
+++ b/sql/share/spanish/errmsg.txt
@@ -293,3 +293,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/swedish/errmsg.txt b/sql/share/swedish/errmsg.txt
index 9c13347cc3c..f9f05c7e122 100644
--- a/sql/share/swedish/errmsg.txt
+++ b/sql/share/swedish/errmsg.txt
@@ -291,3 +291,4 @@ character-set=latin1
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "The target table %-.100s of the %s is not updatable.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/share/ukrainian/errmsg.txt b/sql/share/ukrainian/errmsg.txt
index b5d5f74ef77..255083529c3 100644
--- a/sql/share/ukrainian/errmsg.txt
+++ b/sql/share/ukrainian/errmsg.txt
@@ -296,3 +296,4 @@ character-set=koi8u
 "Unknown table engine '%s'",
 "'%s' is deprecated. Use '%s' instead.",
 "������� %-.100s � %s �� ���� ������������.",
+"The '%s' feature was disabled. You need MySQL built with '%s' define to have it working"
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 413fb77d929..60da32fceca 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -510,6 +510,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
       blob_columns++;
       break;
     case FIELD_TYPE_GEOMETRY:
+#ifdef HAVE_SPATIAL
       if (!(file->table_flags() & HA_HAS_GEOMETRY))
       {
 	my_printf_error(ER_CHECK_NOT_IMPLEMENTED, ER(ER_CHECK_NOT_IMPLEMENTED),
@@ -525,6 +526,11 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
       sql_field->unireg_check=Field::BLOB_FIELD;
       blob_columns++;
       break;
+#else
+      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED), MYF(0),
+		      sym_group_geom.name, sym_group_geom.needed_define);
+      DBUG_RETURN(-1);
+#endif /*HAVE_SPATIAL*/
     case FIELD_TYPE_VAR_STRING:
     case FIELD_TYPE_STRING:
       sql_field->pack_flag=0;
@@ -658,8 +664,14 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
         key_info->flags = HA_FULLTEXT;
         break;
     case Key::SPATIAL:
+#ifdef HAVE_SPATIAL
         key_info->flags = HA_SPATIAL;
         break;
+#else
+	my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
+			sym_group_geom.name, sym_group_geom.needed_define);
+	DBUG_RETURN(-1);
+#endif
     case Key::FOREIGN_KEY:
       key_number--;				// Skip this key
       continue;
@@ -698,8 +710,10 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
         DBUG_RETURN(-1);
       }
     }
-    else if (key_info->algorithm == HA_KEY_ALG_RTREE)
+    else
+    if (key_info->algorithm == HA_KEY_ALG_RTREE)
     {
+#ifdef HAVE_RTREE_KEYS
       if ((key_info->key_parts & 1) == 1)
       {
 	my_printf_error(ER_WRONG_ARGUMENTS,
@@ -710,6 +724,11 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
       my_printf_error(ER_NOT_SUPPORTED_YET, ER(ER_NOT_SUPPORTED_YET),
 		      MYF(0), "RTREE INDEX");
       DBUG_RETURN(-1);
+#else
+      my_printf_error(ER_FEATURE_DISABLED,ER(ER_FEATURE_DISABLED),MYF(0),
+		      sym_group_rtree.name, sym_group_rtree.needed_define);
+      DBUG_RETURN(-1);
+#endif
     }
 
     List_iterator<key_part_spec> cols(key->columns);
@@ -779,6 +798,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
             DBUG_RETURN(-1);
           }
         }
+#ifdef HAVE_SPATIAL
         if (key->type  == Key::SPATIAL)
         {
           if (!column->length )
@@ -790,6 +810,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
             column->length=4*sizeof(double);
           }
         }
+#endif
         if (!(sql_field->flags & NOT_NULL_FLAG))
         {
           if (key->type == Key::PRIMARY)
@@ -834,6 +855,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
 	    DBUG_RETURN(-1);
 	  }
 	}
+        /* TODO HF What's this for??? */
 	else if (f_is_geom(sql_field->pack_flag))
 	{
 	}
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 5ab53a1b934..02a677038cb 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -611,7 +611,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b,int *yystacksize);
 	udf_type if_exists opt_local opt_table_options table_options
         table_option opt_if_not_exists opt_no_write_to_binlog opt_var_type
         opt_var_ident_type delete_option opt_temporary all_or_any opt_distinct
-        opt_ignore_leaves fulltext_options
+        opt_ignore_leaves fulltext_options spatial_type
 
 %type <ulong_num>
 	ULONG_NUM raid_types merge_insert_types
@@ -628,7 +628,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b,int *yystacksize);
 	table_wild no_in_expr expr_expr simple_expr no_and_expr
 	using_list expr_or_default set_expr_or_default interval_expr
 	param_marker singlerow_subselect singlerow_subselect_init
-	exists_subselect exists_subselect_init
+	exists_subselect exists_subselect_init geometry_function
 	signed_literal NUM_literal
 
 %type <item_list>
@@ -1297,30 +1297,19 @@ type:
 					  $$=FIELD_TYPE_TINY_BLOB; }
 	| BLOB_SYM opt_len		{ Lex->charset=&my_charset_bin;
 					  $$=FIELD_TYPE_BLOB; }
-	| GEOMETRY_SYM			{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_GEOMETRY;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| GEOMETRYCOLLECTION		{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_GEOMETRYCOLLECTION;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| POINT_SYM			{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_POINT;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| MULTIPOINT			{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_MULTIPOINT;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| LINESTRING			{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_LINESTRING;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| MULTILINESTRING		{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_MULTILINESTRING;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| POLYGON			{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_POLYGON;
-					  $$=FIELD_TYPE_GEOMETRY; }
-	| MULTIPOLYGON			{ Lex->charset=&my_charset_bin;
-					  Lex->uint_geom_type= (uint) Field::GEOM_MULTIPOLYGON;
-					  $$=FIELD_TYPE_GEOMETRY; }
+	| spatial_type			{ 
+#ifdef HAVE_SPATIAL
+					  Lex->charset=&my_charset_bin;
+					  Lex->uint_geom_type= (uint)$1;
+					  $$=FIELD_TYPE_GEOMETRY;
+#else
+	                                  net_printf(Lex->thd, ER_FEATURE_DISABLED,
+			                             ER(ER_FEATURE_DISABLED),
+			                             sym_group_geom.name,
+	                                             sym_group_geom.needed_define);
+					  YYABORT;
+#endif
+					}
 	| MEDIUMBLOB			{ Lex->charset=&my_charset_bin;
 					  $$=FIELD_TYPE_MEDIUM_BLOB; }
 	| LONGBLOB			{ Lex->charset=&my_charset_bin;
@@ -1359,6 +1348,17 @@ type:
 	  }
 	;
 
+spatial_type:
+	GEOMETRY_SYM	      { $$= Field::GEOM_GEOMETRY; }
+	| GEOMETRYCOLLECTION  { $$= Field::GEOM_GEOMETRYCOLLECTION; }
+	| POINT_SYM           { $$= Field::GEOM_POINT; }
+	| MULTIPOINT          { $$= Field::GEOM_MULTIPOINT; }
+	| LINESTRING          { $$= Field::GEOM_LINESTRING; }
+	| MULTILINESTRING     { $$= Field::GEOM_MULTILINESTRING; }
+	| POLYGON             { $$= Field::GEOM_POLYGON; }
+	| MULTIPOLYGON        { $$= Field::GEOM_MULTIPOLYGON; }
+	;
+
 char:
 	CHAR_SYM {}
 	;
@@ -1589,20 +1589,32 @@ delete_option:
 
 key_type:
 	key_or_index			    { $$= Key::MULTIPLE; }
-	| FULLTEXT_SYM			    { $$= Key::FULLTEXT; }
-	| FULLTEXT_SYM key_or_index	    { $$= Key::FULLTEXT; }
-	| SPATIAL_SYM			    { $$= Key::SPATIAL; }
-	| SPATIAL_SYM key_or_index	    { $$= Key::SPATIAL; };
+	| FULLTEXT_SYM opt_key_or_index	    { $$= Key::FULLTEXT; }
+	| SPATIAL_SYM opt_key_or_index
+	  {
+#ifdef HAVE_SPATIAL
+	    $$= Key::SPATIAL;
+#else
+	    net_printf(Lex->thd, ER_FEATURE_DISABLED,
+	               ER(ER_FEATURE_DISABLED),
+		       sym_group_geom.name, sym_group_geom.needed_define);
+	    YYABORT;
+#endif
+	  };
 
 constraint_key_type:
 	PRIMARY_SYM KEY_SYM  { $$= Key::PRIMARY; }
-	| UNIQUE_SYM	    { $$= Key::UNIQUE; }
-	| UNIQUE_SYM key_or_index { $$= Key::UNIQUE; };
+	| UNIQUE_SYM opt_key_or_index { $$= Key::UNIQUE; };
 
 key_or_index:
 	KEY_SYM {}
 	| INDEX {};
 
+opt_key_or_index:
+	/* empty */ {}
+	| key_or_index
+	;
+
 opt_keys_or_index:
 	/* empty */ {}
 	| keys_or_index
@@ -1617,7 +1629,17 @@ opt_unique_or_fulltext:
 	/* empty */	{ $$= Key::MULTIPLE; }
 	| UNIQUE_SYM	{ $$= Key::UNIQUE; }
 	| FULLTEXT_SYM	{ $$= Key::FULLTEXT;}
-	| SPATIAL_SYM	{ $$= Key::SPATIAL; }
+	| SPATIAL_SYM
+	  {
+#ifdef HAVE_SPATIAL
+	    $$= Key::SPATIAL;
+#else
+	    net_printf(Lex->thd, ER_FEATURE_DISABLED,
+	               ER(ER_FEATURE_DISABLED),
+	               sym_group_geom.name, sym_group_geom.needed_define);
+	    YYABORT;
+#endif
+	  }
         ;
 
 key_alg:
@@ -1627,7 +1649,10 @@ key_alg:
 
 opt_btree_or_rtree:
 	BTREE_SYM	{ $$= HA_KEY_ALG_BTREE; }
-	| RTREE_SYM	{ $$= HA_KEY_ALG_RTREE; }
+	| RTREE_SYM
+	  {
+	    $$= HA_KEY_ALG_RTREE;
+	  }
 	| HASH_SYM	{ $$= HA_KEY_ALG_HASH; };
 
 key_list:
@@ -2556,13 +2581,53 @@ simple_expr:
 	| VALUES '(' simple_ident ')'
 	  { $$= new Item_insert_value($3); }
 	| FUNC_ARG0 '(' ')'
-	  { $$= ((Item*(*)(void))($1.symbol->create_func))();}
+	  {
+	    if (!$1.symbol->create_func)
+	    {
+	      net_printf(Lex->thd, ER_FEATURE_DISABLED,
+			 ER(ER_FEATURE_DISABLED),
+			 $1.symbol->group->name,
+	                 $1.symbol->group->needed_define);
+	      YYABORT;
+	    }
+	    $$= ((Item*(*)(void))($1.symbol->create_func))();
+	  }
 	| FUNC_ARG1 '(' expr ')'
-	  { $$= ((Item*(*)(Item*))($1.symbol->create_func))($3);}
+	  {
+	    if (!$1.symbol->create_func)
+	    {
+	      net_printf(Lex->thd, ER_FEATURE_DISABLED,
+			 ER(ER_FEATURE_DISABLED),
+			 $1.symbol->group->name,
+	                 $1.symbol->group->needed_define);
+	      YYABORT;
+	    }
+	    $$= ((Item*(*)(Item*))($1.symbol->create_func))($3);
+	  }
 	| FUNC_ARG2 '(' expr ',' expr ')'
-	  { $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5);}
+	  {
+	    if (!$1.symbol->create_func)
+	    {
+	      net_printf(Lex->thd, ER_FEATURE_DISABLED,
+			 ER(ER_FEATURE_DISABLED),
+			 $1.symbol->group->name,
+	                 $1.symbol->group->needed_define);
+	      YYABORT;
+	    }
+	    $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5);
+	  }
 	| FUNC_ARG3 '(' expr ',' expr ',' expr ')'
-	  { $$= ((Item*(*)(Item*,Item*,Item*))($1.symbol->create_func))($3,$5,$7);}
+	  {
+	    if (!$1.symbol->create_func)
+	    {
+	      net_printf(Lex->thd, ER_FEATURE_DISABLED,
+			 ER(ER_FEATURE_DISABLED),
+			 $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 ')'
@@ -2645,18 +2710,17 @@ simple_expr:
 	  }
 	| FIELD_FUNC '(' expr ',' expr_list ')'
 	  { $5->push_front($3); $$= new Item_func_field(*$5); }
-	| GEOMFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| GEOMFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
-	| GEOMFROMWKB '(' expr ')'
-	  { $$= new Item_func_geometry_from_wkb($3); }
-	| GEOMFROMWKB '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_wkb($3, $5); }
-	| GEOMETRYCOLLECTION '(' expr_list ')'
-	  { $$= new Item_func_spatial_collection(* $3,
-                       Geometry::wkbGeometryCollection,
-                       Geometry::wkbPoint); }
+	| geometry_function
+	  {
+#ifdef HAVE_SPATIAL
+	    $$= $1;
+#else
+	    net_printf(Lex->thd, ER_FEATURE_DISABLED,
+	               ER(ER_FEATURE_DISABLED),
+	               sym_group_geom.name, sym_group_geom.needed_define);
+	    YYABORT;
+#endif
+	  }
 	| GET_FORMAT '(' date_time_type  ',' expr ')'
 	  { $$= new Item_func_get_format($3, $5); }
 	| HOUR_SYM '(' expr ')'
@@ -2690,17 +2754,10 @@ simple_expr:
 	  }
 	| LEFT '(' expr ',' expr ')'
 	  { $$= new Item_func_left($3,$5); }
-	| LINESTRING '(' expr_list ')'
-	  { $$= new Item_func_spatial_collection(* $3,
-               Geometry::wkbLineString, Geometry::wkbPoint); }
 	| LOCATE '(' expr ',' expr ')'
 	  { $$= new Item_func_locate($5,$3); }
 	| LOCATE '(' expr ',' expr ',' expr ')'
 	  { $$= new Item_func_locate($5,$3,$7); }
- 	| GEOMCOLLFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| GEOMCOLLFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
 	| GREATEST_SYM '(' expr ',' expr_list ')'
 	  { $5->push_front($3); $$= new Item_func_max(*$5); }
 	| LEAST_SYM '(' expr ',' expr_list ')'
@@ -2709,10 +2766,6 @@ simple_expr:
 	  { $$= new Item_func_log($3); }
 	| LOG_SYM '(' expr ',' expr ')'
 	  { $$= new Item_func_log($3, $5); }
- 	| LINEFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| LINEFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
 	| MASTER_POS_WAIT '(' expr ',' expr ')'
 	  {
 	    $$= new Item_master_pos_wait($3, $5);
@@ -2731,27 +2784,6 @@ simple_expr:
 	  { $$ = new Item_func_mod( $3, $5); }
 	| MONTH_SYM '(' expr ')'
 	  { $$= new Item_func_month($3); }
- 	| MULTILINESTRING '(' expr_list ')'
- 	  { $$= new Item_func_spatial_collection(* $3,
-                    Geometry::wkbMultiLineString, Geometry::wkbLineString); }
- 	| MLINEFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| MLINEFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
-	| MPOINTFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| MPOINTFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
-	| MPOLYFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| MPOLYFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
-	| MULTIPOINT '(' expr_list ')'
-	  { $$= new Item_func_spatial_collection(* $3,
-                    Geometry::wkbMultiPoint, Geometry::wkbPoint); }
- 	| MULTIPOLYGON '(' expr_list ')'
-	  { $$= new Item_func_spatial_collection(* $3,
-                       Geometry::wkbMultiPolygon, Geometry::wkbPolygon ); }
 	| NOW_SYM optional_braces
 	  { $$= new Item_func_now_local(); Lex->safe_to_cache_query=0;}
 	| NOW_SYM '(' expr ')'
@@ -2764,19 +2796,6 @@ simple_expr:
 	  }
 	| OLD_PASSWORD '(' expr ')'
 	  { $$=  new Item_func_old_password($3); }
-	| POINT_SYM '(' expr ',' expr ')'
-	  { $$= new Item_func_point($3,$5); }
- 	| POINTFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| POINTFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
-	| POLYFROMTEXT '(' expr ')'
-	  { $$= new Item_func_geometry_from_text($3); }
-	| POLYFROMTEXT '(' expr ',' expr ')'
-	  { $$= new Item_func_geometry_from_text($3, $5); }
-	| POLYGON '(' expr_list ')'
-	  { $$= new Item_func_spatial_collection(* $3,
-			Geometry::wkbPolygon, Geometry::wkbLineString); }
 	| POSITION_SYM '(' no_in_expr IN_SYM expr ')'
 	  { $$ = new Item_func_locate($5,$3); }
 	| RAND '(' expr ')'
@@ -2914,6 +2933,66 @@ simple_expr:
 	| EXTRACT_SYM '(' interval FROM expr ')'
 	{ $$=new Item_extract( $3, $5); };
 
+geometry_function:
+	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::wkbGeometryCollection,
+                           Geometry::wkbPoint)); }
+	| LINESTRING '(' expr_list ')'
+	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
+                  Geometry::wkbLineString, Geometry::wkbPoint)); }
+ 	| MULTILINESTRING '(' expr_list ')'
+	  { $$= GEOM_NEW( Item_func_spatial_collection(* $3,
+                   Geometry::wkbMultiLineString, Geometry::wkbLineString)); }
+ 	| 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::wkbMultiPoint, Geometry::wkbPoint)); }
+ 	| MULTIPOLYGON '(' expr_list ')'
+	  { $$= GEOM_NEW(Item_func_spatial_collection(* $3,
+                  Geometry::wkbMultiPolygon, Geometry::wkbPolygon)); }
+	| 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::wkbPolygon, Geometry::wkbLineString)); }
+ 	| 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)); }
+	;
+
 fulltext_options:
         /* nothing */                   { $$= FT_NL;  }
         | WITH QUERY_SYM EXPANSION_SYM  { $$= FT_NL | FT_EXPAND; }
diff --git a/sql/table.cc b/sql/table.cc
index 1127349db20..8fe061af530 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -405,8 +405,13 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
       // charset and geometry_type share the same byte in frm
       if (field_type == FIELD_TYPE_GEOMETRY)
       {
+#ifdef HAVE_SPATIAL
 	geom_type= (Field::geometry_type) strpos[14];
 	charset= &my_charset_bin;
+#else
+	error= 4;  // unsupported field type
+	goto err_not_open;
+#endif
       }
       else
       {
diff --git a/sql/unireg.cc b/sql/unireg.cc
index fc948ddd5a6..6ebba313442 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -471,7 +471,12 @@ static bool pack_fields(File file,List<create_field> &create_fields)
     buff[12]= (uchar) field->interval_id;
     buff[13]= (uchar) field->sql_type; 
     if (field->sql_type == FIELD_TYPE_GEOMETRY)
+    {
       buff[14]= (uchar) field->geom_type;
+#ifndef HAVE_SPATIAL
+      DBUG_ASSERT(0);                           // Should newer happen
+#endif
+    }
     else if (field->charset) 
       buff[14]= (uchar) field->charset->number;
     else