← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/csv/ha_tina.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/csv/ha_tina.cc
45
45
#pragma implementation        // gcc: Class implementation
46
46
#endif
47
47
 
48
 
#include "mysql_priv.h"
49
 
#include <mysql/plugin.h>
 
48
#include <drizzled/mysql_priv.h>
50
49
#include "ha_tina.h"
51
50
 
52
51
 
120
119
  return 0;
121
120
}
122
121
 
123
 
static int tina_done_func(void *p __attribute__((__unused__)))
 
122
static int tina_done_func(void *p __attribute__((unused)))
124
123
{
125
124
  hash_free(&tina_open_tables);
126
125
  pthread_mutex_destroy(&tina_mutex);
133
132
  Simple lock controls.
134
133
*/
135
134
static TINA_SHARE *get_share(const char *table_name,
136
 
                             TABLE *table __attribute__((__unused__)))
 
135
                             TABLE *table __attribute__((unused)))
137
136
{
138
137
  TINA_SHARE *share;
139
138
  char meta_file_name[FN_REFLEN];
450
449
  Encode a buffer into the quoted format.
451
450
*/
452
451
 
453
 
int ha_tina::encode_quote(uchar *buf __attribute__((__unused__)))
 
452
int ha_tina::encode_quote(uchar *buf __attribute__((unused)))
454
453
{
455
454
  char attribute_buffer[1024];
456
455
  String attribute(attribute_buffer, sizeof(attribute_buffer),
685
684
        
686
685
        packlength= blob->pack_length_no_ptr();
687
686
        length= blob->get_length(blob->ptr);
688
 
        memcpy_fixed(&src, blob->ptr + packlength, sizeof(char*));
 
687
        memcpy(&src, blob->ptr + packlength, sizeof(char*));
689
688
        if (src)
690
689
        {
691
690
          tgt= (uchar*) alloc_root(&blobroot, length);
692
 
          bmove(tgt, src, length);
693
 
          memcpy_fixed(blob->ptr + packlength, &tgt, sizeof(char*));
 
691
          memcpy(tgt, src, length);
 
692
          memcpy(blob->ptr + packlength, &tgt, sizeof(char*));
694
693
        }
695
694
      }
696
695
    }
725
724
*/
726
725
 
727
726
void tina_get_status(void* param,
728
 
                     int concurrent_insert __attribute__((__unused__)))
 
727
                     int concurrent_insert __attribute__((unused)))
729
728
{
730
729
  ha_tina *tina= (ha_tina*) param;
731
730
  tina->get_status();
738
737
}
739
738
 
740
739
/* this should exist and return 0 for concurrent insert to work */
741
 
bool tina_check_status(void* param __attribute__((__unused__)))
 
740
bool tina_check_status(void* param __attribute__((unused)))
742
741
{
743
742
  return 0;
744
743
}
805
804
  this will not be called for every request. Any sort of positions
806
805
  that need to be reset should be kept in the ::extra() call.
807
806
*/
808
 
int ha_tina::open(const char *name, int mode __attribute__((__unused__)),
 
807
int ha_tina::open(const char *name, int mode __attribute__((unused)),
809
808
                  uint open_options)
810
809
{
811
810
  if (!(share= get_share(name, table)))
918
917
  This will be called in a table scan right before the previous ::rnd_next()
919
918
  call.
920
919
*/
921
 
int ha_tina::update_row(const uchar * old_data __attribute__((__unused__)),
 
920
int ha_tina::update_row(const uchar * old_data __attribute__((unused)),
922
921
                        uchar * new_data)
923
922
{
924
923
  int size;
967
966
  The table will then be deleted/positioned based on the ORDER (so RANDOM,
968
967
  DESC, ASC).
969
968
*/
970
 
int ha_tina::delete_row(const uchar * buf __attribute__((__unused__)))
 
969
int ha_tina::delete_row(const uchar * buf __attribute__((unused)))
971
970
{
972
971
  ha_statistic_increment(&SSV::ha_delete_count);
973
972
 
1046
1045
 
1047
1046
*/
1048
1047
 
1049
 
int ha_tina::rnd_init(bool scan __attribute__((__unused__)))
 
1048
int ha_tina::rnd_init(bool scan __attribute__((unused)))
1050
1049
{
1051
1050
  /* set buffer to the beginning of the file */
1052
1051
  if (share->crashed || init_data_file())
1107
1106
  its just a position. Look at the bdb code if you want to see a case
1108
1107
  where something other then a number is stored.
1109
1108
*/
1110
 
void ha_tina::position(const uchar *record __attribute__((__unused__)))
 
1109
void ha_tina::position(const uchar *record __attribute__((unused)))
1111
1110
{
1112
1111
  my_store_ptr(ref, ref_length, current_position);
1113
1112
  return;
1131
1130
  Currently this table handler doesn't implement most of the fields
1132
1131
  really needed. SHOW also makes use of this data
1133
1132
*/
1134
 
int ha_tina::info(uint flag __attribute__((__unused__)))
 
1133
int ha_tina::info(uint flag __attribute__((unused)))
1135
1134
{
1136
1135
  /* This is a lie, but you don't want the optimizer to see zero or 1 */
1137
1136
  if (!records_is_known && stats.records < 2) 
1304
1303
*/
1305
1304
 
1306
1305
int ha_tina::repair(THD* thd,
1307
 
                    HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
1306
                    HA_CHECK_OPT* check_opt __attribute__((unused)))
1308
1307
{
1309
1308
  char repaired_fname[FN_REFLEN];
1310
1309
  uchar *buf;
1449
1448
  Called by the database to lock the table. Keep in mind that this
1450
1449
  is an internal lock.
1451
1450
*/
1452
 
THR_LOCK_DATA **ha_tina::store_lock(THD *thd __attribute__((__unused__)),
 
1451
THR_LOCK_DATA **ha_tina::store_lock(THD *thd __attribute__((unused)),
1453
1452
                                    THR_LOCK_DATA **to,
1454
1453
                                    enum thr_lock_type lock_type)
1455
1454
{
1465
1464
*/
1466
1465
 
1467
1466
int ha_tina::create(const char *name, TABLE *table_arg,
1468
 
                    HA_CREATE_INFO *create_info __attribute__((__unused__)))
 
1467
                    HA_CREATE_INFO *create_info __attribute__((unused)))
1469
1468
{
1470
1469
  char name_buff[FN_REFLEN];
1471
1470
  File create_file;
1502
1501
}
1503
1502
 
1504
1503
int ha_tina::check(THD* thd,
1505
 
                   HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
1504
                   HA_CHECK_OPT* check_opt __attribute__((unused)))
1506
1505
{
1507
1506
  int rc= 0;
1508
1507
  uchar *buf;
1551
1550
}
1552
1551
 
1553
1552
 
1554
 
bool ha_tina::check_if_incompatible_data(HA_CREATE_INFO *info __attribute__((__unused__)),
1555
 
                                         uint table_changes __attribute__((__unused__)))
 
1553
bool ha_tina::check_if_incompatible_data(HA_CREATE_INFO *info __attribute__((unused)),
 
1554
                                         uint table_changes __attribute__((unused)))
1556
1555
{
1557
1556
  return COMPATIBLE_DATA_YES;
1558
1557
}