← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/temporal_interval.cc

  • Committer: clint at fewbar
  • Date: 2009-07-21 17:42:23 UTC
  • mto: (1093.1.33 captain)
  • mto: This revision was merged to the branch mainline in revision 1105.
  • Revision ID: clint@fewbar.com-20090721174223-s4srxyar028f3kl7
style/documentation cleanups and replacing copyright notices

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/temporal_interval.cc
1
 
// vim:ts=2 sts=2 sw=2:et ai:
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
2
20
#include <drizzled/global.h>
3
21
#include <drizzled/error.h>
4
22
#include <drizzled/session.h>
6
24
#include <drizzled/function/time/date.h>
7
25
#include <drizzled/temporal_interval.h>
8
26
 
9
 
bool drizzled::TemporalInterval::value_from_item(Item *args, interval_type int_type, String *str_value)
 
27
bool drizzled::TemporalInterval::initFromItem(Item *args, interval_type int_type, String *str_value)
10
28
{
11
29
  uint64_t array[5];
12
30
  int64_t value= 0;
78
96
      second=value;
79
97
      break;
80
98
    case INTERVAL_YEAR_MONTH:                   // Allow YEAR-MONTH YYYYYMM
81
 
      if (get_interval_info(str,length,cs,2,array,0))
 
99
      if (getIntervalInfo(str,length,cs,2,array,0))
82
100
        return true;
83
101
      year=  (ulong) array[0];
84
102
      month= (ulong) array[1];
85
103
      break;
86
104
    case INTERVAL_DAY_HOUR:
87
 
      if (get_interval_info(str,length,cs,2,array,0))
 
105
      if (getIntervalInfo(str,length,cs,2,array,0))
88
106
        return true;
89
107
      day=  (ulong) array[0];
90
108
      hour= (ulong) array[1];
91
109
      break;
92
110
    case INTERVAL_DAY_MICROSECOND:
93
 
      if (get_interval_info(str,length,cs,5,array,1))
 
111
      if (getIntervalInfo(str,length,cs,5,array,1))
94
112
        return true;
95
113
      day=    (ulong) array[0];
96
114
      hour=   (ulong) array[1];
99
117
      second_part= array[4];
100
118
      break;
101
119
    case INTERVAL_DAY_MINUTE:
102
 
      if (get_interval_info(str,length,cs,3,array,0))
 
120
      if (getIntervalInfo(str,length,cs,3,array,0))
103
121
        return true;
104
122
      day=    (ulong) array[0];
105
123
      hour=   (ulong) array[1];
106
124
      minute= array[2];
107
125
      break;
108
126
    case INTERVAL_DAY_SECOND:
109
 
      if (get_interval_info(str,length,cs,4,array,0))
 
127
      if (getIntervalInfo(str,length,cs,4,array,0))
110
128
        return true;
111
129
      day=    (ulong) array[0];
112
130
      hour=   (ulong) array[1];
114
132
      second= array[3];
115
133
      break;
116
134
    case INTERVAL_HOUR_MICROSECOND:
117
 
      if (get_interval_info(str,length,cs,4,array,1))
 
135
      if (getIntervalInfo(str,length,cs,4,array,1))
118
136
        return true;
119
137
      hour=   (ulong) array[0];
120
138
      minute= array[1];
122
140
      second_part= array[3];
123
141
      break;
124
142
    case INTERVAL_HOUR_MINUTE:
125
 
      if (get_interval_info(str,length,cs,2,array,0))
 
143
      if (getIntervalInfo(str,length,cs,2,array,0))
126
144
        return true;
127
145
      hour=   (ulong) array[0];
128
146
      minute= array[1];
129
147
      break;
130
148
    case INTERVAL_HOUR_SECOND:
131
 
      if (get_interval_info(str,length,cs,3,array,0))
 
149
      if (getIntervalInfo(str,length,cs,3,array,0))
132
150
        return true;
133
151
      hour=   (ulong) array[0];
134
152
      minute= array[1];
135
153
      second= array[2];
136
154
      break;
137
155
    case INTERVAL_MINUTE_MICROSECOND:
138
 
      if (get_interval_info(str,length,cs,3,array,1))
 
156
      if (getIntervalInfo(str,length,cs,3,array,1))
139
157
        return true;
140
158
      minute= array[0];
141
159
      second= array[1];
142
160
      second_part= array[2];
143
161
      break;
144
162
    case INTERVAL_MINUTE_SECOND:
145
 
      if (get_interval_info(str,length,cs,2,array,0))
 
163
      if (getIntervalInfo(str,length,cs,2,array,0))
146
164
        return true;
147
165
      minute= array[0];
148
166
      second= array[1];
149
167
      break;
150
168
    case INTERVAL_SECOND_MICROSECOND:
151
 
      if (get_interval_info(str,length,cs,2,array,1))
 
169
      if (getIntervalInfo(str,length,cs,2,array,1))
152
170
        return true;
153
171
      second= array[0];
154
172
      second_part= array[1];
160
178
  return false;
161
179
}
162
180
 
163
 
bool drizzled::TemporalInterval::add_date(DRIZZLE_TIME *ltime, interval_type int_type)
 
181
bool drizzled::TemporalInterval::addDate(DRIZZLE_TIME *ltime, interval_type int_type)
164
182
{
165
183
  long period, sign;
166
184
 
268
286
  return 1;
269
287
}
270
288
 
271
 
bool drizzled::TemporalInterval::get_interval_info(const char *str,uint32_t length, const CHARSET_INFO * const cs,
 
289
bool drizzled::TemporalInterval::getIntervalInfo(const char *str,uint32_t length, const CHARSET_INFO * const cs,
272
290
    uint32_t count, uint64_t *values,
273
291
    bool transform_msec)
274
292
{
275
293
  const char *end=str+length;
276
 
  uint32_t i;
 
294
  uint32_t x;
 
295
 
277
296
  while (str != end && !my_isdigit(cs,*str))
278
297
    str++;
279
298
 
280
 
  for (i=0 ; i < count ; i++)
 
299
  for (x= 0 ; x < count ; x++)
281
300
  {
282
301
    int64_t value;
283
302
    const char *start= str;
284
 
    for (value=0; str != end && my_isdigit(cs,*str) ; str++)
 
303
    for (value= 0 ; str != end && my_isdigit(cs,*str) ; str++)
285
304
      value= value * 10L + (int64_t) (*str - '0');
286
 
    if (transform_msec && i == count - 1) // microseconds always last
 
305
    if (transform_msec && x == count - 1) // microseconds always last
287
306
    {
288
307
      long msec_length= 6 - (str - start);
289
308
      if (msec_length > 0)
290
309
        value*= (long) log_10_int[msec_length];
291
310
    }
292
 
    values[i]= value;
 
311
    values[x]= value;
293
312
    while (str != end && !my_isdigit(cs,*str))
294
313
      str++;
295
 
    if (str == end && i != count-1)
 
314
    if (str == end && x != count-1)
296
315
    {
297
 
      i++;
298
 
      /* Change values[0...i-1] -> values[0...count-1] */
299
 
      bmove_upp((unsigned char*) (values+count), (unsigned char*) (values+i),
300
 
          sizeof(*values)*i);
301
 
      memset(values, 0, sizeof(*values)*(count-i));
 
316
      x++;
 
317
      /* Change values[0...x-1] -> values[0...count-1] */
 
318
      bmove_upp((unsigned char*) (values+count), (unsigned char*) (values+x),
 
319
          sizeof(*values)*x);
 
320
      memset(values, 0, sizeof(*values)*(count-x));
302
321
      break;
303
322
    }
304
323
  }