ha_innobase.cc, ha_innobase.h, handler.h, handler.cc, sql_class.h, log.cc: (d927ff75) · Commits · Software / OSDI20 Artifacts / mariadb

sql/ha_innobase.cc

+21 −0

Original line number	Diff line number	Diff line
		@@ -730,6 +730,27 @@ innobase_commit(
		DBUG_RETURN(error);
		}

		/*********************************************************************
		This is called when MySQL writes the binlog entry for the current
		transaction. Writes to the InnoDB tablespace info which tells where the
		MySQL binlog entry for the current transaction ended. Also commits the
		transaction inside InnoDB. */

		int
		innobase_report_binlog_offset_and_commit(
		/=====================================/
		/* out: 0 or error code */
		THD* thd, /* in: user thread */
		void* trx_handle, /* in: InnoDB trx handle */
		char* log_file_name, /* in: latest binlog file name */
		my_off_t end_offset) /* in: the offset in the binlog file
		up to which we wrote */
		{
		/* Currently does nothing ! */

		return(0);
		}

		/*********************************************************************
		Rolls back a transaction in an InnoDB database. */

sql/ha_innobase.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -185,6 +185,11 @@ bool innobase_flush_logs(void);
		uint innobase_get_free_space(void);

		int innobase_commit(THD thd, void trx_handle);
		int innobase_report_binlog_offset_and_commit(
		THD* thd,
		void* trx_handle,
		char* log_file_name,
		my_off_t end_offset);
		int innobase_rollback(THD thd, void trx_handle);
		int innobase_close_connection(THD *thd);
		int innobase_drop_database(char *path);

sql/handler.cc

+39 −1

Original line number	Diff line number	Diff line
		@@ -257,6 +257,44 @@ int ha_autocommit_or_rollback(THD *thd, int error)
		DBUG_RETURN(error);
		}

		/* This function is called when MySQL writes the log segment of a transaction
		to the binlog. It is called when the LOCK_log mutex is reserved. Here we
		communicate to transactional table handlers whta binlog position corresponds
		to the current transaction. The handler can store it and in recovery print
		to the user, so that the user knows from what position in the binlog to
		start possible roll-forward, for example, if the crashed server was a slave
		in replication. This function also calls the commit of the table handler,
		because the order of trasnactions in the log of the table handler must be
		the same as in the binlog. */

		int ha_report_binlog_offset_and_commit(
		THD thd, / in: user thread */
		char log_file_name, / in: latest binlog file name */
		my_off_t end_offset) /* in: the offset in the binlog file
		up to which we wrote */
		{
		THD_TRANS *trans;
		int error = 0;

		trans = &thd->transaction.all;

		#ifdef HAVE_INNOBASE_DB
		if (trans->innobase_tid)
		{
		if ((error=innobase_report_binlog_offset_and_commit(thd,
		trans->innobase_tid,
		log_file_name,
		end_offset)))
		{
		my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
		error=1;
		}
		trans->innodb_active_trans=0;
		}
		#endif

		return error;
		}

		int ha_commit_trans(THD thd, THD_TRANS trans)
		{
		@@ -269,7 +307,7 @@ int ha_commit_trans(THD thd, THD_TRANS trans)
		if (trans == &thd->transaction.all && mysql_bin_log.is_open() &&
		my_b_tell(&thd->transaction.trans_log))
		{
		mysql_bin_log.write(&thd->transaction.trans_log);
		mysql_bin_log.write(thd, &thd->transaction.trans_log);
		reinit_io_cache(&thd->transaction.trans_log,
		WRITE_CACHE, (my_off_t) 0, 0, 1);
		thd->transaction.trans_log.end_of_file= max_binlog_cache_size;

sql/handler.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -353,6 +353,10 @@ int ha_delete_table(enum db_type db_type, const char *path);
		void ha_drop_database(char* path);
		void ha_key_cache(void);
		int ha_start_stmt(THD *thd);
		int ha_report_binlog_offset_and_commit(
		THD *thd,
		char *log_file_name,
		my_off_t end_offset);
		int ha_commit_trans(THD thd, THD_TRANS trans);
		int ha_rollback_trans(THD thd, THD_TRANS trans);
		int ha_autocommit_or_rollback(THD *thd, int error);

sql/log.cc

+20 −1

Original line number	Diff line number	Diff line
		@@ -658,6 +658,7 @@ bool MYSQL_LOG::write(Query_log_event* event_info)
		VOID(pthread_mutex_unlock(&LOCK_log));
		return 0;
		}

		error=1;

		if (thd->last_insert_id_used)
		@@ -694,6 +695,20 @@ bool MYSQL_LOG::write(Query_log_event* event_info)
		goto err;
		error=0;
		should_rotate = (file == &log_file && my_b_tell(file) >= max_binlog_size);

		/* Tell for transactional table handlers up to which position in the
		binlog file we wrote. The table handler can store this info, and
		after crash recovery print for the user the offset of the last
		transactions which were recovered. Actually, we must also call
		the table handler commit here, protected by the LOCK_log mutex,
		because otherwise the transactions may end up in a different order
		in the table handler log! */

		if (file == &log_file) {
		error = ha_report_binlog_offset_and_commit(thd, log_file_name,
		file->pos_in_file);
		}

		err:
		if (error)
		{
		@@ -718,7 +733,7 @@ bool MYSQL_LOG::write(Query_log_event* event_info)
		'cache' needs to be reinitialized after this functions returns.
		*/

		bool MYSQL_LOG::write(IO_CACHE *cache)
		bool MYSQL_LOG::write(THD thd, IO_CACHE cache)
		{
		VOID(pthread_mutex_lock(&LOCK_log));
		bool error=1;
		@@ -754,6 +769,10 @@ bool MYSQL_LOG::write(IO_CACHE *cache)
		sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno);
		goto err;
		}
		error = ha_report_binlog_offset_and_commit(thd, log_file_name,
		log_file.pos_in_file);
		if (error)
		goto err;
		}
		error=0;