← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/archive/ha_archive.cc

  • Committer: Brian Aker
  • Date: 2008-07-06 07:56:50 UTC
  • mfrom: (53.2.38 codestyle)
  • Revision ID: brian@tangent.org-20080706075650-17hslbw06ggz9zb0
Resolved merge from Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/archive/ha_archive.cc
201
201
    FALSE       OK
202
202
*/
203
203
 
204
 
int archive_db_done(void *p)
 
204
int archive_db_done(void *p __attribute__((__unused__)))
205
205
{
206
206
  hash_free(&archive_open_tables);
207
207
  VOID(pthread_mutex_destroy(&archive_mutex));
221
221
  archive_reader_open= FALSE;
222
222
}
223
223
 
224
 
int archive_discover(handlerton *hton, THD* thd, const char *db, 
 
224
int archive_discover(handlerton *hton __attribute__((__unused__)),
 
225
                     THD* thd __attribute__((__unused__)),
 
226
                     const char *db,
225
227
                     const char *name,
226
 
                     uchar **frmblob, 
 
228
                     uchar **frmblob,
227
229
                     size_t *frmlen)
228
230
{
229
231
  DBUG_ENTER("archive_discover");
484
486
  Init out lock.
485
487
  We open the file we will read from.
486
488
*/
487
 
int ha_archive::open(const char *name, int mode, uint open_options)
 
489
int ha_archive::open(const char *name,
 
490
                     int mode __attribute__((__unused__)),
 
491
                     uint open_options)
488
492
{
489
493
  int rc= 0;
490
494
  DBUG_ENTER("ha_archive::open");
731
735
  the bytes required for the length in the header.
732
736
*/
733
737
 
734
 
uint32 ha_archive::max_row_length(const uchar *buf)
 
738
uint32 ha_archive::max_row_length(const uchar *buf __attribute__((__unused__)))
735
739
{
736
740
  uint32 length= (uint32)(table->s->reclength + table->s->fields*2);
737
741
  length+= ARCHIVE_ROW_HEADER_SIZE;
890
894
}
891
895
 
892
896
 
893
 
void ha_archive::get_auto_increment(uint64_t offset, uint64_t increment,
894
 
                                    uint64_t nb_desired_values,
895
 
                                    uint64_t *first_value,
896
 
                                    uint64_t *nb_reserved_values)
 
897
void ha_archive::get_auto_increment(uint64_t offset __attribute__((__unused__)),
 
898
                                    uint64_t increment __attribute__((__unused__)),
 
899
                                    uint64_t nb_desired_values __attribute__((__unused__)),
 
900
                                    uint64_t *first_value __attribute__((__unused__)),
 
901
                                    uint64_t *nb_reserved_values __attribute__((__unused__)))
897
902
{
898
903
  *nb_reserved_values= ULONGLONG_MAX;
899
904
  *first_value= share->archive_write.auto_increment + 1;
900
905
}
901
906
 
902
907
/* Initialized at each key walk (called multiple times unlike rnd_init()) */
903
 
int ha_archive::index_init(uint keynr, bool sorted)
 
908
int ha_archive::index_init(uint keynr, bool sorted __attribute__((__unused__)))
904
909
{
905
910
  DBUG_ENTER("ha_archive::index_init");
906
911
  active_index= keynr;
923
928
 
924
929
 
925
930
int ha_archive::index_read_idx(uchar *buf, uint index, const uchar *key,
926
 
                                 uint key_len, enum ha_rkey_function find_flag)
 
931
                               uint key_len,
 
932
                               enum ha_rkey_function find_flag __attribute__((__unused__)))
927
933
{
928
934
  int rc;
929
935
  bool found= 0;
1122
1128
  needed.
1123
1129
*/
1124
1130
 
1125
 
void ha_archive::position(const uchar *record)
 
1131
void ha_archive::position(const uchar *record __attribute__((__unused__)))
1126
1132
{
1127
1133
  DBUG_ENTER("ha_archive::position");
1128
1134
  my_store_ptr(ref, ref_length, current_position);
1169
1175
  The table can become fragmented if data was inserted, read, and then
1170
1176
  inserted again. What we do is open up the file and recompress it completely. 
1171
1177
*/
1172
 
int ha_archive::optimize(THD* thd, HA_CHECK_OPT* check_opt)
 
1178
int ha_archive::optimize(THD* thd __attribute__((__unused__)),
 
1179
                         HA_CHECK_OPT* check_opt __attribute__((__unused__)))
1173
1180
{
1174
1181
  DBUG_ENTER("ha_archive::optimize");
1175
1182
  int rc= 0;
1460
1467
  Simple scan of the tables to make sure everything is ok.
1461
1468
*/
1462
1469
 
1463
 
int ha_archive::check(THD* thd, HA_CHECK_OPT* check_opt)
 
1470
int ha_archive::check(THD* thd,
 
1471
                      HA_CHECK_OPT* check_opt __attribute__((__unused__)))
1464
1472
{
1465
1473
  int rc= 0;
1466
1474
  const char *old_proc_info;