revision-id: 31081593aabb116b6d8f86b6c7e76126edb392b4 (mariadb-10.1.35-38-g31081593aab) parent(s): b0026e33af8fc3b25a42099c096a84591fd550e2 3a4242fd57b3a2235d2478ed080941b67a82ad1b author: Oleksandr Byelkin committer: Oleksandr Byelkin timestamp: 2018-09-06 22:45:19 +0200 message: Merge branch '11.0' into 10.1 mysql-test/extra/rpl_tests/rpl_foreign_key.test | 60 - mysql-test/mysql-test-run.pl | 2 +- mysql-test/r/gis.result | 16 + mysql-test/r/group_min_max.result | 28 + mysql-test/r/join.result | 6 +- mysql-test/r/selectivity.result | 44 +- mysql-test/r/selectivity_innodb.result | 44 +- mysql-test/r/sp.result | 17 + mysql-test/r/stat_tables.result | 13 + mysql-test/r/stat_tables_innodb.result | 13 + mysql-test/suite/innodb/r/foreign-keys.result | 73 + mysql-test/suite/innodb/r/foreign_key.result | 19 + mysql-test/suite/innodb/t/foreign-keys.test | 87 + mysql-test/suite/innodb/t/foreign_key.test | 25 + mysql-test/suite/maria/create.result | 33 + mysql-test/suite/maria/create.test | 42 + mysql-test/suite/maria/maria.result | 4 + mysql-test/suite/maria/maria.test | 10 + .../suite/rpl/r/rpl_foreign_key_innodb.result | 3 +- mysql-test/suite/rpl/t/rpl_foreign_key_innodb.test | 62 +- mysql-test/t/gis.test | 15 + mysql-test/t/group_min_max.test | 17 + mysql-test/t/join.test | 3 +- mysql-test/t/selectivity.test | 36 + mysql-test/t/sp.test | 21 + mysql-test/t/stat_tables.test | 12 + scripts/mysql_install_db.sh | 2 +- sql/field.cc | 17 +- sql/item.cc | 10 +- sql/lex.h | 6 +- sql/opt_range.cc | 27 +- sql/sp_head.cc | 33 +- sql/sql_base.cc | 79 +- sql/sql_base.h | 2 + sql/sql_class.cc | 3 +- sql/sql_class.h | 2 - sql/sql_lex.h | 4 +- sql/sql_select.cc | 2 +- sql/sql_show.cc | 9 +- sql/sql_statistics.cc | 3 + sql/sql_statistics.h | 29 +- sql/sql_table.cc | 62 +- sql/sql_yacc.yy | 38 +- sql/table.cc | 21 + sql/table.h | 59 +- sql/table_cache.cc | 2 - storage/connect/javaconn.cpp | 6 +- storage/connect/jdbconn.cpp | 10 +- storage/connect/jmgoconn.cpp | 4 +- storage/connect/tabjmg.cpp | 2 +- storage/innobase/handler/ha_innodb.cc | 36 +- storage/innobase/handler/handler0alter.cc | 20 +- storage/maria/ma_blockrec.c | 14 +- storage/mroonga/ha_mroonga.cpp | 7 - storage/mroonga/ha_mroonga.hpp | 4 - storage/tokudb/CMakeLists.txt | 8 +- storage/tokudb/PerconaFT/CMakeLists.txt | 3 +- .../cmake_modules/TokuSetupCompiler.cmake | 3 + .../tokudb/PerconaFT/ft/cachetable/cachetable.cc | 21 +- .../tokudb/PerconaFT/ft/cachetable/cachetable.h | 8 +- .../tokudb/PerconaFT/ft/ft-cachetable-wrappers.cc | 3 - storage/tokudb/PerconaFT/ft/ft-test-helpers.cc | 3 - storage/tokudb/PerconaFT/ft/ft.h | 3 + storage/tokudb/PerconaFT/ft/node.cc | 2 + .../PerconaFT/ft/serialize/block_allocator.cc | 2 +- .../tokudb/PerconaFT/ft/tests/cachetable-4357.cc | 4 - .../tokudb/PerconaFT/ft/tests/cachetable-4365.cc | 4 - .../tokudb/PerconaFT/ft/tests/cachetable-5097.cc | 6 +- .../tokudb/PerconaFT/ft/tests/cachetable-5978-2.cc | 7 +- .../tokudb/PerconaFT/ft/tests/cachetable-5978.cc | 13 +- .../PerconaFT/ft/tests/cachetable-all-write.cc | 5 +- .../ft/tests/cachetable-checkpoint-pending.cc | 8 +- .../ft/tests/cachetable-checkpoint-pinned-nodes.cc | 6 +- .../ft/tests/cachetable-cleaner-checkpoint.cc | 5 +- .../ft/tests/cachetable-cleaner-checkpoint2.cc | 5 +- .../cachetable-cleaner-thread-attrs-accumulate.cc | 8 +- .../cachetable-cleaner-thread-everything-pinned.cc | 5 +- ...etable-cleaner-thread-nothing-needs-flushing.cc | 5 +- .../cachetable-cleaner-thread-same-fullhash.cc | 7 +- .../ft/tests/cachetable-cleaner-thread-simple.cc | 7 +- .../ft/tests/cachetable-clock-eviction.cc | 9 +- .../ft/tests/cachetable-clock-eviction2.cc | 9 +- .../ft/tests/cachetable-clock-eviction3.cc | 9 +- .../ft/tests/cachetable-clock-eviction4.cc | 9 +- .../ft/tests/cachetable-clone-checkpoint.cc | 5 +- .../cachetable-clone-partial-fetch-pinned-node.cc | 7 +- .../ft/tests/cachetable-clone-partial-fetch.cc | 7 +- .../ft/tests/cachetable-clone-pin-nonblocking.cc | 7 +- .../ft/tests/cachetable-clone-unpin-remove.cc | 5 +- .../ft/tests/cachetable-eviction-close-test.cc | 4 - .../ft/tests/cachetable-eviction-close-test2.cc | 4 - .../ft/tests/cachetable-eviction-getandpin-test.cc | 14 +- .../tests/cachetable-eviction-getandpin-test2.cc | 12 +- .../ft/tests/cachetable-fetch-inducing-evictor.cc | 15 +- .../ft/tests/cachetable-flush-during-cleaner.cc | 3 +- .../ft/tests/cachetable-getandpin-test.cc | 8 +- .../cachetable-kibbutz_and_flush_cachefile.cc | 3 +- .../PerconaFT/ft/tests/cachetable-partial-fetch.cc | 18 +- .../ft/tests/cachetable-pin-checkpoint.cc | 6 - .../cachetable-pin-nonblocking-checkpoint-clean.cc | 9 +- .../ft/tests/cachetable-prefetch-close-test.cc | 2 - .../ft/tests/cachetable-prefetch-getandpin-test.cc | 12 +- .../ft/tests/cachetable-put-checkpoint.cc | 9 - .../PerconaFT/ft/tests/cachetable-simple-clone.cc | 7 +- .../PerconaFT/ft/tests/cachetable-simple-clone2.cc | 5 +- .../PerconaFT/ft/tests/cachetable-simple-close.cc | 20 +- .../ft/tests/cachetable-simple-maybe-get-pin.cc | 3 +- .../ft/tests/cachetable-simple-pin-cheap.cc | 9 +- .../ft/tests/cachetable-simple-pin-dep-nodes.cc | 8 +- .../cachetable-simple-pin-nonblocking-cheap.cc | 19 +- .../ft/tests/cachetable-simple-pin-nonblocking.cc | 13 +- .../PerconaFT/ft/tests/cachetable-simple-pin.cc | 11 +- .../ft/tests/cachetable-simple-put-dep-nodes.cc | 6 +- .../cachetable-simple-read-pin-nonblocking.cc | 13 +- .../ft/tests/cachetable-simple-read-pin.cc | 13 +- .../cachetable-simple-unpin-remove-checkpoint.cc | 7 +- .../PerconaFT/ft/tests/cachetable-simple-verify.cc | 5 +- .../tokudb/PerconaFT/ft/tests/cachetable-test.cc | 22 +- .../ft/tests/cachetable-unpin-and-remove-test.cc | 4 +- .../cachetable-unpin-remove-and-checkpoint.cc | 6 +- .../PerconaFT/ft/tests/cachetable-unpin-test.cc | 2 - storage/tokudb/PerconaFT/ft/tests/test-TDB2-pe.cc | 178 + storage/tokudb/PerconaFT/ft/tests/test-TDB89.cc | 208 + storage/tokudb/PerconaFT/ft/txn/rollback-apply.cc | 2 + storage/tokudb/PerconaFT/ft/txn/rollback.cc | 2 +- storage/tokudb/PerconaFT/ftcxx/malloc_utils.cpp | 2 +- storage/tokudb/PerconaFT/ftcxx/malloc_utils.hpp | 2 +- storage/tokudb/PerconaFT/portability/memory.cc | 14 +- storage/tokudb/PerconaFT/portability/toku_assert.h | 2 +- .../tokudb/PerconaFT/portability/toku_debug_sync.h | 3 +- .../PerconaFT/portability/toku_instr_mysql.cc | 6 +- .../PerconaFT/portability/toku_instrumentation.h | 6 +- .../PerconaFT/portability/toku_portability.h | 2 +- .../tokudb/PerconaFT/portability/toku_race_tools.h | 2 +- storage/tokudb/PerconaFT/src/tests/get_last_key.cc | 32 +- storage/tokudb/PerconaFT/src/ydb.cc | 3 + storage/tokudb/PerconaFT/src/ydb_lib.cc | 2 +- storage/tokudb/PerconaFT/util/dmt.cc | 4 +- storage/tokudb/PerconaFT/util/minicron.cc | 3 +- storage/tokudb/PerconaFT/util/scoped_malloc.cc | 2 +- .../util/tests/minicron-change-period-data-race.cc | 66 + storage/tokudb/ha_tokudb.cc | 325 +- storage/tokudb/ha_tokudb.h | 92 +- storage/tokudb/ha_tokudb_admin.cc | 8 +- storage/tokudb/ha_tokudb_alter_55.cc | 4 + storage/tokudb/ha_tokudb_alter_56.cc | 265 +- storage/tokudb/ha_tokudb_alter_common.cc | 6 +- storage/tokudb/ha_tokudb_update.cc | 96 +- storage/tokudb/hatoku_cmp.cc | 33 +- storage/tokudb/hatoku_cmp.h | 14 +- storage/tokudb/hatoku_defines.h | 51 +- storage/tokudb/hatoku_hton.cc | 183 +- storage/tokudb/hatoku_hton.h | 25 +- storage/tokudb/mysql-test/rpl/disabled.def | 1 + .../r/rpl_mixed_replace_into.result | 0 .../rpl/r/rpl_parallel_tokudb_delete_pk.result | 5 - ...pl_parallel_tokudb_update_pk_uc0_lookup0.result | 5 - .../rpl/r/rpl_parallel_tokudb_write_pk.result | 2 - .../r/rpl_row_replace_into.result | 0 .../r/rpl_stmt_replace_into.result | 0 .../mysql-test/rpl/r/rpl_xa_interleave.result | 59 + .../t/rpl_mixed_replace_into.test | 0 .../t/rpl_row_replace_into.test | 0 .../t/rpl_stmt_replace_into.test | 0 .../tokudb/mysql-test/rpl/t/rpl_xa_interleave.test | 103 + .../tokudb/include/fast_update_gen_footer.inc | 2 + .../include/fast_update_gen_footer_silent.inc | 9 + .../tokudb/include/fast_update_gen_header.inc | 6 + .../mysql-test/tokudb/include/fast_update_int.inc | 48 + .../tokudb/include/fast_upsert_gen_header.inc | 6 + .../mysql-test/tokudb/include/fast_upsert_int.inc | 19 + .../tokudb/mysql-test/tokudb/include/have_mrr.inc | 0 .../tokudb/include/setup_fast_update_upsert.inc | 8 + .../tokudb/mysql-test/tokudb/r/compressions.result | 11 + .../tokudb/r/fast_update_binlog_mixed.result | 225 +- .../tokudb/r/fast_update_binlog_row.result | 19 +- .../tokudb/r/fast_update_binlog_statement.result | 222 +- .../mysql-test/tokudb/r/fast_update_blobs.result | 18253 +--------- .../r/fast_update_blobs_fixed_varchar.result | 33026 ------------------ .../tokudb/r/fast_update_blobs_with_varchar.result | 32771 +----------------- .../mysql-test/tokudb/r/fast_update_char.result | 60 +- .../tokudb/r/fast_update_deadlock.result | 19 +- .../tokudb/r/fast_update_decr_floor.result | 314 +- .../r/fast_update_disable_slow_update.result | 7 - .../mysql-test/tokudb/r/fast_update_error.result | 12 +- .../mysql-test/tokudb/r/fast_update_int.result | 562 +- .../tokudb/r/fast_update_int_bounds.result | 52 +- .../mysql-test/tokudb/r/fast_update_key.result | 54 +- .../mysql-test/tokudb/r/fast_update_sqlmode.result | 21 +- .../tokudb/r/fast_update_uint_bounds.result | 36 +- .../mysql-test/tokudb/r/fast_update_varchar.result | 13575 +------- .../mysql-test/tokudb/r/fast_upsert_bin_pad.result | Bin 659 -> 738 bytes .../mysql-test/tokudb/r/fast_upsert_char.result | 24 +- .../tokudb/r/fast_upsert_deadlock.result | 19 +- .../mysql-test/tokudb/r/fast_upsert_int.result | 428 +- .../mysql-test/tokudb/r/fast_upsert_key.result | 43 +- .../mysql-test/tokudb/r/fast_upsert_sqlmode.result | 23 +- .../mysql-test/tokudb/r/fast_upsert_values.result | 18 +- .../tokudb/mysql-test/tokudb/r/tokudb_mrr.result | 326 + storage/tokudb/mysql-test/tokudb/suite.pm | 6 + .../tokudb/mysql-test/tokudb/t/compressions.test | 68 + storage/tokudb/mysql-test/tokudb/t/disabled.def | 24 - .../tokudb/t/fast_update_binlog_mixed-master.opt | 2 + .../tokudb/t/fast_update_binlog_mixed.test | 15 +- .../tokudb/t/fast_update_binlog_row-master.opt | 2 + .../tokudb/t/fast_update_binlog_row.test | 19 +- .../t/fast_update_binlog_statement-master.opt | 2 + .../tokudb/t/fast_update_binlog_statement.test | 15 +- .../mysql-test/tokudb/t/fast_update_blobs.py | 57 - .../mysql-test/tokudb/t/fast_update_blobs.test | 18575 +---------- .../tokudb/t/fast_update_blobs_fixed_varchar.py | 63 - .../tokudb/t/fast_update_blobs_fixed_varchar.test | 33287 ------------------- .../tokudb/t/fast_update_blobs_with_varchar.py | 62 - .../tokudb/t/fast_update_blobs_with_varchar.test | 33115 +----------------- .../mysql-test/tokudb/t/fast_update_char.test | 66 +- .../mysql-test/tokudb/t/fast_update_deadlock.test | 21 +- .../mysql-test/tokudb/t/fast_update_decr_floor.py | 58 - .../tokudb/t/fast_update_decr_floor.test | 409 +- .../tokudb/t/fast_update_disable_slow_update.test | 17 - .../mysql-test/tokudb/t/fast_update_error.test | 16 +- .../tokudb/mysql-test/tokudb/t/fast_update_int.py | 77 - .../mysql-test/tokudb/t/fast_update_int.test | 682 +- .../tokudb/t/fast_update_int_bounds.test | 55 +- .../mysql-test/tokudb/t/fast_update_key.test | 63 +- .../mysql-test/tokudb/t/fast_update_sqlmode.test | 25 +- .../tokudb/t/fast_update_uint_bounds.test | 42 +- .../mysql-test/tokudb/t/fast_update_varchar.py | 63 - .../mysql-test/tokudb/t/fast_update_varchar.test | 7390 +--- .../mysql-test/tokudb/t/fast_upsert_bin_pad.test | 19 +- .../mysql-test/tokudb/t/fast_upsert_char.test | 27 +- .../mysql-test/tokudb/t/fast_upsert_deadlock.test | 22 +- .../tokudb/mysql-test/tokudb/t/fast_upsert_int.py | 50 - .../mysql-test/tokudb/t/fast_upsert_int.test | 486 +- .../mysql-test/tokudb/t/fast_upsert_key.test | 46 +- .../mysql-test/tokudb/t/fast_upsert_sqlmode.test | 27 +- .../mysql-test/tokudb/t/fast_upsert_values.test | 21 +- storage/tokudb/mysql-test/tokudb/t/tokudb_mrr.test | 73 + .../tokudb/mysql-test/tokudb_bugs/r/PS-3773.result | 8 + .../r/alter_table_comment_rebuild_data.result | 177 + .../tokudb/mysql-test/tokudb_bugs/t/PS-3773.test | 26 + .../t/alter_table_comment_rebuild_data.test | 188 + storage/tokudb/tokudb_debug.h | 5 - storage/tokudb/tokudb_dir_cmd.h | 6 +- storage/tokudb/tokudb_information_schema.cc | 74 +- storage/tokudb/tokudb_sysvars.cc | 122 +- storage/tokudb/tokudb_sysvars.h | 16 +- storage/tokudb/tokudb_thread.h | 26 +- storage/tokudb/tokudb_update_fun.cc | 230 +- storage/xtradb/handler/ha_innodb.cc | 36 +- storage/xtradb/handler/handler0alter.cc | 20 +- 250 files changed, 4958 insertions(+), 194807 deletions(-) diff --cc mysql-test/r/gis.result index 76f4f6accdb,fc69c13516f..f89cceb3664 --- a/mysql-test/r/gis.result +++ b/mysql-test/r/gis.result @@@ -1733,131 -1659,21 +1733,147 @@@ c DROP TABLE t1; SET optimizer_switch=@save_optimizer_switch; # + # MDEV-16995: ER_CANT_CREATE_GEOMETRY_OBJECT encountered for a query with + # optimizer_use_condition_selectivity>=3 + # + CREATE TABLE t1 (a POINT); + INSERT INTO t1 VALUES (POINT(1,1)),(POINT(1,2)),(POINT(1,3)); + set @save_use_stat_tables= @@use_stat_tables; + set @save_optimizer_use_condition_selectivity= @@optimizer_use_condition_selectivity; + set @@use_stat_tables= PREFERABLY; + set @@optimizer_use_condition_selectivity=3; + SELECT COUNT(*) FROM t1 WHERE a IN ('test','test1'); + COUNT(*) + 0 + set @@use_stat_tables= @save_use_stat_tables; + set @@optimizer_use_condition_selectivity= @save_optimizer_use_condition_selectivity; + drop table t1; + # # End 10.0 tests # +SHOW CREATE TABLE information_schema.geometry_columns; +Table Create Table +GEOMETRY_COLUMNS CREATE TEMPORARY TABLE `GEOMETRY_COLUMNS` ( + `F_TABLE_CATALOG` varchar(512) NOT NULL DEFAULT '', + `F_TABLE_SCHEMA` varchar(64) NOT NULL DEFAULT '', + `F_TABLE_NAME` varchar(64) NOT NULL DEFAULT '', + `F_GEOMETRY_COLUMN` varchar(64) NOT NULL DEFAULT '', + `G_TABLE_CATALOG` varchar(512) NOT NULL DEFAULT '', + `G_TABLE_SCHEMA` varchar(64) NOT NULL DEFAULT '', + `G_TABLE_NAME` varchar(64) NOT NULL DEFAULT '', + `G_GEOMETRY_COLUMN` varchar(64) NOT NULL DEFAULT '', + `STORAGE_TYPE` tinyint(2) NOT NULL DEFAULT '0', + `GEOMETRY_TYPE` int(7) NOT NULL DEFAULT '0', + `COORD_DIMENSION` tinyint(2) NOT NULL DEFAULT '0', + `MAX_PPR` tinyint(2) NOT NULL DEFAULT '0', + `SRID` smallint(5) NOT NULL DEFAULT '0' +) ENGINE=MEMORY DEFAULT CHARSET=utf8 +SHOW CREATE TABLE information_schema.spatial_ref_sys; +Table Create Table +SPATIAL_REF_SYS CREATE TEMPORARY TABLE `SPATIAL_REF_SYS` ( + `SRID` smallint(5) NOT NULL DEFAULT '0', + `AUTH_NAME` varchar(512) NOT NULL DEFAULT '', + `AUTH_SRID` int(5) NOT NULL DEFAULT '0', + `SRTEXT` varchar(2048) NOT NULL DEFAULT '' +) ENGINE=MEMORY DEFAULT CHARSET=utf8 +create table t1(g GEOMETRY, pt POINT); +create table t2(g LINESTRING, pl POLYGON); +select * from information_schema.geometry_columns where f_table_schema='test'; +F_TABLE_CATALOG F_TABLE_SCHEMA F_TABLE_NAME F_GEOMETRY_COLUMN G_TABLE_CATALOG G_TABLE_SCHEMA G_TABLE_NAME G_GEOMETRY_COLUMN STORAGE_TYPE GEOMETRY_TYPE COORD_DIMENSION MAX_PPR SRID +def test t1 def test t1 g 1 0 2 0 0 +def test t1 def test t1 pt 1 1 2 0 0 +def test t2 def test t2 g 1 2 2 0 0 +def test t2 def test t2 pl 1 3 2 0 0 +drop table t1, t2; +10.1 tests +create table t1(g GEOMETRY(9,4) REF_SYSTEM_ID=101, pt POINT(8,2), pg GEOMETRY REF_SYSTEM_ID=102); +SELECT SRID from information_schema.geometry_columns WHERE f_table_schema='test' and G_TABLE_NAME='t1'; +SRID +101 +0 +102 +drop table t1; +# Expect an int(1) column to be created +CREATE TABLE t1 AS SELECT CONTAINS(NULL, NULL); +SHOW CREATE TABLE t1; +Table Create Table +t1 CREATE TABLE `t1` ( + `CONTAINS(NULL, NULL)` int(1) DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 +DROP TABLE t1; +# +# MDEV-7334 valgrind warning "unitialized bytes" in 10.1. +# +CREATE TABLE t1 ( +gp point, +ln linestring, +pg polygon, +mp multipoint, +mln multilinestring, +mpg multipolygon, +gc geometrycollection, +gm geometry +); +ALTER TABLE t1 ADD fid INT NOT NULL; +select SRID from information_schema.geometry_columns where F_TABLE_NAME='t1'; +SRID +0 +0 +0 +0 +0 +0 +0 +0 +drop table t1; +# +# MDEV-7510 GIS: IsRing returns false for a primitive triangle. +# +select ST_IsRing(ST_LineFromText('LINESTRING(0 0,0 10,10 10,0 0)')); +ST_IsRing(ST_LineFromText('LINESTRING(0 0,0 10,10 10,0 0)')) +1 +select ST_IsRing(ST_LineFromText('LINESTRING(0 0,0 10,10 10,-10 -10, 0 -10, 0 0)')); +ST_IsRing(ST_LineFromText('LINESTRING(0 0,0 10,10 10,-10 -10, 0 -10, 0 0)')) +0 +# +# MDEV-7514 GIS: PointOnSurface returns NULL instead of the point. +# +SELECT ST_GEOMETRYTYPE(ST_PointOnSurface(ST_PolyFromText('POLYGON((-70.916 42.1002,-70.9468 42.0946,-70.9754 42.0875,-70.9749 42.0879,-70.9759 42.0897,-70.916 42.1002))'))); +ST_GEOMETRYTYPE(ST_PointOnSurface(ST_PolyFromText('POLYGON((-70.916 42.1002,-70.9468 42.0946,-70.9754 42.0875,-70.9749 42.0879,-70.9759 42.0897,-70.916 42.1002))'))) +NULL +# +# MDEV-7529 GIS: ST_Relate returns unexpected results for POINT relations +# +select ST_Relate(ST_PointFromText('POINT(0 0)'),ST_PointFromText('POINT(0 0)'),'T*F**FFF*') AS equals; +equals +1 +select ST_Relate(ST_PointFromText('POINT(0 0)'),ST_PointFromText('POINT(0 0)'),'T*****FF*') AS contains; +contains +1 +select ST_Relate(ST_PointFromText('POINT(0 0)'),ST_PointFromText('POINT(0 0)'),'T*F**F***') AS within; +within +1 +select ST_Relate(ST_PointFromText('POINT(0 0)'),ST_PointFromText('POINT(1 1)'),'FF*FF****') as disjoint; +disjoint +1 +select ST_Relate(ST_PointFromText('POINT(0 0)'),ST_PointFromText('POINT(0 0)'),'FF*FF****') as disjoint; +disjoint +0 +# +# MDEV-7528 GIS: Functions return NULL instead of specified -1 for NULL arguments. +# +select ST_IsRing(NULL); +ST_IsRing(NULL) +-1 +# +# MDEV-8675 Different results of GIS functions on NULL vs NOT NULL columns +# +CREATE TABLE t1 (g1 GEOMETRY NOT NULL,g2 GEOMETRY NULL); +CREATE TABLE t2 AS SELECT WITHIN(g1,g1) as w1,WITHIN(g2,g2) AS w2 FROM t1; +SHOW CREATE TABLE t2; +Table Create Table +t2 CREATE TABLE `t2` ( + `w1` int(1) DEFAULT NULL, + `w2` int(1) DEFAULT NULL +) ENGINE=MyISAM DEFAULT CHARSET=latin1 +DROP TABLE t1,t2; diff --cc mysql-test/r/group_min_max.result index ec3f4d9bf99,a4cb8da5cce..777780f8400 --- a/mysql-test/r/group_min_max.result +++ b/mysql-test/r/group_min_max.result @@@ -3733,182 -3733,33 +3733,210 @@@ id MIN(a) MAX(a 4 2001-01-04 2001-01-04 DROP TABLE t1; # + # MDEV-17039: Query plan changes when we use GROUP BY optimization with optimizer_use_condition_selectivity=4 + # and use_stat_tables= PREFERABLY + # + CREATE TABLE t1 (a INT, b INT,c INT DEFAULT 0, INDEX (a,b)); + INSERT INTO t1 (a, b) VALUES (1,1), (1,2), (1,3), (1,4), (1,5), + (2,2), (2,3), (2,1), (3,1), (4,1), (4,2), (4,3), (4,4), (4,5), (4,6); + set @save_optimizer_use_condition_selectivity= @@optimizer_use_condition_selectivity; + set @save_use_stat_tables= @@use_stat_tables; + set @@optimizer_use_condition_selectivity=4; + set @@use_stat_tables=PREFERABLY; + explain extended SELECT a FROM t1 AS t1_outer WHERE a IN (SELECT max(b) FROM t1 GROUP BY a); + id select_type table type possible_keys key key_len ref rows filtered Extra + 1 PRIMARY <subquery2> ALL distinct_key NULL NULL NULL 8 100.00 + 1 PRIMARY t1_outer ref a a 5 <subquery2>.max(b) 2 100.00 Using index + 2 MATERIALIZED t1 range NULL a 5 NULL 8 100.00 Using index for group-by + Warnings: + Note 1003 select `test`.`t1_outer`.`a` AS `a` from <materialize> (select max(`test`.`t1`.`b`) from `test`.`t1` group by `test`.`t1`.`a`) join `test`.`t1` `t1_outer` where (`test`.`t1_outer`.`a` = `<subquery2>`.`max(b)`) + set @@optimizer_use_condition_selectivity=@save_optimizer_use_condition_selectivity; + set @@use_stat_tables=@save_use_stat_tables; + explain extended SELECT a FROM t1 AS t1_outer WHERE a IN (SELECT max(b) FROM t1 GROUP BY a); + id select_type table type possible_keys key key_len ref rows filtered Extra + 1 PRIMARY <subquery2> ALL distinct_key NULL NULL NULL 8 100.00 + 1 PRIMARY t1_outer ref a a 5 <subquery2>.max(b) 2 100.00 Using index + 2 MATERIALIZED t1 range NULL a 5 NULL 8 100.00 Using index for group-by + Warnings: + Note 1003 select `test`.`t1_outer`.`a` AS `a` from <materialize> (select max(`test`.`t1`.`b`) from `test`.`t1` group by `test`.`t1`.`a`) join `test`.`t1` `t1_outer` where (`test`.`t1_outer`.`a` = `<subquery2>`.`max(b)`) + drop table t1; + # # End of 10.0 tests # +# +# Start of 10.1 tests +# +# +# MDEV-6990 GROUP_MIN_MAX optimization is not applied in some cases when it could +# +CREATE TABLE t1 (id INT NOT NULL, a DATE, KEY(id,a)) ENGINE=MyISAM; +INSERT INTO t1 VALUES (1,'2001-01-01'); +INSERT INTO t1 VALUES (1,'2001-01-02'); +INSERT INTO t1 VALUES (1,'2001-01-03'); +INSERT INTO t1 VALUES (1,'2001-01-04'); +INSERT INTO t1 VALUES (2,'2001-01-01'); +INSERT INTO t1 VALUES (2,'2001-01-02'); +INSERT INTO t1 VALUES (2,'2001-01-03'); +INSERT INTO t1 VALUES (2,'2001-01-04'); +INSERT INTO t1 VALUES (3,'2001-01-01'); +INSERT INTO t1 VALUES (3,'2001-01-02'); +INSERT INTO t1 VALUES (3,'2001-01-03'); +INSERT INTO t1 VALUES (3,'2001-01-04'); +INSERT INTO t1 VALUES (4,'2001-01-01'); +INSERT INTO t1 VALUES (4,'2001-01-02'); +INSERT INTO t1 VALUES (4,'2001-01-03'); +INSERT INTO t1 VALUES (4,'2001-01-04'); +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a>='2001-01-04' GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 range NULL id 8 NULL 9 Using where; Using index for group-by +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a>=20010104.0 GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 range NULL id 8 NULL 9 Using where; Using index for group-by +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a>=20010104e0 GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 range NULL id 8 NULL 9 Using where; Using index for group-by +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a>='2001-01-04' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a>=20010104.0 GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a>=20010104e0 GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +DROP TABLE t1; +# +# MDEV-8229 GROUP_MIN_MAX is erroneously applied for BETWEEN in some cases +# +SET NAMES latin1; +CREATE TABLE t1 (id INT NOT NULL, a VARCHAR(20)) ENGINE=MyISAM; +INSERT INTO t1 VALUES (1,'2001-01-01'); +INSERT INTO t1 VALUES (1,'2001-01-02'); +INSERT INTO t1 VALUES (1,'2001-01-03'); +INSERT INTO t1 VALUES (1,' 2001-01-04'); +INSERT INTO t1 VALUES (2,'2001-01-01'); +INSERT INTO t1 VALUES (2,'2001-01-02'); +INSERT INTO t1 VALUES (2,'2001-01-03'); +INSERT INTO t1 VALUES (2,' 2001-01-04'); +INSERT INTO t1 VALUES (3,'2001-01-01'); +INSERT INTO t1 VALUES (3,'2001-01-02'); +INSERT INTO t1 VALUES (3,'2001-01-03'); +INSERT INTO t1 VALUES (3,' 2001-01-04'); +INSERT INTO t1 VALUES (4,'2001-01-01'); +INSERT INTO t1 VALUES (4,'2001-01-02'); +INSERT INTO t1 VALUES (4,'2001-01-03'); +INSERT INTO t1 VALUES (4,' 2001-01-04'); +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN ' 2001-01-04' AND '2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-03 +2 2001-01-04 2001-01-03 +3 2001-01-04 2001-01-03 +4 2001-01-04 2001-01-03 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN '2001-01-04' AND '2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN DATE'2001-01-04' AND DATE'2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN DATE'2001-01-04' AND '2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN '2001-01-04' AND DATE'2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +ALTER TABLE t1 ADD KEY(id,a); +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN ' 2001-01-04' AND '2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-03 +2 2001-01-04 2001-01-03 +3 2001-01-04 2001-01-03 +4 2001-01-04 2001-01-03 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN '2001-01-04' AND '2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN DATE'2001-01-04' AND DATE'2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN DATE'2001-01-04' AND '2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN '2001-01-04' AND DATE'2001-01-05' GROUP BY id; +id MIN(a) MAX(a) +1 2001-01-04 2001-01-04 +2 2001-01-04 2001-01-04 +3 2001-01-04 2001-01-04 +4 2001-01-04 2001-01-04 +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN ' 2001-01-04' AND '2001-01-05' GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 range NULL id 27 NULL 9 Using where; Using index for group-by +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN '2001-01-04' AND '2001-01-05' GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 range NULL id 27 NULL 9 Using where; Using index for group-by +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN DATE'2001-01-04' AND DATE'2001-01-05' GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL id 27 NULL 16 Using where; Using index +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN DATE'2001-01-04' AND '2001-01-05' GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL id 27 NULL 16 Using where; Using index +EXPLAIN SELECT id,MIN(a),MAX(a) FROM t1 WHERE a BETWEEN '2001-01-04' AND DATE'2001-01-05' GROUP BY id; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index NULL id 27 NULL 16 Using where; Using index +DROP TABLE t1; +# +# MIN() optimization didn't work correctly with BETWEEN when using too +# long strings. +# +create table t1 (a varchar(10), key (a)) engine=myisam; +insert into t1 values("bar"),("Cafe"); +explain select min(a) from t1 where a between "a" and "Cafe2"; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Select tables optimized away +explain select min(a) from t1 where a between "a" and "Cafeeeeeeeeeeeeeeeeeeeeeeeeee"; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index a a 13 NULL 2 Using where; Using index +explain select min(a) from t1 where a between "abbbbbbbbbbbbbbbbbbbb" and "Cafe2"; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 index a a 13 NULL 2 Using where; Using index +drop table t1; +# +# MDEV-15433: Optimizer does not use group by optimization with distinct +# +CREATE TABLE t1 (id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, a INT NOT NULL, KEY(a)); +OPTIMIZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 optimize status OK +EXPLAIN SELECT DISTINCT a FROM t1; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 range NULL a 4 NULL 5 Using index for group-by +SELECT DISTINCT a FROM t1; +a +1 +2 +3 +4 +drop table t1; +# +# End of 10.1 tests +# diff --cc mysql-test/r/stat_tables.result index ceadb61feea,cd78d44462e..224c734118b --- a/mysql-test/r/stat_tables.result +++ b/mysql-test/r/stat_tables.result @@@ -578,71 -578,15 +578,84 @@@ db_name table_name column_name min_valu DROP TABLE t1; set use_stat_tables=@save_use_stat_tables; # + # MDEV-17023: Crash during read_histogram_for_table with optimizer_use_condition_selectivity set to 4 + # + set @save_optimizer_use_condition_selectivity=@@optimizer_use_condition_selectivity; + set @@optimizer_use_condition_selectivity=4; + set @@use_stat_tables= PREFERABLY; + explain + SELECT * FROM INFORMATION_SCHEMA.PROFILING, mysql.user; + id select_type table type possible_keys key key_len ref rows Extra + 1 SIMPLE PROFILING ALL NULL NULL NULL NULL NULL + 1 SIMPLE user ALL NULL NULL NULL NULL 4 Using join buffer (flat, BNL join) + set @@optimizer_use_condition_selectivity=@save_optimizer_use_condition_selectivity; + set use_stat_tables=@save_use_stat_tables; ++# +# MDEV-16757: manual addition of min/max statistics for BLOB +# +SET use_stat_tables= PREFERABLY; +CREATE TABLE t1 (pk INT PRIMARY KEY, t TEXT); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze Warning Engine-independent statistics are not collected for column 't' +test.t1 analyze status OK +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +test t1 pk 1 2 0.0000 4.0000 1.0000 0 NULL NULL +DELETE FROM mysql.column_stats +WHERE db_name='test' AND table_name='t1' AND column_name='t'; +INSERT INTO mysql.column_stats VALUES +('test','t1','t','bar','foo', 0.0, 3.0, 1.0, 0, NULL, NULL); +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +test t1 pk 1 2 0.0000 4.0000 1.0000 0 NULL NULL +test t1 t bar foo 0.0000 3.0000 1.0000 0 NULL NULL +SELECT pk FROM t1; +pk +1 +2 +DROP TABLE t1; +set use_stat_tables=@save_use_stat_tables; +# +# MDEV-16760: CREATE OR REPLACE TABLE after ANALYZE TABLE +# +SET use_stat_tables= PREFERABLY; +CREATE TABLE t1 (pk int PRIMARY KEY, c varchar(32)); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze status OK +SELECT * FROM t1; +pk c +1 foo +2 bar +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +test t1 pk 1 2 0.0000 4.0000 1.0000 0 NULL NULL +test t1 c bar foo 0.0000 3.0000 1.0000 0 NULL NULL +CREATE OR REPLACE TABLE t1 (pk int PRIMARY KEY, a char(7)); +SELECT * FROM t1; +pk a +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +DROP TABLE t1; +set use_stat_tables=@save_use_stat_tables; +# +# MDEV-16711:CREATE OR REPLACE TABLE introducing BLOB column +# +SET use_stat_tables= PREFERABLY; +CREATE TABLE t1 (pk INT PRIMARY KEY, t CHAR(60)); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze status OK +CREATE OR REPLACE TABLE t1 (pk INT PRIMARY KEY, t TEXT); +SELECT MAX(pk) FROM t1; +MAX(pk) +NULL +DROP TABLE t1; +set use_stat_tables=@save_use_stat_tables; diff --cc mysql-test/r/stat_tables_innodb.result index c5e7309861c,02a07fa8bbb..ba1dee3106d --- a/mysql-test/r/stat_tables_innodb.result +++ b/mysql-test/r/stat_tables_innodb.result @@@ -605,73 -605,17 +605,86 @@@ db_name table_name column_name min_valu DROP TABLE t1; set use_stat_tables=@save_use_stat_tables; # + # MDEV-17023: Crash during read_histogram_for_table with optimizer_use_condition_selectivity set to 4 + # + set @save_optimizer_use_condition_selectivity=@@optimizer_use_condition_selectivity; + set @@optimizer_use_condition_selectivity=4; + set @@use_stat_tables= PREFERABLY; + explain + SELECT * FROM INFORMATION_SCHEMA.PROFILING, mysql.user; + id select_type table type possible_keys key key_len ref rows Extra + 1 SIMPLE PROFILING ALL NULL NULL NULL NULL NULL + 1 SIMPLE user ALL NULL NULL NULL NULL 4 Using join buffer (flat, BNL join) + set @@optimizer_use_condition_selectivity=@save_optimizer_use_condition_selectivity; + set use_stat_tables=@save_use_stat_tables; ++# +# MDEV-16757: manual addition of min/max statistics for BLOB +# +SET use_stat_tables= PREFERABLY; +CREATE TABLE t1 (pk INT PRIMARY KEY, t TEXT); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze Warning Engine-independent statistics are not collected for column 't' +test.t1 analyze status OK +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +test t1 pk 1 2 0.0000 4.0000 1.0000 0 NULL NULL +DELETE FROM mysql.column_stats +WHERE db_name='test' AND table_name='t1' AND column_name='t'; +INSERT INTO mysql.column_stats VALUES +('test','t1','t','bar','foo', 0.0, 3.0, 1.0, 0, NULL, NULL); +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +test t1 pk 1 2 0.0000 4.0000 1.0000 0 NULL NULL +test t1 t bar foo 0.0000 3.0000 1.0000 0 NULL NULL +SELECT pk FROM t1; +pk +1 +2 +DROP TABLE t1; +set use_stat_tables=@save_use_stat_tables; +# +# MDEV-16760: CREATE OR REPLACE TABLE after ANALYZE TABLE +# +SET use_stat_tables= PREFERABLY; +CREATE TABLE t1 (pk int PRIMARY KEY, c varchar(32)); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze status OK +SELECT * FROM t1; +pk c +1 foo +2 bar +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +test t1 pk 1 2 0.0000 4.0000 1.0000 0 NULL NULL +test t1 c bar foo 0.0000 3.0000 1.0000 0 NULL NULL +CREATE OR REPLACE TABLE t1 (pk int PRIMARY KEY, a char(7)); +SELECT * FROM t1; +pk a +SELECT * FROM mysql.column_stats; +db_name table_name column_name min_value max_value nulls_ratio avg_length avg_frequency hist_size hist_type histogram +DROP TABLE t1; +set use_stat_tables=@save_use_stat_tables; +# +# MDEV-16711:CREATE OR REPLACE TABLE introducing BLOB column +# +SET use_stat_tables= PREFERABLY; +CREATE TABLE t1 (pk INT PRIMARY KEY, t CHAR(60)); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +Table Op Msg_type Msg_text +test.t1 analyze status Engine-independent statistics collected +test.t1 analyze status OK +CREATE OR REPLACE TABLE t1 (pk INT PRIMARY KEY, t TEXT); +SELECT MAX(pk) FROM t1; +MAX(pk) +NULL +DROP TABLE t1; +set use_stat_tables=@save_use_stat_tables; set optimizer_switch=@save_optimizer_switch_for_stat_tables_test; SET SESSION STORAGE_ENGINE=DEFAULT; diff --cc mysql-test/t/stat_tables.test index 2c9c1eca7d3,a0b2a22b946..c318cc5e75f --- a/mysql-test/t/stat_tables.test +++ b/mysql-test/t/stat_tables.test @@@ -357,64 -357,14 +357,76 @@@ DROP TABLE t1 set use_stat_tables=@save_use_stat_tables; + --echo # + --echo # MDEV-17023: Crash during read_histogram_for_table with optimizer_use_condition_selectivity set to 4 + --echo # + + set @save_optimizer_use_condition_selectivity=@@optimizer_use_condition_selectivity; + set @@optimizer_use_condition_selectivity=4; + set @@use_stat_tables= PREFERABLY; + explain + SELECT * FROM INFORMATION_SCHEMA.PROFILING, mysql.user; + set @@optimizer_use_condition_selectivity=@save_optimizer_use_condition_selectivity; + set use_stat_tables=@save_use_stat_tables; ++ +--echo # +--echo # MDEV-16757: manual addition of min/max statistics for BLOB +--echo # + +SET use_stat_tables= PREFERABLY; + +CREATE TABLE t1 (pk INT PRIMARY KEY, t TEXT); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +--sorted_result +SELECT * FROM mysql.column_stats; +DELETE FROM mysql.column_stats + WHERE db_name='test' AND table_name='t1' AND column_name='t'; +INSERT INTO mysql.column_stats VALUES + ('test','t1','t','bar','foo', 0.0, 3.0, 1.0, 0, NULL, NULL); +--sorted_result +SELECT * FROM mysql.column_stats; + +SELECT pk FROM t1; + +DROP TABLE t1; + +set use_stat_tables=@save_use_stat_tables; + +--echo # +--echo # MDEV-16760: CREATE OR REPLACE TABLE after ANALYZE TABLE +--echo # + +SET use_stat_tables= PREFERABLY; + +CREATE TABLE t1 (pk int PRIMARY KEY, c varchar(32)); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +SELECT * FROM t1; +SELECT * FROM mysql.column_stats; + +CREATE OR REPLACE TABLE t1 (pk int PRIMARY KEY, a char(7)); +SELECT * FROM t1; +SELECT * FROM mysql.column_stats; + +DROP TABLE t1; + +set use_stat_tables=@save_use_stat_tables; + + +--echo # +--echo # MDEV-16711:CREATE OR REPLACE TABLE introducing BLOB column +--echo # + +SET use_stat_tables= PREFERABLY; + +CREATE TABLE t1 (pk INT PRIMARY KEY, t CHAR(60)); +INSERT INTO t1 VALUES (1,'foo'),(2,'bar'); +ANALYZE TABLE t1; +CREATE OR REPLACE TABLE t1 (pk INT PRIMARY KEY, t TEXT); + +SELECT MAX(pk) FROM t1; + +DROP TABLE t1; + +set use_stat_tables=@save_use_stat_tables; diff --cc sql/lex.h index 6a1cb6653e9,868f19ed9c4..87c87d03fb3 --- a/sql/lex.h +++ b/sql/lex.h @@@ -633,8 -630,9 +633,8 @@@ static SYMBOL symbols[] = { "UPGRADE", SYM(UPGRADE_SYM)}, { "USAGE", SYM(USAGE)}, { "USE", SYM(USE_SYM)}, - { "USER", SYM(USER)}, + { "USER", SYM(USER_SYM)}, { "USER_RESOURCES", SYM(RESOURCES)}, - { "USER_STATISTICS", SYM(USER_STATS_SYM)}, { "USE_FRM", SYM(USE_FRM)}, { "USING", SYM(USING)}, { "UTC_DATE", SYM(UTC_DATE_SYM)}, diff --cc sql/opt_range.cc index 1e29efda0d1,0fd2cd267fc..d8ecf8077b8 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@@ -2913,7 -3510,18 +2922,18 @@@ bool calculate_cond_selectivity_for_tab table->cond_selectivity= 1.0; - if (!*cond || table_records == 0) + if (table_records == 0) + DBUG_RETURN(FALSE); + + QUICK_SELECT_I *quick; + if ((quick=table->reginfo.join_tab->quick) && + quick->get_type() == QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX) + { + table->cond_selectivity*= (quick->records/table_records); + DBUG_RETURN(FALSE); + } + - if (!cond) ++ if (!*cond) DBUG_RETURN(FALSE); if (table->pos_in_table_list->schema_table) diff --cc sql/sql_lex.h index 3b47b1d25c9,d58be8b336a..05e31c28277 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@@ -2590,10 -2479,11 +2590,10 @@@ public uint profile_query_id; uint profile_options; - uint uint_geom_type; uint grant, grant_tot_col, which_columns; enum Foreign_key::fk_match_opt fk_match_option; - enum Foreign_key::fk_option fk_update_opt; - enum Foreign_key::fk_option fk_delete_opt; + enum_fk_option fk_update_opt; + enum_fk_option fk_delete_opt; uint slave_thd_opt, start_transaction_opt; int nest_level; /* diff --cc sql/sql_table.cc index dc55754ff01,5d20ad3967c..da65f168d84 --- a/sql/sql_table.cc +++ b/sql/sql_table.cc @@@ -9136,13 -9066,62 +9142,63 @@@ bool mysql_alter_table(THD *thd,char *n { /* table is a normal table: Create temporary table in same directory */ /* Open our intermediate table. */ - new_table= open_table_uncached(thd, new_db_type, alter_ctx.get_tmp_path(), + new_table= open_table_uncached(thd, new_db_type, &frm, + alter_ctx.get_tmp_path(), alter_ctx.new_db, alter_ctx.tmp_name, true, true); + if (!new_table) + goto err_new_table_cleanup; + + /* + Normally, an attempt to modify an FK parent table will cause + FK children to be prelocked, so the table-being-altered cannot + be modified by a cascade FK action, because ALTER holds a lock + and prelocking will wait. + + But if a new FK is being added by this very ALTER, then the target + table is not locked yet (it's a temporary table). So, we have to + lock FK parents explicitly. + */ + if (alter_info->flags & Alter_info::ADD_FOREIGN_KEY) + { + List <FOREIGN_KEY_INFO> fk_list; + List_iterator<FOREIGN_KEY_INFO> fk_list_it(fk_list); + FOREIGN_KEY_INFO *fk; + + /* tables_opened can be > 1 only for MERGE tables */ + DBUG_ASSERT(tables_opened == 1); + DBUG_ASSERT(&table_list->next_global == thd->lex->query_tables_last); + + new_table->file->get_foreign_key_list(thd, &fk_list); + while ((fk= fk_list_it++)) + { + if (lower_case_table_names) + { + char buf[NAME_LEN]; + uint len; + strmake_buf(buf, fk->referenced_db->str); + len = my_casedn_str(files_charset_info, buf); + thd->make_lex_string(fk->referenced_db, buf, len); + strmake_buf(buf, fk->referenced_table->str); + len = my_casedn_str(files_charset_info, buf); + thd->make_lex_string(fk->referenced_table, buf, len); + } + if (table_already_fk_prelocked(table_list, fk->referenced_db, + fk->referenced_table, TL_READ_NO_INSERT)) + continue; + + TABLE_LIST *tl= (TABLE_LIST *) thd->alloc(sizeof(TABLE_LIST)); + tl->init_one_table_for_prelocking(fk->referenced_db->str, fk->referenced_db->length, + fk->referenced_table->str, fk->referenced_table->length, + NULL, TL_READ_NO_INSERT, false, NULL, 0, + &thd->lex->query_tables_last); + } + + if (open_tables(thd, &table_list->next_global, &tables_opened, 0, + &alter_prelocking_strategy)) + goto err_new_table_cleanup; + } } - if (!new_table) - goto err_new_table_cleanup; /* Note: In case of MERGE table, we do not attach children. We do not copy data for MERGE tables. Only the children have data. diff --cc sql/sql_yacc.yy index fcfc63439cb,1ae964ac7f8..6ae65e0c50f --- a/sql/sql_yacc.yy +++ b/sql/sql_yacc.yy @@@ -950,72 -899,60 +950,72 @@@ bool LEX::set_bincmp(CHARSET_INFO *cs, ulong ulong_num; ulonglong ulonglong_number; longlong longlong_number; + + /* structs */ LEX_STRING lex_str; - LEX_STRING *lex_str_ptr; LEX_SYMBOL symbol; - LEX_TYPE lex_type; - Table_ident *table; - char *simple_string; + struct sys_var_with_base variable; + struct { int vars, conds, hndlrs, curs; } spblock; + + /* pointers */ + CHARSET_INFO *charset; + Condition_information_item *cond_info_item; + DYNCALL_CREATE_DEF *dyncol_def; + Diagnostics_information *diag_info; Item *item; Item_num *item_num; + Item_param *item_param; + Key_part_spec *key_part; + LEX *lex; + LEX_STRING *lex_str_ptr; + LEX_USER *lex_user; + List<Condition_information_item> *cond_info_list; + List<DYNCALL_CREATE_DEF> *dyncol_def_list; List<Item> *item_list; + List<Statement_information_item> *stmt_info_list; List<String> *string_list; + Statement_information_item *stmt_info_item; String *string; - Key_part_spec *key_part; TABLE_LIST *table_list; - udf_func *udf; - LEX_USER *lex_user; - struct sys_var_with_base variable; - enum enum_var_type var_type; - Key::Keytype key_type; - enum ha_key_alg key_alg; - handlerton *db_type; - enum row_type row_type; - enum ha_rkey_function ha_rkey_mode; - enum enum_tx_isolation tx_isolation; - enum Cast_target cast_type; - enum Item_udftype udf_type; - enum ha_choice choice; - CHARSET_INFO *charset; - thr_lock_type lock_type; - interval_type interval, interval_time_st; - timestamp_type date_time_type; - st_select_lex *select_lex; + Table_ident *table; + char *simple_string; chooser_compare_func_creator boolfunc2creator; + class my_var *myvar; class sp_condition_value *spcondvalue; - struct { int vars, conds, hndlrs, curs; } spblock; - sp_name *spname; - LEX *lex; - sp_head *sphead; + class sp_head *sphead; + class sp_label *splabel; + class sp_name *spname; + class sp_variable *spvar; + handlerton *db_type; + st_select_lex *select_lex; struct p_elem_val *p_elem_value; - enum index_hint_type index_hint; - enum enum_filetype filetype; + udf_func *udf; + + /* enums */ + enum Cast_target cast_type; + enum Condition_information_item::Name cond_info_item_name; + enum enum_diag_condition_item_name diag_condition_item_name; + enum Diagnostics_information::Which_area diag_area; + enum Field::geometry_type geom_type; - enum Foreign_key::fk_option m_fk_option; + enum enum_fk_option m_fk_option; + enum Item_udftype udf_type; + enum Key::Keytype key_type; + enum Statement_information_item::Name stmt_info_item_name; + enum enum_field_types field_type; + enum enum_filetype filetype; + enum enum_tx_isolation tx_isolation; + enum enum_var_type var_type; enum enum_yes_no_unknown m_yes_no_unk; - Diag_condition_item_name diag_condition_item_name; - Diagnostics_information::Which_area diag_area; - Diagnostics_information *diag_info; - Statement_information_item *stmt_info_item; - Statement_information_item::Name stmt_info_item_name; - List<Statement_information_item> *stmt_info_list; - Condition_information_item *cond_info_item; - Condition_information_item::Name cond_info_item_name; - List<Condition_information_item> *cond_info_list; - DYNCALL_CREATE_DEF *dyncol_def; - List<DYNCALL_CREATE_DEF> *dyncol_def_list; - bool is_not_empty; + enum ha_choice choice; + enum ha_key_alg key_alg; + enum ha_rkey_function ha_rkey_mode; + enum index_hint_type index_hint; + enum interval_type interval, interval_time_st; + enum row_type row_type; + enum sp_variable::enum_mode spvar_mode; + enum thr_lock_type lock_type; + enum enum_mysql_timestamp_type date_time_type; + DDL_options_st object_ddl_options; } %{ @@@ -1651,7 -1584,8 +1651,7 @@@ bool my_yyoverflow(short **a, YYSTYPE * %token UPDATE_SYM /* SQL-2003-R */ %token UPGRADE_SYM %token USAGE /* SQL-2003-N */ - %token USER /* SQL-2003-R */ + %token USER_SYM /* SQL-2003-R */ -%token USER_STATS_SYM %token USE_FRM %token USE_SYM %token USING /* SQL-2003-R */ @@@ -2538,17 -2446,22 +2538,17 @@@ create Lex->create_view_algorithm= DTYPE_ALGORITHM_UNDEFINED; Lex->create_view_suid= TRUE; } - view_or_trigger_or_sp_or_event - { - if ($1 && Lex->sql_command != SQLCOM_CREATE_VIEW) - { - my_error(ER_WRONG_USAGE, MYF(0), "OR REPLACE", - "TRIGGERS / SP / EVENT"); - MYSQL_YYABORT; - } - } - | CREATE USER_SYM clear_privileges grant_list + view_or_trigger_or_sp_or_event { } - | create_or_replace USER opt_if_not_exists clear_privileges grant_list ++ | create_or_replace USER_SYM opt_if_not_exists clear_privileges grant_list { - Lex->sql_command = SQLCOM_CREATE_USER; + if (Lex->set_command_with_check(SQLCOM_CREATE_USER, $1 | $3)) + MYSQL_YYABORT; } - | CREATE ROLE_SYM clear_privileges role_list opt_with_admin + | create_or_replace ROLE_SYM opt_if_not_exists + clear_privileges role_list opt_with_admin { - Lex->sql_command = SQLCOM_CREATE_ROLE; + if (Lex->set_command_with_check(SQLCOM_CREATE_ROLE, $1 | $3)) + MYSQL_YYABORT; } | CREATE LOGFILE_SYM GROUP_SYM logfile_group_info { @@@ -2581,10 -2496,9 +2581,10 @@@ server_options_list ; server_option: - USER TEXT_STRING_sys + USER_SYM TEXT_STRING_sys { - Lex->server_options.username= $2.str; + MYSQL_YYABORT_UNLESS(Lex->server_options.username.str == 0); + Lex->server_options.username= $2; } | HOST_SYM TEXT_STRING_sys { @@@ -6736,13 -6784,17 +6736,13 @@@ opt_on_update_delete ; delete_option: - RESTRICT { $$= Foreign_key::FK_OPTION_RESTRICT; } - | CASCADE { $$= Foreign_key::FK_OPTION_CASCADE; } - | SET NULL_SYM { $$= Foreign_key::FK_OPTION_SET_NULL; } - | NO_SYM ACTION { $$= Foreign_key::FK_OPTION_NO_ACTION; } - | SET DEFAULT { $$= Foreign_key::FK_OPTION_DEFAULT; } + RESTRICT { $$= FK_OPTION_RESTRICT; } + | CASCADE { $$= FK_OPTION_CASCADE; } + | SET NULL_SYM { $$= FK_OPTION_SET_NULL; } + | NO_SYM ACTION { $$= FK_OPTION_NO_ACTION; } + | SET DEFAULT { $$= FK_OPTION_SET_DEFAULT; } ; -normal_key_type: - key_or_index { $$= Key::MULTIPLE; } - ; - constraint_key_type: PRIMARY_SYM KEY_SYM { $$= Key::PRIMARY; } | UNIQUE_SYM opt_key_or_index { $$= Key::UNIQUE; } @@@ -9383,9 -9470,9 +9383,9 @@@ function_call_keyword if ($$ == NULL) MYSQL_YYABORT; } - | USER '(' ')' + | USER_SYM '(' ')' { - $$= new (thd->mem_root) Item_func_user(); + $$= new (thd->mem_root) Item_func_user(thd); if ($$ == NULL) MYSQL_YYABORT; Lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION); @@@ -11635,17 -11752,21 +11635,17 @@@ drop { LEX *lex=Lex; if (lex->sphead) - { - my_error(ER_SP_NO_DROP_SP, MYF(0), "PROCEDURE"); - MYSQL_YYABORT; - } - lex->sql_command = SQLCOM_DROP_PROCEDURE; - lex->check_exists= $3; + my_yyabort_error((ER_SP_NO_DROP_SP, MYF(0), "PROCEDURE")); + lex->set_command(SQLCOM_DROP_PROCEDURE, $3); lex->spname= $4; } - | DROP USER opt_if_exists clear_privileges user_list - | DROP USER_SYM clear_privileges user_list ++ | DROP USER_SYM opt_if_exists clear_privileges user_list { - Lex->sql_command = SQLCOM_DROP_USER; + Lex->set_command(SQLCOM_DROP_USER, $3); } - | DROP ROLE_SYM clear_privileges role_list + | DROP ROLE_SYM opt_if_exists clear_privileges role_list { - Lex->sql_command = SQLCOM_DROP_ROLE; + Lex->set_command(SQLCOM_DROP_ROLE, $3); } | DROP VIEW_SYM opt_if_exists { @@@ -12945,11 -13016,11 +12945,11 @@@ kill_option kill_expr: expr { - Lex->value_list.push_front($$); + Lex->value_list.push_front($$, thd->mem_root); } - | USER user + | USER_SYM user { - Lex->users_list.push_back($2); + Lex->users_list.push_back($2, thd->mem_root); Lex->kill_type= KILL_TYPE_USER; } ; @@@ -14274,7 -14366,8 +14274,7 @@@ keyword_sp | UNDOFILE_SYM {} | UNKNOWN_SYM {} | UNTIL_SYM {} - | USER {} + | USER_SYM {} - | USER_STATS_SYM {} | USE_FRM {} | VARIABLES {} | VIEW_SYM {} diff --cc sql/table_cache.cc index b911252019f,bdb7914c32b..16a47b37417 --- a/sql/table_cache.cc +++ b/sql/table_cache.cc @@@ -49,12 -49,10 +49,11 @@@ */ #include "my_global.h" -#include "hash.h" +#include "lf.h" #include "table.h" #include "sql_base.h" - #include "sql_statistics.h" + /** Configuration. */ ulong tdc_size; /**< Table definition cache threshold for LRU eviction. */ ulong tc_size; /**< Table cache threshold for LRU eviction. */ @@@ -762,34 -852,34 +761,33 @@@ void tdc_release_share(TABLE_SHARE *sha DBUG_PRINT("enter", ("share: 0x%lx table: %s.%s ref_count: %u version: %lu", (ulong) share, share->db.str, share->table_name.str, - share->tdc.ref_count, share->tdc.version)); - DBUG_ASSERT(share->tdc.ref_count); + share->tdc->ref_count, share->tdc->version)); + DBUG_ASSERT(share->tdc->ref_count); - if (share->tdc.ref_count > 1) + if (share->tdc->ref_count > 1) { - share->tdc.ref_count--; + share->tdc->ref_count--; if (!share->is_view) - mysql_cond_broadcast(&share->tdc.COND_release); - mysql_mutex_unlock(&share->tdc.LOCK_table_share); + mysql_cond_broadcast(&share->tdc->COND_release); + mysql_mutex_unlock(&share->tdc->LOCK_table_share); DBUG_VOID_RETURN; } - mysql_mutex_unlock(&share->tdc.LOCK_table_share); + mysql_mutex_unlock(&share->tdc->LOCK_table_share); mysql_mutex_lock(&LOCK_unused_shares); - mysql_mutex_lock(&share->tdc.LOCK_table_share); - if (share->tdc.flushed) + mysql_mutex_lock(&share->tdc->LOCK_table_share); + if (--share->tdc->ref_count) { - mysql_mutex_unlock(&share->tdc.LOCK_table_share); + if (!share->is_view) + mysql_cond_broadcast(&share->tdc->COND_release); + mysql_mutex_unlock(&share->tdc->LOCK_table_share); mysql_mutex_unlock(&LOCK_unused_shares); - tdc_delete_share_from_hash(share); DBUG_VOID_RETURN; } - if (--share->tdc.ref_count) + if (share->tdc->flushed || tdc_records() > tdc_size) { - delete_stat_values_for_table_share(share); - if (!share->is_view) - mysql_cond_broadcast(&share->tdc.COND_release); - mysql_mutex_unlock(&share->tdc.LOCK_table_share); mysql_mutex_unlock(&LOCK_unused_shares); + tdc_delete_share_from_hash(share->tdc); DBUG_VOID_RETURN; } /* Link share last in used_table_share list */ diff --cc storage/maria/ma_blockrec.c index c0a93415379,367c8da26c0..8ef463d2918 --- a/storage/maria/ma_blockrec.c +++ b/storage/maria/ma_blockrec.c @@@ -5161,11 -5123,19 +5161,19 @@@ int _ma_read_block_record(MARIA_HA *inf info->buff, share->page_type, PAGECACHE_LOCK_LEFT_UNLOCKED, 0))) DBUG_RETURN(my_errno); + + /* + Unallocated page access can happen if this is an access to a page where + all rows where deleted as part of this statement. + */ + DBUG_ASSERT((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == HEAD_PAGE || + (buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == UNALLOCATED_PAGE); + - if (((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == UNALLOCATED_PAGE) || - !(data= get_record_position(buff, block_size, offset, &end_of_data))) + DBUG_ASSERT((buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) == HEAD_PAGE); + if (!(data= get_record_position(share, buff, offset, &end_of_data))) { DBUG_ASSERT(!maria_assert_if_crashed_table); - DBUG_PRINT("error", ("Wrong directory entry in data block")); + DBUG_PRINT("warning", ("Wrong directory entry in data block")); my_errno= HA_ERR_RECORD_DELETED; /* File crashed */ DBUG_RETURN(HA_ERR_RECORD_DELETED); } diff --cc storage/mroonga/ha_mroonga.cpp index cbf902b7c0e,e4b6698cdf6..d317fef44fb --- a/storage/mroonga/ha_mroonga.cpp +++ b/storage/mroonga/ha_mroonga.cpp @@@ -16761,22 -15755,12 +16761,15 @@@ int ha_mroonga::storage_get_foreign_key ref_table_buff, ref_table_name_length, TRUE); - #ifdef MRN_FOREIGN_KEY_USE_METHOD_ENUM f_key_info.update_method = FK_OPTION_RESTRICT; f_key_info.delete_method = FK_OPTION_RESTRICT; - #else - f_key_info.update_method = thd_make_lex_string(thd, NULL, "RESTRICT", - 8, TRUE); - f_key_info.delete_method = thd_make_lex_string(thd, NULL, "RESTRICT", - 8, TRUE); - #endif f_key_info.referenced_key_name = thd_make_lex_string(thd, NULL, "PRIMARY", 7, TRUE); - LEX_STRING *field_name = thd_make_lex_string(thd, NULL, column_name, - column_name_size, TRUE); + LEX_STRING *field_name = thd_make_lex_string(thd, + NULL, + column_name.c_str(), + column_name.length(), + TRUE); f_key_info.foreign_fields.push_back(field_name); char ref_path[FN_REFLEN + 1]; diff --cc storage/tokudb/PerconaFT/cmake_modules/TokuSetupCompiler.cmake index 50d35ee4906,d8796db8cbe..8f65895cc9c --- a/storage/tokudb/PerconaFT/cmake_modules/TokuSetupCompiler.cmake +++ b/storage/tokudb/PerconaFT/cmake_modules/TokuSetupCompiler.cmake @@@ -106,7 -138,13 +106,10 @@@ endif ( set_cflags_if_supported( -Wno-error=strict-overflow ) -set_ldflags_if_supported( - -Wno-error=strict-overflow - ) + # new flag sets in MySQL 8.0 seem to explicitly disable this + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions") + ## set extra debugging flags and preprocessor definitions set(CMAKE_C_FLAGS_DEBUG "-g3 -O0 ${CMAKE_C_FLAGS_DEBUG}") set(CMAKE_CXX_FLAGS_DEBUG "-g3 -O0 ${CMAKE_CXX_FLAGS_DEBUG}") diff --cc storage/tokudb/PerconaFT/portability/toku_race_tools.h index 96712ffffdc,c70ee1969a6..eee08185513 --- a/storage/tokudb/PerconaFT/portability/toku_race_tools.h +++ b/storage/tokudb/PerconaFT/portability/toku_race_tools.h @@@ -40,12 -40,7 +40,12 @@@ Copyright (c) 2006, 2015, Percona and/o #include <portability/toku_config.h> +#ifdef HAVE_valgrind +#undef USE_VALGRIND +#define USE_VALGRIND 1 +#endif + - #if defined(__linux__) && USE_VALGRIND + #if defined(__linux__) && defined(USE_VALGRIND) && USE_VALGRIND # include <valgrind/helgrind.h> # include <valgrind/drd.h> diff --cc storage/tokudb/ha_tokudb_admin.cc index e1443101bb6,c400e5bd22c..8d4a67186fe --- a/storage/tokudb/ha_tokudb_admin.cc +++ b/storage/tokudb/ha_tokudb_admin.cc @@@ -1000,10 -1001,11 +1001,11 @@@ struct check_context THD* thd; }; - static int ha_tokudb_check_progress(void* extra, float progress) { + static int ha_tokudb_check_progress(void* extra, + TOKUDB_UNUSED(float progress)) { struct check_context* context = (struct check_context*)extra; int result = 0; - if (thd_killed(context->thd)) + if (thd_kill_level(context->thd)) result = ER_ABORTING_CONNECTION; return result; } diff --cc storage/tokudb/ha_tokudb_alter_56.cc index 473c4984eb6,293086b897e..b579d00f67b --- a/storage/tokudb/ha_tokudb_alter_56.cc +++ b/storage/tokudb/ha_tokudb_alter_56.cc @@@ -911,9 -929,10 +929,10 @@@ bool ha_tokudb::commit_inplace_alter_ta ha_alter_info->group_commit_ctx = NULL; } #endif + #if defined(TOKU_INCLUDE_WRITE_FRM_DATA) && TOKU_INCLUDE_WRITE_FRM_DATA #if (50500 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 50599) || \ - (100000 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 100099) + (100000 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 100199) - #if WITH_PARTITION_STORAGE_ENGINE + #if defined(WITH_PARTITION_STORAGE_ENGINE) && WITH_PARTITION_STORAGE_ENGINE if (TOKU_PARTITION_WRITE_FRM_DATA || altered_table->part_info == NULL) { #else if (true) { diff --cc storage/tokudb/hatoku_defines.h index 360272969e5,66a8fa5d982..ab9e0f79ef8 --- a/storage/tokudb/hatoku_defines.h +++ b/storage/tokudb/hatoku_defines.h @@@ -69,8 -74,20 +74,20 @@@ Copyright (c) 2006, 2015, Percona and/o #pragma interface /* gcc class implementation */ #endif - #if 100000 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 100199 + // TOKU_INCLUDE_WRITE_FRM_DATA, TOKU_PARTITION_WRITE_FRM_DATA, and + // TOKU_INCLUDE_DISCOVER_FRM all work together as two opposing sides + // of the same functionality. The 'WRITE' includes functionality to + // write a copy of every tables .frm data into the tables status dictionary on + // CREATE or ALTER. When WRITE is in, the .frm data is also verified whenever a + // table is opened. + // + // The 'DISCOVER' then implements the MySQL table discovery API which reads + // this same data and returns it back to MySQL. + // In most cases, they should all be in or out without mixing. There may be + // extreme cases though where one side (WRITE) is supported but perhaps + // 'DISCOVERY' may not be, thus the need for individual indicators. -#if 100000 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 100099 ++#if 100000 <= MYSQL_VERSION_ID && MYSQL_VERSION_ID <= 100199 // mariadb 10.0 #define TOKU_USE_DB_TYPE_TOKUDB 1 #define TOKU_INCLUDE_ALTER_56 1 diff --cc storage/tokudb/hatoku_hton.cc index 1016ae83ad2,39ffa6daa70..50fffd0a999 --- a/storage/tokudb/hatoku_hton.cc +++ b/storage/tokudb/hatoku_hton.cc @@@ -913,12 -922,12 +928,12 @@@ static int tokudb_commit(handlerton * h DB_TXN *this_txn = *txn; if (this_txn) { uint32_t syncflag = - tokudb_sync_on_commit(thd, trx, this_txn) ? 0 : DB_TXN_NOSYNC; + tokudb_sync_on_commit(thd, this_txn) ? 0 : DB_TXN_NOSYNC; TOKUDB_TRACE_FOR_FLAGS( TOKUDB_DEBUG_TXN, - "commit trx %u txn %p syncflag %u", + "commit trx %u txn %p %" PRIu64 " syncflag %u", all, - this_txn, + this_txn, this_txn->id64(this_txn), syncflag); // test hook to induce a crash on a debug build DBUG_EXECUTE_IF("tokudb_crash_commit_before", DBUG_SUICIDE();); diff --cc storage/tokudb/hatoku_hton.h index 80e13fa9b0c,c5b6aab1769..e632a9afe88 --- a/storage/tokudb/hatoku_hton.h +++ b/storage/tokudb/hatoku_hton.h @@@ -175,12 -181,13 +181,13 @@@ inline uint64_t tokudb_get_killed_time_ inline int tokudb_killed_callback(void) { THD *thd = current_thd; - return thd_killed(thd); + return thd_kill_level(thd); } - inline bool tokudb_killed_thd_callback(void *extra, uint64_t deleted_rows) { + inline bool tokudb_killed_thd_callback(void* extra, + TOKUDB_UNUSED(uint64_t deleted_rows)) { THD *thd = static_cast<THD *>(extra); - return thd_killed(thd) != 0; + return thd_kill_level(thd) != 0; } extern HASH tokudb_open_tables;