← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.cc
25
25
 
26
26
#include "mysql_priv.h"
27
27
#include "rpl_filter.h"
28
 
#include <myisampack.h>
29
28
#include <errno.h>
30
29
 
31
30
/*
331
330
    break;
332
331
  };
333
332
 
334
 
  if (hton->panic)
335
 
    hton->panic(hton, HA_PANIC_CLOSE);
 
333
  if (hton && plugin->plugin->deinit)
 
334
    (void)plugin->plugin->deinit(hton);
336
335
 
337
336
  my_free((uchar*)hton, MYF(0));
338
337
 
353
352
    structure. Apparently get_backup_engine was not NULL even though it was
354
353
    not initialized.
355
354
   */
356
 
  bzero(hton, sizeof(hton));
 
355
  memset(hton, 0, sizeof(hton));
357
356
  /* Historical Requirement */
358
357
  plugin->data= hton; // shortcut for the future
359
358
  if (plugin->plugin->init)
463
462
  return(error);
464
463
}
465
464
 
466
 
static bool dropdb_handlerton(THD *unused1 __attribute__((__unused__)),
 
465
static bool dropdb_handlerton(THD *unused1 __attribute__((unused)),
467
466
                              plugin_ref plugin,
468
467
                              void *path)
469
468
{
481
480
 
482
481
 
483
482
static bool closecon_handlerton(THD *thd, plugin_ref plugin,
484
 
                                void *unused __attribute__((__unused__)))
 
483
                                void *unused __attribute__((unused)))
485
484
{
486
485
  handlerton *hton= plugin_data(plugin, handlerton *);
487
486
  /*
1201
1200
  int result;
1202
1201
};
1203
1202
 
1204
 
static bool xacommit_handlerton(THD *unused1 __attribute__((__unused__)),
 
1203
static bool xacommit_handlerton(THD *unused1 __attribute__((unused)),
1205
1204
                                plugin_ref plugin,
1206
1205
                                void *arg)
1207
1206
{
1214
1213
  return false;
1215
1214
}
1216
1215
 
1217
 
static bool xarollback_handlerton(THD *unused1 __attribute__((__unused__)),
 
1216
static bool xarollback_handlerton(THD *unused1 __attribute__((unused)),
1218
1217
                                  plugin_ref plugin,
1219
1218
                                  void *arg)
1220
1219
{
1264
1263
  bool dry_run;
1265
1264
};
1266
1265
 
1267
 
static bool xarecover_handlerton(THD *unused __attribute__((__unused__)),
 
1266
static bool xarecover_handlerton(THD *unused __attribute__((unused)),
1268
1267
                                 plugin_ref plugin,
1269
1268
                                 void *arg)
1270
1269
{
1445
1444
    always 0
1446
1445
*/
1447
1446
static bool release_temporary_latches(THD *thd, plugin_ref plugin,
1448
 
                                      void *unused __attribute__((__unused__)))
 
1447
                                      void *unused __attribute__((unused)))
1449
1448
{
1450
1449
  handlerton *hton= plugin_data(plugin, handlerton *);
1451
1450
 
1605
1604
}
1606
1605
 
1607
1606
 
1608
 
static bool flush_handlerton(THD *thd __attribute__((__unused__)),
 
1607
static bool flush_handlerton(THD *thd __attribute__((unused)),
1609
1608
                             plugin_ref plugin,
1610
 
                             void *arg __attribute__((__unused__)))
 
1609
                             void *arg __attribute__((unused)))
1611
1610
{
1612
1611
  handlerton *hton= plugin_data(plugin, handlerton *);
1613
1612
  if (hton->state == SHOW_OPTION_YES && hton->flush_logs && 
1672
1671
 
1673
1672
bool
1674
1673
Ha_delete_table_error_handler::
1675
 
handle_error(uint sql_errno  __attribute__((__unused__)),
 
1674
handle_error(uint sql_errno  __attribute__((unused)),
1676
1675
             const char *message,
1677
 
             MYSQL_ERROR::enum_warning_level level __attribute__((__unused__)),
1678
 
             THD *thd __attribute__((__unused__)))
 
1676
             MYSQL_ERROR::enum_warning_level level __attribute__((unused)),
 
1677
             THD *thd __attribute__((unused)))
1679
1678
{
1680
1679
  /* Grab the error message */
1681
1680
  strmake(buff, message, sizeof(buff)-1);
1696
1695
  TABLE dummy_table;
1697
1696
  TABLE_SHARE dummy_share;
1698
1697
 
1699
 
  bzero((char*) &dummy_table, sizeof(dummy_table));
1700
 
  bzero((char*) &dummy_share, sizeof(dummy_share));
 
1698
  memset((char*) &dummy_table, 0, sizeof(dummy_table));
 
1699
  memset((char*) &dummy_share, 0, sizeof(dummy_share));
1701
1700
  dummy_table.s= &dummy_share;
1702
1701
 
1703
1702
  /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
2210
2209
  @param first_value         (OUT) the first value reserved by the handler
2211
2210
  @param nb_reserved_values  (OUT) how many values the handler reserved
2212
2211
*/
2213
 
void handler::get_auto_increment(uint64_t offset __attribute__((__unused__)),
2214
 
                                 uint64_t increment __attribute__((__unused__)),
2215
 
                                 uint64_t nb_desired_values __attribute__((__unused__)),
 
2212
void handler::get_auto_increment(uint64_t offset __attribute__((unused)),
 
2213
                                 uint64_t increment __attribute__((unused)),
 
2214
                                 uint64_t nb_desired_values __attribute__((unused)),
2216
2215
                                 uint64_t *first_value,
2217
2216
                                 uint64_t *nb_reserved_values)
2218
2217
{
2510
2509
  @return
2511
2510
    Returns true if this is a temporary error
2512
2511
*/
2513
 
bool handler::get_error_message(int error __attribute__((__unused__)),
2514
 
                                String* buf __attribute__((__unused__)))
 
2512
bool handler::get_error_message(int error __attribute__((unused)),
 
2513
                                String* buf __attribute__((unused)))
2515
2514
{
2516
2515
  return false;
2517
2516
}
2536
2535
        if (!keypart->fieldnr)
2537
2536
          continue;
2538
2537
        Field *field= table->field[keypart->fieldnr-1];
2539
 
        if (field->type() == MYSQL_TYPE_BLOB)
 
2538
        if (field->type() == DRIZZLE_TYPE_BLOB)
2540
2539
        {
2541
2540
          if (check_opt->sql_flags & TT_FOR_UPGRADE)
2542
2541
            check_opt->flags= T_MEDIUM;
3139
3138
  TABLE table;
3140
3139
  TABLE_SHARE share;
3141
3140
 
3142
 
  bzero((uchar*) &create_info,sizeof(create_info));
 
3141
  memset((uchar*) &create_info, 0, sizeof(create_info));
3143
3142
  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
3144
3143
  {
3145
3144
    /* Table could not be discovered and thus not created */
3199
3198
/**
3200
3199
  Init a key cache if it has not been initied before.
3201
3200
*/
3202
 
int ha_init_key_cache(const char *name __attribute__((__unused__)),
 
3201
int ha_init_key_cache(const char *name __attribute__((unused)),
3203
3202
                      KEY_CACHE *key_cache)
3204
3203
{
3205
3204
  if (!key_cache->key_cache_inited)
3453
3452
ha_rows
3454
3453
handler::multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq,
3455
3454
                                     void *seq_init_param,
3456
 
                                     uint n_ranges_arg __attribute__((__unused__)),
 
3455
                                     uint n_ranges_arg __attribute__((unused)),
3457
3456
                                     uint *bufsz, uint *flags, COST_VECT *cost)
3458
3457
{
3459
3458
  KEY_MULTI_RANGE range;
3605
3604
int
3606
3605
handler::multi_range_read_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param,
3607
3606
                               uint n_ranges, uint mode,
3608
 
                               HANDLER_BUFFER *buf __attribute__((__unused__)))
 
3607
                               HANDLER_BUFFER *buf __attribute__((unused)))
3609
3608
{
3610
3609
  mrr_iter= seq_funcs->init(seq_init_param, n_ranges, mode);
3611
3610
  mrr_funcs= *seq_funcs;
3631
3630
int handler::multi_range_read_next(char **range_info)
3632
3631
{
3633
3632
  int result= 0;
3634
 
  int range_res;
 
3633
  int range_res= 0;
3635
3634
 
3636
3635
  if (!mrr_have_range)
3637
3636
  {
3822
3821
  @retval other  Error
3823
3822
*/
3824
3823
 
3825
 
int DsMrr_impl::dsmrr_fill_buffer(handler *unused __attribute__((__unused__)))
 
3824
int DsMrr_impl::dsmrr_fill_buffer(handler *unused __attribute__((unused)))
3826
3825
{
3827
3826
  char *range_info;
3828
 
  int res;
 
3827
  int res = 0;
3829
3828
 
3830
3829
  rowids_buf_cur= rowids_buf;
3831
3830
  while ((rowids_buf_cur < rowids_buf_end) && 
4277
4276
int handler::read_range_first(const key_range *start_key,
4278
4277
                              const key_range *end_key,
4279
4278
                              bool eq_range_arg,
4280
 
                              bool sorted  __attribute__((__unused__)))
 
4279
                              bool sorted  __attribute__((unused)))
4281
4280
{
4282
4281
  int result;
4283
4282
 
4407
4406
  @retval
4408
4407
    pointer             pointer to TYPELIB structure
4409
4408
*/
4410
 
static bool exts_handlerton(THD *unused __attribute__((__unused__)),
 
4409
static bool exts_handlerton(THD *unused __attribute__((unused)),
4411
4410
                            plugin_ref plugin,
4412
4411
                            void *arg)
4413
4412
{