2018-04-19 22:27:02 +02:00
|
|
|
/* Copyright (c) 2000, 2018, Oracle and/or its affiliates.
|
MDEV-15563: Instant ROW_FORMAT=REDUNDANT column extension
This was developed by Aleksey Midenkov based on my design.
In the original InnoDB storage format (that was retroactively named
ROW_FORMAT=REDUNDANT in MySQL 5.0.3), the length of each index field
is stored explicitly.
Because of this, we can and now will allow instant conversion from
VARCHAR to CHAR or VARBINARY to BINARY of equal or greater size,
as well as instant conversion of TINYINT to SMALLINT to MEDIUMINT
to INT to BIGINT (while not changing between signed and unsigned).
Theoretically, we could allow changing from an unsigned integer to
a bigger unsigned integer, as well as changing CHAR to VARCHAR, but
that would require additional metadata and conversions whenever
reading old records.
Field_str::is_equal(), Field_varstring::is_equal(), Field_num::is_equal():
Return the new result IS_EQUAL_PACK_LENGTH_EXT if the table advertises
HA_EXTENDED_TYPES_CONVERSION capability and we are considering the
above-mentioned conversions.
ALTER_COLUMN_EQUAL_PACK_LENGTH_EXT: A new ALTER TABLE flag, similar
to ALTER_COLUMN_EQUAL_PACK_LENGTH but requiring conversions when
reading the data. The Field::is_equal() result IS_EQUAL_PACK_LENGTH_EXT
will map to this flag.
dtype_get_fixed_size_low(): For BINARY, CHAR and integer columns
in ROW_FORMAT=REDUNDANT, return 0 (variable length) from now on.
dtype_get_sql_null_size(): Keep returning the current size for
BINARY, CHAR and integer columns, so that in ROW_FORMAT=REDUNDANT
it will remain possible to update in place between NULL and NOT NULL
values.
btr_index_rec_validate(): Relax a CHECK TABLE length check for
ROW_FORMAT=REDUNDANT tables.
btr_cur_instant_init_low(): No longer trust fixed_len
for ROW_FORMAT=REDUNDANT tables.
We cannot rely on fixed_len anymore because the record can have shorter
length from before instant extension. Note that importing such tablespace
into earlier MariaDB versions produces ER_TABLE_SCHEMA_MISMATCH when
using a .cfg file.
2019-02-13 16:39:05 +01:00
|
|
|
Copyright (c) 2010, 2019, MariaDB
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
2019-05-11 20:29:06 +02:00
|
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@file
|
|
|
|
|
|
|
|
|
|
@details
|
|
|
|
|
Mostly this file is used in the server. But a little part of it is used in
|
|
|
|
|
mysqlbinlog too (definition of SELECT_DISTINCT and others).
|
|
|
|
|
The consequence is that 90% of the file is wrapped in \#ifndef MYSQL_CLIENT,
|
|
|
|
|
except the part which must be in the server and in the client.
|
|
|
|
|
*/
|
|
|
|
|
|
2010-04-21 00:29:30 +02:00
|
|
|
#ifndef SQL_PRIV_INCLUDED
|
|
|
|
|
#define SQL_PRIV_INCLUDED
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
#ifndef MYSQL_CLIENT
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Generates a warning that a feature is deprecated. After a specified
|
|
|
|
|
version asserts that the feature is removed.
|
|
|
|
|
|
|
|
|
|
Using it as
|
|
|
|
|
|
|
|
|
|
WARN_DEPRECATED(thd, 6,2, "BAD", "'GOOD'");
|
|
|
|
|
|
|
|
|
|
Will result in a warning
|
|
|
|
|
|
|
|
|
|
"The syntax 'BAD' is deprecated and will be removed in MySQL 6.2. Please
|
|
|
|
|
use 'GOOD' instead"
|
|
|
|
|
|
|
|
|
|
Note that in macro arguments BAD is not quoted, while 'GOOD' is.
|
|
|
|
|
Note that the version is TWO numbers, separated with a comma
|
|
|
|
|
(two macro arguments, that is)
|
|
|
|
|
*/
|
|
|
|
|
#define WARN_DEPRECATED(Thd,VerHi,VerLo,Old,New) \
|
|
|
|
|
do { \
|
|
|
|
|
compile_time_assert(MYSQL_VERSION_ID < VerHi * 10000 + VerLo * 100); \
|
|
|
|
|
if (((THD *) Thd) != NULL) \
|
2013-06-15 17:32:08 +02:00
|
|
|
push_warning_printf(((THD *) Thd), Sql_condition::WARN_LEVEL_WARN, \
|
2015-07-06 19:24:14 +02:00
|
|
|
ER_WARN_DEPRECATED_SYNTAX, \
|
|
|
|
|
ER_THD(((THD *) Thd), ER_WARN_DEPRECATED_SYNTAX), \
|
|
|
|
|
(Old), (New)); \
|
2010-03-31 16:05:33 +02:00
|
|
|
else \
|
|
|
|
|
sql_print_warning("The syntax '%s' is deprecated and will be removed " \
|
|
|
|
|
"in a future release. Please use %s instead.", \
|
|
|
|
|
(Old), (New)); \
|
|
|
|
|
} while(0)
|
|
|
|
|
|
2014-07-02 11:22:52 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Generates a warning that a feature is deprecated and there is no replacement.
|
|
|
|
|
|
|
|
|
|
Using it as
|
|
|
|
|
|
|
|
|
|
WARN_DEPRECATED_NO_REPLACEMENT(thd, "BAD");
|
|
|
|
|
|
|
|
|
|
Will result in a warning
|
|
|
|
|
|
|
|
|
|
"'BAD' is deprecated and will be removed in a future release."
|
|
|
|
|
|
|
|
|
|
Note that in macro arguments BAD is not quoted.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define WARN_DEPRECATED_NO_REPLACEMENT(Thd,Old) \
|
|
|
|
|
do { \
|
2015-07-20 19:47:46 +02:00
|
|
|
THD *thd_= ((THD*) Thd); \
|
|
|
|
|
if (thd_ != NULL) \
|
|
|
|
|
push_warning_printf(thd_, Sql_condition::WARN_LEVEL_WARN, \
|
|
|
|
|
ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT, \
|
|
|
|
|
ER_THD(thd_, ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT), \
|
|
|
|
|
(Old)); \
|
2014-07-02 11:22:52 +02:00
|
|
|
else \
|
|
|
|
|
sql_print_warning("'%s' is deprecated and will be removed " \
|
|
|
|
|
"in a future release.", (Old)); \
|
|
|
|
|
} while(0)
|
|
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
This is included in the server and in the client.
|
|
|
|
|
Options for select set by the yacc parser (stored in lex->options).
|
|
|
|
|
|
|
|
|
|
NOTE
|
|
|
|
|
log_event.h defines OPTIONS_WRITTEN_TO_BIN_LOG to specify what THD
|
|
|
|
|
options list are written into binlog. These options can NOT change their
|
|
|
|
|
values, or it will break replication between version.
|
|
|
|
|
|
|
|
|
|
context is encoded as following:
|
|
|
|
|
SELECT - SELECT_LEX_NODE::options
|
|
|
|
|
THD - THD::options
|
|
|
|
|
intern - neither. used only as
|
|
|
|
|
func(..., select_node->options | thd->options | OPTION_XXX, ...)
|
|
|
|
|
|
|
|
|
|
TODO: separate three contexts above, move them to separate bitfields.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define SELECT_DISTINCT (1ULL << 0) // SELECT, user
|
|
|
|
|
#define SELECT_STRAIGHT_JOIN (1ULL << 1) // SELECT, user
|
|
|
|
|
#define SELECT_DESCRIBE (1ULL << 2) // SELECT, user
|
|
|
|
|
#define SELECT_SMALL_RESULT (1ULL << 3) // SELECT, user
|
|
|
|
|
#define SELECT_BIG_RESULT (1ULL << 4) // SELECT, user
|
|
|
|
|
#define OPTION_FOUND_ROWS (1ULL << 5) // SELECT, user
|
|
|
|
|
#define OPTION_TO_QUERY_CACHE (1ULL << 6) // SELECT, user
|
|
|
|
|
#define SELECT_NO_JOIN_CACHE (1ULL << 7) // intern
|
|
|
|
|
/** always the opposite of OPTION_NOT_AUTOCOMMIT except when in fix_autocommit() */
|
|
|
|
|
#define OPTION_AUTOCOMMIT (1ULL << 8) // THD, user
|
|
|
|
|
#define OPTION_BIG_SELECTS (1ULL << 9) // THD, user
|
|
|
|
|
#define OPTION_LOG_OFF (1ULL << 10) // THD, user
|
2017-06-14 00:33:11 +02:00
|
|
|
#define OPTION_QUOTE_SHOW_CREATE (1ULL << 11) // THD, user
|
2010-03-31 16:05:33 +02:00
|
|
|
#define TMP_TABLE_ALL_COLUMNS (1ULL << 12) // SELECT, intern
|
|
|
|
|
#define OPTION_WARNINGS (1ULL << 13) // THD, user
|
|
|
|
|
#define OPTION_AUTO_IS_NULL (1ULL << 14) // THD, user, binlog
|
2019-03-08 18:14:03 +01:00
|
|
|
#define OPTION_NO_CHECK_CONSTRAINT_CHECKS (1ULL << 15)
|
2010-03-31 16:05:33 +02:00
|
|
|
#define OPTION_SAFE_UPDATES (1ULL << 16) // THD, user
|
|
|
|
|
#define OPTION_BUFFER_RESULT (1ULL << 17) // SELECT, user
|
|
|
|
|
#define OPTION_BIN_LOG (1ULL << 18) // THD, user
|
|
|
|
|
#define OPTION_NOT_AUTOCOMMIT (1ULL << 19) // THD, user
|
|
|
|
|
#define OPTION_BEGIN (1ULL << 20) // THD, intern
|
|
|
|
|
#define OPTION_TABLE_LOCK (1ULL << 21) // THD, intern
|
|
|
|
|
#define OPTION_QUICK (1ULL << 22) // SELECT (for DELETE)
|
|
|
|
|
#define OPTION_KEEP_LOG (1ULL << 23) // THD, user
|
|
|
|
|
|
2022-07-02 12:22:10 +02:00
|
|
|
#define OPTION_EXPLICIT_DEF_TIMESTAMP (1ULL << 24) // THD, user
|
2014-02-05 18:01:59 +01:00
|
|
|
#define OPTION_GTID_BEGIN (1ULL << 25) // GTID BEGIN found in log
|
|
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
/** The following can be set when importing tables in a 'wrong order'
|
|
|
|
|
to suppress foreign key checks */
|
|
|
|
|
#define OPTION_NO_FOREIGN_KEY_CHECKS (1ULL << 26) // THD, user, binlog
|
|
|
|
|
/** The following speeds up inserts to InnoDB tables by suppressing unique
|
|
|
|
|
key checks in some cases */
|
|
|
|
|
#define OPTION_RELAXED_UNIQUE_CHECKS (1ULL << 27) // THD, user, binlog
|
2019-12-30 12:56:19 +01:00
|
|
|
#define OPTION_IF_EXISTS (1ULL << 28) // binlog
|
2010-03-31 16:05:33 +02:00
|
|
|
#define OPTION_SCHEMA_TABLE (1ULL << 29) // SELECT, intern
|
|
|
|
|
/** Flag set if setup_tables already done */
|
|
|
|
|
#define OPTION_SETUP_TABLES_DONE (1ULL << 30) // intern
|
|
|
|
|
/** If not set then the thread will ignore all warnings with level notes. */
|
|
|
|
|
#define OPTION_SQL_NOTES (1ULL << 31) // THD, user
|
|
|
|
|
/**
|
|
|
|
|
Force the used temporary table to be a MyISAM table (because we will use
|
|
|
|
|
fulltext functions when reading from it.
|
|
|
|
|
*/
|
|
|
|
|
#define TMP_TABLE_FORCE_MYISAM (1ULL << 32)
|
|
|
|
|
#define OPTION_PROFILING (1ULL << 33)
|
Committing on behalf or Dmitry Lenev:
Fix for bug #46947 "Embedded SELECT without FOR UPDATE is
causing a lock", with after-review fixes.
SELECT statements with subqueries referencing InnoDB tables
were acquiring shared locks on rows in these tables when they
were executed in REPEATABLE-READ mode and with statement or
mixed mode binary logging turned on.
This was a regression which were introduced when fixing
bug 39843.
The problem was that for tables belonging to subqueries
parser set TL_READ_DEFAULT as a lock type. In cases when
statement/mixed binary logging at open_tables() time this
type of lock was converted to TL_READ_NO_INSERT lock at
open_tables() time and caused InnoDB engine to acquire
shared locks on reads from these tables. Although in some
cases such behavior was correct (e.g. for subqueries in
DELETE) in case of SELECT it has caused unnecessary locking.
This patch tries to solve this problem by rethinking our
approach to how we handle locking for SELECT and subqueries.
Now we always set TL_READ_DEFAULT lock type for all cases
when we read data. When at open_tables() time this lock
is interpreted as TL_READ_NO_INSERT or TL_READ depending
on whether this statement as a whole or call to function
which uses particular table should be written to the
binary log or not (if yes then statement should be properly
serialized with concurrent statements and stronger lock
should be acquired).
Test coverage is added for both InnoDB and MyISAM.
This patch introduces an "incompatible" change in locking
scheme for subqueries used in SELECT ... FOR UPDATE and
SELECT .. IN SHARE MODE.
In 4.1 the server would use a snapshot InnoDB read for
subqueries in SELECT FOR UPDATE and SELECT .. IN SHARE MODE
statements, regardless of whether the binary log is on or off.
If the user required a different type of read (i.e. locking read),
he/she could request so explicitly by providing FOR UPDATE/IN SHARE MODE
clause for each individual subquery.
On of the patches for 5.0 broke this behaviour (which was not documented
or tested), and started to use locking reads fora all subqueries in SELECT ...
FOR UPDATE/IN SHARE MODE. This patch restored 4.1 behaviour.
mysql-test/include/check_concurrent_insert.inc:
Added auxiliary script which allows to check if statement
reading table allows concurrent inserts in it.
mysql-test/include/check_no_concurrent_insert.inc:
Added auxiliary script which allows to check that statement
reading table doesn't allow concurrent inserts in it.
mysql-test/include/check_no_row_lock.inc:
Added auxiliary script which allows to check if statement
reading table doesn't take locks on its rows.
mysql-test/include/check_shared_row_lock.inc:
Added auxiliary script which allows to check if statement
reading table takes shared locks on some of its rows.
mysql-test/r/bug39022.result:
After bug #46947 'Embedded SELECT without FOR UPDATE is
causing a lock' was fixed test case for bug 39022 has to
be adjusted in order to trigger execution path on which
original problem was encountered.
mysql-test/r/innodb_mysql_lock2.result:
Added coverage for handling of locking in various cases when
we read data from InnoDB tables (includes test case for
bug #46947 'Embedded SELECT without FOR UPDATE is causing a
lock').
mysql-test/r/lock_sync.result:
Added coverage for handling of locking in various cases when
we read data from MyISAM tables.
mysql-test/t/bug39022.test:
After bug #46947 'Embedded SELECT without FOR UPDATE is
causing a lock' was fixed test case for bug 39022 has to
be adjusted in order to trigger execution path on which
original problem was encountered.
mysql-test/t/innodb_mysql_lock2.test:
Added coverage for handling of locking in various cases when
we read data from InnoDB tables (includes test case for
bug #46947 'Embedded SELECT without FOR UPDATE is causing a
lock').
mysql-test/t/lock_sync.test:
Added coverage for handling of locking in various cases when
we read data from MyISAM tables.
sql/log_event.cc:
Since LEX::lock_option member was removed we no longer can
rely on its value in Load_log_event::print_query() to
determine that log event correponds to LOAD DATA CONCURRENT
statement (this was not correct in all situations anyway).
A new Load_log_event's member was introduced as a replacement.
It is initialized at event object construction time and
explicitly indicates whether LOAD DATA was concurrent.
sql/log_event.h:
Since LEX::lock_option member was removed we no longer can
rely on its value in Load_log_event::print_query() to
determine that log event correponds to LOAD DATA CONCURRENT
statement (this was not correct in all situations anyway).
A new Load_log_event's member was introduced as a replacement.
It is initialized at event object construction time and
explicitly indicates whether LOAD DATA was concurrent.
sql/sp_head.cc:
sp_head::reset_lex():
Before parsing substatement reset part of parser state
which needs this (e.g. set Yacc_state::m_lock_type to
default value).
sql/sql_acl.cc:
Since LEX::reset_n_backup_query_tables_list() now also
resets LEX::sql_command member (as it became part of
Query_tables_list class) we have to restore it in cases
when while working with proxy Query_table_list we assume
that LEX::sql_command still corresponds to original SQL
command being executed (for example, when we are logging
statement to the binary log while having Query_tables_list
reset and backed up).
sql/sql_base.cc:
Changed read_lock_type_for_table() to return a weak TL_READ
type of lock in cases when we are executing statement which
won't update tables directly and table doesn't belong to
statement's prelocking list and thus can't be used by a
stored function. It is OK to do so since in this case table
won't be used by statement or function call which will be
written to the binary log, so serializability requirements
for it can be relaxed.
One of results from this change is that SELECTs on InnoDB
tables no longer takes shared row locks for tables which
are used in subqueries (i.e. bug #46947 is fixed).
Another result is that for similar SELECTs on MyISAM tables
concurrent inserts are allowed.
In order to implement this change signature of
read_lock_type_for_table() function was changed to take
pointers to Query_tables_list and TABLE_LIST objects.
sql/sql_base.h:
- Function read_lock_type_for_table() now takes pointers
to Query_tables_list and TABLE_LIST elements as its
arguments since to correctly determine lock type it needs
to know what statement is being performed and whether table
element for which lock type to be determined belongs to
prelocking list.
sql/sql_lex.cc:
- Removed LEX::lock_option and st_select_lex::lock_option
members. Places in parser that were using them now use
Yacc_state::m_lock_type instead.
- To emphasize that LEX::sql_command member is used during
process of opening and locking of tables it was moved to
Query_tables_list class. It is now reset by
Query_tables_list::reset_query_tables_list() method.
sql/sql_lex.h:
- Removed st_select_lex::lock_option member as there is no
real need for per-SELECT lock type (HIGH_PRIORITY option
should apply to the whole statement. FOR UPDATE/LOCK IN
SHARE MODE clauses can be handled without this member).
The main effect which was achieved by introduction of this
member, i.e. using TL_READ_DEFAULT lock type for
subqueries, is now achieved by setting LEX::lock_option
(or rather its replacement - Yacc_state::m_lock_type) to
TL_READ_DEFAULT in almost all cases.
- To emphasize that LEX::sql_command member is used during
process of opening and locking of tables it was moved to
Query_tables_list class.
- Replaced LEX::lock_option with Yacc_state::m_lock_type
in order to emphasize that this value is relevant only
during parsing. Unlike for LEX::lock_option the default
value for Yacc_state::m_lock_type is TL_READ_DEFAULT.
Note that for cases when it is OK to take a "weak" read
lock (e.g. simple SELECT) this lock type will be converted
to TL_READ at open_tables() time. So this change won't
cause negative change in behavior for such statements.
OTOH this change ensures that, for example, for SELECTs
which are used in stored functions TL_READ_NO_INSERT lock
is taken when necessary and as result calls to such stored
functions can be written to the binary log with correct
serialization.
sql/sql_load.cc:
Load_log_event constructor now requires a parameter that
indicates whether LOAD DATA is concurrent.
sql/sql_parse.cc:
LEX::lock_option was replaced with Yacc_state::m_lock_type.
And instead of resetting the latter implicitly in
mysql_init_multi_delete() we do it explicitly in the
places in parser which call this function.
sql/sql_priv.h:
- To be able more easily distinguish high-priority SELECTs
in st_select_lex::print() method added flag for
HIGH_PRIORITY option.
sql/sql_select.cc:
Changed code not to rely on LEX::lock_option to determine
that it is high-priority SELECT. It was replaced with
Yacc_state::m_lock_type which is accessible only at
parse time. So instead of LEX::lock_option we now rely
on a newly introduced flag for st_select_lex::options -
SELECT_HIGH_PRIORITY.
sql/sql_show.cc:
Since LEX::reset_n_backup_query_tables_list() now also
resets LEX::sql_command member (as it became part of
Query_tables_list class) we have to restore it in cases
when while working with proxy Query_table_list we assume
that LEX::sql_command still corresponds to original SQL
command being executed.
sql/sql_table.cc:
Since LEX::reset_query_tables_list() now also resets
LEX::sql_command member (as it became part of
Query_tables_list class) we have to restore value of this
member when this method is called by mysql_admin_table(),
to make this code safe for re-execution.
sql/sql_trigger.cc:
Since LEX::reset_n_backup_query_tables_list() now also
resets LEX::sql_command member (as it became part of
Query_tables_list class) we have to restore it in cases
when while working with proxy Query_table_list we assume
that LEX::sql_command still corresponds to original SQL
command being executed (for example, when we are logging
statement to the binary log while having Query_tables_list
reset and backed up).
sql/sql_update.cc:
Function read_lock_type_for_table() now takes pointers
to Query_tables_list and TABLE_LIST elements as its
arguments since to correctly determine lock type it needs
to know what statement is being performed and whether table
element for which lock type to be determined belongs to
prelocking list.
sql/sql_yacc.yy:
- Removed st_select_lex::lock_option member as there is no
real need for per-SELECT lock type (HIGH_PRIORITY option
should apply to the whole statement. FOR UPDATE/LOCK IN
SHARE MODE clauses can be handled without this member).
The main effect which was achieved by introduction of this
member, i.e. using TL_READ_DEFAULT lock type for
subqueries, is now achieved by setting LEX::lock_option
(or rather its replacement - Yacc_state::m_lock_type) to
TL_READ_DEFAULT in almost all cases.
- Replaced LEX::lock_option with Yacc_state::m_lock_type
in order to emphasize that this value is relevant only
during parsing. Unlike for LEX::lock_option the default
value for Yacc_state::m_lock_type is TL_READ_DEFAULT.
Note that for cases when it is OK to take a "weak" read
lock (e.g. simple SELECT) this lock type will be converted
to TL_READ at open_tables() time. So this change won't
cause negative change in behavior for such statements.
OTOH this change ensures that, for example, for SELECTs
which are used in stored functions TL_READ_NO_INSERT lock
is taken when necessary and as result calls to such stored
functions can be written to the binary log with correct
serialization.
- To be able more easily distinguish high-priority SELECTs
in st_select_lex::print() method we now use new flag
in st_select_lex::options bit-field.
2010-04-28 12:04:11 +02:00
|
|
|
/**
|
|
|
|
|
Indicates that this is a HIGH_PRIORITY SELECT.
|
|
|
|
|
Currently used only for printing of such selects.
|
|
|
|
|
Type of locks to be acquired is specified directly.
|
|
|
|
|
*/
|
|
|
|
|
#define SELECT_HIGH_PRIORITY (1ULL << 34) // SELECT, user
|
A pre-requisite patch for the fix for Bug#52044.
This patch also fixes Bug#55452 "SET PASSWORD is
replicated twice in RBR mode".
The goal of this patch is to remove the release of
metadata locks from close_thread_tables().
This is necessary to not mistakenly release
the locks in the course of a multi-step
operation that involves multiple close_thread_tables()
or close_tables_for_reopen().
On the same token, move statement commit outside
close_thread_tables().
Other cleanups:
Cleanup COM_FIELD_LIST.
Don't call close_thread_tables() in COM_SHUTDOWN -- there
are no open tables there that can be closed (we leave
the locked tables mode in THD destructor, and this
close_thread_tables() won't leave it anyway).
Make open_and_lock_tables() and open_and_lock_tables_derived()
call close_thread_tables() upon failure.
Remove the calls to close_thread_tables() that are now
unnecessary.
Simplify the back off condition in Open_table_context.
Streamline metadata lock handling in LOCK TABLES
implementation.
Add asserts to ensure correct life cycle of
statement transaction in a session.
Remove a piece of dead code that has also become redundant
after the fix for Bug 37521.
mysql-test/r/variables.result:
Update results: set @@autocommit and statement transaction/
prelocked mode.
mysql-test/r/view.result:
A harmless change in CHECK TABLE <view> status for a broken view.
If previously a failure to prelock all functions used in a view
would leave the connection in LTM_PRELOCKED mode, now we call
close_thread_tables() from open_and_lock_tables()
and leave prelocked mode, thus some check in mysql_admin_table() that
works only in prelocked/locked tables mode is no longer activated.
mysql-test/suite/rpl/r/rpl_row_implicit_commit_binlog.result:
Fixed Bug#55452 "SET PASSWORD is replicated twice in
RBR mode": extra binlog events are gone from the
binary log.
mysql-test/t/variables.test:
Add a test case: set autocommit and statement transaction/prelocked
mode.
sql/event_data_objects.cc:
Simplify code in Event_job_data::execute().
Move sp_head memory management to lex_end().
sql/event_db_repository.cc:
Move the release of metadata locks outside
close_thread_tables().
Make sure we call close_thread_tables() when
open_and_lock_tables() fails and remove extra
code from the events data dictionary.
Use close_mysql_tables(), a new internal
function to properly close mysql.* tables
in the data dictionary.
Contract Event_db_repository::drop_events_by_field,
drop_schema_events into one function.
When dropping all events in a schema,
make sure we don't mistakenly release all
locks acquired by DROP DATABASE. These
include locks on the database name
and the global intention exclusive
metadata lock.
sql/event_db_repository.h:
Function open_event_table() does not require an instance
of Event_db_repository.
sql/events.cc:
Use close_mysql_tables() instead of close_thread_tables()
to bootstrap events, since the latter no longer
releases metadata locks.
sql/ha_ndbcluster.cc:
- mysql_rm_table_part2 no longer releases
acquired metadata locks. Do it in the caller.
sql/ha_ndbcluster_binlog.cc:
Deploy the new protocol for closing thread
tables in run_query() and ndb_binlog_index
code.
sql/handler.cc:
Assert that we never call ha_commit_trans/
ha_rollback_trans in sub-statement, which
is now the case.
sql/handler.h:
Add an accessor to check whether THD_TRANS object
is empty (has no transaction started).
sql/log.cc:
Update a comment.
sql/log_event.cc:
Since now we commit/rollback statement transaction in
mysql_execute_command(), we need a mechanism to communicate
from Query_log_event::do_apply_event() to mysql_execute_command()
that the statement transaction should be rolled back, not committed.
Ideally it would be a virtual method of THD. I hesitate
to make THD a virtual base class in this already large patch.
Use a thd->variables.option_bits for now.
Remove a call to close_thread_tables() from the slave IO
thread. It doesn't open any tables, and the protocol
for closing thread tables is more complicated now.
Make sure we properly close thread tables, however,
in Load_data_log_event, which doesn't
follow the standard server execution procedure
with mysql_execute_command().
@todo: this piece should use Server_runnable
framework instead.
Remove an unnecessary call to mysql_unlock_tables().
sql/rpl_rli.cc:
Update Relay_log_info::slave_close_thread_tables()
to follow the new close protocol.
sql/set_var.cc:
Remove an unused header.
sql/slave.cc:
Remove an unnecessary call to
close_thread_tables().
sql/sp.cc:
Remove unnecessary calls to close_thread_tables()
from SP DDL implementation. The tables will
be closed by the caller, in mysql_execute_command().
When dropping all routines in a database, make sure
to not mistakenly drop all metadata locks acquired
so far, they include the scoped lock on the schema.
sql/sp_head.cc:
Correct the protocol that closes thread tables
in an SP instruction.
Clear lex->sphead before cleaning up lex
with lex_end to make sure that we don't
delete the sphead twice. It's considered
to be "cleaner" and more in line with
future changes than calling delete lex->sphead
in other places that cleanup the lex.
sql/sp_head.h:
When destroying m_lex_keeper of an instruction,
don't delete the sphead that all lex objects
share.
@todo: don't store a reference to routine's sp_head
instance in instruction's lex.
sql/sql_acl.cc:
Don't call close_thread_tables() where the caller will
do that for us.
Fix Bug#55452 "SET PASSWORD is replicated twice in RBR
mode" by disabling RBR replication in change_password()
function.
Use close_mysql_tables() in bootstrap and ACL reload
code to make sure we release all metadata locks.
sql/sql_base.cc:
This is the main part of the patch:
- remove manipulation with thd->transaction
and thd->mdl_context from close_thread_tables().
Now this function is only responsible for closing
tables, nothing else.
This is necessary to be able to easily use
close_thread_tables() in procedures, that
involve multiple open/close tables, which all
need to be protected continuously by metadata
locks.
Add asserts ensuring that TABLE object
is only used when is protected by a metadata lock.
Simplify the back off condition of Open_table_context,
we no longer need to look at the autocommit mode.
Make open_and_lock_tables() and open_normal_and_derived_tables()
close thread tables and release metadata locks acquired so-far
upon failure. This simplifies their usage.
Implement close_mysql_tables().
sql/sql_base.h:
Add declaration for close_mysql_tables().
sql/sql_class.cc:
Remove a piece of dead code that has also become redundant
after the fix for Bug 37521.
The code became dead when my_eof() was made a non-protocol method,
but a method that merely modifies the diagnostics area.
The code became redundant with the fix for Bug#37521, when
we started to cal close_thread_tables() before
Protocol::end_statement().
sql/sql_do.cc:
Do nothing in DO if inside a substatement
(the assert moved out of trans_rollback_stmt).
sql/sql_handler.cc:
Add comments.
sql/sql_insert.cc:
Remove dead code.
Release metadata locks explicitly at the
end of the delayed insert thread.
sql/sql_lex.cc:
Add destruction of lex->sphead to lex_end(),
lex "reset" method called at the end of each statement.
sql/sql_parse.cc:
Move close_thread_tables() and other related
cleanups to mysql_execute_command()
from dispatch_command(). This has become
possible after the fix for Bug#37521.
Mark federated SERVER statements as DDL.
Next step: make sure that we don't store
eof packet in the query cache, and move
the query cache code outside mysql_parse.
Brush up the code of COM_FIELD_LIST.
Remove unnecessary calls to close_thread_tables().
When killing a query, don't report "OK"
if it was a suicide.
sql/sql_parse.h:
Remove declaration of a function that is now static.
sql/sql_partition.cc:
Remove an unnecessary call to close_thread_tables().
sql/sql_plugin.cc:
open_and_lock_tables() will clean up
after itself after a failure.
Move close_thread_tables() above
end: label, and replace with close_mysql_tables(),
which will also release the metadata lock
on mysql.plugin.
sql/sql_prepare.cc:
Now that we no longer release locks in close_thread_tables()
statement prepare code has become more straightforward.
Remove the now redundant check for thd->killed() (used
only by the backup project) from Execute_server_runnable.
Reorder code to take into account that now mysql_execute_command()
performs lex->unit.cleanup() and close_thread_tables().
sql/sql_priv.h:
Add a new option to server options to interact
between the slave SQL thread and execution
framework (hack). @todo: use a virtual
method of class THD instead.
sql/sql_servers.cc:
Due to Bug 25705 replication of
DROP/CREATE/ALTER SERVER is broken.
Make sure at least we do not attempt to
replicate these statements using RBR,
as this violates the assert in close_mysql_tables().
sql/sql_table.cc:
Do not release metadata locks in mysql_rm_table_part2,
this is done by the caller.
Do not call close_thread_tables() in mysql_create_table(),
this is done by the caller.
Fix a bug in DROP TABLE under LOCK TABLES when,
upon error in wait_while_table_is_used() we would mistakenly
release the metadata lock on a non-dropped table.
Explicitly release metadata locks when doing an implicit
commit.
sql/sql_trigger.cc:
Now that we delete lex->sphead in lex_end(),
zero the trigger's sphead in lex after loading
the trigger, to avoid double deletion.
sql/sql_udf.cc:
Use close_mysql_tables() instead of close_thread_tables().
sql/sys_vars.cc:
Remove code added in scope of WL#4284 which would
break when we perform set @@session.autocommit along
with setting other variables and using tables or functions.
A test case added to variables.test.
sql/transaction.cc:
Add asserts.
sql/tztime.cc:
Use close_mysql_tables() rather than close_thread_tables().
2010-07-27 12:25:53 +02:00
|
|
|
/**
|
|
|
|
|
Is set in slave SQL thread when there was an
|
|
|
|
|
error on master, which, when is not reproducible
|
|
|
|
|
on slave (i.e. the query succeeds on slave),
|
|
|
|
|
is not terminal to the state of repliation,
|
|
|
|
|
and should be ignored. The slave SQL thread,
|
|
|
|
|
however, needs to rollback the effects of the
|
|
|
|
|
succeeded statement to keep replication consistent.
|
|
|
|
|
*/
|
2013-04-07 14:00:16 +02:00
|
|
|
#define OPTION_MASTER_SQL_ERROR (1ULL << 35)
|
2010-03-31 16:05:33 +02:00
|
|
|
|
2013-04-07 14:00:16 +02:00
|
|
|
#define OPTION_SKIP_REPLICATION (1ULL << 37) // THD, user
|
2015-02-06 10:02:02 +01:00
|
|
|
#define OPTION_RPL_SKIP_PARALLEL (1ULL << 38)
|
2018-05-22 19:08:39 +02:00
|
|
|
#define OPTION_NO_QUERY_CACHE (1ULL << 39) // SELECT, user
|
|
|
|
|
#define OPTION_PROCEDURE_CLAUSE (1ULL << 40) // Internal usage
|
2019-12-30 12:56:19 +01:00
|
|
|
#define SELECT_NO_UNLOCK (1ULL << 41) // SELECT, intern
|
2020-01-28 22:23:51 +01:00
|
|
|
#define OPTION_BIN_TMP_LOG_OFF (1ULL << 42) // disable binlog, intern
|
2020-06-18 10:57:19 +02:00
|
|
|
/* Disable commit of binlog. Used to combine many DDL's and DML's as one */
|
|
|
|
|
#define OPTION_BIN_COMMIT_OFF (1ULL << 43)
|
2022-07-02 12:22:10 +02:00
|
|
|
/* The following is used to detect a conflict with DISTINCT */
|
|
|
|
|
#define SELECT_ALL (1ULL << 44) // SELECT, user, parser
|
2018-05-22 19:08:39 +02:00
|
|
|
|
|
|
|
|
#define OPTION_LEX_FOUND_COMMENT (1ULL << 0) // intern, parser
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
/* The rest of the file is included in the server only */
|
|
|
|
|
#ifndef MYSQL_CLIENT
|
|
|
|
|
|
2023-06-19 20:42:16 +02:00
|
|
|
/* @@optimizer_switch flags. These must be in sync with optimizer_switch_names */
|
2010-03-31 16:05:33 +02:00
|
|
|
#define OPTIMIZER_SWITCH_INDEX_MERGE (1ULL << 0)
|
|
|
|
|
#define OPTIMIZER_SWITCH_INDEX_MERGE_UNION (1ULL << 1)
|
|
|
|
|
#define OPTIMIZER_SWITCH_INDEX_MERGE_SORT_UNION (1ULL << 2)
|
|
|
|
|
#define OPTIMIZER_SWITCH_INDEX_MERGE_INTERSECT (1ULL << 3)
|
2011-10-19 21:45:18 +02:00
|
|
|
#define OPTIMIZER_SWITCH_INDEX_MERGE_SORT_INTERSECT (1ULL << 4)
|
2014-08-25 23:13:37 +02:00
|
|
|
#define deprecated_ENGINE_CONDITION_PUSHDOWN (1ULL << 5)
|
2011-10-19 21:45:18 +02:00
|
|
|
#define OPTIMIZER_SWITCH_INDEX_COND_PUSHDOWN (1ULL << 6)
|
|
|
|
|
#define OPTIMIZER_SWITCH_DERIVED_MERGE (1ULL << 7)
|
|
|
|
|
#define OPTIMIZER_SWITCH_DERIVED_WITH_KEYS (1ULL << 8)
|
|
|
|
|
#define OPTIMIZER_SWITCH_FIRSTMATCH (1ULL << 9)
|
|
|
|
|
#define OPTIMIZER_SWITCH_LOOSE_SCAN (1ULL << 10)
|
|
|
|
|
#define OPTIMIZER_SWITCH_MATERIALIZATION (1ULL << 11)
|
|
|
|
|
#define OPTIMIZER_SWITCH_IN_TO_EXISTS (1ULL << 12)
|
|
|
|
|
#define OPTIMIZER_SWITCH_SEMIJOIN (1ULL << 13)
|
|
|
|
|
#define OPTIMIZER_SWITCH_PARTIAL_MATCH_ROWID_MERGE (1ULL << 14)
|
|
|
|
|
#define OPTIMIZER_SWITCH_PARTIAL_MATCH_TABLE_SCAN (1ULL << 15)
|
|
|
|
|
#define OPTIMIZER_SWITCH_SUBQUERY_CACHE (1ULL << 16)
|
|
|
|
|
/** If this is off, MRR is never used. */
|
|
|
|
|
#define OPTIMIZER_SWITCH_MRR (1ULL << 17)
|
|
|
|
|
/**
|
|
|
|
|
If OPTIMIZER_SWITCH_MRR is on and this is on, MRR is used depending on a
|
|
|
|
|
cost-based choice ("automatic"). If OPTIMIZER_SWITCH_MRR is on and this is
|
|
|
|
|
off, MRR is "forced" (i.e. used as long as the storage engine is capable of
|
|
|
|
|
doing it).
|
|
|
|
|
*/
|
|
|
|
|
#define OPTIMIZER_SWITCH_MRR_COST_BASED (1ULL << 18)
|
|
|
|
|
#define OPTIMIZER_SWITCH_MRR_SORT_KEYS (1ULL << 19)
|
|
|
|
|
#define OPTIMIZER_SWITCH_OUTER_JOIN_WITH_CACHE (1ULL << 20)
|
|
|
|
|
#define OPTIMIZER_SWITCH_SEMIJOIN_WITH_CACHE (1ULL << 21)
|
|
|
|
|
#define OPTIMIZER_SWITCH_JOIN_CACHE_INCREMENTAL (1ULL << 22)
|
|
|
|
|
#define OPTIMIZER_SWITCH_JOIN_CACHE_HASHED (1ULL << 23)
|
|
|
|
|
#define OPTIMIZER_SWITCH_JOIN_CACHE_BKA (1ULL << 24)
|
|
|
|
|
#define OPTIMIZER_SWITCH_OPTIMIZE_JOIN_BUFFER_SIZE (1ULL << 25)
|
|
|
|
|
#define OPTIMIZER_SWITCH_TABLE_ELIMINATION (1ULL << 26)
|
2012-03-03 00:03:20 +01:00
|
|
|
#define OPTIMIZER_SWITCH_EXTENDED_KEYS (1ULL << 27)
|
2013-02-26 00:20:17 +01:00
|
|
|
#define OPTIMIZER_SWITCH_EXISTS_TO_IN (1ULL << 28)
|
2016-06-01 22:43:11 +02:00
|
|
|
#define OPTIMIZER_SWITCH_ORDERBY_EQ_PROP (1ULL << 29)
|
2016-09-01 01:16:54 +02:00
|
|
|
#define OPTIMIZER_SWITCH_COND_PUSHDOWN_FOR_DERIVED (1ULL << 30)
|
2017-12-30 21:29:09 +01:00
|
|
|
#define OPTIMIZER_SWITCH_SPLIT_MATERIALIZED (1ULL << 31)
|
2018-05-15 23:45:59 +02:00
|
|
|
#define OPTIMIZER_SWITCH_COND_PUSHDOWN_FOR_SUBQUERY (1ULL << 32)
|
2018-08-15 23:24:52 +02:00
|
|
|
#define OPTIMIZER_SWITCH_USE_ROWID_FILTER (1ULL << 33)
|
2018-06-17 19:48:00 +02:00
|
|
|
#define OPTIMIZER_SWITCH_COND_PUSHDOWN_FROM_HAVING (1ULL << 34)
|
2019-08-31 03:47:14 +02:00
|
|
|
#define OPTIMIZER_SWITCH_NOT_NULL_RANGE_SCAN (1ULL << 35)
|
2010-03-31 16:05:33 +02:00
|
|
|
|
2011-10-19 21:45:18 +02:00
|
|
|
#define OPTIMIZER_SWITCH_DEFAULT (OPTIMIZER_SWITCH_INDEX_MERGE | \
|
2010-11-25 18:17:28 +01:00
|
|
|
OPTIMIZER_SWITCH_INDEX_MERGE_UNION | \
|
|
|
|
|
OPTIMIZER_SWITCH_INDEX_MERGE_SORT_UNION | \
|
|
|
|
|
OPTIMIZER_SWITCH_INDEX_MERGE_INTERSECT | \
|
2011-11-27 17:46:20 +01:00
|
|
|
OPTIMIZER_SWITCH_INDEX_COND_PUSHDOWN | \
|
2012-01-13 15:50:02 +01:00
|
|
|
OPTIMIZER_SWITCH_DERIVED_MERGE | \
|
|
|
|
|
OPTIMIZER_SWITCH_DERIVED_WITH_KEYS | \
|
2011-10-19 21:45:18 +02:00
|
|
|
OPTIMIZER_SWITCH_TABLE_ELIMINATION | \
|
2014-02-24 22:18:13 +01:00
|
|
|
OPTIMIZER_SWITCH_EXTENDED_KEYS | \
|
2011-10-19 21:45:18 +02:00
|
|
|
OPTIMIZER_SWITCH_IN_TO_EXISTS | \
|
2011-11-27 17:46:20 +01:00
|
|
|
OPTIMIZER_SWITCH_MATERIALIZATION | \
|
2010-11-25 18:17:28 +01:00
|
|
|
OPTIMIZER_SWITCH_PARTIAL_MATCH_ROWID_MERGE|\
|
|
|
|
|
OPTIMIZER_SWITCH_PARTIAL_MATCH_TABLE_SCAN|\
|
2012-01-13 15:50:02 +01:00
|
|
|
OPTIMIZER_SWITCH_OUTER_JOIN_WITH_CACHE | \
|
|
|
|
|
OPTIMIZER_SWITCH_SEMIJOIN_WITH_CACHE | \
|
2011-10-19 21:45:18 +02:00
|
|
|
OPTIMIZER_SWITCH_JOIN_CACHE_INCREMENTAL | \
|
|
|
|
|
OPTIMIZER_SWITCH_JOIN_CACHE_HASHED | \
|
2011-11-22 18:04:38 +01:00
|
|
|
OPTIMIZER_SWITCH_JOIN_CACHE_BKA | \
|
2012-01-13 15:50:02 +01:00
|
|
|
OPTIMIZER_SWITCH_SUBQUERY_CACHE | \
|
2011-11-22 18:04:38 +01:00
|
|
|
OPTIMIZER_SWITCH_SEMIJOIN | \
|
|
|
|
|
OPTIMIZER_SWITCH_FIRSTMATCH | \
|
2014-06-09 12:42:21 +02:00
|
|
|
OPTIMIZER_SWITCH_LOOSE_SCAN | \
|
2016-05-01 21:29:47 +02:00
|
|
|
OPTIMIZER_SWITCH_EXISTS_TO_IN | \
|
2016-09-24 14:27:56 +02:00
|
|
|
OPTIMIZER_SWITCH_ORDERBY_EQ_PROP | \
|
2017-08-04 06:19:19 +02:00
|
|
|
OPTIMIZER_SWITCH_COND_PUSHDOWN_FOR_DERIVED | \
|
2018-05-15 23:45:59 +02:00
|
|
|
OPTIMIZER_SWITCH_SPLIT_MATERIALIZED | \
|
2019-02-19 12:18:17 +01:00
|
|
|
OPTIMIZER_SWITCH_COND_PUSHDOWN_FOR_SUBQUERY | \
|
2018-06-17 19:48:00 +02:00
|
|
|
OPTIMIZER_SWITCH_USE_ROWID_FILTER | \
|
2019-02-19 12:18:17 +01:00
|
|
|
OPTIMIZER_SWITCH_COND_PUSHDOWN_FROM_HAVING | \
|
2019-02-18 13:05:17 +01:00
|
|
|
OPTIMIZER_SWITCH_OPTIMIZE_JOIN_BUFFER_SIZE)
|
2017-08-04 06:19:19 +02:00
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
/*
|
|
|
|
|
Replication uses 8 bytes to store SQL_MODE in the binary log. The day you
|
|
|
|
|
use strictly more than 64 bits by adding one more define above, you should
|
|
|
|
|
contact the replication team because the replication code should then be
|
|
|
|
|
updated (to store more bytes on disk).
|
|
|
|
|
|
|
|
|
|
NOTE: When adding new SQL_MODE types, make sure to also add them to
|
|
|
|
|
the scripts used for creating the MySQL system tables
|
|
|
|
|
in scripts/mysql_system_tables.sql and scripts/mysql_system_tables_fix.sql
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2010-12-14 11:46:00 +01:00
|
|
|
/*
|
|
|
|
|
Flags below are set when we perform
|
|
|
|
|
context analysis of the statement and make
|
|
|
|
|
subqueries non-const. It prevents subquery
|
|
|
|
|
evaluation at context analysis stage.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Don't evaluate this subquery during statement prepare even if
|
|
|
|
|
it's a constant one. The flag is switched off in the end of
|
|
|
|
|
mysqld_stmt_prepare.
|
|
|
|
|
*/
|
|
|
|
|
#define CONTEXT_ANALYSIS_ONLY_PREPARE 1
|
|
|
|
|
/*
|
|
|
|
|
Special JOIN::prepare mode: changing of query is prohibited.
|
|
|
|
|
When creating a view, we need to just check its syntax omitting
|
|
|
|
|
any optimizations: afterwards definition of the view will be
|
|
|
|
|
reconstructed by means of ::print() methods and written to
|
|
|
|
|
to an .frm file. We need this definition to stay untouched.
|
|
|
|
|
*/
|
|
|
|
|
#define CONTEXT_ANALYSIS_ONLY_VIEW 2
|
|
|
|
|
/*
|
|
|
|
|
Don't evaluate this subquery during derived table prepare even if
|
|
|
|
|
it's a constant one.
|
|
|
|
|
*/
|
|
|
|
|
#define CONTEXT_ANALYSIS_ONLY_DERIVED 4
|
2011-10-19 21:45:18 +02:00
|
|
|
/*
|
|
|
|
|
Don't evaluate constant sub-expressions of virtual column
|
|
|
|
|
expressions when opening tables
|
|
|
|
|
*/
|
|
|
|
|
#define CONTEXT_ANALYSIS_ONLY_VCOL_EXPR 8
|
2010-12-14 11:46:00 +01:00
|
|
|
|
2011-10-19 21:45:18 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Uncachable causes:
|
|
|
|
|
*/
|
|
|
|
|
/* This subquery has fields from outer query (put by user) */
|
|
|
|
|
#define UNCACHEABLE_DEPENDENT_GENERATED 1
|
|
|
|
|
/* This subquery contains functions with random result */
|
2010-03-31 16:05:33 +02:00
|
|
|
#define UNCACHEABLE_RAND 2
|
2011-10-19 21:45:18 +02:00
|
|
|
/* This subquery contains functions with side effect */
|
2010-03-31 16:05:33 +02:00
|
|
|
#define UNCACHEABLE_SIDEEFFECT 4
|
2011-10-19 21:45:18 +02:00
|
|
|
/* Forcing to save JOIN tables for explain */
|
2010-03-31 16:05:33 +02:00
|
|
|
#define UNCACHEABLE_EXPLAIN 8
|
|
|
|
|
/* For uncorrelated SELECT in an UNION with some correlated SELECTs */
|
2010-12-14 11:46:00 +01:00
|
|
|
#define UNCACHEABLE_UNITED 16
|
|
|
|
|
#define UNCACHEABLE_CHECKOPTION 32
|
2011-10-19 21:45:18 +02:00
|
|
|
/*
|
|
|
|
|
This subquery has fields from outer query injected during
|
|
|
|
|
transformation process
|
|
|
|
|
*/
|
|
|
|
|
#define UNCACHEABLE_DEPENDENT_INJECTED 64
|
|
|
|
|
/* This subquery has fields from outer query (any nature) */
|
|
|
|
|
#define UNCACHEABLE_DEPENDENT (UNCACHEABLE_DEPENDENT_GENERATED | \
|
|
|
|
|
UNCACHEABLE_DEPENDENT_INJECTED)
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
/* Used to check GROUP BY list in the MODE_ONLY_FULL_GROUP_BY mode */
|
|
|
|
|
#define UNDEF_POS (-1)
|
|
|
|
|
|
2017-11-04 19:14:34 +01:00
|
|
|
#define IN_SUBQUERY_CONVERSION_THRESHOLD 1000
|
|
|
|
|
|
2016-02-26 11:34:27 +01:00
|
|
|
#endif /* !MYSQL_CLIENT */
|
|
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
/* BINLOG_DUMP options */
|
|
|
|
|
|
|
|
|
|
#define BINLOG_DUMP_NON_BLOCK 1
|
2011-10-19 21:45:18 +02:00
|
|
|
#define BINLOG_SEND_ANNOTATE_ROWS_EVENT 2
|
|
|
|
|
|
|
|
|
|
#ifndef MYSQL_CLIENT
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
/*
|
MDEV-15563: Instant ROW_FORMAT=REDUNDANT column extension
This was developed by Aleksey Midenkov based on my design.
In the original InnoDB storage format (that was retroactively named
ROW_FORMAT=REDUNDANT in MySQL 5.0.3), the length of each index field
is stored explicitly.
Because of this, we can and now will allow instant conversion from
VARCHAR to CHAR or VARBINARY to BINARY of equal or greater size,
as well as instant conversion of TINYINT to SMALLINT to MEDIUMINT
to INT to BIGINT (while not changing between signed and unsigned).
Theoretically, we could allow changing from an unsigned integer to
a bigger unsigned integer, as well as changing CHAR to VARCHAR, but
that would require additional metadata and conversions whenever
reading old records.
Field_str::is_equal(), Field_varstring::is_equal(), Field_num::is_equal():
Return the new result IS_EQUAL_PACK_LENGTH_EXT if the table advertises
HA_EXTENDED_TYPES_CONVERSION capability and we are considering the
above-mentioned conversions.
ALTER_COLUMN_EQUAL_PACK_LENGTH_EXT: A new ALTER TABLE flag, similar
to ALTER_COLUMN_EQUAL_PACK_LENGTH but requiring conversions when
reading the data. The Field::is_equal() result IS_EQUAL_PACK_LENGTH_EXT
will map to this flag.
dtype_get_fixed_size_low(): For BINARY, CHAR and integer columns
in ROW_FORMAT=REDUNDANT, return 0 (variable length) from now on.
dtype_get_sql_null_size(): Keep returning the current size for
BINARY, CHAR and integer columns, so that in ROW_FORMAT=REDUNDANT
it will remain possible to update in place between NULL and NOT NULL
values.
btr_index_rec_validate(): Relax a CHECK TABLE length check for
ROW_FORMAT=REDUNDANT tables.
btr_cur_instant_init_low(): No longer trust fixed_len
for ROW_FORMAT=REDUNDANT tables.
We cannot rely on fixed_len anymore because the record can have shorter
length from before instant extension. Note that importing such tablespace
into earlier MariaDB versions produces ER_TABLE_SCHEMA_MISMATCH when
using a .cfg file.
2019-02-13 16:39:05 +01:00
|
|
|
Field::is_equal() return codes.
|
2010-03-31 16:05:33 +02:00
|
|
|
*/
|
|
|
|
|
#define IS_EQUAL_NO 0
|
|
|
|
|
#define IS_EQUAL_YES 1
|
MDEV-15563: Instant ROW_FORMAT=REDUNDANT column extension
This was developed by Aleksey Midenkov based on my design.
In the original InnoDB storage format (that was retroactively named
ROW_FORMAT=REDUNDANT in MySQL 5.0.3), the length of each index field
is stored explicitly.
Because of this, we can and now will allow instant conversion from
VARCHAR to CHAR or VARBINARY to BINARY of equal or greater size,
as well as instant conversion of TINYINT to SMALLINT to MEDIUMINT
to INT to BIGINT (while not changing between signed and unsigned).
Theoretically, we could allow changing from an unsigned integer to
a bigger unsigned integer, as well as changing CHAR to VARCHAR, but
that would require additional metadata and conversions whenever
reading old records.
Field_str::is_equal(), Field_varstring::is_equal(), Field_num::is_equal():
Return the new result IS_EQUAL_PACK_LENGTH_EXT if the table advertises
HA_EXTENDED_TYPES_CONVERSION capability and we are considering the
above-mentioned conversions.
ALTER_COLUMN_EQUAL_PACK_LENGTH_EXT: A new ALTER TABLE flag, similar
to ALTER_COLUMN_EQUAL_PACK_LENGTH but requiring conversions when
reading the data. The Field::is_equal() result IS_EQUAL_PACK_LENGTH_EXT
will map to this flag.
dtype_get_fixed_size_low(): For BINARY, CHAR and integer columns
in ROW_FORMAT=REDUNDANT, return 0 (variable length) from now on.
dtype_get_sql_null_size(): Keep returning the current size for
BINARY, CHAR and integer columns, so that in ROW_FORMAT=REDUNDANT
it will remain possible to update in place between NULL and NOT NULL
values.
btr_index_rec_validate(): Relax a CHECK TABLE length check for
ROW_FORMAT=REDUNDANT tables.
btr_cur_instant_init_low(): No longer trust fixed_len
for ROW_FORMAT=REDUNDANT tables.
We cannot rely on fixed_len anymore because the record can have shorter
length from before instant extension. Note that importing such tablespace
into earlier MariaDB versions produces ER_TABLE_SCHEMA_MISMATCH when
using a .cfg file.
2019-02-13 16:39:05 +01:00
|
|
|
/**
|
|
|
|
|
new_field has compatible packed representation with old type,
|
|
|
|
|
so it is theoretically possible to perform change by only updating
|
|
|
|
|
data dictionary without changing table rows
|
|
|
|
|
*/
|
2010-03-31 16:05:33 +02:00
|
|
|
#define IS_EQUAL_PACK_LENGTH 2
|
|
|
|
|
|
|
|
|
|
enum enum_parsing_place
|
|
|
|
|
{
|
|
|
|
|
NO_MATTER,
|
|
|
|
|
IN_HAVING,
|
|
|
|
|
SELECT_LIST,
|
|
|
|
|
IN_WHERE,
|
2010-11-25 18:17:28 +01:00
|
|
|
IN_ON,
|
|
|
|
|
IN_GROUP_BY,
|
2016-03-24 00:09:58 +01:00
|
|
|
IN_ORDER_BY,
|
2017-10-28 20:54:18 +02:00
|
|
|
IN_UPDATE_ON_DUP_KEY,
|
2017-10-28 21:54:22 +02:00
|
|
|
IN_PART_FUNC,
|
2018-05-22 19:08:39 +02:00
|
|
|
BEFORE_OPT_LIST,
|
|
|
|
|
AFTER_LIST,
|
|
|
|
|
FOR_LOOP_BOUND,
|
2022-09-26 09:59:10 +02:00
|
|
|
IN_RETURNING,
|
2010-11-25 18:17:28 +01:00
|
|
|
PARSING_PLACE_SIZE /* always should be the last */
|
2010-03-31 16:05:33 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class sys_var;
|
|
|
|
|
|
Draft patch that fixes and a sketches test cases for:
Bug#20837 Apparent change of isolation level during transaction,
Bug#46527 COMMIT AND CHAIN RELEASE does not make sense,
Bug#53343 completion_type=1, COMMIT/ROLLBACK AND CHAIN don't
preserve the isolation level
Bug#53346 completion_type has strange effect in a stored
procedure/prepared statement
Make thd->tx_isolation mean strictly "current transaction
isolation level"
Make thd->variables.tx_isolation mean "current session isolation
level".
The current transaction isolation level is now established
at transaction start. If there was a SET TRANSACTION
ISOLATION LEVEL statement, the value is taken from it.
Otherwise, the session value is used.
A change in a session value, made while a transaction is active,
whereas still allowed, no longer has any effect on the
current transaction isolation level. This is an incompatible
change.
A change in a session isolation level, made while there is
no active transaction, overrides SET TRANSACTION statement,
if there was any.
Changed the impelmentation to not look at @@session.completion_type
in the parser, and thus fixed Bug#53346.
Changed the parser to not allow AND NO CHAIN RELEASE,
and thus fixed Bug#46527.
Changed the transaction API to take the current transaction
isolation level into account:
- BEGIN/COMMIT now do preserve the current transaction
isolation level if chaining is on.
- implicit commit, XA COMMIT or XA ROLLBACK or autocommit don't.
2010-05-07 18:28:59 +02:00
|
|
|
enum enum_yes_no_unknown
|
|
|
|
|
{
|
|
|
|
|
TVL_YES, TVL_NO, TVL_UNKNOWN
|
|
|
|
|
};
|
|
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
#ifdef MYSQL_SERVER
|
2012-03-19 09:35:32 +01:00
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
/*
|
|
|
|
|
External variables
|
|
|
|
|
*/
|
|
|
|
|
|
2012-05-16 17:20:00 +02:00
|
|
|
|
2021-05-23 18:38:46 +02:00
|
|
|
/* yy_*.cc */
|
2010-03-31 16:05:33 +02:00
|
|
|
#ifndef DBUG_OFF
|
2019-11-21 09:29:07 +01:00
|
|
|
extern void turn_parser_debug_on_MYSQLparse();
|
|
|
|
|
extern void turn_parser_debug_on_ORAparse();
|
2010-03-31 16:05:33 +02:00
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
convert a hex digit into number.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
inline int hexchar_to_int(char c)
|
|
|
|
|
{
|
|
|
|
|
if (c <= '9' && c >= '0')
|
|
|
|
|
return c-'0';
|
|
|
|
|
c|=32;
|
|
|
|
|
if (c <= 'f' && c >= 'a')
|
|
|
|
|
return c-'a'+10;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This must match the path length limit in the ER_NOT_RW_DIR error msg. */
|
|
|
|
|
#define ER_NOT_RW_DIR_PATHSIZE 200
|
|
|
|
|
|
|
|
|
|
#define IS_TABLESPACES_TABLESPACE_NAME 0
|
|
|
|
|
#define IS_TABLESPACES_ENGINE 1
|
|
|
|
|
#define IS_TABLESPACES_TABLESPACE_TYPE 2
|
|
|
|
|
#define IS_TABLESPACES_LOGFILE_GROUP_NAME 3
|
|
|
|
|
#define IS_TABLESPACES_EXTENT_SIZE 4
|
|
|
|
|
#define IS_TABLESPACES_AUTOEXTEND_SIZE 5
|
|
|
|
|
#define IS_TABLESPACES_MAXIMUM_SIZE 6
|
|
|
|
|
#define IS_TABLESPACES_NODEGROUP_ID 7
|
|
|
|
|
#define IS_TABLESPACES_TABLESPACE_COMMENT 8
|
|
|
|
|
|
2012-10-18 23:33:06 +02:00
|
|
|
bool db_name_is_in_ignore_db_dirs_list(const char *dbase);
|
|
|
|
|
|
2010-03-31 16:05:33 +02:00
|
|
|
#endif /* MYSQL_SERVER */
|
|
|
|
|
|
|
|
|
|
#endif /* MYSQL_CLIENT */
|
|
|
|
|
|
2010-04-21 00:29:30 +02:00
|
|
|
#endif /* SQL_PRIV_INCLUDED */
|