SqlDate.h File Reference

SqlDate. More...

Go to the source code of this file.

Enumerations
enum	SqlDateTimeType { SQLDATE, SQLTIME, SQLTIMESTAMP }
Functions
boost::posix_time::ptime const	epoc (boost::gregorian::date(1970, 1, 1))
int FENNEL_CALCULATOR_EXPORT	TimeToIsoString (char *dest, boost::posix_time::ptime t)
int FENNEL_CALCULATOR_EXPORT	DateToIsoString (char *dest, boost::posix_time::ptime t)
int FENNEL_CALCULATOR_EXPORT	TimestampToIsoString (char *dest, boost::posix_time::ptime t)
int64_t FENNEL_CALCULATOR_EXPORT	IsoStringToTime (char const *const src, int len)
int64_t FENNEL_CALCULATOR_EXPORT	IsoStringToDate (char const *const src, int len)
int64_t FENNEL_CALCULATOR_EXPORT	IsoStringToTimestamp (char const *const src, int len)
template<int CodeUnitBytes, int MaxCodeUnitsPerCodePoint, SqlDateTimeType dateTimeType>
int	SqlDateToStr (char *dest, int destStorageBytes, int64_t const d, bool fixed=false, int padchar= ' ')
template<int CodeUnitBytes, int MaxCodeUnitsPerCodePoint, SqlDateTimeType dateTimeType>
int64_t	SqlStrToDate (char *src, int len)
int64_t FENNEL_CALCULATOR_EXPORT	UniversalTime ()
	Returns time of day in UTC.
int64_t FENNEL_CALCULATOR_EXPORT	UniversalTimestamp ()
	Returns timestamp in UTC.
int64_t FENNEL_CALCULATOR_EXPORT	LocalTime (boost::local_time::time_zone_ptr tzPtr)
	Returns the time of day in the given time zone.
int64_t FENNEL_CALCULATOR_EXPORT	LocalTimestamp (boost::local_time::time_zone_ptr tzPtr)
	Returns the timestamp in the given time zone.

---

Detailed Description

SqlDate.

Definition in file SqlDate.h.

---

Enumeration Type Documentation

enum SqlDateTimeType

Enumerator:

SQLDATE
SQLTIME
SQLTIMESTAMP

Definition at line 53 of file SqlDate.h.

                     {
    SQLDATE,
    SQLTIME,
    SQLTIMESTAMP
};

---

Function Documentation

int FENNEL_CALCULATOR_EXPORT DateToIsoString	(	char *	dest,
		boost::posix_time::ptime	t
	)

Definition at line 47 of file SqlDate.cpp.

Referenced by SqlDateToStr().

{
    int y = t.date().year();
    int m =  t.date().month();
    int dy = t.date().day();
    return snprintf(dest,11, "%4d-%02d-%02d", y,m, dy);
}

boost::posix_time::ptime const epoc

(

boost::gregorian::

date(1970, 1, 1)

)

Referenced by IsoStringToDate(), IsoStringToTimestamp(), SqlDateToStr(), and UniversalTimestamp().

int64_t FENNEL_CALCULATOR_EXPORT IsoStringToDate	(	char const *const	src,
		int	len
	)

Definition at line 96 of file SqlDate.cpp.

References epoc(), milliseconds_per_day, and trimSpaces().

Referenced by SqlStrToDate(), and SqlDateTest::testSqlStrToDate_Ascii_Helper().

{
    std::string s(src,len);
    trimSpaces(s);

    boost::regex dateExp("\\d+-\\d+-\\d+");
    if (boost::regex_match(s, dateExp)) {
        try {
            date_duration td = boost::gregorian::from_string(s) - epoc.date();
            return td.days() * milliseconds_per_day;
        } catch (...) {
            // Fall through to throw
        }
    }

    // Parse of date failed
    // SQL2003 Part 2 Section 6.12 General Rule 13 data
    // exception -- invalid datetime format
    throw "22007";
}

int64_t FENNEL_CALCULATOR_EXPORT IsoStringToTime	(	char const *const	src,
		int	len
	)

Definition at line 117 of file SqlDate.cpp.

References min(), and trimSpaces().

Referenced by SqlStrToDate(), and SqlDateTest::testSqlStrToDate_Ascii_Helper().

{
    std::string s(src, len);
    trimSpaces(s);

    // TODO: Boost library doesn't catch invalid hour, min, sec
    // TODO: Try updated boost library to see if we can get
    // TODO: rid of this tiresome check
    boost::cmatch what;
    boost::regex timeExp("(\\d+):(\\d+):(\\d+)(\\.\\d+)?");
    if (boost::regex_match(s.c_str(), what, timeExp)) {
        try {
            int hour = atoi(what[1].first);
            int min = atoi(what[2].first);
            int sec = atoi(what[3].first);

            if ((hour >= 0) && (hour < 24) &&
                (min >= 0) && (min < 60) &&
                (sec >= 0) && (sec < 60)) {
                time_duration td = duration_from_string(s);
                return td.total_milliseconds();
            }
        } catch (...) {
            // Fall through to throw
        }
    }

    // Parse of time failed
    // SQL2003 Part 2 Section 6.12 General Rule 15,16 data
    // exception -- invalid datetime format
    throw "22007";
}

