← 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-12-10 03:50:07 UTC
  • mto: (1992.4.2 system-tables)
  • mto: This revision was merged to the branch mainline in revision 2001.
  • Revision ID: brian@tangent.org-20101210035007-w8ld6aze3ub0cu2s
Additional cerr output bits for a few classes (Item, Field,...)

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
 
#include <drizzled/sql_error.h>
31
 
#include <drizzled/type/decimal.h>
32
 
#include <drizzled/key_map.h>
33
 
#include <drizzled/sql_list.h>
34
 
#include <drizzled/structs.h>
35
 
#include <drizzled/charset_info.h>
36
 
#include <drizzled/item_result.h>
37
 
#include <drizzled/charset_info.h>
 
28
#include "drizzled/sql_error.h"
 
29
#include "drizzled/decimal.h"
 
30
#include "drizzled/key_map.h"
 
31
#include "drizzled/sql_list.h"
 
32
#include "drizzled/structs.h"
 
33
#include "drizzled/charset_info.h"
 
34
#include "drizzled/item_result.h"
 
35
 
 
36
#include "drizzled/function/field/default.h"
38
37
 
39
38
#include <string>
40
39
#include <vector>
41
40
 
42
 
#include <drizzled/visibility.h>
43
 
 
44
41
namespace drizzled
45
42
{
46
43
 
80
77
 * The store_xxx() methods take various input and convert
81
78
 * the input into the raw bytes stored in the ptr member variable.
82
79
 */
83
 
class DRIZZLED_API Field
 
80
class Field
84
81
{
85
82
  /* Prevent use of these */
86
83
  Field(const Field&);
87
84
  void operator=(Field &);
88
85
 
 
86
  function::field::Default *default_function;
 
87
 
89
88
public:
90
89
  unsigned char *ptr; /**< Position to field in record. Stores raw field value */
91
90
  unsigned char *null_ptr; /**< Byte where null_bit is */
98
97
   */
99
98
private:
100
99
  Table *table;
101
 
 
102
100
public:
103
101
  Table *getTable()
104
102
  {
147
145
  utype unireg_check;
148
146
  uint32_t field_length; /**< Length of this field in bytes */
149
147
  uint32_t flags;
150
 
 
151
 
  bool isUnsigned() const
152
 
  {
153
 
    return flags & UNSIGNED_FLAG;
154
 
  }
155
 
 
156
 
private:
157
148
  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
149
  unsigned char null_bit; /**< Bit used to test null bit */
172
150
  /**
173
151
     If true, this field was created in create_tmp_field_from_item from a NULL
205
183
                    const CHARSET_INFO * const cs)=0;
206
184
  virtual int store(double nr)=0;
207
185
  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);
 
186
  virtual int store_decimal(const my_decimal *d)=0;
 
187
  int store(const char *to,
 
188
            uint32_t length,
 
189
            const CHARSET_INFO * const cs,
 
190
            enum_check_fields check_level);
213
191
  /**
214
192
    This is called when storing a date in a string.
215
193
 
216
194
    @note
217
195
      Needs to be changed if/when we want to support different time formats.
218
196
  */
219
 
  virtual int store_time(type::Time &ltime, type::timestamp_t t_type);
220
 
  virtual double val_real() const=0;
221
 
  virtual int64_t val_int() const =0;
222
 
  virtual type::Decimal *val_decimal(type::Decimal *) const;
223
 
  String *val_str_internal(String *str) const
 
197
  virtual int store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type t_type);
 
198
  virtual double val_real(void)=0;
 
199
  virtual int64_t val_int(void)=0;
 
200
  virtual my_decimal *val_decimal(my_decimal *);
 
201
  inline String *val_str(String *str)
224
202
  {
225
203
    return val_str(str, str);
226
204
  }
227
 
 
228
205
  /*
229
206
     val_str(buf1, buf2) gets two buffers and should use them as follows:
230
207
     if it needs a temp buffer to convert result to string - use buf1
237
214
     an unnecessary free (and later, may be an alloc).
238
215
     This trickery is used to decrease a number of malloc calls.
239
216
  */
240
 
  virtual String *val_str(String*, String *) const =0;
241
 
 
 
217
  virtual String *val_str(String*, String *)=0;
242
218
  /*
243
219
   str_needs_quotes() returns true if the value returned by val_str() needs
244
220
   to be quoted when used in constructing an SQL query.
247
223
  virtual Item_result result_type () const=0;
248
224
  virtual Item_result cmp_type () const { return result_type(); }
249
225
  virtual Item_result cast_to_int_type () const { return result_type(); }
250
 
 
251
226
  /**
252
227
     Check whether a field type can be partially indexed by a key.
253
228
 
294
269
   */
295
270
  virtual bool eq_def(Field *field);
296
271
 
297
 
  virtual bool is_timestamp() const
298
 
  {
299
 
    return false;
300
 
  }
301
 
 
302
272
  /**
303
273
   * Returns size (in bytes) used to store field data in memory
304
274
   * (i.e. it returns the maximum size of the field in a row of the table,
342
312
  virtual uint32_t key_length() const;
343
313
  virtual enum_field_types type() const =0;
344
314
  virtual enum_field_types real_type() const;
345
 
  virtual int cmp_max(const unsigned char *a, const unsigned char *b, uint32_t max_len);
 
315
  inline  int cmp(const unsigned char *str) { return cmp(ptr,str); }
 
316
  virtual int cmp_max(const unsigned char *a, const unsigned char *b,
 
317
                      uint32_t max_len);
346
318
  virtual int cmp(const unsigned char *,const unsigned char *)=0;
347
 
  int cmp_internal(const unsigned char *str) { return cmp(ptr,str); }
348
319
  virtual int cmp_binary(const unsigned char *a,const unsigned char *b,
349
320
                         uint32_t max_length=UINT32_MAX);
350
321
  virtual int cmp_offset(uint32_t row_offset);
363
334
  // For new field
364
335
  virtual uint32_t size_of() const =0;
365
336
 
366
 
  bool is_null(ptrdiff_t row_offset= 0) const;
367
 
  bool is_real_null(ptrdiff_t row_offset= 0) const;
368
 
  bool is_null_in_record(const unsigned char *record) const;
369
 
  bool is_null_in_record_with_offset(ptrdiff_t offset) const;
 
337
  bool is_null(ptrdiff_t row_offset= 0);
 
338
  bool is_real_null(ptrdiff_t row_offset= 0);
 
339
  bool is_null_in_record(const unsigned char *record);
 
340
  bool is_null_in_record_with_offset(ptrdiff_t offset);
370
341
  void set_null(ptrdiff_t row_offset= 0);
371
342
  void set_notnull(ptrdiff_t row_offset= 0);
372
 
  bool maybe_null(void) const;
373
 
  bool real_maybe_null(void) const;
 
343
  bool maybe_null(void);
 
344
  bool real_maybe_null(void);
374
345
 
375
346
  virtual void make_field(SendField *);
376
347
  virtual void sort_string(unsigned char *buff,uint32_t length)=0;
396
367
                               uint32_t new_null_bit);
397
368
  /** This is used to generate a field in Table from TableShare */
398
369
  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)
 
370
  inline void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
400
371
  {
401
372
    ptr= ptr_arg;
402
373
    null_ptr= null_ptr_arg;
403
374
    null_bit= null_bit_arg;
404
375
  }
405
 
  void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
 
376
  inline void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
406
377
  virtual void move_field_offset(ptrdiff_t ptr_diff)
407
378
  {
408
379
    ptr= ADD_TO_PTR(ptr,ptr_diff, unsigned char*);
460
431
  {
461
432
    set_image(buff,length, &my_charset_bin);
462
433
  }
463
 
  int64_t val_int_offset(uint32_t row_offset)
 
434
  inline int64_t val_int_offset(uint32_t row_offset)
464
435
  {
465
436
    ptr+=row_offset;
466
437
    int64_t tmp=val_int();
468
439
    return tmp;
469
440
  }
470
441
 
471
 
  int64_t val_int_internal(const unsigned char *new_ptr)
 
442
  inline int64_t val_int(const unsigned char *new_ptr)
472
443
  {
473
444
    unsigned char *old_ptr= ptr;
 
445
    int64_t return_value;
474
446
    ptr= const_cast<unsigned char*>(new_ptr);
475
 
    int64_t return_value= val_int();
 
447
    return_value= val_int();
476
448
    ptr= old_ptr;
477
449
    return return_value;
478
450
  }
479
 
 
480
 
  String *val_str_internal(String *str, const unsigned char *new_ptr)
 
451
  inline String *val_str(String *str, const unsigned char *new_ptr)
481
452
  {
482
453
    unsigned char *old_ptr= ptr;
483
454
    ptr= const_cast<unsigned char*>(new_ptr);
484
 
    val_str_internal(str);
 
455
    val_str(str);
485
456
    ptr= old_ptr;
486
457
    return str;
487
458
  }
590
561
    return max_length;
591
562
  }
592
563
 
593
 
  uint32_t offset(const unsigned char *record)
 
564
  inline uint32_t offset(const unsigned char *record)
594
565
  {
595
566
    return (uint32_t) (ptr - record);
596
567
  }
597
568
  void copy_from_tmp(int offset);
598
569
  uint32_t fill_cache_field(CacheField *copy);
599
 
  virtual bool get_date(type::Time &ltime,uint32_t fuzzydate) const;
600
 
  virtual bool get_time(type::Time &ltime) const;
 
570
  virtual bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
 
571
  virtual bool get_time(DRIZZLE_TIME *ltime);
601
572
  virtual const CHARSET_INFO *charset(void) const { return &my_charset_bin; }
602
573
  virtual const CHARSET_INFO *sort_charset(void) const { return charset(); }
603
574
  virtual bool has_charset(void) const { return false; }
629
600
      0 otherwise
630
601
  */
631
602
  bool set_warning(DRIZZLE_ERROR::enum_warning_level,
632
 
                   drizzled::error_t code,
 
603
                   unsigned int code,
633
604
                   int cuted_increment);
634
605
  /**
635
606
    Produce warning or note about datetime string data saved into field.
647
618
      thread.
648
619
  */
649
620
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
650
 
                            drizzled::error_t code,
 
621
                            uint32_t code,
651
622
                            const char *str,
652
623
                            uint32_t str_len,
653
 
                            type::timestamp_t ts_type,
 
624
                            enum enum_drizzle_timestamp_type ts_type,
654
625
                            int cuted_increment);
