← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/blob.h

Merge of Jay

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/blob.h
1
 
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
1
/* - mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2008 MySQL
21
21
#ifndef DRIZZLE_SERVER_FIELD_BLOB
22
22
#define DRIZZLE_SERVER_FIELD_BLOB
23
23
 
24
 
class Field_blob :public Field_longstr {
 
24
#include <drizzled/field/str.h>
 
25
 
 
26
#include <string>
 
27
 
 
28
/**
 
29
 * Class representing a BLOB data type column
 
30
 */
 
31
class Field_blob :public Field_str {
25
32
protected:
26
 
  uint packlength;
 
33
  uint32_t packlength;
27
34
  String value;                         // For temporaries
28
35
public:
29
 
  Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
 
36
 
 
37
  using Field::store;
 
38
  using Field::cmp;
 
39
  using Field::pack;
 
40
  using Field::unpack;
 
41
  using Field::val_int;
 
42
  using Field::val_str;
 
43
 
 
44
 
 
45
  Field_blob(unsigned char *ptr_arg, unsigned char *null_ptr_arg, unsigned char null_bit_arg,
30
46
             enum utype unireg_check_arg, const char *field_name_arg,
31
 
             TABLE_SHARE *share, uint blob_pack_length, const CHARSET_INFO * const cs);
32
 
  Field_blob(uint32_t len_arg,bool maybe_null_arg, const char *field_name_arg,
 
47
             TableShare *share, uint32_t blob_pack_length, const CHARSET_INFO * const cs);
 
48
  Field_blob(uint32_t len_arg, bool maybe_null_arg, const char *field_name_arg,
33
49
             const CHARSET_INFO * const cs)
34
 
