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

A pre-requisite for the fix for Bug#12713 "Error in a stored function

Browse Source 
called from a SELECT doesn't cause ROLLBACK of state"
Make private all class handler methods (PSEA API) that may modify
data. Introduce and deploy public ha_* wrappers for these methods in 
all sql/.
This necessary to keep track of all data modifications in sql/,
which is in turn necessary to be able to optimize two-phase
commit of those transactions that do not modify data.
This commit is contained in:
kostja@bodhi.(none) 2007-12-20 21:16:55 +03:00
parent ab6ef39cd1
commit dfe685e6fc
13 changed files with 548 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
sql/ha_partition.cc
View File

@ -367,7 +367,7 @@ bool ha_partition::initialise_partition(MEM_ROOT *mem_root)
HA_CAN_GEOMETRY, HA_CAN_FULLTEXT, HA_CAN_SQL_HANDLER, HA_DUPLICATE_POS, HA_CAN_GEOMETRY, HA_CAN_FULLTEXT, HA_CAN_SQL_HANDLER, HA_DUPLICATE_POS,
HA_CAN_INSERT_DELAYED is disabled until further investigated. HA_CAN_INSERT_DELAYED is disabled until further investigated.
*/ */
m_table_flags= (ulong)m_file[0]->table_flags(); m_table_flags= (ulong)m_file[0]->ha_table_flags();
m_low_byte_first= m_file[0]->low_byte_first(); m_low_byte_first= m_file[0]->low_byte_first();
m_pkey_is_clustered= TRUE; m_pkey_is_clustered= TRUE;
file_array= m_file; file_array= m_file;
@ -382,7 +382,7 @@ bool ha_partition::initialise_partition(MEM_ROOT *mem_root)
} }
if (!file->primary_key_is_clustered()) if (!file->primary_key_is_clustered())
m_pkey_is_clustered= FALSE; m_pkey_is_clustered= FALSE;
m_table_flags&= file->table_flags(); m_table_flags&= file->ha_table_flags();
} while (*(++file_array)); } while (*(++file_array));
m_table_flags&= ~(HA_CAN_GEOMETRY | HA_CAN_FULLTEXT | HA_DUPLICATE_POS | m_table_flags&= ~(HA_CAN_GEOMETRY | HA_CAN_FULLTEXT | HA_DUPLICATE_POS |
HA_CAN_SQL_HANDLER | HA_CAN_INSERT_DELAYED | HA_CAN_SQL_HANDLER | HA_CAN_INSERT_DELAYED |
@ -616,7 +616,7 @@ int ha_partition::drop_partitions(const char *path)
sub_elem->partition_name, name_variant); sub_elem->partition_name, name_variant);
file= m_file[part]; file= m_file[part];
DBUG_PRINT("info", ("Drop subpartition %s", part_name_buff)); DBUG_PRINT("info", ("Drop subpartition %s", part_name_buff));
if ((ret_error= file->delete_table((const char *) part_name_buff))) if ((ret_error= file->ha_delete_table(part_name_buff)))
error= ret_error; error= ret_error;
if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos)) if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -629,7 +629,7 @@ int ha_partition::drop_partitions(const char *path)
TRUE); TRUE);
file= m_file[i]; file= m_file[i];
DBUG_PRINT("info", ("Drop partition %s", part_name_buff)); DBUG_PRINT("info", ("Drop partition %s", part_name_buff));
if ((ret_error= file->delete_table((const char *) part_name_buff))) if ((ret_error= file->ha_delete_table(part_name_buff)))
error= ret_error; error= ret_error;
if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos)) if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -707,7 +707,7 @@ int ha_partition::rename_partitions(const char *path)
sub_elem->partition_name, sub_elem->partition_name,
NORMAL_PART_NAME); NORMAL_PART_NAME);
DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff)); DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff));
if ((ret_error= file->delete_table((const char *) norm_name_buff))) if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -722,7 +722,7 @@ int ha_partition::rename_partitions(const char *path)
part_elem->partition_name, NORMAL_PART_NAME, part_elem->partition_name, NORMAL_PART_NAME,
TRUE); TRUE);
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff)); DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
if ((ret_error= file->delete_table((const char *) norm_name_buff))) if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -778,7 +778,7 @@ int ha_partition::rename_partitions(const char *path)
{ {
file= m_reorged_file[part_count++]; file= m_reorged_file[part_count++];
DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff)); DBUG_PRINT("info", ("Delete subpartition %s", norm_name_buff));
if ((ret_error= file->delete_table((const char *) norm_name_buff))) if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -791,8 +791,8 @@ int ha_partition::rename_partitions(const char *path)
TEMP_PART_NAME); TEMP_PART_NAME);
DBUG_PRINT("info", ("Rename subpartition from %s to %s", DBUG_PRINT("info", ("Rename subpartition from %s to %s",
part_name_buff, norm_name_buff)); part_name_buff, norm_name_buff));
if ((ret_error= file->rename_table((const char *) part_name_buff, if ((ret_error= file->ha_rename_table(part_name_buff,
(const char *) norm_name_buff))) norm_name_buff)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -809,7 +809,7 @@ int ha_partition::rename_partitions(const char *path)
{ {
file= m_reorged_file[part_count++]; file= m_reorged_file[part_count++];
DBUG_PRINT("info", ("Delete partition %s", norm_name_buff)); DBUG_PRINT("info", ("Delete partition %s", norm_name_buff));
if ((ret_error= file->delete_table((const char *) norm_name_buff))) if ((ret_error= file->ha_delete_table(norm_name_buff)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -821,8 +821,8 @@ int ha_partition::rename_partitions(const char *path)
TRUE); TRUE);
DBUG_PRINT("info", ("Rename partition from %s to %s", DBUG_PRINT("info", ("Rename partition from %s to %s",
part_name_buff, norm_name_buff)); part_name_buff, norm_name_buff));
if ((ret_error= file->rename_table((const char *) part_name_buff, if ((ret_error= file->ha_rename_table(part_name_buff,
(const char *) norm_name_buff))) norm_name_buff)))
error= ret_error; error= ret_error;
else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos)) else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
error= 1; error= 1;
@ -1036,9 +1036,9 @@ static int handle_opt_part(THD *thd, HA_CHECK_OPT *check_opt,
DBUG_PRINT("enter", ("flag = %u", flag)); DBUG_PRINT("enter", ("flag = %u", flag));
if (flag == OPTIMIZE_PARTS) if (flag == OPTIMIZE_PARTS)
error= file->optimize(thd, check_opt); error= file->ha_optimize(thd, check_opt);
else if (flag == ANALYZE_PARTS) else if (flag == ANALYZE_PARTS)
error= file->analyze(thd, check_opt); error= file->ha_analyze(thd, check_opt);
else if (flag == CHECK_PARTS) else if (flag == CHECK_PARTS)
error= file->ha_check(thd, check_opt); error= file->ha_check(thd, check_opt);
else if (flag == REPAIR_PARTS) else if (flag == REPAIR_PARTS)
@ -1139,7 +1139,7 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
if ((error= set_up_table_before_create(tbl, part_name, create_info, if ((error= set_up_table_before_create(tbl, part_name, create_info,
0, p_elem))) 0, p_elem)))
goto error; goto error;
if ((error= file->create(part_name, tbl, create_info))) if ((error= file->ha_create(part_name, tbl, create_info)))
goto error; goto error;
create_flag= TRUE; create_flag= TRUE;
if ((error= file->ha_open(tbl, part_name, m_mode, m_open_test_lock))) if ((error= file->ha_open(tbl, part_name, m_mode, m_open_test_lock)))
@ -1150,13 +1150,13 @@ int ha_partition::prepare_new_partition(TABLE *tbl,
assumes that external_lock() is last call that may fail here. assumes that external_lock() is last call that may fail here.
Otherwise see description for cleanup_new_partition(). Otherwise see description for cleanup_new_partition().
*/ */
if ((error= file->external_lock(current_thd, m_lock_type))) if ((error= file->ha_external_lock(current_thd, m_lock_type)))
goto error; goto error;
DBUG_RETURN(0); DBUG_RETURN(0);
error: error:
if (create_flag) if (create_flag)
VOID(file->delete_table(part_name)); VOID(file->ha_delete_table(part_name));
DBUG_RETURN(error); DBUG_RETURN(error);
} }
@ -1585,7 +1585,7 @@ int ha_partition::copy_partitions(ulonglong *copied, ulonglong *deleted)
} }
} }
late_extra_no_cache(reorg_part); late_extra_no_cache(reorg_part);
file->rnd_end(); file->ha_rnd_end();
reorg_part++; reorg_part++;
} }
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);
@ -1702,16 +1702,15 @@ uint ha_partition::del_ren_cre_table(const char *from,
{ // Rename branch { // Rename branch
create_partition_name(to_buff, to, name_buffer_ptr, NORMAL_PART_NAME, create_partition_name(to_buff, to, name_buffer_ptr, NORMAL_PART_NAME,
FALSE); FALSE);
error= (*file)->rename_table((const char*) from_buff, error= (*file)->ha_rename_table(from_buff, to_buff);
(const char*) to_buff);
} }
else if (table_arg == NULL) // delete branch else if (table_arg == NULL) // delete branch
error= (*file)->delete_table((const char*) from_buff); error= (*file)->ha_delete_table(from_buff);
else else
{ {
if ((error= set_up_table_before_create(table_arg, from_buff, if ((error= set_up_table_before_create(table_arg, from_buff,
create_info, i, NULL)) || create_info, i, NULL)) ||
((error= (*file)->create(from_buff, table_arg, create_info)))) ((error= (*file)->ha_create(from_buff, table_arg, create_info))))
goto create_error; goto create_error;
} }
name_buffer_ptr= strend(name_buffer_ptr) + 1; name_buffer_ptr= strend(name_buffer_ptr) + 1;
@ -1726,7 +1725,7 @@ create_error:
{ {
create_partition_name(from_buff, from, name_buffer_ptr, NORMAL_PART_NAME, create_partition_name(from_buff, from, name_buffer_ptr, NORMAL_PART_NAME,
FALSE); FALSE);
VOID((*file)->delete_table((const char*) from_buff)); VOID((*file)->ha_delete_table((const char*) from_buff));
name_buffer_ptr= strend(name_buffer_ptr) + 1; name_buffer_ptr= strend(name_buffer_ptr) + 1;
} }
DBUG_RETURN(error); DBUG_RETURN(error);
@ -2318,7 +2317,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
} }
/* Recalculate table flags as they may change after open */ /* Recalculate table flags as they may change after open */
m_table_flags= m_file[0]->table_flags(); m_table_flags= m_file[0]->ha_table_flags();
file= m_file; file= m_file;
do do
{ {
@ -2330,7 +2329,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
m_no_locks+= (*file)->lock_count(); m_no_locks+= (*file)->lock_count();
name_buffer_ptr+= strlen(name_buffer_ptr) + 1; name_buffer_ptr+= strlen(name_buffer_ptr) + 1;
set_if_bigger(ref_length, ((*file)->ref_length)); set_if_bigger(ref_length, ((*file)->ref_length));
m_table_flags&= (*file)->table_flags(); m_table_flags&= (*file)->ha_table_flags();
} while (*(++file)); } while (*(++file));
m_table_flags&= ~(HA_CAN_GEOMETRY | HA_CAN_FULLTEXT | HA_DUPLICATE_POS | m_table_flags&= ~(HA_CAN_GEOMETRY | HA_CAN_FULLTEXT | HA_DUPLICATE_POS |
HA_CAN_SQL_HANDLER | HA_CAN_INSERT_DELAYED); HA_CAN_SQL_HANDLER | HA_CAN_INSERT_DELAYED);
@ -2486,7 +2485,7 @@ repeat:
{ {
DBUG_PRINT("info", ("external_lock(thd, %d) iteration %d", DBUG_PRINT("info", ("external_lock(thd, %d) iteration %d",
lock_type, (int) (file - m_file))); lock_type, (int) (file - m_file)));
if ((error= (*file)->external_lock(thd, lock_type))) if ((error= (*file)->ha_external_lock(thd, lock_type)))
{ {
if (F_UNLCK != lock_type) if (F_UNLCK != lock_type)
goto err_handler; goto err_handler;
@ -2505,7 +2504,7 @@ repeat:
err_handler: err_handler:
while (file-- != m_file) while (file-- != m_file)
{ {
(*file)->external_lock(thd, F_UNLCK); (*file)->ha_external_lock(thd, F_UNLCK);
} }
DBUG_RETURN(error); DBUG_RETURN(error);
} }
@ -2913,6 +2912,7 @@ int ha_partition::delete_row(const uchar *buf)
{ {
uint32 part_id; uint32 part_id;
int error; int error;
THD *thd= ha_thd();
DBUG_ENTER("ha_partition::delete_row"); DBUG_ENTER("ha_partition::delete_row");
if ((error= get_part_for_delete(buf, m_rec0, m_part_info, &part_id))) if ((error= get_part_for_delete(buf, m_rec0, m_part_info, &part_id)))
@ -2920,7 +2920,10 @@ int ha_partition::delete_row(const uchar *buf)
DBUG_RETURN(error); DBUG_RETURN(error);
} }
m_last_part= part_id; m_last_part= part_id;
DBUG_RETURN(m_file[part_id]->delete_row(buf)); tmp_disable_binlog(thd);
error= m_file[part_id]->ha_delete_row(buf);
reenable_binlog(thd);
DBUG_RETURN(error);
} }
@ -2955,7 +2958,7 @@ int ha_partition::delete_all_rows()
file= m_file; file= m_file;
do do
{ {
if ((error= (*file)->delete_all_rows())) if ((error= (*file)->ha_delete_all_rows()))
DBUG_RETURN(error); DBUG_RETURN(error);
} while (*(++file)); } while (*(++file));
DBUG_RETURN(0); DBUG_RETURN(0);
@ -4016,7 +4019,7 @@ int ha_partition::handle_unordered_next(uchar *buf, bool is_next_same)
} }
else if (!(error= file->index_next(buf))) else if (!(error= file->index_next(buf)))
{ {
if (!(file->table_flags() & HA_READ_ORDER) || if (!(file->ha_table_flags() & HA_READ_ORDER) ||
compare_key(end_range) <= 0) compare_key(end_range) <= 0)
{ {
m_last_part= m_part_spec.start_part; m_last_part= m_part_spec.start_part;
@ -4094,7 +4097,7 @@ int ha_partition::handle_unordered_scan_next_partition(uchar * buf)
} }
if (!error) if (!error)
{ {
if (!(file->table_flags() & HA_READ_ORDER) || if (!(file->ha_table_flags() & HA_READ_ORDER) ||
compare_key(end_range) <= 0) compare_key(end_range) <= 0)
{ {
m_last_part= i; m_last_part= i;
@ -5016,7 +5019,7 @@ int ha_partition::reset(void)
file= m_file; file= m_file;
do do
{ {
if ((tmp= (*file)->reset())) if ((tmp= (*file)->ha_reset()))
result= tmp; result= tmp;
} while (*(++file)); } while (*(++file));
DBUG_RETURN(result); DBUG_RETURN(result);
@ -5658,7 +5661,7 @@ void ha_partition::release_auto_increment()
for (uint i= 0; i < m_tot_parts; i++) for (uint i= 0; i < m_tot_parts; i++)
{ {
m_file[i]->release_auto_increment(); m_file[i]->ha_release_auto_increment();
} }
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
@ -5694,7 +5697,7 @@ int ha_partition::disable_indexes(uint mode)
for (file= m_file; *file; file++) for (file= m_file; *file; file++)
{ {
if ((error= (*file)->disable_indexes(mode))) if ((error= (*file)->ha_disable_indexes(mode)))
break; break;
} }
return error; return error;
@ -5718,7 +5721,7 @@ int ha_partition::enable_indexes(uint mode)
for (file= m_file; *file; file++) for (file= m_file; *file; file++)
{ {
if ((error= (*file)->enable_indexes(mode))) if ((error= (*file)->ha_enable_indexes(mode)))
break; break;
} }
return error; return error;

337
sql/handler.cc
View File

@ -1468,7 +1468,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
DBUG_RETURN(ENOENT); DBUG_RETURN(ENOENT);
path= check_lowercase_names(file, path, tmp_path); path= check_lowercase_names(file, path, tmp_path);
if ((error= file->delete_table(path)) && generate_warning) if ((error= file->ha_delete_table(path)) && generate_warning)
{ {
/* /*
Because file->print_error() use my_error() to generate the error message Because file->print_error() use my_error() to generate the error message
@ -1487,8 +1487,7 @@ int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
dummy_share.table_name.length= strlen(alias); dummy_share.table_name.length= strlen(alias);
dummy_table.alias= alias; dummy_table.alias= alias;
file->table_share= &dummy_share; file->change_table_ptr(&dummy_table, &dummy_share);
file->table= &dummy_table;
thd->push_internal_handler(&ha_delete_table_error_handler); thd->push_internal_handler(&ha_delete_table_error_handler);
file->print_error(error, 0); file->print_error(error, 0);
@ -2502,6 +2501,12 @@ int handler::ha_check(THD *thd, HA_CHECK_OPT *check_opt)
} }
/**
Repair table: public interface.
@sa handler::repair()
*/
int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt) int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{ {
int result; int result;
@ -2511,6 +2516,328 @@ int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
} }
/**
Bulk update row: public interface.
@sa handler::bulk_update_row()
*/
int
handler::ha_bulk_update_row(const uchar *old_data, uchar *new_data,
uint *dup_key_found)
{
return bulk_update_row(old_data, new_data, dup_key_found);
}
/**
Delete all rows: public interface.
@sa handler::delete_all_rows()
*/
int
handler::ha_delete_all_rows()
{
return delete_all_rows();
}
/**
Reset auto increment: public interface.
@sa handler::reset_auto_increment()
*/
int
handler::ha_reset_auto_increment(ulonglong value)
{
return reset_auto_increment(value);
}
/**
Backup table: public interface.
@sa handler::backup()
*/
int
handler::ha_backup(THD* thd, HA_CHECK_OPT* check_opt)
{
return backup(thd, check_opt);
}
/**
Restore table: public interface.
@sa handler::restore()
*/
int
handler::ha_restore(THD* thd, HA_CHECK_OPT* check_opt)
{
return restore(thd, check_opt);
}
/**
Optimize table: public interface.
@sa handler::optimize()
*/
int
handler::ha_optimize(THD* thd, HA_CHECK_OPT* check_opt)
{
return optimize(thd, check_opt);
}
/**
Analyze table: public interface.
@sa handler::analyze()
*/
int
handler::ha_analyze(THD* thd, HA_CHECK_OPT* check_opt)
{
return analyze(thd, check_opt);
}
/**
Check and repair table: public interface.
@sa handler::check_and_repair()
*/
bool
handler::ha_check_and_repair(THD *thd)
{
return check_and_repair(thd);
}
/**
Disable indexes: public interface.
@sa handler::disable_indexes()
*/
int
handler::ha_disable_indexes(uint mode)
{
return disable_indexes(mode);
}
/**
Enable indexes: public interface.
@sa handler::enable_indexes()
*/
int
handler::ha_enable_indexes(uint mode)
{
return enable_indexes(mode);
}
/**
Discard or import tablespace: public interface.
@sa handler::discard_or_import_tablespace()
*/
int
handler::ha_discard_or_import_tablespace(my_bool discard)
{
return discard_or_import_tablespace(discard);
}
/**
Prepare for alter: public interface.
Called to prepare an *online* ALTER.
@sa handler::prepare_for_alter()
*/
void
handler::ha_prepare_for_alter()
{
prepare_for_alter();
}
/**
Rename table: public interface.
@sa handler::rename_table()
*/
int
handler::ha_rename_table(const char *from, const char *to)
{
return rename_table(from, to);
}
/**
Delete table: public interface.
@sa handler::delete_table()
*/
int
handler::ha_delete_table(const char *name)
{
return delete_table(name);
}
/**
Drop table in the engine: public interface.
@sa handler::drop_table()
*/
void
handler::ha_drop_table(const char *name)
{
return drop_table(name);
}
/**
Create a table in the engine: public interface.
@sa handler::create()
*/
int
handler::ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info)
{
return create(name, form, info);
}
/**
Create handler files for CREATE TABLE: public interface.
@sa handler::create_handler_files()
*/
int
handler::ha_create_handler_files(const char *name, const char *old_name,
int action_flag, HA_CREATE_INFO *info)
{
return create_handler_files(name, old_name, action_flag, info);
}
/**
Change partitions: public interface.
@sa handler::change_partitions()
*/
int
handler::ha_change_partitions(HA_CREATE_INFO *create_info,
const char *path,
ulonglong *copied,
ulonglong *deleted,
const uchar *pack_frm_data,
size_t pack_frm_len)
{
return change_partitions(create_info, path, copied, deleted,
pack_frm_data, pack_frm_len);
}
/**
Drop partitions: public interface.
@sa handler::drop_partitions()
*/
int
handler::ha_drop_partitions(const char *path)
{
return drop_partitions(path);
}
/**
Rename partitions: public interface.
@sa handler::rename_partitions()
*/
int
handler::ha_rename_partitions(const char *path)
{
return rename_partitions(path);
}
/**
Optimize partitions: public interface.
@sa handler::optimize_partitions()
*/
int
handler::ha_optimize_partitions(THD *thd)
{
return optimize_partitions(thd);
}
/**
Analyze partitions: public interface.
@sa handler::analyze_partitions()
*/
int
handler::ha_analyze_partitions(THD *thd)
{
return analyze_partitions(thd);
}
/**
Check partitions: public interface.
@sa handler::check_partitions()
*/
int
handler::ha_check_partitions(THD *thd)
{
return check_partitions(thd);
}
/**
Repair partitions: public interface.
@sa handler::repair_partitions()
*/
int
handler::ha_repair_partitions(THD *thd)
{
return repair_partitions(thd);
}
/** @brief /** @brief
Tell the storage engine that it is allowed to "disable transaction" in the Tell the storage engine that it is allowed to "disable transaction" in the
handler. It is a hint that ACID is not required - it is used in NDB for handler. It is a hint that ACID is not required - it is used in NDB for
@ -2654,7 +2981,7 @@ int ha_create_table(THD *thd, const char *path,
name= check_lowercase_names(table.file, share.path.str, name_buff); name= check_lowercase_names(table.file, share.path.str, name_buff);
error= table.file->create(name, &table, create_info); error= table.file->ha_create(name, &table, create_info);
VOID(closefrm(&table, 0)); VOID(closefrm(&table, 0));
if (error) if (error)
{ {
@ -2724,7 +3051,7 @@ int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE; create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
check_lowercase_names(table.file, path, path); check_lowercase_names(table.file, path, path);
error=table.file->create(path,&table,&create_info); error=table.file->ha_create(path, &table, &create_info);
VOID(closefrm(&table, 1)); VOID(closefrm(&table, 1));
DBUG_RETURN(error != 0); DBUG_RETURN(error != 0);

212
sql/handler.h
View File

@ -967,10 +967,6 @@ uint calculate_key_len(TABLE *, uint, const uchar *, key_part_map);
class handler :public Sql_alloc class handler :public Sql_alloc
{ {
friend class ha_partition;
friend int ha_delete_table(THD*,handlerton*,const char*,const char*,
const char*,bool);
public: public:
typedef ulonglong Table_flags; typedef ulonglong Table_flags;
protected: protected:
@ -1118,6 +1114,40 @@ public:
estimation_rows_to_insert= 0; estimation_rows_to_insert= 0;
return end_bulk_insert(); return end_bulk_insert();
} }
int ha_bulk_update_row(const uchar *old_data, uchar *new_data,
uint *dup_key_found);
int ha_delete_all_rows();
int ha_reset_auto_increment(ulonglong value);
int ha_backup(THD* thd, HA_CHECK_OPT* check_opt);
int ha_restore(THD* thd, HA_CHECK_OPT* check_opt);
int ha_optimize(THD* thd, HA_CHECK_OPT* check_opt);
int ha_analyze(THD* thd, HA_CHECK_OPT* check_opt);
bool ha_check_and_repair(THD *thd);
int ha_disable_indexes(uint mode);
int ha_enable_indexes(uint mode);
int ha_discard_or_import_tablespace(my_bool discard);
void ha_prepare_for_alter();
int ha_rename_table(const char *from, const char *to);
int ha_delete_table(const char *name);
void ha_drop_table(const char *name);
int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info);
int ha_create_handler_files(const char *name, const char *old_name,
int action_flag, HA_CREATE_INFO *info);
int ha_change_partitions(HA_CREATE_INFO *create_info,
const char *path,
ulonglong *copied,
ulonglong *deleted,
const uchar *pack_frm_data,
size_t pack_frm_len);
int ha_drop_partitions(const char *path);
int ha_rename_partitions(const char *path);
int ha_optimize_partitions(THD *thd);
int ha_analyze_partitions(THD *thd);
int ha_check_partitions(THD *thd);
int ha_repair_partitions(THD *thd);
void adjust_next_insert_id_after_explicit_value(ulonglong nr); void adjust_next_insert_id_after_explicit_value(ulonglong nr);
int update_auto_increment(); int update_auto_increment();
@ -1203,25 +1233,6 @@ public:
@retval 1 Bulk delete not used, normal operation used @retval 1 Bulk delete not used, normal operation used
*/ */
virtual bool start_bulk_delete() { return 1; } virtual bool start_bulk_delete() { return 1; }
/**
This method is similar to update_row, however the handler doesn't need
to execute the updates at this point in time. The handler can be certain
that another call to bulk_update_row will occur OR a call to
exec_bulk_update before the set of updates in this query is concluded.
@param old_data Old record
@param new_data New record
@param dup_key_found Number of duplicate keys found
@retval 0 Bulk delete used by handler
@retval 1 Bulk delete not used, normal operation used
*/
virtual int bulk_update_row(const uchar *old_data, uchar *new_data,
uint *dup_key_found)
{
DBUG_ASSERT(FALSE);
return HA_ERR_WRONG_COMMAND;
}
/** /**
After this call all outstanding updates must be performed. The number After this call all outstanding updates must be performed. The number
of duplicate key errors are reported in the duplicate key parameter. of duplicate key errors are reported in the duplicate key parameter.
@ -1365,14 +1376,6 @@ public:
virtual void try_semi_consistent_read(bool) {} virtual void try_semi_consistent_read(bool) {}
virtual void unlock_row() {} virtual void unlock_row() {}
virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;} virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
/**
This is called to delete all rows in a table
If the handler don't support this, then this function will
return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
by one.
*/
virtual int delete_all_rows()
{ return (my_errno=HA_ERR_WRONG_COMMAND); }
virtual void get_auto_increment(ulonglong offset, ulonglong increment, virtual void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values, ulonglong nb_desired_values,
ulonglong *first_value, ulonglong *first_value,
@ -1397,42 +1400,17 @@ public:
next_insert_id= (prev_insert_id > 0) ? prev_insert_id : next_insert_id= (prev_insert_id > 0) ? prev_insert_id :
insert_id_for_cur_row; insert_id_for_cur_row;
} }
/**
Reset the auto-increment counter to the given value, i.e. the next row
inserted will get the given value. This is called e.g. after TRUNCATE
is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
returned by storage engines that don't support this operation.
*/
virtual int reset_auto_increment(ulonglong value)
{ return HA_ERR_WRONG_COMMAND; }
virtual void update_create_info(HA_CREATE_INFO *create_info) {} virtual void update_create_info(HA_CREATE_INFO *create_info) {}
int check_old_types(); int check_old_types();
virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
/**
Restore assumes .frm file must exist, and that generate_table() has been
called; It will just copy the data file and run repair.
*/
virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt) virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; } { return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt) virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; } { return HA_ADMIN_NOT_IMPLEMENTED; }
/* end of the list of admin commands */ /* end of the list of admin commands */
virtual bool check_and_repair(THD *thd) { return HA_ERR_WRONG_COMMAND; }
virtual int dump(THD* thd, int fd = -1) { return HA_ERR_WRONG_COMMAND; } virtual int dump(THD* thd, int fd = -1) { return HA_ERR_WRONG_COMMAND; }
virtual int disable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
virtual int enable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
virtual int indexes_are_disabled(void) {return 0;} virtual int indexes_are_disabled(void) {return 0;}
virtual int discard_or_import_tablespace(my_bool discard)
{return HA_ERR_WRONG_COMMAND;}
virtual int net_read_dump(NET* net) { return HA_ERR_WRONG_COMMAND; } virtual int net_read_dump(NET* net) { return HA_ERR_WRONG_COMMAND; }
virtual char *update_table_comment(const char * comment) virtual char *update_table_comment(const char * comment)
{ return (char*) comment;} { return (char*) comment;}
@ -1489,7 +1467,6 @@ public:
virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0; virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
virtual void prepare_for_alter() { return; }
virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys) virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys)
{ return (HA_ERR_WRONG_COMMAND); } { return (HA_ERR_WRONG_COMMAND); }
virtual int prepare_drop_index(TABLE *table_arg, uint *key_num, virtual int prepare_drop_index(TABLE *table_arg, uint *key_num,
@ -1521,44 +1498,12 @@ public:
virtual bool is_crashed() const { return 0; } virtual bool is_crashed() const { return 0; }
virtual bool auto_repair() const { return 0; } virtual bool auto_repair() const { return 0; }
/**
default rename_table() and delete_table() rename/delete files with a
given name and extensions from bas_ext()
*/
virtual int rename_table(const char *from, const char *to);
virtual int delete_table(const char *name);
virtual void drop_table(const char *name);
virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
#define CHF_CREATE_FLAG 0 #define CHF_CREATE_FLAG 0
#define CHF_DELETE_FLAG 1 #define CHF_DELETE_FLAG 1
#define CHF_RENAME_FLAG 2 #define CHF_RENAME_FLAG 2
#define CHF_INDEX_FLAG 3 #define CHF_INDEX_FLAG 3
virtual int create_handler_files(const char *name, const char *old_name,
int action_flag, HA_CREATE_INFO *info)
{ return FALSE; }
virtual int change_partitions(HA_CREATE_INFO *create_info,
const char *path,
ulonglong *copied,
ulonglong *deleted,
const uchar *pack_frm_data,
size_t pack_frm_len)
{ return HA_ERR_WRONG_COMMAND; }
virtual int drop_partitions(const char *path)
{ return HA_ERR_WRONG_COMMAND; }
virtual int rename_partitions(const char *path)
{ return HA_ERR_WRONG_COMMAND; }
virtual int optimize_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
virtual int analyze_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
virtual int check_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
virtual int repair_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
/** /**
@note lock_count() can return > 1 if the table is MERGE or partitioned. @note lock_count() can return > 1 if the table is MERGE or partitioned.
@ -1686,6 +1631,16 @@ protected:
void ha_statistic_increment(ulong SSV::*offset) const; void ha_statistic_increment(ulong SSV::*offset) const;
void **ha_data(THD *) const; void **ha_data(THD *) const;
THD *ha_thd(void) const; THD *ha_thd(void) const;
/**
Default rename_table() and delete_table() rename/delete files with a
given name and extensions from bas_ext().
These methods can be overridden, but their default implementation
provide useful functionality.
*/
virtual int rename_table(const char *from, const char *to);
virtual int delete_table(const char *name);
private: private:
/* /*
Low-level primitives for storage engines. These should be Low-level primitives for storage engines. These should be
@ -1775,6 +1730,85 @@ private:
{ return HA_ERR_WRONG_COMMAND; } { return HA_ERR_WRONG_COMMAND; }
virtual int index_read_last(uchar * buf, const uchar * key, uint key_len) virtual int index_read_last(uchar * buf, const uchar * key, uint key_len)
{ return (my_errno= HA_ERR_WRONG_COMMAND); } { return (my_errno= HA_ERR_WRONG_COMMAND); }
/**
This method is similar to update_row, however the handler doesn't need
to execute the updates at this point in time. The handler can be certain
that another call to bulk_update_row will occur OR a call to
exec_bulk_update before the set of updates in this query is concluded.
@param old_data Old record
@param new_data New record
@param dup_key_found Number of duplicate keys found
@retval 0 Bulk delete used by handler
@retval 1 Bulk delete not used, normal operation used
*/
virtual int bulk_update_row(const uchar *old_data, uchar *new_data,
uint *dup_key_found)
{
DBUG_ASSERT(FALSE);
return HA_ERR_WRONG_COMMAND;
}
/**
This is called to delete all rows in a table
If the handler don't support this, then this function will
return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
by one.
*/
virtual int delete_all_rows()
{ return (my_errno=HA_ERR_WRONG_COMMAND); }
/**
Reset the auto-increment counter to the given value, i.e. the next row
inserted will get the given value. This is called e.g. after TRUNCATE
is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
returned by storage engines that don't support this operation.
*/
virtual int reset_auto_increment(ulonglong value)
{ return HA_ERR_WRONG_COMMAND; }
virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
/**
Restore assumes .frm file must exist, and that generate_table() has been
called; It will just copy the data file and run repair.
*/
virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt)
{ return HA_ADMIN_NOT_IMPLEMENTED; }
virtual bool check_and_repair(THD *thd) { return HA_ERR_WRONG_COMMAND; }
virtual int disable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
virtual int enable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
virtual int discard_or_import_tablespace(my_bool discard)
{ return (my_errno=HA_ERR_WRONG_COMMAND); }
virtual void prepare_for_alter() { return; }
virtual void drop_table(const char *name);
virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
virtual int create_handler_files(const char *name, const char *old_name,
int action_flag, HA_CREATE_INFO *info)
{ return FALSE; }
virtual int change_partitions(HA_CREATE_INFO *create_info,
const char *path,
ulonglong *copied,
ulonglong *deleted,
const uchar *pack_frm_data,
size_t pack_frm_len)
{ return HA_ERR_WRONG_COMMAND; }
virtual int drop_partitions(const char *path)
{ return HA_ERR_WRONG_COMMAND; }
virtual int rename_partitions(const char *path)
{ return HA_ERR_WRONG_COMMAND; }
virtual int optimize_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
virtual int analyze_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
virtual int check_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
virtual int repair_partitions(THD *thd)
{ return HA_ERR_WRONG_COMMAND; }
}; };

