~drizzle-trunk/drizzle/development

   @param level     error, warning or info

   @param ha_error  HA_ERR_ code

   @param rli       pointer to the active Relay_log_info instance

   @param table     pointer to the event's table object

   @param type      the type of the event

   @param log_name  the master binlog file name

 

*/

static void inline slave_rows_error_report(enum loglevel level, int ha_error,

                                           Table *table, const char * type,

                                           const char *log_name, ulong pos)

{

  char buff[MAX_SLAVE_ERRMSG], *slider;

  const char *buff_end= buff + sizeof(buff);

  uint32_t len;

  DRIZZLE_ERROR *err;

  buff[0]= 0;

 

                  _(" %s, Error_code: %d;"), err->msg, err->code);

  }

  

              _("Could not execute %s event on table %s.%s;"

                "%s handler error %s; "

                "the event's master log %s, end_log_pos %lu"),

  pretty_print_str()

*/

 

{

  rli->clear_error();

}

 

  Log_event::Log_event()

*/

 

{

  cache_stmt=   using_trans;

}

 

 

/**

  This minimal constructor is for when you are not even sure that there

  flushing logs after receiving a SIGHUP (then we must write a Rotate to

*/

 

Log_event::Log_event()

  :temp_buf(0), exec_time(0), flags(0), cache_stmt(0),

{

  server_id=    ::server_id;

  /*

                     const Format_description_log_event* description_event)

  :temp_buf(0), cache_stmt(0)

{

  when= uint4korr(buf);

  server_id= uint4korr(buf + SERVER_ID_OFFSET);

  data_written= uint4korr(buf + EVENT_LEN_OFFSET);

  }

  data_len= uint4korr(buf + EVENT_LEN_OFFSET);

  if (data_len < LOG_EVENT_MINIMAL_HEADER_LEN ||

  {

    result= ((data_len < LOG_EVENT_MINIMAL_HEADER_LEN) ? LOG_READ_BOGUS :

             LOG_READ_TOO_LARGE);

  const char *error= 0;

  Log_event *res=  0;

#ifndef max_allowed_packet

#endif

 

  if (data_len > max_allowed_packet)

/*

  SYNOPSIS

    Query_log_event::Query_log_event()

      query_arg         - array of char representing the query

      query_length      - size of the  `query_arg' array

      using_trans       - there is a modified transactional table

      suppress_use      - suppress the generation of 'USE' statements

                          if the value is different from the default, the arg

  DESCRIPTION

  Creates an event for binlogging

  The value for local `killed_status' can be supplied by caller.

*/

                                 ulong query_length, bool using_trans,

                                 bool suppress_use,

              0) |

             (suppress_use ? LOG_EVENT_SUPPRESS_USE_F : 0),

             using_trans),

   /* save the original thread id; we already know the server id */

   flags2_inited(1), sql_mode_inited(1), charset_inited(1),

   sql_mode(0),

   charset_database_number(0)

