Merge tsmith@bk-internal.mysql.com:/home/bk/mysql-5.1-maint (fc0d8af8) · Commits · Software / OSDI20 Artifacts / mariadb

sql/event_data_objects.cc

+0 −10

Original line number	Diff line number	Diff line
		@@ -1810,16 +1810,6 @@ Event_job_data::compile(THD thd, MEM_ROOT mem_root)
		{
		DBUG_PRINT("error", ("error during compile or thd->is_fatal_error: %d",
		thd->is_fatal_error));
		/*
		The first thing we do after parse error is freeing sp_head to
		ensure that we have restored original memroot.
		*/
		if (lex.sphead)
		{
		/* Clean up after failed stored procedure/function */
		delete lex.sphead;
		lex.sphead= NULL;
		}
		lex.unit.cleanup();

		sql_print_error("SCHEDULER: Error during compilation of %s.%s or "

sql/log_event.cc

+2 −2

Original line number	Diff line number	Diff line
		@@ -3335,8 +3335,8 @@ int Load_log_event::exec_event(NET* net, struct st_relay_log_info* rli,

		ex.skip_lines = skip_lines;
		List<Item> field_list;
		thd->main_lex.select_lex.context.resolve_in_table_list_only(&tables);
		set_fields(tables.db, field_list, &thd->main_lex.select_lex.context);
		thd->lex->select_lex.context.resolve_in_table_list_only(&tables);
		set_fields(tables.db, field_list, &thd->lex->select_lex.context);
		thd->variables.pseudo_thread_id= thread_id;
		if (net)
		{

sql/mysqld.cc

+0 −12

Original line number	Diff line number	Diff line
		@@ -1689,18 +1689,6 @@ static void network_init(void)

		#endif /!EMBEDDED_LIBRARY/

		void MYSQLerror(const char *s)
		{
		THD *thd=current_thd;
		char yytext= (char) thd->lex->tok_start;
		/* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */
		if (strcmp(s,"parse error") == 0 \|\| strcmp(s,"syntax error") == 0)
		s=ER(ER_SYNTAX_ERROR);
		my_printf_error(ER_PARSE_ERROR, ER(ER_PARSE_ERROR), MYF(0), s,
		(yytext ? (char*) yytext : ""),
		thd->lex->yylineno);
		}


		#ifndef EMBEDDED_LIBRARY
		/*

sql/sql_class.cc

+14 −18

Original line number	Diff line number	Diff line
		@@ -192,14 +192,10 @@ void *thd_ha_data(const THD thd, const struct handlerton *hton)
		}


		/*
		Pass nominal parameters to Statement constructor only to ensure that
		the destructor works OK in case of error. The main_mem_root will be
		re-initialized in init().
		*/

		THD::THD()
		:Statement(CONVENTIONAL_EXECUTION, 0, ALLOC_ROOT_MIN_BLOCK_SIZE, 0),
		:Statement(&main_lex, &main_mem_root, CONVENTIONAL_EXECUTION,
		/* statement id */ 0),
		Open_tables_state(refresh_version), rli_fake(0),
		lock_id(&main_lock_id),
		user_time(0), in_sub_stmt(0),
		@@ -216,6 +212,12 @@ THD::THD()
		{
		ulong tmp;

		/*
		Pass nominal parameters to init_alloc_root only to ensure that
		the destructor works OK in case of an error. The main_mem_root
		will be re-initialized in init_for_queries().
		*/
		init_sql_alloc(&main_mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
		stmt_arena= this;
		thread_stack= 0;
		db= 0;
		@@ -518,6 +520,7 @@ THD::~THD()
		delete rli_fake;
		#endif

		free_root(&main_mem_root, MYF(0));
		DBUG_VOID_RETURN;
		}

		@@ -1721,18 +1724,17 @@ void Query_arena::cleanup_stmt()
		Statement functions
		*/

		Statement::Statement(enum enum_state state_arg, ulong id_arg,
		ulong alloc_block_size, ulong prealloc_size)
		:Query_arena(&main_mem_root, state_arg),
		Statement::Statement(LEX lex_arg, MEM_ROOT mem_root_arg,
		enum enum_state state_arg, ulong id_arg)
		:Query_arena(mem_root_arg, state_arg),
		id(id_arg),
		mark_used_columns(MARK_COLUMNS_READ),
		lex(&main_lex),
		lex(lex_arg),
		query(0),
		query_length(0),
		cursor(0)
		{
		name.str= NULL;
		init_sql_alloc(&main_mem_root, alloc_block_size, prealloc_size);
		}


		@@ -1774,7 +1776,7 @@ void Statement::restore_backup_statement(Statement stmt, Statement backup)

		void THD::end_statement()
		{
		/* Cleanup SQL processing state to resuse this statement in next query. */
		/* Cleanup SQL processing state to reuse this statement in next query. */
		lex_end(lex);
		delete lex->result;
		lex->result= 0;
		@@ -1815,12 +1817,6 @@ void THD::restore_active_arena(Query_arena set, Query_arena backup)

		Statement::~Statement()
		{
		/*
		We must free `main_mem_root', not `mem_root' (pointer), to work
		correctly if this statement is used as a backup statement,
		for which `mem_root' may point to some other statement.
		*/
		free_root(&main_mem_root, MYF(0));
		}

		C_MODE_START

sql/sql_class.h

+38 −16

Original line number	Diff line number	Diff line
		@@ -452,8 +452,10 @@ class Query_arena

		class Server_side_cursor;

		/*
		State of a single command executed against this connection.
		/**
		@class Statement
		@brief State of a single command executed against this connection.

		One connection can contain a lot of simultaneously running statements,
		some of which could be:
		- prepared, that is, contain placeholders,
		@@ -471,10 +473,6 @@ class Statement: public ilink, public Query_arena
		Statement(const Statement &rhs); /* not implemented: */
		Statement &operator=(const Statement &rhs); /* non-copyable */
		public:
		/* FIXME: these must be protected */
		MEM_ROOT main_mem_root;
		LEX main_lex;

		/*
		Uniquely identifies each statement object in thread scope; change during
		statement lifetime. FIXME: must be const
		@@ -525,10 +523,10 @@ class Statement: public ilink, public Query_arena
		public:

		/* This constructor is called for backup statements */
		Statement() { clear_alloc_root(&main_mem_root); }
		Statement() {}

		Statement(enum enum_state state_arg, ulong id_arg,
		ulong alloc_block_size, ulong prealloc_size);
		Statement(LEX lex_arg, MEM_ROOT mem_root_arg,
		enum enum_state state_arg, ulong id_arg);
		virtual ~Statement();

		/* Assign execution context (note: not all members) of given stmt to self */
		@@ -540,7 +538,7 @@ class Statement: public ilink, public Query_arena
		};


		/*
		/**
		Container for all statements created/used in a connection.
		Statements in Statement_map have unique Statement::id (guaranteed by id
		assignment in Statement::Statement)
		@@ -620,6 +618,10 @@ bool xid_cache_insert(XID *xid, enum xa_states xa_state);
		bool xid_cache_insert(XID_STATE *xid_state);
		void xid_cache_delete(XID_STATE *xid_state);

		/**
		@class Security_context
		@brief A set of THD members describing the current authenticated user.
		*/

		class Security_context {
		public:
		@@ -651,7 +653,7 @@ class Security_context {
		};


		/*
		/**
		A registry for item tree transformations performed during
		query optimization. We register only those changes which require
		a rollback to re-execute a prepared statement or stored procedure
		@@ -662,7 +664,7 @@ struct Item_change_record;
		typedef I_List<Item_change_record> Item_change_list;


		/*
		/**
		Type of prelocked mode.
		See comment for THD::prelocked_mode for complete description.
		*/
		@@ -671,7 +673,7 @@ enum prelocked_mode_type {NON_PRELOCKED= 0, PRELOCKED= 1,
		PRELOCKED_UNDER_LOCK_TABLES= 2};


		/*
		/**
		Class that holds information about tables which were opened and locked
		by the thread. It is also used to save/restore this information in
		push_open_tables_state()/pop_open_tables_state().
		@@ -774,14 +776,17 @@ class Open_tables_state
		}
		};


		/* class to save context when executing a function or trigger */
		/**
		@class Sub_statement_state
		@brief Used to save context when executing a function or trigger
		*/

		/* Defines used for Sub_statement_state::in_sub_stmt */

		#define SUB_STMT_TRIGGER 1
		#define SUB_STMT_FUNCTION 2


		class Sub_statement_state
		{
		public:
		@@ -856,7 +861,8 @@ class Internal_error_handler
		};


		/*
		/**
		@class THD
		For each client connection we create a separate thread with THD serving as
		a thread/connection descriptor
		*/
		@@ -1700,6 +1706,22 @@ class THD :public Statement,
		private:
		/** The current internal error handler for this thread, or NULL. */
		Internal_error_handler *m_internal_handler;
		/**
		The lex to hold the parsed tree of conventional (non-prepared) queries.
		Whereas for prepared and stored procedure statements we use an own lex
		instance for each new query, for conventional statements we reuse
		the same lex. (@see mysql_parse for details).
		*/
		LEX main_lex;
		/**
		This memory root is used for two purposes:
		- for conventional queries, to allocate structures stored in main_lex
		during parsing, and allocate runtime data (execution plan, etc.)
		during execution.
		- for prepared queries, only to allocate runtime data. The parsed
		tree itself is reused between executions and thus is stored elsewhere.
		*/
		MEM_ROOT main_mem_root;
		};