← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/tztime.cc

  • Committer: Jay Pipes
  • Date: 2009-02-21 16:00:06 UTC
  • mto: (907.1.1 trunk-with-temporal)
  • mto: This revision was merged to the branch mainline in revision 908.
  • Revision ID: jpipes@serialcoder-20090221160006-vnk3wt4qbcz62eru
Removes the TIME column type and related time functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/tztime.cc
18
18
 */
19
19
 
20
20
 
21
 
#include "config.h"
22
 
#include "drizzled/tzfile.h"
23
 
#include "drizzled/tztime.h"
24
 
#include "drizzled/gettext.h"
25
 
#include "drizzled/session.h"
26
 
#include "drizzled/time_functions.h"
27
 
 
28
 
namespace drizzled
29
 
{
 
21
#include <drizzled/server_includes.h>
 
22
#include <drizzled/tzfile.h>
 
23
#include <drizzled/tztime.h>
 
24
#include <drizzled/gettext.h>
 
25
#include <drizzled/session.h>
30
26
 
31
27
/* Structure describing local time type (e.g. Moscow summer time (MSD)) */
32
28
typedef struct ttinfo
70
66
  uint32_t typecnt;  // Number of local time types
71
67
  uint32_t charcnt;  // Number of characters used for abbreviations
72
68
  uint32_t revcnt;   // Number of transition descr. for TIME->time_t conversion
73
 
  /* The following are dynamical arrays are allocated in memory::Root */
 
69
  /* The following are dynamical arrays are allocated in MEM_ROOT */
74
70
  time_t *ats;       // Times of transitions between time types
75
71
  unsigned char *types; // Local time types for transitions
76
72
  TRAN_TYPE_INFO *ttis; // Local time types descriptions
116
112
  DAYS_PER_NYEAR, DAYS_PER_LYEAR
117
113
};
118
114
 
119
 
static inline int leaps_thru_end_of(int year)
120
 
{
121
 
  return ((year) / 4 - (year) / 100 + (year) / 400);
122
 
}
 
115
#define LEAPS_THRU_END_OF(y)  ((y) / 4 - (y) / 100 + (y) / 400)
123
116
 
124
 
static inline bool isleap(int year)
125
 
{
126
 
  return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
127
 
}
128
117
 
129
118
/*
130
119
  Converts time from time_t representation (seconds in UTC since Epoch)
188
177
    if (days < 0)
189
178
      newy--;
190
179
    days-= (newy - y) * DAYS_PER_NYEAR +
191
 
           leaps_thru_end_of(newy - 1) -
192
 
           leaps_thru_end_of(y - 1);
 
180
           LEAPS_THRU_END_OF(newy - 1) -
 
181
           LEAPS_THRU_END_OF(y - 1);
193
182
    y= newy;
194
183
  }
195
184
  tmp->year= y;
395
384
  */
396
385
  assert(mon > 0 && mon < 13);
397
386
  long days= year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +
398
 
             leaps_thru_end_of(year - 1) -
399
 
             leaps_thru_end_of(EPOCH_YEAR - 1);
 
387
             LEAPS_THRU_END_OF(year - 1) -
 
388
             LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
400
389
  days+= mon_starts[isleap(year)][mon - 1];
401
390
#else
402
391
  long norm_month= (mon - 1) % MONS_PER_YEAR;
403
392
  long a_year= year + (mon - 1)/MONS_PER_YEAR - (int)(norm_month < 0);
404
393
  long days= a_year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +
405
 
             leaps_thru_end_of(a_year - 1) -
406
 
             leaps_thru_end_of(EPOCH_YEAR - 1);
 
394
             LEAPS_THRU_END_OF(a_year - 1) -
 
395
             LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
407
396
  days+= mon_starts[isleap(a_year)]
408
397
                    [norm_month + (norm_month < 0 ? MONS_PER_YEAR : 0)];
409
398
#endif
845
834
time_t
846
835
Time_zone_db::TIME_to_gmt_sec(const DRIZZLE_TIME *t, bool *in_dst_time_gap) const
847
836
{
848
 
  return ::drizzled::TIME_to_gmt_sec(t, tz_info, in_dst_time_gap);
 
837
  return ::TIME_to_gmt_sec(t, tz_info, in_dst_time_gap);
849
838
}
850
839
 
851
840
 
