← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.h

  • Committer: Brian Aker
  • Date: 2010-10-20 20:26:18 UTC
  • mfrom: (1859.2.13 refactor)
  • Revision ID: brian@tangent.org-20101020202618-9222n39lm329urv5
Merge for Brian 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
22
22
  variables must declare the size_of() member function.
23
23
*/
24
24
 
25
 
 
26
 
 
27
25
#ifndef DRIZZLED_FIELD_H
28
26
#define DRIZZLED_FIELD_H
29
27
 
30
28
#include "drizzled/sql_error.h"
31
 
#include "drizzled/type/decimal.h"
 
29
#include "drizzled/decimal.h"
32
30
#include "drizzled/key_map.h"
33
31
#include "drizzled/sql_list.h"
34
32
#include "drizzled/structs.h"
35
33
#include "drizzled/charset_info.h"
36
34
#include "drizzled/item_result.h"
37
 
#include "drizzled/charset_info.h"
38
35
 
39
36
#include <string>
40
37
#include <vector>
41
38
 
42
 
#include "drizzled/visibility.h"
43
 
 
44
39
namespace drizzled
45
40
{
46
41
 
80
75
 * The store_xxx() methods take various input and convert
81
76
 * the input into the raw bytes stored in the ptr member variable.
82
77
 */
83
 
class DRIZZLED_API Field
 
78
class Field
84
79
{
85
80
  /* Prevent use of these */
86
81
  Field(const Field&);
87
82
  void operator=(Field &);
88
 
 
89
83
public:
90
84
  unsigned char *ptr; /**< Position to field in record. Stores raw field value */
91
85
  unsigned char *null_ptr; /**< Byte where null_bit is */
98
92
   */
99
93
private:
100
94
  Table *table;
101
 
 
102
95
public:
103
96
  Table *getTable()
104
97
  {
147
140
  utype unireg_check;
148
141
  uint32_t field_length; /**< Length of this field in bytes */
149
142
  uint32_t flags;
150
 
 
151
 
  bool isUnsigned() const
152
 
  {
153
 
    return flags & UNSIGNED_FLAG;
154
 
  }
155
 
 
156
 
private:
157
143
  uint16_t field_index; /**< Index of this Field in Table::fields array */
158
 
 
159
 
public:
160
 
 
161
 
  uint16_t position() const
162
 
  {
163
 
    return field_index;
164
 
  }
165
 
 
166
 
  void setPosition(uint32_t arg)
167
 
  {
168
 
    field_index= arg;
169
 
  }
170
 
 
171
144
  unsigned char null_bit; /**< Bit used to test null bit */
172
145
  /**
173
146
     If true, this field was created in create_tmp_field_from_item from a NULL
193
166
        utype unireg_check_arg,
194
167
        const char *field_name_arg);
195
168
  virtual ~Field() {}
196
 
 
197
 
  bool hasDefault() const
198
 
  {
199
 
    return not (flags & NO_DEFAULT_VALUE_FLAG);
200
 
  }
201
 
 
202
169
  /* Store functions returns 1 on overflow and -1 on fatal error */
203
170
  virtual int store(const char *to,
204
171
                    uint32_t length,
205
172
                    const CHARSET_INFO * const cs)=0;
206
173
  virtual int store(double nr)=0;
207
174
  virtual int store(int64_t nr, bool unsigned_val)=0;
208
 
  virtual int store_decimal(const type::Decimal *d)=0;
209
 
  int store_and_check(enum_check_fields check_level,
210
 
                      const char *to,
211
 
                      uint32_t length,
212
 
                      const CHARSET_INFO * const cs);
 
175
  virtual int store_decimal(const my_decimal *d)=0;
 
176
  int store(const char *to,
 
177
            uint32_t length,
 
178
            const CHARSET_INFO * const cs,
 
179
            enum_check_fields check_level);
213
180
  /**
214
181
    This is called when storing a date in a string.
215
182
 
216
183
    @note
217
184
      Needs to be changed if/when we want to support different time formats.
218
185
  */
219
 
  virtual int store_time(type::Time &ltime, type::timestamp_t t_type);
220
 
  virtual double val_real()=0;
221
 
  virtual int64_t val_int()=0;
222
 
  virtual type::Decimal *val_decimal(type::Decimal *);
223
 
  String *val_str_internal(String *str)
 
186
  virtual int store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type t_type);
 
187
  virtual double val_real(void)=0;
 
188
  virtual int64_t val_int(void)=0;
 
189
  virtual my_decimal *val_decimal(my_decimal *);
 
190
  inline String *val_str(String *str)
224
191
  {
225
192
    return val_str(str, str);
226
193
  }
227
 
 
228
194
  /*
229
195
     val_str(buf1, buf2) gets two buffers and should use them as follows:
230
196
     if it needs a temp buffer to convert result to string - use buf1
238
204
     This trickery is used to decrease a number of malloc calls.
239
205
  */
240
206
  virtual String *val_str(String*, String *)=0;
241
 
 
242
207
  /*
243
208
   str_needs_quotes() returns true if the value returned by val_str() needs
244
209
   to be quoted when used in constructing an SQL query.
247
212
  virtual Item_result result_type () const=0;
248
213
  virtual Item_result cmp_type () const { return result_type(); }
249
214
  virtual Item_result cast_to_int_type () const { return result_type(); }
250
 
 
251
215
  /**
252
216
     Check whether a field type can be partially indexed by a key.
253
217
 
294
258
   */
295
259
  virtual bool eq_def(Field *field);
296
260
 
297
 
  virtual bool is_timestamp() const
298
 
  {
299
 
    return false;
300
 
  }
301
 
 
302
261
  /**
303
262
   * Returns size (in bytes) used to store field data in memory
304
263
   * (i.e. it returns the maximum size of the field in a row of the table,
342
301
  virtual uint32_t key_length() const;
343
302
  virtual enum_field_types type() const =0;
344
303
  virtual enum_field_types real_type() const;
345
 
  virtual int cmp_max(const unsigned char *a, const unsigned char *b, uint32_t max_len);
 
304
  inline  int cmp(const unsigned char *str) { return cmp(ptr,str); }
 
305
  virtual int cmp_max(const unsigned char *a, const unsigned char *b,
 
306
                      uint32_t max_len);
346
307
  virtual int cmp(const unsigned char *,const unsigned char *)=0;
347
 
  int cmp_internal(const unsigned char *str) { return cmp(ptr,str); }
348
308
  virtual int cmp_binary(const unsigned char *a,const unsigned char *b,
349
309
                         uint32_t max_length=UINT32_MAX);
350
310
  virtual int cmp_offset(uint32_t row_offset);
396
356
                               uint32_t new_null_bit);
397
357
  /** This is used to generate a field in Table from TableShare */
398
358
  Field *clone(memory::Root *mem_root, Table *new_table);
399
 
  void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
 
359
  inline void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
400
360
  {
401
361
    ptr= ptr_arg;
402
362
    null_ptr= null_ptr_arg;
403
363
    null_bit= null_bit_arg;
404
364
  }
405
 
  void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
 
365
  inline void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
406
366
  virtual void move_field_offset(ptrdiff_t ptr_diff)
407
367
  {
408
368
    ptr= ADD_TO_PTR(ptr,ptr_diff, unsigned char*);
460
420
  {
461
421
    set_image(buff,length, &my_charset_bin);
462
422
  }
463
 
  int64_t val_int_offset(uint32_t row_offset)
 
423
  inline int64_t val_int_offset(uint32_t row_offset)
464
424
  {
465
425
    ptr+=row_offset;
466
426
    int64_t tmp=val_int();
468
428
    return tmp;
469
429
  }
470
430
 
471
 
  int64_t val_int_internal(const unsigned char *new_ptr)
 
431
  inline int64_t val_int(const unsigned char *new_ptr)
472
432
  {
473
433
    unsigned char *old_ptr= ptr;
474
434
    int64_t return_value;
477
437
    ptr= old_ptr;
478
438
    return return_value;
479
439
  }
480
 
 
481
 
  String *val_str_internal(String *str, const unsigned char *new_ptr)
 
440
  inline String *val_str(String *str, const unsigned char *new_ptr)
482
441
  {
483
442
    unsigned char *old_ptr= ptr;
484
443
    ptr= const_cast<unsigned char*>(new_ptr);
485
 
    val_str_internal(str);
 
444
    val_str(str);
486
445
    ptr= old_ptr;
487
446
    return str;
488
447
  }
591
550
    return max_length;
592
551
  }
593
552
 
594
 
  uint32_t offset(const unsigned char *record)
 
553
  inline uint32_t offset(const unsigned char *record)
595
554
  {
596
555
    return (uint32_t) (ptr - record);
597
556
  }
598
557
  void copy_from_tmp(int offset);
599
558
  uint32_t fill_cache_field(CacheField *copy);
600
 
  virtual bool get_date(type::Time &ltime,uint32_t fuzzydate);
601
 
  virtual bool get_time(type::Time &ltime);
 
559
  virtual bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
 
560
  virtual bool get_time(DRIZZLE_TIME *ltime);
602
561
  virtual const CHARSET_INFO *charset(void) const { return &my_charset_bin; }
603
562
  virtual const CHARSET_INFO *sort_charset(void) const { return charset(); }
604
563
  virtual bool has_charset(void) const { return false; }
630
589
      0 otherwise
631
590
  */
632
591
  bool set_warning(DRIZZLE_ERROR::enum_warning_level,
633
 
                   drizzled::error_t code,
 
592
                   unsigned int code,
634
593
                   int cuted_increment);
635
594
  /**
636
595
    Produce warning or note about datetime string data saved into field.
648
607
      thread.
649
608
  */
650
609
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
651
 
                            drizzled::error_t code,
 
610
                            uint32_t code,
652
611
                            const char *str,
653
612
                            uint32_t str_len,
654
 
                            type::timestamp_t ts_type,
 
613
                            enum enum_drizzle_timestamp_type ts_type,
655
614
                            int cuted_increment);
656
615
  /**
657
616
    Produce warning or note about integer datetime value saved into field.
668
627
      thread.
669
628
  */
670
629
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
671
 
                            drizzled::error_t code,
 
630
                            uint32_t code,
672
631
                            int64_t nr,
673
 
                            type::timestamp_t ts_type,
 
632
                            enum enum_drizzle_timestamp_type ts_type,
674
633
                            int cuted_increment);