int64_t FENNEL_CALCULATOR_EXPORT IsoStringToTimestamp	(	char const *const	src,
		int	len
	)

Definition at line 150 of file SqlDate.cpp.

References epoc(), min(), and trimSpaces().

Referenced by SqlStrToDate(), and SqlDateTest::testSqlStrToDate_Ascii_Helper().

{
    std::string s(src, len);
    trimSpaces(s);

    // TODO: Boost library doesn't catch invalid hour, min, sec
    // TODO: Try updated boost library to see if we can get
    // TODO: rid of this tiresome check
    boost::cmatch what;
    boost::regex timestampExp("\\d+-\\d+-\\d+ +"
                       "(\\d+):(\\d+):(\\d+)(\\.\\d+)?");
    if (boost::regex_match(s.c_str(), what, timestampExp)) {
        try {
            int hour = atoi(what[1].first);
            int min = atoi(what[2].first);
            int sec = atoi(what[3].first);

            if ((hour >= 0) && (hour < 24) &&
                (min >= 0) && (min < 60) &&
                (sec >= 0) && (sec < 60)) {
                ptime p(time_from_string(s));
                time_duration td = p - epoc;
                return td.total_milliseconds();
            }
        } catch (...) {
            // Fall through to throw
        }
    }

    // Parse of timestamp failed
    // SQL2003 Part 2 Section 6.12 General Rule 17,18 data
    // exception -- invalid datetime format
    throw "22007";
}

int64_t FENNEL_CALCULATOR_EXPORT LocalTime

(

boost::local_time::time_zone_ptr

tzPtr

)

Returns the time of day in the given time zone.

Definition at line 203 of file SqlDate.cpp.

{
    local_date_time plocal = local_microsec_clock::local_time(tzPtr);
    return plocal.local_time().time_of_day().total_milliseconds();
}

int64_t FENNEL_CALCULATOR_EXPORT LocalTimestamp

(

boost::local_time::time_zone_ptr

tzPtr

)

Returns the timestamp in the given time zone.

Definition at line 209 of file SqlDate.cpp.

{
    // Create a local epoch. For PST, for example, the epoch is 1970/1/1 PST,
    // which occurred 8 hrs after the UTC epoch.
    date d(1970, 1, 1);
    time_duration td(0, 0, 0);
    local_date_time local_epoc(
        d, td, tzPtr, local_date_time::NOT_DATE_TIME_ON_ERROR);

    local_date_time plocal = local_microsec_clock::local_time(tzPtr);
    time_duration diff = plocal - local_epoc;

    // Adjust the difference if we are now in DST and the epoch is not, or vice
    // versa.
    if (plocal.is_dst()) {
        if (local_epoc.is_dst()) {
            // same offset: nothing to do
        } else {
            diff += tzPtr->dst_offset();
        }
    } else {
        if (local_epoc.is_dst()) {
            diff -= tzPtr->dst_offset();
        } else {
            // same offset: nothing to do
        }
    }
    return diff.total_milliseconds();
}

template<int CodeUnitBytes, int MaxCodeUnitsPerCodePoint, SqlDateTimeType dateTimeType>

int SqlDateToStr	(	char *	dest,
		int	destStorageBytes,
		int64_t const	d,
		bool	fixed = false,
		int	padchar = ' '
	)

Definition at line 80 of file SqlDate.h.

References DateToIsoString(), epoc(), fixed, SQLDATE, SQLTIME, SQLTIMESTAMP, TimestampToIsoString(), and TimeToIsoString().

