← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/csv/ha_tina.cc

  • Committer: Monty Taylor
  • Date: 2009-01-06 18:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 762.
  • Revision ID: mordred@inaugust.com-20090106184625-kqu7nsnwjwm5jv4s
Enabled dirty_close.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/csv/ha_tina.cc
40
40
 
41
41
 -Brian
42
42
*/
43
 
#include <drizzled/common_includes.h>
 
43
#include <drizzled/server_includes.h>
44
44
#include <drizzled/field.h>
45
45
#include <drizzled/field/blob.h>
46
46
#include <drizzled/field/timestamp.h>
76
76
pthread_mutex_t tina_mutex;
77
77
static HASH tina_open_tables;
78
78
static handler *tina_create_handler(handlerton *hton,
79
 
                                    TABLE_SHARE *table, 
 
79
                                    TABLE_SHARE *table,
80
80
                                    MEM_ROOT *mem_root);
81
81
 
82
82
 
96
96
  return ( a->begin > b->begin ? 1 : ( a->begin < b->begin ? -1 : 0 ) );
97
97
}
98
98
 
99
 
static unsigned char* tina_get_key(TINA_SHARE *share, size_t *length,
100
 
                          bool not_used __attribute__((unused)))
 
99
static unsigned char* tina_get_key(TINA_SHARE *share, size_t *length, bool)
101
100
{
102
101
  *length=share->table_name_length;
103
102
  return (unsigned char*) share->table_name;
113
112
                   (hash_get_key) tina_get_key,0,0);
114
113
  tina_hton->state= SHOW_OPTION_YES;
115
114
  tina_hton->create= tina_create_handler;
116
 
  tina_hton->flags= (HTON_CAN_RECREATE | HTON_SUPPORT_LOG_TABLES | 
 
115
  tina_hton->flags= (HTON_CAN_RECREATE | HTON_SUPPORT_LOG_TABLES |
117
116
                     HTON_NO_PARTITION);
118
117
  return 0;
119
118
}
120
119
 
121
 
static int tina_done_func(void *p __attribute__((unused)))
 
