← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/my_handler.cc

  • Committer: Daniel Nichter
  • Date: 2011-10-23 16:01:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2448.
  • Revision ID: daniel@percona.com-20111023160137-7ac3blgz8z4tf8za
Add Administration Getting Started and Logging.  Capitalize SQL clause keywords.

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
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
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 <drizzled/global.h>
 
20
#include <config.h>
21
21
 
22
 
#include <mystrings/m_ctype.h>
 
22
#include <drizzled/charset.h>
23
23
#include <drizzled/base.h>
24
 
#include <storage/myisam/my_handler.h>
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)
39
 
 
40
 
 
41
 
int ha_compare_text(const CHARSET_INFO * const charset_info, unsigned char *a, uint32_t a_length,
 
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
}
 
38
 
 
39
 
 
40
int ha_compare_text(const charset_info_st * const charset_info, unsigned char *a, uint32_t a_length,
42
41
                    unsigned char *b, uint32_t b_length, bool part_key,
43
42
                    bool skip_end_space)
44
43
{
53
52
static int compare_bin(unsigned char *a, uint32_t a_length, unsigned char *b, uint32_t b_length,
54
53
                       bool part_key, bool skip_end_space)
55
54
{
56
 
  uint32_t length= cmin(a_length,b_length);
 
55
  uint32_t length= min(a_length,b_length);
57
56
  unsigned char *end= a+ length;
58
57
  int flag;
59
58
 
105
104
    next_flag   How keys should be compared
106
105
                If bit SEARCH_FIND is not set the keys includes the row
107
106
                position and this should also be compared
108
 
    diff_pos    OUT Number of first keypart where values differ, counting 
 
107
    diff_pos    OUT Number of first keypart where values differ, counting
109
108
                from one.
110
109
    diff_pos[1] OUT  (b + diff_pos[1]) points to first value in tuple b
111
110
                      that is different from corresponding value in tuple a.
112
 
  
113
 
  EXAMPLES 
 
111
 
 
112
  EXAMPLES
114
113
   Example1: if the function is called for tuples
115
114
     ('aaa','bbb') and ('eee','fff'), then
116
115
     diff_pos[0] = 1 (as 'aaa' != 'eee')
138
137
               uint32_t *diff_pos)
139
138
{
140
139
  int flag;
141
 
  int16_t s_1,s_2;
142
140
  int32_t l_1,l_2;
143
141
  uint32_t u_1,u_2;
144
 
  float f_1,f_2;
145
142
  double d_1,d_2;
146
143
  uint32_t next_key_length;
147
144
  unsigned char *orig_b= b;
181
178
        continue;                               /* To next key part */
182
179
      }
183
180
    }
184
 
    end= a+ cmin(keyseg->length,key_length);
 
181
    end= a+ min((uint32_t)keyseg->length,key_length);
185
182
    next_key_length=key_length-keyseg->length;
186
183
 
187
184
    switch ((enum ha_base_keytype) keyseg->type) {
217
214
      }
218
215
      break;
219
216
    case HA_KEYTYPE_BINARY:
220
 
    case HA_KEYTYPE_BIT:
221
217
      if (keyseg->flag & HA_SPACE_PACK)
222
218
      {
223
219
        int a_length,b_length,pack_length;
268
264
        b+= b_length;
269
265
        break;
270
266
      }
271
 
      break;
272
267
    case HA_KEYTYPE_VARBINARY1:
273
268
    case HA_KEYTYPE_VARBINARY2:
274
269
      {
286
281
        b+=b_length;
287
282
        break;
288
283
      }
289
 
      break;
290
 
    case HA_KEYTYPE_INT8:
291
 
    {
292
 
      int i_1= (int) *((signed char*) a);
293
 
      int i_2= (int) *((signed char*) b);
294
 
      if (piks && (flag = CMP_NUM(i_1,i_2)))
295
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
296
 
      a= end;
297
 
      b++;
298
 
      break;
299
 
    }
300
 
    case HA_KEYTYPE_SHORT_INT:
301
 
      s_1= mi_sint2korr(a);
302
 
      s_2= mi_sint2korr(b);
303
 
      if (piks && (flag = CMP_NUM(s_1,s_2)))
304
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
305
 
      a=  end;
306
 
      b+= 2; /* sizeof(short int); */
307
 
      break;
308
 
    case HA_KEYTYPE_USHORT_INT:
309
 
      {
310
 
        uint16_t us_1,us_2;
311
 
        us_1= mi_sint2korr(a);
312
 
        us_2= mi_sint2korr(b);
313
 
        if (piks && (flag = CMP_NUM(us_1,us_2)))
314
 
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
315
 
        a=  end;
316
 
        b+=2; /* sizeof(short int); */
317
 
        break;
318
 
      }
319
284
    case HA_KEYTYPE_LONG_INT:
320
285
      l_1= mi_sint4korr(a);
321
286
      l_2= mi_sint4korr(b);
332
297
      a=  end;
333
298
      b+= 4; /* sizeof(long int); */
334
299
      break;
335
 
    case HA_KEYTYPE_INT24:
336
 
      l_1=mi_sint3korr(a);
337
 
      l_2=mi_sint3korr(b);
338
 
      if (piks && (flag = CMP_NUM(l_1,l_2)))
339
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
340
 
      a=  end;
