← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field.cc

  • Committer: Mark Atwood
  • Date: 2011-06-22 05:48:25 UTC
  • mfrom: (2318.6.17 refactor12)
  • Revision ID: me@mark.atwood.name-20110622054825-mf8nxjs9dxcpvcfe
bzr merge lp:~olafvdspek/drizzle/refactor12

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field.cc
57
57
#include <drizzled/display.h>
58
58
#include <drizzled/typelib.h>
59
59
 
60
 
namespace drizzled
61
 
{
 
60
namespace drizzled {
62
61
 
63
62
/*****************************************************************************
64
63
  Instansiate templates and static variables
748
747
 
749
748
bool Field::is_null(ptrdiff_t row_offset) const
750
749
{
751
 
  return null_ptr ?
752
 
    (null_ptr[row_offset] & null_bit ? true : false) :
753
 
    table->null_row;
 
750
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : table->null_row;
754
751
}
755
752
 
756
753
bool Field::is_real_null(ptrdiff_t row_offset) const
757
754
{
758
 
  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : false;
 
755
  return null_ptr && (null_ptr[row_offset] & null_bit);
759
756
}
760
757
 
761
758
bool Field::is_null_in_record(const unsigned char *record) const
762
759
{
763
 
  if (! null_ptr)
764
 
    return false;
765
 
  return test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
 
760
  return null_ptr && test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
766
761
}
767
762
 
768
763
bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset) const
769
764
{
770
 
  if (! null_ptr)
771
 
    return false;
772
 
  return test(null_ptr[with_offset] & null_bit);
 
765
  return null_ptr && test(null_ptr[with_offset] & null_bit);
773
766
}
774
767
 
775
768
void Field::set_null(ptrdiff_t row_offset)
796
789
 
797
790
bool Field::type_can_have_key_part(enum enum_field_types type)
798
791
{
799
 
  switch (type) {
 
792
  switch (type) 
 
793
  {
800
794
  case DRIZZLE_TYPE_VARCHAR:
801
795
  case DRIZZLE_TYPE_BLOB:
802
796
    return true;
883
877
                           const charset_info_st * const cs)
884
878
 
885
879
{
886
 
  int res;
887
880
  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
888
881
  table->in_use->count_cuted_fields= check_level;
889
 
  res= store(to, length, cs);
 
882
  int res= store(to, length, cs);
890
883
  table->in_use->count_cuted_fields= old_check_level;
891
884
  return res;
892
885
}
901
894
 
902
895
unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
903
896
{
904
 
  unsigned char *result= this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
905
 
  return(result);
 
897
  return this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
906
898
}
907
899
 
908
900
const unsigned char *Field::unpack(unsigned char* to,
939
931
 
940
932
const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
941
933
{
942
 
  const unsigned char *result= unpack(to, from, 0U, table->getShare()->db_low_byte_first);
943
 
  return(result);
 
934
  return unpack(to, from, 0, table->getShare()->db_low_byte_first);
944
935
}
945
936
 
946
937
type::Decimal *Field::val_decimal(type::Decimal *) const
947
938
{
948
939
  /* This never have to be called */
949
 
  assert(0);
 
940
  assert(false);
950
941
  return 0;
951
942
}
952
943
 
1015
1006
bool Field::get_date(type::Time &ltime, uint32_t fuzzydate) const
1016
1007
{
1017
1008
  char buff[type::Time::MAX_STRING_LENGTH];
1018
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
 
1009
  String tmp(buff,sizeof(buff),&my_charset_bin);
1019
1010
 
1020
1011
  assert(getTable() and getTable()->getSession());
1021
1012
 
1022
 
  if (not (res= val_str_internal(&tmp)) or
1023
 
      str_to_datetime_with_warn(getTable()->getSession(),
1024
 
                                res->ptr(), res->length(),
1025
 
                                &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR)
1026
 
  {
1027
 
    return true;
1028
 
  }
1029
 
 
1030
 
  return false;
 
1013
  String* res= val_str_internal(&tmp);
 
1014
  return not res or str_to_datetime_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR;
1031
1015
}
1032
1016
 
1033
1017
bool Field::get_time(type::Time &ltime) const
1034
1018
{
1035
1019
  char buff[type::Time::MAX_STRING_LENGTH];
1036
 
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1037
 
 
1038
 
  if (not (res= val_str_internal(&tmp)) or
1039
 
      str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime))
1040
 
  {
1041
 
    return true;
1042
 
  }
1043
 
 
1044
 
  return false;
 
1020
  String tmp(buff,sizeof(buff),&my_charset_bin);
 
1021
 
 
1022
  String* res= val_str_internal(&tmp);
 
1023
  return not res or str_to_time_with_warn(getTable()->getSession(), res->ptr(), res->length(), &ltime);
1045
1024
}
1046
1025
 
1047
1026
int Field::store_time(type::Time &ltime, type::timestamp_t)
1048
1027
{
1049
1028
  String tmp;
1050
 
 
1051
1029
  ltime.convert(tmp);
1052
 
 
1053
1030
  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
1054
1031
}
1055
1032
 
1060
1037
 
1061
1038
Field *Field::new_field(memory::Root *root, Table *new_table, bool)
1062
1039
{
1063
 
  Field *tmp;
1064
 
  if (!(tmp= (Field*) root->memdup_root((char*) this,size_of())))
1065
 
    return 0;
1066
 
 
 
1040
  Field* tmp= (Field*) root->memdup_root((char*) this,size_of());
1067
1041
  if (tmp->table->maybe_null)
1068
1042
    tmp->flags&= ~NOT_NULL_FLAG;
1069
1043
  tmp->table= new_table;
1081
1055
                            unsigned char *new_null_ptr,
1082
1056
                            uint32_t new_null_bit)
1083
1057
{
1084
 
  Field *tmp;
1085
 
  if ((tmp= new_field(root, new_table, table == new_table)))
1086
 
  {
1087
 
    tmp->ptr= new_ptr;
1088
 
    tmp->null_ptr= new_null_ptr;
1089
 
    tmp->null_bit= new_null_bit;
1090
 
  }
 
1058
  Field *tmp= new_field(root, new_table, table == new_table);
 
1059
  tmp->ptr= new_ptr;
 
1060
  tmp->null_ptr= new_null_ptr;
 
1061
  tmp->null_bit= new_null_bit;
1091
1062
  return tmp;
1092
1063
}
1093
1064
 
1094
1065
Field *Field::clone(memory::Root *root, Table *new_table)
1095
1066
{
1096
 
  Field *tmp;
1097
 
  if ((tmp= (Field*) root->memdup_root((char*) this,size_of())))
1098
 
  {
1099
 
    tmp->init(new_table);
1100
 
    tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() -
1101
 
                                           new_table->getDefaultValues()));
1102
 
  }
 
