← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/stored_key.h

  • Committer: Brian Aker
  • Date: 2009-02-21 00:18:15 UTC
  • Revision ID: brian@tangent.org-20090221001815-x20e8h71e984lvs1
Completion (?) of uint conversion.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/stored_key.h
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
 
#ifndef DRIZZLED_STORED_KEY_H
21
 
#define DRIZZLED_STORED_KEY_H
22
 
 
23
 
namespace drizzled
24
 
{
25
 
 
26
 
/** class to store an field/item as a key struct */
27
 
class StoredKey :public memory::SqlAlloc
28
 
{
29
 
public:
30
 
  bool null_key; /**< If true, the value of the key has a null part */
31
 
  enum store_key_result 
32
 
  { 
33
 
    STORE_KEY_OK,
34
 
    STORE_KEY_FATAL, 
35
 
    STORE_KEY_CONV 
36
 
  };
37
 
protected:
38
 
  Field *to_field;                              // Store data here
39
 
  unsigned char *null_ptr;
40
 
  unsigned char err;
41
 
  virtual enum store_key_result copy_inner()=0;
42
 
public:
43
 
  StoredKey(Session *session,
44
 
            Field *field_arg, 
45
 
            unsigned char *ptr,
46
 
            unsigned char *null, 
47
 
            uint32_t length)
48
 
    :
49
 
      null_key(0), 
50
 
      null_ptr(null), 
51
 
      err(0)
52
 
  {
53
 
    if (field_arg->type() == DRIZZLE_TYPE_BLOB)
54
 
    {
55
 
      /*
56
 
        Key segments are always packed with a 2 byte length prefix.
57
 
        See mi_rkey for details.
58
 
      */
59
 
      to_field= new Field_varstring(ptr,
60
 
                                    length,
61
 
                                    2,
62
 
                                    null,
63
 
                                    1,
64
 
                                    field_arg->field_name,
65
 
                                    field_arg->charset());
66
 
      to_field->init(field_arg->getTable());
67
 
    }
68
 
    else
69
 
      to_field= field_arg->new_key_field(session->mem_root, field_arg->getTable(),
70
 
                                        ptr, null, 1);
71
 
 
72
 
    to_field->setWriteSet();
73
 
  }
74
 
  virtual ~StoredKey() {}                       /** Not actually needed */
75
 
  virtual const char *name() const=0;
76
 
 
77
 
  /**
78
 
    @brief sets ignore truncation warnings mode and calls the real copy method
79
 
 
80
 
    @details this function makes sure truncation warnings when preparing the
81
 
    key buffers don't end up as errors (because of an enclosing INSERT/UPDATE).
82
 
  */
83
 
  enum store_key_result copy()
84
 
  {
85
 
    enum store_key_result result;
86
 
    Session *session= to_field->getTable()->in_use;
87
 
    enum_check_fields saved_count_cuted_fields= session->count_cuted_fields;
88
 
    session->count_cuted_fields= CHECK_FIELD_IGNORE;
89
 
    result= copy_inner();
90
 
    session->count_cuted_fields= saved_count_cuted_fields;
91
 
 
92
 
    return result;
93
 
  }
94
 
};
95
 
 
96
 
class store_key_field: public StoredKey
97
 
{
98
 
  CopyField copy_field;
99
 
  const char *field_name;
100
 
public:
101
 
  store_key_field(Session *session, Field *to_field_arg, unsigned char *ptr,
102
 
                  unsigned char *null_ptr_arg,
103
 
                  uint32_t length, Field *from_field, const char *name_arg)
104
 
    :StoredKey(session, to_field_arg,ptr,
105
 
               null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
106
 
               : (unsigned char*) 0, length), field_name(name_arg)
107
 
  {
108
 
    if (to_field)
109
 
    {
110
 
      copy_field.set(to_field,from_field,0);
111
 
    }
112
 
  }
113
 
  const char *name() const { return field_name; }
114
 
 
115
 
protected:
116
 
  enum store_key_result copy_inner()
117
 
  {
118
 
    copy_field.do_copy(&copy_field);
119
 
    null_key= to_field->is_null();
120
 
    return err != 0 ? STORE_KEY_FATAL : STORE_KEY_OK;
121
 
  }
122
 
};
123
 
 
124
 
class store_key_item :public StoredKey
125
 
{
126
 
 protected:
127
 
  Item *item;
128
 
public:
129
 
  store_key_item(Session *session, Field *to_field_arg, unsigned char *ptr,
130
 
                 unsigned char *null_ptr_arg, uint32_t length, Item *item_arg)
131
 
    :StoredKey(session, to_field_arg, ptr,
132
 
               null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
133
 
               &err : (unsigned char*) 0, length), item(item_arg)
134
 
  {}
135
 
  const char *name() const { return "func"; }
136
 
 
137
 
 protected:
138
 
  enum store_key_result copy_inner()
139
 
  {
140
 
    int res= item->save_in_field(to_field, 1);
141
 
    null_key= to_field->is_null() || item->null_value;
142
 
    return (err != 0 || res > 2 ? STORE_KEY_FATAL : (store_key_result) res);
143
 
  }
144
 
};
145
 
 
146
 
class store_key_const_item :public store_key_item
147
 
{
148
 
  bool inited;
149
 
public:
150
 
  store_key_const_item(Session *session, Field *to_field_arg, unsigned char *ptr,
151
 
                       unsigned char *null_ptr_arg, uint32_t length,
152
 
                       Item *item_arg)
153
 
    :store_key_item(session, to_field_arg,ptr,
154
 
                    null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
155
 
                    &err : (unsigned char*) 0, length, item_arg), inited(0)
156
 
  {
157
 
  }
158
 
  const char *name() const { return "const"; }
159
 
 
160
 
protected:
161
 
  enum store_key_result copy_inner()
162
 
  {
163
 
    int res;
164
 
    if (!inited)
165
 
    {
166
 
      inited=1;
167
 
      if ((res= item->save_in_field(to_field, 1)))
168
 
      {
169
 
        if (!err)
170
 
          err= res;
171
 
      }
172
 
    }
173
 
    null_key= to_field->is_null() || item->null_value;
174
 
    return (err > 2 ?  STORE_KEY_FATAL : (store_key_result) err);
175
 
  }
176
 
};
177
 
 
178
 
} /* namespace drizzled */
179
 
 
180
 
#endif /* DRIZZLED_STORED_KEY_H */