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

Merge zim.(none):/home/brian/mysql/merge-5.1

Browse Source 
into  zim.(none):/home/brian/mysql/arch-5.1


sql/mysql_priv.h:
  Auto merged
sql/share/errmsg.txt:
  Auto merged
sql/sql_show.cc:
  Auto merged
sql/handler.h:
  Merge from G's work
sql/sql_cursor.cc:
  Merge from G's work
storage/csv/ha_tina.cc:
  Merge of G's work
storage/innobase/handler/ha_innodb.cc:
  Merge of G's work
storage/innobase/handler/ha_innodb.h:
  Merge of G's work
storage/myisam/ha_myisam.cc:
  Merge of G's work
This commit is contained in:
unknown 2006-09-30 18:44:42 -07:00
commit ab6830a094
39 changed files with 463 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/heap.h
View File

@ -225,6 +225,7 @@ extern int heap_indexes_are_disabled(HP_INFO *info);
extern void heap_update_auto_increment(HP_INFO *info, const byte *record);
ha_rows hp_rb_records_in_range(HP_INFO *info, int inx, key_range *min_key,
key_range *max_key);
int hp_panic(enum ha_panic_function flag);
int heap_rkey(HP_INFO *info, byte *record, int inx, const byte *key,
uint key_len, enum ha_rkey_function find_flag);
extern gptr heap_find(HP_INFO *info,int inx,const byte *key);

6
mysql-test/r/partition.result
View File