    :Field_longstr((uchar*) 0, len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
 
50
    :Field_str((unsigned char*) 0, len_arg, maybe_null_arg ? (unsigned char*) "": 0, 0,
35
51
                   NONE, field_name_arg, cs),
36
52
    packlength(4)
37
53
  {
38
54
    flags|= BLOB_FLAG;
39
55
  }
40
 
  Field_blob(uint32_t len_arg,bool maybe_null_arg, const char *field_name_arg,
 
56
  Field_blob(uint32_t len_arg, bool maybe_null_arg, const char *field_name_arg,
41
57
             const CHARSET_INFO * const cs, bool set_packlength)
42
 
    :Field_longstr((uchar*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0, 0,
 
58
    :Field_str((unsigned char*) 0,len_arg, maybe_null_arg ? (unsigned char*) "": 0, 0,
43
59
                   NONE, field_name_arg, cs)
44
60
  {
45
61
    flags|= BLOB_FLAG;
53
69
    }
54
70
  }
55
71
  Field_blob(uint32_t packlength_arg)
56
 
    :Field_longstr((uchar*) 0, 0, (uchar*) "", 0, NONE, "temp", system_charset_info),
 
72
    :Field_str((unsigned char*) 0, 0, (unsigned char*) "", 0, NONE, "temp", system_charset_info),
57
73
    packlength(packlength_arg) {}
58
74
  enum_field_types type() const { return DRIZZLE_TYPE_BLOB;}
59
75
  enum ha_base_keytype key_type() const
60
76
    { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; }
61
 
  int  store(const char *to,uint length, const CHARSET_INFO * const charset);
 
77
  int  store(const char *to,uint32_t length,
 
78
             const CHARSET_INFO * const charset);
62
79
  int  store(double nr);
63
80
  int  store(int64_t nr, bool unsigned_val);
 
81
 
64
82
  double val_real(void);
65
83
  int64_t val_int(void);
66
84
  String *val_str(String*,String *);
67
85
  my_decimal *val_decimal(my_decimal *);
68
 
  int cmp_max(const uchar *, const uchar *, uint max_length);
69
 
  int cmp(const uchar *a,const uchar *b)
70
 
    { return cmp_max(a, b, ~0L); }
71
 
  int cmp(const uchar *a, uint32_t a_length, const uchar *b, uint32_t b_length);
72
 
  int cmp_binary(const uchar *a,const uchar *b, uint32_t max_length=~0L);
73
 
  int key_cmp(const uchar *,const uchar*);
74
 
  int key_cmp(const uchar *str, uint length);
 
86
  int cmp_max(const unsigned char *, const unsigned char *, uint32_t max_length);
 
87
  int cmp(const unsigned char *a,const unsigned char *b)
 
88
    { return cmp_max(a, b, UINT32_MAX); }
 
89
  int cmp(const unsigned char *a, uint32_t a_length, const unsigned char *b, uint32_t b_length);
 
90
  int cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t max_length=UINT32_MAX);
 
91
  int key_cmp(const unsigned char *,const unsigned char*);
 
92
  int key_cmp(const unsigned char *str, uint32_t length);
75
93
  uint32_t key_length() const { return 0; }
76
 
  void sort_string(uchar *buff,uint length);
77
 
  uint32_t pack_length() const
78
 
  { return (uint32_t) (packlength+table->s->blob_ptr_size); }
 
94
  void sort_string(unsigned char *buff,uint32_t length);
 
95
  uint32_t pack_length() const;
 
96
 
79
97
 
80
98
  /**
81
 
     Return the packed length without the pointer size added. 
 
99
     Return the packed length without the pointer size added.
82
100
 
83
101
     This is used to determine the size of the actual data in the row
84
102
     buffer.
87
105
  */
88
106
  uint32_t pack_length_no_ptr() const
89
107
  { return (uint32_t) (packlength); }
90
 
  uint row_pack_length() { return pack_length_no_ptr(); }
 
108
  uint32_t row_pack_length() { return pack_length_no_ptr(); }
91
109
  uint32_t sort_length() const;
92
110
  virtual uint32_t max_data_length() const
93
111
  {
94
112
    return (uint32_t) (((uint64_t) 1 << (packlength*8)) -1);
95
113
  }
96
 
  int reset(void) { memset(ptr, 0, packlength+sizeof(uchar*)); return 0; }
 
114
  int reset(void) { memset(ptr, 0, packlength+sizeof(unsigned char*)); return 0; }
97
115
  void reset_fields() { memset(&value, 0, sizeof(value)); }
98
116
#ifndef WORDS_BIGENDIAN
99
117
  static
100
118
#endif
101
 
  void store_length(uchar *i_ptr, uint i_packlength, uint32_t i_number, bool low_byte_first);
102
 
  void store_length(uchar *i_ptr, uint i_packlength, uint32_t i_number)
103
 
  {
104
 
    store_length(i_ptr, i_packlength, i_number, table->s->db_low_byte_first);
105
 
  }
 
119
  void store_length(unsigned char *i_ptr, uint32_t i_packlength,
 
120
                    uint32_t i_number, bool low_byte_first);
 
121
  void store_length(unsigned char *i_ptr, uint32_t i_packlength,
 
122
                    uint32_t i_number);
 
123
 
106
124
  inline void store_length(uint32_t number)
107
125
  {
108
126
    store_length(ptr, packlength, number);
109
127
  }
110
128
 
111
129
  /**
112
 
     Return the packed length plus the length of the data. 
 
130
     Return the packed length plus the length of the data.
113
131
 
114
 
     This is used to determine the size of the data plus the 
 
132
     This is used to determine the size of the data plus the
115
133
     packed length portion in the row data.
116
134
 
117
135
     @returns The length in the row plus the size of the data.
118
136
  */
119
 
  uint32_t get_packed_size(const uchar *ptr_arg, bool low_byte_first)
120
 
    {return packlength + get_length(ptr_arg, packlength, low_byte_first);}
 
137
  uint32_t get_packed_size(const unsigned char *ptr_arg, bool low_byte_first);
121
138
 
122
 
  inline uint32_t get_length(uint row_offset= 0)
123
 
  { return get_length(ptr+row_offset, this->packlength, table->s->db_low_byte_first); }
124
 
  uint32_t get_length(const uchar *ptr, uint packlength, bool low_byte_first);
125
 
  uint32_t get_length(const uchar *ptr_arg)
126
 
  { return get_length(ptr_arg, this->packlength, table->s->db_low_byte_first); }
127
 
  void put_length(uchar *pos, uint32_t length);
128
 
  inline void get_ptr(uchar **str)
 
139
  uint32_t get_length(uint32_t row_offset= 0);
 
140
  uint32_t get_length(const unsigned char *ptr, uint32_t packlength,
 
141
                      bool low_byte_first);
 
142
  uint32_t get_length(const unsigned char *ptr_arg);
 
143
  void put_length(unsigned char *pos, uint32_t length);
 
144
  inline void get_ptr(unsigned char **str)
129
145
    {
130
 
      memcpy(str,ptr+packlength,sizeof(uchar*));
 
146
      memcpy(str,ptr+packlength,sizeof(unsigned char*));
131
147
    }
132
 
  inline void get_ptr(uchar **str, uint row_offset)
 
148
  inline void get_ptr(unsigned char **str, uint32_t row_offset)
133
149
    {
134
150
      memcpy(str,ptr+packlength+row_offset,sizeof(char*));
135
151
    }
136
 
  inline void set_ptr(uchar *length, uchar *data)
 
152
  inline void set_ptr(unsigned char *length, unsigned char *data)
137
153
    {
138
154
      memcpy(ptr,length,packlength);
139
155
      memcpy(ptr+packlength,&data,sizeof(char*));
140
156
    }
141
 
  void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32_t length, uchar *data)
 
157
  void set_ptr_offset(my_ptrdiff_t ptr_diff, uint32_t length, unsigned char *data)
142
158
    {
143
 
      uchar *ptr_ofs= ADD_TO_PTR(ptr,ptr_diff,uchar*);
 
159
      unsigned char *ptr_ofs= ADD_TO_PTR(ptr,ptr_diff,unsigned char*);
144
160
      store_length(ptr_ofs, packlength, length);
145
161
      memcpy(ptr_ofs+packlength,&data,sizeof(char*));
146
162
    }
147
 
  inline void set_ptr(uint32_t length, uchar *data)
 
163
  inline void set_ptr(uint32_t length, unsigned char *data)
148
164
    {
149
165
      set_ptr_offset(0, length, data);
150
166
    }
151
 
  uint get_key_image(uchar *buff,uint length, imagetype type);
152
 
  void set_key_image(const uchar *buff,uint length);
 
167
  uint32_t get_key_image(unsigned char *buff,uint32_t length);
 
168
  uint32_t get_key_image(std::basic_string<unsigned char> &buff, uint32_t length);
 
169
  void set_key_image(const unsigned char *buff,uint32_t length);
153
170
  void sql_type(String &str) const;
154
171
  inline bool copy()
155
172
  {
156
 
    uchar *tmp;
 
173
    unsigned char *tmp;
157
174
    get_ptr(&tmp);
158
175
    if (value.copy((char*) tmp, get_length(), charset()))
159
176
    {
160
177
      Field_blob::reset();
161
178
      return 1;
162
179
    }
163
 
    tmp=(uchar*) value.ptr();
 
180
    tmp=(unsigned char*) value.ptr();
164
181
    memcpy(ptr+packlength,&tmp,sizeof(char*));
165
182
    return 0;
166
183
  }
167
 
  virtual uchar *pack(uchar *to, const uchar *from,
168
 
                      uint max_length, bool low_byte_first);
169
 
  uchar *pack_key(uchar *to, const uchar *from,
170
 
                  uint max_length, bool low_byte_first);
171
 
  uchar *pack_key_from_key_image(uchar* to, const uchar *from,
172
 
                                 uint max_length, bool low_byte_first);
173
 
  virtual const uchar *unpack(uchar *to, const uchar *from,
174
 
                              uint param_data, bool low_byte_first);
175
 
  const uchar *unpack_key(uchar* to, const uchar *from,
176
 
                          uint max_length, bool low_byte_first);
177
 
  int pack_cmp(const uchar *a, const uchar *b, uint key_length,
178
 
               bool insert_or_update);
179
 
  int pack_cmp(const uchar *b, uint key_length,bool insert_or_update);
180
 
  uint packed_col_length(const uchar *col_ptr, uint length);
181
 
  uint max_packed_col_length(uint max_length);
 
184
  virtual unsigned char *pack(unsigned char *to, const unsigned char *from,
 
185
                      uint32_t max_length, bool low_byte_first);
 
186
  unsigned char *pack_key(unsigned char *to, const unsigned char *from,
 
187
                  uint32_t max_length, bool low_byte_first);
 
188
  virtual const unsigned char *unpack(unsigned char *to, const unsigned char *from,
 
189
                              uint32_t param_data, bool low_byte_first);
182
190
  void free() { value.free(); }
183
191
  inline void clear_temporary() { memset(&value, 0, sizeof(value)); }
184
192
  friend int field_conv(Field *to,Field *from);
185
 
  uint size_of() const { return sizeof(*this); }
 
193
  uint32_t size_of() const { return sizeof(*this); }
186
194
  bool has_charset(void) const
187
195
  { return charset() == &my_charset_bin ? false : true; }
188
196
  uint32_t max_display_length();
189
 
  uint is_equal(Create_field *new_field);
190
 
  inline bool in_read_set() { return bitmap_is_set(table->read_set, field_index); }
191
 
  inline bool in_write_set() { return bitmap_is_set(table->write_set, field_index); }
 
197
  uint32_t is_equal(CreateField *new_field);
 
198
 
192
199
private:
193
 
  int do_save_field_metadata(uchar *first_byte);
 
200
  int do_save_field_metadata(unsigned char *first_byte);
194
201
};
195
202
 
196
203
#endif