861
850
void
862
851
Time_zone_db::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const
863
852
{
864
 
  ::drizzled::gmt_sec_to_TIME(tmp, t, tz_info);
 
853
  ::gmt_sec_to_TIME(tmp, t, tz_info);
865
854
}
866
855
 
867
856
 
1018
1007
static Time_zone_system tz_SYSTEM;
1019
1008
static Time_zone_offset tz_OFFSET0(0);
1020
1009
 
 
1010
Time_zone *my_tz_OFFSET0= &tz_OFFSET0;
 
1011
Time_zone *my_tz_UTC= &tz_UTC;
1021
1012
Time_zone *my_tz_SYSTEM= &tz_SYSTEM;
1022
1013
 
1023
 
class Tz_names_entry: public memory::SqlAlloc
 
1014
class Tz_names_entry: public Sql_alloc
1024
1015
{
1025
1016
public:
1026
1017
  String name;
1076
1067
  return false;
1077
1068
}
1078
1069
 
 
1070
 
 
1071
/*
 
1072
  Free resources used by time zone support infrastructure.
 
1073
*/
 
1074
 
 
1075
void my_tz_free()
 
1076
{
 
1077
}
 
1078
 
 
1079
 
 
1080
/*
 
1081
  Parse string that specifies time zone as offset from UTC.
 
1082
 
 
1083
  SYNOPSIS
 
1084
    str_to_offset()
 
1085
      str    - pointer to string which contains offset
 
1086
      length - length of string
 
1087
      offset - out parameter for storing found offset in seconds.
 
1088
 
 
1089
  DESCRIPTION
 
1090
    This function parses string which contains time zone offset
 
1091
    in form similar to '+10:00' and converts found value to
 
1092
    seconds from UTC form (east is positive).
 
1093
 
 
1094
  RETURN VALUE
 
1095
    0 - Ok
 
1096
    1 - String doesn't contain valid time zone offset
 
1097
*/
 
1098
bool
 
1099
str_to_offset(const char *str, uint32_t length, long *offset)
 
1100
{
 
1101
  const char *end= str + length;
 
1102
  bool negative;
 
1103
  ulong number_tmp;
 
1104
  long offset_tmp;
 
1105
 
 
1106
  if (length < 4)
 
1107
    return 1;
 
1108
 
 
1109
  if (*str == '+')
 
1110
    negative= 0;
 
1111
  else if (*str == '-')
 
1112
    negative= 1;
 
1113
  else
 
1114
    return 1;
 
1115
  str++;
 
1116
 
 
1117
  number_tmp= 0;
 
1118
 
 
1119
  while (str < end && my_isdigit(&my_charset_utf8_general_ci, *str))
 
1120
  {
 
1121
    number_tmp= number_tmp*10 + *str - '0';
 
1122
    str++;
 
1123
  }
 
1124
 
 
1125
  if (str + 1 >= end || *str != ':')
 
1126
    return 1;
 
1127
  str++;
 
1128
 
 
1129
  offset_tmp = number_tmp * MINS_PER_HOUR; number_tmp= 0;
 
1130
 
 
1131
  while (str < end && my_isdigit(&my_charset_utf8_general_ci, *str))
 
1132
  {
 
1133
    number_tmp= number_tmp * 10 + *str - '0';
 
1134
    str++;
 
1135
  }
 
1136
 
 
1137
  if (str != end)
 
1138
    return 1;
 
1139
 
 
1140
  offset_tmp= (offset_tmp + number_tmp) * SECS_PER_MIN;
 
1141
 
 
1142
  if (negative)
 
1143
    offset_tmp= -offset_tmp;
 
1144
 
 
1145
  /*
 
1146
    Check if offset is in range prescribed by standard
 
1147
    (from -12:59 to 13:00).
 
1148
  */
 
1149
 
 
1150
  if (number_tmp > 59 || offset_tmp < -13 * SECS_PER_HOUR + 1 ||
 
1151
      offset_tmp > 13 * SECS_PER_HOUR)
 
1152
    return 1;
 
1153
 
 
1154
  *offset= offset_tmp;
 
1155
 
 
1156
  return 0;
 
1157
}
 
1158
 
 
1159
 
1079
1160
/*
1080
1161
  Get Time_zone object for specified time zone.
1081
1162
 
1088
1169
{
1089
1170
  return NULL;
1090
1171
}
1091
 
 
1092
 
} /* namespace drizzled */