← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/heap/ha_heap.cc

  • Committer: Brian Aker
  • Date: 2008-10-06 05:57:49 UTC
  • Revision ID: brian@tangent.org-20081006055749-svg700gciuqi0zu1
Remove all of uchar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/heap/ha_heap.cc
202
202
}
203
203
 
204
204
 
205
 
int ha_heap::write_row(uchar * buf)
 
205
int ha_heap::write_row(unsigned char * buf)
206
206
{
207
207
  int res;
208
208
  ha_statistic_increment(&SSV::ha_write_count);
226
226
  return res;
227
227
}
228
228
 
229
 
int ha_heap::update_row(const uchar * old_data, uchar * new_data)
 
229
int ha_heap::update_row(const unsigned char * old_data, unsigned char * new_data)
230
230
{
231
231
  int res;
232
232
  ha_statistic_increment(&SSV::ha_update_count);
245
245
  return res;
246
246
}
247
247
 
248
 
int ha_heap::delete_row(const uchar * buf)
 
248
int ha_heap::delete_row(const unsigned char * buf)
249
249
{
250
250
  int res;
251
251
  ha_statistic_increment(&SSV::ha_delete_count);
262
262
  return res;
263
263
}
264
264
 
265
 
int ha_heap::index_read_map(uchar *buf, const uchar *key,
 
265
int ha_heap::index_read_map(unsigned char *buf, const unsigned char *key,
266
266
                            key_part_map keypart_map,
267
267
                            enum ha_rkey_function find_flag)
268
268
{
273
273
  return error;
274
274
}
275
275
 
276
 
int ha_heap::index_read_last_map(uchar *buf, const uchar *key,
 
276
int ha_heap::index_read_last_map(unsigned char *buf, const unsigned char *key,
277
277
                                 key_part_map keypart_map)
278
278
{
279
279
  assert(inited==INDEX);
284
284
  return error;
285
285
}
286
286
 
287
 
int ha_heap::index_read_idx_map(uchar *buf, uint index, const uchar *key,
 
287
int ha_heap::index_read_idx_map(unsigned char *buf, uint index, const unsigned char *key,
288
288
                                key_part_map keypart_map,
289
289
                                enum ha_rkey_function find_flag)
290
290
{
294
294
  return error;
295
295
}
296
296
 
297
 
int ha_heap::index_next(uchar * buf)
 
297
int ha_heap::index_next(unsigned char * buf)
298
298
{
299
299
  assert(inited==INDEX);
300
300
  ha_statistic_increment(&SSV::ha_read_next_count);
303
303
  return error;
304
304
}
305
305
 
306
 
int ha_heap::index_prev(uchar * buf)
 
306
int ha_heap::index_prev(unsigned char * buf)
307
307
{
308
308
  assert(inited==INDEX);
309
309
  ha_statistic_increment(&SSV::ha_read_prev_count);
312
312
  return error;
313
313
}
314
314
 
315
 
int ha_heap::index_first(uchar * buf)
 
315
int ha_heap::index_first(unsigned char * buf)
316
316
{
317
317
  assert(inited==INDEX);
318
318
  ha_statistic_increment(&SSV::ha_read_first_count);
321
321
  return error;
322
322
}
323
323
 
324
 
int ha_heap::index_last(uchar * buf)
 
324
int ha_heap::index_last(unsigned char * buf)
325
325
{
326
326
  assert(inited==INDEX);
327
327
  ha_statistic_increment(&SSV::ha_read_last_count);
335
335
  return scan ? heap_scan_init(file) : 0;
336
336
}
337
337
 
338
 
int ha_heap::rnd_next(uchar *buf)
 
338
int ha_heap::rnd_next(unsigned char *buf)
339
339
{
340
340
  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
341
341
  int error=heap_scan(file, buf);
343
343
  return error;
344
344
}
345
345
 
346
 
int ha_heap::rnd_pos(uchar * buf, uchar *pos)
 
346
int ha_heap::rnd_pos(unsigned char * buf, unsigned char *pos)
347
347
{
348
348
  int error;
349
349
  HEAP_PTR heap_position;
354
354
  return error;
355
355
}
356
356
 
357
 
void ha_heap::position(const uchar *record __attribute__((unused)))
 
357
void ha_heap::position(const unsigned char *record __attribute__((unused)))
358
358
{
359
359
  *(HEAP_PTR*) ref= heap_position(file);        // Ref is aligned
360
360
}
620
620
    if (field->null_bit)
621
621
    {
622
622
      column->null_bit= field->null_bit;
623
 
      column->null_pos= (uint) (field->null_ptr - (uchar*) table_arg->record[0]);
 
623
      column->null_pos= (uint) (field->null_ptr - (unsigned char*) table_arg->record[0]);
624
624
    }
625
625
    else
626
626
    {
710
710
      if (field->null_ptr)
711
711
      {
712
712
        seg->null_bit= field->null_bit;
713
 
        seg->null_pos= (uint) (field->null_ptr - (uchar*) table_arg->record[0]);
 
713
        seg->null_pos= (uint) (field->null_ptr - (unsigned char*) table_arg->record[0]);
714
714
      }
715
715
      else
716
716
      {
768
768
         (uint32_t) share->max_rows, (uint32_t) share->min_rows,
769
769
         &hp_create_info, &internal_share);
770
770
  
771
 
  free((uchar*) keydef);
 
771
  free((unsigned char*) keydef);
772
772
  free((void *) columndef);
773
773
  assert(file == 0);
774
774
  return (error);