| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| ************************************************************************** |
| * |
| * File: DatetimeType.cpp |
| * Description: Datetime type |
| * Created: 2/2/96 |
| * Language: C++ |
| * |
| * |
| ************************************************************************** |
| */ |
| |
| // ----------------------------------------------------------------------- |
| |
| #include <ctype.h> |
| #include <math.h> |
| |
| #include "DatetimeType.h" |
| #include "NumericType.h" |
| #include "str.h" |
| #include "exp_clause_derived.h" |
| #include "exp_datetime.h" |
| |
| #include <cextdecs/cextdecs.h> |
| |
| NAString LiteralDate("DATE"); |
| NAString LiteralTime("TIME"); |
| NAString LiteralTimestamp("TIMESTAMP"); |
| NAString LiteralDateTime("DATETIME"); |
| NAString DEFAULT_DATE_DISPLAY_FORMAT("YYYY-MM-DD"); |
| |
| |
| //*********************************************************************** |
| // Static data initializations. |
| //*********************************************************************** |
| |
| // Note that ANSI 6.1 GR 4 indicates that SECONDS can occasionally |
| // include one or two extra leap seconds in a minute, so sometimes |
| // it will be legal for SECONDS to be 60 or 61. We'll deal with that |
| // later however, in some DatetimeValue::validateTime() method to |
| // be called by scanTime(), and adjust the check in DatetimeValue::scanField. |
| // |
| // The string literal values are in the ANSI 5.3 format (FORMAT_DEFAULT below). |
| // |
| static const UInt32 maxFieldLen[] = { 4, 2, 2, 2, 2, 2, DatetimeType::MAX_FRACTION_PRECISION }; |
| static const UInt32 storageLen[] = { 2, 1, 1, 1, 1, 1, 4 }; |
| static const ULng32 minValue[] = { 0001, 01, 01, 00, 00, 00, 000000 }; |
| static const ULng32 maxValue[] = { 9999, 12, 31, 23, 59, 59, 999999 }; |
| static const char minValueString[] = "0001-01-01 00:00:00.000000"; |
| static const char maxValueString[] = "9999-12-31 23:59:59.999999"; |
| static const size_t valueStringLen = /*123456789012345678901234567*/ 27; |
| static const char precedingPunc[] = "^-- ::."; |
| // ^ is placeholder, as there is no |
| // punctuation before YEAR, of course. |
| static const UInt32 daysInMonth[] = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; |
| |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : Constructors and accessors |
| // |
| // *********************************************************************** |
| |
| DatetimeType::DatetimeType (NAMemory *h, const NAString & adtName, |
| NABoolean allowSQLnull, |
| rec_datetime_field startField, |
| rec_datetime_field endField, |
| UInt32 fractionPrecision) |
| : DatetimeIntervalCommonType (h, adtName, |
| NA_DATETIME_TYPE, |
| getStorageSize(startField, |
| endField, |
| fractionPrecision), |
| allowSQLnull, |
| startField, |
| endField, |
| fractionPrecision, |
| 1 /* no data alignment */ |
| ) |
| , displayFormat_(h) |
| { |
| assert(validate(startField, endField, fractionPrecision) != SUBTYPE_ILLEGAL); |
| } |
| |
| |
| |
| short DatetimeType::getFSDatatype() const |
| { |
| return REC_DATETIME; |
| } |
| |
| NAString DatetimeType::getSimpleTypeName() const |
| { |
| return getTypeName(); |
| } |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : Virtual methods |
| // |
| // *********************************************************************** |
| |
| NABoolean DatetimeType::isCompatible(const NAType& other, UInt32 * flags) const |
| { |
| // DATEs are compatible only with DATEs, TIMEs with TIMEs, TIMESTAMPS w/ TS. |
| // |
| if (NOT NAType::isCompatible(other, flags)) |
| return FALSE; |
| |
| // DATE/TIME, TIMESTAMP/TIME are not compatible. All others are. |
| if (getStartField() != ((DatetimeType&) other).getStartField()) |
| return FALSE; |
| |
| NABoolean allowIncompOper = |
| ((flags) && ((*flags & NAType::ALLOW_INCOMP_OPER) != 0)); |
| const DatetimeType* datetime2 = (DatetimeType*) &other; |
| if (NOT allowIncompOper) |
| { |
| if (getEndField() == datetime2->getEndField()) |
| return TRUE; |
| else |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| #if defined( NA_LITTLE_ENDIAN ) |
| NABoolean DatetimeType::isEncodingNeeded() const |
| { |
| return TRUE; |
| } |
| #endif |
| |
| NABoolean DatetimeType::operator==(const NAType& other) const |
| { |
| return NAType::operator==(other) && |
| getStartField() == ((DatetimeType&) other).getStartField() && |
| getEndField() == ((DatetimeType&) other).getEndField() && |
| getFractionPrecision() == ((DatetimeType&) other).getFractionPrecision(); |
| } |
| |
| NAType::SynthesisPrecedence DatetimeType::getSynthesisPrecedence() const |
| { |
| return SYNTH_PREC_DATETIME; |
| } |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : Ancillary construction functions (static methods) |
| // |
| // *********************************************************************** |
| |
| // For indexing through the static arrays above. |
| Int32 DatetimeType::getExtendedEndField(rec_datetime_field endField, |
| UInt32 fractionPrecision) |
| { |
| Int32 result = endField; |
| if (fractionPrecision > 0) { |
| if (endField == REC_DATE_SECOND) |
| result++; // The FRACTION field of the |
| else // static arrays above. |
| assert(endField == REC_DATE_FRACTION_MP); |
| } |
| |
| return result; |
| } // DatetimeType::getExtendedEndField |
| |
| // Return the storage size in bytes for a datetime type. |
| // |
| // Datetime field Digits precision Storage bytes |
| // (maxFieldLen[]) (storageLen[]) |
| // -------------- ---------------- ------------- |
| // YEAR 4 2 |
| // MONTH 2 1 |
| // DAY 2 1 |
| // HOUR 2 1 |
| // MINUTE 2 1 |
| // SECOND 2 1 |
| // FRACTION 1-6 4 |
| // |
| // Thus, DATE [YMD] is size 4, |
| // TIME(0) [HMS] is size 3, |
| // TIME(n) [HMSF] is size 7, |
| // TIMESTAMP(0) [YMDHMS] is size 7, |
| // TIMESTAMP(n) [YMDHMSF] is size 11. |
| // |
| Lng32 DatetimeType::getStorageSize(rec_datetime_field startField, |
| rec_datetime_field endField, |
| UInt32 fractionPrecision) |
| { |
| Lng32 storageSize = 0; |
| Int32 end = getExtendedEndField(endField, fractionPrecision); |
| for (Int32 field = startField; field <= end; field++) { |
| Int32 index = field - REC_DATE_YEAR; |
| storageSize += storageLen[index]; |
| } |
| return storageSize; |
| |
| } // DatetimeType::getStorageSize |
| |
| // *********************************************************************** |
| // |
| // Convert internal representation to an array of unsigned long. |
| // |
| // *********************************************************************** |
| |
| void DatetimeType::datetimeToLong(void *bufPtr, |
| ULng32 values[]) const |
| { |
| char *str = (char *)bufPtr; |
| short sw; |
| Lng32 size; |
| Int32 start = getStartField(); |
| Int32 end = getExtendedEndField(getEndField(), getFractionPrecision()); |
| ULng32 val = 0; |
| |
| for (Int32 i = start; i <= end; i++) |
| { |
| size = storageLen[i - 1]; |
| switch (size) { |
| case sizeof(char): |
| val = *str; |
| break; |
| case sizeof(short): |
| memcpy((char *)&sw, str, sizeof(short)); |
| val = sw; |
| break; |
| case sizeof(Lng32): |
| memcpy((char *)&val, str, sizeof(Lng32)); |
| break; |
| default: |
| assert(FALSE); |
| } |
| |
| // limit values to the max value for SQL/MX datetime, SQL/MP |
| // may use binary ones for max values |
| if (val > maxValue[i-1]) |
| val = maxValue[i-1]; |
| values[i - start] = val; |
| str += size; |
| } |
| } |
| |
| // *********************************************************************** |
| // |
| // Returns the number of days for DATE and TIMESTAMP, |
| // starting from Jan 1, 0001. |
| // |
| // *********************************************************************** |
| |
| Lng32 DatetimeType::gregorianDays(const ULng32 values[]) |
| { |
| Lng32 year = values[0] - 1; |
| |
| Lng32 leapDays = year/4 + year/400 - year/100; |
| Lng32 days = year * 365 + leapDays; |
| |
| Lng32 month = values[1]; |
| |
| for (Int32 i = 1; i < month; i++) |
| days += daysInMonth[i]; |
| |
| if ((month > 2) && |
| !leapYear(year + 1)) |
| days--; |
| |
| days += values[2]; |
| return days; |
| } |
| |
| Int64 DatetimeType::julianTimestampValue(const char * value, const short valueLen, |
| UInt32 fractionPrec) |
| { |
| Int64 juliantimestamp = 0; |
| const char *datetimeOpData = value; |
| short year; |
| char month; |
| char day; |
| char hour; |
| char minute; |
| char second; |
| Lng32 fraction = 0; |
| str_cpy_all((char *) &year, datetimeOpData, sizeof(year)); |
| datetimeOpData += sizeof(year); |
| month = *datetimeOpData++; |
| day = *datetimeOpData++; |
| hour = *datetimeOpData++; |
| minute = *datetimeOpData++; |
| second = *datetimeOpData++; |
| if ((datetimeOpData - value) < valueLen) |
| { |
| str_cpy_all((char *) &fraction, datetimeOpData, sizeof(fraction)); |
| if (fractionPrec > 0) |
| { |
| if (fractionPrec > DatetimeType::MAX_FRACTION_PRECISION_USEC) |
| // Adjust the fractional seconds part to be the number of microseconds |
| fraction /= (Lng32)pow(10, (fractionPrec - DatetimeType::MAX_FRACTION_PRECISION_USEC)); |
| else |
| fraction *= (Lng32)pow(10, (DatetimeType::MAX_FRACTION_PRECISION_USEC - fractionPrec)); |
| } |
| } |
| short timestamp[] = { |
| year, month, day, hour, minute, second, (short)(fraction / 1000), (short)(fraction % 1000) |
| }; |
| short error; |
| juliantimestamp = COMPUTETIMESTAMP(timestamp, &error); |
| if (error) |
| { |
| return 0; |
| } |
| |
| return juliantimestamp; |
| } |
| |
| // *********************************************************************** |
| // |
| // Returns the number of seconds for TIME and TIMESTAMP. |
| // |
| // *********************************************************************** |
| |
| Lng32 DatetimeType::secondsInTime(const ULng32 values[]) |
| { |
| return (values[0] * 60 * 60 + |
| values[1] * 60 + |
| values[2]); |
| } |
| |
| enum DatetimeType::Subtype DatetimeType::validate(rec_datetime_field startField, |
| rec_datetime_field endField, |
| UInt32 fractionPrecision) |
| { |
| // if (fractionPrecision > MAX_FRACTION_PRECISION) |
| // return SUBTYPE_ILLEGAL; |
| |
| switch (startField) |
| { |
| case REC_DATE_YEAR: |
| switch (endField) |
| { |
| case REC_DATE_DAY: // YEAR TO DAY == DATE |
| return SUBTYPE_SQLDate; |
| |
| case REC_DATE_SECOND: // YEAR TO SECOND == TIMESTAMP |
| case REC_DATE_FRACTION_MP: |
| return SUBTYPE_SQLTimestamp; |
| |
| case REC_DATE_YEAR: |
| case REC_DATE_MONTH: |
| case REC_DATE_HOUR: |
| case REC_DATE_MINUTE: |
| return SUBTYPE_SQLMPDatetime; |
| |
| default: |
| assert (FALSE); |
| } // end switch on endfield |
| break; |
| |
| case REC_DATE_HOUR: |
| switch (endField) |
| { |
| case REC_DATE_SECOND: // HOUR TO SECOND == TIME |
| case REC_DATE_FRACTION_MP: |
| return SUBTYPE_SQLTime; |
| |
| case REC_DATE_YEAR: |
| case REC_DATE_MONTH: |
| case REC_DATE_DAY: |
| return SUBTYPE_ILLEGAL; |
| |
| case REC_DATE_HOUR: |
| case REC_DATE_MINUTE: |
| return SUBTYPE_SQLMPDatetime; |
| |
| default: |
| assert (FALSE); |
| } // end switch on endfield |
| break; |
| |
| case REC_DATE_MONTH: |
| case REC_DATE_DAY: |
| case REC_DATE_MINUTE: |
| case REC_DATE_SECOND: |
| case REC_DATE_FRACTION_MP: |
| |
| if (startField <= endField) |
| return SUBTYPE_SQLMPDatetime; |
| else |
| return SUBTYPE_ILLEGAL; |
| |
| |
| default: |
| assert (FALSE); |
| } // end switch on startfield |
| |
| return SUBTYPE_ILLEGAL; |
| |
| } // DatetimeType::validate |
| |
| DatetimeType* DatetimeType::constructSubtype(NABoolean allowSQLnull, |
| rec_datetime_field startField, |
| rec_datetime_field endField, |
| UInt32 precision, |
| NAMemory* h) |
| { |
| switch (validate(startField, endField, precision)) { |
| case SUBTYPE_SQLDate: return new (h) SQLDate(h, allowSQLnull); |
| case SUBTYPE_SQLTime: return new (h) SQLTime(h, allowSQLnull, precision); |
| case SUBTYPE_SQLTimestamp: return new (h) SQLTimestamp(h, allowSQLnull, precision); |
| case SUBTYPE_SQLMPDatetime: return new (h) SQLMPDatetime(h, startField, |
| endField, |
| allowSQLnull, |
| precision); |
| |
| default: return NULL; |
| } |
| } // DatetimeType::constructSubtype |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : The datetime data type |
| // |
| // *********************************************************************** |
| |
| Lng32 DatetimeType::getDisplayLength() const |
| { |
| Int32 field = getStartField() - REC_DATE_YEAR; |
| size_t displayLength = maxFieldLen[field]; |
| while (field < (getEndField() - REC_DATE_YEAR)) |
| displayLength += 1 /* for separator */ + maxFieldLen[++field]; |
| if (getFractionPrecision() > 0) |
| { |
| if (getStartField() == REC_DATE_FRACTION_MP) |
| { |
| displayLength = getFractionPrecision(); |
| } |
| else |
| { |
| displayLength += 1 /* for separator */ + getFractionPrecision(); |
| } |
| } |
| return displayLength; |
| } // DatetimeType::getDisplayLength |
| |
| Lng32 DatetimeType::getDisplayLength(Lng32 datatype, |
| Lng32 length, |
| Lng32 precision, |
| Lng32 scale, |
| Lng32 heading_len) const |
| { |
| Lng32 d_len = (Lng32)getDisplayLength(); |
| |
| if (d_len >= heading_len) |
| return d_len; |
| else |
| return heading_len; |
| } |
| |
| NAString DatetimeType::getTypeSQLname(NABoolean terse) const |
| { |
| NAString name(getTypeName()); |
| |
| name += getDatetimeQualifierAsString(TRUE); // TRUE-- include fractional prec |
| |
| getTypeSQLnull(name, terse); |
| return name; |
| } // DatetimeType::getTypeSQLname |
| |
| // *********************************************************************** |
| // |
| // Type synthesis for binary operators |
| // |
| // *********************************************************************** |
| |
| const NAType* DatetimeType::synthesizeType(enum NATypeSynthRuleEnum synthRule, |
| const NAType& operand1, |
| const NAType& operand2, |
| NAMemory* h, |
| UInt32 *flags) const |
| { |
| // |
| // If the second operand's type synthesis rules have higher precedence than |
| // this operand's rules, use the second operand's rules. |
| // |
| if (operand2.getSynthesisPrecedence() > getSynthesisPrecedence()) |
| return operand2.synthesizeType(synthRule, operand1, operand2, h, flags); |
| // |
| // Only D-D, I+D, D+I, and D-I are legal. |
| // (And union, i.e. supertyping, of course.) |
| // ANSI 6.14 and 6.15. |
| // |
| const DatetimeType* datetime; |
| const IntervalType* interval; |
| switch (synthRule) { |
| case SYNTH_RULE_ADD: |
| switch (operand1.getTypeQualifier()) { |
| case NA_INTERVAL_TYPE: |
| if (operand2.getTypeQualifier() != NA_DATETIME_TYPE) |
| return NULL; |
| interval = (IntervalType*) &operand1; |
| datetime = (DatetimeType*) &operand2; |
| break; |
| case NA_DATETIME_TYPE: |
| if (operand2.getTypeQualifier() != NA_INTERVAL_TYPE) |
| return NULL; |
| datetime = (DatetimeType*) &operand1; |
| interval = (IntervalType*) &operand2; |
| break; |
| default: |
| return NULL; |
| } |
| // |
| // INTERVALs are compatible with datetimes if the interval |
| // only contains fields that are in the datetime: ANSI 6.14 SR 3. |
| // |
| if ((datetime->getStartField() > interval->getStartField()) || |
| (datetime->getEndField() < interval->getEndField())) |
| return NULL; |
| |
| return constructSubtype(datetime->supportsSQLnull() || interval->supportsSQLnull(), |
| datetime->getStartField(), |
| datetime->getEndField(), |
| datetime->getFractionPrecision(), |
| h); |
| |
| break; |
| |
| case SYNTH_RULE_SUB: |
| if ((operand1.getTypeQualifier() != NA_DATETIME_TYPE) || |
| ((operand2.getTypeQualifier() != NA_INTERVAL_TYPE) && |
| (operand2.getTypeQualifier() != NA_DATETIME_TYPE))) |
| return NULL; |
| |
| if (operand2.getTypeQualifier() == NA_INTERVAL_TYPE) |
| { |
| datetime = (DatetimeType*) &operand1; |
| interval = (IntervalType*) &operand2; |
| |
| // |
| // INTERVALs are compatible with datetimes if the interval |
| // only contains fields that are in the datetime: ANSI 6.14 SR 3. |
| // |
| if ((datetime->getStartField() > interval->getStartField()) || |
| (datetime->getEndField() < interval->getEndField())) |
| return NULL; |
| |
| return constructSubtype(datetime->supportsSQLnull() || interval->supportsSQLnull(), |
| datetime->getStartField(), |
| datetime->getEndField(), |
| datetime->getFractionPrecision(), |
| h); |
| } |
| else |
| { |
| const DatetimeType* datetime1 = (DatetimeType*) &operand1; |
| const DatetimeType* datetime2 = (DatetimeType*) &operand2; |
| |
| if ((datetime1->getStartField() != datetime2->getStartField()) || |
| (datetime1->getEndField() != datetime2->getEndField())) |
| return NULL; |
| |
| NABoolean modeSpecial4 = |
| ((flags) && ((*flags & NAType::MODE_SPECIAL_4) != 0)); |
| |
| NABoolean allowNulls = (((datetime1->supportsSQLnull()) || |
| (datetime2->supportsSQLnull())) ? TRUE : FALSE); |
| |
| UInt32 fractionPrecision = MAXOF(datetime1->getFractionPrecision(), |
| datetime2->getFractionPrecision()); |
| |
| if ((modeSpecial4) && |
| (fractionPrecision == 0) && |
| (datetime1->getSubtype() == DatetimeType::SUBTYPE_SQLDate) && |
| (datetime2->getSubtype() == DatetimeType::SUBTYPE_SQLDate)) |
| { |
| // this is DATE subtraction in modespecial4. |
| // Result is numeric. |
| return new(h) SQLInt(h); |
| } |
| else |
| { |
| Int32 leadingPrecision = IntervalType::computeLeadingPrecision |
| (datetime1->getEndField(), |
| SQLInterval::MAX_LEADING_PRECISION, |
| datetime1->getEndField(), |
| fractionPrecision); |
| |
| return new(h) SQLInterval(h, allowNulls, |
| datetime1->getEndField(), |
| leadingPrecision, |
| datetime1->getEndField(), |
| fractionPrecision); |
| } |
| } |
| break; |
| |
| case SYNTH_RULE_UNION: { |
| if (! operand1.isCompatible(operand2, flags)) |
| return NULL; |
| const DatetimeType& op1 = (DatetimeType&) operand1; |
| const DatetimeType& op2 = (DatetimeType&) operand2; |
| UInt32 fractionPrecision = MAXOF(op1.getFractionPrecision(), |
| op2.getFractionPrecision()); |
| return constructSubtype(op1.supportsSQLnull() || op2.supportsSQLnull(), |
| op1.getStartField(), |
| op1.getEndField(), |
| fractionPrecision, |
| h); |
| } |
| default: |
| return NULL; |
| } |
| } // synthesizeType() |
| |
| // *********************************************************************** |
| // |
| // Type synthesis for ternary operators |
| // |
| // *********************************************************************** |
| |
| const NAType* DatetimeType::synthesizeTernary(enum NATypeSynthRuleEnum synthRule, |
| const NAType& operand1, |
| const NAType& operand2, |
| const NAType& operand3, |
| NAMemory* h) const |
| { |
| // |
| // If the second operand's type synthesis rules have higher precedence than |
| // this operand's rules, use the second operand's rules. |
| // |
| if (operand2.getSynthesisPrecedence() > getSynthesisPrecedence()) |
| return operand2.synthesizeTernary(synthRule, operand1, operand2, operand3,h); |
| // |
| // If the third operand's type synthesis rules have higher precedence than |
| // this operand's rules, use the third operand's rules. |
| // |
| if (operand3.getSynthesisPrecedence() > getSynthesisPrecedence()) |
| return operand3.synthesizeTernary(synthRule, operand1, operand2, operand3,h); |
| // |
| // So far, "(D-D) interval_qualifier" is the only ternary operator. |
| // |
| switch (synthRule) { |
| case SYNTH_RULE_SUB: { |
| if ((operand1.getTypeQualifier() != NA_DATETIME_TYPE) || |
| (operand2.getTypeQualifier() != NA_DATETIME_TYPE) || |
| (operand3.getTypeQualifier() != NA_INTERVAL_TYPE) || |
| (! operand1.isCompatible(operand2))) |
| return NULL; |
| const DatetimeType& op1 = (DatetimeType&) operand1; |
| const DatetimeType& op2 = (DatetimeType&) operand2; |
| const IntervalType& op3 = (IntervalType&) operand3; |
| return new(h) SQLInterval(h, op1.supportsSQLnull() || op2.supportsSQLnull(), |
| op3.getStartField(), |
| op3.getLeadingPrecision(), |
| op3.getEndField(), |
| op3.getFractionPrecision()); |
| } |
| default: |
| break; |
| } |
| return NULL; |
| } // synthesizeTernary() |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : Min and max values |
| // |
| // *********************************************************************** |
| |
| void DatetimeType::getRepresentableValue(const char* inValueString, |
| void* bufPtr, Lng32* bufLen, |
| NAString** stringLiteral, |
| NAMemory* h) const |
| { |
| Int32 startIndex = getStartField() - REC_DATE_YEAR; |
| Int32 endIndex = getEndField() - REC_DATE_YEAR; |
| Int32 startOff, endOff, i = 0; |
| UInt32 fracPrec = 0; |
| for (startOff = 0; i < startIndex; i++) startOff = startOff + maxFieldLen[i] + 1; |
| for (endOff = startOff; i <= endIndex; i++) endOff = endOff + maxFieldLen[i] + 1; |
| if (getFractionPrecision()) |
| { |
| endOff += getFractionPrecision() + 1; |
| } |
| |
| endOff--; // was at offset of next field, now at offset of the delimiter |
| i = endOff - startOff; // length (endOff is one past last char) |
| |
| if (getSubtype() == SUBTYPE_SQLMPDatetime) |
| { |
| fracPrec = getFractionPrecision(); |
| if (getStartField() == REC_DATE_FRACTION_MP) |
| { |
| Int32 adjust = (6-fracPrec) + 2; // move past "00." (seconds + decimal pt.) |
| startOff += adjust; |
| i -= adjust; |
| } |
| } |
| |
| char valueString[valueStringLen]; |
| str_cpy_all(valueString, &inValueString[startOff], i /*length*/); |
| valueString[i] = '\0'; |
| DatetimeValue dtValue(valueString, getStartField(), getEndField(), fracPrec, |
| FALSE); |
| |
| assert(*bufLen >= dtValue.getValueLen() && dtValue.isValid()); |
| *bufLen = dtValue.getValueLen(); |
| str_cpy_all((char*)bufPtr, (char*)dtValue.getValue(), dtValue.getValueLen()); |
| |
| if (stringLiteral) |
| { |
| *stringLiteral = new (h) NAString(getSimpleTypeName(), h); |
| **stringLiteral += "\'"; |
| **stringLiteral += valueString; |
| **stringLiteral += "\'"; |
| if (getSubtype() == SUBTYPE_SQLMPDatetime) |
| { |
| **stringLiteral += getDatetimeQualifierAsString(FALSE); |
| } |
| } |
| } // DatetimeType::getRepresentableValue |
| |
| |
| void DatetimeType::minRepresentableValue(void* bufPtr, Lng32* bufLen, |
| NAString** stringLiteral, |
| NAMemory* h) const |
| { |
| getRepresentableValue(minValueString, |
| bufPtr, bufLen, stringLiteral, h); |
| } |
| |
| void DatetimeType::maxRepresentableValue(void* bufPtr, Lng32* bufLen, |
| NAString** stringLiteral, |
| NAMemory* h) const |
| { |
| getRepresentableValue(maxValueString, bufPtr, bufLen, stringLiteral, h); |
| } |
| |
| NABoolean DatetimeType::createSQLLiteral(const char * buf, |
| NAString *&stringLiteral, |
| NABoolean &isNull, |
| CollHeap *h) const |
| { |
| if (NAType::createSQLLiteral(buf, stringLiteral, isNull, h)) |
| return TRUE; |
| |
| // First step is to convert to ASCII, then add datetime syntax around it |
| const int RESULT_LEN = 100; |
| char result[RESULT_LEN]; |
| const char *valPtr = buf + getSQLnullHdrSize(); |
| unsigned short resultLen = 0; |
| ComDiagsArea *diags = NULL; |
| |
| ex_expr::exp_return_type ok = |
| convDoIt((char *) valPtr, |
| getNominalSize(), |
| getFSDatatype(), |
| getPrecision(), |
| getScale(), |
| result, |
| RESULT_LEN, |
| REC_BYTE_V_ASCII, |
| 0, |
| SQLCHARSETCODE_UTF8, |
| (char *) &resultLen, |
| sizeof(resultLen), |
| h, |
| &diags, |
| ConvInstruction::CONV_UNKNOWN, |
| 0); |
| |
| if ( ok != ex_expr::EXPR_OK || resultLen == 0) |
| return FALSE; |
| |
| stringLiteral = new(h) NAString(result, resultLen, h); |
| *stringLiteral += '\''; |
| if (getTypeName() == "DATE") |
| stringLiteral->prepend(" DATE '"); |
| else if (getTypeName() == "TIME") |
| stringLiteral->prepend(" TIME '"); |
| else if (getTypeName() == "TIMESTAMP") |
| stringLiteral->prepend(" TIMESTAMP '"); |
| return TRUE; |
| } |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : getRecDateTimeCode |
| // |
| // Converts start/end combination into REC_DATETIME_CODE enum. |
| // *********************************************************************** |
| |
| Lng32 DatetimeType::getRecDateTimeCode(rec_datetime_field startField, rec_datetime_field endField) const |
| { |
| switch (startField) { |
| case REC_DATE_YEAR: |
| switch (endField) { |
| case REC_DATE_YEAR: |
| return REC_DTCODE_YEAR; |
| case REC_DATE_MONTH: |
| return REC_DTCODE_YEAR_MONTH; |
| case REC_DATE_DAY: |
| return REC_DTCODE_DATE; |
| case REC_DATE_HOUR: |
| return REC_DTCODE_YEAR_HOUR; |
| case REC_DATE_MINUTE: |
| return REC_DTCODE_YEAR_MINUTE; |
| case REC_DATE_SECOND: |
| return REC_DTCODE_TIMESTAMP; |
| } |
| case REC_DATE_MONTH: |
| switch (endField) { |
| case REC_DATE_MONTH: |
| return REC_DTCODE_MONTH; |
| case REC_DATE_DAY: |
| return REC_DTCODE_MONTH_DAY; |
| case REC_DATE_HOUR: |
| return REC_DTCODE_MONTH_HOUR; |
| case REC_DATE_MINUTE: |
| return REC_DTCODE_MONTH_MINUTE; |
| case REC_DATE_SECOND: |
| return REC_DTCODE_MONTH_SECOND; |
| } |
| case REC_DATE_DAY: |
| switch (endField) { |
| case REC_DATE_DAY: |
| return REC_DTCODE_DAY; |
| case REC_DATE_HOUR: |
| return REC_DTCODE_DAY_HOUR; |
| case REC_DATE_MINUTE: |
| return REC_DTCODE_DAY_MINUTE; |
| case REC_DATE_SECOND: |
| return REC_DTCODE_DAY_SECOND; |
| } |
| case REC_DATE_HOUR: |
| switch (endField) { |
| case REC_DATE_HOUR: |
| return REC_DTCODE_HOUR; |
| case REC_DATE_MINUTE: |
| return REC_DTCODE_HOUR_MINUTE; |
| case REC_DATE_SECOND: |
| return REC_DTCODE_TIME; |
| } |
| case REC_DATE_MINUTE: |
| switch (endField) { |
| case REC_DATE_MINUTE: |
| return REC_DTCODE_MINUTE; |
| case REC_DATE_SECOND: |
| return REC_DTCODE_MINUTE_SECOND; |
| } |
| case REC_DATE_SECOND: |
| switch (endField) { |
| case REC_DATE_SECOND: |
| return REC_DTCODE_SECOND; |
| } |
| case REC_DATE_FRACTION_MP: |
| switch (endField) { |
| case REC_DATE_FRACTION_MP: |
| return REC_DTCODE_FRACTION; |
| } |
| } |
| |
| // Invalid combination of start/end fields. |
| // |
| assert(0); |
| return REC_DTCODE_FRACTION; |
| } |
| // *********************************************************************** |
| // |
| // DatetimeType :: containsField |
| // |
| // Checks if the given field is contained within the given type. |
| // (Note very similar routine in DatetimeValue class.) |
| // *********************************************************************** |
| |
| NABoolean DatetimeType::containsField(rec_datetime_field theField) const |
| { |
| if (theField >= getStartField() && theField <= getEndField()) |
| { |
| return TRUE; |
| } |
| else |
| { |
| return FALSE; |
| } |
| } |
| |
| // *********************************************************************** |
| // |
| // DatetimeType :: fieldsOverlap |
| // |
| // Checks if the given types have overlapping fields. |
| // |
| // *********************************************************************** |
| NABoolean DatetimeType::fieldsOverlap(const DatetimeType& other) const |
| { |
| if (getEndField() < other.getStartField() || (getStartField() > other.getEndField())) |
| { |
| return FALSE; |
| } |
| else |
| { |
| return TRUE; |
| } |
| } |
| |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : Encode |
| // |
| // *********************************************************************** |
| |
| double DatetimeType::encode (void* bufPtr) const |
| { |
| return -1; // for now ...## |
| } // DatetimeType::encode |
| |
| // *********************************************************************** |
| // |
| // DatetimeType : Display/debug |
| // |
| // *********************************************************************** |
| void DatetimeType::print(FILE* ofd, const char* indent) /*const*/ |
| { |
| fprintf(ofd, "%s ", getTypeSQLname().data()); |
| NAType::print(ofd, indent); |
| } // DatetimeType::print |
| |
| // *********************************************************************** |
| // |
| // DatetimeType::getDatetimeQualifierAsString |
| // modelled after IntervalType::getIntervalQualifierAsString() |
| // |
| // *********************************************************************** |
| const NAString DatetimeType::getDatetimeQualifierAsString(NABoolean includeFractionalPrec) const |
| { |
| NAString fields; |
| char precision[8]; // '(' , '%u', ')' '\0' |
| |
| if (getSubtype() == SUBTYPE_SQLMPDatetime) |
| { |
| fields += " "; |
| fields += getFieldName(getStartField()); |
| if (getStartField() != getEndField() || (getFractionPrecision() > 0 && getEndField() >= REC_DATE_SECOND)) |
| { |
| fields += " TO "; // change endField of SECOND back to FRACTION for display. |
| if (getFractionPrecision() > 0 && getEndField() >= REC_DATE_SECOND) |
| { |
| fields += getFieldName(REC_DATE_FRACTION_MP); |
| } |
| else |
| { |
| fields += getFieldName(getEndField()); |
| includeFractionalPrec = FALSE; |
| } |
| } |
| } |
| |
| if (getEndField() >= REC_DATE_SECOND && includeFractionalPrec |
| && (getFractionPrecision() > 0 || (getSubtype() != SUBTYPE_SQLMPDatetime))) |
| { |
| sprintf(precision, "(%u)", getFractionPrecision()); |
| fields += precision; |
| } |
| return fields; |
| } |
| |
| double SQLDate::encode(void *bufPtr) const |
| { |
| char * valPtr = (char *)bufPtr; |
| double val; |
| |
| if (supportsSQLnull()) valPtr += getSQLnullHdrSize(); |
| ULng32 w[10]; |
| |
| for (Int32 i = 0; i < 10; i++) |
| w[i] = 0; |
| |
| datetimeToLong(valPtr, w); |
| assert(w[0] <= 9999); |
| val = gregorianDays(w); |
| return (val * 24.0 * 60 * 60); // watch out for overflow! |
| } |
| |
| // Convert to a SQL Date literal "date 'yyyy-mm-dd'" |
| NAString* SQLDate::convertToString(double v, NAMemory* h) const |
| { |
| // v contains seconds since Jan 1, 0001 (see encode() and gregorianDays()). |
| |
| // Julian date for Jan 1, 0001 is 1721423.5. Convert to seconds. |
| // Add 1 day to make the day correct. |
| double secs = 1721424.5 * 86400; |
| |
| // Convert v into Julian date in seconds. |
| secs += v; |
| |
| UInt32 dtvFields[DatetimeValue::N_DATETIME_FIELDS]; |
| DatetimeValue::decodeTimestamp(Int64(secs * 1000000), // in microseconds |
| 0, // fracSec |
| dtvFields); |
| |
| char data[20]; |
| |
| sprintf(data, "DATE '%4d-%02d-%02d'", dtvFields[DatetimeValue::YEAR], |
| dtvFields[DatetimeValue::MONTH], |
| dtvFields[DatetimeValue::DAY] |
| ); |
| |
| return new (h) NAString(data, h); |
| } |
| |
| double SQLDate::encodeSqlLiteral(char* source) const |
| { |
| char target[40]; |
| memset(target, '\0', sizeof(target)); |
| |
| char* targetPtr = target; |
| Lng32 targetLen = sizeof(target); |
| |
| if (supportsSQLnull()) { |
| targetPtr += getSQLnullHdrSize(); |
| targetLen -= getSQLnullHdrSize(); |
| } |
| |
| //NAMemory* heap = h_; |
| |
| ex_expr::exp_return_type ok = |
| convDoIt(source, strlen(source), REC_BYTE_F_ASCII, 0, 0, |
| targetPtr, targetLen, REC_DATETIME, REC_DTCODE_DATE, 0, |
| NULL, 0, |
| 0, // heap |
| 0, // diagsPtr |
| ConvInstruction::CONV_UNKNOWN, |
| 0,// data conversionErrorFlag |
| 0 // flags |
| ); |
| |
| if ( ok != ex_expr::EXPR_OK ) |
| return 0; |
| |
| return encode(target); |
| } |
| |
| double SQLDate::getMinValue() const |
| { |
| char source[20]; |
| sprintf(source, "0001-01-01"); |
| return encodeSqlLiteral(source); |
| } |
| |
| double SQLDate::getMaxValue() const |
| { |
| char source[20]; |
| sprintf(source, "9999-12-31"); |
| return encodeSqlLiteral(source); |
| } |
| |
| |
| |
| double SQLTime::encode(void *bufPtr) const |
| { |
| char * valPtr = (char *)bufPtr; |
| double val; |
| |
| if (supportsSQLnull()) valPtr += getSQLnullHdrSize(); |
| ULng32 w[6]; |
| |
| for (Int32 i = 0; i < 6; i++) |
| w[i] = 0; |
| |
| datetimeToLong(valPtr, w); |
| assert(w[0] <= 24); |
| val = secondsInTime(w) + (double)w[3] / pow(10, getFractionPrecision()); |
| return val; |
| } |
| |
| NAString* SQLTime::convertToString(double v, NAMemory* h) const |
| { |
| |
| // v contains seconds since Jan 1, 0001 (see encode() and gregorianDays()). |
| |
| // Julian date for Jan 1, 2014 0:0:0 sec is 2456658.5. Convert to seconds. |
| double secs = 2456658.5 * 86400; |
| |
| // Convert v into Julian date in seconds. |
| secs += v; |
| |
| UInt32 dtvFields[DatetimeValue::N_DATETIME_FIELDS]; |
| DatetimeValue::decodeTimestamp(Int64(secs * 1000000), // in microseconds |
| 0, // fracSec |
| dtvFields); |
| |
| char data[30]; |
| |
| sprintf(data, "TIME '%02d:%02d:%02d.%d'", |
| dtvFields[DatetimeValue::HOUR], |
| dtvFields[DatetimeValue::MINUTE], |
| dtvFields[DatetimeValue::SECOND], |
| dtvFields[DatetimeValue::FRACTION] |
| ); |
| |
| NAString* result = new (h) NAString(data, h); |
| |
| return result; |
| } |
| |
| double SQLTime::encodeSqlLiteral(char* source) const |
| { |
| char target[40]; |
| memset(target, '\0', sizeof(target)); |
| |
| char* targetPtr = target; |
| Lng32 targetLen = sizeof(target); |
| |
| if (supportsSQLnull()) { |
| targetPtr += getSQLnullHdrSize(); |
| targetLen -= getSQLnullHdrSize(); |
| } |
| |
| ex_expr::exp_return_type ok = |
| convDoIt(source, strlen(source), REC_BYTE_F_ASCII, 0, 0, |
| targetPtr, targetLen, REC_DATETIME, REC_DTCODE_TIME, 0, |
| NULL, 0, |
| 0, // heap |
| 0, // diagsPtr |
| ConvInstruction::CONV_UNKNOWN, |
| 0,// data conversionErrorFlag |
| 0 // flags |
| ); |
| |
| if ( ok != ex_expr::EXPR_OK ) |
| return 0; |
| |
| return encode(target); |
| } |
| |
| |
| double SQLTime::getMinValue() const |
| { |
| char source[20]; |
| sprintf(source, "00:00:00"); |
| return encodeSqlLiteral(source); |
| } |
| |
| double SQLTime::getMaxValue() const |
| { |
| char source[20]; |
| sprintf(source, "23:59:59"); |
| return encodeSqlLiteral(source); |
| } |
| |
| double SQLTimestamp::encode(void *bufPtr) const |
| { |
| char * valPtr = (char *)bufPtr; |
| double val; |
| |
| if (supportsSQLnull()) valPtr += getSQLnullHdrSize(); |
| ULng32 w[10]; |
| |
| for (Int32 i = 0; i < 10; i++) |
| w[i] = 0; |
| |
| datetimeToLong(valPtr, w); |
| assert(w[0] <= 9999); |
| val = gregorianDays(w) * 24.0 * 60 * 60 + secondsInTime(&w[3]); // watch out for overflow! |
| val += (double)w[6] / pow(10, getFractionPrecision()); |
| return val; |
| } |
| |
| // Convert to a SQL Timestamp literal 'timestamp yyyy-mm-dd hh:mm:ss.fraction' |
| NAString* SQLTimestamp::convertToString(double v, NAMemory* h) const |
| { |
| // v contains seconds since Jan 1, 0001 (see encode() and gregorianDays()). |
| |
| // Julian date for Jan 1, 0001 is 1721423.5. Convert to seconds. |
| // Add 1 day to make the day correct. |
| double secs = 1721424.5 * 86400; |
| |
| // Convert v into Julian date in seconds. |
| secs += v; |
| |
| UInt32 dtvFields[DatetimeValue::N_DATETIME_FIELDS]; |
| DatetimeValue::decodeTimestamp(Int64(secs * 1000000), // in microseconds |
| 0, // fracSec |
| dtvFields); |
| |
| char date[30]; |
| |
| sprintf(date, "timestamp '%4d-%02d-%02d", dtvFields[DatetimeValue::YEAR], |
| dtvFields[DatetimeValue::MONTH], |
| dtvFields[DatetimeValue::DAY] |
| ); |
| |
| NAString* result = new (h) NAString(date, h); |
| |
| char time[40]; |
| sprintf(time, " %02d:%02d:%02d.%d'", |
| dtvFields[DatetimeValue::HOUR], |
| dtvFields[DatetimeValue::MINUTE], |
| dtvFields[DatetimeValue::SECOND], |
| dtvFields[DatetimeValue::FRACTION] |
| ); |
| |
| result->append(time); |
| return result; |
| |
| } |
| |
| double SQLTimestamp::encodeSqlLiteral(char* source) const |
| { |
| char target[40]; |
| memset(target, '\0', sizeof(target)); |
| |
| char* targetPtr = target; |
| Lng32 targetLen = sizeof(target); |
| |
| if (supportsSQLnull()) { |
| targetPtr += getSQLnullHdrSize(); |
| targetLen -= getSQLnullHdrSize(); |
| } |
| |
| ex_expr::exp_return_type ok = |
| convDoIt(source, strlen(source), REC_BYTE_F_ASCII, 0, 0, |
| targetPtr, targetLen, REC_DATETIME, REC_DTCODE_TIMESTAMP, 0, |
| NULL, 0, |
| 0, // heap |
| 0, // diagsPtr |
| ConvInstruction::CONV_UNKNOWN, |
| 0,// data conversionErrorFlag |
| 0 // flags |
| ); |
| |
| if ( ok != ex_expr::EXPR_OK ) |
| return 0; |
| |
| return encode(target); |
| } |
| |
| |
| double SQLTimestamp::getMinValue() const |
| { |
| char source[40]; |
| sprintf(source, "0001-01-01 00:00:00"); |
| return encodeSqlLiteral(source); |
| } |
| |
| double SQLTimestamp::getMaxValue() const |
| { |
| char source[50]; |
| // initialize length to size without the fraction part |
| Int32 len=19; |
| sprintf(source, "9999-12-31 23:59:59"); |
| // 0123456789012345678901234567890 = 18 characters |
| |
| if ( getScale() > 0 ) { |
| char* fraction = source + strlen(source); |
| fraction[0] = '.'; // 19 chars |
| fraction++; |
| for (Int32 i=0; i<getScale(); i++ ) { |
| fraction[i] = '9'; // getScale() <= 6 |
| } |
| } |
| |
| // add the fraction size if any |
| len +=getScale(); |
| source[len+1]=0; |
| |
| return encodeSqlLiteral(source); |
| } |
| |
| |
| double SQLMPDatetime::encode(void *bufPtr) const |
| { |
| char * valPtr = (char *)bufPtr; |
| double val; |
| |
| if (supportsSQLnull()) valPtr += getSQLnullHdrSize(); |
| ULng32 w[10]; |
| |
| w[REC_DATE_YEAR-1] = 1; // should use min values here |
| w[REC_DATE_MONTH-1] = 1; |
| w[REC_DATE_DAY-1] = 1; |
| for (Int32 i = REC_DATE_HOUR-1; i < 10; i++) |
| w[i] = 0; |
| |
| datetimeToLong(valPtr, &w[getStartField()-1]); |
| assert(w[0] <= 9999); |
| val = gregorianDays(w) * 24.0 * 60 * 60 + secondsInTime(&w[3]); // watch out for overflow! |
| val += (double)w[6] / pow(10, getFractionPrecision()); |
| return val; |
| } |
| |
| |
| // *********************************************************************** |
| // |
| // SQLMPDatetime::isSupportedType |
| // |
| // *********************************************************************** |
| |
| NABoolean SQLMPDatetime::isSupportedType(void) const |
| { |
| if (getStartField() == REC_DATE_FRACTION_MP) |
| return FALSE; |
| else |
| return TRUE; |
| } |
| |
| |
| // *********************************************************************** |
| // |
| // SQLMPDatetime::synthesizeType |
| // |
| // *********************************************************************** |
| |
| const NAType*SQLMPDatetime::synthesizeType(enum NATypeSynthRuleEnum synthRule, |
| const NAType& operand1, |
| const NAType& operand2, |
| NAMemory* h, |
| UInt32 *flags) const |
| { |
| if (!operand1.isSupportedType() || !operand2.isSupportedType()) |
| return NULL; |
| else |
| return DatetimeType::synthesizeType(synthRule, |
| operand1, |
| operand2, |
| h, |
| flags); |
| } |
| |
| |
| // *********************************************************************** |
| // |
| // SQLMPDatetime::isCompatible |
| // |
| // *********************************************************************** |
| |
| NABoolean SQLMPDatetime::isCompatible(const NAType& other, UInt32 * flags) const |
| { |
| if (!this->isSupportedType() || !other.isSupportedType()) |
| return FALSE; |
| else |
| return DatetimeType::isCompatible(other, flags); |
| } |
| |
| |
| // *********************************************************************** |
| // |
| // DatetimeValue : A datetime value |
| // |
| // *********************************************************************** |
| DatetimeValue::DatetimeValue |
| ( const char* strValue |
| , rec_datetime_field startField |
| , rec_datetime_field endField |
| , UInt32& fractionPrecision /* IN - OUT */ |
| , NABoolean useOldConstructor |
| ) |
| : value_(NULL) |
| , valueLen_(0) |
| , startField_(startField) |
| , endField_ (endField) |
| { |
| fractionPrecision = 0; |
| if (useOldConstructor) |
| { |
| oldConstructor(strValue, startField, endField, fractionPrecision); |
| return; |
| } |
| |
| char dstValue[101]; |
| |
| ComDiagsArea *diags = NULL; |
| |
| Lng32 trueFP = DatetimeType::MAX_FRACTION_PRECISION; |
| ULng32 flags = 0; |
| flags |= CONV_NO_HADOOP_DATE_FIX; |
| short rc = |
| ExpDatetime::convAsciiToDatetime((char*)strValue, strlen(strValue), |
| dstValue, 100, |
| startField, endField, |
| ExpDatetime::DATETIME_FORMAT_NONE, |
| trueFP, |
| NULL, &diags, flags); |
| if (rc) |
| return; |
| |
| if (endField == REC_DATE_SECOND) |
| { |
| Lng32 fp = trueFP; |
| for (; fp < DatetimeType::MAX_FRACTION_PRECISION; fp++) |
| { |
| if (startField == REC_DATE_YEAR) |
| *(Lng32*)&dstValue[7] /= 10; |
| else |
| *(Lng32*)&dstValue[3] /= 10; |
| } |
| } |
| else |
| trueFP = 0; |
| |
| fractionPrecision = trueFP; |
| valueLen_ = (unsigned short) DatetimeType::getStorageSize( |
| startField, endField, trueFP); |
| unsigned char *value = value_ = new unsigned char[valueLen_]; |
| |
| memcpy(value, dstValue, valueLen_); |
| |
| } // DatetimeValue::DatetimeValue ctor |
| |
| void DatetimeValue::oldConstructor(const char* strValue, |
| rec_datetime_field startField, |
| rec_datetime_field endField, |
| UInt32& fractionPrecision /* OUT */) |
| { |
| UInt32 saveMPPrecision = fractionPrecision; |
| |
| fractionPrecision = 0; |
| // |
| // Check that the value is a date, time, or timestamp. |
| // |
| |
| DatetimeType::Subtype subtype = DatetimeType::validate(startField, endField, 0); |
| if (subtype == DatetimeType::SUBTYPE_ILLEGAL) |
| return; |
| // |
| // Skip leading blanks. |
| // |
| while (*strValue == ' ' || *strValue == '\t') |
| strValue++; |
| // |
| // If this contains a YEAR, MONTH or DAY, scan it as a DATE |
| // |
| DatetimeFormat format = FORMAT_ANY; |
| ULng32 values[N_DATETIME_FIELDS]; |
| if (startField <= REC_DATE_DAY && |
| (! scanDate(strValue /* INOUT */ |
| ,format /* OUT */ |
| ,values /* OUT */ |
| ))) |
| { // restore original specified precision |
| |
| if (subtype == DatetimeType::SUBTYPE_SQLMPDatetime) |
| { |
| fractionPrecision = saveMPPrecision; |
| } |
| |
| return; |
| } |
| // |
| // If this contains both a DAY and HOUR, scan the separator between them |
| // |
| if (startField <= REC_DATE_DAY && endField >= REC_DATE_HOUR && |
| (! scanChar(strValue, ' ')) && (! scanChar(strValue, ':')) && |
| (! scanChar(strValue, 'T'))) |
| return; |
| // |
| // If this contains an HOUR, MINUTE or SECOND, scan is as time. |
| // |
| if (endField >= REC_DATE_HOUR && |
| (! scanTime(strValue /* INOUT */ |
| ,format /* IN */ |
| ,values /* OUT */ |
| ,fractionPrecision /* OUT */ |
| ))) |
| { // restore original specified precision |
| if (subtype == DatetimeType::SUBTYPE_SQLMPDatetime) |
| { |
| fractionPrecision = saveMPPrecision; |
| } |
| |
| return; |
| } |
| // |
| // Skip trailing blanks. |
| // |
| while (*strValue == ' ' || *strValue == '\t') |
| strValue++; |
| // Like INTERVAL, actual precision of MPDatetime must match specified precision |
| |
| if (subtype == DatetimeType::SUBTYPE_SQLMPDatetime) |
| { |
| if (fractionPrecision > saveMPPrecision) |
| { |
| fractionPrecision = saveMPPrecision; |
| return; |
| } |
| else |
| { // adjust the fractional value based on fractional precision. |
| for (; fractionPrecision < saveMPPrecision; fractionPrecision++) |
| { |
| values[6] *= 10; |
| } |
| } |
| } |
| // |
| // If this is the end of the string, the datetime value is valid. |
| // |
| if (*strValue == '\0') |
| setValue(startField, endField, fractionPrecision, values); |
| } |
| |
| DatetimeValue::DatetimeValue |
| ( const char* value |
| , Lng32 storageSize |
| ) |
| : value_(new unsigned char[storageSize]) |
| , valueLen_((unsigned short) storageSize) |
| { |
| memcpy(value_, value, valueLen_); |
| } // DatetimeValue ctor |
| |
| NABoolean DatetimeValue::scanDate(const char* &strValue, |
| DatetimeFormat &format, |
| ULng32 values[]) const |
| { |
| // |
| // Determine the datetime format (DEFAULT, USA, or EUROPEAN). |
| // |
| Int32 firstFieldSize = 0; |
| const char* s = strValue; |
| while (isdigit(*s)) |
| { |
| s++; |
| firstFieldSize++; |
| } |
| |
| // |
| // The following check does not apply if there is only one DATE field present. |
| // The format cannot be determined because there is no separator. |
| // |
| static const char separator[] = "-/./"; |
| char currSeparator = 0; |
| |
| if (startField_ == endField_ || startField_ == REC_DATE_DAY) |
| { |
| format = FORMAT_DEFAULT; |
| } |
| else |
| { |
| Int32 i = FORMAT_DEFAULT; |
| for (; separator[i] != '\0'; i++) |
| if (*s == separator[i]) |
| { |
| currSeparator = separator[i]; |
| break; |
| } |
| |
| format = (DatetimeFormat) i; |
| |
| if ((format == FORMAT_USA) && |
| (firstFieldSize == 4)) |
| { |
| currSeparator = '/'; |
| format = FORMAT_DEFAULT; |
| } |
| |
| if ((format == FORMAT_DEFAULT) && |
| (firstFieldSize == 2)) |
| { |
| currSeparator = '-'; |
| format = FORMAT_USA; |
| } |
| |
| if (separator[format] == '\0') |
| return FALSE; |
| } |
| // |
| // Scan the year, month, day, and the separators in between. |
| // |
| static const DatetimeField dateField[][4] = { |
| { YEAR, MONTH, DAY } /* DEFAULT */ |
| , { MONTH, DAY, YEAR } /* USA */ |
| , { DAY, MONTH, YEAR } /* EUROPEAN */ |
| , { YEAR, MONTH, DAY } /* ANY: YYYY/MM/DD */ |
| }; |
| |
| DatetimeField fieldToScan = dateField[format][0]; |
| NABoolean needSeparator = FALSE; |
| |
| if (containsField (fieldToScan, startField_, endField_)) |
| { |
| if (! scanField(strValue, fieldToScan, values)) |
| return FALSE; |
| needSeparator = TRUE; |
| } |
| |
| fieldToScan = dateField[format][1]; |
| |
| if (containsField (fieldToScan, startField_, endField_)) |
| { |
| if (needSeparator) |
| { |
| if (! scanChar(strValue, currSeparator)) |
| return FALSE; |
| } |
| if (! scanField(strValue, fieldToScan, values)) |
| return FALSE; |
| |
| needSeparator = TRUE; |
| } |
| |
| fieldToScan = dateField[format][2]; |
| |
| if (containsField (fieldToScan, startField_, endField_)) |
| { |
| if (needSeparator) |
| { |
| if (! scanChar(strValue, currSeparator)) |
| return FALSE; |
| } |
| if (! scanField(strValue, fieldToScan, values)) |
| return FALSE; |
| } |
| |
| // |
| // Validate the date. |
| // |
| if (! validateDate(values)) |
| return FALSE; |
| |
| // The format could not be determined because there was no separator. |
| if (startField_ == REC_DATE_DAY) |
| { |
| format = FORMAT_ANY; |
| } |
| |
| return TRUE; |
| } // DatetimeValue::scanDate |
| |
| NABoolean DatetimeValue::scanTime(const char* &strValue, |
| DatetimeFormat format, |
| ULng32 values[], |
| UInt32 &fractionPrecision) const |
| { |
| static const char separator[] = "::.:"; |
| NABoolean needSeparator = FALSE; |
| |
| // |
| // Scan the hour. |
| // |
| if (containsField (HOUR, startField_, endField_)) |
| { |
| if (! scanField(strValue, HOUR, values)) |
| return FALSE; |
| needSeparator = TRUE; |
| } |
| // |
| // If the format is not known yet and the separator is a period, the format |
| // is EUROPEAN. |
| // |
| if (format == FORMAT_ANY && *strValue == '.') |
| format = FORMAT_EUROPEAN; |
| // |
| // Scan the MINUTE and possible separator. |
| // |
| if (containsField (MINUTE, startField_, endField_)) |
| { |
| if (needSeparator) |
| { |
| if (! scanChar(strValue, separator[format])) |
| return FALSE; |
| } |
| if (!scanField(strValue, MINUTE, values)) |
| return FALSE; |
| |
| needSeparator = TRUE; |
| } |
| // |
| // Scan the seconds and possible separator. |
| // |
| if (containsField (SECOND, startField_, endField_)) |
| { |
| if (needSeparator) |
| { |
| if (! scanChar(strValue, separator[format])) |
| return FALSE; |
| } |
| if (!scanField(strValue, SECOND, values)) |
| return FALSE; |
| } |
| // |
| // Scan the decimal point before the fraction if present. |
| // Scan the fraction if present. |
| // |
| fractionPrecision = 0; |
| values[FRACTION] = 0; |
| if (startField_ == REC_DATE_FRACTION_MP || scanChar(strValue, '.')) { |
| if (isdigit(*strValue)) { |
| const char* fraction = strValue; |
| if (! scanField(strValue, FRACTION, values)) |
| return FALSE; |
| fractionPrecision = strValue - fraction; |
| } |
| } |
| // |
| // Scan the AM or PM if present. |
| // |
| if (containsField (HOUR, startField_, endField_)) { |
| if (format == FORMAT_ANY || format == FORMAT_USA) { |
| if (strncmp(strValue, " AM", 3) == 0 || |
| strncmp(strValue, " am", 3) == 0 || |
| strncmp(strValue, " Am", 3) == 0 || |
| strncmp(strValue, " aM", 3) == 0) { |
| if (values[HOUR] > 12) |
| return FALSE; |
| if (values[HOUR] == 12) |
| values[HOUR] = 0; |
| strValue += 3; |
| } else if (strncmp(strValue, " PM", 3) == 0 || |
| strncmp(strValue, " pm", 3) == 0 || |
| strncmp(strValue, " Pm", 3) == 0 || |
| strncmp(strValue, " pM", 3) == 0) { |
| if (values[HOUR] > 12) |
| return FALSE; |
| if (values[HOUR] < 12) |
| values[HOUR] += 12; |
| strValue += 3; |
| } |
| } // FORMAT_ANY or FORMAT_USA |
| else if (format == FORMAT_DEFAULT) { |
| if (strncmp(strValue, "Z", 1) == 0) { |
| strValue += 1; |
| } |
| } // FORMAT_DEFAULT |
| } // contains HOUR |
| |
| return TRUE; |
| } // DatetimeValue::scanTime |
| |
| NABoolean DatetimeValue::scanField(const char* &strValue, |
| DatetimeField field, |
| ULng32 values[]) const |
| { |
| // |
| // Compute the value of the datetime field. |
| // |
| ULng32 value = 0; |
| UInt32 i = 0; |
| for (; i < maxFieldLen[field] && isdigit(strValue[i]); i++) |
| value = value * 10 + strValue[i] - '0'; |
| #ifdef DONT_USE |
| // For Release 1 of MX on NSK, all tables are SQL/MP tables, and datetime |
| // fields are SQL/MP datetime fields. |
| // If we want to support single digit fields (non-ANSI) we could pass a flag |
| // in from the parser indicating that MP text is being parsed, and enable this; |
| // however, the ANSI exact check below would have to be skipped. |
| |
| static const UInt32 minFieldLen[] = { 4, 1, 1, 1, 1, 1, 0 }; |
| if (i < minFieldLen[field] ) // too short |
| return FALSE; |
| #endif |
| // |
| // ANSI 5.3 SR 21 prescribes an EXACT number of digits for each field |
| // except for the seconds fraction, which may be zero digits (i.e. absent). |
| // |
| if (i < maxFieldLen[field] && field != FRACTION) // too short |
| return FALSE; |
| if (isdigit(strValue[i])) // too long |
| return FALSE; |
| strValue += i; // just right Goldilocks |
| // |
| // If the value is too small or too large, the field is invalid. |
| // |
| if (value < minValue[field] || value > maxValue[field]) |
| return FALSE; |
| values[field] = value; |
| return TRUE; |
| } // DatetimeValue::scanField |
| |
| NABoolean DatetimeValue::validateDate(const ULng32 values[]) const |
| { |
| // |
| // If the days field is more than the number of days in the month, the date |
| // is invalid. |
| // |
| if (startField_ <= REC_DATE_MONTH && containsField (DAY, startField_, endField_)) |
| { |
| if (values[DAY] > daysInMonth[values[MONTH]]) |
| return FALSE; |
| } |
| // |
| // If the month field is February and the year is not a leap year, the |
| // maximum number of days is 28. |
| // |
| if (startField_ == REC_DATE_YEAR && containsField (DAY, startField_, endField_)) |
| { |
| if (values[MONTH] == 2 && values[DAY] > 28) |
| if (values[YEAR] % 4 != 0 || |
| (values[YEAR] % 100 == 0 && values[YEAR] % 400 != 0)) |
| return FALSE; |
| } |
| |
| return TRUE; |
| } // DatetimeValue::validateDate |
| |
| // Note how this mirrors the structure of DatetimeType::getStorageSize() |
| void DatetimeValue::setValue(rec_datetime_field startField, |
| rec_datetime_field endField, |
| UInt32 fractionPrecision, |
| const ULng32 values[]) |
| { |
| valueLen_ = (unsigned short) DatetimeType::getStorageSize( |
| startField, endField, fractionPrecision); |
| unsigned char *value = value_ = new unsigned char[valueLen_]; |
| Int32 end = DatetimeType::getExtendedEndField(endField, fractionPrecision); |
| for (Int32 field = startField; field <= end; field++) { |
| Int32 index = field - REC_DATE_YEAR; |
| // This is portable, on endianness |
| switch (storageLen[index]) { |
| case sizeof(unsigned char): |
| { |
| unsigned char v = (unsigned char) values[index]; |
| memcpy(value, &v, storageLen[index]); |
| break; |
| } |
| case sizeof(unsigned short): |
| { |
| unsigned short v = (unsigned short) values[index]; |
| memcpy(value, &v, storageLen[index]); |
| break; |
| } |
| case sizeof(ULng32): |
| memcpy(value, &values[index], storageLen[index]); |
| break; |
| default: |
| assert(FALSE); |
| } |
| value += storageLen[index]; |
| } |
| } // DatetimeValue::setValue |
| |
| NAString DatetimeValue::getValueAsString(const DatetimeType& dt) const |
| { |
| NAString result; |
| if (! isValid()) |
| return result; |
| |
| char cbuf[DatetimeType::MAX_FRACTION_PRECISION + 1]; // +1 for sprintf '\0' |
| Int32 clen; |
| ULng32 ulbuf = 0; |
| unsigned short usbuf; |
| unsigned char ucbuf; |
| const unsigned char *value = getValue(); |
| Int32 end = dt.getExtendedEndField(dt.getEndField(), dt.getFractionPrecision()); |
| for (Int32 field = dt.getStartField(); field <= end; field++) { |
| Int32 index = field - REC_DATE_YEAR; |
| if (value - getValue() >= getValueLen()) { |
| assert(index == FRACTION); |
| ulbuf = 0; // optional seconds fraction value defaults to zero |
| } else { |
| // This is portable, on both endianness and alignment of short/long |
| switch (storageLen[index]) { |
| case sizeof(unsigned char): |
| memcpy(&ucbuf, value, storageLen[index]); |
| ulbuf = ucbuf; |
| break; |
| case sizeof(unsigned short): |
| memcpy(&usbuf, value, storageLen[index]); |
| ulbuf = usbuf; |
| break; |
| case sizeof(ULng32): |
| memcpy(&ulbuf, value, storageLen[index]); |
| break; |
| default: |
| assert(FALSE); |
| } |
| } |
| value += storageLen[index]; |
| if (index != FRACTION) |
| clen = maxFieldLen[index]; |
| else |
| clen = dt.getFractionPrecision(); |
| if (! result.isNull()) { |
| sprintf(cbuf, "%c", precedingPunc[index]); |
| result += cbuf; |
| } |
| sprintf(cbuf, "%0*u", clen, ulbuf); |
| result += cbuf; |
| } |
| return result; |
| } // DatetimeValue::getValueAsString |
| |
| void DatetimeValue::print(const DatetimeType& dt, |
| FILE* ofd, const char* indent) const |
| { |
| if (isValid()) |
| fprintf(ofd, "%s\n", getValueAsString(dt).data()); |
| else |
| fprintf(ofd, "%sInvalid %s\n", indent, dt.getTypeSQLname().data()); |
| } // DatetimeValue::print |
| |
| // Decode a Julian timestamp into an array of fields that can be used with |
| // setValue(). |
| void DatetimeValue::decodeTimestamp(Int64 julianTimestamp, |
| UInt32 fracSec, |
| UInt32* dtvFields) |
| { |
| // Need one extra element in tsFields array; interprettimestamp splits |
| // fractional seconds into 2 fields |
| short tsFields[N_DATETIME_FIELDS+1]; |
| |
| INTERPRETTIMESTAMP(julianTimestamp, tsFields); |
| for (int field=YEAR; field<=SECOND; field++) |
| dtvFields[field] = tsFields[field]; |
| |
| // For fractional seconds, combine milliseconds and microseconds, which are |
| // stored in separate fields of the INTERPRETTIMESTAMP output. Scale the result |
| // according to the fractional precision of the type. |
| dtvFields[FRACTION] = (UInt32)((tsFields[6] * 1000 + tsFields[7]) |
| / (Int64)pow(10, 6 - fracSec)); |
| } |
| |
