/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */

/**

@file

@brief

logging of commands

@todo

Abort logging when we get an error in reading or writing log files

*/

#include "my_global.h" /* NO_EMBEDDED_ACCESS_CHECKS */

#include "sql_priv.h"

#include "log.h"

#include "sql_base.h" // open_log_table

#include "sql_repl.h"

#include "sql_delete.h" // mysql_truncate

#include "sql_parse.h" // command_name

#include "sql_time.h" // calc_time_from_sec, my_time_compare

#include "tztime.h" // my_tz_OFFSET0, struct Time_zone

#include "sql_acl.h" // SUPER_ACL

#include "log_event.h" // Query_log_event

#include "rpl_filter.h"

#include "rpl_rli.h"

#include "sql_audit.h"

#include <my_dir.h>

#include <stdarg.h>

#include <m_ctype.h> // For test_if_number

#ifdef _WIN32

#include "message.h"

#endif

#include "sql_plugin.h"

#include "rpl_handler.h"

#include "debug_sync.h"

/* max size of the log message */

#define MAX_LOG_BUFFER_SIZE 1024

#define MAX_TIME_SIZE 32

#define MY_OFF_T_UNDEF (~(my_off_t)0UL)

#define FLAGSTR(V,F) ((V)&(F)?#F" ":"")

LOGGER logger;

MYSQL_BIN_LOG mysql_bin_log(&sync_binlog_period);

static bool test_if_number(const char *str,

ulong *res, bool allow_wildcards);

static int binlog_init(void *p);

static int binlog_close_connection(handlerton *hton, THD *thd);

static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv);

static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv);

static int binlog_commit(handlerton *hton, THD *thd, bool all);

static int binlog_rollback(handlerton *hton, THD *thd, bool all);

static int binlog_prepare(handlerton *hton, THD *thd, bool all);

/**

purge logs, master and slave sides both, related error code

convertor.

Called from @c purge_error_message(), @c MYSQL_BIN_LOG::reset_logs()

@param res an internal to purging routines error code

@return the user level error code ER_*

*/

uint purge_log_get_error_code(int res)

{

uint errcode= 0;

switch (res) {

case 0: break;

case LOG_INFO_EOF: errcode= ER_UNKNOWN_TARGET_BINLOG; break;

case LOG_INFO_IO: errcode= ER_IO_ERR_LOG_INDEX_READ; break;

case LOG_INFO_INVALID:errcode= ER_BINLOG_PURGE_PROHIBITED; break;

case LOG_INFO_SEEK: errcode= ER_FSEEK_FAIL; break;

case LOG_INFO_MEM: errcode= ER_OUT_OF_RESOURCES; break;

case LOG_INFO_FATAL: errcode= ER_BINLOG_PURGE_FATAL_ERR; break;

case LOG_INFO_IN_USE: errcode= ER_LOG_IN_USE; break;

case LOG_INFO_EMFILE: errcode= ER_BINLOG_PURGE_EMFILE; break;

default: errcode= ER_LOG_PURGE_UNKNOWN_ERR; break;

}

return errcode;

}

/**

Silence all errors and warnings reported when performing a write

to a log table.

Errors and warnings are not reported to the client or SQL exception

handlers, so that the presence of logging does not interfere and affect

the logic of an application.

*/

class Silence_log_table_errors : public Internal_error_handler

{

char m_message[MYSQL_ERRMSG_SIZE];

public:

Silence_log_table_errors()

{

m_message[0]= '\0';

}

virtual ~Silence_log_table_errors() {}

virtual bool handle_condition(THD *thd,

uint sql_errno,

const char* sql_state,

MYSQL_ERROR::enum_warning_level level,

const char* msg,

MYSQL_ERROR ** cond_hdl);

const char *message() const { return m_message; }

};

bool

Silence_log_table_errors::handle_condition(THD *,

uint,

const char*,

MYSQL_ERROR::enum_warning_level,

const char* msg,

MYSQL_ERROR ** cond_hdl)

