← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/temporal.cc

  • Committer: Patrick Crews
  • Date: 2011-01-29 14:17:35 UTC
  • mto: (2126.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2127.
  • Revision ID: gleebix@gmail.com-20110129141735-3y2658vt5ur0a33o
Fixes to make test-dbqp

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/temporal.cc
1
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
5
 *
6
6
 *  Authors:
7
7
 *
37
37
#include "config.h"
38
38
 
39
39
#include "drizzled/charset_info.h"
40
 
#include "drizzled/decimal.h"
 
40
#include "drizzled/type/decimal.h"
41
41
#include "drizzled/calendar.h"
42
42
#include "drizzled/temporal.h"
43
 
#ifdef NOTYETIMPLEMENTED
44
 
#include "drizzled/temporal_interval.h"
45
 
#endif
46
43
#include "drizzled/temporal_format.h"
47
44
#include "drizzled/time_functions.h"
48
45
#include "time.h"
49
46
 
 
47
#include <drizzled/util/gmtime.h>
 
48
 
50
49
#include <time.h>
51
50
 
 
51
#include <cstdio>
52
52
#include <ostream>
53
53
#include <iomanip>
54
54
#include <vector>
61
61
extern std::vector<TemporalFormat *> known_date_formats;
62
62
extern std::vector<TemporalFormat *> known_time_formats;
63
63
 
64
 
Temporal::Temporal()
65
 
:
66
 
  _calendar(GREGORIAN)
67
 
, _years(0)
68
 
, _months(0)
69
 
, _days(0)
70
 
, _hours(0)
71
 
, _minutes(0)
72
 
, _seconds(0)
73
 
, _epoch_seconds(0)
74
 
, _useconds(0)
75
 
, _nseconds(0)
76
 
, _overflow(false)
 
64
Temporal::Temporal() :
 
65
  _calendar(GREGORIAN),
 
66
  _years(0),
 
67
  _months(0),
 
68
  _days(0),
 
69
  _hours(0),
 
70
  _minutes(0),
 
71
  _seconds(0),
 
72
  _epoch_seconds(0),
 
73
  _useconds(0),
 
74
  _nseconds(0),
 
75
  _overflow(false)
77
76
{}
78
77
 
79
78
uint64_t Temporal::_cumulative_seconds_in_time() const
83
82
      + _seconds);
84
83
}
85
84
 
 
85
#if defined(TARGET_OS_SOLARIS)
 
86
/* @TODO: Replace this with Boost.DateTime */
 
87
static time_t timegm(struct tm *my_time)
 
88
{
 
89
        time_t local_secs, gm_secs;
 
90
        struct tm gm__rec, *gm_time;
 
91
 
 
92
        // Interpret 't' as the local time and convert it to seconds since the Epoch
 
93
        local_secs = mktime(my_time);
 
94
        if (local_secs == -1)
 
95
  {
 
96
                my_time->tm_hour--;
 
97
                local_secs = mktime (my_time);
 
98
                if (local_secs == -1)
 
99
                        return -1; 
 
100
                local_secs += 3600;
 
101
        }
 
102
        
 
103
        // Get the gmtime based on the local seconds since the Epoch
 
104
        gm_time = util::gmtime(local_secs, &gm__rec);
 
105
        gm_time->tm_isdst = 0;
 
106
        
 
107
        // Interpret gmtime as the local time and convert it to seconds since the Epoch
 
108
        gm_secs = mktime (gm_time);
 
109
        if (gm_secs == -1)
 
110
  {
 
111
                gm_time->tm_hour--;
 
112
                gm_secs = mktime (gm_time);
 
113
                if (gm_secs == -1)
 
114
                        return -1; 
 
115
                gm_secs += 3600;
 
116
        }
 
117
        
 
118
        // Return the local time adjusted by the difference from GM time.
 
119
        return (local_secs - (gm_secs - local_secs));
 
120
}
 
121
#endif
 
122
 