341
 
      b+= 3;
342
 
      break;
343
 
    case HA_KEYTYPE_UINT24:
344
 
      l_1=mi_uint3korr(a);
345
 
      l_2=mi_uint3korr(b);
346
 
      if (piks && (flag = CMP_NUM(l_1,l_2)))
347
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
348
 
      a=  end;
349
 
      b+= 3;
350
 
      break;
351
 
    case HA_KEYTYPE_FLOAT:
352
 
      mi_float4get(f_1,a);
353
 
      mi_float4get(f_2,b);
354
 
      /*
355
 
        The following may give a compiler warning about floating point
356
 
        comparison not being safe, but this is ok in this context as
357
 
        we are bascily doing sorting
358
 
      */
359
 
      if (piks && (flag = CMP_NUM(f_1,f_2)))
360
 
        return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
361
 
      a=  end;
362
 
      b+= 4; /* sizeof(float); */
363
 
      break;
364
300
    case HA_KEYTYPE_DOUBLE:
365
301
      mi_float8get(d_1,a);
366
302
      mi_float8get(d_2,b);
374
310
      a=  end;
375
311
      b+= 8;  /* sizeof(double); */
376
312
      break;
377
 
    case HA_KEYTYPE_NUM:                                /* Numeric key */
378
 
    {
379
 
      int swap_flag= 0;
380
 
      int alength,blength;
381
 
 
382
 
      if (keyseg->flag & HA_REVERSE_SORT)
383
 
      {
384
 
        swap_variables(unsigned char*, a, b);
385
 
        swap_flag=1;                            /* Remember swap of a & b */
386
 
        end= a+ (int) (end-b);
387
 
      }
388
 
      if (keyseg->flag & HA_SPACE_PACK)
389
 
      {
390
 
        alength= *a++; blength= *b++;
391
 
        end=a+alength;
392
 
        next_key_length=key_length-blength-1;
393
 
      }
394
 
      else
395
 
      {
396
 
        alength= (int) (end-a);
397
 
        blength=keyseg->length;
398
 
        /* remove pre space from keys */
399
 
        for ( ; alength && *a == ' ' ; a++, alength--) ;
400
 
        for ( ; blength && *b == ' ' ; b++, blength--) ;
401
 
      }
402
 
      if (piks)
403
 
      {
404
 
        if (*a == '-')
405
 
        {
406
 
          if (*b != '-')
407
 
            return -1;
408
 
          a++; b++;
409
 
          swap_variables(unsigned char*, a, b);
410
 
          swap_variables(int, alength, blength);
411
 
          swap_flag=1-swap_flag;
412
 
          alength--; blength--;
413
 
          end=a+alength;
414
 
        }
415
 
        else if (*b == '-')
416
 
          return 1;
417
 
        while (alength && (*a == '+' || *a == '0'))
418
 
        {
419
 
          a++; alength--;
420
 
        }
421
 
        while (blength && (*b == '+' || *b == '0'))
422
 
        {
423
 
          b++; blength--;
424
 
        }
425
 
        if (alength != blength)
426
 
          return (alength < blength) ? -1 : 1;
427
 
        while (a < end)
428
 
          if (*a++ !=  *b++)
429
 
            return ((int) a[-1] - (int) b[-1]);
430
 
      }
431
 
      else
432
 
      {
433
 
        b+=(end-a);
434
 
        a=end;
435
 
      }
436
 
 
437
 
      if (swap_flag)                            /* Restore pointers */
438
 
        swap_variables(unsigned char*, a, b);
439
 
      break;
440
 
    }
441
313
    case HA_KEYTYPE_LONGLONG:
442
314
    {
443
315
      int64_t ll_a,ll_b;
526
398
    switch ((enum ha_base_keytype) keyseg->type) {
527
399
    case HA_KEYTYPE_TEXT:
528
400
    case HA_KEYTYPE_BINARY:
529
 
    case HA_KEYTYPE_BIT:
530
401
      if (keyseg->flag & HA_SPACE_PACK)
531
402
      {
532
403
        int a_length;
547
418
        a+= a_length;
548
419
        break;
549
420
      }
550
 
    case HA_KEYTYPE_NUM:
551
 
      if (keyseg->flag & HA_SPACE_PACK)
552
 
      {
553
 
        int alength= *a++;
554
 
        end= a+alength;
555
 
      }
556
 
      a= end;
557
 
      break;
558
 
    case HA_KEYTYPE_INT8:
559
 
    case HA_KEYTYPE_SHORT_INT:
560
 
    case HA_KEYTYPE_USHORT_INT:
561
421
    case HA_KEYTYPE_LONG_INT:
562
422
    case HA_KEYTYPE_ULONG_INT:
563
 
    case HA_KEYTYPE_INT24:
564
 
    case HA_KEYTYPE_UINT24:
565
423
    case HA_KEYTYPE_LONGLONG:
566
424
    case HA_KEYTYPE_ULONGLONG:
567
 
    case HA_KEYTYPE_FLOAT:
568
425
    case HA_KEYTYPE_DOUBLE:
569
426
      a= end;
570
427
      break;
571
 
    case HA_KEYTYPE_END:                        /* purecov: inspected */
 
428
    case HA_KEYTYPE_END:
572
429
      /* keep compiler happy */
573
430
      assert(0);
574
431
      break;