← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_handler.c

merge mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_handler.c
15
15
   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
16
16
   MA 02111-1307, USA */
17
17
 
18
 
#include "mysys_priv.h"
19
 
 
20
 
#include <mystrings/m_ctype.h>
21
 
#include <drizzled/base.h>
 
18
#include <my_global.h>
 
19
#include <m_ctype.h>
 
20
#include <my_base.h>
22
21
#include <my_handler.h>
23
22
#include <my_sys.h>
24
23
 
 
24
#include "mysys_priv.h"
25
25
#include "my_handler_errors.h"
26
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,
42
 
                    unsigned char *b, uint32_t b_length, bool part_key,
43
 
                    bool skip_end_space)
 
27
int ha_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
 
28
                    uchar *b, uint b_length, my_bool part_key,
 
29
                    my_bool skip_end_space)
44
30
{
45
31
  if (!part_key)
46
32
    return charset_info->coll->strnncollsp(charset_info, a, a_length,
47
 
                                           b, b_length, (bool)!skip_end_space);
 
33
                                           b, b_length, (my_bool)!skip_end_space);
48
34
  return charset_info->coll->strnncoll(charset_info, a, a_length,
49
35
                                       b, b_length, part_key);
50
36
}
51
37
 
52
38
 
53
 
static int compare_bin(unsigned char *a, uint32_t a_length, unsigned char *b, uint32_t b_length,
54
 
                       bool part_key, bool skip_end_space)
 
39
static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
 
40
                       my_bool part_key, my_bool skip_end_space)
55
41
{
56
 
  uint32_t length= cmin(a_length,b_length);
57
 
  unsigned char *end= a+ length;
 
42
  uint length= min(a_length,b_length);
 
43
  uchar *end= a+ length;
58
44
  int flag;
59
45
 
60
46
  while (a < end)
133
119
 
134
120
#define FCMP(A,B) ((int) (A) - (int) (B))
135
121
 
136
 
int ha_key_cmp(register HA_KEYSEG *keyseg, register unsigned char *a,
137
 
               register unsigned char *b, uint32_t key_length, uint32_t nextflag,
138
 
               uint32_t *diff_pos)
 
122
int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 
123
               register uchar *b, uint key_length, uint nextflag,
 
124
               uint *diff_pos)
139
125
{
140
126
  int flag;
141
 
  int16_t s_1,s_2;
142
 
  int32_t l_1,l_2;
143
 
  uint32_t u_1,u_2;
 
127
  int16 s_1,s_2;
 
128
  int32 l_1,l_2;
 
129
  uint32 u_1,u_2;
144
130
  float f_1,f_2;
145
131
  double d_1,d_2;
146
 
  uint32_t next_key_length;
147
 
  unsigned char *orig_b= b;
 
132
  uint next_key_length;
 
133
  uchar *orig_b= b;
148
134
 
149
135
  *diff_pos=0;
150
136
  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
151
137
  {
152
 
    unsigned char *end;
153
 
    uint32_t piks=! (keyseg->flag & HA_NO_SORT);
 
138
    uchar *end;
 
139
    uint piks=! (keyseg->flag & HA_NO_SORT);
154
140
    (*diff_pos)++;
155
141
    diff_pos[1]= (uint)(b - orig_b);
156
142
 
181
167
        continue;                               /* To next key part */
182
168
      }
183
169
    }
184
 
    end= a+ cmin(keyseg->length,key_length);
 
170
    end= a+ min(keyseg->length,key_length);
185
171
    next_key_length=key_length-keyseg->length;
186
172
 
187
173
    switch ((enum ha_base_keytype) keyseg->type) {
195
181
 
196
182
        if (piks &&
197
183
            (flag=ha_compare_text(keyseg->charset,a,a_length,b,b_length,
198
 
                                  (bool) ((nextflag & SEARCH_PREFIX) &&
 
184
                                  (my_bool) ((nextflag & SEARCH_PREFIX) &&
199
185
                                             next_key_length <= 0),
200
 
                                  (bool)!(nextflag & SEARCH_PREFIX))))
 
186
                                  (my_bool)!(nextflag & SEARCH_PREFIX))))
201
187
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
202
188
        a+=a_length;
203
189
        b+=b_length;
205
191
      }
206
192
      else
207
193
      {
208
 
        uint32_t length=(uint) (end-a), a_length=length, b_length=length;
 
194
        uint length=(uint) (end-a), a_length=length, b_length=length;
209
195
        if (piks &&
210
196
            (flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
211
 
                                   (bool) ((nextflag & SEARCH_PREFIX) &&
 
197
                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
212
198
                                              next_key_length <= 0),
213
 
                                   (bool)!(nextflag & SEARCH_PREFIX))))
 
199
                                   (my_bool)!(nextflag & SEARCH_PREFIX))))
214
200
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
215
201
        a=end;
216
202
        b+=length;
227
213
 
228
214
        if (piks &&
229
215
            (flag=compare_bin(a,a_length,b,b_length,
230
 
                              (bool) ((nextflag & SEARCH_PREFIX) &&
 
216
                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
231
217
                                         next_key_length <= 0),1)))
232
218
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
233
219
        a+=a_length;