86
123
void Temporal::set_epoch_seconds()
87
124
{
88
125
  /* 
117
154
  TemporalFormat *current_format;
118
155
  std::vector<TemporalFormat *>::iterator current= known_date_formats.begin();
119
156
 
 
157
  _useconds= 0; // We may not match on it, so we need to make sure we zero it out.
120
158
  while (current != known_date_formats.end())
121
159
  {
122
160
    current_format= *current;
795
833
 
796
834
  return *this;
797
835
}
798
 
#ifdef NOTYETIMPLEMENTED
799
 
Date& Date::operator+=(const TemporalIntervalYear &rhs)
800
 
{
801
 
  /* Simple one...add the years and adjust for any leaps */
802
 
  int64_t new_years= _years;
803
 
  new_years+= rhs._years;
804
 
  if (new_years > DRIZZLE_MAX_YEARS_SQL)
805
 
  {
806
 
    /* 
807
 
     * Set everything to zero. We got an overflow.
808
 
     * @TODO Exceptions would be great here...
809
 
     */
810
 
    _reset();
811
 
    _overflow= true;
812
 
    return *this;
813
 
  }
814
 
  _years= (uint32_t) new_years;
815
 
  if (_months == 2 && _days == 29 && days_in_gregorian_year_month(_years, _months) != 366)
816
 
    _days= 28;
817
 
  return *this;
818
 
} 
819
 
 
820
 
Date& Date::operator-=(const TemporalIntervalYear &rhs)
821
 
{
822
 
  /* Simple one...subtract the years and adjust for any leaps */
823
 
  int64_t new_years= _years;
824
 
  new_years-= rhs._years;
825
 
  if (new_years < 0)
826
 
  {
827
 
    /* 
828
 
     * Set everything to zero. We got an overflow.
829
 
     * @TODO Exceptions would be great here...
830
 
     */
831
 
    _reset();
832
 
    _overflow= true;
833
 
    return *this;
834
 
  }
835
 
  _years= (uint32_t) new_years;
836
 
  if (_months == 2 && _days == 29 && days_in_gregorian_year_month(_years, _months) != 366)
837
 
    _days= 28;
838
 
  return *this;
839
 
} 
840
 
 
841
 
Date& Date::operator+=(const TemporalIntervalDayOrWeek &rhs)
842
 
{
843
 
  /* Simple one...add the days */
844
 
  int64_t julian_day= julian_day_number_from_gregorian_date(_years, _months, _days) + rhs._days;
845
 
  gregorian_date_from_julian_day_number(julian_day, &_years, &_months, &_days);
846
 
  return *this;
847
 
} 
848
 
 
849
 
Date& Date::operator-=(const TemporalIntervalDayOrWeek &rhs)
850
 
{
851
 
  /* Simple one...subtract the days */
852
 
  int64_t julian_day= julian_day_number_from_gregorian_date(_years, _months, _days) - rhs._days;
853
 
  gregorian_date_from_julian_day_number(julian_day, &_years, &_months, &_days);
854
 
  return *this;
855
 
} 
856
 
 
857
 
Date& Date::operator+=(const TemporalIntervalYearMonth &rhs)
858
 
{
859
 
  /* Simple one...add the months in the period adjust */
860
 
  int64_t period= (_years * 12) + (rhs._years * 12) + (_months - 1) + rhs._months;
861
 
  int64_t new_years= (period / 12);
862
 
  if (new_years > DRIZZLE_MAX_YEARS_SQL)
863
 
  {
864
 
    /* 
865
 
     * Set everything to zero. We got an overflow.
866
 
     * @TODO Exceptions would be great here...
867
 
     */
868
 
    _reset();
869
 
    _overflow= true;
870
 
    return *this;
871
 
  }
872
 
  _years= (uint32_t) new_years;
873
 
  _months= (uint32_t) (period % 12) + 1;
874
 
  
875
 
  /* Adjust day if the new month doesn't have enough days */
876
 
  uint32_t days_in_new_month= days_in_gregorian_year_month(_years, _months);
877
 
  if (_days > days_in_new_month)
878
 
    _days= days_in_new_month;
879
 
  return *this;
880
 
} 
881
 
 
882
 
Date& Date::operator-=(const TemporalIntervalYearMonth &rhs)
883
 
