← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/tztime.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-03-21 01:02:23 UTC
  • mto: (960.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 961.
  • Revision ID: osullivan.padraig@gmail.com-20090321010223-j8cph7eeyt1u3xol
Fixed function object to ensure it correctly returns a boolean type since
memcmp returns an integer. Added some more comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/tztime.cc
1
 
/* Copyright (C) 2004 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
#ifdef USE_PRAGMA_IMPLEMENTATION
17
 
#pragma implementation                          // gcc: Class implementation
18
 
#endif
 
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
 
19
20
 
20
21
#include <drizzled/server_includes.h>
21
 
#include "tzfile.h"
 
22
#include <drizzled/tzfile.h>
 
23
#include <drizzled/tztime.h>
 
24
#include <drizzled/gettext.h>
 
25
#include <drizzled/session.h>
22
26
 
23
27
/* Structure describing local time type (e.g. Moscow summer time (MSD)) */
24
28
typedef struct ttinfo
35
39
/* Structure describing leap-second corrections. */
36
40
typedef struct lsinfo
37
41
{
38
 
  my_time_t ls_trans; // Transition time
 
42
  time_t ls_trans; // Transition time
39
43
  long      ls_corr;  // Correction to apply
40
44
} LS_INFO;
41
45
 
42
46
/*
43
 
  Structure with information describing ranges of my_time_t shifted to local
44
 
  time (my_time_t + offset). Used for local DRIZZLE_TIME -> my_time_t conversion.
 
47
  Structure with information describing ranges of time_t shifted to local
 
48
  time (time_t + offset). Used for local DRIZZLE_TIME -> time_t conversion.
45
49
  See comments for TIME_to_gmt_sec() for more info.
46
50
*/
47
51
typedef struct revtinfo
50
54
  uint32_t rt_type;    // Type of period 0 - Normal period. 1 - Spring time-gap
51
55
} REVT_INFO;
52
56
 
53
 
#ifdef TZNAME_MAX
54
 
#define MY_TZNAME_MAX   TZNAME_MAX
55
 
#endif
56
 
#ifndef TZNAME_MAX
57
 
#define MY_TZNAME_MAX   255
58
 
#endif
59
57
 
60
58
/*
61
59
  Structure which fully describes time zone which is
67
65
  uint32_t timecnt;  // Number of transitions between time types
68
66
  uint32_t typecnt;  // Number of local time types
69
67
  uint32_t charcnt;  // Number of characters used for abbreviations
70
 
  uint32_t revcnt;   // Number of transition descr. for TIME->my_time_t conversion
 
68
  uint32_t revcnt;   // Number of transition descr. for TIME->time_t conversion
71
69
  /* The following are dynamical arrays are allocated in MEM_ROOT */
72
 
  my_time_t *ats;       // Times of transitions between time types
 
70
  time_t *ats;       // Times of transitions between time types
73
71
  unsigned char *types; // Local time types for transitions
74
72
  TRAN_TYPE_INFO *ttis; // Local time types descriptions
75
73
  /* Storage for local time types abbreviations. They are stored as ASCIIZ */
80
78
  */
81
79
  LS_INFO *lsis;
82
80
  /*
83
 
    Starting points and descriptions of shifted my_time_t (my_time_t + offset)
84
 
    ranges on which shifted my_time_t -> my_time_t mapping is linear or undefined.
85
 
    Used for tm -> my_time_t conversion.
 
81
    Starting points and descriptions of shifted time_t (time_t + offset)
 
82
    ranges on which shifted time_t -> time_t mapping is linear or undefined.
 
83
    Used for tm -> time_t conversion.
86
84
  */
87
 
  my_time_t *revts;
 
85
  time_t *revts;
88
86
  REVT_INFO *revtis;