236
222
      }
237
223
      else
238
224
      {
239
 
        uint32_t length=keyseg->length;
 
225
        uint length=keyseg->length;
240
226
        if (piks &&
241
227
            (flag=compare_bin(a,length,b,length,
242
 
                              (bool) ((nextflag & SEARCH_PREFIX) &&
 
228
                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
243
229
                                         next_key_length <= 0),0)))
244
230
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
245
231
        a+=length;
256
242
 
257
243
        if (piks &&
258
244
            (flag= ha_compare_text(keyseg->charset,a,a_length,b,b_length,
259
 
                                   (bool) ((nextflag & SEARCH_PREFIX) &&
 
245
                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
260
246
                                              next_key_length <= 0),
261
 
                                   (bool) ((nextflag & (SEARCH_FIND |
 
247
                                   (my_bool) ((nextflag & (SEARCH_FIND |
262
248
                                                           SEARCH_UPDATE)) ==
263
249
                                              SEARCH_FIND &&
264
250
                                              ! (keyseg->flag &
279
265
 
280
266
        if (piks &&
281
267
            (flag=compare_bin(a,a_length,b,b_length,
282
 
                              (bool) ((nextflag & SEARCH_PREFIX) &&
 
268
                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
283
269
                                         next_key_length <= 0), 0)))
284
270
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
285
271
        a+=a_length;
307
293
      break;
308
294
    case HA_KEYTYPE_USHORT_INT:
309
295
      {
310
 
        uint16_t us_1,us_2;
 
296
        uint16 us_1,us_2;
311
297
        us_1= mi_sint2korr(a);
312
298
        us_2= mi_sint2korr(b);
313
299
        if (piks && (flag = CMP_NUM(us_1,us_2)))
381
367
 
382
368
      if (keyseg->flag & HA_REVERSE_SORT)
383
369
      {
384
 
        swap_variables(unsigned char*, a, b);
 
370
        swap_variables(uchar*, a, b);
385
371
        swap_flag=1;                            /* Remember swap of a & b */
386
372
        end= a+ (int) (end-b);
387
373
      }
406
392
          if (*b != '-')
407
393
            return -1;
408
394
          a++; b++;
409
 
          swap_variables(unsigned char*, a, b);
 
395
          swap_variables(uchar*, a, b);
410
396
          swap_variables(int, alength, blength);
411
397
          swap_flag=1-swap_flag;
412
398
          alength--; blength--;
435
421
      }
436
422
 
437
423
      if (swap_flag)                            /* Restore pointers */
438
 
        swap_variables(unsigned char*, a, b);
 
424
        swap_variables(uchar*, a, b);
439
425
      break;
440
426
    }
441
427
    case HA_KEYTYPE_LONGLONG:
442
428
    {
443
 
      int64_t ll_a,ll_b;
 
429
      longlong ll_a,ll_b;
444
430
      ll_a= mi_sint8korr(a);
445
431
      ll_b= mi_sint8korr(b);
446
432
      if (piks && (flag = CMP_NUM(ll_a,ll_b)))
451
437
    }
452
438
    case HA_KEYTYPE_ULONGLONG:
453
439
    {
454
 
      uint64_t ll_a,ll_b;
 
440
      ulonglong ll_a,ll_b;
455
441
      ll_a= mi_uint8korr(a);
456
442
      ll_b= mi_uint8korr(b);
457
443
      if (piks && (flag = CMP_NUM(ll_a,ll_b)))
468
454
end:
469
455
  if (!(nextflag & SEARCH_FIND))
470
456
  {
471
 
    uint32_t i;
 
457
    uint i;
472
458
    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
473
459
      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
474
460
    flag=0;
511
497
    NULLs.
512
498
*/
513
499
 
514
 
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, unsigned char *a)
 
500
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a)
515
501
{
516
502
  for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
517
503
  {
518
 
    unsigned char *end;
 
504
    uchar *end;
519
505
    if (keyseg->null_bit)
520
506
    {
521
507
      if (!*a++)
570
556
      break;
571
557
    case HA_KEYTYPE_END:                        /* purecov: inspected */
572
558
      /* keep compiler happy */
573
 
      assert(0);
 
559
      DBUG_ASSERT(0);
574
560
      break;
575
561
    }
576
562
  }
595
581
    that every HA_ERR_xxx constant has a corresponding error message in
596
582
    handler_error_messages[] list (check mysys/ma_handler_errors.h and
597
583
    include/my_base.h).
598
 
 
599
 
    TODO: Remove fix the handler_error_messages so that this hack isn't 
600
 
          necessary.
601
584
  */
602
 
#ifdef __GNUC__
603
 
  char compile_time_assert[(HA_ERR_FIRST +
604
 
                            array_elements(handler_error_messages) ==
605
 
                            HA_ERR_LAST + 1) ? 1 : -1]
606
 
      __attribute__ ((__unused__));
607
 
#endif
 
585
  compile_time_assert(HA_ERR_FIRST + array_elements(handler_error_messages) ==
 
586
                      HA_ERR_LAST + 1);
608
587
  my_error_register(handler_error_messages, HA_ERR_FIRST,
609
588
                    HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
610
589
}