{
884
 
  /* Simple one...subtract the months in the period and adjust */
885
 
  int64_t period= (_years * 12) - (rhs._years * 12) + (_months - 1) - rhs._months;
886
 
  int64_t new_years= (period / 12);
887
 
  if (new_years < 0)
888
 
  {
889
 
    /* 
890
 
     * Set everything to zero. We got an overflow.
891
 
     * @TODO Exceptions would be great here...
892
 
     */
893
 
    _reset();
894
 
    _overflow= true;
895
 
    return *this;
896
 
  }
897
 
  _years= (uint32_t) (period / 12);
898
 
  _months= (uint32_t) (period % 12) + 1;
899
 
  
900
 
  /* Adjust day if the new month doesn't have enough days */
901
 
  uint32_t days_in_new_month= days_in_gregorian_year_month(_years, _months);
902
 
  if (_days > days_in_new_month)
903
 
    _days= days_in_new_month;
904
 
  return *this;
905
 
} 
906
 
 
907
 
Date& Date::operator+=(const TemporalIntervalDayOrLess &rhs)
908
 
{
909
 
  /* 
910
 
   * Convert the temporal and the interval into a number of 
911
 
   * microseconds, then add them together and convert the
912
 
   * resulting microseconds back into a broken-down temporal
913
 
   * component.
914
 
   */
915
 
  int64_t new_seconds;
916
 
  int64_t new_microseconds;
917
 
  int64_t extra_sec;
918
 
  int64_t new_days;
919
 
  new_microseconds= _useconds + rhs._useconds;
920
 
  extra_sec= new_microseconds / INT64_C(1000000);
921
 
  new_microseconds= new_microseconds % INT64_C(1000000);
922
 
 
923
 
  new_seconds= ((_days - 1) * 3600 * 24) + (_hours * 3600) + (_minutes * 60) + _seconds;
924
 
  new_seconds+= (rhs._days * 3600 * 24) + (rhs._hours * 3600) + (rhs._minutes * 60) + rhs._seconds;
925
 
  new_seconds+= extra_sec;
926
 
 
927
 
  if (new_microseconds < 0)
928
 
  {
929
 
    new_microseconds+= INT64_C(1000000);
930
 
    new_seconds--;
931
 
  }
932
 
  
933
 
  new_days= new_seconds / (3600 * 24L);
934
 
  new_seconds-= new_days * 3600 * 24L;
935
 
  if (new_seconds < 0)
936
 
  {
937
 
    new_days--;
938
 
    new_seconds+= 3600 * 24L;
939
 
  }
940
 
  _useconds= (uint32_t) new_microseconds;
941
 
  _seconds= (uint32_t) (new_seconds % 60);
942
 
  _minutes= (uint32_t) ((new_seconds / 60) % 60);
943
 
  _hours= (uint32_t) (new_seconds / 3600);
944
 
  int64_t julian_day= julian_day_number_from_gregorian_date(_years, _months, 1) + new_days;
945
 
  gregorian_date_from_julian_day_number(julian_day, &_years, &_months, &_days);
946
 
  return *this;
947
 
}
948
 
 
949
 
Date& Date::operator-=(const TemporalIntervalDayOrLess &rhs)
950
 
{
951
 
  /* 
952
 
   * Convert the temporal and the interval into a number of 
953
 
   * microseconds, then subtract them from each other and convert 
954
 
   * the resulting microseconds back into a broken-down temporal
955
 
   * component.
956
 
   */
957
 
  int64_t new_seconds;
958
 
  int64_t new_microseconds;
959
 
  int64_t extra_sec;
960
 
  int64_t new_days;
961
 
  new_microseconds= _useconds - rhs._useconds;
962
 
  extra_sec= new_microseconds / INT64_C(1000000);
963
 
  new_microseconds= new_microseconds % INT64_C(1000000);
964
 
 
965
 
  new_seconds= ((_days - 1) * 3600 * 24) + (_hours * 3600) + (_minutes * 60) + _seconds;
966
 
  new_seconds-= (rhs._days * 3600 * 24) + (rhs._hours * 3600) + (rhs._minutes * 60) + rhs._seconds;
967
 
  new_seconds+= extra_sec;
968
 
 
969
 
  if (new_microseconds < 0)
970
 
  {
971
 
    new_microseconds+= INT64_C(1000000);
972
 
    new_seconds--;
973
 
  }
974
 
  
975
 
  new_days= new_seconds / (3600 * 24L);
976
 
  new_seconds-= new_days * 3600 * 24L;
977
 
  if (new_seconds < 0)
978
 
  {
979
 
    new_days--;
980
 
    new_seconds+= 3600 * 24L;
981
 
  }
982
 
  _useconds= (uint32_t) new_microseconds;
983
 
  _seconds= (uint32_t) (new_seconds % 60);
984
 
  _minutes= (uint32_t) ((new_seconds / 60) % 60);
985
 
  _hours= (uint32_t) (new_seconds / 3600);
986
 
  int64_t julian_day= julian_day_number_from_gregorian_date(_years, _months, 1) + new_days;
987
 
  gregorian_date_from_julian_day_number(julian_day, &_years, &_months, &_days);
988
 
  return *this;
989
 
}
990
 
