Current Path : /usr/opt/mysql57/mysql-test/suite/ndb/t/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
Current File : //usr/opt/mysql57/mysql-test/suite/ndb/t/ndbinfo.test |
# The include statement below is a temp one for tests that are yet to #be ported to run with InnoDB, #but needs to be kept for tests that would need MyISAM in future. --source include/force_myisam_default.inc --result_format 2 --source include/have_ndb.inc SELECT PLUGIN_NAME,PLUGIN_VERSION,PLUGIN_STATUS,PLUGIN_TYPE, PLUGIN_LIBRARY,PLUGIN_LIBRARY_VERSION,PLUGIN_AUTHOR,PLUGIN_DESCRIPTION FROM information_schema.plugins WHERE PLUGIN_NAME = 'ndbinfo'; ## Creation of temporary tables should not be supported by NDBINFO engine --error ER_ILLEGAL_HA_CREATE_OPTION CREATE TEMPORARY TABLE `t1` ( `dummy` INT UNSIGNED ) ENGINE=NDBINFO; USE ndbinfo; # Current usage may vary. Therefor the test only checks that if falls in the # <0%,5%> range. SELECT node_id, memory_type, used>0 AND used < total/20 AS used_ok, used_pages>0 AND used_pages < total_pages/20 AS used_pages_ok, total, total_pages FROM ndbinfo.memoryusage WHERE memory_type="Long message buffer" ORDER BY node_id; # Current usage may vary. Therefor the test only checks that if falls in the # <0%,5%> range. SELECT node_id, block_number, block_instance, pool_name, used>0 AND used < total/20 AS used_ok, total, high>=used AND high < total/20 AS high_ok, entry_size, config_param1, config_param2, config_param3, config_param4 FROM ndbinfo.ndb$pools WHERE pool_name="Long message buffer" ORDER BY node_id; SHOW CREATE TABLE ndb$tables; SELECT * FROM ndb$tables; SELECT COUNT(*) FROM ndb$tables; SELECT * FROM ndb$tables WHERE table_id = 2; SELECT * FROM ndb$tables WHERE table_id > 5; SELECT * FROM ndb$tables WHERE table_name = 'LOGDESTINATION'; SELECT COUNT(*) FROM ndb$tables t1, ndb$tables t2 WHERE t1.table_id = t1.table_id; SELECT table_id, table_name, comment from ndb$tables WHERE table_id > 2 AND table_id <= 5 ORDER BY table_id; SELECT table_id FROM ndb$tables WHERE table_id = 2 ORDER BY table_name; SELECT table_id, table_name FROM ndb$tables ORDER BY table_name; SELECT table_id, column_id, column_name FROM ndb$columns LIMIT 7; --error ER_OPEN_AS_READONLY UPDATE ndb$tables SET table_id=2 WHERE table_id=3; --error ER_OPEN_AS_READONLY UPDATE ndb$tables SET table_id=9 WHERE 1=0; --error ER_OPEN_AS_READONLY UPDATE ndb$tables SET table_id=9 WHERE table_id > 1; --error ER_OPEN_AS_READONLY DELETE FROM ndb$tables WHERE table_id=3; --error ER_OPEN_AS_READONLY DELETE FROM ndb$tables WHERE 1=0; --error ER_OPEN_AS_READONLY DELETE FROM ndb$tables WHERE table_id > 1; --error ER_ILLEGAL_HA ALTER TABLE ndb$test ADD COLUMN another_col varchar(255); FLUSH TABLES; SELECT table_id FROM ndb$tables; --error ER_OPEN_AS_READONLY TRUNCATE ndb$tables; ## Variables and status SHOW GLOBAL STATUS LIKE 'ndbinfo\_%'; let $current_version = `select @@ndbinfo_version`; --replace_result $current_version NDB_VERSION_D SHOW GLOBAL VARIABLES LIKE 'ndbinfo\_%'; SELECT counter, HEX(counter2) FROM ndb$test LIMIT 10; # All tables that contain data are hidden by default # and becomes visible with ndbinfo_show_hidden SHOW TABLES LIKE 'ndb$te%'; set @@ndbinfo_show_hidden=TRUE; SHOW TABLES LIKE 'ndb$te%'; set @@ndbinfo_show_hidden=default; # Check that ndbinfo_table_prefix is readonly --error ER_INCORRECT_GLOBAL_LOCAL_VAR set @@ndbinfo_table_prefix="somethingelse"; # Check that ndbinfo_database is readonly --error ER_INCORRECT_GLOBAL_LOCAL_VAR set @@ndbinfo_database="somethingelse"; # Check that block table has been created and contain data SELECT count(*) >= 20 FROM blocks; # Test incompatible table definition between NDB and MySQL Server # using the ndb$test table which originally looks like # CREATE TABLE `ndb$test` ( # `node_id` int unsigned DEFAULT NULL, # `block_number` int unsigned DEFAULT NULL, # `block_instance` int unsigned DEFAULT NULL, # `counter` int unsigned DEFAULT NULL, # `counter2` bigint unsigned DEFAULT NULL # ) ENGINE=NDBINFO COMMENT='for testing' ## 1) More columns in NDB -> allowed, with warning DROP TABLE ndb$test; CREATE TABLE ndb$test (node_id int unsigned) ENGINE = ndbinfo; SELECT node_id != 0 FROM ndb$test LIMIT 1; DROP TABLE ndb$test; ## 2) Column does not exist in NDB -> allowed, with warning, non existing ## column(s) return NULL ## 2a) Extra column at end CREATE TABLE ndb$test (node_id int, non_existing int) ENGINE = ndbinfo; SELECT DISTINCT node_id, non_existing FROM ndb$test; DROP TABLE ndb$test; ## 2b) Extra column(s) in middle CREATE TABLE ndb$test ( node_id int unsigned, non_existing int unsigned, block_number int unsigned, block_instance int unsigned, counter int unsigned, counter2 bigint unsigned ) ENGINE = ndbinfo; SELECT DISTINCT node_id, non_existing, block_number FROM ndb$test; DROP TABLE ndb$test; ## 2c) Extra column first CREATE TABLE ndb$test (non_existing int, node_id int) ENGINE = ndbinfo; SELECT DISTINCT node_id, non_existing FROM ndb$test; SELECT DISTINCT non_existing, node_id FROM ndb$test; DROP TABLE ndb$test; ## 3) Incompatible column type -> error, with warning ## 3a) int instead of bigint CREATE TABLE ndb$test (counter2 int) ENGINE = ndbinfo; --error ER_GET_ERRMSG SELECT * FROM ndb$test; SHOW WARNINGS; ## 3b) bigint instead of int DROP TABLE ndb$test; CREATE TABLE ndb$test (node_id bigint) ENGINE = ndbinfo; --error ER_GET_ERRMSG SELECT * FROM ndb$test; SHOW WARNINGS; ## 3c) varchar instead of int DROP TABLE ndb$test; CREATE TABLE ndb$test (node_id varchar(255)) ENGINE = ndbinfo; --error ER_GET_ERRMSG SELECT * FROM ndb$test; SHOW WARNINGS; DROP TABLE ndb$test; ## 3d) column which is NOT NULL CREATE TABLE ndb$test (node_id int unsigned NOT NULL) ENGINE = ndbinfo; --error ER_GET_ERRMSG SELECT * FROM ndb$test; SHOW WARNINGS; DROP TABLE ndb$test; ## 3e) non existing column which is NOT NULL CREATE TABLE ndb$test ( block_number int unsigned, non_existing int NOT NULL) ENGINE = ndbinfo; --error ER_GET_ERRMSG SELECT * FROM ndb$test; SHOW WARNINGS; DROP TABLE ndb$test; ## 4) Table with primary key/indexes not supported --error ER_TOO_MANY_KEYS CREATE TABLE ndb$test (node_id int, block_number int PRIMARY KEY) ENGINE = ndbinfo; ## 5) Table with blobs not supported --error ER_TABLE_CANT_HANDLE_BLOB CREATE TABLE ndb$test (node_id int, block_number blob) ENGINE = ndbinfo; ## 6) Table with autoincrement not supported --error ER_TABLE_CANT_HANDLE_AUTO_INCREMENT CREATE TABLE ndb$test (node_id int AUTO_INCREMENT) ENGINE = ndbinfo; # wl#5567 - exercise table... # only node_id is guranteed to be same... # (unless we change cluster config for test) # but this will anyway pull results from datanode... # --sorted_result select distinct node_id from ndbinfo.diskpagebuffer; # # BUG#11885602 # - It was allowed to CREATE TABLE which was not in NDB, but # creating a view on that table failed. Implement ndbinfo_offline # mode which allows tables to be created and opened although they # don't exists or have different table definition. # This is exactly the same behaviour as when NDBCLUSTER # is disabled # # Check ndbinfo_offline is GLOBAL variable --error ER_GLOBAL_VARIABLE set @@ndbinfo_offline=1; # Query used to check that open tables are closed # when offline mode is turned on and off let $q1 = SELECT DISTINCT(node_id) FROM ndbinfo.counters ORDER BY node_id; eval $q1; # new views desc threadblocks; select distinct block_name from threadblocks order by 1; desc threadstat; select count(*) > 0 block_name from threadstat; desc disk_write_speed_aggregate; select count(*) from disk_write_speed_aggregate; desc disk_write_speed_base; select node_id from disk_write_speed_base group by node_id, thr_no; select count(*) from disk_write_speed_aggregate_node; desc restart_info; select * from restart_info; desc cluster_transactions; desc server_transactions; desc cluster_operations; desc server_operations; create table t1 (a int primary key) engine = ndb; begin; insert into t1 values (1); select state, count_operations, outstanding_operations, IF(client_node_id <= 255, "<client_node_id>", "<incorrect node id>") client_node_id from server_transactions; select node_id, operation_type, state, IF(tc_node_id <= 48, "<tc_node_id>", "<incorrect nodeid>") tc_node_id, IF(client_node_id <= 255, "<client_node_id>", "<incorrect node id>") client_node_id from server_operations order by 1; --sorted_result select st.state, st.count_operations, st.outstanding_operations, so.node_id, so.state, so.operation_type from server_transactions st, server_operations so where st.transid = so.transid and so.tc_node_id = st.node_id and so.tc_block_instance = st.block_instance and so.client_node_id = st.client_node_id and so.client_block_ref = st.client_block_ref; rollback; drop table t1; # select distinct resource_name from resources order by 1; select distinct counter_name from counters order by 1; # Turn on ndbinfo_offline set @@global.ndbinfo_offline=TRUE; select @@ndbinfo_offline; CREATE TABLE ndb$does_not_exist_in_ndb( node_id int, message varchar(255) ) ENGINE = ndbinfo; CREATE VIEW view_on_table_which_does_not_exist_in_ndb AS SELECT node_id, message FROM ndbinfo.ndb$does_not_exist_in_ndb; SHOW CREATE TABLE ndb$does_not_exist_in_ndb; # SELECTs return no rows in offline mode SELECT * FROM view_on_table_which_does_not_exist_in_ndb; SELECT * FROM ndb$does_not_exist_in_ndb; eval $q1; DROP VIEW view_on_table_which_does_not_exist_in_ndb; DROP TABLE ndb$does_not_exist_in_ndb; # Restore original value set @@global.ndbinfo_offline = FALSE; eval $q1; # # Bug#17018500 BOGUS DEFINER VALUE FOR NDBINFO VIEWS REPORTED # IN INFORMATION_SCHEMA.VIEW # --echo Verify there are no ndbinfo views without 'root@localhost' as definer select table_schema, table_name, definer from information_schema.views where table_schema = 'ndbinfo' and definer != 'root@localhost'; # ################################ # Test memory_per_fragment table. # ################################ # A helper table for populating t1. create table numbers( i int ); insert into numbers values (0),(1),(2),(3),(4),(5),(6),(7),(8),(9); create table t1( a int not null primary key, b int not null, c1 char(255), vc1 varchar(1024), tx1 text )engine=ndbcluster; # Popultate t1 with 1000 rows, including som sizable varsize data. insert into t1 select x1.i+x2.i*10+x3.i*100, x1.i-x2.i*10-x3.i*100, repeat('x', 1+x1.i), repeat('y', 1000+x1.i), repeat('z', x1.i*100) from numbers as x1, numbers as x2, numbers as x3; drop table numbers; # Create some extra indexes to test different schema object types. create index ix1 on t1(c1); create unique index ix2 on t1(b) using hash; # The table id of 't1' may vary from run to run. We need to make sure that the # output from the subsequent tests does not depend on the numrical value of # that table id. set @t1_id = (select cast(id as signed integer) from ndbinfo.ndb$dict_obj_info where fq_name REGEXP "def/t1$"); # Test the dict_obj_info table. Replace table id of t1 in 'fq_name' values that # contain it (index and blob table names do), since the table id may vary # between runs. select type, state, parent_obj_type, replace(fq_name, cast(@t1_id as char(10)), "<t1 id>") as fq_name, if(parent_obj_id=@t1_id, "child_of_t1", if(parent_obj_id=0, "root", "error!")) as nesting from ndbinfo.ndb$dict_obj_info where id >= @t1_id and type <= 6 order by type, id; # Disable query log while defining the view below, since view definition # conatins the table id of t1, which may vary between runs. disable_query_log; let $t1_id = query_get_value(select @t1_id as id, id, 1); # Create som views that we reuse after modifying t1 below. # This one sums usage counts for all fragments of each table. # Some values, such as fixed_elem_free_count and fixed_elem_count for ordered # indexes may vary depending on the number of fragments and other factors. # These are therefore not returned directly, but used in calculations that # should provide stable results. # Observe that memory_per_fragment.fq_name, parent_fq_name, type are all # functionally dependent on 'table_id', but since this cannot be deduced from # the schema, they are all included in the 'group by' clause. eval create view sum_per_tab as select replace(fq_name, cast($t1_id as char(10)), "<t1 id>") as fq_name, parent_fq_name, type, if (type="Ordered index", -(round(sum(fixed_elem_count)/165)), sum(fixed_elem_count)) as fixed_elem_count, max(fixed_elem_size_bytes) as fixed_elem_size_bytes, round(sum(fixed_elem_alloc_bytes/fixed_elem_size_bytes) /sum(fixed_elem_count+fixed_elem_free_count),1) as fixed_elem_alloc_ok, sum(fixed_elem_free_bytes/fixed_elem_size_bytes) = sum(fixed_elem_free_count) as fixed_elem_free_bytes_ok, sum(var_elem_count) as var_elem_count, sum(var_elem_alloc_bytes) >= sum(var_elem_free_bytes) as var_bytes_ok from ndbinfo.memory_per_fragment where table_id >= $t1_id group by table_id, memory_per_fragment.fq_name, parent_fq_name, type order by table_id; enable_query_log; # Sum usage counts for all fragments of all tables. create view frag_sum as select sum(fixed_elem_alloc_bytes) as fixed_elem_alloc_bytes, sum(var_elem_alloc_bytes) as var_elem_alloc_bytes, sum(hash_index_alloc_bytes) as hash_index_alloc_bytes from ndbinfo.memory_per_fragment; # Sum pool values across all block instances. # 'Data memory' appears twice in 'pools' therefore a 'where' clause is needed. create view pool_sum as select pool_name, block_number, max(entry_size) * sum(used) as used_bytes from ndbinfo.ndb$pools where pool_name <> "Data memory" or block_number=249 group by pool_name, block_number; # Check that the combined size of all L2PMap nodes equals the total size # of the allocated L2PMap pages minus a small (<1%) page overhead. create view check_l2pmap_pools as select min(floor(1000*nodes.total*nodes.entry_size/ (pages.used*pages.entry_size))) as l2pmap_ratio from ndbinfo.ndb$pools as pages join ndbinfo.ndb$pools as nodes where pages.node_id=nodes.node_id and pages.block_instance=nodes.block_instance and pages.block_number=nodes.block_number and pages.pool_name="L2PMap pages" and nodes.pool_name="L2PMap nodes"; create view l2p_frag_sum as select sum(tuple_l2pmap_alloc_bytes) as l2p_sum, 'TUP' as block from ndbinfo.ndb$frag_mem_use union select sum(hash_index_l2pmap_alloc_bytes) as l2p_sum, 'ACC' as block from ndbinfo.ndb$frag_mem_use; # Check that we get the same result from the common pool as when we add up # the values for each fragment. select used_bytes - hash_index_alloc_bytes from pool_sum, frag_sum where pool_name='Index memory'; select used_bytes - fixed_elem_alloc_bytes - var_elem_alloc_bytes from pool_sum, frag_sum where pool_name='Data memory'; select l2p_sum-used_bytes from l2p_frag_sum, pool_sum where pool_name='L2PMap nodes' and ((block='ACC' and block_number=248) or (block='TUP' and block_number=249)); select * from check_l2pmap_pools; select * from sum_per_tab; # Now delete som scattered rows and check memory usage again. delete from t1 where a%10=0; select used_bytes - hash_index_alloc_bytes from pool_sum, frag_sum where pool_name='Index memory'; select used_bytes - fixed_elem_alloc_bytes - var_elem_alloc_bytes from pool_sum, frag_sum where pool_name='Data memory'; select l2p_sum-used_bytes from l2p_frag_sum, pool_sum where pool_name='L2PMap nodes' and ((block='ACC' and block_number=248) or (block='TUP' and block_number=249)); select * from check_l2pmap_pools; select * from sum_per_tab; # Now update some var-sized fields and check memory usage again. update t1 set vc1=repeat('x', a%300), tx1=repeat('y', a*2); select used_bytes - hash_index_alloc_bytes from pool_sum, frag_sum where pool_name='Index memory'; select used_bytes - fixed_elem_alloc_bytes - var_elem_alloc_bytes from pool_sum, frag_sum where pool_name='Data memory'; select l2p_sum-used_bytes from l2p_frag_sum, pool_sum where pool_name='L2PMap nodes' and ((block='ACC' and block_number=248) or (block='TUP' and block_number=249)); select * from check_l2pmap_pools; select * from sum_per_tab; drop table t1; drop view l2p_frag_sum; drop view check_l2pmap_pools; drop view sum_per_tab; drop view pool_sum; drop view frag_sum; # ################################ # Test operations_per_fragment table. # ################################ # Create a view that sums counters across all fragments, so that results # will not depend on endianness. # Observe that operations_per_fragment.fq_name, parent_fq_name, type are all # functionally dependent on 'table_id', but since this cannot be deduced from # the schema, they are all included in the 'group by' clause. create view frag_ops as select if(type in ('Ordered index', 'Unique hash index'), substring(fq_name from 1+locate('/', fq_name, 9)), if(fq_name like '%BLOB%', left(fq_name, locate('_', fq_name)), fq_name)) as fq_name, parent_fq_name, type, count(fragment_num) as frag_count, sum(tot_key_reads) as tot_key_reads, sum(tot_key_inserts) as tot_key_inserts, sum(tot_key_updates) as tot_key_updates, sum(tot_key_writes) as tot_key_writes, sum(tot_key_deletes) as tot_key_deletes, sum(tot_key_refs) as tot_key_refs, # Attrinfo for read operations is a bit longer when running with embedded # mysqld, which is why we do the rounding below. round(log2(1+sum(tot_key_attrinfo_bytes))) as log_tot_key_attrinfo_bytes, sum(tot_key_keyinfo_bytes) as tot_key_keyinfo_bytes, sum(tot_key_prog_bytes) as tot_key_prog_bytes, sum(tot_key_inst_exec) as tot_key_inst_exec, sum(tot_key_bytes_returned) as tot_key_bytes_returned, sum(tot_frag_scans) as tot_frag_scans, sum(tot_scan_rows_examined) as tot_scan_rows_examined, sum(tot_scan_rows_returned) as tot_scan_rows_returned, sum(tot_scan_bytes_returned) as tot_scan_bytes_returned, sum(tot_scan_prog_bytes) as tot_scan_prog_bytes, sum(tot_scan_bound_bytes) as tot_scan_bound_bytes, sum(tot_scan_inst_exec) as tot_scan_inst_exec, sum(conc_frag_scans) as conc_frag_scans, sum(conc_qd_frag_scans) as conc_qd_frag_scans, sum(tot_commits) as tot_commits from ndbinfo.operations_per_fragment where fq_name like 'ndbinfo%' or parent_fq_name like 'ndbinfo%' group by table_id, type, operations_per_fragment.fq_name, parent_fq_name order by table_id; # Create and populate test tables. create table t1 ( a int not null, b int not null, c int not null, d int not null, t text not null, primary key (b,a) ) engine=ndbcluster partition by key(b,a) partitions 8; create unique index ix1 on t1(d) using hash; # A helper table for populating t1. create table numbers( i int ); insert into numbers values (0),(1),(2),(3),(4),(5),(6),(7),(8),(9); insert into t1 select x1.i+x2.i*10, 1, 1+x1.i+x2.i*10, 1+x1.i+x2.i*10, repeat('x', 512) from numbers as x1, numbers as x2; drop table numbers; create table t2 ( a int, b int, primary key(a) using hash) engine = ndb partition by key(a) partitions 8; insert into t2 values (1, 2); insert into t2 values (2, 3); insert into t2 values (3, 1); # Check counters before the test queries. --query_vertical select * from frag_ops; # Do a table scan with a pushed condition. explain select count(*) from t1 where d<10; select count(*) from t1 where d<10; # Do an index scan. explain select count(*) from t1 where b=1 and a<10; select count(*) from t1 where b=1 and a<10; # Do a PK read. explain select * from t1 where b=1 and a = -5; select * from t1 where b=1 and a = -5; # Try to insert a duplicate key. --error ER_DUP_ENTRY insert into t1 values (1,1,1,1,''); # Use replace to generate PK write operations. replace t1 values (-1,-1,-1,-1,''); replace t1 values (1,1,5,500,''); # Do update and delete. update t1 set d = -d, t = repeat('a', 300) where b=1 and a > 90; delete from t1 where a%30=0; # This error insert causes the next index scan from SPJ to be queued on node 2. # This command may fail if error inserts is not available on this build, # therefore we permit return code 255. --error 0,255 --exec $NDB_MGM --no-defaults --ndb-connectstring="$NDB_CONNECTSTRING" -e "2 error 5084" >> $NDB_TOOLS_OUTPUT # Do a pushed query that starts multiple index scans on each t1 fragment. # That way the first scan (on node 2) will be queued until the next finishes. explain select count(*) from t1 as x1 join t1 as x2 on x1.c=x2.b; select count(*) from t1 as x1 join t1 as x2 on x1.c=x2.b; # Check number of queued scans. Test for debug build # to handle builds without error inserts (i.e. non-debug builds). select if ((select version() like '%debug'), sum(tot_qd_frag_scans), 4) as tot_qd_frag_scans from ndbinfo.operations_per_fragment where fq_name like 'ndbinfo%' or parent_fq_name like 'ndbinfo%'; # Check how these operations changed the counters. --query_vertical select * from frag_ops; # This query should give PK read operations with an interpreted program. # (Multi-range read mapped to PK reads.) explain select count(*) from t2 as tx, t2 as ty where tx.a in (1,3,5) and ty.a = tx.b; # The 'explain' above triggers an implicit 'analyze table'. That increments # operations_per_fragment counters in a way that is endian-dependent. # We therefore save the current values of the counters to isolate the # effect of the query below. create table save_counters as select * from frag_ops; select count(*) from t2 as tx, t2 as ty where tx.a in (1,3,5) and ty.a = tx.b; create view changes as select new.fq_name, new.parent_fq_name, new.type, new.frag_count, new.tot_key_reads - old.tot_key_reads, new.tot_key_inserts - old.tot_key_inserts, new.tot_key_updates - old.tot_key_updates, new.tot_key_writes - old.tot_key_writes, new.tot_key_deletes - old.tot_key_deletes, new.tot_key_refs - old.tot_key_refs, new.log_tot_key_attrinfo_bytes - old.log_tot_key_attrinfo_bytes, new.tot_key_keyinfo_bytes - old.tot_key_keyinfo_bytes, new.tot_key_prog_bytes - old.tot_key_prog_bytes, new.tot_key_inst_exec - old.tot_key_inst_exec, new.tot_key_bytes_returned - old.tot_key_bytes_returned, new.tot_frag_scans - old.tot_frag_scans, new.tot_scan_rows_examined - old.tot_scan_rows_examined, new.tot_scan_rows_returned - old.tot_scan_rows_returned, new.tot_scan_bytes_returned - old.tot_scan_bytes_returned, new.tot_scan_prog_bytes - old.tot_scan_prog_bytes, new.tot_scan_bound_bytes - old.tot_scan_bound_bytes, new.tot_scan_inst_exec - old.tot_scan_inst_exec, new.tot_commits - old.tot_commits from frag_ops as new, save_counters as old where new.fq_name=old.fq_name and new.fq_name like '%t2'; --query_vertical select * from changes # Drop test views and tables. drop view changes; drop table save_counters; drop view frag_ops; drop table t1; drop table t2; # # WL#7575 Remove ndbinfo's usage of other engine # - the five lookup tables which resided in another engine # was converted to virtual(aka. hardcoded) tables inside ha_ndbinfo # - three new views was added to preserve backwards compatibility # for those tabes which was changed to prefix ndb$ ## Check that the new tables return data and exists. select count(*) > 10 from ndb$blocks; select param_number, param_name from ndb$config_params where param_name = "DataMemory"; select * from ndb$dict_obj_types where type_id < 3; --disable_result_log select * from ndb$dbtc_apiconnect_state; select * from ndb$dblqh_tcconnect_state; --enable_result_log ## Check that the new views return data and exists. select block_number from blocks where block_name = "DBTC"; select param_name from config_params where param_number = 101; select type_name from ndb$dict_obj_types where type_id = 3; ## All tables in ndbinfo/ should now be using engine=NDBINFO select count(*) from information_schema.tables where table_schema = 'ndbinfo' and engine != 'ndbinfo'; # # BUG#20075747 RND_INIT() ON AN OPEN SCAN IS USED TO REPOSITION THE CURSOR # - rnd_init() on an open scan is used to reposition the "cursor" # back to first row # set @@optimizer_switch='block_nested_loop=off'; create temporary table old_count select counter_name, sum(val) as val from ndbinfo.counters where block_name='DBSPJ' group by counter_name; drop table old_count; set @@optimizer_switch=default; # # Bug#16731538 MYSQLD CRITICAL FAILURE DURING ORDERED SELECT FROM NDBINFO.CLUSTER_OPERATIONS # - ha_ndbinfo::estimate_rows_upper_bound() returned 0 rows # --disable_result_log select * from ndbinfo.config_params order by param_number; --enable_result_log # # Bug#11762750 TABLE NDBINFO.CONFIG_PARAMS SHOULD BE READ-ONLY (FOR NOW) # # # Checking the table --error ER_OPEN_AS_READONLY UPDATE ndb$config_params SET param_number=1 WHERE param_name = "NoOfReplicas"; # Checking the view --error ER_OPEN_AS_READONLY UPDATE config_params SET param_number=1 WHERE param_name = "NoOfReplicas";