mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-30 02:30:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

cleanup: spaces, casts, comments

Browse source
This commit is contained in:
Sergei Golubchik 2024-01-08 18:29:12 +01:00
parent 9f2adffcca
commit 9fa31c1bd9
22 changed files with 162 additions and 254 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
include/my_base.h
View file

@ -99,16 +99,16 @@ enum ha_rkey_function {
HA_READ_MBR_EQUAL HA_READ_MBR_EQUAL
}; };
/* Key algorithm types */ /* Key algorithm types (stored in .frm) */
enum ha_key_alg { enum ha_key_alg {
HA_KEY_ALG_UNDEF= 0, /* Not specified (old file) */ HA_KEY_ALG_UNDEF= 0, /* Not specified (old file) */
HA_KEY_ALG_BTREE= 1, /* B-tree, default one */ HA_KEY_ALG_BTREE= 1, /* B-tree, default one */
HA_KEY_ALG_RTREE= 2, /* R-tree, for spatial searches */ HA_KEY_ALG_RTREE= 2, /* R-tree, for spatial searches */
HA_KEY_ALG_HASH= 3, /* HASH keys (HEAP tables) */ HA_KEY_ALG_HASH= 3, /* HASH keys (HEAP tables) */
HA_KEY_ALG_FULLTEXT= 4, /* FULLTEXT (MyISAM tables) */ HA_KEY_ALG_FULLTEXT= 4, /* FULLTEXT */
HA_KEY_ALG_LONG_HASH= 5, /* long BLOB keys */ HA_KEY_ALG_LONG_HASH= 5, /* long BLOB keys */
HA_KEY_ALG_UNIQUE_HASH= 6 /* Internal UNIQUE hash (Aria) */ HA_KEY_ALG_UNIQUE_HASH= 6 /* Internal UNIQUE hash (Aria) */
}; };
/* Storage media types */ /* Storage media types */

2
include/my_bit.h
View file

@ -37,7 +37,7 @@ extern const uchar _my_bits_reverse_table[256];
- returns 0 for (1<<0) - returns 0 for (1<<0)
- returns 1 for (1<<1) - returns 1 for (1<<1)
- returns 2 for (1<<2) - returns 2 for (1<<2)
- returns 2 for 3, which has (1<<2) as the highest bit set. - returns 1 for 3, which has (1<<1) as the highest bit set.
Note, the behaviour of log2(0) is not defined. Note, the behaviour of log2(0) is not defined.
Let's return 0 for the input 0, for the code simplicity. Let's return 0 for the input 0, for the code simplicity.

6
include/mysql/plugin.h
View file

