← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/date.cc

  • Committer: Brian Aker
  • Date: 2008-07-31 19:57:34 UTC
  • mfrom: (236.1.27 codestyle)
  • Revision ID: brian@tangent.org-20080731195734-c7cu4gx70xgjr68o
Merge from Monty.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/date.cc
54
54
                         CHARSET_INFO *cs __attribute__((unused)))
55
55
{
56
56
  long tmp;
57
 
  MYSQL_TIME l_time;
 
57
  DRIZZLE_TIME l_time;
58
58
  int error;
59
59
  THD *thd= table ? table->in_use : current_thd;
60
 
  enum enum_mysql_timestamp_type ret;
 
60
  enum enum_drizzle_timestamp_type ret;
61
61
  if ((ret= str_to_datetime(from, len, &l_time,
62
62
                            (TIME_FUZZY_DATE |
63
63
                             (thd->variables.sql_mode &
64
64
                              (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
65
65
                               MODE_INVALID_DATES))),
66
 
                            &error)) <= MYSQL_TIMESTAMP_ERROR)
 
66
                            &error)) <= DRIZZLE_TIMESTAMP_ERROR)
67
67
  {
68
68
    tmp= 0;
69
69
    error= 2;
71
71
  else
72
72
  {
73
73
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
74
 
    if (!error && (ret != MYSQL_TIMESTAMP_DATE) &&
 
74
    if (!error && (ret != DRIZZLE_TIMESTAMP_DATE) &&
75
75
        (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
76
76
      error= 3;                                 // Datetime was cut (note)
77
77
  }
79
79
  if (error)
80
80
    set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
81
81
                         MYSQL_ERROR::WARN_LEVEL_WARN,
82
 
                         WARN_DATA_TRUNCATED,
83
 
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
 
82
                         ER_WARN_DATA_TRUNCATED,
 
83
                         from, len, DRIZZLE_TIMESTAMP_DATE, 1);
84
84
 
85
85
  int3store(ptr, tmp);
86
86
  return error;
93
93
  {
94
94
    int3store(ptr,(int32_t) 0);
95
95
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
96
 
                         WARN_DATA_TRUNCATED, nr, MYSQL_TIMESTAMP_DATE);
 
96
                         ER_WARN_DATA_TRUNCATED, nr, DRIZZLE_TIMESTAMP_DATE);
97
97
    return 1;
98
98
  }
99
99
  return Field_newdate::store((int64_t) rint(nr), false);
103
103
int Field_newdate::store(int64_t nr,
104
104
                         bool unsigned_val __attribute__((unused)))
105
105
{
106
 
  MYSQL_TIME l_time;
 
106
  DRIZZLE_TIME l_time;
107
107
  int64_t tmp;
108
108
  int error;
109
109
  THD *thd= table ? table->in_use : current_thd;
120
120
  else
121
121
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
122
122
 
123
 
  if (!error && l_time.time_type != MYSQL_TIMESTAMP_DATE &&
 
123
  if (!error && l_time.time_type != DRIZZLE_TIMESTAMP_DATE &&
124
124
      (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
125
125
    error= 3;
126
126
 
128
128
    set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
129
129
                         MYSQL_ERROR::WARN_LEVEL_WARN,
130
130
                         error == 2 ? 
131
 
                         ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED,
132
 
                         nr,MYSQL_TIMESTAMP_DATE, 1);
 
131
                         ER_WARN_DATA_OUT_OF_RANGE : ER_WARN_DATA_TRUNCATED,
 
132
                         nr,DRIZZLE_TIMESTAMP_DATE, 1);
133
133
 
134
134
  int3store(ptr,tmp);
135
135
  return error;
136
136
}
137
137
 
138
138
 
139
 
int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
 
139
int Field_newdate::store_time(DRIZZLE_TIME *ltime,timestamp_type time_type)
140
140
{
141
141
  long tmp;
142
142
  int error= 0;
143
 
  if (time_type == MYSQL_TIMESTAMP_DATE ||
144
 
      time_type == MYSQL_TIMESTAMP_DATETIME)
 
143
  if (time_type == DRIZZLE_TIMESTAMP_DATE ||
 
144
      time_type == DRIZZLE_TIMESTAMP_DATETIME)
145
145
  {
146
146
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
147
147
    if (check_date(ltime, tmp != 0,
153
153
      char buff[MAX_DATE_STRING_REP_LENGTH];
154
154
      String str(buff, sizeof(buff), &my_charset_latin1);
155
155
      make_date((DATE_TIME_FORMAT *) 0, ltime, &str);
156
 
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
157
 
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
 
156
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
 
157
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
158
158
    }
159
 
    if (!error && ltime->time_type != MYSQL_TIMESTAMP_DATE &&
 
159
    if (!error && ltime->time_type != DRIZZLE_TIMESTAMP_DATE &&
160
160
        (ltime->hour || ltime->minute || ltime->second || ltime->second_part))
161
161
    {
162
162
      char buff[MAX_DATE_STRING_REP_LENGTH];
163
163
      String str(buff, sizeof(buff), &my_charset_latin1);
164
164
      make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
165
165
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_NOTE,
166
 
                           WARN_DATA_TRUNCATED,
167
 
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
 
166
                           ER_WARN_DATA_TRUNCATED,
 
167
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
168
168
      error= 3;
169
169
    }
170
170
  }
172
172
  {
173
173
    tmp=0;
174
174
    error= 1;
175
 
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
 
175
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
176
176
  }
177
177
  int3store(ptr,tmp);
178
178
  return error;
181
181
 
182
182
bool Field_newdate::send_binary(Protocol *protocol)
183
183
{
184
 
  MYSQL_TIME tm;
 
184
  DRIZZLE_TIME tm;
185
185
  Field_newdate::get_date(&tm,0);
186
186
  return protocol->store_date(&tm);
187
187
}
229
229
}
230
230
 
231
231
 
232
 
bool Field_newdate::get_date(MYSQL_TIME *ltime,uint fuzzydate)
 
232
bool Field_newdate::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
233
233
{
234
234
  uint32_t tmp=(uint32_t) uint3korr(ptr);
235
235
  ltime->day=   tmp & 31;
236
236
  ltime->month= (tmp >> 5) & 15;
237
237
  ltime->year=  (tmp >> 9);
238
 
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
 
238
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
239
239
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
240
240
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
241
241
          1 : 0);
242
242
}
243
243
 
244
244
 
245
 
bool Field_newdate::get_time(MYSQL_TIME *ltime)
 
245
bool Field_newdate::get_time(DRIZZLE_TIME *ltime)
246
246
{
247
247
  return Field_newdate::get_date(ltime,0);
248
248
}