#endif /* NOTYETIMPLEMENTED */
 
836
 
991
837
/*
992
838
 * Comparison operators between a Date and a Timestamp
993
839
 */
1019
865
}
1020
866
bool Date::operator>(const Timestamp& rhs)
1021
867
{
1022
 
  return ! (*this < rhs);
 
868
  return ! (*this <= rhs);
1023
869
}
1024
870
bool Date::operator>=(const Timestamp& rhs)
1025
871
{
1026
 
  return ! (*this <= rhs);
 
872
  return ! (*this < rhs);
1027
873
}
1028
874
/*
1029
875
 * Comparison operators between a Timestamp and a Date
1056
902
}
1057
903
bool Timestamp::operator>(const Date& rhs)
1058
904
{
1059
 
  return ! (*this < rhs);
 
905
  return ! (*this <= rhs);
1060
906
}
1061
907
bool Timestamp::operator>=(const Date& rhs)
1062
908
{
1063
 
  return ! (*this <= rhs);
 
909
  return ! (*this < rhs);
1064
910
}
1065
911
/*
1066
912
 * Comparison operators between a Timestamp and a DateTime
1109
955
}
1110
956
bool Timestamp::operator>(const DateTime& rhs)
1111
957
{
1112
 
  return ! (*this < rhs);
 
958
  return ! (*this <= rhs);
1113
959
}
1114
960
bool Timestamp::operator>=(const DateTime& rhs)
1115
961
{
1116
 
  return ! (*this <= rhs);
 
962
  return ! (*this < rhs);
1117
963
}
1118
964
/*
1119
965
 * Comparison operators between two Timestamps
1136
982
}
1137
983
bool Timestamp::operator>(const Timestamp& rhs)
1138
984
{
1139
 
  return ! (*this < rhs);
 
985
  return ! (*this <= rhs);
1140
986
}
1141
987
bool Timestamp::operator>=(const Timestamp& rhs)
1142
988
{
1143
 
  return ! (*this <= rhs);
 
989
  return ! (*this < rhs);
1144
990
}
1145
991
 
1146
992
/**
1181
1027
    current++;
1182
1028
  }
1183
1029
 
1184
 
  if (! matched)
 
1030
  if (not matched)
1185
1031
    return false;
1186
 
  else
1187
 
    return is_valid();
 
1032
 
 
1033
  return is_fuzzy_valid();
1188
1034
}
1189
1035
 
1190
1036
int Time::to_string(char *to, size_t to_len) const
1225
1071
int MicroTimestamp::to_string(char *to, size_t to_len) const
1226
1072
{
1227
1073
  return snprintf(to, to_len,
1228
 
                  "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32
1229
 
                      " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
1230
 
                  _years, _months, _days,
1231
 
                  _hours, _minutes, _seconds, _useconds);
 
1074
                  "%04" PRIu32 "-%02" PRIu32 "-%02" PRIu32
 
1075
                  " %02" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%06" PRIu32,
 
1076
                  _years, _months, _days,
 
1077
                  _hours, _minutes, _seconds, _useconds);
1232
1078
}
1233
1079
 
1234
 
void Time::to_decimal(my_decimal *to) const
 
1080
void Time::to_decimal(type::Decimal *to) const
1235
1081
{
1236
1082
  int64_t time_portion= (((_hours * 100L) + _minutes) * 100L) + _seconds;
1237
 
  (void) int2my_decimal(E_DEC_FATAL_ERROR, time_portion, false, to);
 
1083
  (void) int2_class_decimal(E_DEC_FATAL_ERROR, time_portion, false, to);
1238
1084
  if (_useconds > 0)
1239
1085
  {
1240
1086
    to->buf[(to->intg-1) / 9 + 1]= _useconds * 1000;
1242
1088
  }
1243
1089
}
1244
1090
 
1245
 
void Date::to_decimal(my_decimal *to) const
 
1091
void Date::to_decimal(type::Decimal *to) const
1246
1092
{
1247
1093
  int64_t date_portion= (((_years * 100L) + _months) * 100L) + _days;
1248
 
  (void) int2my_decimal(E_DEC_FATAL_ERROR, date_portion, false, to);
 
1094
  (void) int2_class_decimal(E_DEC_FATAL_ERROR, date_portion, false, to);
1249
1095
}
1250
1096
 
1251
 
void DateTime::to_decimal(my_decimal *to) const
 
1097
void DateTime::to_decimal(type::Decimal *to) const
1252
1098
{
1253
1099
  int64_t date_portion= (((_years * 100L) + _months) * 100L) + _days;
1254
1100
  int64_t time_portion= (((((date_portion * 100L) + _hours) * 100L) + _minutes) * 100L) + _seconds;
1255
 
  (void) int2my_decimal(E_DEC_FATAL_ERROR, time_portion, false, to);
 
1101
  (void) int2_class_decimal(E_DEC_FATAL_ERROR, time_portion, false, to);
1256
1102
  if (_useconds > 0)
1257
1103
  {
1258
1104
    to->buf[(to->intg-1) / 9 + 1]= _useconds * 1000;
1281
1127
     + _seconds;
1282
1128
}
1283
1129
 
 
1130
// We fill the structure based on just int
 
1131
void Time::to_uint64_t(uint64_t &to) const
 
1132
{
 
1133
  to= _hours * 24
 
1134
     + _minutes * 60
 
1135
     + _seconds;
 
1136
}
 
1137
 
1284
1138
void DateTime::to_int64_t(int64_t *to) const
1285
1139
{
1286
1140
  *to= ((
1341
1195
bool Time::from_int32_t(const int32_t from)
1342
1196
{
1343
1197
  uint32_t copy_from= (uint32_t) from;
1344
 
  _hours= copy_from % INT32_C(10000);
1345
 
  _minutes= copy_from % INT32_C(100);
1346
 
  _seconds= copy_from & 3; /* Masks off all but last 2 digits */
 
