summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorunknown <hf@deer.(none)>2004-01-15 21:06:22 +0400
committerunknown <hf@deer.(none)>2004-01-15 21:06:22 +0400
commit235f1a4d60968bd9083780d13e249aad9fe7120c (patch)
tree24c233c602a5644cbcc259252d10163dc0551fc5
parent24f8054460a574660730024690786b877afccfd3 (diff)
downloadmariadb-git-235f1a4d60968bd9083780d13e249aad9fe7120c.tar.gz
SCRUM:
WL#1163 (Making spatial code optional) Pack of changes to do in sql/ code. sql/field.cc: Spatial code #ifdef-ed sql/field.h: Spatial code #ifdef-ed sql/item_create.cc: Spatial code #ifdef-ed sql/item_create.h: Spatial code #ifdef-ed sql/item_geofunc.cc: Spatial code #ifdef-ed sql/item_geofunc.h: Spatial code #ifdef-ed GEOM_NEW implementation sql/lex.h: Code was significally modified to support optional group of functions sql/lex_symbol.h: SYM_GROUP structure presented sql/sql_table.cc: Spatial code #ifdef-ed sql/sql_yacc.yy: Several modifications to make spatial code optional sql/table.cc: Spatial code #ifdef-ed sql/unireg.cc: Spatial code #ifdef-ed
Diffstat
-rw-r--r--sql/field.cc10
-rw-r--r--sql/field.h7
-rw-r--r--sql/item_create.cc2
-rw-r--r--sql/item_create.h4
-rw-r--r--sql/item_geofunc.cc4
-rw-r--r--sql/item_geofunc.h11
-rw-r--r--sql/lex.h1283
-rw-r--r--sql/lex_symbol.h6
-rw-r--r--sql/sql_table.cc29
-rw-r--r--sql/sql_yacc.yy289
-rw-r--r--sql/table.cc5
-rw-r--r--sql/unireg.cc5
12 files changed, 919 insertions, 736 deletions
diff --git a/sql/field.cc b/sql/field.cc
index a9029b893e3..6d6218dc60a 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -4470,7 +4470,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)
@@ -4705,6 +4705,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)
@@ -4721,6 +4722,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)
{
@@ -4930,6 +4932,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)
@@ -5013,6 +5016,7 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
return 0;
}
+#endif /*HAVE_SPATIAL*/
/****************************************************************************
** enum type.
@@ -5488,10 +5492,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,
@@ -5651,10 +5657,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/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..671c4ed6de4 100644
--- a/sql/item_geofunc.cc
+++ b/sql/item_geofunc.cc
@@ -17,6 +17,8 @@
/* This file defines all spatial functions */
+#ifdef HAVE_SPATIAL
+
#ifdef __GNUC__
#pragma implementation // gcc: Class implementation
#endif
@@ -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/lex.h b/sql/lex.h
index 6e69df6f96c..78a22fad153 100644
--- a/sql/lex.h
+++ b/sql/lex.h
@@ -20,13 +20,24 @@
#include "lex_symbol.h"
/* We don't want to include sql_yacc.h into gen_lex_hash */
+static SYM_GROUP sym_group_common= {"", ""};
+static SYM_GROUP sym_group_geom= {"Spatial extentions", "HAVE_SPATIAL"};
#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_GEOM
+#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 +47,641 @@
*/
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)},
+#ifdef DUMMY
+ { "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", 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)},
+#endif /*dummy*/
+ { "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..63d4f9d69c2 100644
--- a/sql/lex_symbol.h
+++ b/sql/lex_symbol.h
@@ -20,11 +20,17 @@
#ifndef _lex_symbol_h
#define _lex_symbol_h
+typedef struct st_sym_group {
+ const char *name;
+ const char *needed_define;
+} SYM_GROUP;
+
typedef struct st_symbol {
const char *name;
uint tok;
uint length;
void *create_func;
+ SYM_GROUP *group;
} SYMBOL;
typedef struct st_lex_symbol
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index ecd5f9ccb66..127dc4c3474 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),
+ "Spatial extentions", "HAVE_SPATIAL");
+ 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),
+ "Spatial extentions", "HAVE_SPATIAL");
+ DBUG_RETURN(-1);
+#endif
case Key::FOREIGN_KEY:
key_number--; // Skip this key
continue;
@@ -688,6 +700,7 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
checking for proper key parts number:
*/
+#ifdef HAVE_SPATIAL
/* TODO: Add proper checks if handler supports key_type and algorithm */
if (key_info->flags == HA_SPATIAL)
{
@@ -698,8 +711,11 @@ 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
+#endif
+ 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 +726,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),
+ "Spatial extentions", "HAVE_SPATIAL");
+ DBUG_RETURN(-1);
+#endif
}
List_iterator<key_part_spec> cols(key->columns);
@@ -779,6 +800,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 +812,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)
@@ -806,11 +829,13 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
MYF(0),column->field_name);
DBUG_RETURN(-1);
}
+#ifdef HAVE_SPATIAL
if (key->type == Key::SPATIAL)
{
my_error(ER_SPATIAL_CANT_HAVE_NULL, MYF(0));
DBUG_RETURN(-1);
}
+#endif
}
if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
{
@@ -834,9 +859,11 @@ int mysql_create_table(THD *thd,const char *db, const char *table_name,
DBUG_RETURN(-1);
}
}
+#ifdef HAVE_SPATIAL //TODO HF What's this for???
else if (f_is_geom(sql_field->pack_flag))
{
}
+#endif
else if (column->length > length ||
((f_is_packed(sql_field->pack_flag) ||
((file->table_flags() & HA_NO_PREFIX_CHAR_KEYS) &&
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 310d8a41be2..6ab44cb9f08 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>
@@ -1244,8 +1244,8 @@ field_spec:
(enum enum_field_types) $3,
lex->length,lex->dec,lex->type,
lex->default_value, lex->comment,
- lex->change,lex->interval,lex->charset,
- lex->uint_geom_type))
+ lex->change,lex->interval,lex->charset
+ ,lex->uint_geom_type))
YYABORT;
};
@@ -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),
+ MYF(0), "Spatial extentions",
+ "HAVE_SPATIAL");
+ 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 {}
;
@@ -1591,8 +1591,30 @@ 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; };
+ | SPATIAL_SYM
+ {
+#ifdef HAVE_SPATIAL
+ $$= Key::SPATIAL;
+#else
+ net_printf(Lex->thd, ER_FEATURE_DISABLED,
+ ER(ER_FEATURE_DISABLED),
+ MYF(0), "Spatial extentions",
+ "HAVE_SPATIAL");
+ YYABORT;
+#endif
+ }
+ | SPATIAL_SYM key_or_index
+ {
+#ifdef HAVE_SPATIAL
+ $$= Key::SPATIAL;
+#else
+ net_printf(Lex->thd, ER_FEATURE_DISABLED,
+ ER(ER_FEATURE_DISABLED),
+ MYF(0), "Spatial extentions",
+ "HAVE_SPATIAL");
+ YYABORT;
+#endif
+ };
constraint_key_type:
PRIMARY_SYM KEY_SYM { $$= Key::PRIMARY; }
@@ -1617,7 +1639,18 @@ 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),
+ MYF(0), "Spatial extentions",
+ "HAVE_SPATIAL");
+ YYABORT;
+#endif
+ }
;
key_alg:
@@ -1627,7 +1660,18 @@ key_alg:
opt_btree_or_rtree:
BTREE_SYM { $$= HA_KEY_ALG_BTREE; }
- | RTREE_SYM { $$= HA_KEY_ALG_RTREE; }
+ | RTREE_SYM
+ {
+#ifdef HAVE_RTREE_KEYS
+ $$= HA_KEY_ALG_RTREE;
+#else
+ net_printf(Lex->thd, ER_FEATURE_DISABLED,
+ ER(ER_FEATURE_DISABLED),
+ MYF(0), "RTree keys",
+ "HAVE_RTREE_KEYS");
+ YYABORT;
+#endif
+ }
| HASH_SYM { $$= HA_KEY_ALG_HASH; };
key_list:
@@ -1725,8 +1769,8 @@ alter_list_item:
(enum enum_field_types) $5,
lex->length,lex->dec,lex->type,
lex->default_value, lex->comment,
- $3.str, lex->interval, lex->charset,
- lex->uint_geom_type))
+ $3.str, lex->interval, lex->charset
+ ,lex->uint_geom_type))
YYABORT;
}
opt_place
@@ -2556,13 +2600,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),
+ MYF(0), $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),
+ MYF(0), $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),
+ MYF(0), $1.symbol->group->name,
+ $1.symbol->group->needed_define);
+ YYABORT;
+ }
+ $$= ((Item*(*)(Item*,Item*))($1.symbol->create_func))($3,$5);
+ }
| FUNC_ARG3 '(' expr ',' expr ',' expr ')'
- { $$= ((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),
+ MYF(0), $1.symbol->group->name,
+ $1.symbol->group->needed_define);
+ YYABORT;
+ }
+ $$= ((Item*(*)(Item*,Item*,Item*))($1.symbol->create_func))($3,$5,$7);
+ }
| ADDDATE_SYM '(' expr ',' expr ')'
{ $$= new Item_date_add_interval($3, $5, INTERVAL_DAY, 0);}
| ADDDATE_SYM '(' expr ',' INTERVAL_SYM expr interval ')'
@@ -2645,18 +2729,18 @@ 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),
+ MYF(0), "Spatial extentions",
+ "HAVE_SPATIAL");
+ YYABORT;
+#endif
+ }
| GET_FORMAT '(' date_time_type ',' expr ')'
{ $$= new Item_func_get_format($3, $5); }
| HOUR_SYM '(' expr ')'
@@ -2690,17 +2774,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 +2786,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 +2804,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 +2816,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 +2953,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 912c133e571..724921c956b 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
View Lorry Controller Status