{

*cond_hdl= NULL;

strmake(m_message, msg, sizeof(m_message)-1);

return TRUE;

}

sql_print_message_func sql_print_message_handlers[3] =

{

sql_print_information,

sql_print_warning,

sql_print_error

};

/**

Create the name of the log specified.

This method forms a new path + file name for the

log specified in @c name.

@param[IN] buff Location for building new string.

@param[IN] name Name of the log file.

@param[IN] log_ext The extension for the log (e.g. .log).

@returns Pointer to new string containing the name.

*/

char *make_log_name(char *buff, const char *name, const char* log_ext)

{

strmake(buff, name, FN_REFLEN-5);

return fn_format(buff, buff, mysql_real_data_home, log_ext,

MYF(MY_UNPACK_FILENAME|MY_REPLACE_EXT));

}

/*

Helper class to hold a mutex for the duration of the

block.

Eliminates the need for explicit unlocking of mutexes on, e.g.,

error returns. On passing a null pointer, the sentry will not do

anything.

*/

class Mutex_sentry

{

public:

Mutex_sentry(mysql_mutex_t *mutex)

: m_mutex(mutex)

{

if (m_mutex)

mysql_mutex_lock(mutex);

}

~Mutex_sentry()

{

if (m_mutex)

mysql_mutex_unlock(m_mutex);

#ifndef DBUG_OFF

m_mutex= 0;

#endif

}

private:

mysql_mutex_t *m_mutex;

// It's not allowed to copy this object in any way

Mutex_sentry(Mutex_sentry const&);

void operator=(Mutex_sentry const&);

};

/*

Helper classes to store non-transactional and transactional data

before copying it to the binary log.

*/

class binlog_cache_data

