← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_handler.c

  • Committer: Monty Taylor
  • Date: 2008-09-15 17:24:04 UTC
  • Revision ID: monty@inaugust.com-20080915172404-ygh6hiyu0q7qpa9x
Removed strndup calls.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_handler.c
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#include <config.h>
 
1
/* Copyright (C) 2002-2006 MySQL AB
 
2
   
 
3
   This library is free software; you can redistribute it and/or
 
4
   modify it under the terms of the GNU Library General Public
 
5
   License as published by the Free Software Foundation; version 2
 
6
   of the License.
 
7
   
 
8
   This library is distributed in the hope that it will be useful,
 
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
11
   Library General Public License for more details.
 
12
 
 
13
   You should have received a copy of the GNU Library General Public
 
14
   License along with this library; if not, write to the Free
 
15
   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 
16
   MA 02111-1307, USA */
 
17
 
 
18
#include "mysys_priv.h"
21
19
 
22
20
#include <mystrings/m_ctype.h>
23
21
#include <drizzled/base.h>
24
 
#include <storage/myisam/my_handler.h>
25
 
#include <mysys/my_sys.h>
 
22
#include <my_handler.h>
 
23
#include <my_sys.h>
 
24
 
 
25
#include "my_handler_errors.h"
26
26
 
27
27
/**
28
28
  Swap the contents of two variables.
35
35
    b= dummy;                      \
36
36
  } while (0)
37
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,
 
38
int ha_compare_text(const CHARSET_INFO * const charset_info, uchar *a, uint a_length,
 
39
                    uchar *b, uint b_length, bool part_key,
43
40
                    bool skip_end_space)
44
41
{
45
42
  if (!part_key)
50
47
}
51
48
 
52
49
 
53
 
static int compare_bin(unsigned char *a, uint32_t a_length, unsigned char *b, uint32_t b_length,
 
50
static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
54
51
                       bool part_key, bool skip_end_space)
55
52
{
56
 
  uint32_t length= cmin(a_length,b_length);
57
 
  unsigned char *end= a+ length;
 
53
  uint length= min(a_length,b_length);
 
54
  uchar *end= a+ length;
58
55
  int flag;
59
56
 
60
57
  while (a < end)
133
130
 
134
131
#define FCMP(A,B) ((int) (A) - (int) (B))
135
132
 
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)
 
133
int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
 
134
               register uchar *b, uint key_length, uint nextflag,
 
135
               uint *diff_pos)
139
136
{
140
137
  int flag;
141
138
  int16_t s_1,s_2;
143
140
  uint32_t u_1,u_2;
144
141
  float f_1,f_2;
145
142
  double d_1,d_2;
146
 
  uint32_t next_key_length;
147
 
  unsigned char *orig_b= b;
 
143
  uint next_key_length;
 
144
  uchar *orig_b= b;
148
145
 
149
146
  *diff_pos=0;
150
147
  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
151
148
  {
152
 
    unsigned char *end;
153
 
    uint32_t piks=! (keyseg->flag & HA_NO_SORT);
 
149
    uchar *end;
 
150
    uint piks=! (keyseg->flag & HA_NO_SORT);
154
151
    (*diff_pos)++;
155
152
    diff_pos[1]= (uint)(b - orig_b);
156
153
 
181
178
        continue;                               /* To next key part */
182
179
      }
183
180
    }
184
 
    end= a+ cmin(keyseg->length,key_length);
 
181
    end= a+ min(keyseg->length,key_length);
185
182
    next_key_length=key_length-keyseg->length;
186
183
 
187
184
    switch ((enum ha_base_keytype) keyseg->type) {
205
202
      }
206
203
      else
207
204
      {
208
 
        uint32_t length=(uint) (end-a), a_length=length, b_length=length;
 
205
        uint length=(uint) (end-a), a_length=length, b_length=length;
209
206
        if (piks &&
210
207
            (flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
211
208
                                   (bool) ((nextflag & SEARCH_PREFIX) &&
236
233
      }
237
234
      else
238
235
      {
239
 
        uint32_t length=keyseg->length;
 
236
        uint length=keyseg->length;
240
237
        if (piks &&
241
238
            (flag=compare_bin(a,length,b,length,
242
239
                              (bool) ((nextflag & SEARCH_PREFIX) &&
381
378
 
382
379
      if (keyseg->flag & HA_REVERSE_SORT)
383
380
      {
384
 
        swap_variables(unsigned char*, a, b);
 
381
        swap_variables(uchar*, a, b);
385
382
        swap_flag=1;                            /* Remember swap of a & b */
386
383
        end= a+ (int) (end-b);
387
384
      }
406
403
          if (*b != '-')
407
404
            return -1;
408
405
          a++; b++;
409
 
          swap_variables(unsigned char*, a, b);
 
406
          swap_variables(uchar*, a, b);
410
407
          swap_variables(int, alength, blength);
411
408
          swap_flag=1-swap_flag;
412
409
          alength--; blength--;
435
432
      }
436
433
 
437
434
      if (swap_flag)                            /* Restore pointers */
438
 
        swap_variables(unsigned char*, a, b);
 
435
        swap_variables(uchar*, a, b);
439
436
      break;
440
437
    }
441
438
    case HA_KEYTYPE_LONGLONG:
468
465
end:
469
466
  if (!(nextflag & SEARCH_FIND))
470
467
  {
471
 
    uint32_t i;
 
468
    uint i;
472
469
    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
473
470
      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
474
471
    flag=0;
511
508
    NULLs.
512
509
*/
513
510
 
514
 
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, unsigned char *a)
 
511
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a)
515
512
{
516
513
  for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
517
514
  {
518
 
    unsigned char *end;
 
515
    uchar *end;
519
516
    if (keyseg->null_bit)
520
517
    {
521
518
      if (!*a++)
579
576
 
580
577
 
581
578
 
 
579
/*
 
580
  Register handler error messages for usage with my_error()
 
581
 
 
582
  NOTES
 
583
    This is safe to call multiple times as my_error_register()
 
584
    will ignore calls to register already registered error numbers.
 
585
*/
 
586
 
 
587
 
 
588
void my_handler_error_register(void)
 
589
{
 
590
  /*
 
591
    If you got compilation error here about compile_time_assert array, check
 
592
    that every HA_ERR_xxx constant has a corresponding error message in
 
593
    handler_error_messages[] list (check mysys/ma_handler_errors.h and
 
594
    include/my_base.h).
 
595
  */
 
596
  compile_time_assert(HA_ERR_FIRST + array_elements(handler_error_messages) ==
 
597
                      HA_ERR_LAST + 1);
 
598
  my_error_register(handler_error_messages, HA_ERR_FIRST,
 
599
                    HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
 
600
}
 
601
 
 
602
 
 
603
void my_handler_error_unregister(void)
 
604
{
 
605
  my_error_unregister(HA_ERR_FIRST,
 
606
                      HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
 
607
}