1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MDEV-4022 table attributes with sysvar as a default value

Browse Source
This commit is contained in:
Sergei Golubchik 2013-04-09 23:27:24 +02:00
parent 7d3288129f
commit 5f293dd694
11 changed files with 265 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mysql-test/r/partition_example.result
View File

@ -7,7 +7,7 @@ show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) NOT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `VAROPT`='5'
/*!50100 PARTITION BY LIST (a)
(PARTITION p0 VALUES IN (1) ENGINE = EXAMPLE,
PARTITION p1 VALUES IN (2) ENGINE = EXAMPLE) */
@ -20,7 +20,7 @@ show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) NOT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ull`=12340
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ull`=12340 `VAROPT`='5'
/*!50100 PARTITION BY LIST (a)
(PARTITION p0 VALUES IN (1) ENGINE = EXAMPLE,
PARTITION p1 VALUES IN (2) ENGINE = EXAMPLE) */

36
mysql-test/r/plugin.result
View File

@ -49,6 +49,7 @@ show variables like 'example%';
Variable_name Value
example_enum_var e1
example_ulong_var 500
example_varopt_default 5
UNINSTALL SONAME 'ha_example';
Warnings:
Warning 1620 Plugin is busy and will be uninstalled on shutdown
@ -119,7 +120,7 @@ show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL `complex`='c,f,f,f'
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ULL`=10000 `STR`='dskj' `one_or_two`='one' `YESNO`=0
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ULL`=10000 `STR`='dskj' `one_or_two`='one' `YESNO`=0 `VAROPT`='5'
drop table t1;
SET @OLD_SQL_MODE=@@SQL_MODE;
SET SQL_MODE='IGNORE_BAD_TABLE_OPTIONS';
@ -133,20 +134,20 @@ show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ULL`=10000000000000000000 `one_or_two`='ttt' `YESNO`=SSS
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ULL`=10000000000000000000 `one_or_two`='ttt' `YESNO`=SSS `VAROPT`='5'
#alter table
alter table t1 ULL=10000000;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `one_or_two`='ttt' `YESNO`=SSS `ULL`=10000000
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `one_or_two`='ttt' `YESNO`=SSS `VAROPT`='5' `ULL`=10000000
alter table t1 change a a int complex='c,c,c';
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL `complex`='c,c,c'
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `one_or_two`='ttt' `YESNO`=SSS `ULL`=10000000
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `one_or_two`='ttt' `YESNO`=SSS `VAROPT`='5' `ULL`=10000000
drop table t1;
#illegal value error
SET SQL_MODE='';
@ -161,17 +162,38 @@ SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ULL`=4660
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `ULL`=4660 `VAROPT`='5'
SET example_varopt_default=33;
select create_options from information_schema.tables where table_schema='test' and table_name='t1';
create_options
`ULL`=4660
`ULL`=4660 `VAROPT`='5'
ALTER TABLE t1 ULL=DEFAULT;
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `VAROPT`='5'
DROP TABLE t1;
create table t1 (a int) engine=example;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `VAROPT`='33'
drop table t1;
create table t1 (a int) engine=example varopt=15;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `varopt`=15
alter table t1 varopt=default;
show create table t1;
Table Create Table
t1 CREATE TABLE `t1` (
`a` int(11) DEFAULT NULL
) ENGINE=EXAMPLE DEFAULT CHARSET=latin1 `VAROPT`='33'
drop table t1;
SET @@SQL_MODE=@OLD_SQL_MODE;
select 1;
1

11
mysql-test/t/plugin.test
View File

@ -144,6 +144,7 @@ CREATE TABLE t1 (a int) ENGINE=example ULL=1e2;
CREATE TABLE t1 (a int) ENGINE=example ULL=0x1234;
SHOW CREATE TABLE t1;
SET example_varopt_default=33; # does not affect varopt of t1
select create_options from information_schema.tables where table_schema='test' and table_name='t1';
@ -152,6 +153,16 @@ SHOW CREATE TABLE t1;
DROP TABLE t1;
create table t1 (a int) engine=example; # varopt is 10
show create table t1;
drop table t1;
create table t1 (a int) engine=example varopt=15;
show create table t1;
alter table t1 varopt=default;
show create table t1;
drop table t1;
SET @@SQL_MODE=@OLD_SQL_MODE;
#

175
sql/create_options.cc
View File

@ -21,6 +21,7 @@
#include "create_options.h"
#include <my_getopt.h>
#include "set_var.h"
#define FRM_QUOTED_VALUE 0x8000
@ -115,7 +116,7 @@ static bool report_unknown_option(THD *thd, engine_option_value *val,
}
static bool set_one_value(ha_create_table_option *opt,
THD *thd, LEX_STRING *value, void *base,
THD *thd, const LEX_STRING *value, void *base,
bool suppress_warning,
MEM_ROOT *root)
{
@ -126,6 +127,8 @@ static bool set_one_value(ha_create_table_option *opt,
(value->str ? value->str : "<DEFAULT>")));
switch (opt->type)
{
case HA_OPTION_TYPE_SYSVAR:
DBUG_ASSERT(0); // HA_OPTION_TYPE_SYSVAR's are replaced in resolve_sysvars()
case HA_OPTION_TYPE_ULL:
{
ulonglong *val= (ulonglong*)((char*)base + opt->offset);
@ -257,51 +260,92 @@ static const size_t ha_option_type_sizeof[]=
@retval FALSE OK
*/
bool parse_option_list(THD* thd, void *option_struct_arg,
engine_option_value *option_list,
bool parse_option_list(THD* thd, handlerton *hton, void *option_struct_arg,
engine_option_value **option_list,
ha_create_table_option *rules,
bool suppress_warning, MEM_ROOT *root)
{
ha_create_table_option *opt;
size_t option_struct_size= 0;
engine_option_value *val= option_list;
engine_option_value *val, *last;
void **option_struct= (void**)option_struct_arg;
DBUG_ENTER("parse_option_list");
DBUG_PRINT("enter",
("struct: %p list: %p rules: %p suppress_warning: %u root: %p",
*option_struct, option_list, rules,
*option_struct, *option_list, rules,
(uint) suppress_warning, root));
if (rules)
{
LEX_STRING default_val= null_lex_str;
for (opt= rules; opt->name; opt++)
set_if_bigger(option_struct_size, opt->offset +
ha_option_type_sizeof[opt->type]);
*option_struct= alloc_root(root, option_struct_size);
/* set all values to default */
for (opt= rules; opt->name; opt++)
set_one_value(opt, thd, &default_val, *option_struct,
suppress_warning, root);
}
for (; val; val= val->next)
for (opt= rules; opt && opt->name; opt++)
{
for (opt= rules; opt && opt->name; opt++)
bool seen=false;
for (val= *option_list; val; val= val->next)
{
last= val;
if (my_strnncoll(system_charset_info,
(uchar*)opt->name, opt->name_length,
(uchar*)val->name.str, val->name.length))
continue;
seen=true;
if (val->parsed && !val->value.str)
continue;
if (set_one_value(opt, thd, &val->value,
*option_struct, suppress_warning || val->parsed, root))
DBUG_RETURN(TRUE);
val->parsed= true;
break;
}
if (!seen)
{
LEX_STRING default_val= null_lex_str;
/*
If it's CREATE/ALTER TABLE parsing mode (options are created in the
transient thd->mem_root, not in the long living TABLE_SHARE::mem_root),
and variable-backed option was not explicitly set.
If it's not create, but opening of the existing frm (that was,
probably, created with the older version of the storage engine and
does not have this option stored), we take the *default* value of the
sysvar, not the *current* value. Because we don't want to have
different option values for the same table if it's opened many times.
*/
if (root == thd->mem_root && opt->var)
{
// take a value from the variable and add it to the list
sys_var *sysvar= find_hton_sysvar(hton, opt->var);
DBUG_ASSERT(sysvar);
char buf[256];
String sbuf(buf, sizeof(buf), system_charset_info), *str;
if ((str= sysvar->val_str(&sbuf, thd, OPT_SESSION, 0)))
{
LEX_STRING name= { const_cast<char*>(opt->name), opt->name_length };
default_val.str= strmake_root(root, str->ptr(), str->length());
default_val.length= str->length();
val= new (root) engine_option_value(name, default_val, true,
option_list, &last);
val->parsed= true;
}
}
set_one_value(opt, thd, &default_val, *option_struct,
suppress_warning, root);
}
}
for (val= *option_list; val; val= val->next)
{
if (report_unknown_option(thd, val, suppress_warning))
DBUG_RETURN(TRUE);
val->parsed= true;
@ -311,6 +355,102 @@ bool parse_option_list(THD* thd, void *option_struct_arg,
}
/**
Resolves all HA_OPTION_TYPE_SYSVAR elements.
This is done when an engine is loaded.
*/
static bool resolve_sysvars(handlerton *hton, ha_create_table_option *rules)
{
for (ha_create_table_option *opt= rules; opt && opt->name; opt++)
{
if (opt->type == HA_OPTION_TYPE_SYSVAR)
{
struct my_option optp;
plugin_opt_set_limits(&optp, opt->var);
switch(optp.var_type) {
case GET_ULL:
case GET_ULONG:
case GET_UINT:
opt->type= HA_OPTION_TYPE_ULL;
opt->def_value= (ulonglong)optp.def_value;
opt->min_value= (ulonglong)optp.min_value;
opt->max_value= (ulonglong)optp.max_value;
opt->block_size= (ulonglong)optp.block_size;
break;
case GET_STR:
case GET_STR_ALLOC:
opt->type= HA_OPTION_TYPE_STRING;
break;
case GET_BOOL:
opt->type= HA_OPTION_TYPE_BOOL;
opt->def_value= optp.def_value;
break;
case GET_ENUM:
{
opt->type= HA_OPTION_TYPE_ENUM;
opt->def_value= optp.def_value;
char buf[256];
String str(buf, sizeof(buf), system_charset_info);
for (const char **s= optp.typelib->type_names; *s; s++)
{
if (str.append(*s) || str.append(','))
return 1;
}
DBUG_ASSERT(str.length());
opt->values= my_strndup(str.ptr(), str.length()-1, MYF(MY_WME));
if (!opt->values)
return 1;
break;
}
default:
DBUG_ASSERT(0);
}
}
}
return 0;
}
bool resolve_sysvar_table_options(handlerton *hton)
{
return resolve_sysvars(hton, hton->table_options) ||
resolve_sysvars(hton, hton->field_options) ||
resolve_sysvars(hton, hton->index_options);
}
/*
Restore HA_OPTION_TYPE_SYSVAR options back as they were
before resolve_sysvars().
This is done when the engine is unloaded, so that we could
call resolve_sysvars() if the engine is installed again.
*/
static void free_sysvars(handlerton *hton, ha_create_table_option *rules)
{
for (ha_create_table_option *opt= rules; opt && opt->name; opt++)
{
if (opt->var)
{
my_free(const_cast<char*>(opt->values));
opt->type= HA_OPTION_TYPE_SYSVAR;
opt->def_value= 0;
opt->min_value= 0;
opt->max_value= 0;
opt->block_size= 0;
opt->values= 0;
}
}
}
void free_sysvar_table_options(handlerton *hton)
{
free_sysvars(hton, hton->table_options);
free_sysvars(hton, hton->field_options);
free_sysvars(hton, hton->index_options);
}
/**
Parses all table/fields/keys options
@ -327,21 +467,22 @@ bool parse_engine_table_options(THD *thd, handlerton *ht, TABLE_SHARE *share)
MEM_ROOT *root= &share->mem_root;
DBUG_ENTER("parse_engine_table_options");
if (parse_option_list(thd, &share->option_struct, share->option_list,
if (parse_option_list(thd, ht, &share->option_struct, & share->option_list,
ht->table_options, TRUE, root))
DBUG_RETURN(TRUE);
for (Field **field= share->field; *field; field++)
{
if (parse_option_list(thd, &(*field)->option_struct, (*field)->option_list,
if (parse_option_list(thd, ht, &(*field)->option_struct,
& (*field)->option_list,
ht->field_options, TRUE, root))
DBUG_RETURN(TRUE);
}
for (uint index= 0; index < share->keys; index ++)
{
if (parse_option_list(thd, &share->key_info[index].option_struct,
share->key_info[index].option_list,
if (parse_option_list(thd, ht, &share->key_info[index].option_struct,
& share->key_info[index].option_list,
ht->index_options, TRUE, root))
DBUG_RETURN(TRUE);
}

6
sql/create_options.h
View File

@ -69,9 +69,11 @@ class engine_option_value: public Sql_alloc
typedef struct st_key KEY;
class Create_field;
bool resolve_sysvar_table_options(handlerton *hton);
void free_sysvar_table_options(handlerton *hton);
bool parse_engine_table_options(THD *thd, handlerton *ht, TABLE_SHARE *share);
bool parse_option_list(THD* thd, void *option_struct,
engine_option_value *option_list,
bool parse_option_list(THD* thd, handlerton *hton, void *option_struct,
engine_option_value **option_list,
ha_create_table_option *rules,
bool suppress_warning, MEM_ROOT *root);
bool engine_table_options_frm_read(const uchar *buff, uint length,

6
sql/handler.cc
View File

@ -448,6 +448,9 @@ int ha_finalize_handlerton(st_plugin_int *plugin)
}
}
free_sysvar_table_options(hton);
update_discovery_counters(hton, -1);
/*
In case a plugin is uninstalled and re-installed later, it should
reuse an array slot. Otherwise the number of uninstall/install
@ -461,8 +464,6 @@ int ha_finalize_handlerton(st_plugin_int *plugin)
hton2plugin[hton->slot]= NULL;
}
update_discovery_counters(hton, -1);
my_free(hton);
end:
@ -603,6 +604,7 @@ int ha_initialize_handlerton(st_plugin_int *plugin)
break;
};
resolve_sysvar_table_options(hton);
update_discovery_counters(hton, 1);
DBUG_RETURN(0);

28
sql/handler.h
View File

@ -714,22 +714,26 @@ struct ha_index_option_struct;
enum ha_option_type { HA_OPTION_TYPE_ULL, /* unsigned long long */
HA_OPTION_TYPE_STRING, /* char * */
HA_OPTION_TYPE_ENUM, /* uint */
HA_OPTION_TYPE_BOOL}; /* bool */
HA_OPTION_TYPE_BOOL, /* bool */
HA_OPTION_TYPE_SYSVAR};/* type of the sysval */
#define HA_xOPTION_NUMBER(name, struc, field, def, min, max, blk_siz) \
{ HA_OPTION_TYPE_ULL, name, sizeof(name)-1, \
offsetof(struc, field), def, min, max, blk_siz, 0 }
offsetof(struc, field), def, min, max, blk_siz, 0, 0 }
#define HA_xOPTION_STRING(name, struc, field) \
{ HA_OPTION_TYPE_STRING, name, sizeof(name)-1, \
offsetof(struc, field), 0, 0, 0, 0, 0 }
offsetof(struc, field), 0, 0, 0, 0, 0, 0}
#define HA_xOPTION_ENUM(name, struc, field, values, def) \
{ HA_OPTION_TYPE_ENUM, name, sizeof(name)-1, \
offsetof(struc, field), def, 0, \
sizeof(values)-1, 0, values }
sizeof(values)-1, 0, values, 0 }
#define HA_xOPTION_BOOL(name, struc, field, def) \
{ HA_OPTION_TYPE_BOOL, name, sizeof(name)-1, \
offsetof(struc, field), def, 0, 1, 0, 0 }
#define HA_xOPTION_END { HA_OPTION_TYPE_ULL, 0, 0, 0, 0, 0, 0, 0, 0 }
offsetof(struc, field), def, 0, 1, 0, 0, 0 }
#define HA_xOPTION_SYSVAR(name, struc, field, sysvar) \
{ HA_OPTION_TYPE_SYSVAR, name, sizeof(name)-1, \
offsetof(struc, field), 0, 0, 0, 0, 0, MYSQL_SYSVAR(sysvar) }
#define HA_xOPTION_END { HA_OPTION_TYPE_ULL, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
#define HA_TOPTION_NUMBER(name, field, def, min, max, blk_siz) \
HA_xOPTION_NUMBER(name, ha_table_option_struct, field, def, min, max, blk_siz)
@ -739,6 +743,8 @@ enum ha_option_type { HA_OPTION_TYPE_ULL, /* unsigned long long */
HA_xOPTION_ENUM(name, ha_table_option_struct, field, values, def)
#define HA_TOPTION_BOOL(name, field, def) \
HA_xOPTION_BOOL(name, ha_table_option_struct, field, def)
#define HA_TOPTION_SYSVAR(name, field, sysvar) \
HA_xOPTION_SYSVAR(name, ha_table_option_struct, field, sysvar)
#define HA_TOPTION_END HA_xOPTION_END
#define HA_FOPTION_NUMBER(name, field, def, min, max, blk_siz) \
@ -749,6 +755,8 @@ enum ha_option_type { HA_OPTION_TYPE_ULL, /* unsigned long long */
HA_xOPTION_ENUM(name, ha_field_option_struct, field, values, def)
#define HA_FOPTION_BOOL(name, field, def) \
HA_xOPTION_BOOL(name, ha_field_option_struct, field, def)
#define HA_FOPTION_SYSVAR(name, field, sysvar) \
HA_xOPTION_SYSVAR(name, ha_field_option_struct, field, sysvar)
#define HA_FOPTION_END HA_xOPTION_END
#define HA_IOPTION_NUMBER(name, field, def, min, max, blk_siz) \
@ -759,6 +767,8 @@ enum ha_option_type { HA_OPTION_TYPE_ULL, /* unsigned long long */
HA_xOPTION_ENUM(name, ha_index_option_struct, field, values, def)
#define HA_IOPTION_BOOL(name, field, values, def) \
HA_xOPTION_BOOL(name, ha_index_option_struct, field, values, def)
#define HA_IOPTION_SYSVAR(name, field, sysvar) \
HA_xOPTION_SYSVAR(name, ha_index_option_struct, field, sysvar)
#define HA_IOPTION_END HA_xOPTION_END
typedef struct st_ha_create_table_option {
@ -769,6 +779,7 @@ typedef struct st_ha_create_table_option {
ulonglong def_value;
ulonglong min_value, max_value, block_size;
const char *values;
struct st_mysql_sys_var *var;
} ha_create_table_option;
enum handler_iterator_type
@ -1197,6 +1208,11 @@ static inline LEX_STRING *hton_name(const handlerton *hton)
return &(hton2plugin[hton->slot]->name);
}
static inline sys_var *find_hton_sysvar(handlerton *hton, st_mysql_sys_var *var)
{
return find_plugin_sysvar(hton2plugin[hton->slot], var);
}
/* Possible flags of a handlerton (there can be 32 of them) */
#define HTON_NO_FLAGS 0

21
sql/sql_plugin.cc
View File

@ -308,8 +308,6 @@ static void unlock_variables(THD *thd, struct system_variables *vars);
static void cleanup_variables(THD *thd, struct system_variables *vars);
static void plugin_vars_free_values(sys_var *vars);
static void restore_pluginvar_names(sys_var *first);
static void plugin_opt_set_limits(struct my_option *,
const struct st_mysql_sys_var *);
static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref plugin);
static void intern_plugin_unlock(LEX *lex, plugin_ref plugin);
static void reap_plugins(void);
@ -3286,8 +3284,8 @@ bool sys_var_pluginvar::global_update(THD *thd, set_var *var)
options->block_size= (long) (opt)->blk_sz
static void plugin_opt_set_limits(struct my_option *options,
const struct st_mysql_sys_var *opt)
void plugin_opt_set_limits(struct my_option *options,
const struct st_mysql_sys_var *opt)
{
options->sub_size= 0;
@ -3866,3 +3864,18 @@ void add_plugin_options(DYNAMIC_ARRAY *options, MEM_ROOT *mem_root)
}
}
/**
Returns a sys_var corresponding to a particular MYSQL_SYSVAR(...)
*/
sys_var *find_plugin_sysvar(st_plugin_int *plugin, st_mysql_sys_var *plugin_var)
{
for (sys_var *var= plugin->system_vars; var; var= var->next)
{
sys_var_pluginvar *pvar=var->cast_pluginvar();
if (pvar->plugin_var == plugin_var)
return var;
}
return 0;
}

2
sql/sql_plugin.h
View File

@ -163,6 +163,8 @@ extern bool mysql_uninstall_plugin(THD *thd, const LEX_STRING *name,
extern bool plugin_register_builtin(struct st_mysql_plugin *plugin);
extern void plugin_thdvar_init(THD *thd);
extern void plugin_thdvar_cleanup(THD *thd);
sys_var *find_plugin_sysvar(st_plugin_int *plugin, st_mysql_sys_var *var);
void plugin_opt_set_limits(struct my_option *, const struct st_mysql_sys_var *);
extern SHOW_COMP_OPTION plugin_status(const char *name, size_t len, int type);
extern bool check_valid_path(const char *path, size_t length);

12
sql/sql_table.cc
View File

@ -3224,8 +3224,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
sql_field->offset= record_offset;
if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
auto_increment++;
if (parse_option_list(thd, &sql_field->option_struct,
sql_field->option_list,
if (parse_option_list(thd, create_info->db_type, &sql_field->option_struct,
&sql_field->option_list,
create_info->db_type->field_options, FALSE,
thd->mem_root))
DBUG_RETURN(TRUE);
@ -3427,8 +3427,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
key_info->usable_key_parts= key_number;
key_info->algorithm= key->key_create_info.algorithm;
key_info->option_list= key->option_list;
if (parse_option_list(thd, &key_info->option_struct,
key_info->option_list,
if (parse_option_list(thd, create_info->db_type, &key_info->option_struct,
&key_info->option_list,
create_info->db_type->index_options, FALSE,
thd->mem_root))
DBUG_RETURN(TRUE);
@ -3874,8 +3874,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
file->engine_name()->str,
"TRANSACTIONAL=1");
if (parse_option_list(thd, &create_info->option_struct,
create_info->option_list,
if (parse_option_list(thd, file->partition_ht(), &create_info->option_struct,
&create_info->option_list,
file->partition_ht()->table_options, FALSE,
thd->mem_root))
DBUG_RETURN(TRUE);

10
storage/example/ha_example.cc
View File

@ -118,6 +118,8 @@ static HASH example_open_tables;
/* The mutex used to init the hash; variable for example share methods */
mysql_mutex_t example_mutex;
static MYSQL_THDVAR_ULONG(varopt_default, PLUGIN_VAR_RQCMDARG,
"default value of the VAROPT table option", NULL, NULL, 5, 0, 100, 0);
/**
Structure for CREATE TABLE options (table options).
@ -133,6 +135,7 @@ struct ha_table_option_struct
ulonglong ullparam;
uint enumparam;
bool boolparam;
ulonglong varparam;
};
@ -179,6 +182,12 @@ ha_create_table_option example_table_option_list[]=
The default is 1, that is true, yes, on.
*/
HA_TOPTION_BOOL("YESNO", boolparam, 1),
/*
one option defined by the system variable. The type, the range, or
a list of allowed values is the same as for the system variable.
*/
HA_TOPTION_SYSVAR("VAROPT", varparam, varopt_default),
HA_TOPTION_END
};
@ -1089,6 +1098,7 @@ static MYSQL_SYSVAR_ULONG(
static struct st_mysql_sys_var* example_system_variables[]= {
MYSQL_SYSVAR(enum_var),
MYSQL_SYSVAR(ulong_var),
MYSQL_SYSVAR(varopt_default),
NULL
};