675
634
  /**
676
635
    Produce warning or note about double datetime data saved into field.
686
645
      thread.
687
646
  */
688
647
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
689
 
                            const drizzled::error_t code,
 
648
                            const uint32_t code,
690
649
                            double nr,
691
 
                            type::timestamp_t ts_type);
692
 
  bool check_overflow(int op_result)
 
650
                            enum enum_drizzle_timestamp_type ts_type);
 
651
  inline bool check_overflow(int op_result)
693
652
  {
694
653
    return (op_result == E_DEC_OVERFLOW);
695
654
  }
723
682
    @return
724
683
      value converted from val
725
684
  */
726
 
  int64_t convert_decimal2int64_t(const type::Decimal *val,
 
685
  int64_t convert_decimal2int64_t(const my_decimal *val,
727
686
                                  bool unsigned_flag,
728
687
                                  int *err);
729
688
  /* The max. number of characters */
730
 
  uint32_t char_length() const
 
689
  inline uint32_t char_length() const
731
690
  {
732
691
    return field_length / charset()->mbmaxlen;
733
692
  }
734
693
 
735
 
  enum column_format_type column_format() const
 
694
  inline enum column_format_type column_format() const
736
695
  {
737
696
    return (enum column_format_type)
738
697
      ((flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
759
718
  bool isWriteSet();
760
719
  void setReadSet(bool arg= true);
761
720
  void setWriteSet(bool arg= true);
762
 
 
763
 
protected:
764
 
 
765
 
  void pack_num(uint64_t arg, unsigned char *destination= NULL);
766
 
  void pack_num(uint32_t arg, unsigned char *destination= NULL);
767
 
  uint64_t unpack_num(uint64_t &destination, const unsigned char *arg= NULL) const;
768
 
  uint32_t unpack_num(uint32_t &destination, const unsigned char *arg= NULL) const;
769
721
};
770
722
 
771
 
std::ostream& operator<<(std::ostream& output, const Field &field);
772
 
 
773
723
} /* namespace drizzled */
774
724
 
775
725
/** @TODO Why is this in the middle of the file???*/
802
752
  SendField() {}
803
753
};
804
754
 
 
755
/**
 
756
 * A class for quick copying data to fields
 
757
 */
 
758
class CopyField :public memory::SqlAlloc
 
759
{
 
760
  /**
 
761
    Convenience definition of a copy function returned by
 
762
    get_copy_func.
 
763
  */
 
764
  typedef void Copy_func(CopyField*);
 
765
  Copy_func *get_copy_func(Field *to, Field *from);
 
766
public:
 
767
  unsigned char *from_ptr;
 
768
  unsigned char *to_ptr;
 
769
  unsigned char *from_null_ptr;
 
770
  unsigned char *to_null_ptr;
 
771
  bool *null_row;
 
772
  uint32_t from_bit;
 
773
  uint32_t to_bit;
 
774
  uint32_t from_length;
 
775
  uint32_t to_length;
 
776
  Field *from_field;
 
777
  Field *to_field;
 
778
  String tmp;                                   // For items
 
779
 
 
780
  CopyField() {}
 
781
  ~CopyField() {}
 
782
  void set(Field *to,Field *from,bool save);    // Field to field
 
783
  void set(unsigned char *to,Field *from);              // Field to string
 
784
  void (*do_copy)(CopyField *);
 
785
  void (*do_copy2)(CopyField *);                // Used to handle null values
 
786
};
 
787
 
805
788
uint32_t pack_length_to_packflag(uint32_t type);
806
789
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
807
790
int set_field_to_null(Field *field);