{

public:

binlog_cache_data(): m_pending(0), before_stmt_pos(MY_OFF_T_UNDEF),

incident(FALSE), changes_to_non_trans_temp_table_flag(FALSE),

saved_max_binlog_cache_size(0), ptr_binlog_cache_use(0),

ptr_binlog_cache_disk_use(0)

{ }

~binlog_cache_data()

{

DBUG_ASSERT(empty());

close_cached_file(&cache_log);

}

bool empty() const

{

return pending() == NULL && my_b_tell(&cache_log) == 0;

}

Rows_log_event *pending() const

{

return m_pending;

}

void set_pending(Rows_log_event *const pending)

{

m_pending= pending;

}

void set_incident(void)

{

incident= TRUE;

}

bool has_incident(void)

{

return(incident);

}

void set_changes_to_non_trans_temp_table()

{

changes_to_non_trans_temp_table_flag= TRUE;

}

bool changes_to_non_trans_temp_table()

{

return (changes_to_non_trans_temp_table_flag);

}

void reset()

{

compute_statistics();

truncate(0);

changes_to_non_trans_temp_table_flag= FALSE;

incident= FALSE;

before_stmt_pos= MY_OFF_T_UNDEF;

/*

The truncate function calls reinit_io_cache that calls my_b_flush_io_cache

which may increase disk_writes. This breaks the disk_writes use by the

binary log which aims to compute the ratio between in-memory cache usage

and disk cache usage. To avoid this undesirable behavior, we reset the

variable after truncating the cache.

*/

cache_log.disk_writes= 0;

DBUG_ASSERT(empty());

}

my_off_t get_byte_position() const

{

return my_b_tell(&cache_log);

}

my_off_t get_prev_position()

{

return(before_stmt_pos);

}

void set_prev_position(my_off_t pos)

{

before_stmt_pos= pos;

}

void restore_prev_position()

{

truncate(before_stmt_pos);

}

void restore_savepoint(my_off_t pos)

{

truncate(pos);

if (pos < before_stmt_pos)

before_stmt_pos= MY_OFF_T_UNDEF;

}

void set_binlog_cache_info(ulong param_max_binlog_cache_size,

ulong *param_ptr_binlog_cache_use,

ulong *param_ptr_binlog_cache_disk_use)

{

/*

The assertions guarantee that the set_binlog_cache_info is

called just once and information passed as parameters are

never zero.

This is done while calling the constructor binlog_cache_mngr.

We cannot set informaton in the constructor binlog_cache_data

because the space for binlog_cache_mngr is allocated through

a placement new.

In the future, we can refactor this and change it to avoid

the set_binlog_info.

*/

DBUG_ASSERT(saved_max_binlog_cache_size == 0 &&

param_max_binlog_cache_size != 0 &&

ptr_binlog_cache_use == 0 &&

param_ptr_binlog_cache_use != 0 &&

ptr_binlog_cache_disk_use == 0 &&

param_ptr_binlog_cache_disk_use != 0);

saved_max_binlog_cache_size= param_max_binlog_cache_size;

ptr_binlog_cache_use= param_ptr_binlog_cache_use;

ptr_binlog_cache_disk_use= param_ptr_binlog_cache_disk_use;

cache_log.end_of_file= saved_max_binlog_cache_size;

}

/*

Cache to store data before copying it to the binary log.

*/

IO_CACHE cache_log;

private:

/*

Pending binrows event. This event is the event where the rows are currently

written.

*/

Rows_log_event *m_pending;

/*

Binlog position before the start of the current statement.

*/

my_off_t before_stmt_pos;

/*

This indicates that some events did not get into the cache and most likely

it is corrupted.

*/

bool incident;

/*

This flag indicates if the cache has changes to temporary tables.

@TODO This a temporary fix and should be removed after BUG#54562.

*/

bool changes_to_non_trans_temp_table_flag;

/**

This function computes binlog cache and disk usage.

*/

void compute_statistics()

{

if (!empty())

{

statistic_increment(*ptr_binlog_cache_use, &LOCK_status);

if (cache_log.disk_writes != 0)

statistic_increment(*ptr_binlog_cache_disk_use, &LOCK_status);

}

}

/*

Stores the values of maximum size of the cache allowed when this cache

is configured. This corresponds to either

. max_binlog_cache_size or max_binlog_stmt_cache_size.

*/

ulong saved_max_binlog_cache_size;

/*

Stores a pointer to the status variable that keeps track of the in-memory

cache usage. This corresponds to either

. binlog_cache_use or binlog_stmt_cache_use.

*/

ulong *ptr_binlog_cache_use;

/*

Stores a pointer to the status variable that keeps track of the disk

cache usage. This corresponds to either

. binlog_cache_disk_use or binlog_stmt_cache_disk_use.

*/

ulong *ptr_binlog_cache_disk_use;

/*

It truncates the cache to a certain position. This includes deleting the

pending event.

*/

void truncate(my_off_t pos)

{

DBUG_PRINT("info", ("truncating to position %lu", (ulong) pos));

if (pending())

{

delete pending();

set_pending(0);

}

reinit_io_cache(&cache_log, WRITE_CACHE, pos, 0, 0);

cache_log.end_of_file= saved_max_binlog_cache_size;

}

binlog_cache_data& operator=(const binlog_cache_data& info);

binlog_cache_data(const binlog_cache_data& info);

};

class binlog_cache_mngr {

public:

binlog_cache_mngr(ulong param_max_binlog_stmt_cache_size,

ulong param_max_binlog_cache_size,

ulong *param_ptr_binlog_stmt_cache_use,

ulong *param_ptr_binlog_stmt_cache_disk_use,

ulong *param_ptr_binlog_cache_use,

ulong *param_ptr_binlog_cache_disk_use)

{

stmt_cache.set_binlog_cache_info(param_max_binlog_stmt_cache_size,

param_ptr_binlog_stmt_cache_use,

param_ptr_binlog_stmt_cache_disk_use);

trx_cache.set_binlog_cache_info(param_max_binlog_cache_size,

param_ptr_binlog_cache_use,

param_ptr_binlog_cache_disk_use);

}

void reset_cache(binlog_cache_data* cache_data)

{

cache_data->reset();

}

binlog_cache_data* get_binlog_cache_data(bool is_transactional)

{

return (is_transactional ? &trx_cache : &stmt_cache);

}

IO_CACHE* get_binlog_cache_log(bool is_transactional)

{

return (is_transactional ? &trx_cache.cache_log : &stmt_cache.cache_log);

}

binlog_cache_data stmt_cache;

binlog_cache_data trx_cache;

private:

binlog_cache_mngr& operator=(const binlog_cache_mngr& info);

binlog_cache_mngr(const binlog_cache_mngr& info);

};