1198
  _hours= copy_from / INT32_C(10000);
 
1199
  _minutes= (copy_from % INT32_C(10000)) / INT32_C(100);
 
1200
  _seconds= copy_from % INT32_C(100); /* Masks off all but last 2 digits */
1347
1201
  return is_valid();
1348
1202
}
1349
1203
 
1382
1236
    else if (copy_from <  DRIZZLE_YY_PART_YEAR * 10000000000LL + 101000000LL)
1383
1237
      return false;
1384
1238
    else if (copy_from <= 991231235959LL)
1385
 
      copy_from= copy_from + 19000000000000LL;          /* YYMMDDHHMMSS, 1970-1999 */
 
1239
      copy_from= copy_from + 19000000000000LL;    /* YYMMDDHHMMSS, 1970-1999 */
1386
1240
  }
1387
1241
 
1388
1242
  part1= (int64_t) (copy_from / 1000000LL);
1437
1291
  struct tm broken_time;
1438
1292
  struct tm *result;
1439
1293
 
1440
 
  result= gmtime_r(&from, &broken_time);
 
1294
  result= util::gmtime(from, &broken_time);
1441
1295
  if (result != NULL)
1442
1296
  {
1443
1297
    _years= 0;
1461
1315
  struct tm broken_time;
1462
1316
  struct tm *result;
1463
1317
 
1464
 
  result= gmtime_r(&from, &broken_time);
 
1318
  result= util::gmtime(from, &broken_time);
1465
1319
  if (result != NULL)
1466
1320
  {
1467
1321
    _years= 1900 + broken_time.tm_year;
1480
1334
    return false;
1481
1335
}
1482
1336
 
 
1337
bool DateTime::from_timeval(struct timeval &timeval_arg)
 
1338
{
 
1339
  struct tm broken_time;
 
1340
  struct tm *result;
 
1341
 
 
1342
  result= util::gmtime(timeval_arg.tv_sec, &broken_time);
 
1343
  if (result != NULL)
 
1344
  {
 
1345
    _years= 1900 + broken_time.tm_year;
 
1346
    _months= 1 + broken_time.tm_mon; /* Month is NOT ordinal for struct tm! */
 
1347
    _days= broken_time.tm_mday; /* Day IS ordinal for struct tm */
 
1348
    _hours= broken_time.tm_hour;
 
1349
    _minutes= broken_time.tm_min;
 
1350
    _seconds= broken_time.tm_sec;
 
1351
    _epoch_seconds= timeval_arg.tv_sec;
 
1352
    /* Set hires precision to zero */
 
1353
    _useconds= timeval_arg.tv_usec;
 
1354
    _nseconds= 0;
 
1355
    return is_valid();
 
1356
  }
 
1357
  else 
 
1358
  {
 
1359
    return false;
 
1360
  }
 
1361
}
 
1362
 
1483
1363
bool DateTime::from_time_t(const time_t from)
1484
1364
{
1485
1365
  struct tm broken_time;
1486
1366
  struct tm *result;
1487
1367
 
1488
 
  result= gmtime_r(&from, &broken_time);
 
1368
  result= util::gmtime(from, &broken_time);
1489
1369
  if (result != NULL)
1490
1370
  {
1491
1371
    _years= 1900 + broken_time.tm_year;
1501
1381
    return is_valid();
1502
1382
  }
1503
1383
  else 
 
1384
  {
1504
1385
    return false;
 
1386
  }
1505
1387
}
1506
1388
 
1507
 
void Date::to_time_t(time_t *to) const
 
1389
void Date::to_time_t(time_t &to) const
1508
1390
{
1509
1391
  if (in_unix_epoch())
1510
1392
  {
1511
 
    *to= _epoch_seconds;
 
1393
    to= _epoch_seconds;
1512
1394
  }
1513
1395
  else
1514
 
    *to= 0;
1515
 
}
1516
 
 
1517
 
void Timestamp::to_time_t(time_t *to) const
1518
 
{
1519
 
  *to= _epoch_seconds;
1520
 
}
1521
 
 
1522
 
void MicroTimestamp::to_timeval(struct timeval *to) const
1523
 
{
1524
 
  to->tv_sec= _epoch_seconds;
1525
 
  to->tv_usec= _useconds;
 
1396
  {
 
1397
    to= 0;
 
1398
  }
 
1399
}
 
1400
 
 
1401
void Timestamp::to_time_t(time_t &to) const
 
1402
{
 
1403
  to= _epoch_seconds;
 
1404
}
 
1405
 
 
1406
void MicroTimestamp::to_timeval(struct timeval &to) const
 
1407
{
 
1408
  to.tv_sec= _epoch_seconds;
 
1409
  to.tv_usec= _useconds;
1526
1410
}
1527
1411
 
1528
1412
void NanoTimestamp::to_timespec(struct timespec *to) const
1548
1432
      && (_seconds <= 59); /* No Leap second... TIME is for elapsed time... */
1549
1433
}
1550
1434
 
 
1435
bool Time::is_fuzzy_valid() const
 