89
87
  /*
90
88
    Time type which is used for times smaller than first transition or if
118
116
 
119
117
 
120
118
/*
121
 
  Converts time from my_time_t representation (seconds in UTC since Epoch)
 
119
  Converts time from time_t representation (seconds in UTC since Epoch)
122
120
  to broken down representation using given local time zone offset.
123
121
 
124
122
  SYNOPSIS
125
123
    sec_to_TIME()
126
124
      tmp    - pointer to structure for broken down representation
127
 
      t      - my_time_t value to be converted
 
125
      t      - time_t value to be converted
128
126
      offset - local time zone offset
129
127
 
130
128
  DESCRIPTION
131
 
    Convert my_time_t with offset to DRIZZLE_TIME struct. Differs from timesub
 
129
    Convert time_t with offset to DRIZZLE_TIME struct. Differs from timesub
132
130
    (from elsie code) because doesn't contain any leap correction and
133
131
    TM_GMTOFF and is_dst setting and contains some MySQL specific
134
132
    initialization. Funny but with removing of these we almost have
135
133
    glibc's offtime function.
136
134
*/
137
135
static void
138
 
sec_to_TIME(DRIZZLE_TIME * tmp, my_time_t t, long offset)
 
136
sec_to_TIME(DRIZZLE_TIME * tmp, time_t t, long offset)
139
137
{
140
138
  long days;
141
139
  long rem;
148
146
 
149
147
  /*
150
148
    We do this as separate step after dividing t, because this
151
 
    allows us handle times near my_time_t bounds without overflows.
 
149
    allows us handle times near time_t bounds without overflows.
152
150
  */
153
151
  rem+= offset;
154
152
  while (rem < 0)
161
159
    rem -= SECS_PER_DAY;
162
160
    days++;
163
161
  }
164
 
  tmp->hour= (uint)(rem / SECS_PER_HOUR);
 
162
  tmp->hour= (uint32_t)(rem / SECS_PER_HOUR);
165
163
  rem= rem % SECS_PER_HOUR;
166
 
  tmp->minute= (uint)(rem / SECS_PER_MIN);
 
164
  tmp->minute= (uint32_t)(rem / SECS_PER_MIN);
167
165
  /*
168
166
    A positive leap second requires a special
169
167
    representation.  This uses "... ??:59:60" et seq.
170
168
  */
171
 
  tmp->second= (uint)(rem % SECS_PER_MIN);
 
169
  tmp->second= (uint32_t)(rem % SECS_PER_MIN);
172
170
 
173
171
  y= EPOCH_YEAR;
174
172
  while (days < 0 || days >= (long)year_lengths[yleap= isleap(y)])
189
187
  for (tmp->month= 0; days >= (long) ip[tmp->month]; tmp->month++)
190
188
    days= days - (long) ip[tmp->month];
191
189
  tmp->month++;
192
 
  tmp->day= (uint)(days + 1);
 
190
  tmp->day= (uint32_t)(days + 1);
193
191
 
194
192
  /* filling MySQL specific DRIZZLE_TIME members */
195
193
  tmp->neg= 0; tmp->second_part= 0;
198
196
 
199
197
 
200
198
/*
201
 
  Find time range wich contains given my_time_t value
 
199
  Find time range wich contains given time_t value
202
200
 
203
201
  SYNOPSIS
204
202
    find_time_range()
205
 
      t                - my_time_t value for which we looking for range
 
203
      t                - time_t value for which we looking for range
206
204
      range_boundaries - sorted array of range starts.
207
205
      higher_bound     - number of ranges
208
206
 
209
207
  DESCRIPTION
210
 
    Performs binary search for range which contains given my_time_t value.
211
 
    It has sense if number of ranges is greater than zero and my_time_t value
 
208
    Performs binary search for range which contains given time_t value.
 
209
    It has sense if number of ranges is greater than zero and time_t value
212
210
    is greater or equal than beginning of first range. It also assumes that
213
 
    t belongs to some range specified or end of last is MY_TIME_T_MAX.
 
211
    t belongs to some range specified.
214
212
 
215
213
    With this localtime_r on real data may takes less time than with linear
216
214
    search (I've seen 30% speed up).
219
217
    Index of range to which t belongs
220
218
*/
221
219
static uint
222
 
