← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/my_handler.cc

  • Committer: Brian Aker
  • Date: 2009-08-18 07:20:29 UTC
  • mfrom: (1117.1.9 merge)
  • Revision ID: brian@gaz-20090818072029-s9ch5lcmltxwidn7
Merge of Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/my_handler.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include <config.h>
 
20
#include <drizzled/global.h>
21
21
 
22
 
#include <drizzled/charset_info.h>
 
22
#include <mystrings/m_ctype.h>
23
23
#include <drizzled/base.h>
24
24
#include <plugin/myisam/my_handler.h>
25
 
#include <drizzled/internal/my_sys.h>
 
25
#include <mysys/my_sys.h>
26
26
 
27
 
#include <cassert>
28
27
#include <algorithm>
29
28
 
30
 
using namespace drizzled;
31
29
using namespace std;
32
30
 
33
 
template<class T>
34
 
int CMP_NUM(const T& a, const T&b)
35
 
{
36
 
  return (a < b) ? -1 : (a == b) ? 0 : 1;
37
 
}
 
31
/**
 
32
  Swap the contents of two variables.
 
33
 */
 
34
#define swap_variables(TYPE, a, b) \
 
35
  do {                             \
 
36
    TYPE dummy;                    \
 
37
    dummy= a;                      \
 
38
    a= b;                          \
 
39
    b= dummy;                      \
 
40
  } while (0)
 
41
 
 
42
#define CMP_NUM(a,b) (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1)
38
43
 
39
44
 
40
45
int ha_compare_text(const CHARSET_INFO * const charset_info, unsigned char *a, uint32_t a_length,
137
142
               uint32_t *diff_pos)
138
143
{
139
144
  int flag;
 
145
  int16_t s_1,s_2;
140
146
  int32_t l_1,l_2;
141
147
  uint32_t u_1,u_2;
 
148
  float f_1,f_2;
142
149
  double d_1,d_2;
143
150
  uint32_t next_key_length;
144
151
  unsigned char *orig_b= b;
214
221
      }
215
222
      break;
216
223
    case HA_KEYTYPE_BINARY:
 
224
    case HA_KEYTYPE_BIT:
217
225
      if (keyseg->flag & HA_SPACE_PACK)
218
226
      {
219
227
        int a_length,b_length,pack_length;
281
289
        b+=b_length;
282
290
        break;
283
291
      }
 
292
    case HA_KEYTYPE_INT8:
 
293
    {
 
294
      int i_1= (int) *((signed char*) a);
 
295
      int i_2= (int) *((signed char*) b);
 
296
      if (piks && (flag = CMP_NUM(i_1,i_2)))
 
297
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
298
      a= end;
 
299
      b++;
 
300
      break;
 
301
    }
 
302
    case HA_KEYTYPE_SHORT_INT:
 
303
      s_1= mi_sint2korr(a);
 
304
      s_2= mi_sint2korr(b);
 
305
      if (piks && (flag = CMP_NUM(s_1,s_2)))
 
306
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
307
      a=  end;
 
308
      b+= 2; /* sizeof(short int); */
 
309
      break;
 
310
    case HA_KEYTYPE_USHORT_INT:
 
311
      {
 
312
        uint16_t us_1,us_2;
 
313
        us_1= mi_sint2korr(a);
 
314
        us_2= mi_sint2korr(b);
 
315
        if (piks && (flag = CMP_NUM(us_1,us_2)))
 
316
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
317
        a=  end;
 
318
        b+=2; /* sizeof(short int); */
 
319
        break;
 
320
      }
284
321
    case HA_KEYTYPE_LONG_INT:
285
322
      l_1= mi_sint4korr(a);
286
323
      l_2= mi_sint4korr(b);
297
334
      a=  end;
298
335
      b+= 4; /* sizeof(long int); */
299
336
      break;
 
337
    case HA_KEYTYPE_INT24:
 
338
      l_1=mi_sint3korr(a);
 
339
      l_2=mi_sint3korr(b);
 
340
      if (piks && (flag = CMP_NUM(l_1,l_2)))
 
341
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
342
      a=  end;
 
343
      b+= 3;
 
344
      break;
 
345
    case HA_KEYTYPE_UINT24:
 
346
      l_1=mi_uint3korr(a);
 
347
      l_2=mi_uint3korr(b);
 
348
      if (piks && (flag = CMP_NUM(l_1,l_2)))
 
349
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
350
      a=  end;
 
351
      b+= 3;
 
352
      break;
 
353
    case HA_KEYTYPE_FLOAT:
 
354
      mi_float4get(f_1,a);
 
355
      mi_float4get(f_2,b);
 