2
sql/item_sum.cc
View File

@ -2603,7 +2603,7 @@ void Item_sum_count_distinct::clear()
else if (table) else if (table)
{ {
table->file->extra(HA_EXTRA_NO_CACHE); table->file->extra(HA_EXTRA_NO_CACHE);
table->file->delete_all_rows(); table->file->ha_delete_all_rows();
table->file->extra(HA_EXTRA_WRITE_CACHE); table->file->extra(HA_EXTRA_WRITE_CACHE);
} }
} }

6
sql/sql_base.cc
View File

@ -3934,7 +3934,7 @@ retry:
READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD, READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
ha_open_options | HA_OPEN_FOR_REPAIR, ha_open_options | HA_OPEN_FOR_REPAIR,
entry, FALSE) || ! entry->file || entry, FALSE) || ! entry->file ||
(entry->file->is_crashed() && entry->file->check_and_repair(thd))) (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
{ {
/* Give right error message */ /* Give right error message */
thd->clear_error(); thd->clear_error();
@ -5400,7 +5400,7 @@ bool rm_temporary_table(handlerton *base, char *path)
error=1; /* purecov: inspected */ error=1; /* purecov: inspected */
*ext= 0; // remove extension *ext= 0; // remove extension
file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base); file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
if (file && file->delete_table(path)) if (file && file->ha_delete_table(path))
{ {
error=1; error=1;
sql_print_warning("Could not remove temporary table: '%s', error: %d", sql_print_warning("Could not remove temporary table: '%s', error: %d",
@ -8070,7 +8070,7 @@ my_bool mysql_rm_tmp_tables(void)
((handler_file= get_new_handler(&share, thd->mem_root, ((handler_file= get_new_handler(&share, thd->mem_root,
share.db_type())))) share.db_type()))))
{ {
handler_file->delete_table(filePathCopy); handler_file->ha_delete_table(filePathCopy);
delete handler_file; delete handler_file;
} }
free_table_share(&share); free_table_share(&share);

4
sql/sql_delete.cc
View File

@ -123,7 +123,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK); table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
ha_rows const maybe_deleted= table->file->stats.records; ha_rows const maybe_deleted= table->file->stats.records;
DBUG_PRINT("debug", ("Trying to use delete_all_rows()")); DBUG_PRINT("debug", ("Trying to use delete_all_rows()"));
if (!(error=table->file->delete_all_rows())) if (!(error=table->file->ha_delete_all_rows()))
{ {
error= -1; // ok error= -1; // ok
deleted= maybe_deleted; deleted= maybe_deleted;
@ -328,7 +328,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds,
We're really doing a truncate and need to reset the table's We're really doing a truncate and need to reset the table's
auto-increment counter. auto-increment counter.
*/ */
int error2= table->file->reset_auto_increment(0); int error2= table->file->ha_reset_auto_increment(0);
if (error2 && (error2 != HA_ERR_WRONG_COMMAND)) if (error2 && (error2 != HA_ERR_WRONG_COMMAND))
{ {

18
sql/sql_partition.cc
View File

@ -5108,9 +5108,9 @@ static bool mysql_change_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("mysql_change_partitions"); DBUG_ENTER("mysql_change_partitions");
build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0); build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0);
if ((error= file->change_partitions(lpt->create_info, path, &lpt->copied, if ((error= file->ha_change_partitions(lpt->create_info, path, &lpt->copied,
&lpt->deleted, lpt->pack_frm_data, &lpt->deleted, lpt->pack_frm_data,
lpt->pack_frm_len))) lpt->pack_frm_len)))
{ {
if (error != ER_OUTOFMEMORY) if (error != ER_OUTOFMEMORY)
file->print_error(error, MYF(0)); file->print_error(error, MYF(0));
@ -5148,7 +5148,7 @@ static bool mysql_rename_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("mysql_rename_partitions"); DBUG_ENTER("mysql_rename_partitions");
build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0); build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0);
if ((error= lpt->table->file->rename_partitions(path))) if ((error= lpt->table->file->ha_rename_partitions(path)))
{ {
if (error != 1) if (error != 1)
lpt->table->file->print_error(error, MYF(0)); lpt->table->file->print_error(error, MYF(0));
@ -5189,7 +5189,7 @@ static bool mysql_drop_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
DBUG_ENTER("mysql_drop_partitions"); DBUG_ENTER("mysql_drop_partitions");
build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0); build_table_filename(path, sizeof(path), lpt->db, lpt->table_name, "", 0);
if ((error= lpt->table->file->drop_partitions(path))) if ((error= lpt->table->file->ha_drop_partitions(path)))
{ {
lpt->table->file->print_error(error, MYF(0)); lpt->table->file->print_error(error, MYF(0));
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
@ -6105,13 +6105,13 @@ uint fast_alter_partition_table(THD *thd, TABLE *table,
int error; int error;
written_bin_log= FALSE; written_bin_log= FALSE;
if (((alter_info->flags & ALTER_OPTIMIZE_PARTITION) && if (((alter_info->flags & ALTER_OPTIMIZE_PARTITION) &&
(error= table->file->optimize_partitions(thd))) || (error= table->file->ha_optimize_partitions(thd))) ||
((alter_info->flags & ALTER_ANALYZE_PARTITION) && ((alter_info->flags & ALTER_ANALYZE_PARTITION) &&
(error= table->file->analyze_partitions(thd))) || (error= table->file->ha_analyze_partitions(thd))) ||
((alter_info->flags & ALTER_CHECK_PARTITION) && ((alter_info->flags & ALTER_CHECK_PARTITION) &&
(error= table->file->check_partitions(thd))) || (error= table->file->ha_check_partitions(thd))) ||
((alter_info->flags & ALTER_REPAIR_PARTITION) && ((alter_info->flags & ALTER_REPAIR_PARTITION) &&
(error= table->file->repair_partitions(thd)))) (error= table->file->ha_repair_partitions(thd))))
{ {
table->file->print_error(error, MYF(0)); table->file->print_error(error, MYF(0));
goto err; goto err;

12
sql/sql_select.cc
View File

@ -1534,14 +1534,14 @@ JOIN::reinit()
if (exec_tmp_table1) if (exec_tmp_table1)
{ {
exec_tmp_table1->file->extra(HA_EXTRA_RESET_STATE); exec_tmp_table1->file->extra(HA_EXTRA_RESET_STATE);
exec_tmp_table1->file->delete_all_rows(); exec_tmp_table1->file->ha_delete_all_rows();
free_io_cache(exec_tmp_table1); free_io_cache(exec_tmp_table1);
filesort_free_buffers(exec_tmp_table1,0); filesort_free_buffers(exec_tmp_table1,0);
} }
if (exec_tmp_table2) if (exec_tmp_table2)
{ {
exec_tmp_table2->file->extra(HA_EXTRA_RESET_STATE); exec_tmp_table2->file->extra(HA_EXTRA_RESET_STATE);
exec_tmp_table2->file->delete_all_rows(); exec_tmp_table2->file->ha_delete_all_rows();
free_io_cache(exec_tmp_table2); free_io_cache(exec_tmp_table2);
filesort_free_buffers(exec_tmp_table2,0); filesort_free_buffers(exec_tmp_table2,0);
} }
@ -10467,9 +10467,9 @@ free_tmp_table(THD *thd, TABLE *entry)
if (entry->file) if (entry->file)
{ {
if (entry->db_stat) if (entry->db_stat)
entry->file->drop_table(entry->s->table_name.str); entry->file->ha_drop_table(entry->s->table_name.str);
else else
entry->file->delete_table(entry->s->table_name.str); entry->file->ha_delete_table(entry->s->table_name.str);
delete entry->file; delete entry->file;
} }
@ -10525,7 +10525,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
if (open_tmp_table(&new_table)) if (open_tmp_table(&new_table))
goto err1; goto err1;
if (table->file->indexes_are_disabled()) if (table->file->indexes_are_disabled())
new_table.file->disable_indexes(HA_KEY_SWITCH_ALL); new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);
table->file->ha_index_or_rnd_end(); table->file->ha_index_or_rnd_end();
table->file->ha_rnd_init(1); table->file->ha_rnd_init(1);
if (table->no_rows) if (table->no_rows)
@ -10591,7 +10591,7 @@ bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
(void) table->file->ha_rnd_end(); (void) table->file->ha_rnd_end();
(void) new_table.file->close(); (void) new_table.file->close();
err1: err1:
new_table.file->delete_table(new_table.s->table_name.str); new_table.file->ha_delete_table(new_table.s->table_name.str);
err2: err2:
delete new_table.file; delete new_table.file;
thd->proc_info=save_proc_info; thd->proc_info=save_proc_info;

2
sql/sql_show.cc
View File

@ -5864,7 +5864,7 @@ bool get_schema_tables_result(JOIN *join,
{ {
table_list->table->file->extra(HA_EXTRA_NO_CACHE); table_list->table->file->extra(HA_EXTRA_NO_CACHE);
table_list->table->file->extra(HA_EXTRA_RESET_STATE); table_list->table->file->extra(HA_EXTRA_RESET_STATE);
table_list->table->file->delete_all_rows(); table_list->table->file->ha_delete_all_rows();
free_io_cache(table_list->table); free_io_cache(table_list->table);
filesort_free_buffers(table_list->table,1); filesort_free_buffers(table_list->table,1);
table_list->table->null_row= 0; table_list->table->null_row= 0;

50
sql/sql_table.cc
View File

@ -625,7 +625,7 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
} }
else else
{ {
if ((error= file->delete_table(ddl_log_entry->name))) if ((error= file->ha_delete_table(ddl_log_entry->name)))
{ {
if (error != ENOENT && error != HA_ERR_NO_SUCH_TABLE) if (error != ENOENT && error != HA_ERR_NO_SUCH_TABLE)
break; break;
@ -662,8 +662,8 @@ static int execute_ddl_log_action(THD *thd, DDL_LOG_ENTRY *ddl_log_entry)
} }
else else
{ {
if (file->rename_table(ddl_log_entry->from_name, if (file->ha_rename_table(ddl_log_entry->from_name,
ddl_log_entry->name)) ddl_log_entry->name))
break; break;
} }
if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos))) if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos)))
@ -1294,9 +1294,9 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
lpt->table_name, lpt->create_info, lpt->table_name, lpt->create_info,
lpt->alter_info->create_list, lpt->key_count, lpt->alter_info->create_list, lpt->key_count,
lpt->key_info_buffer, lpt->table->file)) || lpt->key_info_buffer, lpt->table->file)) ||
lpt->table->file->create_handler_files(shadow_path, NULL, lpt->table->file->ha_create_handler_files(shadow_path, NULL,
CHF_CREATE_FLAG, CHF_CREATE_FLAG,
lpt->create_info)) lpt->create_info))
{ {
my_delete(shadow_frm_name, MYF(0)); my_delete(shadow_frm_name, MYF(0));
error= 1; error= 1;
@ -1348,15 +1348,15 @@ bool mysql_write_frm(ALTER_PARTITION_PARAM_TYPE *lpt, uint flags)
VOID(pthread_mutex_lock(&LOCK_open)); VOID(pthread_mutex_lock(&LOCK_open));
if (my_delete(frm_name, MYF(MY_WME)) || if (my_delete(frm_name, MYF(MY_WME)) ||
#ifdef WITH_PARTITION_STORAGE_ENGINE #ifdef WITH_PARTITION_STORAGE_ENGINE
lpt->table->file->create_handler_files(path, shadow_path, lpt->table->file->ha_create_handler_files(path, shadow_path,
CHF_DELETE_FLAG, NULL) || CHF_DELETE_FLAG, NULL) ||
deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos) || deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos) ||
(sync_ddl_log(), FALSE) || (sync_ddl_log(), FALSE) ||
#endif #endif
#ifdef WITH_PARTITION_STORAGE_ENGINE #ifdef WITH_PARTITION_STORAGE_ENGINE
my_rename(shadow_frm_name, frm_name, MYF(MY_WME)) || my_rename(shadow_frm_name, frm_name, MYF(MY_WME)) ||
lpt->table->file->create_handler_files(path, shadow_path, lpt->table->file->ha_create_handler_files(path, shadow_path,
CHF_RENAME_FLAG, NULL)) CHF_RENAME_FLAG, NULL))
#else #else
my_rename(shadow_frm_name, frm_name, MYF(MY_WME))) my_rename(shadow_frm_name, frm_name, MYF(MY_WME)))
#endif #endif
@ -3713,14 +3713,14 @@ mysql_rename_table(handlerton *base, const char *old_db,
to_base= lc_to; to_base= lc_to;
} }
if (!file || !(error=file->rename_table(from_base, to_base))) if (!file || !(error=file->ha_rename_table(from_base, to_base)))
{ {
if (!(flags & NO_FRM_RENAME) && rename_file_ext(from,to,reg_ext)) if (!(flags & NO_FRM_RENAME) && rename_file_ext(from,to,reg_ext))
{ {
error=my_errno; error=my_errno;
/* Restore old file name */ /* Restore old file name */
if (file) if (file)
file->rename_table(to_base, from_base); file->ha_rename_table(to_base, from_base);
} }
} }
delete file; delete file;
@ -4371,7 +4371,7 @@ send_result_message:
if (!result_code) // recreation went ok if (!result_code) // recreation went ok
{ {
if ((table->table= open_ltable(thd, table, lock_type, 0)) && if ((table->table= open_ltable(thd, table, lock_type, 0)) &&
((result_code= table->table->file->analyze(thd, check_opt)) > 0)) ((result_code= table->table->file->ha_analyze(thd, check_opt)) > 0))
result_code= 0; // analyze went ok result_code= 0; // analyze went ok
} }
if (result_code) // either mysql_recreate_table or analyze failed if (result_code) // either mysql_recreate_table or analyze failed
@ -4481,7 +4481,7 @@ bool mysql_backup_table(THD* thd, TABLE_LIST* table_list)
"MySQL Administrator (mysqldump, mysql)"); "MySQL Administrator (mysqldump, mysql)");
DBUG_RETURN(mysql_admin_table(thd, table_list, 0, DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
"backup", TL_READ, 0, 0, 0, 0, "backup", TL_READ, 0, 0, 0, 0,
&handler::backup, 0)); &handler::ha_backup, 0));
} }
@ -4493,7 +4493,7 @@ bool mysql_restore_table(THD* thd, TABLE_LIST* table_list)
DBUG_RETURN(mysql_admin_table(thd, table_list, 0, DBUG_RETURN(mysql_admin_table(thd, table_list, 0,
"restore", TL_WRITE, 1, 1, 0, "restore", TL_WRITE, 1, 1, 0,
&prepare_for_restore, &prepare_for_restore,
&handler::restore, 0)); &handler::ha_restore, 0));
} }
@ -4514,7 +4514,7 @@ bool mysql_optimize_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
DBUG_ENTER("mysql_optimize_table"); DBUG_ENTER("mysql_optimize_table");
DBUG_RETURN(mysql_admin_table(thd, tables, check_opt, DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
"optimize", TL_WRITE, 1,0,0,0, "optimize", TL_WRITE, 1,0,0,0,
&handler::optimize, 0)); &handler::ha_optimize, 0));
} }
@ -4928,7 +4928,7 @@ bool mysql_analyze_table(THD* thd, TABLE_LIST* tables, HA_CHECK_OPT* check_opt)
DBUG_ENTER("mysql_analyze_table"); DBUG_ENTER("mysql_analyze_table");
DBUG_RETURN(mysql_admin_table(thd, tables, check_opt, DBUG_RETURN(mysql_admin_table(thd, tables, check_opt,
"analyze", lock_type, 1, 0, 0, 0, "analyze", lock_type, 1, 0, 0, 0,
&handler::analyze, 0)); &handler::ha_analyze, 0));
} }
@ -4975,7 +4975,7 @@ mysql_discard_or_import_tablespace(THD *thd,
DBUG_RETURN(-1); DBUG_RETURN(-1);
} }
error=table->file->discard_or_import_tablespace(discard); error= table->file->ha_discard_or_import_tablespace(discard);
thd->proc_info="end"; thd->proc_info="end";
@ -5348,14 +5348,14 @@ bool alter_table_manage_keys(TABLE *table, int indexes_were_disabled,
switch (keys_onoff) { switch (keys_onoff) {
case ENABLE: case ENABLE:
error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE); error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
break; break;
case LEAVE_AS_IS: case LEAVE_AS_IS:
if (!indexes_were_disabled) if (!indexes_were_disabled)
break; break;
/* fall-through: disabled indexes */ /* fall-through: disabled indexes */
case DISABLE: case DISABLE:
error= table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE); error= table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
} }
if (error == HA_ERR_WRONG_COMMAND) if (error == HA_ERR_WRONG_COMMAND)
@ -6125,14 +6125,14 @@ view_err:
wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN); wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
VOID(pthread_mutex_unlock(&LOCK_open)); VOID(pthread_mutex_unlock(&LOCK_open));
DBUG_EXECUTE_IF("sleep_alter_enable_indexes", my_sleep(6000000);); DBUG_EXECUTE_IF("sleep_alter_enable_indexes", my_sleep(6000000););
error= table->file->enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE); error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
/* COND_refresh will be signaled in close_thread_tables() */ /* COND_refresh will be signaled in close_thread_tables() */
break; break;
case DISABLE: case DISABLE:
VOID(pthread_mutex_lock(&LOCK_open)); VOID(pthread_mutex_lock(&LOCK_open));
wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN); wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
VOID(pthread_mutex_unlock(&LOCK_open)); VOID(pthread_mutex_unlock(&LOCK_open));
error=table->file->disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE); error=table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
/* COND_refresh will be signaled in close_thread_tables() */ /* COND_refresh will be signaled in close_thread_tables() */
break; break;
default: default:
@ -6540,7 +6540,7 @@ view_err:
KEY_PART_INFO *part_end; KEY_PART_INFO *part_end;
DBUG_PRINT("info", ("No new_table, checking add/drop index")); DBUG_PRINT("info", ("No new_table, checking add/drop index"));
table->file->prepare_for_alter(); table->file->ha_prepare_for_alter();
if (index_add_count) if (index_add_count)
{ {
/* The add_index() method takes an array of KEY structs. */ /* The add_index() method takes an array of KEY structs. */
@ -6758,8 +6758,8 @@ view_err:
t_table= table; t_table= table;
} }
/* Tell the handler that a new frm file is in place. */ /* Tell the handler that a new frm file is in place. */
if (t_table->file->create_handler_files(path, NULL, CHF_INDEX_FLAG, if (t_table->file->ha_create_handler_files(path, NULL, CHF_INDEX_FLAG,
create_info)) create_info))
goto err_with_placeholders; goto err_with_placeholders;
if (thd->locked_tables && new_name == table_name && new_db == db) if (thd->locked_tables && new_name == table_name && new_db == db)
{ {

6
sql/sql_union.cc
View File

@ -440,10 +440,10 @@ bool st_select_lex_unit::exec()
{ {
item->assigned(0); // We will reinit & rexecute unit item->assigned(0); // We will reinit & rexecute unit
item->reset(); item->reset();
table->file->delete_all_rows(); table->file->ha_delete_all_rows();
} }
/* re-enabling indexes for next subselect iteration */ /* re-enabling indexes for next subselect iteration */
if (union_distinct && table->file->enable_indexes(HA_KEY_SWITCH_ALL)) if (union_distinct && table->file->ha_enable_indexes(HA_KEY_SWITCH_ALL))
{ {
DBUG_ASSERT(0); DBUG_ASSERT(0);
} }
@ -485,7 +485,7 @@ bool st_select_lex_unit::exec()
sl->join->exec(); sl->join->exec();
if (sl == union_distinct) if (sl == union_distinct)
{ {
if (table->file->disable_indexes(HA_KEY_SWITCH_ALL)) if (table->file->ha_disable_indexes(HA_KEY_SWITCH_ALL))
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
table->no_keyread=1; table->no_keyread=1;
} }

6
sql/sql_update.cc
View File

@ -623,9 +623,9 @@ int mysql_update(THD *thd,
call then it should be included in the count of dup_key_found call then it should be included in the count of dup_key_found
and error should be set to 0 (only if these errors are ignored). and error should be set to 0 (only if these errors are ignored).
*/ */
error= table->file->bulk_update_row(table->record[1], error= table->file->ha_bulk_update_row(table->record[1],
table->record[0], table->record[0],
&dup_key_found); &dup_key_found);
limit+= dup_key_found; limit+= dup_key_found;
updated-= dup_key_found; updated-= dup_key_found;
} }

4
sql/unireg.cc
View File

@ -393,7 +393,7 @@ int rea_create_table(THD *thd, const char *path,
DBUG_ASSERT(*fn_rext(frm_name)); DBUG_ASSERT(*fn_rext(frm_name));
if (thd->variables.keep_files_on_create) if (thd->variables.keep_files_on_create)
create_info->options|= HA_CREATE_KEEP_FILES; create_info->options|= HA_CREATE_KEEP_FILES;
if (file->create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info)) if (file->ha_create_handler_files(path, NULL, CHF_CREATE_FLAG, create_info))
goto err_handler; goto err_handler;
if (!create_info->frm_only && ha_create_table(thd, path, db, table_name, if (!create_info->frm_only && ha_create_table(thd, path, db, table_name,
create_info,0)) create_info,0))
@ -401,7 +401,7 @@ int rea_create_table(THD *thd, const char *path,
DBUG_RETURN(0); DBUG_RETURN(0);
err_handler: err_handler:
VOID(file->create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info)); VOID(file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));
my_delete(frm_name, MYF(0)); my_delete(frm_name, MYF(0));
DBUG_RETURN(1); DBUG_RETURN(1);
} /* rea_create_table */ } /* rea_create_table */