@ -68,7 +68,7 @@ create table t1 (a int)
engine = csv
partition by list (a)
(partition p0 values in (null));
ERROR HY000: CSV handler cannot be used in partitioned tables
ERROR HY000: Engine cannot be used in partitioned tables
create table t1 (a bigint)
partition by range (a)
(partition p0 values less than (0xFFFFFFFFFFFFFFFF),
@ -102,7 +102,7 @@ create table t1 (a int)
engine = csv
partition by list (a)
(partition p0 values in (null));
ERROR HY000: CSV handler cannot be used in partitioned tables
ERROR HY000: Engine cannot be used in partitioned tables
create table t1 (a int)
partition by key(a)
(partition p0 engine = MEMORY);
@ -1054,7 +1054,7 @@ drop table t1;
create table t1 (a int)
partition by key (a)
(partition p0 engine = MERGE);
ERROR HY000: MyISAM Merge handler cannot be used in partitioned tables
ERROR HY000: Engine cannot be used in partitioned tables
create table t1 (a varchar(1))
partition by key (a)
as select 'a';

61
sql/ha_ndbcluster.cc
View File

@ -75,17 +75,25 @@ static const int max_transactions= 3; // should really be 2 but there is a trans
static uint ndbcluster_partition_flags();
static uint ndbcluster_alter_table_flags(uint flags);
static int ndbcluster_init(void *);
static int ndbcluster_end(ha_panic_function flag);
static bool ndbcluster_show_status(THD*,stat_print_fn *,enum ha_stat_type);
static int ndbcluster_alter_tablespace(THD* thd, st_alter_tablespace *info);
static int ndbcluster_fill_files_table(THD *thd, TABLE_LIST *tables, COND *cond);
static int ndbcluster_end(handlerton *hton, ha_panic_function flag);
static bool ndbcluster_show_status(handlerton *hton, THD*,
stat_print_fn *,
enum ha_stat_type);
static int ndbcluster_alter_tablespace(handlerton *hton,
THD* thd,
st_alter_tablespace *info);
static int ndbcluster_fill_files_table(handlerton *hton,
THD *thd,
TABLE_LIST *tables,
COND *cond);
handlerton *ndbcluster_hton;
static handlerton *ndbcluster_hton;
static handler *ndbcluster_create_handler(TABLE_SHARE *table,
static handler *ndbcluster_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_ndbcluster(table);
return new (mem_root) ha_ndbcluster(hton, table);
}
static uint ndbcluster_partition_flags()
@ -4201,7 +4209,7 @@ int ha_ndbcluster::start_stmt(THD *thd, thr_lock_type lock_type)
Commit a transaction started in NDB
*/
static int ndbcluster_commit(THD *thd, bool all)
static int ndbcluster_commit(handlerton *hton, THD *thd, bool all)
{
int res= 0;
Thd_ndb *thd_ndb= get_thd_ndb(thd);
@ -4252,7 +4260,7 @@ static int ndbcluster_commit(THD *thd, bool all)
Rollback a transaction started in NDB
*/
static int ndbcluster_rollback(THD *thd, bool all)
static int ndbcluster_rollback(handlerton *hton, THD *thd, bool all)
{
int res= 0;
Thd_ndb *thd_ndb= get_thd_ndb(thd);
@ -5552,8 +5560,8 @@ void ha_ndbcluster::get_auto_increment(ulonglong offset, ulonglong increment,
HA_HAS_OWN_BINLOGGING | \
HA_HAS_RECORDS
ha_ndbcluster::ha_ndbcluster(TABLE_SHARE *table_arg):
handler(ndbcluster_hton, table_arg),
ha_ndbcluster::ha_ndbcluster(handlerton *hton, TABLE_SHARE *table_arg):
handler(hton, table_arg),
m_active_trans(NULL),
m_active_cursor(NULL),
m_table(NULL),
@ -5816,7 +5824,7 @@ int ha_ndbcluster::check_ndb_connection(THD* thd)
}
static int ndbcluster_close_connection(THD *thd)
static int ndbcluster_close_connection(handlerton *hton, THD *thd)
{
Thd_ndb *thd_ndb= get_thd_ndb(thd);
DBUG_ENTER("ndbcluster_close_connection");
@ -5833,8 +5841,10 @@ static int ndbcluster_close_connection(THD *thd)
Try to discover one table from NDB
*/
int ndbcluster_discover(THD* thd, const char *db, const char *name,
const void** frmblob, uint* frmlen)
int ndbcluster_discover(handlerton *hton, THD* thd, const char *db,
const char *name,
const void** frmblob,
uint* frmlen)
{
int error= 0;
NdbError ndb_error;
@ -5914,7 +5924,8 @@ err:
*/
int ndbcluster_table_exists_in_engine(THD* thd, const char *db,
int ndbcluster_table_exists_in_engine(handlerton *hton, THD* thd,
const char *db,
const char *name)
{
Ndb* ndb;
@ -6014,7 +6025,7 @@ int ndbcluster_drop_database_impl(const char *path)
DBUG_RETURN(ret);
}
static void ndbcluster_drop_database(char *path)
static void ndbcluster_drop_database(handlerton *hton, char *path)
{
THD *thd= current_thd;
DBUG_ENTER("ndbcluster_drop_database");
@ -6175,7 +6186,9 @@ int ndbcluster_find_all_files(THD *thd)
DBUG_RETURN(-(skipped + unhandled));
}
int ndbcluster_find_files(THD *thd,const char *db,const char *path,
int ndbcluster_find_files(handlerton *hton, THD *thd,
const char *db,
const char *path,
const char *wild, bool dir, List<char> *files)
{
DBUG_ENTER("ndbcluster_find_files");
@ -6285,7 +6298,7 @@ int ndbcluster_find_files(THD *thd,const char *db,const char *path,
DBUG_PRINT("info", ("%s existed on disk", name));
// The .ndb file exists on disk, but it's not in list of tables in ndb
// Verify that handler agrees table is gone.
if (ndbcluster_table_exists_in_engine(thd, db, file_name) == 0)
if (ndbcluster_table_exists_in_engine(hton, thd, db, file_name) == 0)
{
DBUG_PRINT("info", ("NDB says %s does not exists", file_name));
it.remove();
@ -6539,7 +6552,7 @@ ndbcluster_init_error:
DBUG_RETURN(TRUE);
}
static int ndbcluster_end(ha_panic_function type)
static int ndbcluster_end(handlerton *hton, ha_panic_function type)
{
DBUG_ENTER("ndbcluster_end");
@ -6623,7 +6636,7 @@ void ndbcluster_print_error(int error, const NdbOperation *error_op)
share.db.length= 0;
share.table_name.str= (char *) tab_name;
share.table_name.length= strlen(tab_name);
ha_ndbcluster error_handler(&share);
ha_ndbcluster error_handler(ndbcluster_hton, &share);
error_handler.print_error(error, MYF(0));
DBUG_VOID_RETURN;
}
@ -9703,7 +9716,7 @@ err:
Implements the SHOW NDB STATUS command.
*/
bool
ndbcluster_show_status(THD* thd, stat_print_fn *stat_print,
ndbcluster_show_status(handlerton *hton, THD* thd, stat_print_fn *stat_print,
enum ha_stat_type stat_type)
{
char buf[IO_SIZE];
@ -10167,7 +10180,7 @@ bool set_up_undofile(st_alter_tablespace *info,
return false;
}
int ndbcluster_alter_tablespace(THD* thd, st_alter_tablespace *info)
int ndbcluster_alter_tablespace(handlerton *hton, THD* thd, st_alter_tablespace *info)
{
DBUG_ENTER("ha_ndbcluster::alter_tablespace");
@ -10428,7 +10441,9 @@ bool ha_ndbcluster::get_no_parts(const char *name, uint *no_parts)
DBUG_RETURN(TRUE);
}
static int ndbcluster_fill_files_table(THD *thd, TABLE_LIST *tables,
static int ndbcluster_fill_files_table(handlerton *hton,
THD *thd,
TABLE_LIST *tables,
COND *cond)
{
TABLE* table= tables->table;

2
sql/ha_ndbcluster.h
View File

@ -627,7 +627,7 @@ class Thd_ndb
class ha_ndbcluster: public handler
{
public:
ha_ndbcluster(TABLE_SHARE *table);
ha_ndbcluster(handlerton *hton, TABLE_SHARE *table);
~ha_ndbcluster();
int ha_initialise();

6
sql/ha_ndbcluster_binlog.cc
View File

@ -506,7 +506,7 @@ ndbcluster_binlog_index_purge_file(THD *thd, const char *file)
}
static void
ndbcluster_binlog_log_query(THD *thd, enum_binlog_command binlog_command,
ndbcluster_binlog_log_query(handlerton *hton, THD *thd, enum_binlog_command binlog_command,
const char *query, uint query_length,
const char *db, const char *table_name)
{
@ -637,7 +637,9 @@ static void ndbcluster_reset_slave(THD *thd)
/*
Initialize the binlog part of the ndb handlerton
*/
static int ndbcluster_binlog_func(THD *thd, enum_binlog_func fn, void *arg)
static int ndbcluster_binlog_func(handlerton *hton, THD *thd,
enum_binlog_func fn,
void *arg)
{
switch(fn)
{

18
sql/ha_partition.cc
View File

@ -69,16 +69,17 @@ static PARTITION_SHARE *get_share(const char *table_name, TABLE * table);
MODULE create/delete handler object
****************************************************************************/
static handler *partition_create_handler(TABLE_SHARE *share,
static handler *partition_create_handler(handlerton *hton,
TABLE_SHARE *share,
MEM_ROOT *mem_root);
static uint partition_flags();
static uint alter_table_flags(uint flags);
handlerton *partition_hton;
static int partition_initialize(void *p)
{
handlerton *partition_hton;
partition_hton= (handlerton *)p;
partition_hton->state= SHOW_OPTION_YES;
@ -102,10 +103,11 @@ static int partition_initialize(void *p)
New partition object
*/
static handler *partition_create_handler(TABLE_SHARE *share,
static handler *partition_create_handler(handlerton *hton,
TABLE_SHARE *share,
MEM_ROOT *mem_root)
{
ha_partition *file= new (mem_root) ha_partition(share);
ha_partition *file= new (mem_root) ha_partition(hton, share);
if (file && file->initialise_partition(mem_root))
{
delete file;
@ -155,8 +157,8 @@ static uint alter_table_flags(uint flags __attribute__((unused)))
NONE
*/
ha_partition::ha_partition(TABLE_SHARE *share)
:handler(partition_hton, share), m_part_info(NULL), m_create_handler(FALSE),
ha_partition::ha_partition(handlerton *hton, TABLE_SHARE *share)
:handler(hton, share), m_part_info(NULL), m_create_handler(FALSE),
m_is_sub_partitioned(0)
{
DBUG_ENTER("ha_partition::ha_partition(table)");
@ -176,8 +178,8 @@ ha_partition::ha_partition(TABLE_SHARE *share)
NONE
*/
ha_partition::ha_partition(partition_info *part_info)
:handler(partition_hton, NULL), m_part_info(part_info),
ha_partition::ha_partition(handlerton *hton, partition_info *part_info)
:handler(hton, NULL), m_part_info(part_info),
m_create_handler(TRUE),
m_is_sub_partitioned(m_part_info->is_sub_partitioned())

4
sql/ha_partition.h
View File

@ -149,8 +149,8 @@ public:
partition handler.
-------------------------------------------------------------------------
*/
ha_partition(TABLE_SHARE * table);
ha_partition(partition_info * part_info);
ha_partition(handlerton *hton, TABLE_SHARE * table);
ha_partition(handlerton *hton, partition_info * part_info);
~ha_partition();
/*
A partition handler has no characteristics in itself. It only inherits

97
sql/handler.cc
View File

@ -170,7 +170,7 @@ const char *ha_get_storage_engine(enum legacy_db_type db_type)
static handler *create_default(TABLE_SHARE *table, MEM_ROOT *mem_root)
{
handlerton *hton= ha_default_handlerton(current_thd);
return (hton && hton->create) ? hton->create(table, mem_root) : NULL;
return (hton && hton->create) ? hton->create(hton, table, mem_root) : NULL;
}
@ -232,7 +232,7 @@ handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
if (db_type && db_type->state == SHOW_OPTION_YES && db_type->create)
{
if ((file= db_type->create(share, alloc)))
if ((file= db_type->create(db_type, share, alloc)))
file->init();
DBUG_RETURN(file);
}
@ -251,7 +251,7 @@ handler *get_ha_partition(partition_info *part_info)
{
ha_partition *partition;
DBUG_ENTER("get_ha_partition");
if ((partition= new ha_partition(part_info)))
if ((partition= new ha_partition(partition_hton, part_info)))
{
if (partition->initialise_partition(current_thd->mem_root))
{
@ -376,7 +376,7 @@ int ha_finalize_handlerton(st_plugin_int *plugin)
case SHOW_OPTION_YES:
if (installed_htons[hton->db_type] == hton)
installed_htons[hton->db_type]= NULL;
if (hton->panic && hton->panic(HA_PANIC_CLOSE))
if (hton->panic && hton->panic(hton, HA_PANIC_CLOSE))
DBUG_RETURN(1);
break;
};
@ -465,6 +465,26 @@ int ha_initialize_handlerton(st_plugin_int *plugin)
hton->state= SHOW_OPTION_DISABLED;
break;
}
/*
This is entirely for legacy. We will create a new "disk based" hton and a
"memory" hton which will be configurable longterm. We should be able to
remove partition and myisammrg.
*/
switch (hton->db_type) {
case DB_TYPE_HEAP:
heap_hton= hton;
break;
case DB_TYPE_MYISAM:
myisam_hton= hton;
break;
case DB_TYPE_PARTITION_DB:
partition_hton= hton;
break;
default:
break;
};
DBUG_RETURN(0);
err:
DBUG_RETURN(1);
@ -498,7 +518,7 @@ static my_bool panic_handlerton(THD *unused1, st_plugin_int *plugin, void *arg)
{
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->panic)
((int*)arg)[0]|= hton->panic((enum ha_panic_function)((int*)arg)[1]);
((int*)arg)[0]|= hton->panic(hton, (enum ha_panic_function)((int*)arg)[1]);
return FALSE;
}
@ -520,7 +540,7 @@ static my_bool dropdb_handlerton(THD *unused1, st_plugin_int *plugin,
{
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->drop_database)
hton->drop_database((char *)path);
hton->drop_database(hton, (char *)path);
return FALSE;
}
@ -541,7 +561,7 @@ static my_bool closecon_handlerton(THD *thd, st_plugin_int *plugin,
*/
if (hton->state == SHOW_OPTION_YES && hton->close_connection &&
thd->ha_data[hton->slot])
hton->close_connection(thd);
hton->close_connection(hton, thd);
return FALSE;
}
@ -617,7 +637,7 @@ int ha_prepare(THD *thd)
statistic_increment(thd->status_var.ha_prepare_count,&LOCK_status);
if ((*ht)->prepare)
{
if ((err= (*(*ht)->prepare)(thd, all)))
if ((err= (*(*ht)->prepare)(*ht, thd, all)))
{
my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
ha_rollback_trans(thd, all);
@ -691,7 +711,7 @@ int ha_commit_trans(THD *thd, bool all)
for (; *ht && !error; ht++)
{
int err;
if ((err= (*(*ht)->prepare)(thd, all)))
if ((err= (*(*ht)->prepare)(*ht, thd, all)))
{
my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
error= 1;
@ -738,7 +758,7 @@ int ha_commit_one_phase(THD *thd, bool all)
for (ht=trans->ht; *ht; ht++)
{
int err;
if ((err= (*(*ht)->commit)(thd, all)))
if ((err= (*(*ht)->commit)(*ht, thd, all)))
{
my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
error=1;
@ -794,7 +814,7 @@ int ha_rollback_trans(THD *thd, bool all)
for (handlerton **ht=trans->ht; *ht; ht++)
{
int err;
if ((err= (*(*ht)->rollback)(thd, all)))
if ((err= (*(*ht)->rollback)(*ht, thd, all)))
{ // cannot happen
my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
error=1;
@ -871,7 +891,7 @@ static my_bool xacommit_handlerton(THD *unused1, st_plugin_int *plugin,
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->recover)
{
hton->commit_by_xid(((struct xahton_st *)arg)->xid);
hton->commit_by_xid(hton, ((struct xahton_st *)arg)->xid);
((struct xahton_st *)arg)->result= 0;
}
return FALSE;
@ -883,7 +903,7 @@ static my_bool xarollback_handlerton(THD *unused1, st_plugin_int *plugin,
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->recover)
{
hton->rollback_by_xid(((struct xahton_st *)arg)->xid);
hton->rollback_by_xid(hton, ((struct xahton_st *)arg)->xid);
((struct xahton_st *)arg)->result= 0;
}
return FALSE;
@ -993,7 +1013,7 @@ static my_bool xarecover_handlerton(THD *unused, st_plugin_int *plugin,
if (hton->state == SHOW_OPTION_YES && hton->recover)
{
while ((got= hton->recover(info->list, info->len)) > 0 )
while ((got= hton->recover(hton, info->list, info->len)) > 0 )
{
sql_print_information("Found %d prepared transaction(s) in %s",
got, hton2plugin[hton->slot]->name.str);
@ -1024,7 +1044,7 @@ static my_bool xarecover_handlerton(THD *unused, st_plugin_int *plugin,
char buf[XIDDATASIZE*4+6]; // see xid_to_str
sql_print_information("commit xid %s", xid_to_str(buf, info->list+i));
#endif
hton->commit_by_xid(info->list+i);
hton->commit_by_xid(hton, info->list+i);
}
else
{
@ -1033,7 +1053,7 @@ static my_bool xarecover_handlerton(THD *unused, st_plugin_int *plugin,
sql_print_information("rollback xid %s",
xid_to_str(buf, info->list+i));
#endif
hton->rollback_by_xid(info->list+i);
hton->rollback_by_xid(hton, info->list+i);
}
}
if (got < info->len)
@ -1179,7 +1199,7 @@ static my_bool release_temporary_latches(THD *thd, st_plugin_int *plugin,
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->release_temporary_latches)
hton->release_temporary_latches(thd);
hton->release_temporary_latches(hton, thd);
return FALSE;
}
@ -1212,7 +1232,7 @@ int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
{
int err;
DBUG_ASSERT((*ht)->savepoint_set != 0);
if ((err= (*(*ht)->savepoint_rollback)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
if ((err= (*(*ht)->savepoint_rollback)(*ht, thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
{ // cannot happen
my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
error=1;
@ -1228,7 +1248,7 @@ int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
for (; *ht ; ht++)
{
int err;
if ((err= (*(*ht)->rollback)(thd, !thd->in_sub_stmt)))
if ((err= (*(*ht)->rollback)(*ht, thd, !thd->in_sub_stmt)))
{ // cannot happen
my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
error=1;
@ -1262,7 +1282,7 @@ int ha_savepoint(THD *thd, SAVEPOINT *sv)
error=1;
break;
}
if ((err= (*(*ht)->savepoint_set)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
if ((err= (*(*ht)->savepoint_set)(*ht, thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
{ // cannot happen
my_error(ER_GET_ERRNO, MYF(0), err);
error=1;
@ -1288,7 +1308,9 @@ int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
int err;
if (!(*ht)->savepoint_release)
continue;
if ((err= (*(*ht)->savepoint_release)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
if ((err= (*(*ht)->savepoint_release)(*ht, thd,
(byte *)(sv+1)+
(*ht)->savepoint_offset)))
{ // cannot happen
my_error(ER_GET_ERRNO, MYF(0), err);
error=1;
@ -1305,7 +1327,7 @@ static my_bool snapshot_handlerton(THD *thd, st_plugin_int *plugin,
if (hton->state == SHOW_OPTION_YES &&
hton->start_consistent_snapshot)
{
hton->start_consistent_snapshot(thd);
hton->start_consistent_snapshot(hton, thd);
*((bool *)arg)= false;
}
return FALSE;
@ -1333,7 +1355,8 @@ static my_bool flush_handlerton(THD *thd, st_plugin_int *plugin,
void *arg)
{
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->flush_logs && hton->flush_logs())
if (hton->state == SHOW_OPTION_YES && hton->flush_logs &&
hton->flush_logs(hton))
return TRUE;
return FALSE;
}
@ -1350,7 +1373,7 @@ bool ha_flush_logs(handlerton *db_type)
else
{
if (db_type->state != SHOW_OPTION_YES ||
(db_type->flush_logs && db_type->flush_logs()))
(db_type->flush_logs && db_type->flush_logs(db_type)))
return TRUE;
}
return FALSE;
@ -2765,7 +2788,9 @@ static my_bool discover_handlerton(THD *thd, st_plugin_int *plugin,
st_discover_args *vargs= (st_discover_args *)arg;
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->discover &&
(!(hton->discover(thd, vargs->db, vargs->name, vargs->frmblob, vargs->frmlen))))
(!(hton->discover(hton, thd, vargs->db, vargs->name,
vargs->frmblob,
vargs->frmlen))))
return TRUE;
return FALSE;
@ -2814,7 +2839,7 @@ static my_bool find_files_handlerton(THD *thd, st_plugin_int *plugin,
if (hton->state == SHOW_OPTION_YES && hton->find_files)
if (hton->find_files(thd, vargs->db, vargs->path, vargs->wild,
if (hton->find_files(hton, thd, vargs->db, vargs->path, vargs->wild,
vargs->dir, vargs->files))
return TRUE;
@ -2861,7 +2886,7 @@ static my_bool table_exists_in_engine_handlerton(THD *thd, st_plugin_int *plugin
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->table_exists_in_engine)
if ((hton->table_exists_in_engine(thd, vargs->db, vargs->name)) == 1)
if ((hton->table_exists_in_engine(hton, thd, vargs->db, vargs->name)) == 1)
return TRUE;
return FALSE;
@ -2930,7 +2955,7 @@ static my_bool binlog_func_foreach(THD *thd, binlog_func_st *bfn)
uint i= 0, sz= hton_list.sz;
while(i < sz)
hton_list.hton[i++]->binlog_func(thd, bfn->fn, bfn->arg);
hton_list.hton[i++]->binlog_func(hton, thd, bfn->fn, bfn->arg);
return FALSE;
}
@ -2977,12 +3002,12 @@ struct binlog_log_query_st
};
static my_bool binlog_log_query_handlerton2(THD *thd,
const handlerton *hton,
handlerton *hton,
void *args)
{
struct binlog_log_query_st *b= (struct binlog_log_query_st*)args;
if (hton->state == SHOW_OPTION_YES && hton->binlog_log_query)
hton->binlog_log_query(thd,
hton->binlog_log_query(hton, thd,
b->binlog_command,
b->query,
b->query_length,
@ -2995,10 +3020,10 @@ static my_bool binlog_log_query_handlerton(THD *thd,
st_plugin_int *plugin,
void *args)
{
return binlog_log_query_handlerton2(thd, (const handlerton *)plugin->data, args);
return binlog_log_query_handlerton2(thd, (handlerton *)plugin->data, args);
}
void ha_binlog_log_query(THD *thd, const handlerton *hton,
void ha_binlog_log_query(THD *thd, handlerton *hton,
enum_binlog_command binlog_command,
const char *query, uint query_length,
const char *db, const char *table_name)
@ -3296,7 +3321,7 @@ static my_bool exts_handlerton(THD *unused, st_plugin_int *plugin,
handlerton *hton= (handlerton *)plugin->data;
handler *file;
if (hton->state == SHOW_OPTION_YES && hton->create &&
(file= hton->create((TABLE_SHARE*) 0, current_thd->mem_root)))
(file= hton->create(hton, (TABLE_SHARE*) 0, current_thd->mem_root)))
{
List_iterator_fast<char> it(*found_exts);
const char **ext, *old_ext;
@ -3371,7 +3396,7 @@ static my_bool showstat_handlerton(THD *thd, st_plugin_int *plugin,
enum ha_stat_type stat= *(enum ha_stat_type *) arg;
handlerton *hton= (handlerton *)plugin->data;
if (hton->state == SHOW_OPTION_YES && hton->show_status &&
hton->show_status(thd, stat_print, stat))
hton->show_status(hton, thd, stat_print, stat))
return TRUE;
return FALSE;
}
@ -3405,7 +3430,7 @@ bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
}
else
result= db_type->show_status &&
db_type->show_status(thd, stat_print, stat) ? 1 : 0;
db_type->show_status(db_type, thd, stat_print, stat) ? 1 : 0;
}
if (!result)
@ -3726,7 +3751,7 @@ int example_of_iterator_using_for_logs_cleanup(handlerton *hton)
if (!hton->create_iterator)
return 1; /* iterator creator is not supported */
if ((*hton->create_iterator)(HA_TRANSACTLOG_ITERATOR, &iterator) !=
if ((*hton->create_iterator)(hton, HA_TRANSACTLOG_ITERATOR, &iterator) !=
HA_ITERATOR_OK)
{
/* error during creation of log iterator or iterator is not supported */

74
sql/handler.h
View File

@ -449,7 +449,7 @@ class st_alter_tablespace : public Sql_alloc
ulonglong autoextend_size;
ulonglong max_size;
uint nodegroup_id;
const handlerton *storage_engine;
handlerton *storage_engine;
bool wait_until_completed;
const char *ts_comment;
enum tablespace_access_mode ts_access_mode;
@ -605,18 +605,18 @@ struct handlerton
this storage area - set it to something, so that MySQL would know
this storage engine was accessed in this connection
*/
int (*close_connection)(THD *thd);
int (*close_connection)(handlerton *hton, THD *thd);
/*
sv points to an uninitialized storage area of requested size
(see savepoint_offset description)
*/
int (*savepoint_set)(THD *thd, void *sv);
int (*savepoint_set)(handlerton *hton, THD *thd, void *sv);
/*
sv points to a storage area, that was earlier passed
to the savepoint_set call
*/
int (*savepoint_rollback)(THD *thd, void *sv);
int (*savepoint_release)(THD *thd, void *sv);
int (*savepoint_rollback)(handlerton *hton, THD *thd, void *sv);
int (*savepoint_release)(handlerton *hton, THD *thd, void *sv);
/*
'all' is true if it's a real commit, that makes persistent changes
'all' is false if it's not in fact a commit but an end of the
@ -624,25 +624,25 @@ struct handlerton
NOTE 'all' is also false in auto-commit mode where 'end of statement'
and 'real commit' mean the same event.
*/
int (*commit)(THD *thd, bool all);
int (*rollback)(THD *thd, bool all);
int (*prepare)(THD *thd, bool all);
int (*recover)(XID *xid_list, uint len);
int (*commit_by_xid)(XID *xid);
int (*rollback_by_xid)(XID *xid);
void *(*create_cursor_read_view)(THD *thd);
void (*set_cursor_read_view)(THD *thd, void *read_view);
void (*close_cursor_read_view)(THD *thd, void *read_view);
handler *(*create)(TABLE_SHARE *table, MEM_ROOT *mem_root);
void (*drop_database)(char* path);
int (*panic)(enum ha_panic_function flag);
int (*start_consistent_snapshot)(THD *thd);
bool (*flush_logs)();
bool (*show_status)(THD *thd, stat_print_fn *print, enum ha_stat_type stat);
int (*commit)(handlerton *hton, THD *thd, bool all);
int (*rollback)(handlerton *hton, THD *thd, bool all);
int (*prepare)(handlerton *hton, THD *thd, bool all);
int (*recover)(handlerton *hton, XID *xid_list, uint len);
int (*commit_by_xid)(handlerton *hton, XID *xid);
int (*rollback_by_xid)(handlerton *hton, XID *xid);
void *(*create_cursor_read_view)(handlerton *hton, THD *thd);
void (*set_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);
void (*close_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);
handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root);
void (*drop_database)(handlerton *hton, char* path);
int (*panic)(handlerton *hton, enum ha_panic_function flag);
int (*start_consistent_snapshot)(handlerton *hton, THD *thd);
bool (*flush_logs)(handlerton *hton);
bool (*show_status)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat);
uint (*partition_flags)();
uint (*alter_table_flags)(uint flags);
int (*alter_tablespace)(THD *thd, st_alter_tablespace *ts_info);
int (*fill_files_table)(THD *thd,
int (*alter_tablespace)(handlerton *hton, THD *thd, st_alter_tablespace *ts_info);
int (*fill_files_table)(handlerton *hton, THD *thd,
struct st_table_list *tables,
class Item *cond);
uint32 flags; /* global handler flags */
@ -650,11 +650,12 @@ struct handlerton
Those handlerton functions below are properly initialized at handler
init.
*/
int (*binlog_func)(THD *thd, enum_binlog_func fn, void *arg);
void (*binlog_log_query)(THD *thd, enum_binlog_command binlog_command,
int (*binlog_func)(handlerton *hton, THD *thd, enum_binlog_func fn, void *arg);
void (*binlog_log_query)(handlerton *hton, THD *thd,
enum_binlog_command binlog_command,
const char *query, uint query_length,
const char *db, const char *table_name);
int (*release_temporary_latches)(THD *thd);
int (*release_temporary_latches)(handlerton *hton, THD *thd);
/*
Get log status.
@ -663,20 +664,24 @@ struct handlerton
(see example of implementation in handler.cc, TRANS_LOG_MGM_EXAMPLE_CODE)
*/
enum log_status (*get_log_status)(char *log);
enum log_status (*get_log_status)(handlerton *hton, char *log);
/*
Iterators creator.
Presence of the pointer should be checked before using
*/
enum handler_create_iterator_result
(*create_iterator)(enum handler_iterator_type type,
(*create_iterator)(handlerton *hton, enum handler_iterator_type type,
struct handler_iterator *fill_this_in);
int (*discover)(THD* thd, const char *db, const char *name,
const void** frmblob, uint* frmlen);
int (*find_files)(THD *thd,const char *db,const char *path,
int (*discover)(handlerton *hton, THD* thd, const char *db,
const char *name,
const void** frmblob,
uint* frmlen);
int (*find_files)(handlerton *hton, THD *thd,
const char *db,
const char *path,
const char *wild, bool dir, List<char> *files);
int (*table_exists_in_engine)(THD* thd, const char *db,
int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db,
const char *name);
};
@ -691,6 +696,7 @@ struct handlerton
#define HTON_NOT_USER_SELECTABLE (1 << 5)
#define HTON_TEMPORARY_NOT_SUPPORTED (1 << 6) //Having temporary tables not supported
#define HTON_SUPPORT_LOG_TABLES (1 << 7) //Engine supports log tables
#define HTON_NO_PARTITION (1 << 8) //You can not partition these tables
typedef struct st_thd_trans
{
@ -893,7 +899,7 @@ class handler :public Sql_alloc
virtual void start_bulk_insert(ha_rows rows) {}
virtual int end_bulk_insert() {return 0; }
public:
const handlerton *ht; /* storage engine of this handler */
handlerton *ht; /* storage engine of this handler */
byte *ref; /* Pointer to current row */
byte *dup_ref; /* Pointer to duplicate row */
@ -943,7 +949,7 @@ public:
*/
Discrete_interval auto_inc_interval_for_cur_row;
handler(const handlerton *ht_arg, TABLE_SHARE *share_arg)
handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
:table_share(share_arg), estimation_rows_to_insert(0), ht(ht_arg),
ref(0), key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
ref_length(sizeof(my_off_t)),
@ -1716,7 +1722,7 @@ void trans_register_ha(THD *thd, bool all, handlerton *ht);
int ha_reset_logs(THD *thd);
int ha_binlog_index_purge_file(THD *thd, const char *file);
void ha_reset_slave(THD *thd);
void ha_binlog_log_query(THD *thd, const handlerton *db_type,
void ha_binlog_log_query(THD *thd, handlerton *db_type,
enum_binlog_command binlog_command,
const char *query, uint query_length,
const char *db, const char *table_name);

29
sql/log.cc
View File

@ -46,13 +46,13 @@ static Muted_query_log_event invisible_commit;
static bool test_if_number(const char *str,
long *res, bool allow_wildcards);
static int binlog_init();
static int binlog_close_connection(THD *thd);
static int binlog_savepoint_set(THD *thd, void *sv);
static int binlog_savepoint_rollback(THD *thd, void *sv);
static int binlog_commit(THD *thd, bool all);
static int binlog_rollback(THD *thd, bool all);
static int binlog_prepare(THD *thd, bool all);
static int binlog_init(void *p);
static int binlog_close_connection(handlerton *hton, THD *thd);
static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv);
static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv);
static int binlog_commit(handlerton *hton, THD *thd, bool all);
static int binlog_rollback(handlerton *hton, THD *thd, bool all);
static int binlog_prepare(handlerton *hton, THD *thd, bool all);
sql_print_message_func sql_print_message_handlers[3] =
{
@ -1171,7 +1171,7 @@ int binlog_init(void *p)
return 0;
}
static int binlog_close_connection(THD *thd)
static int binlog_close_connection(handlerton *hton, THD *thd)
{
binlog_trx_data *const trx_data=
(binlog_trx_data*) thd->ha_data[binlog_hton->slot];
@ -1184,7 +1184,8 @@ static int binlog_close_connection(THD *thd)
}
static int
binlog_end_trans(THD *thd, binlog_trx_data *trx_data, Log_event *end_ev)
binlog_end_trans(THD *thd, binlog_trx_data *trx_data,
Log_event *end_ev)
{
DBUG_ENTER("binlog_end_trans");
int error=0;
@ -1238,7 +1239,7 @@ binlog_end_trans(THD *thd, binlog_trx_data *trx_data, Log_event *end_ev)
DBUG_RETURN(error);
}
static int binlog_prepare(THD *thd, bool all)
static int binlog_prepare(handlerton *hton, THD *thd, bool all)
{
/*
do nothing.
@ -1249,7 +1250,7 @@ static int binlog_prepare(THD *thd, bool all)
return 0;
}
static int binlog_commit(THD *thd, bool all)
static int binlog_commit(handlerton *hton, THD *thd, bool all)
{
DBUG_ENTER("binlog_commit");
binlog_trx_data *const trx_data=
@ -1273,7 +1274,7 @@ static int binlog_commit(THD *thd, bool all)
DBUG_RETURN(binlog_end_trans(thd, trx_data, &invisible_commit));
}
static int binlog_rollback(THD *thd, bool all)
static int binlog_rollback(handlerton *hton, THD *thd, bool all)
{
DBUG_ENTER("binlog_rollback");
int error=0;
@ -1326,7 +1327,7 @@ static int binlog_rollback(THD *thd, bool all)
that case there is no need to have it in the binlog).
*/
static int binlog_savepoint_set(THD *thd, void *sv)
static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv)
{
DBUG_ENTER("binlog_savepoint_set");
binlog_trx_data *const trx_data=
@ -1342,7 +1343,7 @@ static int binlog_savepoint_set(THD *thd, void *sv)
DBUG_RETURN(error);
}
static int binlog_savepoint_rollback(THD *thd, void *sv)
static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv)
{
DBUG_ENTER("binlog_savepoint_rollback");
binlog_trx_data *const trx_data=

12
sql/mysql_priv.h
View File

@ -1637,19 +1637,7 @@ extern SHOW_COMP_OPTION have_ndbcluster;
extern SHOW_COMP_OPTION have_partition_db;
extern SHOW_COMP_OPTION have_merge_db;
#ifdef WITH_CSV_STORAGE_ENGINE
extern handlerton *tina_hton;
#endif
#ifdef WITH_NDBCLUSTER_STORAGE_ENGINE
extern handlerton *ndbcluster_hton;
#endif
#ifdef WITH_PARTITION_STORAGE_ENGINE
extern handlerton *partition_hton;
#endif
#ifdef WITH_MYISAMMRG_STORAGE_ENGINE
extern handlerton *myisammrg_hton;
#endif
extern handlerton *myisam_hton;
extern handlerton *heap_hton;

8
sql/mysqld.cc
View File

@ -354,6 +354,14 @@ my_bool opt_safe_user_create = 0, opt_no_mix_types = 0;
my_bool opt_show_slave_auth_info, opt_sql_bin_update = 0;
my_bool opt_log_slave_updates= 0;
my_bool opt_innodb;
/*
Legacy global handlerton. These will be removed (please do not add more).
*/
handlerton *heap_hton;
handlerton *myisam_hton;
handlerton *partition_hton;
#ifdef WITH_INNOBASE_STORAGE_ENGINE
extern ulong innobase_fast_shutdown;
extern ulong innobase_large_page_size;

6
sql/partition_info.cc
View File

@ -443,11 +443,9 @@ bool partition_info::check_engine_mix(handlerton **engine_array, uint no_parts)
DBUG_RETURN(TRUE);
}
} while (++i < no_parts);
if (engine_array[0] == myisammrg_hton ||
engine_array[0] == tina_hton)
if (engine_array[0]->flags & HTON_NO_PARTITION)
{
my_error(ER_PARTITION_MERGE_ERROR, MYF(0),
engine_array[0] == myisammrg_hton ? "MyISAM Merge" : "CSV");
my_error(ER_PARTITION_MERGE_ERROR, MYF(0));
DBUG_RETURN(TRUE);
}
DBUG_RETURN(FALSE);

6
sql/share/errmsg.txt
View File

@ -5960,9 +5960,9 @@ ER_EVENT_SET_VAR_ERROR
eng "Error during starting/stopping of the scheduler. Error code %u"
ger "Fehler während des Startens oder Anhalten des Schedulers. Fehlercode %u"
ER_PARTITION_MERGE_ERROR
eng "%s handler cannot be used in partitioned tables"
ger "%s-Handler kann in partitionierten Tabellen nicht verwendet werden"
swe "%s kan inte användas i en partitionerad tabell"
eng "Engine cannot be used in partitioned tables"
ger "Engine kann in partitionierten Tabellen nicht verwendet werden"
swe "Engine inte användas i en partitionerad tabell"
ER_CANT_ACTIVATE_LOG
eng "Cannot activate '%-.64s' log"
ger "Kann Logdatei '%-.64s' nicht aktivieren"

4
sql/sql_cache.cc
View File

@ -2389,7 +2389,7 @@ Query_cache::register_tables_from_list(TABLE_LIST *tables_used,
tables_used->engine_data))
DBUG_RETURN(0);
if (tables_used->table->s->db_type == myisammrg_hton)
if (tables_used->table->s->db_type->db_type == DB_TYPE_MRG_MYISAM)
{
ha_myisammrg *handler = (ha_myisammrg *) tables_used->table->file;
MYRG_INFO *file = handler->myrg_info();
@ -3013,7 +3013,7 @@ static TABLE_COUNTER_TYPE process_and_count_tables(TABLE_LIST *tables_used,
"other non-cacheable table(s)"));
DBUG_RETURN(0);
}
if (tables_used->table->s->db_type == myisammrg_hton)
if (tables_used->table->s->db_type->db_type == DB_TYPE_MRG_MYISAM)
{
ha_myisammrg *handler = (ha_myisammrg *)tables_used->table->file;
MYRG_INFO *file = handler->myrg_info();

12
sql/sql_cursor.cc
View File

@ -45,7 +45,7 @@ class Sensitive_cursor: public Server_side_cursor
query_id_t query_id;
struct Engine_info
{
const handlerton *ht;
handlerton *ht;
void *read_view;
};
Engine_info ht_info[MAX_HA];
@ -318,12 +318,12 @@ Sensitive_cursor::post_open(THD *thd)
info= &ht_info[0];
for (handlerton **pht= thd->transaction.stmt.ht; *pht; pht++)
{
const handlerton *ht= *pht;
handlerton *ht= *pht;
close_at_commit|= test(ht->flags & HTON_CLOSE_CURSORS_AT_COMMIT);
if (ht->create_cursor_read_view)
{
info->ht= ht;
info->read_view= (ht->create_cursor_read_view)(thd);
info->read_view= (ht->create_cursor_read_view)(ht, thd);
++info;
}
}
@ -433,7 +433,7 @@ Sensitive_cursor::fetch(ulong num_rows)
thd->set_n_backup_active_arena(this, &backup_arena);
for (info= ht_info; info->read_view ; info++)
(info->ht->set_cursor_read_view)(thd, info->read_view);
(info->ht->set_cursor_read_view)(info->htthd, info->read_view);
join->fetch_limit+= num_rows;
@ -454,7 +454,7 @@ Sensitive_cursor::fetch(ulong num_rows)
reset_thd(thd);
for (info= ht_info; info->read_view; info++)
(info->ht->set_cursor_read_view)(thd, 0);
(info->ht->set_cursor_read_view)(info->ht, thd, 0);
if (error == NESTED_LOOP_CURSOR_LIMIT)
{
@ -487,7 +487,7 @@ Sensitive_cursor::close()
for (Engine_info *info= ht_info; info->read_view; info++)
{
(info->ht->close_cursor_read_view)(thd, info->read_view);
(info->ht->close_cursor_read_view)(info->ht, thd, info->read_view);
info->read_view= 0;
info->ht= 0;
}

2
sql/sql_show.cc
View File

@ -4999,7 +4999,7 @@ static my_bool run_hton_fill_schema_files(THD *thd, st_plugin_int *plugin,
(run_hton_fill_schema_files_args *) arg;
handlerton *hton= (handlerton *)plugin->data;
if(hton->fill_files_table && hton->state == SHOW_OPTION_YES)
hton->fill_files_table(thd, args->tables, args->cond);
hton->fill_files_table(hton, thd, args->tables, args->cond);
return false;
}

4
sql/sql_tablespace.cc
View File

@ -21,7 +21,7 @@
int mysql_alter_tablespace(THD *thd, st_alter_tablespace *ts_info)
{
int error= HA_ADMIN_NOT_IMPLEMENTED;
const handlerton *hton= ts_info->storage_engine;
handlerton *hton= ts_info->storage_engine;
DBUG_ENTER("mysql_alter_tablespace");
/*
@ -42,7 +42,7 @@ int mysql_alter_tablespace(THD *thd, st_alter_tablespace *ts_info)
if (hton->alter_tablespace)
{
if ((error= hton->alter_tablespace(thd, ts_info)))
if ((error= hton->alter_tablespace(hton, thd, ts_info)))
{
if (error == HA_ADMIN_NOT_IMPLEMENTED)
{

21
storage/archive/ha_archive.cc
View File

@ -139,17 +139,21 @@ static HASH archive_open_tables;
#define ARCHIVE_CHECK_HEADER 254 // The number we use to determine corruption
/* Static declarations for handerton */
static handler *archive_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root);
static handler *archive_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
int archive_db_end(handlerton *hton, ha_panic_function type);
/*
Number of rows that will force a bulk insert.
*/
#define ARCHIVE_MIN_ROWS_TO_USE_BULK_INSERT 2
handlerton *archive_hton;
static handler *archive_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
static handler *archive_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_archive(table);
return new (mem_root) ha_archive(hton, table);
}
/*
@ -178,6 +182,7 @@ static byte* archive_get_key(ARCHIVE_SHARE *share,uint *length,
int archive_db_init(void *p)
{
DBUG_ENTER("archive_db_init");
handlerton *archive_hton;
if (archive_inited)
DBUG_RETURN(FALSE);
archive_hton= (handlerton *)p;
@ -226,13 +231,13 @@ int archive_db_done(void *p)
}
int archive_db_end(ha_panic_function type)
int archive_db_end(handlerton *hton, ha_panic_function type)
{
return archive_db_done(NULL);
}
ha_archive::ha_archive(TABLE_SHARE *table_arg)
:handler(archive_hton, table_arg), delayed_insert(0), bulk_insert(0)
ha_archive::ha_archive(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg), delayed_insert(0), bulk_insert(0)
{
/* Set our original buffer from pre-allocated memory */
buffer.set((char *)byte_buffer, IO_SIZE, system_charset_info);

4
storage/archive/ha_archive.h
View File

@ -67,7 +67,7 @@ class ha_archive: public handler
uint current_k_offset;
public:
ha_archive(TABLE_SHARE *table_arg);
ha_archive(handlerton *hton, TABLE_SHARE *table_arg);
~ha_archive()
{
}
@ -139,5 +139,3 @@ public:
bool check_and_repair(THD *thd);
};
int archive_db_end(ha_panic_function type);

12
storage/blackhole/ha_blackhole.cc
View File

@ -24,11 +24,11 @@
/* Static declarations for handlerton */
handlerton *blackhole_hton;
static handler *blackhole_create_handler(TABLE_SHARE *table,
static handler *blackhole_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_blackhole(table);
return new (mem_root) ha_blackhole(hton, table);
}
@ -36,8 +36,9 @@ static handler *blackhole_create_handler(TABLE_SHARE *table,
** BLACKHOLE tables
*****************************************************************************/
ha_blackhole::ha_blackhole(TABLE_SHARE *table_arg)
:handler(blackhole_hton, table_arg)
ha_blackhole::ha_blackhole(handlerton *hton,
TABLE_SHARE *table_arg)
:handler(hton, table_arg)
{}
@ -203,6 +204,7 @@ int ha_blackhole::index_last(byte * buf)
static int blackhole_init(void *p)
{
handlerton *blackhole_hton;
blackhole_hton= (handlerton *)p;
blackhole_hton->state= SHOW_OPTION_YES;
blackhole_hton->db_type= DB_TYPE_BLACKHOLE_DB;

2
storage/blackhole/ha_blackhole.h
View File

@ -28,7 +28,7 @@ class ha_blackhole: public handler
THR_LOCK thr_lock;
public:
ha_blackhole(TABLE_SHARE *table_arg);
ha_blackhole(handlerton *hton, TABLE_SHARE *table_arg);
~ha_blackhole()
{
}

24
storage/csv/ha_tina.cc
View File

@ -74,7 +74,11 @@ static int write_meta_file(File meta_file, ha_rows rows, bool dirty);
pthread_mutex_t tina_mutex;
static HASH tina_open_tables;
static int tina_init= 0;
static handler *tina_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root);
static handler *tina_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
int tina_end(handlerton *hton, ha_panic_function type);
off_t Transparent_file::read_next()
{
@ -123,7 +127,6 @@ char Transparent_file::get_value(off_t offset)
return buff[0];
}
}
handlerton *tina_hton;
/*****************************************************************************
** TINA tables
@ -150,6 +153,8 @@ static byte* tina_get_key(TINA_SHARE *share,uint *length,
static int tina_init_func(void *p)
{
handlerton *tina_hton;
if (!tina_init)
{
tina_hton= (handlerton *)p;
@ -161,7 +166,8 @@ static int tina_init_func(void *p)
tina_hton->db_type= DB_TYPE_CSV_DB;
tina_hton->create= tina_create_handler;
tina_hton->panic= tina_end;
tina_hton->flags= HTON_CAN_RECREATE | HTON_SUPPORT_LOG_TABLES;
tina_hton->flags= (HTON_CAN_RECREATE | HTON_SUPPORT_LOG_TABLES |
HTON_NO_PARTITION);
}
return 0;
}
@ -449,7 +455,7 @@ static int free_share(TINA_SHARE *share)
DBUG_RETURN(result_code);
}
int tina_end(ha_panic_function type)
int tina_end(handlerton *hton, ha_panic_function type)
{
return tina_done_func(NULL);
}
@ -493,14 +499,16 @@ off_t find_eoln_buff(Transparent_file *data_buff, off_t begin,
}
static handler *tina_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
static handler *tina_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_tina(table);
return new (mem_root) ha_tina(hton, table);
}
ha_tina::ha_tina(TABLE_SHARE *table_arg)
:handler(tina_hton, table_arg),
ha_tina::ha_tina(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg),
/*
These definitions are found in handler.h
They are not probably completely right.

4
storage/csv/ha_tina.h
View File

@ -129,7 +129,7 @@ private:
int init_tina_writer();
public:
ha_tina(TABLE_SHARE *table_arg);
ha_tina(handlerton *hton, TABLE_SHARE *table_arg);
~ha_tina()
{
if (chain_alloced)
@ -212,5 +212,3 @@ public:
int chain_append();
};
int tina_end(ha_panic_function type);

14
storage/example/ha_example.cc
View File

@ -73,7 +73,9 @@
#include <mysql/plugin.h>
static handler *example_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root);
static handler *example_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
static int example_init_func();
static bool example_init_func_for_handlerton();
static int example_panic(enum ha_panic_function flag);
@ -201,14 +203,16 @@ static int free_share(EXAMPLE_SHARE *share)
}
static handler* example_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
static handler* example_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_example(table);
return new (mem_root) ha_example(hton, table);
}
ha_example::ha_example(TABLE_SHARE *table_arg)
:handler(example_hton, table_arg)
ha_example::ha_example(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg)
{}
/*

2
storage/example/ha_example.h
View File

@ -45,7 +45,7 @@ class ha_example: public handler
EXAMPLE_SHARE *share; /* Shared lock info */
public:
ha_example(TABLE_SHARE *table_arg);
ha_example(handlerton *hton, TABLE_SHARE *table_arg);
~ha_example()
{
}

46
storage/federated/ha_federated.cc
View File

@ -359,19 +359,22 @@ static const uint sizeof_trailing_and= sizeof(" AND ") - 1;
static const uint sizeof_trailing_where= sizeof(" WHERE ") - 1;
/* Static declaration for handerton */
static handler *federated_create_handler(TABLE_SHARE *table,
static handler *federated_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
static int federated_commit(THD *thd, bool all);
static int federated_rollback(THD *thd, bool all);
static int federated_commit(handlerton *hton, THD *thd, bool all);
static int federated_rollback(handlerton *hton, THD *thd, bool all);
static int federated_db_init(void);
static int federated_db_end(handlerton *hton, ha_panic_function type);
/* Federated storage engine handlerton */
handlerton *federated_hton;
static handler *federated_create_handler(TABLE_SHARE *table,
static handler *federated_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_federated(table);
return new (mem_root) ha_federated(hton, table);
}
@ -399,7 +402,7 @@ static byte *federated_get_key(FEDERATED_SHARE *share, uint *length,
int federated_db_init(void *p)
{
DBUG_ENTER("federated_db_init");
federated_hton= (handlerton *)p;
handlerton *federated_hton= (handlerton *)p;
federated_hton->state= SHOW_OPTION_YES;
federated_hton->db_type= DB_TYPE_FEDERATED_DB;
federated_hton->commit= federated_commit;
@ -434,7 +437,7 @@ error:
FALSE OK
*/
int federated_db_end(ha_panic_function type)
int federated_db_end(handlerton *hton, ha_panic_function type)
{
if (federated_init)
{
@ -723,8 +726,9 @@ error:
** FEDERATED tables
*****************************************************************************/
ha_federated::ha_federated(TABLE_SHARE *table_arg)
:handler(federated_hton, table_arg),
ha_federated::ha_federated(handlerton *hton,
TABLE_SHARE *table_arg)
:handler(hton, table_arg),
mysql(0), stored_result(0)
{
trx_next= 0;
@ -2736,7 +2740,7 @@ bool ha_federated::get_error_message(int error, String* buf)
int ha_federated::external_lock(THD *thd, int lock_type)
{
int error= 0;
ha_federated *trx= (ha_federated *)thd->ha_data[federated_hton->slot];
ha_federated *trx= (ha_federated *)thd->ha_data[ht->slot];
DBUG_ENTER("ha_federated::external_lock");
if (lock_type != F_UNLCK)
@ -2754,7 +2758,7 @@ int ha_federated::external_lock(THD *thd, int lock_type)
DBUG_PRINT("info", ("error setting autocommit TRUE: %d", error));
DBUG_RETURN(error);
}
trans_register_ha(thd, FALSE, federated_hton);
trans_register_ha(thd, FALSE, ht);
}
else
{
@ -2770,8 +2774,8 @@ int ha_federated::external_lock(THD *thd, int lock_type)
DBUG_PRINT("info", ("error setting autocommit FALSE: %d", error));
DBUG_RETURN(error);
}
thd->ha_data[federated_hton->slot]= this;
trans_register_ha(thd, TRUE, federated_hton);
thd->ha_data[ht->slot]= this;
trans_register_ha(thd, TRUE, ht);
/*
Send a lock table to the remote end.
We do not support this at the moment
@ -2796,10 +2800,10 @@ int ha_federated::external_lock(THD *thd, int lock_type)
}
static int federated_commit(THD *thd, bool all)
static int federated_commit(handlerton *hton, THD *thd, bool all)
{
int return_val= 0;
ha_federated *trx= (ha_federated *)thd->ha_data[federated_hton->slot];
ha_federated *trx= (ha_federated *)thd->ha_data[hton->slot];
DBUG_ENTER("federated_commit");
if (all)
@ -2814,7 +2818,7 @@ static int federated_commit(THD *thd, bool all)
if (error && !return_val);
return_val= error;
}
thd->ha_data[federated_hton->slot]= NULL;
thd->ha_data[hton->slot]= NULL;
}
DBUG_PRINT("info", ("error val: %d", return_val));
@ -2822,10 +2826,10 @@ static int federated_commit(THD *thd, bool all)
}
static int federated_rollback(THD *thd, bool all)
static int federated_rollback(handlerton *hton, THD *thd, bool all)
{
int return_val= 0;
ha_federated *trx= (ha_federated *)thd->ha_data[federated_hton->slot];
ha_federated *trx= (ha_federated *)thd->ha_data[hton->slot];
DBUG_ENTER("federated_rollback");
if (all)
@ -2840,7 +2844,7 @@ static int federated_rollback(THD *thd, bool all)
if (error && !return_val)
return_val= error;
}
thd->ha_data[federated_hton->slot]= NULL;
thd->ha_data[hton->slot]= NULL;
}
DBUG_PRINT("info", ("error val: %d", return_val));

5
storage/federated/ha_federated.h
View File

@ -94,7 +94,7 @@ private:
int stash_remote_error();
public:
ha_federated(TABLE_SHARE *table_arg);
ha_federated(handlerton *hton, TABLE_SHARE *table_arg);
~ha_federated() {}
/* The name that will be used for display purposes */
const char *table_type() const { return "FEDERATED"; }
@ -236,6 +236,3 @@ public:
MYSQL_RES **result);
};
int federated_db_init(void);
int federated_db_end(ha_panic_function type);

22
storage/heap/ha_heap.cc
View File

@ -25,12 +25,20 @@
#include "ha_heap.h"
static handler *heap_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root);
static handler *heap_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
int heap_panic(handlerton *hton, ha_panic_function flag)
{
return hp_panic(flag);
}
handlerton *heap_hton;
int heap_init(void *p)
{
handlerton *heap_hton;
heap_hton= (handlerton *)p;
heap_hton->state= SHOW_OPTION_YES;
heap_hton->db_type= DB_TYPE_HEAP;
@ -41,9 +49,11 @@ int heap_init(void *p)
return 0;
}
static handler *heap_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
static handler *heap_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_heap(table);
return new (mem_root) ha_heap(hton, table);
}
@ -51,8 +61,8 @@ static handler *heap_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
** HEAP tables
*****************************************************************************/
ha_heap::ha_heap(TABLE_SHARE *table_arg)
:handler(heap_hton, table_arg), file(0), records_changed(0),
ha_heap::ha_heap(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg), file(0), records_changed(0),
key_stat_version(0)
{}

2
storage/heap/ha_heap.h
View File

@ -31,7 +31,7 @@ class ha_heap: public handler
uint records_changed;
uint key_stat_version;
public:
ha_heap(TABLE_SHARE *table);
ha_heap(handlerton *hton, TABLE_SHARE *table);
~ha_heap() {}
const char *table_type() const
{

6
storage/heap/hp_panic.c
View File

@ -19,10 +19,10 @@
/* if flag == HA_PANIC_CLOSE then all files are removed for more
memory */
int heap_panic(enum ha_panic_function flag)
int hp_panic(enum ha_panic_function flag)
{
LIST *element,*next_open;
DBUG_ENTER("heap_panic");
DBUG_ENTER("hp_panic");
pthread_mutex_lock(&THR_LOCK_heap);
for (element=heap_open_list ; element ; element=next_open)
@ -54,4 +54,4 @@ int heap_panic(enum ha_panic_function flag)
}
pthread_mutex_unlock(&THR_LOCK_heap);
DBUG_RETURN(0);
} /* heap_panic */
} /* hp_panic */

2
storage/heap/hp_test1.c
View File

@ -155,7 +155,7 @@ int main(int argc, char **argv)
}
#endif
if (heap_close(file) || heap_panic(HA_PANIC_CLOSE))
if (heap_close(file) || hp_panic(HA_PANIC_CLOSE))
goto err;
my_end(MY_GIVE_INFO);
return(0);

4
storage/heap/hp_test2.c
View File

@ -603,7 +603,7 @@ end:
if (heap_close(file) || (file2 && heap_close(file2)))
goto err;
heap_delete_table(filename2);
heap_panic(HA_PANIC_CLOSE);
hp_panic(HA_PANIC_CLOSE);
my_end(MY_GIVE_INFO);
return(0);
err:
@ -669,7 +669,7 @@ static sig_handler endprog(int sig_number __attribute__((unused)))
else
#endif
{
heap_panic(HA_PANIC_CLOSE);
hp_panic(HA_PANIC_CLOSE);
my_end(1);
exit(1);
}

195
storage/innobase/handler/ha_innodb.cc
View File

@ -54,6 +54,12 @@ pthread_cond_t commit_cond;
pthread_mutex_t commit_cond_m;
bool innodb_inited= 0;
/*
This needs to exist until the query cache callback is removed
or learns to pass hton.
*/
static handlerton *legacy_innodb_hton;
/*-----------------------------------------------------------------*/
/* These variables are used to implement (semi-)synchronous MySQL binlog
replication for InnoDB tables. */
@ -197,22 +203,25 @@ static mysql_byte* innobase_get_key(INNOBASE_SHARE *share,uint *length,
my_bool not_used __attribute__((unused)));
static INNOBASE_SHARE *get_share(const char *table_name);
static void free_share(INNOBASE_SHARE *share);
static int innobase_close_connection(THD* thd);
static int innobase_commit(THD* thd, bool all);
static int innobase_rollback(THD* thd, bool all);
static int innobase_rollback_to_savepoint(THD* thd, void *savepoint);
static int innobase_savepoint(THD* thd, void *savepoint);
static int innobase_release_savepoint(THD* thd, void *savepoint);
static handler *innobase_create_handler(TABLE_SHARE *table,
static int innobase_close_connection(handlerton *hton, THD* thd);
static int innobase_commit(handlerton *hton, THD* thd, bool all);
static int innobase_rollback(handlerton *hton, THD* thd, bool all);
static int innobase_rollback_to_savepoint(handlerton *hton, THD* thd,
void *savepoint);
static int innobase_savepoint(handlerton *hton, THD* thd, void *savepoint);
static int innobase_release_savepoint(handlerton *hton, THD* thd,
void *savepoint);
static handler *innobase_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
static const char innobase_hton_name[]= "InnoDB";
handlerton *innobase_hton;
static handler *innobase_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
static handler *innobase_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_innobase(table);
return new (mem_root) ha_innobase(hton, table);
}
@ -380,7 +389,8 @@ documentation, see handler.cc. */
int
innobase_release_temporary_latches(
/*===============================*/
THD *thd)
handlerton *hton,
THD *thd)
{
trx_t* trx;
@ -389,7 +399,7 @@ innobase_release_temporary_latches(
return 0;
}
trx = (trx_t*) thd->ha_data[innobase_hton->slot];
trx = (trx_t*) thd->ha_data[hton->slot];
if (trx) {
innobase_release_stat_resources(trx);
@ -841,13 +851,14 @@ trx_t*
check_trx_exists(
/*=============*/
/* out: InnoDB transaction handle */
handlerton* hton, /* in: handlerton for innodb */
THD* thd) /* in: user thread handle */
{
trx_t* trx;
ut_ad(thd == current_thd);
trx = (trx_t*) thd->ha_data[innobase_hton->slot];
trx = (trx_t*) thd->ha_data[hton->slot];
if (trx == NULL) {
DBUG_ASSERT(thd != NULL);
@ -861,7 +872,7 @@ check_trx_exists(
CPU time */
trx->support_xa = (ibool)(thd->variables.innodb_support_xa);
thd->ha_data[innobase_hton->slot] = trx;
thd->ha_data[hton->slot] = trx;
} else {
if (trx->magic_n != TRX_MAGIC_N) {
mem_analyze_corruption(trx);
@ -889,8 +900,8 @@ check_trx_exists(
/*************************************************************************
Construct ha_innobase handler. */
ha_innobase::ha_innobase(TABLE_SHARE *table_arg)
:handler(innobase_hton, table_arg),
ha_innobase::ha_innobase(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg),
int_table_flags(HA_REC_NOT_IN_SEQ |
HA_NULL_IN_KEY |
HA_CAN_INDEX_BLOBS |
@ -917,7 +928,7 @@ ha_innobase::update_thd(
row_prebuilt_t* prebuilt = (row_prebuilt_t*) innobase_prebuilt;
trx_t* trx;
trx = check_trx_exists(thd);
trx = check_trx_exists(ht, thd);
if (prebuilt->trx != trx) {
@ -938,10 +949,11 @@ inline
void
innobase_register_stmt(
/*===================*/
handlerton* hton, /* in: Innobase hton */
THD* thd) /* in: MySQL thd (connection) object */
{
/* Register the statement */
trans_register_ha(thd, FALSE, innobase_hton);
trans_register_ha(thd, FALSE, hton);
}
/*************************************************************************
@ -955,17 +967,18 @@ inline
void
innobase_register_trx_and_stmt(
/*===========================*/
handlerton *hton, /* in: Innobase handlerton */
THD* thd) /* in: MySQL thd (connection) object */
{
/* NOTE that actually innobase_register_stmt() registers also
the transaction in the AUTOCOMMIT=1 mode. */
innobase_register_stmt(thd);
innobase_register_stmt(hton, thd);
if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) {
/* No autocommit mode, register for a transaction */
trans_register_ha(thd, TRUE, innobase_hton);
trans_register_ha(thd, TRUE, hton);
}
}
@ -1061,7 +1074,7 @@ innobase_query_caching_of_table_permitted(
return((my_bool)FALSE);
}
trx = check_trx_exists(thd);
trx = check_trx_exists(legacy_innodb_hton, thd);
if (trx->has_search_latch) {
ut_print_timestamp(stderr);
sql_print_error("The calling thread is holding the adaptive "
@ -1120,7 +1133,7 @@ innobase_query_caching_of_table_permitted(
if (trx->active_trans == 0) {
innobase_register_trx_and_stmt(thd);
innobase_register_trx_and_stmt(legacy_innodb_hton, thd);
trx->active_trans = 1;
}
@ -1295,7 +1308,7 @@ ha_innobase::init_table_handle_for_HANDLER(void)
if (prebuilt->trx->active_trans == 0) {
innobase_register_trx_and_stmt(current_thd);
innobase_register_trx_and_stmt(ht, current_thd);
prebuilt->trx->active_trans = 1;
}
@ -1338,7 +1351,8 @@ innobase_init(void *p)
char *default_path;
DBUG_ENTER("innobase_init");
innobase_hton= (handlerton *)p;
handlerton *innobase_hton= (handlerton *)p;
legacy_innodb_hton= innobase_hton;
innobase_hton->state=have_innodb;
innobase_hton->db_type= DB_TYPE_INNODB;
@ -1613,7 +1627,7 @@ error:
Closes an InnoDB database. */
int
innobase_end(ha_panic_function type)
innobase_end(handlerton *hton, ha_panic_function type)
/*==============*/
/* out: TRUE if error */
{
@ -1651,7 +1665,7 @@ Flushes InnoDB logs to disk and makes a checkpoint. Really, a commit flushes
the logs, and the name of this function should be innobase_checkpoint. */
bool
innobase_flush_logs(void)
innobase_flush_logs(handlerton *hton)
/*=====================*/
/* out: TRUE if error */
{
@ -1690,6 +1704,7 @@ int
innobase_start_trx_and_assign_read_view(
/*====================================*/
/* out: 0 */
handlerton *hton, /* in: Innodb handlerton */
THD* thd) /* in: MySQL thread handle of the user for whom
the transaction should be committed */
{
@ -1699,7 +1714,7 @@ innobase_start_trx_and_assign_read_view(
/* Create a new trx struct for thd, if it does not yet have one */
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
/* This is just to play safe: release a possible FIFO ticket and
search latch. Since we will reserve the kernel mutex, we have to
@ -1718,9 +1733,7 @@ innobase_start_trx_and_assign_read_view(
/* Set the MySQL flag to mark that there is an active transaction */
if (trx->active_trans == 0) {
innobase_register_trx_and_stmt(current_thd);
innobase_register_trx_and_stmt(hton, current_thd);
trx->active_trans = 1;
}
@ -1735,7 +1748,8 @@ int
innobase_commit(
/*============*/
/* out: 0 */
THD* thd, /* in: MySQL thread handle of the user for whom
handlerton *hton, /* in: Innodb handlerton */
THD* thd, /* in: MySQL thread handle of the user for whom
the transaction should be committed */
bool all) /* in: TRUE - commit transaction
FALSE - the current SQL statement ended */
@ -1745,7 +1759,7 @@ innobase_commit(
DBUG_ENTER("innobase_commit");
DBUG_PRINT("trans", ("ending transaction"));
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
/* Update the info whether we should skip XA steps that eat CPU time */
trx->support_xa = (ibool)(thd->variables.innodb_support_xa);
@ -1871,6 +1885,7 @@ int
innobase_report_binlog_offset_and_commit(
/*=====================================*/
/* out: 0 */
handlerton *hton, /* in: Innodb handlerton */
THD* thd, /* in: user thread */
void* trx_handle, /* in: InnoDB trx handle */
char* log_file_name, /* in: latest binlog file name */
@ -1888,7 +1903,7 @@ innobase_report_binlog_offset_and_commit(
trx->flush_log_later = TRUE;
innobase_commit(thd, TRUE);
innobase_commit(hton, thd, TRUE);
trx->flush_log_later = FALSE;
@ -1936,11 +1951,12 @@ int
innobase_commit_complete(
/*=====================*/
/* out: 0 */
handlerton *hton, /* in: Innodb handlerton */
THD* thd) /* in: user thread */
{
trx_t* trx;
trx = (trx_t*) thd->ha_data[innobase_hton->slot];
trx = (trx_t*) thd->ha_data[hton->slot];
if (trx && trx->active_trans) {
@ -1964,6 +1980,7 @@ static int
innobase_rollback(
/*==============*/
/* out: 0 or error number */
handlerton *hton, /* in: Innodb handlerton */
THD* thd, /* in: handle to the MySQL thread of the user
whose transaction should be rolled back */
bool all) /* in: TRUE - commit transaction
@ -1975,7 +1992,7 @@ innobase_rollback(
DBUG_ENTER("innobase_rollback");
DBUG_PRINT("trans", ("aborting transaction"));
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
/* Update the info whether we should skip XA steps that eat CPU time */
trx->support_xa = (ibool)(thd->variables.innodb_support_xa);
@ -2047,6 +2064,7 @@ innobase_rollback_to_savepoint(
/*===========================*/
/* out: 0 if success, HA_ERR_NO_SAVEPOINT if
no savepoint with the given name */
handlerton *hton, /* in: Innodb handlerton */
THD* thd, /* in: handle to the MySQL thread of the user
whose transaction should be rolled back */
void* savepoint) /* in: savepoint data */
@ -2058,7 +2076,7 @@ innobase_rollback_to_savepoint(
DBUG_ENTER("innobase_rollback_to_savepoint");
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
/* Release a possible FIFO ticket and search latch. Since we will
reserve the kernel mutex, we have to release the search system latch
@ -2083,6 +2101,7 @@ innobase_release_savepoint(
/*=======================*/
/* out: 0 if success, HA_ERR_NO_SAVEPOINT if
no savepoint with the given name */
handlerton* hton, /* in: handlerton for Innodb */
THD* thd, /* in: handle to the MySQL thread of the user
whose transaction should be rolled back */
void* savepoint) /* in: savepoint data */
@ -2093,7 +2112,7 @@ innobase_release_savepoint(
DBUG_ENTER("innobase_release_savepoint");
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
/* TODO: use provided savepoint data area to store savepoint data */
@ -2111,6 +2130,7 @@ int
innobase_savepoint(
/*===============*/
/* out: always 0, that is, always succeeds */
handlerton* hton, /* in: handle to the Innodb handlerton */
THD* thd, /* in: handle to the MySQL thread */
void* savepoint) /* in: savepoint data */
{
@ -2127,7 +2147,7 @@ innobase_savepoint(
DBUG_ASSERT(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
thd->in_sub_stmt);
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
/* Release a possible FIFO ticket and search latch. Since we will
reserve the kernel mutex, we have to release the search system latch
@ -2154,12 +2174,13 @@ int
innobase_close_connection(
/*======================*/
/* out: 0 or error number */
handlerton* hton, /* in: innobase handlerton */
THD* thd) /* in: handle to the MySQL thread of the user
whose resources should be free'd */
{
trx_t* trx;
trx = (trx_t*)thd->ha_data[innobase_hton->slot];
trx = (trx_t*)thd->ha_data[hton->slot];
ut_a(trx);
@ -3252,11 +3273,11 @@ ha_innobase::write_row(
DBUG_ENTER("ha_innobase::write_row");
if (prebuilt->trx !=
(trx_t*) current_thd->ha_data[innobase_hton->slot]) {
(trx_t*) current_thd->ha_data[ht->slot]) {
sql_print_error("The transaction object for the table handle is at "
"%p, but for the current thread it is at %p",
prebuilt->trx,
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
fputs("InnoDB: Dump of 200 bytes around prebuilt: ", stderr);
ut_print_buf(stderr, ((const byte*)prebuilt) - 100, 200);
@ -3264,7 +3285,7 @@ ha_innobase::write_row(
"InnoDB: Dump of 200 bytes around transaction.all: ",
stderr);
ut_print_buf(stderr,
((byte*)(&(current_thd->ha_data[innobase_hton->slot]))) - 100,
((byte*)(&(current_thd->ha_data[ht->slot]))) - 100,
200);
putc('\n', stderr);
ut_error;
@ -3318,7 +3339,7 @@ no_commit:
no need to re-acquire locks on it. */
/* Altering to InnoDB format */
innobase_commit(user_thd, 1);
innobase_commit(ht, user_thd, 1);
/* Note that this transaction is still active. */
prebuilt->trx->active_trans = 1;
/* We will need an IX lock on the destination table. */
@ -3334,7 +3355,7 @@ no_commit:
/* Commit the transaction. This will release the table
locks, so they have to be acquired again. */
innobase_commit(user_thd, 1);
innobase_commit(ht, user_thd, 1);
/* Note that this transaction is still active. */
prebuilt->trx->active_trans = 1;
/* Re-acquire the table lock on the source table. */
@ -3637,7 +3658,7 @@ ha_innobase::update_row(
DBUG_ENTER("ha_innobase::update_row");
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
table->timestamp_field->set_time();
@ -3698,7 +3719,7 @@ ha_innobase::delete_row(
DBUG_ENTER("ha_innobase::delete_row");
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
if (last_query_id != user_thd->query_id) {
prebuilt->sql_stat_start = TRUE;
@ -3796,7 +3817,7 @@ ha_innobase::try_semi_consistent_read(bool yes)
row_prebuilt_t* prebuilt = (row_prebuilt_t*) innobase_prebuilt;
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
/* Row read type is set to semi consistent read if this was
requested by the MySQL and either innodb_locks_unsafe_for_binlog
@ -3963,7 +3984,7 @@ ha_innobase::index_read(
DBUG_ENTER("index_read");
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
statistic_increment(current_thd->status_var.ha_read_key_count,
&LOCK_status);
@ -4078,7 +4099,7 @@ ha_innobase::change_active_index(
ut_ad(user_thd == current_thd);
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
active_index = keynr;
@ -4168,7 +4189,7 @@ ha_innobase::general_fetch(
DBUG_ENTER("general_fetch");
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
innodb_srv_conc_enter_innodb(prebuilt->trx);
@ -4404,7 +4425,7 @@ ha_innobase::rnd_pos(
&LOCK_status);
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
if (prebuilt->clust_index_was_generated) {
/* No primary key was defined for the table and we
@ -4454,7 +4475,7 @@ ha_innobase::position(
uint len;
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
if (prebuilt->clust_index_was_generated) {
/* No primary key was defined for the table and we
@ -4782,7 +4803,7 @@ ha_innobase::create(
/* Get the transaction associated with the current thd, or create one
if not yet created */
parent_trx = check_trx_exists(thd);
parent_trx = check_trx_exists(ht, thd);
/* In case MySQL calls this in the middle of a SELECT query, release
possible adaptive hash latch to avoid deadlocks of threads */
@ -4955,7 +4976,7 @@ ha_innobase::discard_or_import_tablespace(
ut_a(prebuilt->trx && prebuilt->trx->magic_n == TRX_MAGIC_N);
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
dict_table = prebuilt->table;
trx = prebuilt->trx;
@ -5035,7 +5056,7 @@ ha_innobase::delete_table(
/* Get the transaction associated with the current thd, or create one
if not yet created */
parent_trx = check_trx_exists(thd);
parent_trx = check_trx_exists(ht, thd);
/* In case MySQL calls this in the middle of a SELECT query, release
possible adaptive hash latch to avoid deadlocks of threads */
@ -5102,6 +5123,7 @@ void
innobase_drop_database(
/*===================*/
/* out: error number */
handlerton *hton, /* in: handlerton of Innodb */
char* path) /* in: database path; inside InnoDB the name
of the last directory in the path is used as
the database name: for example, in 'mysql/data/test'
@ -5117,7 +5139,7 @@ innobase_drop_database(
/* Get the transaction associated with the current thd, or create one
if not yet created */
parent_trx = check_trx_exists(current_thd);
parent_trx = check_trx_exists(hton, current_thd);
/* In case MySQL calls this in the middle of a SELECT query, release
possible adaptive hash latch to avoid deadlocks of threads */
@ -5196,7 +5218,7 @@ ha_innobase::rename_table(
/* Get the transaction associated with the current thd, or create one
if not yet created */
parent_trx = check_trx_exists(current_thd);
parent_trx = check_trx_exists(ht, current_thd);
/* In case MySQL calls this in the middle of a SELECT query, release
possible adaptive hash latch to avoid deadlocks of threads */
@ -5283,7 +5305,7 @@ ha_innobase::records_in_range(
DBUG_ENTER("records_in_range");
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
prebuilt->trx->op_info = (char*)"estimating records in index range";
@ -5725,7 +5747,7 @@ ha_innobase::check(
ut_a(prebuilt->trx && prebuilt->trx->magic_n == TRX_MAGIC_N);
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
if (prebuilt->mysql_template == NULL) {
/* Build the template; we will use a dummy template
@ -6009,7 +6031,7 @@ ha_innobase::can_switch_engines(void)
DBUG_ENTER("ha_innobase::can_switch_engines");
ut_a(prebuilt->trx ==
(trx_t*) current_thd->ha_data[innobase_hton->slot]);
(trx_t*) current_thd->ha_data[ht->slot]);
prebuilt->trx->op_info =
"determining if there are foreign key constraints";
@ -6202,10 +6224,10 @@ ha_innobase::start_stmt(
/* Set the MySQL flag to mark that there is an active transaction */
if (trx->active_trans == 0) {
innobase_register_trx_and_stmt(thd);
innobase_register_trx_and_stmt(ht, thd);
trx->active_trans = 1;
} else {
innobase_register_stmt(thd);
innobase_register_stmt(ht, thd);
}
return(0);
@ -6278,10 +6300,10 @@ ha_innobase::external_lock(
transaction */
if (trx->active_trans == 0) {
innobase_register_trx_and_stmt(thd);
innobase_register_trx_and_stmt(ht, thd);
trx->active_trans = 1;
} else if (trx->n_mysql_tables_in_use == 0) {
innobase_register_stmt(thd);
innobase_register_stmt(ht, thd);
}
trx->n_mysql_tables_in_use++;
@ -6359,7 +6381,7 @@ ha_innobase::external_lock(
if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
if (trx->active_trans != 0) {
innobase_commit(thd, TRUE);
innobase_commit(ht, thd, TRUE);
}
} else {
if (trx->isolation_level <= TRX_ISO_READ_COMMITTED
@ -6440,7 +6462,7 @@ ha_innobase::transactional_table_lock(
/* Set the MySQL flag to mark that there is an active transaction */
if (trx->active_trans == 0) {
innobase_register_trx_and_stmt(thd);
innobase_register_trx_and_stmt(ht, thd);
trx->active_trans = 1;
}
@ -6488,6 +6510,7 @@ Monitor to the client. */
bool
innodb_show_status(
/*===============*/
handlerton* hton, /* in: the innodb handlerton */
THD* thd, /* in: the MySQL query thread of the caller */
stat_print_fn *stat_print)
{
@ -6503,7 +6526,7 @@ innodb_show_status(
DBUG_RETURN(FALSE);
}
trx = check_trx_exists(thd);
trx = check_trx_exists(hton, thd);
innobase_release_stat_resources(trx);
@ -6578,6 +6601,7 @@ Implements the SHOW MUTEX STATUS command. . */
bool
innodb_mutex_show_status(
/*=====================*/
handlerton* hton, /* in: the innodb handlerton */
THD* thd, /* in: the MySQL query thread of the
caller */
stat_print_fn* stat_print)
@ -6659,14 +6683,15 @@ innodb_mutex_show_status(
DBUG_RETURN(FALSE);
}
bool innobase_show_status(THD* thd, stat_print_fn* stat_print,
enum ha_stat_type stat_type)
bool innobase_show_status(handlerton *hton, THD* thd,
stat_print_fn* stat_print,
enum ha_stat_type stat_type)
{
switch (stat_type) {
case HA_ENGINE_STATUS:
return innodb_show_status(thd, stat_print);
return innodb_show_status(hton, thd, stat_print);
case HA_ENGINE_MUTEX:
return innodb_mutex_show_status(thd, stat_print);
return innodb_mutex_show_status(hton, thd, stat_print);
default:
return FALSE;
}
@ -6766,7 +6791,7 @@ ha_innobase::store_lock(
because we call update_thd() later, in ::external_lock()! Failure to
understand this caused a serious memory corruption bug in 5.1.11. */
trx = check_trx_exists(thd);
trx = check_trx_exists(ht, thd);
/* NOTE: MySQL can call this function with lock 'type' TL_IGNORE!
Be careful to ignore TL_IGNORE if we are going to do something with
@ -7152,7 +7177,7 @@ ha_innobase::reset_auto_increment(ulonglong value)
bool
ha_innobase::get_error_message(int error, String *buf)
{
trx_t* trx = check_trx_exists(current_thd);
trx_t* trx = check_trx_exists(ht, current_thd);
buf->copy(trx->detailed_error, strlen(trx->detailed_error),
system_charset_info);
@ -7371,13 +7396,14 @@ int
innobase_xa_prepare(
/*================*/
/* out: 0 or error number */
handlerton *hton,
THD* thd, /* in: handle to the MySQL thread of the user
whose XA transaction should be prepared */
bool all) /* in: TRUE - commit transaction
FALSE - the current SQL statement ended */
{
int error = 0;
trx_t* trx = check_trx_exists(thd);
trx_t* trx = check_trx_exists(hton, thd);
if (thd->lex->sql_command != SQLCOM_XA_PREPARE &&
(all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))))
@ -7467,6 +7493,7 @@ innobase_xa_recover(
/*================*/
/* out: number of prepared transactions
stored in xid_list */
handlerton *hton,
XID* xid_list, /* in/out: prepared transactions */
uint len) /* in: number of slots in xid_list */
{
@ -7486,6 +7513,7 @@ int
innobase_commit_by_xid(
/*===================*/
/* out: 0 or error number */
handlerton *hton,
XID* xid) /* in: X/Open XA transaction identification */
{
trx_t* trx;
@ -7509,6 +7537,7 @@ int
innobase_rollback_by_xid(
/*=====================*/
/* out: 0 or error number */
handlerton *hton,
XID *xid) /* in: X/Open XA transaction identification */
{
trx_t* trx;
@ -7530,13 +7559,12 @@ using a cursor. */
void*
innobase_create_cursor_view(
/*========================*/
/* out: pointer to cursor
view or NULL */
THD* thd) /* in: user thread handle */
/* out: pointer to cursor view or NULL */
handlerton *hton, /* in: innobase hton */
THD* thd) /* in: user thread handle */
{
return(read_cursor_view_create_for_mysql(
check_trx_exists(thd)));
check_trx_exists(hton, thd)));
}
/***********************************************************************
@ -7546,11 +7574,11 @@ corresponding MySQL thread still lacks one. */
void
innobase_close_cursor_view(
/*=======================*/
handlerton *hton,
THD* thd, /* in: user thread handle */
void* curview)/* in: Consistent read view to be closed */
{
read_cursor_view_close_for_mysql(check_trx_exists(current_thd),
read_cursor_view_close_for_mysql(check_trx_exists(hton, current_thd),
(cursor_view_t*) curview);
}
@ -7563,10 +7591,11 @@ restored to a transaction read view. */
void
innobase_set_cursor_view(
/*=====================*/
handlerton *hton,
THD* thd, /* in: user thread handle */
void* curview)/* in: Consistent cursor view to be set */
{
read_cursor_set_for_mysql(check_trx_exists(current_thd),
read_cursor_set_for_mysql(check_trx_exists(hton, current_thd),
(cursor_view_t*) curview);
}

29
storage/innobase/handler/ha_innodb.h
View File

@ -80,7 +80,7 @@ class ha_innobase: public handler
/* Init values for the class: */
public:
ha_innobase(TABLE_SHARE *table_arg);
ha_innobase(handlerton *hton, TABLE_SHARE *table_arg);
~ha_innobase() {}
/*
Get the row type from the storage engine. If this method returns
@ -240,8 +240,8 @@ extern ulong srv_flush_log_at_trx_commit;
}
int innobase_init(void);
int innobase_end(ha_panic_function type);
bool innobase_flush_logs(void);
int innobase_end(handlerton *hton, ha_panic_function type);
bool innobase_flush_logs(handlerton *hton);
uint innobase_get_free_space(void);
/*
@ -258,14 +258,14 @@ int innobase_commit_complete(void* trx_handle);
void innobase_store_binlog_offset_and_flush_log(char *binlog_name,longlong offset);
#endif
void innobase_drop_database(char *path);
bool innobase_show_status(THD* thd, stat_print_fn*, enum ha_stat_type);
void innobase_drop_database(handlerton *hton, char *path);
bool innobase_show_status(handlerton *hton, THD* thd, stat_print_fn*, enum ha_stat_type);
int innobase_release_temporary_latches(THD *thd);
int innobase_release_temporary_latches(handlerton *hton, THD *thd);
void innobase_store_binlog_offset_and_flush_log(char *binlog_name,longlong offset);
void innobase_store_binlog_offset_and_flush_log(handlerton *hton, char *binlog_name,longlong offset);
int innobase_start_trx_and_assign_read_view(THD* thd);
int innobase_start_trx_and_assign_read_view(handlerton *hton, THD* thd);
/***********************************************************************
This function is used to prepare X/Open XA distributed transaction */
@ -273,6 +273,7 @@ This function is used to prepare X/Open XA distributed transaction */
int innobase_xa_prepare(
/*====================*/
/* out: 0 or error number */
handlerton *hton, /* in: innobase hton */
THD* thd, /* in: handle to the MySQL thread of the user
whose XA transaction should be prepared */
bool all); /* in: TRUE - commit transaction
@ -285,6 +286,7 @@ int innobase_xa_recover(
/*====================*/
/* out: number of prepared transactions
stored in xid_list */
handlerton *hton, /* in: innobase hton */
XID* xid_list, /* in/out: prepared transactions */
uint len); /* in: number of slots in xid_list */
@ -295,6 +297,7 @@ which is in the prepared state */
int innobase_commit_by_xid(
/*=======================*/
/* out: 0 or error number */
handlerton *hton, /* in: innobase hton */
XID* xid); /* in : X/Open XA Transaction Identification */
/***********************************************************************
@ -303,6 +306,7 @@ which is in the prepared state */
int innobase_rollback_by_xid(
/* out: 0 or error number */
handlerton *hton, /* in: innobase hton */
XID *xid); /* in : X/Open XA Transaction Identification */
@ -314,10 +318,9 @@ using a cursor. */
void*
innobase_create_cursor_view(
/*========================*/
/* out: pointer to cursor
view or NULL */
THD* thd); /* in: user thread handle */
/* out: Pointer to cursor view or NULL */
handlerton *hton, /* in: innobase hton */
THD* thd); /* in: user thread handle */
/***********************************************************************
Close the given consistent cursor view of a transaction and restore
@ -327,6 +330,7 @@ corresponding MySQL thread still lacks one. */
void
innobase_close_cursor_view(
/*=======================*/
handlerton *hton, /* in: innobase hton */
THD* thd, /* in: user thread handle */
void* curview); /* in: Consistent read view to be closed */
@ -340,5 +344,6 @@ restored to a transaction read view. */
void
innobase_set_cursor_view(
/*=====================*/
handlerton *hton, /* in: innobase hton */
THD* thd, /* in: user thread handle */
void* curview); /* in: Consistent read view to be set */

26
storage/myisam/ha_myisam.cc
View File

@ -48,9 +48,11 @@ TYPELIB myisam_stats_method_typelib= {
** MyISAM tables
*****************************************************************************/
static handler *myisam_create_handler(TABLE_SHARE *table, MEM_ROOT *mem_root)
static handler *myisam_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_myisam(table);
return new (mem_root) ha_myisam(hton, table);
}
// collect errors printed by mi_check routines
@ -133,8 +135,8 @@ void mi_check_print_warning(MI_CHECK *param, const char *fmt,...)
}
ha_myisam::ha_myisam(TABLE_SHARE *table_arg)
:handler(myisam_hton, table_arg), file(0),
ha_myisam::ha_myisam(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg), file(0),
int_table_flags(HA_NULL_IN_KEY | HA_CAN_FULLTEXT | HA_CAN_SQL_HANDLER |
HA_DUPLICATE_POS | HA_CAN_INDEX_BLOBS | HA_AUTO_PART_KEY |
HA_FILE_BASED | HA_CAN_GEOMETRY | HA_NO_TRANSACTIONS |
@ -1787,15 +1789,21 @@ bool ha_myisam::check_if_incompatible_data(HA_CREATE_INFO *info,
return COMPATIBLE_DATA_YES;
}
handlerton *myisam_hton;
extern int mi_panic(enum ha_panic_function flag);
int myisam_panic(handlerton *hton, ha_panic_function flag)
{
return mi_panic(flag);
}
static int myisam_init(void *p)
{
handlerton *myisam_hton;
myisam_hton= (handlerton *)p;
myisam_hton->state=SHOW_OPTION_YES;
myisam_hton->db_type=DB_TYPE_MYISAM;
myisam_hton->create=myisam_create_handler;
myisam_hton->panic=mi_panic;
myisam_hton->state= SHOW_OPTION_YES;
myisam_hton->db_type= DB_TYPE_MYISAM;
myisam_hton->create= myisam_create_handler;
myisam_hton->panic= myisam_panic;
myisam_hton->flags= HTON_CAN_RECREATE | HTON_SUPPORT_LOG_TABLES;
return 0;
}

2
storage/myisam/ha_myisam.h
View File

@ -43,7 +43,7 @@ class ha_myisam: public handler
int repair(THD *thd, MI_CHECK &param, bool optimize);
public:
ha_myisam(TABLE_SHARE *table_arg);
ha_myisam(handlerton *hton, TABLE_SHARE *table_arg);
~ha_myisam() {}
handler *clone(MEM_ROOT *mem_root);
const char *table_type() const { return "MyISAM"; }

31
storage/myisammrg/ha_myisammrg.cc
View File

@ -34,19 +34,16 @@
static handler *myisammrg_create_handler(TABLE_SHARE *table,
MEM_ROOT *mem_root);
/* MyISAM MERGE handlerton */
handlerton *myisammrg_hton;
static handler *myisammrg_create_handler(TABLE_SHARE *table,
static handler *myisammrg_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_myisammrg(table);
return new (mem_root) ha_myisammrg(hton, table);
}
ha_myisammrg::ha_myisammrg(TABLE_SHARE *table_arg)
:handler(myisammrg_hton, table_arg), file(0)
ha_myisammrg::ha_myisammrg(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg), file(0)
{}
static const char *ha_myisammrg_exts[] = {
@ -554,15 +551,23 @@ bool ha_myisammrg::check_if_incompatible_data(HA_CREATE_INFO *info,
return COMPATIBLE_DATA_NO;
}
extern int myrg_panic(enum ha_panic_function flag);
int myisammrg_panic(handlerton *hton, ha_panic_function flag)
{
return myrg_panic(flag);
}
static int myisammrg_init(void *p)
{
handlerton *myisammrg_hton;
myisammrg_hton= (handlerton *)p;
myisammrg_hton->state=have_merge_db;
myisammrg_hton->db_type=DB_TYPE_MRG_MYISAM;
myisammrg_hton->create=myisammrg_create_handler;
myisammrg_hton->panic=myrg_panic;
myisammrg_hton->flags= HTON_CAN_RECREATE;
myisammrg_hton->state= have_merge_db;
myisammrg_hton->db_type= DB_TYPE_MRG_MYISAM;
myisammrg_hton->create= myisammrg_create_handler;
myisammrg_hton->panic= myisammrg_panic;
myisammrg_hton->flags= HTON_CAN_RECREATE|HTON_NO_PARTITION;
return 0;
}

2
storage/myisammrg/ha_myisammrg.h
View File

@ -28,7 +28,7 @@ class ha_myisammrg: public handler
MYRG_INFO *file;
public:
ha_myisammrg(TABLE_SHARE *table_arg);
ha_myisammrg(handlerton *hton, TABLE_SHARE *table_arg);
~ha_myisammrg() {}
const char *table_type() const { return "MRG_MyISAM"; }
const char **bas_ext() const;