{

  time_t end_time;

 

 

  error_code=

  

  time(&end_time);

  /**

    @todo this means that if we have no catalog, then it is replicated

    as an existing catalog of length zero. is that safe? /sven

  catalog_len = (catalog) ? (uint32_t) strlen(catalog) : 0;

  /* status_vars_len is set just before writing the event */

  db_len = (db) ? (uint32_t) strlen(db) : 0;

  

  /*

    If we don't use flags2 for anything else than options contained in

    (OPTIONS_WRITTEN_TO_BIN_LOG would be used only at reading time).

    But it's likely that we don't want to use 32 bits for 3 bits; in the future

    we will probably want to reclaim the 29 bits. So we need the &.

  */

  {

    /*

      Note that our event becomes dependent on the Time_zone object

      representing the time zone. Fortunately such objects are never deleted

      or changed during mysqld's lifetime.

    */

  }

  else

    time_zone_len= 0;

     sql_print_error("Slave: did not get the expected number of affected \

     rows running query from master - expected %d, got %d (this numbers \

     should have matched modulo 4294967296).", 0, ...);

     }

  @endcode

  We may also want an option to tell the slave to ignore "affected"

  LEX_STRING new_db;

  int expected_error,actual_error= 0;

  /*

    not an entire alloced block (see

    you.

  */

  new_db.length= db_len;

  new_db.str= (char *) rpl_filter->get_rewrite_db(db, &new_db.length);

 

  /*

    InnoDB internally stores the master log position it has executed so far,

  */

  const_cast<Relay_log_info*>(rli)->future_group_master_log_pos= log_pos;

 

  const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();

 

  /*

            ::do_apply_event(), then the companion SET also have so

            we don't need to reset_one_shot_variables().

  */

  {

    pthread_mutex_lock(&LOCK_thread_count);

    pthread_mutex_unlock(&LOCK_thread_count);

 

    if (ignored_error_code((expected_error= error_code)) ||

    {

      if (flags2_inited)

        /*

          must take their value from flags2.

        */

      if (time_zone_len)

      {

        String tmp(time_zone_str, time_zone_len, &my_charset_bin);

        {

          my_error(ER_UNKNOWN_TIME_ZONE, MYF(0), tmp.c_ptr());

          goto compare_errors;

        }

      }

      if (lc_time_names_number)

      {

              my_locale_by_number(lc_time_names_number)))

        {

          my_printf_error(ER_UNKNOWN_ERROR,

                      "Unknown locale: '%d'", MYF(0), lc_time_names_number);

          goto compare_errors;

        }

      }

      else

      if (charset_database_number)

      {

        const CHARSET_INFO *cs;

          my_error(ER_UNKNOWN_COLLATION, MYF(0), buf);

          goto compare_errors;

        }

      }

      else

      

      /* Execute the query (note that we bypass dispatch_command()) */

      const char* found_semicolon= NULL;

    }

    else

    {

        we exit gracefully; otherwise we warn about the bad error and tell DBA

        to check/fix it.

      */

      else

      {

        rli->report(ERROR_LEVEL, expected_error,

                      "this query manually on the slave and then restart the "

                      "slave with SET GLOBAL SQL_SLAVE_SKIP_COUNTER=1; "

                      "START SLAVE; . Query: '%s'"),

      }

      goto end;

    }

      If we expected a non-zero error code, and we don't get the same error

      code, and none of them should be ignored.

    */

    if ((expected_error != actual_error) &&

        expected_error &&

        !ignored_error_code(actual_error) &&

                    "Default database: '%s'. Query: '%s'"),

                  ER_SAFE(expected_error),

                  expected_error,

                  actual_error,

                  print_slave_db_safe(db), query_arg);

    }

    /*

      If we get the same error code as expected, or they should be ignored. 

    else if (expected_error == actual_error ||

             ignored_error_code(actual_error))

    {

    }

    /*

      Other cases: mostly we expected no error and get one.

    */

    {

      rli->report(ERROR_LEVEL, actual_error,

                  _("Error '%s' on query. Default database: '%s'. Query: '%s'"),

                   _("unexpected success or fatal error")),

    }

 

    /*

      sql_print_error("Slave: did not get the expected number of affected \

      rows running query from master - expected %d, got %d (this numbers \

      should have matched modulo 4294967296).", 0, ...);

      }

      We may also want an option to tell the slave to ignore "affected"

      mismatch. This mismatch could be implemented with a new ER_ code, and

end:

  pthread_mutex_lock(&LOCK_thread_count);

  /*

    in the data_buf of this event. Now the event is going to be deleted

    pointers to freed memory. 

    So we must set them to 0, so that those bad pointers values are not later

    used. Note that "cleanup" queries like automatic DROP TEMPORARY Table

    don't suffer from these assignments to 0 as DROP TEMPORARY

    Table uses the db.table syntax.

  */

  pthread_mutex_unlock(&LOCK_thread_count);

  /*

    As a disk space optimization, future masters will not log an event for

    LAST_INSERT_ID() if that function returned 0 (and thus they will be able

    resetting below we are ready to support that.

  */

}

 

int Query_log_event::do_update_pos(Relay_log_info *rli)

    after a SET ONE_SHOT, because SET ONE_SHOT should not be separated

    from its following updating query.

  */

  {

    rli->inc_event_relay_log_pos();

    return 0;

  {

    if (strcmp("BEGIN", query) == 0)

    {

      return(Log_event::continue_group(rli));

    }

 

    if (strcmp("COMMIT", query) == 0 || strcmp("ROLLBACK", query) == 0)

    {

      return(Log_event::EVENT_SKIP_COUNT);

    }

  }

    */

    if (created)

    {

      cleanup_load_tmpdir();

    }

    break;

        Can distinguish, based on the value of 'created': this event was

        generated at master startup.

      */

    }

    /*

      Otherwise, can't distinguish a Start_log_event generated at

    original place when it comes to us; we'll know this by checking

    log_pos ("artificial" events have log_pos == 0).

  */

  {

    /* This is not an error (XA is safe), just an information */

    rli->report(INFORMATION_LEVEL, 0,

                  "or ROLLBACK in relay log). A probable cause is that "

                  "the master died while writing the transaction to "

                  "its binary log, thus rolled back too."));

  }

  /*

    If this event comes from ourselves, there is no cleaning task to

  Load_log_event::Load_log_event()

*/

 

                               const char *db_arg, const char *table_name_arg,

                               List<Item> &fields_arg,

                               enum enum_duplicates handle_dup,

                               bool ignore, bool using_trans)

             using_trans),

   num_fields(0),fields(0),

   field_lens(0),field_block_len(0),

   table_name(table_name_arg ? table_name_arg : ""),