handlerton *binlog_hton;

bool LOGGER::is_log_table_enabled(uint log_table_type)

{

switch (log_table_type) {

case QUERY_LOG_SLOW:

return (table_log_handler != NULL) && opt_slow_log;

case QUERY_LOG_GENERAL:

return (table_log_handler != NULL) && opt_log ;

default:

DBUG_ASSERT(0);

return FALSE; /* make compiler happy */

}

}

/* Check if a given table is opened log table */

int check_if_log_table(size_t db_len, const char *db, size_t table_name_len,

const char *table_name, bool check_if_opened)

{

if (db_len == 5 &&

!(lower_case_table_names ?

my_strcasecmp(system_charset_info, db, "mysql") :

strcmp(db, "mysql")))

{

if (table_name_len == 11 && !(lower_case_table_names ?

my_strcasecmp(system_charset_info,

table_name, "general_log") :

strcmp(table_name, "general_log")))

{

if (!check_if_opened || logger.is_log_table_enabled(QUERY_LOG_GENERAL))

return QUERY_LOG_GENERAL;

return 0;

}

if (table_name_len == 8 && !(lower_case_table_names ?

my_strcasecmp(system_charset_info, table_name, "slow_log") :

strcmp(table_name, "slow_log")))

{

if (!check_if_opened || logger.is_log_table_enabled(QUERY_LOG_SLOW))

return QUERY_LOG_SLOW;

return 0;

}

}

return 0;

}

Log_to_csv_event_handler::Log_to_csv_event_handler()

{

}

Log_to_csv_event_handler::~Log_to_csv_event_handler()

{

}

void Log_to_csv_event_handler::cleanup()

{

logger.is_log_tables_initialized= FALSE;

}

/* log event handlers */

/**

Log command to the general log table

Log given command to the general log table.

@param event_time command start timestamp

@param user_host the pointer to the string with user@host info

@param user_host_len length of the user_host string. this is computed

once and passed to all general log event handlers

@param thread_id Id of the thread, issued a query

@param command_type the type of the command being logged

@param command_type_len the length of the string above

@param sql_text the very text of the query being executed

@param sql_text_len the length of sql_text string

@return This function attempts to never call my_error(). This is

necessary, because general logging happens already after a statement

status has been sent to the client, so the client can not see the

error anyway. Besides, the error is not related to the statement

being executed and is internal, and thus should be handled

internally (@todo: how?).

If a write to the table has failed, the function attempts to

write to a short error message to the file. The failure is also

indicated in the return value.

@retval FALSE OK

@retval TRUE error occured

*/

bool Log_to_csv_event_handler::

log_general(THD *thd, time_t event_time, const char *user_host,

uint user_host_len, int thread_id,

const char *command_type, uint command_type_len,

const char *sql_text, uint sql_text_len,

CHARSET_INFO *client_cs)