{
    using namespace boost::posix_time;
    using namespace boost::gregorian;

    typedef boost::date_time::c_local_adjustor<boost::posix_time::ptime>
        local_adj;
    if (CodeUnitBytes == MaxCodeUnitsPerCodePoint) {
        if (CodeUnitBytes == 1) {
            // ASCII

            // from_time_t isn't in the version of boost we're using. sigh.
            // FIXME: jhyde: No longer true. Let's use it.
            //   boost::posix_time::ptime t = boost::posix_time::from_time_t(d);

            // we could use the millisecond() duration constructor,
            // instead of time_duration(...), but the time_duration was
            // the only way i could find didn't use an explicit long
            // parameter, instead of the type parameter, since
            // int64_t == (long long) on (fc1) linux.
            boost::posix_time::ptime t = epoc + time_duration(0,0,0,d);

            int len;
            char buf[20];
            switch (dateTimeType) {
            case SQLDATE:
                len = DateToIsoString(buf, t);
                if (len > destStorageBytes) {
                    // SQL99 Part 2 Section 6.22 General Rule 9.a.iii =>
                    // exception SQL99 22.1 22-001 "String Data Right
                    // truncation"
                    throw "22001";
                }
                memcpy(dest,buf,len);
                break;
            case SQLTIME:
                len = TimeToIsoString(buf, t);
                if (len > destStorageBytes) {
                    // SQL99 Part 2 Section 6.22 General Rule 9.a.iii =>
                    // exception SQL99 22.1 22-001 "String Data Right
                    // truncation"
                    throw "22001";
                }
                memcpy(dest,buf,len);
                break;
            case SQLTIMESTAMP:
                len = TimestampToIsoString(buf, t);
                if (len > destStorageBytes) {
                    // SQL99 Part 2 Section 6.22 General Rule 9.a.iii =>
                    // exception SQL99 22.1 22-001 "String Data Right
                    // truncation"
                    throw "22001";
                }
                memcpy(dest,buf,len);
                break;
            default:
                throw std::logic_error("bad dateTimeType" + dateTimeType);
            }

            if (fixed) {
                memset(dest + len, padchar, destStorageBytes - len);
                return destStorageBytes;
            } else {
                return len;
            }
        } else if (CodeUnitBytes == 2) {
            // TODO: Add UCS2 here
            throw std::logic_error("no UCS2");
        } else {
            throw std::logic_error("no such encoding");
        }
    } else {
        throw std::logic_error("no UTF8/16/32");
    }

}

template<int CodeUnitBytes, int MaxCodeUnitsPerCodePoint, SqlDateTimeType dateTimeType>

int64_t SqlStrToDate	(	char *	src,
		int	len
	)

Definition at line 167 of file SqlDate.h.

References IsoStringToDate(), IsoStringToTime(), IsoStringToTimestamp(), SQLDATE, SQLTIME, and SQLTIMESTAMP.

{
    using namespace boost::posix_time;
    using namespace boost::gregorian;

    if (CodeUnitBytes == MaxCodeUnitsPerCodePoint) {
        if (CodeUnitBytes == 1) {
            // ASCII

            switch (dateTimeType) {
            case SQLDATE:
                return IsoStringToDate(src,len);
            case SQLTIME:
                return IsoStringToTime(src,len);
            case SQLTIMESTAMP:
                return IsoStringToTimestamp(src,len);
            }
        } else if (CodeUnitBytes == 2) {
            // TODO: Add UCS2 here
            throw std::logic_error("no UCS2");
        } else {
            throw std::logic_error("no such encoding");
        }
    } else {
        throw std::logic_error("no UTF8/16/32");
    }
}

int FENNEL_CALCULATOR_EXPORT TimestampToIsoString	(	char *	dest,
		boost::posix_time::ptime	t
	)

Definition at line 65 of file SqlDate.cpp.

References min().

Referenced by SqlDateToStr().

{
    time_duration td = t.time_of_day();
    int h   = td.hours();
    int min = td.minutes();
    int s   = td.seconds();

    int y   = t.date().year();
    int mon = t.date().month();
    int dy  = t.date().day();
    return snprintf(
        dest, 20, "%4d-%02d-%02d %02d:%02d:%02d", y,mon, dy, h, min, s);
}

int FENNEL_CALCULATOR_EXPORT TimeToIsoString	(	char *	dest,
		boost::posix_time::ptime	t
	)

Definition at line 56 of file SqlDate.cpp.

Referenced by SqlDateToStr().

{
    time_duration td = t.time_of_day();
    int h = td.hours();
    int m = td.minutes();
    int s = td.seconds();
    return snprintf(dest,9, "%02d:%02d:%02d", h, m, s);
}

int64_t FENNEL_CALCULATOR_EXPORT UniversalTime

(

)

Returns time of day in UTC.

(This function used to be called CurrentTime, but as FNL-77 points out, that is misleading, because CurrentTime's result is in the local timezone.)

Definition at line 185 of file SqlDate.cpp.

Referenced by CurrentTime(), and SqlDateTest::testUniversalTime().

{
    ptime p = second_clock::universal_time();
    return p.time_of_day().total_milliseconds();
}

int64_t FENNEL_CALCULATOR_EXPORT UniversalTimestamp

(

)

Returns timestamp in UTC.

That is, milliseconds since 1970-1-1 00:00:00 UTC.

(This function used to be called CurrentTimestamp, but as FNL-77 points out, that is misleading, because CurrentTimestamp's result is in the local timezone.)

Definition at line 191 of file SqlDate.cpp.

References epoc().

Referenced by CurrentTimestamp(), and SqlDateTest::testUniversalTime().

{
    // REVIEW: SWZ: 4/30/2006: In practice, we should return the micro
    // second delta (or as much precision as we can muster) and let
    // the instruction (which may have been given an explicit
    // precision) truncate the fractional seconds.  For now, returning
    // millis causes Fennel Calc to behave like the Java Calc for
    // CURRENT_TIME[STAMP].
    ptime p = microsec_clock::universal_time();
    return (p - epoc).total_milliseconds();
}

---