summaryrefslogtreecommitdiff
path: root/sql
diff options
context:
space:
mode:
Diffstat (limited to 'sql')
-rw-r--r--sql/Makefile.am4
-rw-r--r--sql/ha_innodb.cc478
-rw-r--r--sql/ha_innodb.h22
-rw-r--r--sql/handler.cc65
-rw-r--r--sql/handler.h5
-rw-r--r--sql/item_func.cc3
-rw-r--r--sql/log_event.cc9
-rw-r--r--sql/mysqld.cc14
-rw-r--r--sql/nt_servc.cc2
-rw-r--r--sql/set_var.cc4
-rw-r--r--sql/slave.cc178
-rw-r--r--sql/sql_class.h1
-rw-r--r--sql/sql_lex.h5
-rw-r--r--sql/sql_parse.cc21
-rw-r--r--sql/sql_repl.cc67
-rw-r--r--sql/sql_select.cc3
-rw-r--r--sql/sql_yacc.yy9
17 files changed, 720 insertions, 170 deletions
diff --git a/sql/Makefile.am b/sql/Makefile.am
index a589f1379f9..e2494e50d96 100644
--- a/sql/Makefile.am
+++ b/sql/Makefile.am
@@ -114,8 +114,8 @@ sql_yacc.o: sql_yacc.cc sql_yacc.h
$(CXXCOMPILE) $(LM_CFLAGS) -c $<
lex_hash.h: lex.h gen_lex_hash.cc sql_yacc.h
- $(MAKE) gen_lex_hash
- ./gen_lex_hash > $@
+ $(MAKE) gen_lex_hash$(EXEEXT)
+ ./gen_lex_hash$(EXEEXT) > $@
# Hack to ensure that lex_hash.h is built early
sql_lex.o: lex_hash.h
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
index 72267f2426c..6e5a14cfb05 100644
--- a/sql/ha_innodb.cc
+++ b/sql/ha_innodb.cc
@@ -43,7 +43,9 @@ InnoDB */
pthread_mutex_t innobase_mutex;
/* Store MySQL definition of 'byte': in Linux it is char while InnoDB
-uses unsigned char */
+uses unsigned char; the header univ.i which we include next defines
+'byte' as a macro which expands to 'unsigned char' */
+
typedef byte mysql_byte;
#define INSIDE_HA_INNOBASE_CC
@@ -130,11 +132,44 @@ static void innobase_print_error(const char* db_errpfx, char* buffer);
/* General functions */
/**********************************************************************
+Save some CPU by testing the value of srv_thread_concurrency in inline
+functions. */
+inline
+void
+innodb_srv_conc_enter_innodb(
+/*=========================*/
+ trx_t* trx) /* in: transaction handle */
+{
+ if (srv_thread_concurrency >= 500) {
+
+ return;
+ }
+
+ srv_conc_enter_innodb(trx);
+}
+
+/**********************************************************************
+Save some CPU by testing the value of srv_thread_concurrency in inline
+functions. */
+inline
+void
+innodb_srv_conc_exit_innodb(
+/*========================*/
+ trx_t* trx) /* in: transaction handle */
+{
+ if (srv_thread_concurrency >= 500) {
+
+ return;
+ }
+
+ srv_conc_exit_innodb(trx);
+}
+
+/**********************************************************************
Releases possible search latch and InnoDB thread FIFO ticket. These should
be released at each SQL statement end, and also when mysqld passes the
control to the client. It does no harm to release these also in the middle
of an SQL statement. */
-static
inline
void
innobase_release_stat_resources(
@@ -183,7 +218,9 @@ innobase_active_small(void)
}
/************************************************************************
-Converts an InnoDB error code to a MySQL error code. */
+Converts an InnoDB error code to a MySQL error code and also tells to MySQL
+about a possible transaction rollback inside InnoDB caused by a lock wait
+timeout or a deadlock. */
static
int
convert_error_code_to_mysql(
@@ -206,10 +243,10 @@ convert_error_code_to_mysql(
} else if (error == (int) DB_ERROR) {
- return(HA_ERR_NO_ACTIVE_RECORD);
+ return(-1); /* unspecified error */
} else if (error == (int) DB_DEADLOCK) {
- /* Since we roll back the whole transaction, we must
+ /* Since we rolled back the whole transaction, we must
tell it also to MySQL so that MySQL knows to empty the
cached binlog for this transaction */
@@ -221,11 +258,10 @@ convert_error_code_to_mysql(
} else if (error == (int) DB_LOCK_WAIT_TIMEOUT) {
- /* Since we roll back the whole transaction, we must
+ /* Since we rolled back the whole transaction, we must
tell it also to MySQL so that MySQL knows to empty the
cached binlog for this transaction */
-
if (thd) {
ha_rollback(thd);
}
@@ -271,6 +307,9 @@ convert_error_code_to_mysql(
} else if (error == (int) DB_CORRUPTION) {
return(HA_ERR_CRASHED);
+ } else if (error == (int) DB_NO_SAVEPOINT) {
+
+ return(HA_ERR_NO_SAVEPOINT);
} else {
return(-1); // Unknown error
}
@@ -941,18 +980,23 @@ innobase_commit(
DBUG_ENTER("innobase_commit");
DBUG_PRINT("trans", ("ending transaction"));
- /* The flag thd->transaction.all.innodb_active_trans is set to 1
- in ::external_lock and ::start_stmt, and it is only set to 0 in
- a commit or a rollback. If it is 0 we know there cannot be resources
- to be freed and we can return immediately. */
+ trx = check_trx_exists(thd);
- if (thd->transaction.all.innodb_active_trans == 0) {
+ /* The flag thd->transaction.all.innodb_active_trans is set to 1 in
+ ::external_lock, ::start_stmt, and innobase_savepoint, and it is only
+ set to 0 in a commit or a rollback. If it is 0 we know there cannot be
+ resources to be freed and we could return immediately. For the time
+ being we play safe and do the cleanup though there should be nothing
+ to clean up. */
- DBUG_RETURN(0);
+ if (thd->transaction.all.innodb_active_trans == 0
+ && trx->conc_state != TRX_NOT_STARTED) {
+
+ fprintf(stderr,
+"InnoDB: Error: thd->transaction.all.innodb_active_trans == 0\n"
+"InnoDB: but trx->conc_state != TRX_NOT_STARTED\n");
}
- trx = check_trx_exists(thd);
-
if (trx_handle != (void*)&innodb_dummy_stmt_trx_handle
|| (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))) {
@@ -964,9 +1008,9 @@ innobase_commit(
/* If we had reserved the auto-inc lock for some
table in this SQL statement we release it now */
- srv_conc_enter_innodb(trx);
+ innodb_srv_conc_enter_innodb(trx);
row_unlock_table_autoinc_for_mysql(trx);
- srv_conc_exit_innodb(trx);
+ innodb_srv_conc_exit_innodb(trx);
}
/* Store the current undo_no of the transaction so that we
know where to roll back if we have to roll back the next
@@ -1050,7 +1094,7 @@ innobase_commit_complete(
}
/*********************************************************************
-Rolls back a transaction or the latest SQL statement in an InnoDB database. */
+Rolls back a transaction or the latest SQL statement. */
int
innobase_rollback(
@@ -1071,25 +1115,64 @@ innobase_rollback(
trx = check_trx_exists(thd);
if (trx->auto_inc_lock) {
-
- /* If we had reserved the auto-inc lock for
- some table in this SQL statement, we release it now */
-
- srv_conc_enter_innodb(trx);
+ /* If we had reserved the auto-inc lock for some table (if
+ we come here to roll back the latest SQL statement) we
+ release it now before a possibly lengthy rollback */
+
+ innodb_srv_conc_enter_innodb(trx);
row_unlock_table_autoinc_for_mysql(trx);
- srv_conc_exit_innodb(trx);
+ innodb_srv_conc_exit_innodb(trx);
}
- srv_conc_enter_innodb(trx);
+ innodb_srv_conc_enter_innodb(trx);
+
+ if (trx_handle != (void*)&innodb_dummy_stmt_trx_handle
+ || (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))) {
- if (trx_handle != (void*)&innodb_dummy_stmt_trx_handle) {
error = trx_rollback_for_mysql(trx);
- thd->transaction.all.innodb_active_trans=0;
+ thd->transaction.all.innodb_active_trans = 0;
} else {
error = trx_rollback_last_sql_stat_for_mysql(trx);
}
- srv_conc_exit_innodb(trx);
+ innodb_srv_conc_exit_innodb(trx);
+
+ /* Release a possible FIFO ticket and search latch */
+ innobase_release_stat_resources(trx);
+
+ DBUG_RETURN(convert_error_code_to_mysql(error, NULL));
+}
+
+/*********************************************************************
+Rolls back a transaction to a savepoint. */
+
+int
+innobase_rollback_to_savepoint(
+/*===========================*/
+ /* out: 0 if success, HA_ERR_NO_SAVEPOINT if
+ no savepoint with the given name */
+ THD* thd, /* in: handle to the MySQL thread of the user
+ whose transaction should be rolled back */
+ char* savepoint_name, /* in: savepoint name */
+ my_off_t* binlog_cache_pos)/* out: position which corresponds to the
+ savepoint in the binlog cache of this
+ transaction, not defined if error */
+{
+ ib_longlong mysql_binlog_cache_pos;
+ int error = 0;
+ trx_t* trx;
+
+ DBUG_ENTER("innobase_rollback_to_savepoint");
+
+ trx = check_trx_exists(thd);
+
+ innodb_srv_conc_enter_innodb(trx);
+
+ error = trx_rollback_to_savepoint_for_mysql(trx, savepoint_name,
+ &mysql_binlog_cache_pos);
+ innodb_srv_conc_exit_innodb(trx);
+
+ *binlog_cache_pos = (my_off_t)mysql_binlog_cache_pos;
/* Release a possible FIFO ticket and search latch */
innobase_release_stat_resources(trx);
@@ -1098,6 +1181,46 @@ innobase_rollback(
}
/*********************************************************************
+Sets a transaction savepoint. */
+
+int
+innobase_savepoint(
+/*===============*/
+ /* out: always 0, that is, always succeeds */
+ THD* thd, /* in: handle to the MySQL thread */
+ char* savepoint_name, /* in: savepoint name */
+ my_off_t binlog_cache_pos)/* in: offset up to which the current
+ transaction has cached log entries to its
+ binlog cache, not defined if no transaction
+ active, or we are in the autocommit state, or
+ binlogging is not switched on */
+{
+ int error = 0;
+ trx_t* trx;
+
+ DBUG_ENTER("innobase_savepoint");
+
+ if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) {
+ /* In the autocommit state there is no sense to set a
+ savepoint: we return immediate success */
+ DBUG_RETURN(0);
+ }
+
+ trx = check_trx_exists(thd);
+
+ /* Setting a savepoint starts a transaction inside InnoDB since
+ it allocates resources for it (memory to store the savepoint name,
+ for example) */
+
+ thd->transaction.all.innodb_active_trans = 1;
+
+ error = trx_savepoint_for_mysql(trx, savepoint_name,
+ (ib_longlong)binlog_cache_pos);
+
+ DBUG_RETURN(convert_error_code_to_mysql(error, NULL));
+}
+
+/*********************************************************************
Frees a possible InnoDB trx object associated with the current
THD. */
@@ -1220,7 +1343,6 @@ ha_innobase::open(
{
dict_table_t* ib_table;
int error = 0;
- uint buff_len;
char norm_name[1000];
DBUG_ENTER("ha_innobase::open");
@@ -1245,11 +1367,11 @@ ha_innobase::open(
fields when packed actually became 1 byte longer, when we also
stored the string length as the first byte. */
- buff_len = table->reclength + table->max_key_length
+ upd_and_key_val_buff_len = table->reclength + table->max_key_length
+ MAX_REF_PARTS * 3;
if (!(mysql_byte*) my_multi_malloc(MYF(MY_WME),
- &upd_buff, buff_len,
- &key_val_buff, buff_len,
+ &upd_buff, upd_and_key_val_buff_len,
+ &key_val_buff, upd_and_key_val_buff_len,
NullS)) {
free_share(share);
DBUG_RETURN(1);
@@ -1500,6 +1622,10 @@ innobase_mysql_cmp(
case FIELD_TYPE_STRING:
case FIELD_TYPE_VAR_STRING:
+ case FIELD_TYPE_TINY_BLOB:
+ case FIELD_TYPE_MEDIUM_BLOB:
+ case FIELD_TYPE_BLOB:
+ case FIELD_TYPE_LONG_BLOB:
ret = my_sortncmp((const char*) a, a_length,
(const char*) b, b_length);
if (ret < 0) {
@@ -1526,7 +1652,7 @@ get_innobase_type_from_mysql_type(
/* out: DATA_BINARY, DATA_VARCHAR, ... */
Field* field) /* in: MySQL field */
{
- /* The following asserts check that MySQL type code fits in
+ /* The following asserts check that the MySQL type code fits in
8 bits: this is used in ibuf and also when DATA_NOT_NULL is
ORed to the type */
@@ -1537,6 +1663,8 @@ get_innobase_type_from_mysql_type(
DBUG_ASSERT((ulint)FIELD_TYPE_DECIMAL < 256);
switch (field->type()) {
+ /* NOTE that we only allow string types in DATA_MYSQL
+ and DATA_VARMYSQL */
case FIELD_TYPE_VAR_STRING: if (field->flags & BINARY_FLAG) {
return(DATA_BINARY);
@@ -1590,8 +1718,7 @@ get_innobase_type_from_mysql_type(
}
/***********************************************************************
-Stores a key value for a row to a buffer. This must currently only be used
-to store a row reference to the 'ref' buffer of this table handle! */
+Stores a key value for a row to a buffer. */
uint
ha_innobase::store_key_val_for_row(
@@ -1599,41 +1726,108 @@ ha_innobase::store_key_val_for_row(
/* out: key value length as stored in buff */
uint keynr, /* in: key number */
char* buff, /* in/out: buffer for the key value (in MySQL
- format); currently this MUST be the 'ref'
- buffer! */
+ format) */
+ uint buff_len,/* in: buffer length */
const mysql_byte* record)/* in: row in MySQL format */
{
KEY* key_info = table->key_info + keynr;
KEY_PART_INFO* key_part = key_info->key_part;
KEY_PART_INFO* end = key_part + key_info->key_parts;
char* buff_start = buff;
+ enum_field_types mysql_type;
+ Field* field;
+ ulint blob_len;
+ byte* blob_data;
+ ibool is_null;
DBUG_ENTER("store_key_val_for_row");
+ /* The format for storing a key field in MySQL is the following:
+
+ 1. If the column can be NULL, then in the first byte we put 1 if the
+ field value is NULL, 0 otherwise.
+
+ 2. If the column is of a BLOB type (it must be a column prefix field
+ in this case), then we put the length of the data in the field to the
+ next 2 bytes, in the little-endian format. If the field is SQL NULL,
+ then these 2 bytes are set to 0. Note that the length of data in the
+ field is <= column prefix length.
+
+ 3. In a column prefix field, prefix_len next bytes are reserved for
+ data. In a normal field the max field length next bytes are reserved
+ for data. For a VARCHAR(n) the max field length is n. If the stored
+ value is the SQL NULL then these data bytes are set to 0. */
+
+ /* We have to zero-fill the buffer so that MySQL is able to use a
+ simple memcmp to compare two key values to determine if they are
+ equal. MySQL does this to compare contents of two 'ref' values. */
+
+ bzero(buff, buff_len);
+
for (; key_part != end; key_part++) {
+ is_null = FALSE;
if (key_part->null_bit) {
- /* Store 0 if the key part is a NULL part */
-
if (record[key_part->null_offset]
& key_part->null_bit) {
- *buff++ = 1;
- continue;
- }
-
- *buff++ = 0;
+ *buff = 1;
+ is_null = TRUE;
+ } else {
+ *buff = 0;
+ }
+ buff++;
}
- memcpy(buff, record + key_part->offset, key_part->length);
- buff += key_part->length;
+ field = key_part->field;
+ mysql_type = field->type();
+
+ if (mysql_type == FIELD_TYPE_TINY_BLOB
+ || mysql_type == FIELD_TYPE_MEDIUM_BLOB
+ || mysql_type == FIELD_TYPE_BLOB
+ || mysql_type == FIELD_TYPE_LONG_BLOB) {
+
+ ut_a(key_part->key_part_flag & HA_PART_KEY);
+
+ if (is_null) {
+ buff += key_part->length + 2;
+
+ continue;
+ }
+
+ blob_data = row_mysql_read_blob_ref(&blob_len,
+ (byte*) (record
+ + (ulint)get_field_offset(table, field)),
+ (ulint) field->pack_length());
+
+ ut_a(get_field_offset(table, field)
+ == key_part->offset);
+ if (blob_len > key_part->length) {
+ blob_len = key_part->length;
+ }
+
+ /* MySQL reserves 2 bytes for the length and the
+ storage of the number is little-endian */
+
+ ut_a(blob_len < 256);
+ *((byte*)buff) = (byte)blob_len;
+ buff += 2;
+
+ memcpy(buff, blob_data, blob_len);
+
+ buff += key_part->length;
+ } else {
+ if (is_null) {
+ buff += key_part->length;
+
+ continue;
+ }
+ memcpy(buff, record + key_part->offset,
+ key_part->length);
+ buff += key_part->length;
+ }
}
- /*
- We have to zero-fill the 'ref' buffer so that MySQL is able to
- use a simple memcmp to compare two key values to determine if they
- are equal
- */
- bzero(buff, (ref_length- (uint) (buff - buff_start)));
+ ut_a(buff <= buff_start + buff_len);
DBUG_RETURN((uint)(buff - buff_start));
}
@@ -1669,7 +1863,11 @@ build_template(
if (prebuilt->read_just_key) {
/* MySQL has instructed us that it is enough to
- fetch the columns in the key */
+ fetch the columns in the key; looks like MySQL
+ can set this flag also when there is only a
+ prefix of the column in the key: in that case we
+ retrieve the whole column from the clustered
+ index */
fetch_all_in_key = TRUE;
} else {
@@ -1730,9 +1928,8 @@ build_template(
field = table->field[i];
if (templ_type == ROW_MYSQL_REC_FIELDS
- && !(fetch_all_in_key &&
- ULINT_UNDEFINED != dict_index_get_nth_col_pos(
- index, i))
+ && !(fetch_all_in_key
+ && dict_index_contains_col_or_prefix(index, i))
&& thd->query_id != field->query_id
&& thd->query_id != (field->query_id ^ MAX_ULONG_BIT)
&& thd->query_id !=
@@ -1905,9 +2102,9 @@ ha_innobase::write_row(
The lock is released at each SQL statement's
end. */
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
error = row_lock_table_autoinc_for_mysql(prebuilt);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
if (error != DB_SUCCESS) {
@@ -1918,14 +2115,15 @@ ha_innobase::write_row(
dict_table_autoinc_update(prebuilt->table, auto_inc);
} else {
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
if (!prebuilt->trx->auto_inc_lock) {
error = row_lock_table_autoinc_for_mysql(
prebuilt);
if (error != DB_SUCCESS) {
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(
+ prebuilt->trx);
error = convert_error_code_to_mysql(
error, user_thd);
@@ -1939,7 +2137,7 @@ ha_innobase::write_row(
auto_inc = dict_table_autoinc_get(prebuilt->table);
incremented_auto_inc_counter = TRUE;
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
/* We can give the new value for MySQL to place in
the field */
@@ -1962,11 +2160,11 @@ ha_innobase::write_row(
build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW);
}
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
error = row_insert_for_mysql((byte*) record, prebuilt);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
if (error != DB_SUCCESS) {
/* If the insert did not succeed we restore the value of
@@ -2037,7 +2235,6 @@ innobase_convert_and_store_changed_col(
while (len > 0 && data[len - 1] == ' ') {
len--;
}
-
} else if (col_type == DATA_INT) {
/* Store integer data in InnoDB in a big-endian
format, sign bit negated, if signed */
@@ -2075,9 +2272,11 @@ calc_row_difference(
struct st_table* table, /* in: table in MySQL data
dictionary */
mysql_byte* upd_buff, /* in: buffer to use */
+ ulint buff_len, /* in: buffer length */
row_prebuilt_t* prebuilt, /* in: InnoDB prebuilt struct */
THD* thd) /* in: user thread */
{
+ mysql_byte* original_upd_buff = upd_buff;
Field* field;
uint n_fields;
ulint o_len;
@@ -2159,12 +2358,13 @@ calc_row_difference(
(prebuilt->table->cols + i)->clust_pos;
n_changed++;
}
- ;
}
uvect->n_fields = n_changed;
uvect->info_bits = 0;
+ ut_a(buf <= (byte*)original_upd_buff + buff_len);
+
return(0);
}
@@ -2213,17 +2413,19 @@ ha_innobase::update_row(
(uses upd_buff of the handle) */
calc_row_difference(uvect, (mysql_byte*) old_row, new_row, table,
- upd_buff, prebuilt, user_thd);
+ upd_buff, (ulint)upd_and_key_val_buff_len,
+ prebuilt, user_thd);
+
/* This is not a delete */
prebuilt->upd_node->is_delete = FALSE;
assert(prebuilt->template_type == ROW_MYSQL_WHOLE_ROW);
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
error = row_update_for_mysql((byte*) old_row, prebuilt);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
error = convert_error_code_to_mysql(error, user_thd);
@@ -2267,11 +2469,11 @@ ha_innobase::delete_row(
prebuilt->upd_node->is_delete = TRUE;
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
error = row_update_for_mysql((byte*) record, prebuilt);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
error = convert_error_code_to_mysql(error, user_thd);
@@ -2459,10 +2661,11 @@ ha_innobase::index_read(
prebuilt->search_tuple */
row_sel_convert_mysql_key_to_innobase(prebuilt->search_tuple,
- (byte*) key_val_buff,
- index,
- (byte*) key_ptr,
- (ulint) key_len);
+ (byte*) key_val_buff,
+ (ulint)upd_and_key_val_buff_len,
+ index,
+ (byte*) key_ptr,
+ (ulint) key_len);
} else {
/* We position the cursor to the last or the first entry
in the index */
@@ -2484,11 +2687,11 @@ ha_innobase::index_read(
last_match_mode = match_mode;
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
ret = row_search_for_mysql((byte*) buf, mode, prebuilt, match_mode, 0);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
if (ret == DB_SUCCESS) {
error = 0;
@@ -2632,11 +2835,11 @@ ha_innobase::general_fetch(
ut_a(prebuilt->trx ==
(trx_t*) current_thd->transaction.all.innobase_tid);
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
ret = row_search_for_mysql((byte*)buf, 0, prebuilt, match_mode,
direction);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
if (ret == DB_SUCCESS) {
error = 0;
@@ -2925,7 +3128,8 @@ ha_innobase::position(
memcpy(ref, prebuilt->row_id, len);
} else {
- len = store_key_val_for_row(primary_key, (char*) ref, record);
+ len = store_key_val_for_row(primary_key, (char*)ref,
+ ref_length, record);
}
/* Since we do not store len to the buffer 'ref', we must assume
@@ -2939,7 +3143,6 @@ ha_innobase::position(
}
}
-
/*********************************************************************
Creates a table definition to an InnoDB database. */
static
@@ -2958,6 +3161,8 @@ create_table_def(
ulint col_type;
ulint nulls_allowed;
ulint unsigned_type;
+ ulint binary_type;
+ ulint nonlatin1_type;
ulint i;
DBUG_ENTER("create_table_def");
@@ -2986,9 +3191,24 @@ create_table_def(
unsigned_type = 0;
}
+ if (col_type == DATA_BLOB
+ && strcmp(default_charset_info->name, "latin1") != 0) {
+ nonlatin1_type = DATA_NONLATIN1;
+ } else {
+ nonlatin1_type = 0;
+ }
+
+ if (field->flags & BINARY_FLAG) {
+ binary_type = DATA_BINARY_TYPE;
+ nonlatin1_type = 0;
+ } else {
+ binary_type = 0;
+ }
+
dict_mem_table_add_col(table, (char*) field->field_name,
col_type, (ulint)field->type()
- | nulls_allowed | unsigned_type,
+ | nulls_allowed | unsigned_type
+ | nonlatin1_type | binary_type,
field->pack_length(), 0);
}
@@ -3011,6 +3231,7 @@ create_index(
const char* table_name, /* in: table name */
uint key_num) /* in: index number */
{
+ Field* field;
dict_index_t* index;
int error;
ulint n_fields;
@@ -3020,6 +3241,7 @@ create_index(
ulint col_type;
ulint prefix_len;
ulint i;
+ ulint j;
DBUG_ENTER("create_index");
@@ -3046,31 +3268,63 @@ create_index(
for (i = 0; i < n_fields; i++) {
key_part = key->key_part + i;
- if (key_part->length != key_part->field->pack_length()) {
+ /* (The flag HA_PART_KEY denotes in MySQL a column prefix
+ field in an index: we only store a specified number of first
+ bytes of the column to the index field.) The flag does not
+ seem to be properly set by MySQL. Let us fall back on testing
+ the length of the key part versus the column. */
+
+ field = NULL;
+ for (j = 0; j < form->fields; j++) {
+
+ field = form->field[j];
+
+ if (strlen(field->field_name)
+ == strlen(key_part->field->field_name)
+ && 0 == ut_cmp_in_lower_case(
+ (char*)field->field_name,
+ (char*)key_part->field->field_name,
+ strlen(field->field_name))) {
+ /* Found the corresponding column */
+
+ break;
+ }
+ }
+
+ ut_a(j < form->fields);
+
+ col_type = get_innobase_type_from_mysql_type(key_part->field);
+
+ if (DATA_BLOB == col_type
+ || key_part->length < field->pack_length()) {
+
prefix_len = key_part->length;
- col_type = get_innobase_type_from_mysql_type(
- key_part->field);
if (col_type == DATA_INT
|| col_type == DATA_FLOAT
|| col_type == DATA_DOUBLE
|| col_type == DATA_DECIMAL) {
fprintf(stderr,
"InnoDB: error: MySQL is trying to create a column prefix index field\n"
-"InnoDB: on an inappropriate data type %lu. Table name %s, column name %s.\n",
- col_type, table_name,
- key_part->field->field_name);
+"InnoDB: on an inappropriate data type. Table name %s, column name %s.\n",
+ table_name, key_part->field->field_name);
prefix_len = 0;
}
} else {
prefix_len = 0;
- }
+ }
+
+ if (prefix_len >= DICT_MAX_COL_PREFIX_LEN) {
+ DBUG_RETURN(-1);
+ }
/* We assume all fields should be sorted in ascending
order, hence the '0': */
+
dict_mem_index_add_field(index,
- (char*) key_part->field->field_name, 0);
+ (char*) key_part->field->field_name,
+ 0, prefix_len);
}
error = row_create_index_for_mysql(index, trx);
@@ -3536,6 +3790,8 @@ ha_innobase::records_in_range(
table->reclength
+ table->max_key_length + 100,
MYF(MY_WME));
+ ulint buff2_len = table->reclength
+ + table->max_key_length + 100;
dtuple_t* range_start;
dtuple_t* range_end;
ib_longlong n_rows;
@@ -3572,12 +3828,15 @@ ha_innobase::records_in_range(
dict_index_copy_types(range_end, index, key->key_parts);
row_sel_convert_mysql_key_to_innobase(
- range_start, (byte*) key_val_buff, index,
+ range_start, (byte*) key_val_buff,
+ (ulint)upd_and_key_val_buff_len,
+ index,
(byte*) start_key,
(ulint) start_key_len);
row_sel_convert_mysql_key_to_innobase(
- range_end, (byte*) key_val_buff2, index,
+ range_end, (byte*) key_val_buff2,
+ buff2_len, index,
(byte*) end_key,
(ulint) end_key_len);
@@ -3787,8 +4046,32 @@ ha_innobase::info(
}
for (i = 0; i < table->keys; i++) {
+ if (index == NULL) {
+ ut_print_timestamp(stderr);
+ fprintf(stderr,
+" InnoDB: Error: table %s contains less indexes inside InnoDB\n"
+"InnoDB: than are defined in the MySQL .frm file. Have you mixed up\n"
+"InnoDB: .frm files from different installations? See section\n"
+"InnoDB: 15.1 at http://www.innodb.com/ibman.html\n",
+ ib_table->name);
+ break;
+ }
+
for (j = 0; j < table->key_info[i].key_parts; j++) {
+ if (j + 1 > index->n_uniq) {
+ ut_print_timestamp(stderr);
+ fprintf(stderr,
+" InnoDB: Error: index %s of %s has %lu columns unique inside InnoDB\n"
+"InnoDB: but MySQL is asking statistics for %lu columns. Have you mixed up\n"
+"InnoDB: .frm files from different installations? See section\n"
+"InnoDB: 15.1 at http://www.innodb.com/ibman.html\n",
+ index->name,
+ ib_table->name, index->n_uniq,
+ j + 1);
+ break;
+ }
+
if (index->stat_n_diff_key_vals[j + 1] == 0) {
rec_per_key = records;
@@ -4052,10 +4335,11 @@ ha_innobase::reset(void)
}
/**********************************************************************
-MySQL calls this function at the start of each SQL statement. Inside LOCK
-TABLES the ::external_lock method does not work to mark SQL statement
-borders. Note also a special case: if a temporary table is created inside
-LOCK TABLES, MySQL has not called external_lock() at all on that table. */
+MySQL calls this function at the start of each SQL statement inside LOCK
+TABLES. Inside LOCK TABLES the ::external_lock method does not work to
+mark SQL statement borders. Note also a special case: if a temporary table
+is created inside LOCK TABLES, MySQL has not called external_lock() at all
+on that table. */
int
ha_innobase::start_stmt(
@@ -4454,9 +4738,9 @@ ha_innobase::innobase_read_and_init_auto_inc(
return(0);
}
- srv_conc_enter_innodb(prebuilt->trx);
+ innodb_srv_conc_enter_innodb(prebuilt->trx);
error = row_lock_table_autoinc_for_mysql(prebuilt);
- srv_conc_exit_innodb(prebuilt->trx);
+ innodb_srv_conc_exit_innodb(prebuilt->trx);
if (error != DB_SUCCESS) {
error = convert_error_code_to_mysql(error, user_thd);
diff --git a/sql/ha_innodb.h b/sql/ha_innodb.h
index 3f354a2fa11..86f409aff67 100644
--- a/sql/ha_innodb.h
+++ b/sql/ha_innodb.h
@@ -52,6 +52,9 @@ class ha_innobase: public handler
byte* key_val_buff; /* buffer used in converting
search key values from MySQL format
to Innodb format */
+ ulong upd_and_key_val_buff_len;
+ /* the length of each of the previous
+ two buffers */
ulong int_table_flags;
uint primary_key;
uint last_dup_key;
@@ -73,7 +76,8 @@ class ha_innobase: public handler
longlong auto_inc_counter_for_this_stat;
ulong max_row_length(const byte *buf);
- uint store_key_val_for_row(uint keynr, char* buff, const byte* record);
+ uint store_key_val_for_row(uint keynr, char* buff, uint buff_len,
+ const byte* record);
int update_thd(THD* thd);
int change_active_index(uint keynr);
int general_fetch(byte* buf, uint direction, uint match_mode);
@@ -83,13 +87,15 @@ class ha_innobase: public handler
public:
ha_innobase(TABLE *table): handler(table),
int_table_flags(HA_REC_NOT_IN_SEQ |
- HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
- HA_NULL_KEY | HA_CAN_SQL_HANDLER |
+ HA_KEYPOS_TO_RNDPOS |
+ HA_LASTKEY_ORDER |
+ HA_NULL_KEY |
+ HA_BLOB_KEY |
+ HA_CAN_SQL_HANDLER |
HA_NOT_EXACT_COUNT |
HA_NO_WRITE_DELAYED |
HA_PRIMARY_KEY_IN_READ_INDEX |
HA_DROP_BEFORE_CREATE |
- HA_NO_PREFIX_CHAR_KEYS |
HA_TABLE_SCAN_ON_INDEX),
last_dup_key((uint) -1),
start_of_scan(0)
@@ -218,6 +224,14 @@ int innobase_report_binlog_offset_and_commit(
int innobase_commit_complete(
void* trx_handle);
int innobase_rollback(THD *thd, void* trx_handle);
+int innobase_rollback_to_savepoint(
+ THD* thd,
+ char* savepoint_name,
+ my_off_t* binlog_cache_pos);
+int innobase_savepoint(
+ THD* thd,
+ char* savepoint_name,
+ my_off_t binlog_cache_pos);
int innobase_close_connection(THD *thd);
int innobase_drop_database(char *path);
int innodb_show_status(THD* thd);
diff --git a/sql/handler.cc b/sql/handler.cc
index cae1777e958..4ea5bc0e9f5 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -379,7 +379,6 @@ int ha_commit_trans(THD *thd, THD_TRANS* trans)
trans->innodb_active_trans=0;
if (trans == &thd->transaction.all)
operation_done= transaction_commited= 1;
-
}
#endif
#ifdef HAVE_QUERY_CACHE
@@ -447,6 +446,70 @@ int ha_rollback_trans(THD *thd, THD_TRANS *trans)
DBUG_RETURN(error);
}
+
+/*
+Rolls the current transaction back to a savepoint.
+Return value: 0 if success, 1 if there was not a savepoint of the given
+name.
+*/
+
+int ha_rollback_to_savepoint(THD *thd, char *savepoint_name)
+{
+ my_off_t binlog_cache_pos=0;
+ bool operation_done=0;
+ int error=0;
+ DBUG_ENTER("ha_rollback_to_savepoint");
+#ifdef USING_TRANSACTIONS
+ if (opt_using_transactions)
+ {
+#ifdef HAVE_INNOBASE_DB
+ /*
+ Retrieve the trans_log binlog cache position corresponding to the
+ savepoint, and if the rollback is successful inside InnoDB reset the write
+ position in the binlog cache to what it was at the savepoint.
+ */
+ if ((error=innobase_rollback_to_savepoint(thd, savepoint_name,
+ &binlog_cache_pos)))
+ {
+ my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), error);
+ error=1;
+ }
+ else
+ reinit_io_cache(&thd->transaction.trans_log, WRITE_CACHE,
+ binlog_cache_pos, 0, 0);
+ operation_done=1;
+#endif
+ if (operation_done)
+ statistic_increment(ha_rollback_count,&LOCK_status);
+ }
+#endif /* USING_TRANSACTIONS */
+
+ DBUG_RETURN(error);
+}
+
+
+/*
+Sets a transaction savepoint.
+Return value: always 0, that is, succeeds always
+*/
+
+int ha_savepoint(THD *thd, char *savepoint_name)
+{
+ my_off_t binlog_cache_pos=0;
+ int error=0;
+ DBUG_ENTER("ha_savepoint");
+#ifdef USING_TRANSACTIONS
+ if (opt_using_transactions)
+ {
+ binlog_cache_pos=my_b_tell(&thd->transaction.trans_log);
+#ifdef HAVE_INNOBASE_DB
+ innobase_savepoint(thd,savepoint_name, binlog_cache_pos);
+#endif
+ }
+#endif /* USING_TRANSACTIONS */
+ DBUG_RETURN(error);
+}
+
bool ha_flush_logs()
{
bool result=0;
diff --git a/sql/handler.h b/sql/handler.h
index fbad36bffdd..56f63d1d521 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -189,7 +189,8 @@ class handler :public Sql_alloc
public:
byte *ref; /* Pointer to current row */
byte *dupp_ref; /* Pointer to dupp row */
- uint ref_length; /* Length of ref (1-8) */
+ uint ref_length; /* Length of ref (1-8 or the clustered
+ key length) */
uint block_size; /* index block size */
ha_rows records; /* Records i datafilen */
ha_rows deleted; /* Deleted records */
@@ -376,6 +377,8 @@ int ha_commit_complete(THD *thd);
int ha_release_temporary_latches(THD *thd);
int ha_commit_trans(THD *thd, THD_TRANS *trans);
int ha_rollback_trans(THD *thd, THD_TRANS *trans);
+int ha_rollback_to_savepoint(THD *thd, char *savepoint_name);
+int ha_savepoint(THD *thd, char *savepoint_name);
int ha_autocommit_or_rollback(THD *thd, int error);
void ha_set_spin_retries(uint retries);
bool ha_flush_logs(void);
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 532a7cedec0..e847b203006 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -2299,6 +2299,9 @@ double Item_func_match::val()
if (ft_handler == NULL)
DBUG_RETURN(-1.0);
+ if (table->null_row) /* NULL row from an outer join */
+ return 0.0;
+
if (join_key)
{
if (table->file->ft_handler)
diff --git a/sql/log_event.cc b/sql/log_event.cc
index ff968babcf0..727b2052969 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -168,12 +168,15 @@ static void cleanup_load_tmpdir()
uint i;
if (!(dirp=my_dir(slave_load_tmpdir,MYF(MY_WME))))
return;
-
+ char fname[FN_REFLEN];
for (i=0 ; i < (uint)dirp->number_off_files; i++)
{
file=dirp->dir_entry+i;
if (is_prefix(file->name,"SQL_LOAD-"))
- my_delete(file->name, MYF(0));
+ {
+ fn_format(fname,file->name,slave_load_tmpdir,"",0);
+ my_delete(fname, MYF(0));
+ }
}
my_dirend(dirp);
@@ -813,7 +816,7 @@ Rotate_log_event::Rotate_log_event(const char* buf, int event_len,
int Rotate_log_event::write_data(IO_CACHE* file)
{
char buf[ROTATE_HEADER_LEN];
- int8store(buf, pos + R_POS_OFFSET);
+ int8store(buf + R_POS_OFFSET, pos);
return (my_b_safe_write(file, (byte*)buf, ROTATE_HEADER_LEN) ||
my_b_safe_write(file, (byte*)new_log_ident, (uint) ident_len));
}
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 0f3500248c0..5613f1eeb07 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -2322,6 +2322,12 @@ The server will not act as a slave.");
opt_binlog_index_name,LOG_BIN);
using_update_log=1;
}
+ else if (opt_log_slave_updates)
+ {
+ sql_print_error("\
+Warning: you need to use --log-bin to make --log-slave-updates work. \
+Now disabling --log-slave-updates.");
+ }
if (opt_bootstrap)
{
@@ -3179,7 +3185,8 @@ enum options {
OPT_BDB_CACHE_SIZE,
OPT_BDB_LOG_BUFFER_SIZE,
OPT_BDB_MAX_LOCK,
- OPT_ERROR_LOG_FILE
+ OPT_ERROR_LOG_FILE,
+ OPT_DEFAULT_WEEK_FORMAT
};
@@ -3988,6 +3995,11 @@ replicating a LOAD DATA INFILE command",
(gptr*) &global_system_variables.net_wait_timeout,
(gptr*) &max_system_variables.net_wait_timeout, 0, GET_ULONG,
REQUIRED_ARG, NET_WAIT_TIMEOUT, 1, LONG_TIMEOUT, 0, 1, 0},
+ { "default-week-format", OPT_DEFAULT_WEEK_FORMAT,
+ "The default week format used by WEEK() functions.",
+ (gptr*) &global_system_variables.default_week_format,
+ (gptr*) &max_system_variables.default_week_format,
+ 0, GET_ULONG, REQUIRED_ARG, 0, 0, 3L, 0, 1, 0},
{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};
diff --git a/sql/nt_servc.cc b/sql/nt_servc.cc
index b917c91ce15..b18d3d00d88 100644
--- a/sql/nt_servc.cc
+++ b/sql/nt_servc.cc
@@ -462,7 +462,7 @@ BOOL NTService::SeekStatus(LPCSTR szInternName, int OperationType)
{
/* a remove operation */
if (!(service = OpenService(scm,szInternName, SERVICE_ALL_ACCESS )))
- printf("The service doesn't exists!\n");
+ printf("The service doesn't exist!\n");
else
{
SERVICE_STATUS ss;
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 1da187598c4..32603ec51d9 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -296,6 +296,8 @@ static sys_var_slave_skip_counter sys_slave_skip_counter("sql_slave_skip_counter
static sys_var_rand_seed1 sys_rand_seed1("rand_seed1");
static sys_var_rand_seed2 sys_rand_seed2("rand_seed2");
+static sys_var_thd_ulong sys_default_week_format("default_week_format",
+ &SV::default_week_format);
/*
List of all variables for initialisation and storage in hash
@@ -316,6 +318,7 @@ sys_var *sys_variables[]=
&sys_bulk_insert_buff_size,
&sys_concurrent_insert,
&sys_connect_timeout,
+ &sys_default_week_format,
&sys_convert_charset,
&sys_delay_key_write,
&sys_delayed_insert_limit,
@@ -421,6 +424,7 @@ struct show_var_st init_vars[]= {
{sys_connect_timeout.name, (char*) &sys_connect_timeout, SHOW_SYS},
{sys_convert_charset.name, (char*) &sys_convert_charset, SHOW_SYS},
{"datadir", mysql_real_data_home, SHOW_CHAR},
+ {"default_week_format", (char*) &sys_default_week_format, SHOW_SYS},
{sys_delay_key_write.name, (char*) &sys_delay_key_write, SHOW_SYS},
{sys_delayed_insert_limit.name, (char*) &sys_delayed_insert_limit,SHOW_SYS},
{sys_delayed_insert_timeout.name, (char*) &sys_delayed_insert_timeout, SHOW_SYS},
diff --git a/sql/slave.cc b/sql/slave.cc
index cc0fa26027f..6c29d1a98bc 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -115,6 +115,8 @@ int init_slave()
{
DBUG_ENTER("init_slave");
+ /* This is called when mysqld starts */
+
/*
TODO: re-write this to interate through the list of files
for multi-master
@@ -126,11 +128,16 @@ int init_slave()
If master_host is specified, create the master_info file if it doesn't
exists.
*/
- if (!active_mi ||
- init_master_info(active_mi,master_info_file,relay_log_info_file,
+ if (!active_mi)
+ {
+ sql_print_error("Failed to allocate memory for the master info structure");
+ goto err;
+ }
+
+ if(init_master_info(active_mi,master_info_file,relay_log_info_file,
!master_host))
{
- sql_print_error("Note: Failed to initialized master info");
+ sql_print_error("Failed to initialize the master info structure");
goto err;
}
@@ -150,7 +157,7 @@ int init_slave()
relay_log_info_file,
SLAVE_IO | SLAVE_SQL))
{
- sql_print_error("Warning: Can't create threads to handle slave");
+ sql_print_error("Failed to create slave threads");
goto err;
}
}
@@ -282,6 +289,9 @@ err:
pthread_cond_broadcast(&rli->data_cond);
if (need_data_lock)
pthread_mutex_unlock(&rli->data_lock);
+
+ /* Isn't this strange: if !need_data_lock, we broadcast with no lock ?? */
+
pthread_mutex_unlock(log_lock);
DBUG_RETURN ((*errmsg) ? 1 : 0);
}
@@ -1226,7 +1236,10 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
"-relay-bin", opt_relaylog_index_name,
LOG_BIN, 1 /* read_append cache */,
1 /* no auto events */))
+ {
+ sql_print_error("Failed in open_log() called from init_relay_log_info()");
DBUG_RETURN(1);
+ }
/* if file does not exist */
if (access(fname,F_OK))
@@ -1237,10 +1250,18 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
*/
if (info_fd >= 0)
my_close(info_fd, MYF(MY_WME));
- if ((info_fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ||
- init_io_cache(&rli->info_file, info_fd, IO_SIZE*2, READ_CACHE, 0L,0,
- MYF(MY_WME)))
+ if ((info_fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
{
+ sql_print_error("Failed to create a new relay log info file (\
+file '%s', errno %d)", fname, my_errno);
+ msg= current_thd->net.last_error;
+ goto err;
+ }
+ if (init_io_cache(&rli->info_file, info_fd, IO_SIZE*2, READ_CACHE, 0L,0,
+ MYF(MY_WME)))
+ {
+ sql_print_error("Failed to create a cache on relay log info file (\
+file '%s')", fname);
msg= current_thd->net.last_error;
goto err;
}
@@ -1248,7 +1269,11 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
/* Init relay log with first entry in the relay index file */
if (init_relay_log_pos(rli,NullS,BIN_LOG_HEADER_SIZE,0 /* no data lock */,
&msg))
+ {
+ sql_print_error("Failed to open the relay log (relay_log_name='FIRST', \
+relay_log_pos=4");
goto err;
+ }
rli->master_log_name[0]= 0;
rli->master_log_pos= 0;
rli->info_fd= info_fd;
@@ -1257,18 +1282,33 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
{
if (info_fd >= 0)
reinit_io_cache(&rli->info_file, READ_CACHE, 0L,0,0);
- else if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ||
- init_io_cache(&rli->info_file, info_fd,
- IO_SIZE*2, READ_CACHE, 0L, 0, MYF(MY_WME)))
+ else
{
- if (info_fd >= 0)
- my_close(info_fd, MYF(0));
- rli->info_fd= -1;
- rli->relay_log.close(1);
- pthread_mutex_unlock(&rli->data_lock);
- DBUG_RETURN(1);
+ int error=0;
+ if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
+ {
+ sql_print_error("Failed to open the existing relay log info file (\
+file '%s', errno %d)", fname, my_errno);
+ error= 1;
+ }
+ else if (init_io_cache(&rli->info_file, info_fd,
+ IO_SIZE*2, READ_CACHE, 0L, 0, MYF(MY_WME)))
+ {
+ sql_print_error("Failed to create a cache on relay log info file (\
+file '%s')", fname);
+ error= 1;
+ }
+ if (error)
+ {
+ if (info_fd >= 0)
+ my_close(info_fd, MYF(0));
+ rli->info_fd= -1;
+ rli->relay_log.close(1);
+ pthread_mutex_unlock(&rli->data_lock);
+ DBUG_RETURN(1);
+ }
}
-
+
rli->info_fd = info_fd;
int relay_log_pos, master_log_pos;
if (init_strvar_from_file(rli->relay_log_name,
@@ -1292,7 +1332,12 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
rli->relay_log_pos,
0 /* no data lock*/,
&msg))
+ {
+ char llbuf[22];
+ sql_print_error("Failed to open the relay log (relay_log_name='%s', \
+relay_log_pos=%s", rli->relay_log_name, llstr(rli->relay_log_pos, llbuf));
goto err;
+ }
}
DBUG_ASSERT(rli->relay_log_pos >= BIN_LOG_HEADER_SIZE);
DBUG_ASSERT(my_b_tell(rli->cur_log) == rli->relay_log_pos);
@@ -1301,7 +1346,8 @@ int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
before flush_relay_log_info
*/
reinit_io_cache(&rli->info_file, WRITE_CACHE,0L,0,1);
- error= flush_relay_log_info(rli);
+ if ((error= flush_relay_log_info(rli)))
+ sql_print_error("Failed to flush relay log info file");
if (count_relay_log_space(rli))
{
msg="Error counting relay log space";
@@ -1346,18 +1392,18 @@ static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli)
{
bool slave_killed=0;
MASTER_INFO* mi = rli->mi;
- const char* save_proc_info;
THD* thd = mi->io_thd;
DBUG_ENTER("wait_for_relay_log_space");
pthread_mutex_lock(&rli->log_space_lock);
- save_proc_info = thd->proc_info;
- thd->proc_info = "Waiting for relay log space to free";
+ const char* save_proc_info= thd->enter_cond(&rli->log_space_cond,
+ &rli->log_space_lock,
+ "Waiting for relay log space to free");
while (rli->log_space_limit < rli->log_space_total &&
!(slave_killed=io_slave_killed(thd,mi)) &&
!rli->ignore_log_space_limit)
pthread_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
- thd->proc_info = save_proc_info;
+ thd->exit_cond(save_proc_info);
pthread_mutex_unlock(&rli->log_space_lock);
DBUG_RETURN(slave_killed);
}
@@ -1404,6 +1450,8 @@ int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
pthread_mutex_lock(&mi->data_lock);
fd = mi->fd;
+
+ /* does master.info exist ? */
if (access(fname,F_OK))
{
@@ -1418,10 +1466,19 @@ int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
*/
if (fd >= 0)
my_close(fd, MYF(MY_WME));
- if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ||
- init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
+ if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
+ {
+ sql_print_error("Failed to create a new master info file (\
+file '%s', errno %d)", fname, my_errno);
+ goto err;
+ }
+ if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
MYF(MY_WME)))
+ {
+ sql_print_error("Failed to create a cache on master info file (\
+file '%s')", fname);
goto err;
+ }
mi->master_log_name[0] = 0;
mi->master_log_pos = BIN_LOG_HEADER_SIZE; // skip magic number
@@ -1440,10 +1497,22 @@ int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
{
if (fd >= 0)
reinit_io_cache(&mi->file, READ_CACHE, 0L,0,0);
- else if ((fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 ||
- init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,
- 0, MYF(MY_WME)))
- goto err;
+ else
+ {
+ if ((fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
+ {
+ sql_print_error("Failed to open the existing master info file (\
+file '%s', errno %d)", fname, my_errno);
+ goto err;
+ }
+ if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,
+ 0, MYF(MY_WME)))
+ {
+ sql_print_error("Failed to create a cache on master info file (\
+file '%s')", fname);
+ goto err;
+ }
+ }
mi->fd = fd;
int port, connect_retry, master_log_pos;
@@ -1484,7 +1553,8 @@ int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
mi->inited = 1;
// now change cache READ -> WRITE - must do this before flush_master_info
reinit_io_cache(&mi->file, WRITE_CACHE,0L,0,1);
- error=test(flush_master_info(mi));
+ if ((error=test(flush_master_info(mi))))
+ sql_print_error("Failed to flush master info file");
pthread_mutex_unlock(&mi->data_lock);
DBUG_RETURN(error);
@@ -1574,6 +1644,7 @@ int show_master_info(THD* thd, MASTER_INFO* mi)
if (mi->host[0])
{
+ DBUG_PRINT("info",("host is set: '%s'", mi->host));
String *packet= &thd->packet;
packet->length(0);
@@ -1711,6 +1782,13 @@ int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
the master info. To catch this, these commands
modify abort_pos_wait ; we just monitor abort_pos_wait
and see if it has changed.
+ Why do we have this mechanism instead of simply monitoring slave_running in
+ the loop (we do this too), as CHANGE MASTER/RESET SLAVE require that the
+ SQL thread be stopped? This is in case
+ STOP SLAVE;CHANGE MASTER/RESET SLAVE; START SLAVE;
+ happens very quickly between the moment pthread_cond_wait() wakes up and
+ the while() is evaluated: in that case slave_running is again 1 when the
+ while() is evaluated.
*/
init_abort_pos_wait= abort_pos_wait;
@@ -1747,7 +1825,12 @@ int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
//"compare and wait" main loop
while (!thd->killed &&
init_abort_pos_wait == abort_pos_wait &&
- mi->slave_running)
+ /*
+ formerly we tested mi->slave_running, but what we care about is
+ rli->slave_running (because this concerns the SQL thread, while
+ mi->slave_running concerns the I/O thread).
+ */
+ slave_running)
{
bool pos_reached;
int cmp_result= 0;
@@ -1785,6 +1868,10 @@ int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
DBUG_PRINT("info",("Waiting for master update"));
const char* msg = thd->enter_cond(&data_cond, &data_lock,
"Waiting for master update");
+ /*
+ We are going to pthread_cond_(timed)wait(); if the SQL thread stops it
+ will wake us up.
+ */
if (timeout > 0)
{
/*
@@ -1802,6 +1889,7 @@ int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
}
else
pthread_cond_wait(&data_cond, &data_lock);
+ DBUG_PRINT("info",("Got signal of master update"));
thd->exit_cond(msg);
if (error == ETIMEDOUT || error == ETIME)
{
@@ -1810,6 +1898,7 @@ int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
}
error=0;
event_count++;
+ DBUG_PRINT("info",("Testing if killed or SQL thread not running"));
}
err:
@@ -1818,11 +1907,11 @@ err:
improper_arguments: %d timed_out: %d",
(int) thd->killed,
(int) (init_abort_pos_wait != abort_pos_wait),
- (int) mi->slave_running,
+ (int) slave_running,
(int) (error == -2),
(int) (error == -1)));
if (thd->killed || init_abort_pos_wait != abort_pos_wait ||
- !mi->slave_running)
+ !slave_running)
{
error= -2;
}
@@ -2357,6 +2446,17 @@ reconnect done to recover from failed read");
for no reason, but this function will do a clean read, notice the clean
value and exit immediately.
*/
+#ifndef DBUG_OFF
+ {
+ char llbuf1[22], llbuf2[22];
+ DBUG_PRINT("info", ("log_space_limit=%s log_space_total=%s \
+ignore_log_space_limit=%d",
+ llstr(mi->rli.log_space_limit,llbuf1),
+ llstr(mi->rli.log_space_total,llbuf2),
+ (int) mi->rli.ignore_log_space_limit));
+ }
+#endif
+
if (mi->rli.log_space_limit && mi->rli.log_space_limit <
mi->rli.log_space_total &&
!mi->rli.ignore_log_space_limit)
@@ -2529,8 +2629,16 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
VOID(pthread_mutex_unlock(&LOCK_thread_count));
thd->proc_info = "Waiting for slave mutex on exit";
pthread_mutex_lock(&rli->run_lock);
+ /* We need data_lock, at least to wake up any waiting master_pos_wait() */
+ pthread_mutex_lock(&rli->data_lock);
DBUG_ASSERT(rli->slave_running == 1); // tracking buffer overrun
- rli->slave_running = 0;
+ /* When master_pos_wait() wakes up it will check this and terminate */
+ rli->slave_running= 0;
+ /* Wake up master_pos_wait() */
+ pthread_mutex_unlock(&rli->data_lock);
+ DBUG_PRINT("info",("Signaling possibly waiting master_pos_wait() functions"));
+ pthread_cond_broadcast(&rli->data_cond);
+ rli->ignore_log_space_limit= 0; /* don't need any lock */
rli->save_temporary_tables = thd->temporary_tables;
/*
@@ -3173,8 +3281,8 @@ Log_event* next_event(RELAY_LOG_INFO* rli)
log), and also when the SQL thread starts. We should also reset
ignore_log_space_limit to 0 when the user does RESET SLAVE, but in
fact, no need as RESET SLAVE requires that the slave
- be stopped, and when the SQL thread is later restarted
- ignore_log_space_limit will be reset to 0.
+ be stopped, and the SQL thread sets ignore_log_space_limit to 0 when
+ it stops.
*/
pthread_mutex_lock(&rli->log_space_lock);
// prevent the I/O thread from blocking next times
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 9857774fb84..a8a24451ecc 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -309,6 +309,7 @@ struct system_variables
ulong tmp_table_size;
ulong tx_isolation;
ulong table_type;
+ ulong default_week_format;
my_bool log_warnings;
my_bool low_priority_updates;
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 7d931399782..0618f04a79b 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -53,8 +53,9 @@ enum enum_sql_command {
SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
- SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
- SQLCOM_ROLLBACK, SQLCOM_COMMIT, SQLCOM_SAVEPOINT,
+ SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
+ SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
+ SQLCOM_COMMIT, SQLCOM_SAVEPOINT,
SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 3a8895ab120..3b3da6d35b3 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -583,6 +583,11 @@ check_connections(THD *thd)
if (thd->client_capabilities & CLIENT_SSL)
{
/* Do the SSL layering. */
+ if (!ssl_acceptor_fd)
+ {
+ inc_host_errors(&thd->remote.sin_addr);
+ return(ER_HANDSHAKE_ERROR);
+ }
DBUG_PRINT("info", ("IO layer change in progress..."));
if (sslaccept(ssl_acceptor_fd, net->vio, thd->variables.net_wait_timeout))
{
@@ -2536,8 +2541,22 @@ mysql_execute_command(void)
res= -1;
thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
break;
+ case SQLCOM_ROLLBACK_TO_SAVEPOINT:
+ if (!ha_rollback_to_savepoint(thd, lex->savepoint_name))
+ {
+ if (thd->options & OPTION_STATUS_NO_TRANS_UPDATE)
+ send_warning(&thd->net,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
+ else
+ send_ok(&thd->net);
+ }
+ else
+ res= -1;
+ break;
case SQLCOM_SAVEPOINT:
- send_ok(&thd->net);
+ if (!ha_savepoint(thd, lex->savepoint_name))
+ send_ok(&thd->net);
+ else
+ res= -1;
break;
default: /* Impossible */
send_ok(&thd->net);
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index ca993c053a1..d0ed1a19d96 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -51,7 +51,7 @@ int check_binlog_magic(IO_CACHE* log, const char** errmsg)
}
static int fake_rotate_event(NET* net, String* packet, char* log_file_name,
- const char**errmsg)
+ ulonglong position, const char**errmsg)
{
char header[LOG_EVENT_HEADER_LEN], buf[ROTATE_HEADER_LEN];
memset(header, 0, 4); // when does not matter
@@ -68,9 +68,12 @@ static int fake_rotate_event(NET* net, String* packet, char* log_file_name,
int4store(header + LOG_POS_OFFSET, 0);
packet->append(header, sizeof(header));
- /* We need to split the next statement because of problem with cxx */
- int4store(buf,4); // tell slave to skip magic number
- int4store(buf+4,0);
+ /*
+ An old comment said talked about a need for splitting the int8store below
+ into 2 int4store because of a problem with cxx; I can't understand that as
+ we already use int8store in Rotatel_log_event::write_data().
+ */
+ int8store(buf+R_POS_OFFSET,position);
packet->append(buf, ROTATE_HEADER_LEN);
packet->append(p,ident_len);
if (my_net_write(net, (char*)packet->ptr(), packet->length()))
@@ -159,10 +162,18 @@ File open_binlog(IO_CACHE *log, const char *log_file_name,
File file;
DBUG_ENTER("open_binlog");
- if ((file = my_open(log_file_name, O_RDONLY | O_BINARY, MYF(MY_WME))) < 0 ||
- init_io_cache(log, file, IO_SIZE*2, READ_CACHE, 0, 0,
+ if ((file = my_open(log_file_name, O_RDONLY | O_BINARY, MYF(MY_WME))) < 0)
+ {
+ sql_print_error("Failed to open log (\
+file '%s', errno %d)", log_file_name, my_errno);
+ *errmsg = "Could not open log file"; // This will not be sent
+ goto err;
+ }
+ if (init_io_cache(log, file, IO_SIZE*2, READ_CACHE, 0, 0,
MYF(MY_WME | MY_DONT_CHECK_FILESIZE)))
{
+ sql_print_error("Failed to create a cache on log (\
+file '%s')", log_file_name);
*errmsg = "Could not open log file"; // This will not be sent
goto err;
}
@@ -374,17 +385,30 @@ impossible position";
*/
packet->set("\0", 1);
- // if we are at the start of the log
- if (pos == BIN_LOG_HEADER_SIZE)
+ /*
+ Before 4.0.14 we called fake_rotate_event below only if
+ (pos == BIN_LOG_HEADER_SIZE), because if this is false then the slave
+ already knows the binlog's name.
+ Now we always call fake_rotate_event; if the slave already knew the log's
+ name (ex: CHANGE MASTER TO MASTER_LOG_FILE=...) this is useless but does not
+ harm much. It is nice for 3.23 (>=.58) slaves which test Rotate events
+ to see if the master is 4.0 (then they choose to stop because they can't
+ replicate 4.0); by always calling fake_rotate_event we are sure that 3.23.58
+ and newer will detect the problem as soon as replication starts (BUG#198).
+ Always calling fake_rotate_event makes sending of normal
+ (=from-binlog) Rotate events a priori unneeded, but it is not so simple: the
+ 2 Rotate events are not equivalent, the normal one is before the Stop event,
+ the fake one is after. If we don't send the normal one, then the Stop event
+ will be interpreted (by existing 4.0 slaves) as "the master stopped", which
+ is wrong. So for safety, given that we want minimum modification of 4.0, we
+ send the normal and fake Rotates.
+ */
+ if (fake_rotate_event(net, packet, log_file_name, pos, &errmsg))
{
- // tell the client log name with a fake rotate_event
- if (fake_rotate_event(net, packet, log_file_name, &errmsg))
- {
- my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
- goto err;
- }
- packet->set("\0", 1);
+ my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
+ goto err;
}
+ packet->set("\0", 1);
while (!net->error && net->vio != 0 && !thd->killed)
{
@@ -577,10 +601,12 @@ Increase max_allowed_packet on master";
end_io_cache(&log);
(void) my_close(file, MYF(MY_WME));
- // fake Rotate_log event just in case it did not make it to the log
- // otherwise the slave make get confused about the offset
+ /*
+ Even if the previous log contained a Rotate_log_event, we still fake
+ one.
+ */
if ((file=open_binlog(&log, log_file_name, &errmsg)) < 0 ||
- fake_rotate_event(net, packet, log_file_name, &errmsg))
+ fake_rotate_event(net, packet, log_file_name, BIN_LOG_HEADER_SIZE, &errmsg))
{
my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
goto err;
@@ -743,6 +769,9 @@ int reset_slave(THD *thd, MASTER_INFO* mi)
//Clear master's log coordinates (only for good display of SHOW SLAVE STATUS)
mi->master_log_name[0]= 0;
mi->master_log_pos= BIN_LOG_HEADER_SIZE;
+ //Clear the errors displayed by SHOW SLAVE STATUS
+ mi->rli.last_slave_error[0]=0;
+ mi->rli.last_slave_errno=0;
//close master_info_file, relay_log_info_file, set mi->inited=rli->inited=0
end_master_info(mi);
//and delete these two files
@@ -817,7 +846,7 @@ int change_master(THD* thd, MASTER_INFO* mi)
// TODO: see if needs re-write
if (init_master_info(mi, master_info_file, relay_log_info_file, 0))
{
- send_error(&thd->net, 0, "Could not initialize master info");
+ send_error(&thd->net, ER_MASTER_INFO);
unlock_slave_threads(mi);
DBUG_RETURN(1);
}
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index ff6fde1ca0c..0e8b191e4ef 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -1688,6 +1688,9 @@ add_ft_keys(DYNAMIC_ARRAY *keyuse_array,
if (!cond_func || cond_func->key == NO_SUCH_KEY)
return;
+ if (!(usable_tables & cond_func->table->map))
+ return;
+
KEYUSE keyuse;
keyuse.table= cond_func->table;
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 2ef0992cdf7..0ff09a52a9e 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -2002,7 +2002,11 @@ simple_expr:
| USER '(' ')'
{ $$= new Item_func_user(); current_thd->safe_to_cache_query=0; }
| WEEK_SYM '(' expr ')'
- { $$= new Item_func_week($3,new Item_int((char*) "0",0,1)); }
+ {
+ LEX *lex=Lex;
+ $$= new Item_func_week($3,new Item_int((char*) "0",
+ lex->thd->variables.default_week_format,1));
+ }
| WEEK_SYM '(' expr ',' expr ')'
{ $$= new Item_func_week($3,$5); }
| YEAR_SYM '(' expr ')'
@@ -3922,11 +3926,10 @@ rollback:
ROLLBACK_SYM
{
Lex->sql_command = SQLCOM_ROLLBACK;
- Lex->savepoint_name = NULL;
}
| ROLLBACK_SYM TO_SYM SAVEPOINT_SYM ident
{
- Lex->sql_command = SQLCOM_ROLLBACK;
+ Lex->sql_command = SQLCOM_ROLLBACK_TO_SAVEPOINT;
Lex->savepoint_name = $4.str;
};
savepoint:
View Lorry Controller Status