1067
  Field *tmp= (Field*) root->memdup_root((char*) this,size_of());
 
1068
  tmp->init(new_table);
 
1069
  tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() - new_table->getDefaultValues()));
1103
1070
  return tmp;
1104
1071
}
1105
1072
 
1106
 
 
1107
1073
uint32_t Field::is_equal(CreateField *new_field_ptr)
1108
1074
{
1109
 
  return (new_field_ptr->sql_type == real_type());
 
1075
  return new_field_ptr->sql_type == real_type();
1110
1076
}
1111
1077
 
1112
1078
bool Field::eq_def(Field *field)
1113
1079
{
1114
 
  if (real_type() != field->real_type() || charset() != field->charset() ||
1115
 
      pack_length() != field->pack_length())
1116
 
    return 0;
1117
 
  return 1;
 
1080
  return real_type() == field->real_type() && charset() == field->charset() && pack_length() == field->pack_length();
1118
1081
}
1119
1082
 
1120
1083
bool Field_enum::eq_def(Field *field)
1130
1093
  for (uint32_t i=0 ; i < from_lib->count ; i++)
1131
1094
  {
1132
1095
    if (my_strnncoll(field_charset,
1133
 
                     (const unsigned char*)typelib->type_names[i],
1134
 
                     strlen(typelib->type_names[i]),
1135
 
                     (const unsigned char*)from_lib->type_names[i],
1136
 
                     strlen(from_lib->type_names[i])))
 
1096
                     (const unsigned char*)typelib->type_names[i], strlen(typelib->type_names[i]),
 
1097
                     (const unsigned char*)from_lib->type_names[i], strlen(from_lib->type_names[i])))
1137
1098
      return 0;
1138
1099
  }
1139
1100
 
1142
1103
 
1143
1104
uint32_t calc_pack_length(enum_field_types type,uint32_t length)
1144
1105
{
1145
 
  switch (type) {
 
1106
  switch (type) 
 
1107
  {
1146
1108
  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
1147
1109
  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
1148
1110
  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
1167
1129
 
1168
1130
uint32_t pack_length_to_packflag(uint32_t type)
1169
1131
{
1170
 
  switch (type) {
1171
 
    case 1: return 1 << FIELDFLAG_PACK_SHIFT;
1172
 
    case 2: assert(1);
1173
 
    case 3: assert(1);
1174
 
    case 4: return f_settype(DRIZZLE_TYPE_LONG);
1175
 
    case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
 
1132
  switch (type) 
 
1133
  {
 
1134
  case 1: return 1 << FIELDFLAG_PACK_SHIFT;
 
1135
  case 2: assert(0);
 
1136
  case 3: assert(0);
 
1137
  case 4: return f_settype(DRIZZLE_TYPE_LONG);
 
1138
  case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
1176
1139
  }
 
1140
  assert(false);
1177
1141
  return 0;                                     // This shouldn't happen
1178
1142
}
1179
1143