655
626
  /**
656
627
    Produce warning or note about integer datetime value saved into field.
667
638
      thread.
668
639
  */
669
640
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
670
 
                            drizzled::error_t code,
 
641
                            uint32_t code,
671
642
                            int64_t nr,
672
 
                            type::timestamp_t ts_type,
 
643
                            enum enum_drizzle_timestamp_type ts_type,
673
644
                            int cuted_increment);
674
645
  /**
675
646
    Produce warning or note about double datetime data saved into field.
685
656
      thread.
686
657
  */
687
658
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
688
 
                            const drizzled::error_t code,
 
659
                            const uint32_t code,
689
660
                            double nr,
690
 
                            type::timestamp_t ts_type);
691
 
  bool check_overflow(int op_result)
 
661
                            enum enum_drizzle_timestamp_type ts_type);
 
662
  inline bool check_overflow(int op_result)
692
663
  {
693
664
    return (op_result == E_DEC_OVERFLOW);
694
665
  }
722
693
    @return
723
694
      value converted from val
724
695
  */
725
 
  int64_t convert_decimal2int64_t(const type::Decimal *val,
 
696
  int64_t convert_decimal2int64_t(const my_decimal *val,
726
697
                                  bool unsigned_flag,
727
698
                                  int *err);
728
699
  /* The max. number of characters */
729
 
  uint32_t char_length() const
 
700
  inline uint32_t char_length() const
730
701
  {
731
702
    return field_length / charset()->mbmaxlen;
732
703
  }
733
704
 
734
 
  enum column_format_type column_format() const
 
705
  inline enum column_format_type column_format() const
735
706
  {
736
707
    return (enum column_format_type)
737
708
      ((flags >> COLUMN_FORMAT_FLAGS) & COLUMN_FORMAT_MASK);
738
709
  }
739
710
 
740
711
  /* Hash value */
741
 
  virtual void hash(uint32_t *nr, uint32_t *nr2) const;
 
712
  virtual void hash(uint32_t *nr, uint32_t *nr2);
742
713
  friend bool reopen_table(Session *,Table *,bool);
743
714
 
744
715
  friend class CopyField;
754
725
  friend class Item_sum_max;
755
726
  friend class Item_func_group_concat;
756
727
 
757
 
  bool isReadSet() const;
 
728
  bool isReadSet();
758
729
  bool isWriteSet();
759
730
  void setReadSet(bool arg= true);
760
731
  void setWriteSet(bool arg= true);
761
 
 
762
 
protected:
763
 
 
764
 
  void pack_num(uint64_t arg, unsigned char *destination= NULL);
765
 
  void pack_num(uint32_t arg, unsigned char *destination= NULL);
766
 
  uint64_t unpack_num(uint64_t &destination, const unsigned char *arg= NULL) const;
767
 
  uint32_t unpack_num(uint32_t &destination, const unsigned char *arg= NULL) const;
768
732
};
769
733
 
