← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/my_handler.cc

  • Committer: Monty Taylor
  • Date: 2009-04-25 20:45:19 UTC
  • mto: (997.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 1003.
  • Revision ID: mordred@inaugust.com-20090425204519-lgrl7mz2r66v0jby
Blackhole.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/my_handler.cc
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"
26
 
 
27
 
#include <cassert>
28
 
#include <algorithm>
29
 
 
30
 
using namespace drizzled;
31
 
using namespace std;
32
 
 
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
 
}
 
25
#include <mysys/my_sys.h>
 
26
 
 
27
/**
 
28
  Swap the contents of two variables.
 
29
 */
 
30
#define swap_variables(TYPE, a, b) \
 
31
  do {                             \
 
32
    TYPE dummy;                    \
 
33
    dummy= a;                      \
 
34
    a= b;                          \
 
35
    b= dummy;                      \
 
36
  } while (0)
 
37
 
 
38
#define CMP_NUM(a,b) (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1)
38
39
 
39
40
 
40
41
int ha_compare_text(const CHARSET_INFO * const charset_info, unsigned char *a, uint32_t a_length,
52
53
static int compare_bin(unsigned char *a, uint32_t a_length, unsigned char *b, uint32_t b_length,
53
54
                       bool part_key, bool skip_end_space)
54
55
{
55
 
  uint32_t length= min(a_length,b_length);
 
56
  uint32_t length= cmin(a_length,b_length);
56
57
  unsigned char *end= a+ length;
57
58
  int flag;
58
59
 
137
138
               uint32_t *diff_pos)
138
139
{
139
140
  int flag;
 
141
  int16_t s_1,s_2;
140
142
  int32_t l_1,l_2;
141
143
  uint32_t u_1,u_2;
 
144
  float f_1,f_2;
142
145
  double d_1,d_2;
143
146
  uint32_t next_key_length;
144
147
  unsigned char *orig_b= b;
178
181
        continue;                               /* To next key part */
179
182
      }
180
183
    }
181
 
    end= a+ min((uint32_t)keyseg->length,key_length);
 
184
    end= a+ cmin(keyseg->length,key_length);
182
185
    next_key_length=key_length-keyseg->length;
183
186
 
184
187
    switch ((enum ha_base_keytype) keyseg->type) {
214
217
      }
215
218
      break;
216
219
    case HA_KEYTYPE_BINARY:
 
220
    case HA_KEYTYPE_BIT:
217
221
      if (keyseg->flag & HA_SPACE_PACK)
218
222
      {
219
223
        int a_length,b_length,pack_length;
281
285
        b+=b_length;
282
286
        break;
283
287
      }
 
288
    case HA_KEYTYPE_INT8:
 
289
    {
 
290
      int i_1= (int) *((signed char*) a);
 
291
      int i_2= (int) *((signed char*) b);
 
292
      if (piks && (flag = CMP_NUM(i_1,i_2)))
 
293
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
294
      a= end;
 
295
      b++;
 
296
      break;
 
297
    }
 
298
    case HA_KEYTYPE_SHORT_INT:
 
299
      s_1= mi_sint2korr(a);
 
300
      s_2= mi_sint2korr(b);
 
301
      if (piks && (flag = CMP_NUM(s_1,s_2)))
 
302
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
303
      a=  end;
 
304
      b+= 2; /* sizeof(short int); */
 
305
      break;
 
306
    case HA_KEYTYPE_USHORT_INT:
 
307
      {
 
308
        uint16_t us_1,us_2;
 
309
        us_1= mi_sint2korr(a);
 
310
        us_2= mi_sint2korr(b);
 
311
        if (piks && (flag = CMP_NUM(us_1,us_2)))
 
312
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
313
        a=  end;
 
314
        b+=2; /* sizeof(short int); */
 
315
        break;
 
316
      }
284
317
    case HA_KEYTYPE_LONG_INT:
285
318
      l_1= mi_sint4korr(a);
286
319
      l_2= mi_sint4korr(b);
297
330
      a=  end;
298
331
      b+= 4; /* sizeof(long int); */
299
332
      break;
 
333
    case HA_KEYTYPE_INT24:
 
334
      l_1=mi_sint3korr(a);
 
335
      l_2=mi_sint3korr(b);
 
336
      if (piks && (flag = CMP_NUM(l_1,l_2)))
 
337
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
338
      a=  end;
 
339
      b+= 3;
 
340
      break;
300
341
    case HA_KEYTYPE_UINT24:
301
342
      l_1=mi_uint3korr(a);
302
343
      l_2=mi_uint3korr(b);
305
346
      a=  end;
306
347
      b+= 3;
307
348
      break;
 
349
    case HA_KEYTYPE_FLOAT:
 
350
      mi_float4get(f_1,a);
 
351
      mi_float4get(f_2,b);
 