find_time_range(my_time_t t, const my_time_t *range_boundaries,
 
220
find_time_range(time_t t, const time_t *range_boundaries,
223
221
                uint32_t higher_bound)
224
222
{
225
223
  uint32_t i, lower_bound= 0;
248
246
}
249
247
 
250
248
/*
251
 
  Find local time transition for given my_time_t.
 
249
  Find local time transition for given time_t.
252
250
 
253
251
  SYNOPSIS
254
252
    find_transition_type()
255
 
      t   - my_time_t value to be converted
 
253
      t   - time_t value to be converted
256
254
      sp  - pointer to struct with time zone description
257
255
 
258
256
  RETURN VALUE
259
257
    Pointer to structure in time zone description describing
260
 
    local time type for given my_time_t.
 
258
    local time type for given time_t.
261
259
*/
262
260
static
263
261
const TRAN_TYPE_INFO *
264
 
find_transition_type(my_time_t t, const TIME_ZONE_INFO *sp)
 
262
find_transition_type(time_t t, const TIME_ZONE_INFO *sp)
265
263
{
266
264
  if (unlikely(sp->timecnt == 0 || t < sp->ats[0]))
267
265
  {
282
280
 
283
281
 
284
282
/*
285
 
  Converts time in my_time_t representation (seconds in UTC since Epoch) to
 
283
  Converts time in time_t representation (seconds in UTC since Epoch) to
286
284
  broken down DRIZZLE_TIME representation in local time zone.
287
285
 
288
286
  SYNOPSIS
289
287
    gmt_sec_to_TIME()
290
288
      tmp          - pointer to structure for broken down represenatation
291
 
      sec_in_utc   - my_time_t value to be converted
 
289
      sec_in_utc   - time_t value to be converted
292
290
      sp           - pointer to struct with time zone description
293
291
 
294
292
  TODO
298
296
    (60th and 61st second, look how we calculate them as "hit" in this
299
297
    function).
300
298
    Under realistic assumptions about frequency of transitions the same array
301
 
    can be used fot DRIZZLE_TIME -> my_time_t conversion. For this we need to
 
299
    can be used for DRIZZLE_TIME -> time_t conversion. For this we need to
302
300
    implement tweaked binary search which will take into account that some
303
 
    DRIZZLE_TIME has two matching my_time_t ranges and some of them have none.
 
301
    DRIZZLE_TIME has two matching time_t ranges and some of them have none.
304
302
*/
305
303
static void
306
 
gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t sec_in_utc, const TIME_ZONE_INFO *sp)
 
304
gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t sec_in_utc, const TIME_ZONE_INFO *sp)
307
305
{
308
306
  const TRAN_TYPE_INFO *ttisp;
309
307
  const LS_INFO *lp;
359
357
 
360
358
/*
361
359
  Converts local time in broken down representation to local
362
 
  time zone analog of my_time_t represenation.
 
360
  time zone analog of time_t represenation.
363
361
 
364
362
  SYNOPSIS
365
363
    sec_since_epoch()
366
364
      year, mon, mday, hour, min, sec - broken down representation.
367
365
 
368
366
  DESCRIPTION
369
 
    Converts time in broken down representation to my_time_t representation
 
367
    Converts time in broken down representation to time_t representation
370
368
    ignoring time zone. Note that we cannot convert back some valid _local_
371
 
    times near ends of my_time_t range because of my_time_t  overflow. But we
 
369
    times near ends of time_t range because of time_t overflow. But we
372
370
    ignore this fact now since MySQL will never pass such argument.
373
371
 
374
372
  RETURN VALUE
375
373
    Seconds since epoch time representation.
376
374
*/
377
 
static my_time_t
 
375
static time_t
378
376
sec_since_epoch(int year, int mon, int mday, int hour, int min ,int sec)
379
377
{
380
 
  /* Guard against my_time_t overflow(on system with 32 bit my_time_t) */
 
378
  /* Guard against time_t overflow (on system with 32 bit time_t) */
381
379
  assert(!(year == TIMESTAMP_MAX_YEAR && mon == 1 && mday > 17));
382
380
#ifndef WE_WANT_TO_HANDLE_UNORMALIZED_DATES
383
381
  /*
405
403
}
406
404
 
407
405
/*
408
 
  Converts local time in broken down DRIZZLE_TIME representation to my_time_t
 
406
  Converts local time in broken down DRIZZLE_TIME representation to time_t
409
407
  representation.
410
408
 
411
409
  SYNOPSIS
423
421
      has two answers it will give the smaller one
424
422
    - If we are in spring time gap then it will return
425
423
      beginning of the gap
426
 
    - It can give wrong results near the ends of my_time_t due to
 
424
    - It can give wrong results near the ends of time_t due to
427
425
      overflows, but we are safe since in MySQL we will never
428
426
      call this function for such dates (its restriction for year
429
427
      between 1970 and 2038 gives us several days of reserve).
447
445
 
448
446
    We use completely different approach. It is better since it is both
449
447
    faster than iterative implementations and fully determenistic. If you
450
 
    look at my_time_t to DRIZZLE_TIME conversion then you'll find that it consist
 
448
    look at time_t to DRIZZLE_TIME conversion then you'll find that it consist
451
449
    of two steps:
452
 
    The first is calculating shifted my_time_t value and the second - TIME
453
 
    calculation from shifted my_time_t value (well it is a bit simplified
454
 
    picture). The part in which we are interested in is my_time_t -> shifted
455
 
    my_time_t conversion. It is piecewise linear function which is defined
 
450
    The first is calculating shifted time_t value and the second - TIME
 
451
    calculation from shifted time_t value (well it is a bit simplified
 
452
    picture). The part in which we are interested in is time_t -> shifted
 
453
    time_t conversion. It is piecewise linear function which is defined
456
454
    by combination of transition times as break points and times offset
457
455
    as changing function parameter. The possible inverse function for this
458
456
    converison would be ambiguos but with MySQL's restrictions we can use
459
457
    some function which is the same as inverse function on unambigiuos
460
458
    ranges and coincides with one of branches of inverse function in
461
459
    other ranges. Thus we just need to build table which will determine
462
 
    this shifted my_time_t -> my_time_t conversion similar to existing
463
 
    (my_time_t -> shifted my_time_t table). We do this in
 
460
    this shifted time_t -> time_t conversion similar to existing
 
461
    (time_t -> shifted time_t table). We do this in
464
462
    prepare_tz_info function.
465
463
 
466
464
  TODO
476
474
    Seconds in UTC since Epoch.
477
475
    0 in case of error.
478
476
*/
479
 
static my_time_t
 
477
static time_t
480
478
TIME_to_gmt_sec(const DRIZZLE_TIME *t, const TIME_ZONE_INFO *sp,
481
479
                bool *in_dst_time_gap)
482
480
{
483
 
  my_time_t local_t;
 
481
  time_t local_t;
484
482
  uint32_t saved_seconds;
485
483
  uint32_t i;
486
484
  int shift= 0;
496
494
    saved_seconds= t->second;
497
495
 
498
496
  /*
499
 
    NOTE: to convert full my_time_t range we do a shift of the
500
 
    boundary dates here to avoid overflow of my_time_t.
 
497
    NOTE: to convert full time_t range we do a shift of the
 
498
    boundary dates here to avoid overflow of time_t.
501
499
    We use alike approach in my_system_gmt_sec().
502
500
 
503
501
    However in that function we also have to take into account
528
526
  if (local_t < sp->revts[0] || local_t > sp->revts[sp->revcnt])
529
527
  {
530
528
    /*
531
 
      This means that source time can't be represented as my_time_t due to
532
 
      limited my_time_t range.
 
529
      This means that source time can't be represented as time_t due to
 
530
      limited time_t range.
533
531
    */
534
532
    return(0);
535
533
  }
544
542
  */
545
543
  if (shift)
546
544
  {
547
 
    if (local_t > (my_time_t) (TIMESTAMP_MAX_VALUE - shift * SECS_PER_DAY +
548
 
                               sp->revtis[i].rt_offset - saved_seconds))
 
545
    if (local_t > (time_t) (TIMESTAMP_MAX_VALUE - shift * SECS_PER_DAY +
 
546
                            sp->revtis[i].rt_offset - saved_seconds))
549
547
    {
550
 
      return(0);                           /* my_time_t overflow */
 
548
      return(0);                           /* time_t overflow */
551
549
    }
552
550
    local_t+= shift * SECS_PER_DAY;
553
551
  }
557
555
    /*
558
556
      Oops! We are in spring time gap.
559
557
      May be we should return error here?
560
 
      Now we are returning my_time_t value corresponding to the
 
558
      Now we are returning time_t value corresponding to the
561
559
      beginning of the gap.
562
560
    */
563
561
    *in_dst_time_gap= 1;
600
598
{
601
599
public:
602
600
  Time_zone_system() {}                       /* Remove gcc warning */
603
 
  virtual my_time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
 
601
  virtual time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
604
602
                                    bool *in_dst_time_gap) const;
605
 
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const;
 
603
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const;
606
604
  virtual const String * get_name() const;
607
605
};
608
606
 
609
607
 
610
608
/*
611
609
  Converts local time in system time zone in DRIZZLE_TIME representation
612
 
  to its my_time_t representation.
 
610
  to its time_t representation.
613
611
 
614
612
  SYNOPSIS
615
613
    TIME_to_gmt_sec()
621
619
 
622
620
  DESCRIPTION
623
621
    This method uses system function (localtime_r()) for conversion
624
 
    local time in system time zone in DRIZZLE_TIME structure to its my_time_t
 
622
    local time in system time zone in DRIZZLE_TIME structure to its time_t
625
623
    representation. Unlike the same function for Time_zone_db class
626
624
    it it won't handle unnormalized input properly. Still it will
627
 
    return lowest possible my_time_t in case of ambiguity or if we
 
625
    return lowest possible time_t in case of ambiguity or if we
628
626
    provide time corresponding to the time-gap.
629
627
 
630
628
    You should call init_time() function before using this function.
631
629
 
632
630
  RETURN VALUE
633
 
    Corresponding my_time_t value or 0 in case of error
 
631
    Corresponding time_t value or 0 in case of error
634
632
*/
635
 
my_time_t
 
633
time_t
636
634
Time_zone_system::TIME_to_gmt_sec(const DRIZZLE_TIME *t, bool *in_dst_time_gap) const
637
635
{
638
636
  long not_used;
641
639
 
642
640
 
643
641
/*
644
 
  Converts time from UTC seconds since Epoch (my_time_t) representation
 
642
  Converts time from UTC seconds since Epoch (time_t) representation
645
643
  to system local time zone broken-down representation.
646
644
 
647
645
  SYNOPSIS
648
646
    gmt_sec_to_TIME()
649
647
      tmp - pointer to DRIZZLE_TIME structure to fill-in
650
 
      t   - my_time_t value to be converted
 
648
      t   - time_t value to be converted
651
649
 
652
650
  NOTE
653
651
    We assume that value passed to this function will fit into time_t range
657
655
    the 1902 easily.
658
656
*/
659
657
void
660
 
Time_zone_system::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const
 
658
Time_zone_system::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const
661
659
{
662
660
  struct tm tmp_tm;
663
661
  time_t tmp_t= (time_t)t;
687
685
/*
688
686
  Instance of this class represents UTC time zone. It uses system gmtime_r
689
687
  function for conversions and is always available. It is used only for
690
 
  my_time_t -> DRIZZLE_TIME conversions in various UTC_...  functions, it is not
691
 
  intended for DRIZZLE_TIME -> my_time_t conversions and shouldn't be exposed to user.
 
688
  time_t -> DRIZZLE_TIME conversions in various UTC_...  functions, it is not
 
689
  intended for DRIZZLE_TIME -> time_t conversions and shouldn't be exposed to user.
692
690
*/
693
691
class Time_zone_utc : public Time_zone
694
692
{
695
693
public:
696
694
  Time_zone_utc() {}                          /* Remove gcc warning */
697
 
  virtual my_time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
 
695
  virtual time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
698
696
                                    bool *in_dst_time_gap) const;
699
 
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const;
 
697
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const;
700
698
  virtual const String * get_name() const;
701
699
};
702
700
 
703
701
 
704
702
/*
705
 
  Convert UTC time from DRIZZLE_TIME representation to its my_time_t representation.
 
703
  Convert UTC time from DRIZZLE_TIME representation to its time_t representation.
706
704
 
707
705
  SYNOPSIS
708
706
    TIME_to_gmt_sec()
713
711
                        spring time-gap) and is not touched otherwise.
714
712
 
715
713
  DESCRIPTION
716
 
    Since Time_zone_utc is used only internally for my_time_t -> TIME
 
714
    Since Time_zone_utc is used only internally for time_t -> TIME
717
715
    conversions, this function of Time_zone interface is not implemented for
718
716
    this class and should not be called.
719
717
 
720
718
  RETURN VALUE
721
719
    0
722
720
*/
723
 
my_time_t
724
 
Time_zone_utc::TIME_to_gmt_sec(const DRIZZLE_TIME *t __attribute__((unused)),
725
 
                               bool *in_dst_time_gap __attribute__((unused))) const
 
721
time_t
 
722
Time_zone_utc::TIME_to_gmt_sec(const DRIZZLE_TIME *,
 
723
                               bool *) const
726
724
{
727
725
  /* Should be never called */
728
726
  assert(0);
731
729
 
732
730
 
733
731
/*
734
 
  Converts time from UTC seconds since Epoch (my_time_t) representation
 
732
  Converts time from UTC seconds since Epoch (time_t) representation
735
733
  to broken-down representation (also in UTC).
736
734
 
737
735
  SYNOPSIS
738
736
    gmt_sec_to_TIME()
739
737
      tmp - pointer to DRIZZLE_TIME structure to fill-in
740
 
      t   - my_time_t value to be converted
 
738
      t   - time_t value to be converted
741
739
 
742
740
  NOTE
743
741
    See note for apropriate Time_zone_system method.
744
742
*/
745
743
void
746
 
Time_zone_utc::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const
 
744
Time_zone_utc::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const
747
745
{
748
746
  struct tm tmp_tm;
749
747
  time_t tmp_t= (time_t)t;
784
782
{
785
783
public:
786
784
  Time_zone_db(TIME_ZONE_INFO *tz_info_arg, const String * tz_name_arg);
787
 
  virtual my_time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
 
785
  virtual time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
788
786
                                    bool *in_dst_time_gap) const;
789
 
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const;
 
787
  virtual void gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const;
790
788
  virtual const String * get_name() const;
791
789
private:
792
790
  TIME_ZONE_INFO *tz_info;
816
814
 
817
815
/*
818
816
  Converts local time in time zone described from TIME
819
 
  representation to its my_time_t representation.
 
817
  representation to its time_t representation.
820
818
 
821
819
  SYNOPSIS
822
820
    TIME_to_gmt_sec()
831
829
    parameter restrictions.
832
830
 
833
831
  RETURN VALUE
834
 
    Corresponding my_time_t value or 0 in case of error
 
832
    Corresponding time_t value or 0 in case of error
835
833
*/
836
 
my_time_t
 
834
time_t
837
835
Time_zone_db::TIME_to_gmt_sec(const DRIZZLE_TIME *t, bool *in_dst_time_gap) const
838
836
{
839
837
  return ::TIME_to_gmt_sec(t, tz_info, in_dst_time_gap);
841
839
 
842
840
 
843
841
/*
844
 
  Converts time from UTC seconds since Epoch (my_time_t) representation
 
842
  Converts time from UTC seconds since Epoch (time_t) representation
845
843
  to local time zone described in broken-down representation.
846
844
 
847
845
  SYNOPSIS
848
846
    gmt_sec_to_TIME()
849
847
      tmp - pointer to DRIZZLE_TIME structure to fill-in
850
 
      t   - my_time_t value to be converted
 
848
      t   - time_t value to be converted
851
849
*/
852
850
void
853
 
Time_zone_db::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const
 
851
Time_zone_db::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const
854
852
{
855
853
  ::gmt_sec_to_TIME(tmp, t, tz_info);
856
854
}
880
878
{
881
879
public:
882
880
  Time_zone_offset(long tz_offset_arg);
883
 
  virtual my_time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
 
881
  virtual time_t TIME_to_gmt_sec(const DRIZZLE_TIME *t,
884
882
                                    bool *in_dst_time_gap) const;
885
 
  virtual void   gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const;
 
883
  virtual void   gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const;
886
884
  virtual const String * get_name() const;
887
885
  /*
888
886
    This have to be public because we want to be able to access it from
917
915
 
918
916
/*
919
917
  Converts local time in time zone described as offset from UTC
920
 
  from DRIZZLE_TIME representation to its my_time_t representation.
 
918
  from DRIZZLE_TIME representation to its time_t representation.
921
919
 
922
920
  SYNOPSIS
923
921
    TIME_to_gmt_sec()
930
928
                        It is not really used in this class.
931
929
 
932
930
  RETURN VALUE
933
 
    Corresponding my_time_t value or 0 in case of error
 
931
    Corresponding time_t value or 0 in case of error
934
932
*/
935
 
my_time_t
 
933
time_t
936
934
Time_zone_offset::TIME_to_gmt_sec(const DRIZZLE_TIME *t,
937
 
                                  bool *in_dst_time_gap __attribute__((unused))) const
 
935
                                  bool *) const
938
936
{
939
 
  my_time_t local_t;
 
937
  time_t local_t;
940
938
  int shift= 0;
941
939
 
942
940
  /*
948
946
 
949
947
  /*
950
948
    Do a temporary shift of the boundary dates to avoid
951
 
    overflow of my_time_t if the time value is near it's
 
949
    overflow of time_t if the time value is near it's
952
950
    maximum range
953
951
  */
954
952
  if ((t->year == TIMESTAMP_MAX_YEAR) && (t->month == 1) && t->day > 4)
973
971
 
974
972
 
975
973
/*
976
 
  Converts time from UTC seconds since Epoch (my_time_t) representation
 
974
  Converts time from UTC seconds since Epoch (time_t) representation
977
975
  to local time zone described as offset from UTC and in broken-down
978
976
  representation.
979
977
 
980
978
  SYNOPSIS
981
979
    gmt_sec_to_TIME()
982
980
      tmp - pointer to DRIZZLE_TIME structure to fill-in
983
 
      t   - my_time_t value to be converted
 
981
      t   - time_t value to be converted
984
982
*/
985
983
void
986
 
Time_zone_offset::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, my_time_t t) const
 
984
Time_zone_offset::gmt_sec_to_TIME(DRIZZLE_TIME *tmp, time_t t) const
987
985
{
988
986
  sec_to_TIME(tmp, t, offset);
989
987
}
1026
1024
 
1027
1025
  SYNOPSIS
1028
1026
    my_tz_init()
1029
 
      thd            - current thread object
 
1027
      session            - current thread object
1030
1028
      default_tzname - default time zone or 0 if none.
1031
1029
      bootstrap      - indicates whenever we are in bootstrap mode
1032
1030
 
1047
1045
    1 - Error
1048
1046
*/
1049
1047
bool
1050
 
my_tz_init(THD *thd, const char *default_tzname,
1051
 
           bool bootstrap __attribute__((unused)))
 
1048
my_tz_init(Session *session, const char *default_tzname)
1052
1049
{
1053
1050
  if (default_tzname)
1054
1051
  {
1058
1055
      most of them once more, but this is OK for system tables open
1059
1056
      for READ.
1060
1057
    */
1061
 
    if (!(global_system_variables.time_zone= my_tz_find(thd, &tmp_tzname2)))
 
1058
    if (!(global_system_variables.time_zone= my_tz_find(session, &tmp_tzname2)))
1062
1059
    {
1063
 
      sql_print_error(_("Fatal error: Illegal or unknown default time zone '%s'"),
1064
 
                      default_tzname);
 
1060
      errmsg_printf(ERRMSG_LVL_ERROR,
 
1061
                    _("Fatal error: Illegal or unknown default time zone '%s'"),
 
1062
                    default_tzname);
1065
1063
      return true;
1066
1064
    }
1067
1065
  }
1166
1164
 
1167
1165
*/
1168
1166
Time_zone *
1169
 
my_tz_find(THD *thd __attribute__((unused)),
1170
 
           const String *name __attribute__((unused)))
 
1167
my_tz_find(Session *,
 
1168
           const String *)
1171
1169
{
1172
1170
  return NULL;
1173
1171
}