1436
{
 
1437
  if (is_valid())
 
1438
    return true;
 
1439
 
 
1440
  return (_years >= DRIZZLE_MIN_YEARS_SQL && _years <= DRIZZLE_MAX_YEARS_SQL)
 
1441
      && (_months >= 1 && _months <= 12)
 
1442
      && (_days >= 1 && _days <= days_in_gregorian_year_month(_years, _months))
 
1443
      && (_hours <= 23)
 
1444
      && (_minutes <= 59)
 
1445
      && (_seconds <= 59); /* No Leap second... TIME is for elapsed time... */
 
1446
}
 
1447
 
1551
1448
bool DateTime::is_valid() const
1552
1449
{
1553
1450
  return (_years >= DRIZZLE_MIN_YEARS_SQL && _years <= DRIZZLE_MAX_YEARS_SQL)
1561
1458
bool Timestamp::is_valid() const
1562
1459
{
1563
1460
  return DateTime::is_valid() 
1564
 
      && in_unix_epoch_range(_years, _months, _days, _hours, _minutes, _seconds);
 
1461
      && in_unix_epoch_range(_years, _months, _days, _hours, _minutes, _seconds)
 
1462
      && (_seconds <= 59);
1565
1463
}
1566
1464
 
1567
1465
bool MicroTimestamp::is_valid() const