770
 
namespace field {
771
 
 
772
 
inline bool isDateTime(const enum_field_types &arg)
773
 
{
774
 
  switch (arg)
775
 
  {
776
 
  case DRIZZLE_TYPE_DATE:
777
 
  case DRIZZLE_TYPE_DATETIME:
778
 
  case DRIZZLE_TYPE_MICROTIME:
779
 
  case DRIZZLE_TYPE_TIME:
780
 
  case DRIZZLE_TYPE_TIMESTAMP:
781
 
    return true;
782
 
 
783
 
  case DRIZZLE_TYPE_BLOB:
784
 
  case DRIZZLE_TYPE_BOOLEAN:
785
 
  case DRIZZLE_TYPE_DECIMAL:
786
 
  case DRIZZLE_TYPE_DOUBLE:
787
 
  case DRIZZLE_TYPE_ENUM:
788
 
  case DRIZZLE_TYPE_LONG:
789
 
  case DRIZZLE_TYPE_LONGLONG:
790
 
  case DRIZZLE_TYPE_NULL:
791
 
  case DRIZZLE_TYPE_UUID:
792
 
  case DRIZZLE_TYPE_VARCHAR:
793
 
    return false;
794
 
  }
795
 
 
796
 
  assert(0);
797
 
  abort();
798
 
}
799
 
 
800
 
} // namespace field
801
 
 
802
734
std::ostream& operator<<(std::ostream& output, const Field &field);
803
735
 
