← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/blackhole/ha_blackhole.cc

  • Committer: Jay Pipes
  • Date: 2008-07-17 18:48:58 UTC
  • mto: This revision was merged to the branch mainline in revision 182.
  • Revision ID: jay@mysql.com-20080717184858-2mbouxl8xi41gcge
Removed DBUG from CSV and Blackhole storage engines

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/blackhole/ha_blackhole.cc
61
61
int ha_blackhole::open(const char *name, int mode __attribute__((__unused__)),
62
62
                       uint test_if_locked __attribute__((__unused__)))
63
63
{
64
 
  DBUG_ENTER("ha_blackhole::open");
65
 
 
66
64
  if (!(share= get_share(name)))
67
 
    DBUG_RETURN(HA_ERR_OUT_OF_MEM);
 
65
    return(HA_ERR_OUT_OF_MEM);
68
66
 
69
67
  thr_lock_data_init(&share->lock, &lock, NULL);
70
 
  DBUG_RETURN(0);
 
68
  return(0);
71
69
}
72
70
 
73
71
int ha_blackhole::close(void)
74
72
{
75
 
  DBUG_ENTER("ha_blackhole::close");
76
73
  free_share(share);
77
 
  DBUG_RETURN(0);
 
74
  return(0);
78
75
}
79
76
 
80
77
int ha_blackhole::create(const char *name __attribute__((__unused__)),
81
78
                         TABLE *table_arg __attribute__((__unused__)),
82
79
                         HA_CREATE_INFO *create_info __attribute__((__unused__)))
83
80
{
84
 
  DBUG_ENTER("ha_blackhole::create");
85
 
  DBUG_RETURN(0);
 
81
  return(0);
86
82
}
87
83
 
88
84
const char *ha_blackhole::index_type(uint key_number)
89
85
{
90
 
  DBUG_ENTER("ha_blackhole::index_type");
91
 
  DBUG_RETURN((table_share->key_info[key_number].flags & HA_FULLTEXT) ? 
 
86
  return((table_share->key_info[key_number].flags & HA_FULLTEXT) ? 
92
87
              "FULLTEXT" :
93
88
              (table_share->key_info[key_number].flags & HA_SPATIAL) ?
94
89
              "SPATIAL" :
98
93
 
99
94
int ha_blackhole::write_row(uchar * buf __attribute__((__unused__)))
100
95
{
101
 
  DBUG_ENTER("ha_blackhole::write_row");
102
 
  DBUG_RETURN(table->next_number_field ? update_auto_increment() : 0);
 
96
  return(table->next_number_field ? update_auto_increment() : 0);
103
97
}
104
98
 
105
99
int ha_blackhole::rnd_init(bool scan __attribute__((__unused__)))
106
100
{
107
 
  DBUG_ENTER("ha_blackhole::rnd_init");
108
 
  DBUG_RETURN(0);
 
101
  return(0);
109
102
}
110
103
 
111
104
 
112
105
int ha_blackhole::rnd_next(uchar *buf __attribute__((__unused__)))
113
106
{
114
 
  DBUG_ENTER("ha_blackhole::rnd_next");
115
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
107
  return(HA_ERR_END_OF_FILE);
116
108
}
117
109
 
118
110
 
119
111
int ha_blackhole::rnd_pos(uchar * buf __attribute__((__unused__)),
120
112
                          uchar *pos __attribute__((__unused__)))
121
113
{
122
 
  DBUG_ENTER("ha_blackhole::rnd_pos");
123
 
  DBUG_ASSERT(0);
124
 
  DBUG_RETURN(0);
 
114
  assert(0);
 
115
  return(0);
125
116
}
126
117
 
127
118
 
128
119
void ha_blackhole::position(const uchar *record __attribute__((__unused__)))
129
120
{
130
 
  DBUG_ENTER("ha_blackhole::position");
131
 
  DBUG_ASSERT(0);
132
 
  DBUG_VOID_RETURN;
 
121
  assert(0);
 
122
  return;
133
123
}
134
124
 
135
125
 
136
126
int ha_blackhole::info(uint flag)
137
127
{
138
 
  DBUG_ENTER("ha_blackhole::info");
139
 
 
140
128
  bzero((char*) &stats, sizeof(stats));
141
129
  if (flag & HA_STATUS_AUTO)
142
130
    stats.auto_increment_value= 1;
143
 
  DBUG_RETURN(0);
 
131
  return(0);
144
132
}
145
133
 
146
134
int ha_blackhole::external_lock(THD *thd __attribute__((__unused__)),
147
135
                                int lock_type __attribute__((__unused__)))
148
136
{
149
 
  DBUG_ENTER("ha_blackhole::external_lock");
150
 
  DBUG_RETURN(0);
 
137
  return(0);
151
138
}
152
139
 
153
140
 
155
142
                                         THR_LOCK_DATA **to,
156
143
                                         enum thr_lock_type lock_type)
157
144
{
158
 
  DBUG_ENTER("ha_blackhole::store_lock");
159
145
  if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
160
146
  {
161
147
    /*
184
170
    lock.type= lock_type;
185
171
  }
186
172
  *to++= &lock;
187
 
  DBUG_RETURN(to);
 
173
  return(to);
188
174
}
189
175
 
190
176
 
193
179
                                 key_part_map keypart_map  __attribute__((__unused__)),
194
180
                                 enum ha_rkey_function find_flag __attribute__((__unused__)))
195
181
{
196
 
  DBUG_ENTER("ha_blackhole::index_read");
197
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
182
  return(HA_ERR_END_OF_FILE);
198
183
}
199
184
 
200
185
 
204
189
                                     key_part_map keypart_map __attribute__((__unused__)),
205
190
                                     enum ha_rkey_function find_flag __attribute__((__unused__)))
206
191
{
207
 
  DBUG_ENTER("ha_blackhole::index_read_idx");
208
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
192
  return(HA_ERR_END_OF_FILE);
209
193
}
210
194
 
211
195
 
213
197
                                      const uchar * key __attribute__((__unused__)),
214
198
                                      key_part_map keypart_map __attribute__((__unused__)))
215
199
{
216
 
  DBUG_ENTER("ha_blackhole::index_read_last");
217
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
200
  return(HA_ERR_END_OF_FILE);
218
201
}
219
202
 
220
203
 
221
204
int ha_blackhole::index_next(uchar * buf __attribute__((__unused__)))
222
205
{
223
 
  DBUG_ENTER("ha_blackhole::index_next");
224
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
206
  return(HA_ERR_END_OF_FILE);
225
207
}
226
208
 
227
209
 
228
210
int ha_blackhole::index_prev(uchar * buf __attribute__((__unused__)))
229
211
{
230
 
  DBUG_ENTER("ha_blackhole::index_prev");
231
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
212
  return(HA_ERR_END_OF_FILE);
232
213
}
233
214
 
234
215
 
235
216
int ha_blackhole::index_first(uchar * buf __attribute__((__unused__)))
236
217
{
237
 
  DBUG_ENTER("ha_blackhole::index_first");
238
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
218
  return(HA_ERR_END_OF_FILE);
239
219
}
240
220
 
241
221
 
242
222
int ha_blackhole::index_last(uchar * buf __attribute__((__unused__)))
243
223
{
244
 
  DBUG_ENTER("ha_blackhole::index_last");
245
 
  DBUG_RETURN(HA_ERR_END_OF_FILE);
 
224
  return(HA_ERR_END_OF_FILE);
246
225
}
247
226
 
248
227