← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/strfunc.cc

Refactor Typelib

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/strfunc.cc
20
20
#include <drizzled/charset_info.h>
21
21
#include <drizzled/global_charset_info.h>
22
22
 
23
 
namespace drizzled
24
 
{
25
 
 
26
 
/*
27
 
  Return bitmap for strings used in a set
28
 
 
29
 
  SYNOPSIS
30
 
  find_set()
31
 
  lib                   Strings in set
32
 
  str                   Strings of set-strings separated by ','
33
 
  err_pos               If error, set to point to start of wrong set string
34
 
  err_len               If error, set to the length of wrong set string
35
 
  set_warning           Set to 1 if some string in set couldn't be used
36
 
 
37
 
  NOTE
38
 
    We delete all end space from str before comparison
39
 
 
40
 
  RETURN
41
 
    bitmap of all sets found in x.
42
 
    set_warning is set to 1 if there was any sets that couldn't be set
43
 
*/
44
 
 
45
 
static const char field_separator=',';
46
 
 
47
 
uint64_t TYPELIB::find_set(const char *str, uint32_t length,
48
 
                  const charset_info_st * const cs,
49
 
                  char **err_pos, uint32_t *err_len, bool *set_warning) const
50
 
{
51
 
  const charset_info_st * const strip= cs ? cs : &my_charset_utf8_general_ci;
52
 
  const char *end= str + strip->cset->lengthsp(strip, str, length);
53
 
  uint64_t found= 0;
54
 
  *err_pos= 0;                  // No error yet
55
 
  if (str != end)
56
 
  {
57
 
    const char *start= str;
58
 
    for (;;)
59
 
    {
60
 
      const char *pos= start;
61
 
      uint32_t var_len;
62
 
      int mblen= 1;
63
 
 
64
 
      for (; pos != end && *pos != field_separator; pos++) 
65
 
      {}
66
 
      var_len= (uint32_t) (pos - start);
67
 
      uint32_t find= cs ? find_type2(start, var_len, cs) : find_type(start, var_len, false);
68
 
      if (!find)
69
 
      {
70
 
        *err_pos= (char*) start;
71
 
        *err_len= var_len;
72
 
        *set_warning= 1;
73
 
      }
74
 
      else
75
 
        found|= ((int64_t) 1 << (find - 1));
76
 
      if (pos >= end)
77
 
        break;
78
 
      start= pos + mblen;
79
 
    }
80
 
  }
81
 
  return found;
82
 
}
83
 
 
 
23
namespace drizzled {
84
24
 
85
25
/*
86
26
  Function to find a string in a TYPELIB
101
41
uint32_t TYPELIB::find_type(const char *find, uint32_t length, bool part_match) const
102
42
{
103
43
  uint32_t found_count=0, found_pos=0;
104
 
  const char *end= find+length;
105
 
  const char *i;
106
 
  const char *j;
 
44
  const char* end= find + length;
 
45
  const char* i;
 
46
  const char* j;
107
47
  for (uint32_t pos= 0 ; (j= type_names[pos++]) ; )
108
48
  {
109
 
    for (i=find ; i != end &&
110
 
           my_toupper(system_charset_info,*i) ==
111
 
           my_toupper(system_charset_info,*j) ; i++, j++) ;
 
49
    for (i= find ; i != end && my_toupper(system_charset_info, *i) == my_toupper(system_charset_info, *j); i++, j++) 
 
50
    {
 
51
    }
112
52
    if (i == end)
113
53
    {
114
 
      if (! *j)
115
 
        return(pos);
 
54
      if (not *j)
 
55
        return pos;
116
56
      found_count++;
117
57
      found_pos= pos;
118
58
    }
119
59
  }
120
 
  return(found_count == 1 && part_match ? found_pos : 0);
 
60
  return found_count == 1 && part_match ? found_pos : 0;
121
61
}
122
62
 
123
63