120
static int tina_done_func(void *)
122
121
{
123
122
  hash_free(&tina_open_tables);
124
123
  pthread_mutex_destroy(&tina_mutex);
130
129
/*
131
130
  Simple lock controls.
132
131
*/
133
 
static TINA_SHARE *get_share(const char *table_name,
134
 
                             Table *table __attribute__((unused)))
 
132
static TINA_SHARE *get_share(const char *table_name, Table *)
135
133
{
136
134
  TINA_SHARE *share;
137
135
  char meta_file_name[FN_REFLEN];
167
165
    share->update_file_opened= false;
168
166
    share->tina_write_opened= false;
169
167
    share->data_file_version= 0;
170
 
    my_stpcpy(share->table_name, table_name);
 
168
    strcpy(share->table_name, table_name);
171
169
    fn_format(share->data_file_name, table_name, "", CSV_EXT,
172
170
              MY_REPLACE_EXT|MY_UNPACK_FILENAME);
173
171
    fn_format(meta_file_name, table_name, "", CSM_EXT,
236
234
  unsigned char meta_buffer[META_BUFFER_SIZE];
237
235
  unsigned char *ptr= meta_buffer;
238
236
 
239
 
  my_seek(meta_file, 0, MY_SEEK_SET, MYF(0));
 
237
  lseek(meta_file, 0, SEEK_SET);
240
238
  if (my_read(meta_file, (unsigned char*)meta_buffer, META_BUFFER_SIZE, 0)
241
239
      != META_BUFFER_SIZE)
242
240
    return(HA_ERR_CRASHED_ON_USAGE);
303
301
  ptr+= 3*sizeof(uint64_t);
304
302
  *ptr= (unsigned char)dirty;
305
303
 
306
 
  my_seek(meta_file, 0, MY_SEEK_SET, MYF(0));
 
304
  lseek(meta_file, 0, SEEK_SET);
307
305
  if (my_write(meta_file, (unsigned char *)meta_buffer, META_BUFFER_SIZE, 0)
308
306
      != META_BUFFER_SIZE)
309
307
    return(-1);
419
417
 
420
418
 
421
419
static handler *tina_create_handler(handlerton *hton,
422
 
                                    TABLE_SHARE *table, 
 
420
                                    TABLE_SHARE *table,
423
421
                                    MEM_ROOT *mem_root)
424
422
{
425
423
  return new (mem_root) ha_tina(hton, table);
447
445
  Encode a buffer into the quoted format.
448
446
*/
449
447
 
450
 
int ha_tina::encode_quote(unsigned char *buf __attribute__((unused)))
 
448
int ha_tina::encode_quote(unsigned char *)
451
449
{
452
450
  char attribute_buffer[1024];
453
451
  String attribute(attribute_buffer, sizeof(attribute_buffer),
460
458
    const char *ptr;
461
459
    const char *end_ptr;
462
460
    const bool was_null= (*field)->is_null();
463
 
    
 
461
 
464
462
    /*
465
463
      assistance for backwards compatibility in production builds.
466
464
      note: this will not work for ENUM columns.
472
470
    }
473
471
 
474
472
    (*field)->val_str(&attribute,&attribute);
475
 
    
 
473
 
476
474
    if (was_null)
477
475
      (*field)->set_null();
478
476
 
483
481
 
484
482
      buffer.append('"');
485
483
 
486
 
      while (ptr < end_ptr) 
 
484
      while (ptr < end_ptr)
487
485
      {
488
486
        if (*ptr == '"')
489
487
        {
548
546
      chain_size += DEFAULT_CHAIN_LENGTH;
549
547
      if (chain_alloced)
550
548
      {
551
 
        /* Must cast since my_malloc unlike malloc doesn't have a void ptr */
552
 
        if ((chain= (tina_set *) my_realloc((unsigned char*)chain,
553
 
                                            chain_size, MYF(MY_WME))) == NULL)
 
549
        if ((chain= (tina_set *) realloc(chain, chain_size)) == NULL)
554
550
          return -1;
555
551
      }
556
552
      else
557
553
      {
558
 
        tina_set *ptr= (tina_set *) my_malloc(chain_size * sizeof(tina_set),
559
 
                                              MYF(MY_WME));
 
554
        tina_set *ptr= (tina_set *) malloc(chain_size * sizeof(tina_set));
 
555
        if (ptr == NULL)
 
556
          return -1;
560
557
        memcpy(ptr, chain, DEFAULT_CHAIN_LENGTH * sizeof(tina_set));
561
558
        chain= ptr;
562
559
        chain_alloced++;
681
678
        if (src)
682
679
        {
683
680
          tgt= (unsigned char*) alloc_root(&blobroot, length);
684
 
          memcpy(tgt, src, length);
 
681
          memmove(tgt, src, length);
685
682
          memcpy(blob->ptr + packlength, &tgt, sizeof(char*));
686
683
        }
687
684
      }
715
712
  for CSV engine. For more details see mysys/thr_lock.c
716
713
*/
717
714
 
718
 
void tina_get_status(void* param,
719
 
                     int concurrent_insert __attribute__((unused)))
 
715
void tina_get_status(void* param, int)
720
716
{
721
717
  ha_tina *tina= (ha_tina*) param;
722
718
  tina->get_status();
729
725
}
730
726
 
731
727
/* this should exist and return 0 for concurrent insert to work */
732
 
bool tina_check_status(void* param __attribute__((unused)))
 
728
bool tina_check_status(void *)
733
729
{
734
730
  return 0;
735
731
}
769
765
    For log tables concurrent insert works different. The reason is that
770
766
    log tables are always opened and locked. And as they do not unlock
771
767
    tables, the file length after writes should be updated in a different
772
 
    way. 
 
768
    way.
773
769
*/
774
770
 
775
771
void ha_tina::update_status()
784
780
  this will not be called for every request. Any sort of positions
785
781
  that need to be reset should be kept in the ::extra() call.
786
782
*/
787
 
int ha_tina::open(const char *name, int mode __attribute__((unused)),
788
 
                  uint32_t open_options)
 
783
int ha_tina::open(const char *name, int, uint32_t open_options)
789
784
{
790
785
  if (!(share= get_share(name, table)))
791
786
    return(HA_ERR_OUT_OF_MEM);
895
890
  This will be called in a table scan right before the previous ::rnd_next()
896
891
  call.
897
892
*/
898
 
int ha_tina::update_row(const unsigned char * old_data __attribute__((unused)),
899
 
                        unsigned char * new_data)
 
893
int ha_tina::update_row(const unsigned char *, unsigned char * new_data)
900
894
{
901
895
  int size;
902
896
  int rc= -1;
909
903
  size= encode_quote(new_data);
910
904
 
911
905
  /*
912
 
    During update we mark each updating record as deleted 
913
 
    (see the chain_append()) then write new one to the temporary data file. 
 
906
    During update we mark each updating record as deleted
 
907
    (see the chain_append()) then write new one to the temporary data file.
914
908
    At the end of the sequence in the rnd_end() we append all non-marked
915
909
    records from the data file to the temporary data file then rename it.
916
910
    The temp_file_length is used to calculate new data file length.
941
935
  The table will then be deleted/positioned based on the ORDER (so RANDOM,
942
936
  DESC, ASC).
943
937
*/
944
 
int ha_tina::delete_row(const unsigned char * buf __attribute__((unused)))
 
938
int ha_tina::delete_row(const unsigned char *)
945
939
{
946
940
  ha_statistic_increment(&SSV::ha_delete_count);
947
941
 
961
955
 
962
956
/**
963
957
  @brief Initialize the data file.
964
 
  
 
958
 
965
959
  @details Compare the local version of the data file with the shared one.
966
960
  If they differ, there are some changes behind and we have to reopen
967
961
  the data file to make the changes visible.
968
 
  Call @c file_buff->init_buff() at the end to read the beginning of the 
 
962
  Call @c file_buff->init_buff() at the end to read the beginning of the
969
963
  data file into buffer.
970
 
  
 
964
 
971
965
  @retval  0  OK.
972
966
  @retval  1  There was an error.
973
967
*/
1017
1011
 
1018
1012
*/
1019
1013
 
1020
 
int ha_tina::rnd_init(bool scan __attribute__((unused)))
 
1014
int ha_tina::rnd_init(bool)
1021
1015
{
1022
1016
  /* set buffer to the beginning of the file */
1023
1017
  if (share->crashed || init_data_file())
1078
1072
  its just a position. Look at the bdb code if you want to see a case
1079
1073
  where something other then a number is stored.
1080
1074
*/
1081
 
void ha_tina::position(const unsigned char *record __attribute__((unused)))
 
1075
void ha_tina::position(const unsigned char *)
1082
1076
{
1083
1077
  my_store_ptr(ref, ref_length, current_position);
1084
1078
  return;
1102
1096
  Currently this table handler doesn't implement most of the fields
1103
1097
  really needed. SHOW also makes use of this data
1104
1098
*/
1105
 
int ha_tina::info(uint32_t flag __attribute__((unused)))
 
1099
int ha_tina::info(uint32_t)
1106
1100
{
1107
1101
  /* This is a lie, but you don't want the optimizer to see zero or 1 */
1108
 
  if (!records_is_known && stats.records < 2) 
 
1102
  if (!records_is_known && stats.records < 2)
1109
1103
    stats.records= 2;
1110
1104
  return(0);
1111
1105
}
1172
1166
      /* if there is something to write, write it */
1173
1167
      if (write_length)
1174
1168
      {
1175
 
        if (my_write(update_temp_file, 
 
1169
        if (my_write(update_temp_file,
1176
1170
                     (unsigned char*) (file_buff->ptr() +
1177
1171
                               (write_begin - file_buff->start())),
1178
1172
                     write_length, MYF_RW))
1226
1220
    if (((data_file= my_open(share->data_file_name, O_RDONLY, MYF(0))) == -1))
1227
1221
      return(-1);
1228
1222
    /*
1229
 
      As we reopened the data file, increase share->data_file_version 
1230
 
      in order to force other threads waiting on a table lock and  
 
1223
      As we reopened the data file, increase share->data_file_version
 
1224
      in order to force other threads waiting on a table lock and
1231
1225
      have already opened the table to reopen the data file.
1232
1226
      That makes the latest changes become visible to them.
1233
 
      Update local_data_file_version as no need to reopen it in the 
 
1227
      Update local_data_file_version as no need to reopen it in the
1234
1228
      current thread.
1235
1229
    */
1236
1230
    share->data_file_version++;
1241
1235
      Here we record this fact to the meta-file.
1242
1236
    */
1243
1237
    (void)write_meta_file(share->meta_file, share->rows_recorded, false);
1244
 
    /* 
1245
 
      Update local_saved_data_file_length with the real length of the 
 
1238
    /*
 
1239
      Update local_saved_data_file_length with the real length of the
1246
1240
      data file.
1247
1241
    */
1248
1242
    local_saved_data_file_length= temp_file_length;
1274
1268
         rows (after the first bad one) as well.
1275
1269
*/
1276
1270
 
1277
 
int ha_tina::repair(Session* session,
1278
 
                    HA_CHECK_OPT* check_opt __attribute__((unused)))
 
1271
int ha_tina::repair(Session* session, HA_CHECK_OPT *)
1279
1272
{
1280
1273
  char repaired_fname[FN_REFLEN];
1281
1274
  unsigned char *buf;
1293
1286
 
1294
1287
  /* Don't assert in field::val() functions */
1295
1288
  table->use_all_columns();
1296
 
  if (!(buf= (unsigned char*) my_malloc(table->s->reclength, MYF(MY_WME))))
 
1289
  if (!(buf= (unsigned char*) malloc(table->s->reclength)))
1297
1290
    return(HA_ERR_OUT_OF_MEM);
1298
1291
 
1299
1292
  /* position buffer to the start of the file */
1420
1413
  Called by the database to lock the table. Keep in mind that this
1421
1414
  is an internal lock.
1422
1415
*/
1423
 
THR_LOCK_DATA **ha_tina::store_lock(Session *session __attribute__((unused)),
 
1416
THR_LOCK_DATA **ha_tina::store_lock(Session *,
1424
1417
                                    THR_LOCK_DATA **to,
1425
1418
                                    enum thr_lock_type lock_type)
1426
1419
{
1430
1423
  return to;
1431
1424
}
1432
1425
 
1433
 
/* 
 
1426
/*
1434
1427
  Create a table. You do not want to leave the table open after a call to
1435
1428
  this (the database will call ::open() if it needs to).
1436
1429
*/
1437
1430
 
1438
 
int ha_tina::create(const char *name, Table *table_arg,
1439
 
                    HA_CREATE_INFO *create_info __attribute__((unused)))
 
1431
int ha_tina::create(const char *name, Table *table_arg, HA_CREATE_INFO *)
1440
1432
{
1441
1433
  char name_buff[FN_REFLEN];
1442
1434
  File create_file;
1452
1444
      return(HA_ERR_UNSUPPORTED);
1453
1445
    }
1454
1446
  }
1455
 
  
 
1447
 
1456
1448
 
1457
1449
  if ((create_file= my_create(fn_format(name_buff, name, "", CSM_EXT,
1458
1450
                                        MY_REPLACE_EXT|MY_UNPACK_FILENAME), 0,
1472
1464
  return(0);
1473
1465
}
1474
1466
 
1475
 
int ha_tina::check(Session* session,
1476
 
                   HA_CHECK_OPT* check_opt __attribute__((unused)))
 
1467
int ha_tina::check(Session* session, HA_CHECK_OPT *)
1477
1468
{
1478
1469
  int rc= 0;
1479
1470
  unsigned char *buf;
1482
1473
 
1483
1474
  old_proc_info= get_session_proc_info(session);
1484
1475
  set_session_proc_info(session, "Checking table");
1485
 
  if (!(buf= (unsigned char*) my_malloc(table->s->reclength, MYF(MY_WME))))
 
1476
  if (!(buf= (unsigned char*) malloc(table->s->reclength)))
1486
1477
    return(HA_ERR_OUT_OF_MEM);
1487
1478
 
1488
1479
  /* position buffer to the start of the file */
1507
1498
    count--;
1508
1499
    current_position= next_position;
1509
1500
  }
1510
 
  
 
1501
 
1511
1502
  free_root(&blobroot, MYF(0));
1512
1503
 
1513
1504
  free((char*)buf);
1523
1514
}
1524
1515
 
1525
1516
 
1526
 
bool ha_tina::check_if_incompatible_data(HA_CREATE_INFO *info __attribute__((unused)),
1527
 
                                         uint32_t table_changes __attribute__((unused)))
 
1517
bool ha_tina::check_if_incompatible_data(HA_CREATE_INFO *, uint32_t)
1528
1518
{
1529
1519
  return COMPATIBLE_DATA_YES;
1530
1520
}