← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_handler.c

Put errmsg.c in sql-common since it can be built only once and used twice.
Put client.c and net_serv.c in libmysql so that we can only have one
link_sources section. 
Got rid of just about all copying and other weirdness, other than some stuff
in client and client.c/net_serv.c, which need to be reworked.

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
 
25
24
#include "my_handler_errors.h"
26
25
 
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)
 
26
int ha_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
 
27
                    uchar *b, uint b_length, my_bool part_key,
 
28
                    my_bool skip_end_space)
44
29
{
45
30
  if (!part_key)
46
31
    return charset_info->coll->strnncollsp(charset_info, a, a_length,
47
 
                                           b, b_length, (bool)!skip_end_space);
 
32
                                           b, b_length, (my_bool)!skip_end_space);
48
33
  return charset_info->coll->strnncoll(charset_info, a, a_length,
49
34
                                       b, b_length, part_key);
50
35
}
51
36
 
52
37
 
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)
 
38
static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
 
39
                       my_bool part_key, my_bool skip_end_space)
55
40
{
56
 
  uint32_t length= cmin(a_length,b_length);
57
 
  unsigned char *end= a+ length;
 
41
  uint length= min(a_length,b_length);
 
42
  uchar *end= a+ length;
58
43
  int flag;
59
44
 
60
45
  while (a < end)
133
118
 
134
119
#define FCMP(A,B) ((int) (A) - (int) (B))
135
120
 
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)
 
121
int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 
122
               register uchar *b, uint key_length, uint nextflag,
 
123
               uint *diff_pos)
139
124
{
140
125
  int flag;
141
 
  int16_t s_1,s_2;
142
 
  int32_t l_1,l_2;
143
 
  uint32_t u_1,u_2;
 
126
  int16 s_1,s_2;
 
127
  int32 l_1,l_2;
 
128
  uint32 u_1,u_2;
144
129
  float f_1,f_2;
145
130
  double d_1,d_2;
146
 
  uint32_t next_key_length;
147
 
  unsigned char *orig_b= b;
 
131
  uint next_key_length;
 
132
  uchar *orig_b= b;
148
133
 
149
134
  *diff_pos=0;
150
135
  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
151
136
  {
152
 
    unsigned char *end;
153
 
    uint32_t piks=! (keyseg->flag & HA_NO_SORT);
 
137
    uchar *end;
 
138
    uint piks=! (keyseg->flag & HA_NO_SORT);
154
139
    (*diff_pos)++;
155
140
    diff_pos[1]= (uint)(b - orig_b);
156
141
 
181
166
        continue;                               /* To next key part */
182
167
      }
183
168
    }
184
 
    end= a+ cmin(keyseg->length,key_length);
 
169
    end= a+ min(keyseg->length,key_length);
185
170
    next_key_length=key_length-keyseg->length;
186
171
 
187
172
    switch ((enum ha_base_keytype) keyseg->type) {
195
180
 
196
181
        if (piks &&
197
182
            (flag=ha_compare_text(keyseg->charset,a,a_length,b,b_length,
198
 
                                  (bool) ((nextflag & SEARCH_PREFIX) &&
 
183
                                  (my_bool) ((nextflag & SEARCH_PREFIX) &&
199
184
                                             next_key_length <= 0),
200
 
                                  (bool)!(nextflag & SEARCH_PREFIX))))
 
185
                                  (my_bool)!(nextflag & SEARCH_PREFIX))))
201
186
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
202
187
        a+=a_length;
203
188
        b+=b_length;
205
190
      }
206
191
      else
207
192
      {
208
 
        uint32_t length=(uint) (end-a), a_length=length, b_length=length;
 
193
        uint length=(uint) (end-a), a_length=length, b_length=length;
209
194
        if (piks &&
210
195
            (flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
211
 
                                   (bool) ((nextflag & SEARCH_PREFIX) &&
 
196
                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
212
197
                                              next_key_length <= 0),
213
 
                                   (bool)!(nextflag & SEARCH_PREFIX))))
 
198
                                   (my_bool)!(nextflag & SEARCH_PREFIX))))
214
199
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
215
200
        a=end;
216
201
        b+=length;
227
212
 
228
213
        if (piks &&
229
214
            (flag=compare_bin(a,a_length,b,b_length,
230
 
                              (bool) ((nextflag & SEARCH_PREFIX) &&
 
215
                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
231
216
                                         next_key_length <= 0),1)))
232
217
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
233
218
        a+=a_length;
236
221
      }
237
222
      else