{

TABLE_LIST table_list;

TABLE *table;

bool result= TRUE;

bool need_close= FALSE;

bool need_pop= FALSE;

bool need_rnd_end= FALSE;

uint field_index;

Silence_log_table_errors error_handler;

Open_tables_backup open_tables_backup;

ulonglong save_thd_options;

bool save_time_zone_used;

/*

CSV uses TIME_to_timestamp() internally if table needs to be repaired

which will set thd->time_zone_used

*/

save_time_zone_used= thd->time_zone_used;

save_thd_options= thd->variables.option_bits;

thd->variables.option_bits&= ~OPTION_BIN_LOG;

table_list.init_one_table(MYSQL_SCHEMA_NAME.str, MYSQL_SCHEMA_NAME.length,

GENERAL_LOG_NAME.str, GENERAL_LOG_NAME.length,

GENERAL_LOG_NAME.str,

TL_WRITE_CONCURRENT_INSERT);

/*

1) open_log_table generates an error of the

table can not be opened or is corrupted.

2) "INSERT INTO general_log" can generate warning sometimes.

Suppress these warnings and errors, they can't be dealt with

properly anyway.

QQ: this problem needs to be studied in more detail.

Comment this 2 lines and run "cast.test" to see what's happening.

*/

thd->push_internal_handler(& error_handler);

need_pop= TRUE;

if (!(table= open_log_table(thd, &table_list, &open_tables_backup)))

goto err;

need_close= TRUE;

if (table->file->extra(HA_EXTRA_MARK_AS_LOG_TABLE) ||

table->file->ha_rnd_init(0))

goto err;

need_rnd_end= TRUE;

/* Honor next number columns if present */

table->next_number_field= table->found_next_number_field;

/*

NOTE: we do not call restore_record() here, as all fields are

filled by the Logger (=> no need to load default ones).

*/

/*

We do not set a value for table->field[0], as it will use

default value (which is CURRENT_TIMESTAMP).

*/

/* check that all columns exist */

if (table->s->fields < 6)

goto err;

DBUG_ASSERT(table->field[0]->type() == MYSQL_TYPE_TIMESTAMP);

((Field_timestamp*) table->field[0])->store_timestamp((my_time_t)

event_time);

/* do a write */

if (table->field[1]->store(user_host, user_host_len, client_cs) ||

table->field[2]->store((longlong) thread_id, TRUE) ||

table->field[3]->store((longlong) server_id, TRUE) ||

table->field[4]->store(command_type, command_type_len, client_cs))

goto err;

/*

A positive return value in store() means truncation.

Still logging a message in the log in this case.

*/

table->field[5]->flags|= FIELDFLAG_HEX_ESCAPE;

if (table->field[5]->store(sql_text, sql_text_len, client_cs) < 0)

goto err;

/* mark all fields as not null */

table->field[1]->set_notnull();

table->field[2]->set_notnull();

table->field[3]->set_notnull();

table->field[4]->set_notnull();

table->field[5]->set_notnull();

/* Set any extra columns to their default values */

for (field_index= 6 ; field_index < table->s->fields ; field_index++)

{

table->field[field_index]->set_default();

}

/* log table entries are not replicated */

if (table->file->ha_write_row(table->record[0]))

goto err;

result= FALSE;

err:

if (result && !thd->killed)

sql_print_error("Failed to write to mysql.general_log: %s",

error_handler.message());

if (need_rnd_end)

{

table->file->ha_rnd_end();

table->file->ha_release_auto_increment();

}

if (need_pop)

thd->pop_internal_handler();

if (need_close)

close_log_table(thd, &open_tables_backup);

thd->variables.option_bits= save_thd_options;

thd->time_zone_used= save_time_zone_used;

return result;

}

/*

Log a query to the slow log table

SYNOPSIS

log_slow()

thd THD of the query

current_time current timestamp

query_start_arg command start timestamp

user_host the pointer to the string with user@host info

user_host_len length of the user_host string. this is computed once

and passed to all general log event handlers

query_time Amount of time the query took to execute (in microseconds)

lock_time Amount of time the query was locked (in microseconds)

is_command The flag, which determines, whether the sql_text is a

query or an administrator command (these are treated

differently by the old logging routines)

sql_text the very text of the query or administrator command

processed

sql_text_len the length of sql_text string

DESCRIPTION

Log a query to the slow log table

RETURN

FALSE - OK

TRUE - error occured

*/

bool Log_to_csv_event_handler::

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

const char *user_host, uint user_host_len,

ulonglong query_utime, ulonglong lock_utime, bool is_command,

