← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/log.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/log.cc
29
29
#include "rpl_filter.h"
30
30
#include "rpl_rli.h"
31
31
 
32
 
#include <my_dir.h>
 
32
#include <mysys/my_dir.h>
33
33
#include <stdarg.h>
34
 
#include <m_ctype.h>                            // For test_if_number
35
34
 
36
 
#include <mysql/plugin.h>
 
35
#include <drizzled/plugin.h>
37
36
 
38
37
/* max size of the log message */
39
38
#define MAX_LOG_BUFFER_SIZE 1024
203
202
 
204
203
 
205
204
/* Check if a given table is opened log table */
206
 
int check_if_log_table(uint db_len __attribute__((__unused__)),
207
 
                       const char *db __attribute__((__unused__)),
208
 
                       uint table_name_len __attribute__((__unused__)),
209
 
                       const char *table_name __attribute__((__unused__)),
210
 
                       uint check_if_opened __attribute__((__unused__)))
 
205
int check_if_log_table(uint db_len __attribute__((unused)),
 
206
                       const char *db __attribute__((unused)),
 
207
                       uint table_name_len __attribute__((unused)),
 
208
                       const char *table_name __attribute__((unused)),
 
209
                       uint check_if_opened __attribute__((unused)))
211
210
{
212
211
  return 0;
213
212
}
249
248
*/
250
249
 
251
250
bool Log_to_file_event_handler::
252
 
  log_general(THD *thd __attribute__((__unused__)),
 
251
  log_general(THD *thd __attribute__((unused)),
253
252
              time_t event_time, const char *user_host,
254
253
              uint user_host_len, int thread_id,
255
254
              const char *command_type, uint command_type_len,
256
255
              const char *sql_text, uint sql_text_len,
257
 
              CHARSET_INFO *client_cs __attribute__((__unused__)))
 
256
              CHARSET_INFO *client_cs __attribute__((unused)))
258
257
{
259
258
  return mysql_log.write(event_time, user_host, user_host_len,
260
259
                         thread_id, command_type, command_type_len,
366
365
}
367
366
 
368
367
 
369
 
bool LOGGER::flush_logs(THD *thd __attribute__((__unused__)))
 
368
bool LOGGER::flush_logs(THD *thd __attribute__((unused)))
370
369
{
371
370
  int rc= 0;
372
371
 
542
541
    error_log_handler_list[0]= file_log_handler;
543
542
    error_log_handler_list[1]= 0;
544
543
    break;
545
 
    /* these two are disabled for now */
546
 
  case LOG_TABLE:
547
 
    assert(0);
548
 
    break;
549
 
  case LOG_TABLE|LOG_FILE:
550
 
    assert(0);
551
 
    break;
552
544
  }
553
545
}
554
546
 
577
569
}
578
570
 
579
571
 
580
 
