← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/date.cc

Moved my_getopt.h

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/date.cc
22
22
#pragma implementation                          // gcc: Class implementation
23
23
#endif
24
24
 
25
 
#include <drizzled/server_includes.h>
26
25
#include <drizzled/field/date.h>
27
26
 
28
27
/****************************************************************************
52
51
 
53
52
int Field_newdate::store(const char *from,
54
53
                         uint len,
55
 
                         const CHARSET_INFO * const cs __attribute__((unused)))
 
54
                         CHARSET_INFO *cs __attribute__((unused)))
56
55
{
57
56
  long tmp;
58
 
  DRIZZLE_TIME l_time;
 
57
  MYSQL_TIME l_time;
59
58
  int error;
60
59
  THD *thd= table ? table->in_use : current_thd;
61
 
  enum enum_drizzle_timestamp_type ret;
 
60
  enum enum_mysql_timestamp_type ret;
62
61
  if ((ret= str_to_datetime(from, len, &l_time,
63
62
                            (TIME_FUZZY_DATE |
64
63
                             (thd->variables.sql_mode &
65
 
                              (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))),
66
 
                            &error)) <= DRIZZLE_TIMESTAMP_ERROR)
 
64
                              (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
 
65
                               MODE_INVALID_DATES))),
 
66
                            &error)) <= MYSQL_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 != DRIZZLE_TIMESTAMP_DATE) &&
 
74
    if (!error && (ret != MYSQL_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
  }
78
78
 
79
79
  if (error)
80
 
    set_datetime_warning(error == 3 ? DRIZZLE_ERROR::WARN_LEVEL_NOTE :
81
 
                         DRIZZLE_ERROR::WARN_LEVEL_WARN,
82
 
                         ER_WARN_DATA_TRUNCATED,
83
 
                         from, len, DRIZZLE_TIMESTAMP_DATE, 1);
 
80
    set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
 
81
                         MYSQL_ERROR::WARN_LEVEL_WARN,
 
82
                         WARN_DATA_TRUNCATED,
 
83
                         from, len, MYSQL_TIMESTAMP_DATE, 1);
84
84
 
85
85
  int3store(ptr, tmp);
86
86
  return error;
92
92
  if (nr < 0.0 || nr > 99991231235959.0)
93
93
  {
94
94
    int3store(ptr,(int32_t) 0);
95
 
    set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
96
 
                         ER_WARN_DATA_TRUNCATED, nr, DRIZZLE_TIMESTAMP_DATE);
 
95
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
96
                         WARN_DATA_TRUNCATED, nr, MYSQL_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
 
  DRIZZLE_TIME l_time;
 
106
  MYSQL_TIME l_time;
107
107
  int64_t tmp;
108
108
  int error;
109
109
  THD *thd= table ? table->in_use : current_thd;
110
110
  if (number_to_datetime(nr, &l_time,
111
111
                         (TIME_FUZZY_DATE |
112
112
                          (thd->variables.sql_mode &
113
 
                           (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))),
 
113
                           (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
 
114
                            MODE_INVALID_DATES))),
114
115
                         &error) == -1LL)
115
116
  {
116
117
    tmp= 0L;
119
120
  else
120
121
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
121
122
 
122
 
  if (!error && l_time.time_type != DRIZZLE_TIMESTAMP_DATE &&
 
123
  if (!error && l_time.time_type != MYSQL_TIMESTAMP_DATE &&
123
124
      (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
124
125
    error= 3;
125
126
 
126
127
  if (error)
127
 
    set_datetime_warning(error == 3 ? DRIZZLE_ERROR::WARN_LEVEL_NOTE :
128
 
                         DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
128
    set_datetime_warning(error == 3 ? MYSQL_ERROR::WARN_LEVEL_NOTE :
 
129
                         MYSQL_ERROR::WARN_LEVEL_WARN,
129
130
                         error == 2 ? 
130
 
                         ER_WARN_DATA_OUT_OF_RANGE : ER_WARN_DATA_TRUNCATED,
131
 
                         nr,DRIZZLE_TIMESTAMP_DATE, 1);
 
131
                         ER_WARN_DATA_OUT_OF_RANGE : WARN_DATA_TRUNCATED,
 
132
                         nr,MYSQL_TIMESTAMP_DATE, 1);
132
133
 
133
134
  int3store(ptr,tmp);
134
135
  return error;
135
136
}
136
137
 
137
138
 
138
 
int Field_newdate::store_time(DRIZZLE_TIME *ltime,timestamp_type time_type)
 
139
int Field_newdate::store_time(MYSQL_TIME *ltime,timestamp_type time_type)
139
140
{
140
141
  long tmp;
141
142
  int error= 0;
142
 
  if (time_type == DRIZZLE_TIMESTAMP_DATE ||
143
 
      time_type == DRIZZLE_TIMESTAMP_DATETIME)
 
143
  if (time_type == MYSQL_TIMESTAMP_DATE ||
 
144
      time_type == MYSQL_TIMESTAMP_DATETIME)
144
145
  {
145
146
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
146
147
    if (check_date(ltime, tmp != 0,
147
148
                   (TIME_FUZZY_DATE |
148
149
                    (current_thd->variables.sql_mode &
149
 
                     (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))), &error))
 
150
                     (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE |
 
151
                      MODE_INVALID_DATES))), &error))
150
152
    {
151
153
      char buff[MAX_DATE_STRING_REP_LENGTH];
152
 
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
 
154
      String str(buff, sizeof(buff), &my_charset_latin1);
153
155
      make_date((DATE_TIME_FORMAT *) 0, ltime, &str);
154
 
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
155
 
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
 
156
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
 
157
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
156
158
    }
157
 
    if (!error && ltime->time_type != DRIZZLE_TIMESTAMP_DATE &&
 
159
    if (!error && ltime->time_type != MYSQL_TIMESTAMP_DATE &&
158
160
        (ltime->hour || ltime->minute || ltime->second || ltime->second_part))
159
161
    {
160
162
      char buff[MAX_DATE_STRING_REP_LENGTH];
161
 
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
 
163
      String str(buff, sizeof(buff), &my_charset_latin1);
162
164
      make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
163
 
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE,
164
 
                           ER_WARN_DATA_TRUNCATED,
165
 
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
 
165
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_NOTE,
 
166
                           WARN_DATA_TRUNCATED,
 
167
                           str.ptr(), str.length(), MYSQL_TIMESTAMP_DATE, 1);
166
168
      error= 3;
167
169
    }
168
170
  }
170
172
  {
171
173
    tmp=0;
172
174
    error= 1;
173
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
175
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED, 1);
174
176
  }
175
177
  int3store(ptr,tmp);
176
178
  return error;
179
181
 
180
182
bool Field_newdate::send_binary(Protocol *protocol)
181
183
{
182
 
  DRIZZLE_TIME tm;
 
184
  MYSQL_TIME tm;
183
185
  Field_newdate::get_date(&tm,0);
184
186
  return protocol->store_date(&tm);
185
187
}
193
195
 
194
196
int64_t Field_newdate::val_int(void)
195
197
{
196
 
  uint32_t j= uint3korr(ptr);
 
198
  ulong j= uint3korr(ptr);
197
199
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
198
200
  return (int64_t) j;
199
201
}
227
229
}
228
230
 
229
231
 
230
 
bool Field_newdate::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
 
232
bool Field_newdate::get_date(MYSQL_TIME *ltime,uint fuzzydate)
231
233
{
232
234
  uint32_t tmp=(uint32_t) uint3korr(ptr);
233
235
  ltime->day=   tmp & 31;
234
236
  ltime->month= (tmp >> 5) & 15;
235
237
  ltime->year=  (tmp >> 9);
236
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
 
238
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
237
239
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
238
240
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
239
241
          1 : 0);
240
242
}
241
243
 
242
244
 
243
 
bool Field_newdate::get_time(DRIZZLE_TIME *ltime)
 
245
bool Field_newdate::get_time(MYSQL_TIME *ltime)
244
246
{
245
247
  return Field_newdate::get_date(ltime,0);
246
248
}