database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-27 18:02:13 +03:00
Code Activity

BUG#39934: Slave stops for engine that only support row-based logging

Browse Source 
General overview:
The logic for switching to row format when binlog_format=MIXED had
numerous flaws. The underlying problem was the lack of a consistent
architecture.
General purpose of this changeset:
This changeset introduces an architecture for switching to row format
when binlog_format=MIXED. It enforces the architecture where it has
to. It leaves some bugs to be fixed later. It adds extensive tests to
verify that unsafe statements work as expected and that appropriate
errors are produced by problems with the selection of binlog format.
It was not practical to split this into smaller pieces of work.

Problem 1:
To determine the logging mode, the code has to take several parameters
into account (namely: (1) the value of binlog_format; (2) the
capabilities of the engines; (3) the type of the current statement:
normal, unsafe, or row injection). These parameters may conflict in
several ways, namely:
 - binlog_format=STATEMENT for a row injection
 - binlog_format=STATEMENT for an unsafe statement
 - binlog_format=STATEMENT for an engine only supporting row logging
 - binlog_format=ROW for an engine only supporting statement logging
 - statement is unsafe and engine does not support row logging
 - row injection in a table that does not support statement logging
 - statement modifies one table that does not support row logging and
   one that does not support statement logging
Several of these conflicts were not detected, or were detected with
an inappropriate error message. The problem of BUG#39934 was that no
appropriate error message was written for the case when an engine
only supporting row logging executed a row injection with
binlog_format=ROW. However, all above cases must be handled.
Fix 1:
Introduce new error codes (sql/share/errmsg.txt). Ensure that all
conditions are detected and handled in decide_logging_format()

Problem 2:
The binlog format shall be determined once per statement, in
decide_logging_format(). It shall not be changed before or after that.
Before decide_logging_format() is called, all information necessary to
determine the logging format must be available. This principle ensures
that all unsafe statements are handled in a consistent way.
However, this principle is not followed:
thd->set_current_stmt_binlog_row_based_if_mixed() is called in several
places, including from code executing UPDATE..LIMIT,
INSERT..SELECT..LIMIT, DELETE..LIMIT, INSERT DELAYED, and
SET @@binlog_format. After Problem 1 was fixed, that caused
inconsistencies where these unsafe statements would not print the
appropriate warnings or errors for some of the conflicts.
Fix 2:
Remove calls to THD::set_current_stmt_binlog_row_based_if_mixed() from
code executed after decide_logging_format(). Compensate by calling the
set_current_stmt_unsafe() at parse time. This way, all unsafe statements
are detected by decide_logging_format().

Problem 3:
INSERT DELAYED is not unsafe: it is logged in statement format even if
binlog_format=MIXED, and no warning is printed even if
binlog_format=STATEMENT. This is BUG#45825.
Fix 3:
Made INSERT DELAYED set itself to unsafe at parse time. This allows
decide_logging_format() to detect that a warning should be printed or
the binlog_format changed.

Problem 4:
LIMIT clause were not marked as unsafe when executed inside stored
functions/triggers/views/prepared statements. This is
BUG#45785.
Fix 4:
Make statements containing the LIMIT clause marked as unsafe at
parse time, instead of at execution time. This allows propagating
unsafe-ness to the view.
This commit is contained in:
Sven Sandberg
2009-07-14 21:31:19 +02:00
parent 81b5a391b0
commit f3985c649d
110 changed files with 4967 additions and 6362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
sql/sql_lex.h
View File

@ -1044,24 +1044,49 @@ public:
}
/**
Has the parser/scanner detected that this statement is unsafe?
*/
Has the parser/scanner detected that this statement is unsafe?
@retval 0 if the statement is not marked as unsafe
@retval nonzero if the statement is marked as unsafe
*/
inline bool is_stmt_unsafe() const {
return binlog_stmt_flags & (1U << BINLOG_STMT_FLAG_UNSAFE);
}
/**
Is this statement actually a row injection?
@retval 0 if the statement is not a row injection
@retval nonzero if the statement is a row injection
*/
inline bool is_stmt_row_injection() const {
return binlog_stmt_flags & (1U << BINLOG_STMT_FLAG_ROW_INJECTION);
}
/**
Flag the statement as a row injection. (A row injection is either
a BINLOG statement, or a row event in the relay log executed by
the slave SQL thread.)
*/
inline void set_stmt_row_injection() {
DBUG_ENTER("set_stmt_row_injection");
binlog_stmt_flags|= (1U << BINLOG_STMT_FLAG_ROW_INJECTION);
DBUG_VOID_RETURN;
}
/**
Flag the current (top-level) statement as unsafe.
The flag will be reset after the statement has finished.
*/
inline void set_stmt_unsafe() {
DBUG_ENTER("set_stmt_unsafe");
binlog_stmt_flags|= (1U << BINLOG_STMT_FLAG_UNSAFE);
DBUG_VOID_RETURN;
}
inline void clear_stmt_unsafe() {
DBUG_ENTER("clear_stmt_unsafe");
binlog_stmt_flags&= ~(1U << BINLOG_STMT_FLAG_UNSAFE);
DBUG_VOID_RETURN;
}
/**
@ -1072,16 +1097,37 @@ public:
{ return sroutines_list.elements != 0; }
private:
/**
Flags indicating properties of the statement with respect to
logging.
These are combined in a binary manner; e.g., an unsafe statement
has the bit (1<<BINLOG_STMT_FLAG_UNSAFE) set.
*/
enum enum_binlog_stmt_flag {
BINLOG_STMT_FLAG_UNSAFE,
/** The statement is unsafe to log in statement mode. */
BINLOG_STMT_FLAG_UNSAFE= 0,
/**
The statement is a row injection (i.e., either a BINLOG
statement or a row event executed by the slave SQL thread).
*/
BINLOG_STMT_FLAG_ROW_INJECTION,
/**
The last element of this enumeration type. Insert new members
above.
*/
BINLOG_STMT_FLAG_COUNT
};
/*
Tells if the parsing stage detected properties of the statement,
for example: that some items require row-based binlogging to give
a reliable binlog/replication, or if we will use stored functions
or triggers which themselves need require row-based binlogging.
/**
Indicates the type of statement with respect to binlogging.
This is typically zeroed before parsing a statement, set during
parsing (depending on the query), and read when deciding the
logging format of the current statement.
This is a binary combination of one or more bits (1<<flag), where
flag is a member of enum_binlog_stmt_flag.
*/
uint32 binlog_stmt_flags;
};
@ -1891,6 +1937,7 @@ typedef struct st_lex : public Query_tables_list
}
return FALSE;
}
} LEX;