← 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: 2011-02-12 10:06:03 UTC
  • mfrom: (2154.2.16 drizzle-build)
  • Revision ID: brian@tangent.org-20110212100603-i5ww0s02p8l4a8q7
Merge in solaris tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/stored_key.h
20
20
#ifndef DRIZZLED_STORED_KEY_H
21
21
#define DRIZZLED_STORED_KEY_H
22
22
 
 
23
#include <drizzled/memory/sql_alloc.h>
 
24
#include <drizzled/copy_field.h>
 
25
 
23
26
namespace drizzled
24
27
{
25
28
 
 
29
class Field;
 
30
class Session;
 
31
class Item;
 
32
 
26
33
/** class to store an field/item as a key struct */
27
34
class StoredKey :public memory::SqlAlloc
28
35
{
34
41
    STORE_KEY_FATAL, 
35
42
    STORE_KEY_CONV 
36
43
  };
 
44
 
37
45
protected:
38
46
  Field *to_field;                              // Store data here
39
47
  unsigned char *null_ptr;
40
48
  unsigned char err;
41
49
  virtual enum store_key_result copy_inner()=0;
 
50
 
42
51
public:
43
52
  StoredKey(Session *session,
44
53
            Field *field_arg, 
45
54
            unsigned char *ptr,
46
55
            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);
 
56
            uint32_t length);
71
57
 
72
 
    to_field->setWriteSet();
73
 
  }
74
58
  virtual ~StoredKey() {}                       /** Not actually needed */
75
59
  virtual const char *name() const=0;
76
60
 
80
64
    @details this function makes sure truncation warnings when preparing the
81
65
    key buffers don't end up as errors (because of an enclosing INSERT/UPDATE).
82
66
  */
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;
 
67
  enum store_key_result copy();
91
68
 
92
 
    return result;
93
 
  }
94
69
};
95
70
 
96
71
class store_key_field: public StoredKey
97
72
{
98
73
  CopyField copy_field;
99
74
  const char *field_name;
 
75
 
100
76
public:
101
77
  store_key_field(Session *session, Field *to_field_arg, unsigned char *ptr,
102
78
                  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
 
  {
 
79
                  uint32_t length, Field *from_field, const char *name_arg) :
 
80
    StoredKey(session, to_field_arg,ptr,
 
81
              null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
 
82
              : (unsigned char*) 0, length), field_name(name_arg)
 
83
    {
108
84
    if (to_field)
109
85
    {
110
86
      copy_field.set(to_field,from_field,0);
123
99
 
124
100
class store_key_item :public StoredKey
125
101
{
126
 
 protected:
 
102
protected:
127
103
  Item *item;
 
104
 
128
105
public:
129
106
  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,
 
107
                 unsigned char *null_ptr_arg, uint32_t length, Item *item_arg) :
 
108
    StoredKey(session, to_field_arg, ptr,
132
109
               null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
133
110
               &err : (unsigned char*) 0, length), item(item_arg)
134
111
  {}
146
123
class store_key_const_item :public store_key_item
147
124
{
148
125
  bool inited;
 
126
 
149
127
public:
150
128
  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)
 
129
                       unsigned char *null_ptr_arg, uint32_t length,
 
130
                       Item *item_arg) :
 
131
    store_key_item(session, to_field_arg,ptr,
 
132
                   null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
 
133
                   &err : (unsigned char*) 0, length, item_arg), inited(0)
156
134
  {
157
135
  }
158
136
  const char *name() const { return "const"; }