352
      /*
 
353
        The following may give a compiler warning about floating point
 
354
        comparison not being safe, but this is ok in this context as
 
355
        we are bascily doing sorting
 
356
      */
 
357
      if (piks && (flag = CMP_NUM(f_1,f_2)))
 
358
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
 
359
      a=  end;
 
360
      b+= 4; /* sizeof(float); */
 
361
      break;
308
362
    case HA_KEYTYPE_DOUBLE:
309
363
      mi_float8get(d_1,a);
310
364
      mi_float8get(d_2,b);
318
372
      a=  end;
319
373
      b+= 8;  /* sizeof(double); */
320
374
      break;
 
375
    case HA_KEYTYPE_NUM:                                /* Numeric key */
 
376
    {
 
377
      int swap_flag= 0;
 
378
      int alength,blength;
 
379
 
 
380
      if (keyseg->flag & HA_REVERSE_SORT)
 
381
      {
 
382
        swap_variables(unsigned char*, a, b);
 
383
        swap_flag=1;                            /* Remember swap of a & b */
 
384
        end= a+ (int) (end-b);
 
385
      }
 
386
      if (keyseg->flag & HA_SPACE_PACK)
 
387
      {
 
388
        alength= *a++; blength= *b++;
 
389
        end=a+alength;
 
390
        next_key_length=key_length-blength-1;
 
391
      }
 
392
      else
 
393
      {
 
394
        alength= (int) (end-a);
 
395
        blength=keyseg->length;
 
396
        /* remove pre space from keys */
 
397
        for ( ; alength && *a == ' ' ; a++, alength--) ;
 
398
        for ( ; blength && *b == ' ' ; b++, blength--) ;
 
399
      }
 
400
      if (piks)
 
401
      {
 
402
        if (*a == '-')
 
403
        {
 
404
          if (*b != '-')
 
405
            return -1;
 
406
          a++; b++;
 
407
          swap_variables(unsigned char*, a, b);
 
408
          swap_variables(int, alength, blength);
 
409
          swap_flag=1-swap_flag;
 
410
          alength--; blength--;
 
411
          end=a+alength;
 
412
        }
 
413
        else if (*b == '-')
 
414
          return 1;
 
415
        while (alength && (*a == '+' || *a == '0'))
 
416
        {
 
417
          a++; alength--;
 
418
        }
 
419
        while (blength && (*b == '+' || *b == '0'))
 
420
        {
 
421
          b++; blength--;
 
422
        }
 
423
        if (alength != blength)
 
424
          return (alength < blength) ? -1 : 1;
 
425
        while (a < end)
 
426
          if (*a++ !=  *b++)
 
427
            return ((int) a[-1] - (int) b[-1]);
 
428
      }
 
429
      else
 
430
      {
 
431
        b+=(end-a);
 
432
        a=end;
 
433
      }
 
434
 
 
435
      if (swap_flag)                            /* Restore pointers */
 
436
        swap_variables(unsigned char*, a, b);
 
437
      break;
 
438
    }
321
439
    case HA_KEYTYPE_LONGLONG:
322
440
    {
323
441
      int64_t ll_a,ll_b;
406
524
    switch ((enum ha_base_keytype) keyseg->type) {
407
525
    case HA_KEYTYPE_TEXT:
408
526
    case HA_KEYTYPE_BINARY:
 
527
    case HA_KEYTYPE_BIT:
409
528
      if (keyseg->flag & HA_SPACE_PACK)
410
529
      {
411
530
        int a_length;
426
545
        a+= a_length;
427
546
        break;
428
547
      }
 
548
    case HA_KEYTYPE_NUM:
 
549
      if (keyseg->flag & HA_SPACE_PACK)
 
550
      {
 
551
        int alength= *a++;
 
552
        end= a+alength;
 
553
      }
 
554
      a= end;
 
555
      break;
 
556
    case HA_KEYTYPE_INT8:
 
557
    case HA_KEYTYPE_SHORT_INT:
 
558
    case HA_KEYTYPE_USHORT_INT:
429
559
    case HA_KEYTYPE_LONG_INT:
430
560
    case HA_KEYTYPE_ULONG_INT:
 
561
    case HA_KEYTYPE_INT24:
431
562
    case HA_KEYTYPE_UINT24:
432
563
    case HA_KEYTYPE_LONGLONG:
433
564
    case HA_KEYTYPE_ULONGLONG:
 
565
    case HA_KEYTYPE_FLOAT:
434
566
    case HA_KEYTYPE_DOUBLE:
435
567
      a= end;
436
568
      break;
437
 
    case HA_KEYTYPE_END:
 
569
    case HA_KEYTYPE_END:                        /* purecov: inspected */
438
570
      /* keep compiler happy */
439
571
      assert(0);
440
572
      break;