const char *sql_text, uint sql_text_len)

{

TABLE_LIST table_list;

TABLE *table;

bool result= TRUE;

bool need_close= FALSE;

bool need_rnd_end= FALSE;

Silence_log_table_errors error_handler;

Open_tables_backup open_tables_backup;

CHARSET_INFO *client_cs= thd->variables.character_set_client;

bool save_time_zone_used;

DBUG_ENTER("Log_to_csv_event_handler::log_slow");

thd->push_internal_handler(& error_handler);

/*

CSV uses TIME_to_timestamp() internally if table needs to be repaired

which will set thd->time_zone_used

*/

save_time_zone_used= thd->time_zone_used;

table_list.init_one_table(MYSQL_SCHEMA_NAME.str, MYSQL_SCHEMA_NAME.length,

SLOW_LOG_NAME.str, SLOW_LOG_NAME.length,

SLOW_LOG_NAME.str,

TL_WRITE_CONCURRENT_INSERT);

if (!(table= open_log_table(thd, &table_list, &open_tables_backup)))

goto err;

need_close= TRUE;

if (table->file->extra(HA_EXTRA_MARK_AS_LOG_TABLE) ||

table->file->ha_rnd_init(0))

goto err;

need_rnd_end= TRUE;

/* Honor next number columns if present */

table->next_number_field= table->found_next_number_field;

restore_record(table, s->default_values); // Get empty record

/* check that all columns exist */

if (table->s->fields < 11)

goto err;

/* store the time and user values */

DBUG_ASSERT(table->field[0]->type() == MYSQL_TYPE_TIMESTAMP);

((Field_timestamp*) table->field[0])->store_timestamp((my_time_t)

current_time);

if (table->field[1]->store(user_host, user_host_len, client_cs))

goto err;

if (query_start_arg)

{

longlong query_time= (longlong) (query_utime/1000000);

longlong lock_time= (longlong) (lock_utime/1000000);

/*

A TIME field can not hold the full longlong range; query_time or

lock_time may be truncated without warning here, if greater than

839 hours (~35 days)

*/

MYSQL_TIME t;

t.neg= 0;

/* fill in query_time field */

calc_time_from_sec(&t, (long) min(query_time, (longlong) TIME_MAX_VALUE_SECONDS), 0);

if (table->field[2]->store_time(&t, MYSQL_TIMESTAMP_TIME))

goto err;

/* lock_time */

calc_time_from_sec(&t, (long) min(lock_time, (longlong) TIME_MAX_VALUE_SECONDS), 0);

if (table->field[3]->store_time(&t, MYSQL_TIMESTAMP_TIME))

goto err;

/* rows_sent */

if (table->field[4]->store((longlong) thd->sent_row_count, TRUE))

goto err;

/* rows_examined */

if (table->field[5]->store((longlong) thd->examined_row_count, TRUE))

goto err;

}

else

{

table->field[2]->set_null();

table->field[3]->set_null();

table->field[4]->set_null();

table->field[5]->set_null();

}

/* fill database field */

if (thd->db)

{

if (table->field[6]->store(thd->db, thd->db_length, client_cs))

goto err;

table->field[6]->set_notnull();

}

if (thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt)

{

if (table->

field[7]->store((longlong)

thd->first_successful_insert_id_in_prev_stmt_for_binlog,

TRUE))

goto err;

table->field[7]->set_notnull();

}

/*

Set value if we do an insert on autoincrement column. Note that for

some engines (those for which get_auto_increment() does not leave a

table lock until the statement ends), this is just the first value and

the next ones used may not be contiguous to it.

*/

if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0)

{

if (table->

field[8]->store((longlong)

thd->auto_inc_intervals_in_cur_stmt_for_binlog.minimum(), TRUE))

goto err;

table->field[8]->set_notnull();

}

if (table->field[9]->store((longlong) server_id, TRUE))

goto err;

table->field[9]->set_notnull();