bool LOGGER::activate_log_handler(THD* thd __attribute__((__unused__)),
 
572
bool LOGGER::activate_log_handler(THD* thd __attribute__((unused)),
581
573
                                  uint log_type)
582
574
{
583
575
  MYSQL_QUERY_LOG *file_log;
612
604
}
613
605
 
614
606
 
615
 
void LOGGER::deactivate_log_handler(THD *thd __attribute__((__unused__)),
 
607
void LOGGER::deactivate_log_handler(THD *thd __attribute__((unused)),
616
608
                                    uint log_type)
617
609
{
618
610
  bool *tmp_opt= 0;
645
637
                         uint general_log_printer)
646
638
{
647
639
  /* error log table is not supported yet */
648
 
  assert(error_log_printer < LOG_TABLE);
649
 
 
650
640
  lock_exclusive();
651
641
 
652
642
  init_error_log(error_log_printer);
736
726
  binlog_hton->rollback= binlog_rollback;
737
727
  binlog_hton->prepare= binlog_prepare;
738
728
  binlog_hton->flags= HTON_NOT_USER_SELECTABLE | HTON_HIDDEN;
 
729
 
739
730
  return 0;
740
731
}
741
732
 
742
 
static int binlog_close_connection(handlerton *hton __attribute__((__unused__)),
 
733
static int binlog_close_connection(handlerton *hton __attribute__((unused)),
743
734
                                   THD *thd)
744
735
{
745
736
  binlog_trx_data *const trx_data=
846
837
  return(error);
847
838
}
848
839
 
849
 
static int binlog_prepare(handlerton *hton __attribute__((__unused__)),
850
 
                          THD *thd __attribute__((__unused__)),
851
 
                          bool all __attribute__((__unused__)))
 
840
static int binlog_prepare(handlerton *hton __attribute__((unused)),
 
841
                          THD *thd __attribute__((unused)),
 
842
                          bool all __attribute__((unused)))
852
843
{
853
844
  /*
854
845
    do nothing.
874
865
 
875
866
  @see handlerton::commit
876
867
*/
877
 
static int binlog_commit(handlerton *hton __attribute__((__unused__)),
 
868
static int binlog_commit(handlerton *hton __attribute__((unused)),
878
869
                         THD *thd, bool all)
879
870
{
880
871
  binlog_trx_data *const trx_data=
972
963
 
973
964
  @see handlerton::rollback
974
965
*/
975
 
static int binlog_rollback(handlerton *hton __attribute__((__unused__)),
 
966
static int binlog_rollback(handlerton *hton __attribute__((unused)),
976
967
                           THD *thd, bool all)
977
968
{
978
969
  int error=0;
1037
1028
  that case there is no need to have it in the binlog).
1038
1029
*/
1039
1030
 
1040
 
static int binlog_savepoint_set(handlerton *hton __attribute__((__unused__)),
 
1031
static int binlog_savepoint_set(handlerton *hton __attribute__((unused)),
1041
1032
                                THD *thd, void *sv)
1042
1033
{
1043
1034
  binlog_trans_log_savepos(thd, (my_off_t*) sv);
1049
1040
  return(error);
1050
1041
}
1051
1042
 
1052
 
static int binlog_savepoint_rollback(handlerton *hton __attribute__((__unused__)),
 
1043
static int binlog_savepoint_rollback(handlerton *hton __attribute__((unused)),
1053
1044
                                     THD *thd, void *sv)
1054
1045
{
1055
1046
  /*
1160
1151
  file_info= dir_info->dir_entry;
1161
1152
  for (i=dir_info->number_off_files ; i-- ; file_info++)
1162
1153
  {
1163
 
    if (bcmp((uchar*) file_info->name, (uchar*) start, length) == 0 &&
 
1154
    if (memcmp((uchar*) file_info->name, (uchar*) start, length) == 0 &&
1164
1155
        test_if_number(file_info->name+length, &number,0))
1165
1156
    {
1166
1157
      set_if_bigger(max_found,(ulong) number);
1282
1273
    called only in main(). Doing initialization here would make it happen
1283
1274
    before main().
1284
1275
  */
1285
 
  bzero((char*) &log_file, sizeof(log_file));
 
1276
  memset((char*) &log_file, 0, sizeof(log_file));
1286
1277
}
1287
1278
 
1288
1279
void MYSQL_LOG::init_pthread_objects()
1428
1419
*/
1429
1420
 
1430
1421
bool MYSQL_QUERY_LOG::write(time_t event_time,
1431
 
                            const char *user_host __attribute__((__unused__)),
1432
 
                            uint user_host_len __attribute__((__unused__)),
 
1422
                            const char *user_host __attribute__((unused)),
 
1423
                            uint user_host_len __attribute__((unused)),
1433
1424
                            int thread_id,
1434
1425
                            const char *command_type, uint command_type_len,
1435
1426
                            const char *sql_text, uint sql_text_len)
1530
1521
*/
1531
1522
 
1532
1523
bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
1533
 
                            time_t query_start_arg __attribute__((__unused__)),
 
1524
                            time_t query_start_arg __attribute__((unused)),
1534
1525
                            const char *user_host,
1535
1526
                            uint user_host_len, uint64_t query_utime,
1536
1527
                            uint64_t lock_utime, bool is_command,
1696
1687
    before main().
1697
1688
  */
1698
1689
  index_file_name[0] = 0;
1699
 
  bzero((char*) &index_file, sizeof(index_file));
 
1690
  memset((char*) &index_file, 0, sizeof(index_file));
1700
1691
}
1701
1692
 
1702
1693
/* this is called only once */
3896
3887
    return an error (e.g. logging to the log tables)
3897
3888
*/
3898
3889
static void print_buffer_to_file(enum loglevel level,
3899
 
                                 int error_code __attribute__((__unused__)),
 
3890
                                 int error_code __attribute__((unused)),
3900
3891
                                 const char *buffer,
3901
 
                                 size_t buffer_length __attribute__((__unused__)))
 
3892
                                 size_t buffer_length __attribute__((unused)))
3902
3893
{
3903
3894
  time_t skr;
3904
3895
  struct tm tm_tmp;
4227
4218
    to the position in memory where xid was logged to.
4228
4219
*/
4229
4220
 
4230
 
int TC_LOG_MMAP::log_xid(THD *thd __attribute__((__unused__)), my_xid xid)
 
4221
int TC_LOG_MMAP::log_xid(THD *thd __attribute__((unused)), my_xid xid)
4231
4222
{
4232
4223
  int err;
4233
4224
  PAGE *p;
4339
4330
  cookie points directly to the memory where xid was logged.
4340
4331
*/
4341
4332
 
4342
 
void TC_LOG_MMAP::unlog(ulong cookie, my_xid xid __attribute__((__unused__)))
 
4333
void TC_LOG_MMAP::unlog(ulong cookie, my_xid xid __attribute__((unused)))
4343
4334
{
4344
4335
  PAGE *p=pages+(cookie/tc_log_page_size);
4345
4336
  my_xid *x=(my_xid *)(data+cookie);
4429
4420
    goto err2;
4430
4421
 
4431
4422
  hash_free(&xids);
4432
 
  bzero(data, (size_t)file_length);
 
4423
  memset(data, 0, (size_t)file_length);
4433
4424
  return 0;
4434
4425
 
4435
4426
err2:
4597
4588
  return(!binlog_end_trans(thd, trx_data, &xle, true));
4598
4589
}
4599
4590
 
4600
 
void TC_LOG_BINLOG::unlog(ulong cookie __attribute__((__unused__)),
4601
 
                          my_xid xid __attribute__((__unused__)))
 
4591
void TC_LOG_BINLOG::unlog(ulong cookie __attribute__((unused)),
 
4592
                          my_xid xid __attribute__((unused)))
4602
4593
{
4603
4594
  pthread_mutex_lock(&LOCK_prep_xids);
4604
4595
  assert(prepared_xids > 0);