238
223
      {
239
 
        uint32_t length=keyseg->length;
 
224
        uint length=keyseg->length;
240
225
        if (piks &&
241
226
            (flag=compare_bin(a,length,b,length,
242
 
                              (bool) ((nextflag & SEARCH_PREFIX) &&
 
227
                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
243
228
                                         next_key_length <= 0),0)))
244
229
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
245
230
        a+=length;
256
241
 
257
242
        if (piks &&
258
243
            (flag= ha_compare_text(keyseg->charset,a,a_length,b,b_length,
259
 
                                   (bool) ((nextflag & SEARCH_PREFIX) &&
 
244
                                   (my_bool) ((nextflag & SEARCH_PREFIX) &&
260
245
                                              next_key_length <= 0),
261
 
                                   (bool) ((nextflag & (SEARCH_FIND |
 
246
                                   (my_bool) ((nextflag & (SEARCH_FIND |
262
247
                                                           SEARCH_UPDATE)) ==
263
248
                                              SEARCH_FIND &&
264
249
                                              ! (keyseg->flag &
279
264
 
280
265
        if (piks &&
281
266
            (flag=compare_bin(a,a_length,b,b_length,
282
 
                              (bool) ((nextflag & SEARCH_PREFIX) &&
 
267
                              (my_bool) ((nextflag & SEARCH_PREFIX) &&
283
268
                                         next_key_length <= 0), 0)))
284
269
          return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
285
270
        a+=a_length;
307
292
      break;
308
293
    case HA_KEYTYPE_USHORT_INT:
309
294
      {
310
 
        uint16_t us_1,us_2;
 
295
        uint16 us_1,us_2;
311
296
        us_1= mi_sint2korr(a);
312
297
        us_2= mi_sint2korr(b);
313
298
        if (piks && (flag = CMP_NUM(us_1,us_2)))
381
366
 
382
367
      if (keyseg->flag & HA_REVERSE_SORT)
383
368
      {
384
 
        swap_variables(unsigned char*, a, b);
 
369
        swap_variables(uchar*, a, b);
385
370
        swap_flag=1;                            /* Remember swap of a & b */
386
371
        end= a+ (int) (end-b);
387
372
      }
406
391
          if (*b != '-')
407
392
            return -1;
408
393
          a++; b++;
409
 
          swap_variables(unsigned char*, a, b);
 
394
          swap_variables(uchar*, a, b);
410
395
          swap_variables(int, alength, blength);
411
396
          swap_flag=1-swap_flag;
412
397
          alength--; blength--;
435
420
      }
436
421
 
437
422
      if (swap_flag)                            /* Restore pointers */
438
 
        swap_variables(unsigned char*, a, b);
 
423
        swap_variables(uchar*, a, b);
439
424
      break;
440
425
    }
 
426
#ifdef HAVE_LONG_LONG
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)))
460
446
      b+= 8;
461
447
      break;
462
448
    }
 
449
#endif
463
450
    case HA_KEYTYPE_END:                        /* Ready */
464
451
      goto end;                                 /* diff_pos is incremented */
465
452
    }
468
455
end:
469
456
  if (!(nextflag & SEARCH_FIND))
470
457
  {
471
 
    uint32_t i;
 
458
    uint i;
472
459
    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
473
460
      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
474
461
    flag=0;
511
498
    NULLs.
512
499
*/
513
500
 
514
 
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, unsigned char *a)
 
501
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a)
515
502
{
516
503
  for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
517
504
  {
518
 
    unsigned char *end;
 
505
    uchar *end;
519
506
    if (keyseg->null_bit)
520
507
    {
521
508
      if (!*a++)
562
549
    case HA_KEYTYPE_ULONG_INT:
563
550
    case HA_KEYTYPE_INT24:
564
551
    case HA_KEYTYPE_UINT24:
 
552
#ifdef HAVE_LONG_LONG
565
553
    case HA_KEYTYPE_LONGLONG:
566
554
    case HA_KEYTYPE_ULONGLONG:
 
555
#endif
567
556
    case HA_KEYTYPE_FLOAT:
568
557
    case HA_KEYTYPE_DOUBLE:
569
558
      a= end;
570
559
      break;
571
560
    case HA_KEYTYPE_END:                        /* purecov: inspected */
572
561
      /* keep compiler happy */
573
 
      assert(0);
 
562
      DBUG_ASSERT(0);
574
563
      break;
575
564
    }
576
565
  }
595
584
    that every HA_ERR_xxx constant has a corresponding error message in
596
585
    handler_error_messages[] list (check mysys/ma_handler_errors.h and
597
586
    include/my_base.h).
598
 
 
599
 
    TODO: Remove fix the handler_error_messages so that this hack isn't 
600
 
          necessary.
601
587
  */
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
 
588
  compile_time_assert(HA_ERR_FIRST + array_elements(handler_error_messages) ==
 
589
                      HA_ERR_LAST + 1);
608
590
  my_error_register(handler_error_messages, HA_ERR_FIRST,
609
591
                    HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
610
592
}