356
      /*
 
357
        The following may give a compiler warning about floating point
 
358
        comparison not being safe, but this is ok in this context as
 
359
        we are bascily doing sorting
 
360
      */
 
361
      if (piks && (flag = CMP_NUM(f_1,f_2)))
 
362
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
363
      a=  end;
 
364
      b+= 4; /* sizeof(float); */
 
365
      break;
300
366
    case HA_KEYTYPE_DOUBLE:
301
367
      mi_float8get(d_1,a);
302
368
      mi_float8get(d_2,b);
310
376
      a=  end;
311
377
      b+= 8;  /* sizeof(double); */
312
378
      break;
 
379
    case HA_KEYTYPE_NUM:                                /* Numeric key */
 
380
    {
 
381
      int swap_flag= 0;
 
382
      int alength,blength;
 
383
 
 
384
      if (keyseg->flag & HA_REVERSE_SORT)
 
385
      {
 
386
        swap_variables(unsigned char*, a, b);
 
387
        swap_flag=1;                            /* Remember swap of a & b */
 
388
        end= a+ (int) (end-b);
 
389
      }
 
390
      if (keyseg->flag & HA_SPACE_PACK)
 
391
      {
 
392
        alength= *a++; blength= *b++;
 
393
        end=a+alength;
 
394
        next_key_length=key_length-blength-1;
 
395
      }
 
396
      else
 
397
      {
 
398
        alength= (int) (end-a);
 
399
        blength=keyseg->length;
 
400
        /* remove pre space from keys */
 
401
        for ( ; alength && *a == ' ' ; a++, alength--) ;
 
402
        for ( ; blength && *b == ' ' ; b++, blength--) ;
 
403
      }
 
404
      if (piks)
 
405
      {
 
406
        if (*a == '-')
 
407
        {
 
408
          if (*b != '-')
 
409
            return -1;
 
410
          a++; b++;
 
411
          swap_variables(unsigned char*, a, b);
 
412
          swap_variables(int, alength, blength);
 
413
          swap_flag=1-swap_flag;
 
414
          alength--; blength--;
 
415
          end=a+alength;
 
416
        }
 
417
        else if (*b == '-')
 
418
          return 1;
 
419
        while (alength && (*a == '+' || *a == '0'))
 
420
        {
 
421
          a++; alength--;
 
422
        }
 
423
        while (blength && (*b == '+' || *b == '0'))
 
424
        {
 
425
          b++; blength--;
 
426
        }
 
427
        if (alength != blength)
 
428
          return (alength < blength) ? -1 : 1;
 
429
        while (a < end)
 
430
          if (*a++ !=  *b++)
 
431
            return ((int) a[-1] - (int) b[-1]);
 
432
      }
 
433
      else
 
434
      {
 
435
        b+=(end-a);
 
436
        a=end;
 
437
      }
 
438
 
 
439
      if (swap_flag)                            /* Restore pointers */
 
440
        swap_variables(unsigned char*, a, b);
 
441
      break;
 
442
    }
313
443
    case HA_KEYTYPE_LONGLONG:
314
444
    {
315
445
      int64_t ll_a,ll_b;
398
528
    switch ((enum ha_base_keytype) keyseg->type) {
399
529
    case HA_KEYTYPE_TEXT:
400
530
    case HA_KEYTYPE_BINARY:
 
531
    case HA_KEYTYPE_BIT:
401
532
      if (keyseg->flag & HA_SPACE_PACK)
402
533
      {
403
534
        int a_length;
418
549
        a+= a_length;
419
550
        break;
420
551
      }
 
552
    case HA_KEYTYPE_NUM:
 
553
      if (keyseg->flag & HA_SPACE_PACK)
 
554
      {
 
555
        int alength= *a++;
 
556
        end= a+alength;
 
557
      }
 
558
      a= end;
 
559
      break;
 
560
    case HA_KEYTYPE_INT8:
 
561
    case HA_KEYTYPE_SHORT_INT:
 
562
    case HA_KEYTYPE_USHORT_INT:
421
563
    case HA_KEYTYPE_LONG_INT:
422
564
    case HA_KEYTYPE_ULONG_INT:
 
565
    case HA_KEYTYPE_INT24:
 
566
    case HA_KEYTYPE_UINT24:
423
567
    case HA_KEYTYPE_LONGLONG:
424
568
    case HA_KEYTYPE_ULONGLONG:
 
569
    case HA_KEYTYPE_FLOAT:
425
570
    case HA_KEYTYPE_DOUBLE:
426
571
      a= end;
427
572
      break;
428
 
    case HA_KEYTYPE_END:
 
573
    case HA_KEYTYPE_END:                        /* purecov: inspected */
429
574
      /* keep compiler happy */
430
575
      assert(0);
431
576
      break;