← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/tztime.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

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"
 
21
#include <config.h>
22
22
#include <cstdio>
23
 
#include "drizzled/tzfile.h"
24
 
#include "drizzled/tztime.h"
25
 
#include "drizzled/gettext.h"
26
 
#include "drizzled/session.h"
27
 
#include "drizzled/time_functions.h"
 
23
#include <drizzled/tztime.h>
 
24
#include <drizzled/gettext.h>
 
25
#include <drizzled/session.h>
 
26
#include <drizzled/time_functions.h>
28
27
 
29
28
namespace drizzled
30
29
{
49
48
{
50
49
public:
51
50
  Time_zone_system() {}                       /* Remove gcc warning */
52
 
  virtual time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
53
 
                                    bool *in_dst_time_gap) const;
54
 
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const;
 
51
  virtual type::Time::epoch_t TIME_to_gmt_sec(const type::Time &t,
 
52
                                              bool *in_dst_time_gap) const;
 
53
  virtual void gmt_sec_to_TIME(type::Time &tmp, type::Time::epoch_t t) const;
55
54
  virtual const String * get_name() const;
56
55
};
57
56
 
58
57
 
59
58
/**
60
59
 * @brief
61
 
 * Converts local time in system time zone in DRIZZLE_TIME representation
62
 
 * to its time_t representation.
 
60
 * Converts local time in system time zone in type::Time representation
 
61
 * to its type::Time::epoch_t representation.
63
62
 *
64
63
 * @details
65
64
 * This method uses system function (localtime_r()) for conversion
66
 
 * local time in system time zone in DRIZZLE_TIME structure to its time_t
 
65
 * local time in system time zone in type::Time structure to its type::Time::epoch_t
67
66
 * representation. Unlike the same function for Time_zone_db class
68
67
 * it it won't handle unnormalized input properly. Still it will
69
 
 * return lowest possible time_t in case of ambiguity or if we
 
68
 * return lowest possible type::Time::epoch_t in case of ambiguity or if we
70
69
 * provide time corresponding to the time-gap.
71
70
 *
72
71
 * You should call init_time() function before using this function.
73
72
 *
74
 
 * @param   t               pointer to DRIZZLE_TIME structure with local time in
 
73
 * @param   t               pointer to type::Time structure with local time in
75
74
 *                          broken-down representation.
76
75
 * @param   in_dst_time_gap pointer to bool which is set to true if datetime
77
76
 *                          value passed doesn't really exist (i.e. falls into
78
77
 *                          spring time-gap) and is not touched otherwise.
79
78
 *
80
79
 * @return
81
 
 * Corresponding time_t value or 0 in case of error
 
80
 * Corresponding type::Time::epoch_t value or 0 in case of error
82
81
 */
83
 
time_t
84
 
Time_zone_system::TIME_to_gmt_sec(const DRIZZLE_TIME *t, bool *in_dst_time_gap) const
 
82
type::Time::epoch_t
 
83
Time_zone_system::TIME_to_gmt_sec(const type::Time &t, bool *in_dst_time_gap) const
85
84
{
86
85
  long not_used;
87
 
  return my_system_gmt_sec(t, &not_used, in_dst_time_gap);
 
86
  type::Time::epoch_t tmp;
 
87
  t.convert(tmp, &not_used, in_dst_time_gap);
 
88
  return tmp;
88
89
}
89
90
 
90
91
 
91
92
/**
92
93
 * @brief
93
 
 * Converts time from UTC seconds since Epoch (time_t) representation
 
94
 * Converts time from UTC seconds since Epoch (type::Time::epoch_t) representation
94
95
 * to system local time zone broken-down representation.
95
96
 *
96
 
 * @param    tmp   pointer to DRIZZLE_TIME structure to fill-in
97
 
 * @param    t     time_t value to be converted
 
97
 * @param    tmp   pointer to type::Time structure to fill-in
 
98
 * @param    t     type::Time::epoch_t value to be converted
98
99
 *
99
 
 * Note: We assume that value passed to this function will fit into time_t range
 
100
 * Note: We assume that value passed to this function will fit into type::Time::epoch_t range
100
101
 * supported by localtime_r. This conversion is putting restriction on
101
102
 * TIMESTAMP range in MySQL. If we can get rid of SYSTEM time zone at least
102
103
 * for interaction with client then we can extend TIMESTAMP range down to
103
104
 * the 1902 easily.
104
105
 */
105
106
void
106
 
Time_zone_system::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const
 
107
Time_zone_system::gmt_sec_to_TIME(type::Time &tmp, type::Time::epoch_t t) const
107
108
{
108
 
  struct tm tmp_tm;
109
 
  time_t tmp_t= (time_t)t;
110
 
 
111
 
  localtime_r(&tmp_t, &tmp_tm);
112
 
  localtime_to_TIME(tmp, &tmp_tm);
113
 
  tmp->time_type= DRIZZLE_TIMESTAMP_DATETIME;
 
109
  tmp.store(t);
114
110
}
115
111
 
116
112
 
131
127
 
132
128
Time_zone *my_tz_SYSTEM= &tz_SYSTEM;
133
129
 
134
 
 
135
 
/**
136
 
 * @brief
137
 
 * Initialize time zone support infrastructure.
138
 
 *
139
 
 * @details
140
 
 * This function will init memory structures needed for time zone support,
141
 
 * it will register mandatory SYSTEM time zone in them. It will try to open
142
 
 * mysql.time_zone* tables and load information about default time zone and
143
 
 * information which further will be shared among all time zones loaded.
144
 
 * If system tables with time zone descriptions don't exist it won't fail
145
 
 * (unless default_tzname is time zone from tables). If bootstrap parameter
146
 
 * is true then this routine assumes that we are in bootstrap mode and won't
147
 
 * load time zone descriptions unless someone specifies default time zone
148
 
 * which is supposedly stored in those tables.
149
 
 * It'll also set default time zone if it is specified.
150
 
 *
151
 
 * @param   session            current thread object
152
 
 * @param   default_tzname     default time zone or 0 if none.
153
 
 * @param   bootstrap          indicates whenever we are in bootstrap mode
154
 
 *
155
 
 * @return
156
 
 *  0 - ok
157
 
 *  1 - Error
158
 
 */
159
 
bool
160
 
my_tz_init(Session *session, const char *default_tzname)
161
 
{
162
 
  if (default_tzname)
163
 
  {
164
 
    String tmp_tzname2(default_tzname, &my_charset_utf8_general_ci);
165
 
    /*
166
 
      Time zone tables may be open here, and my_tz_find() may open
167
 
      most of them once more, but this is OK for system tables open
168
 
      for READ.
169
 
    */
170
 
    if (!(global_system_variables.time_zone= my_tz_find(session, &tmp_tzname2)))
171
 
    {
172
 
      errmsg_printf(ERRMSG_LVL_ERROR,
173
 
                    _("Fatal error: Illegal or unknown default time zone '%s'"),
174
 
                    default_tzname);
175
 
      return true;
176
 
    }
177
 
  }
178
 
 
179
 
  return false;
180
 
}
181
 
 
182
 
/**
183
 
 * @brief
184
 
 * Get Time_zone object for specified time zone.
185
 
 *
186
 
 * @todo
187
 
 * Not implemented yet. This needs to hook into some sort of OS system call.
188
 
 */
189
 
Time_zone *
190
 
my_tz_find(Session *,
191
 
           const String *)
192
 
{
193
 
  return NULL;
194
 
}
195
 
 
196
130
} /* namespace drizzled */