{

  time_t end_time;

  time(&end_time);

  /* db can never be a zero pointer in 4.0 */

  db_len = (uint32_t) strlen(db);

  table_name_len = (uint32_t) strlen(table_name);

  LEX_STRING new_db;

  new_db.length= db_len;

  new_db.str= (char *) rpl_filter->get_rewrite_db(db, &new_db.length);

 

  /* see Query_log_event::do_apply_event() and BUG#13360 */

  assert(!rli->m_table_map.count());

    Usually lex_start() is called by mysql_parse(), but we need it here

    as the present method does not call mysql_parse().

  */

 

  if (!use_rli_only_for_errors)

  {

            ::do_apply_event(), then the companion SET also have so

            we don't need to reset_one_shot_variables().

  */

  {

    pthread_mutex_lock(&LOCK_thread_count);

    pthread_mutex_unlock(&LOCK_thread_count);

    /*

      influence in the case of the slave SQL thread (it is used to generate a

      "data truncated" warning but which is absorbed and never gets to the

      error log); still we init it to avoid a Valgrind message.

    */

 

    TableList tables;

    memset(&tables, 0, sizeof(tables));

    tables.alias = tables.table_name = (char*) table_name;

    tables.lock_type = TL_WRITE;

    tables.updating= 1;

 

    // the table will be opened in mysql_load    

    {

      // TODO: this is a bug - this needs to be moved to the I/O thread

      if (net)

        Forge LOAD DATA INFILE query which will be used in SHOW PROCESS LIST

        and written to slave's binlog if binlogging is on.

      */

      {

        /*

          that something is wrong.

        */

        goto error;

      }

 

      *end= 0;

 

      if (sql_ex.opt_flags & REPLACE_FLAG)

      {

        handle_dup= DUP_ERROR;

      }

      /*

        since InnoDB tests these variables to decide if this is a LOAD

        DATA ... REPLACE INTO ... statement even though mysql_parse()

        is not called.  This is not needed in 5.0 since there the LOAD

        DATA ... statement is replicated using mysql_parse(), which

      */

 

      sql_exchange ex((char*)fname, sql_ex.opt_flags & DUMPFILE_FLAG);

      String field_term(sql_ex.field_term,sql_ex.field_term_len,log_cs);

 

      ex.skip_lines = skip_lines;

      List<Item> field_list;

      if (net)

      {

        /*

          Make sure the client does not get confused about the packet sequence

        */

      }

      /*

        It is safe to use tmp_list twice because we are not going to

        update it inside mysql_load().

      */

      List<Item> tmp_list;

                     handle_dup, ignore, net != 0))

      {

        /* log_pos is the position of the LOAD event in the master log */

        sql_print_warning(_("Slave: load data infile on table '%s' at "

                          "warning(s). Default database: '%s'"),

                          (char*) table_name,

                          llstr(log_pos,llbuff), RPL_LOG_NAME, 

      }

      if (net)

    }

  }

  else

  }

 

error:

  pthread_mutex_lock(&LOCK_thread_count);

  pthread_mutex_unlock(&LOCK_thread_count);

 

  {

    /* this err/sql_errno code is copy-paste from net_send_error() */

    const char *err;

    int sql_errno;

    {

    }

    else

    {

                _("Error '%s' running LOAD DATA INFILE on table '%s'. "

                  "Default database: '%s'"),

                err, (char*)table_name, print_slave_db_safe(remember_db));

    return 1;

  }

 

  {

    char buf[256];

    snprintf(buf, sizeof(buf),

    rli->notify_group_relay_log_name_update();

    rli->group_relay_log_pos= rli->event_relay_log_pos;

    /*

      a master's downgrade from 5.0 to 4.0.

      However, no need to reset description_event_for_exec: indeed, if the next

      master is 5.0 (even 5.0.1) we will soon get a Format_desc; if the next

      master is 4.0 then the events are in the slave's format (conversion).

    */

  }

  pthread_mutex_unlock(&rli->data_lock);

  pthread_cond_broadcast(&rli->data_cond);

 

  switch (type) {

  case LAST_INSERT_ID_EVENT:

    break;

  case INSERT_ID_EVENT:

    break;

  }

  return 0;

   */

  const_cast<Relay_log_info*>(rli)->set_flag(Relay_log_info::IN_STMT);

 

  return 0;

}

 

 