@ -595,7 +595,7 @@ struct st_maria_plugin
API for Storage Engine plugin. (MYSQL_DAEMON_PLUGIN) API for Storage Engine plugin. (MYSQL_DAEMON_PLUGIN)
*/ */
/* handlertons of different MySQL releases are incompatible */ /* daemon plugins of different MySQL releases are incompatible */
#define MYSQL_DAEMON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8) #define MYSQL_DAEMON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
/* /*
@ -613,7 +613,7 @@ struct st_mysql_daemon
API for I_S plugin. (MYSQL_INFORMATION_SCHEMA_PLUGIN) API for I_S plugin. (MYSQL_INFORMATION_SCHEMA_PLUGIN)
*/ */
/* handlertons of different MySQL releases are incompatible */ /* information schema plugins different MySQL releases are incompatible */
#define MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION (MYSQL_VERSION_ID << 8) #define MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
/* /*
@ -631,7 +631,7 @@ struct st_mysql_information_schema
API for Storage Engine plugin. (MYSQL_STORAGE_ENGINE_PLUGIN) API for Storage Engine plugin. (MYSQL_STORAGE_ENGINE_PLUGIN)
*/ */
/* handlertons of different MySQL releases are incompatible */ /* storage engines of different MySQL releases are incompatible */
#define MYSQL_HANDLERTON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8) #define MYSQL_HANDLERTON_INTERFACE_VERSION (MYSQL_VERSION_ID << 8)
/* /*

3
mysql-test/main/myisam.result
View file

@ -454,9 +454,6 @@ select * from t1 where a='807780' and b='477' and c='165';
a b c a b c
807780 477 165 807780 477 165
drop table t1; drop table t1;
DROP TABLE IF EXISTS t1;
Warnings:
Note 1051 Unknown table 'test.t1'
CREATE TABLE t1 (a varchar(150) NOT NULL, KEY (a)); CREATE TABLE t1 (a varchar(150) NOT NULL, KEY (a));
INSERT t1 VALUES ("can \tcan"); INSERT t1 VALUES ("can \tcan");
INSERT t1 VALUES ("can can"); INSERT t1 VALUES ("can can");

7
mysql-test/main/myisam.test
View file

@ -437,7 +437,6 @@ drop table t1;
# #
# space-stripping in _mi_prefix_search: BUG#5284 # space-stripping in _mi_prefix_search: BUG#5284
# #
DROP TABLE IF EXISTS t1;
CREATE TABLE t1 (a varchar(150) NOT NULL, KEY (a)); CREATE TABLE t1 (a varchar(150) NOT NULL, KEY (a));
INSERT t1 VALUES ("can \tcan"); INSERT t1 VALUES ("can \tcan");
INSERT t1 VALUES ("can can"); INSERT t1 VALUES ("can can");
@ -1128,7 +1127,7 @@ drop table t1;
create table t1 (c1 int) engine=myisam pack_keys=0; create table t1 (c1 int) engine=myisam pack_keys=0;
create table t2 (c1 int) engine=myisam pack_keys=1; create table t2 (c1 int) engine=myisam pack_keys=1;
create table t3 (c1 int) engine=myisam pack_keys=default; create table t3 (c1 int) engine=myisam pack_keys=default;
--error 1064 --error ER_PARSE_ERROR
create table t4 (c1 int) engine=myisam pack_keys=2; create table t4 (c1 int) engine=myisam pack_keys=2;
drop table t1, t2, t3; drop table t1, t2, t3;
@ -1315,9 +1314,9 @@ create table t1 (a int not null, key `a` (a) key_block_size=1025);
show create table t1; show create table t1;
drop table t1; drop table t1;
--error 1064 --error ER_PARSE_ERROR
create table t1 (a int not null, key key_block_size=1024 (a)); create table t1 (a int not null, key key_block_size=1024 (a));
--error 1064 --error ER_PARSE_ERROR
create table t1 (a int not null, key `a` key_block_size=1024 (a)); create table t1 (a int not null, key `a` key_block_size=1024 (a));
# #

1
mysql-test/main/table_options-5867.opt
View file

@ -1 +0,0 @@
--plugin-maturity=unknown

2
mysql-test/suite/maria/maria.result
View file

@ -7,8 +7,6 @@ set global default_storage_engine=aria;
set session default_storage_engine=aria; set session default_storage_engine=aria;
set global aria_page_checksum=0; set global aria_page_checksum=0;
set global aria_log_file_size=4294959104; set global aria_log_file_size=4294959104;
drop table if exists t1,t2;
drop view if exists v1;
SET SQL_WARNINGS=1; SET SQL_WARNINGS=1;
CREATE TABLE t1 ( CREATE TABLE t1 (
STRING_DATA char(255) default NULL, STRING_DATA char(255) default NULL,

10
mysql-test/suite/maria/maria.test
View file

@ -21,10 +21,6 @@ let $default_log_file_size=`select @@global.aria_log_file_size`;
set global aria_log_file_size=4294959104; set global aria_log_file_size=4294959104;
# Initialise # Initialise
--disable_warnings
drop table if exists t1,t2;
drop view if exists v1;
--enable_warnings
SET SQL_WARNINGS=1; SET SQL_WARNINGS=1;
# #
@ -1062,7 +1058,7 @@ drop table t1;
create table t1 (c1 int) pack_keys=0; create table t1 (c1 int) pack_keys=0;
create table t2 (c1 int) pack_keys=1; create table t2 (c1 int) pack_keys=1;
create table t3 (c1 int) pack_keys=default; create table t3 (c1 int) pack_keys=default;
--error 1064 --error ER_PARSE_ERROR
create table t4 (c1 int) pack_keys=2; create table t4 (c1 int) pack_keys=2;
drop table t1, t2, t3; drop table t1, t2, t3;
@ -1209,9 +1205,9 @@ create table t1 (a int not null, key `a` (a) key_block_size=1025);
show create table t1; show create table t1;
drop table t1; drop table t1;
--error 1064 --error ER_PARSE_ERROR
create table t1 (a int not null, key key_block_size=1024 (a)); create table t1 (a int not null, key key_block_size=1024 (a));
--error 1064 --error ER_PARSE_ERROR
create table t1 (a int not null, key `a` key_block_size=1024 (a)); create table t1 (a int not null, key `a` key_block_size=1024 (a));
# #

13
sql/filesort.cc
View file

@ -48,7 +48,7 @@ static ha_rows find_all_keys(THD *thd, Sort_param *param, SQL_SELECT *select,
ha_rows *found_rows); ha_rows *found_rows);
static bool write_keys(Sort_param *param, SORT_INFO *fs_info, static bool write_keys(Sort_param *param, SORT_INFO *fs_info,
uint count, IO_CACHE *buffer_file, IO_CACHE *tempfile); uint count, IO_CACHE *buffer_file, IO_CACHE *tempfile);
static uint make_sortkey(Sort_param *param, uchar *to, uchar *ref_pos, static uint make_sortkey(Sort_param *, uchar *, uchar *,
bool using_packed_sortkeys= false); bool using_packed_sortkeys= false);
static uint make_sortkey(Sort_param *param, uchar *to); static uint make_sortkey(Sort_param *param, uchar *to);
static uint make_packed_sortkey(Sort_param *param, uchar *to); static uint make_packed_sortkey(Sort_param *param, uchar *to);
@ -1516,8 +1516,7 @@ static void register_used_fields(Sort_param *param)
} }
static bool save_index(Sort_param *param, uint count, static bool save_index(Sort_param *param, uint count, SORT_INFO *table_sort)
SORT_INFO *table_sort)
{ {
uint offset,res_length, length; uint offset,res_length, length;
uchar *to; uchar *to;
@ -2958,16 +2957,14 @@ static uint make_sortkey(Sort_param *param, uchar *to)
{ {
bool maybe_null=0; bool maybe_null=0;
if ((field=sort_field->field)) if ((field=sort_field->field))
{ { // Field
// Field
field->make_sort_key_part(to, sort_field->length); field->make_sort_key_part(to, sort_field->length);
if ((maybe_null= field->maybe_null())) if ((maybe_null= field->maybe_null()))
to++; to++;
} }
else else
{ // Item { // Item
sort_field->item->type_handler()->make_sort_key_part(to, sort_field->item->type_handler()->make_sort_key_part(to, sort_field->item,
sort_field->item,
sort_field, sort_field,
&param->tmp_buffer); &param->tmp_buffer);
if ((maybe_null= sort_field->item->maybe_null())) if ((maybe_null= sort_field->item->maybe_null()))

14
sql/ha_partition.cc
View file

@ -141,9 +141,8 @@ int ha_partition::notify_tabledef_changed(LEX_CSTRING *db,
{ {
LEX_CSTRING table_name; LEX_CSTRING table_name;
const char *table_name_ptr; const char *table_name_ptr;
if (create_partition_name(from_buff, sizeof(from_buff), if (create_partition_name(from_buff, sizeof(from_buff), from_path,
from_path, name_buffer_ptr, name_buffer_ptr, NORMAL_PART_NAME, FALSE))
NORMAL_PART_NAME, FALSE))
res=1; res=1;
table_name_ptr= from_buff + dirname_length(from_buff); table_name_ptr= from_buff + dirname_length(from_buff);
@ -159,12 +158,9 @@ int ha_partition::notify_tabledef_changed(LEX_CSTRING *db,
static int static int
partition_notify_tabledef_changed(handlerton *, partition_notify_tabledef_changed(handlerton *, LEX_CSTRING *db,
LEX_CSTRING *db, LEX_CSTRING *table, LEX_CUSTRING *frm,
LEX_CSTRING *table, LEX_CUSTRING *version, handler *file)
LEX_CUSTRING *frm,
LEX_CUSTRING *version,
handler *file)
{ {
DBUG_ENTER("partition_notify_tabledef_changed"); DBUG_ENTER("partition_notify_tabledef_changed");
DBUG_RETURN(static_cast<ha_partition*> DBUG_RETURN(static_cast<ha_partition*>

53
sql/handler.cc
View file

@ -871,8 +871,8 @@ int ha_end()
DBUG_RETURN(error); DBUG_RETURN(error);
} }
static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,
void *path) static my_bool dropdb_handlerton(THD *, plugin_ref plugin, void *path)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->drop_database) if (hton->drop_database)
@ -888,8 +888,7 @@ void ha_drop_database(const char* path)
} }
static my_bool checkpoint_state_handlerton(THD *unused1, plugin_ref plugin, static my_bool checkpoint_state_handlerton(THD *, plugin_ref plugin, void *disable)
void *disable)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->checkpoint_state) if (hton->checkpoint_state)
@ -909,8 +908,8 @@ struct st_commit_checkpoint_request {
void (*pre_hook)(void *); void (*pre_hook)(void *);
}; };
static my_bool commit_checkpoint_request_handlerton(THD *unused1, plugin_ref plugin, static my_bool commit_checkpoint_request_handlerton(THD *, plugin_ref plugin,
void *data) void *data)
{ {
st_commit_checkpoint_request *st= (st_commit_checkpoint_request *)data; st_commit_checkpoint_request *st= (st_commit_checkpoint_request *)data;
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
@ -1024,8 +1023,7 @@ void ha_signal_ddl_recovery_done()
Backup functions Backup functions
******************************************************************************/ ******************************************************************************/
static my_bool plugin_prepare_for_backup(THD *unused1, plugin_ref plugin, static my_bool plugin_prepare_for_backup(THD *, plugin_ref plugin, void *)
void *not_used)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->prepare_for_backup) if (hton->prepare_for_backup)
@ -1040,8 +1038,7 @@ void ha_prepare_for_backup()
PLUGIN_IS_DELETED|PLUGIN_IS_READY, 0); PLUGIN_IS_DELETED|PLUGIN_IS_READY, 0);
} }
static my_bool plugin_end_backup(THD *unused1, plugin_ref plugin, static my_bool plugin_end_backup(THD *, plugin_ref plugin, void *)
void *not_used)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->end_backup) if (hton->end_backup)
@ -2419,8 +2416,7 @@ struct xahton_st {
int result; int result;
}; };
static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin, static my_bool xacommit_handlerton(THD *, plugin_ref plugin, void *arg)
void *arg)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->recover) if (hton->recover)
@ -2431,8 +2427,7 @@ static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin,
return FALSE; return FALSE;
} }
static my_bool xarollback_handlerton(THD *unused1, plugin_ref plugin, static my_bool xarollback_handlerton(THD *, plugin_ref plugin, void *arg)
void *arg)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->recover) if (hton->recover)
@ -2713,7 +2708,7 @@ static void xarecover_do_commit_or_rollback(handlerton *hton,
/* /*
Per hton recovery decider function. Per hton recovery decider function.
*/ */
static my_bool xarecover_do_commit_or_rollback_handlerton(THD *unused, static my_bool xarecover_do_commit_or_rollback_handlerton(THD *,
plugin_ref plugin, plugin_ref plugin,
void *arg) void *arg)
{ {
@ -2783,8 +2778,7 @@ uint ha_recover_complete(HASH *commit_list, Binlog_offset *coord)
return complete.count; return complete.count;
} }
static my_bool xarecover_handlerton(THD *unused, plugin_ref plugin, static my_bool xarecover_handlerton(THD *, plugin_ref plugin, void *arg)
void *arg)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
struct xarecover_st *info= (struct xarecover_st *) arg; struct xarecover_st *info= (struct xarecover_st *) arg;
@ -3159,9 +3153,7 @@ int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
DBUG_RETURN(error); DBUG_RETURN(error);
} }
static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin, void *arg)
static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin,
void *arg)
{ {
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);
if (hton->start_consistent_snapshot) if (hton->start_consistent_snapshot)
@ -3281,6 +3273,13 @@ Lex_cstring handler::get_canonical_filename(const Lex_cstring &path,
/** /**
Delete a table in the engine Delete a table in the engine
@param thd
@param hton
@param path no extension, e.g. "./test/t1"
@param db for the error message only
@param alias table name, for the error message only
@param generate_warning generate "table not found" warnings as needed
@return 0 Table was deleted @return 0 Table was deleted
@return -1 Table didn't exists, no error given @return -1 Table didn't exists, no error given
@return # Error from table handler @return # Error from table handler
@ -6310,6 +6309,14 @@ int handler::calculate_checksum()
/** /**
Initiates table-file and calls appropriate database-creator. Initiates table-file and calls appropriate database-creator.
@param thd
@param path no extension, e.g. "./test/t1"
@param db
@param table_name
@param create_info
@param frm an frm image or NULL (meaning, read it from the file)
@param skip_frm_file do not write the frm image to the .frm file
@retval @retval
0 ok 0 ok
@retval @retval
@ -6400,8 +6407,7 @@ void st_ha_check_opt::init()
/** /**
Init a key cache if it has not been initied before. Init a key cache if it has not been initied before.
*/ */
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache, void *unused int ha_init_key_cache(const char *name, KEY_CACHE *key_cache, void *)
__attribute__((unused)))
{ {
DBUG_ENTER("ha_init_key_cache"); DBUG_ENTER("ha_init_key_cache");
@ -7285,8 +7291,7 @@ int handler::index_read_idx_map(uchar * buf, uint index, const uchar * key,
@retval @retval
pointer pointer to TYPELIB structure pointer pointer to TYPELIB structure
*/ */
static my_bool exts_handlerton(THD *unused, plugin_ref plugin, static my_bool exts_handlerton(THD *, plugin_ref plugin, void *arg)
void *arg)
{ {
List<char> *found_exts= (List<char> *) arg; List<char> *found_exts= (List<char> *) arg;
handlerton *hton= plugin_hton(plugin); handlerton *hton= plugin_hton(plugin);

2
sql/handler.h
View file

@ -150,7 +150,7 @@ enum chf_create_flags {
*/ */
#define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1ULL << 6) #define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1ULL << 6)
#define HA_NULL_IN_KEY (1ULL << 7) /* One can have keys with NULL */ #define HA_NULL_IN_KEY (1ULL << 7) /* One can have keys with NULL */
#define HA_DUPLICATE_POS (1ULL << 8) /* ha_position() gives dup row */ #define HA_DUPLICATE_POS (1ULL << 8) /* position() gives dup row */
#define HA_NO_BLOBS (1ULL << 9) /* Doesn't support blobs */ #define HA_NO_BLOBS (1ULL << 9) /* Doesn't support blobs */
#define HA_CAN_INDEX_BLOBS (1ULL << 10) #define HA_CAN_INDEX_BLOBS (1ULL << 10)
#define HA_AUTO_PART_KEY (1ULL << 11) /* auto-increment in multi-part key */ #define HA_AUTO_PART_KEY (1ULL << 11) /* auto-increment in multi-part key */

2
sql/item.h
View file

@ -2821,7 +2821,7 @@ inline Item* get_item_copy (THD *thd, const T* item)
if (likely(copy)) if (likely(copy))
copy->register_in(thd); copy->register_in(thd);
return copy; return copy;
} }
#ifndef DBUG_OFF #ifndef DBUG_OFF

6
sql/sql_insert.cc
View file

@ -4373,12 +4373,8 @@ bool select_insert::prepare_eof()
DBUG_PRINT("enter", ("trans_table: %d, table_type: '%s'", DBUG_PRINT("enter", ("trans_table: %d, table_type: '%s'",
trans_table, table->file->table_type())); trans_table, table->file->table_type()));
#ifdef WITH_WSREP error= IF_WSREP(thd->wsrep_cs().current_error(), 0) ? -1 :
error= (thd->wsrep_cs().current_error()) ? -1 :
(thd->locked_tables_mode <= LTM_LOCK_TABLES) ? (thd->locked_tables_mode <= LTM_LOCK_TABLES) ?
#else
error= (thd->locked_tables_mode <= LTM_LOCK_TABLES) ?
#endif /* WITH_WSREP */
table->file->ha_end_bulk_insert() : 0; table->file->ha_end_bulk_insert() : 0;
if (likely(!error) && unlikely(thd->is_error())) if (likely(!error) && unlikely(thd->is_error()))

33
sql/sql_select.cc
View file

@ -245,7 +245,6 @@ static int join_init_quick_read_record(JOIN_TAB *tab);
static quick_select_return test_if_quick_select(JOIN_TAB *tab); static quick_select_return test_if_quick_select(JOIN_TAB *tab);
static int test_if_use_dynamic_range_scan(JOIN_TAB *join_tab); static int test_if_use_dynamic_range_scan(JOIN_TAB *join_tab);
static int join_read_first(JOIN_TAB *tab); static int join_read_first(JOIN_TAB *tab);
static int join_read_next(READ_RECORD *info);
static int join_read_next_same(READ_RECORD *info); static int join_read_next_same(READ_RECORD *info);
static int join_read_last(JOIN_TAB *tab); static int join_read_last(JOIN_TAB *tab);
static int join_read_prev_same(READ_RECORD *info); static int join_read_prev_same(READ_RECORD *info);
@ -374,13 +373,7 @@ static
bool join_limit_shortcut_is_applicable(const JOIN *join); bool join_limit_shortcut_is_applicable(const JOIN *join);
POSITION *join_limit_shortcut_finalize_plan(JOIN *join, double *cost); POSITION *join_limit_shortcut_finalize_plan(JOIN *join, double *cost);
static static bool find_indexes_matching_order(JOIN *, TABLE *, ORDER *, key_map *);
bool find_indexes_matching_order(JOIN *join, TABLE *table, ORDER *order,
key_map *usable_keys);
static
void compute_part_of_sort_key_for_equals(JOIN *join, TABLE *table,
Item_field *item_field,
key_map *col_keys);
#ifndef DBUG_OFF #ifndef DBUG_OFF
@ -7246,8 +7239,7 @@ add_keyuse(DYNAMIC_ARRAY *keyuse_array, KEY_FIELD *key_field,
static LEX_CSTRING equal_str= { STRING_WITH_LEN("=") }; static LEX_CSTRING equal_str= { STRING_WITH_LEN("=") };
static bool static bool add_key_part(DYNAMIC_ARRAY *keyuse_array, KEY_FIELD *key_field)
add_key_part(DYNAMIC_ARRAY *keyuse_array, KEY_FIELD *key_field)
{ {
Field *field=key_field->field; Field *field=key_field->field;
TABLE *form= field->table; TABLE *form= field->table;
@ -7260,7 +7252,7 @@ add_key_part(DYNAMIC_ARRAY *keyuse_array, KEY_FIELD *key_field)
if (!(form->keys_in_use_for_query.is_set(key))) if (!(form->keys_in_use_for_query.is_set(key)))
continue; continue;
if (form->key_info[key].flags & (HA_FULLTEXT | HA_SPATIAL)) if (form->key_info[key].flags & (HA_FULLTEXT | HA_SPATIAL))
continue; // ToDo: ft-keys in non-ft queries. SerG continue;
KEY *keyinfo= form->key_info+key; KEY *keyinfo= form->key_info+key;
uint key_parts= form->actual_n_key_parts(keyinfo); uint key_parts= form->actual_n_key_parts(keyinfo);
@ -11555,9 +11547,7 @@ bool test_if_skip_sort_order_early(JOIN *join,
// Step #1: Find indexes that produce the required ordering. // Step #1: Find indexes that produce the required ordering.
if (find_indexes_matching_order(join, table, join->order, &usable_keys)) if (find_indexes_matching_order(join, table, join->order, &usable_keys))
{
return false; // Cannot skip sorting return false; // Cannot skip sorting
}
// Step #2: Check if the index we're using produces the needed ordering // Step #2: Check if the index we're using produces the needed ordering
uint ref_key; uint ref_key;
@ -26441,7 +26431,6 @@ part_of_refkey(TABLE *table,Field *field)
@param used_key_parts [out] NULL by default, otherwise return value for @param used_key_parts [out] NULL by default, otherwise return value for
used key parts. used key parts.
@note @note
used_key_parts is set to correct key parts used if return value != 0 used_key_parts is set to correct key parts used if return value != 0
(On other cases, used_key_part may be changed) (On other cases, used_key_part may be changed)
@ -26457,9 +26446,8 @@ part_of_refkey(TABLE *table,Field *field)
-1 Reverse key can be used -1 Reverse key can be used
*/ */
static int test_if_order_by_key(JOIN *join, static int test_if_order_by_key(JOIN *join, ORDER *order, TABLE *table,
ORDER *order, TABLE *table, uint idx, uint idx, uint *used_key_parts)
uint *used_key_parts)
{ {
KEY_PART_INFO *key_part,*key_part_end; KEY_PART_INFO *key_part,*key_part_end;
key_part=table->key_info[idx].key_part; key_part=table->key_info[idx].key_part;
@ -26474,8 +26462,7 @@ static int test_if_order_by_key(JOIN *join,
DBUG_ENTER("test_if_order_by_key"); DBUG_ENTER("test_if_order_by_key");
if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) && if ((table->file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
table->key_info[idx].ext_key_part_map && table->key_info[idx].ext_key_part_map && pk != MAX_KEY && pk != idx)
pk != MAX_KEY && pk != idx)
{ {
have_pk_suffix= true; have_pk_suffix= true;
} }
@ -27078,9 +27065,7 @@ test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
// Step #1: Find indexes that produce the required ordering. // Step #1: Find indexes that produce the required ordering.
if (find_indexes_matching_order(tab->join, table, order, &usable_keys)) if (find_indexes_matching_order(tab->join, table, order, &usable_keys))
{
DBUG_RETURN(false); // Cannot skip sorting DBUG_RETURN(false); // Cannot skip sorting
}
/* /*
Step #2: Analyze the current access method. Note the used index as ref_key Step #2: Analyze the current access method. Note the used index as ref_key
@ -32729,8 +32714,7 @@ test_if_cheaper_ordering(bool in_join_optimizer,
temporary table + filesort could be cheaper for grouping temporary table + filesort could be cheaper for grouping
queries too. queries too.
*/ */
if (is_covering || if (is_covering || has_limit ||
has_limit ||
(ref_key < 0 && (group || table->force_index))) (ref_key < 0 && (group || table->force_index)))
{ {
double rec_per_key; double rec_per_key;
@ -32995,8 +32979,7 @@ uint get_index_for_order(ORDER *order, TABLE *table, SQL_SELECT *select,
int key, direction; int key, direction;
double new_cost; double new_cost;
if (test_if_cheaper_ordering(FALSE, NULL, order, table, if (test_if_cheaper_ordering(FALSE, NULL, order, table,
table->keys_in_use_for_order_by, -1, table->keys_in_use_for_order_by, -1, limit,
limit,
&key, &direction, &limit, &new_cost) && &key, &direction, &limit, &new_cost) &&
!is_key_used(table, key, table->write_set)) !is_key_used(table, key, table->write_set))
{ {

30
sql/sql_show.cc
View file

@ -2611,7 +2611,6 @@ static void store_key_options(THD *thd, String *packet, TABLE *table,
MODE_DB2 | MODE_DB2 |
MODE_MAXDB | MODE_MAXDB |
MODE_ANSI)) != 0; MODE_ANSI)) != 0;
char *end, buff[32];
if (!(thd->variables.sql_mode & MODE_NO_KEY_OPTIONS) && if (!(thd->variables.sql_mode & MODE_NO_KEY_OPTIONS) &&
!limited_mysql_mode && !foreign_db_mode) !limited_mysql_mode && !foreign_db_mode)
@ -2633,8 +2632,7 @@ static void store_key_options(THD *thd, String *packet, TABLE *table,
table->s->key_block_size != key_info->block_size) table->s->key_block_size != key_info->block_size)
{ {
packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE=")); packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
end= longlong10_to_str(key_info->block_size, buff, 10); packet->append_ulonglong(key_info->block_size);
packet->append(buff, (uint) (end - buff));
} }
DBUG_ASSERT(MY_TEST(key_info->flags & HA_USES_COMMENT) == DBUG_ASSERT(MY_TEST(key_info->flags & HA_USES_COMMENT) ==
(key_info->comment.length > 0)); (key_info->comment.length > 0));
@ -7299,9 +7297,8 @@ err:
} }
static int get_schema_stat_record(THD *thd, TABLE_LIST *tables, static int get_schema_stat_record(THD *thd, TABLE_LIST *tables, TABLE *table,
TABLE *table, bool res, bool res, const LEX_CSTRING *db_name,
const LEX_CSTRING *db_name,
const LEX_CSTRING *table_name) const LEX_CSTRING *table_name)
{ {
CHARSET_INFO *cs= system_charset_info; CHARSET_INFO *cs= system_charset_info;
@ -7309,7 +7306,7 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
if (!tables->view) if (!tables->view)
{ {
TABLE *show_table= tables->table; TABLE *show_table= tables->table;
KEY *key_info=show_table->s->key_info; KEY *key_info= show_table->s->key_info;
if (show_table->file) if (show_table->file)
{ {
(void) read_statistics_for_tables(thd, tables, false); (void) read_statistics_for_tables(thd, tables, false);
@ -7363,21 +7360,18 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
table->field[0]->store(STRING_WITH_LEN("def"), cs); table->field[0]->store(STRING_WITH_LEN("def"), cs);
table->field[1]->store(db_name->str, db_name->length, cs); table->field[1]->store(db_name->str, db_name->length, cs);
table->field[2]->store(table_name->str, table_name->length, cs); table->field[2]->store(table_name->str, table_name->length, cs);
table->field[3]->store((longlong) ((key_info->flags & table->field[3]->store(key_info->flags & HA_NOSAME ? 0 : 1, TRUE);
HA_NOSAME) ? 0 : 1), TRUE);
table->field[4]->store(db_name->str, db_name->length, cs); table->field[4]->store(db_name->str, db_name->length, cs);
table->field[5]->store(key_info->name.str, key_info->name.length, cs); table->field[5]->store(key_info->name.str, key_info->name.length, cs);
table->field[6]->store((longlong) (j+1), TRUE); table->field[6]->store((longlong) (j+1), TRUE);
str= (key_part->field ? &key_part->field->field_name : str= key_part->field ? &key_part->field->field_name : &unknown;
&unknown);
table->field[7]->store(str->str, str->length, cs); table->field[7]->store(str->str, str->length, cs);
if (show_table->file) if (show_table->file)
{ {
if (show_table->file->index_flags(i, j, 0) & HA_READ_ORDER) if (show_table->file->index_flags(i, j, 0) & HA_READ_ORDER)
{ {
table->field[8]->store(((key_part->key_part_flag & table->field[8]->store(key_part->key_part_flag & HA_REVERSE_SORT
HA_REVERSE_SORT) ? ? "D" : "A", 1, cs);
"D" : "A"), 1, cs);
table->field[8]->set_notnull(); table->field[8]->set_notnull();
} }
if (key_info->algorithm == HA_KEY_ALG_LONG_HASH) if (key_info->algorithm == HA_KEY_ALG_LONG_HASH)
@ -7389,11 +7383,11 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
from table as key_info points to TABLE_SHARE which has no from table as key_info points to TABLE_SHARE which has no
statistics. statistics.
*/ */
KEY *key_info= show_table->key_info + i; KEY *keyinfo= show_table->key_info + i;
if (key_info->rec_per_key[j]) if (keyinfo->rec_per_key[j])
{ {
ha_rows records= (ha_rows) ((double) show_table->stat_records() / ha_rows records= (ha_rows) ((double) show_table->stat_records() /
key_info->actual_rec_per_key(j)); keyinfo->actual_rec_per_key(j));
table->field[9]->store((longlong) records, TRUE); table->field[9]->store((longlong) records, TRUE);
table->field[9]->set_notnull(); table->field[9]->set_notnull();
} }
@ -7411,7 +7405,7 @@ static int get_schema_stat_record(THD *thd, TABLE_LIST *tables,
table->field[10]->set_notnull(); table->field[10]->set_notnull();
} }
uint flags= key_part->field ? key_part->field->flags : 0; uint flags= key_part->field ? key_part->field->flags : 0;
const char *pos=(char*) ((flags & NOT_NULL_FLAG) ? "" : "YES"); const char *pos= flags & NOT_NULL_FLAG ? "" : "YES";
table->field[12]->store(pos, strlen(pos), cs); table->field[12]->store(pos, strlen(pos), cs);
if (!show_table->s->keys_in_use.is_set(i)) if (!show_table->s->keys_in_use.is_set(i))
table->field[14]->store(STRING_WITH_LEN("disabled"), cs); table->field[14]->store(STRING_WITH_LEN("disabled"), cs);

164
sql/sql_table.cc
View file

@ -1208,8 +1208,7 @@ bool mysql_rm_table(THD *thd,TABLE_LIST *tables, bool if_exists,
/* mark for close and remove all cached entries */ /* mark for close and remove all cached entries */
thd->push_internal_handler(&err_handler); thd->push_internal_handler(&err_handler);
error= mysql_rm_table_no_locks(thd, tables, &thd->db, (DDL_LOG_STATE*) 0, error= mysql_rm_table_no_locks(thd, tables, &thd->db, (DDL_LOG_STATE*) 0,
if_exists, if_exists, drop_temporary,
drop_temporary,
false, drop_sequence, dont_log_query, false, drop_sequence, dont_log_query,
false); false);
thd->pop_internal_handler(); thd->pop_internal_handler();
@ -1306,32 +1305,28 @@ static uint32 get_comment(THD *thd, uint32 comment_pos,
int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
const LEX_CSTRING *current_db, const LEX_CSTRING *current_db,
DDL_LOG_STATE *ddl_log_state, DDL_LOG_STATE *ddl_log_state, bool if_exists,
bool if_exists,
bool drop_temporary, bool drop_view, bool drop_temporary, bool drop_view,
bool drop_sequence, bool drop_sequence, bool dont_log_query,
bool dont_log_query,
bool dont_free_locks) bool dont_free_locks)
{ {
TABLE_LIST *table; TABLE_LIST *table;
char path[FN_REFLEN + 1]; char path[FN_REFLEN + 1];
LEX_CSTRING alias= null_clex_str; LEX_CSTRING alias= null_clex_str;
LEX_CUSTRING version; LEX_CUSTRING version;
LEX_CSTRING partition_engine_name= {NULL, 0}; LEX_CSTRING partition_engine_name= null_clex_str;
StringBuffer<160> unknown_tables(system_charset_info); StringBuffer<160> unknown_tables(system_charset_info);
DDL_LOG_STATE local_ddl_log_state; DDL_LOG_STATE local_ddl_log_state;
const char *comment_start; const char *comment_start;
uint table_count= 0, non_temp_tables_count= 0; uint table_count= 0, non_temp_tables_count= 0;
int error= 0; int error= 0;
uint32 comment_len; size_t comment_len;
bool trans_tmp_table_deleted= 0, non_trans_tmp_table_deleted= 0; bool trans_tmp_table_deleted= 0, non_trans_tmp_table_deleted= 0;
bool is_drop_tmp_if_exists_added= 0, non_tmp_table_deleted= 0; bool is_drop_tmp_if_exists_added= 0, non_tmp_table_deleted= 0;
bool log_if_exists= if_exists; bool log_if_exists= if_exists;
const LEX_CSTRING *object_to_drop= ((drop_sequence) ? const LEX_CSTRING *object_to_drop= drop_sequence ? &SEQUENCE_clex_str
&SEQUENCE_clex_str : : &TABLE_clex_str;
&TABLE_clex_str); String normal_tables, built_trans_tmp_query, built_non_trans_tmp_query;
String normal_tables;
String built_trans_tmp_query, built_non_trans_tmp_query;
DBUG_ENTER("mysql_rm_table_no_locks"); DBUG_ENTER("mysql_rm_table_no_locks");
if (!ddl_log_state) if (!ddl_log_state)
@ -1456,7 +1451,7 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
} }
/* First try to delete temporary tables and temporary sequences */ /* First try to delete temporary tables and temporary sequences */
if ((table->open_type != OT_BASE_ONLY && is_temporary_table(table))) if (table->open_type != OT_BASE_ONLY && is_temporary_table(table))
{ {
table_creation_was_logged= table->table->s->table_creation_was_logged; table_creation_was_logged= table->table->s->table_creation_was_logged;
if (thd->drop_temporary_table(table->table, &is_trans, true)) if (thd->drop_temporary_table(table->table, &is_trans, true))
@ -1538,7 +1533,7 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
continue; continue;
} }
lex_string_set3(&cpath, path, (size_t) (path_end - path)); cpath = { path, (size_t)(path_end - path) };
{ {
char engine_buf[NAME_CHAR_LEN + 1]; char engine_buf[NAME_CHAR_LEN + 1];
@ -1560,7 +1555,7 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
if (!table_count++) if (!table_count++)
{ {
LEX_CSTRING comment= {comment_start, (size_t) comment_len}; LEX_CSTRING comment= {comment_start, comment_len};
if (ddl_log_drop_table_init(ddl_log_state, current_db, &comment)) if (ddl_log_drop_table_init(ddl_log_state, current_db, &comment))
{ {
error= 1; error= 1;
@ -1621,11 +1616,9 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
bool enoent_warning= !dont_log_query && !(hton && hton->discover_table); bool enoent_warning= !dont_log_query && !(hton && hton->discover_table);
if (was_view) if (was_view)
res= ddl_log_drop_view(ddl_log_state, &cpath, &db, res= ddl_log_drop_view(ddl_log_state, &cpath, &db, &table_name);
&table_name);
else else
res= ddl_log_drop_table(ddl_log_state, hton, &cpath, &db, res= ddl_log_drop_table(ddl_log_state, hton, &cpath, &db, &table_name);
&table_name);
if (res) if (res)
{ {
error= -1; error= -1;
@ -1633,8 +1626,7 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
} }
debug_crash_here("ddl_log_drop_before_delete_table"); debug_crash_here("ddl_log_drop_before_delete_table");
error= ha_delete_table(thd, hton, path, &db, &table_name, error= ha_delete_table(thd, hton, path, &db, &table_name, enoent_warning);
enoent_warning);
debug_crash_here("ddl_log_drop_after_delete_table"); debug_crash_here("ddl_log_drop_after_delete_table");
if (!error) if (!error)
@ -1702,8 +1694,7 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables,
int ferror= 0; int ferror= 0;
DBUG_ASSERT(!was_view); DBUG_ASSERT(!was_view);
if (ddl_log_drop_table(ddl_log_state, 0, &cpath, &db, if (ddl_log_drop_table(ddl_log_state, 0, &cpath, &db, &table_name))
&table_name))
{ {
error= -1; error= -1;
goto err; goto err;
@ -1762,7 +1753,6 @@ report_error:
uint is_note= (if_exists && (was_view || wrong_drop_sequence) ? uint is_note= (if_exists && (was_view || wrong_drop_sequence) ?
ME_NOTE : 0); ME_NOTE : 0);
tbl_name.length(0);
tbl_name.append(&db); tbl_name.append(&db);
tbl_name.append('.'); tbl_name.append('.');
tbl_name.append(&table_name); tbl_name.append(&table_name);
@ -1890,9 +1880,8 @@ err:
built_non_trans_tmp_query.append(generated_by_server); built_non_trans_tmp_query.append(generated_by_server);
error |= (thd->binlog_query(THD::STMT_QUERY_TYPE, error |= (thd->binlog_query(THD::STMT_QUERY_TYPE,
built_non_trans_tmp_query.ptr(), built_non_trans_tmp_query.ptr(),
built_non_trans_tmp_query.length(), built_non_trans_tmp_query.length(), FALSE,
FALSE, FALSE, FALSE, is_drop_tmp_if_exists_added,
is_drop_tmp_if_exists_added,
0) > 0); 0) > 0);
} }
if (trans_tmp_table_deleted) if (trans_tmp_table_deleted)
@ -1902,9 +1891,8 @@ err:
built_trans_tmp_query.append(generated_by_server); built_trans_tmp_query.append(generated_by_server);
error |= (thd->binlog_query(THD::STMT_QUERY_TYPE, error |= (thd->binlog_query(THD::STMT_QUERY_TYPE,
built_trans_tmp_query.ptr(), built_trans_tmp_query.ptr(),
built_trans_tmp_query.length(), built_trans_tmp_query.length(), TRUE,
TRUE, FALSE, FALSE, is_drop_tmp_if_exists_added,
is_drop_tmp_if_exists_added,
0) > 0); 0) > 0);
} }
if (non_tmp_table_deleted) if (non_tmp_table_deleted)
@ -1932,8 +1920,7 @@ err:
thd->binlog_xid= thd->query_id; thd->binlog_xid= thd->query_id;
ddl_log_update_xid(ddl_log_state, thd->binlog_xid); ddl_log_update_xid(ddl_log_state, thd->binlog_xid);
error |= (thd->binlog_query(THD::STMT_QUERY_TYPE, error |= (thd->binlog_query(THD::STMT_QUERY_TYPE,
built_query.ptr(), built_query.ptr(), built_query.length(),
built_query.length(),
TRUE, FALSE, FALSE, 0) > 0); TRUE, FALSE, FALSE, 0) > 0);
thd->binlog_xid= 0; thd->binlog_xid= 0;
} }
@ -2101,6 +2088,7 @@ bool quick_rm_table(THD *thd, handlerton *base, const LEX_CSTRING *db,
DBUG_RETURN(error); DBUG_RETURN(error);
} }
#define return_if_nonzero(X) do { if (int r=(X)) return r; } while(0)
/* /*
Sort keys in the following order: Sort keys in the following order:
@ -2119,48 +2107,37 @@ bool quick_rm_table(THD *thd, handlerton *base, const LEX_CSTRING *db,
static int sort_keys(KEY *a, KEY *b) static int sort_keys(KEY *a, KEY *b)
{ {
ulong a_flags= a->flags, b_flags= b->flags; ulong a_flags= a->flags, b_flags= b->flags;
/* /*
Do not reorder LONG_HASH indexes, because they must match the order Do not reorder HA_KEY_ALG_LONG_HASH indexes, because they must match the
of their LONG_UNIQUE_HASH_FIELD's. order of their LONG_UNIQUE_HASH_FIELD's.
*/ */
if (a->algorithm == HA_KEY_ALG_LONG_HASH && if (a->algorithm == HA_KEY_ALG_LONG_HASH &&
b->algorithm == HA_KEY_ALG_LONG_HASH) b->algorithm == HA_KEY_ALG_LONG_HASH)
return a->usable_key_parts - b->usable_key_parts; return a->usable_key_parts - b->usable_key_parts;
return_if_nonzero((b_flags & HA_NOSAME) - (a_flags & HA_NOSAME));
/* historically, rules below apply only to UNIQUE keys */
if (a_flags & HA_NOSAME) if (a_flags & HA_NOSAME)
{ {
if (!(b_flags & HA_NOSAME)) /* Long Unique keys should always be last unique key. */
return -1; return_if_nonzero((a->algorithm == HA_KEY_ALG_LONG_HASH) -
/* (b->algorithm == HA_KEY_ALG_LONG_HASH));
Long Unique keys should always be last unique key.
Before this patch they used to change order wrt to partial keys
(MDEV-19049)
*/
if (a->algorithm == HA_KEY_ALG_LONG_HASH)
return 1;
if (b->algorithm == HA_KEY_ALG_LONG_HASH)
return -1;
if ((a_flags ^ b_flags) & HA_NULL_PART_KEY)
{
/* Sort NOT NULL keys before other keys */
return (a_flags & HA_NULL_PART_KEY) ? 1 : -1;
}
if (a->name.str == primary_key_name.str)
return -1;
if (b->name.str == primary_key_name.str)
return 1;
/* Sort keys don't containing partial segments before others */
if ((a_flags ^ b_flags) & HA_KEY_HAS_PART_KEY_SEG)
return (a_flags & HA_KEY_HAS_PART_KEY_SEG) ? 1 : -1;
}
else if (b_flags & HA_NOSAME)
return 1; // Prefer b
if ((a_flags ^ b_flags) & HA_FULLTEXT) /* Sort NOT NULL keys before other keys */
{ return_if_nonzero((a_flags & HA_NULL_PART_KEY) -
return (a_flags & HA_FULLTEXT) ? 1 : -1; (b_flags & HA_NULL_PART_KEY));
return_if_nonzero((b->name.str == primary_key_name.str) -
(a->name.str == primary_key_name.str));
/* Sort keys don't containing partial segments before others */
return_if_nonzero((a_flags & HA_KEY_HAS_PART_KEY_SEG) -
(b_flags & HA_KEY_HAS_PART_KEY_SEG));
} }
return_if_nonzero((a_flags & HA_FULLTEXT) -
(b_flags & HA_FULLTEXT));
/* /*
Prefer original key order. usable_key_parts contains here Prefer original key order. usable_key_parts contains here
the original key position. the original key position.
@ -2619,8 +2596,8 @@ static inline void make_long_hash_field_name(LEX_CSTRING *buf, uint num)
@param create_list List of table fields. @param create_list List of table fields.
@param key_info current long unique key info @param key_info current long unique key info
*/ */
static Create_field * add_hash_field(THD * thd, List<Create_field> *create_list, static Create_field *add_hash_field(THD *thd, List<Create_field> *create_list,
KEY *key_info) KEY *key_info)
{ {
List_iterator<Create_field> it(*create_list); List_iterator<Create_field> it(*create_list);
Create_field *dup_field, *cf= new (thd->mem_root) Create_field(); Create_field *dup_field, *cf= new (thd->mem_root) Create_field();
@ -2632,7 +2609,7 @@ static Create_field * add_hash_field(THD * thd, List<Create_field> *create_list,
cf->vcol_info= new (thd->mem_root) Virtual_column_info(); cf->vcol_info= new (thd->mem_root) Virtual_column_info();
cf->vcol_info->set_vcol_type(VCOL_GENERATED_VIRTUAL); cf->vcol_info->set_vcol_type(VCOL_GENERATED_VIRTUAL);
uint num= 1; uint num= 1;
LEX_CSTRING field_name; Lex_ident_column field_name;
field_name.str= (char *)thd->alloc(LONG_HASH_FIELD_NAME_LENGTH); field_name.str= (char *)thd->alloc(LONG_HASH_FIELD_NAME_LENGTH);
make_long_hash_field_name(&field_name, num); make_long_hash_field_name(&field_name, num);
/* /*
@ -3340,11 +3317,11 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
} }
cols2.rewind(); cols2.rewind();
const Type_handler *field_type= sql_field->type_handler();
switch(key->type) { switch(key->type) {
case Key::FULLTEXT: case Key::FULLTEXT:
if (sql_field->type_handler()->Key_part_spec_init_ft(column, if (field_type->Key_part_spec_init_ft(column, *sql_field) ||
*sql_field) ||
(ft_key_charset && sql_field->charset != ft_key_charset)) (ft_key_charset && sql_field->charset != ft_key_charset))
{ {
my_error(ER_BAD_FT_COLUMN, MYF(0), column->field_name.str); my_error(ER_BAD_FT_COLUMN, MYF(0), column->field_name.str);
@ -3354,8 +3331,7 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
break; break;
case Key::SPATIAL: case Key::SPATIAL:
if (sql_field->type_handler()->Key_part_spec_init_spatial(column, if (field_type->Key_part_spec_init_spatial(column, *sql_field) ||
*sql_field) ||
sql_field->check_vcol_for_key(thd)) sql_field->check_vcol_for_key(thd))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
if (!(sql_field->flags & NOT_NULL_FLAG)) if (!(sql_field->flags & NOT_NULL_FLAG))
@ -3372,9 +3348,7 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
my_error(ER_PRIMARY_KEY_BASED_ON_GENERATED_COLUMN, MYF(0)); my_error(ER_PRIMARY_KEY_BASED_ON_GENERATED_COLUMN, MYF(0));
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
if (sql_field->type_handler()->Key_part_spec_init_primary(column, if (field_type->Key_part_spec_init_primary(column, *sql_field, file))
*sql_field,
file))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
if (!(sql_field->flags & NOT_NULL_FLAG)) if (!(sql_field->flags & NOT_NULL_FLAG))
{ {
@ -3386,27 +3360,22 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
break; break;
case Key::MULTIPLE: case Key::MULTIPLE:
if (sql_field->type_handler()->Key_part_spec_init_multiple(column, if (field_type->Key_part_spec_init_multiple(column, *sql_field, file) ||
*sql_field,
file) ||
sql_field->check_vcol_for_key(thd) || sql_field->check_vcol_for_key(thd) ||
key_add_part_check_null(file, key_info, sql_field, column)) key_add_part_check_null(file, key_info, sql_field, column))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
break; break;
case Key::FOREIGN_KEY: case Key::FOREIGN_KEY:
if (sql_field->type_handler()->Key_part_spec_init_foreign(column, if (field_type->Key_part_spec_init_foreign(column, *sql_field, file) ||
*sql_field,
file) ||
sql_field->check_vcol_for_key(thd) || sql_field->check_vcol_for_key(thd) ||
key_add_part_check_null(file, key_info, sql_field, column)) key_add_part_check_null(file, key_info, sql_field, column))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
break; break;
case Key::UNIQUE: case Key::UNIQUE:
if (sql_field->type_handler()->Key_part_spec_init_unique(column, if (field_type->Key_part_spec_init_unique(column, *sql_field, file,
*sql_field, file, &is_hash_field_needed) ||
&is_hash_field_needed) ||
sql_field->check_vcol_for_key(thd) || sql_field->check_vcol_for_key(thd) ||
key_add_part_check_null(file, key_info, sql_field, column)) key_add_part_check_null(file, key_info, sql_field, column))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
@ -3428,8 +3397,7 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
key_part_info->offset= (uint16) sql_field->offset; key_part_info->offset= (uint16) sql_field->offset;
key_part_info->key_type=sql_field->pack_flag; key_part_info->key_type=sql_field->pack_flag;
key_part_info->key_part_flag= column->asc ? 0 : HA_REVERSE_SORT; key_part_info->key_part_flag= column->asc ? 0 : HA_REVERSE_SORT;
uint key_part_length= sql_field->type_handler()-> uint key_part_length= field_type->calc_key_length(*sql_field);
calc_key_length(*sql_field);
if (column->length) if (column->length)
{ {
@ -3460,7 +3428,7 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
// is prefix length bigger than field length? // is prefix length bigger than field length?
(column->length > key_part_length || (column->length > key_part_length ||
// can the field have a partial key? // can the field have a partial key?
!sql_field->type_handler()->type_can_have_key_part() || !field_type->type_can_have_key_part() ||
// a packed field can't be used in a partial key // a packed field can't be used in a partial key
f_is_packed(sql_field->pack_flag) || f_is_packed(sql_field->pack_flag) ||
// does the storage engine allow prefixed search? // does the storage engine allow prefixed search?
@ -3524,12 +3492,11 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
(key_part_length >= KEY_DEFAULT_PACK_LENGTH) && (key_part_length >= KEY_DEFAULT_PACK_LENGTH) &&
!is_hash_field_needed) !is_hash_field_needed)
{ {
key_info->flags|= sql_field->type_handler()->KEY_pack_flags(column_nr); key_info->flags|= field_type->KEY_pack_flags(column_nr);
} }
/* Check if the key segment is partial, set the key flag accordingly */ /* Check if the key segment is partial, set the key flag accordingly */
if (key_part_length != sql_field->type_handler()-> if (key_part_length != field_type->calc_key_length(*sql_field) &&
calc_key_length(*sql_field) && key_part_length != field_type->max_octet_length())
key_part_length != sql_field->type_handler()->max_octet_length())
key_info->flags|= HA_KEY_HAS_PART_KEY_SEG; key_info->flags|= HA_KEY_HAS_PART_KEY_SEG;
key_length+= key_part_length; key_length+= key_part_length;
@ -3558,12 +3525,11 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
if (auto_increment_key) if (auto_increment_key)
{ {
my_error(ER_NO_AUTOINCREMENT_WITH_UNIQUE, MYF(0), my_error(ER_NO_AUTOINCREMENT_WITH_UNIQUE, MYF(0),
sql_field->field_name.str, sql_field->field_name.str, key_info->name.str);
key_info->name.str);
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
if (key_info->algorithm != HA_KEY_ALG_UNDEF && if (key_info->algorithm != HA_KEY_ALG_UNDEF &&
key_info->algorithm != HA_KEY_ALG_HASH ) key_info->algorithm != HA_KEY_ALG_HASH)
{ {
my_error(ER_TOO_LONG_KEY, MYF(0), max_key_length); my_error(ER_TOO_LONG_KEY, MYF(0), max_key_length);
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
@ -3571,8 +3537,7 @@ mysql_prepare_create_table_finalize(THD *thd, HA_CREATE_INFO *create_info,
} }
if (is_hash_field_needed || if (is_hash_field_needed ||
(key_info->algorithm == HA_KEY_ALG_HASH && (key_info->algorithm == HA_KEY_ALG_HASH &&
key->type != Key::PRIMARY && key->type != Key::PRIMARY && key_info->flags & HA_NOSAME &&
key_info->flags & HA_NOSAME &&
!(file->ha_table_flags() & HA_CAN_HASH_KEYS ) && !(file->ha_table_flags() & HA_CAN_HASH_KEYS ) &&
file->ha_table_flags() & HA_CAN_VIRTUAL_COLUMNS)) file->ha_table_flags() & HA_CAN_VIRTUAL_COLUMNS))
{ {
@ -4783,10 +4748,9 @@ int mysql_create_table_no_lock(THD *thd,
} }
lex_string_set3(&cpath, path, path_length); lex_string_set3(&cpath, path, path_length);
res= create_table_impl(thd, ddl_log_state_create, ddl_log_state_rm, res= create_table_impl(thd, ddl_log_state_create, ddl_log_state_rm, *db,
*db, *table_name, *db, *table_name, cpath, *table_name, *db, *table_name, cpath, *create_info,
*create_info, create_info, create_info, alter_info, create_table_mode,
alter_info, create_table_mode,
is_trans, &not_used_1, &not_used_2, &frm); is_trans, &not_used_1, &not_used_2, &frm);
my_free(const_cast<uchar*>(frm.str)); my_free(const_cast<uchar*>(frm.str));

3
sql/sql_trigger.cc
View file

@ -1385,8 +1385,7 @@ bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables,
/* This code is executed in case of DROP TRIGGER */ /* This code is executed in case of DROP TRIGGER */
lex_string_set3(&query, thd->query(), thd->query_length()); lex_string_set3(&query, thd->query(), thd->query_length());
} }
if (ddl_log_drop_trigger(ddl_log_state, if (ddl_log_drop_trigger(ddl_log_state, &tables->db, &tables->table_name,
&tables->db, &tables->table_name,
sp_name, &query)) sp_name, &query))
goto err; goto err;
} }

8
sql/sys_vars.cc
View file

@ -7452,12 +7452,6 @@ static Sys_var_ulonglong Sys_binlog_large_commit_threshold(
"binlogging", "binlogging",
GLOBAL_VAR(opt_binlog_commit_by_rotate_threshold), GLOBAL_VAR(opt_binlog_commit_by_rotate_threshold),
CMD_LINE(REQUIRED_ARG), CMD_LINE(REQUIRED_ARG),
#ifndef DBUG_OFF
// Allow a smaller minimum value for debug builds to help with testing // Allow a smaller minimum value for debug builds to help with testing
VALID_RANGE(100 * 1024, ULLONG_MAX), VALID_RANGE(IF_DBUG(100, 10240) * 1024, ULLONG_MAX),
#else
VALID_RANGE(10 * 1024 * 1024, ULLONG_MAX),
#endif
DEFAULT(128 * 1024 * 1024), BLOCK_SIZE(1)); DEFAULT(128 * 1024 * 1024), BLOCK_SIZE(1));

28
sql/table.cc
View file

@ -789,11 +789,9 @@ err_not_open:
} }
static bool create_key_infos(const uchar *strpos, const uchar *frm_image_end, static bool create_key_infos(const uchar *strpos, const uchar *frm_image_end,
uint keys, KEY *keyinfo, uint keys, KEY *keyinfo, uint new_frm_ver,
uint new_frm_ver, uint *ext_key_parts, uint *ext_key_parts, TABLE_SHARE *share, uint len,
TABLE_SHARE *share, uint len, KEY *first_keyinfo, LEX_STRING *keynames)
KEY *first_keyinfo,
LEX_STRING *keynames)
{ {
uint i, j, n_length; uint i, j, n_length;
uint primary_key_parts= 0; uint primary_key_parts= 0;
@ -882,26 +880,25 @@ static bool create_key_infos(const uchar *strpos, const uchar *frm_image_end,
{ {
if (strpos + (new_frm_ver >= 1 ? 9 : 7) >= frm_image_end) if (strpos + (new_frm_ver >= 1 ? 9 : 7) >= frm_image_end)
return 1; return 1;
if (!(keyinfo->algorithm == HA_KEY_ALG_LONG_HASH)) if (keyinfo->algorithm != HA_KEY_ALG_LONG_HASH)
rec_per_key++; rec_per_key++;
key_part->fieldnr= (uint16) (uint2korr(strpos) & FIELD_NR_MASK); key_part->fieldnr= (uint16) (uint2korr(strpos) & FIELD_NR_MASK);
key_part->offset= (uint) uint2korr(strpos+2)-1; key_part->offset= (uint) uint2korr(strpos+2)-1;
key_part->key_type= (uint) uint2korr(strpos+5); key_part->key_type= (uint) uint2korr(strpos+5);
// key_part->field= (Field*) 0; // Will be fixed later
if (new_frm_ver >= 1) if (new_frm_ver >= 1)
{ {
key_part->key_part_flag= *(strpos+4); key_part->key_part_flag= *(strpos+4);
key_part->length= (uint) uint2korr(strpos+7); key_part->length= (uint) uint2korr(strpos+7);
strpos+=9; strpos+=9;
} }
else else
{ {
key_part->length= *(strpos+4); key_part->length= *(strpos+4);
key_part->key_part_flag=0; key_part->key_part_flag=0;
if (key_part->length > 128) if (key_part->length > 128)
{ {
key_part->length&=127; /* purecov: inspected */ key_part->length&= 127;
key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */ key_part->key_part_flag=HA_REVERSE_SORT;
} }
strpos+=7; strpos+=7;
} }
@ -4164,8 +4161,7 @@ bool copy_keys_from_share(TABLE *outparam, MEM_ROOT *root)
KEY_PART_INFO *key_part; KEY_PART_INFO *key_part;
if (!multi_alloc_root(root, &key_info, share->keys*sizeof(KEY), if (!multi_alloc_root(root, &key_info, share->keys*sizeof(KEY),
&key_part, &key_part, share->ext_key_parts*sizeof(KEY_PART_INFO),
share->ext_key_parts*sizeof(KEY_PART_INFO),
NullS)) NullS))
return 1; return 1;

5
storage/maria/ma_check.c
View file

@ -733,9 +733,8 @@ static int chk_index_down(HA_CHECK *param, MARIA_HA *info,
if (page + keyinfo->block_length > max_length) if (page + keyinfo->block_length > max_length)
goto err; goto err;
/* Fix the remembered key file length. */ /* Fix the remembered key file length. */
share->state.state.key_file_length= (max_length & share->state.state.key_file_length=
~ (my_off_t) (keyinfo->block_length - max_length & ~ (my_off_t) (keyinfo->block_length - 1);
1));
/* purecov: end */ /* purecov: end */
} }

8
storage/myisam/mi_open.c
View file

@ -1367,13 +1367,9 @@ int mi_indexes_are_disabled(MI_INFO *info)
{ {
MYISAM_SHARE *share= info->s; MYISAM_SHARE *share= info->s;
/* /* No keys or all are enabled */
No keys or all are enabled. keys is the number of keys. Left shifted
gives us only one bit set. When decreased by one, gives us all all bits
up to this one set and it gets unset.
*/
if (!share->base.keys || if (!share->base.keys ||
(mi_is_all_keys_active(share->state.key_map, share->base.keys))) mi_is_all_keys_active(share->state.key_map, share->base.keys))
return 0; return 0;
/* All are disabled */ /* All are disabled */