From c437565cff2111fd0856b9dfed525cd9a921ff84 Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 15 Jun 2006 10:11:50 +0200 Subject: [PATCH] Fixing code to avoid compile problem on Solaris (aCC). sql/handler.cc: Moving write_locked_table_maps() and binlog_log_row() into an anonymous namespace. --- sql/handler.cc | 160 ++++++++++++++++++++++++++----------------------- 1 file changed, 84 insertions(+), 76 deletions(-) diff --git a/sql/handler.cc b/sql/handler.cc index e6f2f564d39..7ab7e88ec9a 100644 --- a/sql/handler.cc +++ b/sql/handler.cc @@ -3221,100 +3221,108 @@ namespace { THD::lock THD::locked_tables */ -static int -write_locked_table_maps(THD *thd) +namespace { - DBUG_ENTER("write_locked_table_maps"); - DBUG_PRINT("enter", ("thd=%p, thd->lock=%p, thd->locked_tables=%p", - thd, thd->lock, thd->locked_tables)); - - if (thd->get_binlog_table_maps() == 0) + int write_locked_table_maps(THD *thd) { - /* - Exactly one table has to be locked, otherwise this code is not - guaranteed to work. - */ - DBUG_ASSERT((thd->lock != NULL) + (thd->locked_tables != NULL) == 1); + DBUG_ENTER("write_locked_table_maps"); + DBUG_PRINT("enter", ("thd=%p, thd->lock=%p, thd->locked_tables=%p", + thd, thd->lock, thd->locked_tables)); - MYSQL_LOCK *lock= thd->lock ? thd->lock : thd->locked_tables; - DBUG_ASSERT(lock->table_count > 0); - TABLE **const end_ptr= lock->table + lock->table_count; - for (TABLE **table_ptr= lock->table ; - table_ptr != end_ptr ; - ++table_ptr) + if (thd->get_binlog_table_maps() == 0) { - TABLE *const table= *table_ptr; - DBUG_PRINT("info", ("Checking table %s", table->s->table_name)); - if (table->current_lock == F_WRLCK && - check_table_binlog_row_based(thd, table)) + /* + Exactly one table has to be locked, otherwise this code is not + guaranteed to work. + */ + DBUG_ASSERT((thd->lock != NULL) + (thd->locked_tables != NULL) == 1); + + MYSQL_LOCK *lock= thd->lock ? thd->lock : thd->locked_tables; + DBUG_ASSERT(lock->table_count > 0); + TABLE **const end_ptr= lock->table + lock->table_count; + for (TABLE **table_ptr= lock->table ; + table_ptr != end_ptr ; + ++table_ptr) { - int const has_trans= table->file->has_transactions(); - int const error= thd->binlog_write_table_map(table, has_trans); - /* - If an error occurs, it is the responsibility of the caller to - roll back the transaction. - */ - if (unlikely(error)) - DBUG_RETURN(1); + TABLE *const table= *table_ptr; + DBUG_PRINT("info", ("Checking table %s", table->s->table_name)); + if (table->current_lock == F_WRLCK && + check_table_binlog_row_based(thd, table)) + { + int const has_trans= table->file->has_transactions(); + int const error= thd->binlog_write_table_map(table, has_trans); + /* + If an error occurs, it is the responsibility of the caller to + roll back the transaction. + */ + if (unlikely(error)) + DBUG_RETURN(1); + } } } + DBUG_RETURN(0); } - DBUG_RETURN(0); -} -template int binlog_log_row(TABLE* table, - const byte *before_record, - const byte *after_record) -{ - if (table->file->is_injective()) - return 0; - bool error= 0; - THD *const thd= table->in_use; - - if (check_table_binlog_row_based(thd, table)) + template int + binlog_log_row(TABLE* table, + const byte *before_record, + const byte *after_record) { - MY_BITMAP cols; - /* Potential buffer on the stack for the bitmap */ - uint32 bitbuf[BITMAP_STACKBUF_SIZE/sizeof(uint32)]; - uint n_fields= table->s->fields; - my_bool use_bitbuf= n_fields <= sizeof(bitbuf)*8; + if (table->file->is_injective()) + return 0; + bool error= 0; + THD *const thd= table->in_use; - /* - If there are no table maps written to the binary log, this is - the first row handled in this statement. In that case, we need - to write table maps for all locked tables to the binary log. - */ - if (likely(!(error= bitmap_init(&cols, - use_bitbuf ? bitbuf : NULL, - (n_fields + 7) & ~7UL, - false)))) + if (check_table_binlog_row_based(thd, table)) { - bitmap_set_all(&cols); - if (likely(!(error= write_locked_table_maps(thd)))) + MY_BITMAP cols; + /* Potential buffer on the stack for the bitmap */ + uint32 bitbuf[BITMAP_STACKBUF_SIZE/sizeof(uint32)]; + uint n_fields= table->s->fields; + my_bool use_bitbuf= n_fields <= sizeof(bitbuf)*8; + + /* + If there are no table maps written to the binary log, this is + the first row handled in this statement. In that case, we need + to write table maps for all locked tables to the binary log. + */ + if (likely(!(error= bitmap_init(&cols, + use_bitbuf ? bitbuf : NULL, + (n_fields + 7) & ~7UL, + false)))) { - error= - RowsEventT::binlog_row_logging_function(thd, table, - table->file->has_transactions(), - &cols, table->s->fields, - before_record, after_record); + bitmap_set_all(&cols); + if (likely(!(error= write_locked_table_maps(thd)))) + { + error= + RowsEventT::binlog_row_logging_function(thd, table, + table->file->has_transactions(), + &cols, table->s->fields, + before_record, after_record); + } + if (!use_bitbuf) + bitmap_free(&cols); } - if (!use_bitbuf) - bitmap_free(&cols); } + return error ? HA_ERR_RBR_LOGGING_FAILED : 0; } - return error ? HA_ERR_RBR_LOGGING_FAILED : 0; + + + /* + Instantiate the versions we need for the above template function, + because we have -fno-implicit-template as compiling option. + */ + + template int + binlog_log_row(TABLE *, const byte *, const byte *); + + template int + binlog_log_row(TABLE *, const byte *, const byte *); + + template int + binlog_log_row(TABLE *, const byte *, const byte *); } - -/* - Instantiate the versions we need for the above template function, because we - have -fno-implicit-template as compiling option. -*/ - -template int binlog_log_row(TABLE *, const byte *, const byte *); -template int binlog_log_row(TABLE *, const byte *, const byte *); -template int binlog_log_row(TABLE *, const byte *, const byte *); - #endif /* HAVE_ROW_BASED_REPLICATION */ int handler::ha_external_lock(THD *thd, int lock_type)