summaryrefslogtreecommitdiff
path: root/sql
diff options
context:
space:
mode:
Diffstat (limited to 'sql')
-rwxr-xr-xsql/CMakeLists.txt5
-rw-r--r--sql/Makefile.am3
-rw-r--r--sql/ha_berkeley.cc5
-rw-r--r--sql/ha_heap.cc5
-rw-r--r--sql/ha_innodb.cc3
-rw-r--r--sql/ha_myisam.cc14
-rw-r--r--sql/ha_myisam.h1
-rw-r--r--sql/ha_myisammrg.cc6
-rw-r--r--sql/ha_ndbcluster.cc4
-rw-r--r--sql/handler.cc32
-rw-r--r--sql/handler.h3
-rw-r--r--sql/item.cc41
-rw-r--r--sql/item.h51
-rw-r--r--sql/item_cmpfunc.cc212
-rw-r--r--sql/item_cmpfunc.h4
-rw-r--r--sql/item_func.cc64
-rw-r--r--sql/item_func.h2
-rw-r--r--sql/mysql_priv.h14
-rw-r--r--sql/opt_range.cc7
-rw-r--r--sql/opt_sum.cc4
-rw-r--r--sql/share/errmsg.txt2
-rw-r--r--sql/sql_delete.cc3
-rw-r--r--sql/sql_insert.cc2
-rw-r--r--sql/sql_lex.cc23
-rw-r--r--sql/sql_lex.h2
-rw-r--r--sql/sql_list.h6
-rw-r--r--sql/sql_parse.cc17
-rw-r--r--sql/sql_select.cc552
-rw-r--r--sql/sql_update.cc3
-rw-r--r--sql/sql_yacc.yy156
-rw-r--r--sql/udf_example.c11
-rw-r--r--sql/udf_example.def24
32 files changed, 848 insertions, 433 deletions
diff --git a/sql/CMakeLists.txt b/sql/CMakeLists.txt
index b01871872ce..9b2fae847d6 100755
--- a/sql/CMakeLists.txt
+++ b/sql/CMakeLists.txt
@@ -110,5 +110,8 @@ ADD_CUSTOM_COMMAND(
COMMAND ${GEN_LEX_HASH_EXE} ARGS > lex_hash.h
DEPENDS ${GEN_LEX_HASH_EXE}
)
-
ADD_DEPENDENCIES(mysqld gen_lex_hash)
+
+ADD_LIBRARY(udf_example MODULE udf_example.c udf_example.def)
+ADD_DEPENDENCIES(udf_example strings)
+TARGET_LINK_LIBRARIES(udf_example wsock32)
diff --git a/sql/Makefile.am b/sql/Makefile.am
index 45f87621e07..d9cea960915 100644
--- a/sql/Makefile.am
+++ b/sql/Makefile.am
@@ -117,7 +117,8 @@ DEFS = -DMYSQL_SERVER \
BUILT_SOURCES = sql_yacc.cc sql_yacc.h lex_hash.h
EXTRA_DIST = $(BUILT_SOURCES) nt_servc.cc nt_servc.h \
- message.mc examples/CMakeLists.txt CMakeLists.txt
+ message.mc examples/CMakeLists.txt CMakeLists.txt \
+ udf_example.c udf_example.def
DISTCLEANFILES = lex_hash.h sql_yacc.output
AM_YFLAGS = -d --debug --verbose
diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc
index 72af402a0dc..4209bc93d30 100644
--- a/sql/ha_berkeley.cc
+++ b/sql/ha_berkeley.cc
@@ -953,7 +953,10 @@ int ha_berkeley::write_row(byte * record)
if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
table->timestamp_field->set_time();
if (table->next_number_field && record == table->record[0])
- update_auto_increment();
+ {
+ if ((error= update_auto_increment()))
+ DBUG_RETURN(error);
+ }
if ((error=pack_row(&row, record,1)))
DBUG_RETURN(error); /* purecov: inspected */
diff --git a/sql/ha_heap.cc b/sql/ha_heap.cc
index 79d4575ff1b..3aaa0287098 100644
--- a/sql/ha_heap.cc
+++ b/sql/ha_heap.cc
@@ -176,7 +176,10 @@ int ha_heap::write_row(byte * buf)
if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
table->timestamp_field->set_time();
if (table->next_number_field && buf == table->record[0])
- update_auto_increment();
+ {
+ if ((res= update_auto_increment()))
+ return res;
+ }
res= heap_write(file,buf);
if (!res && (++records_changed*HEAP_STATS_UPDATE_THRESHOLD >
file->s->records))
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
index ddf2fbf26aa..e99d93784c9 100644
--- a/sql/ha_innodb.cc
+++ b/sql/ha_innodb.cc
@@ -3252,7 +3252,8 @@ no_commit:
/* We must use the handler code to update the auto-increment
value to be sure that we increment it correctly. */
- update_auto_increment();
+ if ((error= update_auto_increment()))
+ goto func_exit;
auto_inc_used = 1;
}
diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc
index 128cc191434..fc3bd3d3b08 100644
--- a/sql/ha_myisam.cc
+++ b/sql/ha_myisam.cc
@@ -169,6 +169,14 @@ ha_myisam::ha_myisam(TABLE *table_arg)
can_enable_indexes(1)
{}
+handler *ha_myisam::clone(MEM_ROOT *mem_root)
+{
+ ha_myisam *new_handler= static_cast <ha_myisam *>(handler::clone(mem_root));
+ if (new_handler)
+ new_handler->file->state= file->state;
+ return new_handler;
+}
+
static const char *ha_myisam_exts[] = {
".MYI",
@@ -316,7 +324,11 @@ int ha_myisam::write_row(byte * buf)
or a new row, then update the auto_increment value in the record.
*/
if (table->next_number_field && buf == table->record[0])
- update_auto_increment();
+ {
+ int error;
+ if ((error= update_auto_increment()))
+ return error;
+ }
return mi_write(file,buf);
}
diff --git a/sql/ha_myisam.h b/sql/ha_myisam.h
index ca684463311..950817d42bd 100644
--- a/sql/ha_myisam.h
+++ b/sql/ha_myisam.h
@@ -45,6 +45,7 @@ class ha_myisam: public handler
public:
ha_myisam(TABLE *table_arg);
~ha_myisam() {}
+ handler *clone(MEM_ROOT *mem_root);
const char *table_type() const { return "MyISAM"; }
const char *index_type(uint key_number);
const char **bas_ext() const;
diff --git a/sql/ha_myisammrg.cc b/sql/ha_myisammrg.cc
index 0b6e05fcbd4..cb11d9b0452 100644
--- a/sql/ha_myisammrg.cc
+++ b/sql/ha_myisammrg.cc
@@ -139,7 +139,11 @@ int ha_myisammrg::write_row(byte * buf)
if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
table->timestamp_field->set_time();
if (table->next_number_field && buf == table->record[0])
- update_auto_increment();
+ {
+ int error;
+ if ((error= update_auto_increment()))
+ return error;
+ }
return myrg_write(file,buf);
}
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
index 9c4a2c20ca0..5448b08b74f 100644
--- a/sql/ha_ndbcluster.cc
+++ b/sql/ha_ndbcluster.cc
@@ -2131,9 +2131,11 @@ int ha_ndbcluster::write_row(byte *record)
if (has_auto_increment)
{
THD *thd= table->in_use;
+ int error;
m_skip_auto_increment= FALSE;
- update_auto_increment();
+ if ((error= update_auto_increment()))
+ DBUG_RETURN(error);
/* Ensure that handler is always called for auto_increment values */
thd->next_insert_id= 0;
m_skip_auto_increment= !auto_increment_column_changed;
diff --git a/sql/handler.cc b/sql/handler.cc
index b0051b02d91..4accc746664 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -429,6 +429,8 @@ static int ha_init_errors(void)
SETMSG(HA_ERR_TABLE_DEF_CHANGED, ER(ER_TABLE_DEF_CHANGED));
SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE, ER(ER_TABLE_NEEDS_UPGRADE));
SETMSG(HA_ERR_TABLE_READONLY, ER(ER_OPEN_AS_READONLY));
+ SETMSG(HA_ERR_AUTOINC_READ_FAILED, ER(ER_AUTOINC_READ_FAILED));
+ SETMSG(HA_ERR_AUTOINC_ERANGE, ER(ER_WARN_DATA_OUT_OF_RANGE));
/* Register the error messages for use with my_error(). */
return my_error_register(errmsgs, HA_ERR_FIRST, HA_ERR_LAST);
@@ -1374,6 +1376,15 @@ int ha_delete_table(THD *thd, enum db_type table_type, const char *path,
/****************************************************************************
** General handler functions
****************************************************************************/
+handler *handler::clone(MEM_ROOT *mem_root)
+{
+ handler *new_handler= get_new_handler(table, mem_root, table->s->db_type);
+ if (new_handler && !new_handler->ha_open(table->s->path, table->db_stat,
+ HA_OPEN_IGNORE_IF_LOCKED))
+ return new_handler;
+ return NULL;
+}
+
/* Open database-handler. Try O_RDONLY if can't open as O_RDWR */
/* Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set */
@@ -1542,7 +1553,10 @@ prev_insert_id(ulonglong nr, struct system_variables *variables)
RETURN
0 ok
- 1 get_auto_increment() was called and returned ~(ulonglong) 0
+ HA_ERR_AUTOINC_READ_FAILED
+ get_auto_increment() was called and returned ~(ulonglong) 0
+ HA_ERR_AUTOINC_ERANGE
+ storing value in field caused strict mode failure.
IMPLEMENTATION
@@ -1586,13 +1600,12 @@ prev_insert_id(ulonglong nr, struct system_variables *variables)
thd->next_insert_id is cleared after it's been used for a statement.
*/
-bool handler::update_auto_increment()
+int handler::update_auto_increment()
{
ulonglong nr;
THD *thd= table->in_use;
struct system_variables *variables= &thd->variables;
bool auto_increment_field_not_null;
- bool result= 0;
DBUG_ENTER("handler::update_auto_increment");
/*
@@ -1616,7 +1629,7 @@ bool handler::update_auto_increment()
if (!(nr= thd->next_insert_id))
{
if ((nr= get_auto_increment()) == ~(ulonglong) 0)
- result= 1; // Mark failure
+ DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED); // Mark failure
if (variables->auto_increment_increment != 1)
nr= next_insert_id(nr-1, variables);
@@ -1636,6 +1649,7 @@ bool handler::update_auto_increment()
if (likely(!table->next_number_field->store((longlong) nr, TRUE)))
thd->insert_id((ulonglong) nr);
else
+ if (thd->killed != THD::KILL_BAD_DATA) /* did we fail strict mode? */
{
/*
overflow of the field; we'll use the max value, however we try to
@@ -1646,6 +1660,8 @@ bool handler::update_auto_increment()
if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
thd->insert_id(nr= table->next_number_field->val_int());
}
+ else
+ DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);
/*
We can't set next_insert_id if the auto-increment key is not the
@@ -1666,7 +1682,7 @@ bool handler::update_auto_increment()
/* Mark that we generated a new value */
auto_increment_column_changed=1;
- DBUG_RETURN(result);
+ DBUG_RETURN(0);
}
/*
@@ -1864,6 +1880,12 @@ void handler::print_error(int error, myf errflag)
case HA_ERR_TABLE_READONLY:
textno= ER_OPEN_AS_READONLY;
break;
+ case HA_ERR_AUTOINC_READ_FAILED:
+ textno= ER_AUTOINC_READ_FAILED;
+ break;
+ case HA_ERR_AUTOINC_ERANGE:
+ textno= ER_WARN_DATA_OUT_OF_RANGE;
+ break;
default:
{
/* The error was "unknown" to this function.
diff --git a/sql/handler.h b/sql/handler.h
index 44de0cc715a..481a98be285 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -563,9 +563,10 @@ public:
pushed_cond(NULL)
{}
virtual ~handler(void) { /* TODO: DBUG_ASSERT(inited == NONE); */ }
+ virtual handler *clone(MEM_ROOT *mem_root);
int ha_open(const char *name, int mode, int test_if_locked);
void adjust_next_insert_id_after_explicit_value(ulonglong nr);
- bool update_auto_increment();
+ int update_auto_increment();
virtual void print_error(int error, myf errflag);
virtual bool get_error_message(int error, String *buf);
uint get_dup_key(int error);
diff --git a/sql/item.cc b/sql/item.cc
index 34e5e2da165..de78a2539a7 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -3789,13 +3789,48 @@ Item_equal *Item_field::find_item_equal(COND_EQUAL *cond_equal)
/*
+ Check whether a field can be substituted by an equal item
+
+ SYNOPSIS
+ equal_fields_propagator()
+ arg - *arg != NULL <-> the field is in the context where
+ substitution for an equal item is valid
+
+ DESCRIPTION
+ The function checks whether a substitution of the field
+ occurrence for an equal item is valid.
+
+ NOTES
+ The following statement is not always true:
+ x=y => F(x)=F(x/y).
+ This means substitution of an item for an equal item not always
+ yields an equavalent condition.
+ Here's an example:
+ 'a'='a '
+ (LENGTH('a')=1) != (LENGTH('a ')=2)
+ Such a substitution is surely valid if either the substituted
+ field is not of a STRING type or if it is an argument of
+ a comparison predicate.
+
+ RETURN
+ TRUE substitution is valid
+ FALSE otherwise
+*/
+
+bool Item_field::subst_argument_checker(byte **arg)
+{
+ return (result_type() != STRING_RESULT) || (*arg);
+}
+
+
+/*
Set a pointer to the multiple equality the field reference belongs to
(if any)
SYNOPSIS
equal_fields_propagator()
- arg - reference to list of multiple equalities where
- the field (this object) is to be looked for
+ arg - reference to list of multiple equalities where
+ the field (this object) is to be looked for
DESCRIPTION
The function looks for a multiple equality containing the field item
@@ -3807,7 +3842,7 @@ Item_equal *Item_field::find_item_equal(COND_EQUAL *cond_equal)
NOTES
This function is supposed to be called as a callback parameter in calls
- of the transform method.
+ of the compile method.
RETURN VALUES
pointer to the replacing constant item, if the field item was substituted
diff --git a/sql/item.h b/sql/item.h
index 58a3bfd0d75..0cfb0b01fd8 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -410,7 +410,19 @@ public:
};
-typedef bool (Item::*Item_processor)(byte *arg);
+typedef bool (Item::*Item_processor) (byte *arg);
+/*
+ Analyzer function
+ SYNOPSIS
+ argp in/out IN: Analysis parameter
+ OUT: Parameter to be passed to the transformer
+
+ RETURN
+ TRUE Invoke the transformer
+ FALSE Don't do it
+
+*/
+typedef bool (Item::*Item_analyzer) (byte **argp);
typedef Item* (Item::*Item_transformer) (byte *arg);
typedef void (*Cond_traverser) (const Item *item, void *arg);
@@ -736,6 +748,30 @@ public:
virtual Item* transform(Item_transformer transformer, byte *arg);
+ /*
+ This function performs a generic "compilation" of the Item tree.
+ The process of compilation is assumed to go as follows:
+
+ compile()
+ {
+ if (this->*some_analyzer(...))
+ {
+ compile children if any;
+ this->*some_transformer(...);
+ }
+ }
+
+ i.e. analysis is performed top-down while transformation is done
+ bottom-up.
+ */
+ virtual Item* compile(Item_analyzer analyzer, byte **arg_p,
+ Item_transformer transformer, byte *arg_t)
+ {
+ if ((this->*analyzer) (arg_p))
+ return ((this->*transformer) (arg_t));
+ return 0;
+ }
+
virtual void traverse_cond(Cond_traverser traverser,
void *arg, traverse_order order)
{
@@ -750,6 +786,12 @@ public:
virtual bool change_context_processor(byte *context) { return 0; }
virtual bool reset_query_id_processor(byte *query_id) { return 0; }
virtual bool is_expensive_processor(byte *arg) { return 0; }
+ virtual bool subst_argument_checker(byte **arg)
+ {
+ if (*arg)
+ *arg= NULL;
+ return TRUE;
+ }
virtual Item *equal_fields_propagator(byte * arg) { return this; }
virtual bool set_no_const_sub(byte *arg) { return FALSE; }
@@ -1251,6 +1293,7 @@ public:
return field->can_be_compared_as_longlong();
}
Item_equal *find_item_equal(COND_EQUAL *cond_equal);
+ bool subst_argument_checker(byte **arg);
Item *equal_fields_propagator(byte *arg);
bool set_no_const_sub(byte *arg);
Item *replace_equal_field(byte *arg);
@@ -2141,7 +2184,11 @@ public:
{
return Item_field::save_in_field(field_arg, no_conversions);
}
- table_map used_tables() const { return (table_map)0L; }
+ /*
+ We use RAND_TABLE_BIT to prevent Item_insert_value from
+ being treated as a constant and precalculated before execution
+ */
+ table_map used_tables() const { return RAND_TABLE_BIT; }
bool walk(Item_processor processor, byte *args)
{
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 919a23ed65d..780d70d51dc 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -77,131 +77,14 @@ static void agg_result_type(Item_result *type, Item **items, uint nitems)
This function aggregates result types from the array of items. Found type
supposed to be used later for comparison of values of these items.
Aggregation itself is performed by the item_cmp_type() function.
-
- NOTES
- Aggregation rules:
- If there are DATE/TIME fields/functions in the list and no string
- fields/functions in the list then:
- The INT_RESULT type will be used for aggregation instead of original
- result type of any DATE/TIME field/function in the list
- All constant items in the list will be converted to a DATE/TIME using
- found field or result field of found function.
-
- Implementation notes:
- The code is equivalent to:
- 1. Check the list for presence of a STRING field/function.
- Collect the is_const flag.
- 2. Get a Field* object to use for type coercion
- 3. Perform type conversion.
- 1 and 2 are implemented in 2 loops. The first searches for a DATE/TIME
- field/function and checks presence of a STRING field/function.
- The second loop works only if a DATE/TIME field/function is found.
- It checks presence of a STRING field/function in the rest of the list.
-
- TODO
- 1) The current implementation can produce false comparison results for
- expressions like:
- date_time_field BETWEEN string_field_with_dates AND string_constant
- if the string_constant will omit some of leading zeroes.
- In order to fully implement correct comparison of DATE/TIME the new
- DATETIME_RESULT result type should be introduced and agg_cmp_type()
- should return the DATE/TIME field used for the conversion. Later
- this field can be used by comparison functions like Item_func_between to
- convert string values to ints on the fly and thus return correct results.
- This modification will affect functions BETWEEN, IN and CASE.
-
- 2) If in the list a DATE field/function and a DATETIME field/function
- are present in the list then the first found field/function will be
- used for conversion. This may lead to wrong results and probably should
- be fixed.
*/
static void agg_cmp_type(THD *thd, Item_result *type, Item **items, uint nitems)
{
uint i;
- Item::Type res= (Item::Type)0;
- /* Used only for date/time fields, max_length = 19 */
- char buff[20];
- uchar null_byte;
- Field *field= NULL;
-
- /*
- Do not convert items while creating a or showing a view in order
- to store/display the original query in these cases.
- */
- if (thd->lex->sql_command != SQLCOM_CREATE_VIEW &&
- thd->lex->sql_command != SQLCOM_SHOW_CREATE)
- {
- /* Search for date/time fields/functions */
- for (i= 0; i < nitems; i++)
- {
- if (!items[i]->result_as_longlong())
- {
- /* Do not convert anything if a string field/function is present */
- if (!items[i]->const_item() && items[i]->result_type() == STRING_RESULT)
- {
- i= nitems;
- break;
- }
- continue;
- }
- if ((res= items[i]->real_item()->type()) == Item::FIELD_ITEM &&
- items[i]->result_type() != INT_RESULT)
- {
- field= ((Item_field *)items[i]->real_item())->field;
- break;
- }
- else if (res == Item::FUNC_ITEM)
- {
- field= items[i]->tmp_table_field_from_field_type(0);
- if (field)
- field->move_field(buff, &null_byte, 0);
- break;
- }
- }
- }
- if (field)
- {
- /* Check the rest of the list for presence of a string field/function. */
- for (i++ ; i < nitems; i++)
- {
- if (!items[i]->const_item() && items[i]->result_type() == STRING_RESULT &&
- !items[i]->result_as_longlong())
- {
- if (res == Item::FUNC_ITEM)
- delete field;
- field= 0;
- break;
- }
- }
- }
- /*
- If the first item is a date/time function then its result should be
- compared as int
- */
- if (field)
- /* Suppose we are comparing dates */
- type[0]= INT_RESULT;
- else
- type[0]= items[0]->result_type();
-
- for (i= 0; i < nitems ; i++)
- {
- Item_result result= items[i]->result_type();
- /*
- Use INT_RESULT as result type for DATE/TIME fields/functions and
- for constants successfully converted to DATE/TIME
- */
- if (field &&
- ((!items[i]->const_item() && items[i]->result_as_longlong()) ||
- (items[i]->const_item() && convert_constant_item(thd, field,
- &items[i]))))
- result= INT_RESULT;
- type[0]= item_cmp_type(type[0], result);
- }
-
- if (res == Item::FUNC_ITEM && field)
- delete field;
+ type[0]= items[0]->result_type();
+ for (i= 1 ; i < nitems ; i++)
+ type[0]= item_cmp_type(type[0], items[i]->result_type());
}
@@ -1220,10 +1103,32 @@ void Item_func_between::fix_length_and_dec()
if (!args[0] || !args[1] || !args[2])
return;
agg_cmp_type(thd, &cmp_type, args, 3);
- args[0]->cmp_context= args[1]->cmp_context= args[2]->cmp_context= cmp_type;
+ if (cmp_type == STRING_RESULT &&
+ agg_arg_charsets(cmp_collation, args, 3, MY_COLL_CMP_CONV, 1))
+ return;
- if (cmp_type == STRING_RESULT)
- agg_arg_charsets(cmp_collation, args, 3, MY_COLL_CMP_CONV, 1);
+ /*
+ Make a special case of compare with date/time and longlong fields.
+ They are compared as integers, so for const item this time-consuming
+ conversion can be done only once, not for every single comparison
+ */
+ if (args[0]->type() == FIELD_ITEM &&
+ thd->lex->sql_command != SQLCOM_CREATE_VIEW &&
+ thd->lex->sql_command != SQLCOM_SHOW_CREATE)
+ {
+ Field *field=((Item_field*) args[0])->field;
+ if (field->can_be_compared_as_longlong())
+ {
+ /*
+ The following can't be recoded with || as convert_constant_item
+ changes the argument
+ */
+ if (convert_constant_item(thd, field,&args[1]))
+ cmp_type=INT_RESULT; // Works for all types.
+ if (convert_constant_item(thd, field,&args[2]))
+ cmp_type=INT_RESULT; // Works for all types.
+ }
+ }
}
@@ -2747,16 +2652,16 @@ bool Item_cond::walk(Item_processor processor, byte *arg)
SYNOPSIS
transform()
- transformer the transformer callback function to be applied to the nodes
- of the tree of the object
- arg parameter to be passed to the transformer
+ transformer the transformer callback function to be applied to the nodes
+ of the tree of the object
+ arg parameter to be passed to the transformer
DESCRIPTION
- The function recursively applies the transform method with the
- same transformer to each member item of the condition list.
+ The function recursively applies the transform method to each
+ member item of the condition list.
If the call of the method for a member item returns a new item
the old item is substituted for a new one.
- After this the transform method is applied to the root node
+ After this the transformer is applied to the root node
of the Item_cond object.
RETURN VALUES
@@ -2787,6 +2692,55 @@ Item *Item_cond::transform(Item_transformer transformer, byte *arg)
return Item_func::transform(transformer, arg);
}
+
+/*
+ Compile Item_cond object with a processor and a transformer callback functions
+
+ SYNOPSIS
+ compile()
+ analyzer the analyzer callback function to be applied to the nodes
+ of the tree of the object
+ arg_p in/out parameter to be passed to the analyzer
+ transformer the transformer callback function to be applied to the nodes
+ of the tree of the object
+ arg_t parameter to be passed to the transformer
+
+ DESCRIPTION
+ First the function applies the analyzer to the root node of
+ the Item_func object. Then if the analyzer succeeeds (returns TRUE)
+ the function recursively applies the compile method to member
+ item of the condition list.
+ If the call of the method for a member item returns a new item
+ the old item is substituted for a new one.
+ After this the transformer is applied to the root node
+ of the Item_cond object.
+
+ RETURN VALUES
+ Item returned as the result of transformation of the root node
+*/
+
+Item *Item_cond::compile(Item_analyzer analyzer, byte **arg_p,
+ Item_transformer transformer, byte *arg_t)
+{
+ if (!(this->*analyzer)(arg_p))
+ return 0;
+
+ List_iterator<Item> li(list);
+ Item *item;
+ while ((item= li++))
+ {
+ /*
+ The same parameter value of arg_p must be passed
+ to analyze any argument of the condition formula.
+ */
+ byte *arg_v= *arg_p;
+ Item *new_item= item->compile(analyzer, &arg_v, transformer, arg_t);
+ if (new_item && new_item != item)
+ li.replace(new_item);
+ }
+ return Item_func::transform(transformer, arg_t);
+}
+
void Item_cond::traverse_cond(Cond_traverser traverser,
void *arg, traverse_order order)
{
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 47f9f2aa98f..f2c43833bd9 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -240,6 +240,7 @@ public:
}
Item *neg_transformer(THD *thd);
virtual Item *negated_item();
+ bool subst_argument_checker(byte **arg) { return TRUE; }
};
class Item_func_not :public Item_bool_func
@@ -1171,6 +1172,9 @@ public:
Item *transform(Item_transformer transformer, byte *arg);
void traverse_cond(Cond_traverser, void *arg, traverse_order order);
void neg_arguments(THD *thd);
+ bool subst_argument_checker(byte **arg) { return TRUE; }
+ Item *compile(Item_analyzer analyzer, byte **arg_p,
+ Item_transformer transformer, byte *arg_t);
};
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 24f5eff197b..2e594c74031 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -234,22 +234,21 @@ void Item_func::traverse_cond(Cond_traverser traverser,
}
-
/*
Transform an Item_func object with a transformer callback function
SYNOPSIS
transform()
- transformer the transformer callback function to be applied to the nodes
- of the tree of the object
- argument parameter to be passed to the transformer
+ transformer the transformer callback function to be applied to the nodes
+ of the tree of the object
+ argument parameter to be passed to the transformer
DESCRIPTION
- The function recursively applies the transform method with the
- same transformer to each argument the function.
- If the call of the method for a member item returns a new item
+ The function recursively applies the transform method to each
+ argument of the Item_func node.
+ If the call of the method for an argument item returns a new item
the old item is substituted for a new one.
- After this the transform method is applied to the root node
+ After this the transformer is applied to the root node
of the Item_func object.
RETURN VALUES
@@ -283,6 +282,55 @@ Item *Item_func::transform(Item_transformer transformer, byte *argument)
}
+/*
+ Compile Item_func object with a processor and a transformer callback functions
+
+ SYNOPSIS
+ compile()
+ analyzer the analyzer callback function to be applied to the nodes
+ of the tree of the object
+ arg_p in/out parameter to be passed to the processor
+ transformer the transformer callback function to be applied to the nodes
+ of the tree of the object
+ arg_t parameter to be passed to the transformer
+
+ DESCRIPTION
+ First the function applies the analyzer to the root node of
+ the Item_func object. Then if the analizer succeeeds (returns TRUE)
+ the function recursively applies the compile method to each argument
+ of the Item_func node.
+ If the call of the method for an argument item returns a new item
+ the old item is substituted for a new one.
+ After this the transformer is applied to the root node
+ of the Item_func object.
+
+ RETURN VALUES
+ Item returned as the result of transformation of the root node
+*/
+
+Item *Item_func::compile(Item_analyzer analyzer, byte **arg_p,
+ Item_transformer transformer, byte *arg_t)
+{
+ if (!(this->*analyzer)(arg_p))
+ return 0;
+ if (arg_count)
+ {
+ Item **arg,**arg_end;
+ for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
+ {
+ /*
+ The same parameter value of arg_p must be passed
+ to analyze any argument of the condition formula.
+ */
+ byte *arg_v= *arg_p;
+ Item *new_item= (*arg)->compile(analyzer, &arg_v, transformer, arg_t);
+ if (new_item && *arg != new_item)
+ current_thd->change_item_tree(arg, new_item);
+ }
+ }
+ return (this->*transformer)(arg_t);
+}
+
/* See comments in Item_cmp_func::split_sum_func() */
void Item_func::split_sum_func(THD *thd, Item **ref_pointer_array,
diff --git a/sql/item_func.h b/sql/item_func.h
index 8abf5d91cd5..177daf0311f 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -187,6 +187,8 @@ public:
}
bool walk(Item_processor processor, byte *arg);
Item *transform(Item_transformer transformer, byte *arg);
+ Item* compile(Item_analyzer analyzer, byte **arg_p,
+ Item_transformer transformer, byte *arg_t);
void traverse_cond(Cond_traverser traverser,
void * arg, traverse_order order);
bool is_expensive_processor(byte *arg);
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index d73b1f1aac0..5bf37d6b5f7 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -131,7 +131,18 @@ MY_LOCALE *my_locale_by_name(const char *name);
#define MAX_ACCEPT_RETRY 10 // Test accept this many times
#define MAX_FIELDS_BEFORE_HASH 32
#define USER_VARS_HASH_SIZE 16
-#define STACK_MIN_SIZE 8192 // Abort if less stack during eval.
+
+/*
+ Value of 9236 discovered through binary search 2006-09-26 on Ubuntu Dapper
+ Drake, libc6 2.3.6-0ubuntu2, Linux kernel 2.6.15-27-686, on x86. (Added
+ 100 bytes as reasonable buffer against growth and other environments'
+ requirements.)
+
+ Feel free to raise this by the smallest amount you can to get the
+ "execution_constants" test to pass.
+ */
+#define STACK_MIN_SIZE 9336 // Abort if less stack during eval.
+
#define STACK_MIN_SIZE_FOR_OPEN 1024*80
#define STACK_BUFF_ALLOC 256 // For stack overrun checks
#ifndef MYSQLD_NET_RETRY_COUNT
@@ -425,6 +436,7 @@ void view_store_options(THD *thd, st_table_list *table, String *buff);
#define TL_OPTION_UPDATING 1
#define TL_OPTION_FORCE_INDEX 2
#define TL_OPTION_IGNORE_LEAVES 4
+#define TL_OPTION_ALIAS 8
/* Some portable defines */
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 6189d0412b3..79cfbc72fe7 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -1034,10 +1034,7 @@ int QUICK_RANGE_SELECT::init_ror_merged_scan(bool reuse_handler)
}
THD *thd= current_thd;
- if (!(file= get_new_handler(head, thd->mem_root, head->s->db_type)))
- goto failure;
- DBUG_PRINT("info", ("Allocated new handler %p", file));
- if (file->ha_open(head->s->path, head->db_stat, HA_OPEN_IGNORE_IF_LOCKED))
+ if (!(file= head->file->clone(thd->mem_root)))
{
/* Caller will free the memory */
goto failure;
@@ -6724,7 +6721,6 @@ int QUICK_RANGE_SELECT::get_next()
}
}
-
/*
Get the next record with a different prefix.
@@ -9378,7 +9374,6 @@ static void print_ror_scans_arr(TABLE *table, const char *msg,
DBUG_VOID_RETURN;
}
-
/*****************************************************************************
** Print a quick range for debugging
** TODO:
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index 1f6190241a3..d17c42bca38 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -191,7 +191,7 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
Type of range for the key part for this field will be
returned in range_fl.
*/
- if ((outer_tables & table->map) ||
+ if (table->file->inited || (outer_tables & table->map) ||
!find_key_for_maxmin(0, &ref, item_field->field, conds,
&range_fl, &prefix_len))
{
@@ -278,7 +278,7 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
Type of range for the key part for this field will be
returned in range_fl.
*/
- if ((outer_tables & table->map) ||
+ if (table->file->inited || (outer_tables & table->map) ||
!find_key_for_maxmin(1, &ref, item_field->field, conds,
&range_fl, &prefix_len))
{
diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt
index d10f66e3878..05b31b1e8b2 100644
--- a/sql/share/errmsg.txt
+++ b/sql/share/errmsg.txt
@@ -5623,6 +5623,8 @@ ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA
eng "Triggers can not be created on system tables"
ER_REMOVED_SPACES
eng "Leading spaces are removed from name '%s'"
+ER_AUTOINC_READ_FAILED
+ eng "Failed to read auto-increment value from storage engine"
ER_USERNAME
eng "user name"
ER_HOSTNAME
diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc
index e420022b8a1..c95fb5d5973 100644
--- a/sql/sql_delete.cc
+++ b/sql/sql_delete.cc
@@ -342,6 +342,7 @@ cleanup:
*/
bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds)
{
+ Item *fake_conds= 0;
SELECT_LEX *select_lex= &thd->lex->select_lex;
DBUG_ENTER("mysql_prepare_delete");
@@ -367,7 +368,7 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds)
DBUG_RETURN(TRUE);
}
}
- select_lex->fix_prepare_information(thd, conds);
+ select_lex->fix_prepare_information(thd, conds, &fake_conds);
DBUG_RETURN(FALSE);
}
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index b70d11e4b26..b5dab814d08 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -1002,7 +1002,7 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list,
update_non_unique_table_error(table_list, "INSERT", duplicate);
DBUG_RETURN(TRUE);
}
- select_lex->fix_prepare_information(thd, &fake_conds);
+ select_lex->fix_prepare_information(thd, &fake_conds, &fake_conds);
select_lex->first_execution= 0;
}
if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 43aeea2bf53..d0087b14d6a 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -2158,15 +2158,25 @@ static void fix_prepare_info_in_table_list(THD *thd, TABLE_LIST *tbl)
/*
- fix some structures at the end of preparation
+ Save WHERE/HAVING/ON clauses and replace them with disposable copies
SYNOPSIS
st_select_lex::fix_prepare_information
- thd thread handler
- conds pointer on conditions which will be used for execution statement
+ thd thread handler
+ conds in/out pointer to WHERE condition to be met at execution
+ having_conds in/out pointer to HAVING condition to be met at execution
+
+ DESCRIPTION
+ The passed WHERE and HAVING are to be saved for the future executions.
+ This function saves it, and returns a copy which can be thrashed during
+ this execution of the statement. By saving/thrashing here we mean only
+ AND/OR trees.
+ The function also calls fix_prepare_info_in_table_list that saves all
+ ON expressions.
*/
-void st_select_lex::fix_prepare_information(THD *thd, Item **conds)
+void st_select_lex::fix_prepare_information(THD *thd, Item **conds,
+ Item **having_conds)
{
if (!thd->stmt_arena->is_conventional() && first_execution)
{
@@ -2176,6 +2186,11 @@ void st_select_lex::fix_prepare_information(THD *thd, Item **conds)
prep_where= *conds;
*conds= where= prep_where->copy_andor_structure(thd);
}
+ if (*having_conds)
+ {
+ prep_having= *having_conds;
+ *having_conds= having= prep_having->copy_andor_structure(thd);
+ }
fix_prepare_info_in_table_list(thd, (TABLE_LIST *)table_list.first);
}
}
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 2e19c54cbfe..fdf14c691e9 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -656,7 +656,7 @@ public:
void print(THD *thd, String *str);
static void print_order(String *str, ORDER *order);
void print_limit(THD *thd, String *str);
- void fix_prepare_information(THD *thd, Item **conds);
+ void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
/*
Destroy the used execution plan (JOIN) of this subtree (this
SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
diff --git a/sql/sql_list.h b/sql/sql_list.h
index b2bcc4ea401..afad6d0f6ac 100644
--- a/sql/sql_list.h
+++ b/sql/sql_list.h
@@ -94,9 +94,9 @@ public:
inline base_list() { empty(); }
inline base_list(const base_list &tmp) :Sql_alloc()
{
- elements=tmp.elements;
- first=tmp.first;
- last=tmp.last;
+ elements= tmp.elements;
+ first= tmp.first;
+ last= elements ? tmp.last : &first;
}
inline base_list(bool error) { }
inline bool push_back(void *info)
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index d809c1b2cb0..ddd39bd1c9e 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -4765,6 +4765,19 @@ end_with_restore_list:
}
append_identifier(thd, &buff, first_table->table_name,
first_table->table_name_length);
+ if (lex->view_list.elements)
+ {
+ List_iterator_fast<LEX_STRING> names(lex->view_list);
+ LEX_STRING *name;
+ int i;
+
+ for (i= 0; name= names++; i++)
+ {
+ buff.append(i ? ", " : "(");
+ append_identifier(thd, &buff, name->str, name->length);
+ }
+ buff.append(')');
+ }
buff.append(STRING_WITH_LEN(" AS "));
buff.append(first_table->source.str, first_table->source.length);
@@ -6085,6 +6098,7 @@ bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
table_options A set of the following bits:
TL_OPTION_UPDATING Table will be updated
TL_OPTION_FORCE_INDEX Force usage of index
+ TL_OPTION_ALIAS an alias in multi table DELETE
lock_type How table should be locked
use_index List of indexed used in USE INDEX
ignore_index List of indexed used in IGNORE INDEX
@@ -6113,7 +6127,8 @@ TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
if (!table)
DBUG_RETURN(0); // End of memory
alias_str= alias ? alias->str : table->table.str;
- if (check_table_name(table->table.str, table->table.length))
+ if (!test(table_options & TL_OPTION_ALIAS) &&
+ check_table_name(table->table.str, table->table.length))
{
my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
DBUG_RETURN(0);
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index e9d0e003f6d..ac4b404ce8e 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -382,12 +382,14 @@ JOIN::prepare(Item ***rref_pointer_array,
if ((res= subselect->select_transformer(this)) !=
Item_subselect::RES_OK)
{
- select_lex->fix_prepare_information(thd, &conds);
+ select_lex->fix_prepare_information(thd, &conds, &having);
DBUG_RETURN((res == Item_subselect::RES_ERROR));
}
}
}
+ select_lex->fix_prepare_information(thd, &conds, &having);
+
if (having && having->with_sum_func)
having->split_sum_func2(thd, ref_pointer_array, all_fields,
&having, TRUE);
@@ -499,7 +501,6 @@ JOIN::prepare(Item ***rref_pointer_array,
if (alloc_func_list())
goto err;
- select_lex->fix_prepare_information(thd, &conds);
DBUG_RETURN(0); // All OK
err:
@@ -618,7 +619,6 @@ JOIN::optimize()
build_bitmap_for_nested_joins(join_list, 0);
sel->prep_where= conds ? conds->copy_andor_structure(thd) : 0;
- sel->prep_having= having ? having->copy_andor_structure(thd) : 0;
if (arena)
thd->restore_active_arena(arena, &backup);
@@ -1324,7 +1324,7 @@ JOIN::exec()
}
(void) result->prepare2(); // Currently, this cannot fail.
- if (!tables_list)
+ if (!tables_list && (tables || !select_lex->with_sum_func))
{ // Only test of functions
if (select_options & SELECT_DESCRIBE)
select_describe(this, FALSE, FALSE, FALSE,
@@ -1364,7 +1364,12 @@ JOIN::exec()
thd->examined_row_count= 0;
DBUG_VOID_RETURN;
}
- thd->limit_found_rows= thd->examined_row_count= 0;
+ /*
+ don't reset the found rows count if there're no tables
+ as FOUND_ROWS() may be called.
+ */
+ if (tables)
+ thd->limit_found_rows= thd->examined_row_count= 0;
if (zero_result_cause)
{
@@ -1403,7 +1408,8 @@ JOIN::exec()
having= tmp_having;
select_describe(this, need_tmp,
order != 0 && !skip_sort_order,
- select_distinct);
+ select_distinct,
+ !tables ? "No tables used" : NullS);
DBUG_VOID_RETURN;
}
@@ -6351,29 +6357,30 @@ finish:
/*
- Check whether an item is a simple equality predicate and if so
- create/find a multiple equality for this predicate
+ Check whether an equality can be used to build multiple equalities
SYNOPSIS
- check_equality()
- item item to check
- cond_equal multiple equalities that must hold together with the predicate
+ check_simple_equality()
+ left_item left term of the quality to be checked
+ right_item right term of the equality to be checked
+ item equality item if the equality originates from a condition
+ predicate, 0 if the equality is the result of row elimination
+ cond_equal multiple equalities that must hold together with the equality
DESCRIPTION
- This function first checks whether an item is a simple equality i.e.
- the one that equates a field with another field or a constant
- (item=constant_item or item=field_item).
- If this is the case the function looks a for a multiple equality
+ This function first checks whether the equality (left_item=right_item)
+ is a simple equality i.e. the one that equates a field with another field
+ or a constant (field=field_item or field=const_item).
+ If this is the case the function looks for a multiple equality
in the lists referenced directly or indirectly by cond_equal inferring
the given simple equality. If it doesn't find any, it builds a multiple
equality that covers the predicate, i.e. the predicate can be inferred
- from it.
+ from this multiple equality.
The built multiple equality could be obtained in such a way:
create a binary multiple equality equivalent to the predicate, then
merge it, if possible, with one of old multiple equalities.
This guarantees that the set of multiple equalities covering equality
- predicates will
- be minimal.
+ predicates will be minimal.
EXAMPLE
For the where condition
@@ -6391,7 +6398,7 @@ finish:
and will transform *cond_equal into (ptr(CE),[Item_equal(f,e)]).
NOTES
- Now only fields that have the same type defintions (verified by
+ Now only fields that have the same type definitions (verified by
the Field::eq_def method) are placed to the same multiple equalities.
Because of this some equality predicates are not eliminated and
can be used in the constant propagation procedure.
@@ -6424,177 +6431,289 @@ finish:
copying would be much more complicated.
RETURN
- TRUE - if the predicate is a simple equality predicate
- FALSE - otherwise
+ TRUE if the predicate is a simple equality predicate to be used
+ for building multiple equalities
+ FALSE otherwise
*/
-static bool check_equality(Item *item, COND_EQUAL *cond_equal)
+static bool check_simple_equality(Item *left_item, Item *right_item,
+ Item *item, COND_EQUAL *cond_equal)
{
- if (item->type() == Item::FUNC_ITEM &&
- ((Item_func*) item)->functype() == Item_func::EQ_FUNC)
+ if (left_item->type() == Item::REF_ITEM &&
+ ((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)
{
- Item *left_item= ((Item_func*) item)->arguments()[0];
- Item *right_item= ((Item_func*) item)->arguments()[1];
+ if (((Item_ref*)left_item)->depended_from)
+ return FALSE;
+ left_item= left_item->real_item();
+ }
+ if (right_item->type() == Item::REF_ITEM &&
+ ((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)
+ {
+ if (((Item_ref*)right_item)->depended_from)
+ return FALSE;
+ right_item= right_item->real_item();
+ }
+ if (left_item->type() == Item::FIELD_ITEM &&
+ right_item->type() == Item::FIELD_ITEM &&
+ !((Item_field*)left_item)->depended_from &&
+ !((Item_field*)right_item)->depended_from)
+ {
+ /* The predicate the form field1=field2 is processed */
+
+ Field *left_field= ((Item_field*) left_item)->field;
+ Field *right_field= ((Item_field*) right_item)->field;
+
+ if (!left_field->eq_def(right_field))
+ return FALSE;
+
+ /* Search for multiple equalities containing field1 and/or field2 */
+ bool left_copyfl, right_copyfl;
+ Item_equal *left_item_equal=
+ find_item_equal(cond_equal, left_field, &left_copyfl);
+ Item_equal *right_item_equal=
+ find_item_equal(cond_equal, right_field, &right_copyfl);
+
+ /* As (NULL=NULL) != TRUE we can't just remove the predicate f=f */
+ if (left_field->eq(right_field)) /* f = f */
+ return (!(left_field->maybe_null() && !left_item_equal));
- if (left_item->type() == Item::REF_ITEM &&
- ((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)
+ if (left_item_equal && left_item_equal == right_item_equal)
{
- if (((Item_ref*)left_item)->depended_from)
- return FALSE;
- left_item= left_item->real_item();
+ /*
+ The equality predicate is inference of one of the existing
+ multiple equalities, i.e the condition is already covered
+ by upper level equalities
+ */
+ return TRUE;
}
- if (right_item->type() == Item::REF_ITEM &&
- ((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)
+
+ /* Copy the found multiple equalities at the current level if needed */
+ if (left_copyfl)
{
- if (((Item_ref*)right_item)->depended_from)
- return FALSE;
- right_item= right_item->real_item();
+ /* left_item_equal of an upper level contains left_item */
+ left_item_equal= new Item_equal(left_item_equal);
+ cond_equal->current_level.push_back(left_item_equal);
}
- if (left_item->type() == Item::FIELD_ITEM &&
- right_item->type() == Item::FIELD_ITEM &&
- !((Item_field*)left_item)->depended_from &&
- !((Item_field*)right_item)->depended_from)
+ if (right_copyfl)
{
- /* The predicate the form field1=field2 is processed */
+ /* right_item_equal of an upper level contains right_item */
+ right_item_equal= new Item_equal(right_item_equal);
+ cond_equal->current_level.push_back(right_item_equal);
+ }
- Field *left_field= ((Item_field*) left_item)->field;
- Field *right_field= ((Item_field*) right_item)->field;
+ if (left_item_equal)
+ {
+ /* left item was found in the current or one of the upper levels */
+ if (! right_item_equal)
+ left_item_equal->add((Item_field *) right_item);
+ else
+ {
+ /* Merge two multiple equalities forming a new one */
+ left_item_equal->merge(right_item_equal);
+ /* Remove the merged multiple equality from the list */
+ List_iterator<Item_equal> li(cond_equal->current_level);
+ while ((li++) != right_item_equal);
+ li.remove();
+ }
+ }
+ else
+ {
+ /* left item was not found neither the current nor in upper levels */
+ if (right_item_equal)
+ right_item_equal->add((Item_field *) left_item);
+ else
+ {
+ /* None of the fields was found in multiple equalities */
+ Item_equal *item= new Item_equal((Item_field *) left_item,
+ (Item_field *) right_item);
+ cond_equal->current_level.push_back(item);
+ }
+ }
+ return TRUE;
+ }
- if (!left_field->eq_def(right_field))
- return FALSE;
+ {
+ /* The predicate of the form field=const/const=field is processed */
+ Item *const_item= 0;
+ Item_field *field_item= 0;
+ if (left_item->type() == Item::FIELD_ITEM &&
+ !((Item_field*)left_item)->depended_from &&
+ right_item->const_item())
+ {
+ field_item= (Item_field*) left_item;
+ const_item= right_item;
+ }
+ else if (right_item->type() == Item::FIELD_ITEM &&
+ !((Item_field*)right_item)->depended_from &&
+ left_item->const_item())
+ {
+ field_item= (Item_field*) right_item;
+ const_item= left_item;
+ }
- if (left_field->eq(right_field)) /* f = f */
- return TRUE;
-
- /* Search for multiple equalities containing field1 and/or field2 */
- bool left_copyfl, right_copyfl;
- Item_equal *left_item_equal=
- find_item_equal(cond_equal, left_field, &left_copyfl);
- Item_equal *right_item_equal=
- find_item_equal(cond_equal, right_field, &right_copyfl);
+ if (const_item &&
+ field_item->result_type() == const_item->result_type())
+ {
+ bool copyfl;
- if (left_item_equal && left_item_equal == right_item_equal)
+ if (field_item->result_type() == STRING_RESULT)
{
- /*
- The equality predicate is inference of one of the existing
- multiple equalities, i.e the condition is already covered
- by upper level equalities
- */
- return TRUE;
+ CHARSET_INFO *cs= ((Field_str*) field_item->field)->charset();
+ if (!item)
+ {
+ Item_func_eq *eq_item;
+ if ((eq_item= new Item_func_eq(left_item, right_item)))
+ return FALSE;
+ eq_item->set_cmp_func();
+ eq_item->quick_fix_field();
+ item= eq_item;
+ }
+ if ((cs != ((Item_func *) item)->compare_collation()) ||
+ !cs->coll->propagate(cs, 0, 0))
+ return FALSE;
}
-
- /* Copy the found multiple equalities at the current level if needed */
- if (left_copyfl)
+
+ Item_equal *item_equal = find_item_equal(cond_equal,
+ field_item->field, &copyfl);
+ if (copyfl)
{
- /* left_item_equal of an upper level contains left_item */
- left_item_equal= new Item_equal(left_item_equal);
- cond_equal->current_level.push_back(left_item_equal);
+ item_equal= new Item_equal(item_equal);
+ cond_equal->current_level.push_back(item_equal);
}
- if (right_copyfl)
+ if (item_equal)
{
- /* right_item_equal of an upper level contains right_item */
- right_item_equal= new Item_equal(right_item_equal);
- cond_equal->current_level.push_back(right_item_equal);
- }
-
- if (left_item_equal)
- {
- /* left item was found in the current or one of the upper levels */
- if (! right_item_equal)
- left_item_equal->add((Item_field *) right_item);
- else
- {
- /* Merge two multiple equalities forming a new one */
- left_item_equal->merge(right_item_equal);
- /* Remove the merged multiple equality from the list */
- List_iterator<Item_equal> li(cond_equal->current_level);
- while ((li++) != right_item_equal);
- li.remove();
- }
+ /*
+ The flag cond_false will be set to 1 after this, if item_equal
+ already contains a constant and its value is not equal to
+ the value of const_item.
+ */
+ item_equal->add(const_item);
}
else
- {
- /* left item was not found neither the current nor in upper levels */
- if (right_item_equal)
- right_item_equal->add((Item_field *) left_item);
- else
- {
- /* None of the fields was found in multiple equalities */
- Item_equal *item= new Item_equal((Item_field *) left_item,
- (Item_field *) right_item);
- cond_equal->current_level.push_back(item);
- }
+ {
+ item_equal= new Item_equal(const_item, field_item);
+ cond_equal->current_level.push_back(item_equal);
}
return TRUE;
}
+ }
+ return FALSE;
+}
- {
- /* The predicate of the form field=const/const=field is processed */
- Item *const_item= 0;
- Item_field *field_item= 0;
- if (left_item->type() == Item::FIELD_ITEM &&
- !((Item_field*)left_item)->depended_from &&
- right_item->const_item())
- {
- field_item= (Item_field*) left_item;
- const_item= right_item;
- }
- else if (right_item->type() == Item::FIELD_ITEM &&
- !((Item_field*)right_item)->depended_from &&
- left_item->const_item())
- {
- field_item= (Item_field*) right_item;
- const_item= left_item;
- }
- if (const_item &&
- field_item->result_type() == const_item->result_type())
- {
- bool copyfl;
+/*
+ Convert row equalities into a conjunction of regular equalities
- if (field_item->result_type() == STRING_RESULT)
- {
- CHARSET_INFO *cs= ((Field_str*) field_item->field)->charset();
- if ((cs != ((Item_cond *) item)->compare_collation()) ||
- !cs->coll->propagate(cs, 0, 0))
- return FALSE;
- }
+ SYNOPSIS
+ check_row_equality()
+ left_row left term of the row equality to be processed
+ right_row right term of the row equality to be processed
+ cond_equal multiple equalities that must hold together with the predicate
+ eq_list results of conversions of row equalities that are not simple
+ enough to form multiple equalities
- Item_equal *item_equal = find_item_equal(cond_equal,
- field_item->field, &copyfl);
- if (copyfl)
- {
- item_equal= new Item_equal(item_equal);
- cond_equal->current_level.push_back(item_equal);
- }
- if (item_equal)
- {
- /*
- The flag cond_false will be set to 1 after this, if item_equal
- already contains a constant and its value is not equal to
- the value of const_item.
- */
- item_equal->add(const_item);
- }
- else
- {
- item_equal= new Item_equal(const_item, field_item);
- cond_equal->current_level.push_back(item_equal);
- }
- return TRUE;
- }
+ DESCRIPTION
+ The function converts a row equality of the form (E1,...,En)=(E'1,...,E'n)
+ into a list of equalities E1=E'1,...,En=E'n. For each of these equalities
+ Ei=E'i the function checks whether it is a simple equality or a row equality.
+ If it is a simple equality it is used to expand multiple equalities of
+ cond_equal. If it is a row equality it converted to a sequence of equalities
+ between row elements. If Ei=E'i is neither a simple equality nor a row
+ equality the item for this predicate is added to eq_list.
+
+ RETURN
+ TRUE if conversion has succeeded (no fatal error)
+ FALSE otherwise
+*/
+
+static bool check_row_equality(Item *left_row, Item_row *right_row,
+ COND_EQUAL *cond_equal, List<Item>* eq_list)
+{
+ uint n= left_row->cols();
+ for (uint i= 0 ; i < n; i++)
+ {
+ bool is_converted;
+ Item *left_item= left_row->el(i);
+ Item *right_item= right_row->el(i);
+ if (left_item->type() == Item::ROW_ITEM &&
+ right_item->type() == Item::ROW_ITEM)
+ is_converted= check_row_equality((Item_row *) left_item,
+ (Item_row *) right_item,
+ cond_equal, eq_list);
+ else
+ is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);
+
+ if (!is_converted)
+ {
+ Item_func_eq *eq_item;
+ if (!(eq_item= new Item_func_eq(left_item, right_item)))
+ return FALSE;
+ eq_item->set_cmp_func();
+ eq_item->quick_fix_field();
+ eq_list->push_back(eq_item);
}
}
+ return TRUE;
+}
+
+
+/*
+ Eliminate row equalities and form multiple equalities predicates
+
+ SYNOPSIS
+ check_equality()
+ item predicate to process
+ cond_equal multiple equalities that must hold together with the predicate
+ eq_list results of conversions of row equalities that are not simple
+ enough to form multiple equalities
+
+ DESCRIPTION
+ This function checks whether the item is a simple equality
+ i.e. the one that equates a field with another field or a constant
+ (field=field_item or field=constant_item), or, a row equality.
+ For a simple equality the function looks for a multiple equality
+ in the lists referenced directly or indirectly by cond_equal inferring
+ the given simple equality. If it doesn't find any, it builds/expands
+ multiple equality that covers the predicate.
+ Row equalities are eliminated substituted for conjunctive regular equalities
+ which are treated in the same way as original equality predicates.
+
+ RETURN
+ TRUE if re-writing rules have been applied
+ FALSE otherwise, i.e.
+ if the predicate is not an equality,
+ or, if the equality is neither a simple one nor a row equality,
+ or, if the procedure fails by a fatal error.
+*/
+
+static bool check_equality(Item *item, COND_EQUAL *cond_equal,
+ List<Item> *eq_list)
+{
+ if (item->type() == Item::FUNC_ITEM &&
+ ((Item_func*) item)->functype() == Item_func::EQ_FUNC)
+ {
+ Item *left_item= ((Item_func*) item)->arguments()[0];
+ Item *right_item= ((Item_func*) item)->arguments()[1];
+
+ if (left_item->type() == Item::ROW_ITEM &&
+ right_item->type() == Item::ROW_ITEM)
+ return check_row_equality((Item_row *) left_item,
+ (Item_row *) right_item,
+ cond_equal, eq_list);
+ else
+ return check_simple_equality(left_item, right_item, item, cond_equal);
+ }
return FALSE;
}
+
/*
Replace all equality predicates in a condition by multiple equality items
SYNOPSIS
build_equal_items_for_cond()
- cond condition(expression) where to make replacement
- inherited path to all inherited multiple equality items
+ cond condition(expression) where to make replacement
+ inherited path to all inherited multiple equality items
DESCRIPTION
At each 'and' level the function detects items for equality predicates
@@ -6608,7 +6727,9 @@ static bool check_equality(Item *item, COND_EQUAL *cond_equal)
The function also traverses the cond tree and and for each field reference
sets a pointer to the multiple equality item containing the field, if there
is any. If this multiple equality equates fields to a constant the
- function replace the field reference by the constant.
+ function replaces the field reference by the constant in the cases
+ when the field is not of a string type or when the field reference is
+ just an argument of a comparison predicate.
The function also determines the maximum number of members in
equality lists of each Item_cond_and object assigning it to
cond_equal->max_members of this object and updating accordingly
@@ -6659,10 +6780,12 @@ static COND *build_equal_items_for_cond(COND *cond,
Item_equal *item_equal;
uint members;
COND_EQUAL cond_equal;
+ COND *new_cond;
cond_equal.upper_levels= inherited;
if (cond->type() == Item::COND_ITEM)
{
+ List<Item> eq_list;
bool and_level= ((Item_cond*) cond)->functype() ==
Item_func::COND_AND_FUNC;
List<Item> *args= ((Item_cond*) cond)->argument_list();
@@ -6685,7 +6808,7 @@ static COND *build_equal_items_for_cond(COND *cond,
structure here because it's restored before each
re-execution of any prepared statement/stored procedure.
*/
- if (check_equality(item, &cond_equal))
+ if (check_equality(item, &cond_equal, &eq_list))
li.remove();
}
@@ -6732,10 +6855,14 @@ static COND *build_equal_items_for_cond(COND *cond,
}
}
if (and_level)
+ {
+ args->concat(&eq_list);
args->concat((List<Item> *)&cond_equal.current_level);
+ }
}
else if (cond->type() == Item::FUNC_ITEM)
{
+ List<Item> eq_list;
/*
If an equality predicate forms the whole and level,
we call it standalone equality and it's processed here.
@@ -6746,19 +6873,57 @@ static COND *build_equal_items_for_cond(COND *cond,
for WHERE a=b AND c=d AND (b=c OR d=5)
b=c is replaced by =(a,b,c,d).
*/
- if (check_equality(cond, &cond_equal) &&
- (item_equal= cond_equal.current_level.pop()))
+ if (check_equality(cond, &cond_equal, &eq_list))
{
- item_equal->fix_length_and_dec();
- item_equal->update_used_tables();
- return item_equal;
+ int n= cond_equal.current_level.elements + eq_list.elements;
+ if (n == 0)
+ return new Item_int((longlong) 1,1);
+ else if (n == 1)
+ {
+ if ((item_equal= cond_equal.current_level.pop()))
+ {
+ item_equal->fix_length_and_dec();
+ item_equal->update_used_tables();
+ return item_equal;
+ }
+ else
+ return eq_list.pop();
+ }
+ else
+ {
+ /*
+ Here a new AND level must be created. It can happen only
+ when a row equality is processed as a standalone predicate.
+ */
+ Item_cond_and *and_cond= new Item_cond_and(eq_list);
+ and_cond->quick_fix_field();
+ List<Item> *args= and_cond->argument_list();
+ List_iterator_fast<Item_equal> it(cond_equal.current_level);
+ while ((item_equal= it++))
+ {
+ item_equal->fix_length_and_dec();
+ item_equal->update_used_tables();
+ members= item_equal->members();
+ if (cond_equal.max_members < members)
+ cond_equal.max_members= members;
+ }
+ and_cond->cond_equal= cond_equal;
+ args->concat((List<Item> *)&cond_equal.current_level);
+
+ return and_cond;
+ }
}
/*
For each field reference in cond, not from equal item predicates,
set a pointer to the multiple equality it belongs to (if there is any)
+ as soon the field is not of a string type or the field reference is
+ an argument of a comparison predicate.
*/
- cond= cond->transform(&Item::equal_fields_propagator,
- (byte *) inherited);
+ byte *is_subst_valid= (byte *) 1;
+ cond= cond->compile(&Item::subst_argument_checker,
+ &is_subst_valid,
+ &Item::equal_fields_propagator,
+ (byte *) inherited);
cond->update_used_tables();
}
return cond;
@@ -7038,7 +7203,7 @@ static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,
/*
Substitute every field reference in a condition by the best equal field
- and eliminate all multiplle equality predicates
+ and eliminate all multiple equality predicates
SYNOPSIS
substitute_for_best_equal_field()
@@ -8949,10 +9114,11 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
keyinfo->rec_per_key=0;
keyinfo->algorithm= HA_KEY_ALG_UNDEF;
keyinfo->name= (char*) "group_key";
- for (; group ; group=group->next,key_part_info++)
+ ORDER *cur_group= group;
+ for (; cur_group ; cur_group= cur_group->next, key_part_info++)
{
- Field *field=(*group->item)->get_tmp_table_field();
- bool maybe_null=(*group->item)->maybe_null;
+ Field *field=(*cur_group->item)->get_tmp_table_field();
+ bool maybe_null=(*cur_group->item)->maybe_null;
key_part_info->null_bit=0;
key_part_info->field= field;
key_part_info->offset= field->offset();
@@ -8965,8 +9131,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
0 : FIELDFLAG_BINARY;
if (!using_unique_constraint)
{
- group->buff=(char*) group_buff;
- if (!(group->field= field->new_key_field(thd->mem_root,table,
+ cur_group->buff=(char*) group_buff;
+ if (!(cur_group->field= field->new_key_field(thd->mem_root,table,
(char*) group_buff +
test(maybe_null),
field->null_ptr,
@@ -8984,12 +9150,12 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
key_part_info->null_bit=field->null_bit;
key_part_info->null_offset= (uint) (field->null_ptr -
(uchar*) table->record[0]);
- group->buff++; // Pointer to field data
+ cur_group->buff++; // Pointer to field data
group_buff++; // Skipp null flag
}
/* In GROUP BY 'a' and 'a ' are equal for VARCHAR fields */
key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL;
- group_buff+= group->field->pack_length();
+ group_buff+= cur_group->field->pack_length();
}
keyinfo->key_length+= key_part_info->length;
}
@@ -9587,9 +9753,13 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
table->file->ha_index_init(0);
}
/* Set up select_end */
- join->join_tab[join->tables-1].next_select= setup_end_select_func(join);
+ Next_select_func end_select= setup_end_select_func(join);
+ if (join->tables)
+ {
+ join->join_tab[join->tables-1].next_select= end_select;
- join_tab=join->join_tab+join->const_tables;
+ join_tab=join->join_tab+join->const_tables;
+ }
join->send_records=0;
if (join->tables == join->const_tables)
{
@@ -9599,7 +9769,6 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
*/
if (!join->conds || join->conds->val_int())
{
- Next_select_func end_select= join->join_tab[join->tables-1].next_select;
error= (*end_select)(join,join_tab,0);
if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)
error= (*end_select)(join,join_tab,1);
@@ -9613,6 +9782,8 @@ do_select(JOIN *join,List<Item> *fields,TABLE *table,Procedure *procedure)
}
else
{
+ DBUG_ASSERT(join->tables);
+ DBUG_ASSERT(join_tab);
error= sub_select(join,join_tab,0);
if (error == NESTED_LOOP_OK || error == NESTED_LOOP_NO_MORE_ROWS)
error= sub_select(join,join_tab,1);
@@ -13189,6 +13360,8 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
param->copy_funcs.empty();
for (i= 0; (pos= li++); i++)
{
+ Field *field;
+ char *tmp;
Item *real_pos= pos->real_item();
if (real_pos->type() == Item::FIELD_ITEM)
{
@@ -13219,17 +13392,25 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
set up save buffer and change result_field to point at
saved value
*/
- Field *field= item->field;
+ field= item->field;
item->result_field=field->new_field(thd->mem_root,field->table, 1);
- char *tmp=(char*) sql_alloc(field->pack_length()+1);
+ /*
+ We need to allocate one extra byte for null handling and
+ another extra byte to not get warnings from purify in
+ Field_string::val_int
+ */
+ tmp= (char*) sql_alloc(field->pack_length()+2);
if (!tmp)
goto err;
- if (copy)
- {
- copy->set(tmp, item->result_field);
- item->result_field->move_field(copy->to_ptr,copy->to_null_ptr,1);
- copy++;
- }
+ if (copy)
+ {
+ copy->set(tmp, item->result_field);
+ item->result_field->move_field(copy->to_ptr,copy->to_null_ptr,1);
+#ifdef HAVE_purify
+ copy->to_ptr[copy->from_length]= 0;
+#endif
+ copy++;
+ }
}
}
else if ((real_pos->type() == Item::FUNC_ITEM ||
@@ -14232,9 +14413,12 @@ static void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
item_list.push_back(new Item_string(table_name_buffer, len, cs));
}
else
- item_list.push_back(new Item_string(table->alias,
- strlen(table->alias),
+ {
+ TABLE_LIST *tab=table->pos_in_table_list;
+ item_list.push_back(new Item_string(tab->alias,
+ strlen(tab->alias),
cs));
+ }
/* type */
item_list.push_back(new Item_string(join_type_str[tab->type],
strlen(join_type_str[tab->type]),
@@ -14421,8 +14605,8 @@ bool mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit, select_result *result)
// drop UNCACHEABLE_EXPLAIN, because it is for internal usage only
uint8 uncacheable= (sl->uncacheable & ~UNCACHEABLE_EXPLAIN);
sl->type= (((&thd->lex->select_lex)==sl)?
- ((thd->lex->all_selects_list != sl) ?
- primary_key_name : "SIMPLE"):
+ (sl->first_inner_unit() || sl->next_select() ?
+ "PRIMARY" : "SIMPLE"):
((sl == first)?
((sl->linkage == DERIVED_TABLE_TYPE) ?
"DERIVED":
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 84b22c56cf9..a5a767b6ebc 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -606,6 +606,7 @@ err:
bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
Item **conds, uint order_num, ORDER *order)
{
+ Item *fake_conds= 0;
TABLE *table= table_list->table;
TABLE_LIST tables;
List<Item> all_fields;
@@ -645,7 +646,7 @@ bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list,
DBUG_RETURN(TRUE);
}
}
- select_lex->fix_prepare_information(thd, conds);
+ select_lex->fix_prepare_information(thd, conds, &fake_conds);
DBUG_RETURN(FALSE);
}
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 30c7da220a6..32f618e9601 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -753,8 +753,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
predicate bit_expr bit_term bit_factor value_expr term factor
table_wild simple_expr udf_expr
expr_or_default set_expr_or_default interval_expr
- param_marker singlerow_subselect singlerow_subselect_init
- exists_subselect exists_subselect_init geometry_function
+ param_marker geometry_function
signed_literal now_or_signed_literal opt_escape
sp_opt_default
simple_ident_nospvar simple_ident_q
@@ -819,7 +818,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
%type <variable> internal_variable_name
-%type <select_lex> in_subselect in_subselect_init
+%type <select_lex> subselect subselect_init
get_select_lex
%type <boolfunc2creator> comp_op
@@ -3942,12 +3941,14 @@ select_paren:
yyerror(ER(ER_SYNTAX_ERROR));
YYABORT;
}
- if (sel->linkage == UNION_TYPE &&
- !sel->master_unit()->first_select()->braces)
- {
- yyerror(ER(ER_SYNTAX_ERROR));
- YYABORT;
- }
+ if (sel->linkage == UNION_TYPE &&
+ !sel->master_unit()->first_select()->braces &&
+ sel->master_unit()->first_select()->linkage ==
+ UNION_TYPE)
+ {
+ yyerror(ER(ER_SYNTAX_ERROR));
+ YYABORT;
+ }
/* select in braces, can't contain global parameters */
if (sel->master_unit()->fake_select_lex)
sel->master_unit()->global_parameters=
@@ -4205,37 +4206,37 @@ bool_pri:
| bool_pri EQUAL_SYM predicate { $$= new Item_func_equal($1,$3); }
| bool_pri comp_op predicate %prec EQ
{ $$= (*$2)(0)->create($1,$3); }
- | bool_pri comp_op all_or_any in_subselect %prec EQ
- { $$= all_any_subquery_creator($1, $2, $3, $4); }
+ | bool_pri comp_op all_or_any '(' subselect ')' %prec EQ
+ { $$= all_any_subquery_creator($1, $2, $3, $5); }
| predicate ;
predicate:
- bit_expr IN_SYM '(' expr_list ')'
+ bit_expr IN_SYM '(' subselect ')'
+ { $$= new Item_in_subselect($1, $4); }
+ | bit_expr not IN_SYM '(' subselect ')'
+ { $$= negate_expression(YYTHD, new Item_in_subselect($1, $5)); }
+ | bit_expr IN_SYM '(' expr ')'
+ {
+ $$= new Item_func_eq($1, $4);
+ }
+ | bit_expr IN_SYM '(' expr ',' expr_list ')'
{
- if ($4->elements == 1)
- $$= new Item_func_eq($1, $4->head());
- else
- {
- $4->push_front($1);
- $$= new Item_func_in(*$4);
- }
+ $6->push_front($4);
+ $6->push_front($1);
+ $$= new Item_func_in(*$6);
}
- | bit_expr not IN_SYM '(' expr_list ')'
+ | bit_expr not IN_SYM '(' expr ')'
{
- if ($5->elements == 1)
- $$= new Item_func_ne($1, $5->head());
- else
- {
- $5->push_front($1);
- Item_func_in *item = new Item_func_in(*$5);
+ $$= new Item_func_ne($1, $5);
+ }
+ | bit_expr not IN_SYM '(' expr ',' expr_list ')'
+ {
+ $7->push_front($5);
+ $7->push_front($1);
+ Item_func_in *item = new Item_func_in(*$7);
item->negate();
$$= item;
- }
}
- | bit_expr IN_SYM in_subselect
- { $$= new Item_in_subselect($1, $3); }
- | bit_expr not IN_SYM in_subselect
- { $$= negate_expression(YYTHD, new Item_in_subselect($1, $4)); }
| bit_expr BETWEEN_SYM bit_expr AND_SYM predicate
{ $$= new Item_func_between($1,$3,$5); }
| bit_expr not BETWEEN_SYM bit_expr AND_SYM predicate
@@ -4357,6 +4358,10 @@ simple_expr:
| '-' simple_expr %prec NEG { $$= new Item_func_neg($2); }
| '~' simple_expr %prec NEG { $$= new Item_func_bit_neg($2); }
| not2 simple_expr %prec NEG { $$= negate_expression(YYTHD, $2); }
+ | '(' subselect ')'
+ {
+ $$= new Item_singlerow_subselect($2);
+ }
| '(' expr ')' { $$= $2; }
| '(' expr ',' expr_list ')'
{
@@ -4368,8 +4373,10 @@ simple_expr:
$5->push_front($3);
$$= new Item_row(*$5);
}
- | EXISTS exists_subselect { $$= $2; }
- | singlerow_subselect { $$= $1; }
+ | EXISTS '(' subselect ')'
+ {
+ $$= new Item_exists_subselect($3);
+ }
| '{' ident expr '}' { $$= $3; }
| MATCH ident_list_arg AGAINST '(' bit_expr fulltext_options ')'
{ $2->push_front($5);
@@ -6347,14 +6354,17 @@ table_wild_one:
ident opt_wild opt_table_alias
{
if (!Select->add_table_to_list(YYTHD, new Table_ident($1), $3,
- TL_OPTION_UPDATING, Lex->lock_option))
+ TL_OPTION_UPDATING |
+ TL_OPTION_ALIAS, Lex->lock_option))
YYABORT;
}
| ident '.' ident opt_wild opt_table_alias
{
if (!Select->add_table_to_list(YYTHD,
new Table_ident(YYTHD, $1, $3, 0),
- $5, TL_OPTION_UPDATING,
+ $5,
+ TL_OPTION_UPDATING |
+ TL_OPTION_ALIAS,
Lex->lock_option))
YYABORT;
}
@@ -6911,6 +6921,9 @@ load: LOAD DATA_SYM
YYABORT;
}
lex->sql_command = SQLCOM_LOAD_MASTER_TABLE;
+ WARN_DEPRECATED("LOAD TABLE FROM MASTER",
+ "mysqldump or future "
+ "BACKUP/RESTORE DATABASE facility");
if (!Select->add_table_to_list(YYTHD, $3, NULL, TL_OPTION_UPDATING))
YYABORT;
};
@@ -6949,6 +6962,9 @@ load_data:
FROM MASTER_SYM
{
Lex->sql_command = SQLCOM_LOAD_MASTER_DATA;
+ WARN_DEPRECATED("LOAD DATA FROM MASTER",
+ "mysqldump or future "
+ "BACKUP/RESTORE DATABASE facility");
};
opt_local:
@@ -7574,6 +7590,7 @@ keyword:
| TRUNCATE_SYM {}
| UNICODE_SYM {}
| XA_SYM {}
+ | UPGRADE_SYM {}
;
/*
@@ -8896,49 +8913,38 @@ union_option:
| ALL { $$=0; }
;
-singlerow_subselect:
- subselect_start singlerow_subselect_init
- subselect_end
- {
- $$= $2;
- };
-
-singlerow_subselect_init:
- select_init2
- {
- $$= new Item_singlerow_subselect(Lex->current_select->
- master_unit()->first_select());
- };
-
-exists_subselect:
- subselect_start exists_subselect_init
- subselect_end
- {
- $$= $2;
- };
-
-exists_subselect_init:
- select_init2
- {
- $$= new Item_exists_subselect(Lex->current_select->master_unit()->
- first_select());
- };
-
-in_subselect:
- subselect_start in_subselect_init
- subselect_end
- {
- $$= $2;
- };
+subselect:
+ SELECT_SYM subselect_start subselect_init subselect_end
+ {
+ $$= $3;
+ }
+ | '(' subselect_start subselect ')'
+ {
+ LEX *lex= Lex;
+ THD *thd= YYTHD;
+ /*
+ note that a local variable can't be used for
+ $3 as it's used in local variable construction
+ and some compilers can't guarnatee the order
+ in which the local variables are initialized.
+ */
+ List_iterator<Item> it($3->item_list);
+ Item *item;
+ /*
+ we must fill the items list for the "derived table".
+ */
+ while ((item= it++))
+ add_item_to_list(thd, item);
+ }
+ union_clause subselect_end { $$= $3; };
-in_subselect_init:
+subselect_init:
select_init2
{
$$= Lex->current_select->master_unit()->first_select();
};
subselect_start:
- '(' SELECT_SYM
{
LEX *lex=Lex;
if (lex->sql_command == (int)SQLCOM_HA_READ ||
@@ -8947,12 +8953,18 @@ subselect_start:
yyerror(ER(ER_SYNTAX_ERROR));
YYABORT;
}
+ /*
+ we are making a "derived table" for the parenthesis
+ as we need to have a lex level to fit the union
+ after the parenthesis, e.g.
+ (SELECT .. ) UNION ... becomes
+ SELECT * FROM ((SELECT ...) UNION ...)
+ */
if (mysql_new_select(Lex, 1))
YYABORT;
};
subselect_end:
- ')'
{
LEX *lex=Lex;
lex->pop_context();
diff --git a/sql/udf_example.c b/sql/udf_example.c
index a80fce81278..2fa7474eb16 100644
--- a/sql/udf_example.c
+++ b/sql/udf_example.c
@@ -127,7 +127,14 @@ typedef long long longlong;
#else
#include <my_global.h>
#include <my_sys.h>
+#if defined(MYSQL_SERVER)
#include <m_string.h> /* To get strmov() */
+#else
+/* when compiled as standalone */
+#define strmov(a,b) strcpy(a,b)
+#define bzero(a,b) memset(a,0,b)
+#define memcpy_fixed(a,b,c) memcpy(a,b,c)
+#endif
#endif
#include <mysql.h>
#include <ctype.h>
@@ -674,10 +681,14 @@ longlong sequence(UDF_INIT *initid __attribute__((unused)), UDF_ARGS *args,
**
****************************************************************************/
+#ifdef __WIN__
+#include <winsock.h>
+#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
+#endif
my_bool lookup_init(UDF_INIT *initid, UDF_ARGS *args, char *message);
void lookup_deinit(UDF_INIT *initid);
diff --git a/sql/udf_example.def b/sql/udf_example.def
new file mode 100644
index 00000000000..d3081ca7768
--- /dev/null
+++ b/sql/udf_example.def
@@ -0,0 +1,24 @@
+LIBRARY udf_example
+DESCRIPTION 'MySQL Sample for UDF'
+VERSION 1.0
+EXPORTS
+ lookup
+ lookup_init
+ reverse_lookup
+ reverse_lookup_init
+ metaphon_init
+ metaphon_deinit
+ metaphon
+ myfunc_double_init
+ myfunc_double
+ myfunc_int_init
+ myfunc_int
+ sequence_init
+ sequence_deinit
+ sequence
+ avgcost_init
+ avgcost_deinit
+ avgcost_reset
+ avgcost_add
+ avgcost_clear
+ avgcost
View Lorry Controller Status