~drizzle-trunk/drizzle/development

 

LOGGER logger;

 

ulong sync_binlog_counter= 0;

 

static bool test_if_number(const char *str,

}

 

 

 

bool Log_to_file_event_handler::

  log_slow(THD *thd, time_t current_time, time_t query_start_arg,

 

 

/**

   want all log event handlers to have the same signature.

*/

 

bool LOGGER::activate_log_handler(THD* thd __attribute__((unused)),

                                  uint log_type)

{

  bool res= false;

  lock_exclusive();

  switch (log_type) {

                                    uint log_type)

{

  bool *tmp_opt= 0;

 

  switch (log_type) {

  case QUERY_LOG_SLOW:

 

/*

  this function is mostly a placeholder.

  should be moved here.

*/

 

    do nothing.

    just pretend we can do 2pc, so that MySQL won't

    switch to 1pc.

  */

  return 0;

}

 

  if (trx_data->empty())

  {

    trx_data->reset();

    return(0);

  }

  if ((in_transaction && (all || (!trx_data->at_least_one_stmt && thd->transaction.stmt.modified_non_trans_table))) || (!in_transaction && !all))

  {

    Query_log_event qev(thd, STRING_WITH_LEN("COMMIT"), true, false);

    int error= binlog_end_trans(thd, trx_data, &qev, all);

    return(error);

  }

      rolled back on the slave.

    */

    Query_log_event qev(thd, STRING_WITH_LEN("ROLLBACK"), true, false);

    error= binlog_end_trans(thd, trx_data, &qev, all);

  }

  else if ((all && !thd->transaction.all.modified_non_trans_table) ||

}

 

 

                     enum cache_type io_cache_type_arg)

{

  log_type= log_type_arg;

    1   error

*/

 

                     const char *new_name, enum cache_type io_cache_type_arg)

{

  char buff[FN_REFLEN];

    char *end;

    int len=snprintf(buff, sizeof(buff), "%s, Version: %s (%s). "

                     "started with:\nTCP Port: %d, Named Pipe: %s\n",

                     mysqld_port, ""

                     );

    end= stpncpy(buff + len, "Time                 Id Command    Argument\n",

  return(1);

}

 

  : name(0), write_error(false), inited(false), log_type(LOG_UNKNOWN),

    log_state(LOG_CLOSED)

{

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

}

 

{

  assert(inited == 0);

  inited= 1;

    The internal structures are not freed until cleanup() is called

*/

 

{                                       // One can't set log_type here!

  if (log_state == LOG_OPENED)

  {

 

/** This is called only once. */

 

{

  if (inited)

  {

}

 

 

{

  fn_format(new_name, log_name, mysql_data_home, "", 4);

  if (log_type == LOG_BIN)

*/

 

 

{

  char *save_name;

 

    TRUE - error occured

*/

 

                            const char *user_host __attribute__((unused)),

                            uint user_host_len __attribute__((unused)),

                            int thread_id,

    TRUE - error occured

*/

 

                            time_t query_start_arg __attribute__((unused)),

                            const char *user_host,

                            uint user_host_len, uint64_t query_utime,

  The following should be using fn_format();  We just need to

  first change fn_format() to cut the file name if it's too long.

*/

                                      const char *suffix,

                                      bool strip_ext, char *buff)

{

 

 

 

  :bytes_written(0), prepared_xids(0), file_id(1), open_count(1),

   need_start_event(true), m_table_map_version(0),

   description_event_for_exec(0), description_event_for_queue(0)

 

/* this is called only once */

 

{

  if (inited)

  {

 

 

/* Init binlog-specific vars */

{

  no_auto_events= no_auto_events_arg;

  max_size= max_size_arg;

}

 

 

{

  assert(inited == 0);

  inited= 1;

}

 

 

                                const char *log_name)

{

  File index_file_nr= -1;

    1   error

*/

 

                         enum_log_type log_type_arg,

                         const char *new_name,

                         enum cache_type io_cache_type_arg,

  write_error=0;

 

  /* open the main log file */

    return(1);                            /* all warnings issued */

 

  init(no_auto_events_arg, max_size_arg);

}

 

 

{

  pthread_mutex_lock(&LOCK_log);

  int ret = raw_get_current_log(linfo);

  return ret;

}

 

{

  strmake(linfo->log_file_name, log_file_name, sizeof(linfo->log_file_name)-1);

  linfo->pos = my_b_tell(&log_file);

    LOG_INFO_IO         Got IO error while reading file

*/

 

                            bool need_lock)

{

  int error= 0;

    LOG_INFO_IO         Got IO error while reading file

*/

 

{

  int error= 0;

  uint length;

    1   error

*/

 

{

  LOG_INFO linfo;

  bool error=0;

 

#ifdef HAVE_REPLICATION

 

{

  int error;

 

  Update log index_file.

*/

 

{

  if (copy_up_file_and_fill(&index_file, log_info->index_file_start_offset))

    return LOG_INFO_IO;

                                stat() or my_delete()

*/

 

                          bool included,

                          bool need_mutex, 

                          bool need_update_threads, 

                                stat() or my_delete()

*/

 

{

  int error;

  LOG_INFO log_info;

    If file name will be longer then FN_REFLEN it will be truncated

*/

 

{

  uint dir_len = dirname_length(log_file_name); 

  if (dir_len >= FN_REFLEN)

  Check if we are writing/reading to the given log file.

*/

 

{

  return !strcmp(log_file_name, log_file_name_arg);

}

  method).

*/

 

{

  new_file_impl(1);

}

 

 

{

  new_file_impl(0);

}

    The new file name is stored last in the index file

*/

 

{

  char new_name[FN_REFLEN], *new_name_ptr, *old_name;

 

}

 

 

{

  bool error = 0;

  pthread_mutex_lock(&LOCK_log);

}

 

 

{

  bool error= 0;

  va_list(args);

}

 

 

{

  int err=0, fd=log_file.file;

  safe_mutex_assert_owner(&LOCK_log);

  return err;

}

 

{

  assert(!thd->binlog_evt_union.do_union);

  thd->binlog_evt_union.do_union= true;

  thd->binlog_evt_union.first_query_id= query_id_param;

}

 

{

  assert(thd->binlog_evt_union.do_union);

  thd->binlog_evt_union.do_union= false;

}

 

{

  return (thd->binlog_evt_union.do_union && 

          query_id_param >= thd->binlog_evt_union.first_query_id);

  event.

*/

int

                                                Rows_log_event* event)

{

  assert(mysql_bin_log.is_open());

  Write an event to the binary log.

*/

 

{

  THD *thd= event_info->thd;

  bool error= 1;

  return false;

}

 

{

  if (!(flags & RP_LOCK_LOG_IS_ALREADY_LOCKED))

    pthread_mutex_lock(&LOCK_log);

    pthread_mutex_unlock(&LOCK_log);

}

 

{

  uint res;

  pthread_mutex_lock(&LOCK_log);

    be reset as a READ_CACHE to be able to read the contents from it.

 */

 

{

  Mutex_sentry sentry(lock_log ? &LOCK_log : NULL);

 

    'cache' needs to be reinitialized after this functions returns.

*/

 

{

  VOID(pthread_mutex_lock(&LOCK_log));

 

    It will be released at the end of the function.

*/

 

{

  const char *old_msg;

  old_msg= thd->enter_cond(&update_cond, &LOCK_log,

    LOCK_log is released by the caller.

*/

 

                                           const struct timespec *timeout)

{

  int ret= 0;

    The internal structures are not freed until cleanup() is called

*/

 

{                                       // One can't set log_type here!

  if (log_state == LOG_OPENED)

  {

    }

 

    /* this will cleanup IO_CACHE, sync and close the file */

  }

 

  /*

}

 

 

{

  /*

    We need to take locks, otherwise this may happen:

   return result;

}

 

{

  pthread_cond_broadcast(&update_cond);

  return;

    threads waiting for a page, but then all these threads will be waiting

    for a fsync() anyway

 

   records XID in a special Xid_log_event.

   If tc_log = TC_LOG_MMAP then xid is written in a special memory-mapped

   log.

}

 

/****** transaction coordinator log for 2pc - binlog() based solution ******/

 

/**

  @todo

 

mysql_declare_plugin(binlog)

{

  "binlog",

  "1.0",

  "MySQL AB",