Skip to content

M
mariadb
Commit c0309e5a authored by unknown's avatar unknown
Browse files
Options

added DBUG_ENTER/RETURN tags, dbug_add_tags.pl bugfix 


dbug/dbug_add_tags.pl:
  small fix
sql/ha_myisam.cc:
  added DBUG_ENTER/RETURN tags
sql/ha_myisammrg.cc:
  added DBUG_ENTER/RETURN tags
sql/handler.cc:
  added DBUG_ENTER/RETURN tags
parent 7675eafe
Hide whitespace changes
Inline Side-by-side
Showing with 339 additions and 143 deletions
dbug/dbug_add_tags.pl
View file @ c0309e5a
...@@ -5,7 +5,7 @@ die "No files specified\n" unless $ARGV[0]; ...@@ -5,7 +5,7 @@ die "No files specified\n" unless $ARGV[0];
$ctags="exctags -x -f - --c-types=f -u"; $ctags="exctags -x -f - --c-types=f -u";
sub get_tag { sub get_tag {
local $_=<TAGS>; local $.; local $_=<TAGS>;
($symbol, $line)= /^(.*\S)\s+function\s+(\d+)/; ($symbol, $line)= /^(.*\S)\s+function\s+(\d+)/;
$symbol=$1 if /\s(\S+)\s*\(/; $symbol=$1 if /\s(\S+)\s*\(/;
$line=1e50 unless $line; $line=1e50 unless $line;
...@@ -40,7 +40,6 @@ while($src=shift) ...@@ -40,7 +40,6 @@ while($src=shift)
warn "$src:".($.-1)."\t$orig" if /\breturn\b/; warn "$src:".($.-1)."\t$orig" if /\breturn\b/;
} }
print; print;
next if /DBUG_ENTER/;
next if $. < $line; next if $. < $line;
die "Something wrong: \$.=$., \$line=$line, \$symbol=$symbol\n" if $. > $line; die "Something wrong: \$.=$., \$line=$line, \$symbol=$symbol\n" if $. > $line;
&get_tag && next if /^\s*inline /; &get_tag && next if /^\s*inline /;
......
sql/ha_myisam.cc
View file @ c0309e5a
...@@ -48,6 +48,8 @@ TYPELIB myisam_recover_typelib= {array_elements(myisam_recover_names)-1,"", ...@@ -48,6 +48,8 @@ TYPELIB myisam_recover_typelib= {array_elements(myisam_recover_names)-1,"",
static void mi_check_print_msg(MI_CHECK *param, const char* msg_type, static void mi_check_print_msg(MI_CHECK *param, const char* msg_type,
const char *fmt, va_list args) const char *fmt, va_list args)
{ {
DBUG_ENTER("mi_check_print_msg");
THD* thd = (THD*)param->thd; THD* thd = (THD*)param->thd;
String* packet = &thd->packet; String* packet = &thd->packet;
uint length; uint length;
...@@ -64,12 +66,12 @@ static void mi_check_print_msg(MI_CHECK *param, const char* msg_type, ...@@ -64,12 +66,12 @@ static void mi_check_print_msg(MI_CHECK *param, const char* msg_type,
if (thd->net.vio == 0) if (thd->net.vio == 0)
{ {
sql_print_error(msgbuf); sql_print_error(msgbuf);
return; DBUG_VOID_RETURN;
} }
if (param->testflag & (T_CREATE_MISSING_KEYS | T_SAFE_REPAIR | T_AUTO_REPAIR)) if (param->testflag & (T_CREATE_MISSING_KEYS | T_SAFE_REPAIR | T_AUTO_REPAIR))
{ {
my_message(ER_NOT_KEYFILE,msgbuf,MYF(MY_WME)); my_message(ER_NOT_KEYFILE,msgbuf,MYF(MY_WME));
return; DBUG_VOID_RETURN;
} }
length=(uint) (strxmov(name, param->db_name,".",param->table_name,NullS) - length=(uint) (strxmov(name, param->db_name,".",param->table_name,NullS) -
name); name);
...@@ -81,37 +83,46 @@ static void mi_check_print_msg(MI_CHECK *param, const char* msg_type, ...@@ -81,37 +83,46 @@ static void mi_check_print_msg(MI_CHECK *param, const char* msg_type,
if (my_net_write(&thd->net, (char*)thd->packet.ptr(), thd->packet.length())) if (my_net_write(&thd->net, (char*)thd->packet.ptr(), thd->packet.length()))
sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n", sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n",
msgbuf); msgbuf);
return; DBUG_VOID_RETURN;
} }
extern "C" { extern "C" {
void mi_check_print_error(MI_CHECK *param, const char *fmt,...) void mi_check_print_error(MI_CHECK *param, const char *fmt,...)
{ {
DBUG_ENTER("mi_check_print_error");
param->error_printed|=1; param->error_printed|=1;
param->out_flag|= O_DATA_LOST; param->out_flag|= O_DATA_LOST;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
mi_check_print_msg(param, "error", fmt, args); mi_check_print_msg(param, "error", fmt, args);
va_end(args); va_end(args);
DBUG_VOID_RETURN;
} }
void mi_check_print_info(MI_CHECK *param, const char *fmt,...) void mi_check_print_info(MI_CHECK *param, const char *fmt,...)
{ {
va_list args; va_list args;
DBUG_ENTER("mi_check_print_info");
va_start(args, fmt); va_start(args, fmt);
mi_check_print_msg(param, "info", fmt, args); mi_check_print_msg(param, "info", fmt, args);
va_end(args); va_end(args);
DBUG_VOID_RETURN;
} }
void mi_check_print_warning(MI_CHECK *param, const char *fmt,...) void mi_check_print_warning(MI_CHECK *param, const char *fmt,...)
{ {
DBUG_ENTER("mi_check_print_warning");
param->warning_printed=1; param->warning_printed=1;
param->out_flag|= O_DATA_LOST; param->out_flag|= O_DATA_LOST;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
mi_check_print_msg(param, "warning", fmt, args); mi_check_print_msg(param, "warning", fmt, args);
va_end(args); va_end(args);
DBUG_VOID_RETURN;
} }
} }
...@@ -122,15 +133,18 @@ const char **ha_myisam::bas_ext() const ...@@ -122,15 +133,18 @@ const char **ha_myisam::bas_ext() const
const char *ha_myisam::index_type(uint key_number) const char *ha_myisam::index_type(uint key_number)
{ {
return ((table->key_info[key_number].flags & HA_FULLTEXT) ? DBUG_ENTER("*ha_myisam::index_type");
DBUG_RETURN(((table->key_info[key_number].flags & HA_FULLTEXT) ?
"FULLTEXT" : "FULLTEXT" :
"BTREE"); "BTREE"));
} }
int ha_myisam::net_read_dump(NET* net) int ha_myisam::net_read_dump(NET* net)
{ {
int data_fd = file->dfile; int data_fd = file->dfile;
int error = 0; int error = 0;
DBUG_ENTER("ha_myisam::net_read_dump");
my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME)); my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
for (;;) for (;;)
...@@ -153,12 +167,14 @@ int ha_myisam::net_read_dump(NET* net) ...@@ -153,12 +167,14 @@ int ha_myisam::net_read_dump(NET* net)
} }
err: err:
return error; DBUG_RETURN(error);
} }
int ha_myisam::dump(THD* thd, int fd) int ha_myisam::dump(THD* thd, int fd)
{ {
DBUG_ENTER("ha_myisam::dump");
MYISAM_SHARE* share = file->s; MYISAM_SHARE* share = file->s;
NET* net = &thd->net; NET* net = &thd->net;
uint blocksize = share->blocksize; uint blocksize = share->blocksize;
...@@ -166,7 +182,7 @@ int ha_myisam::dump(THD* thd, int fd) ...@@ -166,7 +182,7 @@ int ha_myisam::dump(THD* thd, int fd)
int data_fd = file->dfile; int data_fd = file->dfile;
byte * buf = (byte*) my_malloc(blocksize, MYF(MY_WME)); byte * buf = (byte*) my_malloc(blocksize, MYF(MY_WME));
if (!buf) if (!buf)
return ENOMEM; DBUG_RETURN(ENOMEM);
int error = 0; int error = 0;
my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME)); my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
...@@ -206,15 +222,17 @@ int ha_myisam::dump(THD* thd, int fd) ...@@ -206,15 +222,17 @@ int ha_myisam::dump(THD* thd, int fd)
err: err:
my_free((gptr) buf, MYF(0)); my_free((gptr) buf, MYF(0));
return error; DBUG_RETURN(error);
} }
/* Name is here without an extension */ /* Name is here without an extension */
int ha_myisam::open(const char *name, int mode, uint test_if_locked) int ha_myisam::open(const char *name, int mode, uint test_if_locked)
{ {
DBUG_ENTER("ha_myisam::open");
if (!(file=mi_open(name, mode, test_if_locked))) if (!(file=mi_open(name, mode, test_if_locked)))
return (my_errno ? my_errno : -1); DBUG_RETURN((my_errno ? my_errno : -1));
if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE)) if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))
VOID(mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0)); VOID(mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0));
...@@ -223,18 +241,22 @@ int ha_myisam::open(const char *name, int mode, uint test_if_locked) ...@@ -223,18 +241,22 @@ int ha_myisam::open(const char *name, int mode, uint test_if_locked)
VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0)); VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0));
if (!table->db_record_offset) if (!table->db_record_offset)
int_table_flags|=HA_REC_NOT_IN_SEQ; int_table_flags|=HA_REC_NOT_IN_SEQ;
return (0); DBUG_RETURN((0));
} }
int ha_myisam::close(void) int ha_myisam::close(void)
{ {
MI_INFO *tmp=file; MI_INFO *tmp=file;
DBUG_ENTER("ha_myisam::close");
file=0; file=0;
return mi_close(tmp); DBUG_RETURN(mi_close(tmp));
} }
int ha_myisam::write_row(byte * buf) int ha_myisam::write_row(byte * buf)
{ {
DBUG_ENTER("ha_myisam::write_row");
statistic_increment(ha_write_count,&LOCK_status); statistic_increment(ha_write_count,&LOCK_status);
/* If we have a timestamp column, update it to the current time */ /* If we have a timestamp column, update it to the current time */
...@@ -248,12 +270,14 @@ int ha_myisam::write_row(byte * buf) ...@@ -248,12 +270,14 @@ int ha_myisam::write_row(byte * buf)
*/ */
if (table->next_number_field && buf == table->record[0]) if (table->next_number_field && buf == table->record[0])
update_auto_increment(); update_auto_increment();
return mi_write(file,buf); DBUG_RETURN(mi_write(file,buf));
} }
int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt) int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)
{ {
if (!file) return HA_ADMIN_INTERNAL_ERROR; DBUG_ENTER("ha_myisam::check");
if (!file) DBUG_RETURN(HA_ADMIN_INTERNAL_ERROR);
int error; int error;
MI_CHECK param; MI_CHECK param;
MYISAM_SHARE* share = file->s; MYISAM_SHARE* share = file->s;
...@@ -278,7 +302,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt) ...@@ -278,7 +302,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)
share->state.open_count == 0) || share->state.open_count == 0) ||
((param.testflag & T_FAST) && (share->state.open_count == ((param.testflag & T_FAST) && (share->state.open_count ==
(uint) (share->global_changed ? 1 : 0))))) (uint) (share->global_changed ? 1 : 0)))))
return HA_ADMIN_ALREADY_DONE; DBUG_RETURN(HA_ADMIN_ALREADY_DONE);
error = chk_status(&param, file); // Not fatal error = chk_status(&param, file); // Not fatal
error = chk_size(&param, file); error = chk_size(&param, file);
...@@ -331,7 +355,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt) ...@@ -331,7 +355,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)
} }
thd->proc_info=old_proc_info; thd->proc_info=old_proc_info;
return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK; DBUG_RETURN(error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK);
} }
...@@ -345,6 +369,8 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt) ...@@ -345,6 +369,8 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt)
{ {
int error=0; int error=0;
MI_CHECK param; MI_CHECK param;
DBUG_ENTER("ha_myisam::analyze");
MYISAM_SHARE* share = file->s; MYISAM_SHARE* share = file->s;
myisamchk_init(&param); myisamchk_init(&param);
...@@ -357,7 +383,7 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt) ...@@ -357,7 +383,7 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt)
param.using_global_keycache = 1; param.using_global_keycache = 1;
if (!(share->state.changed & STATE_NOT_ANALYZED)) if (!(share->state.changed & STATE_NOT_ANALYZED))
return HA_ADMIN_ALREADY_DONE; DBUG_RETURN(HA_ADMIN_ALREADY_DONE);
error = chk_key(&param, file); error = chk_key(&param, file);
if (!error) if (!error)
...@@ -368,7 +394,7 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt) ...@@ -368,7 +394,7 @@ int ha_myisam::analyze(THD *thd, HA_CHECK_OPT* check_opt)
} }
else if (!mi_is_crashed(file)) else if (!mi_is_crashed(file))
mi_mark_crashed(file); mi_mark_crashed(file);
return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK; DBUG_RETURN(error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK);
} }
...@@ -380,7 +406,7 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) ...@@ -380,7 +406,7 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
char* table_name = table->real_name; char* table_name = table->real_name;
int error; int error;
const char* errmsg; const char* errmsg;
DBUG_ENTER("restore"); DBUG_ENTER("ha_myisam::restore");
if (fn_format_relative_to_data_home(src_path, table_name, backup_dir, if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
MI_NAME_DEXT)) MI_NAME_DEXT))
...@@ -399,17 +425,15 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt) ...@@ -399,17 +425,15 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
DBUG_RETURN(repair(thd, &tmp_check_opt)); DBUG_RETURN(repair(thd, &tmp_check_opt));
err: err:
{ MI_CHECK param;
MI_CHECK param; myisamchk_init(&param);
myisamchk_init(&param); param.thd = thd;
param.thd = thd; param.op_name = (char*)"restore";
param.op_name = (char*)"restore"; param.db_name = table->table_cache_key;
param.db_name = table->table_cache_key; param.table_name = table->table_name;
param.table_name = table->table_name; param.testflag = 0;
param.testflag = 0; mi_check_print_error(&param,errmsg, my_errno);
mi_check_print_error(&param,errmsg, my_errno); DBUG_RETURN(error);
DBUG_RETURN(error);
}
} }
...@@ -460,17 +484,15 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt) ...@@ -460,17 +484,15 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
DBUG_RETURN(HA_ADMIN_OK); DBUG_RETURN(HA_ADMIN_OK);
err: err:
{ MI_CHECK param;
MI_CHECK param; myisamchk_init(&param);
myisamchk_init(&param); param.thd = thd;
param.thd = thd; param.op_name = (char*)"backup";
param.op_name = (char*)"backup"; param.db_name = table->table_cache_key;
param.db_name = table->table_cache_key; param.table_name = table->table_name;
param.table_name = table->table_name; param.testflag = 0;
param.testflag = 0; mi_check_print_error(&param,errmsg, my_errno);
mi_check_print_error(&param,errmsg, my_errno); DBUG_RETURN(error);
DBUG_RETURN(error);
}
} }
...@@ -479,8 +501,9 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt) ...@@ -479,8 +501,9 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt)
int error; int error;
MI_CHECK param; MI_CHECK param;
ha_rows start_records; ha_rows start_records;
DBUG_ENTER("ha_myisam::repair");
if (!file) return HA_ADMIN_INTERNAL_ERROR; if (!file) DBUG_RETURN(HA_ADMIN_INTERNAL_ERROR);
myisamchk_init(&param); myisamchk_init(&param);
param.thd = thd; param.thd = thd;
...@@ -520,12 +543,14 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt) ...@@ -520,12 +543,14 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt)
llstr(start_records, llbuff2), llstr(start_records, llbuff2),
table->path); table->path);
} }
return error; DBUG_RETURN(error);
} }
int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt) int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt)
{ {
if (!file) return HA_ADMIN_INTERNAL_ERROR; DBUG_ENTER("ha_myisam::optimize");
if (!file) DBUG_RETURN(HA_ADMIN_INTERNAL_ERROR);
MI_CHECK param; MI_CHECK param;
myisamchk_init(&param); myisamchk_init(&param);
...@@ -534,7 +559,7 @@ int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt) ...@@ -534,7 +559,7 @@ int ha_myisam::optimize(THD* thd, HA_CHECK_OPT *check_opt)
param.testflag = (check_opt->flags | T_SILENT | T_FORCE_CREATE | param.testflag = (check_opt->flags | T_SILENT | T_FORCE_CREATE |
T_REP_BY_SORT | T_STATISTICS | T_SORT_INDEX); T_REP_BY_SORT | T_STATISTICS | T_SORT_INDEX);
param.sort_buffer_length= check_opt->sort_buffer_size; param.sort_buffer_length= check_opt->sort_buffer_size;
return repair(thd,param,1); DBUG_RETURN(repair(thd,param,1));
} }
...@@ -669,6 +694,8 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize) ...@@ -669,6 +694,8 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
void ha_myisam::deactivate_non_unique_index(ha_rows rows) void ha_myisam::deactivate_non_unique_index(ha_rows rows)
{ {
DBUG_ENTER("ha_myisam::deactivate_non_unique_index");
MYISAM_SHARE* share = file->s; MYISAM_SHARE* share = file->s;
if (share->state.key_map == ((ulonglong) 1L << share->base.keys)-1) if (share->state.key_map == ((ulonglong) 1L << share->base.keys)-1)
{ {
...@@ -690,6 +717,7 @@ void ha_myisam::deactivate_non_unique_index(ha_rows rows) ...@@ -690,6 +717,7 @@ void ha_myisam::deactivate_non_unique_index(ha_rows rows)
} }
else else
enable_activate_all_index=0; enable_activate_all_index=0;
DBUG_VOID_RETURN;
} }
...@@ -698,7 +726,7 @@ bool ha_myisam::activate_all_index(THD *thd) ...@@ -698,7 +726,7 @@ bool ha_myisam::activate_all_index(THD *thd)
int error=0; int error=0;
MI_CHECK param; MI_CHECK param;
MYISAM_SHARE* share = file->s; MYISAM_SHARE* share = file->s;
DBUG_ENTER("activate_all_index"); DBUG_ENTER("ha_myisam::activate_all_index");
mi_extra(file, HA_EXTRA_BULK_INSERT_END, 0); mi_extra(file, HA_EXTRA_BULK_INSERT_END, 0);
table->bulk_insert= 0; table->bulk_insert= 0;
...@@ -752,131 +780,165 @@ bool ha_myisam::check_and_repair(THD *thd) ...@@ -752,131 +780,165 @@ bool ha_myisam::check_and_repair(THD *thd)
bool ha_myisam::is_crashed() const bool ha_myisam::is_crashed() const
{ {
return (file->s->state.changed & STATE_CRASHED || DBUG_ENTER("ha_myisam::is_crashed");
(my_disable_locking && file->s->state.open_count));
DBUG_RETURN((file->s->state.changed & STATE_CRASHED ||
(my_disable_locking && file->s->state.open_count)));
} }
int ha_myisam::update_row(const byte * old_data, byte * new_data) int ha_myisam::update_row(const byte * old_data, byte * new_data)
{ {
DBUG_ENTER("ha_myisam::update_row");
statistic_increment(ha_update_count,&LOCK_status); statistic_increment(ha_update_count,&LOCK_status);
if (table->time_stamp) if (table->time_stamp)
update_timestamp(new_data+table->time_stamp-1); update_timestamp(new_data+table->time_stamp-1);
return mi_update(file,old_data,new_data); DBUG_RETURN(mi_update(file,old_data,new_data));
} }
int ha_myisam::delete_row(const byte * buf) int ha_myisam::delete_row(const byte * buf)
{ {
DBUG_ENTER("ha_myisam::delete_row");
statistic_increment(ha_delete_count,&LOCK_status); statistic_increment(ha_delete_count,&LOCK_status);
return mi_delete(file,buf); DBUG_RETURN(mi_delete(file,buf));
} }
int ha_myisam::index_read(byte * buf, const byte * key, int ha_myisam::index_read(byte * buf, const byte * key,
uint key_len, enum ha_rkey_function find_flag) uint key_len, enum ha_rkey_function find_flag)
{ {
DBUG_ENTER("ha_myisam::index_read");
statistic_increment(ha_read_key_count,&LOCK_status); statistic_increment(ha_read_key_count,&LOCK_status);
int error=mi_rkey(file,buf,active_index, key, key_len, find_flag); int error=mi_rkey(file,buf,active_index, key, key_len, find_flag);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_read_idx(byte * buf, uint index, const byte * key, int ha_myisam::index_read_idx(byte * buf, uint index, const byte * key,
uint key_len, enum ha_rkey_function find_flag) uint key_len, enum ha_rkey_function find_flag)
{ {
DBUG_ENTER("ha_myisam::index_read_idx");
statistic_increment(ha_read_key_count,&LOCK_status); statistic_increment(ha_read_key_count,&LOCK_status);
int error=mi_rkey(file,buf,index, key, key_len, find_flag); int error=mi_rkey(file,buf,index, key, key_len, find_flag);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_read_last(byte * buf, const byte * key, uint key_len) int ha_myisam::index_read_last(byte * buf, const byte * key, uint key_len)
{ {
DBUG_ENTER("ha_myisam::index_read_last");
statistic_increment(ha_read_key_count,&LOCK_status); statistic_increment(ha_read_key_count,&LOCK_status);
int error=mi_rkey(file,buf,active_index, key, key_len, HA_READ_PREFIX_LAST); int error=mi_rkey(file,buf,active_index, key, key_len, HA_READ_PREFIX_LAST);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_next(byte * buf) int ha_myisam::index_next(byte * buf)
{ {
DBUG_ENTER("ha_myisam::index_next");
statistic_increment(ha_read_next_count,&LOCK_status); statistic_increment(ha_read_next_count,&LOCK_status);
int error=mi_rnext(file,buf,active_index); int error=mi_rnext(file,buf,active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_prev(byte * buf) int ha_myisam::index_prev(byte * buf)
{ {
DBUG_ENTER("ha_myisam::index_prev");
statistic_increment(ha_read_prev_count,&LOCK_status); statistic_increment(ha_read_prev_count,&LOCK_status);
int error=mi_rprev(file,buf, active_index); int error=mi_rprev(file,buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_first(byte * buf) int ha_myisam::index_first(byte * buf)
{ {
DBUG_ENTER("ha_myisam::index_first");
statistic_increment(ha_read_first_count,&LOCK_status); statistic_increment(ha_read_first_count,&LOCK_status);
int error=mi_rfirst(file, buf, active_index); int error=mi_rfirst(file, buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_last(byte * buf) int ha_myisam::index_last(byte * buf)
{ {
DBUG_ENTER("ha_myisam::index_last");
statistic_increment(ha_read_last_count,&LOCK_status); statistic_increment(ha_read_last_count,&LOCK_status);
int error=mi_rlast(file, buf, active_index); int error=mi_rlast(file, buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::index_next_same(byte * buf, int ha_myisam::index_next_same(byte * buf,
const byte *key __attribute__((unused)), const byte *key __attribute__((unused)),
uint length __attribute__((unused))) uint length __attribute__((unused)))
{ {
DBUG_ENTER("ha_myisam::index_next_same");
statistic_increment(ha_read_next_count,&LOCK_status); statistic_increment(ha_read_next_count,&LOCK_status);
int error=mi_rnext_same(file,buf); int error=mi_rnext_same(file,buf);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::rnd_init(bool scan) int ha_myisam::rnd_init(bool scan)
{ {
DBUG_ENTER("ha_myisam::rnd_init");
if (scan) if (scan)
return mi_scan_init(file); DBUG_RETURN(mi_scan_init(file));
return mi_extra(file, HA_EXTRA_RESET, 0); DBUG_RETURN(mi_extra(file, HA_EXTRA_RESET, 0));
} }
int ha_myisam::rnd_next(byte *buf) int ha_myisam::rnd_next(byte *buf)
{ {
DBUG_ENTER("ha_myisam::rnd_next");
statistic_increment(ha_read_rnd_next_count,&LOCK_status); statistic_increment(ha_read_rnd_next_count,&LOCK_status);
int error=mi_scan(file, buf); int error=mi_scan(file, buf);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisam::restart_rnd_next(byte *buf, byte *pos) int ha_myisam::restart_rnd_next(byte *buf, byte *pos)
{ {
return rnd_pos(buf,pos); DBUG_ENTER("ha_myisam::restart_rnd_next");
DBUG_RETURN(rnd_pos(buf,pos));
} }
int ha_myisam::rnd_pos(byte * buf, byte *pos) int ha_myisam::rnd_pos(byte * buf, byte *pos)
{ {
DBUG_ENTER("ha_myisam::rnd_pos");
statistic_increment(ha_read_rnd_count,&LOCK_status); statistic_increment(ha_read_rnd_count,&LOCK_status);
int error=mi_rrnd(file, buf, ha_get_ptr(pos,ref_length)); int error=mi_rrnd(file, buf, ha_get_ptr(pos,ref_length));
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
void ha_myisam::position(const byte* record) void ha_myisam::position(const byte* record)
{ {
my_off_t position=mi_position(file); my_off_t position=mi_position(file);
DBUG_ENTER("ha_myisam::position");
ha_store_ptr(ref, ref_length, position); ha_store_ptr(ref, ref_length, position);
DBUG_VOID_RETURN;
} }
void ha_myisam::info(uint flag) void ha_myisam::info(uint flag)
{ {
MI_ISAMINFO info; MI_ISAMINFO info;
char name_buff[FN_REFLEN]; char name_buff[FN_REFLEN];
DBUG_ENTER("ha_myisam::info");
(void) mi_status(file,&info,flag); (void) mi_status(file,&info,flag);
if (flag & HA_STATUS_VARIABLE) if (flag & HA_STATUS_VARIABLE)
...@@ -930,14 +992,17 @@ void ha_myisam::info(uint flag) ...@@ -930,14 +992,17 @@ void ha_myisam::info(uint flag)
update_time = info.update_time; update_time = info.update_time;
if (flag & HA_STATUS_AUTO) if (flag & HA_STATUS_AUTO)
auto_increment_value= info.auto_increment; auto_increment_value= info.auto_increment;
DBUG_VOID_RETURN;
} }
int ha_myisam::extra(enum ha_extra_function operation) int ha_myisam::extra(enum ha_extra_function operation)
{ {
DBUG_ENTER("ha_myisam::extra");
if ((specialflag & SPECIAL_SAFE_MODE) && operation == HA_EXTRA_KEYREAD) if ((specialflag & SPECIAL_SAFE_MODE) && operation == HA_EXTRA_KEYREAD)
return 0; DBUG_RETURN(0);
return mi_extra(file, operation, 0); DBUG_RETURN(mi_extra(file, operation, 0));
} }
...@@ -945,34 +1010,44 @@ int ha_myisam::extra(enum ha_extra_function operation) ...@@ -945,34 +1010,44 @@ int ha_myisam::extra(enum ha_extra_function operation)
int ha_myisam::extra_opt(enum ha_extra_function operation, ulong cache_size) int ha_myisam::extra_opt(enum ha_extra_function operation, ulong cache_size)
{ {
DBUG_ENTER("ha_myisam::extra_opt");
if ((specialflag & SPECIAL_SAFE_MODE) & if ((specialflag & SPECIAL_SAFE_MODE) &
(operation == HA_EXTRA_WRITE_CACHE || (operation == HA_EXTRA_WRITE_CACHE ||
operation == HA_EXTRA_BULK_INSERT_BEGIN)) operation == HA_EXTRA_BULK_INSERT_BEGIN))
return 0; DBUG_RETURN(0);
return mi_extra(file, operation, (void*) &cache_size); DBUG_RETURN(mi_extra(file, operation, (void*) &cache_size));
} }
int ha_myisam::reset(void) int ha_myisam::reset(void)
{ {
return mi_extra(file, HA_EXTRA_RESET, 0); DBUG_ENTER("ha_myisam::reset");
DBUG_RETURN(mi_extra(file, HA_EXTRA_RESET, 0));
} }
int ha_myisam::delete_all_rows() int ha_myisam::delete_all_rows()
{ {
return mi_delete_all_rows(file); DBUG_ENTER("ha_myisam::delete_all_rows");
DBUG_RETURN(mi_delete_all_rows(file));
} }
int ha_myisam::delete_table(const char *name) int ha_myisam::delete_table(const char *name)
{ {
return mi_delete_table(name); DBUG_ENTER("ha_myisam::delete_table");
DBUG_RETURN(mi_delete_table(name));
} }
int ha_myisam::external_lock(THD *thd, int lock_type) int ha_myisam::external_lock(THD *thd, int lock_type)
{ {
DBUG_ENTER("ha_myisam::external_lock");
if (!table->tmp_table) if (!table->tmp_table)
return mi_lock_database(file,lock_type); DBUG_RETURN(mi_lock_database(file,lock_type));
return 0; DBUG_RETURN(0);
} }
...@@ -980,14 +1055,18 @@ THR_LOCK_DATA **ha_myisam::store_lock(THD *thd, ...@@ -980,14 +1055,18 @@ THR_LOCK_DATA **ha_myisam::store_lock(THD *thd,
THR_LOCK_DATA **to, THR_LOCK_DATA **to,
enum thr_lock_type lock_type) enum thr_lock_type lock_type)
{ {
DBUG_ENTER("**ha_myisam::store_lock");
if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK) if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
file->lock.type=lock_type; file->lock.type=lock_type;
*to++= &file->lock; *to++= &file->lock;
return to; DBUG_RETURN(to);
} }
void ha_myisam::update_create_info(HA_CREATE_INFO *create_info) void ha_myisam::update_create_info(HA_CREATE_INFO *create_info)
{ {
DBUG_ENTER("ha_myisam::update_create_info");
table->file->info(HA_STATUS_AUTO | HA_STATUS_CONST); table->file->info(HA_STATUS_AUTO | HA_STATUS_CONST);
if (!(create_info->used_fields & HA_CREATE_USED_AUTO)) if (!(create_info->used_fields & HA_CREATE_USED_AUTO))
{ {
...@@ -1001,6 +1080,7 @@ void ha_myisam::update_create_info(HA_CREATE_INFO *create_info) ...@@ -1001,6 +1080,7 @@ void ha_myisam::update_create_info(HA_CREATE_INFO *create_info)
} }
create_info->data_file_name=data_file_name; create_info->data_file_name=data_file_name;
create_info->index_file_name=index_file_name; create_info->index_file_name=index_file_name;
DBUG_VOID_RETURN;
} }
...@@ -1196,16 +1276,20 @@ int ha_myisam::create(const char *name, register TABLE *table, ...@@ -1196,16 +1276,20 @@ int ha_myisam::create(const char *name, register TABLE *table,
int ha_myisam::rename_table(const char * from, const char * to) int ha_myisam::rename_table(const char * from, const char * to)
{ {
return mi_rename(from,to); DBUG_ENTER("ha_myisam::rename_table");
DBUG_RETURN(mi_rename(from,to));
} }
longlong ha_myisam::get_auto_increment() longlong ha_myisam::get_auto_increment()
{ {
DBUG_ENTER("ha_myisam::get_auto_increment");
if (!table->next_number_key_offset) if (!table->next_number_key_offset)
{ // Autoincrement at key-start { // Autoincrement at key-start
ha_myisam::info(HA_STATUS_AUTO); ha_myisam::info(HA_STATUS_AUTO);
return auto_increment_value; DBUG_RETURN(auto_increment_value);
} }
if (table->bulk_insert) if (table->bulk_insert)
...@@ -1226,7 +1310,7 @@ longlong ha_myisam::get_auto_increment() ...@@ -1226,7 +1310,7 @@ longlong ha_myisam::get_auto_increment()
nr=(longlong) nr=(longlong)
table->next_number_field->val_int_offset(table->rec_buff_length)+1; table->next_number_field->val_int_offset(table->rec_buff_length)+1;
extra(HA_EXTRA_NO_KEYREAD); extra(HA_EXTRA_NO_KEYREAD);
return nr; DBUG_RETURN(nr);
} }
...@@ -1236,25 +1320,28 @@ ha_rows ha_myisam::records_in_range(int inx, ...@@ -1236,25 +1320,28 @@ ha_rows ha_myisam::records_in_range(int inx,
const byte *end_key,uint end_key_len, const byte *end_key,uint end_key_len,
enum ha_rkey_function end_search_flag) enum ha_rkey_function end_search_flag)
{ {
return (ha_rows) mi_records_in_range(file, DBUG_ENTER("ha_myisam::records_in_range");
DBUG_RETURN((ha_rows) mi_records_in_range(file,
inx, inx,
start_key,start_key_len, start_key,start_key_len,
start_search_flag, start_search_flag,
end_key,end_key_len, end_key,end_key_len,
end_search_flag); end_search_flag));
} }
int ha_myisam::ft_read(byte * buf) int ha_myisam::ft_read(byte * buf)
{ {
int error; int error;
DBUG_ENTER("ha_myisam::ft_read");
if (!ft_handler) if (!ft_handler)
return -1; DBUG_RETURN(-1);
thread_safe_increment(ha_read_next_count,&LOCK_status); // why ? thread_safe_increment(ha_read_next_count,&LOCK_status); // why ?
error=ft_handler->please->read_next(ft_handler,(char*) buf); error=ft_handler->please->read_next(ft_handler,(char*) buf);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
sql/ha_myisammrg.cc
View file @ c0309e5a
...@@ -38,12 +38,14 @@ const char **ha_myisammrg::bas_ext() const ...@@ -38,12 +38,14 @@ const char **ha_myisammrg::bas_ext() const
int ha_myisammrg::open(const char *name, int mode, uint test_if_locked) int ha_myisammrg::open(const char *name, int mode, uint test_if_locked)
{ {
char name_buff[FN_REFLEN]; char name_buff[FN_REFLEN];
DBUG_ENTER("ha_myisammrg::open");
DBUG_PRINT("info", ("ha_myisammrg::open")); DBUG_PRINT("info", ("ha_myisammrg::open"));
if (!(file=myrg_open(fn_format(name_buff,name,"","",2 | 4), mode, if (!(file=myrg_open(fn_format(name_buff,name,"","",2 | 4), mode,
test_if_locked))) test_if_locked)))
{ {
DBUG_PRINT("info", ("ha_myisammrg::open exit %d", my_errno)); DBUG_PRINT("info", ("ha_myisammrg::open exit %d", my_errno));
return (my_errno ? my_errno : -1); DBUG_RETURN((my_errno ? my_errno : -1));
} }
DBUG_PRINT("info", ("ha_myisammrg::open myrg_extrafunc...")) DBUG_PRINT("info", ("ha_myisammrg::open myrg_extrafunc..."))
myrg_extrafunc(file, query_cache_invalidate_by_MyISAM_filename_ref); myrg_extrafunc(file, query_cache_invalidate_by_MyISAM_filename_ref);
...@@ -65,132 +67,165 @@ int ha_myisammrg::open(const char *name, int mode, uint test_if_locked) ...@@ -65,132 +67,165 @@ int ha_myisammrg::open(const char *name, int mode, uint test_if_locked)
if (table->crashed) if (table->crashed)
goto err; goto err;
#endif #endif
return (0); DBUG_RETURN((0));
err: err:
myrg_close(file); myrg_close(file);
file=0; file=0;
return (my_errno= HA_ERR_WRONG_TABLE_DEF); DBUG_RETURN((my_errno= HA_ERR_WRONG_TABLE_DEF));
} }
int ha_myisammrg::close(void) int ha_myisammrg::close(void)
{ {
return myrg_close(file); DBUG_ENTER("ha_myisammrg::close");
DBUG_RETURN(myrg_close(file));
} }
int ha_myisammrg::write_row(byte * buf) int ha_myisammrg::write_row(byte * buf)
{ {
DBUG_ENTER("ha_myisammrg::write_row");
statistic_increment(ha_write_count,&LOCK_status); statistic_increment(ha_write_count,&LOCK_status);
if (table->time_stamp) if (table->time_stamp)
update_timestamp(buf+table->time_stamp-1); update_timestamp(buf+table->time_stamp-1);
if (table->next_number_field && buf == table->record[0]) if (table->next_number_field && buf == table->record[0])
update_auto_increment(); update_auto_increment();
return myrg_write(file,buf); DBUG_RETURN(myrg_write(file,buf));
} }
int ha_myisammrg::update_row(const byte * old_data, byte * new_data) int ha_myisammrg::update_row(const byte * old_data, byte * new_data)
{ {
DBUG_ENTER("ha_myisammrg::update_row");
statistic_increment(ha_update_count,&LOCK_status); statistic_increment(ha_update_count,&LOCK_status);
if (table->time_stamp) if (table->time_stamp)
update_timestamp(new_data+table->time_stamp-1); update_timestamp(new_data+table->time_stamp-1);
return myrg_update(file,old_data,new_data); DBUG_RETURN(myrg_update(file,old_data,new_data));
} }
int ha_myisammrg::delete_row(const byte * buf) int ha_myisammrg::delete_row(const byte * buf)
{ {
DBUG_ENTER("ha_myisammrg::delete_row");
statistic_increment(ha_delete_count,&LOCK_status); statistic_increment(ha_delete_count,&LOCK_status);
return myrg_delete(file,buf); DBUG_RETURN(myrg_delete(file,buf));
} }
int ha_myisammrg::index_read(byte * buf, const byte * key, int ha_myisammrg::index_read(byte * buf, const byte * key,
uint key_len, enum ha_rkey_function find_flag) uint key_len, enum ha_rkey_function find_flag)
{ {
DBUG_ENTER("ha_myisammrg::index_read");
statistic_increment(ha_read_key_count,&LOCK_status); statistic_increment(ha_read_key_count,&LOCK_status);
int error=myrg_rkey(file,buf,active_index, key, key_len, find_flag); int error=myrg_rkey(file,buf,active_index, key, key_len, find_flag);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::index_read_idx(byte * buf, uint index, const byte * key, int ha_myisammrg::index_read_idx(byte * buf, uint index, const byte * key,
uint key_len, enum ha_rkey_function find_flag) uint key_len, enum ha_rkey_function find_flag)
{ {
DBUG_ENTER("ha_myisammrg::index_read_idx");
statistic_increment(ha_read_key_count,&LOCK_status); statistic_increment(ha_read_key_count,&LOCK_status);
int error=myrg_rkey(file,buf,index, key, key_len, find_flag); int error=myrg_rkey(file,buf,index, key, key_len, find_flag);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::index_read_last(byte * buf, const byte * key, uint key_len) int ha_myisammrg::index_read_last(byte * buf, const byte * key, uint key_len)
{ {
DBUG_ENTER("ha_myisammrg::index_read_last");
statistic_increment(ha_read_key_count,&LOCK_status); statistic_increment(ha_read_key_count,&LOCK_status);
int error=myrg_rkey(file,buf,active_index, key, key_len, int error=myrg_rkey(file,buf,active_index, key, key_len,
HA_READ_PREFIX_LAST); HA_READ_PREFIX_LAST);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::index_next(byte * buf) int ha_myisammrg::index_next(byte * buf)
{ {
DBUG_ENTER("ha_myisammrg::index_next");
statistic_increment(ha_read_next_count,&LOCK_status); statistic_increment(ha_read_next_count,&LOCK_status);
int error=myrg_rnext(file,buf,active_index); int error=myrg_rnext(file,buf,active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::index_prev(byte * buf) int ha_myisammrg::index_prev(byte * buf)
{ {
DBUG_ENTER("ha_myisammrg::index_prev");
statistic_increment(ha_read_prev_count,&LOCK_status); statistic_increment(ha_read_prev_count,&LOCK_status);
int error=myrg_rprev(file,buf, active_index); int error=myrg_rprev(file,buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::index_first(byte * buf) int ha_myisammrg::index_first(byte * buf)
{ {
DBUG_ENTER("ha_myisammrg::index_first");
statistic_increment(ha_read_first_count,&LOCK_status); statistic_increment(ha_read_first_count,&LOCK_status);
int error=myrg_rfirst(file, buf, active_index); int error=myrg_rfirst(file, buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::index_last(byte * buf) int ha_myisammrg::index_last(byte * buf)
{ {
DBUG_ENTER("ha_myisammrg::index_last");
statistic_increment(ha_read_last_count,&LOCK_status); statistic_increment(ha_read_last_count,&LOCK_status);
int error=myrg_rlast(file, buf, active_index); int error=myrg_rlast(file, buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::rnd_init(bool scan) int ha_myisammrg::rnd_init(bool scan)
{ {
return myrg_extra(file,HA_EXTRA_RESET,0); DBUG_ENTER("ha_myisammrg::rnd_init");
DBUG_RETURN(myrg_extra(file,HA_EXTRA_RESET,0));
} }
int ha_myisammrg::rnd_next(byte *buf) int ha_myisammrg::rnd_next(byte *buf)
{ {
DBUG_ENTER("ha_myisammrg::rnd_next");
statistic_increment(ha_read_rnd_next_count,&LOCK_status); statistic_increment(ha_read_rnd_next_count,&LOCK_status);
int error=myrg_rrnd(file, buf, HA_OFFSET_ERROR); int error=myrg_rrnd(file, buf, HA_OFFSET_ERROR);
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
int ha_myisammrg::rnd_pos(byte * buf, byte *pos) int ha_myisammrg::rnd_pos(byte * buf, byte *pos)
{ {
DBUG_ENTER("ha_myisammrg::rnd_pos");
statistic_increment(ha_read_rnd_count,&LOCK_status); statistic_increment(ha_read_rnd_count,&LOCK_status);
int error=myrg_rrnd(file, buf, ha_get_ptr(pos,ref_length)); int error=myrg_rrnd(file, buf, ha_get_ptr(pos,ref_length));
table->status=error ? STATUS_NOT_FOUND: 0; table->status=error ? STATUS_NOT_FOUND: 0;
return error; DBUG_RETURN(error);
} }
void ha_myisammrg::position(const byte *record) void ha_myisammrg::position(const byte *record)
{ {
ulonglong position= myrg_position(file); ulonglong position= myrg_position(file);
DBUG_ENTER("ha_myisammrg::position");
ha_store_ptr(ref, ref_length, (my_off_t) position); ha_store_ptr(ref, ref_length, (my_off_t) position);
DBUG_VOID_RETURN;
} }
void ha_myisammrg::info(uint flag) void ha_myisammrg::info(uint flag)
{ {
MYMERGE_INFO info; MYMERGE_INFO info;
DBUG_ENTER("ha_myisammrg::info");
(void) myrg_status(file,&info,flag); (void) myrg_status(file,&info,flag);
/* /*
The following fails if one has not compiled MySQL with -DBIG_TABLES The following fails if one has not compiled MySQL with -DBIG_TABLES
...@@ -216,17 +251,20 @@ void ha_myisammrg::info(uint flag) ...@@ -216,17 +251,20 @@ void ha_myisammrg::info(uint flag)
#else #else
ref_length=4; // Can't be > than my_off_t ref_length=4; // Can't be > than my_off_t
#endif #endif
DBUG_VOID_RETURN;
} }
int ha_myisammrg::extra(enum ha_extra_function operation) int ha_myisammrg::extra(enum ha_extra_function operation)
{ {
DBUG_ENTER("ha_myisammrg::extra");
/* As this is just a mapping, we don't have to force the underlying /* As this is just a mapping, we don't have to force the underlying
tables to be closed */ tables to be closed */
if (operation == HA_EXTRA_FORCE_REOPEN || if (operation == HA_EXTRA_FORCE_REOPEN ||
operation == HA_EXTRA_PREPARE_FOR_DELETE) operation == HA_EXTRA_PREPARE_FOR_DELETE)
return 0; DBUG_RETURN(0);
return myrg_extra(file,operation,0); DBUG_RETURN(myrg_extra(file,operation,0));
} }
...@@ -234,27 +272,35 @@ int ha_myisammrg::extra(enum ha_extra_function operation) ...@@ -234,27 +272,35 @@ int ha_myisammrg::extra(enum ha_extra_function operation)
int ha_myisammrg::extra_opt(enum ha_extra_function operation, ulong cache_size) int ha_myisammrg::extra_opt(enum ha_extra_function operation, ulong cache_size)
{ {
DBUG_ENTER("ha_myisammrg::extra_opt");
if ((specialflag & SPECIAL_SAFE_MODE) & if ((specialflag & SPECIAL_SAFE_MODE) &
(operation == HA_EXTRA_WRITE_CACHE || (operation == HA_EXTRA_WRITE_CACHE ||
operation == HA_EXTRA_BULK_INSERT_BEGIN)) operation == HA_EXTRA_BULK_INSERT_BEGIN))
return 0; DBUG_RETURN(0);
return myrg_extra(file, operation, (void*) &cache_size); DBUG_RETURN(myrg_extra(file, operation, (void*) &cache_size));
} }
int ha_myisammrg::reset(void) int ha_myisammrg::reset(void)
{ {
return myrg_extra(file,HA_EXTRA_RESET,0); DBUG_ENTER("ha_myisammrg::reset");
DBUG_RETURN(myrg_extra(file,HA_EXTRA_RESET,0));
} }
int ha_myisammrg::external_lock(THD *thd, int lock_type) int ha_myisammrg::external_lock(THD *thd, int lock_type)
{ {
return myrg_lock_database(file,lock_type); DBUG_ENTER("ha_myisammrg::external_lock");
DBUG_RETURN(myrg_lock_database(file,lock_type));
} }
uint ha_myisammrg::lock_count(void) const uint ha_myisammrg::lock_count(void) const
{ {
return file->tables; DBUG_ENTER("ha_myisammrg::lock_count");
DBUG_RETURN(file->tables);
} }
...@@ -263,6 +309,7 @@ THR_LOCK_DATA **ha_myisammrg::store_lock(THD *thd, ...@@ -263,6 +309,7 @@ THR_LOCK_DATA **ha_myisammrg::store_lock(THD *thd,
enum thr_lock_type lock_type) enum thr_lock_type lock_type)
{ {
MYRG_TABLE *table; MYRG_TABLE *table;
DBUG_ENTER("**ha_myisammrg::store_lock");
for (table=file->open_tables ; table != file->end_table ; table++) for (table=file->open_tables ; table != file->end_table ; table++)
{ {
...@@ -270,13 +317,14 @@ THR_LOCK_DATA **ha_myisammrg::store_lock(THD *thd, ...@@ -270,13 +317,14 @@ THR_LOCK_DATA **ha_myisammrg::store_lock(THD *thd,
if (lock_type != TL_IGNORE && table->table->lock.type == TL_UNLOCK) if (lock_type != TL_IGNORE && table->table->lock.type == TL_UNLOCK)
table->table->lock.type=lock_type; table->table->lock.type=lock_type;
} }
return to; DBUG_RETURN(to);
} }
void ha_myisammrg::update_create_info(HA_CREATE_INFO *create_info) void ha_myisammrg::update_create_info(HA_CREATE_INFO *create_info)
{ {
// [phi] auto_increment stuff is missing (but currently not needed)
DBUG_ENTER("ha_myisammrg::update_create_info"); DBUG_ENTER("ha_myisammrg::update_create_info");
// [phi] auto_increment stuff is missing (but currently not needed)
if (!(create_info->used_fields & HA_CREATE_USED_UNION)) if (!(create_info->used_fields & HA_CREATE_USED_UNION))
{ {
MYRG_TABLE *table; MYRG_TABLE *table;
...@@ -334,6 +382,8 @@ int ha_myisammrg::create(const char *name, register TABLE *form, ...@@ -334,6 +382,8 @@ int ha_myisammrg::create(const char *name, register TABLE *form,
void ha_myisammrg::append_create_info(String *packet) void ha_myisammrg::append_create_info(String *packet)
{ {
char buff[FN_REFLEN]; char buff[FN_REFLEN];
DBUG_ENTER("ha_myisammrg::append_create_info");
if (file->merge_insert_method != MERGE_INSERT_DISABLED) if (file->merge_insert_method != MERGE_INSERT_DISABLED)
{ {
packet->append(" INSERT_METHOD=",15); packet->append(" INSERT_METHOD=",15);
...@@ -351,4 +401,5 @@ void ha_myisammrg::append_create_info(String *packet) ...@@ -351,4 +401,5 @@ void ha_myisammrg::append_create_info(String *packet)
packet->append(buff,(uint) strlen(buff)); packet->append(buff,(uint) strlen(buff));
} }
packet->append(')'); packet->append(')');
DBUG_VOID_RETURN;
} }
sql/handler.cc
View file @ c0309e5a
...@@ -72,14 +72,16 @@ TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"", ...@@ -72,14 +72,16 @@ TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
enum db_type ha_checktype(enum db_type database_type) enum db_type ha_checktype(enum db_type database_type)
{ {
DBUG_ENTER("ha_checktype");
switch (database_type) { switch (database_type) {
#ifdef HAVE_BERKELEY_DB #ifdef HAVE_BERKELEY_DB
case DB_TYPE_BERKELEY_DB: case DB_TYPE_BERKELEY_DB:
return(berkeley_skip ? DB_TYPE_MYISAM : database_type); DBUG_RETURN((berkeley_skip ? DB_TYPE_MYISAM : database_type));
#endif #endif
#ifdef HAVE_INNOBASE_DB #ifdef HAVE_INNOBASE_DB
case DB_TYPE_INNODB: case DB_TYPE_INNODB:
return(innodb_skip ? DB_TYPE_MYISAM : database_type); DBUG_RETURN((innodb_skip ? DB_TYPE_MYISAM : database_type));
#endif #endif
#ifndef NO_HASH #ifndef NO_HASH
case DB_TYPE_HASH: case DB_TYPE_HASH:
...@@ -91,52 +93,57 @@ enum db_type ha_checktype(enum db_type database_type) ...@@ -91,52 +93,57 @@ enum db_type ha_checktype(enum db_type database_type)
case DB_TYPE_HEAP: case DB_TYPE_HEAP:
case DB_TYPE_MYISAM: case DB_TYPE_MYISAM:
case DB_TYPE_MRG_MYISAM: case DB_TYPE_MRG_MYISAM:
return (database_type); /* Database exists on system */ DBUG_RETURN((database_type)); /* Database exists on system */
default: default:
break; break;
} }
return(DB_TYPE_MYISAM); /* Use this as default */ DBUG_RETURN((DB_TYPE_MYISAM)); /* Use this as default */
} /* ha_checktype */ } /* ha_checktype */
handler *get_new_handler(TABLE *table, enum db_type db_type) handler *get_new_handler(TABLE *table, enum db_type db_type)
{ {
DBUG_ENTER("*get_new_handler");
switch (db_type) { switch (db_type) {
#ifndef NO_HASH #ifndef NO_HASH
return new ha_hash(table); DBUG_RETURN(new ha_hash(table));
#endif #endif
#ifdef HAVE_ISAM #ifdef HAVE_ISAM
case DB_TYPE_MRG_ISAM: case DB_TYPE_MRG_ISAM:
return new ha_isammrg(table); DBUG_RETURN(new ha_isammrg(table));
case DB_TYPE_ISAM: case DB_TYPE_ISAM:
return new ha_isam(table); DBUG_RETURN(new ha_isam(table));
#endif #endif
#ifdef HAVE_BERKELEY_DB #ifdef HAVE_BERKELEY_DB
case DB_TYPE_BERKELEY_DB: case DB_TYPE_BERKELEY_DB:
return new ha_berkeley(table); DBUG_RETURN(new ha_berkeley(table));
#endif #endif
#ifdef HAVE_INNOBASE_DB #ifdef HAVE_INNOBASE_DB
case DB_TYPE_INNODB: case DB_TYPE_INNODB:
return new ha_innobase(table); DBUG_RETURN(new ha_innobase(table));
#endif #endif
case DB_TYPE_HEAP: case DB_TYPE_HEAP:
return new ha_heap(table); DBUG_RETURN(new ha_heap(table));
case DB_TYPE_MYISAM: case DB_TYPE_MYISAM:
default: // should never happen default: // should never happen
return new ha_myisam(table); DBUG_RETURN(new ha_myisam(table));
case DB_TYPE_MRG_MYISAM: case DB_TYPE_MRG_MYISAM:
return new ha_myisammrg(table); DBUG_RETURN(new ha_myisammrg(table));
} }
DBUG_RETURN(NULL); // impossible
} }
int ha_init() int ha_init()
{ {
DBUG_ENTER("ha_init");
#ifdef HAVE_BERKELEY_DB #ifdef HAVE_BERKELEY_DB
if (!berkeley_skip) if (!berkeley_skip)
{ {
int error; int error;
if ((error=berkeley_init())) if ((error=berkeley_init()))
return error; DBUG_RETURN(error);
if (!berkeley_skip) // If we couldn't use handler if (!berkeley_skip) // If we couldn't use handler
opt_using_transactions=1; opt_using_transactions=1;
else else
...@@ -147,14 +154,14 @@ int ha_init() ...@@ -147,14 +154,14 @@ int ha_init()
if (!innodb_skip) if (!innodb_skip)
{ {
if (innobase_init()) if (innobase_init())
return -1; DBUG_RETURN(-1);
if (!innodb_skip) // If we couldn't use handler if (!innodb_skip) // If we couldn't use handler
opt_using_transactions=1; opt_using_transactions=1;
else else
have_innodb=SHOW_OPTION_DISABLED; have_innodb=SHOW_OPTION_DISABLED;
} }
#endif #endif
return 0; DBUG_RETURN(0);
} }
/* close, flush or restart databases */ /* close, flush or restart databases */
...@@ -163,6 +170,8 @@ int ha_init() ...@@ -163,6 +170,8 @@ int ha_init()
int ha_panic(enum ha_panic_function flag) int ha_panic(enum ha_panic_function flag)
{ {
int error=0; int error=0;
DBUG_ENTER("ha_panic");
#ifndef NO_HASH #ifndef NO_HASH
error|=h_panic(flag); /* fix hash */ error|=h_panic(flag); /* fix hash */
#endif #endif
...@@ -181,23 +190,29 @@ int ha_panic(enum ha_panic_function flag) ...@@ -181,23 +190,29 @@ int ha_panic(enum ha_panic_function flag)
if (!innodb_skip) if (!innodb_skip)
error|=innobase_end(); error|=innobase_end();
#endif #endif
return error; DBUG_RETURN(error);
} /* ha_panic */ } /* ha_panic */
void ha_drop_database(char* path) void ha_drop_database(char* path)
{ {
DBUG_ENTER("ha_drop_database");
#ifdef HAVE_INNOBASE_DB #ifdef HAVE_INNOBASE_DB
if (!innodb_skip) if (!innodb_skip)
innobase_drop_database(path); innobase_drop_database(path);
#endif #endif
DBUG_VOID_RETURN;
} }
void ha_close_connection(THD* thd) void ha_close_connection(THD* thd)
{ {
DBUG_ENTER("ha_close_connection");
#ifdef HAVE_INNOBASE_DB #ifdef HAVE_INNOBASE_DB
if (!innodb_skip) if (!innodb_skip)
innobase_close_connection(thd); innobase_close_connection(thd);
#endif #endif
DBUG_VOID_RETURN;
} }
/* /*
...@@ -247,6 +262,8 @@ int ha_report_binlog_offset_and_commit(THD *thd, ...@@ -247,6 +262,8 @@ int ha_report_binlog_offset_and_commit(THD *thd,
my_off_t end_offset) my_off_t end_offset)
{ {
int error= 0; int error= 0;
DBUG_ENTER("ha_report_binlog_offset_and_commit");
#ifdef HAVE_INNOBASE_DB #ifdef HAVE_INNOBASE_DB
THD_TRANS *trans; THD_TRANS *trans;
trans = &thd->transaction.all; trans = &thd->transaction.all;
...@@ -263,7 +280,7 @@ int ha_report_binlog_offset_and_commit(THD *thd, ...@@ -263,7 +280,7 @@ int ha_report_binlog_offset_and_commit(THD *thd,
trans->innodb_active_trans=0; trans->innodb_active_trans=0;
} }
#endif #endif
return error; DBUG_RETURN(error);
} }
int ha_commit_trans(THD *thd, THD_TRANS* trans) int ha_commit_trans(THD *thd, THD_TRANS* trans)
...@@ -380,6 +397,8 @@ int ha_rollback_trans(THD *thd, THD_TRANS *trans) ...@@ -380,6 +397,8 @@ int ha_rollback_trans(THD *thd, THD_TRANS *trans)
bool ha_flush_logs() bool ha_flush_logs()
{ {
bool result=0; bool result=0;
DBUG_ENTER("ha_flush_logs");
#ifdef HAVE_BERKELEY_DB #ifdef HAVE_BERKELEY_DB
if (!berkeley_skip && berkeley_flush_logs()) if (!berkeley_skip && berkeley_flush_logs())
result=1; result=1;
...@@ -388,7 +407,7 @@ bool ha_flush_logs() ...@@ -388,7 +407,7 @@ bool ha_flush_logs()
if (!innodb_skip && innobase_flush_logs()) if (!innodb_skip && innobase_flush_logs())
result=1; result=1;
#endif #endif
return result; DBUG_RETURN(result);
} }
/* /*
...@@ -399,15 +418,19 @@ bool ha_flush_logs() ...@@ -399,15 +418,19 @@ bool ha_flush_logs()
int ha_delete_table(enum db_type table_type, const char *path) int ha_delete_table(enum db_type table_type, const char *path)
{ {
handler *file=get_new_handler((TABLE*) 0, table_type); handler *file=get_new_handler((TABLE*) 0, table_type);
DBUG_ENTER("ha_delete_table");
if (!file) if (!file)
return ENOENT; DBUG_RETURN(ENOENT);
int error=file->delete_table(path); int error=file->delete_table(path);
delete file; delete file;
return error; DBUG_RETURN(error);
} }
void ha_store_ptr(byte *buff, uint pack_length, my_off_t pos) void ha_store_ptr(byte *buff, uint pack_length, my_off_t pos)
{ {
DBUG_ENTER("ha_store_ptr");
switch (pack_length) { switch (pack_length) {
#if SIZEOF_OFF_T > 4 #if SIZEOF_OFF_T > 4
case 8: mi_int8store(buff,pos); break; case 8: mi_int8store(buff,pos); break;
...@@ -420,12 +443,14 @@ void ha_store_ptr(byte *buff, uint pack_length, my_off_t pos) ...@@ -420,12 +443,14 @@ void ha_store_ptr(byte *buff, uint pack_length, my_off_t pos)
case 2: mi_int2store(buff,(uint) pos); break; case 2: mi_int2store(buff,(uint) pos); break;
case 1: buff[0]= (uchar) pos; break; case 1: buff[0]= (uchar) pos; break;
} }
return; DBUG_VOID_RETURN;
} }
my_off_t ha_get_ptr(byte *ptr, uint pack_length) my_off_t ha_get_ptr(byte *ptr, uint pack_length)
{ {
my_off_t pos; my_off_t pos;
DBUG_ENTER("ha_get_ptr");
switch (pack_length) { switch (pack_length) {
#if SIZEOF_OFF_T > 4 #if SIZEOF_OFF_T > 4
case 8: case 8:
...@@ -457,7 +482,7 @@ my_off_t ha_get_ptr(byte *ptr, uint pack_length) ...@@ -457,7 +482,7 @@ my_off_t ha_get_ptr(byte *ptr, uint pack_length)
pos=0; // Impossible pos=0; // Impossible
break; break;
} }
return pos; DBUG_RETURN(pos);
} }
/**************************************************************************** /****************************************************************************
...@@ -511,32 +536,44 @@ int handler::ha_open(const char *name, int mode, int test_if_locked) ...@@ -511,32 +536,44 @@ int handler::ha_open(const char *name, int mode, int test_if_locked)
int handler::check(THD* thd, HA_CHECK_OPT* check_opt) int handler::check(THD* thd, HA_CHECK_OPT* check_opt)
{ {
return HA_ADMIN_NOT_IMPLEMENTED; DBUG_ENTER("handler::check");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
} }
int handler::backup(THD* thd, HA_CHECK_OPT* check_opt) int handler::backup(THD* thd, HA_CHECK_OPT* check_opt)
{ {
return HA_ADMIN_NOT_IMPLEMENTED; DBUG_ENTER("handler::backup");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
} }
int handler::restore(THD* thd, HA_CHECK_OPT* check_opt) int handler::restore(THD* thd, HA_CHECK_OPT* check_opt)
{ {
return HA_ADMIN_NOT_IMPLEMENTED; DBUG_ENTER("handler::restore");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
} }
int handler::repair(THD* thd, HA_CHECK_OPT* check_opt) int handler::repair(THD* thd, HA_CHECK_OPT* check_opt)
{ {
return HA_ADMIN_NOT_IMPLEMENTED; DBUG_ENTER("handler::repair");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
} }
int handler::optimize(THD* thd, HA_CHECK_OPT* check_opt) int handler::optimize(THD* thd, HA_CHECK_OPT* check_opt)
{ {
return HA_ADMIN_NOT_IMPLEMENTED; DBUG_ENTER("handler::optimize");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
} }
int handler::analyze(THD* thd, HA_CHECK_OPT* check_opt) int handler::analyze(THD* thd, HA_CHECK_OPT* check_opt)
{ {
return HA_ADMIN_NOT_IMPLEMENTED; DBUG_ENTER("handler::analyze");
DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
} }
/* /*
...@@ -581,7 +618,9 @@ int handler::read_first_row(byte * buf, uint primary_key) ...@@ -581,7 +618,9 @@ int handler::read_first_row(byte * buf, uint primary_key)
int handler::restart_rnd_next(byte *buf, byte *pos) int handler::restart_rnd_next(byte *buf, byte *pos)
{ {
return HA_ERR_WRONG_COMMAND; DBUG_ENTER("handler::restart_rnd_next");
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
} }
...@@ -590,6 +629,8 @@ int handler::restart_rnd_next(byte *buf, byte *pos) ...@@ -590,6 +629,8 @@ int handler::restart_rnd_next(byte *buf, byte *pos)
void handler::update_timestamp(byte *record) void handler::update_timestamp(byte *record)
{ {
long skr= (long) current_thd->query_start(); long skr= (long) current_thd->query_start();
DBUG_ENTER("handler::update_timestamp");
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
if (table->db_low_byte_first) if (table->db_low_byte_first)
{ {
...@@ -598,7 +639,7 @@ void handler::update_timestamp(byte *record) ...@@ -598,7 +639,7 @@ void handler::update_timestamp(byte *record)
else else
#endif #endif
longstore(record,skr); longstore(record,skr);
return; DBUG_VOID_RETURN;
} }
/* /*
...@@ -632,6 +673,7 @@ longlong handler::get_auto_increment() ...@@ -632,6 +673,7 @@ longlong handler::get_auto_increment()
{ {
longlong nr; longlong nr;
int error; int error;
DBUG_ENTER("handler::get_auto_increment");
(void) extra(HA_EXTRA_KEYREAD); (void) extra(HA_EXTRA_KEYREAD);
index_init(table->next_number_index); index_init(table->next_number_index);
...@@ -655,7 +697,7 @@ longlong handler::get_auto_increment() ...@@ -655,7 +697,7 @@ longlong handler::get_auto_increment()
val_int_offset(table->rec_buff_length)+1; val_int_offset(table->rec_buff_length)+1;
index_end(); index_end();
(void) extra(HA_EXTRA_NO_KEYREAD); (void) extra(HA_EXTRA_NO_KEYREAD);
return nr; DBUG_RETURN(nr);
} }
/* Print error that we got from handler function */ /* Print error that we got from handler function */
...@@ -777,6 +819,8 @@ uint handler::get_dup_key(int error) ...@@ -777,6 +819,8 @@ uint handler::get_dup_key(int error)
int handler::delete_table(const char *name) int handler::delete_table(const char *name)
{ {
int error=0; int error=0;
DBUG_ENTER("handler::delete_table");
for (const char **ext=bas_ext(); *ext ; ext++) for (const char **ext=bas_ext(); *ext ; ext++)
{ {
if (delete_file(name,*ext,2)) if (delete_file(name,*ext,2))
...@@ -785,7 +829,7 @@ int handler::delete_table(const char *name) ...@@ -785,7 +829,7 @@ int handler::delete_table(const char *name)
break; break;
} }
} }
return error; DBUG_RETURN(error);
} }
...@@ -806,14 +850,16 @@ int handler::rename_table(const char * from, const char * to) ...@@ -806,14 +850,16 @@ int handler::rename_table(const char * from, const char * to)
int ha_recovery_logging(THD *thd, bool on) int ha_recovery_logging(THD *thd, bool on)
{ {
int error=0; int error=0;
DBUG_ENTER("ha_recovery_logging"); DBUG_ENTER("ha_recovery_logging");
DBUG_RETURN(error); DBUG_RETURN(error);
} }
int handler::index_next_same(byte *buf, const byte *key, uint keylen) int handler::index_next_same(byte *buf, const byte *key, uint keylen)
{ {
int error; int error;
DBUG_ENTER("handler::index_next_same");
if (!(error=index_next(buf))) if (!(error=index_next(buf)))
{ {
if (key_cmp(table, key, active_index, keylen)) if (key_cmp(table, key, active_index, keylen))
...@@ -822,7 +868,7 @@ int handler::index_next_same(byte *buf, const byte *key, uint keylen) ...@@ -822,7 +868,7 @@ int handler::index_next_same(byte *buf, const byte *key, uint keylen)
error=HA_ERR_END_OF_FILE; error=HA_ERR_END_OF_FILE;
} }
} }
return error; DBUG_RETURN(error);
} }
...@@ -835,7 +881,9 @@ int handler::index_next_same(byte *buf, const byte *key, uint keylen) ...@@ -835,7 +881,9 @@ int handler::index_next_same(byte *buf, const byte *key, uint keylen)
int handler::delete_all_rows() int handler::delete_all_rows()
{ {
return (my_errno=HA_ERR_WRONG_COMMAND); DBUG_ENTER("handler::delete_all_rows");
DBUG_RETURN((my_errno=HA_ERR_WRONG_COMMAND));
} }
/**************************************************************************** /****************************************************************************
...@@ -881,26 +929,37 @@ int ha_create_table(const char *name, HA_CREATE_INFO *create_info, ...@@ -881,26 +929,37 @@ int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
void ha_key_cache(void) void ha_key_cache(void)
{ {
DBUG_ENTER("ha_key_cache");
if (keybuff_size) if (keybuff_size)
(void) init_key_cache(keybuff_size); (void) init_key_cache(keybuff_size);
DBUG_VOID_RETURN;
} }
void ha_resize_key_cache(void) void ha_resize_key_cache(void)
{ {
DBUG_ENTER("ha_resize_key_cache");
(void) resize_key_cache(keybuff_size); (void) resize_key_cache(keybuff_size);
DBUG_VOID_RETURN;
} }
static int NEAR_F delete_file(const char *name,const char *ext,int extflag) static int NEAR_F delete_file(const char *name,const char *ext,int extflag)
{ {
char buff[FN_REFLEN]; char buff[FN_REFLEN];
DBUG_ENTER("delete_file");
VOID(fn_format(buff,name,"",ext,extflag | 4)); VOID(fn_format(buff,name,"",ext,extflag | 4));
return(my_delete_with_symlink(buff,MYF(MY_WME))); DBUG_RETURN((my_delete_with_symlink(buff,MYF(MY_WME))));
} }
void st_ha_check_opt::init() void st_ha_check_opt::init()
{ {
DBUG_ENTER("st_ha_check_opt::init");
flags= sql_flags= 0; flags= sql_flags= 0;
sort_buffer_size = current_thd->variables.myisam_sort_buff_size; sort_buffer_size = current_thd->variables.myisam_sort_buff_size;
DBUG_VOID_RETURN;
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7