=== modified file 'libmysqld/Makefile.am' --- a/libmysqld/Makefile.am 2008-07-01 19:52:47 +0000 +++ b/libmysqld/Makefile.am 2008-07-14 21:29:41 +0000 @@ -81,7 +81,7 @@ sql_tablespace.cc \ rpl_injector.cc my_user.c partition_info.cc \ sql_servers.cc ddl_blocker.cc si_objects.cc sql_audit.cc \ - event_parse_data.cc mdl.cc sql_signal.cc + event_parse_data.cc mdl.cc sql_signal.cc sql_fixstring.cc libmysqld_int_a_SOURCES= $(libmysqld_sources) nodist_libmysqld_int_a_SOURCES= $(libmysqlsources) $(sqlsources) === modified file 'mysql-test/r/signal.result' --- a/mysql-test/r/signal.result 2008-06-27 00:04:55 +0000 +++ b/mysql-test/r/signal.result 2008-07-14 21:29:41 +0000 @@ -1740,17 +1740,17 @@ end $$ call test_signal() $$ Warnings: -Warning 1292 Truncated incorrect VARCHAR(64) value: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIX' -Warning 1292 Truncated incorrect VARCHAR(64) value: 'JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJX' -Warning 1292 Truncated incorrect VARCHAR(128) value: '11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222288888888' +Warning 1683 Data truncated for condition item CLASS_ORIGIN +Warning 1683 Data truncated for condition item SUBCLASS_ORIGIN +Warning 1683 Data truncated for condition item CONSTRAINT_CATALOG +Warning 1683 Data truncated for condition item CONSTRAINT_SCHEMA +Warning 1683 Data truncated for condition item CONSTRAINT_NAME +Warning 1683 Data truncated for condition item CATALOG_NAME +Warning 1683 Data truncated for condition item SCHEMA_NAME +Warning 1683 Data truncated for condition item TABLE_NAME +Warning 1683 Data truncated for condition item COLUMN_NAME +Warning 1683 Data truncated for condition item CURSOR_NAME +Warning 1683 Data truncated for condition item MESSAGE_TEXT Warning 10000 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222288888888 drop procedure test_signal $$ create procedure test_signal() === added file 'mysql-test/r/signal_sqlmode.result' --- a/mysql-test/r/signal_sqlmode.result 1970-01-01 00:00:00 +0000 +++ b/mysql-test/r/signal_sqlmode.result 2008-07-14 21:29:41 +0000 @@ -0,0 +1,86 @@ +SET @save_sql_mode=@@sql_mode; +SET sql_mode=''; +drop procedure if exists p; +drop procedure if exists p2; +drop procedure if exists p3; +create procedure p() +begin +declare utf8_var VARCHAR(128) CHARACTER SET UTF8; +set utf8_var = concat(repeat('A', 128), 'X'); +select length(utf8_var), utf8_var; +end +$$ +create procedure p2() +begin +declare msg VARCHAR(129) CHARACTER SET UTF8; +set msg = concat(repeat('A', 128), 'X'); +select length(msg), msg; +signal sqlstate '55555' set message_text = msg; +end +$$ +create procedure p3() +begin +declare name VARCHAR(65) CHARACTER SET UTF8; +set name = concat(repeat('A', 64), 'X'); +select length(name), name; +signal sqlstate '55555' set +message_text = 'Message', +table_name = name; +end +$$ +call p; +length(utf8_var) utf8_var +128 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +Warnings: +Warning 1265 Data truncated for column 'utf8_var' at row 1 +call p2; +length(msg) msg +129 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX +ERROR 55555: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +call p3; +length(name) name +65 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX +ERROR 55555: Message +drop procedure p; +drop procedure p2; +drop procedure p3; +SET sql_mode='STRICT_ALL_TABLES'; +create procedure p() +begin +declare utf8_var VARCHAR(128) CHARACTER SET UTF8; +set utf8_var = concat(repeat('A', 128), 'X'); +select length(utf8_var), utf8_var; +end +$$ +create procedure p2() +begin +declare msg VARCHAR(129) CHARACTER SET UTF8; +set msg = concat(repeat('A', 128), 'X'); +select length(msg), msg; +signal sqlstate '55555' set message_text = msg; +end +$$ +create procedure p3() +begin +declare name VARCHAR(65) CHARACTER SET UTF8; +set name = concat(repeat('A', 64), 'X'); +select length(name), name; +signal sqlstate '55555' set +message_text = 'Message', +table_name = name; +end +$$ +call p; +ERROR 22001: Data too long for column 'utf8_var' at row 1 +call p2; +length(msg) msg +129 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX +ERROR HY000: Data too long for condition item MESSAGE_TEXT +call p3; +length(name) name +65 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAX +ERROR HY000: Data too long for condition item TABLE_NAME +drop procedure p; +drop procedure p2; +drop procedure p3; +SET @@sql_mode=@save_sql_mode; === added file 'mysql-test/t/signal_sqlmode.test' --- a/mysql-test/t/signal_sqlmode.test 1970-01-01 00:00:00 +0000 +++ b/mysql-test/t/signal_sqlmode.test 2008-07-14 21:29:41 +0000 @@ -0,0 +1,123 @@ +# Copyright (C) 2008 Sun Microsystems, Inc +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; version 2 of the License. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +# Tests for SIGNAL, RESIGNAL and GET DIAGNOSTICS + +SET @save_sql_mode=@@sql_mode; + +SET sql_mode=''; + +--disable_warnings +drop procedure if exists p; +drop procedure if exists p2; +drop procedure if exists p3; +--enable_warnings + +delimiter $$; + +create procedure p() +begin + declare utf8_var VARCHAR(128) CHARACTER SET UTF8; + set utf8_var = concat(repeat('A', 128), 'X'); + select length(utf8_var), utf8_var; +end +$$ + +create procedure p2() +begin + declare msg VARCHAR(129) CHARACTER SET UTF8; + set msg = concat(repeat('A', 128), 'X'); + select length(msg), msg; + + signal sqlstate '55555' set message_text = msg; +end +$$ + +create procedure p3() +begin + declare name VARCHAR(65) CHARACTER SET UTF8; + set name = concat(repeat('A', 64), 'X'); + select length(name), name; + + signal sqlstate '55555' set + message_text = 'Message', + table_name = name; +end +$$ +delimiter ;$$ + +call p; + +--error ER_SIGNAL_EXCEPTION +call p2; + +--error ER_SIGNAL_EXCEPTION +call p3; + +drop procedure p; +drop procedure p2; +drop procedure p3; + +SET sql_mode='STRICT_ALL_TABLES'; + +delimiter $$; + +create procedure p() +begin + declare utf8_var VARCHAR(128) CHARACTER SET UTF8; + set utf8_var = concat(repeat('A', 128), 'X'); + select length(utf8_var), utf8_var; +end +$$ + +create procedure p2() +begin + declare msg VARCHAR(129) CHARACTER SET UTF8; + set msg = concat(repeat('A', 128), 'X'); + select length(msg), msg; + + signal sqlstate '55555' set message_text = msg; +end +$$ + +create procedure p3() +begin + declare name VARCHAR(65) CHARACTER SET UTF8; + set name = concat(repeat('A', 64), 'X'); + select length(name), name; + + signal sqlstate '55555' set + message_text = 'Message', + table_name = name; +end +$$ + +delimiter ;$$ + +--error ER_DATA_TOO_LONG +call p; + +--error ER_COND_ITEM_TOO_LONG +call p2; + +--error ER_COND_ITEM_TOO_LONG +call p3; + +drop procedure p; +drop procedure p2; +drop procedure p3; + +SET @@sql_mode=@save_sql_mode; + === modified file 'sql/Makefile.am' --- a/sql/Makefile.am 2008-07-01 19:52:47 +0000 +++ b/sql/Makefile.am 2008-07-14 21:29:41 +0000 @@ -62,7 +62,7 @@ item_create.h item_subselect.h item_row.h \ mysql_priv.h item_geofunc.h sql_bitmap.h \ procedure.h sql_class.h sql_lex.h sql_list.h \ - sql_map.h sql_string.h unireg.h \ + sql_map.h sql_string.h sql_fixstring.h unireg.h \ sql_error.h field.h handler.h mysqld_suffix.h \ sql_profile.h \ ha_ndbcluster.h ha_ndbcluster_cond.h \ @@ -89,7 +89,8 @@ sql_partition.h partition_info.h partition_element.h \ probes.h sql_audit.h \ contributors.h sql_servers.h ddl_blocker.h \ - si_objects.h sql_plist.h mdl.h sql_signal.h + si_objects.h sql_plist.h mdl.h \ + sql_signal.h sql_fixstring.h mysqld_SOURCES = sql_lex.cc sql_handler.cc sql_partition.cc \ item.cc item_sum.cc item_buff.cc item_func.cc \ @@ -135,7 +136,7 @@ sql_builtin.cc sql_tablespace.cc partition_info.cc \ sql_servers.cc sql_audit.cc sha2.cc \ ddl_blocker.cc si_objects.cc event_parse_data.cc \ - mdl.cc sql_signal.cc + mdl.cc sql_signal.cc sql_fixstring.cc if HAVE_DTRACE mysqld_SOURCES += probes.d === modified file 'sql/mysql_priv.h' --- a/sql/mysql_priv.h 2008-07-01 19:52:47 +0000 +++ b/sql/mysql_priv.h 2008-07-14 21:29:41 +0000 @@ -772,6 +772,7 @@ uint key_length, ulonglong *engine_data); #include "sql_string.h" +#include "sql_fixstring.h" #include "sql_list.h" #include "sql_map.h" #include "my_decimal.h" === modified file 'sql/share/errmsg.txt' --- a/sql/share/errmsg.txt 2008-07-01 19:52:47 +0000 +++ b/sql/share/errmsg.txt 2008-07-14 21:29:41 +0000 @@ -6289,3 +6289,9 @@ ER_SIGNAL_BAD_CONDITION_TYPE eng "SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE" +WARN_COND_ITEM_TRUNCATED + eng "Data truncated for condition item %s" + +ER_COND_ITEM_TOO_LONG + eng "Data too long for condition item %s" + === modified file 'sql/sp_rcontext.cc' --- a/sql/sp_rcontext.cc 2008-07-09 22:23:07 +0000 +++ b/sql/sp_rcontext.cc 2008-07-14 21:29:41 +0000 @@ -319,7 +319,7 @@ if ((cond->m_level == MYSQL_ERROR::WARN_LEVEL_WARN) && thd->really_abort_on_warning()) { - SQL_condition elevated_cond; + SQL_condition elevated_cond(thd->mem_root); elevated_cond.set(thd, cond->m_sqlcode, cond->get_message_text(), MYSQL_ERROR::WARN_LEVEL_ERROR, === modified file 'sql/sql_class.cc' --- a/sql/sql_class.cc 2008-07-01 19:52:47 +0000 +++ b/sql/sql_class.cc 2008-07-14 21:29:41 +0000 @@ -711,7 +711,7 @@ void THD::raise_error(uint code, const char *str, myf MyFlags) { - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set(this, code, str, MYSQL_ERROR::WARN_LEVEL_ERROR, MyFlags); raise_condition(& cond); @@ -731,7 +731,7 @@ (void) my_vsnprintf (ebuff, sizeof(ebuff), format, args); va_end(args); - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set(this, code, ebuff, MYSQL_ERROR::WARN_LEVEL_ERROR, MyFlags); raise_condition(& cond); @@ -740,7 +740,7 @@ void THD::raise_warning(uint code, const char *msg) { - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set(this, code, msg, MYSQL_ERROR::WARN_LEVEL_WARN, MYF(0)); raise_condition(& cond); @@ -759,7 +759,7 @@ my_vsnprintf(ebuff, sizeof(ebuff), format, args); va_end(args); - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set(this, code, ebuff, MYSQL_ERROR::WARN_LEVEL_WARN, MYF(0)); raise_condition(& cond); @@ -774,7 +774,7 @@ if (!(this->options & OPTION_SQL_NOTES)) DBUG_VOID_RETURN; - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set(this, code, msg, MYSQL_ERROR::WARN_LEVEL_NOTE, MYF(0)); raise_condition(& cond); @@ -797,7 +797,7 @@ my_vsnprintf(ebuff, sizeof(ebuff), format, args); va_end(args); - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set(this, code, ebuff, MYSQL_ERROR::WARN_LEVEL_NOTE, MYF(0)); raise_condition(& cond); === modified file 'sql/sql_class.h' --- a/sql/sql_class.h 2008-07-01 19:52:47 +0000 +++ b/sql/sql_class.h 2008-07-14 21:29:41 +0000 @@ -1244,56 +1244,6 @@ SYSTEM_THREAD_BACKUP= 64 }; -/** - UTF8String64 is a String helper used to - - manipulate strings in the UFT8 character set, - - truncate the string length to 64 characters (with a warning), - - control which MEM_ROOT the string uses. -*/ -class UTF8String64 -{ -public: - /** Constructor. */ - UTF8String64(); - - /** Destructor. */ - ~UTF8String64() - {} - - /** - Get the string value. - @return the wrapped String object. - */ - const String* get_string() const - { return & m_value; } - - /** - Set the string value. - The string will be truncated with a warning if necessary. - @param thd the current thread. - @param String the value to set. - */ - void set_string(THD *thd, String *value); - - /** - Set the string value. - The string will be truncated with a warning if necessary. - @param thd the current thread. - @param value the value to set. - */ - void set_string(THD *thd, const char* value); - - /** - Deep copy. - @param mem_root The memory root to use to copy the value to. - @param str The value to copy from. - */ - void deep_copy(MEM_ROOT *mem_root, const UTF8String64& str); - -private: - /** The wrapped String value. */ - String m_value; -}; /** Representation of a SQL condition. @@ -1304,7 +1254,7 @@ { public: /** Constructor. */ - SQL_condition(); + SQL_condition(MEM_ROOT *mem_root); /** Destructor. */ ~SQL_condition() @@ -2779,12 +2729,12 @@ void raise_ER_NO_SUCH_TABLE(const char* db, const char* table) { - SQL_condition cond; + SQL_condition cond(this->mem_root); cond.set_printf(this, ER_NO_SUCH_TABLE, ER(ER_NO_SUCH_TABLE), MYSQL_ERROR::WARN_LEVEL_ERROR, MYF(0), db, table); - cond.m_schema_name.set_string(this, db); - cond.m_table_name.set_string(this, table); + cond.m_schema_name.set(db); + cond.m_table_name.set(table); raise_condition(& cond); } === modified file 'sql/sql_error.cc' --- a/sql/sql_error.cc 2008-07-01 23:01:11 +0000 +++ b/sql/sql_error.cc 2008-07-14 21:29:41 +0000 @@ -118,7 +118,7 @@ break; case MYSQL_ERROR::WARN_LEVEL_ERROR: { - SQL_condition cond; + SQL_condition cond(thd->mem_root); cond.set(thd, code, msg, MYSQL_ERROR::WARN_LEVEL_WARN, MYF(0)); /* FIXME: broken calling code */ cond.m_broken_caller= TRUE; === added file 'sql/sql_fixstring.cc' --- a/sql/sql_fixstring.cc 1970-01-01 00:00:00 +0000 +++ b/sql/sql_fixstring.cc 2008-07-14 21:29:41 +0000 @@ -0,0 +1,158 @@ +/* Copyright (C) 2008 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "mysql_priv.h" + +Fixed_string::~Fixed_string() +{} + +void Fixed_string::set(const char* str) +{ + set(str, strlen(str)); +} + +void Fixed_string::set(const char* str, size_t len) +{ + size_t numchars; + size_t to_copy; + CHARSET_INFO *cs= m_param->m_cs; + const char *end= str+len; + + numchars= cs->cset->numchars(cs, str, end); + + if (numchars <= m_param->m_max_char_length) + { + to_copy= len; + m_truncated= FALSE; + } + else + { + to_copy= cs->cset->charpos(cs, str, end, m_param->m_max_char_length); + m_truncated= TRUE; + } + + reserve(to_copy + cs->mbminlen); + if (m_ptr) + { + m_byte_length= to_copy; + memcpy(m_ptr, str, to_copy); + add_null(m_ptr + to_copy); + } +} + +void Fixed_string::set(const String* str) +{ + set(str->ptr(), str->length(), (CHARSET_INFO*) str->charset()); +} + +void Fixed_string::set(const char* str, size_t len, const CHARSET_INFO *str_cs) +{ + uint32 dummy_offset; + size_t numchars; + size_t to_copy; + CHARSET_INFO *cs= m_param->m_cs; + const char *end= str + len; + + numchars= cs->cset->numchars(cs, str, end); + + if (numchars <= m_param->m_max_char_length) + { + to_copy= len; + m_truncated= FALSE; + } + else + { + numchars= m_param->m_max_char_length; + to_copy= cs->cset->charpos(cs, str, end, numchars); + m_truncated= TRUE; + } + + if (String::needs_conversion(to_copy, (CHARSET_INFO*) str_cs, + (CHARSET_INFO*) cs, & dummy_offset)) + { + size_t dest_len= numchars * cs->mbmaxlen; + reserve(dest_len + cs->mbminlen); + if (m_ptr) + { + const char* well_formed_error_pos; + const char* cannot_convert_error_pos; + const char* from_end_pos; + + m_byte_length= well_formed_copy_nchars((CHARSET_INFO *) cs, + m_ptr, dest_len, + (CHARSET_INFO*) str_cs, str, len, + numchars, + & well_formed_error_pos, + & cannot_convert_error_pos, + & from_end_pos); + add_null(m_ptr + m_byte_length); + } + } + else + { + reserve(to_copy + cs->mbminlen); + if (m_ptr) + { + m_byte_length= to_copy; + memcpy(m_ptr, str, to_copy); + add_null(m_ptr + to_copy); + } + } +} + +void Fixed_string::add_null(char *ptr) +{ + /* + Assume that the NUL character is always encoded using 0 bytes, + and is always using an encoding of the minimum length. + Verified for: + - UTF8 : NUL = 1 zero byte + - latin* : NUL = 1 zero byte + - UTF16 : NUL = 2 zero byte + - UTF32 : NUL = 4 zero byte + */ + switch (m_param->m_cs->mbminlen) + { + case 4: *ptr++ = '\0'; /* fall through */ + case 3: *ptr++ = '\0'; /* fall through */ + case 2: *ptr++ = '\0'; /* fall through */ + case 1: *ptr++ = '\0'; break; + default: DBUG_ASSERT(FALSE); break; + } +} + +void Fixed_string::copy(const Fixed_string *str) +{ + DBUG_ASSERT(m_param->m_cs->number == str->m_param->m_cs->number); + + set(str->m_ptr, str->m_byte_length); +} + +void Fixed_string::reserve(size_t len) +{ + if ((m_ptr != NULL) && (m_allocated_length >= len)) + return; + + m_ptr= (char*) alloc_root(m_memroot, len); + m_allocated_length= (m_ptr ? len : 0); +} + +const Fixed_string_param UTF8String64::params= +{64, & my_charset_utf8_bin }; + +const Fixed_string_param UTF8String128::params= +{128, & my_charset_utf8_bin }; + + === added file 'sql/sql_fixstring.h' --- a/sql/sql_fixstring.h 1970-01-01 00:00:00 +0000 +++ b/sql/sql_fixstring.h 2008-07-14 21:29:41 +0000 @@ -0,0 +1,100 @@ +/* Copyright (C) 2008 MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#ifndef SQL_FIXSTRING_H +#define SQL_FIXSTRING_H + +struct Fixed_string_param +{ + size_t m_max_char_length; + CHARSET_INFO *m_cs; +}; + +class Fixed_string +{ +public: + Fixed_string(const Fixed_string_param *param, MEM_ROOT *root) + : m_param(param), + m_memroot(root), + m_byte_length(0), + m_allocated_length(0), + m_truncated(FALSE), + m_ptr(NULL) + {} + + ~Fixed_string(); + + void set(const char* str); + void set(const char* str, size_t len); + void set(const String* str); + void set(const char* str, size_t len, const CHARSET_INFO *str_cs); + + bool is_truncated() const + { return m_truncated; } + + const char* ptr() const + { return m_ptr; } + + size_t length() const + { return m_byte_length; } + + const CHARSET_INFO *charset() const + { return m_param->m_cs; } + + void copy(const Fixed_string *str); + +private: + void reserve(size_t len); + void add_null(char *ptr); + + const Fixed_string_param *m_param; + MEM_ROOT *m_memroot; + size_t m_byte_length; + size_t m_allocated_length; + bool m_truncated; + char * m_ptr; +}; + +class UTF8String64 : public Fixed_string +{ +public: + UTF8String64(MEM_ROOT *root) + : Fixed_string(& params, root) + {} + + ~UTF8String64() + {} + +private: + static const Fixed_string_param params; +}; + +class UTF8String128 : public Fixed_string +{ +public: + UTF8String128(MEM_ROOT *root) + : Fixed_string(& params, root) + {} + + ~UTF8String128() + {} + +private: + static const Fixed_string_param params; +}; + +#endif + + === modified file 'sql/sql_signal.cc' --- a/sql/sql_signal.cc 2008-07-09 22:23:07 +0000 +++ b/sql/sql_signal.cc 2008-07-14 21:29:41 +0000 @@ -75,107 +75,34 @@ { C_STRING_WITH_LEN("TRANSACTION_ACTIVE") } }; -UTF8String64::UTF8String64() - : m_value() -{ - m_value.set_charset(& my_charset_utf8_bin); -} - -void UTF8String64::set_string(THD *thd, String *value) -{ - m_value.length(0); - - if (value) - { - m_value.append(value->ptr(), value->length(), value->charset()); - - if (m_value.numchars() > 64) - { - push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, - ER_TRUNCATED_WRONG_VALUE, - ER(ER_TRUNCATED_WRONG_VALUE), - "VARCHAR(64)", value->c_ptr_safe()); - - uint32 end= m_value.charpos(64); - m_value.length(end); - } - } - /* - Enforce the string is 0 terminated, - which the 'String' class does not provide ... - */ - (void) m_value.c_ptr_safe(); -} - -void UTF8String64::set_string(THD *thd, const char* value) -{ - m_value.length(0); - - if (value) - { - m_value.append(value, strlen(value), & my_charset_utf8_bin); - - if (m_value.numchars() > 64) - { - push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, - ER_TRUNCATED_WRONG_VALUE, - ER(ER_TRUNCATED_WRONG_VALUE), - "VARCHAR(64)", value); - - uint32 end= m_value.charpos(64); - m_value.length(end); - } - } - /* - Enforce the string is 0 terminated, - which the 'String' class does not provide ... - */ - (void) m_value.c_ptr_safe(); -} - -void -UTF8String64::deep_copy(MEM_ROOT *mem_root, const UTF8String64& str) -{ - if (str.m_value.length()) - { - const char* copy; - - copy= strdup_root(mem_root, str.m_value.ptr()); - m_value.set(copy, str.m_value.length(), & my_charset_utf8_bin); - } - else - m_value.length(0); - - DBUG_ASSERT(! m_value.is_alloced()); -} - -SQL_condition::SQL_condition() + +SQL_condition::SQL_condition(MEM_ROOT *mem_root) : Sql_alloc(), - m_class_origin(), - m_subclass_origin(), - m_constraint_catalog(), - m_constraint_schema(), - m_constraint_name(), - m_catalog_name(), - m_schema_name(), - m_table_name(), - m_column_name(), - m_cursor_name(), + m_class_origin(mem_root), + m_subclass_origin(mem_root), + m_constraint_catalog(mem_root), + m_constraint_schema(mem_root), + m_constraint_name(mem_root), + m_catalog_name(mem_root), + m_schema_name(mem_root), + m_table_name(mem_root), + m_column_name(mem_root), + m_cursor_name(mem_root), m_message_text(), m_sqlcode(0), - m_condition_identifier(), - m_connection_name(), - m_parameter_mode(), - m_parameter_name(), + m_condition_identifier(mem_root), + m_connection_name(mem_root), + m_parameter_mode(mem_root), + m_parameter_name(mem_root), m_parameter_ordinal_position(0), - m_routine_catalog(), - m_routine_name(), - m_routine_schema(), - m_server_name(), - m_specific_name(), - m_trigger_catalog(), - m_trigger_name(), - m_trigger_schema(), + m_routine_catalog(mem_root), + m_routine_name(mem_root), + m_routine_schema(mem_root), + m_server_name(mem_root), + m_specific_name(mem_root), + m_trigger_catalog(mem_root), + m_trigger_name(mem_root), + m_trigger_schema(mem_root), m_level(MYSQL_ERROR::WARN_LEVEL_ERROR), m_flags(0), m_broken_caller(FALSE) @@ -187,7 +114,7 @@ SQL_condition::deep_copy(THD *thd, MEM_ROOT *mem_root, const SQL_condition *cond) { - SQL_condition *copy= new (mem_root) SQL_condition; + SQL_condition *copy= new (mem_root) SQL_condition(mem_root); if (copy) copy->deep_copy(mem_root, cond); return copy; @@ -212,30 +139,30 @@ DBUG_ASSERT(! m_message_text.is_alloced()); - m_class_origin.deep_copy(mem_root, cond->m_class_origin); - m_subclass_origin.deep_copy(mem_root, cond->m_subclass_origin); - m_constraint_catalog.deep_copy(mem_root, cond->m_constraint_catalog); - m_constraint_schema.deep_copy(mem_root, cond->m_constraint_schema); - m_constraint_name.deep_copy(mem_root, cond->m_constraint_name); - m_catalog_name.deep_copy(mem_root, cond->m_catalog_name); - m_schema_name.deep_copy(mem_root, cond->m_schema_name); - m_table_name.deep_copy(mem_root, cond->m_table_name); - m_column_name.deep_copy(mem_root, cond->m_column_name); - m_cursor_name.deep_copy(mem_root, cond->m_cursor_name); + m_class_origin.copy(& cond->m_class_origin); + m_subclass_origin.copy(& cond->m_subclass_origin); + m_constraint_catalog.copy(& cond->m_constraint_catalog); + m_constraint_schema.copy(& cond->m_constraint_schema); + m_constraint_name.copy(& cond->m_constraint_name); + m_catalog_name.copy(& cond->m_catalog_name); + m_schema_name.copy(& cond->m_schema_name); + m_table_name.copy(& cond->m_table_name); + m_column_name.copy(& cond->m_column_name); + m_cursor_name.copy(& cond->m_cursor_name); m_sqlcode= cond->m_sqlcode; - m_condition_identifier.deep_copy(mem_root, cond->m_condition_identifier); - m_connection_name.deep_copy(mem_root, cond->m_connection_name); - m_parameter_mode.deep_copy(mem_root, cond->m_parameter_mode); - m_parameter_name.deep_copy(mem_root, cond->m_parameter_name); + m_condition_identifier.copy(& cond->m_condition_identifier); + m_connection_name.copy(& cond->m_connection_name); + m_parameter_mode.copy(& cond->m_parameter_mode); + m_parameter_name.copy(& cond->m_parameter_name); m_parameter_ordinal_position= cond->m_parameter_ordinal_position; - m_routine_catalog.deep_copy(mem_root, cond->m_routine_catalog); - m_routine_name.deep_copy(mem_root, cond->m_routine_name); - m_routine_schema.deep_copy(mem_root, cond->m_routine_schema); - m_server_name.deep_copy(mem_root, cond->m_server_name); - m_specific_name.deep_copy(mem_root, cond->m_specific_name); - m_trigger_catalog.deep_copy(mem_root, cond->m_trigger_catalog); - m_trigger_name.deep_copy(mem_root, cond->m_trigger_name); - m_trigger_schema.deep_copy(mem_root, cond->m_trigger_schema); + m_routine_catalog.copy(& cond->m_routine_catalog); + m_routine_name.copy(& cond->m_routine_name); + m_routine_schema.copy(& cond->m_routine_schema); + m_server_name.copy(& cond->m_server_name); + m_specific_name.copy(& cond->m_specific_name); + m_trigger_catalog.copy(& cond->m_trigger_catalog); + m_trigger_name.copy(& cond->m_trigger_name); + m_trigger_schema.copy(& cond->m_trigger_schema); m_level= cond->m_level; m_flags= cond->m_flags; m_broken_caller= cond->m_broken_caller; @@ -416,6 +343,41 @@ return 0; } +int assign_condition_item(const char* name, THD *thd, Item *set, + UTF8String64 *ci) +{ + String str_value; + String *str; + + DBUG_ENTER("assign_condition_item"); + + if (set->is_null()) + { + my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, "NULL"); + DBUG_RETURN(1); + } + + str= set->val_str(& str_value); + ci->set(str); + if (ci->is_truncated()) + { + if (thd->variables.sql_mode & (MODE_STRICT_TRANS_TABLES | + MODE_STRICT_ALL_TABLES)) + { + my_error(ER_COND_ITEM_TOO_LONG, MYF(0), name); + DBUG_RETURN(1); + } + + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, + WARN_COND_ITEM_TRUNCATED, + ER(WARN_COND_ITEM_TRUNCATED), + name); + } + + DBUG_RETURN(0); +} + + int Abstract_signal::eval_signal_informations(THD *thd, SQL_condition *cond) { Item *set; @@ -445,121 +407,81 @@ set= m_set_signal_information.m_item[DIAG_CLASS_ORIGIN]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "CLASS_ORIGIN", "NULL"); + if (assign_condition_item("CLASS_ORIGIN", thd, set, + & cond->m_class_origin)) goto end; - } - str= set->val_str(& str_value); - cond->m_class_origin.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_SUBCLASS_ORIGIN]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "SUBCLASS_ORIGIN", "NULL"); + if (assign_condition_item("SUBCLASS_ORIGIN", thd, set, + & cond->m_subclass_origin)) goto end; - } - str= set->val_str(& str_value); - cond->m_subclass_origin.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_CONSTRAINT_CATALOG]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "CONSTRAINT_CATALOG", "NULL"); + if (assign_condition_item("CONSTRAINT_CATALOG", thd, set, + & cond->m_constraint_catalog)) goto end; - } - str= set->val_str(& str_value); - cond->m_constraint_catalog.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_CONSTRAINT_SCHEMA]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "CONSTRAINT_SCHEMA", "NULL"); + if (assign_condition_item("CONSTRAINT_SCHEMA", thd, set, + & cond->m_constraint_schema)) goto end; - } - str= set->val_str(& str_value); - cond->m_constraint_schema.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_CONSTRAINT_NAME]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "CONSTRAINT_NAME", "NULL"); + if (assign_condition_item("CONSTRAINT_NAME", thd, set, + & cond->m_constraint_name)) goto end; - } - str= set->val_str(& str_value); - cond->m_constraint_name.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_CATALOG_NAME]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "CATALOG_NAME", "NULL"); + if (assign_condition_item("CATALOG_NAME", thd, set, + & cond->m_catalog_name)) goto end; - } - str= set->val_str(& str_value); - cond->m_catalog_name.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_SCHEMA_NAME]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "SCHEMA_NAME", "NULL"); + if (assign_condition_item("SCHEMA_NAME", thd, set, + & cond->m_schema_name)) goto end; - } - str= set->val_str(& str_value); - cond->m_schema_name.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_TABLE_NAME]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "TABLE_NAME", "NULL"); + if (assign_condition_item("TABLE_NAME", thd, set, + & cond->m_table_name)) goto end; - } - str= set->val_str(& str_value); - cond->m_table_name.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_COLUMN_NAME]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "COLUMN_NAME", "NULL"); + if (assign_condition_item("COLUMN_NAME", thd, set, + & cond->m_column_name)) goto end; - } - str= set->val_str(& str_value); - cond->m_column_name.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_CURSOR_NAME]; if (set != NULL) { - if (set->is_null()) - { - my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), "CURSOR_NAME", "NULL"); + if (assign_condition_item("CURSOR_NAME", thd, set, + & cond->m_cursor_name)) goto end; - } - str= set->val_str(& str_value); - cond->m_cursor_name.set_string(thd, str); } set= m_set_signal_information.m_item[DIAG_MESSAGE_TEXT]; @@ -574,29 +496,33 @@ Enforce that SET MESSAGE_TEXT = evaluates the value as VARCHAR(128) CHARACTER SET UTF8. */ + UTF8String128 utf8_text(thd->mem_root); str= set->val_str(& str_value); - String utf8_text; - utf8_text.set_charset(& my_charset_utf8_bin); - utf8_text.append(str->ptr(), str->length(), str->charset()); - if (utf8_text.numchars() > 128) + utf8_text.set(str->ptr(), (size_t) str->length(), str->charset()); + + if (utf8_text.is_truncated()) { + if (thd->variables.sql_mode & (MODE_STRICT_TRANS_TABLES | + MODE_STRICT_ALL_TABLES)) + { + my_error(ER_COND_ITEM_TOO_LONG, MYF(0), "MESSAGE_TEXT"); + goto end; + } + push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, - ER_TRUNCATED_WRONG_VALUE, - ER(ER_TRUNCATED_WRONG_VALUE), - "VARCHAR(128)", str->c_ptr_safe()); - - uint32 end= utf8_text.charpos(128); - utf8_text.length(end); + WARN_COND_ITEM_TRUNCATED, + ER(WARN_COND_ITEM_TRUNCATED), + "MESSAGE_TEXT"); } /* Convert to the character set used with --language. - This code will be removed once WL#xxx is implemented. + This code should be removed when WL#751 is implemented. */ String converted_text; converted_text.set_charset(error_message_charset_info); converted_text.append(utf8_text.ptr(), utf8_text.length(), - utf8_text.charset()); + (CHARSET_INFO *) utf8_text.charset()); cond->set_builtin_message_text(converted_text.c_ptr_safe()); } @@ -680,7 +606,7 @@ int SQLCOM_signal::execute(THD *thd) { int result= 1; - SQL_condition cond; + SQL_condition cond(thd->mem_root); DBUG_ENTER("SQLCOM_signal::execute"); @@ -727,7 +653,7 @@ thd->raise_condition_no_handler(signaled); - SQL_condition new_cond; + SQL_condition new_cond(thd->mem_root); new_cond.deep_copy(thd->mem_root, signaled); result= raise_condition(thd, & new_cond); DBUG_RETURN(result); @@ -800,7 +726,7 @@ Settable_routine_parameter *setter; int result= 1; int32 int_value; - const String *str_value; + const UTF8String64 *str_value; Item *value= NULL; String utf8_text; const char* language_text; @@ -816,64 +742,64 @@ switch(item_name) { case DIAG_CLASS_ORIGIN: - str_value= cond->m_class_origin.get_string(); + str_value= & cond->m_class_origin; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_SUBCLASS_ORIGIN: - str_value= cond->m_subclass_origin.get_string(); + str_value= & cond->m_subclass_origin; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_CONSTRAINT_CATALOG: - str_value= cond->m_constraint_catalog.get_string(); + str_value= & cond->m_constraint_catalog; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_CONSTRAINT_SCHEMA: - str_value= cond->m_constraint_schema.get_string(); + str_value= & cond->m_constraint_schema; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_CONSTRAINT_NAME: - str_value= cond->m_constraint_name.get_string(); + str_value= & cond->m_constraint_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_CATALOG_NAME: - str_value= cond->m_catalog_name.get_string(); + str_value= & cond->m_catalog_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_SCHEMA_NAME: - str_value= cond->m_schema_name.get_string(); + str_value= & cond->m_schema_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_TABLE_NAME: - str_value= cond->m_table_name.get_string(); + str_value= & cond->m_table_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_COLUMN_NAME: - str_value= cond->m_column_name.get_string(); + str_value= & cond->m_column_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_CURSOR_NAME: - str_value= cond->m_cursor_name.get_string(); + str_value= & cond->m_cursor_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_MESSAGE_TEXT: language_text= cond->get_message_text(); @@ -889,20 +815,20 @@ value= new (thd->mem_root) Item_int(int_value); break; case DIAG_CONDITION_IDENTIFIER: - str_value= cond->m_condition_identifier.get_string(); + str_value= & cond->m_condition_identifier; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_CONDITION_NUMBER: int_value= condition_number; value= new (thd->mem_root) Item_int(int_value); break; case DIAG_CONNECTION_NAME: - str_value= cond->m_connection_name.get_string(); + str_value= & cond->m_connection_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_MESSAGE_LENGTH: language_text= cond->get_message_text(); @@ -917,16 +843,16 @@ value= new (thd->mem_root) Item_int(int_value); break; case DIAG_PARAMETER_MODE: - str_value= cond->m_parameter_mode.get_string(); + str_value= & cond->m_parameter_mode; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_PARAMETER_NAME: - str_value= cond->m_parameter_name.get_string(); + str_value= & cond->m_parameter_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_PARAMETER_ORDINAL_POSITION: int_value= cond->m_parameter_ordinal_position; @@ -938,52 +864,52 @@ & my_charset_utf8_bin); break; case DIAG_ROUTINE_CATALOG: - str_value= cond->m_routine_catalog.get_string(); + str_value= & cond->m_routine_catalog; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_ROUTINE_NAME: - str_value= cond->m_routine_name.get_string(); + str_value= & cond->m_routine_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_ROUTINE_SCHEMA: - str_value= cond->m_routine_schema.get_string(); + str_value= & cond->m_routine_schema; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_SERVER_NAME: - str_value= cond->m_server_name.get_string(); + str_value= & cond->m_server_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_SPECIFIC_NAME: - str_value= cond->m_specific_name.get_string(); + str_value= & cond->m_specific_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_TRIGGER_CATALOG: - str_value= cond->m_trigger_catalog.get_string(); + str_value= & cond->m_trigger_catalog; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_TRIGGER_NAME: - str_value= cond->m_trigger_name.get_string(); + str_value= & cond->m_trigger_name; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; case DIAG_TRIGGER_SCHEMA: - str_value= cond->m_trigger_schema.get_string(); + str_value= & cond->m_trigger_schema; value= new (thd->mem_root) Item_string("", str_value->ptr(), str_value->length(), - str_value->charset()); + (CHARSET_INFO*) str_value->charset()); break; } @@ -1000,7 +926,7 @@ Item *item; ulong cond_number; uint cond_position; - SQL_condition success; + SQL_condition success(thd->mem_root); SQL_condition *cond= NULL; int result= 1;