804
736
} /* namespace drizzled */
805
737
 
806
738
/** @TODO Why is this in the middle of the file???*/
807
 
#include <drizzled/create_field.h>
 
739
#include "drizzled/create_field.h"
808
740
 
809
741
namespace drizzled
810
742
{
833
765
  SendField() {}
834
766
};
835
767
 
 
768
/**
 
769
 * A class for quick copying data to fields
 
770
 */
 
771
class CopyField :public memory::SqlAlloc
 
772
{
 
773
  /**
 
774
    Convenience definition of a copy function returned by
 
775
    get_copy_func.
 
776
  */
 
777
  typedef void Copy_func(CopyField*);
 
778
  Copy_func *get_copy_func(Field *to, Field *from);
 
779
public:
 
780
  unsigned char *from_ptr;
 
781
  unsigned char *to_ptr;
 
782
  unsigned char *from_null_ptr;
 
783
  unsigned char *to_null_ptr;
 
784
  bool *null_row;
 
785
  uint32_t from_bit;
 
786
  uint32_t to_bit;
 
787
  uint32_t from_length;
 
788
  uint32_t to_length;
 
789
  Field *from_field;
 
790
  Field *to_field;
 
791
  String tmp;                                   // For items
 
792
 
 
793
  CopyField() {}
 
794
  ~CopyField() {}
 
795
  void set(Field *to,Field *from,bool save);    // Field to field
 
796
  void set(unsigned char *to,Field *from);              // Field to string
 
797
  void (*do_copy)(CopyField *);
 
798
  void (*do_copy2)(CopyField *);                // Used to handle null values
 
799
};
 
800
 
836
801
uint32_t pack_length_to_packflag(uint32_t type);
837
802
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
838
803
int set_field_to_null(Field *field);