added DBUG_ENTER/RETURN tags, dbug_add_tags.pl bugfix (6f963dad) · Commits · Software / OSDI20 Artifacts / mariadb

dbug/dbug_add_tags.pl

+1 −2

Original line number	Diff line number	Diff line
		@@ -5,7 +5,7 @@ die "No files specified\n" unless $ARGV[0];
		$ctags="exctags -x -f - --c-types=f -u";

		sub get_tag {
		local $_=<TAGS>;
		local $.; local $_=<TAGS>;
		($symbol, $line)= /^(.*\S)\s+function\s+(\d+)/;
		$symbol=$1 if /\s(\S+)\s*\(/;
		$line=1e50 unless $line;
		@@ -40,7 +40,6 @@ while($src=shift)
		warn "$src:".($.-1)."\t$orig" if /\breturn\b/;
		}
		print;
		next if /DBUG_ENTER/;
		next if $. < $line;
		die "Something wrong: \$.=$., \$line=$line, \$symbol=$symbol\n" if $. > $line;
		&get_tag && next if /^\s*inline /;

sql/ha_myisam.cc

+166 −79

Original line number	Diff line number	Diff line
		@@ -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,
		const char *fmt, va_list args)
		{
		DBUG_ENTER("mi_check_print_msg");

		THD* thd = (THD*)param->thd;
		String* packet = &thd->packet;
		uint length;
		@@ -64,12 +66,12 @@ static void mi_check_print_msg(MI_CHECK param, const char msg_type,
		if (thd->net.vio == 0)
		{
		sql_print_error(msgbuf);
		return;
		DBUG_VOID_RETURN;
		}
		if (param->testflag & (T_CREATE_MISSING_KEYS \| T_SAFE_REPAIR \| T_AUTO_REPAIR))
		{
		my_message(ER_NOT_KEYFILE,msgbuf,MYF(MY_WME));
		return;
		DBUG_VOID_RETURN;
		}
		length=(uint) (strxmov(name, param->db_name,".",param->table_name,NullS) -
		name);
		@@ -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()))
		sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n",
		msgbuf);
		return;
		DBUG_VOID_RETURN;
		}

		extern "C" {

		void mi_check_print_error(MI_CHECK param, const char fmt,...)
		{
		DBUG_ENTER("mi_check_print_error");

		param->error_printed\|=1;
		param->out_flag\|= O_DATA_LOST;
		va_list args;
		va_start(args, fmt);
		mi_check_print_msg(param, "error", fmt, args);
		va_end(args);
		DBUG_VOID_RETURN;
		}

		void mi_check_print_info(MI_CHECK param, const char fmt,...)
		{
		va_list args;
		DBUG_ENTER("mi_check_print_info");

		va_start(args, fmt);
		mi_check_print_msg(param, "info", fmt, args);
		va_end(args);
		DBUG_VOID_RETURN;
		}

		void mi_check_print_warning(MI_CHECK param, const char fmt,...)
		{
		DBUG_ENTER("mi_check_print_warning");

		param->warning_printed=1;
		param->out_flag\|= O_DATA_LOST;
		va_list args;
		va_start(args, fmt);
		mi_check_print_msg(param, "warning", fmt, args);
		va_end(args);
		DBUG_VOID_RETURN;
		}

		}
		@@ -122,15 +133,18 @@ const char **ha_myisam::bas_ext() const

		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" :
		"BTREE");
		"BTREE"));
		}

		int ha_myisam::net_read_dump(NET* net)
		{
		int data_fd = file->dfile;
		int error = 0;
		DBUG_ENTER("ha_myisam::net_read_dump");

		my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
		for (;;)
		@@ -153,12 +167,14 @@ int ha_myisam::net_read_dump(NET* net)
		}

		err:
		return error;
		DBUG_RETURN(error);
		}


		int ha_myisam::dump(THD* thd, int fd)
		{
		DBUG_ENTER("ha_myisam::dump");

		MYISAM_SHARE* share = file->s;
		NET* net = &thd->net;
		uint blocksize = share->blocksize;
		@@ -166,7 +182,7 @@ int ha_myisam::dump(THD* thd, int fd)
		int data_fd = file->dfile;
		byte * buf = (byte*) my_malloc(blocksize, MYF(MY_WME));
		if (!buf)
		return ENOMEM;
		DBUG_RETURN(ENOMEM);

		int error = 0;
		my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
		@@ -206,15 +222,17 @@ int ha_myisam::dump(THD* thd, int fd)

		err:
		my_free((gptr) buf, MYF(0));
		return error;
		DBUG_RETURN(error);
		}

		/* Name is here without an extension */

		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)))
		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))
		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)
		VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0));
		if (!table->db_record_offset)
		int_table_flags\|=HA_REC_NOT_IN_SEQ;
		return (0);
		DBUG_RETURN((0));
		}

		int ha_myisam::close(void)
		{
		MI_INFO *tmp=file;
		DBUG_ENTER("ha_myisam::close");

		file=0;
		return mi_close(tmp);
		DBUG_RETURN(mi_close(tmp));
		}

		int ha_myisam::write_row(byte * buf)
		{
		DBUG_ENTER("ha_myisam::write_row");

		statistic_increment(ha_write_count,&LOCK_status);

		/* If we have a timestamp column, update it to the current time */
		@@ -248,12 +270,14 @@ int ha_myisam::write_row(byte * buf)
		*/
		if (table->next_number_field && buf == table->record[0])
		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)
		{
		if (!file) return HA_ADMIN_INTERNAL_ERROR;
		DBUG_ENTER("ha_myisam::check");

		if (!file) DBUG_RETURN(HA_ADMIN_INTERNAL_ERROR);
		int error;
		MI_CHECK param;
		MYISAM_SHARE* share = file->s;
		@@ -278,7 +302,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)
		share->state.open_count == 0) \|\|
		((param.testflag & T_FAST) && (share->state.open_count ==
		(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_size(&param, file);
		@@ -331,7 +355,7 @@ int ha_myisam::check(THD* thd, HA_CHECK_OPT* check_opt)
		}

		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)
		{
		int error=0;
		MI_CHECK param;
		DBUG_ENTER("ha_myisam::analyze");

		MYISAM_SHARE* share = file->s;

		myisamchk_init(&param);
		@@ -357,7 +383,7 @@ int ha_myisam::analyze(THD thd, HA_CHECK_OPT check_opt)
		param.using_global_keycache = 1;

		if (!(share->state.changed & STATE_NOT_ANALYZED))
		return HA_ADMIN_ALREADY_DONE;
		DBUG_RETURN(HA_ADMIN_ALREADY_DONE);

		error = chk_key(&param, file);
		if (!error)
		@@ -368,7 +394,7 @@ int ha_myisam::analyze(THD thd, HA_CHECK_OPT check_opt)
		}
		else if (!mi_is_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)
		char* table_name = table->real_name;
		int error;
		const char* errmsg;
		DBUG_ENTER("restore");
		DBUG_ENTER("ha_myisam::restore");

		if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
		MI_NAME_DEXT))
		@@ -399,7 +425,6 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
		DBUG_RETURN(repair(thd, &tmp_check_opt));

		err:
		{
		MI_CHECK param;
		myisamchk_init(&param);
		param.thd = thd;
		@@ -410,7 +435,6 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
		mi_check_print_error(&param,errmsg, my_errno);
		DBUG_RETURN(error);
		}
		}


		int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
		@@ -460,7 +484,6 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
		DBUG_RETURN(HA_ADMIN_OK);

		err:
		{
		MI_CHECK param;
		myisamchk_init(&param);
		param.thd = thd;
		@@ -471,7 +494,6 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
		mi_check_print_error(&param,errmsg, my_errno);
		DBUG_RETURN(error);
		}
		}


		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;
		MI_CHECK param;
		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);
		param.thd = thd;
		@@ -520,12 +543,14 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt)
		llstr(start_records, llbuff2),
		table->path);
		}
		return error;
		DBUG_RETURN(error);
		}

		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;

		myisamchk_init(&param);
		@@ -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 \|
		T_REP_BY_SORT \| T_STATISTICS \| T_SORT_INDEX);
		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)

		void ha_myisam::deactivate_non_unique_index(ha_rows rows)
		{
		DBUG_ENTER("ha_myisam::deactivate_non_unique_index");

		MYISAM_SHARE* share = file->s;
		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)
		}
		else
		enable_activate_all_index=0;
		DBUG_VOID_RETURN;
		}


		@@ -698,7 +726,7 @@ bool ha_myisam::activate_all_index(THD *thd)
		int error=0;
		MI_CHECK param;
		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);
		table->bulk_insert= 0;
		@@ -752,131 +780,165 @@ bool ha_myisam::check_and_repair(THD *thd)

		bool ha_myisam::is_crashed() const
		{
		return (file->s->state.changed & STATE_CRASHED \|\|
		(my_disable_locking && file->s->state.open_count));
		DBUG_ENTER("ha_myisam::is_crashed");

		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)
		{
		DBUG_ENTER("ha_myisam::update_row");

		statistic_increment(ha_update_count,&LOCK_status);
		if (table->time_stamp)
		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)
		{
		DBUG_ENTER("ha_myisam::delete_row");

		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,
		uint key_len, enum ha_rkey_function find_flag)
		{
		DBUG_ENTER("ha_myisam::index_read");

		statistic_increment(ha_read_key_count,&LOCK_status);
		int error=mi_rkey(file,buf,active_index, key, key_len, find_flag);
		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,
		uint key_len, enum ha_rkey_function find_flag)
		{
		DBUG_ENTER("ha_myisam::index_read_idx");

		statistic_increment(ha_read_key_count,&LOCK_status);
		int error=mi_rkey(file,buf,index, key, key_len, find_flag);
		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)
		{
		DBUG_ENTER("ha_myisam::index_read_last");

		statistic_increment(ha_read_key_count,&LOCK_status);
		int error=mi_rkey(file,buf,active_index, key, key_len, HA_READ_PREFIX_LAST);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisam::index_next(byte * buf)
		{
		DBUG_ENTER("ha_myisam::index_next");

		statistic_increment(ha_read_next_count,&LOCK_status);
		int error=mi_rnext(file,buf,active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisam::index_prev(byte * buf)
		{
		DBUG_ENTER("ha_myisam::index_prev");

		statistic_increment(ha_read_prev_count,&LOCK_status);
		int error=mi_rprev(file,buf, active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisam::index_first(byte * buf)
		{
		DBUG_ENTER("ha_myisam::index_first");

		statistic_increment(ha_read_first_count,&LOCK_status);
		int error=mi_rfirst(file, buf, active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisam::index_last(byte * buf)
		{
		DBUG_ENTER("ha_myisam::index_last");

		statistic_increment(ha_read_last_count,&LOCK_status);
		int error=mi_rlast(file, buf, active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisam::index_next_same(byte * buf,
		const byte *key __attribute__((unused)),
		uint length __attribute__((unused)))
		{
		DBUG_ENTER("ha_myisam::index_next_same");

		statistic_increment(ha_read_next_count,&LOCK_status);
		int error=mi_rnext_same(file,buf);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}


		int ha_myisam::rnd_init(bool scan)
		{
		DBUG_ENTER("ha_myisam::rnd_init");

		if (scan)
		return mi_scan_init(file);
		return mi_extra(file, HA_EXTRA_RESET, 0);
		DBUG_RETURN(mi_scan_init(file));
		DBUG_RETURN(mi_extra(file, HA_EXTRA_RESET, 0));
		}

		int ha_myisam::rnd_next(byte *buf)
		{
		DBUG_ENTER("ha_myisam::rnd_next");

		statistic_increment(ha_read_rnd_next_count,&LOCK_status);
		int error=mi_scan(file, buf);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		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)
		{
		DBUG_ENTER("ha_myisam::rnd_pos");

		statistic_increment(ha_read_rnd_count,&LOCK_status);
		int error=mi_rrnd(file, buf, ha_get_ptr(pos,ref_length));
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		void ha_myisam::position(const byte* record)
		{
		my_off_t position=mi_position(file);
		DBUG_ENTER("ha_myisam::position");

		ha_store_ptr(ref, ref_length, position);
		DBUG_VOID_RETURN;
		}

		void ha_myisam::info(uint flag)
		{
		MI_ISAMINFO info;
		char name_buff[FN_REFLEN];
		DBUG_ENTER("ha_myisam::info");

		(void) mi_status(file,&info,flag);
		if (flag & HA_STATUS_VARIABLE)
		@@ -930,14 +992,17 @@ void ha_myisam::info(uint flag)
		update_time = info.update_time;
		if (flag & HA_STATUS_AUTO)
		auto_increment_value= info.auto_increment;
		DBUG_VOID_RETURN;
		}


		int ha_myisam::extra(enum ha_extra_function operation)
		{
		DBUG_ENTER("ha_myisam::extra");

		if ((specialflag & SPECIAL_SAFE_MODE) && operation == HA_EXTRA_KEYREAD)
		return 0;
		return mi_extra(file, operation, 0);
		DBUG_RETURN(0);
		DBUG_RETURN(mi_extra(file, operation, 0));
		}


		@@ -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)
		{
		DBUG_ENTER("ha_myisam::extra_opt");

		if ((specialflag & SPECIAL_SAFE_MODE) &
		(operation == HA_EXTRA_WRITE_CACHE \|\|
		operation == HA_EXTRA_BULK_INSERT_BEGIN))
		return 0;
		return mi_extra(file, operation, (void*) &cache_size);
		DBUG_RETURN(0);
		DBUG_RETURN(mi_extra(file, operation, (void*) &cache_size));
		}


		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()
		{
		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)
		{
		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)
		{
		DBUG_ENTER("ha_myisam::external_lock");

		if (!table->tmp_table)
		return mi_lock_database(file,lock_type);
		return 0;
		DBUG_RETURN(mi_lock_database(file,lock_type));
		DBUG_RETURN(0);
		}


		@@ -980,14 +1055,18 @@ THR_LOCK_DATA *ha_myisam::store_lock(THD thd,
		THR_LOCK_DATA **to,
		enum thr_lock_type lock_type)
		{
		DBUG_ENTER("**ha_myisam::store_lock");

		if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
		file->lock.type=lock_type;
		*to++= &file->lock;
		return to;
		DBUG_RETURN(to);
		}

		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);
		if (!(create_info->used_fields & HA_CREATE_USED_AUTO))
		{
		@@ -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->index_file_name=index_file_name;
		DBUG_VOID_RETURN;
		}


		@@ -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)
		{
		return mi_rename(from,to);
		DBUG_ENTER("ha_myisam::rename_table");

		DBUG_RETURN(mi_rename(from,to));
		}


		longlong ha_myisam::get_auto_increment()
		{
		DBUG_ENTER("ha_myisam::get_auto_increment");

		if (!table->next_number_key_offset)
		{ // Autoincrement at key-start
		ha_myisam::info(HA_STATUS_AUTO);
		return auto_increment_value;
		DBUG_RETURN(auto_increment_value);
		}

		if (table->bulk_insert)
		@@ -1226,7 +1310,7 @@ longlong ha_myisam::get_auto_increment()
		nr=(longlong)
		table->next_number_field->val_int_offset(table->rec_buff_length)+1;
		extra(HA_EXTRA_NO_KEYREAD);
		return nr;
		DBUG_RETURN(nr);
		}


		@@ -1236,25 +1320,28 @@ ha_rows ha_myisam::records_in_range(int inx,
		const byte *end_key,uint end_key_len,
		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,
		start_key,start_key_len,
		start_search_flag,
		end_key,end_key_len,
		end_search_flag);
		end_search_flag));
		}

		int ha_myisam::ft_read(byte * buf)
		{
		int error;
		DBUG_ENTER("ha_myisam::ft_read");

		if (!ft_handler)
		return -1;
		DBUG_RETURN(-1);

		thread_safe_increment(ha_read_next_count,&LOCK_status); // why ?

		error=ft_handler->please->read_next(ft_handler,(char*) buf);

		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

sql/ha_myisammrg.cc

+77 −26

Original line number	Diff line number	Diff line
		@@ -38,12 +38,14 @@ const char **ha_myisammrg::bas_ext() const
		int ha_myisammrg::open(const char *name, int mode, uint test_if_locked)
		{
		char name_buff[FN_REFLEN];
		DBUG_ENTER("ha_myisammrg::open");

		DBUG_PRINT("info", ("ha_myisammrg::open"));
		if (!(file=myrg_open(fn_format(name_buff,name,"","",2 \| 4), mode,
		test_if_locked)))
		{
		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..."))
		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)
		if (table->crashed)
		goto err;
		#endif
		return (0);
		DBUG_RETURN((0));
		err:
		myrg_close(file);
		file=0;
		return (my_errno= HA_ERR_WRONG_TABLE_DEF);
		DBUG_RETURN((my_errno= HA_ERR_WRONG_TABLE_DEF));
		}

		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)
		{
		DBUG_ENTER("ha_myisammrg::write_row");

		statistic_increment(ha_write_count,&LOCK_status);
		if (table->time_stamp)
		update_timestamp(buf+table->time_stamp-1);
		if (table->next_number_field && buf == table->record[0])
		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)
		{
		DBUG_ENTER("ha_myisammrg::update_row");

		statistic_increment(ha_update_count,&LOCK_status);
		if (table->time_stamp)
		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)
		{
		DBUG_ENTER("ha_myisammrg::delete_row");

		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,
		uint key_len, enum ha_rkey_function find_flag)
		{
		DBUG_ENTER("ha_myisammrg::index_read");

		statistic_increment(ha_read_key_count,&LOCK_status);
		int error=myrg_rkey(file,buf,active_index, key, key_len, find_flag);
		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,
		uint key_len, enum ha_rkey_function find_flag)
		{
		DBUG_ENTER("ha_myisammrg::index_read_idx");

		statistic_increment(ha_read_key_count,&LOCK_status);
		int error=myrg_rkey(file,buf,index, key, key_len, find_flag);
		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)
		{
		DBUG_ENTER("ha_myisammrg::index_read_last");

		statistic_increment(ha_read_key_count,&LOCK_status);
		int error=myrg_rkey(file,buf,active_index, key, key_len,
		HA_READ_PREFIX_LAST);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisammrg::index_next(byte * buf)
		{
		DBUG_ENTER("ha_myisammrg::index_next");

		statistic_increment(ha_read_next_count,&LOCK_status);
		int error=myrg_rnext(file,buf,active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisammrg::index_prev(byte * buf)
		{
		DBUG_ENTER("ha_myisammrg::index_prev");

		statistic_increment(ha_read_prev_count,&LOCK_status);
		int error=myrg_rprev(file,buf, active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisammrg::index_first(byte * buf)
		{
		DBUG_ENTER("ha_myisammrg::index_first");

		statistic_increment(ha_read_first_count,&LOCK_status);
		int error=myrg_rfirst(file, buf, active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisammrg::index_last(byte * buf)
		{
		DBUG_ENTER("ha_myisammrg::index_last");

		statistic_increment(ha_read_last_count,&LOCK_status);
		int error=myrg_rlast(file, buf, active_index);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		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)
		{
		DBUG_ENTER("ha_myisammrg::rnd_next");

		statistic_increment(ha_read_rnd_next_count,&LOCK_status);
		int error=myrg_rrnd(file, buf, HA_OFFSET_ERROR);
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		int ha_myisammrg::rnd_pos(byte * buf, byte *pos)
		{
		DBUG_ENTER("ha_myisammrg::rnd_pos");

		statistic_increment(ha_read_rnd_count,&LOCK_status);
		int error=myrg_rrnd(file, buf, ha_get_ptr(pos,ref_length));
		table->status=error ? STATUS_NOT_FOUND: 0;
		return error;
		DBUG_RETURN(error);
		}

		void ha_myisammrg::position(const byte *record)
		{
		ulonglong position= myrg_position(file);
		DBUG_ENTER("ha_myisammrg::position");

		ha_store_ptr(ref, ref_length, (my_off_t) position);
		DBUG_VOID_RETURN;
		}


		void ha_myisammrg::info(uint flag)
		{
		MYMERGE_INFO info;
		DBUG_ENTER("ha_myisammrg::info");

		(void) myrg_status(file,&info,flag);
		/*
		The following fails if one has not compiled MySQL with -DBIG_TABLES
		@@ -216,17 +251,20 @@ void ha_myisammrg::info(uint flag)
		#else
		ref_length=4; // Can't be > than my_off_t
		#endif
		DBUG_VOID_RETURN;
		}


		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
		tables to be closed */
		if (operation == HA_EXTRA_FORCE_REOPEN \|\|
		operation == HA_EXTRA_PREPARE_FOR_DELETE)
		return 0;
		return myrg_extra(file,operation,0);
		DBUG_RETURN(0);
		DBUG_RETURN(myrg_extra(file,operation,0));
		}


		@@ -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)
		{
		DBUG_ENTER("ha_myisammrg::extra_opt");

		if ((specialflag & SPECIAL_SAFE_MODE) &
		(operation == HA_EXTRA_WRITE_CACHE \|\|
		operation == HA_EXTRA_BULK_INSERT_BEGIN))
		return 0;
		return myrg_extra(file, operation, (void*) &cache_size);
		DBUG_RETURN(0);
		DBUG_RETURN(myrg_extra(file, operation, (void*) &cache_size));
		}


		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)
		{
		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
		{
		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,
		enum thr_lock_type lock_type)
		{
		MYRG_TABLE *table;
		DBUG_ENTER("**ha_myisammrg::store_lock");

		for (table=file->open_tables ; table != file->end_table ; table++)
		{
		@@ -270,13 +317,14 @@ THR_LOCK_DATA *ha_myisammrg::store_lock(THD thd,
		if (lock_type != TL_IGNORE && table->table->lock.type == TL_UNLOCK)
		table->table->lock.type=lock_type;
		}
		return to;
		DBUG_RETURN(to);
		}

		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");

		// [phi] auto_increment stuff is missing (but currently not needed)
		if (!(create_info->used_fields & HA_CREATE_USED_UNION))
		{
		MYRG_TABLE *table;
		@@ -334,6 +382,8 @@ int ha_myisammrg::create(const char name, register TABLE form,
		void ha_myisammrg::append_create_info(String *packet)
		{
		char buff[FN_REFLEN];
		DBUG_ENTER("ha_myisammrg::append_create_info");

		if (file->merge_insert_method != MERGE_INSERT_DISABLED)
		{
		packet->append(" INSERT_METHOD=",15);
		@@ -351,4 +401,5 @@ void ha_myisammrg::append_create_info(String *packet)
		packet->append(buff,(uint) strlen(buff));
		}
		packet->append(')');
		DBUG_VOID_RETURN;
		}

sql/handler.cc

+95 −36

File changed.

Preview size limit exceeded, changes collapsed.