IN/BETWEEN predicates in sorting expressions.
Wrong results may occur when the select list contains an expression
with IN/BETWEEN predicate that differs from a sorting expression by
an additional NOT only.
Added the method Item_func_opt_neg::eq to compare correctly expressions
containing [NOT] IN/BETWEEN.
The eq method inherited from the Item_func returns TRUE when comparing
'a IN (1,2)' with 'a NOT IN (1,2)' that is not, of course, correct.
mysql-test/r/order_by.result:
Added a test case for bug #27532.
mysql-test/t/order_by.test:
Added a test case for bug #27532.
sql/item_cmpfunc.cc:
Fixed bug #27532.
Added the method Item_func_opt_neg::eq to compare correctly expressions
containing [NOT] IN/BETWEEN.
The eq method inherited from the Item_func returns TRUE when comparing
'a IN (1,2)' with 'a NOT IN (1,2)' that is not, of course, correct.
sql/item_cmpfunc.h:
Added the method Item_func_opt_neg::eq to compare correctly expressions
containing [NOT] IN/BETWEEN.
The eq method inherited from the Item_func returns TRUE when comparing
'a IN (1,2)' with 'a NOT IN (1,2)' that is not, of course, correct.
Pushbuild fixes:
- Make MAX_SEL_ARGS smaller (even 16K records_in_range() calls is
more than it makes sense to do in typical cases)
- Don't call sel_arg->test_use_count() if we've already allocated
more than MAX_SEL_ARGs elements. The test will succeed but will take
too much time for the test suite (and not provide much value).
mysql-test/r/range.result:
BUG#26624: high mem usage (crash) in range optimizer
Pushbuild fixes: make the test go faster
mysql-test/t/range.test:
BUG#26624: high mem usage (crash) in range optimizer
Pushbuild fixes: make the test go faster
- GRANT and REVOKE statments didn't have the "updating" flag set and
thus statements with a table specified would not replicate if
slave filtering rules where turned on.
For example "GRANT ... ON test.t1 TO ..." would not replicate.
mysql-test/r/rpl_ignore_table.result:
Add test results
mysql-test/t/rpl_ignore_table.test:
Add tests
sql/sql_yacc.yy:
Pass option TL_OPTION_UPDATING to 'add_table_to_list' when parsing a
GRANT or REVOKE and a table specifier is found. This will set the
property "updating" on the table and thus the slave filtering rules will
be applied.
Without setting updating the statement will be not
replicated - since "it's not updating anything" - an optimization
to quickly skip SELECT's and similar.
Thanks to Martin Friebe for finding and submitting a fix for this bug!
A table with maximum number of key segments and maximum length key name
would have a corrupted .frm file, due to an incorrect calculation of the
complete key length. Now the key length is computed correctly (I hope) :-)
MyISAM would reject a table with the maximum number of keys and the maximum
number of key segments in all keys. It would allow one less than this total
maximum. Now MyISAM accepts a table defined with the maximum. (This is a
very minor issue.)
myisam/mi_open.c:
change >= to > in a comparison (i.e., error only if key_parts_in_table
really is greater than MAX_KEY * MAX_KEY_SEG)
mysql-test/r/create.result:
Add test results for bug #26642 (create index corrupts table definition in .frm)
mysql-test/t/create.test:
Add test case for bug #26642 (create index corrupts table definition in .frm)
sql/table.cc:
In create_frm(), fix formula for key_length; it was too small by (keys * 2) bytes
- Added PARAM::alloced_sel_args where we count the # of SEL_ARGs
created by SEL_ARG tree cloning operations.
- Made the range analyzer to shortcut and not do any more cloning
if we've already created MAX_SEL_ARGS SEL_ARG objects in cloning.
- Added comments about space complexity of SEL_ARG-graph
representation.
mysql-test/r/range.result:
BUG#26624: Testcase
mysql-test/t/range.test:
BUG#26624: Testcase
- Define Sql_alloc::operator new() as thow() so that C++ compiler
handles NULL return values
(there is no testcase as there is no portable way to set limit on the
amount of memory that a process can allocate)
sql/sql_list.h:
BUG#26625: crash in range optimizer (out of mem)
- Define Sql_alloc::operator new() as thow() so that C++ compiler
handles NULL return values
Don't use explicit calls to mysql-test-run in spec
Makefile.am:
Don't use explicit calls to mysql-test-run in spec
support-files/mysql.spec.sh:
Don't use explicit calls to mysql-test-run in spec
causes incorrect duplicate entries
Keys for BTREE indexes on ENUM and SET columns of MEMORY tables
with character set UTF8 were computed incorrectly. Many
different column values got the same key value.
Apart of possible performance problems, it made unique indexes
of this type unusable because it rejected many different
values as duplicates.
The problem was that multibyte character detection was tried
on the internal numeric column value. Many values were not
identified as characters. Their key value became blank filled.
Thanks to Alexander Barkov and Ramil Kalimullin for the patch,
which sets the character set of ENUM and SET key segments to
the pseudo binary character set.
mysql-test/r/heap_btree.result:
Bug#24985 - UTF8 ENUM primary key on MEMORY using BTREE
causes incorrect duplicate entries
Added test result.
mysql-test/t/heap_btree.test:
Bug#24985 - UTF8 ENUM primary key on MEMORY using BTREE
causes incorrect duplicate entries
Added test.
sql/ha_heap.cc:
Bug#24985 - UTF8 ENUM primary key on MEMORY using BTREE
causes incorrect duplicate entries
Set key segment charset to my_charset_bin for ENUM and SET
columns.
to 0 causes wrong (large) length to be read
from the row in _mi_calc_blob_length() when
storing NULL values in (e.g) POINT columns.
This large length is then used to allocate
a block of memory that (on some OSes) causes
trouble.
Fixed by calling the base class's
Field_blob::reset() from Field_geom::reset()
that is called when storing a NULL value into
the column.
mysql-test/r/gis.result:
Bug #27164: test case
mysql-test/t/gis.test:
Bug #27164: test case
sql/field.h:
Bug #27164: not reseting the data pointer
to 0 causes wrong (large) length to be read
from the row in _mi_calc_blob_length() when
storing NULL values in (e.g) POINT columns.
This large length is then used to allocate
a block of memory that (on some OSes) causes
trouble.
fixed differently: wake up select_thread with THR_SERVER_ALARM instead
mysys/thr_alarm.c:
reverted linuxthreads thr_client_alarm fix (not future-proof)
(in thr_alarm.cc it happened too late).
mysys/thr_alarm.c:
move thr_client_alarm initialization to mysqld.cc
(here it happened too late)
sql/mysqld.cc:
move thr_client_alarm initialization to mysqld.cc
(in thr_alarm.cc it happened too late).
moved thr_kill_signal initialization to init_signals()
fix for cast( AS DATETIME) + 0 operation.
I just implemented Item_datetime_typecast::val() method
as it is usually done in other classes.
Should be fixed more radically in 5.0
mysql-test/r/type_datetime.result:
result added
mysql-test/t/type_datetime.test:
testcase
sql/item_timefunc.h:
added double conversion to Item_datetime_typecast
- Problem: data separators were copied to a fixed-size buffer
on the stack; memcpy was used, without bounds checking; a
server crash could result if long FIELDS ENCLOSED BY, etc.,
was given
- Fix: write the separators directly, instead of copying to
a buffer first (in select_export::send_data())
sql/sql_class.cc:
In select_export::send_data(), write data separators
directly, instead of copying into a fixed-size memory
buffer before writing. This avoids a buffer overflow
when very large separators are specified.
Using a MEMORY table BTREE index for scanning for updatable rows
could lead to an infinite loop.
Everytime a key was inserted into a btree index, the position
in the index scan was cleared. The search started from the
beginning and found the same key again.
Now we do not clear the position on key insert an more.
heap/hp_write.c:
Bug#26996 - Update of a Field in a Memory Table ends with wrong result
Removed the index-scan-breaking nulling of last_pos.
The comment behind this line ("For heap_rnext/heap_rprev")
was misleading. It should have been "Breaks heap_rnext/heap_rprev".
mysql-test/r/heap_btree.result:
Bug#26996 - Update of a Field in a Memory Table ends with wrong result
Added test result.
mysql-test/t/heap_btree.test:
Bug#26996 - Update of a Field in a Memory Table ends with wrong result
Added test.
when index is used
When the table contained TEXT columns with empty contents
('', zero length, but not NULL) _and_ strings starting with
control characters like tabulator or newline, the empty values
were not found in a "records in range" estimate. Hence count(*)
missed these records.
The reason was a different set of search flags used for key
insert and key range estimation.
I decided to fix the set of flags used in range estimation.
Otherwise millions of databases around the world would require
a repair after an upgrade.
The consequence is that the manual must be fixed, which claims
that TEXT columns are compared with "end space padding". This
is true for CHAR/VARCHAR but wrong for TEXT. See also bug 21335.
myisam/mi_range.c:
Bug#26231 - select count(*) on myisam table returns wrong value
when index is used
Added SEARCH_UPDATE to the search flags so that it compares
like write/update/delete operations do. Only so it expects
the keys at the place where they have been inserted.
myisam/mi_search.c:
Bug#26231 - select count(*) on myisam table returns wrong value
when index is used
Added some comments to explain how _mi_get_binary_pack_key()
works.
mysql-test/r/myisam.result:
Bug#26231 - select count(*) on myisam table returns wrong value
when index is used
Added a test.
mysql-test/t/myisam.test:
Bug#26231 - select count(*) on myisam table returns wrong value
when index is used
Added test result.
TABLE ... WRITE".
CPU hogging occured when connection which had to wait for table lock was
serviced by thread which previously serviced connection that was killed
(note that connections can reuse threads if thread cache is enabled).
One possible scenario which exposed this problem was when thread which
provided binlog dump to replication slave was implicitly/automatically
killed when the same slave reconnected and started pulling data through
different thread/connection.
In 5.* versions memory hogging was added to CPU hogging. Moreover in
those versions the problem also occured when one killed particular query
in connection (using KILL QUERY) and later this connection had to wait for
some table lock.
This problem was caused by the fact that thread-specific mysys_var::abort
variable, which indicates that waiting operations on mysys layer should
be aborted (this includes waiting for table locks), was set by kill
operation but was never reset back. So this value was "inherited" by the
following statements or even other connections (which reused the same
physical thread). Such discrepancy between this variable and THD::killed
flag broke logic on SQL-layer and caused CPU and memory hogging.
This patch tries to fix this problem by properly resetting this member.
There is no test-case associated with this patch since it is hard to test
for memory/CPU hogging conditions in our test-suite.
sql/mysqld.cc:
We should not forget to reset THD::mysys_var::abort after kill operation
if we are going to use thread to which this operation was applied for
handling of other connections.
