← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/blackhole/ha_blackhole.cc

Blackhole is clean.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/blackhole/ha_blackhole.cc
58
58
  return ha_blackhole_exts;
59
59
}
60
60
 
61
 
int ha_blackhole::open(const char *name, int mode, uint test_if_locked)
 
61
int ha_blackhole::open(const char *name, int mode __attribute__((__unused__)),
 
62
                       uint test_if_locked __attribute__((__unused__)))
62
63
{
63
64
  DBUG_ENTER("ha_blackhole::open");
64
65
 
76
77
  DBUG_RETURN(0);
77
78
}
78
79
 
79
 
int ha_blackhole::create(const char *name, TABLE *table_arg,
80
 
                         HA_CREATE_INFO *create_info)
 
80
int ha_blackhole::create(const char *name __attribute__((__unused__)),
 
81
                         TABLE *table_arg __attribute__((__unused__)),
 
82
                         HA_CREATE_INFO *create_info __attribute__((__unused__)))
81
83
{
82
84
  DBUG_ENTER("ha_blackhole::create");
83
85
  DBUG_RETURN(0);
94
96
               HA_KEY_ALG_RTREE) ? "RTREE" : "BTREE");
95
97
}
96
98
 
97
 
int ha_blackhole::write_row(uchar * buf)
 
99
int ha_blackhole::write_row(uchar * buf __attribute__((__unused__)))
98
100
{
99
101
  DBUG_ENTER("ha_blackhole::write_row");
100
102
  DBUG_RETURN(table->next_number_field ? update_auto_increment() : 0);
101
103
}
102
104
 
103
 
int ha_blackhole::rnd_init(bool scan)
 
105
int ha_blackhole::rnd_init(bool scan __attribute__((__unused__)))
104
106
{
105
107
  DBUG_ENTER("ha_blackhole::rnd_init");
106
108
  DBUG_RETURN(0);
107
109
}
108
110
 
109
111
 
110
 
int ha_blackhole::rnd_next(uchar *buf)
 
112
int ha_blackhole::rnd_next(uchar *buf __attribute__((__unused__)))
111
113
{
112
114
  DBUG_ENTER("ha_blackhole::rnd_next");
113
115
  DBUG_RETURN(HA_ERR_END_OF_FILE);
114
116
}
115
117
 
116
118
 
117
 
int ha_blackhole::rnd_pos(uchar * buf, uchar *pos)
 
119
int ha_blackhole::rnd_pos(uchar * buf __attribute__((__unused__)),
 
120
                          uchar *pos __attribute__((__unused__)))
118
121
{
119
122
  DBUG_ENTER("ha_blackhole::rnd_pos");
120
123
  DBUG_ASSERT(0);
122
125
}
123
126
 
124
127
 
125
 
void ha_blackhole::position(const uchar *record)
 
128
void ha_blackhole::position(const uchar *record __attribute__((__unused__)))
126
129
{
127
130
  DBUG_ENTER("ha_blackhole::position");
128
131
  DBUG_ASSERT(0);
140
143
  DBUG_RETURN(0);
141
144
}
142
145
 
143
 
int ha_blackhole::external_lock(THD *thd, int lock_type)
 
146
int ha_blackhole::external_lock(THD *thd __attribute__((__unused__)),
 
147
                                int lock_type __attribute__((__unused__)))
144
148
{
145
149
  DBUG_ENTER("ha_blackhole::external_lock");
146
150
  DBUG_RETURN(0);
184
188
}
185
189
 
186
190
 
187
 
int ha_blackhole::index_read_map(uchar * buf, const uchar * key,
188
 
                                 key_part_map keypart_map,
189
 
                             enum ha_rkey_function find_flag)
 
191
int ha_blackhole::index_read_map(uchar * buf __attribute__((__unused__)),
 
192
                                 const uchar * key __attribute__((__unused__)),
 
193
                                 key_part_map keypart_map  __attribute__((__unused__)),
 
194
                                 enum ha_rkey_function find_flag __attribute__((__unused__)))
190
195
{
191
196
  DBUG_ENTER("ha_blackhole::index_read");
192
197
  DBUG_RETURN(HA_ERR_END_OF_FILE);
193
198
}
194
199
 
195
200
 
196
 
int ha_blackhole::index_read_idx_map(uchar * buf, uint idx, const uchar * key,
197
 
                                 key_part_map keypart_map,
198
 
                                 enum ha_rkey_function find_flag)
 
201
int ha_blackhole::index_read_idx_map(uchar * buf __attribute__((__unused__)),
 
202
                                     uint idx __attribute__((__unused__)),
 
203
                                     const uchar * key __attribute__((__unused__)),
 
204
                                     key_part_map keypart_map __attribute__((__unused__)),
 
205
                                     enum ha_rkey_function find_flag __attribute__((__unused__)))
199
206
{
200
207
  DBUG_ENTER("ha_blackhole::index_read_idx");
201
208
  DBUG_RETURN(HA_ERR_END_OF_FILE);
202
209
}
203
210
 
204
211
 
205
 
int ha_blackhole::index_read_last_map(uchar * buf, const uchar * key,
206
 
                                      key_part_map keypart_map)
 
212
int ha_blackhole::index_read_last_map(uchar * buf __attribute__((__unused__)),
 
213
                                      const uchar * key __attribute__((__unused__)),
 
214
                                      key_part_map keypart_map __attribute__((__unused__)))
207
215
{
208
216
  DBUG_ENTER("ha_blackhole::index_read_last");
209
217
  DBUG_RETURN(HA_ERR_END_OF_FILE);
210
218
}
211
219
 
212
220
 
213
 
int ha_blackhole::index_next(uchar * buf)
 
221
int ha_blackhole::index_next(uchar * buf __attribute__((__unused__)))
214
222
{
215
223
  DBUG_ENTER("ha_blackhole::index_next");
216
224
  DBUG_RETURN(HA_ERR_END_OF_FILE);
217
225
}
218
226
 
219
227
 
220
 
int ha_blackhole::index_prev(uchar * buf)
 
228
int ha_blackhole::index_prev(uchar * buf __attribute__((__unused__)))
221
229
{
222
230
  DBUG_ENTER("ha_blackhole::index_prev");
223
231
  DBUG_RETURN(HA_ERR_END_OF_FILE);
224
232
}
225
233
 
226
234
 
227
 
int ha_blackhole::index_first(uchar * buf)
 
235
int ha_blackhole::index_first(uchar * buf __attribute__((__unused__)))
228
236
{
229
237
  DBUG_ENTER("ha_blackhole::index_first");
230
238
  DBUG_RETURN(HA_ERR_END_OF_FILE);
231
239
}
232
240
 
233
241
 
234
 
int ha_blackhole::index_last(uchar * buf)
 
242
int ha_blackhole::index_last(uchar * buf __attribute__((__unused__)))
235
243
{
236
244
  DBUG_ENTER("ha_blackhole::index_last");
237
245
  DBUG_RETURN(HA_ERR_END_OF_FILE);
311
319
  return 0;
312
320
}
313
321
 
314
 
static int blackhole_fini(void *p)
 
322
static int blackhole_fini(void *p __attribute__((__unused__)))
315
323
{
316
324
  hash_free(&blackhole_open_tables);
317
325
  pthread_mutex_destroy(&blackhole_mutex);