/*

Column sql_text.

A positive return value in store() means truncation.

Still logging a message in the log in this case.

*/

if (table->field[10]->store(sql_text, sql_text_len, client_cs) < 0)

goto err;

/* log table entries are not replicated */

if (table->file->ha_write_row(table->record[0]))

goto err;

result= FALSE;

err:

thd->pop_internal_handler();

if (result && !thd->killed)

sql_print_error("Failed to write to mysql.slow_log: %s",

error_handler.message());

if (need_rnd_end)

{

table->file->ha_rnd_end();

table->file->ha_release_auto_increment();

}

if (need_close)

close_log_table(thd, &open_tables_backup);

thd->time_zone_used= save_time_zone_used;

DBUG_RETURN(result);

}

int Log_to_csv_event_handler::

activate_log(THD *thd, uint log_table_type)

{

TABLE_LIST table_list;

TABLE *table;

LEX_STRING *UNINIT_VAR(log_name);

int result;

Open_tables_backup open_tables_backup;

DBUG_ENTER("Log_to_csv_event_handler::activate_log");

if (log_table_type == QUERY_LOG_GENERAL)

{

log_name= &GENERAL_LOG_NAME;

}

else

{

DBUG_ASSERT(log_table_type == QUERY_LOG_SLOW);

log_name= &SLOW_LOG_NAME;

}

table_list.init_one_table(MYSQL_SCHEMA_NAME.str, MYSQL_SCHEMA_NAME.length,

log_name->str, log_name->length, log_name->str,

TL_WRITE_CONCURRENT_INSERT);

table= open_log_table(thd, &table_list, &open_tables_backup);

if (table)

{

result= 0;

close_log_table(thd, &open_tables_backup);

}

else

result= 1;

DBUG_RETURN(result);

}

bool Log_to_csv_event_handler::

log_error(enum loglevel level, const char *format, va_list args)

{

/* No log table is implemented */

DBUG_ASSERT(0);

return FALSE;

}

bool Log_to_file_event_handler::

log_error(enum loglevel level, const char *format,

va_list args)

{

return vprint_msg_to_log(level, format, args);

}

void Log_to_file_event_handler::init_pthread_objects()

{

mysql_log.init_pthread_objects();

mysql_slow_log.init_pthread_objects();

}

/** Wrapper around MYSQL_LOG::write() for slow log. */

bool Log_to_file_event_handler::

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

const char *user_host, uint user_host_len,

ulonglong query_utime, ulonglong lock_utime, bool is_command,

const char *sql_text, uint sql_text_len)

{

Silence_log_table_errors error_handler;

thd->push_internal_handler(&error_handler);

bool retval= mysql_slow_log.write(thd, current_time, query_start_arg,

user_host, user_host_len,

query_utime, lock_utime, is_command,

sql_text, sql_text_len);

thd->pop_internal_handler();

return retval;

}

/**

Wrapper around MYSQL_LOG::write() for general log. We need it since we

want all log event handlers to have the same signature.

*/

bool Log_to_file_event_handler::

log_general(THD *thd, time_t event_time, const char *user_host,

uint user_host_len, int thread_id,

const char *command_type, uint command_type_len,

const char *sql_text, uint sql_text_len,

CHARSET_INFO *client_cs)

{

Silence_log_table_errors error_handler;

thd->push_internal_handler(&error_handler);

bool retval= mysql_log.write(event_time, user_host, user_host_len,

thread_id, command_type, command_type_len,

sql_text, sql_text_len);

thd->pop_internal_handler();

return retval;

}

bool Log_to_file_event_handler::init()

{

if (!is_initialized)

{

if (opt_slow_log)

mysql_slow_log.open_slow_log(opt_slow_logname);

if (opt_log)

mysql_log.open_query_log(opt_logname);

is_initialized= TRUE;

}

return FALSE;

}

void Log_to_file_event_handler::cleanup()

{

mysql_log.cleanup();

mysql_slow_log.cleanup();

}

void Log_to_file_event_handler::flush()

{