← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/functions/time/to_days.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/functions/time/to_days.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include "config.h"
21
 
 
22
 
#include "drizzled/function/time/to_days.h"
23
 
#include "drizzled/error.h"
24
 
#include "drizzled/temporal.h"
25
 
 
26
 
namespace drizzled
27
 
{
28
 
 
29
 
/* 
30
 
 * We intepret the first argument as a DateTime and then convert
31
 
 * it to a Julian Day Number and return it.
32
 
 */
 
20
#include <drizzled/server_includes.h>
 
21
#include CSTDINT_H
 
22
#include <drizzled/functions/time/to_days.h>
 
23
 
33
24
int64_t Item_func_to_days::val_int()
34
25
{
35
 
  assert(fixed);
36
 
 
37
 
  /* We return NULL from FROM_DAYS() only when supplied a NULL argument */
38
 
  if (args[0]->null_value)
39
 
  {
40
 
    null_value= true;
41
 
    return false;
42
 
  }
43
 
 
44
 
  /*
45
 
   * We attempt to convert the first argument into a
46
 
   * temporal value.  If the conversion is successful, 
47
 
   * we know that a conversion to a Julian Day Number
48
 
   * is always possible.  Upon successful conversion, 
49
 
   * we return the Julian Day Number.  If no conversion
50
 
   * was possible into a temporal value, we throw an 
51
 
   * error and return 0, setting the null_value flag to true.
52
 
   */
53
 
  /* Grab the first argument as a DateTime object */
54
 
  DateTime temporal;
55
 
  Item_result arg0_result_type= args[0]->result_type();
 
26
  assert(fixed == 1);
 
27
  DRIZZLE_TIME ltime;
 
28
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
 
29
    return 0;
 
30
  return (int64_t) calc_daynr(ltime.year,ltime.month,ltime.day);
 
31
}
 
32
 
 
33
 
 
34
/*
 
35
  Get information about this Item tree monotonicity
56
36
  
57
 
  switch (arg0_result_type)
 
37
  SYNOPSIS
 
38
    Item_func_to_days::get_monotonicity_info()
 
39
 
 
40
  DESCRIPTION
 
41
  Get information about monotonicity of the function represented by this item
 
42
  tree.
 
43
 
 
44
  RETURN
 
45
    See enum_monotonicity_info.
 
46
*/
 
47
 
 
48
enum_monotonicity_info Item_func_to_days::get_monotonicity_info() const
 
49
{
 
50
  if (args[0]->type() == Item::FIELD_ITEM)
58
51
  {
59
 
    case REAL_RESULT:
60
 
    case DECIMAL_RESULT: 
61
 
      /* 
62
 
       * For doubles supplied, interpret the arg as a string, 
63
 
       * so intentionally fall-through here...
64
 
       * This allows us to accept double parameters like 
65
 
       * 19971231235959.01 and interpret it the way MySQL does:
66
 
       * as a TIMESTAMP-like thing with a microsecond component.
67
 
       * Ugh, but need to keep backwards-compat.
68
 
       */
69
 
    case STRING_RESULT:
70
 
      {
71
 
        char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];
72
 
        String tmp(buff,sizeof(buff), &my_charset_utf8_bin);
73
 
        String *res= args[0]->val_str(&tmp);
74
 
 
75
 
        if (! res)
76
 
        {
77
 
          /* 
78
 
           * Likely a nested function issue where the nested
79
 
           * function had bad input.  We rely on the nested
80
 
           * function my_error() and simply return false here.
81
 
           */
82
 
          return false;
83
 
        }
84
 
 
85
 
        if (! temporal.from_string(res->c_ptr(), res->length()))
86
 
        {
87
 
          /* 
88
 
          * Could not interpret the function argument as a temporal value, 
89
 
          * so throw an error and return 0
90
 
          */
91
 
          my_error(ER_INVALID_DATETIME_VALUE, MYF(0), res->c_ptr());
92
 
          return 0;
93
 
        }
94
 
      }
95
 
      break;
96
 
    case INT_RESULT:
97
 
      if (temporal.from_int64_t(args[0]->val_int()))
98
 
        break;
99
 
      /* Intentionally fall-through on invalid conversion from integer */
100
 
    default:
101
 
      {
102
 
        /* 
103
 
        * Could not interpret the function argument as a temporal value, 
104
 
        * so throw an error and return 0
105
 
        */
106
 
        null_value= true;
107
 
        char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];
108
 
        String tmp(buff,sizeof(buff), &my_charset_utf8_bin);
109
 
        String *res;
110
 
 
111
 
        res= args[0]->val_str(&tmp);
112
 
 
113
 
        if (! res)
114
 
        {
115
 
          /* 
116
 
           * Likely a nested function issue where the nested
117
 
           * function had bad input.  We rely on the nested
118
 
           * function my_error() and simply return false here.
119
 
           */
120
 
          return false;
121
 
        }
122
 
 
123
 
        my_error(ER_INVALID_DATETIME_VALUE, MYF(0), res->c_ptr());
124
 
        return 0;
125
 
      }
 
52
    if (args[0]->field_type() == DRIZZLE_TYPE_NEWDATE)
 
53
      return MONOTONIC_STRICT_INCREASING;
 
54
    if (args[0]->field_type() == DRIZZLE_TYPE_DATETIME)
 
55
      return MONOTONIC_INCREASING;
126
56
  }
127
 
  int64_t julian_day_number;