int Xid_log_event::do_apply_event(Relay_log_info const *rli __attribute__((unused)))

{

}

 

Log_event::enum_skip_reason

Xid_log_event::do_shall_skip(Relay_log_info *rli)

{

  if (rli->slave_skip_counter > 0) {

    return(Log_event::EVENT_SKIP_COUNT);

  }

  return(Log_event::do_shall_skip(rli));

    Item_func_set_user_var can't substitute something else on its place =>

    0 can be passed as last argument (reference on item)

  */

  /*

    A variable can just be considered as a table with

    a single record and with a single column. Thus, like

    a column value, it could always have IMPLICIT derivation.

   */

  e.update_hash(val, val_len, type, charset, DERIVATION_IMPLICIT, 0);

 

  return 0;

}

  @todo

  re-write this better without holding both locks at the same time

*/

                                 Relay_log_info* rli)

{

  if (!rli->inited)                             // QQ When can this happen ?

    return;

    could give false triggers in MASTER_POS_WAIT() that we have reached

    the target position when in fact we have not.

  */

    rli->inc_event_relay_log_pos();

  else

  {

*/

 

Create_file_log_event::

                      const char* db_arg, const char* table_name_arg,

                      List<Item>& fields_arg, enum enum_duplicates handle_dup,

                      bool ignore,

                      unsigned char* block_arg, uint32_t block_len_arg, bool using_trans)

                  using_trans),

   fake_base(0), block(block_arg), event_buf(0), block_len(block_len_arg),

{

  sql_ex.force_new_format();

  return;

  memset(&file, 0, sizeof(file));

  fname_buf= my_stpcpy(proc_info, "Making temp file ");

  ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");

  my_delete(fname_buf, MYF(0)); // old copy may exist already

  if ((fd= my_create(fname_buf, CREATE_MODE,

                     O_WRONLY | O_EXCL,

    end_io_cache(&file);

  if (fd >= 0)

    my_close(fd, MYF(0));

  return error == 0;

}

 

  Append_block_log_event ctor

*/

 

                                               const char *db_arg,

                                               unsigned char *block_arg,

                                               uint32_t block_len_arg,

                                               bool using_trans)

{

}

 

 

  fname= my_stpcpy(proc_info, "Making temp file ");

  slave_load_file_stem(fname, file_id, server_id, ".data");

  if (get_create_or_append())

  {

    my_delete(fname, MYF(0)); // old copy may exist already

err:

  if (fd >= 0)

    my_close(fd, MYF(0));

  return(error);

}

 

  Delete_file_log_event ctor

*/

 

                                             bool using_trans)

{

}

 

  Execute_load_log_event ctor

*/

 

                                               const char* db_arg,

                                               bool using_trans)

{

}

  

    goto err;

  }

 

  /*

    lev->do_apply_event should use rli only for errors i.e. should

    not advance rli's position.

**************************************************************************/

 

Begin_load_query_log_event::

                           uint32_t block_len_arg, bool using_trans)

                          using_trans)

{

}

 

 

 

 

Execute_load_query_log_event::

                             ulong query_length_arg, uint32_t fn_pos_start_arg,

                             uint32_t fn_pos_end_arg,

                             enum_load_dup_handling dup_handling_arg,

                             bool using_trans, bool suppress_use,

                  suppress_use, killed_err_arg),

  fn_pos_end(fn_pos_end_arg), dup_handling(dup_handling_arg)

{

}

        Rows_log_event member functions

