diff options
| author | brian@zim.(none) <> | 2006-09-30 18:44:42 -0700 |
|---|---|---|
| committer | brian@zim.(none) <> | 2006-09-30 18:44:42 -0700 |
| commit | 4117860ec67f4156a150fdbf1ec8071ce11d1ffb (patch) | |
| tree | 51071e4478e163ac38d94418fa28ed75416be90a | |
| parent | bb09a2a940faf95740211442a95ef98e06cbbbcb (diff) | |
| parent | 56505c01f911d788edc13f099ac99193b92a26c6 (diff) | |
| download | mariadb-git-4117860ec67f4156a150fdbf1ec8071ce11d1ffb.tar.gz | |
Merge zim.(none):/home/brian/mysql/merge-5.1
into zim.(none):/home/brian/mysql/arch-5.1
39 files changed, 465 insertions, 346 deletions
diff --git a/include/heap.h b/include/heap.h index 985b20f9dc9..69d1e441a4b 100644 --- a/include/heap.h +++ b/include/heap.h @@ -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); diff --git a/mysql-test/r/partition.result b/mysql-test/r/partition.result index d8d433ef216..6c37f0834e9 100644 --- a/mysql-test/r/partition.result +++ b/mysql-test/r/partition.result @@ -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'; diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 157af825063..fffa87daf64 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -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); - -handlerton *ndbcluster_hton; - -static handler *ndbcluster_create_handler(TABLE_SHARE *table, +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); + +static handlerton *ndbcluster_hton; + +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; diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h index 5cd5bb2c716..19ff513f9b1 100644 --- a/sql/ha_ndbcluster.h +++ b/sql/ha_ndbcluster.h @@ -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(); diff --git a/sql/ha_ndbcluster_binlog.cc b/sql/ha_ndbcluster_binlog.cc index 3fc84ad1b66..5f5c8bcb221 100644 --- a/sql/ha_ndbcluster_binlog.cc +++ b/sql/ha_ndbcluster_binlog.cc @@ -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) { diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc index 8e704f34550..0da0094d92e 100644 --- a/sql/ha_partition.cc +++ b/sql/ha_partition.cc @@ -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()) diff --git a/sql/ha_partition.h b/sql/ha_partition.h index 97086d7b632..b66db205549 100644 --- a/sql/ha_partition.h +++ b/sql/ha_partition.h @@ -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 diff --git a/sql/handler.cc b/sql/handler.cc index 7848552f3de..ccf1a1ef8d9 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -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 */ diff --git a/sql/handler.h b/sql/handler.h index 3c237149386..e0827fec5c8 100644 --- a/sql/handler.h +++ b/sql/handler.h @@ -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); diff --git a/sql/log.cc b/sql/log.cc index 9c2efb04a44..05758fd6e7d 100644 --- a/sql/log.cc +++ b/sql/log.cc @@ -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= diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index c6f5ff9c3fe..95f194dc7ac 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -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; diff --git a/sql/mysqld.cc b/sql/mysqld.cc index a3844ea8fc0..ba7db6aaf82 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -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; diff --git a/sql/partition_info.cc b/sql/partition_info.cc index 3e8ad9bb78b..b3c7c1b80e7 100644 --- a/sql/partition_info.cc +++ b/sql/partition_info.cc @@ -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); diff --git a/sql/share/errmsg.txt b/sql/share/errmsg.txt index c90e771fd40..e465e5881d6 100644 --- a/sql/share/errmsg.txt +++ b/sql/share/errmsg.txt @@ -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" diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc index e0831b0f8ee..ee3b8aa79fe 100644 --- a/sql/sql_cache.cc +++ b/sql/sql_cache.cc @@ -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(); diff --git a/sql/sql_cursor.cc b/sql/sql_cursor.cc index 82ee8d72d33..a9ad35e7f9b 100644 --- a/sql/sql_cursor.cc +++ b/sql/sql_cursor.cc @@ -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; } diff --git a/sql/sql_show.cc b/sql/sql_show.cc index ce7832569fe..45865adddcd 100644 --- a/sql/sql_show.cc +++ b/sql/sql_show.cc @@ -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; } diff --git a/sql/sql_tablespace.cc b/sql/sql_tablespace.cc index 13dfb491af4..470fa5bc862 100644 --- a/sql/sql_tablespace.cc +++ b/sql/sql_tablespace.cc @@ -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) { diff --git a/storage/archive/ha_archive.cc b/storage/archive/ha_archive.cc index 3971c4d73f0..0fd5f0ed099 100644 --- a/storage/archive/ha_archive.cc +++ b/storage/archive/ha_archive.cc @@ -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); diff --git a/storage/archive/ha_archive.h b/storage/archive/ha_archive.h index d1069afd87f..1a601c8451a 100644 --- a/storage/archive/ha_archive.h +++ b/storage/archive/ha_archive.h @@ -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); - diff --git a/storage/blackhole/ha_blackhole.cc b/storage/blackhole/ha_blackhole.cc index 2ebe43acd4d..7ab32cccf84 100644 --- a/storage/blackhole/ha_blackhole.cc +++ b/storage/blackhole/ha_blackhole.cc @@ -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; diff --git a/storage/blackhole/ha_blackhole.h b/storage/blackhole/ha_blackhole.h index 55c26f6f02e..54cec41fd26 100644 --- a/storage/blackhole/ha_blackhole.h +++ b/storage/blackhole/ha_blackhole.h @@ -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() { } diff --git a/storage/csv/ha_tina.cc b/storage/csv/ha_tina.cc index b9fdfc1ae0c..8f090470f49 100644 --- a/storage/csv/ha_tina.cc +++ b/storage/csv/ha_tina.cc @@ -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. diff --git a/storage/csv/ha_tina.h b/storage/csv/ha_tina.h index 14ca848c855..f408e8f4a7d 100644 --- a/storage/csv/ha_tina.h +++ b/storage/csv/ha_tina.h @@ -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); - diff --git a/storage/example/ha_example.cc b/storage/example/ha_example.cc index 1b49cbbae5a..68840a41879 100644 --- a/storage/example/ha_example.cc +++ b/storage/example/ha_example.cc @@ -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) {} /* diff --git a/storage/example/ha_example.h b/storage/example/ha_example.h index 956dc62311c..2f5dbc29c56 100644 --- a/storage/example/ha_example.h +++ b/storage/example/ha_example.h @@ -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() { } diff --git a/storage/federated/ha_federated.cc b/storage/federated/ha_federated.cc index ecfaa9dff2d..3c1cc722f02 100644 --- a/storage/federated/ha_federated.cc +++ b/storage/federated/ha_federated.cc @@ -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; +/* Federated storage engine handlerton */ -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)); diff --git a/storage/federated/ha_federated.h b/storage/federated/ha_federated.h index ebdc775d3bf..ade1e5b181e 100644 --- a/storage/federated/ha_federated.h +++ b/storage/federated/ha_federated.h @@ -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); - diff --git a/storage/heap/ha_heap.cc b/storage/heap/ha_heap.cc index 1b76b24bd5d..4a83b2e12d8 100644 --- a/storage/heap/ha_heap.cc +++ b/storage/heap/ha_heap.cc @@ -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) {} diff --git a/storage/heap/ha_heap.h b/storage/heap/ha_heap.h index 00e59856f26..0f6386655cb 100644 --- a/storage/heap/ha_heap.h +++ b/storage/heap/ha_heap.h @@ -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 { diff --git a/storage/heap/hp_panic.c b/storage/heap/hp_panic.c index 2b659cbfbb3..08c310bec3d 100644 --- a/storage/heap/hp_panic.c +++ b/storage/heap/hp_panic.c @@ -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 */ diff --git a/storage/heap/hp_test1.c b/storage/heap/hp_test1.c index 703b39b1e2d..a7423effac8 100644 --- a/storage/heap/hp_test1.c +++ b/storage/heap/hp_test1.c @@ -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); diff --git a/storage/heap/hp_test2.c b/storage/heap/hp_test2.c index c1d987a3b5f..b4e8cf98f0b 100644 --- a/storage/heap/hp_test2.c +++ b/storage/heap/hp_test2.c @@ -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); } diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc index aa0c26a5ac5..68e2609cbf8 100644 --- a/storage/innobase/handler/ha_innodb.cc +++ b/storage/innobase/handler/ha_innodb.cc @@ -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); } diff --git a/storage/innobase/handler/ha_innodb.h b/storage/innobase/handler/ha_innodb.h index ed52ee9b094..aebbc3d6654 100644 --- a/storage/innobase/handler/ha_innodb.h +++ b/storage/innobase/handler/ha_innodb.h @@ -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 */ diff --git a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc index 33a6f023645..373e098a2b1 100644 --- a/storage/myisam/ha_myisam.cc +++ b/storage/myisam/ha_myisam.cc @@ -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; } diff --git a/storage/myisam/ha_myisam.h b/storage/myisam/ha_myisam.h index 511b796ebdb..85abcdca8b2 100644 --- a/storage/myisam/ha_myisam.h +++ b/storage/myisam/ha_myisam.h @@ -43,7 +43,7 @@ class ha_myisam: public handler int repair(THD *thd, MI_CHECK ¶m, 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"; } diff --git a/storage/myisammrg/ha_myisammrg.cc b/storage/myisammrg/ha_myisammrg.cc index bc756e78023..7f656c2e67c 100644 --- a/storage/myisammrg/ha_myisammrg.cc +++ b/storage/myisammrg/ha_myisammrg.cc @@ -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; } diff --git a/storage/myisammrg/ha_myisammrg.h b/storage/myisammrg/ha_myisammrg.h index d58a3523c26..faa3ae73c59 100644 --- a/storage/myisammrg/ha_myisammrg.h +++ b/storage/myisammrg/ha_myisammrg.h @@ -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; |