128
 
  temporal.to_julian_day_number(&julian_day_number);
129
 
  return julian_day_number;
 
57
  return NON_MONOTONIC;
130
58
}
131
59
 
132
60
int64_t Item_func_to_days::val_int_endpoint(bool left_endp, bool *incl_endp)
133
61
{
134
 
  assert(fixed);
135
 
 
136
 
  /*
137
 
   * We attempt to convert the first argument into a
138
 
   * temporal value.  If the conversion is successful, 
139
 
   * we know that a conversion to a Julian Day Number
140
 
   * is always possible. Depending on whether the 
141
 
   * first argument is a Date, or a DateTime with no
142
 
   * time-portion, we return the Julian Day Number or
143
 
   * the appropriate end-point integer.
144
 
   */
145
 
  /* Grab the first argument as a DateTime object */
146
 
  DateTime temporal;
147
 
  Item_result arg0_result_type= args[0]->result_type();
148
 
  
149
 
  switch (arg0_result_type)
150
 
  {
151
 
    case REAL_RESULT:
152
 
    case DECIMAL_RESULT: 
153
 
      /* 
154
 
       * For doubles supplied, interpret the arg as a string, 
155
 
       * so intentionally fall-through here...
156
 
       * This allows us to accept double parameters like 
157
 
       * 19971231235959.01 and interpret it the way MySQL does:
158
 
       * as a TIMESTAMP-like thing with a microsecond component.
159
 
       * Ugh, but need to keep backwards-compat.
160
 
       */
161
 
    case STRING_RESULT:
162
 
      {
163
 
        char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];
164
 
        String tmp(buff,sizeof(buff), &my_charset_utf8_bin);
165
 
        String *res= args[0]->val_str(&tmp);
166
 
 
167
 
        if (! res)
168
 
        {
169
 
          /* 
170
 
           * Likely a nested function issue where the nested
171
 
           * function had bad input.  We rely on the nested
172
 
           * function my_error() and simply return false here.
173
 
           */
174
 
          return 0;
175
 
        }
176
 
 
177
 
        if (! temporal.from_string(res->c_ptr(), res->length()))
178
 
        {
179
 
          /* 
180
 
          * Could not interpret the function argument as a temporal value, 
181
 
          * so throw an error and return 0
182
 
          */
183
 
          my_error(ER_INVALID_DATETIME_VALUE, MYF(0), res->c_ptr());
184
 
          return 0;
185
 
        }
186
 
      }
187
 
      break;
188
 
    case INT_RESULT:
189
 
      if (temporal.from_int64_t(args[0]->val_int()))
190
 
        break;
191
 
      /* Intentionally fall-through on invalid conversion from integer */
192
 
    default:
193
 
      {
194
 
        /* 
195
 
        * Could not interpret the function argument as a temporal value, 
196
 
        * so throw an error and return 0
197
 
        */
198
 
        null_value= true;
199
 
        char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];
200
 
        String tmp(buff,sizeof(buff), &my_charset_utf8_bin);
201
 
        String *res;
202
 
 
203
 
        res= args[0]->val_str(&tmp);
204
 
 
205
 
        if (! res)
206
 
        {
207
 
          /* 
208
 
           * Likely a nested function issue where the nested
209
 
           * function had bad input.  We rely on the nested
210
 
           * function my_error() and simply return false here.
211
 
           */
212
 
          return 0;
213
 
        }
214
 
 
215
 
        my_error(ER_INVALID_DATETIME_VALUE, MYF(0), res->c_ptr());
216
 
        return 0;
217
 
      }
218
 
  }
219
 
 
220
 
  if (null_value == true)
 
62
  assert(fixed == 1);
 
63
  DRIZZLE_TIME ltime;
 
64
  int64_t res;
 
65
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
221
66
  {
222
67
    /* got NULL, leave the incl_endp intact */
223
68
    return INT64_MIN;
224
69
  }
225
 
 
226
 
  int64_t julian_day_number;
227
 
  temporal.to_julian_day_number(&julian_day_number);
228
 
 
229
 
  if (args[0]->field_type() == DRIZZLE_TYPE_DATE)
 
70
  res=(int64_t) calc_daynr(ltime.year,ltime.month,ltime.day);
 
71
 
 
72
  if (args[0]->field_type() == DRIZZLE_TYPE_NEWDATE)
230
73
  {
231
 
    /* TO_DAYS() is strictly monotonic for dates, leave incl_endp intact */
232
 
    return julian_day_number;
 
74
    // TO_DAYS() is strictly monotonic for dates, leave incl_endp intact
 
75
    return res;
233
76
  }
234
77
 
235
78
  /*
243
86
 
244
87
      col < '2007-09-15 12:34:56'  -> TO_DAYS(col) <= TO_DAYS('2007-09-15')
245
88
  */
246
 
  if (!left_endp && ! (
247
 
                    temporal.hours() 
248
 
                    || temporal.minutes()
249
 
                    || temporal.seconds() 
250
 
                    || temporal.useconds()
251
 
                    || temporal.nseconds()
252
 
                    )
253
 
                    )
 
89
  if (!left_endp && !(ltime.hour || ltime.minute || ltime.second ||
 
90
                      ltime.second_part))
254
91
    ; /* do nothing */
255
92
  else
256
93
    *incl_endp= true;
257
 
  return julian_day_number;
 
94
  return res;
258
95
}
259
96
 
260
 
} /* namespace drizzled */