**************************************************************************/

 

                               MY_BITMAP const *cols, bool is_transactional)

    m_row_count(0),

    m_table(tbl_arg),

    m_table_id(tid),

   */

  assert((tbl_arg && tbl_arg->s && tid != UINT32_MAX) || (!tbl_arg && !cols && tid == UINT32_MAX));

 

      set_flags(NO_FOREIGN_KEY_CHECKS_F);

      set_flags(RELAXED_UNIQUE_CHECKS_F);

  /* if bitmap_init fails, caught in is_valid() */

  if (likely(!bitmap_init(&m_cols,

    assert(get_flags(STMT_END_F));

 

    const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();

    return(0);

  }

 

  /*

    do_apply_event(). We still check here to prevent future coding

    errors.

  */

 

  /*

    If there is no locks taken, this is the first binrow event seen

    used in the transaction and proceed with execution of the actual

    event.

  */

  {

    bool need_reopen= 1; /* To execute the first lap of the loop below */

 

    /*

      initialized. Contrary to in

      Table_map_log_event::do_apply_event() we don't call

      mysql_init_query() as that may reset the binlog format.

    */

 

    /*

      There are a few flags that are replicated with each row event.

      the event.

    */

    if (get_flags(NO_FOREIGN_KEY_CHECKS_F))

    else

 

    if (get_flags(RELAXED_UNIQUE_CHECKS_F))

    else

    /* A small test to verify that objects have consistent types */

                               rli->tables_to_lock_count, &need_reopen)))

    {

      if (!need_reopen)

      {

        {

          /*

            Error reporting borrowed from Query_log_event with many excessive

            simplifications (we don't honour --slave-skip-errors)

          */

          rli->report(ERROR_LEVEL, actual_error,

                      _("Error '%s' in %s event: when locking tables"),

                      (actual_error

                       : _("unexpected success or fatal error")),

                      get_type_str());

        }

        else

        {

        NOTE: For this new scheme there should be no pending event:

        need to add code to assert that is the case.

       */

      TableList *tables= rli->tables_to_lock;

 

      uint32_t tables_count= rli->tables_to_lock_count;

      {

        {

          /*

            Error reporting borrowed from Query_log_event with many excessive

            simplifications (we don't honour --slave-skip-errors)

          */

          rli->report(ERROR_LEVEL, actual_error,

                      _("Error '%s' on reopening tables"),

                      (actual_error

                       : _("unexpected success or fatal error")));

        }

        const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();

        return(error);

      {

        if (ptr->m_tabledef.compatible_with(rli, ptr->table))

        {

          const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();

          return(ERR_BAD_TABLE_DEF);

        }

      TIMESTAMP column to a table with one.

      So we call set_time(), like in SBR. Presently it changes nothing.

    */

    /*

      There are a few flags that are replicated with each row event.

      Make sure to set/clear them before executing the main body of

      the event.

    */

    if (get_flags(NO_FOREIGN_KEY_CHECKS_F))

    else

 

    if (get_flags(RELAXED_UNIQUE_CHECKS_F))

    else

    

    if (slave_allow_batching)

    else

    

    /* A small test to verify that objects have consistent types */

 

    /*

      Now we are in a statement and will stay in a statement until we

    while (error == 0 && m_curr_row < m_rows_end)

    {

      /* in_use can have been set to NULL in close_tables_for_reopen */

      if (!table->in_use)

 

      error= do_exec_row(rli);

 

      switch (error)

      {

      case 0:

        if (bit_is_set(slave_exec_mode, SLAVE_EXEC_MODE_IDEMPOTENT) == 1)

        {

          if (global_system_variables.log_warnings)

                                    get_type_str(),

                                    RPL_LOG_NAME, (ulong) log_pos);

          error= 0;

        break;

        

      default:

        break;

      }

 

    error= do_after_row_operations(rli, error);

    if (!cache_stmt)

    {

    }

  } // if (table)

 

  if (rli->tables_to_lock && get_flags(STMT_END_F))

    const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();

  /* reset OPTION_ALLOW_BATCH as not affect later events */

  

  if (error)

  {                     /* error has occured during the transaction */

                            get_type_str(), RPL_LOG_NAME, (ulong) log_pos);

  }

  if (error)

      thread is certainly going to stop.

      rollback at the caller along with sbr.

    */

    return(error);

  }

 

      (assume the last master's transaction is ignored by the slave because of

      replicate-ignore rules).

    */

 

    /*

      If this event is not in a transaction, the call below will, if some

      are involved, commit the transaction and flush the pending event to the

      binlog.

    */

 

    /*

      Now what if this is not a transactional engine? we still need to

      flush the pending event to the binlog; we did it with

      what is done for real queries: a call to

      ha_autocommit_or_rollback() (sometimes only if involves a

      transactional engine), and a call to be sure to have the pending

      event flushed.

    */

 

 

    if (error == 0)

    {

      /*

      rli->stmt_done(log_pos, when);

 

      /*

        found" (as this is allowed). This is a safety measure; apparently

        those errors (e.g. when executing a Delete_rows_log_event of a

        non-existing row, like in rpl_row_mystery22.test,

        do not become visible. We still prefer to wipe them out.

      */

    }

    else